pi-harness-runtime 1.1.457 → 1.1.459

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/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) {