@baique/pi-web-sky 0.1.55 → 0.1.57

package/lib/session-time-group.ts

@@ -0,0 +1,55 @@
+/**
+ * 会话列表的时间分组（今天 / 昨天 / 本周 / 近一月 / 更久之前）。
+ *
+ * 只做分类，不排序：调用方（侧栏聊天区）已按 modified 倒序排好，
+ * 这里只负责给每条会话贴上它属于哪一段。
+ */
+export type SessionTimeGroup = "today" | "yesterday" | "thisWeek" | "thisMonth" | "older";
+
+/** 分组展示顺序（由近及远）。 */
+export const SESSION_TIME_GROUP_ORDER: readonly SessionTimeGroup[] = [
+  "today",
+  "yesterday",
+  "thisWeek",
+  "thisMonth",
+  "older",
+];
+
+/** 近一月的窗口长度（含今天），滚动 30 天而非自然月。 */
+const RECENT_MONTH_DAYS = 30;
+
+function startOfDay(ms: number): number {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+/** 加减自然日（走 Date，跨夏令时不会少/多一小时）。 */
+function addDays(ms: number, days: number): number {
+  const d = new Date(ms);
+  d.setDate(d.getDate() + days);
+  return d.getTime();
+}
+
+/** 本周起始（周一 00:00），与中文习惯一致。 */
+function startOfWeek(ms: number): number {
+  const day = new Date(ms).getDay(); // 0 = 周日
+  return addDays(startOfDay(ms), -((day + 6) % 7));
+}
+
+/**
+ * 判断一条会话的修改时间落在哪个时间分组。
+ * @param modified 会话修改时间（ISO 字符串或毫秒时间戳）
+ * @param now 当前时间（毫秒），用于测试注入
+ * @returns 时间分组；时间不可解析时按「更久之前」处理
+ */
+export function sessionTimeGroup(modified: string | number, now: number = Date.now()): SessionTimeGroup {
+  const ms = typeof modified === "number" ? modified : Date.parse(modified);
+  if (!Number.isFinite(ms)) return "older";
+  // 未来时间（客户端与服务端时钟漂移）归今天，别把刚写的会话沉到底部。
+  if (ms >= startOfDay(now)) return "today";
+  if (ms >= addDays(startOfDay(now), -1)) return "yesterday";
+  if (ms >= startOfWeek(now)) return "thisWeek";
+  if (ms >= addDays(startOfDay(now), -(RECENT_MONTH_DAYS - 1))) return "thisMonth";
+  return "older";
+}

package/lib/settings-navigation.ts

@@ -0,0 +1,124 @@
+export const SETTINGS_SECTION_VALUES = [
+  "general",
+  "models",
+  "skills",
+  "agents",
+  "plugins",
+] as const;
+
+export type SettingsSection = (typeof SETTINGS_SECTION_VALUES)[number];
+export type SettingsDetailSection = Exclude<SettingsSection, "general">;
+
+const STORAGE_KEY = "pi-web:settings-navigation";
+const PROJECT_SECTIONS = new Set<SettingsSection>(["skills", "agents", "plugins"]);
+
+interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+interface SettingsNavigationState {
+  section?: string;
+  selections?: Record<string, string>;
+}
+
+function getBrowserStorage(): StorageLike | null {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+function isSettingsSection(value: unknown): value is SettingsSection {
+  return typeof value === "string"
+    && SETTINGS_SECTION_VALUES.includes(value as SettingsSection);
+}
+
+function readState(storage: StorageLike): SettingsNavigationState {
+  const raw = storage.getItem(STORAGE_KEY);
+  if (!raw) return {};
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const state = parsed as SettingsNavigationState;
+    return {
+      section: typeof state.section === "string" ? state.section : undefined,
+      selections: state.selections !== null
+        && typeof state.selections === "object"
+        && !Array.isArray(state.selections)
+        ? state.selections
+        : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+function selectionKey(section: SettingsDetailSection, cwd?: string | null): string | null {
+  if (section === "models") return section;
+  return cwd ? JSON.stringify([section, cwd]) : null;
+}
+
+export function getLastSettingsSection(
+  cwd: string | null,
+  storage: StorageLike | null = getBrowserStorage(),
+): SettingsSection {
+  if (!storage) return "general";
+  try {
+    const section = readState(storage).section;
+    if (!isSettingsSection(section)) return "general";
+    return PROJECT_SECTIONS.has(section) && !cwd ? "general" : section;
+  } catch {
+    return "general";
+  }
+}
+
+export function setLastSettingsSection(
+  section: SettingsSection,
+  storage: StorageLike | null = getBrowserStorage(),
+): void {
+  if (!storage) return;
+  try {
+    const state = readState(storage);
+    state.section = section;
+    storage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {
+    // Browser storage is best-effort.
+  }
+}
+
+export function getLastSettingsSelection(
+  section: SettingsDetailSection,
+  cwd?: string | null,
+  storage: StorageLike | null = getBrowserStorage(),
+): string | null {
+  if (!storage) return null;
+  const key = selectionKey(section, cwd);
+  if (!key) return null;
+  try {
+    const value = readState(storage).selections?.[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+export function setLastSettingsSelection(
+  section: SettingsDetailSection,
+  value: string,
+  cwd?: string | null,
+  storage: StorageLike | null = getBrowserStorage(),
+): void {
+  if (!storage || !value) return;
+  const key = selectionKey(section, cwd);
+  if (!key) return;
+  try {
+    const state = readState(storage);
+    state.selections = { ...state.selections, [key]: value };
+    storage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {
+    // Browser storage is best-effort.
+  }
+}

package/lib/sqlite-db.test.mjs

@@ -189,3 +189,29 @@ test("v10 database upgrades to v11 (session_meta index columns + project index)"
   assert.equal(row.task_id, "task-1");
   assert.equal(row.pinned, 1);
 });
+
+test("schema v12：老库升级后 session_meta 有 last_reply 列，新库直接具备", () => {
+  const old = new DatabaseSync(":memory:");
+  old.exec("PRAGMA user_version = 11");
+  old.exec(
+    "CREATE TABLE session_meta (session_id TEXT PRIMARY KEY, task_id TEXT, updated INTEGER NOT NULL, pinned INTEGER NOT NULL DEFAULT 0, path TEXT, cwd TEXT, project_key TEXT, title TEXT, first_message TEXT, parent_id TEXT, created INTEGER, modified INTEGER)",
+  );
+  old.prepare(
+    "INSERT INTO session_meta (session_id, updated, modified) VALUES ('s-old', 1, 2)",
+  ).run();
+
+  initSchema(old);
+
+  const cols = old.prepare("PRAGMA table_info(session_meta)").all().map((c) => c.name);
+  assert.ok(cols.includes("last_reply"), "v12 adds session_meta.last_reply");
+  assert.equal(old.prepare("PRAGMA user_version").get().user_version, 12);
+  // 老行保留，新列默认 NULL（"还没有最后一条消息"）
+  const kept = old.prepare("SELECT session_id, last_reply FROM session_meta WHERE session_id='s-old'").get();
+  assert.equal(kept.session_id, "s-old");
+  assert.equal(kept.last_reply, null);
+  // 新库第一次建表就该有该列（老库升级与新库同构）
+  const fresh = memoryDb();
+  const freshCols = fresh.prepare("PRAGMA table_info(session_meta)").all().map((c) => c.name);
+  assert.ok(freshCols.includes("last_reply"));
+  assert.equal(fresh.prepare("PRAGMA user_version").get().user_version, 12);
+});

package/lib/sqlite-db.ts

@@ -93,7 +93,7 @@ export function initSchema(db: DatabaseSync): void {
  * 老库打开时自动按序补齐缺失的迁移（每个迁移一个事务，成功后推进版本号），
  * 新库建表后从 v0 一路迁到 SCHEMA_VERSION。重复打开不再执行已完成的迁移。
  */
-export const SCHEMA_VERSION = 11;
+export const SCHEMA_VERSION = 12;
 
 interface Migration {
   version: number;
@@ -219,6 +219,15 @@ const MIGRATIONS: Migration[] = [
       "CREATE INDEX IF NOT EXISTS idx_meta_project_modified ON session_meta(project_key, modified DESC);",
     ],
   },
+  {
+    version: 12,
+    name: "session_meta.last_reply（最后一条消息入库，列表零扫盘）",
+    statements: [
+      // 「最后一条消息」原先靠读取期读文件尾（滞后且每次列表都要摸盘）。改由事件
+      // 链路在一轮循环结束时写入（agent_settled，含取消），读取路径不再读文件。
+      "ALTER TABLE session_meta ADD COLUMN last_reply TEXT;",
+    ],
+  },
 ];
 
 function migrate(db: DatabaseSync): void {

package/lib/subagent-extension.test.mjs

@@ -0,0 +1,424 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const {
+  createSubagentExtension,
+  preferPiWebSubagentExtension,
+} = await createJiti(import.meta.url).import("./subagent-extension.ts");
+
+async function loadTools(runtime, getProfiles = () => [], isEnabled = () => true) {
+  const tools = new Map();
+  const sent = [];
+  const extension = createSubagentExtension(runtime, getProfiles, isEnabled);
+  await extension.factory({
+    registerTool(tool) { tools.set(tool.name, tool); },
+    sendMessage(message, options) { sent.push({ message, options }); },
+  });
+  return { tools, sent };
+}
+
+function run(overrides = {}) {
+  return {
+    sessionId: "child-session",
+    sessionPath: "/tmp/child.jsonl",
+    parentSessionId: "parent-session",
+    parentToolCallId: "tool-call",
+    profile: "explore",
+    description: "Find parser",
+    task: "Find the parser",
+    runInBackground: false,
+    status: "running",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+test("integrated extension exposes the legacy-compatible tool names", async () => {
+  const tools = new Map();
+  const extension = createSubagentExtension({
+    async start(request) {
+      const running = {
+        sessionId: "child-session",
+        sessionPath: "/tmp/child.jsonl",
+        parentSessionId: "parent-session",
+        parentToolCallId: request.parentToolCallId,
+        profile: request.profile,
+        description: request.description,
+        task: request.task,
+        runInBackground: true,
+        status: "running",
+        createdAt: "2026-01-01T00:00:00.000Z",
+      };
+      return {
+        run: running,
+        completion: Promise.resolve({
+          ...running,
+          status: "completed",
+          completedAt: "2026-01-01T00:01:00.000Z",
+          result: "Done",
+        }),
+      };
+    },
+    async get() { return null; },
+    async steer() {},
+    async notifyParent() {},
+  }, () => []);
+  await extension.factory({
+    registerTool(tool) { tools.set(tool.name, tool); },
+    sendMessage() {},
+  });
+
+  assert.deepEqual([...tools.keys()], ["Agent", "get_subagent_result", "steer_subagent"]);
+  const result = await tools.get("Agent").execute(
+    "tool-call",
+    {
+      subagent_type: "explore",
+      prompt: "Find the parser",
+      input_files: ["docs/parser.md"],
+      description: "Find parser",
+      run_in_background: true,
+    },
+    undefined,
+    undefined,
+    { sessionManager: { getSessionId: () => "parent-session" } },
+  );
+  assert.equal(result.details.kind, "pi-web-subagent");
+  assert.equal(result.details.sessionId, "child-session");
+});
+
+test("integrated extension registers no tools while its feature is disabled", async () => {
+  let enabled = false;
+  const runtime = {
+    async start() { throw new Error("unused"); },
+    async get() { return null; },
+    async steer() {},
+    async notifyParent() {},
+  };
+  const extension = createSubagentExtension(runtime, () => [], () => enabled);
+  const disabledTools = new Map();
+  await extension.factory({ registerTool(tool) { disabledTools.set(tool.name, tool); } });
+  assert.deepEqual([...disabledTools], []);
+
+  enabled = true;
+  const enabledTools = new Map();
+  await extension.factory({ registerTool(tool) { enabledTools.set(tool.name, tool); } });
+  assert.deepEqual([...enabledTools.keys()], ["Agent", "get_subagent_result", "steer_subagent"]);
+});
+
+test("Agent tool description lists enabled effective profiles and refreshes when its factory reloads", async () => {
+  const runtime = {
+    async start() { throw new Error("unused"); },
+    async get() { return null; },
+    async steer() {},
+    async notifyParent() {},
+  };
+  let profiles = [
+    {
+      name: "explore",
+      displayName: "Explore",
+      description: "Inspect the codebase",
+      systemPrompt: "Explore",
+      tools: ["read", "grep"],
+      inheritContext: false,
+      runInBackground: false,
+      enabled: true,
+      scope: "builtin",
+    },
+    {
+      name: "disabled-agent",
+      displayName: "Disabled agent",
+      description: "Must stay hidden",
+      systemPrompt: "Disabled",
+      tools: [],
+      model: "provider/hidden",
+      inheritContext: false,
+      runInBackground: false,
+      enabled: false,
+      scope: "project",
+    },
+  ];
+  const extension = createSubagentExtension(runtime, () => profiles);
+
+  const firstTools = new Map();
+  await extension.factory({ registerTool(tool) { firstTools.set(tool.name, tool); }, sendMessage() {} });
+  const first = firstTools.get("Agent");
+  assert.match(first.description, /- explore: Inspect the codebase \(Tools: read, grep\)/);
+  assert.doesNotMatch(first.description, /disabled-agent|Must stay hidden/);
+  assert.match(first.parameters.properties.subagent_type.description, /Available types: explore/);
+
+  profiles = [{
+    name: "reviewer",
+    displayName: "Reviewer",
+    description: "Review a change",
+    systemPrompt: "Review",
+    tools: [],
+    model: "provider/review-model",
+    inheritContext: false,
+    runInBackground: false,
+    enabled: true,
+    scope: "project",
+  }];
+  const reloadedTools = new Map();
+  await extension.factory({ registerTool(tool) { reloadedTools.set(tool.name, tool); }, sendMessage() {} });
+  const reloaded = reloadedTools.get("Agent");
+  assert.match(reloaded.description, /- reviewer: Review a change \(Tools: none; Model: provider\/review-model\)/);
+  assert.doesNotMatch(reloaded.description, /explore/);
+  assert.match(reloaded.parameters.properties.subagent_type.description, /Available types: reviewer/);
+});
+
+test("integrated extension removes a legacy extension that owns the same tools", () => {
+  const host = {
+    path: "<inline:pi-web-subagents>",
+    tools: new Map([["Agent", {}], ["get_subagent_result", {}], ["steer_subagent", {}]]),
+  };
+  const legacy = {
+    path: "/tmp/pi-subagents/index.ts",
+    tools: new Map([["Agent", {}], ["get_subagent_result", {}], ["steer_subagent", {}]]),
+  };
+  const other = { path: "/tmp/other.ts", tools: new Map([["search", {}]]) };
+  const lookalike = {
+    path: "/tmp/unrelated/index.ts",
+    tools: new Map([["Agent", {}], ["get_subagent_result", {}], ["steer_subagent", {}], ["custom", {}]]),
+  };
+  const result = preferPiWebSubagentExtension({
+    extensions: [legacy, lookalike, host, other],
+    errors: [{ path: legacy.path, error: "duplicate" }, { path: other.path, error: "other" }],
+  });
+
+  assert.deepEqual(result.extensions.map((extension) => extension.path), [lookalike.path, host.path, other.path]);
+  assert.deepEqual(result.errors.map((error) => error.path), [other.path]);
+});
+
+test("integrated extension removes recognized legacy extensions with any reserved tool", () => {
+  const host = {
+    path: "<inline:pi-web-subagents>",
+    tools: new Map([["Agent", {}], ["get_subagent_result", {}], ["steer_subagent", {}]]),
+  };
+  for (const toolName of ["Agent", "get_subagent_result", "steer_subagent"]) {
+    const legacy = {
+      path: "/tmp/pi-subagents/index.ts",
+      tools: new Map([[toolName, {}], ["other", {}]]),
+    };
+    const result = preferPiWebSubagentExtension({
+      extensions: [legacy, host],
+      errors: [{
+        path: host.path,
+        error: `Tool "${toolName}" conflicts with ${legacy.path}`,
+      }],
+    });
+    assert.deepEqual(result.extensions, [host]);
+    assert.deepEqual(result.errors, []);
+  }
+});
+
+test("foreground Agent streams updates and returns the completed result", async () => {
+  const updates = [];
+  let request;
+  const { tools } = await loadTools({
+    async start(value) {
+      request = value;
+      value.onUpdate(run({ status: "running" }));
+      return {
+        run: run(),
+        completion: Promise.resolve(run({
+          status: "completed",
+          completedAt: "2026-01-01T00:01:00.000Z",
+          result: "Parser is in lib/parser.ts",
+        })),
+      };
+    },
+    async get() { return null; },
+    async steer() {},
+  });
+  const result = await tools.get("Agent").execute(
+    "tool-call",
+    {
+      subagent_type: "explore",
+      prompt: "Find the parser",
+      input_files: ["docs/parser.md"],
+      description: "Find parser",
+    },
+    undefined,
+    (update) => updates.push(update),
+    { sessionManager: { getSessionId: () => "parent-session" } },
+  );
+
+  assert.equal(request.parentToolCallId, "tool-call");
+  assert.equal(request.task, "Find the parser");
+  assert.deepEqual(request.inputFiles, ["docs/parser.md"]);
+  assert.equal(updates[0].details.status, "running");
+  assert.equal(result.content[0].text, "Parser is in lib/parser.ts");
+  assert.equal(result.details.status, "completed");
+  assert.equal(result.isError, undefined);
+});
+
+test("foreground Agent reports startup and execution failures as tool errors", async () => {
+  const { tools: startFailureTools } = await loadTools({
+    async start() { throw new Error("profile missing"); },
+    async get() { return null; },
+    async steer() {},
+  });
+  const startup = await startFailureTools.get("Agent").execute(
+    "tool-call",
+    { prompt: "task", description: "desc" },
+    undefined,
+    undefined,
+    { sessionManager: { getSessionId: () => "parent-session" } },
+  );
+  assert.equal(startup.isError, true);
+  assert.equal(startup.content[0].text, "profile missing");
+
+  const { tools: runFailureTools } = await loadTools({
+    async start() {
+      return {
+        run: run(),
+        completion: Promise.resolve(run({ status: "failed", error: "model failed" })),
+      };
+    },
+    async get() { return null; },
+    async steer() {},
+  });
+  const failure = await runFailureTools.get("Agent").execute(
+    "tool-call",
+    { prompt: "task", description: "desc" },
+    undefined,
+    undefined,
+    { sessionManager: { getSessionId: () => "parent-session" } },
+  );
+  assert.equal(failure.isError, true);
+  assert.match(failure.content[0].text, /model failed/);
+});
+
+test("Agent resume routes the prompt to the existing-session runtime", async () => {
+  let resumed;
+  const { tools } = await loadTools({
+    async start() { throw new Error("must use resume"); },
+    async resume(request) {
+      resumed = request;
+      return { run: run({ sessionId: "existing", runInBackground: false }), completion: Promise.resolve(run({ sessionId: "existing", status: "completed", result: "continued" })) };
+    },
+    async get() { return null; },
+    async steer() {},
+  });
+  const result = await tools.get("Agent").execute(
+    "tool-call",
+    { resume: "existing", prompt: "Continue the review", description: "Continue review" },
+    undefined,
+    undefined,
+    { sessionManager: { getSessionId: () => "parent-session" } },
+  );
+  assert.equal(resumed.sessionId, "existing");
+  assert.equal(resumed.task, "Continue the review");
+  assert.equal(result.content[0].text, "continued");
+});
+
+test("background Agent returns immediately and delegates one completion notification", async () => {
+  let finish;
+  const notifications = [];
+  const completion = new Promise((resolve) => { finish = resolve; });
+  const { tools, sent } = await loadTools({
+    async start() {
+      return { run: run({ runInBackground: true }), completion };
+    },
+    async get() { return null; },
+    async steer() {},
+    async notifyParent(completed) { notifications.push(completed); },
+  });
+  const result = await tools.get("Agent").execute(
+    "tool-call",
+    { prompt: "task", description: "desc", run_in_background: true },
+    undefined,
+    undefined,
+    { sessionManager: { getSessionId: () => "parent-session" } },
+  );
+  assert.match(result.content[0].text, /started in background/);
+  assert.equal(sent.length, 0);
+
+  finish(run({ runInBackground: true, status: "completed", result: "done" }));
+  await completion;
+  await Promise.resolve();
+  assert.equal(sent.length, 0);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0].result, "done");
+});
+
+test("get_subagent_result covers missing, running, completed, failed, and aborted runs", async () => {
+  let current = null;
+  const { tools } = await loadTools({
+    async start() { throw new Error("unused"); },
+    async get() { return current; },
+    async steer() {},
+  });
+  const tool = tools.get("get_subagent_result");
+
+  let result = await tool.execute("call", { agent_id: "missing" });
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /not found/);
+
+  current = run();
+  result = await tool.execute("call", { agent_id: "child-session" });
+  assert.equal(result.details.status, "running");
+  assert.equal(result.content[0].text, "Subagent child-session is running.");
+
+  current = run({ status: "completed", result: "done" });
+  result = await tool.execute("call", { agent_id: "child-session" });
+  assert.equal(result.content[0].text, "done");
+
+  current = run({ status: "failed", error: "boom" });
+  result = await tool.execute("call", { agent_id: "child-session" });
+  assert.match(result.content[0].text, /boom/);
+  assert.equal(result.isError, true);
+
+  current = run({ status: "aborted" });
+  result = await tool.execute("call", { agent_id: "child-session" });
+  assert.match(result.content[0].text, /was stopped/);
+
+  current = run({ status: "interrupted" });
+  result = await tool.execute("call", { agent_id: "child-session" });
+  assert.match(result.content[0].text, /interrupted before completion/);
+});
+
+test("get_subagent_result wait honors abort signals", async () => {
+  const { tools } = await loadTools({
+    async start() { throw new Error("unused"); },
+    async get() { return run(); },
+    async steer() {},
+  });
+  const controller = new AbortController();
+  controller.abort();
+  await assert.rejects(
+    tools.get("get_subagent_result").execute("call", { agent_id: "child-session", wait: true }, controller.signal),
+    /Result wait aborted/,
+  );
+});
+
+test("steer_subagent returns success and runtime failures", async () => {
+  const calls = [];
+  const { tools } = await loadTools({
+    async start() { throw new Error("unused"); },
+    async get() { return null; },
+    async steer(id, message) {
+      calls.push([id, message]);
+      if (message === "fail") throw new Error("not running");
+    },
+  });
+  const tool = tools.get("steer_subagent");
+  const success = await tool.execute("call", { agent_id: "child-session", message: "focus" });
+  assert.deepEqual(calls[0], ["child-session", "focus"]);
+  assert.match(success.content[0].text, /sent/);
+
+  const failure = await tool.execute("call", { agent_id: "child-session", message: "fail" });
+  assert.equal(failure.isError, true);
+  assert.equal(failure.content[0].text, "not running");
+});
+
+test("legacy preference leaves unrelated and partial-overlap extensions intact", () => {
+  const host = { path: "<inline:pi-web-subagents>", tools: new Map() };
+  const partial = { path: "/tmp/partial.ts", tools: new Map([["Agent", {}]]) };
+  const base = { extensions: [host, partial], errors: [] };
+  assert.equal(preferPiWebSubagentExtension(base), base);
+
+  const noHost = { extensions: [partial], errors: [] };
+  assert.equal(preferPiWebSubagentExtension(noHost), noHost);
+});