fix: complete security and workflow hardening
这个提交存在于:
父节点
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),
|
||||
)
|
||||
161
backend/services/service_registry.py
普通文件
161
backend/services/service_registry.py
普通文件
|
|
@ -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
普通文件
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
普通文件
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
普通文件
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]:
|
||||
|
|
|
|||
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
二进制文件未显示。
64
tests/test_adult_content_gate.py
普通文件
64
tests/test_adult_content_gate.py
普通文件
|
|
@ -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"
|
||||
81
tests/test_layering_rules.py
普通文件
81
tests/test_layering_rules.py
普通文件
|
|
@ -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"]
|
||||
108
tests/test_package_secret_leak.py
普通文件
108
tests/test_package_secret_leak.py
普通文件
|
|
@ -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
|
||||
107
tests/test_queue_fifo_and_cas.py
普通文件
107
tests/test_queue_fifo_and_cas.py
普通文件
|
|
@ -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"
|
||||
181
tests/test_route_ownership_idor.py
普通文件
181
tests/test_route_ownership_idor.py
普通文件
|
|
@ -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()
|
||||
116
tests/test_storage_root_sandbox.py
普通文件
116
tests/test_storage_root_sandbox.py
普通文件
|
|
@ -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"
|
||||
|
|
|
|||
正在加载…
添加表格
在新工单中引用