create-windy 0.8.2 → 0.8.3

package/template/apps/server/src/agent/run-routes.ts

@@ -1,3 +1,9 @@
+import {
+  facadeError,
+  errorResponse,
+  required,
+  isRecord,
+} from "./run-route-response.js";
 import { timingSafeEqual } from "node:crypto";
 import type { RequestGuardContext } from "../guards.js";
 import type { RouteApp } from "../system/routes.js";
@@ -7,6 +13,8 @@ import type { AgentRuntimePort } from "./run-contracts.js";
 import type { AgentRunSessionLinkPort } from "./session-run-link.js";
 import type { SessionRunResultMemoryPort } from "./session-result-memory.js";
 import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import { projectPublicRunEvents } from "./workbench-sse.js";
+import { assertBrowserVisibleOperation } from "./run-browser-visibility.js";
 import {
   AgentToolHostError,
   attachExecutionGrant,
@@ -46,6 +54,7 @@ export function registerAgentRunRoutes(
     const context = raw as RouteContext;
     try {
       const request = parseStartRequest(context.body);
+      assertBrowserVisibleOperation(facade, request.operationKey);
       const idempotencyKey = context.request.headers.get("idempotency-key");
       if (!idempotencyKey?.trim()) {
         return errorResponse("INVALID_INPUT", "幂等键不能为空", 400);
@@ -70,12 +79,15 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const operationKey = parseOperationKey(context.query.operationKey);
+      assertBrowserVisibleOperation(facade, operationKey);
       await facade.authorizeRun(operationKey, runId, context.guardContext);
       const cursor = parseCursor(
         context.query.after,
         context.request.headers.get("last-event-id"),
       );
-      return await remote.events(runId, cursor, context.request.signal);
+      return projectPublicRunEvents(
+        await remote.events(runId, cursor, context.request.signal),
+      );
     } catch (error) {
       return facadeError(error);
     }
@@ -86,6 +98,7 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const operationKey = parseOperationKey(context.query.operationKey);
+      assertBrowserVisibleOperation(facade, operationKey);
       const sessionId = context.query.sessionId
         ? parseSessionId(context.query.sessionId)
         : undefined;
@@ -105,8 +118,14 @@ export function registerAgentRunRoutes(
           status.status === "cancelled"
         ) {
           if (status.status === "completed") {
-            await projectResult(resultMemory, boundSessionId, runId,
-              status.lastSequence, response, context);
+            await projectResult(
+              resultMemory,
+              boundSessionId,
+              runId,
+              status.lastSequence,
+              response,
+              context,
+            );
           }
           await completeSessionRun(
             sessionLinks,
@@ -128,6 +147,7 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const operationKey = parseOperationKey(context.query.operationKey);
+      assertBrowserVisibleOperation(facade, operationKey);
       const sessionId = context.query.sessionId
         ? parseSessionId(context.query.sessionId)
         : undefined;
@@ -141,7 +161,11 @@ export function registerAgentRunRoutes(
         isRecord(context.body) && typeof context.body.reason === "string"
           ? context.body.reason.slice(0, 200)
           : undefined;
-      const response = await remote.cancel(runId, reason, context.request.signal);
+      const response = await remote.cancel(
+        runId,
+        reason,
+        context.request.signal,
+      );
       if (authorized.sessionId && response.ok) {
         const status = await remote.status(runId, context.request.signal);
         if (!["completed", "failed", "cancelled"].includes(status.status)) {
@@ -149,8 +173,14 @@ export function registerAgentRunRoutes(
         }
         if (status.status === "completed") {
           const result = await remote.result(runId, context.request.signal);
-          await projectResult(resultMemory, authorized.sessionId, runId,
-            status.lastSequence, result, context);
+          await projectResult(
+            resultMemory,
+            authorized.sessionId,
+            runId,
+            status.lastSequence,
+            result,
+            context,
+          );
         }
         await completeSessionRun(
           sessionLinks,
@@ -171,6 +201,7 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const request = parseAttachRequest(context.body);
+      assertBrowserVisibleOperation(facade, request.operationKey);
       const authorized = await facade.authorizeRunMutation(
         request.operationKey,
         runId,
@@ -188,8 +219,14 @@ export function registerAgentRunRoutes(
       if (authorized.sessionId && attached.terminalEvent) {
         if (attached.status === "completed") {
           const response = await remote.result(runId, context.request.signal);
-          await projectResult(resultMemory, authorized.sessionId, runId,
-            attached.terminalEvent.sequence, response, context);
+          await projectResult(
+            resultMemory,
+            authorized.sessionId,
+            runId,
+            attached.terminalEvent.sequence,
+            response,
+            context,
+          );
         }
         await completeSessionRun(
           sessionLinks,
@@ -267,7 +304,7 @@ async function projectResult(
     sessionId,
     runId,
     terminalSequence,
-    result: await response.clone().json() as ModuleAiJsonValue,
+    result: (await response.clone().json()) as ModuleAiJsonValue,
     context: context.guardContext,
     signal: context.request.signal,
   });
@@ -302,37 +339,3 @@ export function validInternalToken(
   const right = Buffer.from(expected);
   return left.length === right.length && timingSafeEqual(left, right);
 }
-
-function facadeError(error: unknown): Response {
-  if (error instanceof AgentRunFacadeError) {
-    return errorResponse(error.code, error.message, error.status);
-  }
-  return errorResponse(
-    "RUNTIME_UNAVAILABLE",
-    "Agent Runtime 暂不可用",
-    503,
-    true,
-  );
-}
-
-function errorResponse(
-  code: string,
-  message: string,
-  status: number,
-  retryable = false,
-): Response {
-  return Response.json(
-    { code, message, requestId: crypto.randomUUID(), retryable },
-    { status },
-  );
-}
-
-function required(value: string | undefined): string {
-  if (!value)
-    throw new AgentRunFacadeError("INVALID_INPUT", "Run ID 无效", 400);
-  return value;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/template/apps/server/src/agent/runtime-bootstrap.ts

@@ -1,4 +1,6 @@
 import { resolveCurrentSystemActor } from "../system/actor.js";
+import type { AgentAdminReadinessRef } from "./admin-catalog-bootstrap.js";
+import { registerAgentAdminCatalogRuntime } from "./admin-catalog-bootstrap.js";
 import { AiArtifactCodec } from "../ai-artifact/codec.js";
 import { registerAiArtifactRoutes } from "../ai-artifact/routes.js";
 import { AiArtifactRuntime } from "../ai-artifact/runtime.js";
@@ -41,7 +43,7 @@ import { InMemoryAgentRunBindingRepository } from "./run-binding-repository.js";
 import { AgentBackgroundOperationExecutor } from "./background-operation.js";
 import { createModuleAiPorts } from "./module-ai-port-factory.js";
 import { createManifestAuthorizedRouteApp } from "../module-host/static-route-authorization.js";
-import { registerUnavailableAiRoutes } from "./unavailable-routes.js";
+import { disableAgentRuntime } from "./runtime-disabled-composition.js";
 import { createClientAgentSessionRuntime } from "./client-session/bootstrap.js";
 import { attachClientAgentWorkflowArtifactRuntime } from "./client-workflow-artifact/runtime-composition.js";
 import { bindClientAgentHostRevocations } from "./client-session/host-revocation-composition.js";
@@ -52,6 +54,7 @@ import { registerScreenshotIntakeRoutes } from "./screenshot-intake-routes.js";
 import { createScreenshotIntakeRuntimeV2 } from "./screenshot-intake-bootstrap.js";
 import { requiredEnvironment } from "./required-environment.js";
 import { composeAgentLongSessionRuntime } from "./session-runtime-composition.js";
+import { registerAgentWorkbenchRuntime } from "./workbench-bootstrap.js";
 import type { AgentPlatformRuntimeInput } from "./runtime-bootstrap-input.js";
 import { composeAgentToolRuntime } from "./runtime-tool-composition.js";
 import { registerProductionAgentWorkflowRuntime } from "./workflow-runtime-bootstrap.js";
@@ -62,33 +65,23 @@ import {
 export function registerAgentPlatformRuntime(input: AgentPlatformRuntimeInput) {
   const resolveAgentActor = async (actorId: string) =>
     resolveCurrentSystemActor(input.systemRepositories, actorId);
-  const { features, toolHandlers, toolRegistry, routeAuthorizer } =
-    composeAgentToolRuntime(input);
+  const tools = composeAgentToolRuntime(input);
+  const { features, toolHandlers, toolRegistry, routeAuthorizer } = tools;
+  const catalogReadiness: AgentAdminReadinessRef = {};
+  registerAgentAdminCatalogRuntime(input, tools, catalogReadiness);
   const aiRouteApp = createManifestAuthorizedRouteApp(
     input.app,
     routeAuthorizer,
   );
   if (!input.platformConfig.enableAI) {
-    registerProductionAgentWorkflowRuntime(input, aiRouteApp, toolRegistry);
-    registerUnavailableAiRoutes(
-      createManifestAuthorizedRouteApp(input.app, routeAuthorizer),
-    );
-    return {
-      toolHandlers,
-      aiArtifacts: undefined,
-      aiOperations: undefined,
-      aiReadiness: undefined,
-      clientAgentSessions: undefined,
-      agentWorkflowProjects: undefined,
-      sessionMemory: undefined,
-      sourceInvalidation: undefined,
-      invalidateAuthorization: undefined,
-      disposeAgentRuntime: undefined,
-    };
+    return disableAgentRuntime(input, aiRouteApp, tools);
   }
   const sessionSecret = requiredEnvironment("AI_ARTIFACT_ENCRYPTION_SECRET");
   const internalToken = requiredEnvironment("AGENT_SERVER_INTERNAL_TOKEN");
-  registerAgentSessions({ ...input, secret: internalToken });
+  const businessSessions = registerAgentSessions({
+    ...input,
+    secret: internalToken,
+  });
   const aiArtifacts = new AiArtifactRuntime(
     new AiArtifactCodec(sessionSecret),
     input.hosts,
@@ -203,6 +196,7 @@ export function registerAgentPlatformRuntime(input: AgentPlatformRuntimeInput) {
     trustStore: readinessTrustStore,
     runtime: input.runtime,
   });
+  catalogReadiness.current = aiReadiness;
   const outputRuntime = createDocumentOutputRuntime({
     modules: input.modules,
     readiness: aiReadiness,
@@ -286,6 +280,13 @@ export function registerAgentPlatformRuntime(input: AgentPlatformRuntimeInput) {
   if (agentWorkflowRuntime?.artifacts) {
     clientWorkflowArtifacts.bindTaskArtifacts?.(agentWorkflowRuntime.artifacts);
   }
+  registerAgentWorkbenchRuntime(input, aiRouteApp, {
+    agentFacade,
+    remote,
+    business: businessSessions,
+    sessions: longSessions?.facade,
+    workflows: agentWorkflowRuntime?.query,
+  });
   registerScreenshotIntakeRoutes(aiRouteApp, screenshotIntake);
   registerAgentRunRoutes(
     aiRouteApp,

package/template/apps/server/src/agent/runtime-disabled-composition.ts

@@ -0,0 +1,28 @@
+import type { RouteApp } from "../system/routes.js";
+import type { AgentPlatformRuntimeInput } from "./runtime-bootstrap-input.js";
+import type { composeAgentToolRuntime } from "./runtime-tool-composition.js";
+import { registerAgentWorkbenchRuntime } from "./workbench-bootstrap.js";
+import { registerProductionAgentWorkflowRuntime } from "./workflow-runtime-bootstrap.js";
+import { registerUnavailableAiRoutes } from "./unavailable-routes.js";
+
+export function disableAgentRuntime(
+  input: AgentPlatformRuntimeInput,
+  app: RouteApp,
+  tools: ReturnType<typeof composeAgentToolRuntime>,
+) {
+  registerAgentWorkbenchRuntime(input, app);
+  registerProductionAgentWorkflowRuntime(input, app, tools.toolRegistry);
+  registerUnavailableAiRoutes(app);
+  return {
+    toolHandlers: tools.toolHandlers,
+    aiArtifacts: undefined,
+    aiOperations: undefined,
+    aiReadiness: undefined,
+    clientAgentSessions: undefined,
+    agentWorkflowProjects: undefined,
+    sessionMemory: undefined,
+    sourceInvalidation: undefined,
+    invalidateAuthorization: undefined,
+    disposeAgentRuntime: undefined,
+  };
+}

package/template/apps/server/src/agent/session-projection-facade.ts

@@ -1,4 +1,5 @@
-import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import { projectSessionRecording } from "./session-recording-reader.js";
+import { sessionProjectionGovernance as governance } from "./session-projection-governance.js";
 import type { RequestGuardContext } from "../guards.js";
 import type { MemoryObjectAuthorizationPort } from "./context-memory/contracts.js";
 import {
@@ -89,6 +90,12 @@ export class AgentSessionProjectionFacade {
     };
   }
 
+  async recording(sessionId: string, context: RequestGuardContext) {
+    return projectSessionRecording(
+      await this.replay(sessionId, undefined, context),
+    );
+  }
+
   async contextVersions(sessionId: string, context: RequestGuardContext) {
     const session = await this.requireSession(sessionId, context);
     const rows = await this.contexts.listForSession(session.sessionId);
@@ -339,11 +346,3 @@ export class AgentSessionProjectionFacade {
     return session;
   }
 }
-
-function governance(context: RequestGuardContext) {
-  return {
-    actorId: context.actor.id,
-    scopeDigest:
-      `sha256:${captureAuthorizationScope(context.actor.scopeContext).hash}` as const,
-  };
-}

package/template/apps/server/src/agent/session-projection-governance.ts

@@ -0,0 +1,10 @@
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import type { RequestGuardContext } from "../guards.js";
+
+export function sessionProjectionGovernance(context: RequestGuardContext) {
+  return {
+    actorId: context.actor.id,
+    scopeDigest:
+      `sha256:${captureAuthorizationScope(context.actor.scopeContext).hash}` as const,
+  };
+}

package/template/apps/server/src/agent/session-projection-view.ts

@@ -27,9 +27,7 @@ export function projectAgentSession(session: SessionRecord) {
   };
 }
 
-export function projectAgentSessionTimelineEvent(
-  event: SessionEventEnvelope,
-) {
+export function projectAgentSessionTimelineEvent(event: SessionEventEnvelope) {
   const data = event.data;
   return {
     sequence: event.sequence,
@@ -39,6 +37,9 @@ export function projectAgentSessionTimelineEvent(
     ...("runId" in data && data.runId ? { runId: data.runId } : {}),
     ...("turnId" in data ? { turnId: data.turnId } : {}),
     ...("stepId" in data ? { stepId: data.stepId } : {}),
+    ...("toolCallId" in data ? { toolCallId: data.toolCallId } : {}),
+    ...("toolKey" in data ? { toolKey: data.toolKey } : {}),
+    ...("outcome" in data ? { outcome: data.outcome } : {}),
   };
 }
 
@@ -121,17 +122,19 @@ export function projectableMemory(
 }
 
 function timelineSummary(type: SessionEventEnvelope["data"]["type"]) {
-  return ({
-    "session.created": "Session 已创建",
-    "session.archived": "Session 已归档",
-    "turn.started": "Turn 已开始",
-    "turn.completed": "Turn 已结束",
-    "run.linked": "Run 已关联",
-    "step.started": "Step 已开始",
-    "step.completed": "Step 已结束",
-    "tool.execution-recorded": "Tool 执行事实已记录",
-    "checkpoint.created": "Checkpoint 已创建",
-    "fork.created": "Fork 已创建",
-    "write-tool.reexecuted": "写 Tool 已经显式授权重新执行",
-  } satisfies Record<SessionEventEnvelope["data"]["type"], string>)[type];
+  return (
+    {
+      "session.created": "Session 已创建",
+      "session.archived": "Session 已归档",
+      "turn.started": "Turn 已开始",
+      "turn.completed": "Turn 已结束",
+      "run.linked": "Run 已关联",
+      "step.started": "Step 已开始",
+      "step.completed": "Step 已结束",
+      "tool.execution-recorded": "Tool 执行事实已记录",
+      "checkpoint.created": "Checkpoint 已创建",
+      "fork.created": "Fork 已创建",
+      "write-tool.reexecuted": "写 Tool 已经显式授权重新执行",
+    } satisfies Record<SessionEventEnvelope["data"]["type"], string>
+  )[type];
 }

package/template/apps/server/src/agent/session-recording-reader.contract.test.ts

@@ -0,0 +1,131 @@
+import { expect, test } from "bun:test";
+import { SessionEventLogService } from "./session-log/service.js";
+import { InMemorySessionEventRepository } from "./session-log/in-memory-repository.js";
+import { projectSessionRecording } from "./session-recording-reader.js";
+
+test("fork replay reuses AH1 recorded-only segments and original parent/child sequences", async () => {
+  const repository = new InMemorySessionEventRepository();
+  const service = new SessionEventLogService(repository);
+  const governance = {
+    actorId: "actor-1",
+    scopeDigest: `sha256:${"a".repeat(64)}` as const,
+  };
+  await service.create({
+    sessionId: "session_parent",
+    createdEventId: "session_event_parent",
+    governance,
+  });
+  await service.append({
+    sessionId: "session_parent",
+    expectedSequence: 1,
+    events: [
+      service.newEvent({
+        type: "turn.started",
+        turnId: "session_turn_parent",
+        cause: "user-input",
+        input: {
+          sourceType: "agent-run-input",
+          sourceId: "binding_1",
+          sourceVersion: "business.answer",
+          contentDigest: `sha256:${"b".repeat(64)}`,
+        },
+      }),
+      service.newEvent({
+        type: "run.linked",
+        turnId: "session_turn_parent",
+        runId: "run_parent",
+      }),
+      service.newEvent({
+        type: "turn.completed",
+        turnId: "session_turn_parent",
+        outcome: "completed",
+      }),
+    ],
+  });
+  await service.checkpoint({
+    sessionId: "session_parent",
+    expectedSequence: 4,
+    checkpointId: "session_checkpoint_parent",
+    eventId: "session_event_checkpoint",
+  });
+  await service.fork({
+    parentSessionId: "session_parent",
+    expectedParentSequence: 5,
+    checkpointId: "session_checkpoint_parent",
+    childSessionId: "session_child",
+    parentEventId: "session_event_fork",
+    childCreatedEventId: "session_event_child",
+    governance,
+  });
+  await service.append({
+    sessionId: "session_child",
+    expectedSequence: 1,
+    events: [
+      service.newEvent({
+        type: "turn.started",
+        turnId: "session_turn_child",
+        cause: "user-input",
+        input: {
+          sourceType: "agent-run-input",
+          sourceId: "binding_2",
+          sourceVersion: "business.answer",
+          contentDigest: `sha256:${"c".repeat(64)}`,
+        },
+      }),
+      service.newEvent({
+        type: "run.linked",
+        turnId: "session_turn_child",
+        runId: "run_child",
+      }),
+      service.newEvent({
+        type: "turn.completed",
+        turnId: "session_turn_child",
+        outcome: "completed",
+      }),
+    ],
+  });
+  const replay = await service.replay({ sessionId: "session_child" });
+  const projected = projectSessionRecording({
+    ...replay,
+    segments: await Promise.all(
+      replay.segments.map(async (segment) => ({
+        ...segment,
+        session: (await repository.get(segment.sessionId))!,
+      })),
+    ),
+  });
+  expect(replay.sideEffectPolicy).toBe("recorded-only");
+  expect(projected.segments.map(({ sessionId }) => sessionId)).toEqual([
+    "session_parent",
+    "session_child",
+  ]);
+  expect(
+    projected.segments.map(({ timeline }) =>
+      timeline.map(({ sequence }) => sequence),
+    ),
+  ).toEqual([
+    [1, 2, 3, 4],
+    [1, 2, 3, 4],
+  ]);
+  expect(
+    projected.runRefs.map(({ runId, sessionId, operationKey }) => ({
+      runId,
+      sessionId,
+      operationKey,
+    })),
+  ).toEqual([
+    {
+      runId: "run_parent",
+      sessionId: "session_parent",
+      operationKey: "business.answer",
+    },
+    {
+      runId: "run_child",
+      sessionId: "session_child",
+      operationKey: "business.answer",
+    },
+  ]);
+  expect(projected.truncated).toBe(false);
+  expect((await repository.get("session_parent"))?.headSequence).toBe(6);
+  expect((await repository.get("session_child"))?.headSequence).toBe(4);
+});

package/template/apps/server/src/agent/session-recording-reader.ts

@@ -0,0 +1,62 @@
+import type { SessionRecord } from "./session-log/domain.js";
+import type { ReadOnlySessionReplay } from "./session-log/replay-policy.js";
+import {
+  projectAgentSession,
+  projectAgentSessionTimelineEvent,
+} from "./session-projection-view.js";
+
+/** Already-authorized replay segments preserve parent/child sequence domains. */
+export function projectSessionRecording(
+  replay: Omit<ReadOnlySessionReplay, "segments"> & {
+    segments: readonly {
+      sessionId: string;
+      throughSequence: number;
+      events: ReadOnlySessionReplay["segments"][number]["events"];
+      session: SessionRecord;
+    }[];
+  },
+) {
+  const current = replay.segments.find(
+    ({ sessionId }) => sessionId === replay.sessionId,
+  );
+  if (!current) throw new Error("Current replay segment missing");
+  const segments = replay.segments.map((segment) => ({
+    ...segment,
+    events: segment.events.slice(0, 10_000),
+  }));
+  const runRefs = segments.flatMap(({ sessionId, events }) => {
+    const operations = new Map(
+      events.flatMap(({ data }) =>
+        data.type === "turn.started" &&
+        data.input.sourceType === "agent-run-input"
+          ? [[data.turnId, data.input.sourceVersion] as const]
+          : [],
+      ),
+    );
+    return events.flatMap(({ data }) =>
+      data.type === "run.linked"
+        ? [
+            {
+              runId: data.runId,
+              sessionId,
+              turnId: data.turnId,
+              operationKey: operations.get(data.turnId) ?? "",
+            },
+          ]
+        : [],
+    );
+  });
+  return {
+    session: projectAgentSession(current.session),
+    truncated: replay.segments.some(({ events }) => events.length > 10_000),
+    segments: segments.map(({ sessionId, throughSequence, events }) => ({
+      sessionId,
+      throughSequence,
+      timeline: events.map(projectAgentSessionTimelineEvent),
+    })),
+    timeline: segments
+      .find(({ sessionId }) => sessionId === replay.sessionId)!
+      .events.map(projectAgentSessionTimelineEvent),
+    runRefs,
+  };
+}

package/template/apps/server/src/agent/tool-catalog-audit.ts

@@ -0,0 +1,22 @@
+import { randomUUIDv7 } from "bun";
+import { auditActor, type RequestGuardContext } from "../guards.js";
+import type { createServerRuntime } from "../runtime.js";
+
+export function auditAgentAdminCatalogRead(
+  runtime: ReturnType<typeof createServerRuntime>,
+  context: RequestGuardContext,
+  kind: "tools" | "operations",
+  itemCount: number,
+): void {
+  runtime.auditSink.recordEvent({
+    id: randomUUIDv7(),
+    action:
+      kind === "tools" ? "system.agent-tools.read" : "system.agent-debug.read",
+    actor: auditActor(context),
+    outcome: "success",
+    target: { type: "agent-admin-catalog", id: kind },
+    requestId: context.requestId,
+    metadata: { itemCount },
+    occurredAt: new Date().toISOString(),
+  });
+}

package/template/apps/server/src/agent/tool-catalog-availability.ts

@@ -0,0 +1,21 @@
+import type { AgentAdminAvailabilityReason } from "@southwind-ai/shared";
+import type { GuardDecisionReason } from "../guards.js";
+
+export function catalogGuardReason(
+  reason: GuardDecisionReason,
+): AgentAdminAvailabilityReason {
+  switch (reason) {
+    case "allowed":
+    case "anonymous":
+      return "allowed";
+    case "feature-disabled":
+    case "dependency-missing":
+      return "feature-unavailable";
+    case "license-restricted":
+    case "license-version-not-allowed":
+    case "entitlement-not-granted":
+      return "license-unavailable";
+    default:
+      return "permission-denied";
+  }
+}