@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/src/plugins/reverse-skill.ts

@@ -42,11 +42,15 @@ export default {
         label: "Safe skill inject",
         description: "Inspect untrusted Skill text and return it only when safe, or explicitly approved for review-risk content.",
         promptSnippet: "safely inspect and inject an external skill into context",
-        parameters: Type.Object({
-          text: Type.String({ description: "Untrusted Skill text" }),
-          name: Type.String({ description: "Skill name" }),
-          allowReview: Type.Optional(Type.Boolean({ description: "Allow review-risk content after inspection" })),
-        }),
+        parameters: Type.Object(
+          {
+            text: Type.String({ description: "Untrusted Skill text" }),
+            name: Type.String({ description: "Skill name" }),
+            allowReview: Type.Optional(Type.Boolean({ description: "Allow review-risk content after inspection" })),
+          },
+          { additionalProperties: false },
+        ),
+        executionMode: "sequential",
         execute(_toolCallId, params): Promise<AgentToolResult<SkillInjection>> {
           return Promise.resolve().then(() => {
             const result = buildSkillInjection(params.text, params.name, params.allowReview === true || allowReviewByDefault);

package/packages/core/src/plugins/reviewer-bot.ts

@@ -7,6 +7,7 @@ import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agen
 
 const execFileAsync = promisify(execFile);
 const maxFiles = 512;
+const defaultTimeoutMs = 15_000;
 type ReviewFinding = { kind: "whitespace" | "secret" | "todo"; severity: "error" | "warning"; message: string; path?: string };
 type ReviewFile = { path: string; added: number; removed: number };
 type ReviewReport = {
@@ -20,8 +21,12 @@ type ReviewReport = {
 
 export interface ReviewerBotPluginConfig {
   maxDiffBytes?: number;
+  timeoutMs?: number;
 }
-export const Config: z<ReviewerBotPluginConfig> = z.object({ maxDiffBytes: z.number().default(1024 * 1024) });
+export const Config: z<ReviewerBotPluginConfig> = z.object({
+  maxDiffBytes: z.number().default(1024 * 1024),
+  timeoutMs: z.number().default(defaultTimeoutMs),
+});
 
 function outputOf(error: unknown, key: "stdout" | "stderr"): string {
   if (typeof error === "object" && error !== null && key in error) {
@@ -32,8 +37,8 @@ function outputOf(error: unknown, key: "stdout" | "stderr"): string {
   return "";
 }
 
-async function git(cwd: string, args: readonly string[], maxBuffer: number): Promise<string> {
-  const result = await execFileAsync("git", [...args], { cwd, maxBuffer });
+async function git(cwd: string, args: readonly string[], maxBuffer: number, timeoutMs: number): Promise<string> {
+  const result = await execFileAsync("git", [...args], { cwd, maxBuffer, timeout: timeoutMs });
   return result.stdout;
 }
 
@@ -43,6 +48,7 @@ export default {
   Config,
   apply(context: Context, config: ReviewerBotPluginConfig) {
     const maxDiffBytes = Math.max(16 * 1024, Math.min(8 * 1024 * 1024, Math.trunc(config.maxDiffBytes ?? 1024 * 1024)));
+    const timeoutMs = Math.max(100, Math.min(60_000, Math.trunc(config.timeoutMs ?? defaultTimeoutMs)));
     let latest: ReviewReport | undefined;
     const review = async (): Promise<ReviewReport> => {
       let diff: string;
@@ -50,12 +56,15 @@ export default {
       const findings: ReviewFinding[] = [];
       try {
         [diff, names] = await Promise.all([
-          git(context.piHarnessLaunch.cwd, ["diff", "HEAD", "--no-ext-diff", "--unified=0"], maxDiffBytes),
-          git(context.piHarnessLaunch.cwd, ["diff", "HEAD", "--name-only", "--no-ext-diff"], maxDiffBytes),
+          git(context.piHarnessLaunch.cwd, ["diff", "HEAD", "--no-ext-diff", "--unified=0"], maxDiffBytes, timeoutMs),
+          git(context.piHarnessLaunch.cwd, ["diff", "HEAD", "--name-only", "--no-ext-diff"], maxDiffBytes, timeoutMs),
         ]);
       } catch (error) {
+        const timedOut = typeof error === "object" && error !== null && "killed" in error && (error as { killed?: unknown }).killed === true;
         throw new Error(
-          `Git review requires a repository with a readable HEAD: ${outputOf(error, "stderr").trim() || (error instanceof Error ? error.message : String(error))}`,
+          timedOut
+            ? `Git review timed out after ${timeoutMs} ms`
+            : `Git review requires a repository with a readable HEAD: ${outputOf(error, "stderr").trim() || (error instanceof Error ? error.message : String(error))}`,
           { cause: error },
         );
       }
@@ -94,8 +103,10 @@ export default {
         }
       }
       try {
-        await git(context.piHarnessLaunch.cwd, ["diff", "HEAD", "--check"], maxDiffBytes);
+        await git(context.piHarnessLaunch.cwd, ["diff", "HEAD", "--check"], maxDiffBytes, timeoutMs);
       } catch (error) {
+        const timedOut = typeof error === "object" && error !== null && "killed" in error && (error as { killed?: unknown }).killed === true;
+        if (timedOut) throw new Error(`Git review timed out after ${timeoutMs} ms`, { cause: error });
         const output = `${outputOf(error, "stdout")}\n${outputOf(error, "stderr")}`.trim();
         findings.push({ kind: "whitespace", severity: "error", message: output || "git diff --check 检测到空白错误。" });
       }
@@ -115,7 +126,8 @@ export default {
         label: "Review changes",
         description: "Run a read-only Git diff review for whitespace, likely secrets, and TODO/FIXME findings.",
         promptSnippet: "review the current Git diff for release risks",
-        parameters: Type.Object({}),
+        parameters: Type.Object({}, { additionalProperties: false }),
+        executionMode: "sequential",
         async execute(): Promise<AgentToolResult<ReviewReport>> {
           latest = await review();
           return {
@@ -130,14 +142,20 @@ export default {
         },
       }),
     );
-    const disposePanel = context.piPluginUi.register({
-      id: "reviewer-bot-panel",
-      pluginId: "@pi-harness/core/plugins/reviewer-bot",
-      title: "Reviewer Bot",
-      description: "只读检查 Git 改动中的空白、凭据和遗留标记风险。",
-      icon: "✓",
-      read: () => ({ latest: latest ?? null, maxDiffBytes }),
-    });
+    let disposePanel: () => void;
+    try {
+      disposePanel = context.piPluginUi.register({
+        id: "reviewer-bot-panel",
+        pluginId: "@pi-harness/core/plugins/reviewer-bot",
+        title: "Reviewer Bot",
+        description: "只读检查 Git 改动中的空白、凭据和遗留标记风险。",
+        icon: "✓",
+        read: () => ({ latest: latest ?? null, maxDiffBytes, timeoutMs }),
+      });
+    } catch (error) {
+      unregisterTool();
+      throw error;
+    }
     context.effect(() => () => {
       unregisterTool();
       disposePanel();

package/packages/core/src/plugins/runtime-doctor.ts

@@ -2,6 +2,7 @@ import { stat } from "node:fs/promises";
 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 { EmptyConfig } from "../config.js";
 
 export type RuntimeDoctorCheckStatus = "ok" | "warning" | "error";
 export interface RuntimeDoctorCheck {
@@ -82,6 +83,7 @@ async function pathExists(path: string): Promise<boolean> {
 export default {
   name: "pi-runtime-doctor",
   inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
+  Config: EmptyConfig,
   apply(context: Context) {
     let extensionErrors = 0;
     const inspect = async (): Promise<RuntimeDoctorReport> => {
@@ -110,7 +112,8 @@ export default {
         label: "Runtime doctor",
         description: "Audit workspace, agent directory, model, runtime, MCP servers, and extension errors in one read-only report.",
         promptSnippet: "diagnose whether the Pi Harness runtime is ready",
-        parameters: Type.Object({}),
+        parameters: Type.Object({}, { additionalProperties: false }),
+        executionMode: "sequential",
         async execute(): Promise<AgentToolResult<RuntimeDoctorReport>> {
           const report = await inspect();
           return {

package/packages/core/src/plugins/runtime.ts

@@ -5,6 +5,7 @@ import {
   createAgentSessionRuntime,
   type AgentSession,
   type CreateAgentSessionRuntimeFactory,
+  type ExtensionError,
   type SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { PiRuntime } from "../runtime.js";
@@ -23,6 +24,20 @@ export const Config: z<RuntimePluginConfig> = z.object({
 // streaming, interleaving both runs into one JSONL transcript. Each manager therefore has at most
 // one runtime under construction or teardown at a time.
 const sessionManagerGate = new WeakMap<SessionManager, Promise<void>>();
+const maxForwardedErrorLength = 2_000;
+
+function boundedListenerError(error: unknown): string {
+  if (typeof error === "string") return error.slice(0, maxForwardedErrorLength);
+  if (error !== null && typeof error === "object") {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(error, "message");
+      if (descriptor !== undefined && "value" in descriptor && typeof descriptor.value === "string") return descriptor.value.slice(0, maxForwardedErrorLength);
+    } catch {
+      // Proxy descriptor traps are untrusted too.
+    }
+  }
+  return "Unknown pi/session-event listener error";
+}
 
 function enterSessionManagerGate(manager: SessionManager): { ready: Promise<void>; release: () => void } {
   const ready = sessionManagerGate.get(manager) ?? Promise.resolve();
@@ -48,80 +63,91 @@ export default {
     assertKnownConfigKeys("pi-runtime", config, ["thinkingLevel"]);
     const gate = enterSessionManagerGate(context.piSession.manager);
     await gate.ready;
-    const tools = context.piTools.acquire();
-    context.effect(() => () => tools.release());
-    const requestedTools = [...tools.names, ...tools.customTools.map((tool) => tool.name)];
-    const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
-      const services = cwd === context.piResources.cwd ? context.piResources : await context.piResources.createForCwd(cwd);
-      const result = await createAgentSessionFromServices({
-        services,
-        sessionManager,
-        ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
-        model: context.piModels.model,
-        thinkingLevel: config.thinkingLevel ?? "medium",
-        tools: requestedTools,
-        customTools: tools.customTools,
-      });
-      if (result.extensionsResult.errors.length > 0) {
-        result.session.dispose();
-        throw new Error(`Pi extensions failed to load:\n${result.extensionsResult.errors.map((failure) => `${failure.path}: ${failure.error}`).join("\n")}`);
+    const emitExtensionError = (error: ExtensionError): void => {
+      try {
+        context.emit("pi/extension-error", error);
+      } catch {
+        // Error observers are diagnostic only and must never interrupt runtime lifecycle work.
       }
-      return { ...result, services, diagnostics: services.diagnostics };
     };
-    const sessionRuntime = await createAgentSessionRuntime(createRuntime, {
-      cwd: context.piResources.cwd,
-      agentDir: context.piResources.agentDir,
-      sessionManager: context.piSession.manager,
-    });
-    const runtime = new PiRuntime(sessionRuntime);
-    const bindSession = async (session: AgentSession): Promise<void> => {
-      await session.bindExtensions({
-        mode: "print",
-        abortHandler: () => {
-          void runtime.abort();
-        },
-        onError: (error) => {
-          context.emit("pi/extension-error", error);
-        },
-      });
-      // Reconciled after binding so a tool an extension registers from session_start is visible here.
-      const registeredTools = session.getAllTools().map((tool) => tool.name);
-      const missingTools = requestedTools.filter((name) => !registeredTools.includes(name));
-      if (missingTools.length > 0) throw new Error(`Pi tools are not registered: ${missingTools.join(", ")}`);
-      // Pi treats the tool list as an allowlist, so anything an extension contributed but the
-      // profile did not name is dropped. Report it rather than letting the tool vanish silently.
-      const activeTools = new Set(session.getActiveToolNames());
-      const droppedTools = registeredTools.filter((name) => !activeTools.has(name));
-      if (droppedTools.length > 0)
-        context.emit("pi/extension-error", {
-          extensionPath: "pi-tools",
-          event: "session_start",
-          error: `Pi tools registered by extensions are not enabled because the profile does not list them: ${droppedTools.join(", ")}; add them to the pi-tools names option to enable them`,
+    let runtime: PiRuntime | undefined;
+    let releaseTools: (() => void) | undefined;
+    try {
+      const tools = context.piTools.acquire();
+      releaseTools = () => tools.release();
+      context.effect(() => () => tools.release());
+      const requestedTools = [...tools.names, ...tools.customTools.map((tool) => tool.name)];
+      const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
+        const services = cwd === context.piResources.cwd ? context.piResources : await context.piResources.createForCwd(cwd);
+        const result = await createAgentSessionFromServices({
+          services,
+          sessionManager,
+          ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
+          model: context.piModels.model,
+          thinkingLevel: config.thinkingLevel ?? "medium",
+          tools: requestedTools,
+          customTools: tools.customTools,
         });
-    };
-    let unsubscribe: (() => void) | undefined;
-    const rebindSession = async (session: AgentSession): Promise<void> => {
-      unsubscribe?.();
-      await bindSession(session);
-      unsubscribe = session.subscribe((event) => {
-        // A throwing listener must not unwind back into Pi's event dispatch and kill the run.
-        try {
-          context.emit("pi/session-event", event);
-        } catch (error) {
-          context.emit("pi/extension-error", {
-            extensionPath: "pi/session-event",
-            event: event.type,
-            error: error instanceof Error ? error.message : String(error),
-          });
+        if (result.extensionsResult.errors.length > 0) {
+          result.session.dispose();
+          throw new Error(`Pi extensions failed to load:\n${result.extensionsResult.errors.map((failure) => `${failure.path}: ${failure.error}`).join("\n")}`);
         }
+        return { ...result, services, diagnostics: services.diagnostics };
+      };
+      const sessionRuntime = await createAgentSessionRuntime(createRuntime, {
+        cwd: context.piResources.cwd,
+        agentDir: context.piResources.agentDir,
+        sessionManager: context.piSession.manager,
       });
-    };
-    try {
+      const createdRuntime = new PiRuntime(sessionRuntime);
+      runtime = createdRuntime;
+      const bindSession = async (session: AgentSession): Promise<void> => {
+        await session.bindExtensions({
+          mode: "print",
+          abortHandler: () => {
+            void createdRuntime.abort();
+          },
+          onError: (error) => {
+            emitExtensionError(error);
+          },
+        });
+        // Reconciled after binding so a tool an extension registers from session_start is visible here.
+        const registeredTools = session.getAllTools().map((tool) => tool.name);
+        const missingTools = requestedTools.filter((name) => !registeredTools.includes(name));
+        if (missingTools.length > 0) throw new Error(`Pi tools are not registered: ${missingTools.join(", ")}`);
+        // Pi treats the tool list as an allowlist, so anything an extension contributed but the
+        // profile did not name is dropped. Report it rather than letting the tool vanish silently.
+        const activeTools = new Set(session.getActiveToolNames());
+        const droppedTools = registeredTools.filter((name) => !activeTools.has(name));
+        if (droppedTools.length > 0)
+          emitExtensionError({
+            extensionPath: "pi-tools",
+            event: "session_start",
+            error: `Pi tools registered by extensions are not enabled because the profile does not list them: ${droppedTools.join(", ")}; add them to the pi-tools names option to enable them`,
+          });
+      };
+      let unsubscribe: (() => void) | undefined;
+      const rebindSession = async (session: AgentSession): Promise<void> => {
+        unsubscribe?.();
+        await bindSession(session);
+        unsubscribe = session.subscribe((event) => {
+          // A throwing listener must not unwind back into Pi's event dispatch and kill the run.
+          try {
+            context.emit("pi/session-event", event);
+          } catch (error) {
+            emitExtensionError({
+              extensionPath: "pi/session-event",
+              event: event.type,
+              error: boundedListenerError(error),
+            });
+          }
+        });
+      };
       context.effect(() => {
         return async () => {
           unsubscribe?.();
           try {
-            await runtime.dispose();
+            await createdRuntime.dispose();
           } finally {
             // Released only once teardown has finished, so a replacement fiber cannot build a
             // second session over this SessionManager while this one is still writing to it.
@@ -129,12 +155,16 @@ export default {
           }
         };
       });
-      context.provide("piRuntime", runtime);
+      context.provide("piRuntime", createdRuntime);
       sessionRuntime.setRebindSession(rebindSession);
       await rebindSession(sessionRuntime.session);
     } catch (error) {
-      await runtime.dispose();
-      gate.release();
+      try {
+        if (runtime !== undefined) await runtime.dispose();
+      } finally {
+        releaseTools?.();
+        gate.release();
+      }
       throw error;
     }
   },

package/packages/core/src/plugins/secure-audit.ts

@@ -1,12 +1,16 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 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 { readBoundedFile } from "../bounded-file.js";
 import { resolveExistingWorkspacePath } from "../workspace-path.js";
+import { EmptyConfig } from "../config.js";
 
 const maxFiles = 500;
 const maxFileBytes = 512 * 1024;
+const maxDirectories = 512;
+const maxDepth = 16;
 const ignoredDirectories = new Set([".git", ".pi", "node_modules", "dist", "build", "coverage"]);
 
 export type AuditSeverity = "critical" | "high" | "medium";
@@ -63,16 +67,20 @@ export function summarizeAudit(findings: readonly AuditFinding[], root = ".", sc
   return { root, scanned, skipped, total: findings.length, critical, high, medium, changed: findings.length > 0, findings: [...findings] };
 }
 
-async function workspaceFiles(root: string, current: string, files: string[]): Promise<void> {
-  if (files.length >= maxFiles) return;
+type WalkState = { files: string[]; directories: number };
+
+async function workspaceFiles(root: string, current: string, state: WalkState, depth = 0): Promise<void> {
+  if (state.files.length >= maxFiles || state.directories >= maxDirectories || depth > maxDepth) return;
+  state.directories += 1;
+  if (depth >= maxDepth) return;
   const entries = await readdir(current, { withFileTypes: true });
   for (const entry of entries) {
-    if (files.length >= maxFiles) return;
+    if (state.files.length >= maxFiles || state.directories >= maxDirectories) return;
     const fullPath = join(current, entry.name);
     if (entry.isDirectory()) {
-      if (!ignoredDirectories.has(entry.name)) await workspaceFiles(root, fullPath, files);
+      if (!ignoredDirectories.has(entry.name)) await workspaceFiles(root, fullPath, state, depth + 1);
     } else if (entry.isFile()) {
-      files.push(relative(root, fullPath));
+      state.files.push(relative(root, fullPath));
     }
   }
 }
@@ -82,10 +90,11 @@ export async function auditWorkspace(root: string, requested = "."): Promise<Aud
   root = resolved.root;
   const target = resolved.target;
   const metadata = await stat(target);
-  const files: string[] = [];
-  if (metadata.isFile()) files.push(relative(root, target));
-  else if (metadata.isDirectory()) await workspaceFiles(root, target, files);
+  const state: WalkState = { files: [], directories: 0 };
+  if (metadata.isFile()) state.files.push(relative(root, target));
+  else if (metadata.isDirectory()) await workspaceFiles(root, target, state);
   else throw new Error("Audit target must be a file or directory");
+  const files = state.files;
   const findings: AuditFinding[] = [];
   let skipped = 0;
   for (const file of files) {
@@ -95,8 +104,15 @@ export async function auditWorkspace(root: string, requested = "."): Promise<Aud
       skipped += 1;
       continue;
     }
-    const source = await readFile(fullPath, "utf8");
-    if (source.includes("\u0000")) {
+    let source: string;
+    try {
+      const bytes = await readBoundedFile(fullPath, maxFileBytes, "Audit file");
+      if (bytes.includes(0)) {
+        skipped += 1;
+        continue;
+      }
+      source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
       skipped += 1;
       continue;
     }
@@ -112,6 +128,7 @@ function emptySummary(): AuditSummary {
 export default {
   name: "pi-secure-audit",
   inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
+  Config: EmptyConfig,
   apply(context: Context) {
     let latest: AuditSummary | undefined;
     const unregister = context.piTools.register(
@@ -120,7 +137,11 @@ export default {
         label: "Security audit",
         description: "Read-only scan of workspace text files for exposed credentials and dangerous shell commands; findings are value-redacted.",
         promptSnippet: "audit the workspace for secrets and dangerous commands",
-        parameters: Type.Object({ path: Type.Optional(Type.String({ description: "Workspace-relative file or directory to scan" })) }),
+        parameters: Type.Object(
+          { path: Type.Optional(Type.String({ description: "Workspace-relative file or directory to scan" })) },
+          { additionalProperties: false },
+        ),
+        executionMode: "sequential",
         async execute(_toolCallId, params): Promise<AgentToolResult<AuditSummary>> {
           latest = await auditWorkspace(context.piHarnessLaunch.cwd, params.path ?? ".");
           return {

package/packages/core/src/plugins/session-bookmarks.ts

@@ -1,6 +1,7 @@
 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 { EmptyConfig } from "../config.js";
 
 const maxLabelLength = 120;
 
@@ -30,6 +31,7 @@ export function listSessionBookmarks(entries: readonly unknown[]): SessionBookma
 export default {
   name: "pi-session-bookmarks",
   inject: ["piSession", "piPluginUi", "piTools"],
+  Config: EmptyConfig,
   apply(context: Context) {
     const manager = context.piSession.manager;
     const readBookmarks = (): SessionBookmark[] => listSessionBookmarks(manager.getEntries());
@@ -39,12 +41,16 @@ export default {
         label: "Session bookmarks",
         description: "Add, list, or remove labels on entries in the current Pi session using native session history.",
         promptSnippet: "bookmark an important point in the current session",
-        parameters: Type.Object({
-          action: Type.Union([Type.Literal("add"), Type.Literal("list"), Type.Literal("remove")]),
-          label: Type.Optional(Type.String({ description: "Bookmark label for add" })),
-          entryId: Type.Optional(Type.String({ description: "Native session entry id for add" })),
-          bookmarkId: Type.Optional(Type.String({ description: "Bookmark id for remove" })),
-        }),
+        parameters: Type.Object(
+          {
+            action: Type.Union([Type.Literal("add"), Type.Literal("list"), Type.Literal("remove")]),
+            label: Type.Optional(Type.String({ description: "Bookmark label for add" })),
+            entryId: Type.Optional(Type.String({ description: "Native session entry id for add" })),
+            bookmarkId: Type.Optional(Type.String({ description: "Bookmark id for remove" })),
+          },
+          { additionalProperties: false },
+        ),
+        executionMode: "sequential",
         execute(_toolCallId, params): Promise<AgentToolResult<{ bookmarks: SessionBookmark[] }>> {
           return Promise.resolve().then(() => {
             if (params.action === "add") {