@syengup/friday-channel-next 0.1.36 → 0.1.38

package/src/e2e/status-cors-auth.e2e.test.ts

@@ -1,6 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createAppSimulator } from "../test-support/app-simulator.js";
-import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+import {
+  createTempHistoryDir,
+  removeTempHistoryDir,
+  setMockRuntime,
+} from "../test-support/mock-runtime.js";
 import { registerFridayNextHttpRoutes } from "../http/server.js";
 
 describe("e2e status cors auth", () => {
@@ -22,7 +26,12 @@ describe("e2e status cors auth", () => {
   });
 
   it("CORS 预检", async () => {
-    setMockRuntime({ historyDir, authToken: "test-token", corsEnabled: true, allowOrigin: "https://app.example" });
+    setMockRuntime({
+      historyDir,
+      authToken: "test-token",
+      corsEnabled: true,
+      allowOrigin: "https://app.example",
+    });
     const app = createAppSimulator({ token: "test-token" });
     const res = await app.options("/friday-next/events", "https://app.example");
     expect(res.status).toBe(204);

package/src/e2e/subagent-smoke.e2e.test.ts

@@ -12,10 +12,7 @@ import {
   ensureSubagentFromSpawnTool,
   resetForTest as resetSubagentRegistry,
 } from "../agent/subagent-registry.js";
-import {
-  forwardAgentEventRaw,
-  registerFridaySessionDeviceMapping,
-} from "../friday-session.js";
+import { forwardAgentEventRaw, registerFridaySessionDeviceMapping } from "../friday-session.js";
 import { sseEmitter } from "../sse/emitter.js";
 
 const deviceId = "IOS-DEVICE-AAAA-BBBB-CCCC-DDDD";
@@ -37,17 +34,22 @@ function describeFrame(frame: { event?: string; data?: Record<string, unknown> }
     case "connected":
       return `connected  deviceId=${data.deviceId} lastSeq=${data.lastSeq}`;
     case "subagent": {
-      const extra = data.phase === "ended" ? ` outcome=${data.outcome} error=${data.error ?? "-"}` : "";
+      const extra =
+        data.phase === "ended" ? ` outcome=${data.outcome} error=${data.error ?? "-"}` : "";
       return `subagent   phase=${data.phase} runId=${data.runId ?? "(pending)"} label=${data.label ?? "-"} parentRunId=${data.parentRunId ?? "-"} depth=${data.depth}${extra}`;
     }
     case "agent": {
       const sub = data.subagent as Record<string, unknown> | undefined;
-      const subTag = sub ? ` SUB="agent:${sub.label ?? "?"}" depth=${sub.depth} parent=${sub.parentRunId ?? "-"}` : " (main)";
+      const subTag = sub
+        ? ` SUB="agent:${sub.label ?? "?"}" depth=${sub.depth} parent=${sub.parentRunId ?? "-"}`
+        : " (main)";
       const inner = (data.data ?? {}) as Record<string, unknown>;
       let detail = "";
-      if (data.stream === "thinking") detail = ` thinking: "${String(inner.text ?? "").slice(0, 50)}"`;
+      if (data.stream === "thinking")
+        detail = ` thinking: "${String(inner.text ?? "").slice(0, 50)}"`;
       else if (data.stream === "tool") detail = ` tool=${inner.name ?? "?"} phase=${inner.phase}`;
-      else if (data.stream === "assistant") detail = ` text="${String(inner.text ?? inner.phase ?? "")}"`;
+      else if (data.stream === "assistant")
+        detail = ` text="${String(inner.text ?? inner.phase ?? "")}"`;
       else if (data.stream === "lifecycle") detail = ` phase=${inner.phase}`;
       return `agent      stream=${data.stream} runId=${String(data.runId).slice(0, 30)}…${subTag}${detail}`;
     }
@@ -72,8 +74,11 @@ describe("subagent smoke", () => {
 
     // ── Main run lifecycle start ──────────────────────────
     forwardAgentEventRaw({
-      runId: mainRunId, seq: 1, stream: "lifecycle",
-      sessionKey: mainSessionKey, data: { phase: "start" },
+      runId: mainRunId,
+      seq: 1,
+      stream: "lifecycle",
+      sessionKey: mainSessionKey,
+      data: { phase: "start" },
     });
 
     // ── Subagent A: tool.start (spawning) ─────────────────
@@ -82,10 +87,13 @@ describe("subagent smoke", () => {
     const compoundA = `announce:v1:${childKeyA}:${bareA}`;
 
     forwardAgentEventRaw({
-      runId: mainRunId, seq: 2, stream: "tool",
+      runId: mainRunId,
+      seq: 2,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "start", name: "sessions_spawn",
+        phase: "start",
+        name: "sessions_spawn",
         toolCallId: "call_a",
         args: { taskName: "code-reviewer" },
       },
@@ -93,10 +101,14 @@ describe("subagent smoke", () => {
 
     // ── Subagent A: tool.result (spawned) ─────────────────
     forwardAgentEventRaw({
-      runId: mainRunId, seq: 3, stream: "tool",
+      runId: mainRunId,
+      seq: 3,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "result", name: "sessions_spawn", toolCallId: "call_1",
+        phase: "result",
+        name: "sessions_spawn",
+        toolCallId: "call_1",
         meta: "code-reviewer",
         result: { details: spawnResult(childKeyA, bareA, "code-reviewer") },
       },
@@ -105,26 +117,41 @@ describe("subagent smoke", () => {
 
     // ── Subagent A: agent events (subagent's own sessionKey) ─
     forwardAgentEventRaw({
-      runId: compoundA, seq: 1, stream: "lifecycle",
-      data: { phase: "start" }, sessionKey: childKeyA,
+      runId: compoundA,
+      seq: 1,
+      stream: "lifecycle",
+      data: { phase: "start" },
+      sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 2, stream: "thinking",
-      data: { text: "Let me review the code for issues…", delta: "Let me review the code for issues…", reasoningPrefixChars: 0 },
+      runId: compoundA,
+      seq: 2,
+      stream: "thinking",
+      data: {
+        text: "Let me review the code for issues…",
+        delta: "Let me review the code for issues…",
+        reasoningPrefixChars: 0,
+      },
       sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 3, stream: "tool",
+      runId: compoundA,
+      seq: 3,
+      stream: "tool",
       data: { phase: "start", name: "read", args: { path: "src/app.ts" } },
       sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 4, stream: "tool",
+      runId: compoundA,
+      seq: 4,
+      stream: "tool",
       data: { phase: "result", name: "read", result: "file contents…" },
       sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 5, stream: "assistant",
+      runId: compoundA,
+      seq: 5,
+      stream: "assistant",
       data: { phase: "delta", text: "Found 3 issues in the code." },
       sessionKey: childKeyA,
     });
@@ -135,20 +162,27 @@ describe("subagent smoke", () => {
     const compoundB = `announce:v1:${childKeyB}:${bareB}`;
 
     forwardAgentEventRaw({
-      runId: compoundA, seq: 7, stream: "tool",
+      runId: compoundA,
+      seq: 7,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "start", name: "sessions_spawn",
+        phase: "start",
+        name: "sessions_spawn",
         toolCallId: "call_b",
         args: { taskName: "lint" },
       },
     });
 
     forwardAgentEventRaw({
-      runId: compoundA, seq: 8, stream: "tool",
+      runId: compoundA,
+      seq: 8,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "result", name: "sessions_spawn", toolCallId: "call_2",
+        phase: "result",
+        name: "sessions_spawn",
+        toolCallId: "call_2",
         meta: "lint",
         result: { details: spawnResult(childKeyB, bareB, "lint") },
       },
@@ -157,21 +191,27 @@ describe("subagent smoke", () => {
 
     // ── Subagent B: agent event (subagent's own sessionKey) ─
     forwardAgentEventRaw({
-      runId: compoundB, seq: 1, stream: "assistant",
+      runId: compoundB,
+      seq: 1,
+      stream: "assistant",
       data: { phase: "delta", text: "No lint errors found." },
       sessionKey: childKeyB,
     });
 
     // ── Subagent B ended (subagent's own sessionKey) ──────
     forwardAgentEventRaw({
-      runId: compoundB, seq: 2, stream: "lifecycle",
+      runId: compoundB,
+      seq: 2,
+      stream: "lifecycle",
       data: { phase: "end" },
       sessionKey: childKeyB,
     });
 
     // ── Subagent A ended (subagent's own sessionKey) ──────
     forwardAgentEventRaw({
-      runId: compoundA, seq: 7, stream: "lifecycle",
+      runId: compoundA,
+      seq: 7,
+      stream: "lifecycle",
       data: { phase: "end" },
       sessionKey: childKeyA,
     });

package/src/e2e/subagent.e2e.test.ts

@@ -203,15 +203,20 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Main run start
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       const broadcastCalls = captureBroadcastCalls();
 
       // Simulate sessions_spawn tool result
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
           phase: "result",
@@ -243,17 +248,30 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Main run
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       // Spawn subagent
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId, taskName: "cr" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKey,
+              runId: bareRunId,
+              taskName: "cr",
+            }),
+          },
         },
       });
 
@@ -264,14 +282,14 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Agent event for subagent (announce runId, subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 1, stream: "thinking",
+        runId: compoundRunId,
+        seq: 1,
+        stream: "thinking",
         data: { text: "reviewing..." },
         sessionKey: childKey,
       });
 
-      const agentCall = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "thinking",
-      );
+      const agentCall = calls.find(([, e]) => e.type === "agent" && e.data.stream === "thinking");
       expect(agentCall).toBeTruthy();
       expect(agentCall![1].data.subagent).toEqual({
         label: "cr",
@@ -282,21 +300,24 @@ describe("subagent via sessions_spawn tool", () => {
 
     it("main agent events are NOT annotated", () => {
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       const calls = captureBroadcastToRunCalls();
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "assistant",
+        runId: mainRunId,
+        seq: 2,
+        stream: "assistant",
         sessionKey: mainSessionKey,
         data: { text: "main reply" },
       });
 
-      const agentCall = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "assistant",
-      );
+      const agentCall = calls.find(([, e]) => e.type === "agent" && e.data.stream === "assistant");
       expect(agentCall![1].data.subagent).toBeUndefined();
     });
 
@@ -305,16 +326,29 @@ describe("subagent via sessions_spawn tool", () => {
       const bareRunId = "bare-cr";
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId, taskName: "cr" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKey,
+              runId: bareRunId,
+              taskName: "cr",
+            }),
+          },
         },
       });
 
@@ -325,7 +359,9 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Lifecycle end for subagent (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 5, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKey,
       });
@@ -342,15 +378,22 @@ describe("subagent via sessions_spawn tool", () => {
       const bareRunId = "bare-cr";
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
           result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId }) },
         },
       });
@@ -361,7 +404,9 @@ describe("subagent via sessions_spawn tool", () => {
       const broadcastCalls = captureBroadcastCalls();
 
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 5, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "error", error: "timeout" },
         sessionKey: childKey,
       });
@@ -379,15 +424,22 @@ describe("subagent via sessions_spawn tool", () => {
       const bareRunId = "bare-cr";
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
           result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId }) },
         },
       });
@@ -398,12 +450,16 @@ describe("subagent via sessions_spawn tool", () => {
       const broadcastCalls = captureBroadcastCalls();
 
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 5, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKey,
       });
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 6, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 6,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKey,
       });
@@ -426,17 +482,30 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Main run start
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       // sessions_spawn for A
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKeyA, runId: bareA, taskName: "reviewer" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKeyA,
+              runId: bareA,
+              taskName: "reviewer",
+            }),
+          },
         },
       });
       sseEmitter.trackDeviceForRun(deviceId, compoundA);
@@ -444,13 +513,13 @@ describe("subagent via sessions_spawn tool", () => {
       // Subagent A thinking (subagent's own sessionKey)
       const calls = captureBroadcastToRunCalls();
       forwardAgentEventRaw({
-        runId: compoundA, seq: 1, stream: "thinking",
+        runId: compoundA,
+        seq: 1,
+        stream: "thinking",
         data: { text: "reviewing code..." },
         sessionKey: childKeyA,
       });
-      const thinkingA = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "thinking",
-      );
+      const thinkingA = calls.find(([, e]) => e.type === "agent" && e.data.stream === "thinking");
       expect(thinkingA![1].data.subagent).toEqual({
         label: "reviewer",
         parentRunId: mainRunId,
@@ -461,36 +530,50 @@ describe("subagent via sessions_spawn tool", () => {
       // In reality, B is spawned from a tool call inside A's run, but here we simulate it from the main run
       // The registry handles nesting via requesterSessionKey chain
       forwardAgentEventRaw({
-        runId: compoundA, seq: 2, stream: "tool",
+        runId: compoundA,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c2",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKeyB, runId: bareB, taskName: "lint" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c2",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKeyB,
+              runId: bareB,
+              taskName: "lint",
+            }),
+          },
         },
       });
       sseEmitter.trackDeviceForRun(deviceId, compoundB);
 
       // Subagent B thinking (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundB, seq: 1, stream: "assistant",
+        runId: compoundB,
+        seq: 1,
+        stream: "assistant",
         data: { text: "no lint errors" },
         sessionKey: childKeyB,
       });
-      const assistantB = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "assistant",
-      );
+      const assistantB = calls.find(([, e]) => e.type === "agent" && e.data.stream === "assistant");
       expect(assistantB![1].data.subagent).toBeDefined();
 
       // B ends (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundB, seq: 5, stream: "lifecycle",
+        runId: compoundB,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKeyB,
       });
 
       // A ends (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundA, seq: 6, stream: "lifecycle",
+        runId: compoundA,
+        seq: 6,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKeyA,
       });

package/src/e2e/tool-lifecycle.e2e.test.ts

@@ -1,7 +1,11 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { createAppSimulator } from "../test-support/app-simulator.js";
 import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
-import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+import {
+  createTempHistoryDir,
+  removeTempHistoryDir,
+  setMockRuntime,
+} from "../test-support/mock-runtime.js";
 
 describe("e2e tool lifecycle", () => {
   let historyDir = "";