create-windy 0.6.12 → 0.6.15

package/template/apps/server/src/agent-workflow/production-delegation-scope.ts

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { hashAuthorizationScope } from "../data-access/scope-snapshot.js";
+import { canonicalJson } from "./canonical-json.js";
+import type { DelegationScopeSubsetAuthorizerPort } from "./delegation-policy.js";
+
+export class SameScopeDelegationAuthorizer implements DelegationScopeSubsetAuthorizerPort {
+  async proveSubset(
+    input: Parameters<DelegationScopeSubsetAuthorizerPort["proveSubset"]>[0],
+  ) {
+    const pinnedParentScopeDigest = scopeDigest(input.pinnedParentScope);
+    const currentParentScopeDigest = scopeDigest(input.currentParentScope);
+    if (
+      input.signal.aborted ||
+      input.request.policyKey !== "workflow.scope.same-scope" ||
+      input.request.resourceType !== "authorization-scope" ||
+      input.request.objectIds.length !== 1 ||
+      input.request.objectIds[0] !== pinnedParentScopeDigest ||
+      pinnedParentScopeDigest !== currentParentScopeDigest ||
+      canonicalJson(input.pinnedParentScope) !==
+        canonicalJson(input.currentParentScope) ||
+      input.pinnedParentScope.actorId !== input.actorId
+    ) {
+      throw new Error("DELEGATION_SCOPE_SUBSET_UNPROVEN");
+    }
+    const checkedAt = new Date().toISOString();
+    const scopePolicyDigest = digest({
+      key: input.request.policyKey,
+      version: 1,
+    });
+    return {
+      proofId: digest({
+        actorId: input.actorId,
+        pinnedParentScopeDigest,
+        currentParentScopeDigest,
+        request: input.request,
+        checkedAt,
+      }),
+      policyKey: input.request.policyKey,
+      resourceType: input.request.resourceType,
+      objectIds: [...input.request.objectIds],
+      pinnedParentScopeDigest,
+      currentParentScopeDigest,
+      childScopeSnapshot: structuredClone(input.currentParentScope),
+      childScopeDigest: currentParentScopeDigest,
+      scopePolicyDigest,
+      checkedAt,
+      expiresAt: new Date(Date.parse(checkedAt) + 60_000).toISOString(),
+    };
+  }
+}
+
+function scopeDigest(snapshot: Parameters<typeof hashAuthorizationScope>[0]) {
+  return `sha256:${hashAuthorizationScope(snapshot)}`;
+}
+
+function digest(value: unknown) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}

package/template/apps/server/src/agent-workflow/production-node-policies.ts

@@ -0,0 +1,62 @@
+import {
+  AgentWorkflowConditionRegistry,
+  type AgentWorkflowConditionEvaluator,
+} from "./condition-node-adapter.js";
+import {
+  AgentWorkflowWorkspacePolicyRegistry,
+  type AgentWorkflowWorkspacePolicyDefinition,
+} from "./workspace-policy.js";
+
+export function createProductionWorkflowConditions() {
+  return new AgentWorkflowConditionRegistry([
+    evaluator("workflow.condition.branch", ({ receipts }) => {
+      const result = receipts.at(-1)?.smallResult;
+      return record(result) && typeof result.branch === "string"
+        ? result.branch
+        : undefined;
+    }),
+    evaluator("workflow.condition.boolean", ({ receipts }) => {
+      const result = receipts.at(-1)?.smallResult;
+      const value =
+        typeof result === "boolean"
+          ? result
+          : record(result) && typeof result.value === "boolean"
+            ? result.value
+            : undefined;
+      return value === undefined ? undefined : String(value);
+    }),
+    evaluator("workflow.condition.artifact", ({ receipts }) =>
+      receipts.some(({ artifactIds }) => artifactIds.length)
+        ? "present"
+        : "absent",
+    ),
+  ]);
+}
+
+export function createProductionWorkspacePolicies(
+  definitions: readonly AgentWorkflowWorkspacePolicyDefinition[] = [],
+) {
+  return new AgentWorkflowWorkspacePolicyRegistry(definitions);
+}
+
+function evaluator(
+  conditionKey: string,
+  select: (
+    input: Parameters<AgentWorkflowConditionEvaluator["evaluate"]>[0],
+  ) => string | undefined,
+): AgentWorkflowConditionEvaluator {
+  return {
+    conditionKey,
+    evaluate(input) {
+      const selected = select(input);
+      if (!selected || !input.allowedBranches.includes(selected)) {
+        throw new Error("WORKFLOW_CONDITION_UNRESOLVED");
+      }
+      return selected;
+    },
+  };
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/template/apps/server/src/agent-workflow/project-launch-authority.contract.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test";
+import type { ModuleClientAgentWorkflowArtifactProjectBinding } from "@southwind-ai/server-sdk";
+import { ClientAgentWorkflowArtifactBindingRegistry } from "../agent/client-workflow-artifact/binding-registry.js";
+import { ProjectAgentWorkflowLaunchAuthority } from "./project-launch-authority.js";
+
+const binding = {
+  workflowKey: "analysis.full-case",
+  nodeId: "client-artifact",
+  operationKey: "analysis.page-agent",
+  releaseDigest: `sha256:${"d".repeat(64)}`,
+  scopeContainmentContractVersion: 1,
+  terminalResultAuthority: {
+    version: "sharp.result.v1",
+    digest: `sha256:${"e".repeat(64)}`,
+    async canonicalize({ proposedResult }) {
+      return proposedResult;
+    },
+  },
+  clientTaskAuthority: {
+    version: "sharp.task.v1",
+    digest: `sha256:${"f".repeat(64)}`,
+    async build({ workflowInput }) {
+      return { taskKey: "sharp.full-case", input: workflowInput };
+    },
+  },
+  launchAuthority: {
+    version: "sharp.launch.v1",
+    digest: `sha256:${"a".repeat(64)}`,
+    async authorizeRelease() {},
+    async authorizeRun({ currentAuthorizationScope }) {
+      return {
+        authorizationScope: currentAuthorizationScope,
+      };
+    },
+  },
+  artifact: {
+    kind: "analysis",
+    contentType: "application/json",
+    filename: "analysis.json",
+    retentionPolicyKey: "case-analysis",
+    maxByteSize: 65_536,
+  },
+} satisfies ModuleClientAgentWorkflowArtifactProjectBinding;
+
+test("generic command 对 project-protected Workflow 始终隐藏", () => {
+  const authority = new ProjectAgentWorkflowLaunchAuthority(
+    new ClientAgentWorkflowArtifactBindingRegistry([binding]),
+  );
+  expect(() => authority.requireDirect(binding.workflowKey)).toThrow(
+    "RELEASE_NOT_FOUND",
+  );
+  expect(() => authority.requireDirect("analysis.direct")).not.toThrow();
+});

package/template/apps/server/src/agent-workflow/project-launch-authority.ts

@@ -0,0 +1,92 @@
+import type {
+  AgentWorkflowArtifactRef,
+  AgentWorkflowDefinition,
+  AgentWorkflowRelease,
+  AgentWorkflowReleaseCoordinates,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { authorizationScopeContains } from "../data-access/scope-containment.js";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import { restoreServerScopeContext } from "../data-access/context.js";
+import type { RequestGuardContext } from "../guards.js";
+import { ClientAgentWorkflowArtifactBindingRegistry } from "../agent/client-workflow-artifact/binding-registry.js";
+import { AgentWorkflowCommandError } from "./command-error.js";
+
+export class ProjectAgentWorkflowLaunchAuthority {
+  constructor(
+    private readonly bindings: ClientAgentWorkflowArtifactBindingRegistry,
+  ) {}
+
+  requireDirect(workflowKey: string) {
+    if (this.bindings.findWorkflow(workflowKey)) throw hidden();
+  }
+
+  async authorizeRelease(input: {
+    definition: AgentWorkflowDefinition;
+    coordinates: AgentWorkflowReleaseCoordinates;
+    actorId: string;
+    releaseDigest: string;
+    signal: AbortSignal;
+  }) {
+    const binding = this.requireBinding(
+      input.definition.workflowKey,
+      input.releaseDigest,
+    );
+    try {
+      await binding.launchAuthority.authorizeRelease(input);
+    } catch {
+      throw hidden();
+    }
+  }
+
+  async authorizeRun(input: {
+    release: AgentWorkflowRelease;
+    workflowInput: JsonValue;
+    inputArtifacts: readonly AgentWorkflowArtifactRef[];
+    context: RequestGuardContext;
+    signal: AbortSignal;
+  }): Promise<RequestGuardContext> {
+    const binding = this.requireBinding(
+      input.release.definition.workflowKey,
+      input.release.releaseDigest,
+    );
+    try {
+      const current = captureAuthorizationScope(
+        input.context.actor.scopeContext,
+      ).snapshot;
+      const decision = await binding.launchAuthority.authorizeRun({
+        releaseId: input.release.releaseId,
+        releaseDigest: input.release.releaseDigest,
+        workflowInput: input.workflowInput,
+        inputArtifacts: input.inputArtifacts,
+        actorId: input.context.actor.id,
+        currentAuthorizationScope: structuredClone(current),
+        signal: input.signal,
+      });
+      if (!authorizationScopeContains(current, decision.authorizationScope)) {
+        throw hidden();
+      }
+      const scope = restoreServerScopeContext(decision.authorizationScope);
+      return {
+        ...input.context,
+        actor: {
+          ...input.context.actor,
+          dataAccess: scope,
+          scopeContext: scope,
+        },
+      };
+    } catch {
+      throw hidden();
+    }
+  }
+
+  private requireBinding(workflowKey: string, releaseDigest: string) {
+    const binding = this.bindings.findWorkflow(workflowKey);
+    if (!binding || binding.releaseDigest !== releaseDigest) throw hidden();
+    return binding;
+  }
+}
+
+function hidden() {
+  return new AgentWorkflowCommandError("RELEASE_NOT_FOUND", 404);
+}

package/template/apps/server/src/agent-workflow/query-service.ts

@@ -0,0 +1,198 @@
+import type {
+  AgentWorkflowNodeRun,
+  AgentWorkflowRelease,
+  AgentWorkflowRun,
+} from "@southwind-ai/shared";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import type { RequestGuardContext } from "../guards.js";
+import type {
+  AgentWorkflowRepository,
+  AgentWorkflowRunSnapshot,
+} from "./repository.js";
+
+export class AgentWorkflowQueryService {
+  constructor(private readonly repository: AgentWorkflowRepository) {}
+
+  async list(context: RequestGuardContext, limit = 100) {
+    const access = currentAccess(context);
+    const records = await this.repository.listRunsForActor(
+      access.tenantId,
+      access.actorId,
+      access.scopeDigest,
+      Math.min(Math.max(limit, 1), 200),
+    );
+    const items = await Promise.all(
+      records.map(async ({ run }) => {
+        const [release, nodes] = await Promise.all([
+          this.requireRelease(run.releaseId),
+          this.repository.listNodeRuns(run.runId),
+        ]);
+        return runSummary(run, release, nodes);
+      }),
+    );
+    return { items };
+  }
+
+  async detail(runId: string, context: RequestGuardContext) {
+    const snapshot = await this.requireAuthorizedSnapshot(runId, context);
+    const release = await this.requireRelease(snapshot.run.releaseId);
+    const latest = latestNodeRuns(snapshot.nodeRuns);
+    return {
+      run: {
+        ...runSummary(snapshot.run, release, latest),
+        actorId: snapshot.run.actorId,
+        scopeDigest: snapshot.run.scopeDigest,
+        authorizationSnapshotDigest: snapshot.run.authorizationSnapshotDigest,
+        toolPolicyDigest: snapshot.run.toolPolicyDigest,
+        workspacePolicyDigest: snapshot.run.workspacePolicyDigest,
+        executionPolicyDigest: snapshot.run.executionPolicyDigest,
+        budget: structuredClone(snapshot.run.budget),
+        usage: structuredClone(snapshot.run.usage),
+        deadlineAt: snapshot.run.deadlineAt,
+      },
+      release: {
+        releaseId: release.releaseId,
+        releaseDigest: release.releaseDigest,
+        ...structuredClone(release.coordinates),
+      },
+      nodes: latest.map((node) => projectNode(node, release)),
+      edges: structuredClone(release.definition.edges),
+    };
+  }
+
+  async events(
+    runId: string,
+    context: RequestGuardContext,
+    afterSequence: number,
+    limit: number,
+  ) {
+    await this.requireAuthorizedSnapshot(runId, context);
+    return {
+      items: await this.repository.readEvents({
+        runId,
+        afterSequence,
+        limit,
+      }),
+    };
+  }
+
+  async release(releaseId: string) {
+    return this.requireRelease(releaseId);
+  }
+
+  async requireAuthorizedSnapshot(
+    runId: string,
+    context: RequestGuardContext,
+  ): Promise<AgentWorkflowRunSnapshot> {
+    const snapshot = await this.repository.getSnapshot(runId);
+    if (!snapshot) throw new AgentWorkflowQueryError("RUN_NOT_FOUND", 404);
+    const access = currentAccess(context);
+    if (
+      snapshot.run.tenantId !== access.tenantId ||
+      snapshot.run.actorId !== access.actorId ||
+      snapshot.run.scopeDigest !== access.scopeDigest
+    ) {
+      throw new AgentWorkflowQueryError("RUN_FORBIDDEN", 403);
+    }
+    return snapshot;
+  }
+
+  private async requireRelease(releaseId: string) {
+    const release = await this.repository.getRelease(releaseId);
+    if (!release) throw new AgentWorkflowQueryError("RELEASE_NOT_FOUND", 404);
+    return release;
+  }
+}
+
+function runSummary(
+  run: AgentWorkflowRun,
+  release: AgentWorkflowRelease,
+  nodeRuns: readonly AgentWorkflowNodeRun[],
+) {
+  return {
+    runId: run.runId,
+    workflowKey: release.definition.workflowKey,
+    workflowLabel: release.definition.label,
+    workflowVersion: release.definition.version,
+    releaseId: release.releaseId,
+    releaseDigest: release.releaseDigest,
+    status: run.status,
+    currentNodeCount: new Set(nodeRuns.map(({ nodeId }) => nodeId)).size,
+    totalNodeCount: release.definition.nodes.length,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+    ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
+    ...(run.safeErrorCode ? { safeErrorCode: run.safeErrorCode } : {}),
+  };
+}
+
+function projectNode(
+  nodeRun: AgentWorkflowNodeRun,
+  release: AgentWorkflowRelease,
+) {
+  const node = release.definition.nodes.find(({ id }) => id === nodeRun.nodeId);
+  if (!node || node.type !== nodeRun.nodeType) {
+    throw new AgentWorkflowQueryError("RUN_DEFINITION_MISMATCH", 409);
+  }
+  return {
+    nodeRunId: nodeRun.nodeRunId,
+    nodeId: nodeRun.nodeId,
+    label: node.label,
+    type: nodeRun.nodeType,
+    status: nodeRun.status,
+    attempt: nodeRun.attempt,
+    maxAttempts: nodeRun.maxAttempts,
+    ...(nodeRun.startedAt ? { startedAt: nodeRun.startedAt } : {}),
+    ...(nodeRun.finishedAt ? { finishedAt: nodeRun.finishedAt } : {}),
+    ...(nodeRun.safeErrorCode ? { safeErrorCode: nodeRun.safeErrorCode } : {}),
+    ...(nodeRun.resultReceipt
+      ? {
+          resultReceipt: {
+            receiptId: nodeRun.resultReceipt.receiptId,
+            resultDigest: nodeRun.resultReceipt.resultDigest,
+            ...(nodeRun.resultReceipt.selectedBranch
+              ? { selectedBranch: nodeRun.resultReceipt.selectedBranch }
+              : {}),
+            artifactIds: [...nodeRun.resultReceipt.artifactIds],
+            recordedAt: nodeRun.resultReceipt.recordedAt,
+          },
+        }
+      : {}),
+    inputArtifacts: structuredClone(nodeRun.inputArtifacts),
+    outputArtifacts: structuredClone(nodeRun.outputArtifacts),
+  };
+}
+
+function latestNodeRuns(nodeRuns: readonly AgentWorkflowNodeRun[]) {
+  const latest = new Map<string, AgentWorkflowNodeRun>();
+  for (const nodeRun of nodeRuns) {
+    const current = latest.get(nodeRun.nodeId);
+    if (!current || current.attempt < nodeRun.attempt) {
+      latest.set(nodeRun.nodeId, nodeRun);
+    }
+  }
+  return [...latest.values()];
+}
+
+function currentAccess(context: RequestGuardContext) {
+  const scope = captureAuthorizationScope(context.actor.scopeContext);
+  return {
+    tenantId: scope.snapshot.tenantId,
+    actorId: context.actor.id,
+    scopeDigest: `sha256:${scope.hash}`,
+  };
+}
+
+export class AgentWorkflowQueryError extends Error {
+  constructor(
+    readonly code:
+      | "RUN_NOT_FOUND"
+      | "RUN_FORBIDDEN"
+      | "RELEASE_NOT_FOUND"
+      | "RUN_DEFINITION_MISMATCH",
+    readonly status: 403 | 404 | 409,
+  ) {
+    super(code);
+    this.name = "AgentWorkflowQueryError";
+  }
+}

package/template/apps/server/src/agent-workflow/release.ts

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import type {
+  AgentWorkflowDefinition,
+  AgentWorkflowRelease,
+  AgentWorkflowReleaseCoordinates,
+} from "@southwind-ai/shared";
+import {
+  AgentWorkflowDefinitionError,
+  validateAgentWorkflowDefinition,
+} from "./definition-validation.js";
+import { canonicalJson } from "./canonical-json.js";
+
+export interface PublishAgentWorkflowReleaseInput {
+  readonly definition: AgentWorkflowDefinition;
+  readonly coordinates: AgentWorkflowReleaseCoordinates;
+  readonly publishedBy: string;
+  readonly publishedAt: string;
+}
+
+export function agentWorkflowDefinitionDigest(
+  definition: AgentWorkflowDefinition,
+): string {
+  return digest(validateAgentWorkflowDefinition(definition));
+}
+
+export function buildAgentWorkflowRelease(
+  input: PublishAgentWorkflowReleaseInput,
+): AgentWorkflowRelease {
+  const definition = validateAgentWorkflowDefinition(input.definition);
+  assertCoordinates(input.coordinates);
+  if (!validText(input.publishedBy, 64) || !validTimestamp(input.publishedAt)) {
+    throw new AgentWorkflowDefinitionError(
+      "DEFINITION_INVALID",
+      "Workflow Release 发布身份或时间无效",
+    );
+  }
+  const definitionDigest = digest(definition);
+  const definitionId = `workflow_definition_${digest({
+    workflowKey: definition.workflowKey,
+    version: definition.version,
+  }).slice("sha256:".length, 56)}`;
+  const releaseDigest = digest({
+    definitionDigest,
+    coordinates: input.coordinates,
+  });
+  const releaseId = `workflow_release_${releaseDigest.slice("sha256:".length, 56)}`;
+  return {
+    releaseId,
+    releaseDigest,
+    definitionId,
+    definitionDigest,
+    definition,
+    coordinates: structuredClone(input.coordinates),
+    publishedBy: input.publishedBy,
+    publishedAt: input.publishedAt,
+  };
+}
+
+export function sameAgentWorkflowRelease(
+  left: AgentWorkflowRelease,
+  right: AgentWorkflowRelease,
+) {
+  return (
+    left.releaseId === right.releaseId &&
+    left.releaseDigest === right.releaseDigest &&
+    left.definitionId === right.definitionId &&
+    left.definitionDigest === right.definitionDigest &&
+    canonicalJson(left.definition) === canonicalJson(right.definition) &&
+    canonicalJson(left.coordinates) === canonicalJson(right.coordinates)
+  );
+}
+
+function assertCoordinates(coordinates: AgentWorkflowReleaseCoordinates) {
+  if (
+    Object.values(coordinates).some(
+      (value) => typeof value !== "string" || !validText(value, 200),
+    )
+  ) {
+    throw new AgentWorkflowDefinitionError(
+      "DEFINITION_INVALID",
+      "Workflow Release Coordinates 无效",
+    );
+  }
+}
+
+function validText(value: string, maximum: number) {
+  return value.trim() === value && value.length > 0 && value.length <= maximum;
+}
+
+function validTimestamp(value: string) {
+  return Number.isFinite(Date.parse(value));
+}
+
+function digest(value: unknown): string {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}