@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/test/plugin-stars-view.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { pluginStarsRows } from "../src/plugin-stars-view.js";
+import { pluginStarsPanelView, pluginStarsRows } from "../src/plugin-stars-view.js";
 
 describe("plugin stars view", () => {
   it("sorts by stars and limits the visible ranking rows", () => {
@@ -17,4 +17,91 @@ describe("plugin stars view", () => {
       { rank: 2, fullName: "team/mid", name: "mid", stars: 9, htmlUrl: "https://github.com/team/mid", updatedAt: "2026-03-01" },
     ]);
   });
+
+  it("normalizes a complete plugin stars panel payload", () => {
+    expect(
+      pluginStarsPanelView({
+        source: "https://raw.githubusercontent.com/fixture/ranking/main/plugins.json",
+        limit: 10,
+        timeoutMs: 15_000,
+        latest: {
+          source: "fixture",
+          generatedAt: "2026-09-05T00:00:00Z",
+          total: 2,
+          query: "vision",
+          fetchedAt: "2026-09-05T00:01:00Z",
+          results: [{ fullName: "owner/fixture", name: "fixture", stars: 2, htmlUrl: "https://github.com/owner/fixture", updatedAt: "2026-09-05" }],
+        },
+        inventory: { total: 2, shown: 1, truncated: true },
+        limits: { responseBytes: 2_097_152, sourceItems: 1_000, resultItems: 10, panelItems: 20, queryCharacters: 120, timeoutMs: 15_000 },
+      }),
+    ).toEqual({
+      source: "https://raw.githubusercontent.com/fixture/ranking/main/plugins.json",
+      limit: 10,
+      timeoutMs: 15_000,
+      latest: {
+        source: "fixture",
+        generatedAt: "2026-09-05T00:00:00Z",
+        total: 2,
+        query: "vision",
+        fetchedAt: "2026-09-05T00:01:00Z",
+        results: [
+          {
+            rank: 1,
+            fullName: "owner/fixture",
+            name: "fixture",
+            stars: 2,
+            htmlUrl: "https://github.com/owner/fixture",
+            updatedAt: "2026-09-05",
+          },
+        ],
+      },
+      inventory: { total: 2, shown: 1, truncated: true },
+      limits: { responseBytes: 2_097_152, sourceItems: 1_000, resultItems: 10, panelItems: 20, queryCharacters: 120, timeoutMs: 15_000 },
+      malformed: false,
+    });
+  });
+
+  it("fails closed for hostile panel values, repository rows, and inventory counts", () => {
+    const long = "x".repeat(10_000);
+    const view = pluginStarsPanelView({
+      source: long,
+      limit: Number.POSITIVE_INFINITY,
+      timeoutMs: -1,
+      latest: {
+        source: long,
+        generatedAt: long,
+        total: 99_999,
+        query: long,
+        fetchedAt: long,
+        results: [
+          { fullName: "invalid", name: long, stars: -1, htmlUrl: "javascript:alert(1)", updatedAt: long },
+          ...Array.from({ length: 20 }, (_, index) => ({
+            fullName: `owner/repository-${index}`,
+            name: long,
+            stars: 20 - index,
+            htmlUrl: `https://github.com/owner/repository-${index}`,
+            updatedAt: long,
+          })),
+        ],
+      },
+      inventory: { total: 99_999, shown: 99_999, truncated: false },
+      limits: {},
+    });
+
+    expect(view).toMatchObject({ malformed: true, latest: null, inventory: { total: 0, shown: 0 }, source: "" });
+  });
+
+  it("fails closed for accessor-backed payloads", () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "latest", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return null;
+      },
+    });
+    expect(pluginStarsPanelView(accessor).malformed).toBe(true);
+    expect(getterCalls).toBe(0);
+  });
 });

package/packages/client-web/test/readme-gen-panel.test.ts

@@ -0,0 +1,81 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "vitest";
+import { PluginPanelCard } from "../src/react-room.js";
+
+function renderPanel(data: unknown): string {
+  return renderToStaticMarkup(
+    createElement(PluginPanelCard, {
+      panel: {
+        id: "readme-gen-panel",
+        pluginId: "@pi-harness/core/plugins/readme-gen",
+        title: "README Generator",
+        data,
+      },
+    }),
+  );
+}
+
+function complete(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    generated: true,
+    name: "@scope/demo",
+    scripts: 4,
+    plugins: 12,
+    lastWrite: { path: "docs/README.generated.md", bytes: 4_096, overwritten: false },
+    status: { state: "completed", operation: "write", at: "2026-09-06T00:00:00.000Z" },
+    ...overrides,
+  };
+}
+
+describe("README generator panel", () => {
+  test("renders the validated generation summary, write receipt, and status", () => {
+    const html = renderPanel(complete());
+
+    for (const expected of ["@scope/demo", "4 个脚本", "12 个运行时插件", "docs/README.generated.md", "4,096 bytes", "新文件", "写入已完成"]) {
+      expect(html).toContain(expected);
+    }
+    expect(html).not.toContain("README 面板数据无效");
+  });
+
+  test("renders actionable failure state without hiding the last good draft", () => {
+    const html = renderPanel(
+      complete({
+        lastWrite: null,
+        status: { state: "failed", operation: "write", at: "2026-09-06T00:00:00.000Z", error: "overwrite=true is required" },
+      }),
+    );
+
+    expect(html).toContain("@scope/demo");
+    expect(html).toContain("写入失败");
+    expect(html).toContain("overwrite=true is required");
+  });
+
+  test("renders a useful untouched state", () => {
+    const html = renderPanel({ generated: false, lastWrite: null, status: { state: "idle" } });
+
+    expect(html).toContain("还没有生成 README 草稿");
+    expect(html).toContain("readme_report");
+    expect(html).not.toContain("README 面板数据无效");
+  });
+
+  test("fails closed for malformed data instead of showing zero-valued success", () => {
+    const html = renderPanel(complete({ scripts: -1, plugins: Number.NaN }));
+
+    expect(html).toContain("README 面板数据无效");
+    expect(html).not.toContain("0 个脚本");
+    expect(html).not.toContain("README.generated.md");
+    expect(html).not.toContain("写入已完成");
+  });
+
+  test("wraps maximum-length names and paths", () => {
+    const name = "n".repeat(256);
+    const path = `${"d".repeat(499)}/README.md`;
+    const html = renderPanel(complete({ name, lastWrite: { path, bytes: 1, overwritten: true } }));
+
+    expect(html).toContain(name);
+    expect(html).toContain(path);
+    expect(html).toMatch(/class="[^"]*break-all[^"]*"[^>]*>n{256}</u);
+    expect(html).toMatch(/class="[^"]*break-all[^"]*"[^>]*>d{499}/u);
+  });
+});

package/packages/client-web/test/readme-gen-view.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "vitest";
+import { readmeGenPanelView } from "../src/readme-gen-view.js";
+
+function validPanel(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    generated: true,
+    name: "@scope/demo",
+    scripts: 4,
+    plugins: 12,
+    lastWrite: { path: "docs/README.generated.md", bytes: 4_096, overwritten: false },
+    status: { state: "completed", operation: "write", at: "2026-09-06T00:00:00.000Z" },
+    ...overrides,
+  };
+}
+
+describe("README generator panel view", () => {
+  test("normalizes a complete generated and written report", () => {
+    expect(readmeGenPanelView(validPanel())).toEqual({
+      generated: { name: "@scope/demo", scripts: 4, plugins: 12 },
+      lastWrite: { path: "docs/README.generated.md", bytes: 4_096, overwritten: false },
+      status: { state: "completed", operation: "write", at: "2026-09-06T00:00:00.000Z", error: null },
+      malformed: false,
+      limits: { nameCharacters: 256, pathCharacters: 512, scripts: 256, plugins: 256, errorCharacters: 2_000 },
+    });
+  });
+
+  test("normalizes the untouched idle state without manufacturing counts", () => {
+    expect(readmeGenPanelView({ generated: false, lastWrite: null, status: { state: "idle" } })).toEqual({
+      generated: null,
+      lastWrite: null,
+      status: { state: "idle", operation: null, at: null, error: null },
+      malformed: false,
+      limits: { nameCharacters: 256, pathCharacters: 512, scripts: 256, plugins: 256, errorCharacters: 2_000 },
+    });
+  });
+
+  test("fails closed for contradictory, unbounded, or malformed values", () => {
+    const malformed = [
+      null,
+      [],
+      validPanel({ name: "" }),
+      validPanel({ name: "x".repeat(257) }),
+      validPanel({ scripts: -1 }),
+      validPanel({ plugins: 257 }),
+      validPanel({ lastWrite: { path: "package.json", bytes: 0, overwritten: false } }),
+      validPanel({ lastWrite: { path: "README.md", bytes: Number.NaN, overwritten: false } }),
+      validPanel({ status: { state: "completed", operation: "write", at: "invalid" } }),
+      validPanel({ status: { state: "failed", operation: "report", at: "2026-09-06T00:00:00.000Z" } }),
+      { generated: false, lastWrite: { path: "README.md", bytes: 1, overwritten: false }, status: { state: "idle" } },
+    ];
+
+    for (const value of malformed) {
+      const view = readmeGenPanelView(value);
+      expect(view.generated).toBeNull();
+      expect(view.lastWrite).toBeNull();
+      expect(view.status.state).toBe("unknown");
+      expect(view.malformed).toBe(true);
+    }
+  });
+
+  test("does not invoke accessors or revoked proxies and returns detached data", () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "generated", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return true;
+      },
+    });
+    const nestedAccessor = Object.defineProperty({}, "path", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "README.md";
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    for (const value of [accessor, validPanel({ lastWrite: nestedAccessor }), revocable.proxy]) {
+      expect(() => readmeGenPanelView(value)).not.toThrow();
+      expect(readmeGenPanelView(value).malformed).toBe(true);
+    }
+    expect(getterCalls).toBe(0);
+
+    const source = validPanel();
+    const view = readmeGenPanelView(source);
+    (source.lastWrite as { path: string }).path = "README.changed.md";
+    expect(view.lastWrite?.path).toBe("docs/README.generated.md");
+  });
+});

package/packages/client-web/test/recall-unread-view.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+import { recallUnreadPanelView } from "../src/recall-unread-view.js";
+
+describe("Recall Unread view", () => {
+  it("normalizes session inventory, status, and items", () => {
+    expect(
+      recallUnreadPanelView({
+        scans: 2,
+        total: 1,
+        items: [
+          {
+            id: "session-1",
+            path: "/sessions/session-1.jsonl",
+            cwd: "/workspace",
+            name: "Needs reply",
+            modified: "2026-09-05T12:00:00.000Z",
+            messageCount: 3,
+            message: "Please finish the task",
+          },
+        ],
+        status: { state: "completed", at: "2026-09-05T12:01:00.000Z" },
+        inventory: {
+          available: 2,
+          candidates: 2,
+          scanned: 2,
+          unread: 1,
+          shown: 1,
+          truncated: false,
+          discoveryTruncated: false,
+          scanTruncated: false,
+          displayTruncated: false,
+        },
+        limits: { sessions: 100 },
+      }),
+    ).toMatchObject({
+      scans: 2,
+      total: 1,
+      items: [
+        {
+          id: "session-1",
+          path: "/sessions/session-1.jsonl",
+          cwd: "/workspace",
+          name: "Needs reply",
+          modified: "2026-09-05T12:00:00.000Z",
+          messageCount: 3,
+          message: "Please finish the task",
+        },
+      ],
+      status: { state: "completed", at: "2026-09-05T12:01:00.000Z", error: null },
+      inventory: { available: 2, candidates: 2, scanned: 2, unread: 1, shown: 1, truncated: false },
+      limits: { sessions: 100, allowedSessions: 500, panelItems: 50, previewCharacters: 500 },
+    });
+  });
+
+  it("enforces fixed browser caps on hostile nested data", () => {
+    const long = `unsafe\0${"x".repeat(20_000)}`;
+    const item = {
+      id: long,
+      path: long,
+      cwd: long,
+      name: long,
+      modified: long,
+      messageCount: Number.MAX_SAFE_INTEGER,
+      message: long,
+    };
+    const view = recallUnreadPanelView({
+      scans: Number.MAX_SAFE_INTEGER + 1,
+      total: 999_999,
+      items: Array.from({ length: 100 }, () => item),
+      status: { state: "failed", at: "2026-09-05T12:02:00.000Z", error: long },
+      inventory: {
+        available: 999_999,
+        candidates: 999_999,
+        scanned: 999_999,
+        unread: 999_999,
+        shown: 999_999,
+        truncated: true,
+        discoveryTruncated: true,
+        scanTruncated: true,
+        displayTruncated: true,
+      },
+      limits: Object.fromEntries(
+        [
+          "directoryEntries",
+          "sessionBytes",
+          "sessions",
+          "allowedSessions",
+          "readConcurrency",
+          "contentParts",
+          "previewCharacters",
+          "panelItems",
+          "toolItems",
+          "queryCharacters",
+          "sessionIdCharacters",
+          "sessionNameCharacters",
+          "sessionPathCharacters",
+          "statusErrorCharacters",
+        ].map((key) => [key, 99_999_999]),
+      ),
+    });
+
+    expect(view.scans).toBe(0);
+    expect(view.total).toBe(0);
+    expect(view.items).toHaveLength(50);
+    expect(view.items[0]?.id).toHaveLength(256);
+    expect(view.items[0]?.name).toHaveLength(256);
+    expect(view.items[0]?.path).toHaveLength(4_096);
+    expect(view.items[0]?.cwd).toHaveLength(4_096);
+    expect(view.items[0]?.message).toHaveLength(500);
+    expect(view.items[0]?.modified).toBeNull();
+    expect(view.items[0]?.messageCount).toBe(0);
+    expect(view.status.error).toHaveLength(2_000);
+    expect(view.inventory).toMatchObject({
+      available: 0,
+      candidates: 0,
+      scanned: 0,
+      unread: 0,
+      shown: 0,
+      truncated: true,
+      discoveryTruncated: true,
+      scanTruncated: true,
+      displayTruncated: true,
+    });
+    expect(view.limits).toMatchObject({
+      directoryEntries: 4_096,
+      sessionBytes: 4_194_304,
+      sessions: 100,
+      allowedSessions: 500,
+      readConcurrency: 8,
+      contentParts: 1_000,
+      previewCharacters: 500,
+      panelItems: 50,
+      toolItems: 100,
+      queryCharacters: 120,
+      sessionIdCharacters: 256,
+      sessionNameCharacters: 256,
+      sessionPathCharacters: 4_096,
+      statusErrorCharacters: 2_000,
+    });
+  });
+
+  it("preserves a safe configured scan limit above the default", () => {
+    const view = recallUnreadPanelView({
+      total: 250,
+      inventory: { available: 300, candidates: 300, scanned: 250, unread: 250, shown: 50 },
+      limits: { sessions: 250, allowedSessions: 500 },
+    });
+
+    expect(view.total).toBe(250);
+    expect(view.inventory).toMatchObject({ available: 300, candidates: 300, scanned: 250, unread: 250, shown: 50 });
+    expect(view.limits.sessions).toBe(250);
+  });
+});

package/packages/client-web/test/session-bridge-view.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import { sessionBridgePanelView } from "../src/session-bridge-view.js";
+
+describe("Session Bridge view", () => {
+  it("normalizes the latest handoff preview and operation summary", () => {
+    expect(
+      sessionBridgePanelView({
+        latest: { direction: "export", sessionId: "source", messages: 3, attachments: 1, at: "2026-09-05T10:00:00.000Z" },
+        latestPreview: {
+          source: { sessionId: "source", cwd: "/workspace", model: { provider: "fixture", modelId: "model" } },
+          preview: { goal: "Goal", currentState: "State", decisions: ["Keep API"], keyFiles: ["src/index.ts"], nextStep: "Test" },
+          at: "2026-09-05T10:01:00.000Z",
+        },
+        currentPreview: { goal: "Current goal", currentState: "Current state", decisions: [], keyFiles: [], nextStep: "Current next" },
+        status: { state: "completed", operation: "preview", at: "2026-09-05T10:02:00.000Z" },
+        formatVersion: 1,
+        limits: {
+          packageBytes: 262_144,
+          packageCharacters: 262_144,
+          messages: 100,
+          messageCharacters: 16_000,
+          totalMessageCharacters: 64_000,
+          contentParts: 1_000,
+          attachments: 100,
+          attachmentMarkerCharacters: 256,
+          sessionIdCharacters: 256,
+          cwdCharacters: 4_096,
+          modelFieldCharacters: 256,
+          previewTextCharacters: 1_000,
+          previewListItems: 8,
+          duplicateScanEntries: 10_000,
+          operationErrorCharacters: 2_000,
+        },
+      }),
+    ).toMatchObject({
+      latest: { direction: "export", sessionId: "source", messages: 3, attachments: 1, at: "2026-09-05T10:00:00.000Z" },
+      source: { sessionId: "source", cwd: "/workspace", model: { provider: "fixture", modelId: "model" } },
+      preview: { goal: "Goal", currentState: "State", decisions: ["Keep API"], keyFiles: ["src/index.ts"], nextStep: "Test" },
+      previewAt: "2026-09-05T10:01:00.000Z",
+      status: { state: "completed", operation: "preview", at: "2026-09-05T10:02:00.000Z", error: null },
+      formatVersion: 1,
+      limits: {
+        messages: 100,
+        attachments: 100,
+        previewTextCharacters: 1_000,
+        previewListItems: 8,
+        duplicateScanEntries: 10_000,
+        operationErrorCharacters: 2_000,
+      },
+    });
+  });
+
+  it("enforces fixed browser caps on hostile nested preview data", () => {
+    const long = "x".repeat(20_000);
+    const view = sessionBridgePanelView({
+      latest: { direction: "erase", sessionId: long, messages: 999, attachments: 999, at: long },
+      latestPreview: { source: { sessionId: long, cwd: long, model: { provider: long, modelId: long } }, preview: "invalid", at: long },
+      currentPreview: { goal: long, currentState: long, decisions: Array(20).fill(long), keyFiles: Array(20).fill(long), nextStep: long },
+      status: { state: "failed", operation: "import", at: "2026-09-05T10:03:00.000Z", error: long },
+      formatVersion: 999,
+      limits: {
+        packageBytes: 9_999_999,
+        packageCharacters: 9_999_999,
+        messages: 999,
+        messageCharacters: 99_999,
+        totalMessageCharacters: 99_999,
+        contentParts: 99_999,
+        attachments: 999,
+        attachmentMarkerCharacters: 9_999,
+        sessionIdCharacters: 9_999,
+        cwdCharacters: 99_999,
+        modelFieldCharacters: 9_999,
+        previewTextCharacters: 9_999,
+        previewListItems: 99,
+        duplicateScanEntries: 99_999,
+        operationErrorCharacters: 99_999,
+      },
+    });
+    expect(view?.latest).toBeNull();
+    expect(view?.source).toBeNull();
+    expect(view?.preview.goal).toHaveLength(1_000);
+    expect(view?.preview.currentState).toHaveLength(1_000);
+    expect(view?.preview.nextStep).toHaveLength(1_000);
+    expect(view?.preview.decisions).toHaveLength(8);
+    expect(view?.preview.keyFiles).toHaveLength(8);
+    expect(view?.preview.decisions[0]).toHaveLength(1_000);
+    expect(view?.formatVersion).toBe(1);
+    expect(view?.status).toEqual({ state: "failed", operation: "import", at: "2026-09-05T10:03:00.000Z", error: "x".repeat(2_000) });
+    expect(view?.limits).toMatchObject({
+      packageBytes: 262_144,
+      messages: 100,
+      messageCharacters: 16_000,
+      totalMessageCharacters: 64_000,
+      contentParts: 1_000,
+      attachments: 100,
+      previewTextCharacters: 1_000,
+      previewListItems: 8,
+      duplicateScanEntries: 10_000,
+      operationErrorCharacters: 2_000,
+    });
+  });
+});

package/packages/client-web/test/session-insights-panel.test.ts

@@ -0,0 +1,85 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "vitest";
+import { PluginPanelCard } from "../src/react-room.js";
+
+function renderPanel(data: unknown): string {
+  return renderToStaticMarkup(
+    createElement(PluginPanelCard, {
+      panel: {
+        id: "session-insights-panel",
+        pluginId: "@pi-harness/core/plugins/session-insights",
+        title: "Session Insights",
+        data,
+      },
+    }),
+  );
+}
+
+function report(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    sessionFile: null,
+    sessionId: "session-1",
+    userMessages: 2,
+    assistantMessages: 2,
+    toolCalls: 1,
+    toolResults: 1,
+    totalMessages: 5,
+    tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 35 },
+    cost: 0.012_345,
+    contextUsage: { tokens: 250, contextWindow: 1_000, percent: 25 },
+    compaction: { status: "completed", requestedAt: "2026-09-06T00:00:00.000Z", startedAt: "2026-09-06T00:00:01.000Z", finishedAt: "2026-09-06T00:00:02.000Z" },
+    ...overrides,
+  };
+}
+
+describe("session-insights panel", () => {
+  test("renders validated message, token, cost, context, and compaction details", () => {
+    const html = renderPanel(report());
+
+    for (const expected of ["session-1", "5", "1", "$0.0123", "35", "输入 10", "输出 20", "缓存读取 3", "缓存写入 2", "25.0%", "250 / 1,000", "压缩已完成"]) {
+      expect(html).toContain(expected);
+    }
+    expect(html).not.toContain("会话统计数据无效");
+    expect(html).not.toContain("压缩状态数据无效");
+  });
+
+  test("explains temporarily unknown context usage after compaction", () => {
+    const html = renderPanel(
+      report({
+        contextUsage: { tokens: null, contextWindow: 1_000, percent: null },
+        compaction: { status: "idle" },
+      }),
+    );
+
+    expect(html).toContain("待下一次模型响应");
+    expect(html).toContain("上下文窗口 1,000");
+    expect(html).toContain("尚未请求压缩");
+  });
+
+  test("renders malformed reports as unavailable instead of zero-valued health", () => {
+    const html = renderPanel(report({ cost: Number.NaN }));
+
+    expect(html).toContain("会话统计数据无效");
+    expect(html).not.toContain("$0.0000");
+    expect(html).not.toContain("tracked tokens");
+  });
+
+  test("keeps valid metrics visible while flagging malformed compaction state", () => {
+    const html = renderPanel(report({ compaction: { status: "completed" } }));
+
+    expect(html).toContain("35");
+    expect(html).toContain("$0.0123");
+    expect(html).toContain("压缩状态数据无效");
+    expect(html).not.toContain("压缩已完成");
+  });
+
+  test("wraps the maximum session id without horizontal truncation", () => {
+    const sessionId = "s".repeat(512);
+    const html = renderPanel(report({ sessionId }));
+
+    expect(html).toContain(sessionId);
+    expect(html).toMatch(/class="[^"]*break-all[^"]*"[^>]*>s{512}</u);
+    expect(html).not.toMatch(/class="[^"]*truncate[^"]*"[^>]*>s{512}</u);
+  });
+});