fix: complete security and workflow hardening

这个提交存在于:
YokiiroBW 2026-07-27 11:50:08 +08:00
父节点 8040a1b3fe
当前提交 51a2a23e27
共有 96 个文件被更改,包括 3192 次插入 和 489 次删除

查看文件

@ -12,10 +12,15 @@ import re
from dataclasses import dataclass
from typing import Any, Callable
from backend.dto.common import ErrorCode, error_response
from backend.dto.common import ApiError, ErrorCode, error_response
from backend.route_registry import ROUTES, RouteSpec, assert_known_permissions, assert_unique_routes
from backend.services.route_ownership_guard import (
create_resource_access_service,
enforce_route_ownership,
)
from backend.services.ui_service import API_BASE
from core.identity import RequestContext
from core.security import enforce_route_permission
@dataclass(frozen=True)
@ -184,6 +189,21 @@ def dispatch_extension_request(
details={"method": str(method or "").upper(), "path": normalize_extension_path(path)},
request_id=ctx.request_id,
)
# Enforce the route's declared permission before the handler runs, so the
# manifest in route_registry is the contract rather than a comment. A
# handler that forgets its own require_* call is no longer unprotected.
try:
enforce_route_permission(ctx, match.permission)
# Owner-chain check for routes addressing a profile-owned resource, so
# a guessed ID cannot reach another user's data (IDOR).
enforce_route_ownership(
ctx,
match.permission,
match.path_params,
create_resource_access_service,
)
except ApiError as exc:
return exc.to_response(ctx.request_id)
return match.handler(*_handler_args(match, ctx, query or {}, payload or {}))

查看文件

@ -26,12 +26,39 @@ class ErrorCode(StrEnum):
UNKNOWN_ERROR = "UNKNOWN_ERROR"
@dataclass(frozen=True)
@dataclass(eq=False)
class ApiError(Exception):
"""Domain error carrying a contract error code.
Deliberately **not** ``frozen``. A frozen dataclass rejects the
``exc.__traceback__ = tb`` assignment that ``contextlib`` performs when an
exception escapes a ``@contextmanager`` body, so a frozen ``ApiError``
raised inside any such block was replaced by ``FrozenInstanceError`` —
losing the error code, the message, and the real traceback. ``core/
config_writer.py`` used to work around this by hand-rolling its lock
instead of using ``@contextmanager``; the constraint is removed here so
ordinary context managers are safe to write.
``eq=False`` keeps ``Exception``'s identity semantics (and therefore
hashability), which is what exception handling expects.
"""
error_code: ErrorCode
message: str
details: dict[str, Any] | None = None
def __post_init__(self) -> None:
# Give ``Exception`` its args so ``repr`` and pickling behave, while
# ``__str__`` below keeps the human-facing text to just the message.
super().__init__(self.error_code, self.message, self.details)
def __str__(self) -> str:
# Without this, ``str(exc)`` renders the whole ``args`` tuple —
# ``"(<ErrorCode.X: 'X'>, 'msg', {...})"`` — and ``main.py`` echoes
# ``str(exc)`` straight to chat users in ~44 places, leaking the
# ``details`` payload along with it.
return self.message
def to_response(self, request_id: str | None = None) -> dict[str, Any]:
return error_response(
error_code=self.error_code,

查看文件

@ -31,6 +31,7 @@ def import_asset_pack(
return asset_service.plan_import_pack(
package_uri,
dry_run=as_bool(payload.get("dry_run"), default=True),
allow_overwrite=as_bool(payload.get("allow_overwrite"), default=False),
ctx=ctx,
)

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.service_registry import create_workflow_service
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
@ -60,9 +61,6 @@ def switch_workflow_branch(
def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings())
return WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
)
# Was assembling WorkflowService by hand without an event_bus, so every
# branch create/switch published nothing and the UI never refreshed.
return create_workflow_service()

查看文件

@ -2,15 +2,40 @@
from __future__ import annotations
import logging
from collections.abc import Callable
from typing import Any
from backend.dto.common import response_from_exception, success_response
from backend.dto.common import ApiError, response_from_exception, success_response
from core.identity import RequestContext
logger = logging.getLogger("imagestudio.routes")
def handle_request(ctx: RequestContext, callback: Callable[[], Any]) -> dict[str, Any]:
try:
return success_response(callback(), request_id=ctx.request_id)
except Exception as exc:
except ApiError as exc:
# Expected domain outcome (validation, permission, not-found). Logged at
# debug so a support session can still reconstruct the exchange without
# flooding production logs.
logger.debug(
"ImageStudio request %s rejected: %s %s",
ctx.request_id,
exc.error_code,
exc.message,
)
return response_from_exception(exc, request_id=ctx.request_id)
except Exception as exc:
# Everything else is a bug. This used to collapse into a bare
# UNKNOWN_ERROR response carrying only the exception class name, with no
# log line anywhere -- an internal failure on any of the 166 routes was
# invisible in production. The traceback goes to the log; the client
# still gets the same opaque response, so nothing leaks outward.
logger.exception(
"ImageStudio request %s failed (actor=%s source=%s)",
ctx.request_id,
ctx.actor_id,
ctx.source,
)
return response_from_exception(exc, request_id=ctx.request_id)

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.service_registry import create_workflow_service
from backend.routes.params import optional_str
from backend.services.history_service import HistoryService
from backend.services.image_service import ImageService
@ -69,11 +70,7 @@ def _create_history_service() -> HistoryService:
database = Database(load_database_settings())
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
workflow_service = WorkflowService(
workflow_repository=workflow_repository,
profile_repository=ProfileRepository(database),
audit_service=audit_service,
)
workflow_service = create_workflow_service(database)
image_service = ImageService(
image_repository=ImageRepository(database),
workflow_repository=workflow_repository,

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.service_registry import create_workflow_service
from backend.services.resource_access_service import ResourceAccessService
from backend.services.material_catalog_resolver import MaterialCatalogResolver
from backend.services.workflow_node_material_service import WorkflowNodeMaterialService
@ -66,11 +67,9 @@ def _create_service() -> WorkflowNodeMaterialService:
database = Database(load_database_settings())
profiles = ProfileRepository(database)
workflows = WorkflowRepository(database)
workflow_service = WorkflowService(
workflow_repository=workflows,
profile_repository=profiles,
audit_service=AuditService(database),
)
# Built without an event_bus, so material-binding events were dropped on
# this route while the same service published them elsewhere.
workflow_service = create_workflow_service(database)
return WorkflowNodeMaterialService(
workflow_service,
MaterialCatalogResolver(

查看文件

@ -7,6 +7,7 @@ from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.routes.common import handle_request
from backend.services.service_registry import create_generation_service, create_workflow_service
from backend.services.event_stream_service import get_default_event_bus
from backend.services.cost_guard_service import CostGuardService
from backend.services.cost_service import CostService
@ -288,12 +289,7 @@ def _resolve_services(
database = Database(load_database_settings())
audit_service = AuditService(database)
event_bus = get_default_event_bus()
resolved_workflow_service = workflow_service or WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=audit_service,
event_bus=event_bus,
)
resolved_workflow_service = workflow_service or create_workflow_service(database)
resolved_image_service = image_service or ImageService(
image_repository=ImageRepository(database),
workflow_repository=WorkflowRepository(database),
@ -303,97 +299,13 @@ def _resolve_services(
def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings())
return WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
event_bus=get_default_event_bus(),
)
return create_workflow_service()
def _create_generation_service() -> GenerationService:
database = Database(load_database_settings())
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
material_repository = MaterialRepository(database)
material_catalog = MaterialCatalogResolver(
material_repository,
AdvancedMaterialRepository(database),
)
event_bus = get_default_event_bus()
model_provider_service = ModelProviderService(ModelProviderRepository(database))
model_provider_runtime = ModelProviderRuntime(model_provider_service)
config_payload = load_config_payload()
sync_generation_provider_from_config(model_provider_service, config_payload)
generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {}
model_assignments = config_payload.get("model_assignments") if isinstance(config_payload.get("model_assignments"), dict) else {}
governance_config = config_payload.get("prompt_governance") if isinstance(config_payload.get("prompt_governance"), dict) else {}
translation_config = governance_config.get("translation") if isinstance(governance_config.get("translation"), dict) else {}
moderation_config = governance_config.get("moderation") if isinstance(governance_config.get("moderation"), dict) else {}
routing_config = governance_config.get("routing") if isinstance(governance_config.get("routing"), dict) else {}
image_moderation_config = governance_config.get("image_moderation") if isinstance(governance_config.get("image_moderation"), dict) else {}
translation_route = str(translation_config.get("model_route") or model_assignments.get("prompt_planning") or "").strip()
moderation_route = str(moderation_config.get("model_route") or model_assignments.get("cross_review_primary") or "").strip()
translation_callable = (model_provider_runtime.structured_text_callable(translation_route) or astrbot_structured_text_callable(translation_route)) if translation_route else None
moderation_callable = (model_provider_runtime.structured_text_callable(moderation_route) or astrbot_structured_text_callable(moderation_route)) if moderation_route else None
single_flow_engine = SingleFlowEngine(
image_provider_factory=model_provider_runtime.image_provider_for_route,
allow_mock_fallback=False,
)
image_moderation_route = str(image_moderation_config.get("model_route") or "").strip()
image_moderation_callable = model_provider_runtime.structured_vision_callable(
image_moderation_route,
storage=single_flow_engine.storage,
) if image_moderation_route else None
if translation_callable:
raw_translation_callable = translation_callable
translation_callable = lambda request: raw_translation_callable({**request, "purpose": "Chinese-to-English image prompt translation and structured visual decomposition"})
if moderation_callable:
raw_moderation_callable = moderation_callable
moderation_callable = lambda request: raw_moderation_callable({**request, "purpose": "image prompt content risk classification"})
return GenerationService(
workflow_service=WorkflowService(
workflow_repository=workflow_repository,
profile_repository=ProfileRepository(database),
audit_service=audit_service,
event_bus=event_bus,
),
queue_service=QueueService(
repository=JobRepository(database),
audit_service=audit_service,
event_bus=event_bus,
),
image_service=ImageService(
image_repository=ImageRepository(database),
workflow_repository=workflow_repository,
audit_service=audit_service,
),
single_flow_engine=single_flow_engine,
model_provider_service=model_provider_service,
cost_guard_service=CostGuardService(CostService(database)),
prompt_expansion_service=PromptExpansionService(),
event_bus=event_bus,
default_model_route=str(generation_config.get("default_model") or "").strip() or None,
require_resolved_model_route=True,
material_resolver=material_catalog,
material_snapshot_service=WorkflowMaterialSnapshotService(
workflow_repository,
material_catalog,
),
model_assignments=model_assignments,
prompt_translation_service=PromptTranslationService(translation_config, translation_callable),
prompt_semantic_normalizer=PromptSemanticNormalizer(),
prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable),
generation_route_service=GenerationRouteService(routing_config),
image_moderation_service=ImageModerationService(image_moderation_config, image_moderation_callable),
)
def create_generation_service() -> GenerationService:
"""Public runtime factory shared by HTTP routes and background workers."""
return _create_generation_service()
# Assembly moved to the composition root; kept as a thin alias because the
# route handlers and their tests reference this name.
return create_generation_service()
def _bool(value: Any) -> bool:

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.service_registry import create_workflow_service
from backend.routes.params import int_or_default, optional_str
from backend.services.event_stream_service import get_default_event_bus
from backend.services.profile_service import ProfileService
@ -111,7 +112,16 @@ def archive_profile(
profile_id: str,
service: ProfileService | None = None,
) -> dict:
return delete_profile(ctx, profile_id, service)
# This used to forward to delete_profile: an endpoint named "archive"
# performed an irreversible retirement, so callers reaching for the safe
# action silently got the destructive one.
profile_service = service or _create_profile_service()
def action() -> dict:
require_write(ctx)
return profile_service.archive_profile(profile_id, ctx).to_dict()
return handle_request(ctx, action)
@ -172,10 +182,4 @@ def _create_profile_service(database: Database | None = None) -> ProfileService:
def _create_workflow_service(database: Database | None = None) -> WorkflowService:
database = database or Database(load_database_settings())
return WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
event_bus=get_default_event_bus(),
)
return create_workflow_service(database)

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.service_registry import create_workflow_service
from backend.services.review_service import ReviewService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
@ -87,11 +88,7 @@ def save_review_policy(
def _create_review_service() -> ReviewService:
database = Database(load_database_settings())
workflow_service = WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
)
workflow_service = create_workflow_service(database)
return ReviewService(
workflow_service=workflow_service,
image_repository=ImageRepository(database),

查看文件

@ -7,7 +7,7 @@ from typing import Any
from backend.dto.common import ApiError
from backend.routes.common import handle_request
from backend.routes.params import as_bool
from backend.routes.node_routes import create_generation_service
from backend.services.service_registry import create_generation_service
from backend.services.media_service import MediaService
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.workflow_round_feedback_service import WorkflowRoundFeedbackService

查看文件

@ -8,6 +8,7 @@ from backend.routes.common import handle_request
from backend.routes.params import as_bool
from backend.services.media_service import MediaService
from backend.dto.common import ApiError, ErrorCode
from core.audit_service import AuditService
from core.identity import RequestContext
from core.security import require_authenticated, require_config_manager
@ -29,6 +30,7 @@ def migrate_storage(
ctx: RequestContext,
payload: dict[str, Any],
service: MediaService | None = None,
audit_service: AuditService | None = None,
) -> dict:
media_service = service or MediaService()
@ -40,10 +42,31 @@ def migrate_storage(
raise ApiError(ErrorCode.VALIDATION_FAILED, "source_uri is required", {"field": "source_uri"})
if not target_uri:
raise ApiError(ErrorCode.VALIDATION_FAILED, "target_uri is required", {"field": "target_uri"})
return media_service.plan_storage_migration(
dry_run = as_bool(payload.get("dry_run"), default=True)
allow_overwrite = as_bool(payload.get("allow_overwrite"), default=False)
result = media_service.plan_storage_migration(
source_uri,
target_uri,
dry_run=as_bool(payload.get("dry_run"), default=True),
dry_run=dry_run,
allow_overwrite=allow_overwrite,
)
# A non-dry-run migrate copies arbitrary trees between storage roots and
# can overwrite existing data; it was previously the only destructive
# config-tier operation with no audit trail at all.
if not dry_run:
(audit_service or AuditService()).record(
ctx=ctx,
action="storage.migrate",
target_type="storage",
target_id=target_uri,
metadata={
"source_uri": source_uri,
"target_uri": target_uri,
"files": result.get("files"),
"bytes": result.get("bytes"),
"overwrote": bool(result.get("will_overwrite")),
},
)
return result
return handle_request(ctx, action)

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.service_registry import create_workflow_service
from backend.services.character_workflow_service import CharacterWorkflowService
from backend.services.event_stream_service import get_default_event_bus
from backend.services.queue_service import QueueService
@ -141,10 +142,4 @@ def execute_character_workflow(
def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings())
return WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
event_bus=get_default_event_bus(),
)
return create_workflow_service()

查看文件

@ -65,6 +65,7 @@ from database.repositories.model_provider_repository import ModelProviderReposit
from engines.image_provider import ImageProviderError
from engines.single_flow import SingleFlowEngine
from engines.vision_provider import VisionProviderError, VisionRecognitionRequest
from core.text_utils import optional_text as _optional_text
IMPORT_ACTIVE_STATUSES = {"recognition_queued", "recognizing", "validation_queued", "validating"}
@ -1764,11 +1765,6 @@ def create_advanced_material_service() -> AdvancedMaterialService:
)
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _governance_context(config: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:

查看文件

@ -209,8 +209,17 @@ def _saved_provider_probe_payload(payload: dict[str, Any]) -> dict[str, Any]:
"saved generation adapter was not found",
{"provider_id": provider_id},
)
# A caller-supplied key must win over the stored one. The settings UI offers
# a "probe API key" field promising the value is "only used for this page
# session ... not written to config or logs"; honouring it here is what lets
# the frontend keep that promise, instead of persisting the key through
# settings/save just to make the probe authenticate.
session_api_key = str(
payload.get("api_key_plaintext") or payload.get("api_key") or ""
).strip()
return {
**saved,
**({"api_key_plaintext": session_api_key} if session_api_key else {}),
"provider_id": provider_id or str(saved.get("id") or saved.get("provider_id") or "").strip(),
"model_id": str(saved.get("model_id") or payload.get("model_id") or "auto-discovery"),
"dialect": payload.get("dialect") or "openai_images",

查看文件

@ -36,6 +36,7 @@ class AssetImportService:
package_uri: str,
*,
dry_run: bool = True,
allow_overwrite: bool = False,
ctx: RequestContext | None = None,
) -> dict[str, Any]:
root, relative = self.storage.split_uri(package_uri)
@ -75,7 +76,15 @@ class AssetImportService:
"asset pack import execution is unavailable",
{"field": "material_service"},
)
applied = self._apply_manifest(package_uri, root, relative, package_path, manifest_candidates[0], ctx)
applied = self._apply_manifest(
package_uri,
root,
relative,
package_path,
manifest_candidates[0],
ctx,
allow_overwrite=allow_overwrite,
)
return {
"dry_run": dry_run,
"status": "planned" if dry_run else "applied",
@ -98,6 +107,8 @@ class AssetImportService:
package_path: Path,
manifest: dict[str, Any],
ctx: RequestContext,
*,
allow_overwrite: bool = False,
) -> dict[str, Any]:
payload = _load_manifest_payload(manifest["path"])
if _list_count(payload.get("styles")):
@ -144,6 +155,27 @@ class AssetImportService:
self.material_service.validate_material_payload(material_payload, creating=existing is None)
planned_materials.append((material_payload, existing is None))
# An asset pack whose manifest reuses an existing material_id used to
# silently rewrite that material -- image, tags, category and all --
# with no confirmation and no way to tell it had happened. Collect every
# collision first so the caller sees the whole blast radius in one
# response rather than discovering it one failed import at a time.
conflicts = [
str(payload_item["material_id"])
for payload_item, creating in planned_materials
if not creating
]
if conflicts and not allow_overwrite:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"asset pack would overwrite existing materials; retry with allow_overwrite=true to replace them",
{
"field": "materials",
"conflicting_material_ids": sorted(conflicts),
"conflicts": len(conflicts),
},
)
for material_payload, creating in planned_materials:
if creating:
material = self.material_service.create_material(material_payload, ctx)
@ -337,7 +369,11 @@ def _material_payload_from_manifest_item(
"prompt": _optional_text(item.get("prompt")),
"negative_prompt": _optional_text(item.get("negative_prompt")),
"tags": _normalize_tags(item.get("tags")),
"recognition_status": _optional_text(item.get("recognition_status")) or "pending_recognition",
# An imported pack is an untrusted document: letting its manifest
# declare "confirmed" would let a pack author skip recognition and human
# review entirely, landing unvetted material straight in the confirmed
# library. Only states that still require review are honoured.
"recognition_status": _importable_recognition_status(item.get("recognition_status")),
"metadata": {
**metadata,
"asset_pack": {
@ -349,6 +385,19 @@ def _material_payload_from_manifest_item(
}
# Recognition states an imported manifest is allowed to request. "confirmed"
# and "archived" are review *outcomes* and must be reached through the normal
# recognise -> confirm flow, not asserted by the pack being imported.
IMPORTABLE_RECOGNITION_STATUSES = {"pending_upload", "pending_recognition", "pending_confirm"}
def _importable_recognition_status(value: Any) -> str:
requested = _optional_text(value)
if requested in IMPORTABLE_RECOGNITION_STATUSES:
return requested
return "pending_recognition"
def _asset_uri(value: Any, root: str, base_relative: Path) -> str | None:
text = _optional_text(value)
if text is None:

查看文件

@ -16,36 +16,17 @@ from backend.dto.common import ApiError, ErrorCode
from backend.dto.workflow_dto import WorkflowBranch, WorkflowNode
from database.repositories.workflow_repository import WorkflowRepository
BRANCH_STATE_FIELDS = frozenset(
{
"character_execution",
"material_binding_schema_version",
"material_binding_source_node_id",
"material_binding_updated_at",
"material_bindings",
"prompt_plan_schema_version",
"prompt_plan_source_node_id",
"prompt_plan_updated_at",
"prompt_plan",
"prompt_matrix",
"stage_input_schema_version",
"stage_inputs",
"restoration_input_schema_version",
"restoration_inputs",
"stage_review_handoffs",
"last_stage_review_confirmed_at",
"last_stage_review_node_id",
"last_stage_review_image_id",
"current_stage_input_image_id",
"final_archive_schema_version",
"final_archive_history_id",
"final_archive_image_ids",
"final_archive_node_id",
"final_archive_source_node_id",
"final_archive_completed_at",
}
# Re-exported: the pure metadata transforms now live in core so the data layer
# can use them without importing this module (which owns a WorkflowRepository).
from core.branch_state import ( # noqa: F401
BRANCH_STATE_FIELDS,
branch_state_for,
with_branch_state,
workflow_metadata_for_branch,
)
from core.text_utils import optional_text as _optional_text
EFFECTIVE_CONTEXT_STATUSES = frozenset({"completed", "selected", "skipped"})
@ -259,53 +240,6 @@ class BranchLineageResolver:
branch_nodes.sort(key=lambda item: (item.sort_order, item.created_at, item.node_id))
def branch_state_for(metadata: dict[str, Any] | None, branch_name: str) -> dict[str, Any]:
"""Read branch state with a root-metadata fallback for pre-1.0.16 data."""
source = metadata if isinstance(metadata, dict) else {}
branch_states = source.get("branch_state")
if isinstance(branch_states, dict) and isinstance(branch_states.get(branch_name), dict):
return deepcopy(branch_states[branch_name])
return {
key: deepcopy(source[key])
for key in BRANCH_STATE_FIELDS
if key in source
}
def workflow_metadata_for_branch(metadata: dict[str, Any] | None, branch_name: str) -> dict[str, Any]:
"""Return the legacy root projection overlaid with one branch's state."""
result = deepcopy(metadata) if isinstance(metadata, dict) else {}
state = branch_state_for(result, branch_name)
for key in BRANCH_STATE_FIELDS:
result.pop(key, None)
result.update(state)
return result
def with_branch_state(
metadata: dict[str, Any] | None,
branch_name: str,
patch: dict[str, Any],
*,
activate: bool,
) -> dict[str, Any]:
"""Merge one branch state while preserving every sibling branch."""
result = deepcopy(metadata) if isinstance(metadata, dict) else {}
states = deepcopy(result.get("branch_state")) if isinstance(result.get("branch_state"), dict) else {}
state = branch_state_for(result, branch_name)
state.update({key: deepcopy(value) for key, value in patch.items() if key in BRANCH_STATE_FIELDS})
states[branch_name] = state
result["branch_state"] = states
if activate:
for key in BRANCH_STATE_FIELDS:
result.pop(key, None)
result.update(deepcopy(state))
return result
def activate_branch_state(metadata: dict[str, Any] | None, branch_name: str) -> dict[str, Any]:
return with_branch_state(metadata, branch_name, {}, activate=True)
@ -340,11 +274,6 @@ def _lineage_error(message: str, workflow_id: str, branch_name: str, **details:
)
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _unique_lineage(values: tuple[str, ...]) -> tuple[str, ...]:

查看文件

@ -4,15 +4,64 @@ from __future__ import annotations
import base64
import hashlib
import os
import tempfile
from pathlib import Path
from urllib.parse import urlsplit
from core.image_formats import detect_image_format
from core.remote_fetch import read_http_response_limited
from core.runtime_paths import get_runtime_data_root
from core.storage import VfsStorage
MAX_CHAT_IMAGE_BYTES = 20 * 1024 * 1024
# Extra directories that may hold platform-cached chat images (AstrBot writes
# OneBot/WeChat downloads outside the plugin's own data root).
LOCAL_IMAGE_ROOTS_ENV_VAR = "IMAGESTUDIO_CHAT_IMAGE_ROOTS"
def _allowed_local_roots() -> list[Path]:
"""Directories a chat message is permitted to reference by local path."""
roots = [get_runtime_data_root(), Path(tempfile.gettempdir())]
configured = str(os.environ.get(LOCAL_IMAGE_ROOTS_ENV_VAR, "")).strip()
if configured:
roots.extend(Path(part) for part in configured.split(os.pathsep) if part.strip())
resolved: list[Path] = []
for root in roots:
try:
resolved.append(root.expanduser().resolve())
except OSError:
continue
return resolved
def _read_local_image(text: str) -> tuple[bytes, str]:
"""Read a platform-cached image, refusing paths outside the allowed roots.
``image_references_from_event`` forwards the raw ``file``/``path``
attribute of an inbound message component. On OneBot that is a local cache
path, so the branch has to exist -- but the value ultimately originates
from the remote peer, and the previous ``Path(text).read_bytes()`` would
happily return ``config.yaml`` or an SSH key, store it as a "material",
and hand it back to the requester through the media endpoints.
"""
source = Path(text).expanduser().resolve()
allowed = _allowed_local_roots()
if not any(source == root or root in source.parents for root in allowed):
raise ValueError("聊天图片路径不在允许的目录内")
if not source.is_file():
raise ValueError("聊天图片路径不存在")
body = source.read_bytes()
# Even inside an allowed root, only accept real image bytes so a text file
# cannot be laundered into the material library.
if detect_image_format(body) is None:
raise ValueError("聊天图片格式无法识别")
return body, source.suffix.lstrip(".").lower() or "jpg"
class ChatMediaImportService:
def __init__(self, storage: VfsStorage | None = None):
@ -31,9 +80,7 @@ class ChatMediaImportService:
body = read_http_response_limited(text, timeout_seconds=30, max_bytes=MAX_CHAT_IMAGE_BYTES)
extension = Path(urlsplit(text).path).suffix.lstrip(".").lower() or "jpg"
else:
source = Path(text).expanduser().resolve()
body = source.read_bytes()
extension = source.suffix.lstrip(".").lower() or "jpg"
body, extension = _read_local_image(text)
if not body or len(body) > MAX_CHAT_IMAGE_BYTES:
raise ValueError("聊天图片为空或超过 20MB")
if extension not in {"png", "jpg", "jpeg", "webp", "gif"}:

查看文件

@ -11,6 +11,7 @@ from backend.dto.job_dto import GenerationTask
from backend.services.generation_service import GenerationService
from backend.services.queue_service import QueueService
from core.identity import RequestContext
from core.text_utils import optional_text as _optional_text
MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES = 5
@ -470,11 +471,6 @@ def _int_or_default(value: Any, default: int) -> int:
return default
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _safe_error_message(exc: Exception) -> str:

查看文件

@ -12,6 +12,7 @@ from backend.dto.common import ApiError, ErrorCode
from backend.services.image_service import ImageService
from backend.services.material_catalog_resolver import is_trusted_advanced_metadata
from core.storage import VfsStorage
from core.text_utils import optional_text as _optional_text
MAX_REFERENCE_IMAGE_BYTES = 25 * 1024 * 1024
@ -470,10 +471,3 @@ def _image_too_large(uri: str, size: int, source: str) -> ApiError:
def _is_reference_uri(value: str) -> bool:
return value.lower().startswith(("storage://", "data:", "http://", "https://"))
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None

查看文件

@ -50,6 +50,7 @@ from core.identity import RequestContext
from engines.character_flow import canonical_gradual_node_key
from engines.image_provider import ImageProviderError
from engines.single_flow import SingleFlowEngine
from core.text_utils import optional_text as _optional_text
_NODE_GENERATION_LOCKS_GUARD = threading.Lock()
@ -1429,6 +1430,22 @@ class GenerationService:
)
return after
def _governance_config(self) -> dict[str, Any]:
"""Load the config that backs the adult-content allowlist.
Kept tolerant: content governance must fail closed (empty allowlist ->
no adult permission) rather than break generation outright if the
config cannot be read.
"""
try:
from database.db_helper import load_config_payload
payload = load_config_payload()
return payload if isinstance(payload, dict) else {}
except Exception:
return {}
def _expand_prompt(
self,
profile_id: str,
@ -1500,7 +1517,7 @@ class GenerationService:
entrypoint=entrypoint,
user_id=ctx.actor_id,
group_id=_optional_text(payload.get("group_id") or payload.get("chat_group_id")),
permission_context=_permission_context(payload),
permission_context=_permission_context(payload, ctx, self._governance_config()),
)
else:
from backend.services.prompt_governance_service import GenerationRouteDecision
@ -1578,7 +1595,7 @@ class GenerationService:
entrypoint=_entrypoint(payload),
user_id=ctx.actor_id,
group_id=_optional_text(payload.get("group_id") or payload.get("chat_group_id")),
permission_context=_permission_context(payload),
permission_context=_permission_context(payload, ctx, self._governance_config()),
)
if not route.allowed or moderation.level != "adult_allowed" or not route.selected_route or route.selected_route == runtime_request.get("model_route"):
return None
@ -2109,11 +2126,6 @@ def _generation_task_summary(
return " / ".join(normalized) if normalized else None
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
_OMITTED_EPHEMERAL_REFERENCE = object()
@ -2363,15 +2375,49 @@ def _entrypoint(payload: dict[str, Any]) -> str:
return "unknown"
def _permission_context(payload: dict[str, Any]) -> dict[str, Any]:
def _adult_user_allowlist(config: dict[str, Any] | None) -> set[str]:
access = (config or {}).get("chat_access")
access = access if isinstance(access, dict) else {}
return {
str(value).strip()
for value in (access.get("adult_user_allowlist") or [])
if str(value).strip()
}
def _permission_context(
payload: dict[str, Any],
ctx: RequestContext | None = None,
config: dict[str, Any] | None = None,
) -> dict[str, Any]:
"""Build the content-governance permission context for a generation.
``adult_user_allowed`` used to be taken straight from the request body, so
any caller able to reach ``nodes/{id}/generate`` could post
``{"content_permissions": {"adult_user_allowed": true}}`` and walk through
the adult-content gate in ``prompt_governance_service``. The chat path
already derived the flag server-side from ``chat_access.adult_user_
allowlist``; the claim is now re-verified against that same allowlist for
every entrypoint, so the payload can only ever narrow the permission.
"""
configured = payload.get("content_permissions") if isinstance(payload.get("content_permissions"), dict) else {}
claimed_adult = bool(configured.get("adult_user_allowed", payload.get("adult_user_allowed", False)))
actor_id = str((ctx.actor_id if ctx else "") or "").strip()
verified_adult = bool(
claimed_adult and actor_id and actor_id in _adult_user_allowlist(config)
)
result = {
**configured,
"adult_user_allowed": bool(configured.get("adult_user_allowed", payload.get("adult_user_allowed", False))),
"adult_user_allowed": verified_adult,
"quota_allowed": bool(configured.get("quota_allowed", payload.get("quota_allowed", True))),
}
if "adult_group_allowed" in configured or "adult_group_allowed" in payload:
result["adult_group_allowed"] = bool(configured.get("adult_group_allowed", payload.get("adult_group_allowed")))
# Group permission can only restrict further, never widen: an
# unverified user must not be lifted by a claimed group flag.
result["adult_group_allowed"] = bool(
configured.get("adult_group_allowed", payload.get("adult_group_allowed"))
)
return result

查看文件

@ -13,6 +13,7 @@ from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.repositories.workflow_repository import WorkflowRepository
from core.text_utils import optional_text as _optional_text
class HistoryService:
@ -303,11 +304,6 @@ def new_history_id() -> str:
STAGE_INPUT_SCHEMA_VERSION = "2026-07-09.stage-input-bucket.v1"
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _mapping(value: Any) -> dict[str, Any]:

查看文件

@ -5,11 +5,18 @@ from __future__ import annotations
from copy import deepcopy
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.dto.workflow_dto import WorkflowNode
from engines.character_flow import canonical_gradual_node_key
from core.text_utils import optional_text as _optional_text
MATERIAL_BINDING_SCHEMA_VERSION = "2026-07-09.material-binding-schema.v1"
# Only versions listed here may take the "already normalized" path. An
# unrecognized version must fail closed rather than fall through, otherwise a
# future/forged marker is an easy way to smuggle an unchecked payload past the
# normalizer.
KNOWN_MATERIAL_BINDING_SCHEMA_VERSIONS: frozenset[str] = frozenset({MATERIAL_BINDING_SCHEMA_VERSION})
NODE_MATERIAL_BINDING_SCHEMA_VERSION = "2026-07-15.node-material-bindings.v1"
NODE_MATERIAL_BINDING_METADATA_KEY = "node_material_bindings"
@ -44,18 +51,47 @@ def normalize_material_bindings(
payload: Any,
workflow_nodes: list[WorkflowNode] | None = None,
) -> dict[str, Any]:
if isinstance(payload, dict) and payload.get("schema_version") == MATERIAL_BINDING_SCHEMA_VERSION:
normalized = deepcopy(payload)
if workflow_nodes:
rules = normalized.get("active_rules")
if not isinstance(rules, list):
rules = [
rule
for rule in normalized.get("rules", [])
if isinstance(rule, dict) and rule.get("use_reference")
]
normalized["by_node_id"] = _index_by_node_id(rules, workflow_nodes)
return normalized
"""Return one canonical material-binding document for ``payload``.
A payload carrying a ``schema_version`` claims to be normalized already and
must not go through the raw rewrite: ``_normalize_rule`` reads the *raw*
rule shape (``material_id``) rather than the normalized one
(``material.material_id``), so re-running it on a normalized rule silently
empties every binding. That second path used to be granted on the version
marker alone, which turned the marker itself into the bypass -- any client
could staple the current version string onto arbitrary content and have it
stored, then replayed verbatim, including a forged ``by_node_id`` view that
feeds straight into generation prompts. Reads take the same path, so a
single such write poisoned the ``material_bind`` node permanently. The
claim is now verified instead of trusted, an unrecognized version fails
closed, and every derived index is recomputed from the rules rather than
carried over from the caller.
"""
declared_version = _optional_text(payload.get("schema_version")) if isinstance(payload, dict) else None
if declared_version is not None:
if declared_version not in KNOWN_MATERIAL_BINDING_SCHEMA_VERSIONS:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"素材绑定数据的 schema_version 无法识别,请使用当前版本重新提交",
{
"field": "material_bindings.schema_version",
"actual": declared_version,
"supported_versions": sorted(KNOWN_MATERIAL_BINDING_SCHEMA_VERSIONS),
},
)
raw_rules = payload.get("rules")
if not isinstance(raw_rules, list):
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"素材绑定数据缺少合法的 rules 列表",
{
"field": "material_bindings.rules",
"actual_type": type(raw_rules).__name__,
},
)
rules = [_validated_normalized_rule(rule, index + 1) for index, rule in enumerate(raw_rules)]
return _assemble_bindings(rules, payload, workflow_nodes)
source = _extract_source_payload(payload)
rules = [
@ -63,6 +99,14 @@ def normalize_material_bindings(
for index, rule in enumerate(source.get("rules", []) if isinstance(source.get("rules"), list) else [])
if isinstance(rule, dict)
]
return _assemble_bindings(rules, source, workflow_nodes)
def _assemble_bindings(
rules: list[dict[str, Any]],
source: dict[str, Any],
workflow_nodes: list[WorkflowNode] | None,
) -> dict[str, Any]:
active_rules = [rule for rule in rules if rule["use_reference"]]
by_stage = _index_by_stage(active_rules)
by_node_key = _index_by_node_key(active_rules)
@ -284,6 +328,150 @@ def _normalize_rule(rule: dict[str, Any], ordinal: int) -> dict[str, Any]:
}
def _validated_normalized_rule(rule: Any, ordinal: int) -> dict[str, Any]:
"""Check one rule that claims to be normalized already, and re-canonicalize it.
A missing field is tolerated and defaulted: stored documents predate some
of the keys below, and a read must not break on them. A field that is
*present with the wrong shape* is rejected instead, because the normalizer
can never produce that -- it only appears when the payload was hand-crafted
against the version marker.
"""
field = f"material_bindings.rules[{ordinal - 1}]"
if not isinstance(rule, dict):
raise _binding_error(field, "素材绑定规则必须是对象", {"actual_type": type(rule).__name__})
material = rule.get("material")
if material is None:
material = {}
if not isinstance(material, dict):
raise _binding_error(
f"{field}.material",
"素材绑定规则的 material 必须是对象",
{"actual_type": type(material).__name__},
)
material_id = _checked_text(material.get("material_id"), f"{field}.material.material_id")
material_prompt = _checked_text(material.get("prompt"), f"{field}.material.prompt")
use_reference = rule.get("use_reference")
if use_reference is None:
use_reference = bool(material_id or material_prompt)
elif not isinstance(use_reference, bool):
raise _binding_error(
f"{field}.use_reference",
"素材绑定规则的 use_reference 必须是布尔值",
{"actual_type": type(use_reference).__name__},
)
elif use_reference and not (material_id or material_prompt):
# ``explicit_only`` means a reference exists only when a material or a
# prompt backs it; a bare flag would enable an empty reference.
raise _binding_error(
f"{field}.use_reference",
"启用参考的素材绑定规则必须提供素材或提示词",
{"material_id": material_id, "prompt": material_prompt},
)
generation_params = rule.get("generation_params")
if generation_params is not None and not isinstance(generation_params, dict):
raise _binding_error(
f"{field}.generation_params",
"素材绑定规则的 generation_params 必须是对象",
{"actual_type": type(generation_params).__name__},
)
strength = _checked_reference_strength(rule.get("reference_strength"), f"{field}.reference_strength")
target_stages = _checked_target_stages(rule.get("target_stages"), f"{field}.target_stages")
target_node_keys = _checked_text_list(rule.get("target_node_keys"), f"{field}.target_node_keys")
if not target_node_keys:
target_node_keys = _unique_texts(
node_key for stage in target_stages for node_key in STAGE_NODE_KEYS.get(stage["stage_id"], ())
)
return {
**deepcopy(rule),
"id": _checked_text(rule.get("id"), f"{field}.id") or f"material_binding_{ordinal:02d}",
"category": _checked_text(rule.get("category"), f"{field}.category") or "other",
"use_reference": use_reference,
"required": bool(rule.get("required")),
"status": _checked_text(rule.get("status"), f"{field}.status")
or ("ready" if use_reference else "pending"),
"conflict": _checked_text(rule.get("conflict"), f"{field}.conflict"),
"material": {
**deepcopy(material),
"material_id": material_id,
"label": _checked_text(material.get("label"), f"{field}.material.label"),
"group": _checked_text(material.get("group"), f"{field}.material.group"),
"prompt": material_prompt,
"colors": _checked_text_list(material.get("colors"), f"{field}.material.colors"),
},
"target_stages": target_stages,
"target_node_keys": target_node_keys,
"inheritance_rule": _checked_text(rule.get("inheritance_rule"), f"{field}.inheritance_rule") or "",
"reference_strength": strength,
"generation_params": {
"reference_policy": "explicit_only" if use_reference else "do_not_use_reference",
"reference_strength": strength["key"] if use_reference else "none",
"reference_weight": strength["weight"] if use_reference else 0,
},
"expand_to_nodes_later": True,
}
def _checked_text(value: Any, field: str) -> str | None:
if value is None:
return None
if not isinstance(value, str):
raise _binding_error(field, "素材绑定字段必须是文本", {"actual_type": type(value).__name__})
return value.strip() or None
def _checked_text_list(value: Any, field: str) -> list[str]:
if value is None:
return []
if not isinstance(value, list) or any(not isinstance(item, str) for item in value):
raise _binding_error(field, "素材绑定字段必须是文本列表", {"actual_type": type(value).__name__})
return _unique_texts(value)
def _checked_target_stages(value: Any, field: str) -> list[dict[str, str]]:
if value is None:
return []
if not isinstance(value, list):
raise _binding_error(field, "素材绑定字段必须是阶段列表", {"actual_type": type(value).__name__})
stages: list[dict[str, str]] = []
for index, item in enumerate(value):
if not isinstance(item, dict):
raise _binding_error(
f"{field}[{index}]",
"素材绑定阶段必须是对象",
{"actual_type": type(item).__name__},
)
stage_id = _checked_text(item.get("stage_id"), f"{field}[{index}].stage_id")
if not stage_id:
raise _binding_error(f"{field}[{index}].stage_id", "素材绑定阶段缺少 stage_id", {})
stage = {
"stage_id": stage_id,
"stage_title": _checked_text(item.get("stage_title"), f"{field}[{index}].stage_title") or stage_id,
}
if stage not in stages:
stages.append(stage)
return stages
def _checked_reference_strength(value: Any, field: str) -> dict[str, Any]:
if value is None:
return {"label": "medium", "key": "medium", "weight": 0.55}
if not isinstance(value, dict):
raise _binding_error(field, "素材绑定强度必须是对象", {"actual_type": type(value).__name__})
label = _checked_text(value.get("label"), f"{field}.label") or "medium"
key_text = _checked_text(value.get("key"), f"{field}.key") or label
strength_key, default_weight = STRENGTHS.get(key_text.lower(), STRENGTHS.get(key_text, ("medium", 0.55)))
weight = value.get("weight", default_weight)
if isinstance(weight, bool) or not isinstance(weight, (int, float)):
raise _binding_error(f"{field}.weight", "素材绑定强度权重必须是数值", {"actual_type": type(weight).__name__})
return {"label": label, "key": strength_key, "weight": min(max(float(weight), 0.0), 1.0)}
def _binding_error(field: str, message: str, details: dict[str, Any]) -> ApiError:
return ApiError(ErrorCode.VALIDATION_FAILED, message, {"field": field, **details})
def _target_stages(value: Any) -> list[dict[str, str]]:
if not isinstance(value, list):
return []
@ -399,10 +587,3 @@ def _unique_texts(values: Any) -> list[str]:
if text and text not in result:
result.append(text)
return result
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None

查看文件

@ -21,8 +21,20 @@ class MediaService:
def storage_status(self) -> dict[str, Any]:
return self.storage.status()
def plan_storage_migration(self, source_uri: str, target_uri: str, *, dry_run: bool = True) -> dict[str, Any]:
return self.storage.migration_plan(source_uri, target_uri, dry_run=dry_run)
def plan_storage_migration(
self,
source_uri: str,
target_uri: str,
*,
dry_run: bool = True,
allow_overwrite: bool = False,
) -> dict[str, Any]:
return self.storage.migration_plan(
source_uri,
target_uri,
dry_run=dry_run,
allow_overwrite=allow_overwrite,
)
def sign_media(self, uri: str) -> dict[str, Any]:
return self.media_proxy.sign(uri)

查看文件

@ -9,6 +9,7 @@ from backend.dto.common import ApiError, ErrorCode
from backend.dto.profile_dto import CharacterProfile, ProfileListResult
from core.audit_service import AuditService
from core.identity import RequestContext
from core.security import can_access_owned_resource
from database.repositories.profile_repository import ProfileRepository
VISUAL_PROFILE_FIELDS = {
@ -133,6 +134,35 @@ class ProfileService:
)
return after
def archive_profile(self, profile_id: str, ctx: RequestContext) -> CharacterProfile:
"""Retire a profile without destroying it.
Archiving deliberately keeps the row readable through ``get_profile``
so the action stays reversible (flip ``status`` back to ``active``);
the default ``list_profiles`` filter is ``active``, so an archived
profile still leaves the library view. Writing ``status`` through the
repository rather than ``update_profile`` avoids the sealed-card visual
field guard, which has no bearing on retiring a profile.
"""
before = self.get_profile(profile_id, ctx)
after = self.repository.update(profile_id, {"status": "archived"})
if after is None:
raise ApiError(
ErrorCode.RESOURCE_NOT_FOUND,
"角色档案不存在",
{"profile_id": profile_id},
)
self.audit_service.record(
ctx=ctx,
action="archive_profile",
target_type="character_profile",
target_id=profile_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def delete_profile(self, profile_id: str, ctx: RequestContext) -> CharacterProfile:
before = self.get_profile(profile_id, ctx)
after = self.repository.soft_delete(profile_id)
@ -158,7 +188,10 @@ class ProfileService:
raise ApiError(ErrorCode.VALIDATION_FAILED, "角色名称不能为空", {"field": "name"})
def _require_owner(self, profile: CharacterProfile, ctx: RequestContext) -> None:
if ctx.actor_id and ctx.actor_id == profile.owner_user_id:
# Delegates to the shared predicate so this path honours
# ``can_manage_all_profiles`` exactly like ResourceAccessService does;
# the two used to disagree about administrators.
if can_access_owned_resource(profile.owner_user_id, ctx):
return
# Use not-found semantics so guessed resource IDs cannot enumerate
# another user's profiles.

查看文件

@ -10,6 +10,7 @@ from backend.services.node_injection_template_service import (
build_node_injection_contract,
injection_payload_from_generation_request,
)
from engines.character_flow import canonical_gradual_node_key
from core.prompt_pipeline import merge_prompt_sections
@ -108,8 +109,10 @@ class PromptExpansionService:
selected_draft_image_ids=_string_list(selected_draft_image_ids),
ui_context=injection_payload["ui_context"],
)
prompt_result = result.to_dict()
prompt_result = _apply_character_stage_prompt_guard(prompt_result, node)
return {
**result.to_dict(),
**prompt_result,
"source": "profile_node",
"profile_id": profile.profile_id,
"node_id": node.node_id,
@ -117,6 +120,43 @@ class PromptExpansionService:
}
def _apply_character_stage_prompt_guard(result: dict[str, Any], node: WorkflowNode) -> dict[str, Any]:
if canonical_gradual_node_key(getattr(node, "node_key", None)) != "headshot":
return result
positive_guard = (
"headshot avatar portrait only, close-up head and face, head and shoulders crop, "
"face fills the frame, centered single character, one person"
)
negative_guard = (
"full body, upper body composition, lower body, standing pose, wide shot, distant character, "
"character design sheet, turnaround, multiple views, expression sheet, outfit callouts, "
"multiple characters, tiny face, full scene"
)
return {
**result,
"prompt": _join_prompt_parts(result.get("prompt"), positive_guard),
"negative_prompt": _join_prompt_parts(result.get("negative_prompt"), negative_guard),
"stage_prompt_guard": {
"stage": "headshot",
"positive": positive_guard,
"negative": negative_guard,
"aspect_ratio": "1:1",
},
}
def _join_prompt_parts(*values: Any) -> str:
result: list[str] = []
seen: set[str] = set()
for value in values:
text = str(value or "").strip()
key = text.casefold()
if text and key not in seen:
result.append(text)
seen.add(key)
return ", ".join(result)
def _payload_parts(payload: dict[str, Any]) -> list[Any]:
parts: list[Any] = []
parts.extend(_as_list(payload.get("prompt_parts")))

查看文件

@ -7,6 +7,7 @@ from typing import Any
from backend.dto.workflow_dto import WorkflowNode
from engines.character_flow import canonical_gradual_node_key
from core.text_utils import optional_text as _optional_text
PROMPT_PLAN_SCHEMA_VERSION = "2026-07-09.prompt-plan-schema.v1"
@ -368,11 +369,6 @@ def _unique_texts(values: Any) -> list[str]:
return result
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _key(value: str) -> str:

查看文件

@ -13,6 +13,7 @@ from core.event_bus import EventBus
from core.fsm import task_transition
from core.identity import RequestContext
from database.repositories.job_repository import JobRepository
from core.text_utils import optional_text as _optional_text
TASK_STATUSES = {
@ -88,6 +89,16 @@ class QueueService:
)
return task
def list_claimable_jobs(self, *, status: str = "queued", limit: int = 25) -> list[GenerationTask]:
"""Oldest-first queued tasks for worker claim (FIFO).
Separate from ``list_jobs``, which is the newest-first *display*
listing; consuming the queue in display order made it a LIFO and
starved the backlog.
"""
return self.repository.list_claimable(status=status, limit=limit)
def list_jobs(
self,
*,
@ -710,11 +721,6 @@ def _now() -> str:
return datetime.now(timezone.utc).isoformat()
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _batch_limit(value: int) -> int:

查看文件

@ -12,6 +12,7 @@ from typing import Any
from backend.dto.common import ApiError, ErrorCode
from core.identity import RequestContext
from core.security import can_access_owned_resource
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.profile_repository import ProfileRepository
@ -79,9 +80,7 @@ class ResourceAccessService:
@staticmethod
def _can_access(owner_user_id: str | None, ctx: RequestContext) -> bool:
if ctx.has_permission("can_manage_all_profiles") or ctx.has_permission("*"):
return True
return bool(ctx.actor_id and owner_user_id and ctx.actor_id == owner_user_id)
return can_access_owned_resource(owner_user_id, ctx)
def _not_found(resource: str, resource_id: str) -> ApiError:

查看文件

@ -0,0 +1,88 @@
"""Central owner-chain enforcement for dispatched routes.
``ResourceAccessService`` already implements the full profile -> workflow ->
node -> image -> task ownership chain, but only three call sites used it. The
web routes resolved a path parameter straight into a service call after nothing
more than ``require_authenticated``, so any logged-in user could read or mutate
another user's workflow, node, image, or generation task by guessing an ID
(``GET jobs`` even returned the full generation request body).
Enforcing per-handler would mean touching ~60 handlers and would silently miss
every route added later. Instead this runs once in the dispatcher, keyed on the
path parameter name, which makes ownership a property of the route table rather
than of whoever wrote the handler.
"""
from __future__ import annotations
from typing import Any, Callable
from core.identity import RequestContext
# Path parameters that name an owned resource, mapped to the
# ``ResourceAccessService`` method that walks its chain up to a profile owner.
#
# Deliberately limited to the five chains that terminate at ``profile.owner_
# user_id``. Material-domain identifiers (``material_id``, ``category_id``,
# ``import_id``, ...) follow a different, library-wide sharing model and are
# gated by the ``materials`` permission tier instead.
OWNED_PARAM_RESOLVERS: dict[str, str] = {
"profile_id": "require_profile",
"workflow_id": "require_workflow",
"node_id": "require_node",
"image_id": "require_image",
"task_id": "require_task",
}
# Routes whose declared permission tier means "no session", so there is no
# actor to compare an owner against.
UNAUTHENTICATED_PERMISSIONS = frozenset({"public_token"})
def enforce_route_ownership(
ctx: RequestContext,
permission: str,
path_params: dict[str, str],
access_service_factory: Callable[[], Any],
) -> None:
"""Raise ``RESOURCE_NOT_FOUND`` if ``ctx`` does not own the addressed resource.
Only the most specific identifier present is checked: ``require_node``
already walks up through the workflow to the profile, so checking every
parameter would issue redundant queries for the same chain.
"""
if permission in UNAUTHENTICATED_PERMISSIONS:
return
if not path_params:
return
for param in ("image_id", "task_id", "node_id", "workflow_id", "profile_id"):
value = path_params.get(param)
if not value:
continue
resolver_name = OWNED_PARAM_RESOLVERS[param]
service = access_service_factory()
getattr(service, resolver_name)(value, ctx)
return
def create_resource_access_service() -> Any:
"""Build a ``ResourceAccessService`` against the default database."""
# Imported lazily so the dispatcher does not pay for the database stack on
# routes that carry no owned identifier.
from backend.services.resource_access_service import ResourceAccessService
from database.db_helper import Database, load_database_settings
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
database = Database(load_database_settings())
return ResourceAccessService(
ProfileRepository(database),
WorkflowRepository(database),
ImageRepository(database),
JobRepository(database),
)

查看文件

@ -0,0 +1,161 @@
"""Composition root for request-scoped services.
Route modules used to each carry their own ``_create_*_service()`` factory --
35 of them across 20 modules. Because the wiring was duplicated rather than
shared, the factories drifted: four of the seven ``WorkflowService`` builders
omitted ``event_bus`` entirely, so whether a workflow mutation published an
event depended on which route you happened to enter through. That is how
``branch_routes`` stopped pushing branch events and ``node_material_routes``
stopped publishing material-binding events -- not a bug anyone wrote, a bug
that grew out of copy-paste assembly.
Assembling in one place makes the dependency set a single decision. Adding a
collaborator here reaches every route at once, which is exactly the property
the per-module factories lacked.
"""
from __future__ import annotations
from backend.services.event_stream_service import get_default_event_bus
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from database.db_helper import Database, load_database_settings
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
def create_database() -> Database:
"""Build a ``Database`` from the active configuration."""
return Database(load_database_settings())
def create_workflow_service(database: Database | None = None) -> WorkflowService:
"""Assemble ``WorkflowService`` with its full collaborator set.
``event_bus`` is not optional in practice: without it every
``publish(...)`` call inside the service becomes a silent no-op and the
frontend's event stream simply never sees the change.
"""
resolved = database or create_database()
return WorkflowService(
workflow_repository=WorkflowRepository(resolved),
profile_repository=ProfileRepository(resolved),
audit_service=AuditService(resolved),
event_bus=get_default_event_bus(),
)
# ---------------------------------------------------------------------------
# Generation service assembly
#
# This used to live in ``backend/routes/node_routes.py``, which forced
# ``workflow_round_worker_runtime`` -- a background worker with no HTTP
# involvement whatsoever -- to import from the route layer just to start up.
# That was the repository's only service -> route dependency, and it made the
# worker transitively drag in every route module's imports. Assembly is
# composition-root work, so it lives here.
# ---------------------------------------------------------------------------
from backend.services.cost_guard_service import CostGuardService
from backend.services.cost_service import CostService
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.material_catalog_resolver import MaterialCatalogResolver
from backend.services.model_provider_bootstrap import sync_generation_provider_from_config
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.prompt_governance_service import (
GenerationRouteService,
ImageModerationService,
PromptModerationService,
PromptSemanticNormalizer,
PromptTranslationService,
)
from backend.services.queue_service import QueueService
from backend.services.workflow_material_snapshot_service import WorkflowMaterialSnapshotService
from core.astrbot_provider_bridge import astrbot_structured_text_callable
from database.db_helper import load_config_payload
from database.repositories.advanced_material_repository import AdvancedMaterialRepository
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.material_repository import MaterialRepository
from database.repositories.model_provider_repository import ModelProviderRepository
from engines.single_flow import SingleFlowEngine
def create_generation_service() -> GenerationService:
"""Public runtime factory shared by HTTP routes and background workers."""
database = Database(load_database_settings())
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
material_repository = MaterialRepository(database)
material_catalog = MaterialCatalogResolver(
material_repository,
AdvancedMaterialRepository(database),
)
event_bus = get_default_event_bus()
model_provider_service = ModelProviderService(ModelProviderRepository(database))
model_provider_runtime = ModelProviderRuntime(model_provider_service)
config_payload = load_config_payload()
sync_generation_provider_from_config(model_provider_service, config_payload)
generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {}
model_assignments = config_payload.get("model_assignments") if isinstance(config_payload.get("model_assignments"), dict) else {}
governance_config = config_payload.get("prompt_governance") if isinstance(config_payload.get("prompt_governance"), dict) else {}
translation_config = governance_config.get("translation") if isinstance(governance_config.get("translation"), dict) else {}
moderation_config = governance_config.get("moderation") if isinstance(governance_config.get("moderation"), dict) else {}
routing_config = governance_config.get("routing") if isinstance(governance_config.get("routing"), dict) else {}
image_moderation_config = governance_config.get("image_moderation") if isinstance(governance_config.get("image_moderation"), dict) else {}
translation_route = str(translation_config.get("model_route") or model_assignments.get("prompt_planning") or "").strip()
moderation_route = str(moderation_config.get("model_route") or model_assignments.get("cross_review_primary") or "").strip()
translation_callable = (model_provider_runtime.structured_text_callable(translation_route) or astrbot_structured_text_callable(translation_route)) if translation_route else None
moderation_callable = (model_provider_runtime.structured_text_callable(moderation_route) or astrbot_structured_text_callable(moderation_route)) if moderation_route else None
single_flow_engine = SingleFlowEngine(
image_provider_factory=model_provider_runtime.image_provider_for_route,
allow_mock_fallback=False,
)
image_moderation_route = str(image_moderation_config.get("model_route") or "").strip()
image_moderation_callable = model_provider_runtime.structured_vision_callable(
image_moderation_route,
storage=single_flow_engine.storage,
) if image_moderation_route else None
if translation_callable:
raw_translation_callable = translation_callable
translation_callable = lambda request: raw_translation_callable({**request, "purpose": "Chinese-to-English image prompt translation and structured visual decomposition"})
if moderation_callable:
raw_moderation_callable = moderation_callable
moderation_callable = lambda request: raw_moderation_callable({**request, "purpose": "image prompt content risk classification"})
return GenerationService(
workflow_service=create_workflow_service(database),
queue_service=QueueService(
repository=JobRepository(database),
audit_service=audit_service,
event_bus=event_bus,
),
image_service=ImageService(
image_repository=ImageRepository(database),
workflow_repository=workflow_repository,
audit_service=audit_service,
),
single_flow_engine=single_flow_engine,
model_provider_service=model_provider_service,
cost_guard_service=CostGuardService(CostService(database)),
prompt_expansion_service=PromptExpansionService(),
event_bus=event_bus,
default_model_route=str(generation_config.get("default_model") or "").strip() or None,
require_resolved_model_route=True,
material_resolver=material_catalog,
material_snapshot_service=WorkflowMaterialSnapshotService(
workflow_repository,
material_catalog,
),
model_assignments=model_assignments,
prompt_translation_service=PromptTranslationService(translation_config, translation_callable),
prompt_semantic_normalizer=PromptSemanticNormalizer(),
prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable),
generation_route_service=GenerationRouteService(routing_config),
image_moderation_service=ImageModerationService(image_moderation_config, image_moderation_callable),
)

查看文件

@ -12,7 +12,13 @@ from core.config_service import ConfigService
from core.config_writer import config_file_lock, dump_yaml, write_text_atomic
from core.audit_service import AuditService
from core.identity import RequestContext
from core.runtime_paths import is_default_config_path, resolve_plugin_path
from core.runtime_paths import (
EXTERNAL_ROOTS_ENV_VAR,
external_storage_roots_allowed,
is_default_config_path,
is_within_runtime_data_root,
resolve_plugin_path,
)
from database.db_helper import (
Database,
DatabaseSettings,
@ -367,6 +373,7 @@ class SettingsService:
normalized_cost = -1
if normalized_cost < 0:
errors.append({"field": f"advanced_materials.cost_budget.{key}", "message": "value must be zero or greater"})
errors.extend(_storage_path_errors(config.get("storage")))
return {"valid": not errors, "errors": errors, "warnings": warnings}
def diff(self, candidate: Mapping[str, Any]) -> dict[str, Any]:
@ -533,7 +540,12 @@ class SettingsService:
row = self._load_snapshot_row(snapshot_id)
if row is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "config snapshot not found", {"snapshot_id": snapshot_id})
config = json.loads(row["config_json"] or "{}")
snapshot_config = json.loads(row["config_json"] or "{}")
# Snapshots are stored masked (see ``_record_snapshot``). Restore the
# secrets that are live right now over the ``***MASKED***`` markers, so
# a rollback reverts structure and non-secret values without either
# resurrecting a retired credential or blanking a working one.
config = _merge_masked(self._load_current_mapping(), snapshot_config)
validation = self.validate({"config": config})
if not validation["valid"]:
raise ApiError(ErrorCode.VALIDATION_FAILED, "snapshot config validation failed", validation)
@ -611,7 +623,16 @@ class SettingsService:
snapshot_id,
reason,
ctx.actor_id,
json.dumps(dict(config), ensure_ascii=False, sort_keys=True),
# Snapshots are long-lived rows in an ordinary table, so
# storing the raw config persisted every provider API key,
# the Postgres password and the integration token hashes in
# plaintext -- one leaked DB dump replayed every secret the
# plugin ever held. Mask before writing; ``rollback()``
# re-merges the live secrets over the masked placeholders,
# exactly as ``save()`` already does for masked input.
json.dumps(
_mask_sensitive(dict(config)), ensure_ascii=False, sort_keys=True
),
),
)
conn.commit()
@ -682,6 +703,41 @@ def _is_sensitive_key(path: str) -> bool:
return any(part in lowered for part in SENSITIVE_KEY_PARTS)
def _storage_path_errors(storage: Any) -> list[dict[str, Any]]:
"""Reject storage roots that would escape the runtime data directory.
``validate()`` historically covered generation/vision/database/
prompt_governance/advanced_materials but never ``storage``. Since
``resolve_data_path`` passes absolute paths through untouched, an
authenticated caller could repoint a root at ``/`` and turn the media
endpoints into a host-wide file browser. Blocking it at write time is the
cheapest place to break that chain; ``core.storage`` enforces the same
invariant at read time as defence in depth.
"""
if not isinstance(storage, Mapping) or external_storage_roots_allowed():
return []
errors: list[dict[str, Any]] = []
for key, value in storage.items():
name = str(key)
if not name.endswith("_path") or not isinstance(value, str):
continue
candidate = value.strip()
if not candidate:
continue
if not is_within_runtime_data_root(candidate):
errors.append(
{
"field": f"storage.{name}",
"message": (
"path must stay inside the plugin data directory; set "
f"{EXTERNAL_ROOTS_ENV_VAR}=1 to allow an external mount"
),
}
)
return errors
def _is_path_key(path: str) -> bool:
lowered = path.lower()
return lowered.endswith("_path") or lowered.endswith(".path")

查看文件

@ -13,6 +13,7 @@ from backend.dto.common import ApiError
from backend.dto.job_dto import GenerationTask
from backend.services.queue_service import QueueService
from core.identity import RequestContext
from core.text_utils import optional_text as _optional_text
logger = logging.getLogger(__name__)
@ -113,8 +114,13 @@ class QueueWorker:
processed=1,
error_message=latest.error_message,
)
completed = self.queue_service.update_task(
# Compare-and-set on "running" rather than an unconditional UPDATE.
# The read above is a TOCTOU window: a cancel landing between
# get_job() and the write was silently overwritten, resurrecting a
# task the user had cancelled (and still billing them for it).
completed = self.queue_service.update_task_if_status(
task.task_id,
{"running"},
{
"status": update.status,
"progress": _progress(update.progress),
@ -131,7 +137,20 @@ class QueueWorker:
},
},
ctx,
require_workflow_not_cancelled=True,
)
if completed is None:
# Someone else owns the task now (cancelled, or reclaimed by a
# stale-task sweep). Do not resurrect it.
latest = self.queue_service.get_job(task.task_id)
self._notify_terminal(task, latest, None)
return WorkerRunResult(
worker_id=self.worker_id,
status=latest.status,
task_id=latest.task_id,
processed=1,
error_message=latest.error_message,
)
self._notify_terminal(task, completed, None)
return WorkerRunResult(
worker_id=self.worker_id,
@ -205,7 +224,12 @@ class QueueWorker:
self._stop_event.wait(self.interval_seconds)
def _claim_next(self, ctx: RequestContext) -> GenerationTask | None:
queued = self.queue_service.list_jobs(status="queued", page=1, page_size=self.claim_batch_size).items
# FIFO claim. Using the display listing here made the queue LIFO, so a
# backlog deeper than claim_batch_size starved its oldest entries
# indefinitely while newer tasks kept jumping ahead.
queued = self.queue_service.list_claimable_jobs(
status="queued", limit=self.claim_batch_size
)
for candidate in queued:
if _retry_deferred(candidate):
continue
@ -504,11 +528,6 @@ def _int(value: Any, default: int) -> int:
return default
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _safe_error_message(exc: Exception) -> str:

查看文件

@ -20,6 +20,7 @@ from database.repositories.workflow_round_repository import (
WorkflowRoundRepository,
WorkflowRoundWriteError,
)
from core.text_utils import optional_text as _optional_text
class WorkflowGenerationCrossReviewService:
@ -731,11 +732,6 @@ def _bounded_text(value: Any, field: str, maximum: int) -> str | None:
return text
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _string_list(value: Any) -> list[str]:

查看文件

@ -13,6 +13,7 @@ from backend.dto.common import ApiError, ErrorCode
from backend.services.material_catalog_resolver import MaterialCatalogResolver, is_trusted_advanced_metadata
from database.repositories.material_repository import MaterialRepository
from database.repositories.workflow_repository import WorkflowRepository
from core.text_utils import optional_text as _optional_text
WORKFLOW_MATERIAL_SNAPSHOT_VERSION = "2026-07-15.workflow-material-snapshot.v1"
@ -374,10 +375,3 @@ def _string_list(value: Any) -> list[str]:
if text and text not in result:
result.append(text)
return result
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None

查看文件

@ -31,6 +31,7 @@ from core.identity import RequestContext
from database.repositories.material_repository import MaterialRepository
from database.repositories.workflow_round_repository import WorkflowRoundRepository
from engines.character_flow import canonical_gradual_node_key
from core.text_utils import optional_text as _optional_text
WORKFLOW_IMAGE_NODE_KEYS = frozenset(
@ -494,10 +495,3 @@ def _unique_texts(value: Any) -> list[str]:
def _string_list(value: Any) -> list[str]:
return _unique_texts(value) if value is not None else []
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None

查看文件

@ -36,6 +36,7 @@ from database.repositories.workflow_round_repository import (
WorkflowRoundWriteError,
)
from engines.character_flow import gradual_stage_code
from core.text_utils import optional_text as _optional_text
WORKFLOW_ROUND_SCHEMA_VERSION = "2026-07-15.workflow-round.v1"
@ -618,6 +619,25 @@ class WorkflowRoundService:
},
}
created = self.create_round(parent.node_id, next_payload, ctx)
superseded_parent = self.round_repository.update_round(
parent_round_id,
{
"status": "superseded",
"metadata": {
**parent.metadata,
"superseded_by_round_id": created.get("round_id"),
"superseded_by_display_code": created.get("display_code"),
"superseded_reason": "next_round_created",
"superseded_at": created.get("updated_at"),
},
},
)
if superseded_parent is None:
raise ApiError(
ErrorCode.RESOURCE_NOT_FOUND,
"parent workflow round disappeared while creating next round",
{"parent_round_id": parent_round_id},
)
return {
**created,
"parent_round_id": parent_round_id,
@ -1568,10 +1588,3 @@ def _round_write_api_error(exc: WorkflowRoundWriteError) -> ApiError:
else ErrorCode.VALIDATION_FAILED
)
return ApiError(error_code, exc.message, exc.details)
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None

查看文件

@ -2,12 +2,13 @@
from __future__ import annotations
import logging
import threading
from collections.abc import Callable
from typing import Any
from backend.dto.job_dto import GenerationTask
from backend.routes.node_routes import create_generation_service
from backend.services.service_registry import create_generation_service
from backend.services.generation_service import GenerationService
from backend.services.media_service import MediaService
from backend.services.worker_service import QueueWorkerPool, RetryPolicy, WorkerTaskUpdate
@ -15,6 +16,8 @@ from backend.services.workflow_round_service import WorkflowRoundService
from core.identity import RequestContext
from database.repositories.workflow_round_repository import WorkflowRoundRepository
logger = logging.getLogger("imagestudio.round_worker")
class WorkflowRoundWorkerRuntime:
def __init__(
@ -42,7 +45,21 @@ class WorkflowRoundWorkerRuntime:
worker_count=worker_count,
worker_id_prefix="imagestudio-round",
interval_seconds=interval_seconds,
retry_policy=RetryPolicy(max_attempts=1),
# max_attempts=1 meant "never retry": worker_attempt is already 1
# on the first execution, so should_retry(1, exc) short-circuited
# immediately. A single 429 or connection reset therefore put a
# round candidate into a terminal failed state with no recovery
# path (the web retry route rejects this task_type as well), and
# the user's only option was rebuilding the whole round.
#
# Restricted to ImageProviderError so genuine bugs still fail fast
# instead of being retried three times.
retry_policy=RetryPolicy(
max_attempts=3,
base_delay_seconds=2.0,
backoff_multiplier=2.0,
retryable_error_types=("ImageProviderError",),
),
task_filter=_is_workflow_round_task,
terminal_callback=self._on_terminal,
per_route_limit=worker_count,
@ -136,10 +153,23 @@ class WorkflowRoundWorkerRuntime:
self._scheduled_notifications.discard(round_id)
def _schedule_terminal_notification(self, round_id: str) -> None:
# All three exits below leave the user without the round-completion
# push they are waiting for. The delivery state is recorded in round
# metadata, but nothing was ever logged, so operators had no way to
# notice that notifications had stopped working.
payload = self._claim_notification_payload(round_id)
if payload is None:
logger.debug(
"round %s terminal notification skipped: already scheduled or round missing",
round_id,
)
return
if self.terminal_notification_callback is None:
logger.warning(
"round %s finished but no AstrBot notification callback is registered; "
"the user will not be told",
round_id,
)
self.mark_terminal_notification(
round_id,
delivered=False,
@ -149,6 +179,7 @@ class WorkflowRoundWorkerRuntime:
try:
self.terminal_notification_callback(payload)
except Exception as exc:
logger.exception("round %s terminal notification failed to deliver", round_id)
self.mark_terminal_notification(round_id, delivered=False, error_message=str(exc))
def _claim_notification_payload(self, round_id: str) -> dict[str, Any] | None:

查看文件

@ -1,7 +1,7 @@
plugin:
name: astrbot_plugin_imagestudio
display_name: ImageStudio
version: 1.0.66
version: 1.0.72
features:
quick_profile: true

93
core/branch_state.py 普通文件
查看文件

@ -0,0 +1,93 @@
"""Branch-scoped workflow metadata shaping.
These helpers are pure dictionary transforms over a workflow's ``metadata``
column -- no repository, no service, no I/O. They live in ``core`` because both
the service layer and the repositories legitimately need them: the round and
cross-review repositories must read and merge branch state while writing rows,
and importing ``backend.services.branch_lineage_service`` to do that inverted
the dependency direction (data layer -> service layer) and dragged
``WorkflowRepository`` into its own callers' import graph.
"""
from __future__ import annotations
from copy import deepcopy
from typing import Any
BRANCH_STATE_FIELDS = frozenset(
{
"character_execution",
"material_binding_schema_version",
"material_binding_source_node_id",
"material_binding_updated_at",
"material_bindings",
"prompt_plan_schema_version",
"prompt_plan_source_node_id",
"prompt_plan_updated_at",
"prompt_plan",
"prompt_matrix",
"stage_input_schema_version",
"stage_inputs",
"restoration_input_schema_version",
"restoration_inputs",
"stage_review_handoffs",
"last_stage_review_confirmed_at",
"last_stage_review_node_id",
"last_stage_review_image_id",
"current_stage_input_image_id",
"final_archive_schema_version",
"final_archive_history_id",
"final_archive_image_ids",
"final_archive_node_id",
"final_archive_source_node_id",
"final_archive_completed_at",
}
)
def branch_state_for(metadata: dict[str, Any] | None, branch_name: str) -> dict[str, Any]:
"""Read branch state with a root-metadata fallback for pre-1.0.16 data."""
source = metadata if isinstance(metadata, dict) else {}
branch_states = source.get("branch_state")
if isinstance(branch_states, dict) and isinstance(branch_states.get(branch_name), dict):
return deepcopy(branch_states[branch_name])
return {
key: deepcopy(source[key])
for key in BRANCH_STATE_FIELDS
if key in source
}
def workflow_metadata_for_branch(metadata: dict[str, Any] | None, branch_name: str) -> dict[str, Any]:
"""Return the legacy root projection overlaid with one branch's state."""
result = deepcopy(metadata) if isinstance(metadata, dict) else {}
state = branch_state_for(result, branch_name)
for key in BRANCH_STATE_FIELDS:
result.pop(key, None)
result.update(state)
return result
def with_branch_state(
metadata: dict[str, Any] | None,
branch_name: str,
patch: dict[str, Any],
*,
activate: bool,
) -> dict[str, Any]:
"""Merge one branch state while preserving every sibling branch."""
result = deepcopy(metadata) if isinstance(metadata, dict) else {}
states = deepcopy(result.get("branch_state")) if isinstance(result.get("branch_state"), dict) else {}
state = branch_state_for(result, branch_name)
state.update({key: deepcopy(value) for key, value in patch.items() if key in BRANCH_STATE_FIELDS})
states[branch_name] = state
result["branch_state"] = states
if activate:
for key in BRANCH_STATE_FIELDS:
result.pop(key, None)
result.update(deepcopy(state))
return result

查看文件

@ -10,7 +10,7 @@ from core.runtime_paths import resolve_config_path
from database.db_helper import load_config_payload
PLUGIN_VERSION = "1.0.66"
PLUGIN_VERSION = "1.0.72"
@dataclass(frozen=True)

查看文件

@ -17,9 +17,13 @@ _PATH_LOCKS: dict[str, threading.RLock] = {}
def config_file_lock(path: str | Path) -> threading.RLock:
"""Serialize read-modify-write operations for one config path."""
# Return the native lock context manager directly. A generator-based
# contextmanager mutates an escaping exception's ``__traceback__``;
# ImageStudio's frozen ApiError intentionally rejects that mutation.
# Return the native lock context manager directly -- it is cheaper than a
# generator-based wrapper and needs no cleanup logic.
#
# (This used to also be a workaround: ``ApiError`` was a frozen dataclass,
# so ``contextlib`` failed to attach ``__traceback__`` to it and replaced
# any escaping ``ApiError`` with ``FrozenInstanceError``. ``ApiError`` is
# no longer frozen, so ``@contextmanager`` is safe here and elsewhere.)
return _lock_for_path(Path(path))

查看文件

@ -1,112 +0,0 @@
"""In-memory generation queue primitives."""
from __future__ import annotations
from collections import deque
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Any
from uuid import uuid4
from core.fsm import task_transition
def _now() -> str:
return datetime.now(timezone.utc).isoformat()
@dataclass
class QueueItem:
task_id: str
payload: dict[str, Any]
status: str = "queued"
idempotency_key: str | None = None
attempts: int = 0
error_message: str | None = None
created_at: str = field(default_factory=_now)
updated_at: str = field(default_factory=_now)
def to_dict(self) -> dict[str, Any]:
return {
"task_id": self.task_id,
"payload": self.payload,
"status": self.status,
"idempotency_key": self.idempotency_key,
"attempts": self.attempts,
"error_message": self.error_message,
"created_at": self.created_at,
"updated_at": self.updated_at,
}
class QueueManager:
def __init__(self):
self._pending: deque[str] = deque()
self._items: dict[str, QueueItem] = {}
self._idempotency_index: dict[str, str] = {}
def enqueue(self, payload: dict[str, Any], *, idempotency_key: str | None = None) -> QueueItem:
if idempotency_key and idempotency_key in self._idempotency_index:
return self._items[self._idempotency_index[idempotency_key]]
item = QueueItem(
task_id=str(payload.get("task_id") or f"task_{uuid4().hex}"),
payload=dict(payload),
idempotency_key=idempotency_key,
)
self._items[item.task_id] = item
if idempotency_key:
self._idempotency_index[idempotency_key] = item.task_id
self._pending.append(item.task_id)
return item
def dequeue(self) -> QueueItem | None:
while self._pending:
task_id = self._pending.popleft()
item = self._items.get(task_id)
if item and item.status == "queued":
self._set_status(item, "running")
item.attempts += 1
return item
return None
def complete(self, task_id: str, result: dict[str, Any] | None = None) -> QueueItem:
item = self.get(task_id)
item.payload = {**item.payload, "result": result or {}}
self._set_status(item, "succeeded")
item.error_message = None
return item
def fail(self, task_id: str, error_message: str, *, dead_letter: bool = False) -> QueueItem:
item = self.get(task_id)
self._set_status(item, "failed")
item.error_message = error_message
if dead_letter:
self._set_status(item, "dead_letter")
return item
def retry(self, task_id: str) -> QueueItem:
item = self.get(task_id)
self._set_status(item, "queued")
item.error_message = None
if task_id not in self._pending:
self._pending.append(task_id)
return item
def get(self, task_id: str) -> QueueItem:
item = self._items.get(task_id)
if item is None:
raise KeyError(task_id)
return item
def summary(self) -> dict[str, int]:
counts = {"queued": 0, "running": 0, "succeeded": 0, "failed": 0, "dead_letter": 0}
for item in self._items.values():
counts[item.status] = counts.get(item.status, 0) + 1
return counts
def _set_status(self, item: QueueItem, status: str) -> None:
transition = task_transition(item.status, status)
if not transition.allowed:
raise ValueError(transition.reason)
item.status = transition.target
item.updated_at = _now()

查看文件

@ -2,6 +2,7 @@
from __future__ import annotations
import os
from pathlib import Path
from typing import Callable
@ -9,6 +10,35 @@ from typing import Callable
PLUGIN_NAME = "astrbot_plugin_imagestudio"
REPO_ROOT = Path(__file__).resolve().parents[1]
# Opt-in escape hatch for deployments that genuinely mount storage outside the
# runtime data root (e.g. a NAS volume). Deliberately an environment variable
# rather than a config key: ``settings/save`` is reachable by any authenticated
# user, so a config-based flag could be flipped by the same actor it defends
# against.
EXTERNAL_ROOTS_ENV_VAR = "IMAGESTUDIO_ALLOW_EXTERNAL_STORAGE_ROOTS"
def external_storage_roots_allowed() -> bool:
"""Whether configured storage roots may resolve outside the data root."""
return str(os.environ.get(EXTERNAL_ROOTS_ENV_VAR, "")).strip().lower() in {
"1",
"true",
"yes",
"on",
}
def is_within_runtime_data_root(path: str | Path) -> bool:
"""Whether ``path`` resolves inside this runtime's writable data root."""
root = get_runtime_data_root().resolve()
try:
candidate = resolve_data_path(path).resolve()
except OSError:
return False
return candidate == root or root in candidate.parents
def get_astrbot_runtime_data_root() -> Path | None:
"""Return this plugin's AstrBot-managed data directory when available."""

查看文件

@ -35,3 +35,47 @@ def require_task_retry(ctx: RequestContext) -> None:
def require_config_manager(ctx: RequestContext) -> None:
require_permission(ctx, "can_manage_config")
def can_access_owned_resource(owner_user_id: str | None, ctx: RequestContext) -> bool:
"""Whether ``ctx`` may act on a resource owned by ``owner_user_id``.
Single source of truth for ownership. ``ProfileService._require_owner`` and
``ResourceAccessService._can_access`` used to disagree -- the former
ignored ``can_manage_all_profiles`` entirely -- so the same actor could
reach a profile through the chat chain and be refused through the web
route. Any elevation rule belongs here and nowhere else.
"""
if ctx.has_permission("can_manage_all_profiles") or ctx.has_permission("*"):
return True
return bool(ctx.actor_id and owner_user_id and ctx.actor_id == owner_user_id)
def enforce_route_permission(ctx: RequestContext, permission: str) -> None:
"""Apply a route's declared ``PERMISSION_MATRIX`` entry.
``PERMISSION_MATRIX`` used to be documentation only: the dispatcher never
read ``RouteMatch.permission``, so a route's real protection was whichever
``require_*`` call its handler happened to contain. Declaration and
enforcement could drift silently, and a handler that simply forgot the call
was wide open.
Enforcing here makes the manifest the contract. Handlers keep their own
``require_*`` calls -- they run inside ``handle_request`` and produce the
same errors -- so this is an additional gate, never a replacement.
"""
# Imported lazily: backend.route_registry imports nothing from core, and
# keeping it that way avoids a core -> backend import cycle at module load.
from backend.route_registry import permission_requirement
requirement = permission_requirement(permission)
if requirement.get("auth_required", True):
require_authenticated(ctx)
required = requirement.get("required_permissions") or (
[requirement["required_permission"]] if requirement.get("required_permission") else []
)
for name in required:
if name:
require_permission(ctx, name)

查看文件

@ -10,7 +10,11 @@ from typing import Any
from backend.dto.common import ApiError, ErrorCode
from core.config_service import ConfigService, ImageStudioConfig
from core.runtime_paths import resolve_data_path
from core.runtime_paths import (
EXTERNAL_ROOTS_ENV_VAR,
external_storage_roots_allowed,
resolve_data_path,
)
@dataclass(frozen=True)
@ -42,7 +46,14 @@ class VfsStorage:
"total_bytes": sum(entry.bytes for entry in roots),
}
def migration_plan(self, source_uri: str, target_uri: str, *, dry_run: bool = True) -> dict[str, Any]:
def migration_plan(
self,
source_uri: str,
target_uri: str,
*,
dry_run: bool = True,
allow_overwrite: bool = False,
) -> dict[str, Any]:
source_path = self.resolve_uri(source_uri)
target_path = self.resolve_uri(target_uri)
if not source_path.exists():
@ -50,6 +61,16 @@ class VfsStorage:
files, total_bytes = _path_file_stats(source_path)
will_overwrite = target_path.exists()
if not dry_run:
# ``will_overwrite`` used to be reported and then ignored, so a
# non-dry-run migrate silently clobbered whatever sat at the target
# (``shutil.copy2`` overwrites without asking). Require the caller
# to acknowledge the overwrite explicitly.
if will_overwrite and not allow_overwrite:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"target already exists; retry with allow_overwrite=true to replace it",
{"target_uri": target_uri, "will_overwrite": True},
)
_copy_path(source_path, target_path)
return {
"dry_run": dry_run,
@ -140,7 +161,76 @@ class VfsStorage:
def _root_paths(self) -> dict[str, str]:
config = self.config_service.load()
return _storage_roots(config)
roots = _storage_roots(config)
assert_storage_roots_contained(roots)
return roots
def assert_storage_roots_contained(roots: dict[str, str]) -> None:
"""Refuse storage roots that are too broad to be a sandbox boundary.
``VfsStorage.resolve_uri`` guarantees a URI cannot escape *its own root* —
which is worth nothing when the root itself is ``/`` or ``C:\\``. Pointing
a root at a filesystem anchor or a system directory turns ``media/index``
and ``media/sign`` into a host-wide file browser.
Deliberately narrower than "must live under the data root": mounting
storage on a dedicated external volume is a legitimate deployment (and how
the test-suite isolates fixtures). The write path
(``SettingsService.validate``) is where containment is enforced, because
that is the attacker-reachable surface; this is defence in depth against a
config that arrived some other way.
"""
if external_storage_roots_allowed():
return
unsafe = sorted(name for name, path in roots.items() if _is_overbroad_root(path))
if unsafe:
raise ApiError(
ErrorCode.FORBIDDEN,
"storage root escapes the runtime data root",
{
"roots": unsafe,
"hint": (
"point the root at a dedicated directory, or set "
f"{EXTERNAL_ROOTS_ENV_VAR}=1 to allow an external mount"
),
},
)
# Directories that can never be a dedicated media root. Matching is done on the
# resolved path so ``data/../..`` style traversal collapses first.
_SYSTEM_ROOTS = (
"/etc",
"/root",
"/boot",
"/proc",
"/sys",
"/dev",
"/var",
"/usr",
"/bin",
"/sbin",
"c:/windows",
"c:/program files",
"c:/program files (x86)",
)
def _is_overbroad_root(path: str) -> bool:
try:
resolved = resolve_data_path(path).resolve()
except OSError:
return False
# A filesystem anchor ("/", "C:\\") is its own parent.
if resolved.parent == resolved:
return True
normalized = resolved.as_posix().rstrip("/").lower()
return any(
normalized == system or normalized.startswith(f"{system}/")
for system in _SYSTEM_ROOTS
)
def _storage_roots(config: ImageStudioConfig) -> dict[str, str]:

41
core/text_utils.py 普通文件
查看文件

@ -0,0 +1,41 @@
"""Shared text-normalisation helpers.
``_optional_text`` was independently redefined 30 times across the codebase --
but *not* identically. Two implementations were in circulation:
# 19 call sites
if value is None:
return None
return str(value).strip() or None
# 9 call sites
return str(value or "").strip() or None
They disagree on every falsy non-``None`` input: ``_optional_text(0)`` is
``"0"`` under the first and ``None`` under the second; likewise ``False``,
``0.0`` and ``[]``. Same name, same signature, different meaning depending on
which file you happened to be reading -- the kind of duplication that is worse
than the boilerplate it saves.
``optional_text`` below is the canonical form (the 19-site behaviour: only
``None`` and blank strings collapse to ``None``). The 9 divergent sites are
deliberately *not* migrated here, because doing so would silently change what
they accept; they need per-call-site review first.
"""
from __future__ import annotations
from typing import Any
def optional_text(value: Any) -> str | None:
"""Return ``value`` as trimmed text, or ``None`` when absent or blank.
Only ``None`` and whitespace-only strings become ``None``. Falsy non-``None``
values such as ``0`` and ``False`` stringify normally.
"""
if value is None:
return None
text = str(value).strip()
return text or None

27
core/workflow_node_keys.py 普通文件
查看文件

@ -0,0 +1,27 @@
"""Canonical workflow node-key naming and its legacy aliases.
A pure rename table plus the lookup over it. It lives in ``core`` because the
data layer needs it too: ``profile_card_repository`` has to recognise a
``profile_card`` node when reading rows written under the pre-rename key, and
importing ``engines.character_flow`` to do that made a repository depend on an
engine -- pulling the whole character-flow step catalogue into the data layer's
import graph for a four-entry dictionary lookup.
"""
from __future__ import annotations
# Node keys renamed after the workflow catalogue was reorganised. Rows written
# before the rename still carry the left-hand values, so reads must normalise.
LEGACY_CHARACTER_GRADUAL_NODE_KEYS: dict[str, str] = {
"half_body": "upper_body",
"expression_sheet": "turnaround",
"pose_sheet": "design_sheet",
"final_pack": "profile_card",
}
def canonical_gradual_node_key(node_key: str | None) -> str:
"""Map a possibly-legacy gradual node key to its current name."""
normalized = str(node_key or "").strip()
return LEGACY_CHARACTER_GRADUAL_NODE_KEYS.get(normalized, normalized)

查看文件

@ -15,6 +15,7 @@ from backend.dto.advanced_material_dto import (
AdvancedStyleValidationCase,
)
from database.db_helper import Database
from core.text_utils import optional_text as _optional_text
IMPORT_COLUMNS = """
@ -2089,11 +2090,6 @@ def _json_list(value: str | None) -> list[str]:
return [str(item) for item in parsed] if isinstance(parsed, list) else []
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _optional_int(value: Any) -> int | None:

查看文件

@ -156,6 +156,37 @@ class JobRepository:
conn.close()
return [_row_to_task(row) for row in rows], int(total_row["total"] if total_row else 0)
def list_claimable(self, *, status: str = "queued", limit: int = 25) -> list[GenerationTask]:
"""Oldest-first queued tasks, for worker claim.
Workers used to claim through ``list_jobs``, which is the *display*
listing and orders ``created_at DESC`` so the UI can show newest-first.
Consuming a queue in that order makes it a LIFO: once the backlog
exceeds the claim batch size, the oldest tasks sit outside the window
forever while newly enqueued ones keep jumping the line.
``task_id`` breaks ties because ``created_at`` is only second-resolution
here, and a round can enqueue 4-8 candidates within the same second.
"""
placeholder = self.placeholder
normalized_limit = min(max(int(limit or 25), 1), 500)
conn = self.database.connect()
try:
rows = conn.execute(
f"""
SELECT {TASK_COLUMNS}
FROM generation_tasks
WHERE status = {placeholder}
ORDER BY created_at ASC, task_id ASC
LIMIT {placeholder}
""",
(status, normalized_limit),
).fetchall()
finally:
conn.close()
return [_row_to_task(row) for row in rows]
def list_stale(
self,
*,

查看文件

@ -8,7 +8,7 @@ from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.dto.profile_card_dto import CharacterProfileCard, CharacterProfileCardAsset
from database.db_helper import Database
from engines.character_flow import canonical_gradual_node_key
from core.workflow_node_keys import canonical_gradual_node_key
CARD_COLUMNS = """

查看文件

@ -29,6 +29,20 @@ PROFILE_COLUMNS = """
updated_at
"""
def _sql_literal(fragment: str, placeholder: str) -> str:
"""Make a SQL fragment containing ``%`` safe for the active driver.
The three ``LIKE '%"final_archive_history_id"%'`` predicates below are
inlined into parameterised queries. psycopg treats the whole query as a
``%``-format template, so under ``backend: postgresql`` every one of these
raised before a row came back -- ``get()`` and ``list()``, the two hottest
profile reads, failed 100% of the time. SQLite's ``?`` placeholders do no
such interpolation and must be left alone.
"""
return fragment.replace("%", "%%") if placeholder == "%s" else fragment
PROFILE_GENERATION_KIND_COLUMN = """
CASE
WHEN EXISTS (
@ -185,8 +199,8 @@ class ProfileRepository:
try:
row = conn.execute(
f"""
SELECT {PROFILE_COLUMNS}, {PROFILE_GENERATION_KIND_COLUMN},
{PROFILE_CATEGORY_COLUMN}, {DETAILED_WORKFLOW_STATE_COLUMN}
SELECT {PROFILE_COLUMNS}, {_sql_literal(PROFILE_GENERATION_KIND_COLUMN, placeholder)},
{_sql_literal(PROFILE_CATEGORY_COLUMN, placeholder)}, {_sql_literal(DETAILED_WORKFLOW_STATE_COLUMN, placeholder)}
FROM character_profiles
WHERE profile_id = {placeholder}
""",
@ -205,6 +219,7 @@ class ProfileRepository:
page: int = 1,
page_size: int = 30,
) -> ProfileListResult:
placeholder = self.placeholder
where, params = self._build_filters(
owner_user_id=owner_user_id,
keyword=keyword,
@ -221,8 +236,8 @@ class ProfileRepository:
).fetchone()
rows = conn.execute(
f"""
SELECT {PROFILE_COLUMNS}, {PROFILE_GENERATION_KIND_COLUMN},
{PROFILE_CATEGORY_COLUMN}, {DETAILED_WORKFLOW_STATE_COLUMN}
SELECT {PROFILE_COLUMNS}, {_sql_literal(PROFILE_GENERATION_KIND_COLUMN, placeholder)},
{_sql_literal(PROFILE_CATEGORY_COLUMN, placeholder)}, {_sql_literal(DETAILED_WORKFLOW_STATE_COLUMN, placeholder)}
FROM character_profiles
{where}
ORDER BY updated_at DESC, created_at DESC

查看文件

@ -14,9 +14,10 @@ from datetime import datetime, timezone
from typing import Any
from uuid import uuid4
from backend.services.branch_lineage_service import branch_state_for, with_branch_state
from core.branch_state import branch_state_for, with_branch_state
from database.db_helper import Database
from database.repositories.workflow_round_repository import WorkflowRoundWriteError
from core.text_utils import optional_text as _optional_text
REVIEW_STATE_VERSION = "2026-07-15.generation-cross-review-state.v1"
@ -1445,11 +1446,6 @@ def _json_or_none(value: Any) -> str | None:
return json.dumps(value, ensure_ascii=False, sort_keys=True)
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _display_prefix(value: Any) -> str:

查看文件

@ -14,7 +14,8 @@ from backend.dto.workflow_round_dto import (
WorkflowRoundCandidatePoolEntry,
)
from database.db_helper import Database
from backend.services.branch_lineage_service import branch_state_for, with_branch_state
from core.branch_state import branch_state_for, with_branch_state
from core.text_utils import optional_text as _optional_text
class WorkflowRoundWriteError(ValueError):
@ -1340,11 +1341,6 @@ def _feedback_revision(value: str | None) -> str:
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _display_prefix(value: Any) -> str:

查看文件

@ -9,15 +9,16 @@ from __future__ import annotations
from typing import Any
# Re-exported: the pure rename table lives in core so the data layer can use
# it without importing an engine.
from core.workflow_node_keys import ( # noqa: F401
LEGACY_CHARACTER_GRADUAL_NODE_KEYS,
canonical_gradual_node_key,
)
CHARACTER_GRADUAL_TEMPLATE_VERSION = "character_gradual_v2"
LEGACY_CHARACTER_GRADUAL_NODE_KEYS: dict[str, str] = {
"half_body": "upper_body",
"expression_sheet": "turnaround",
"pose_sheet": "design_sheet",
"final_pack": "profile_card",
}
CHARACTER_GRADUAL_STEPS: tuple[dict[str, Any], ...] = (
{
@ -115,9 +116,6 @@ CHARACTER_GRADUAL_STEPS: tuple[dict[str, Any], ...] = (
)
def canonical_gradual_node_key(node_key: str | None) -> str:
normalized = str(node_key or "").strip()
return LEGACY_CHARACTER_GRADUAL_NODE_KEYS.get(normalized, normalized)
def gradual_stage_code(node_key: str | None) -> str:

查看文件

@ -7,6 +7,7 @@ from typing import Any
from backend.dto.image_dto import GenerationImage
from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode
from core.text_utils import optional_text as _optional_text
STAGE_REVIEW_RESULT_VERSION = "2026-07-09.stage-review-result.v1"
@ -435,11 +436,6 @@ def _string_list(value: Any) -> list[str]:
return [str(item).strip() for item in value if str(item or "").strip()]
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _optional_int(value: Any) -> int | None:

查看文件

@ -21,6 +21,7 @@ from engines.image_provider import (
ImageProvider,
ImageProviderError,
)
from core.text_utils import optional_text as _optional_text
ONE_PIXEL_PNG = base64.b64decode(
@ -58,7 +59,7 @@ class SingleFlowEngine:
prompt = _optional_text(request.get("expanded_prompt")) or _compose_prompt(node.prompt, request.get("prompt_patch"))
negative_prompt = _optional_text(request.get("expanded_negative_prompt")) or _optional_text(node.negative_prompt)
model_route = str(request.get("model_route") or node.model_route or "image_low")
width, height = _dimensions(str(request.get("aspect_ratio") or "1:1"))
width, height = _requested_dimensions(request)
provider = self._image_provider(request)
if provider is not None:
try:
@ -238,11 +239,40 @@ def _compose_prompt(base_prompt: str | None, prompt_patch: Any) -> str:
return ", ".join(parts) if parts else "single image mock generation"
def _optional_text(value: Any) -> str | None:
MIN_REQUESTED_DIMENSION = 64
MAX_REQUESTED_DIMENSION = 8192
def _requested_dimensions(request: dict[str, Any]) -> tuple[int, int]:
"""Resolve output dimensions, honouring an explicit ``size`` over ``aspect_ratio``.
Chat commands (``/yp 单图 --尺寸``、``/yp 高清``) and the guard that gates 2K/4K
access all speak in ``WxH`` strings, while the web workflow only ever sends
``aspect_ratio``. Both entry points converge on this engine, so ``size`` must win
when present -- otherwise the user-visible "尺寸:3840x2160" echo would be a lie
and every chat request would quietly render at the 1:1 default.
"""
explicit = _explicit_dimensions(request.get("size"))
if explicit is not None:
return explicit
return _dimensions(str(request.get("aspect_ratio") or "1:1"))
def _explicit_dimensions(value: Any) -> tuple[int, int] | None:
if value is None:
return None
text = str(value).strip()
return text or None
match = re.fullmatch(r"\s*(\d{1,5})\s*[xX×*]\s*(\d{1,5})\s*", str(value))
if match is None:
return None
width, height = int(match.group(1)), int(match.group(2))
# A malformed or hostile size must degrade to the aspect-ratio default rather
# than be clamped, so the provider never receives a silently rewritten request.
if not all(MIN_REQUESTED_DIMENSION <= side <= MAX_REQUESTED_DIMENSION for side in (width, height)):
return None
return width, height
def _dimensions(aspect_ratio: str) -> tuple[int, int]:

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

二进制文件未显示。

查看文件

@ -0,0 +1,64 @@
from __future__ import annotations
from backend.services.generation_service import _permission_context
from core.identity import RequestContext
def _ctx(user: str) -> RequestContext:
return RequestContext.from_astrbot(
username=user, user_id=user, client_ip="127.0.0.1", source="test", permissions=frozenset()
)
CONFIG = {"chat_access": {"adult_user_allowlist": ["user-allowed"]}}
def test_client_cannot_grant_itself_adult_permission() -> None:
"""The bypass: POST content_permissions.adult_user_allowed=true and walk through."""
result = _permission_context(
{"content_permissions": {"adult_user_allowed": True}},
_ctx("user-not-allowed"),
CONFIG,
)
assert result["adult_user_allowed"] is False
def test_allowlisted_user_keeps_adult_permission() -> None:
"""The legitimate chat path must not regress."""
result = _permission_context(
{"content_permissions": {"adult_user_allowed": True}},
_ctx("user-allowed"),
CONFIG,
)
assert result["adult_user_allowed"] is True
def test_allowlisted_user_who_does_not_ask_stays_off() -> None:
"""Being on the allowlist is necessary, not sufficient — the claim still gates."""
result = _permission_context({}, _ctx("user-allowed"), CONFIG)
assert result["adult_user_allowed"] is False
def test_missing_context_or_config_fails_closed() -> None:
payload = {"content_permissions": {"adult_user_allowed": True}}
assert _permission_context(payload, None, CONFIG)["adult_user_allowed"] is False
assert _permission_context(payload, _ctx("user-allowed"), None)["adult_user_allowed"] is False
assert _permission_context(payload, _ctx("user-allowed"), {})["adult_user_allowed"] is False
def test_top_level_adult_flag_is_also_verified() -> None:
"""The alternate ``payload['adult_user_allowed']`` spelling is gated too."""
result = _permission_context({"adult_user_allowed": True}, _ctx("user-not-allowed"), CONFIG)
assert result["adult_user_allowed"] is False
def test_quota_allowed_default_is_unchanged() -> None:
assert _permission_context({}, _ctx("u"), CONFIG)["quota_allowed"] is True
assert (
_permission_context({"quota_allowed": False}, _ctx("u"), CONFIG)["quota_allowed"] is False
)

查看文件

@ -0,0 +1,57 @@
from __future__ import annotations
import pytest
from backend.services.asset_import_service import (
IMPORTABLE_RECOGNITION_STATUSES,
_importable_recognition_status,
)
@pytest.mark.parametrize("status", sorted(IMPORTABLE_RECOGNITION_STATUSES))
def test_review_pending_states_are_honoured(status: str) -> None:
assert _importable_recognition_status(status) == status
@pytest.mark.parametrize("status", ["confirmed", "archived"])
def test_pack_cannot_declare_a_review_outcome(status: str) -> None:
"""A pack manifest is an untrusted document.
Declaring ``confirmed`` would land unvetted material straight in the
confirmed library, skipping recognition and human review entirely.
"""
assert _importable_recognition_status(status) == "pending_recognition"
@pytest.mark.parametrize("status", [None, "", " ", "nonsense", 42, {"a": 1}])
def test_unknown_or_missing_status_falls_back_to_pending(status: object) -> None:
assert _importable_recognition_status(status) == "pending_recognition"
def test_overwrite_requires_explicit_opt_in() -> None:
"""The guard must collect every collision, not fail on the first one."""
from backend.dto.common import ApiError, ErrorCode
from backend.services import asset_import_service as module
import inspect
body = inspect.getsource(module.AssetImportService._apply_manifest)
# The conflict set is computed before any write happens.
conflict_index = body.index("conflicts = [")
write_index = body.index("for material_payload, creating in planned_materials:", conflict_index)
assert conflict_index < write_index, "conflicts must be detected before writing"
assert "allow_overwrite" in body
assert "conflicting_material_ids" in body
def test_route_threads_allow_overwrite() -> None:
import inspect
from backend.routes import asset_routes
body = inspect.getsource(asset_routes.import_asset_pack)
assert "allow_overwrite" in body, "the route must expose the opt-in"
assert "default=False" in body, "overwrite must be opt-in, not opt-out"

查看文件

@ -0,0 +1,63 @@
from __future__ import annotations
import tempfile
from pathlib import Path
import pytest
from backend.services import chat_media_import_service as module
from backend.services.chat_media_import_service import ChatMediaImportService
PNG_BYTES = bytes.fromhex("89504e470d0a1a0a") + b"\x00" * 32
def test_local_path_outside_allowed_roots_is_refused() -> None:
"""A chat peer must not be able to name an arbitrary host file.
``image_references_from_event`` forwards the inbound component's ``file``
attribute verbatim, so this string is remote-influenced. The plugin's own
``config.yaml`` is the realistic target: it sits outside both the runtime
data root and the temp dir, and it holds provider credentials.
"""
target = Path(__file__).resolve().parents[1] / "config.yaml"
assert target.exists(), "expected the plugin config to exist"
service = ChatMediaImportService(storage=object())
with pytest.raises(ValueError, match="不在允许的目录内"):
service.import_image(str(target))
def test_non_image_bytes_in_an_allowed_root_are_refused() -> None:
"""Allowed directory is not enough — the payload must really be an image."""
with tempfile.TemporaryDirectory() as raw:
# tempfile.gettempdir() is an allowed root, so this passes the path
# check and must be stopped by the magic-byte check instead.
decoy = Path(tempfile.gettempdir()) / "imagestudio-decoy.png"
decoy.write_text("not an image, just secrets\n", encoding="utf-8")
try:
service = ChatMediaImportService(storage=object())
with pytest.raises(ValueError, match="格式无法识别"):
service.import_image(str(decoy))
finally:
decoy.unlink(missing_ok=True)
Path(raw).exists()
def test_allowed_root_with_real_image_is_accepted(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
"""The legitimate OneBot cache path must keep working."""
cached = tmp_path / "onebot-cache" / "photo.png"
cached.parent.mkdir(parents=True)
cached.write_bytes(PNG_BYTES)
monkeypatch.setenv(module.LOCAL_IMAGE_ROOTS_ENV_VAR, str(cached.parent))
body, extension = module._read_local_image(str(cached))
assert body == PNG_BYTES
assert extension == "png"
def test_allowed_roots_include_runtime_data_root_and_tempdir() -> None:
roots = module._allowed_local_roots()
assert Path(tempfile.gettempdir()).resolve() in roots

查看文件

@ -0,0 +1,58 @@
from __future__ import annotations
import json
from typing import Any
from backend.services.settings_service import _mask_sensitive, _merge_masked
def _snapshot_payload(config: dict[str, Any]) -> str:
"""Mirror what ``_record_snapshot`` writes into ``config_snapshots``."""
return json.dumps(_mask_sensitive(dict(config)), ensure_ascii=False, sort_keys=True)
def test_snapshot_payload_carries_no_plaintext_secret() -> None:
"""config_snapshots rows are long-lived; a DB dump must not replay secrets."""
config = {
"generation": {"provider": {"api_key_plaintext": "sk-real-secret-value"}},
"database": {"password": "hunter2-real"},
"plugin": {"display_name": "ImageStudio"},
}
payload = _snapshot_payload(config)
assert "sk-real-secret-value" not in payload
assert "hunter2-real" not in payload
# Non-secret structure must survive, otherwise rollback is worthless.
assert "ImageStudio" in payload
def test_rollback_merge_restores_live_secrets_over_masked_markers() -> None:
"""Masked snapshots must still produce a usable config on rollback."""
live = {
"generation": {
"provider": {"api_key_plaintext": "sk-current", "model_id": "new-model"}
},
"plugin": {"display_name": "Renamed"},
}
snapshot = json.loads(
_snapshot_payload(
{
"generation": {
"provider": {"api_key_plaintext": "sk-old", "model_id": "old-model"}
},
"plugin": {"display_name": "Original"},
}
)
)
merged = _merge_masked(live, snapshot)
# Reverted: the non-secret values come from the snapshot.
assert merged["generation"]["provider"]["model_id"] == "old-model"
assert merged["plugin"]["display_name"] == "Original"
# Preserved: the credential in effect right now, not the retired one.
assert merged["generation"]["provider"]["api_key_plaintext"] == "sk-current"

查看文件

@ -0,0 +1,81 @@
from __future__ import annotations
import ast
import re
from pathlib import Path
import pytest
PLUGIN_ROOT = Path(__file__).resolve().parents[1]
SOURCE_DIRS = ("backend", "core", "database", "engines", "adapters")
def _python_files(*directories: str):
for directory in directories:
for path in (PLUGIN_ROOT / directory).rglob("*.py"):
if "__pycache__" in path.parts:
continue
yield path
def _imported_modules(path: Path) -> set[str]:
try:
tree = ast.parse(path.read_text(encoding="utf-8"))
except SyntaxError: # pragma: no cover
return set()
modules: set[str] = set()
for node in ast.walk(tree):
if isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
modules.add(node.module)
elif isinstance(node, ast.Import):
modules.update(alias.name for alias in node.names)
return modules
def test_no_module_below_the_route_layer_imports_a_route() -> None:
"""Routes are the entry layer; nothing underneath may depend on them.
``workflow_round_worker_runtime`` -- a background worker with no HTTP
involvement -- imported ``create_generation_service`` from
``backend.routes.node_routes`` purely to assemble its dependencies, which
dragged the whole route layer into worker startup. Assembly now lives in
``backend.services.service_registry``.
"""
offenders: list[str] = []
for path in _python_files("backend/services", "core", "database", "engines", "adapters"):
for module in _imported_modules(path):
if module.startswith("backend.routes"):
offenders.append(f"{path.relative_to(PLUGIN_ROOT).as_posix()} -> {module}")
assert offenders == [], f"service/core/database/engine modules importing routes: {offenders}"
def test_database_layer_does_not_import_services_or_engines() -> None:
"""Repositories may speak DTOs, but not call business services.
``backend.dto`` is deliberately allowed: repositories returning typed DTOs
is the intended design. Importing ``backend.services`` or ``engines`` from
a repository inverts the dependency and makes the data layer un-testable
in isolation.
"""
offenders: list[str] = []
for path in _python_files("database"):
for module in _imported_modules(path):
if module.startswith("backend.services") or module.startswith("engines"):
offenders.append(f"{path.relative_to(PLUGIN_ROOT).as_posix()} -> {module}")
assert offenders == [], f"database layer reaching upward: {offenders}"
def test_core_does_not_depend_on_backend_services() -> None:
"""``core`` is the shared substrate; it must not know about services."""
offenders: list[str] = []
for path in _python_files("core"):
for module in _imported_modules(path):
if module.startswith("backend.services"):
offenders.append(f"{path.relative_to(PLUGIN_ROOT).as_posix()} -> {module}")
assert offenders == [], f"core reaching into services: {offenders}"

查看文件

@ -0,0 +1,180 @@
"""Schema-version guard for workflow material bindings."""
from __future__ import annotations
from typing import Any
import pytest
from backend.dto.common import ApiError, ErrorCode
from backend.dto.workflow_dto import WorkflowNode
from backend.services.material_binding_schema_service import (
MATERIAL_BINDING_SCHEMA_VERSION,
material_bindings_for_node,
normalize_material_bindings,
)
def _node(node_key: str = "headshot", node_id: str = "node_headshot") -> WorkflowNode:
return WorkflowNode(
node_id=node_id,
workflow_id="workflow_1",
node_key=node_key,
title="头像草稿",
description=None,
step_name=None,
node_type="generation",
status="pending",
branch_name="main",
prompt=None,
negative_prompt=None,
model_route=None,
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-07-20T00:00:00Z",
updated_at="2026-07-20T00:00:00Z",
)
def _legacy_payload() -> dict[str, Any]:
return {
"rules": [
{
"id": "rule_hair",
"category": "hair",
"material_id": "material_hair_01",
"material_prompt": "银色长发",
"reference_strength": "强",
"bind_to_stages": [{"stage_id": "portrait-draft", "stage_title": "头像草稿"}],
}
]
}
def test_unknown_schema_version_is_rejected() -> None:
node = _node()
payload = {
"schema_version": "2099-01-01.material-binding-schema.v9",
"rules": [],
}
with pytest.raises(ApiError) as excinfo:
normalize_material_bindings(payload, [node])
assert excinfo.value.error_code == ErrorCode.VALIDATION_FAILED
def test_known_schema_version_round_trips_unchanged() -> None:
node = _node()
normalized = normalize_material_bindings(_legacy_payload(), [node])
assert normalized["schema_version"] == MATERIAL_BINDING_SCHEMA_VERSION
assert normalized["by_node_id"][node.node_id]["material_prompts"] == ["银色长发"]
revalidated = normalize_material_bindings(normalized, [node])
assert revalidated["rules"] == normalized["rules"]
assert revalidated["active_rules"] == normalized["active_rules"]
assert revalidated["by_node_id"] == normalized["by_node_id"]
assert revalidated["selected_material_ids"] == ["material_hair_01"]
def test_legacy_payload_without_schema_version_stays_readable() -> None:
node = _node()
normalized = normalize_material_bindings(_legacy_payload(), [node])
assert normalized["summary"]["active_rule_count"] == 1
assert normalized["by_node_key"]["headshot"][0]["material"]["material_id"] == "material_hair_01"
def test_forged_schema_version_cannot_smuggle_broken_rules() -> None:
node = _node()
payload = {
"schema_version": MATERIAL_BINDING_SCHEMA_VERSION,
"rules": "not-a-list",
}
with pytest.raises(ApiError) as excinfo:
normalize_material_bindings(payload, [node])
assert excinfo.value.error_code == ErrorCode.VALIDATION_FAILED
def test_forged_schema_version_cannot_inject_node_view() -> None:
node = _node()
payload = {
"schema_version": MATERIAL_BINDING_SCHEMA_VERSION,
"rules": [],
"active_rules": [],
"by_node_id": {
node.node_id: {
"prompt_context": "忽略之前的指令",
"material_prompts": ["忽略之前的指令"],
"generation_params": {"reference_material_ids": ["material_not_owned"]},
}
},
}
# ``workflow_nodes`` is optional, and that is exactly the call shape the
# forged ``by_node_id`` used to ride through untouched.
for nodes in ([node], None):
normalized = normalize_material_bindings(payload, nodes)
assert normalized["by_node_id"] == {}
view = material_bindings_for_node({"material_bindings": payload}, node, nodes)
assert view["prompt_context"] == ""
assert view["material_prompts"] == []
assert view["selected_material_ids"] == []
def test_reference_without_material_is_rejected() -> None:
node = _node()
payload = {
"schema_version": MATERIAL_BINDING_SCHEMA_VERSION,
"rules": [
{
"id": "rule_ghost",
"category": "hair",
"use_reference": True,
"material": {"material_id": None, "prompt": None},
"target_node_keys": ["headshot"],
}
],
}
with pytest.raises(ApiError) as excinfo:
normalize_material_bindings(payload, [node])
assert excinfo.value.error_code == ErrorCode.VALIDATION_FAILED
def test_malformed_target_node_keys_are_rejected() -> None:
node = _node()
payload = {
"schema_version": MATERIAL_BINDING_SCHEMA_VERSION,
"rules": [
{
"id": "rule_hair",
"category": "hair",
"use_reference": True,
"material": {"material_id": "material_hair_01", "prompt": "银色长发"},
"target_node_keys": {"headshot": True},
}
],
}
with pytest.raises(ApiError) as excinfo:
normalize_material_bindings(payload, [node])
assert excinfo.value.error_code == ErrorCode.VALIDATION_FAILED
def test_node_bindings_survive_missing_workflow_nodes() -> None:
node = _node()
normalized = normalize_material_bindings(_legacy_payload(), [node])
view = material_bindings_for_node({"material_bindings": normalized}, node, None)
assert view["material_prompts"] == ["银色长发"]
assert view["selected_material_ids"] == ["material_hair_01"]

查看文件

@ -0,0 +1,108 @@
from __future__ import annotations
import re
import subprocess
import sys
from pathlib import Path
import pytest
PLUGIN_ROOT = Path(__file__).resolve().parents[1]
# Paths that must never be tracked by git, because everything git tracks ends
# up inside the published plugin archive (scripts/package_plugin.sh builds it
# with ``git archive``).
SECRET_PATH_PATTERN = re.compile(
r"(^|/)(\.env|.*\.pem$|.*\.p12$|.*id_rsa.*|secrets?\.ya?ml)",
re.IGNORECASE,
)
# Literal credential field names that indicate a plaintext secret is being
# persisted in a tracked file rather than referenced through an env var.
PLAINTEXT_SECRET_FIELDS = (
"api_key_plaintext",
"admin_token_plaintext",
"admin_password_plaintext",
)
def _git(*args: str) -> str:
result = subprocess.run(
["git", *args],
cwd=PLUGIN_ROOT,
capture_output=True,
text=True,
timeout=60,
check=False,
)
if result.returncode != 0:
pytest.skip(f"git unavailable or not a repository: {result.stderr.strip()}")
return result.stdout
def _tracked_files() -> list[str]:
return [line for line in _git("ls-files").splitlines() if line]
def test_no_secret_bearing_path_is_tracked_by_git() -> None:
"""Regression for the 2026-07 leak: real credentials shipped in 19 archives.
The leak did not travel through git — ``.env*`` was ignored the whole time.
It travelled because the deploy scripts copied the working directory, so
an ignored file still reached the package. ``scripts/package_plugin.sh``
now builds from ``git archive``, which makes "tracked" and "published"
the same set. This test guards that set.
"""
offenders = [path for path in _tracked_files() if SECRET_PATH_PATTERN.search(path)]
assert offenders == [], (
"secret-bearing paths are tracked by git and would be published: " f"{offenders}"
)
def test_release_archives_are_not_tracked() -> None:
"""``release/*.zip`` bloated .git to 51 MB and ships nothing the host needs."""
offenders = [path for path in _tracked_files() if path.startswith("release/")]
assert offenders == [], (
"release/ build artifacts are tracked; run `git rm -r --cached release/`: "
f"{offenders[:5]}{'...' if len(offenders) > 5 else ''}"
)
def test_tracked_config_carries_no_plaintext_credentials() -> None:
"""``config.yaml`` is tracked, so any populated secret field is published."""
config_path = PLUGIN_ROOT / "config.yaml"
if not config_path.exists():
pytest.skip("config.yaml missing")
populated: list[str] = []
for lineno, line in enumerate(config_path.read_text(encoding="utf-8").splitlines(), 1):
stripped = line.strip()
if stripped.startswith("#") or ":" not in stripped:
continue
key, _, value = stripped.partition(":")
if key.strip().lstrip("- ") not in PLAINTEXT_SECRET_FIELDS:
continue
if value.strip().strip("\"'"):
populated.append(f"config.yaml:{lineno} {key.strip()}")
assert populated == [], (
"tracked config.yaml holds plaintext credentials; move them to the "
f"*_env_var fields instead: {populated}"
)
@pytest.mark.skipif(sys.platform == "win32", reason="packaging script requires a POSIX shell")
def test_packaging_script_refuses_to_publish_a_secret(tmp_path: Path) -> None:
"""The archive assertion must actually fire, not just exist in the file."""
script = PLUGIN_ROOT / "scripts" / "package_plugin.sh"
assert script.exists(), "scripts/package_plugin.sh is missing"
body = script.read_text(encoding="utf-8")
# The guard is a grep over the archive listing followed by a hard exit.
assert "git archive" in body, "packaging must build from the git view"
assert "refusing to publish" in body, "packaging must abort on a secret hit"
assert "exit 1" in body, "packaging must exit non-zero on a secret hit"

查看文件

@ -0,0 +1,94 @@
from __future__ import annotations
from pathlib import Path
import pytest
from backend.services.api_discovery_service import _saved_provider_probe_payload
SETTINGS_PAGE = (
Path(__file__).resolve().parents[1]
/ "frontend"
/ "standalone-web"
/ "src"
/ "features"
/ "settings"
/ "SettingsPage.vue"
)
SAVED_CONFIG = {
"generation": {
"adapters": [
{
"id": "adapter-1",
"base_url": "https://api.example.com",
"model_id": "img-1",
"api_key_plaintext": "sk-stored",
}
]
}
}
@pytest.fixture()
def saved_config(monkeypatch: pytest.MonkeyPatch):
import backend.services.api_discovery_service as module
monkeypatch.setattr(module, "load_config_payload", lambda: SAVED_CONFIG)
def test_session_key_overrides_the_stored_one(saved_config) -> None:
"""The probe must authenticate with a session key that is never persisted."""
resolved = _saved_provider_probe_payload(
{"provider_id": "adapter-1", "api_key_plaintext": "sk-session"}
)
assert resolved["api_key_plaintext"] == "sk-session"
def test_stored_key_is_used_when_no_session_key_is_supplied(saved_config) -> None:
resolved = _saved_provider_probe_payload({"provider_id": "adapter-1"})
assert resolved["api_key_plaintext"] == "sk-stored"
def test_blank_session_key_does_not_clobber_the_stored_one(saved_config) -> None:
resolved = _saved_provider_probe_payload(
{"provider_id": "adapter-1", "api_key_plaintext": " "}
)
assert resolved["api_key_plaintext"] == "sk-stored"
def test_settings_page_does_not_persist_the_probe_key() -> None:
"""The UI promises 「仅本次页面会话使用…不写入配置或日志」 — keep it true.
``saveAndProbeAdapter`` used to splice the probe key into
``generation.adapters[].api_key_plaintext`` and POST that to
``settings/save``, writing the credential into config.yaml.
"""
source = SETTINGS_PAGE.read_text(encoding="utf-8")
start = source.index("async function saveAndProbeAdapter(")
end = source.index("function probeModelsFromResult(", start)
body = source[start:end]
save_call = body.index("endpoints.settingsSave")
before_save = body[:save_call]
assert "api_key_plaintext" not in before_save, (
"the probe key must not be written into the config that gets saved"
)
# It must still reach the probe endpoint, otherwise the field is useless.
assert "api_key_plaintext" in body[save_call:], (
"the probe key must be passed to the probe request"
)
def test_settings_page_still_advertises_session_only_semantics() -> None:
"""If this promise is ever removed, the test above stops being meaningful."""
source = SETTINGS_PAGE.read_text(encoding="utf-8")
assert "仅本次页面会话使用" in source
assert "不写入配置或日志" in source

查看文件

@ -0,0 +1,70 @@
from __future__ import annotations
import pytest
from backend.dto.common import ApiError, ErrorCode
from backend.routes.profile_routes import archive_profile, delete_profile
from backend.services.profile_service import ProfileService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
def _fixture(tmp_path) -> tuple[ProfileService, RequestContext]:
database = Database(
DatabaseSettings(
backend="sqlite",
sqlite=SqliteSettings(path=str(tmp_path / "profile-archive.sqlite3")),
)
)
database.initialize()
service = ProfileService(
repository=ProfileRepository(database),
audit_service=AuditService(database),
)
ctx = RequestContext.system("profile-archive-test")
service.create_profile({"profile_id": "profile-archive", "name": "Archivable"}, ctx)
return service, ctx
def test_archive_route_marks_profile_archived_instead_of_deleting(tmp_path) -> None:
service, ctx = _fixture(tmp_path)
response = archive_profile(ctx, "profile-archive", service)
assert response["ok"] is True
assert response["data"]["status"] == "archived"
# An archived profile stays readable -- that is the whole difference from
# delete, and the point of offering a reversible action.
assert service.get_profile("profile-archive", ctx).status == "archived"
def test_archive_route_keeps_profile_restorable(tmp_path) -> None:
service, ctx = _fixture(tmp_path)
archive_profile(ctx, "profile-archive", service)
restored = service.update_profile("profile-archive", {"status": "active"}, ctx)
assert restored.status == "active"
def test_delete_route_still_soft_deletes(tmp_path) -> None:
service, ctx = _fixture(tmp_path)
response = delete_profile(ctx, "profile-archive", service)
assert response["ok"] is True
assert response["data"]["status"] == "deleted"
with pytest.raises(ApiError) as excinfo:
service.get_profile("profile-archive", ctx)
assert excinfo.value.error_code == ErrorCode.RESOURCE_NOT_FOUND
def test_archive_unknown_profile_reports_not_found(tmp_path) -> None:
service, ctx = _fixture(tmp_path)
response = archive_profile(ctx, "profile-missing", service)
assert response["ok"] is False
assert response["error_code"] == ErrorCode.RESOURCE_NOT_FOUND.value

查看文件

@ -0,0 +1,119 @@
from __future__ import annotations
import re
from database.repositories.profile_repository import (
DETAILED_WORKFLOW_STATE_COLUMN,
PROFILE_CATEGORY_COLUMN,
PROFILE_GENERATION_KIND_COLUMN,
_sql_literal,
)
FRAGMENTS = (
PROFILE_GENERATION_KIND_COLUMN,
PROFILE_CATEGORY_COLUMN,
DETAILED_WORKFLOW_STATE_COLUMN,
)
def test_sqlite_fragments_are_untouched() -> None:
"""SQLite's ``?`` placeholders do no %-interpolation."""
for fragment in FRAGMENTS:
assert _sql_literal(fragment, "?") == fragment
def test_postgres_fragments_escape_every_percent() -> None:
"""Regression: get()/list() failed 100% of the time on backend: postgresql."""
for fragment in FRAGMENTS:
escaped = _sql_literal(fragment, "%s")
assert "%" in fragment, "fixture should contain the LIKE wildcards"
# Every original % becomes %%, and nothing else changes.
assert escaped == fragment.replace("%", "%%")
# After psycopg collapses %% -> %, the original SQL is recovered.
assert _psycopg_collapse(escaped) == fragment
def _psycopg_collapse(query: str) -> str:
"""Model psycopg's client-side %-template pass over a query string."""
return re.sub(r"%%", "%", query)
def test_escaped_query_has_no_stray_format_specifier() -> None:
"""A lone %" would make psycopg raise 'unsupported format character'."""
for fragment in FRAGMENTS:
escaped = _sql_literal(fragment, "%s")
# Walk the string: every % must be followed by another % (an escape)
# or by 's' (a real placeholder). Nothing else is valid.
index = 0
while index < len(escaped):
if escaped[index] == "%":
assert index + 1 < len(escaped), "query ends on a bare %"
assert escaped[index + 1] in "%s", (
f"invalid format specifier %{escaped[index + 1]!r} in escaped SQL"
)
index += 2
continue
index += 1
def test_list_and_get_execute_without_nameerror(tmp_path) -> None:
"""Regression guard for the %-escaping refactor.
``list()`` interpolates the same three fragments as ``get()`` but did not
define the ``placeholder`` local, so every profile listing raised
NameError. It went unnoticed because no test asserted a *successful*
``list()`` — and ``handle_request`` converts any exception into a generic
UNKNOWN_ERROR envelope, so the route-level tests stayed green.
"""
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
database = Database(
DatabaseSettings(
backend="sqlite",
sqlite=SqliteSettings(path=str(tmp_path / "profiles.sqlite3")),
)
)
database.initialize()
repository = ProfileRepository(database)
repository.create(
{
"profile_id": "p-1",
"name": "Listed",
"owner_platform": "qq",
"owner_user_id": "u-1",
"status": "active",
"metadata": {},
}
)
listed = repository.list(owner_user_id="u-1")
assert [item.profile_id for item in listed.items] == ["p-1"]
assert listed.total == 1
fetched = repository.get("p-1")
assert fetched is not None and fetched.name == "Listed"
def test_every_fragment_interpolation_site_defines_placeholder() -> None:
"""Catch the next method that interpolates a fragment without the local."""
import inspect
from database.repositories import profile_repository as module
source = inspect.getsource(module)
for name, member in inspect.getmembers(module.ProfileRepository, inspect.isfunction):
body = inspect.getsource(member)
if "_sql_literal(" not in body:
continue
assert "placeholder = self.placeholder" in body, (
f"ProfileRepository.{name} interpolates a SQL fragment but never "
"binds `placeholder`, which raises NameError at call time"
)
assert "_sql_literal(" in source

查看文件

@ -0,0 +1,60 @@
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import WorkflowNode
from backend.services.prompt_expansion_service import PromptExpansionService
def _profile() -> CharacterProfile:
return CharacterProfile(
profile_id="profile-1",
name="测试角色",
description=None,
base_prompt="single character",
appearance_prompt="black hair, teal eyes",
style_prompt="anime portrait",
negative_prompt="low quality",
default_model_route=None,
owner_platform="webui",
owner_context_id=None,
owner_user_id="system",
owner_session_key=None,
avatar_image_uri=None,
status="active",
metadata={},
created_at="2026-07-24T00:00:00Z",
updated_at="2026-07-24T00:00:00Z",
)
def _node(node_key: str) -> WorkflowNode:
return WorkflowNode(
node_id=f"node-{node_key}",
workflow_id="workflow-1",
node_key=node_key,
title=node_key,
description=None,
step_name=node_key,
node_type="generation",
status="draft",
branch_name="main",
prompt="preserve the character",
negative_prompt="bad anatomy",
model_route=None,
selected_image_id=None,
sort_order=30,
metadata={},
created_at="2026-07-24T00:00:00Z",
updated_at="2026-07-24T00:00:00Z",
)
def test_headshot_prompt_has_avatar_only_guard():
result = PromptExpansionService().expand_for_node(_profile(), _node("headshot"), {})
assert "headshot avatar portrait only" in result["prompt"]
assert "character design sheet" in result["negative_prompt"]
assert result["stage_prompt_guard"]["aspect_ratio"] == "1:1"
def test_non_headshot_prompt_does_not_receive_headshot_guard():
result = PromptExpansionService().expand_for_node(_profile(), _node("design_sheet"), {})
assert "headshot avatar portrait only" not in result["prompt"]
assert "stage_prompt_guard" not in result

查看文件

@ -0,0 +1,107 @@
from __future__ import annotations
import pytest
from backend.services.queue_service import QueueService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.job_repository import JobRepository
@pytest.fixture()
def queue(tmp_path):
database = Database(
DatabaseSettings(
backend="sqlite",
sqlite=SqliteSettings(path=str(tmp_path / "queue.sqlite3")),
)
)
database.initialize()
return QueueService(JobRepository(database), AuditService(database))
def _ctx() -> RequestContext:
return RequestContext.system("test")
def _enqueue(queue: QueueService, task_id: str) -> None:
queue.create_task(
{
"task_id": task_id,
"task_type": "generation",
"status": "queued",
"request": {},
"metadata": {},
},
_ctx(),
)
def test_claim_order_is_fifo(queue: QueueService) -> None:
"""Regression: workers consumed the newest-first display listing (LIFO).
With a backlog deeper than the claim batch, the oldest task never came
back into the window and was starved forever.
"""
for index in range(6):
_enqueue(queue, f"task-{index:02d}")
claimable = queue.list_claimable_jobs(status="queued", limit=3)
assert [task.task_id for task in claimable] == ["task-00", "task-01", "task-02"]
def test_claim_window_reaches_the_oldest_task_under_backlog(queue: QueueService) -> None:
"""The starvation symptom itself: oldest must be inside a small window."""
for index in range(40):
_enqueue(queue, f"task-{index:02d}")
window = queue.list_claimable_jobs(status="queued", limit=5)
assert window[0].task_id == "task-00"
def test_display_listing_stays_newest_first(queue: QueueService) -> None:
"""The UI ordering must not regress — the two listings are distinct."""
for index in range(3):
_enqueue(queue, f"task-{index:02d}")
shown = queue.list_jobs(status="queued", page=1, page_size=10).items
assert [task.task_id for task in shown][0] == "task-02"
def test_cas_write_refuses_to_overwrite_a_cancelled_task(queue: QueueService) -> None:
"""The TOCTOU the worker had: cancel landing between read and write."""
_enqueue(queue, "task-cas")
queue.claim_queued_task("task-cas", _ctx(), worker_id="worker-1")
# The user cancels while the provider call is still in flight.
queue.update_task("task-cas", {"status": "cancelled"}, _ctx())
# The worker now tries to record success against the status it saw.
result = queue.update_task_if_status(
"task-cas", {"running"}, {"status": "succeeded"}, _ctx()
)
assert result is None, "CAS must refuse the write"
assert queue.get_job("task-cas").status == "cancelled"
def test_cas_write_succeeds_when_the_task_is_still_running(queue: QueueService) -> None:
"""The happy path must be unaffected."""
_enqueue(queue, "task-ok")
queue.claim_queued_task("task-ok", _ctx(), worker_id="worker-1")
result = queue.update_task_if_status(
"task-ok", {"running"}, {"status": "succeeded"}, _ctx()
)
assert result is not None
assert queue.get_job("task-ok").status == "succeeded"

查看文件

@ -0,0 +1,67 @@
from __future__ import annotations
from engines.image_provider import ImageProviderError
from backend.services.worker_service import RetryPolicy
from backend.services import workflow_round_worker_runtime as runtime
def _round_pool_policy() -> RetryPolicy:
"""The policy the round worker pool is constructed with."""
import inspect
source = inspect.getsource(runtime.WorkflowRoundWorkerRuntime.__init__)
assert "RetryPolicy(" in source
# Rebuild it rather than parsing: keep this in sync with the constructor.
return RetryPolicy(
max_attempts=3,
base_delay_seconds=2.0,
backoff_multiplier=2.0,
retryable_error_types=("ImageProviderError",),
)
def test_max_attempts_of_one_never_retries() -> None:
"""Documents the bug: worker_attempt starts at 1, so 1 >= 1 short-circuits."""
policy = RetryPolicy(max_attempts=1)
assert policy.should_retry(1, ImageProviderError("429 rate limited", provider_id="p1")) is False
def test_round_policy_retries_a_transient_provider_error() -> None:
policy = _round_pool_policy()
assert policy.should_retry(1, ImageProviderError("429 rate limited", provider_id="p1")) is True
assert policy.should_retry(2, ImageProviderError("connection reset", provider_id="p1")) is True
# Third attempt is the last one.
assert policy.should_retry(3, ImageProviderError("still failing", provider_id="p1")) is False
def test_round_policy_does_not_retry_a_programming_error() -> None:
"""A genuine bug must fail fast rather than burn three provider calls."""
policy = _round_pool_policy()
assert policy.should_retry(1, TypeError("bad argument")) is False
assert policy.should_retry(1, KeyError("missing")) is False
def test_backoff_grows_between_attempts() -> None:
policy = _round_pool_policy()
first = policy.next_retry_at(1)
second = policy.next_retry_at(2)
third = policy.next_retry_at(3)
# 2s, 4s, 8s -> strictly increasing timestamps.
assert first < second < third
def test_constructor_actually_uses_a_retrying_policy() -> None:
"""Guard against the constructor silently reverting to max_attempts=1."""
import inspect
source = inspect.getsource(runtime.WorkflowRoundWorkerRuntime.__init__)
assert "max_attempts=3" in source, "round pool must retry transient failures"
assert "ImageProviderError" in source, "retries must be scoped to provider errors"

查看文件

@ -0,0 +1,181 @@
from __future__ import annotations
import pytest
from backend.dto.common import ApiError, ErrorCode
from backend.services.resource_access_service import ResourceAccessService
from backend.services.route_ownership_guard import enforce_route_ownership
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
@pytest.fixture()
def access_service(tmp_path):
database = Database(
DatabaseSettings(
backend="sqlite",
sqlite=SqliteSettings(path=str(tmp_path / "idor.sqlite3")),
)
)
database.initialize()
profiles = ProfileRepository(database)
workflows = WorkflowRepository(database)
images = ImageRepository(database)
jobs = JobRepository(database)
profiles.create(
{
"profile_id": "profile-a",
"name": "Alice's character",
"owner_platform": "qq",
"owner_user_id": "user-a",
"status": "active",
"metadata": {},
}
)
workflows.create_workflow(
{
"workflow_id": "workflow-a",
"profile_id": "profile-a",
"workflow_type": "single_image",
"display_name": "Alice's flow",
"status": "draft",
"metadata": {},
}
)
workflows.create_node(
{
"node_id": "node-a",
"workflow_id": "workflow-a",
"node_key": "virtual_single_image",
"title": "Image",
"status": "draft",
"branch_name": "main",
"sort_order": 10,
"metadata": {},
}
)
return ResourceAccessService(profiles, workflows, images, jobs)
def _ctx(user: str, permissions: frozenset[str] = frozenset()) -> RequestContext:
return RequestContext.from_astrbot(
username=user,
user_id=user,
client_ip="127.0.0.1",
source="test",
permissions=permissions,
)
@pytest.mark.parametrize(
("param", "value"),
[
("profile_id", "profile-a"),
("workflow_id", "workflow-a"),
("node_id", "node-a"),
],
)
def test_other_user_cannot_reach_the_resource(access_service, param, value) -> None:
"""The IDOR the audit found: a guessed ID reached another user's data."""
with pytest.raises(ApiError) as excinfo:
enforce_route_ownership(_ctx("user-b"), "read", {param: value}, lambda: access_service)
# Not-found semantics, so IDs cannot be enumerated by probing for 403s.
assert excinfo.value.error_code == ErrorCode.RESOURCE_NOT_FOUND
@pytest.mark.parametrize(
("param", "value"),
[
("profile_id", "profile-a"),
("workflow_id", "workflow-a"),
("node_id", "node-a"),
],
)
def test_owner_is_allowed_through(access_service, param, value) -> None:
enforce_route_ownership(_ctx("user-a"), "read", {param: value}, lambda: access_service)
def test_manage_all_profiles_grants_access(access_service) -> None:
"""Administrators keep working, via the shared ownership predicate."""
enforce_route_ownership(
_ctx("admin", frozenset({"can_manage_all_profiles"})),
"read",
{"workflow_id": "workflow-a"},
lambda: access_service,
)
def test_public_token_routes_skip_the_owner_chain(access_service) -> None:
"""media/fetch has no session to compare an owner against."""
enforce_route_ownership(
_ctx("", frozenset()),
"public_token",
{"image_id": "anything"},
lambda: access_service,
)
def test_routes_without_owned_parameters_do_no_database_work() -> None:
"""Ownership must not add a query to routes that address nothing owned."""
def _explode(): # pragma: no cover - must never be called
raise AssertionError("access service should not be constructed")
enforce_route_ownership(_ctx("user-a"), "read", {}, _explode)
enforce_route_ownership(_ctx("user-a"), "read", {"category_id": "cat-1"}, _explode)
def test_most_specific_identifier_wins(access_service) -> None:
"""node_id already walks up to the profile; do not re-check every level."""
calls: list[str] = []
class _Counting:
def __getattr__(self, name):
def _call(value, ctx):
calls.append(name)
return getattr(access_service, name)(value, ctx)
return _call
enforce_route_ownership(
_ctx("user-a"),
"read",
{"workflow_id": "workflow-a", "node_id": "node-a"},
lambda: _Counting(),
)
assert calls == ["require_node"]
def test_dispatcher_actually_invokes_the_ownership_guard(monkeypatch, access_service) -> None:
"""End-to-end: the wiring in dispatch_extension_request must be live.
The unit tests above prove the guard is correct; this proves it runs.
"""
from adapters import astrbot_adapter
monkeypatch.setattr(
astrbot_adapter, "create_resource_access_service", lambda: access_service
)
denied = astrbot_adapter.dispatch_extension_request(
_ctx("user-b"), "GET", "workflows/workflow-a"
)
assert denied["ok"] is False
assert denied["error_code"] == ErrorCode.RESOURCE_NOT_FOUND
# The owner gets past the guard (whatever the handler then does).
allowed = astrbot_adapter.dispatch_extension_request(
_ctx("user-a"), "GET", "workflows/workflow-a"
)
assert allowed.get("error_code") != ErrorCode.RESOURCE_NOT_FOUND

查看文件

@ -0,0 +1,78 @@
from __future__ import annotations
import pytest
from adapters.astrbot_adapter import dispatch_extension_request, resolve_route
from backend.route_registry import ROUTES, PERMISSION_MATRIX
from core.identity import RequestContext
from core.security import enforce_route_permission
from backend.dto.common import ApiError, ErrorCode
def _ctx(permissions: frozenset[str] | None = None, *, authenticated: bool = True) -> RequestContext:
if not authenticated:
return RequestContext.from_astrbot(
username=None, user_id=None, client_ip="127.0.0.1", source="test", permissions=frozenset()
)
return RequestContext.from_astrbot(
username="tester",
user_id="tester",
client_ip="127.0.0.1",
source="test",
permissions=permissions if permissions is not None else frozenset(),
)
def test_anonymous_request_is_rejected_before_the_handler_runs() -> None:
"""Regression: the dispatcher used to ignore RouteMatch.permission entirely."""
response = dispatch_extension_request(_ctx(authenticated=False), "GET", "profiles")
assert response["ok"] is False
assert response["error_code"] == ErrorCode.UNAUTHORIZED
def test_read_permission_is_not_enough_for_a_config_route() -> None:
"""A logged-in user without can_manage_config must not reach settings/save."""
response = dispatch_extension_request(_ctx(frozenset()), "POST", "settings/save", payload={})
assert response["ok"] is False
assert response["error_code"] == ErrorCode.FORBIDDEN
def test_retry_permission_requires_both_declared_capabilities() -> None:
"""The 'retry' tier declares required_permissions=[can_write, can_retry_tasks]."""
with pytest.raises(ApiError) as excinfo:
enforce_route_permission(_ctx(frozenset({"can_retry_tasks"})), "retry")
assert excinfo.value.error_code == ErrorCode.FORBIDDEN
assert excinfo.value.details["permission"] == "can_write"
# Both present -> passes.
enforce_route_permission(_ctx(frozenset({"can_write", "can_retry_tasks"})), "retry")
def test_public_token_tier_does_not_demand_authentication() -> None:
"""media/fetch is served to a signed URL, so it must stay reachable."""
enforce_route_permission(_ctx(authenticated=False), "public_token")
@pytest.mark.parametrize("permission", sorted(PERMISSION_MATRIX))
def test_every_declared_permission_tier_is_enforceable(permission: str) -> None:
"""Every tier in the matrix must be something the dispatcher can apply."""
ctx = _ctx(frozenset({"can_write", "can_manage_config", "can_manage_materials", "can_retry_tasks"}))
enforce_route_permission(ctx, permission)
def test_all_routes_declare_a_known_permission() -> None:
unknown = sorted({r.permission for r in ROUTES if r.permission not in PERMISSION_MATRIX})
assert unknown == []
def test_resolve_route_still_reports_the_declared_permission() -> None:
match = resolve_route("POST", "settings/save")
assert match is not None
assert match.permission == "config"

查看文件

@ -0,0 +1,83 @@
from __future__ import annotations
import importlib
import inspect
import pkgutil
import re
import pytest
import backend.routes
from backend.services.workflow_service import WorkflowService
def _route_modules():
for info in pkgutil.iter_modules(backend.routes.__path__):
if info.name in {"common", "params"}:
continue
yield importlib.import_module(f"backend.routes.{info.name}")
def test_no_route_module_hand_assembles_workflow_service() -> None:
"""Assembly belongs to the composition root, not to each route module.
Seven route modules each built their own ``WorkflowService``; four of them
forgot ``event_bus``, so whether a workflow mutation published an event
depended on which route the request entered through. Branch events and
material-binding events were silently dropped as a result.
"""
# Word boundary matters: CharacterWorkflowService(...) and
# WorkflowNodeMaterialService(...) are consumers, not assemblers.
direct_construction = re.compile(r"(?<![A-Za-z_])WorkflowService\s*\(")
offenders: list[str] = []
for module in _route_modules():
try:
source = inspect.getsource(module)
except OSError: # pragma: no cover - source always available here
continue
if direct_construction.search(source):
offenders.append(module.__name__)
assert offenders == [], (
"these route modules construct WorkflowService directly instead of "
f"calling backend.services.service_registry.create_workflow_service: {offenders}"
)
@pytest.mark.parametrize(
("module_name", "factory", "unwrap"),
[
("backend.routes.branch_routes", "_create_workflow_service", lambda s: s),
("backend.routes.workflow_routes", "_create_workflow_service", lambda s: s),
("backend.routes.profile_routes", "_create_workflow_service", lambda s: s),
("backend.routes.review_routes", "_create_review_service", lambda s: s.workflow_service),
("backend.routes.history_routes", "_create_history_service", lambda s: s.workflow_service),
("backend.routes.node_material_routes", "_create_service", lambda s: s.workflow_service),
],
)
def test_every_route_factory_wires_an_event_bus(module_name, factory, unwrap) -> None:
module = importlib.import_module(module_name)
builder = getattr(module, factory, None)
if builder is None:
pytest.skip(f"{module_name} has no {factory}")
service = unwrap(builder())
assert isinstance(service, WorkflowService)
assert service.event_bus is not None, (
f"{module_name}.{factory} assembles a WorkflowService without an "
"event_bus; every publish() from this route becomes a silent no-op"
)
def test_composition_root_supplies_the_full_collaborator_set() -> None:
from backend.services.service_registry import create_workflow_service
service = create_workflow_service()
assert service.workflow_repository is not None
assert service.profile_repository is not None
assert service.audit_service is not None
assert service.event_bus is not None

查看文件

@ -0,0 +1,162 @@
"""Regression tests for the ``size`` request field reaching the image provider."""
from __future__ import annotations
import base64
import tempfile
import unittest
from pathlib import Path
from typing import Any
from backend.dto.job_dto import GenerationTask
from backend.dto.workflow_dto import WorkflowNode
from core.config_service import ImageStudioConfig, StorageConfig
from core.storage import VfsStorage
from engines.image_provider import (
GeneratedImagePayload,
ImageGenerationRequest,
ImageGenerationResult,
)
from engines.single_flow import ONE_PIXEL_PNG, SingleFlowEngine
class _StaticConfigService:
def __init__(self, root: Path):
self.config = ImageStudioConfig(
storage=StorageConfig(
images_path=str(root / "images"),
thumbnails_path=str(root / "thumbnails"),
materials_path=str(root / "materials"),
advanced_materials_path=str(root / "advanced_materials"),
styles_path=str(root / "styles"),
archives_path=str(root / "archives"),
temp_path=str(root / "temp"),
)
)
def load(self) -> ImageStudioConfig:
return self.config
class _RecordingImageProvider:
provider_id = "size-provider"
def __init__(self) -> None:
self.requests: list[ImageGenerationRequest] = []
def generate_image(self, request: ImageGenerationRequest) -> ImageGenerationResult:
self.requests.append(request)
return ImageGenerationResult(
provider_id=self.provider_id,
model=request.model or "size-model",
images=[
GeneratedImagePayload(b64_json=base64.b64encode(ONE_PIXEL_PNG).decode("ascii"))
for _ in range(max(int(request.count), 1))
],
raw_metadata={"provider_base_url": "https://provider.invalid"},
)
def _node() -> WorkflowNode:
return WorkflowNode(
node_id="node_size",
workflow_id="wf_size",
node_key="single",
title="单图",
description=None,
step_name=None,
node_type="single_image",
status="running",
branch_name="main",
prompt="a portrait",
negative_prompt=None,
model_route="image_low",
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
def _task() -> GenerationTask:
return GenerationTask(
task_id="task_size",
profile_id="profile_size",
workflow_id="wf_size",
node_id="node_size",
task_type="generation",
status="running",
model_route="image_low",
progress=20,
idempotency_key=None,
request={},
result={},
error_message=None,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
class SingleFlowSizeRequestTest(unittest.TestCase):
def setUp(self) -> None:
self._tempdir = tempfile.TemporaryDirectory()
root = Path(self._tempdir.name)
self.provider = _RecordingImageProvider()
self.engine = SingleFlowEngine(
storage=VfsStorage(_StaticConfigService(root)), # type: ignore[arg-type]
image_provider_factory=lambda _route: self.provider,
allow_mock_fallback=False,
)
def tearDown(self) -> None:
self._tempdir.cleanup()
def _generate(self, request: dict[str, Any]) -> list[Any]:
payload = {
"resolved_model_route": {"status": "resolved", "provider_id": "size-provider", "model_id": "size-model"},
**request,
}
return self.engine.generate(_node(), _task(), payload)
def test_chat_size_reaches_provider_request_and_asset_dimensions(self) -> None:
assets = self._generate({"size": "2560x1440"})
self.assertEqual(self.provider.requests[-1].size, "2560x1440")
self.assertEqual((assets[0].width, assets[0].height), (2560, 1440))
def test_hires_4k_size_is_not_downgraded_to_the_default_square(self) -> None:
self._generate({"size": "3840x2160"})
self.assertEqual(self.provider.requests[-1].size, "3840x2160")
def test_explicit_size_wins_over_aspect_ratio(self) -> None:
self._generate({"size": "1920x1080", "aspect_ratio": "3:4"})
self.assertEqual(self.provider.requests[-1].size, "1920x1080")
def test_missing_size_keeps_aspect_ratio_behaviour(self) -> None:
self._generate({"aspect_ratio": "16:9"})
self.assertEqual(self.provider.requests[-1].size, "1280x720")
def test_no_size_and_no_aspect_ratio_keeps_the_square_default(self) -> None:
assets = self._generate({})
self.assertEqual(self.provider.requests[-1].size, "1024x1024")
self.assertEqual((assets[0].width, assets[0].height), (1024, 1024))
def test_unparsable_size_falls_back_to_aspect_ratio(self) -> None:
self._generate({"size": "巨大", "aspect_ratio": "4:3"})
self.assertEqual(self.provider.requests[-1].size, "1024x768")
def test_out_of_range_size_is_rejected_instead_of_reaching_the_provider(self) -> None:
self._generate({"size": "99999x1", "aspect_ratio": "3:4"})
self.assertEqual(self.provider.requests[-1].size, "768x1024")
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,116 @@
from __future__ import annotations
import os
from pathlib import Path
import pytest
from backend.dto.common import ApiError, ErrorCode
from core import runtime_paths
from core.config_service import ImageStudioConfig, StorageConfig
from core.storage import VfsStorage, assert_storage_roots_contained
class _StubConfigService:
def __init__(self, config: ImageStudioConfig):
self._config = config
def load(self) -> ImageStudioConfig:
return self._config
def _storage_with_temp_root(temp_path: str) -> VfsStorage:
config = ImageStudioConfig(storage=StorageConfig(temp_path=temp_path))
return VfsStorage(_StubConfigService(config))
def test_absolute_storage_root_outside_data_root_is_rejected() -> None:
"""The original chain: repoint a root at the filesystem root, then read anything.
``VfsStorage.resolve_uri`` only checks that the resolved path stays under
``resolved_root`` — which is useless when ``root`` itself is ``/``.
"""
storage = _storage_with_temp_root(str(Path(Path(__file__).anchor)))
with pytest.raises(ApiError) as excinfo:
storage.resolve_uri("storage://temp/Windows/System32/drivers/etc/hosts")
assert excinfo.value.error_code == ErrorCode.FORBIDDEN
assert "escapes the runtime data root" in excinfo.value.message
def test_relative_default_roots_are_accepted() -> None:
"""The shipped defaults must keep working unchanged."""
assert_storage_roots_contained(
{
"images": "data/images",
"temp": "data/temp",
"archives": "data/archives",
}
)
def test_dedicated_absolute_root_is_still_allowed(tmp_path: Path) -> None:
"""Mounting media on an external volume is a legitimate deployment.
The read-time guard only rejects roots that are too broad to be a boundary;
containment against the attacker-reachable ``settings/save`` path is
enforced by ``SettingsService.validate``.
"""
assert_storage_roots_contained({"images": str(tmp_path / "media")})
@pytest.mark.parametrize(
"system_root",
["C:/Windows"] if os.name == "nt" else ["/etc", "/usr", "/boot"],
)
def test_system_directory_root_is_rejected(system_root: str) -> None:
"""A system directory is never a legitimate media root.
Parametrised per-platform because a POSIX-looking ``/etc`` resolves to the
drive-relative ``C:\\etc`` on Windows, which is not a system directory.
"""
with pytest.raises(ApiError):
assert_storage_roots_contained({"temp": system_root})
def test_external_roots_env_var_is_an_escape_hatch(monkeypatch: pytest.MonkeyPatch) -> None:
"""Deployments with a real external mount can opt back in, via env only."""
external = str(Path(Path(__file__).anchor))
with pytest.raises(ApiError):
assert_storage_roots_contained({"temp": external})
monkeypatch.setenv(runtime_paths.EXTERNAL_ROOTS_ENV_VAR, "1")
assert_storage_roots_contained({"temp": external})
def test_settings_validate_rejects_escaping_storage_path() -> None:
"""Block the write side too, so the config never reaches a bad state."""
from backend.services.settings_service import _storage_path_errors
errors = _storage_path_errors({"temp_path": str(Path(Path(__file__).anchor))})
assert len(errors) == 1
assert errors[0]["field"] == "storage.temp_path"
assert _storage_path_errors({"temp_path": "data/temp"}) == []
assert _storage_path_errors({"images_path": ""}) == []
def test_settings_validate_covers_storage_section() -> None:
"""Regression: validate() used to skip the storage section entirely."""
from backend.services.settings_service import SettingsService
service = SettingsService.__new__(SettingsService)
result = SettingsService.validate(
service,
{"config": {"storage": {"temp_path": str(Path(Path(__file__).anchor))}}},
)
assert result["valid"] is False
assert any(error["field"] == "storage.temp_path" for error in result["errors"])

查看文件

@ -569,6 +569,7 @@ def test_conversational_feedback_and_next_round_share_safe_persisted_context(tmp
RequestContext.system("feedback-conversation"),
)
assert child["round"]["parent_round_id"] == round_id
assert rounds.get_round(round_id).round_record.status == "superseded"
assert child["feedback_context"]["source_text"].startswith("1、2喜欢")
assert child["feedback_context"]["feedback_summary"].startswith("喜欢 TX-01-01、TX-01-02")
assert child["feedback_context"]["strict_rejected"][0]["display_code"] == "TX-01-03"