create-windy 0.8.3 → 0.9.1

package/template/packages/shared/index.ts

@@ -35,3 +35,15 @@ export * from "./src/stable-key.js";
 export * from "./src/workflow.js";
 
 export * from "./src/license-console-capabilities.js";
+
+// @windy-module system.agent begin
+export * from "./src/agent-skills.js";
+// @windy-module system.agent end
+
+// @windy-module system.audit begin
+export * from "./src/diagnostics.js";
+// @windy-module system.audit end
+
+// @windy-module system.agent begin
+export * from "./src/agent-workflow-presets.js";
+// @windy-module system.agent end

package/template/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/shared",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/shared/src/agent-skills.ts

@@ -0,0 +1,68 @@
+/** DSH 技能是工作方法与文件包，不能授予业务权限或承载可执行授权。 */
+export type AgentSkillScope = "personal" | "department" | "tenant";
+export type AgentSkillOrigin = "builtin" | "shared";
+export type AgentSkillStatus = "published" | "disabled";
+export interface AgentSkillRequirement {
+  readonly toolKey: string;
+  readonly featureKey: string;
+  readonly permissionKey: string;
+}
+export interface AgentSkillFile {
+  readonly path: string;
+  readonly contentBase64: string;
+}
+export interface AgentSkillBundle {
+  readonly name: string;
+  readonly displayName: string;
+  readonly description: string;
+  readonly digest: string;
+  readonly files: readonly AgentSkillFile[];
+}
+export interface AgentSkillVersion {
+  readonly key: string;
+  readonly version: number;
+  readonly tenantId: string;
+  readonly ownerActorId: string;
+  readonly departmentId?: string;
+  readonly scope: AgentSkillScope;
+  readonly origin: AgentSkillOrigin;
+  readonly status: AgentSkillStatus;
+  readonly name: string;
+  readonly description: string;
+  readonly digest: string;
+  readonly requirements: readonly AgentSkillRequirement[];
+  readonly safetyConstraints: readonly string[];
+  readonly createdAt: string;
+  readonly createdBy: string;
+  readonly restoredFromVersion?: number;
+  readonly source: string;
+}
+export interface AgentSkillGovernanceItem {
+  readonly skill: AgentSkillVersion;
+  readonly available: boolean;
+  readonly governable: boolean;
+}
+export interface ImportAgentSkillRequest {
+  readonly format: "markdown" | "zip";
+  /** SKILL.md 正文，或 ZIP 的标准 base64。 */
+  readonly content: string;
+  readonly scope: AgentSkillScope;
+  readonly expectedVersion: number;
+  readonly requirements?: readonly AgentSkillRequirement[];
+  readonly safetyConstraints?: readonly string[];
+}
+export interface AgentSkillCommandRequest {
+  readonly expectedVersion: number;
+  readonly version?: number;
+}
+export interface PublishedAgentSkillBundle {
+  readonly skill: AgentSkillVersion;
+  readonly bundle: AgentSkillBundle;
+}
+
+export interface AgentSkillRuntimeBundle {
+  readonly key: string;
+  readonly version: number;
+  readonly digest: string;
+  readonly files: readonly AgentSkillFile[];
+}

package/template/packages/shared/src/agent-workflow-presets.ts

@@ -0,0 +1,26 @@
+import type { AgentWorkflowBudget } from "./agent-workflow-run.js";
+import type { AgentWorkflowNodeType } from "./agent-workflow-definition.js";
+
+export interface AgentWorkflowPresetSummary {
+  readonly key: string;
+  readonly moduleKey: string;
+  readonly label: string;
+  readonly description: string;
+  readonly workflowKey: string;
+  readonly version: string;
+  readonly budget: AgentWorkflowBudget;
+  readonly nodes: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly type: AgentWorkflowNodeType;
+  }[];
+  readonly availability: "available" | "unavailable";
+  readonly safeCode?: string;
+  readonly blockedReason?: string;
+  /** 由所属模块注册的业务入口；目录本身不发布或启动 Workflow。 */
+  readonly entry?: { readonly path: string; readonly label: string };
+}
+
+export interface AgentWorkflowPresetListResponse {
+  readonly items: readonly AgentWorkflowPresetSummary[];
+}

package/template/packages/shared/src/diagnostics.ts

@@ -0,0 +1,13 @@
+/** 可向授权运维人员公开的失败索引，不包含业务正文、异常堆栈或身份凭据。 */
+export interface DiagnosticRecord {
+  readonly diagnosticId: string;
+  readonly requestId: string;
+  readonly occurredAt: string;
+  readonly expiresAt: string;
+  readonly service: "server";
+  readonly stage: "http";
+  readonly method: string;
+  readonly route: string;
+  readonly statusCode: number;
+  readonly errorCode: string;
+}

package/template/packages/shared/src/rbac.ts

@@ -24,6 +24,7 @@ export type PermissionAction =
   | "reveal"
   | "approve"
   | "execute"
+  | "use"
   | "retry"
   | "manage";
 

package/template/apps/agent-server/install-python-dependencies.sh

@@ -1,92 +0,0 @@
-#!/bin/sh
-set -eu
-
-index_url="${WINDY_PYPI_INDEX_URL:-}"
-total_timeout_seconds="${WINDY_PYPI_TOTAL_TIMEOUT_SECONDS:-}"
-
-case "$index_url" in
-  http://* | https://*) ;;
-  *)
-    echo "Agent Server Python index 必须是 credential-free HTTP(S) URL" >&2
-    exit 64
-    ;;
-esac
-case "$index_url" in
-  *"@"* | *"?"* | *"#"*)
-    echo "Agent Server Python index 不得内嵌 credential、query 或 fragment" >&2
-    exit 64
-    ;;
-esac
-
-index_address="${index_url#*://}"
-index_host="${index_address%%/*}"
-case "$index_address" in
-  "" | *[!A-Za-z0-9._~:/%-]*)
-    echo "Agent Server Python index 含有不安全字符" >&2
-    exit 64
-    ;;
-esac
-case "$index_host" in
-  "" | *[!A-Za-z0-9.:-]*)
-    echo "Agent Server Python index host 无效" >&2
-    exit 64
-    ;;
-esac
-case "$total_timeout_seconds" in
-  "" | *[!0-9]*)
-    echo "WINDY_PYPI_TOTAL_TIMEOUT_SECONDS 必须是 1 到 600 的整数" >&2
-    exit 64
-    ;;
-esac
-if [ "$total_timeout_seconds" -lt 1 ] || [ "$total_timeout_seconds" -gt 600 ]; then
-  echo "WINDY_PYPI_TOTAL_TIMEOUT_SECONDS 必须是 1 到 600 的整数" >&2
-  exit 64
-fi
-
-trusted_host=""
-insecure_host=""
-case "$index_url" in
-  http://*)
-    trusted_host="$index_host"
-    insecure_host="$index_host"
-    ;;
-esac
-
-run_uv_network() {
-  operation="$1"
-  shift
-  if ! timeout --kill-after=5s "${total_timeout_seconds}s" env \
-    UV_DEFAULT_INDEX="$index_url" \
-    UV_INSECURE_HOST="$insecure_host" \
-    UV_CONCURRENT_DOWNLOADS=1 \
-    UV_HTTP_TIMEOUT=30 \
-    UV_HTTP_RETRIES=2 \
-    UV_NO_PROGRESS=1 \
-    sh -c 'attempt=1; while [ "$attempt" -le 3 ]; do "$@" && exit 0; if [ "$attempt" -lt 3 ]; then echo "[windy] Python 网络操作失败，2 秒后重试" >&2; sleep 2; fi; attempt=$((attempt + 1)); done; exit 1' windy-python "$@"; then
-    echo "Agent Server Python index 不可用或总时限已到：${operation}失败" >&2
-    exit 70
-  fi
-}
-
-case "${1:-}" in
-  install-uv)
-    if ! timeout --kill-after=5s "${total_timeout_seconds}s" env \
-      PIP_INDEX_URL="$index_url" \
-      PIP_TRUSTED_HOST="$trusted_host" \
-      pip install --no-cache-dir --timeout 30 --retries 2 uv==0.9.27; then
-      echo "Agent Server Python index 不可用或总时限已到：无法安装 uv" >&2
-      exit 70
-    fi
-    ;;
-  lock)
-    run_uv_network "lock index 刷新" uv lock
-    ;;
-  sync)
-    shift
-    run_uv_network "依赖同步" uv sync "$@"
-    ;;
-  *)
-    echo "未知的 Agent Server Python 安装阶段" >&2
-    exit 64
-    ;;
-esac

package/template/apps/agent-server/pyproject.toml

@@ -1,51 +0,0 @@
-[project]
-name = "southwind-agent-server"
-version = "0.1.0"
-description = "Southwind AI canonical Agent Runtime server"
-requires-python = ">=3.12,<3.13"
-dependencies = [
-  "cryptography==49.0.0",
-  "fastapi==0.139.2",
-  "httpx==0.28.1",
-  "jsonschema==4.26.0",
-  "opentelemetry-api==1.42.1",
-  "opentelemetry-exporter-otlp-proto-http==1.42.1",
-  "opentelemetry-sdk==1.42.1",
-  "pillow==12.3.0",
-  "psycopg[binary,pool]==3.3.4",
-  "pydantic==2.13.4",
-  "uvicorn==0.51.0",
-]
-
-[dependency-groups]
-dev = [
-  "mypy==2.3.0",
-  "pytest==9.1.1",
-  "pytest-asyncio==1.4.0",
-  "ruff==0.15.22",
-  "types-jsonschema==4.26.0.20260518",
-]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-pythonpath = [".", "src"]
-testpaths = ["tests"]
-
-[tool.ruff]
-line-length = 88
-target-version = "py312"
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "UP", "B", "ASYNC"]
-
-[tool.mypy]
-python_version = "3.12"
-strict = true
-files = ["src", "tests"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/southwind_agent_server"]

package/template/apps/agent-server/src/southwind_agent_server/__init__.py

@@ -1,5 +0,0 @@
-"""Southwind AI Agent Server."""
-
-from .app import create_app
-
-__all__ = ["create_app"]

package/template/apps/agent-server/src/southwind_agent_server/app.py

@@ -1,344 +0,0 @@
-from __future__ import annotations
-
-import os
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from typing import Annotated, cast
-
-from fastapi import FastAPI, Header, Query, Request
-from fastapi.exceptions import RequestValidationError
-from fastapi.responses import JSONResponse, StreamingResponse
-from pydantic import ValidationError
-
-from .artifact_input import ArtifactLoader
-from .client_completion_routes import install_client_completion_routes
-from .contracts import (
-    CancelRunRequest,
-    CancelRunResponse,
-    EvaluationResultRequest,
-    EvaluationResultResponse,
-    JsonValue,
-    RunResultResponse,
-    RunStatusResponse,
-    StartRunRequest,
-    StartRunResponse,
-)
-from .engine import AgentEngineAdapter, SafeEngineError
-from .engine_capacity import engine_capacity
-from .health_routes import install_health_routes
-from .http_helpers import (
-    authorized,
-    parse_cursor,
-    provider_governance_snapshot,
-    safe_error,
-)
-from .report_routes import create_report_router
-from .report_store import AgentRuntimeReportStore
-from .runtime_compatibility import (
-    OFFER_DIGEST_HEADER,
-    PROTOCOL_HEADER,
-    RuntimeCompatibilityError,
-    validate_runtime_compatibility_pin,
-)
-from .runtime_factory import (
-    default_engine,
-    default_report_store,
-    default_store,
-)
-from .service import AgentRunService
-from .service_errors import OperationNotFoundError, RunNotFoundError
-from .sqlite_store import RunStoreCapacityError
-from .sse import event_stream
-from .store import IdempotencyConflictError, ReleaseNotFoundError, RunStore
-from .telemetry import configure_telemetry
-from .vision_requirement import require_vision_readiness
-
-
-def create_app(
-    engine: AgentEngineAdapter | None = None,
-    *,
-    heartbeat_seconds: float = 15.0,
-    internal_token: str | None = None,
-    store: RunStore | None = None,
-    report_store: AgentRuntimeReportStore | None = None,
-) -> FastAPI:
-    configure_telemetry()
-    runtime_report_store = report_store or default_report_store()
-    runtime_engine = engine or default_engine(runtime_report_store)
-    capacity = engine_capacity(runtime_engine)
-    runtime = AgentRunService(
-        runtime_engine,
-        store or default_store(),
-        runtime_report_store,
-        (
-            ArtifactLoader(
-                os.environ.get(
-                    "AI_ARTIFACT_URL",
-                    "http://server:9747/api/internal/ai/artifacts",
-                ),
-                internal_token,
-            )
-            if internal_token
-            else None
-        ),
-        max_concurrent_runs=capacity.max_concurrent_runs,
-        max_queue_depth=capacity.max_queue_depth,
-    )
-
-    @asynccontextmanager
-    async def lifespan(_application: FastAPI) -> AsyncIterator[None]:
-        await runtime.recover()
-        try:
-            yield
-        finally:
-            await runtime.close()
-
-    application = FastAPI(
-        title="Southwind AI Agent Server",
-        version="0.1.0",
-        lifespan=lifespan,
-    )
-    application.include_router(
-        create_report_router(runtime_report_store, runtime.store, internal_token)
-    )
-
-    install_health_routes(application, runtime, runtime_engine, internal_token)
-    install_client_completion_routes(application, runtime_engine, internal_token)
-
-    @application.get("/health/provider-governance", response_model=None)
-    async def provider_governance_health(
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> dict[str, int | float | str | None] | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        health = getattr(runtime_engine, "governance_health", None)
-        if not health:
-            return safe_error(
-                503,
-                "RUNTIME_UNAVAILABLE",
-                "Provider 字段治理尚未配置",
-                True,
-            )
-        return provider_governance_snapshot(
-            cast(dict[str, int | float | str | None], health())
-        )
-
-    @application.exception_handler(OperationNotFoundError)
-    async def operation_not_found(
-        _request: Request,
-        _error: OperationNotFoundError,
-    ) -> JSONResponse:
-        return safe_error(404, "OPERATION_NOT_FOUND", "Agent Operation 不存在", False)
-
-    @application.exception_handler(RunNotFoundError)
-    async def run_not_found(
-        _request: Request,
-        _error: RunNotFoundError,
-    ) -> JSONResponse:
-        return safe_error(404, "RUN_CONFLICT", "Agent Run 不存在", False)
-
-    @application.exception_handler(IdempotencyConflictError)
-    async def idempotency_conflict(
-        _request: Request,
-        _error: IdempotencyConflictError,
-    ) -> JSONResponse:
-        return safe_error(409, "RUN_CONFLICT", "幂等键已用于其他请求", False)
-
-    @application.exception_handler(ReleaseNotFoundError)
-    async def release_not_found(
-        _request: Request,
-        _error: ReleaseNotFoundError,
-    ) -> JSONResponse:
-        return safe_error(404, "RUN_CONFLICT", "Agent Release 不存在", False)
-
-    @application.exception_handler(RunStoreCapacityError)
-    async def run_store_capacity(
-        _request: Request,
-        _error: RunStoreCapacityError,
-    ) -> JSONResponse:
-        return safe_error(
-            429,
-            "BUDGET_EXCEEDED",
-            "Agent Run 存储容量已满",
-            True,
-        )
-
-    @application.exception_handler(SafeEngineError)
-    async def safe_engine_error(
-        _request: Request,
-        error: SafeEngineError,
-    ) -> JSONResponse:
-        status = 403 if error.code == "FORBIDDEN" else 503
-        if error.code in {"INVALID_INPUT", "BUDGET_EXCEEDED"}:
-            status = 400
-        return safe_error(
-            status,
-            error.code,
-            error.safe_message,
-            error.retryable,
-        )
-
-    @application.exception_handler(ValidationError)
-    async def validation_error(
-        _request: Request,
-        _error: ValidationError,
-    ) -> JSONResponse:
-        return safe_error(400, "INVALID_INPUT", "请求格式无效", False)
-
-    @application.exception_handler(RequestValidationError)
-    async def request_validation_error(
-        _request: Request,
-        _error: RequestValidationError,
-    ) -> JSONResponse:
-        return safe_error(400, "INVALID_INPUT", "请求格式无效", False)
-
-    @application.post("/api/agent/runs", response_model=StartRunResponse)
-    async def start_run(
-        request: StartRunRequest,
-        idempotency_key: Annotated[str, Header(alias="Idempotency-Key")],
-        authorization: Annotated[str | None, Header()] = None,
-        runtime_protocol: Annotated[str | None, Header(alias=PROTOCOL_HEADER)] = None,
-        runtime_offer_digest: Annotated[
-            str | None, Header(alias=OFFER_DIGEST_HEADER)
-        ] = None,
-    ) -> StartRunResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        if not idempotency_key.strip():
-            return safe_error(400, "INVALID_INPUT", "幂等键不能为空", False)
-        try:
-            validate_runtime_compatibility_pin(
-                runtime_protocol,
-                runtime_offer_digest,
-                runtime_engine.engine_id,
-            )
-        except RuntimeCompatibilityError:
-            return safe_error(
-                409,
-                "RUNTIME_UNAVAILABLE",
-                "Agent Runtime compatibility pin 不匹配",
-                False,
-            )
-        try:
-            await require_vision_readiness(runtime_engine, request)
-        except SafeEngineError as error:
-            return safe_error(503, error.code, error.safe_message, error.retryable)
-        record = await runtime.start(
-            request,
-            idempotency_key,
-        )
-        return StartRunResponse(
-            run_id=record.run_id,
-            status=record.status,
-            events_url=f"/api/agent/runs/{record.run_id}/events",
-        )
-
-    @application.get(
-        "/api/agent/runs/{run_id}",
-        response_model=RunStatusResponse,
-    )
-    async def get_run_status(
-        run_id: str,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> RunStatusResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        record = await runtime.get(run_id)
-        terminal_event = cast(
-            dict[str, JsonValue] | None,
-            record.events[-1] if record.terminal and record.events else None,
-        )
-        return RunStatusResponse(
-            run_id=record.run_id,
-            status=record.status,
-            last_sequence=len(record.events),
-            terminal_event=terminal_event,
-        )
-
-    @application.get("/api/agent/runs/{run_id}/events", response_model=None)
-    async def get_events(
-        run_id: str,
-        after: Annotated[int | None, Query(ge=0)] = None,
-        last_event_id: Annotated[str | None, Header(alias="Last-Event-ID")] = None,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> StreamingResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        await runtime.get(run_id)
-        try:
-            cursor = parse_cursor(after, last_event_id)
-        except ValueError:
-            return safe_error(400, "INVALID_INPUT", "事件游标无效", False)
-        return StreamingResponse(
-            event_stream(runtime, run_id, cursor, heartbeat_seconds),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache, no-transform",
-                "X-Accel-Buffering": "no",
-            },
-        )
-
-    @application.get(
-        "/api/agent/runs/{run_id}/result",
-        response_model=RunResultResponse,
-    )
-    async def get_result(
-        run_id: str,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> RunResultResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        record = await runtime.get(run_id)
-        if record.status == "completed":
-            return RunResultResponse(
-                run_id=record.run_id,
-                status="completed",
-                output=record.output,
-            )
-        if record.status == "cancelled":
-            return safe_error(409, "RUN_CANCELLED", "Agent Run 已取消", False)
-        if record.status == "failed":
-            return safe_error(409, "RUNTIME_UNAVAILABLE", "Agent Run 执行失败", True)
-        return safe_error(409, "RUN_CONFLICT", "Agent Run 尚未完成", True)
-
-    @application.post(
-        "/api/agent/runs/{run_id}/cancel",
-        response_model=CancelRunResponse,
-    )
-    async def cancel_run(
-        run_id: str,
-        _request: CancelRunRequest,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> CancelRunResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        record = await runtime.cancel(run_id)
-        return CancelRunResponse(run_id=record.run_id, status=record.status)
-
-    @application.post(
-        "/api/agent/evaluations",
-        response_model=EvaluationResultResponse,
-    )
-    async def record_evaluation(
-        request: EvaluationResultRequest,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> EvaluationResultResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        evaluation_id = await runtime.record_evaluation(
-            request.release_id,
-            request.evaluation_set_key,
-            request.evaluation_set_version,
-            request.metrics,
-        )
-        return EvaluationResultResponse(
-            evaluation_id=evaluation_id,
-            release_id=request.release_id,
-        )
-
-    application.state.run_service = runtime
-    application.state.report_store = runtime_report_store
-    return application
-
-
-app = create_app(internal_token=os.environ.get("AGENT_SERVER_INTERNAL_TOKEN"))

package/template/apps/agent-server/src/southwind_agent_server/approval_resolution.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from .store import RunRecord, RunStore
-
-
-async def resolve_pending_approval(
-    store: RunStore,
-    record: RunRecord,
-    outcome: str,
-) -> None:
-    pending: dict[str, object] | None = None
-    for event in record.events:
-        if event.get("type") == "approval.required":
-            pending = event
-        elif event.get("type") == "approval.resolved":
-            pending = None
-    if not pending:
-        return
-    work_item_id = pending.get("workItemId")
-    tool_call_id = pending.get("toolCallId")
-    if isinstance(work_item_id, str) and isinstance(tool_call_id, str):
-        await store.append(
-            record.run_id,
-            "approval.resolved",
-            {
-                "workItemId": work_item_id,
-                "toolCallId": tool_call_id,
-                "outcome": outcome,
-            },
-        )