create-windy 0.6.11 → 0.6.14

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/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")}`;
+}

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

@@ -0,0 +1,157 @@
+import type {
+  AgentWorkflowEventData,
+  AgentWorkflowEventEnvelope,
+  AgentWorkflowNodeRun,
+  AgentWorkflowRelease,
+  AgentWorkflowRun,
+  AgentWorkflowSideEffectCommand,
+  AgentWorkflowBudget,
+} from "@southwind-ai/shared";
+
+export interface PendingAgentWorkflowEvent {
+  readonly eventId: string;
+  readonly occurredAt: string;
+  readonly causationEventId?: string;
+  readonly parentEventId?: string;
+  readonly childWorkflowRunId?: string;
+  readonly data: AgentWorkflowEventData;
+}
+
+export interface AgentWorkflowRunRecord {
+  readonly run: AgentWorkflowRun;
+  readonly idempotencyKey: string;
+  readonly headSequence: number;
+  readonly recoveryCount: number;
+}
+
+export interface AgentWorkflowRunSnapshot extends AgentWorkflowRunRecord {
+  readonly nodeRuns: readonly AgentWorkflowNodeRun[];
+  readonly sideEffects: readonly AgentWorkflowSideEffectCommand[];
+}
+
+export interface PublishAgentWorkflowReleaseResult {
+  readonly release: AgentWorkflowRelease;
+  readonly created: boolean;
+}
+
+export interface CreateAgentWorkflowRunInput {
+  readonly idempotencyKey: string;
+  readonly run: AgentWorkflowRun;
+  readonly initialNodeRun: AgentWorkflowNodeRun;
+  readonly event: PendingAgentWorkflowEvent;
+}
+
+export interface AgentWorkflowRunMutation {
+  readonly runId: string;
+  readonly expectedSequence: number;
+  readonly runUpdate?: {
+    readonly expectedVersion: number;
+    readonly value: AgentWorkflowRun;
+  };
+  readonly nodeUpdates?: readonly {
+    readonly expectedVersion: number;
+    readonly value: AgentWorkflowNodeRun;
+  }[];
+  readonly nodeInserts?: readonly AgentWorkflowNodeRun[];
+  readonly recovery?: {
+    readonly expectedCount: number;
+    readonly nextCount: number;
+  };
+  readonly events: readonly PendingAgentWorkflowEvent[];
+}
+
+export interface AgentWorkflowMutationResult {
+  readonly record: AgentWorkflowRunRecord;
+  readonly events: readonly AgentWorkflowEventEnvelope[];
+  readonly replayed: boolean;
+}
+
+export interface AgentWorkflowEventReadInput {
+  readonly runId: string;
+  readonly afterSequence: number;
+  readonly limit: number;
+}
+
+export interface AgentWorkflowRecoveryAdmissionInput {
+  readonly runId: string;
+  readonly expectedSequence: number;
+  readonly expectedRecoveryCount: number;
+  readonly actorId: string;
+  readonly scopeDigest: string;
+  readonly authorizationSnapshotDigest: string;
+  readonly toolPolicyDigest: string;
+  readonly workspacePolicyDigest: string;
+  readonly executionPolicyDigest: string;
+  readonly event: PendingAgentWorkflowEvent;
+}
+
+export interface AgentWorkflowRecoveryAdmissionResult extends AgentWorkflowMutationResult {
+  readonly remainingBudget: AgentWorkflowBudget;
+}
+
+/**
+ * Mutations are atomic. Run/Node versions and event sequence are CAS values;
+ * eventId makes retry of an already committed mutation safe.
+ */
+export interface AgentWorkflowRepository {
+  publishRelease(
+    release: AgentWorkflowRelease,
+  ): Promise<PublishAgentWorkflowReleaseResult>;
+  getRelease(releaseId: string): Promise<AgentWorkflowRelease | undefined>;
+  findRelease(
+    workflowKey: string,
+    version: string,
+  ): Promise<AgentWorkflowRelease | undefined>;
+  createRun(
+    input: CreateAgentWorkflowRunInput,
+  ): Promise<AgentWorkflowMutationResult>;
+  getRun(runId: string): Promise<AgentWorkflowRunRecord | undefined>;
+  listRunsForActor(
+    tenantId: string,
+    actorId: string,
+    scopeDigest: string,
+    limit: number,
+  ): Promise<readonly AgentWorkflowRunRecord[]>;
+  getSnapshot(runId: string): Promise<AgentWorkflowRunSnapshot | undefined>;
+  getNodeRun(nodeRunId: string): Promise<AgentWorkflowNodeRun | undefined>;
+  listNodeRuns(runId: string): Promise<readonly AgentWorkflowNodeRun[]>;
+  readEvents(
+    input: AgentWorkflowEventReadInput,
+  ): Promise<readonly AgentWorkflowEventEnvelope[]>;
+  findEvent(eventId: string): Promise<AgentWorkflowEventEnvelope | undefined>;
+  commit(input: AgentWorkflowRunMutation): Promise<AgentWorkflowMutationResult>;
+  admitRecovery(
+    input: AgentWorkflowRecoveryAdmissionInput,
+  ): Promise<AgentWorkflowRecoveryAdmissionResult>;
+  prepareSideEffect(
+    command: AgentWorkflowSideEffectCommand,
+  ): Promise<{ command: AgentWorkflowSideEffectCommand; created: boolean }>;
+  getSideEffect(
+    commandId: string,
+  ): Promise<AgentWorkflowSideEffectCommand | undefined>;
+  listSideEffects(
+    runId: string,
+  ): Promise<readonly AgentWorkflowSideEffectCommand[]>;
+  updateSideEffect(
+    command: AgentWorkflowSideEffectCommand,
+    expectedVersion: number,
+  ): Promise<AgentWorkflowSideEffectCommand>;
+}
+
+export type AgentWorkflowRepositoryConflictCode =
+  | "RELEASE_IMMUTABLE_CONFLICT"
+  | "RUN_IDEMPOTENCY_CONFLICT"
+  | "RUN_NOT_FOUND"
+  | "VERSION_CONFLICT"
+  | "SEQUENCE_CONFLICT"
+  | "EVENT_ID_CONFLICT"
+  | "NODE_RUN_CONFLICT"
+  | "SIDE_EFFECT_CONFLICT"
+  | "RECOVERY_ADMISSION_REJECTED";
+
+export class AgentWorkflowRepositoryConflict extends Error {
+  constructor(readonly code: AgentWorkflowRepositoryConflictCode) {
+    super(code);
+    this.name = "AgentWorkflowRepositoryConflict";
+  }
+}