create-windy 0.6.0 → 0.6.1

package/dist/cli.js

@@ -378,7 +378,9 @@ var optionalModuleManifests = [
       "packages/modules/src/system-agent-tools.ts",
       "packages/database/src/agent-runtime-schema.test.ts",
       "packages/database/src/ai-output-artifacts.test.ts",
-      "packages/shared/src/ai-runtime-report.ts"
+      "packages/shared/src/ai-runtime-report.ts",
+      "packages/shared/src/screenshot-context-digest.ts",
+      "packages/shared/src/screenshot-context-digest.test.ts"
     ],
     documentation: [
       "docs/architecture/ai-runtime.md",
@@ -3092,6 +3094,9 @@ var agentComposeService = `  tool-sandbox-init:
       EMBEDDING_ADAPTER_URL: \${EMBEDDING_ADAPTER_URL:-}
       EMBEDDING_ADAPTER_TOKEN: \${EMBEDDING_ADAPTER_TOKEN:-}
       EMBEDDING_DEPLOYMENT_KEY: \${EMBEDDING_DEPLOYMENT_KEY:-}
+      EMBEDDING_DEPLOYMENT_IDENTITY: \${EMBEDDING_DEPLOYMENT_IDENTITY:-}
+      EMBEDDING_RELEASE_DIGEST: \${EMBEDDING_RELEASE_DIGEST:-}
+      EMBEDDING_OFFERS_DIGEST: \${EMBEDDING_OFFERS_DIGEST:-}
       EMBEDDING_DEPLOYMENT_ALIAS: \${EMBEDDING_DEPLOYMENT_ALIAS:-}
       EMBEDDING_MODEL: \${EMBEDDING_MODEL:-}
       EMBEDDING_MODEL_VERSION: \${EMBEDDING_MODEL_VERSION:-}
@@ -3099,8 +3104,16 @@ var agentComposeService = `  tool-sandbox-init:
       EMBEDDING_NORMALIZED: \${EMBEDDING_NORMALIZED:-true}
       EMBEDDING_CAPABILITIES: \${EMBEDDING_CAPABILITIES:-embedding.text}
       EMBEDDING_MAX_UNITS: \${EMBEDDING_MAX_UNITS:-256}
+      EMBEDDING_MAX_DURATION_SECONDS: \${EMBEDDING_MAX_DURATION_SECONDS:-600}
+      EMBEDDING_MAX_INPUT_BYTES: \${EMBEDDING_MAX_INPUT_BYTES:-268435456}
+      EMBEDDING_MAX_OUTPUT_BYTES: \${EMBEDDING_MAX_OUTPUT_BYTES:-268435456}
+      EMBEDDING_MAX_ARTIFACTS: \${EMBEDDING_MAX_ARTIFACTS:-16}
+      EMBEDDING_MAX_PIXELS_PER_ARTIFACT: \${EMBEDDING_MAX_PIXELS_PER_ARTIFACT:-100000000}
       EMBEDDING_RUN_ENCRYPTION_SECRET: \${EMBEDDING_RUN_ENCRYPTION_SECRET:-}
       EMBEDDING_MAX_CONCURRENT_RUNS: \${EMBEDDING_MAX_CONCURRENT_RUNS:-1}
+      EMBEDDING_MAX_QUEUE_DEPTH: \${EMBEDDING_MAX_QUEUE_DEPTH:-0}
+      EMBEDDING_READINESS_TIMEOUT_SECONDS: \${EMBEDDING_READINESS_TIMEOUT_SECONDS:-5}
+      EMBEDDING_READINESS_TTL_SECONDS: \${EMBEDDING_READINESS_TTL_SECONDS:-60}
       EMBEDDING_RUN_TERMINAL_TTL_SECONDS: \${EMBEDDING_RUN_TERMINAL_TTL_SECONDS:-604800}
     volumes:
       - embedding-run-data:/app/data/embedding
@@ -3190,6 +3203,9 @@ EMBEDDING_RUN_ARTIFACT_URL=
 EMBEDDING_ADAPTER_URL=
 EMBEDDING_ADAPTER_TOKEN=
 EMBEDDING_DEPLOYMENT_KEY=
+EMBEDDING_DEPLOYMENT_IDENTITY=
+EMBEDDING_RELEASE_DIGEST=
+EMBEDDING_OFFERS_DIGEST=
 EMBEDDING_DEPLOYMENT_ALIAS=
 EMBEDDING_MODEL=
 EMBEDDING_MODEL_VERSION=
@@ -3197,8 +3213,16 @@ EMBEDDING_DIMENSIONS=
 # EMBEDDING_NORMALIZED=true
 # EMBEDDING_CAPABILITIES=embedding.text,embedding.image
 # EMBEDDING_MAX_UNITS=256
+# EMBEDDING_MAX_DURATION_SECONDS=600
+# EMBEDDING_MAX_INPUT_BYTES=268435456
+# EMBEDDING_MAX_OUTPUT_BYTES=268435456
+# EMBEDDING_MAX_ARTIFACTS=16
+# EMBEDDING_MAX_PIXELS_PER_ARTIFACT=100000000
 EMBEDDING_RUN_ENCRYPTION_SECRET=
 # EMBEDDING_MAX_CONCURRENT_RUNS=1
+# EMBEDDING_MAX_QUEUE_DEPTH=0
+# EMBEDDING_READINESS_TIMEOUT_SECONDS=5
+# EMBEDDING_READINESS_TTL_SECONDS=60
 # EMBEDDING_RUN_TERMINAL_TTL_SECONDS=604800
 QWEN_API_URL=
 QWEN_API_KEY=
@@ -7723,6 +7747,11 @@ var recipes = [
     id: "starter-0.5.2-to-0.6.0",
     from: "0.5.2",
     to: "0.6.0"
+  },
+  {
+    id: "starter-0.6.0-to-0.6.1",
+    from: "0.6.0",
+    to: "0.6.1"
   }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
@@ -8774,7 +8803,7 @@ async function mergeTextFile(base, ours, theirs) {
       }
       return { content: new TextEncoder().encode(result2.stdout) };
     }
-    if (result2.code === 1) {
+    if (result2.code > 0 && result2.code <= 127) {
       const resolved = resolveConservativeConflicts(result2.stdout);
       return resolved ? { content: new TextEncoder().encode(resolved) } : { conflict: "\u4E09\u65B9\u5408\u5E76\u5B58\u5728\u91CD\u53E0\u4FEE\u6539" };
     }
@@ -8957,6 +8986,11 @@ function mergeValue(base, ours, theirs, path2, conflicts) {
     if (files)
       return files;
   }
+  if (path2.startsWith("package.json.scripts.")) {
+    const script = mergeConjunctionScript(base, ours, theirs);
+    if (script !== undefined)
+      return script;
+  }
   if (isObject(base) && isObject(ours) && isObject(theirs)) {
     const output = {};
     const keys = new Set([
@@ -8983,6 +9017,52 @@ function mergeAppendOnlyStringSet(base, ours, theirs) {
   }
   return [...new Set([...ours, ...theirs])].sort();
 }
+function mergeConjunctionScript(base, ours, theirs) {
+  if (typeof base !== "string" || typeof ours !== "string" || typeof theirs !== "string") {
+    return;
+  }
+  const baseCommands = conjunctionCommands(base);
+  const oursCommands = conjunctionCommands(ours);
+  const theirsCommands = conjunctionCommands(theirs);
+  if (!baseCommands || !oursCommands || !theirsCommands || !unique(baseCommands) || !unique(oursCommands) || !unique(theirsCommands)) {
+    return;
+  }
+  const oursGaps = additionsByBaseGap(baseCommands, oursCommands);
+  const theirsGaps = additionsByBaseGap(baseCommands, theirsCommands);
+  if (!oursGaps || !theirsGaps)
+    return;
+  const merged = [];
+  for (let gap = 0;gap <= baseCommands.length; gap += 1) {
+    const oursAdded = oursGaps[gap] ?? [];
+    const theirsAdded = theirsGaps[gap] ?? [];
+    if (oursAdded.length && theirsAdded.length && !equal(oursAdded, theirsAdded)) {
+      return;
+    }
+    merged.push(...oursAdded.length ? oursAdded : theirsAdded);
+    if (gap < baseCommands.length)
+      merged.push(baseCommands[gap] ?? "");
+  }
+  return merged.join(" && ");
+}
+function conjunctionCommands(value) {
+  const commands = value.split(" && ");
+  return commands.length && commands.every((command) => command.length > 0) && commands.join(" && ") === value ? commands : undefined;
+}
+function additionsByBaseGap(base, branch) {
+  const gaps = Array.from({ length: base.length + 1 }, () => []);
+  let baseIndex = 0;
+  for (const command of branch) {
+    if (command === base[baseIndex]) {
+      baseIndex += 1;
+    } else {
+      gaps[baseIndex]?.push(command);
+    }
+  }
+  return baseIndex === base.length ? gaps : undefined;
+}
+function unique(values) {
+  return new Set(values).size === values.length;
+}
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "6149af754e862b43ca2fe344c354dcb07149bbc2",
-  "generatorVersion": "0.6.0",
+  "templateCommit": "a035c896c8821fe9a2f3ef3aca9d30b7ec1fb096",
+  "generatorVersion": "0.6.1",
   "modules": [
     {
       "name": "system",

package/template/apps/embedding-server/src/southwind_embedding_server/app.py

@@ -15,23 +15,33 @@ from .adapter import EmbeddingAdapter
 from .config import EmbeddingConfig
 from .contracts import EmbeddingRequest, EmbeddingResponse, ErrorResponse
 from .error import SafeEmbeddingError
+from .readiness import EmbeddingReadinessPort, EmbeddingReadinessProbe
 from .run_cipher import EmbeddingRunCipher
-from .run_service import EmbeddingRunService
+from .run_service import EmbeddingExecutionPort, EmbeddingRunService
 from .run_store import EmbeddingRunStore, RunConflictError
 
 
 def create_app(
     config: EmbeddingConfig,
-    adapter: EmbeddingAdapter | None = None,
+    adapter: EmbeddingExecutionPort | None = None,
+    readiness_probe: EmbeddingReadinessPort | None = None,
 ) -> FastAPI:
     app = FastAPI(title="Southwind Embedding Runtime", docs_url=None, redoc_url=None)
     runtime = adapter or EmbeddingAdapter(config)
+    readiness = readiness_probe or EmbeddingReadinessProbe(config)
     store = EmbeddingRunStore(
         config.run_store_path,
         EmbeddingRunCipher(config.run_encryption_secret),
         config.terminal_ttl_seconds,
     )
-    service = EmbeddingRunService(runtime, store, config.max_concurrent_runs)
+
+    async def admit(request: EmbeddingRequest) -> bool:
+        inspection = await readiness.inspect()
+        return readiness.supports(inspection, request)
+
+    service = EmbeddingRunService(
+        runtime, store, config.max_concurrent_runs, admit=admit
+    )
 
     @asynccontextmanager
     async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
@@ -47,24 +57,9 @@ def create_app(
 
     @app.get("/health/ready")
     async def ready(_: None = Depends(authorize)) -> JSONResponse:
-        if not await runtime.readiness():
-            return JSONResponse(
-                {"status": "unavailable", "capabilities": []},
-                status_code=503,
-            )
+        inspection = await readiness.inspect()
         return JSONResponse(
-            {
-                "status": "ready",
-                "capabilities": list(config.capabilities),
-                "limits": {"maxUnits": config.max_units},
-                "deployment": {
-                    "alias": config.deployment_alias,
-                    "model": config.model,
-                    "version": config.version,
-                    "dimensions": config.dimensions,
-                    "normalized": config.normalized,
-                },
-            }
+            inspection.snapshot, status_code=200 if inspection.ready else 503
         )
 
     @app.post("/api/embeddings")
@@ -75,6 +70,12 @@ def create_app(
     ) -> EmbeddingResponse:
         if not idempotency_key.strip() or len(idempotency_key) > 160:
             raise HTTPException(status_code=400, detail="INVALID_INPUT")
+        if not await admit(request):
+            raise SafeEmbeddingError(
+                "CAPABILITY_UNAVAILABLE",
+                "Embedding Runtime 当前没有匹配的原子 offer",
+                True,
+            )
         try:
             async with asyncio.timeout(request.limits.max_duration_seconds):
                 return await runtime.embed(request)
@@ -98,6 +99,12 @@ def create_app(
             or not valid_run_id(run_id)
         ):
             raise HTTPException(status_code=400, detail="INVALID_INPUT")
+        if not await admit(request):
+            raise SafeEmbeddingError(
+                "CAPABILITY_UNAVAILABLE",
+                "Embedding Runtime 当前没有匹配的原子 offer",
+                True,
+            )
         try:
             record = await service.start(request, idempotency_key, run_id)
         except RunConflictError:

package/template/apps/embedding-server/src/southwind_embedding_server/config.py

@@ -1,9 +1,17 @@
 from __future__ import annotations
 
 import ipaddress
+import re
 from dataclasses import dataclass
 from urllib.parse import urlparse
 
+_STABLE_KEY = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$")
+_DEPLOYMENT_IDENTITY = re.compile(
+    r"^windy-deployment-v1_[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-"
+    r"[89ab][a-f0-9]{3}-[a-f0-9]{12}$"
+)
+_DIGEST = re.compile(r"^sha256:[a-f0-9]{64}$")
+
 
 @dataclass(frozen=True)
 class EmbeddingConfig:
@@ -19,14 +27,35 @@ class EmbeddingConfig:
     dimensions: int
     normalized: bool
     capabilities: tuple[str, ...]
+    deployment_identity: str | None = None
+    release_digest: str | None = None
+    offers_digest: str | None = None
     max_units: int = 256
+    max_duration_seconds: int = 600
+    max_input_bytes: int = 268_435_456
+    max_output_bytes: int = 268_435_456
+    max_artifacts: int = 16
+    max_pixels_per_artifact: int = 100_000_000
     connect_timeout_seconds: float = 5
     request_timeout_seconds: float = 120
     run_store_path: str = "/app/data/embedding/runs.sqlite3"
     run_encryption_secret: str = ""
     max_concurrent_runs: int = 1
+    max_queue_depth: int = 0
+    readiness_timeout_seconds: float = 5
+    readiness_ttl_seconds: int = 60
     terminal_ttl_seconds: int = 7 * 24 * 60 * 60
 
+    @property
+    def readiness_configured(self) -> bool:
+        return bool(
+            self.adapter_url
+            and self.deployment_key
+            and self.deployment_identity
+            and self.release_digest
+            and self.offers_digest
+        )
+
     @classmethod
     def from_environment(cls, environment: dict[str, str]) -> EmbeddingConfig:
         artifact_url = environment.get(
@@ -53,8 +82,18 @@ class EmbeddingConfig:
             adapter_url=adapter_url,
             adapter_token=environment.get("EMBEDDING_ADAPTER_TOKEN", "").strip()
             or None,
-            deployment_key=environment.get("EMBEDDING_DEPLOYMENT_KEY", "").strip()
-            or None,
+            deployment_key=optional_match(
+                environment, "EMBEDDING_DEPLOYMENT_KEY", _STABLE_KEY
+            ),
+            deployment_identity=optional_match(
+                environment, "EMBEDDING_DEPLOYMENT_IDENTITY", _DEPLOYMENT_IDENTITY
+            ),
+            release_digest=optional_match(
+                environment, "EMBEDDING_RELEASE_DIGEST", _DIGEST
+            ),
+            offers_digest=optional_match(
+                environment, "EMBEDDING_OFFERS_DIGEST", _DIGEST
+            ),
             deployment_alias=required(environment, "EMBEDDING_DEPLOYMENT_ALIAS"),
             model=required(environment, "EMBEDDING_MODEL"),
             version=required(environment, "EMBEDDING_MODEL_VERSION"),
@@ -75,6 +114,19 @@ class EmbeddingConfig:
                 )
             ),
             max_units=positive_int(environment, "EMBEDDING_MAX_UNITS", 256),
+            max_duration_seconds=positive_int(
+                environment, "EMBEDDING_MAX_DURATION_SECONDS", 600
+            ),
+            max_input_bytes=positive_int(
+                environment, "EMBEDDING_MAX_INPUT_BYTES", 268_435_456
+            ),
+            max_output_bytes=positive_int(
+                environment, "EMBEDDING_MAX_OUTPUT_BYTES", 268_435_456
+            ),
+            max_artifacts=positive_int(environment, "EMBEDDING_MAX_ARTIFACTS", 16),
+            max_pixels_per_artifact=positive_int(
+                environment, "EMBEDDING_MAX_PIXELS_PER_ARTIFACT", 100_000_000
+            ),
             run_store_path=environment.get(
                 "EMBEDDING_RUN_STORE_PATH", "/app/data/embedding/runs.sqlite3"
             ).strip(),
@@ -84,6 +136,15 @@ class EmbeddingConfig:
             max_concurrent_runs=positive_int(
                 environment, "EMBEDDING_MAX_CONCURRENT_RUNS", 1
             ),
+            max_queue_depth=non_negative_int(
+                environment, "EMBEDDING_MAX_QUEUE_DEPTH", 0
+            ),
+            readiness_timeout_seconds=bounded_positive_float(
+                environment, "EMBEDDING_READINESS_TIMEOUT_SECONDS", 5, 30
+            ),
+            readiness_ttl_seconds=bounded_positive_int(
+                environment, "EMBEDDING_READINESS_TTL_SECONDS", 60, 300
+            ),
             terminal_ttl_seconds=positive_int(
                 environment, "EMBEDDING_RUN_TERMINAL_TTL_SECONDS", 7 * 24 * 60 * 60
             ),
@@ -120,8 +181,54 @@ def boolean(environment: dict[str, str], key: str, default: bool) -> bool:
 
 
 def required_capabilities(value: tuple[str, ...]) -> tuple[str, ...]:
-    if not value:
-        raise ValueError("EMBEDDING_CAPABILITIES 不能为空")
+    if (
+        not value
+        or len(value) != len(set(value))
+        or any(not _STABLE_KEY.fullmatch(item) for item in value)
+    ):
+        raise ValueError("EMBEDDING_CAPABILITIES 无效")
+    return value
+
+
+def optional_match(
+    environment: dict[str, str], key: str, pattern: re.Pattern[str]
+) -> str | None:
+    value = environment.get(key, "").strip()
+    if value and not pattern.fullmatch(value):
+        raise ValueError(f"{key} 格式无效")
+    return value or None
+
+
+def non_negative_int(environment: dict[str, str], key: str, default: int) -> int:
+    raw = environment.get(key, str(default)).strip()
+    try:
+        value = int(raw)
+    except ValueError:
+        raise ValueError(f"{key} 必须是非负整数") from None
+    if value < 0:
+        raise ValueError(f"{key} 必须是非负整数")
+    return value
+
+
+def bounded_positive_int(
+    environment: dict[str, str], key: str, default: int, maximum: int
+) -> int:
+    value = positive_int(environment, key, default)
+    if value > maximum:
+        raise ValueError(f"{key} 不能超过 {maximum}")
+    return value
+
+
+def bounded_positive_float(
+    environment: dict[str, str], key: str, default: float, maximum: float
+) -> float:
+    raw = environment.get(key, str(default)).strip()
+    try:
+        value = float(raw)
+    except ValueError:
+        raise ValueError(f"{key} 必须是正数") from None
+    if value <= 0 or value > maximum:
+        raise ValueError(f"{key} 必须大于 0 且不超过 {maximum:g}")
     return value
 
 

package/template/apps/embedding-server/src/southwind_embedding_server/contracts.py

@@ -66,6 +66,18 @@ class ProviderDataPolicy(CanonicalModel):
     envelope_fields: list[dict[str, JsonValue]]
 
 
+class ReadinessPinV1(CanonicalModel):
+    key: str = Field(pattern=r"^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$")
+    identity: str = Field(
+        pattern=(
+            r"^windy-deployment-v1_[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-"
+            r"[89ab][a-f0-9]{3}-[a-f0-9]{12}$"
+        )
+    )
+    release_digest: str = Field(pattern=r"^sha256:[a-f0-9]{64}$")
+    offers_digest: str = Field(pattern=r"^sha256:[a-f0-9]{64}$")
+
+
 class EmbeddingRequest(CanonicalModel):
     kind: Literal["embedding"]
     operation_key: str = Field(min_length=1)
@@ -77,6 +89,7 @@ class EmbeddingRequest(CanonicalModel):
     limits: RuntimeLimits
     provider_egress: ProviderEgress
     provider_data_policy: ProviderDataPolicy | None = None
+    readiness_pin: ReadinessPinV1 | None = None
 
 
 class EmbeddingVector(CanonicalModel):

package/template/apps/embedding-server/src/southwind_embedding_server/pin_cli.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+
+import httpx
+
+from .config import EmbeddingConfig
+from .readiness_contracts import (
+    AdapterEmbeddingReadinessV1,
+    compute_offers_digest,
+    compute_release_digest,
+    final_offers,
+)
+from .readiness_http import get_json
+
+
+async def compute_pins(
+    config: EmbeddingConfig,
+    transport: httpx.AsyncBaseTransport | None = None,
+) -> dict[str, str]:
+    if not config.deployment_key or not config.deployment_identity:
+        raise ValueError("Embedding deployment key/identity 缺失")
+    if not config.adapter_url:
+        raise ValueError("Embedding Adapter 未配置")
+    adapter = AdapterEmbeddingReadinessV1.model_validate(
+        await get_json(
+            f"{config.adapter_url.rstrip('/')}/v1/embedding/readiness",
+            config.adapter_token,
+            config.readiness_timeout_seconds,
+            transport,
+        )
+    )
+    deployment = adapter.deployment
+    if (
+        deployment.model != config.model
+        or deployment.version != config.version
+        or deployment.dimensions != config.dimensions
+        or deployment.normalized != config.normalized
+    ):
+        raise ValueError("Embedding Adapter deployment 漂移")
+    offers = final_offers(config, adapter)
+    return {
+        "deploymentKey": config.deployment_key,
+        "deploymentIdentity": config.deployment_identity,
+        "releaseDigest": compute_release_digest(adapter),
+        "offersDigest": compute_offers_digest(offers),
+    }
+
+
+async def main() -> None:
+    try:
+        pins = await compute_pins(EmbeddingConfig.from_environment(dict(os.environ)))
+    except Exception as error:
+        message = "Embedding readiness full probe 未通过，未写入 pins"
+        raise SystemExit(message) from error
+    print(json.dumps(pins, separators=(",", ":"), sort_keys=True))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())