@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/test/context-insights-view.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "vitest";
+import { contextInsightsPanelView } from "../src/context-insights-view.js";
+
+describe("Context Insights panel view", () => {
+  test("normalizes a complete bounded context report", () => {
+    expect(
+      contextInsightsPanelView({
+        tokens: 800,
+        contextWindow: 8_000,
+        percent: 10,
+        messages: 5,
+        scannedMessages: 5,
+        messagesTruncated: false,
+        events: 3,
+        compactions: 1,
+        composition: { user: 2, assistant: 1, toolResult: 1, system: 1, other: 0 },
+        recentEvents: [
+          { type: "message_start", at: 1_788_621_600_000 },
+          { type: "message_end", at: 1_788_621_601_000 },
+        ],
+      }),
+    ).toEqual({
+      tokens: 800,
+      contextWindow: 8_000,
+      percent: 10,
+      messages: 5,
+      scannedMessages: 5,
+      messagesTruncated: false,
+      events: 3,
+      compactions: 1,
+      composition: { user: 2, assistant: 1, toolResult: 1, system: 1, other: 0 },
+      recentEvents: [
+        { type: "message_end", at: 1_788_621_601_000 },
+        { type: "message_start", at: 1_788_621_600_000 },
+      ],
+      recentEventsTruncated: false,
+      limits: { scannedMessages: 10_000, retainedEvents: 50, displayedEvents: 6, eventTypeCharacters: 128 },
+    });
+  });
+
+  test("applies fixed browser bounds to malformed panel data", () => {
+    const type = `event\0${"x".repeat(1_000)}`;
+    const view = contextInsightsPanelView({
+      tokens: -1,
+      contextWindow: Number.POSITIVE_INFINITY,
+      percent: Number.NaN,
+      messages: Number.MAX_SAFE_INTEGER,
+      scannedMessages: Number.MAX_SAFE_INTEGER,
+      events: -1,
+      compactions: 1.5,
+      composition: { user: Number.MAX_SAFE_INTEGER },
+      recentEvents: Array.from({ length: 100 }, (_, index) => ({ type, at: index === 99 ? Number.MAX_VALUE : index })),
+    });
+
+    expect(view).toMatchObject({
+      tokens: null,
+      contextWindow: null,
+      percent: null,
+      messages: 0,
+      scannedMessages: 0,
+      events: 0,
+      compactions: 0,
+      composition: { user: 0, assistant: 0, toolResult: 0, system: 0, other: 0 },
+      recentEventsTruncated: true,
+    });
+    expect(view.recentEvents).toHaveLength(6);
+    expect(view.recentEvents[0]).toMatchObject({ at: null });
+    expect(typeof view.recentEvents[0]?.type).toBe("string");
+    expect(view.recentEvents[0]?.type).toHaveLength(128);
+    expect(view.recentEvents[0]?.type).not.toContain("\0");
+  });
+
+  test("preserves over-capacity usage for display", () => {
+    expect(contextInsightsPanelView({ percent: 125 })).toMatchObject({ percent: 125 });
+  });
+
+  test("does not execute root, composition, event array, or event accessors", () => {
+    let accessed = false;
+    const event = { at: 1_788_621_600_000 };
+    Object.defineProperty(event, "type", {
+      enumerable: true,
+      get() {
+        accessed = true;
+        throw new Error("event type getter executed");
+      },
+    });
+    const recentEvents = [event];
+    Object.defineProperty(recentEvents, "0", {
+      enumerable: true,
+      get() {
+        accessed = true;
+        throw new Error("event index getter executed");
+      },
+    });
+    const composition = {};
+    Object.defineProperty(composition, "user", {
+      enumerable: true,
+      get() {
+        accessed = true;
+        throw new Error("composition getter executed");
+      },
+    });
+    const data = { messages: 1, scannedMessages: 1, composition, recentEvents };
+    Object.defineProperty(data, "percent", {
+      enumerable: true,
+      get() {
+        accessed = true;
+        throw new Error("percent getter executed");
+      },
+    });
+
+    expect(() => contextInsightsPanelView(data)).not.toThrow();
+    expect(contextInsightsPanelView(data)).toMatchObject({
+      percent: null,
+      composition: { user: 0, assistant: 0, toolResult: 0, system: 0, other: 1 },
+      recentEvents: [{ type: "unknown", at: null }],
+    });
+    expect(accessed).toBe(false);
+  });
+});

package/packages/client-web/test/cost-meter-view.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "vitest";
+import { costMeterPanelView } from "../src/cost-meter-view.js";
+
+interface CostMeterPanelView {
+  dayBasis: "UTC";
+  entryLimit: number | null;
+  lastError: string | null;
+  entries: Array<{
+    sessionId: string;
+    utcDate: string;
+    dailyCost: number;
+    sessionCost: number;
+    tokens: number;
+    messages: number;
+  }>;
+}
+
+describe("cost meter panel view", () => {
+  test("labels bounded ledger entries as UTC daily increments and session snapshots", () => {
+    const view: CostMeterPanelView = costMeterPanelView({
+      dayBasis: "UTC",
+      entryLimit: 2_000,
+      lastError: "disk full",
+      entries: [
+        {
+          sessionId: "session-a",
+          cost: 1.25,
+          sessionCost: 4.5,
+          tokens: 100,
+          messages: 5,
+          recordedAt: "2026-01-02T03:04:05.000Z",
+        },
+        { sessionId: "invalid", cost: Number.NaN, sessionCost: 1, tokens: 1, messages: 1, recordedAt: "not-a-date" },
+      ],
+    });
+
+    expect(view).toEqual({
+      dayBasis: "UTC",
+      entryLimit: 2_000,
+      lastError: "disk full",
+      entries: [
+        {
+          sessionId: "session-a",
+          utcDate: "2026-01-02",
+          dailyCost: 1.25,
+          sessionCost: 4.5,
+          tokens: 100,
+          messages: 5,
+        },
+      ],
+    });
+  });
+});

package/packages/client-web/test/dependency-checker-panel.test.ts

@@ -0,0 +1,51 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "vitest";
+import { PluginPanelCard } from "../src/react-room.js";
+
+const baseReport = {
+  manifest: "package.json",
+  ecosystem: "npm",
+  declared: 1,
+  installed: 1,
+  scanLimit: 2_000,
+  missing: [],
+  optionalMissing: [],
+  invalid: [],
+  conflicts: [],
+};
+
+function renderDependencyPanel(report: Record<string, unknown>): string {
+  return renderToStaticMarkup(
+    createElement(PluginPanelCard, {
+      panel: {
+        id: "dependency-checker-panel",
+        pluginId: "@pi-harness/core/plugins/dependency-checker",
+        title: "Dependency Checker",
+        data: { report },
+      },
+    }),
+  );
+}
+
+describe("dependency checker panel", () => {
+  test("renders unresolved-only reports as an amber indeterminate state", () => {
+    const html = renderDependencyPanel({
+      ...baseReport,
+      unresolved: [{ name: "shared", constraints: ["workspace:*", "^1.0.0"] }],
+    });
+
+    expect(html).toContain("未决");
+    expect(html).toContain("1 组声明约束无法离线判定");
+    expect(html).toContain("shared");
+    expect(html).toContain("workspace:*");
+    expect(html).not.toContain("依赖声明与本地安装一致");
+  });
+
+  test("does not render malformed or truncated reports as healthy", () => {
+    const html = renderDependencyPanel({ ...baseReport, unresolved: [], unexpected: true });
+
+    expect(html).toContain("报告不完整");
+    expect(html).not.toContain("依赖声明与本地安装一致");
+  });
+});

package/packages/client-web/test/dependency-checker-view.test.ts

@@ -0,0 +1,266 @@
+import { describe, expect, test } from "vitest";
+import { dependencyCheckerPanelView } from "../src/dependency-checker-view.js";
+
+interface DependencyCheckerView {
+  manifest: string;
+  ecosystem: "npm" | "python";
+  declared: number;
+  installed: number;
+  scanLimit: number;
+  missingCount: number;
+  optionalMissingCount: number;
+  invalidCount: number;
+  conflictCount: number;
+  missing: string[];
+  optionalMissing: string[];
+  invalid: string[];
+  conflicts: Array<{ name: string; constraints: string[] }>;
+  truncated: boolean;
+}
+
+describe("dependency checker panel view", () => {
+  function report(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+    return {
+      manifest: "package.json",
+      ecosystem: "npm",
+      declared: 0,
+      installed: 0,
+      scanLimit: 2_000,
+      missing: [],
+      optionalMissing: [],
+      invalid: [],
+      conflicts: [],
+      unresolved: [],
+      ...overrides,
+    };
+  }
+
+  test("bounds report details while preserving issue totals and scan metadata", () => {
+    const missing = Array.from({ length: 25 }, (_, index) => `missing-${index}`);
+    const view: DependencyCheckerView = dependencyCheckerPanelView({
+      report: {
+        manifest: "apps/web/package.json",
+        ecosystem: "npm",
+        declared: 29,
+        installed: 2,
+        scanLimit: 2_000,
+        missing,
+        optionalMissing: ["optional"],
+        invalid: ["../invalid"],
+        conflicts: [{ name: "react", constraints: ["^18", ">=19"] }],
+      },
+    });
+
+    expect(view).toEqual({
+      manifest: "apps/web/package.json",
+      ecosystem: "npm",
+      declared: 29,
+      installed: 2,
+      scanLimit: 2_000,
+      missingCount: 25,
+      optionalMissingCount: 1,
+      invalidCount: 1,
+      conflictCount: 1,
+      unresolvedCount: 0,
+      missing: missing.slice(0, 20),
+      optionalMissing: ["optional"],
+      invalid: ["../invalid"],
+      conflicts: [{ name: "react", constraints: ["^18", ">=19"] }],
+      unresolved: [],
+      truncated: true,
+    });
+  });
+
+  test("marks conflict constraint details as truncated", () => {
+    const constraints = Array.from({ length: 9 }, (_, index) => `>=${index}.0.0`);
+    const view = dependencyCheckerPanelView({ report: { conflicts: [{ name: "package", constraints }] } });
+
+    expect(view.conflicts).toEqual([{ name: "package", constraints: constraints.slice(0, 8) }]);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("marks oversized panel strings as truncated", () => {
+    const constraint = ">=" + "1".repeat(300);
+    const view = dependencyCheckerPanelView({ report: { conflicts: [{ name: "package", constraints: [constraint] }] } });
+
+    expect(view.conflicts[0]?.constraints).toEqual([constraint.slice(0, 256)]);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("normalizes unresolved constraint groups independently from conflicts", () => {
+    const view = dependencyCheckerPanelView({
+      report: {
+        manifest: "package.json",
+        ecosystem: "npm",
+        declared: 1,
+        installed: 1,
+        scanLimit: 2_000,
+        missing: [],
+        optionalMissing: [],
+        invalid: [],
+        conflicts: [],
+        unresolved: [{ name: "shared", constraints: ["workspace:*", "^1.0.0"] }],
+      },
+    });
+
+    expect(view as unknown).toMatchObject({
+      conflictCount: 0,
+      unresolvedCount: 1,
+      unresolved: [{ name: "shared", constraints: ["workspace:*", "^1.0.0"] }],
+      truncated: false,
+    });
+  });
+
+  test("fails closed without invoking root or nested accessors and revoked proxies", () => {
+    let getterCalls = 0;
+    const rootAccessor = Object.defineProperty({}, "report", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return {};
+      },
+    });
+    const listAccessor = Object.defineProperty([], "0", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "poison";
+      },
+    });
+    Object.defineProperty(listAccessor, "length", { value: 1 });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    for (const input of [rootAccessor, revocable.proxy, { report: { missing: listAccessor } }]) {
+      expect(() => dependencyCheckerPanelView(input)).not.toThrow();
+      expect(dependencyCheckerPanelView(input)).toMatchObject({ declared: 0, installed: 0, missing: [], conflicts: [], truncated: true });
+    }
+    expect(getterCalls).toBe(0);
+  });
+
+  test("marks unknown root, report, and conflict fields as truncated", () => {
+    expect(dependencyCheckerPanelView({ report: report(), unexpected: true }).truncated).toBe(true);
+    expect(dependencyCheckerPanelView({ report: report({ unexpected: true }) }).truncated).toBe(true);
+    expect(
+      dependencyCheckerPanelView({
+        report: report({
+          declared: 1,
+          installed: 1,
+          conflicts: [{ name: "react", constraints: ["^18"], unexpected: true }],
+        }),
+      }).truncated,
+    ).toBe(true);
+  });
+
+  test("removes control, bidi, and unpaired surrogate characters from visible text", () => {
+    const view = dependencyCheckerPanelView({
+      report: report({
+        manifest: " apps/\u202Eweb/package.json\uD800 ",
+        declared: 2,
+        missing: ["left\u0000right"],
+        unresolved: [{ name: "pkg\u202Ename", constraints: ["workspace:\uD800*"] }],
+      }),
+    });
+
+    expect(view.manifest).toBe("apps/ web/package.json");
+    expect(view.missing).toEqual(["left right"]);
+    expect(view.unresolved).toEqual([{ name: "pkg name", constraints: ["workspace: *"] }]);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("does not create an unpaired surrogate when truncating visible text", () => {
+    const name = `${"x".repeat(255)}😀tail`;
+    const view = dependencyCheckerPanelView({
+      report: report({ declared: 1, missing: [name] }),
+    });
+
+    expect(view.missing).toEqual([`${"x".repeat(255)}😀`]);
+    expect(view.missing[0]).not.toMatch(/[\p{Cs}]/u);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("reads at most 2000 list entries without invoking later accessors", () => {
+    let getterCalls = 0;
+    const missing = Array.from({ length: 2_001 }, (_, index) => `missing-${index}`);
+    Object.defineProperty(missing, "2000", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "poison";
+      },
+    });
+
+    const view = dependencyCheckerPanelView({
+      report: report({ declared: 2_000, missing }),
+    });
+
+    expect(getterCalls).toBe(0);
+    expect(view.missingCount).toBe(2_000);
+    expect(view.missing).toHaveLength(20);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("fails closed for contradictory declared, installed, and issue totals", () => {
+    const installedBeyondDeclared = dependencyCheckerPanelView({
+      report: report({ declared: 1, installed: 2 }),
+    });
+    const installedPlusIssuesBeyondDeclared = dependencyCheckerPanelView({
+      report: report({ declared: 1, installed: 1, missing: ["missing"] }),
+    });
+
+    expect(installedBeyondDeclared).toMatchObject({ declared: 0, installed: 0, truncated: true });
+    expect(installedPlusIssuesBeyondDeclared).toMatchObject({ declared: 1, installed: 0, missing: ["missing"], truncated: true });
+  });
+
+  test("accepts Python invalid lines outside the declared package total", () => {
+    const view = dependencyCheckerPanelView({
+      report: report({ ecosystem: "python", invalid: ["-r base.txt"] }),
+    });
+
+    expect(view).toMatchObject({
+      ecosystem: "python",
+      declared: 0,
+      installed: 0,
+      invalidCount: 1,
+      invalid: ["-r base.txt"],
+      truncated: false,
+    });
+  });
+
+  test("fails closed when npm declaration classifications do not account for every package", () => {
+    const view = dependencyCheckerPanelView({
+      report: report({ declared: 1, installed: 0 }),
+    });
+
+    expect(view).toMatchObject({ declared: 0, installed: 0, truncated: true });
+  });
+
+  test("marks duplicate and cross-list dependency records as truncated", () => {
+    const duplicate = dependencyCheckerPanelView({
+      report: report({ declared: 2, optionalMissing: ["same", "same"] }),
+    });
+    const crossList = dependencyCheckerPanelView({
+      report: report({ declared: 2, missing: ["same"], optionalMissing: ["same"] }),
+    });
+
+    expect(duplicate.truncated).toBe(true);
+    expect(crossList.truncated).toBe(true);
+  });
+
+  test("returns an explicitly truncated empty view for missing or invalid reports", () => {
+    for (const input of [undefined, null, {}, { report: null }, { report: [] }, { report: new Date() }]) {
+      expect(dependencyCheckerPanelView(input)).toMatchObject({
+        declared: 0,
+        installed: 0,
+        missing: [],
+        optionalMissing: [],
+        invalid: [],
+        conflicts: [],
+        unresolved: [],
+        truncated: true,
+      });
+    }
+  });
+});

package/packages/client-web/test/docker-sandbox-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: "docker-sandbox-panel", pluginId: "@pi-harness/core/plugins/docker-sandbox", title: "Docker Sandbox", data },
+    }),
+  );
+}
+
+const defaults = {
+  image: "alpine:3.20",
+  pull: "never",
+  network: "none",
+  rootFilesystem: "read-only",
+  workspace: "read-only",
+  memory: "512m",
+  cpus: 1,
+  pids: 256,
+  timeoutMs: 120_000,
+};
+
+describe("Docker sandbox panel", () => {
+  test("renders a validated run and enforced defaults", () => {
+    const html = renderPanel({
+      latest: { image: "alpine:3.20", command: ["node", "--version"], write: false, exitCode: 0, status: "completed", output: "v22.0.0\n" },
+      defaults,
+    });
+    expect(html).toContain("alpine:3.20");
+    expect(html).toContain("2 个 argv 参数");
+    expect(html).toContain("network:none");
+    expect(html).not.toContain("面板数据异常");
+  });
+
+  test("renders an explicit error for malformed panel data", () => {
+    const html = renderPanel({ defaults: { ...defaults, network: "host" }, latest: null });
+    expect(html).toContain("Docker Sandbox 面板数据异常");
+    expect(html).toContain("面板数据不完整或不可信");
+    expect(html).not.toContain("还没有沙箱运行");
+  });
+});

package/packages/client-web/test/docker-sandbox-view.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "vitest";
+import { dockerSandboxPanelView } from "../src/docker-sandbox-view.js";
+
+const defaultSettings = {
+  image: "alpine:3.20",
+  pull: "never",
+  network: "none",
+  rootFilesystem: "read-only",
+  workspace: "read-only",
+  memory: "512m",
+  cpus: 1,
+  pids: 256,
+  timeoutMs: 120_000,
+} as const;
+
+describe("Docker sandbox panel view", () => {
+  test("normalizes run status and exposes the enforced sandbox defaults", () => {
+    const view = dockerSandboxPanelView({
+      latest: {
+        image: "alpine:3.20",
+        command: ["node", "--version"],
+        write: false,
+        exitCode: 0,
+        status: "completed",
+        output: "v22.0.0\n",
+      },
+      defaults: {
+        image: "alpine:3.20",
+        pull: "never",
+        network: "none",
+        rootFilesystem: "read-only",
+        workspace: "read-only",
+        memory: "512m",
+        cpus: 1,
+        pids: 256,
+        timeoutMs: 120_000,
+      },
+    });
+
+    expect(view).toEqual({
+      malformed: false,
+      latest: {
+        image: "alpine:3.20",
+        command: ["node", "--version"],
+        commandCount: 2,
+        write: false,
+        exitCode: 0,
+        status: "completed",
+        output: "v22.0.0\n",
+        truncated: false,
+      },
+      defaults: {
+        image: "alpine:3.20",
+        pull: "never",
+        network: "none",
+        rootFilesystem: "read-only",
+        workspace: "read-only",
+        memory: "512m",
+        cpus: 1,
+        pids: 256,
+        timeoutMs: 120_000,
+      },
+    });
+  });
+
+  test("bounds hostile command and output details while preserving totals", () => {
+    const command = Array.from({ length: 20 }, (_, index) => (index === 0 ? "x".repeat(300) : `arg-${index}`));
+    const view = dockerSandboxPanelView({
+      latest: { image: "i".repeat(800), command, write: true, exitCode: 7, status: "failed", output: "o".repeat(5_000) },
+      defaults: { ...defaultSettings },
+    });
+
+    expect(view.latest).toMatchObject({
+      image: "i".repeat(512),
+      commandCount: 20,
+      write: true,
+      exitCode: 7,
+      status: "failed",
+      output: "o".repeat(4_000),
+      truncated: true,
+    });
+    expect(view.latest?.command).toHaveLength(16);
+    expect(view.latest?.command[0]).toBe("x".repeat(256));
+    expect(view.defaults.timeoutMs).toBe(120_000);
+    expect(view.defaults.cpus).toBe(1);
+    expect(view.defaults.pids).toBe(256);
+    expect(view.malformed).toBe(false);
+  });
+
+  test("rejects malformed latest values instead of presenting them as successful runs", () => {
+    const view = dockerSandboxPanelView({ latest: { image: {}, command: "echo ok", exitCode: Number.NaN, status: "completed" } });
+
+    expect(view).toEqual({
+      malformed: true,
+      latest: null,
+      defaults: {
+        image: "alpine:3.20",
+        pull: "never",
+        network: "none",
+        rootFilesystem: "read-only",
+        workspace: "read-only",
+        memory: "512m",
+        cpus: 1,
+        pids: 256,
+        timeoutMs: 120_000,
+      },
+    });
+  });
+
+  test("fails closed for accessors, revoked proxies, and contradictory inventories", () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "defaults", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return {};
+      },
+    });
+    const revoked = Proxy.revocable({}, {});
+    revoked.revoke();
+    for (const value of [accessor, revoked.proxy, { defaults: { ...defaultSettings, timeoutMs: 1 }, latest: null }]) {
+      expect(() => dockerSandboxPanelView(value)).not.toThrow();
+      expect(dockerSandboxPanelView(value).malformed).toBe(true);
+    }
+    expect(getterCalls).toBe(0);
+  });
+});