@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/rpc-session-info.test.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+});
+const { getRpcSessionInfos } = await jiti.import("./rpc-manager.ts");
+
+function makeRuntimeSession({ id, filePath, running, entries }) {
+  const timestamp = "2026-08-12T01:02:03.000Z";
+  const manager = {
+    getHeader: () => ({ type: "session", id, cwd: "/tmp/runtime-cwd", timestamp }),
+    getEntries: () => entries,
+    getSessionFile: () => filePath,
+    getSessionName: () => undefined,
+  };
+  return {
+    isAlive: () => true,
+    isRunning: () => running,
+    inner: { sessionManager: manager },
+    get sessionId() { return id; },
+    get sessionFile() { return filePath; },
+    get cwd() { return "/tmp/runtime-cwd"; },
+  };
+}
+
+test("lists an accepted new prompt before its session file exists", (t) => {
+  const previousRegistry = globalThis.__piSessions;
+  const timestamp = "2026-08-12T01:02:04.000Z";
+  const visible = makeRuntimeSession({
+    id: "visible-runtime",
+    filePath: join(tmpdir(), "pi-web-missing-runtime-session.jsonl"),
+    running: true,
+    entries: [{
+      type: "message",
+      id: "u1",
+      parentId: null,
+      timestamp,
+      message: {
+        role: "user",
+        content: [{ type: "text", text: "first" }, { type: "text", text: "prompt" }],
+      },
+    }],
+  });
+  const emptyEnsureSession = makeRuntimeSession({
+    id: "empty-runtime",
+    filePath: join(tmpdir(), "pi-web-missing-empty-session.jsonl"),
+    running: false,
+    entries: [],
+  });
+  globalThis.__piSessions = new Map([
+    ["visible-runtime", visible],
+    ["empty-runtime", emptyEnsureSession],
+  ]);
+  t.after(() => {
+    globalThis.__piSessions = previousRegistry;
+  });
+
+  const infos = getRpcSessionInfos();
+
+  assert.equal(infos.length, 1);
+  assert.equal(infos[0].id, "visible-runtime");
+  assert.equal(infos[0].firstMessage, "first prompt");
+  assert.equal(infos[0].messageCount, 1);
+  assert.equal(infos[0].transient, true);
+});
+
+test("keeps an idle runtime visible once its JSONL file exists", (t) => {
+  const previousRegistry = globalThis.__piSessions;
+  const dir = mkdtempSync(join(tmpdir(), "pi-web-runtime-session-"));
+  const filePath = join(dir, "session.jsonl");
+  writeFileSync(filePath, "persisted\n");
+  globalThis.__piSessions = new Map([["persisted-runtime", makeRuntimeSession({
+    id: "persisted-runtime",
+    filePath,
+    running: false,
+    entries: [],
+  })]]);
+  t.after(() => {
+    globalThis.__piSessions = previousRegistry;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const infos = getRpcSessionInfos();
+
+  assert.equal(infos.length, 1);
+  assert.equal(infos[0].transient, false);
+});

package/lib/session-delete.test.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { interopDefault: true, moduleCache: false });
+const { collectSessionDescendants } = await jiti.import("./session-delete.ts");
+const { cacheSessionPath } = await jiti.import("./session-reader.ts");
+
+function sessionFile(dir, id, parentPath) {
+  const p = join(dir, `${Date.now()}_${id}.jsonl`);
+  const header = {
+    type: "session",
+    version: 3,
+    id,
+    timestamp: new Date().toISOString(),
+    cwd: dir,
+    ...(parentPath ? { parentSession: parentPath } : {}),
+  };
+  writeFileSync(p, JSON.stringify(header) + "\n");
+  return p;
+}
+
+test("collectSessionDescendants walks the whole fork tree (multi-level)", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "pi-sd-"));
+  try {
+    const rootPath = sessionFile(dir, "root-id");
+    const child1Path = sessionFile(dir, "child1", rootPath);
+    sessionFile(dir, "child2", child1Path); // 两级分叉：child1 → child2
+    sessionFile(dir, "unrelated", undefined); // 无 parentSession 的无关会话
+    // 注入路径缓存，resolveSessionPath 命中后不触碰真实 sessions 目录。
+    cacheSessionPath("root-id", rootPath);
+
+    const ids = await collectSessionDescendants("root-id");
+    assert.deepEqual(ids.sort(), ["root-id", "child1", "child2"].sort());
+    assert.ok(!ids.includes("unrelated"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("collectSessionDescendants returns the root alone when there are no forks", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "pi-sd-"));
+  try {
+    const rootPath = sessionFile(dir, "root-alone");
+    cacheSessionPath("root-alone", rootPath);
+    assert.deepEqual(await collectSessionDescendants("root-alone"), ["root-alone"]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/lib/session-delete.ts

@@ -0,0 +1,86 @@
+// 会话文件树删除 —— 供「删除任务 = 删除任务下所有会话（含 fork 子树）」使用。
+//
+// 与单个会话删除（app/api/sessions/[id] DELETE）不同：那里删一个节点并把
+// 子树级联重挂到父级；这里整棵树全部删除，不做重挂。
+
+import { readdirSync, unlinkSync } from "fs";
+import { dirname, join } from "path";
+import {
+  invalidateSessionListCache,
+  invalidateSessionPathCache,
+  readSessionHeader,
+  resolveSessionPath,
+} from "./session-reader";
+import { sessionPathKey } from "./session-path";
+import { getRpcSession } from "./rpc-manager";
+import { unassignSession } from "./task-store";
+import { removeSessionFromBoards } from "./board-store";
+
+/** 递归收集一个会话的全部 fork 后代 id（含自身）。 */
+export async function collectSessionDescendants(rootId: string): Promise<string[]> {
+  const rootPath = await resolveSessionPath(rootId);
+  if (!rootPath) return [rootId];
+  const dir = dirname(rootPath);
+  const keySet = new Set<string>([sessionPathKey(rootPath)]);
+  const ids = [rootId];
+  let files: string[];
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [rootId];
+  }
+  // 迭代扫描：parentSession 指向已收集集合的 .jsonl 全部纳入（支持多级分叉）。
+  let added = true;
+  while (added) {
+    added = false;
+    for (const file of files) {
+      const p = join(dir, file);
+      const pk = sessionPathKey(p);
+      if (keySet.has(pk)) continue;
+      const header = readSessionHeader(p);
+      if (header?.parentSession && keySet.has(sessionPathKey(header.parentSession))) {
+        keySet.add(pk);
+        ids.push(header.id);
+        added = true;
+      }
+    }
+  }
+  return ids;
+}
+
+/** 删除单个会话文件（含 RPC/路径缓存/列表缓存/任务元数据/画布引用），不重挂子树。 */
+export async function deleteSessionFile(id: string): Promise<void> {
+  // 画布引用清理（断 exec 线/清任务卡/删节点）：无文件也执行，幂等；
+  // 任务整树删除时任务看板已由 deleteBoardCascade 清，此处对手动看板残留兜底。
+  removeSessionFromBoards(id);
+  const filePath = await resolveSessionPath(id);
+  if (!filePath) return;
+  await getRpcSession(id)?.shutdown();
+  try {
+    unlinkSync(filePath); // 文件已被并发删除/缓存残留时忽略（健壮删除）
+  } catch { /* ignore */ }
+  invalidateSessionPathCache(id);
+  invalidateSessionListCache();
+  unassignSession(id);
+}
+
+/**
+ * 删除一组会话（每个根会话连同其 fork 子树），返回实际删除的全部会话 id。
+ * 单个文件失败不中断其余删除。
+ */
+export async function deleteSessionTrees(rootIds: string[]): Promise<string[]> {
+  const seen = new Set<string>();
+  const deleted: string[] = [];
+  for (const rootId of rootIds) {
+    const ids = await collectSessionDescendants(rootId);
+    for (const id of ids) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      try {
+        await deleteSessionFile(id);
+        deleted.push(id);
+      } catch { /* keep deleting the rest */ }
+    }
+  }
+  return deleted;
+}

package/lib/session-file-references-core.ts

@@ -0,0 +1,82 @@
+import type { SessionEntry } from "./types";
+
+const SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export function isValidSessionId(sessionId: string | null): sessionId is string {
+  return !!sessionId && SESSION_ID_RE.test(sessionId);
+}
+
+function safeDecode(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function normalizeSlashes(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+function isPathChar(ch: string): boolean {
+  return /[A-Za-z0-9._~+%@/\\:-]/.test(ch);
+}
+
+function hasReferenceBoundaryAfter(text: string, index: number): boolean {
+  if (index >= text.length) return true;
+  const ch = text[index];
+  if (ch === ":") return /\d/.test(text[index + 1] ?? "");
+  return !isPathChar(ch);
+}
+
+function containsExactPathReference(text: string, filePath: string): boolean {
+  const target = normalizeSlashes(filePath);
+  const targets = target.startsWith("/") ? [target, `file://${target}`] : [target];
+  const haystacks = new Set([normalizeSlashes(text), normalizeSlashes(safeDecode(text))]);
+
+  for (const haystack of haystacks) {
+    for (const t of targets) {
+      let index = haystack.indexOf(t);
+      while (index !== -1) {
+        const before = index === 0 ? "" : haystack[index - 1];
+        const afterIndex = index + t.length;
+        if ((index === 0 || !isPathChar(before)) && hasReferenceBoundaryAfter(haystack, afterIndex)) {
+          return true;
+        }
+        index = haystack.indexOf(t, index + 1);
+      }
+    }
+  }
+
+  return false;
+}
+
+function collectStrings(value: unknown, out: string[]): void {
+  if (typeof value === "string") {
+    out.push(value);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) collectStrings(item, out);
+    return;
+  }
+  for (const item of Object.values(value)) collectStrings(item, out);
+}
+
+export function isFilePathReferencedByEntries(filePath: string, entries: SessionEntry[]): boolean {
+  for (const entry of entries) {
+    const strings: string[] = [];
+    collectStrings(entry, strings);
+    if (strings.some((text) => containsExactPathReference(text, filePath))) return true;
+  }
+  return false;
+}
+
+export function isBashOutputPathReferencedByEntries(filePath: string, entries: SessionEntry[]): boolean {
+  return entries.some((entry) => (
+    entry.type === "message"
+    && entry.message.role === "bashExecution"
+    && entry.message.fullOutputPath === filePath
+  ));
+}

package/lib/session-file-references.test.mjs

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./session-file-references-core.ts");
+}
+
+test("detects exact external file paths referenced in session entries", async () => {
+  const { isFilePathReferencedByEntries } = await loadSubject();
+  const entries = [
+    {
+      type: "message",
+      id: "entry-1",
+      parentId: null,
+      timestamp: "2026-01-01T00:00:00.000Z",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "text",
+            text: "See [/home/me/.codex/config.toml:12](/home/me/.codex/config.toml:12)",
+          },
+        ],
+      },
+    },
+  ];
+
+  assert.equal(isFilePathReferencedByEntries("/home/me/.codex/config.toml", entries), true);
+});
+
+test("does not authorize sibling files by prefix match", async () => {
+  const { isFilePathReferencedByEntries } = await loadSubject();
+  const entries = [
+    {
+      type: "message",
+      id: "entry-1",
+      parentId: null,
+      timestamp: "2026-01-01T00:00:00.000Z",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "text",
+            text: "See /home/me/.codex/config.toml.bak",
+          },
+        ],
+      },
+    },
+  ];
+
+  assert.equal(isFilePathReferencedByEntries("/home/me/.codex/config.toml", entries), false);
+});
+
+test("authorizes full output only from a bash execution message", async () => {
+  const { isBashOutputPathReferencedByEntries } = await loadSubject();
+  const outputPath = "/tmp/pi-bash-ab12.log";
+  const bashEntry = {
+    type: "message",
+    id: "entry-1",
+    parentId: null,
+    timestamp: "2026-01-01T00:00:00.000Z",
+    message: {
+      role: "bashExecution",
+      command: "printf test",
+      output: "test",
+      fullOutputPath: outputPath,
+    },
+  };
+  const assistantEntry = {
+    type: "message",
+    id: "entry-2",
+    parentId: "entry-1",
+    timestamp: "2026-01-01T00:00:01.000Z",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: `mentioned ${outputPath}` }],
+    },
+  };
+
+  assert.equal(isBashOutputPathReferencedByEntries(outputPath, [bashEntry]), true);
+  assert.equal(isBashOutputPathReferencedByEntries(outputPath, [assistantEntry]), false);
+  assert.equal(isBashOutputPathReferencedByEntries("/tmp/pi-bash-other.log", [bashEntry]), false);
+});
+
+test("validates session ids before resolving session paths", async () => {
+  const { isValidSessionId } = await loadSubject();
+
+  assert.equal(isValidSessionId("not-a-session-id"), false);
+  assert.equal(isValidSessionId("../../sessions/foo"), false);
+  assert.equal(isValidSessionId("550e8400-e29b-41d4-a716-446655440000"), true);
+});

package/lib/session-file-references.ts

@@ -0,0 +1,29 @@
+import { getSessionEntries, resolveSessionPath } from "./session-reader";
+export { isFilePathReferencedByEntries } from "./session-file-references-core";
+import {
+  isBashOutputPathReferencedByEntries,
+  isFilePathReferencedByEntries,
+  isValidSessionId,
+} from "./session-file-references-core";
+
+export async function isFilePathReferencedBySession(filePath: string, sessionId: string | null): Promise<boolean> {
+  if (!isValidSessionId(sessionId)) return false;
+  try {
+    const sessionPath = await resolveSessionPath(sessionId);
+    if (!sessionPath) return false;
+    return isFilePathReferencedByEntries(filePath, getSessionEntries(sessionPath));
+  } catch {
+    return false;
+  }
+}
+
+export async function isBashOutputPathReferencedBySession(filePath: string, sessionId: string | null): Promise<boolean> {
+  if (!isValidSessionId(sessionId)) return false;
+  try {
+    const sessionPath = await resolveSessionPath(sessionId);
+    if (!sessionPath) return false;
+    return isBashOutputPathReferencedByEntries(filePath, getSessionEntries(sessionPath));
+  } catch {
+    return false;
+  }
+}

package/lib/session-path.test.mjs

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./session-path.ts");
+}
+
+test("normalizes Windows separators and casing for session identity", async () => {
+  const { sessionPathKey } = await loadSubject();
+
+  assert.equal(
+    sessionPathKey("C:\\Users\\Alex\\.pi\\sessions\\Parent.jsonl", "win32"),
+    sessionPathKey("c:/Users/Alex/.pi/sessions/parent.jsonl", "win32"),
+  );
+});
+
+test("preserves case when session paths are case-sensitive", async () => {
+  const { sessionPathKey } = await loadSubject();
+
+  assert.notEqual(
+    sessionPathKey("/var/lib/pi/Parent.jsonl", "linux"),
+    sessionPathKey("/var/lib/pi/parent.jsonl", "linux"),
+  );
+});

package/lib/session-path.ts

@@ -0,0 +1,11 @@
+import path from "node:path";
+
+export function sessionPathKey(
+  filePath: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const normalized = platform === "win32"
+    ? path.win32.normalize(filePath)
+    : path.posix.normalize(filePath);
+  return platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/lib/session-reader.pagination.test.mjs

@@ -0,0 +1,115 @@
+// Pagination at the data boundary: a linear session (no branching) degrades into
+// a single chain whose depth equals its entry count. The old full-forest read
+// forced O(n) work and was the trigger for #509 (Maximum call stack size
+// exceeded) and #555 (full-history transfer). Slicing bounds both to O(tail).
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const { sliceActiveBranch, buildSessionContext, hasOlderHistory } = await jiti.import("./session-reader.ts");
+
+// Build a linear chain of n entries: e0 -> e1 -> ... -> e(n-1).
+function linearChain(n) {
+  const entries = [];
+  for (let i = 0; i < n; i++) {
+    entries.push({
+      id: `e${i}`,
+      parentId: i === 0 ? null : `e${i - 1}`,
+      type: "message",
+      timestamp: new Date(1000 + i * 1000).toISOString(),
+      message: { role: i % 2 === 0 ? "user" : "assistant", content: `msg ${i}` },
+    });
+  }
+  return entries;
+}
+
+test("sliceActiveBranch returns the most-recent `tail` ancestors, in time order", () => {
+  const entries = linearChain(100);
+  const sliced = sliceActiveBranch(entries, "e99", 50);
+  assert.equal(sliced.length, 50);
+  assert.equal(sliced[0].id, "e50");
+  assert.equal(sliced[sliced.length - 1].id, "e99");
+});
+
+test("sliceActiveBranch walks from leaf back toward root, not forward", () => {
+  const entries = linearChain(10);
+  const sliced = sliceActiveBranch(entries, "e5", 3);
+  assert.deepEqual(sliced.map((e) => e.id), ["e3", "e4", "e5"]);
+});
+
+test("sliceActiveBranch defaults to the last entry when leafId is null", () => {
+  const entries = linearChain(7);
+  const sliced = sliceActiveBranch(entries, null, 3);
+  assert.deepEqual(sliced.map((e) => e.id), ["e4", "e5", "e6"]);
+});
+
+test("deep linear chain (5000 entries) slices without overflowing the stack", () => {
+  const entries = linearChain(5000);
+  // The recursion that #509 hit lived in any path-walk over the full chain.
+  // An iterative slice over 5000 entries must not throw Maximum call stack size.
+  const sliced = sliceActiveBranch(entries, "e4999", 50);
+  assert.equal(sliced.length, 50);
+  assert.equal(sliced[sliced.length - 1].id, "e4999");
+});
+
+test("buildSessionContext with tail returns only the tail window", () => {
+  const entries = linearChain(300);
+  const ctx = buildSessionContext(entries, "e299", { tail: 50 });
+  assert.equal(ctx.messages.length, 50);
+  assert.equal(ctx.entryIds.length, 50);
+  assert.equal(ctx.entryIds[0], "e250");
+  assert.equal(ctx.entryIds[ctx.entryIds.length - 1], "e299");
+});
+
+test("buildSessionContext without tail still returns the full chain", () => {
+  const entries = linearChain(20);
+  const ctx = buildSessionContext(entries, "e19");
+  assert.equal(ctx.messages.length, 20);
+});
+
+test("buildSessionContext excludeLeaf pages upward without duplicating `before`", () => {
+  // User path: client has [e48..e52], requests the page before e48 (older).
+  // excludeLeaf must start from e47's parent so e48 is NOT re-fetched.
+  const entries = linearChain(100);
+  const page1 = buildSessionContext(entries, "e52", { tail: 5 }).entryIds;
+  assert.deepEqual(page1, ["e48", "e49", "e50", "e51", "e52"]);
+  const oldest = page1[0]; // e48
+  const page2 = buildSessionContext(entries, oldest, { tail: 5, excludeLeaf: true }).entryIds;
+  assert.equal(page2[page2.length - 1], "e47");
+  assert.ok(!page2.includes(oldest), "page2 must not duplicate the `before` boundary");
+  // Adjacent pages share no id -> prepending never double-renders.
+  assert.ok(page1.every((id) => !page2.includes(id)));
+});
+
+test("buildSessionContext accepts a large tail and returns the whole chain", () => {
+  const entries = linearChain(5000);
+  const ctx = buildSessionContext(entries, "e4999", { tail: 5000 });
+  assert.equal(ctx.messages.length, 5000);
+  // NOTE: the 1000 cap is enforced at the route layer (Math.min(rawTail, 1000)),
+  // see app/api/sessions/[id]/{route,context/route}.test.mjs.
+});
+
+test("real sessions may store assistant content as a string (deferThinking guard)", () => {
+  // Regression for the long-session 500: entryToUiMessage calls content.map in
+  // the deferThinking branch, but real assistant content can be a plain string.
+  const entries = [
+    { id: "u1", parentId: null, type: "message", timestamp: new Date(1).toISOString(),
+      message: { role: "user", content: "hi" } },
+    { id: "a1", parentId: "u1", type: "message", timestamp: new Date(2).toISOString(),
+      message: { role: "assistant", content: "a string reply, not a block array" } },
+  ];
+  const ctx = buildSessionContext(entries, "a1", { deferThinking: true, tail: 50 });
+  assert.equal(ctx.messages.length, 2);
+  assert.equal(ctx.messages[1].content, "a string reply, not a block array");
+});
+
+test("hasOlderHistory is true only when the active chain exceeds the tail cap", () => {
+  assert.equal(hasOlderHistory(linearChain(100), "e99", 50), true);
+  assert.equal(hasOlderHistory(linearChain(100), "e99", 5000), false);
+  assert.equal(hasOlderHistory(linearChain(30), "e29", 50), false);
+  // excludeLeaf pages upward: with 100 entries and a 50-tail page starting at
+  // e60, there is still older history; at e0 there is not.
+  assert.equal(hasOlderHistory(linearChain(100), "e59", 50, true), true);
+  assert.equal(hasOlderHistory(linearChain(100), "e0", 50, true), false);
+});