@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/test/i18n-pair-view.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, test } from "vitest";
+import { i18nPairPanelView } from "../src/i18n-pair-view.js";
+
+function validPanel(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    status: { state: "completed", at: "2026-09-05T01:00:00.000Z" },
+    report: {
+      base: "locales/en.json",
+      target: "locales/ja.json",
+      baseKeys: 3,
+      targetKeys: 2,
+      missing: ["actions.save"],
+      extra: [],
+      missingTotal: 1,
+      extraTotal: 0,
+      truncated: false,
+    },
+    limits: { fileBytes: 4_194_304, depth: 128, keysPerFile: 50_000, flattenedKeyLength: 2_048, pathLength: 4_096, panelKeysPerSide: 100 },
+    ...overrides,
+  };
+}
+
+describe("I18n pair panel view", () => {
+  test("normalizes comparison status, report inventories, and limits", () => {
+    const view = i18nPairPanelView(validPanel());
+
+    expect(view).toEqual({
+      status: { state: "completed", at: "2026-09-05T01:00:00.000Z", error: null },
+      report: {
+        base: "locales/en.json",
+        target: "locales/ja.json",
+        baseKeys: 3,
+        targetKeys: 2,
+        missing: ["actions.save"],
+        extra: [],
+        missingTotal: 1,
+        extraTotal: 0,
+        truncated: false,
+      },
+      malformed: false,
+      limits: { fileBytes: 4_194_304, depth: 128, keysPerFile: 50_000, flattenedKeyLength: 2_048, pathLength: 4_096, panelKeysPerSide: 100 },
+    });
+  });
+
+  test("bounds a valid server inventory to the visible list limit", () => {
+    const missing = Array.from({ length: 60 }, (_, index) => `missing-${index}`);
+    const extra = Array.from({ length: 60 }, (_, index) => `extra-${index}`);
+    const view = i18nPairPanelView(
+      validPanel({
+        status: { state: "failed", at: "2026-09-05T01:01:00.000Z", error: "comparison failed" },
+        report: {
+          base: "locales/en.json",
+          target: "locales/ja.json",
+          baseKeys: 100,
+          targetKeys: 100,
+          missing,
+          extra,
+          missingTotal: 60,
+          extraTotal: 60,
+          truncated: false,
+        },
+      }),
+    );
+
+    expect(view.status).toEqual({ state: "failed", at: "2026-09-05T01:01:00.000Z", error: "comparison failed" });
+    expect(view.report).toMatchObject({ baseKeys: 100, targetKeys: 100, missingTotal: 60, extraTotal: 60, truncated: true });
+    expect(view.report?.missing).toEqual(missing.slice(0, 50));
+    expect(view.report?.extra).toEqual(extra.slice(0, 50));
+    expect(view.malformed).toBe(false);
+  });
+
+  test("fails closed for malformed or contradictory reports", () => {
+    const malformed = [
+      null,
+      [],
+      {},
+      validPanel({ report: null }),
+      validPanel({ report: { base: "locales/en.json" } }),
+      validPanel({
+        report: {
+          base: "locales/en.json",
+          target: "locales/ja.json",
+          baseKeys: 1,
+          targetKeys: 1,
+          missing: [42],
+          extra: [],
+          missingTotal: 1,
+          extraTotal: 0,
+          truncated: false,
+        },
+      }),
+      validPanel({
+        report: {
+          base: "locales/en.json",
+          target: "locales/ja.json",
+          baseKeys: 1,
+          targetKeys: 1,
+          missing: ["missing"],
+          extra: [],
+          missingTotal: 1,
+          extraTotal: 0,
+          truncated: false,
+        },
+      }),
+      validPanel({ status: { state: "completed", at: "invalid" } }),
+      validPanel({ limits: { fileBytes: -1 } }),
+      validPanel({ unexpected: true }),
+    ];
+
+    for (const value of malformed) {
+      const view = i18nPairPanelView(value);
+      expect(view).toMatchObject({
+        status: { state: "unknown", at: null, error: null },
+        report: null,
+        malformed: true,
+      });
+    }
+  });
+
+  test("does not invoke accessors or revoked proxies and detaches returned arrays", () => {
+    let getterCalls = 0;
+    const rootAccessor = Object.defineProperty({}, "status", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return { state: "idle" };
+      },
+    });
+    const listAccessor: unknown[] = [];
+    Object.defineProperty(listAccessor, "0", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "poison";
+      },
+    });
+    const nestedAccessor = validPanel({
+      report: {
+        base: "locales/en.json",
+        target: "locales/ja.json",
+        baseKeys: 1,
+        targetKeys: 0,
+        missing: listAccessor,
+        extra: [],
+        missingTotal: 1,
+        extraTotal: 0,
+        truncated: false,
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    for (const value of [rootAccessor, nestedAccessor, revocable.proxy]) {
+      expect(() => i18nPairPanelView(value)).not.toThrow();
+      expect(i18nPairPanelView(value).malformed).toBe(true);
+    }
+    expect(getterCalls).toBe(0);
+
+    const source = validPanel();
+    const view = i18nPairPanelView(source);
+    (source.report as { missing: string[] }).missing[0] = "changed";
+    expect(view.report?.missing).toEqual(["actions.save"]);
+  });
+});

package/packages/client-web/test/mcp-client-view.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from "vitest";
+import { mcpClientPanelView } from "../src/mcp-client-view.js";
+
+describe("MCP client panel view", () => {
+  test("normalizes server inventories and production limits", () => {
+    const view = mcpClientPanelView({
+      server: "node server.mjs",
+      tools: [{ name: "echo", description: "Echo text", inputSchema: { type: "object" } }],
+      resources: [{ uri: "fixture://readme", name: "Readme", mimeType: "text/plain" }],
+      prompts: [{ name: "review", description: "Review code", arguments: [] }],
+      lastCall: "echo",
+      servers: [{ id: "docs", command: ["node", "server.mjs"], status: "running", startedAt: 100 }],
+      inventory: {
+        tools: { total: 1, shown: 1, truncated: false },
+        resources: { total: 1, shown: 1, truncated: false },
+        prompts: { total: 1, shown: 1, truncated: false },
+        servers: { total: 1, shown: 1, truncated: false },
+      },
+      limits: {
+        responseBytes: 1_048_576,
+        commandArgs: 32,
+        argumentBytes: 4_096,
+        toolArgumentsBytes: 65_536,
+        toolArgumentDepth: 32,
+        requestTimeoutMs: 30_000,
+        panelItems: 20,
+        inventoryItems: 1_000,
+        paginationPages: 100,
+        stderrBytes: 8_192,
+        managedServers: 128,
+      },
+    });
+
+    expect(view).toEqual({
+      server: "node server.mjs",
+      tools: [{ name: "echo", description: "Echo text" }],
+      resources: [{ uri: "fixture://readme", name: "Readme", mimeType: "text/plain" }],
+      prompts: [{ name: "review", description: "Review code" }],
+      lastCall: "echo",
+      servers: [{ id: "docs", status: "running", startedAt: 100 }],
+      inventory: {
+        tools: { total: 1, shown: 1, truncated: false },
+        resources: { total: 1, shown: 1, truncated: false },
+        prompts: { total: 1, shown: 1, truncated: false },
+        servers: { total: 1, shown: 1, truncated: false },
+      },
+      limits: {
+        responseBytes: 1_048_576,
+        commandArgs: 32,
+        argumentBytes: 4_096,
+        toolArgumentsBytes: 65_536,
+        toolArgumentDepth: 32,
+        requestTimeoutMs: 30_000,
+        panelItems: 20,
+        inventoryItems: 1_000,
+        paginationPages: 100,
+        stderrBytes: 8_192,
+        managedServers: 128,
+      },
+    });
+  });
+
+  test("bounds hostile arrays and strings and marks clipped inventories", () => {
+    const long = "x".repeat(10_000);
+    const view = mcpClientPanelView({
+      server: long,
+      tools: [{ name: 42 }, ...Array.from({ length: 20 }, (_, index) => ({ name: `${index}-${long}`, description: long }))],
+      resources: Array.from({ length: 20 }, (_, index) => ({ uri: `fixture://${index}/${long}`, name: long, mimeType: long })),
+      prompts: Array.from({ length: 20 }, (_, index) => ({ name: `${index}-${long}`, description: long })),
+      servers: Array.from({ length: 20 }, (_, index) => ({ id: `${index}-${long}`, status: index === 0 ? "running" : long, startedAt: -1 })),
+      lastCall: long,
+      inventory: { tools: { total: -1 }, resources: {}, prompts: {} },
+      limits: {},
+    });
+
+    expect(view.server).toBe("x".repeat(4_096));
+    expect(view.lastCall).toBe("x".repeat(512));
+    expect(view.tools).toHaveLength(12);
+    expect(view.tools[0]).toEqual({ name: `0-${"x".repeat(510)}`, description: "x".repeat(500) });
+    expect(view.resources).toHaveLength(8);
+    expect(view.resources[0]?.uri).toHaveLength(4_096);
+    expect(view.resources[0]?.name).toHaveLength(512);
+    expect(view.resources[0]?.mimeType).toHaveLength(256);
+    expect(view.prompts).toHaveLength(8);
+    expect(view.servers).toHaveLength(12);
+    expect(view.servers[0]).toEqual({ id: `0-${"x".repeat(62)}`, status: "running", startedAt: 0 });
+    expect(view.servers[1]?.status).toBe("unknown");
+    expect(view.inventory.tools).toEqual({ total: 12, shown: 12, truncated: true });
+    expect(view.inventory.resources).toEqual({ total: 8, shown: 8, truncated: true });
+    expect(view.inventory.prompts).toEqual({ total: 8, shown: 8, truncated: true });
+    expect(view.inventory.servers).toEqual({ total: 12, shown: 12, truncated: true });
+    expect(view.limits).toEqual({
+      responseBytes: 1_048_576,
+      commandArgs: 32,
+      argumentBytes: 4_096,
+      toolArgumentsBytes: 65_536,
+      toolArgumentDepth: 32,
+      requestTimeoutMs: 30_000,
+      panelItems: 20,
+      inventoryItems: 1_000,
+      paginationPages: 100,
+      stderrBytes: 8_192,
+      managedServers: 128,
+    });
+  });
+});

package/packages/client-web/test/modlens-view.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, test } from "vitest";
+import { modlensPanelView } from "../src/modlens-view.js";
+
+describe("ModLens panel view", () => {
+  test("normalizes completed evidence metadata and fixed safety limits without carrying evidence", () => {
+    const view = modlensPanelView({
+      attached: true,
+      image: {
+        mode: "evidence",
+        path: "screens/diagram.png",
+        mimeType: "image/png",
+        bytes: 24,
+        cached: true,
+        at: "2026-09-05T19:00:00.000Z",
+      },
+      status: {
+        state: "completed",
+        mode: "evidence",
+        path: "screens/diagram.png",
+        mimeType: "image/png",
+        bytes: 24,
+        cached: true,
+        at: "2026-09-05T19:00:00.000Z",
+      },
+      supportedTypes: ["gif", "jpeg", "jpg", "png", "webp"],
+      limits: {
+        imageBytes: 10_485_760,
+        pathCharacters: 4_096,
+        promptCharacters: 4_000,
+        evidenceBytes: 524_288,
+        agentTextBytes: 131_072,
+        timeoutMs: 90_000,
+        cacheEntries: 64,
+      },
+    });
+
+    expect(view).toEqual({
+      attached: true,
+      image: {
+        mode: "evidence",
+        path: "screens/diagram.png",
+        mimeType: "image/png",
+        bytes: 24,
+        cached: true,
+        at: "2026-09-05T19:00:00.000Z",
+      },
+      status: {
+        state: "completed",
+        mode: "evidence",
+        path: "screens/diagram.png",
+        mimeType: "image/png",
+        bytes: 24,
+        cached: true,
+        at: "2026-09-05T19:00:00.000Z",
+      },
+      supportedTypes: ["png", "jpeg", "jpg", "gif", "webp"],
+      limits: {
+        imageBytes: 10_485_760,
+        pathCharacters: 4_096,
+        promptCharacters: 4_000,
+        evidenceBytes: 524_288,
+        agentTextBytes: 131_072,
+        timeoutMs: 90_000,
+        cacheEntries: 64,
+      },
+      truncated: false,
+    });
+    expect(view.image).not.toHaveProperty("evidence");
+    expect(view.status).not.toHaveProperty("evidence");
+  });
+
+  test("marks contradictory completed image metadata as truncated", () => {
+    const view = modlensPanelView({
+      attached: true,
+      image: {
+        mode: "evidence",
+        path: "screens/original.png",
+        mimeType: "image/png",
+        bytes: 24,
+        cached: false,
+        at: "2026-09-05T19:00:00.000Z",
+      },
+      status: {
+        state: "completed",
+        mode: "native",
+        path: "screens/replacement.jpg",
+        mimeType: "image/jpeg",
+        bytes: 25,
+        cached: false,
+        at: "2026-09-05T19:00:01.000Z",
+      },
+      supportedTypes: ["png", "jpeg", "jpg", "gif", "webp"],
+      limits: {
+        imageBytes: 10_485_760,
+        pathCharacters: 4_096,
+        promptCharacters: 4_000,
+        evidenceBytes: 524_288,
+        agentTextBytes: 131_072,
+        timeoutMs: 180_000,
+        cacheEntries: 64,
+      },
+    });
+
+    expect(view.image).toMatchObject({ mode: "evidence", path: "screens/original.png", mimeType: "image/png", bytes: 24 });
+    expect(view.status).toMatchObject({ state: "completed", mode: "native", path: "screens/replacement.jpg", mimeType: "image/jpeg", bytes: 25 });
+    expect(view.truncated).toBe(true);
+  });
+
+  test("bounds hostile payloads, derives attachment state, and never invokes accessors", () => {
+    let getterCalls = 0;
+    const hostileImage = Object.defineProperty({}, "path", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "stolen.png";
+      },
+    });
+    const view = modlensPanelView({
+      attached: true,
+      image: hostileImage,
+      evidence: { summary: "browser-secret" },
+      status: {
+        state: "failed",
+        mode: "native",
+        path: `bad\n${"p".repeat(5_000)}`,
+        at: "2026-09-05T19:00:00.000Z",
+        error: `provider\u202e\n${"x".repeat(3_000)}`,
+      },
+      supportedTypes: Array.from({ length: 10_000 }, () => "svg"),
+      limits: {
+        imageBytes: Number.MAX_SAFE_INTEGER,
+        pathCharacters: Number.POSITIVE_INFINITY,
+        promptCharacters: -1,
+        evidenceBytes: 1,
+        agentTextBytes: 1,
+        timeoutMs: Number.NaN,
+        cacheEntries: 100_000,
+      },
+    });
+
+    expect(getterCalls).toBe(0);
+    expect(view.attached).toBe(false);
+    expect(view.image).toBeNull();
+    expect(view.status.state).toBe("failed");
+    if (view.status.state !== "failed") throw new Error("expected failed status");
+    expect(view.status.path.length).toBeLessThanOrEqual(4_096);
+    expect(view.status.path).not.toMatch(/[\p{Cc}\p{Cf}]/u);
+    expect(view.status.error.length).toBeLessThanOrEqual(2_000);
+    expect(view.status.error).not.toMatch(/[\p{Cc}\p{Cf}]/u);
+    expect(view.supportedTypes).toEqual(["png", "jpeg", "jpg", "gif", "webp"]);
+    expect(view.limits).toEqual({
+      imageBytes: 10_485_760,
+      pathCharacters: 4_096,
+      promptCharacters: 4_000,
+      evidenceBytes: 524_288,
+      agentTextBytes: 131_072,
+      timeoutMs: 180_000,
+      cacheEntries: 64,
+    });
+    expect(view.truncated).toBe(true);
+    expect(JSON.stringify(view)).not.toContain("browser-secret");
+  });
+
+  test("fails closed when a supported-types container throws during inspection", () => {
+    const poisonedTypes = new Proxy(["png"], {
+      get() {
+        throw new Error("must not escape the normalizer");
+      },
+    });
+
+    expect(() =>
+      modlensPanelView({
+        attached: false,
+        image: null,
+        status: { state: "idle" },
+        supportedTypes: poisonedTypes,
+        limits: {
+          imageBytes: 10_485_760,
+          pathCharacters: 4_096,
+          promptCharacters: 4_000,
+          evidenceBytes: 524_288,
+          agentTextBytes: 131_072,
+          timeoutMs: 180_000,
+          cacheEntries: 64,
+        },
+      }),
+    ).not.toThrow();
+    expect(modlensPanelView({ attached: false, image: null, status: { state: "idle" }, supportedTypes: poisonedTypes, limits: {} }).truncated).toBe(true);
+  });
+
+  test("fails closed when the entire payload is a revoked proxy", () => {
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    expect(() => modlensPanelView(revocable.proxy)).not.toThrow();
+    expect(modlensPanelView(revocable.proxy)).toMatchObject({ attached: false, image: null, status: { state: "idle" }, truncated: true });
+  });
+});

package/packages/client-web/test/openpets-view.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { openPetsPanelView } from "../src/openpets-view.js";
+
+describe("OpenPets view", () => {
+  it("normalizes a complete companion panel payload", () => {
+    expect(
+      openPetsPanelView({
+        name: "Mochi",
+        mood: "happy",
+        energy: 92,
+        interactions: 12,
+        lastEvent: "play",
+        updatedAt: "2026-09-05T10:00:00.000Z",
+        recovery: { sessionEntries: 40, scanned: 40, truncated: false, restored: true },
+        persistence: { attempts: 3, failures: 1, lastError: "disk full" },
+        limits: { nameCharacters: 128, recoveryEntries: 10_000, persistenceErrorCharacters: 2_000 },
+      }),
+    ).toEqual({
+      name: "Mochi",
+      mood: "happy",
+      energy: 92,
+      interactions: 12,
+      lastEvent: "play",
+      updatedAt: "2026-09-05T10:00:00.000Z",
+      recovery: { sessionEntries: 40, scanned: 40, truncated: false, restored: true },
+      persistence: { attempts: 3, failures: 1, lastError: "disk full" },
+      limits: { nameCharacters: 128, recoveryEntries: 10_000, persistenceErrorCharacters: 2_000 },
+    });
+  });
+
+  it("enforces fixed browser caps and repairs hostile state and inventory values", () => {
+    const long = "x".repeat(20_000);
+    expect(
+      openPetsPanelView({
+        name: long,
+        mood: "sleepy",
+        energy: Number.NaN,
+        interactions: Number.POSITIVE_INFINITY,
+        lastEvent: long,
+        updatedAt: long,
+        recovery: { sessionEntries: 20_000, scanned: 20_000, truncated: false, restored: "yes" },
+        persistence: { attempts: 4, failures: 99, lastError: long },
+        limits: { nameCharacters: 9_999, recoveryEntries: 99_999, persistenceErrorCharacters: 9_999 },
+      }),
+    ).toEqual({
+      name: "x".repeat(128),
+      mood: "idle",
+      energy: 80,
+      interactions: 0,
+      lastEvent: "session_start",
+      updatedAt: null,
+      recovery: { sessionEntries: 20_000, scanned: 10_000, truncated: true, restored: false },
+      persistence: { attempts: 4, failures: 4, lastError: "x".repeat(2_000) },
+      limits: { nameCharacters: 128, recoveryEntries: 10_000, persistenceErrorCharacters: 2_000 },
+    });
+  });
+});

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

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { pluginDevPanelView } from "../src/plugin-dev-view.js";
+
+describe("plugin dev view", () => {
+  it("normalizes a complete reload panel payload", () => {
+    expect(
+      pluginDevPanelView({
+        status: "running",
+        reason: "reload local extension",
+        requestedAt: "2026-09-05T10:00:00.000Z",
+        startedAt: "2026-09-05T10:00:01.000Z",
+        error: "",
+        limits: { reasonCharacters: 1_000, errorCharacters: 2_000 },
+      }),
+    ).toEqual({
+      status: "running",
+      reason: "reload local extension",
+      requestedAt: "2026-09-05T10:00:00.000Z",
+      startedAt: "2026-09-05T10:00:01.000Z",
+      reloadedAt: null,
+      error: null,
+      busy: true,
+      limits: { reasonCharacters: 1_000, errorCharacters: 2_000 },
+    });
+  });
+
+  it("bounds hostile strings and falls back from invalid status and limits", () => {
+    const long = "x".repeat(10_000);
+    const view = pluginDevPanelView({
+      status: "invented",
+      reason: long,
+      requestedAt: long,
+      startedAt: 42,
+      reloadedAt: long,
+      error: long,
+      limits: { reasonCharacters: 9_999, errorCharacters: 9_999 },
+    });
+    expect(view).toEqual({
+      status: "idle",
+      reason: "x".repeat(1_000),
+      requestedAt: "x".repeat(64),
+      startedAt: null,
+      reloadedAt: "x".repeat(64),
+      error: "x".repeat(2_000),
+      busy: false,
+      limits: { reasonCharacters: 1_000, errorCharacters: 2_000 },
+    });
+  });
+
+  it("accepts every backend state and marks only queued or running work as busy", () => {
+    expect(["idle", "queued", "running", "reloaded", "failed", "cancelled"].map((status) => pluginDevPanelView({ status }).status)).toEqual([
+      "idle",
+      "queued",
+      "running",
+      "reloaded",
+      "failed",
+      "cancelled",
+    ]);
+    expect(pluginDevPanelView({ status: "queued" }).busy).toBe(true);
+    expect(pluginDevPanelView({ status: "running" }).busy).toBe(true);
+    expect(pluginDevPanelView({ status: "cancelled" }).busy).toBe(false);
+  });
+});

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

@@ -0,0 +1,44 @@
+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: "plugin-stars-panel", pluginId: "@pi-harness/core/plugins/plugin-stars", title: "Plugin Stars", data },
+    }),
+  );
+}
+
+const limits = { responseBytes: 2_097_152, sourceItems: 1_000, resultItems: 10, panelItems: 20, queryCharacters: 120, timeoutMs: 15_000 };
+
+describe("Plugin Stars panel", () => {
+  test("renders a validated ranking", () => {
+    const html = renderPanel({
+      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: 1,
+        query: "",
+        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: 1, shown: 1, truncated: false },
+      limits,
+    });
+    expect(html).toContain("owner/fixture");
+    expect(html).toContain("★ 2");
+    expect(html).not.toContain("面板数据异常");
+  });
+
+  test("fails closed for malformed ranking metadata", () => {
+    const html = renderPanel({ source: "fixture", limit: 10, timeoutMs: 15_000, latest: null, inventory: { total: 1, shown: 0, truncated: false }, limits });
+    expect(html).toContain("Plugin Stars 面板数据异常");
+    expect(html).toContain("面板数据不完整或不可信");
+    expect(html).not.toContain("社区排行榜");
+  });
+});