@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/streaming-message.ts

@@ -0,0 +1,151 @@
+import type { ClientAssistantMessageEvent } from "./agent-event-wire";
+import { normalizeStreamingToolCalls } from "./normalize";
+import type {
+  AgentMessage,
+  AssistantContentBlock,
+  AssistantMessage,
+} from "./types";
+
+export type { ClientAssistantMessageEvent } from "./agent-event-wire";
+
+export interface StreamingState {
+  isStreaming: boolean;
+  streamingMessage: AssistantMessage | null;
+}
+
+export type StreamAction =
+  | { type: "start" }
+  | { type: "snapshot"; message: AgentMessage }
+  | { type: "delta"; event: ClientAssistantMessageEvent }
+  | { type: "end" };
+
+export const INITIAL_STREAMING_STATE: StreamingState = {
+  isStreaming: false,
+  streamingMessage: null,
+};
+
+function updateContentBlock(
+  state: StreamingState,
+  contentIndex: number,
+  update: (current: AssistantContentBlock | undefined) => AssistantContentBlock | null,
+): StreamingState {
+  const message = state.streamingMessage;
+  if (!message || !Number.isInteger(contentIndex) || contentIndex < 0) return state;
+
+  const content = [...message.content];
+  const nextBlock = update(content[contentIndex]);
+  if (!nextBlock) return state;
+  content[contentIndex] = nextBlock;
+  return {
+    isStreaming: true,
+    streamingMessage: { ...message, content },
+  };
+}
+
+function applyDelta(
+  state: StreamingState,
+  event: ClientAssistantMessageEvent,
+): StreamingState {
+  switch (event.type) {
+    case "text_start":
+      return updateContentBlock(state, event.contentIndex, (current) => (
+        current?.type === "text" ? current : { type: "text", text: "" }
+      ));
+    case "text_delta":
+      return updateContentBlock(state, event.contentIndex, (current) => (
+        current?.type === "text"
+          ? { ...current, text: current.text + event.delta }
+          : null
+      ));
+    case "text_end":
+      return updateContentBlock(state, event.contentIndex, (current) => ({
+        ...(current?.type === "text" ? current : {}),
+        type: "text",
+        text: event.content,
+      }));
+    case "thinking_start":
+      return updateContentBlock(state, event.contentIndex, (current) => (
+        current?.type === "thinking" ? current : { type: "thinking", thinking: "" }
+      ));
+    case "thinking_delta":
+      return updateContentBlock(state, event.contentIndex, (current) => (
+        current?.type === "thinking"
+          ? { ...current, thinking: current.thinking + event.delta }
+          : null
+      ));
+    case "thinking_end":
+      return updateContentBlock(state, event.contentIndex, (current) => ({
+        ...(current?.type === "thinking" ? current : {}),
+        type: "thinking",
+        thinking: event.content,
+      }));
+    case "toolcall_start":
+      return updateContentBlock(state, event.contentIndex, (current) => {
+        if (current?.type === "toolCall") {
+          return {
+            ...current,
+            toolCallId: event.id ?? current.toolCallId,
+            toolName: event.toolName ?? current.toolName,
+            rawInput: current.rawInput ?? "",
+          };
+        }
+        if (typeof event.toolName !== "string") return null;
+        return {
+          type: "toolCall",
+          toolCallId: event.id ?? "",
+          toolName: event.toolName,
+          input: {},
+          rawInput: "",
+        };
+      });
+    case "toolcall_delta":
+      return updateContentBlock(state, event.contentIndex, (current) => (
+        current?.type === "toolCall"
+          ? {
+            ...current,
+            toolCallId: event.id || current.toolCallId,
+            toolName: event.toolName || current.toolName,
+            rawInput: (current.rawInput ?? "") + event.delta,
+          }
+          : null
+      ));
+    case "toolcall_end":
+      return updateContentBlock(state, event.contentIndex, () => ({
+        type: "toolCall",
+        toolCallId: event.toolCall.id,
+        toolName: event.toolCall.name,
+        input: event.toolCall.arguments,
+      }));
+    default:
+      return state;
+  }
+}
+
+export function streamReducer(
+  state: StreamingState,
+  action: StreamAction,
+): StreamingState {
+  switch (action.type) {
+    case "start":
+      // A late `start` (e.g. the mount-time state restore finishing after the
+      // SSE reconnect already replayed the partial message via `snapshot`)
+      // must not wipe an in-flight streaming message. Clearing it here would
+      // drop every subsequent text delta (applyDelta needs an existing block)
+      // and freeze the typewriter until the whole message lands at message_end.
+      return state.streamingMessage
+        ? { ...state, isStreaming: true }
+        : { isStreaming: true, streamingMessage: null };
+    case "snapshot": {
+      const message = normalizeStreamingToolCalls(action.message);
+      return message.role === "assistant"
+        ? { isStreaming: true, streamingMessage: message }
+        : state;
+    }
+    case "delta":
+      return applyDelta(state, action.event);
+    case "end":
+      return INITIAL_STREAMING_STATE;
+    default:
+      return state;
+  }
+}

package/lib/subagent-widget.test.mjs

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  try {
+    const { createJiti } = await import("jiti");
+    return createJiti(import.meta.url).import("./subagent-widget.ts");
+  } catch {
+    return import("./subagent-widget.ts");
+  }
+}
+
+const {
+  parseSubagentSnapshot,
+  parseSubagentInspectReply,
+  widgetParsers,
+  SUBAGENT_ASYNC_JSON_PREFIX,
+  SUBAGENT_INSPECT_JSON_PREFIX,
+} = await loadSubject();
+
+const SNAPSHOT = {
+  kind: "pi-subagents.async-status-snapshot",
+  version: 1,
+  generatedAt: 1787999999000,
+  caps: { maxRuns: 20, maxChildrenPerNode: 8, maxDepth: 3, maxStringLength: 160, maxSerializedBytes: 32768 },
+  omitted: { runs: 0, children: 0, byteLimitExceeded: false },
+  runs: [
+    {
+      id: "run-1",
+      kind: "subagent",
+      label: "worker",
+      state: "running",
+      startedAt: 1787999998000,
+      activity: { currentTool: "read", toolCount: 3 },
+    },
+  ],
+};
+
+test("解析正常快照，字段映射正确", () => {
+  const lines = [`${SUBAGENT_ASYNC_JSON_PREFIX}${JSON.stringify(SNAPSHOT)}`];
+  const parsed = parseSubagentSnapshot(lines);
+  assert.ok(parsed);
+  assert.equal(parsed.kind, "pi-subagents.async-status-snapshot");
+  assert.equal(parsed.runs.length, 1);
+  assert.equal(parsed.runs[0].label, "worker");
+  assert.equal(parsed.runs[0].state, "running");
+  assert.equal(parsed.runs[0].activity?.currentTool, "read");
+});
+
+test("非 JSON 前缀返回 null", () => {
+  assert.equal(parseSubagentSnapshot(["plain text line"]), null);
+});
+
+test("前缀对但 JSON 非法返回 null", () => {
+  assert.equal(parseSubagentSnapshot([`${SUBAGENT_ASYNC_JSON_PREFIX}{not-json`]), null);
+});
+
+test("前缀对但 kind 不符返回 null", () => {
+  const lines = [`${SUBAGENT_ASYNC_JSON_PREFIX}${JSON.stringify({ kind: "other.kind", runs: [] })}`];
+  assert.equal(parseSubagentSnapshot(lines), null);
+});
+
+test("runs 非数组返回 null", () => {
+  const lines = [
+    `${SUBAGENT_ASYNC_JSON_PREFIX}${JSON.stringify({ kind: "pi-subagents.async-status-snapshot", runs: "nope" })}`,
+  ];
+  assert.equal(parseSubagentSnapshot(lines), null);
+});
+
+test("解析 inspect 回包", () => {
+  const reply = {
+    kind: "pi-subagents.inspect-reply",
+    version: 1,
+    requestId: "req-1",
+    asyncId: "run-1",
+    status: "running",
+    messages: [{ role: "assistant", kind: "toolCall", name: "read", text: "read src/a.ts" }],
+  };
+  const parsed = parseSubagentInspectReply([`${SUBAGENT_INSPECT_JSON_PREFIX}${JSON.stringify(reply)}`]);
+  assert.ok(parsed);
+  assert.equal(parsed.requestId, "req-1");
+  assert.equal(parsed.messages?.[0].kind, "toolCall");
+});
+
+test("注册表骨架含 subagent-async 解析器", () => {
+  assert.equal(typeof widgetParsers["subagent-async"], "function");
+});

package/lib/subagent-widget.ts

@@ -0,0 +1,109 @@
+/**
+ * subagent widget 快照解析 + 注册表骨架。
+ *
+ * pi-subagents 在 RPC 模式下把异步子任务状态压成单行 JSON 推给 pi-web：
+ *   widget key: "subagent-async"
+ *   首行前缀:   "PI_SUBAGENT_ASYNC_JSON:" + JSON.stringify(AsyncStatusSnapshotV1)
+ *
+ * 这里只做「识别 + 解析」，渲染在 components/subagent/*。
+ * 注册表骨架：未来其他插件若也用「带标记的 JSON 行」推结构化内容，
+ * 在 widgetParsers 里加一条即可，pi-web 无需改渲染主流程。
+ */
+
+export const SUBAGENT_ASYNC_WIDGET_KEY = "subagent-async";
+export const SUBAGENT_INSPECT_WIDGET_KEY = "subagent-inspect";
+export const SUBAGENT_FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
+export const SUBAGENT_ASYNC_JSON_PREFIX = "PI_SUBAGENT_ASYNC_JSON:";
+export const SUBAGENT_INSPECT_JSON_PREFIX = "PI_SUBAGENT_INSPECT_JSON:";
+
+/** pi-subagents 推的、在 pi-web 里不应作为可见 widget 渲染的 key（纯数据传输 / TUI 专属） */
+export const SUBAGENT_HIDDEN_WIDGET_KEYS = new Set([
+  SUBAGENT_ASYNC_WIDGET_KEY,
+  SUBAGENT_INSPECT_WIDGET_KEY,
+  SUBAGENT_FLEET_STATUS_WIDGET_KEY,
+]);
+
+/** pi-subagents AsyncStatusSnapshotV1 的节点结构（对齐插件侧，只取展示所需字段） */
+export interface SubagentSnapshotNode {
+  id: string;
+  kind: "subagent" | "workflow" | "step" | "host-step";
+  label: string;
+  state:
+    | "queued"
+    | "running"
+    | "complete"
+    | "failed"
+    | "partial"
+    | "paused"
+    | "stopped"
+    | "rejected";
+  startedAt?: number;
+  endedAt?: number;
+  activity?: {
+    state?: string;
+    currentTool?: string;
+    turnCount?: number;
+    toolCount?: number;
+  };
+  children?: SubagentSnapshotNode[];
+}
+
+export interface SubagentSnapshot {
+  kind: string;
+  version: number;
+  generatedAt: number;
+  runs: SubagentSnapshotNode[];
+}
+
+export interface SubagentInspectMessage {
+  role: string;
+  kind: "text" | "toolCall" | "toolResult";
+  text: string;
+  name?: string;
+  isError?: boolean;
+}
+
+/** pi-subagents.inspect-reply v1 */
+export interface SubagentInspectReply {
+  kind: string;
+  version: number;
+  requestId: string;
+  asyncId?: string;
+  childId?: string;
+  status?: string;
+  label?: string;
+  task?: string;
+  messages?: SubagentInspectMessage[];
+  finalOutput?: string;
+  error?: { code: string; message: string };
+}
+
+function parsePrefixedJson<T>(line: string | undefined, prefix: string): T | null {
+  if (!line || !line.startsWith(prefix)) return null;
+  try {
+    return JSON.parse(line.slice(prefix.length)) as T;
+  } catch {
+    return null;
+  }
+}
+
+/** 解析 subagent-async widget 快照；非本插件内容或解析失败返回 null */
+export function parseSubagentSnapshot(lines: string[]): SubagentSnapshot | null {
+  const raw = parsePrefixedJson<SubagentSnapshot>(lines[0], SUBAGENT_ASYNC_JSON_PREFIX);
+  if (!raw || raw.kind !== "pi-subagents.async-status-snapshot" || !Array.isArray(raw.runs)) {
+    return null;
+  }
+  return raw;
+}
+
+/** 解析 subagent-inspect 回包（emit-then-retract 的 emit 帧） */
+export function parseSubagentInspectReply(lines: string[]): SubagentInspectReply | null {
+  const raw = parsePrefixedJson<SubagentInspectReply>(lines[0], SUBAGENT_INSPECT_JSON_PREFIX);
+  if (!raw || raw.kind !== "pi-subagents.inspect-reply") return null;
+  return raw;
+}
+
+/** 注册表骨架：widget key → 解析器。现在只注册 subagent，未来插件加条目即可。 */
+export const widgetParsers: Record<string, (lines: string[]) => unknown | null> = {
+  [SUBAGENT_ASYNC_WIDGET_KEY]: parseSubagentSnapshot,
+};

package/lib/sync-room-server.mjs

@@ -0,0 +1,137 @@
+// ============================================================================
+// tldraw sync 房间服务器核心（可内嵌 Next.js server，也可独立进程）
+//   - 每看板一个 TLSocketRoom + SQLiteSyncStorage（sync.db，tablePrefix 按 board 隔离）
+//   - 纯文档同步：不懂业务，派生边/补卡由前端 reconcile（读业务数据 → CRDT 写文档）
+//   - 自定义 shape（session-card / task-card / sticky-note）两端注册
+//
+// 用法（内嵌）：server.on("upgrade", handleSyncUpgrade) —— 返回 false 表示未处理，调用方转交 Next
+// 用法（独立）：见 scripts/sync-server.mjs
+// ============================================================================
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join, normalize } from "node:path";
+
+const { DatabaseSync } = require("node:sqlite");
+const { WebSocketServer } = require("ws");
+const core = require("@tldraw/sync-core");
+const tlschema = require("@tldraw/tlschema");
+const T = require("@tldraw/validate").T;
+
+// ---- agent dir（与 lib/sqlite-db.ts 同语义）----
+export function getAgentDir() {
+  const envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) {
+    const expanded = envDir.startsWith("~") ? join(homedir(), envDir.slice(1)) : envDir;
+    return normalize(expanded);
+  }
+  return join(homedir(), ".pi", "agent");
+}
+export const SYNC_DB_FILE = join(getAgentDir(), "sync.db");
+
+// ---- 自定义 shape props 校验器（与 components/canvas/{SessionCardShape,StickyNoteShape,TaskCardShape}.tsx 保持一致）----
+const sessionCardProps = {
+  sessionId: T.string, title: T.string, projectName: T.string,
+  messageCount: T.number, lastReply: T.string, phase: T.string,
+  runningMs: T.number, endedAt: T.number, lastActivityAt: T.number,
+  stale: T.boolean, expanded: T.boolean, cwd: T.string, taskId: T.string,
+  w: T.number, h: T.number, expandedW: T.number, expandedH: T.number,
+  collapsedW: T.number, collapsedH: T.number,
+};
+const stickyNoteProps = {
+  text: T.string, w: T.number, h: T.number,
+  badge: T.string.optional(), createdAt: T.number.optional(),
+};
+const taskCardProps = {
+  cardId: T.string, number: T.number, name: T.string,
+  description: T.string.optional(), readyStatus: T.string, execStatus: T.string, priority: T.number,
+  // due：业务层允许 number | null（无截止=null）。shape 写入可能带 null（草稿初始化/API 回读），
+  // 必须 nullable 否则 sync 校验失败 → INVALID_RECORD → 画布永远 loading（派发后看板死掉根因）
+  due: T.number.nullable().optional(), expanded: T.boolean,
+  w: T.number, h: T.number, expandedW: T.number, expandedH: T.number,
+  collapsedW: T.number, collapsedH: T.number,
+};
+
+export const syncSchema = tlschema.createTLSchema({
+  shapes: {
+    ...tlschema.defaultShapeSchemas,
+    "session-card": { props: sessionCardProps },
+    "sticky-note": { props: stickyNoteProps },
+    "task-card": { props: taskCardProps },
+  },
+  bindings: { ...tlschema.defaultBindingSchemas },
+  assets: { ...tlschema.defaultAssetSchemas },
+});
+
+// ---- 房间管理：每 boardId 一个 TLSocketRoom；SQLite 持久化（同一 sync.db，tablePrefix 隔离）----
+// 单一 DatabaseSync 连接（node:sqlite 同步，单连接线程安全）
+const db = new DatabaseSync(SYNC_DB_FILE);
+const rooms = new Map();
+
+function safePrefix(boardId) {
+  return `board_${boardId.replace(/[^a-zA-Z0-9_]/g, "_")}_`;
+}
+
+export function getSyncRoom(boardId) {
+  let room = rooms.get(boardId);
+  if (room) return room;
+  const storage = new core.SQLiteSyncStorage({
+    sql: new core.NodeSqliteWrapper(db, { tablePrefix: safePrefix(boardId) }),
+  });
+  room = new core.TLSocketRoom({
+    // clientTimeout 不能传 0：0 会让 pruneSessions 把所有 Connected 会话当超时踢掉
+    // （timeSince > 0 恒真）→ 客户端重连风暴。传 undefined 用默认 20s 空闲超时，
+    // ping 每 5s 保活，正常不会触发。
+    storage, schema: syncSchema, clientTimeout: undefined,
+    // INVALID_RECORD 等致命错误会走 log.error（带 TLSyncError 对象）——hook 它打印详情
+    log: {
+      warn: (...a) => console.warn("[sync:room]", ...a),
+      error: (...a) => {
+        const err = a[0];
+        const detail = err instanceof Error ? `${err.message}${err.reason ? ` [reason=${err.reason}]` : ""}` : JSON.stringify(a).slice(0, 500);
+        console.error("[sync:room]", detail);
+      },
+    },
+  });
+  rooms.set(boardId, room);
+  return room;
+}
+
+export function getSyncRoomCount() {
+  return rooms.size;
+}
+
+// noServer WSS：不做端口监听，只负责把 upgrade 的 net.Socket 握手成 ws 实例
+const wss = new WebSocketServer({ noServer: true });
+
+/**
+ * 处理一条 WebSocket upgrade 请求（挂在 Node http server 的 "upgrade" 事件）。
+ * 路径匹配 /connect/:boardId → 房间接管；否则返回 false（调用方转交 Next 自身 handler，如 HMR）。
+ * @returns {boolean} 是否已处理
+ */
+export function handleSyncUpgrade(req, socket, head) {
+  let url;
+  try {
+    url = new URL(req.url, "http://localhost");
+  } catch {
+    return false;
+  }
+  const m = url.pathname.match(/^\/connect\/([^/]+)$/);
+  if (!m) return false;
+
+  const boardId = decodeURIComponent(m[1]);
+  const room = getSyncRoom(boardId);
+  // sessionId 必须复用客户端提供的（useSync 每次重连带固定 TAB_ID）——
+  // 若随机生成，重连被当成新会话，服务器端 session 堆积、协议错乱。
+  const sessionId = url.searchParams.get("sessionId") ?? randomUUID();
+
+  // 握手成功后 ws 即为 EventTarget 兼容实例；handleSocketConnect 自动挂
+  // message/close/error 监听。绝不手动再 ws.on("message")——否则每条消息处理
+  // 两次 → push_result 双发 → 重连死循环。
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    room.handleSocketConnect({ sessionId, socket: ws, isReadonly: false });
+    console.log(`[sync] ${boardId}: client ${sessionId.slice(0, 8)} connected (${room.getNumActiveSessions()})`);
+  });
+  return true;
+}