pi-harness-runtime 1.1.458 → 1.1.460

package/harness/honcho-memory.ts

@@ -13,16 +13,14 @@
 
 import { logServiceEvent, honchoStatus } from "./service-diagnostics.js";
 import { honchoPayload, honchoToolCall } from "./honcho-init.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
 // ---------------------------------------------------------------------------
-// Honcho MCP Configuration (non-destructive)
+// Honcho credential
 // ---------------------------------------------------------------------------
 
-const MCP_CONFIG_DIR = join(homedir(), ".config", "mcp");
-const MCP_CONFIG_FILE = join(MCP_CONFIG_DIR, "mcp.json");
 const HONCHO_KEY_FILE = join(homedir(), ".pi-harness-runtime", "keys", "honcho-api-key.txt");
 
 /**
@@ -78,20 +76,30 @@ function redactSecrets(text: string): string {
 }
 
 /**
- * Ensure MCP config directory exists (non-destructive).
- * Does NOT write config at import time.
- */
-export function ensureMcpConfigDirectory(): void {
-	if (!existsSync(MCP_CONFIG_DIR)) {
-		mkdirSync(MCP_CONFIG_DIR, { recursive: true, mode: 0o755 });
-	}
-}
-
-/**
- * Load Honcho API key from keys directory.
+ * Load the Honcho API key.
+ *
+ * The environment variable wins over the key file: it is the explicit
+ * override of a session. The key file is the per-user default.
  * Does NOT write config files.
+ *
+ * This is deliberately not `key-loader.loadKey`: that one resolves the key
+ * through the Infisical provider, and the Honcho startup must stay a local
+ * read (no secret manager, no network in the startup path). The environment
+ * it reads is already filled by the key loader when another runtime filled
+ * it.
  */
 export function loadHonchoApiKey(): string | undefined {
+	// `process` does not exist in every context (a sandboxed module), so
+	// the environment is read defensively.
+	const fromEnv =
+		typeof process !== "undefined" && process.env
+			? process.env.HONCHO_API_KEY
+			: undefined;
+	const envKey = typeof fromEnv === "string" ? fromEnv.trim() : "";
+	if (envKey !== "") {
+		return envKey;
+	}
+
 	if (existsSync(HONCHO_KEY_FILE)) {
 		try {
 			return readFileSync(HONCHO_KEY_FILE, "utf8").trim() || undefined;
@@ -102,58 +110,6 @@ export function loadHonchoApiKey(): string | undefined {
 	return undefined;
 }
 
-/**
- * Read existing MCP config (non-destructive).
- * Returns null if config doesn't exist or is invalid.
- */
-export function readMcpConfig(): Record<string, unknown> | null {
-	if (!existsSync(MCP_CONFIG_FILE)) {
-		return null;
-	}
-	try {
-		const content = readFileSync(MCP_CONFIG_FILE, "utf8");
-		return JSON.parse(content);
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Write MCP config atomically (non-destructive).
- * Only updates the Honcho server entry, preserves other entries.
- */
-export function writeHonchoMcpConfig(apiKey: string): void {
-	ensureMcpConfigDirectory();
-
-	// Read existing config or create new one
-	let config: Record<string, unknown> = readMcpConfig() || { mcpServers: {} };
-	if (!config.mcpServers || typeof config.mcpServers !== "object") {
-		config = { mcpServers: {} };
-	}
-
-	// Update Honcho entry
-	const mcpServers = config.mcpServers as Record<string, unknown>;
-	mcpServers.honcho = {
-		url: "https://mcp.honcho.dev",
-		headers: {
-			Authorization: `Bearer ${apiKey}`,
-		},
-	};
-
-	// Atomic write with temp file
-	const tempFile = `${MCP_CONFIG_FILE}.tmp`;
-	writeFileSync(tempFile, JSON.stringify(config, null, 2), { mode: 0o644 });
-	try {
-		// Verify the temp file is valid JSON before renaming
-		JSON.parse(readFileSync(tempFile, "utf8"));
-		renameSync(tempFile, MCP_CONFIG_FILE);
-	} catch {
-		// Clean up invalid temp file
-		try { unlinkSync(tempFile); } catch { /* ignore */ }
-		throw new Error("Failed to write valid MCP config");
-	}
-}
-
 // ---------------------------------------------------------------------------
 // Honcho Health Check - Detect suspended accounts
 // ---------------------------------------------------------------------------
@@ -274,7 +230,13 @@ export function stopHonchoHealthCheck(): void {
  * Honcho memory configuration
  */
 export interface HonchoMemoryConfig {
-  /** Honcho API key */
+  /**
+   * Honcho API key.
+   *
+   * Accepted, but the class does not read it: the calls go through the
+   * native MCP client of honcho-init, which owns the credential of the
+   * session. The field stays for the callers that still pass it.
+   */
   apiKey: string;
   /** Workspace ID for memory storage */
   workspaceId?: string;
@@ -475,7 +437,7 @@ export class HonchoMemory {
   }
 
   /**
-   * Call a Honcho MCP tool through the adapter.
+   * Call a Honcho MCP tool through the native MCP client.
    * Uses the honchoToolCall from honcho-init.ts.
    */
   private async callHonchoTool(

package/harness/key-file-audit.ts

@@ -15,7 +15,13 @@
  * state of a file (missing / empty).
  */
 
-import { existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
+import {
+	chmodSync,
+	existsSync,
+	lstatSync,
+	readFileSync,
+	readdirSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -390,6 +396,78 @@ export interface KeyFileAuditResult {
 	exposedDirectories: ExposedKeyDirectory[];
 }
 
+export interface SecureKeyTreeResult {
+	/** False on platforms where chmod does not express the required ACL. */
+	supported: boolean;
+	securedFiles: number;
+	securedDirectories: number;
+	failedPaths: string[];
+}
+
+/**
+ * Restrict the key tree to its owner on Unix-like systems.
+ *
+ * This runs only on the dedicated application key directory. It never
+ * follows symlinks, and records per-path failures so startup can retain a
+ * warning when the current user cannot repair an entry (for example, when
+ * it is owned by another account).
+ */
+export function secureKeyTree(
+	keysDir: string,
+	platform: NodeJS.Platform = process.platform,
+): SecureKeyTreeResult {
+	const result: SecureKeyTreeResult = {
+		supported: platform !== "win32",
+		securedFiles: 0,
+		securedDirectories: 0,
+		failedPaths: [],
+	};
+	if (!result.supported) return result;
+
+	const root = defaultStat(keysDir);
+	if (!root?.isDirectory || root.isSymbolicLink) {
+		result.failedPaths.push(keysDir);
+		return result;
+	}
+
+	const secureDirectory = (path: string): boolean => {
+		try {
+			chmodSync(path, 0o700);
+			result.securedDirectories++;
+			return true;
+		} catch {
+			result.failedPaths.push(path);
+			return false;
+		}
+	};
+
+	const secureFile = (path: string): void => {
+		try {
+			chmodSync(path, 0o600);
+			result.securedFiles++;
+		} catch {
+			result.failedPaths.push(path);
+		}
+	};
+
+	const walk = (dir: string, depth: number): void => {
+		if (depth > MAX_KEY_TREE_DEPTH) return;
+		for (const name of defaultReaddir(dir).sort(compareByName)) {
+			const path = join(dir, name);
+			const info = defaultStat(path);
+			if (!info || info.isSymbolicLink) continue;
+			if (info.isDirectory) {
+				if (secureDirectory(path)) walk(path, depth + 1);
+			} else if (info.isFile) {
+				secureFile(path);
+			}
+		}
+	};
+
+	if (secureDirectory(keysDir)) walk(keysDir, 1);
+	return result;
+}
+
 /**
  * Compare two file names in a stable, locale independent order.
  */

package/harness/pending-countdown.ts

@@ -0,0 +1,348 @@
+/**
+ * The live countdown of a pending question.
+ *
+ * The harness asks a human a question and waits. The wait has a deadline,
+ * and the countdown shows the remaining time in the status row of the TUI
+ * and starts the decision of the judge exactly at that deadline.
+ *
+ * The module owns the two policies of the wait:
+ *
+ * - the first countdown counts down to the deadline of the decision, which
+ *   is derived from the moment the wait started,
+ * - the recheck counts down to the next attempt, after the judge asked to
+ *   wait longer.
+ *
+ * The caller cannot pass a deadline of its own: the displayed deadline and
+ * the deadline the judge uses therefore cannot drift apart.
+ *
+ * The countdown is bound to one request. Every start replaces the previous
+ * binding and every stop releases the timer, so there is never more than
+ * one countdown and never a timer without a request.
+ */
+
+/** What the countdown counts to. */
+export type CountdownMode = "initial" | "recheck";
+
+/** The state of the countdown that is drawn in the status row. */
+export interface CountdownView {
+	/** The request the countdown belongs to. */
+	requestId: string;
+	/** The milliseconds that are left. Never negative. */
+	remainingMs: number;
+	/** The remaining time as "MM:SS". */
+	remaining: string;
+	/** What the countdown counts to. */
+	mode: CountdownMode;
+}
+
+/** The dependencies of a countdown. */
+export interface PendingCountdownDeps {
+	/** Draw the countdown in the status row. */
+	render: (view: CountdownView) => void;
+	/** The deadline was reached and the decision is due. */
+	onDeadline: (requestId: string) => void;
+	/**
+	 * Is the request still the pending one?
+	 *
+	 * A tick of a question that was answered or replaced in the meantime
+	 * must not redraw its status and must not trigger a decision.
+	 */
+	isPending: (requestId: string) => boolean;
+	/** A failing callback of the countdown is reported here. */
+	onError?: (error: unknown) => void;
+	/** The wait is over: the status row is cleared. */
+	onStop?: (requestId: string | null) => void;
+	/** The minutes the judge waits for a human answer. */
+	waitMinutes: number;
+	/** The milliseconds until the next attempt after the judge asked to wait. */
+	recheckIntervalMs: number;
+	/** The clock (the tests drive it). */
+	now?: () => number;
+	/** The timer that drives the ticks (the tests drive it). */
+	setInterval?: (callback: () => void, ms: number) => unknown;
+	/** The timer that stops the ticks (the tests drive it). */
+	clearInterval?: (handle: unknown) => void;
+	/** The tick interval in milliseconds. */
+	tickMs?: number;
+}
+
+/** The milliseconds between two ticks of the display. */
+const COUNTDOWN_TICK_MS = 1_000;
+
+/**
+ * The smallest tick interval.
+ *
+ * A shorter interval would repaint the status row faster than a reader can
+ * follow it and would waste the event loop of the harness.
+ */
+const MIN_TICK_MS = 100;
+
+/**
+ * The deadline of the decision.
+ *
+ * The deadline is derived from the moment the wait started, so the
+ * countdown and the judge share one timestamp.
+ */
+export function decisionDeadlineAt(startedAt: number, waitMinutes: number): number {
+	const minutes = Number.isFinite(waitMinutes) ? Math.max(0, waitMinutes) : 0;
+	const started = Number.isFinite(startedAt) ? startedAt : 0;
+	return started + minutes * 60_000;
+}
+
+/**
+ * The remaining time as "MM:SS".
+ *
+ * A time that is not a number is shown as an empty countdown: a status row
+ * must never claim a time that does not exist.
+ */
+export function formatRemainingTime(remainingMs: number): string {
+	const safeMs = Number.isFinite(remainingMs) ? Math.max(0, remainingMs) : 0;
+	const totalSeconds = Math.floor(safeMs / 1_000);
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+
+/** The binding of a running countdown. */
+interface CountdownBinding {
+	requestId: string;
+	deadlineAt: number;
+	mode: CountdownMode;
+}
+
+/**
+ * The countdown of one pending question.
+ *
+ * The countdown renders at once: the status row must show the remaining
+ * time without waiting for the first tick.
+ */
+export class PendingQuestionCountdown {
+	private readonly deps: PendingCountdownDeps;
+	private readonly now: () => number;
+	private readonly startTimer: (callback: () => void, ms: number) => unknown;
+	private readonly stopTimer: (handle: unknown) => void;
+	private readonly tickMs: number;
+	private handle: unknown = null;
+	private binding: CountdownBinding | null = null;
+	/**
+	 * Bumped on every start and every stop.
+	 *
+	 * A tick of an older generation belongs to a binding that is gone: it is
+	 * ignored instead of redrawing a status or triggering a decision.
+	 */
+	private generation = 0;
+	/**
+	 * True while the countdown owns the wait.
+	 *
+	 * The countdown stays engaged after its deadline fired, until the
+	 * decision path stops it or replaces it. The fallback poll uses this to
+	 * stay out of the way of the accurate timer.
+	 */
+	private engaged = false;
+	/**
+	 * True when the deadline fired and the decision did not start yet.
+	 *
+	 * The countdown owns the wait in that state, but it has no timer: the
+	 * caller arms it again when the decision did not start.
+	 */
+	private deadlineFired = false;
+
+	constructor(deps: PendingCountdownDeps) {
+		this.deps = deps;
+		this.now = deps.now ?? (() => Date.now());
+		this.startTimer =
+			deps.setInterval ??
+			((callback, ms) => setInterval(callback, ms) as unknown);
+		this.stopTimer =
+			deps.clearInterval ??
+			((handle) => clearInterval(handle as NodeJS.Timeout));
+		this.tickMs = Math.max(MIN_TICK_MS, deps.tickMs ?? COUNTDOWN_TICK_MS);
+	}
+
+	/** Does the countdown own the current wait? */
+	get active(): boolean {
+		return this.engaged;
+	}
+
+	/** Did the deadline fire and is the decision still due? */
+	get fired(): boolean {
+		return this.deadlineFired;
+	}
+
+	/** The request the countdown belongs to. */
+	get requestId(): string | null {
+		return this.binding?.requestId ?? null;
+	}
+
+	/** What the countdown counts to. */
+	get mode(): CountdownMode | null {
+		return this.binding?.mode ?? null;
+	}
+
+	/**
+	 * Start the countdown of a request, or replace the running one.
+	 *
+	 * The deadline of the decision is derived from the moment the wait
+	 * started: the caller passes that timestamp, the countdown computes the
+	 * deadline. The countdown and the judge therefore share one timestamp.
+	 */
+	start(requestId: string, startedAt: number): void {
+		this.begin(requestId, decisionDeadlineAt(startedAt, this.deps.waitMinutes), "initial");
+	}
+
+	/**
+	 * Start the countdown of the next attempt.
+	 *
+	 * The judge asked to wait longer: the countdown counts down to the next
+	 * attempt instead of to the deadline of the decision.
+	 */
+	startRecheck(requestId: string): void {
+		this.begin(requestId, this.now() + this.deps.recheckIntervalMs, "recheck");
+	}
+
+	/**
+	 * Stop the countdown and release its timer.
+	 *
+	 * Stopping is idempotent: a countdown that is not running can be stopped
+	 * as often as the cleanup paths need. The status row is cleared with it,
+	 * so a dead countdown never leaves a row that claims a decision is due.
+	 */
+	stop(): void {
+		const requestId = this.binding?.requestId ?? null;
+		this.engaged = false;
+		this.deadlineFired = false;
+		this.generation += 1;
+		this.clearTimer();
+		this.binding = null;
+		this.safeCall(() => this.deps.onStop?.(requestId));
+	}
+
+	/** Bind the countdown to a request and start its timer. */
+	private begin(requestId: string, deadlineAt: number, mode: CountdownMode): void {
+		this.clearTimer();
+		this.generation += 1;
+		const generation = this.generation;
+		this.binding = { requestId, deadlineAt, mode };
+		this.engaged = true;
+		this.deadlineFired = false;
+		try {
+			this.handle = this.startTimer(() => this.tick(generation), this.tickMs);
+		} catch (error) {
+			// The timer could not be created: the countdown owns nothing, so
+			// it must not claim the wait. The row of the countdown is
+			// cleared with it, so no row claims a decision that is not due.
+			this.engaged = false;
+			this.binding = null;
+			this.safeCall(() => this.deps.onStop?.(requestId));
+			this.report(error);
+			return;
+		}
+		this.tick(generation);
+	}
+
+	/**
+	 * One tick of the countdown.
+	 *
+	 * The tick is a no-op when it belongs to a binding that is gone, or
+	 * when the request it counts for is no longer the pending one.
+	 */
+	private tick(generation: number): void {
+		if (!this.engaged || generation !== this.generation) return;
+		const binding = this.binding;
+		if (!binding) return;
+
+		let remainingMs: number;
+		try {
+			if (!this.deps.isPending(binding.requestId)) {
+				// The question was answered or replaced: the countdown of
+				// that question is over.
+				this.stop();
+				return;
+			}
+			// The callback may have stopped the countdown: the binding of
+			// this tick is gone and must not be drawn any more.
+			if (!this.engaged || generation !== this.generation) return;
+			remainingMs = Math.max(0, binding.deadlineAt - this.now());
+		} catch (error) {
+			// A failing callback must never escape the timer: the countdown
+			// stops and the failure is reported.
+			this.stop();
+			this.report(error);
+			return;
+		}
+
+		if (remainingMs <= 0) {
+			// The deadline is reached. The timer stops, the countdown stays
+			// engaged until the decision path stops it or replaces it, so
+			// the fallback poll does not start a second decision.
+			this.clearTimer();
+			this.deadlineFired = true;
+			// The countdown reaches its zero before the decision starts.
+			this.safeRender({
+				requestId: binding.requestId,
+				remainingMs: 0,
+				remaining: formatRemainingTime(0),
+				mode: binding.mode,
+			});
+			// A failing decision handler must not leave a countdown that owns
+			// the wait without a timer: the countdown stops, so the fallback
+			// poll can take over.
+			try {
+				this.deps.onDeadline(binding.requestId);
+			} catch (error) {
+				this.stop();
+				this.report(error);
+			}
+			return;
+		}
+
+		this.safeRender({
+			requestId: binding.requestId,
+			remainingMs,
+			remaining: formatRemainingTime(remainingMs),
+			mode: binding.mode,
+		});
+	}
+
+	/** Draw the countdown, and report a failing status row. */
+	private safeRender(view: CountdownView): void {
+		try {
+			this.deps.render(view);
+		} catch (error) {
+			this.stop();
+			this.report(error);
+		}
+	}
+
+	/** Run a callback of the countdown without letting it escape. */
+	private safeCall(action: () => void): void {
+		try {
+			action();
+		} catch (error) {
+			this.report(error);
+		}
+	}
+
+	/** Report a failure without letting the report escape. */
+	private report(error: unknown): void {
+		try {
+			this.deps.onError?.(error);
+		} catch {
+			// The report of a failure must not become a new failure.
+		}
+	}
+
+	/** Release the timer of the countdown. */
+	private clearTimer(): void {
+		if (this.handle === null) return;
+		const handle = this.handle;
+		this.handle = null;
+		try {
+			this.stopTimer(handle);
+		} catch (error) {
+			// The timer is already released from the point of view of the
+			// countdown: the failure is reported, nothing is left behind.
+			this.report(error);
+		}
+	}
+}

package/harness/service-commands.ts

@@ -101,7 +101,7 @@ async function handleTestJev(ctx: ExtensionContext, flags: Record<string, string
 
 /**
  * Handle /harness-services test honcho --read-only
- * Checks Honcho integration status through the MCP adapter.
+ * Checks the Honcho integration status.
  * Does NOT create sessions/peers, write messages, or claim success when only flags were inspected.
  */
 async function handleTestHoncho(ctx: ExtensionContext, flags: Record<string, string | boolean>): Promise<void> {
@@ -113,33 +113,65 @@ async function handleTestHoncho(ctx: ExtensionContext, flags: Record<string, str
   ctx.ui.notify("[services] Testing Honcho MCP connection...", "info");
 
   try {
-    // Report actual registration status from the status tracker
+    // Report actual status from the status tracker
     ctx.ui.notify(`[services] Honcho configured: ${honchoStatus.configured}`, "info");
     ctx.ui.notify(`[services] Honcho connected: ${honchoStatus.connected}`, "info");
     ctx.ui.notify(`[services] Honcho feature enabled: ${honchoStatus.featureEnabled}`, "info");
 
-    // Check if MCP adapter is available via globalThis
-    // SAFETY: We're accessing pi.events which may not exist in all contexts
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const globalAny = globalThis as any;
-    const piEvents = globalAny.pi?.events;
-
-    if (!piEvents) {
-      ctx.ui.notify("[services] Honcho test skipped: MCP adapter not available (pi.events)", "warning");
-      ctx.ui.notify("[services] Note: Install pi-mcp-adapter to enable Honcho MCP", "info");
-      return;
+    // The cause of the last attempt, when the integration knows one.
+    // The reason is credential-free: it names the status and the cause.
+    let reason: string | undefined;
+    // The memory client and the native tools are two things: a connected
+    // client does not mean that the model sees the Honcho tools.
+    let nativeTools: boolean | undefined;
+    try {
+      const { getHonchoInitResult } = await import("./honcho-init.js");
+      const init = getHonchoInitResult();
+      if (init && init.status !== "ready") {
+        reason = `${init.status}: ${init.reason ?? "no reason reported"}`;
+      }
+      if (init && init.status === "ready") {
+        nativeTools = init.mcpRegistered === true;
+        if (!nativeTools && init.mcpRegistrationReason) {
+          reason = `native tools not registered: ${init.mcpRegistrationReason}`;
+        }
+      }
+    } catch {
+      // The module is optional for this command: the tracker still reports.
     }
 
-    // For read-only test, report current status from our tracker
-    // A full MCP tool discovery would require a non-read-only request
     if (honchoStatus.connected) {
-      ctx.ui.notify("[services] Honcho MCP server is connected", "info");
-      ctx.ui.notify("[services] Honcho test completed successfully", "info");
+      ctx.ui.notify("[services] Honcho memory client is connected", "info");
+      if (nativeTools === true) {
+        ctx.ui.notify("[services] Honcho native MCP tools are registered (the model sees them)", "info");
+        ctx.ui.notify("[services] Honcho test completed successfully", "info");
+      } else if (nativeTools === false) {
+        // The memory works, but the model has no Honcho tools: the check
+        // must not report a success that hides that.
+        ctx.ui.notify("[services] Honcho native MCP tools are NOT registered (the model sees no Honcho tools)", "warning");
+        if (reason) {
+          ctx.ui.notify(`[services] ${reason}`, "warning");
+        }
+        ctx.ui.notify("[services] The memory connection succeeded, but the native tool registration failed", "warning");
+      } else {
+        // The state of the native tools is unknown: only the memory
+        // connection is reported.
+        ctx.ui.notify("[services] Honcho memory test completed successfully", "info");
+      }
     } else if (honchoStatus.configured) {
       ctx.ui.notify("[services] Honcho MCP server not yet connected", "warning");
+      if (reason) {
+        ctx.ui.notify(`[services] Honcho is unavailable: ${reason}`, "warning");
+      }
+      if (honchoStatus.lastErrorCode) {
+        ctx.ui.notify(`[services] Last error: ${honchoStatus.lastErrorCode}`, "warning");
+      }
       ctx.ui.notify("[services] Connection will be established on first use", "info");
     } else {
       ctx.ui.notify("[services] Honcho MCP not configured", "warning");
+      if (reason) {
+        ctx.ui.notify(`[services] Honcho is unavailable: ${reason}`, "warning");
+      }
       ctx.ui.notify("[services] Add API key to enable Honcho memory", "info");
     }
   } catch (err) {