create-windy 0.8.1 → 0.8.3

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

@@ -0,0 +1,328 @@
+import { describe, expect, test } from "bun:test";
+import type { AgentRuntimePort } from "./run-contracts.js";
+import {
+  createRunFacadeFixture,
+  guardContext,
+} from "./run-facade.test-support.js";
+import {
+  AgentWorkbenchRunReader,
+  readRecordedRunEvents,
+} from "./workbench-run-reader.js";
+import { projectPublicRunEvents } from "./workbench-sse.js";
+import { projectWorkbenchResult } from "./workbench-safe-result.js";
+import { validateAgentSessionDetail } from "./agent-session-validation.js";
+
+const records = [
+  { sequence: 1, type: "run.started", runId: "run_1", rawBody: "SECRET" },
+  {
+    sequence: 2,
+    type: "tool.requested",
+    toolCallId: "call_1",
+    toolKey: "business.records.read",
+    arguments: { password: "SECRET" },
+  },
+  {
+    sequence: 3,
+    type: "approval.required",
+    toolCallId: "call_1",
+    workItemId: "item_1",
+  },
+  {
+    sequence: 4,
+    type: "approval.resolved",
+    toolCallId: "call_1",
+    workItemId: "item_1",
+    outcome: "approved",
+  },
+  {
+    sequence: 5,
+    type: "tool.completed",
+    toolCallId: "call_1",
+    result: "SECRET",
+  },
+  {
+    sequence: 6,
+    type: "usage.reported",
+    attemptSequence: 2,
+    usage: {
+      inputTokens: 15,
+      outputTokens: 6,
+      totalTokens: 21,
+      providerBody: "SECRET",
+    },
+  },
+  { sequence: 7, type: "output.delta", text: "受控回答" },
+  { sequence: 8, type: "run.completed" },
+];
+const encoder = new TextEncoder();
+function frames(events: readonly object[], crlf = false) {
+  const content = events
+    .map((event) => `data: ${JSON.stringify(event)}\n\n`)
+    .join("");
+  return crlf ? content.replaceAll("\n", "\r\n") : content;
+}
+function remote(content = frames(records)): AgentRuntimePort {
+  return {
+    start: async () => {
+      throw new Error("must never start");
+    },
+    cancel: async () => {
+      throw new Error("must never cancel");
+    },
+    health: async () => new Response(),
+    events: async () => new Response(content),
+    status: async (runId) => ({
+      runId,
+      status: "completed",
+      lastSequence: records.length,
+    }),
+    result: async () =>
+      Response.json({
+        status: "completed",
+        output: {
+          answer: "业务结果",
+          secret: "SECRET",
+          nested: { reasoning: "SECRET", total: 12 },
+        },
+      }),
+  };
+}
+
+describe("Workbench immutable recorded Run read port", () => {
+  test("current actor authorization precedes read, no start/cancel/Memory writes; Tool/Approval/Attempt order survives", async () => {
+    const fixture = await createRunFacadeFixture();
+    await fixture.facade.start(
+      "business.answer",
+      { question: "测试" },
+      "unique",
+      fixture.context,
+    );
+    const reader = new AgentWorkbenchRunReader(fixture.facade, remote());
+    const result = await reader.read(
+      { runId: "run_1", operationKey: "business.answer" },
+      fixture.context,
+      new AbortController().signal,
+    );
+    expect(result.correlationStatus).toBe("complete");
+    expect(result.events.map(({ sequence }) => sequence)).toEqual([
+      1, 2, 3, 4, 5, 6, 7, 8,
+    ]);
+    expect(result.events[2]?.workItemId).toBe("item_1");
+    expect(result.events[5]?.attemptSequence).toBe(2);
+    expect(result.events[5]?.usage?.totalTokens).toBe(21);
+    expect(result.result?.output).toEqual({
+      answer: "业务结果",
+      nested: { total: 12 },
+    });
+    expect(JSON.stringify(result)).not.toContain("SECRET");
+    expect(fixture.remote.started).toHaveLength(1);
+    const denied = await reader.read(
+      { runId: "run_1", operationKey: "business.answer" },
+      guardContext([]),
+      new AbortController().signal,
+    );
+    expect(denied.missing).toEqual(["RUN_NOT_ACCESSIBLE"]);
+    const wrongSession = await reader.read(
+      {
+        runId: "run_1",
+        operationKey: "business.answer",
+        sessionId: "session_other",
+      },
+      fixture.context,
+      new AbortController().signal,
+    );
+    expect(wrongSession.missing).toEqual(["RUN_NOT_ACCESSIBLE"]);
+  });
+  test("internal Operations never expose answers and partial/empty recordings are explicit", async () => {
+    const fixture = await createRunFacadeFixture();
+    const internal = new AgentWorkbenchRunReader(
+      {
+        authorizeRun: fixture.facade.authorizeRun.bind(fixture.facade),
+        operationPolicy: (key) => {
+          const policy = fixture.facade.operationPolicy(key);
+          return policy
+            ? { ...policy, visibility: "internal" as const }
+            : undefined;
+        },
+      },
+      remote(),
+    );
+    expect(
+      (
+        await internal.read(
+          { runId: "run_1", operationKey: "business.answer" },
+          fixture.context,
+          new AbortController().signal,
+        )
+      ).missing,
+    ).toEqual(["RUN_NOT_ACCESSIBLE"]);
+    await fixture.facade.start(
+      "business.answer",
+      { question: "测试" },
+      "unique",
+      fixture.context,
+    );
+    const port = remote();
+    const empty = new AgentWorkbenchRunReader(fixture.facade, {
+      ...port,
+      status: async (runId) => ({
+        runId,
+        status: "completed",
+        lastSequence: 0,
+      }),
+    });
+    expect(
+      (
+        await empty.read(
+          { runId: "run_1", operationKey: "business.answer" },
+          fixture.context,
+          new AbortController().signal,
+        )
+      ).missing,
+    ).toEqual(["RUN_EVENTS_MISSING"]);
+    expect(
+      (
+        await readRecordedRunEvents(
+          remote(frames([records[0]!, records[2]!])),
+          "run_1",
+          3,
+          new AbortController().signal,
+        )
+      ).missing,
+    ).toEqual(["RUN_EVENTS_PARTIAL"]);
+  });
+  test("many complete frames within one large chunk and split CRLF remain exact ordered facts", async () => {
+    const events = Array.from({ length: 1500 }, (_, index) => ({
+      sequence: index + 1,
+      type: "tool.requested",
+      toolCallId: `call_${index}`,
+      toolKey: "business.records.read",
+      rawBody: "x".repeat(160),
+    }));
+    const content = frames(events, true);
+    const parts = [
+      content.slice(0, content.indexOf("\r\n") + 1),
+      content.slice(content.indexOf("\r\n") + 1),
+    ];
+    const port = {
+      ...remote(),
+      events: async () =>
+        new Response(
+          new ReadableStream({
+            start(controller) {
+              for (const part of parts)
+                controller.enqueue(encoder.encode(part));
+              controller.close();
+            },
+          }),
+        ),
+    };
+    const read = await readRecordedRunEvents(
+      port,
+      "run_1",
+      1500,
+      new AbortController().signal,
+    );
+    expect(read.events).toHaveLength(1500);
+    expect(read.missing).toEqual([]);
+    const stream = projectPublicRunEvents(await port.events());
+    const data = await stream.text();
+    expect(data.match(/^id:/gm)).toHaveLength(1500);
+    expect(data).not.toContain("rawBody");
+  });
+  test("public SSE keeps normal answer, usage and approval fields but strips arbitrary sensitive payloads", async () => {
+    const publicStream = projectPublicRunEvents(new Response(frames(records)));
+    const events = (await publicStream.text())
+      .split("\n\n")
+      .filter(Boolean)
+      .map(
+        (frame) =>
+          JSON.parse(
+            frame
+              .split("\n")
+              .find((line) => line.startsWith("data:"))!
+              .slice(6),
+          ) as Record<string, unknown>,
+      );
+    expect(events[6]?.text).toBe("受控回答");
+    expect(events[2]?.workItemId).toBe("item_1");
+    expect(events[3]?.outcome).toBe("approved");
+    expect(events[5]?.usage).toEqual({
+      inputTokens: 15,
+      outputTokens: 6,
+      totalTokens: 21,
+    });
+    expect(JSON.stringify(events)).not.toContain("SECRET");
+  });
+  test("safe result recursively removes private state while keeping legitimate business JSON", () => {
+    expect(
+      projectWorkbenchResult({
+        output: {
+          currency: "CNY",
+          total: 12,
+          chain_of_thought: "hidden",
+          details: [{ arguments: { secret: "hidden" }, amount: 5 }],
+        },
+        providerBody: "hidden",
+      }),
+    ).toEqual({
+      output: { currency: "CNY", total: 12, details: [{ amount: 5 }] },
+    });
+  });
+  test("provider references are bounded, unique and point to messages actually returned", () => {
+    const base = {
+      sourceId: "1",
+      title: "业务会话",
+      updatedAt: "2026-10-07T01:00:00Z",
+      revision: "1",
+      messages: [
+        {
+          sequence: 2,
+          role: "assistant" as const,
+          content: "回答",
+          createdAt: "2026-10-07T01:00:00Z",
+        },
+      ],
+    };
+    expect(
+      validateAgentSessionDetail(
+        {
+          ...base,
+          truncated: true,
+          runRefs: [
+            {
+              runId: "run_1",
+              operationKey: "business.answer",
+              messageSequence: 2,
+            },
+          ],
+        },
+        "1",
+      ).truncated,
+    ).toBe(true);
+    expect(() =>
+      validateAgentSessionDetail(
+        {
+          ...base,
+          runRefs: [
+            {
+              runId: "run_1",
+              operationKey: "business.answer",
+              messageSequence: 9,
+            },
+          ],
+        },
+        "1",
+      ),
+    ).toThrow();
+    expect(() =>
+      validateAgentSessionDetail(
+        {
+          ...base,
+          workflowRefs: [{ workflowRunId: "wf_1" }, { workflowRunId: "wf_1" }],
+        },
+        "1",
+      ),
+    ).toThrow();
+  });
+});

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

@@ -0,0 +1,97 @@
+import type { RequestGuardContext } from "../guards.js";
+import type { RouteApp } from "../system/routes.js";
+import { AgentSessionFacadeError } from "./agent-session-facade.js";
+import { AgentSessionProjectionError } from "./session-projection-facade.js";
+import {
+  AgentWorkbenchError,
+  type AgentWorkbenchFacade,
+} from "./workbench-facade.js";
+
+interface Context {
+  request: Request;
+  params: Record<string, string | undefined>;
+  guardContext: RequestGuardContext;
+}
+
+export function registerAgentWorkbenchRoutes(
+  app: RouteApp,
+  facade: AgentWorkbenchFacade,
+) {
+  app.get("/agent/admin/session-recordings", (raw) =>
+    handle(raw, (context) =>
+      facade.list(
+        source(context.request),
+        context.guardContext,
+        context.request.signal,
+      ),
+    ),
+  );
+  app.get("/agent/admin/session-recordings/:sessionId", (raw) =>
+    handle(raw, (context) => {
+      const id = context.params.sessionId;
+      if (!id || !/^[A-Za-z0-9_.:-]{1,250}$/.test(id)) throw new InputError();
+      return facade.recording(
+        source(context.request),
+        id,
+        context.guardContext,
+        context.request.signal,
+      );
+    }),
+  );
+  app.post("/agent/admin/test-sessions", (raw) =>
+    handle(raw, (context) => facade.createTestSession(context.guardContext)),
+  );
+}
+
+async function handle(
+  raw: unknown,
+  action: (context: Context) => Promise<unknown>,
+) {
+  const context = raw as Context;
+  try {
+    return json(await action(context));
+  } catch (error) {
+    if (
+      error instanceof AgentWorkbenchError ||
+      error instanceof AgentSessionFacadeError ||
+      error instanceof AgentSessionProjectionError
+    )
+      return json(
+        {
+          code: error.code,
+          requestId: context.guardContext.requestId,
+          retryable: error.status >= 500,
+        },
+        error.status,
+      );
+    if (error instanceof InputError)
+      return json(
+        {
+          code: "INVALID_INPUT",
+          requestId: context.guardContext.requestId,
+          retryable: false,
+        },
+        400,
+      );
+    return json(
+      {
+        code: "WORKBENCH_UNAVAILABLE",
+        requestId: context.guardContext.requestId,
+        retryable: true,
+      },
+      503,
+    );
+  }
+}
+function source(request: Request): "business" | "harness" {
+  const value = new URL(request.url).searchParams.get("source") ?? "harness";
+  if (value !== "harness" && value !== "business") throw new InputError();
+  return value;
+}
+function json(value: unknown, status = 200) {
+  return Response.json(value, {
+    status,
+    headers: { "cache-control": "no-store" },
+  });
+}
+class InputError extends Error {}

package/template/apps/server/src/agent/workbench-run-integration.test.ts

@@ -0,0 +1,231 @@
+import type { AgentWorkbenchRecordingV1 } from "@southwind-ai/shared";
+import type { SessionId } from "./session-log/domain.js";
+import { expect, test } from "bun:test";
+import { Elysia } from "elysia";
+import { systemModuleManifest } from "@southwind-ai/modules";
+import { createServerRuntime } from "../runtime.js";
+import { AgentRunFacade } from "./run-facade.js";
+import {
+  createRunFacadeFixture,
+  guardContext,
+  runFacadeManifest,
+} from "./run-facade.test-support.js";
+import { createTestRunAuthorizationStore } from "./run-authorization.test-support.js";
+import { registerAgentRunRoutes } from "./run-routes.js";
+import type { AgentRuntimePort } from "./run-contracts.js";
+import type { RestrictedAgentToolHost } from "./tool-host.js";
+import { InMemorySessionEventRepository } from "./session-log/in-memory-repository.js";
+import { SessionEventLogService } from "./session-log/service.js";
+import { AgentSessionProjectionFacade } from "./session-projection-facade.js";
+import type { DrizzleSessionEventRepository } from "./session-persistence/drizzle-session-repository.js";
+import type {
+  DrizzleContextProjectionReader,
+  DrizzleMemoryProjectionStore,
+} from "./session-persistence/drizzle-context-memory.js";
+import type { DrizzleSessionMutationCoordinator } from "./session-persistence/drizzle-session-mutations.js";
+import { PersistentAgentRunSessionLink } from "./session-run-link.js";
+import type {
+  SessionRunProjectionReceipt,
+  SessionRunResultMemoryPort,
+} from "./session-result-memory.js";
+import { AgentWorkbenchFacade } from "./workbench-facade.js";
+import { AgentWorkbenchRunReader } from "./workbench-run-reader.js";
+import { registerAgentWorkbenchRoutes } from "./workbench-routes.js";
+
+test("Admin Session → normal governed Run → terminal settlement → read-only replay preserves ledger", async () => {
+  const fixture = await createRunFacadeFixture();
+  const modules = [systemModuleManifest("system.agent"), runFacadeManifest()];
+  const runtime = createServerRuntime(
+    {},
+    {
+      featureCatalog: modules.flatMap(({ features }) => features),
+      licenseResolver: { resolve: () => ({ status: "valid" }) },
+    },
+  );
+  const context = guardContext([
+    "system.agent-debug.read",
+    "system.agent-debug.manage",
+    "system.agent-session.manage",
+    "system.agent-session.read",
+    "business.ai.execute",
+    "business.records.read",
+  ]);
+  // Exercise the production Session service and Run link with an in-memory persistence adapter.
+  const repository = new InMemorySessionEventRepository();
+  const dbRepository = repository as unknown as DrizzleSessionEventRepository;
+  const service = new SessionEventLogService(repository);
+  const sessions = new AgentSessionProjectionFacade(
+    dbRepository,
+    service,
+    {} as DrizzleContextProjectionReader,
+    {} as DrizzleMemoryProjectionStore,
+    {} as DrizzleSessionMutationCoordinator,
+  );
+  const receipts = new Map<string, SessionRunProjectionReceipt>();
+  const links = new PersistentAgentRunSessionLink(dbRepository, service, {
+    read: async (sessionId, runId) => receipts.get(`${sessionId}:${runId}`),
+    append: async (receipt) => {
+      receipts.set(`${receipt.sessionId}:${receipt.runId}`, receipt);
+    },
+  });
+  let resultsRead = 0;
+  let cancelled = false;
+  const eventData = [
+    { sequence: 1, type: "run.started" },
+    {
+      sequence: 2,
+      type: "tool.requested",
+      toolCallId: "call-1",
+      toolKey: "business.records.list",
+      arguments: { password: "private-canary" },
+    },
+    { sequence: 3, type: "tool.completed", toolCallId: "call-1" },
+    {
+      sequence: 4,
+      type: "usage.reported",
+      attemptSequence: 1,
+      usage: { totalTokens: 12 },
+    },
+    { sequence: 5, type: "run.completed" },
+  ];
+  const remote: AgentRuntimePort = {
+    start: (...args) => fixture.remote.start(...args),
+    health: async () => new Response(),
+    status: async (runId) => ({
+      runId,
+      status: cancelled ? "cancelled" : "completed",
+      lastSequence: 5,
+    }),
+    events: async () =>
+      new Response(
+        eventData.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""),
+      ),
+    result: async () => {
+      resultsRead++;
+      return Response.json({
+        status: "completed",
+        output: { answer: "受控测试回答" },
+      });
+    },
+    cancel: async () => {
+      cancelled = true;
+      return Response.json({ status: "cancelled" });
+    },
+  };
+  const resultMemory: SessionRunResultMemoryPort = {
+    hasProjection: async ({ sessionId, runId }) =>
+      receipts.has(`${sessionId}:${runId}`),
+    project: async ({ sessionId, runId, terminalSequence }) => {
+      const receipt: SessionRunProjectionReceipt = {
+        sessionId,
+        runId,
+        terminalSequence,
+        resultDigest: `sha256:${"a".repeat(64)}`,
+        memoryIds: ["memory-1", "memory-2"],
+        projectedAt: new Date().toISOString(),
+      };
+      receipts.set(`${sessionId}:${runId}`, receipt);
+      return receipt;
+    },
+  };
+  const facade = new AgentRunFacade(
+    modules,
+    fixture.hosts,
+    runtime,
+    remote,
+    createTestRunAuthorizationStore(),
+    undefined,
+    undefined,
+    links,
+  );
+  const workbench = new AgentWorkbenchFacade({
+    modules,
+    runtime,
+    sessions,
+    runs: new AgentWorkbenchRunReader(facade, remote),
+  });
+  const app = new Elysia().derive(() => ({ guardContext: context }));
+  registerAgentWorkbenchRoutes(app, workbench);
+  registerAgentRunRoutes(
+    app,
+    facade,
+    remote,
+    {} as RestrictedAgentToolHost,
+    "test-internal",
+    links,
+    resultMemory,
+  );
+  const create = await app.handle(
+    new Request("http://localhost/agent/admin/test-sessions", {
+      method: "POST",
+    }),
+  );
+  expect(create.status).toBe(200);
+  const { sessionId } = (await create.json()) as { sessionId: SessionId };
+  const start = await app.handle(
+    new Request("http://localhost/agent/runs", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "idempotency-key": "test-request",
+      },
+      body: JSON.stringify({
+        operationKey: "business.answer",
+        input: { question: "测试" },
+        sessionId,
+      }),
+    }),
+  );
+  expect(start.status).toBe(200);
+  expect(await start.json()).toMatchObject({ runId: "run_1" });
+  expect(
+    (await repository.read({ sessionId, afterSequence: 0, limit: 100 })).some(
+      ({ data }) => data.type === "run.linked" && data.runId === "run_1",
+    ),
+  ).toBe(true);
+  expect(fixture.remote.started[0]?.executionGrant).toMatch(/^grant_/);
+  const query = new URLSearchParams({
+    operationKey: "business.answer",
+    sessionId,
+  });
+  const events = await app.handle(
+    new Request(`http://localhost/agent/runs/run_1/events?${query}`),
+  );
+  expect(events.status).toBe(200);
+  const text = await events.text();
+  expect(text).toContain("business.records.list");
+  expect(text).not.toContain("private-canary");
+  const result = await app.handle(
+    new Request(`http://localhost/agent/runs/run_1/result?${query}`),
+  );
+  expect(result.status).toBe(200);
+  expect(await result.json()).toMatchObject({
+    output: { answer: "受控测试回答" },
+  });
+  const before = (await repository.get(sessionId))!.headSequence;
+  const detail = await app.handle(
+    new Request(
+      `http://localhost/agent/admin/session-recordings/${sessionId}?source=harness`,
+    ),
+  );
+  expect(detail.status).toBe(200);
+  const recording = (await detail.json()) as AgentWorkbenchRecordingV1;
+  expect(recording).toMatchObject({
+    mode: "read-only",
+    sideEffectPolicy: "no-reexecution",
+  });
+  expect(recording.runs[0]).toMatchObject({
+    runId: "run_1",
+    operationKey: "business.answer",
+    status: "completed",
+  });
+  expect(
+    recording.runs[0].events.map(
+      (event: { sequence: number }) => event.sequence,
+    ),
+  ).toEqual([1, 2, 3, 4, 5]);
+  expect(JSON.stringify(recording)).not.toContain("private-canary");
+  expect((await repository.get(sessionId))!.headSequence).toBe(before);
+  expect(fixture.remote.started).toHaveLength(1);
+  expect(resultsRead).toBe(2);
+});