@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-intercom/broker/spawn.test.ts

@@ -1,8 +1,9 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import path from "node:path";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   getBrokerLaunchSpec,
   getBrokerSpawnOptions,
@@ -14,7 +15,7 @@ import {
 } from "./spawn.ts";
 
 test("getTsxCliPath resolves tsx cli via module resolution", () => {
-  const cliPath = getTsxCliPath("C:/repo");
+  const cliPath = getTsxCliPath();
   // getTsxCliPath resolves the tsx package main entry and locates cli.mjs next
   // to it, so the path reflects the real install location (bundled under
   // extensionDir or hoisted by npm) rather than a hardcoded relative path.
@@ -23,6 +24,38 @@ test("getTsxCliPath resolves tsx cli via module resolution", () => {
   assert.equal(path.basename(path.dirname(path.dirname(cliPath))), "tsx");
 });
 
+test("getTsxCliPath falls back to a flat sibling tsx install", () => {
+  const storeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-store-"));
+
+  try {
+    const extensionDir = path.join(storeDir, "node_modules", "pi-intercom");
+    const cliPath = path.join(storeDir, "node_modules", "tsx", "dist", "cli.mjs");
+    mkdirSync(extensionDir, { recursive: true });
+    mkdirSync(path.dirname(cliPath), { recursive: true });
+    writeFileSync(cliPath, "");
+
+    assert.equal(getTsxCliPath(extensionDir), cliPath);
+  } finally {
+    rmSync(storeDir, { recursive: true, force: true });
+  }
+});
+
+test("getTsxCliPath keeps the nested fallback when no sibling tsx cli exists", () => {
+  const storeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-store-"));
+
+  try {
+    const extensionDir = path.join(storeDir, "pi-intercom");
+    mkdirSync(extensionDir, { recursive: true });
+
+    assert.equal(
+      getTsxCliPath(extensionDir),
+      path.join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs"),
+    );
+  } finally {
+    rmSync(storeDir, { recursive: true, force: true });
+  }
+});
+
 test("getWindowsHiddenLauncherPath points at the broker launcher script", () => {
   const launcherPath = getWindowsHiddenLauncherPath("C:/tmp/intercom");
   assert.equal(launcherPath, path.join("C:/tmp/intercom", "broker-launch.vbs"));
@@ -65,13 +98,14 @@ test("getBrokerLaunchSpec uses wscript launcher on Windows without writing files
     assert.equal(spec.kind, "windows-launcher");
     const expectedTsxPath = getTsxCliPath("C:/repo");
     assert.equal(spec.launcherCommandLine, `"C:/Program Files/nodejs/node.exe" "${expectedTsxPath}" "C:/repo/broker.ts"`);
+    assert.equal(spec.captureStartupStderr, false);
     assert.equal(existsSync(path.join(intercomDir, "broker-launch.vbs")), false);
   } finally {
     rmSync(intercomDir, { recursive: true, force: true });
   }
 });
 
-test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai executable on Windows", () => {
+test("getBrokerLaunchSpec falls back to PATH node for a standalone Pi executable on Windows", () => {
   const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-"));
 
   try {
@@ -82,7 +116,7 @@ test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai execu
       "C:/repo",
       "win32",
       intercomDir,
-      "C:/Program Files/Selesai/selesai.exe",
+      "C:/Program Files/Pi/pi.exe",
     );
     assert.equal(spec.kind, "windows-launcher");
     assert.equal(spec.launcherCommandLine, `"node" "${getTsxCliPath("C:/repo")}" "C:/repo/broker.ts"`);
@@ -112,9 +146,10 @@ test("getBrokerLaunchSpec uses node + resolved tsx for the default non-Windows l
     "C:/repo/broker.ts",
   ]);
   assert.equal(spec.kind, "direct");
+  assert.equal(spec.captureStartupStderr, true);
 });
 
-test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai executable on non-Windows", () => {
+test("getBrokerLaunchSpec falls back to PATH node for a standalone Pi executable on non-Windows", () => {
   const spec = getBrokerLaunchSpec(
     "/repo/broker.ts",
     "npx",
@@ -122,7 +157,7 @@ test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai execu
     "/repo",
     "darwin",
     "/tmp/intercom",
-    "/Applications/Selesai.app/Contents/MacOS/selesai",
+    "/Applications/Pi.app/Contents/MacOS/pi",
   );
   assert.equal(spec.command, "node");
   assert.deepEqual(spec.args, [
@@ -137,13 +172,14 @@ test("getBrokerLaunchSpec uses custom broker command on non-Windows", () => {
   assert.equal(spec.command, "bun");
   assert.deepEqual(spec.args, ["/repo/broker.ts"]);
   assert.equal(spec.kind, "direct");
+  assert.equal(spec.captureStartupStderr, false);
 });
 
 test("getBrokerSpawnOptions hides the broker console window on Windows", () => {
   const options = getBrokerSpawnOptions("C:/repo");
   assert.equal(options.windowsHide, true);
   assert.equal(options.detached, true);
-  assert.equal(options.stdio, "ignore");
+  assert.deepEqual(options.stdio, ["ignore", "ignore", "pipe"]);
   assert.equal(options.cwd, "C:/repo");
 });
 
@@ -151,6 +187,13 @@ test("getBrokerSpawnOptions keeps portable defaults on non-Windows platforms", (
   const options = getBrokerSpawnOptions("/repo");
   assert.equal(options.windowsHide, true);
   assert.equal(options.detached, true);
+  assert.deepEqual(options.stdio, ["ignore", "ignore", "pipe"]);
+  assert.equal(options.cwd, "/repo");
+});
+
+test("getBrokerSpawnOptions can keep custom broker stderr ignored", () => {
+  const options = getBrokerSpawnOptions("/repo", process.env, false);
+  assert.equal(options.detached, true);
   assert.equal(options.stdio, "ignore");
   assert.equal(options.cwd, "/repo");
 });
@@ -160,6 +203,62 @@ test("getBrokerSpawnOptions passes an absolute SELESAI_CODING_AGENT_DIR to the b
   assert.equal(options.env.SELESAI_CODING_AGENT_DIR, path.resolve("relative-agent"));
 });
 
+test("spawnBrokerIfNeeded includes stderr from default broker startup failures", async () => {
+  const root = mkdtempSync(path.join(tmpdir(), "pi-intercom-spawn-"));
+  const extensionDir = path.join(root, "pi-intercom");
+  const brokerDir = path.join(extensionDir, "broker");
+  const fakeTsxCli = path.join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+  const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+
+  try {
+    mkdirSync(brokerDir, { recursive: true });
+    mkdirSync(path.dirname(fakeTsxCli), { recursive: true });
+    writeFileSync(path.join(extensionDir, "package.json"), JSON.stringify({ type: "module" }));
+    writeFileSync(fakeTsxCli, "process.stderr.write('fake tsx failed\\n'); process.exit(1);\n");
+
+    const sourceDir = path.dirname(fileURLToPath(import.meta.url));
+    for (const fileName of ["spawn.ts", "framing.ts", "paths.ts"]) {
+      cpSync(path.join(sourceDir, fileName), path.join(brokerDir, fileName));
+    }
+
+    // Our fork's paths.ts routes through getAgentDir() from @selesai/code, so
+    // the temp copy needs a resolvable shim for the fork's config-dir lookup.
+    const codeShimDir = path.join(extensionDir, "node_modules", "@selesai", "code");
+    mkdirSync(codeShimDir, { recursive: true });
+    writeFileSync(
+      path.join(codeShimDir, "package.json"),
+      JSON.stringify({ name: "@selesai/code", type: "module", exports: { ".": "./index.mjs" } }),
+    );
+    writeFileSync(
+      path.join(codeShimDir, "index.mjs"),
+      `import { homedir } from "node:os";
+import { join } from "node:path";
+export function getAgentDir() {
+  return process.env.SELESAI_CODING_AGENT_DIR ?? join(homedir(), ".selesai", "agent");
+}
+`,
+    );
+
+    process.env.SELESAI_CODING_AGENT_DIR = path.join(root, "agent");
+    const moduleUrl = `${pathToFileURL(path.join(brokerDir, "spawn.ts")).href}?case=${Date.now()}`;
+    const imported = await import(moduleUrl) as typeof import("./spawn.ts");
+
+    await assert.rejects(
+      () => imported.spawnBrokerIfNeeded("npx", ["--no-install", "tsx"]),
+      (error: unknown) => {
+        assert.ok(error instanceof Error);
+        assert.match(error.message, /Intercom broker exited before startup with code 1/);
+        assert.match(error.message, /Broker stderr:\nfake tsx failed/);
+        return true;
+      },
+    );
+  } finally {
+    if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+    else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("isBrokerHealthOkMessage requires the intercom protocol marker", () => {
   assert.equal(isBrokerHealthOkMessage({ type: "health_ok", requestId: "req-1", protocol: "pi-intercom", version: 1 }, "req-1"), true);
   assert.equal(isBrokerHealthOkMessage({ type: "health_ok", requestId: "req-1" }, "req-1"), false);

package/dist/extensions/pi-intercom/broker/spawn.ts

@@ -22,12 +22,14 @@ const INTERCOM_DIR = getIntercomDirPath();
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
 const BROKER_PID = join(INTERCOM_DIR, "broker.pid");
 const BROKER_SPAWN_LOCK = join(INTERCOM_DIR, "broker.spawn.lock");
+const BROKER_STARTUP_STDERR_LIMIT = 4_000;
 
 type BrokerLaunchSpec =
   | {
     kind: "direct";
     command: string;
     args: string[];
+    captureStartupStderr: boolean;
   }
   | {
     kind: "windows-launcher";
@@ -35,6 +37,7 @@ type BrokerLaunchSpec =
     args: string[];
     launcherPath: string;
     launcherCommandLine: string;
+    captureStartupStderr: boolean;
   };
 
 function sleep(ms: number): Promise<void> {
@@ -46,12 +49,17 @@ export function getTsxCliPath(extensionDir: string = EXTENSION_DIR): string {
   // tsx is bundled under extensionDir/node_modules or hoisted to a workspace
   // root by npm. We resolve the tsx package main entry (its "exports" field
   // does not expose ./dist/cli.mjs as a subpath) and then locate cli.mjs next
-  // to it. Falls back to the legacy relative path if resolution fails.
+  // to it. If resolution fails, prefer the flat plugin-store layout before the
+  // legacy nested fallback.
   try {
-    const requireFromExtension = createRequire(import.meta.url);
+    const requireFromExtension = createRequire(join(extensionDir, "package.json"));
     const tsxMain = requireFromExtension.resolve("tsx");
     return join(dirname(tsxMain), "cli.mjs");
   } catch {
+    const siblingTsxCli = join(extensionDir, "..", "tsx", "dist", "cli.mjs");
+    if (existsSync(siblingTsxCli)) {
+      return siblingTsxCli;
+    }
     return join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
   }
 }
@@ -142,6 +150,7 @@ export function getBrokerLaunchSpec(
       args: [launcherPath],
       launcherPath,
       launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs),
+      captureStartupStderr: false,
     };
   }
 
@@ -150,6 +159,7 @@ export function getBrokerLaunchSpec(
       kind: "direct",
       command: getNodeCommand(nodePath),
       args: [getTsxCliPath(extensionDir), brokerPath],
+      captureStartupStderr: true,
     };
   }
 
@@ -157,22 +167,24 @@ export function getBrokerLaunchSpec(
     kind: "direct",
     command: brokerCommand,
     args: [...brokerArgs, brokerPath],
+    captureStartupStderr: false,
   };
 }
 
 export function getBrokerSpawnOptions(
   extensionDir: string = EXTENSION_DIR,
   env: NodeJS.ProcessEnv = process.env,
+  captureStderr = true,
 ): {
   detached: true;
-  stdio: "ignore";
+  stdio: "ignore" | ["ignore", "ignore", "pipe"];
   cwd: string;
   env: NodeJS.ProcessEnv;
   windowsHide: true;
 } {
   return {
     detached: true,
-    stdio: "ignore",
+    stdio: captureStderr ? ["ignore", "ignore", "pipe"] : "ignore",
     cwd: extensionDir,
     env: { ...env, SELESAI_CODING_AGENT_DIR: getAgentDirPath(env), NODE_NO_WARNINGS: "1" },
     windowsHide: true,
@@ -206,18 +218,31 @@ export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: str
     if (launch.kind === "windows-launcher") {
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
-    const child = spawn(launch.command, launch.args, getBrokerSpawnOptions());
+    const child = spawn(launch.command, launch.args, getBrokerSpawnOptions(EXTENSION_DIR, process.env, launch.captureStartupStderr));
+    let brokerStderr = "";
+    const rememberBrokerStderr = (chunk: Buffer | string) => {
+      brokerStderr = `${brokerStderr}${chunk.toString()}`.slice(-BROKER_STARTUP_STDERR_LIMIT);
+    };
+    const brokerStartupError = (message: string, cause?: unknown) => {
+      const stderr = brokerStderr.trim();
+      const errorMessage = stderr ? `${message}\nBroker stderr:\n${stderr}` : message;
+      return cause === undefined ? new Error(errorMessage) : new Error(errorMessage, { cause });
+    };
+    child.stderr?.on("data", rememberBrokerStderr);
+    child.stderr?.unref();
     child.unref();
 
     await new Promise<void>((resolve, reject) => {
       const cleanup = () => {
+        child.stderr?.off("data", rememberBrokerStderr);
+        child.stderr?.resume();
         child.off("error", onError);
-        child.off("exit", onExit);
+        child.off("close", onExit);
       };
 
       const onError = (error: Error) => {
         cleanup();
-        reject(new Error(`Failed to spawn intercom broker: ${error.message}`, { cause: error }));
+        reject(brokerStartupError(`Failed to spawn intercom broker: ${error.message}`, error));
       };
 
       const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
@@ -226,20 +251,21 @@ export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: str
         }
         cleanup();
         if (signal) {
-          reject(new Error(`Intercom broker exited before startup with signal ${signal}`));
+          reject(brokerStartupError(`Intercom broker exited before startup with signal ${signal}`));
           return;
         }
-        reject(new Error(`Intercom broker exited before startup with code ${code ?? "unknown"}`));
+        reject(brokerStartupError(`Intercom broker exited before startup with code ${code ?? "unknown"}`));
       };
 
       child.once("error", onError);
-      child.once("exit", onExit);
+      child.once("close", onExit);
       waitForBroker().then(() => {
         cleanup();
         resolve();
       }, (error) => {
         cleanup();
-        reject(toError(error));
+        const startupError = toError(error);
+        reject(brokerStartupError(startupError.message, startupError));
       });
     });
   } finally {

package/dist/extensions/pi-intercom/config.test.ts

@@ -73,20 +73,18 @@ test("loadConfig accepts a restart-stable intercom id", async () => {
   }
 });
 
-test("loadConfig rejects invalid inboundTrigger values by failing closed", async () => {
+test("loadConfig rejects invalid inboundTrigger values", async () => {
   const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
   try {
     mkdirSync(join(root, "intercom"), { recursive: true });
     writeFileSync(join(root, "intercom", "config.json"), JSON.stringify({ inboundTrigger: "prompt" }));
-    const previousError = console.error;
-    console.error = () => undefined;
-    try {
-      await withAgentDir(root, () => {
-        assert.equal(loadConfig().inboundTrigger, "never");
-      });
-    } finally {
-      console.error = previousError;
-    }
+
+    await withAgentDir(root, () => {
+      assert.throws(
+        () => loadConfig(),
+        /Failed to load intercom config.*"inboundTrigger" must be "always", "replies", or "never"/,
+      );
+    });
   } finally {
     rmSync(root, { recursive: true, force: true });
   }

package/dist/extensions/pi-intercom/config.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { getIntercomDirPath } from "./broker/paths.ts";
 
-export const DEFAULT_ASK_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_ASK_TIMEOUT_MS = 10 * 60 * 1000;
 
 export function getAskTimeoutMs(): number {
   const raw = process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
@@ -151,7 +151,7 @@ export function loadConfig(): IntercomConfig {
 
     return config;
   } catch (error) {
-    console.error(`Failed to load intercom config at ${configPath}:`, error);
-    return { ...defaults, inboundTrigger: "never" };
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load intercom config at ${configPath}: ${message}`, { cause: error });
   }
 }