@pi-harness/pi-harness 0.1.14 → 0.1.16

package/packages/core/src/plugins/telemetry-blocker.ts

@@ -1,78 +0,0 @@
-import type { Context } from "@deepseek-ai/cordis";
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
-import type { PiTelemetryEvent, PiTelemetryService } from "../services.js";
-import { assertKnownConfigKeys } from "../config.js";
-import z from "@deepseek-ai/schemastery";
-
-type TelemetrySnapshot = { blocked: number; names: readonly string[] };
-export const Config = z.object({});
-
-function eventName(value: string): string {
-  const name = value.trim().slice(0, 80);
-  if (name.length === 0) throw new Error("Telemetry event name must not be empty");
-  return name;
-}
-
-export default {
-  name: "pi-telemetry-blocker",
-  inject: ["piPluginUi", "piTools"],
-  Config,
-  apply(context: Context, config: unknown) {
-    assertKnownConfigKeys("telemetry-blocker", config, []);
-    let blocked = 0;
-    const names: string[] = [];
-    const record = (event: PiTelemetryEvent): { blocked: true; name: string } => {
-      const name = eventName(event.name);
-      blocked += 1;
-      if (!names.includes(name)) names.push(name);
-      return { blocked: true, name };
-    };
-    const service: PiTelemetryService = {
-      enabled: false,
-      send: record,
-      snapshot: (): TelemetrySnapshot => ({ blocked, names: [...names] }),
-    };
-    context.provide("piTelemetry", service);
-    const unsubscribe = context.on("pi/telemetry", (event) => {
-      const descriptor = Object.getOwnPropertyDescriptor(event, "name");
-      if (descriptor === undefined || !("value" in descriptor)) return;
-      if (typeof descriptor.value !== "string") return;
-      record({ name: descriptor.value });
-    });
-    const unregisterTool = context.piTools.register(
-      defineTool({
-        name: "telemetry_status",
-        label: "Telemetry status",
-        description: "Report the local telemetry policy. Pi Harness telemetry is disabled and no event properties are retained.",
-        promptSnippet: "check whether telemetry is enabled",
-        parameters: Type.Object({}, { additionalProperties: false }),
-        executionMode: "sequential",
-        execute(): Promise<AgentToolResult<TelemetrySnapshot>> {
-          const snapshot = service.snapshot();
-          return Promise.resolve({ content: [{ type: "text", text: `Telemetry disabled; blocked ${snapshot.blocked} event(s).` }], details: snapshot });
-        },
-      }),
-    );
-    let disposePanel: () => void;
-    try {
-      disposePanel = context.piPluginUi.register({
-        id: "telemetry-blocker-panel",
-        pluginId: "@pi-harness/core/plugins/telemetry-blocker",
-        title: "Telemetry Blocker",
-        description: "默认关闭遥测，只保留事件名和计数，不保存事件属性。",
-        icon: "⊘",
-        read: () => ({ enabled: service.enabled, blocked, names: [...names] }),
-      });
-    } catch (error) {
-      unregisterTool();
-      unsubscribe();
-      throw error;
-    }
-    context.effect(() => () => {
-      unsubscribe();
-      unregisterTool();
-      disposePanel();
-    });
-  },
-};

package/packages/core/src/plugins/test-harness.ts

@@ -1,300 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { isAbsolute } from "node:path";
-import { stripVTControlCharacters } from "node:util";
-import type { Context } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
-import { assertKnownConfigKeys } from "../config.js";
-
-const allowedScripts = ["test", "build", "format:check", "lint", "typecheck"] as const;
-const allowedScriptSet = new Set<string>(allowedScripts);
-const defaultTimeoutMs = 120_000;
-const minimumTimeoutMs = 100;
-const maximumTimeoutMs = 600_000;
-const maxOutputBytes = 12 * 1024;
-const terminationGraceMs = 1_000;
-
-type TestScript = (typeof allowedScripts)[number];
-type TestRunStatus = "passed" | "failed" | "timed-out" | "cancelled";
-
-type TestRun = {
-  script: TestScript;
-  command: string;
-  status: TestRunStatus;
-  exitCode: number | null;
-  signal: string | null;
-  durationMs: number;
-  output: string;
-  outputBytes: number;
-  outputTruncated: boolean;
-  outputSanitized: boolean;
-};
-
-export interface TestHarnessConfig {
-  timeoutMs?: number;
-}
-
-export const Config: z<TestHarnessConfig> = z.object({ timeoutMs: z.number().default(defaultTimeoutMs) });
-
-function testHarnessParameters(value: unknown): { script: TestScript } {
-  if (value === null || typeof value !== "object") throw new Error("Test harness parameters must be a plain object");
-  let descriptors: PropertyDescriptorMap;
-  let prototype: unknown;
-  let array: boolean;
-  try {
-    array = Array.isArray(value);
-    descriptors = Object.getOwnPropertyDescriptors(value);
-    prototype = Object.getPrototypeOf(value) as unknown;
-  } catch (error) {
-    throw new Error("Test harness parameters must be an accessible plain object", { cause: error });
-  }
-  if (array || (prototype !== Object.prototype && prototype !== null)) throw new Error("Test harness parameters must be a plain object");
-  if (Reflect.ownKeys(descriptors).some((key) => key !== "script")) throw new Error("Test harness parameters must contain only script");
-  const descriptor = descriptors.script;
-  if (descriptor === undefined) return { script: "test" };
-  if (!("value" in descriptor) || typeof descriptor.value !== "string") throw new Error("Test harness parameters script must be a string data property");
-  if (!allowedScriptSet.has(descriptor.value)) throw new Error("Test harness parameters script is not an approved verification script");
-  return { script: descriptor.value as TestScript };
-}
-
-function throwIfCancelled(signal: AbortSignal): void {
-  if (signal.aborted) throw new Error("Project verification was cancelled");
-}
-
-function npmInvocation(script: TestScript): { executable: string; args: string[] } {
-  const npmCli = process.env.npm_execpath;
-  if (typeof npmCli === "string" && npmCli.trim() !== "" && isAbsolute(npmCli)) {
-    return { executable: process.execPath, args: [npmCli, "run", script] };
-  }
-  if (process.platform === "win32") {
-    return { executable: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", `npm.cmd run ${script}`] };
-  }
-  return { executable: "npm", args: ["run", script] };
-}
-
-function appendTail(current: Buffer<ArrayBufferLike>, chunk: Buffer<ArrayBufferLike>, maximum: number): Buffer<ArrayBufferLike> {
-  if (chunk.length >= maximum) return Buffer.from(chunk.subarray(chunk.length - maximum));
-  if (current.length + chunk.length <= maximum) return Buffer.concat([current, chunk], current.length + chunk.length);
-  const keep = maximum - chunk.length;
-  return Buffer.concat([current.subarray(current.length - keep), chunk], maximum);
-}
-
-function utf8Tail(value: string, maximum: number): { value: string; truncated: boolean } {
-  if (Buffer.byteLength(value, "utf8") <= maximum) return { value, truncated: false };
-  const codePoints = [...value];
-  let bytes = 0;
-  let start = codePoints.length;
-  while (start > 0) {
-    const size = Buffer.byteLength(codePoints[start - 1]!, "utf8");
-    if (bytes + size > maximum) break;
-    bytes += size;
-    start -= 1;
-  }
-  return { value: codePoints.slice(start).join(""), truncated: true };
-}
-
-function replaceUnsafeControls(value: string): string {
-  let output = "";
-  for (const codePoint of value) {
-    const code = codePoint.codePointAt(0)!;
-    const safeCharacter = code === 9 || code === 10 || (code >= 32 && code !== 127 && (code < 128 || code > 159) && !/[\p{Cf}\p{Cs}]/u.test(codePoint));
-    output += safeCharacter ? codePoint : "�";
-  }
-  return output;
-}
-
-function safeOutput(raw: Buffer): { output: string; boundedAgain: boolean; sanitized: boolean } {
-  const decoded = raw.toString("utf8");
-  const withoutTerminalSequences = stripVTControlCharacters(decoded);
-  const normalized = replaceUnsafeControls(withoutTerminalSequences.replaceAll(/\r\n?/gu, "\n"));
-  const bounded = utf8Tail(normalized, maxOutputBytes);
-  return { output: bounded.value, boundedAgain: bounded.truncated, sanitized: decoded !== normalized };
-}
-
-function terminateProcessTree(child: ChildProcess, signal: NodeJS.Signals): void {
-  if (process.platform === "win32" && child.pid !== undefined) {
-    const terminator = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { shell: false, stdio: "ignore", windowsHide: true });
-    terminator.once("error", () => child.kill(signal));
-    terminator.once("close", (code) => {
-      if (code !== 0) child.kill(signal);
-    });
-    terminator.unref();
-    return;
-  }
-  if (child.pid !== undefined) {
-    try {
-      process.kill(-child.pid, signal);
-      return;
-    } catch {
-      // Fall back when no detached process group was established.
-    }
-  }
-  child.kill(signal);
-}
-
-function safeSpawnFailure(error: unknown): string {
-  if (error !== null && typeof error === "object") {
-    try {
-      const code = Object.getOwnPropertyDescriptor(error, "code");
-      if (code !== undefined && "value" in code && typeof code.value === "string" && /^[A-Z0-9_]{1,32}$/u.test(code.value)) {
-        return `Could not start npm (${code.value})`;
-      }
-    } catch {
-      // Use the stable fallback below.
-    }
-  }
-  return "Could not start npm";
-}
-
-function cloneRun(run: TestRun): TestRun {
-  return { ...run };
-}
-
-function runNpmScript(cwd: string, script: TestScript, timeoutMs: number, signal: AbortSignal): Promise<TestRun> {
-  throwIfCancelled(signal);
-  const started = Date.now();
-  const command = `npm run ${script}`;
-  const invocation = npmInvocation(script);
-  return new Promise((resolve) => {
-    let child: ChildProcess;
-    try {
-      child = spawn(invocation.executable, invocation.args, {
-        cwd,
-        detached: process.platform !== "win32",
-        shell: false,
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true,
-      });
-    } catch (error) {
-      const output = safeSpawnFailure(error);
-      resolve({
-        script,
-        command,
-        status: "failed",
-        exitCode: null,
-        signal: null,
-        durationMs: Date.now() - started,
-        output,
-        outputBytes: Buffer.byteLength(output, "utf8"),
-        outputTruncated: false,
-        outputSanitized: false,
-      });
-      return;
-    }
-
-    let outputTail: Buffer<ArrayBufferLike> = Buffer.alloc(0);
-    let outputBytes = 0;
-    let outputTruncated = false;
-    let stopReason: "timed-out" | "cancelled" | undefined;
-    let spawnFailure: unknown;
-    let killTimer: ReturnType<typeof setTimeout> | undefined;
-    const append = (chunk: Buffer) => {
-      outputBytes = Math.min(Number.MAX_SAFE_INTEGER, outputBytes + chunk.length);
-      outputTruncated ||= outputBytes > maxOutputBytes;
-      outputTail = appendTail(outputTail, chunk, maxOutputBytes);
-    };
-    const stop = (reason: "timed-out" | "cancelled") => {
-      stopReason ??= reason;
-      if (child.exitCode !== null || child.signalCode !== null) return;
-      terminateProcessTree(child, "SIGTERM");
-      killTimer ??= setTimeout(() => terminateProcessTree(child, "SIGKILL"), terminationGraceMs);
-      killTimer.unref();
-    };
-    const onAbort = () => stop("cancelled");
-    signal.addEventListener("abort", onAbort, { once: true });
-    const timeout = setTimeout(() => stop("timed-out"), timeoutMs);
-    timeout.unref();
-    child.stdout?.on("data", append);
-    child.stderr?.on("data", append);
-    child.once("error", (error) => {
-      spawnFailure = error;
-    });
-    child.once("close", (code, childSignal) => {
-      clearTimeout(timeout);
-      if (killTimer !== undefined && process.platform === "win32") clearTimeout(killTimer);
-      signal.removeEventListener("abort", onAbort);
-      let safe = safeOutput(outputTail);
-      if (spawnFailure !== undefined && safe.output === "") {
-        const output = safeSpawnFailure(spawnFailure);
-        safe = { output, boundedAgain: false, sanitized: false };
-        outputBytes = Buffer.byteLength(output, "utf8");
-      }
-      const status: TestRunStatus = stopReason ?? (code === 0 ? "passed" : "failed");
-      resolve({
-        script,
-        command,
-        status,
-        exitCode: stopReason === undefined ? code : null,
-        signal: childSignal,
-        durationMs: Date.now() - started,
-        output: safe.output,
-        outputBytes,
-        outputTruncated: outputTruncated || safe.boundedAgain,
-        outputSanitized: safe.sanitized,
-      });
-    });
-  });
-}
-
-function agentText(run: TestRun): string {
-  const output = run.output.replace(/<\/test-output(?=\s*>)/giu, "<\\/test-output");
-  return `<test-output command="${run.command}" untrusted="true" status="${run.status}" exit-code="${run.exitCode ?? "unknown"}" output-truncated="${run.outputTruncated}">\n${output}\n</test-output>`;
-}
-
-export default {
-  name: "pi-test-harness",
-  inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
-  Config,
-  apply(context: Context, config: TestHarnessConfig) {
-    assertKnownConfigKeys("test-harness", config, ["timeoutMs"]);
-    const timeoutMs = config.timeoutMs ?? defaultTimeoutMs;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < minimumTimeoutMs || timeoutMs > maximumTimeoutMs)
-      throw new Error(`Test-harness timeoutMs must be an integer from ${minimumTimeoutMs} through ${maximumTimeoutMs}`);
-    let latest: TestRun | undefined;
-    const lifecycle = new AbortController();
-    context.effect(() => () => lifecycle.abort(new Error("Test-harness plugin was disposed")));
-    const unregisterTool = context.piTools.register(
-      defineTool({
-        name: "run_project_tests",
-        label: "Run project tests",
-        description: "Run one approved npm verification script in the current workspace with bounded, untrusted output and lifecycle cancellation.",
-        promptSnippet: "run an approved project verification script",
-        parameters: Type.Object(
-          {
-            script: Type.Optional(
-              Type.Union([Type.Literal("test"), Type.Literal("build"), Type.Literal("format:check"), Type.Literal("lint"), Type.Literal("typecheck")], {
-                description: "Approved project verification script; defaults to test",
-              }),
-            ),
-          },
-          { additionalProperties: false },
-        ),
-        executionMode: "sequential",
-        async execute(_toolCallId, rawParams, signal): Promise<AgentToolResult<TestRun>> {
-          const { script } = testHarnessParameters(rawParams);
-          const operationSignal = signal === undefined ? lifecycle.signal : AbortSignal.any([signal, lifecycle.signal]);
-          throwIfCancelled(operationSignal);
-          const run = await runNpmScript(context.piHarnessLaunch.cwd, script, timeoutMs, operationSignal);
-          latest = cloneRun(run);
-          if (run.status === "cancelled") throw new Error("Project verification was cancelled");
-          return { content: [{ type: "text", text: agentText(run) }], details: cloneRun(run) };
-        },
-      }),
-    );
-    context.effect(() => unregisterTool);
-    const disposePanel = context.piPluginUi.register({
-      id: "test-harness-panel",
-      pluginId: "@pi-harness/core/plugins/test-harness",
-      title: "Test Harness",
-      description: "执行受限 npm 验证脚本，并显示真实退出码、耗时和有界输出摘要。",
-      icon: "✓",
-      read: () => ({
-        allowedScripts: [...allowedScripts],
-        latest: latest === undefined ? null : cloneRun(latest),
-        limits: { timeoutMs, outputBytes: maxOutputBytes },
-      }),
-    });
-    context.effect(() => disposePanel);
-  },
-};

package/packages/core/src/plugins/theme-studio.ts

@@ -1,170 +0,0 @@
-import type { Context } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
-
-const customType = "pi-harness/theme-studio";
-
-export type ThemeId = "light" | "midnight" | "paper" | "high-contrast";
-export type ThemePreset = { label: string; description: string; tokens: Readonly<Record<string, string>> };
-export type ThemeState = {
-  theme: ThemeId;
-  label: string;
-  description: string;
-  tokens: Readonly<Record<string, string>>;
-  changed: boolean;
-  changedAt: string | null;
-};
-
-export const themePresets: Readonly<Record<ThemeId, ThemePreset>> = {
-  light: {
-    label: "Light",
-    description: "默认浅色界面，适合长时间编码。",
-    tokens: {
-      "--color-ink": "#0f1115",
-      "--color-muted": "#65707b",
-      "--color-faint": "#8a949f",
-      "--color-line": "rgba(15,17,21,0.12)",
-      "--color-soft": "#f6f8fa",
-      "--color-blue": "#4176e6",
-      "--color-blue-soft": "#edf3fe",
-      "--color-green": "#22c55e",
-      "--color-red": "#ec1313",
-      "--color-amber": "#f59e0b",
-      "--color-empty": "#9aa0a6",
-      "--color-starter-border": "rgba(15,17,21,0.14)",
-    },
-  },
-  midnight: {
-    label: "Midnight",
-    description: "深色工作台，降低夜间屏幕亮度。",
-    tokens: {
-      "--color-ink": "#f8fafc",
-      "--color-muted": "#b7c2d1",
-      "--color-faint": "#8290a3",
-      "--color-line": "rgba(226,232,240,0.18)",
-      "--color-soft": "#111827",
-      "--color-blue": "#8ab4ff",
-      "--color-blue-soft": "#1e3a67",
-      "--color-green": "#58d68d",
-      "--color-red": "#ff8a8a",
-      "--color-amber": "#f6c56a",
-      "--color-empty": "#778399",
-      "--color-starter-border": "rgba(226,232,240,0.22)",
-    },
-  },
-  paper: {
-    label: "Paper",
-    description: "暖白纸张色调，适合阅读和文档整理。",
-    tokens: {
-      "--color-ink": "#332b24",
-      "--color-muted": "#76695d",
-      "--color-faint": "#a09589",
-      "--color-line": "rgba(82,63,45,0.16)",
-      "--color-soft": "#f5f0e8",
-      "--color-blue": "#876334",
-      "--color-blue-soft": "#eee2d0",
-      "--color-green": "#5f8b61",
-      "--color-red": "#b85b4f",
-      "--color-amber": "#b17b36",
-      "--color-empty": "#a59a8e",
-      "--color-starter-border": "rgba(82,63,45,0.18)",
-    },
-  },
-  "high-contrast": {
-    label: "High Contrast",
-    description: "更清晰的文本和边界，适合低视力场景。",
-    tokens: {
-      "--color-ink": "#000000",
-      "--color-muted": "#262626",
-      "--color-faint": "#4a4a4a",
-      "--color-line": "rgba(0,0,0,0.36)",
-      "--color-soft": "#eeeeee",
-      "--color-blue": "#0047b3",
-      "--color-blue-soft": "#dbeafe",
-      "--color-green": "#0b6b2d",
-      "--color-red": "#a40000",
-      "--color-amber": "#754c00",
-      "--color-empty": "#5c5c5c",
-      "--color-starter-border": "rgba(0,0,0,0.42)",
-    },
-  },
-};
-
-export interface ThemeStudioPluginConfig {
-  theme?: ThemeId;
-}
-
-export const Config: z<ThemeStudioPluginConfig> = z.object({
-  theme: z.union(["light", "midnight", "paper", "high-contrast"]).default("light"),
-});
-
-function isThemeId(value: unknown): value is ThemeId {
-  return typeof value === "string" && Object.hasOwn(themePresets, value);
-}
-
-function initialTheme(context: Context, fallback: ThemeId): ThemeId {
-  const entries = context.piSession.manager.getEntries();
-  const entry = [...entries].reverse().find((item) => item.type === "custom" && item.customType === customType);
-  if (entry?.type !== "custom" || entry.data === undefined || typeof entry.data !== "object" || entry.data === null) return fallback;
-  const selected = (entry.data as { theme?: unknown }).theme;
-  return isThemeId(selected) ? selected : fallback;
-}
-
-export default {
-  name: "pi-theme-studio",
-  inject: ["piSession", "piPluginUi", "piTools"],
-  Config,
-  apply(context: Context, config: ThemeStudioPluginConfig) {
-    let theme = initialTheme(context, config.theme ?? "light");
-    let changedAt: string | null = null;
-    const state = (): ThemeState => ({ ...themePresets[theme], theme, changed: changedAt !== null, changedAt });
-    const unregisterSet = context.piTools.register(
-      defineTool({
-        name: "theme_set",
-        label: "Set UI theme",
-        description: "Select one of the bounded Pi Harness theme presets and persist it in the current session.",
-        promptSnippet: "switch the Pi Harness UI theme",
-        parameters: Type.Object(
-          { theme: Type.Union([Type.Literal("light"), Type.Literal("midnight"), Type.Literal("paper"), Type.Literal("high-contrast")]) },
-          { additionalProperties: false },
-        ),
-        executionMode: "sequential",
-        execute(_toolCallId, params): Promise<AgentToolResult<ThemeState>> {
-          theme = params.theme;
-          changedAt = new Date().toISOString();
-          context.piSession.manager.appendCustomEntry(customType, { theme });
-          const details = state();
-          return Promise.resolve({ content: [{ type: "text", text: `Theme selected: ${details.label}` }], details });
-        },
-      }),
-    );
-    const unregisterStatus = context.piTools.register(
-      defineTool({
-        name: "theme_status",
-        label: "Theme status",
-        description: "Show the active theme preset and its UI color tokens.",
-        promptSnippet: "inspect the active Pi Harness theme",
-        parameters: Type.Object({}, { additionalProperties: false }),
-        executionMode: "sequential",
-        execute(): Promise<AgentToolResult<ThemeState>> {
-          const details = state();
-          return Promise.resolve({ content: [{ type: "text", text: `${details.label}: ${details.description}` }], details });
-        },
-      }),
-    );
-    const disposePanel = context.piPluginUi.register({
-      id: "theme-studio-panel",
-      pluginId: "@pi-harness/core/plugins/theme-studio",
-      title: "Theme Studio",
-      description: "切换可审计的界面主题预设，选择会保存到当前 session。",
-      icon: "◐",
-      read: () => ({ ...state(), presets: Object.entries(themePresets).map(([id, preset]) => ({ id, label: preset.label, description: preset.description })) }),
-    });
-    context.effect(() => () => {
-      unregisterSet();
-      unregisterStatus();
-      disposePanel();
-    });
-  },
-};