@selesai/code 0.13.40 → 0.14.3

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

@@ -1,47 +1,42 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import path from "node:path";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { getIntercomDirPath } from "./paths.ts";
 import {
   getBrokerLaunchSpec,
   getBrokerSpawnOptions,
-  getTsxCliPath,
-  getWindowsHiddenLauncherScript,
-  getWindowsBrokerCommandLine,
-  getWindowsHiddenLauncherPath,
+  configureNativeBrokerLauncher,
+  getTsxLoaderPath,
   isBrokerHealthOkMessage,
-  writeWindowsHiddenLauncher,
 } from "./spawn.ts";
 
-test("getTsxCliPath resolves tsx cli via module resolution", () => {
-  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.
-  assert.equal(path.basename(cliPath), "cli.mjs");
-  assert.equal(path.basename(path.dirname(cliPath)), "dist");
-  assert.equal(path.basename(path.dirname(path.dirname(cliPath))), "tsx");
+test("getTsxLoaderPath resolves the tsx loader via module resolution", () => {
+  const loaderPath = getTsxLoaderPath();
+  assert.equal(path.basename(loaderPath), "loader.mjs");
+  assert.equal(path.basename(path.dirname(loaderPath)), "dist");
+  assert.equal(path.basename(path.dirname(path.dirname(loaderPath))), "tsx");
 });
 
-test("getTsxCliPath falls back to a flat sibling tsx install", () => {
+test("getTsxLoaderPath 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");
+    const loaderPath = path.join(storeDir, "node_modules", "tsx", "dist", "loader.mjs");
     mkdirSync(extensionDir, { recursive: true });
-    mkdirSync(path.dirname(cliPath), { recursive: true });
-    writeFileSync(cliPath, "");
+    mkdirSync(path.dirname(loaderPath), { recursive: true });
+    writeFileSync(loaderPath, "");
 
-    assert.equal(getTsxCliPath(extensionDir), cliPath);
+    assert.equal(getTsxLoaderPath(extensionDir), loaderPath);
   } finally {
     rmSync(storeDir, { recursive: true, force: true });
   }
 });
 
-test("getTsxCliPath keeps the nested fallback when no sibling tsx cli exists", () => {
+test("getTsxLoaderPath keeps the nested fallback when no sibling tsx loader exists", () => {
   const storeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-store-"));
 
   try {
@@ -49,190 +44,73 @@ test("getTsxCliPath keeps the nested fallback when no sibling tsx cli exists", (
     mkdirSync(extensionDir, { recursive: true });
 
     assert.equal(
-      getTsxCliPath(extensionDir),
-      path.join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs"),
+      getTsxLoaderPath(extensionDir),
+      path.join(extensionDir, "node_modules", "tsx", "dist", "loader.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"));
-});
-
-test("getWindowsBrokerCommandLine wraps node, resolved tsx cli, and broker path", () => {
-  const commandLine = getWindowsBrokerCommandLine(
-    "C:/repo/broker.ts",
-    "C:/repo",
-    "C:/Program Files/nodejs/node.exe",
-  );
-  const expectedTsxPath = getTsxCliPath("C:/repo");
-  assert.equal(
-    commandLine,
-    `"C:/Program Files/nodejs/node.exe" "${expectedTsxPath}" "C:/repo/broker.ts"`,
-  );
-});
-
-test("getWindowsHiddenLauncherScript runs the broker command without showing a console", () => {
-  const script = getWindowsHiddenLauncherScript('"C:/Program Files/nodejs/node.exe" "C:/repo/node_modules/tsx/dist/cli.mjs" "C:/repo/broker.ts"');
-  assert.match(script, /WshShell\.Run/);
-  assert.match(script, /, 0, False/);
-});
-
-test("writeWindowsHiddenLauncher writes a UTF-16LE script with a BOM", () => {
-  const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-用户-"));
-  const launcherPath = path.join(intercomDir, "broker-launch.vbs");
-  const commandLine = '"C:/Users/用户/node.exe" "C:/repo/用户/broker.ts"';
-
-  try {
-    writeWindowsHiddenLauncher(commandLine, launcherPath);
-    const contents = readFileSync(launcherPath);
-    assert.deepEqual([...contents.subarray(0, 2)], [0xff, 0xfe]);
-    assert.equal(contents.toString("utf16le"), `\uFEFF${getWindowsHiddenLauncherScript(commandLine)}`);
-  } finally {
-    rmSync(intercomDir, { recursive: true, force: true });
-  }
-});
-
-test("getBrokerLaunchSpec uses wscript launcher on Windows without writing files", () => {
-  const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-"));
-
-  try {
-    const spec = getBrokerLaunchSpec(
-      "C:/repo/broker.ts",
-      "npx",
-      ["--no-install", "tsx"],
-      "C:/repo",
-      "win32",
-      intercomDir,
-      "C:/Program Files/nodejs/node.exe",
-    );
-    assert.equal(spec.command, "wscript.exe");
-    assert.deepEqual(spec.args, ["//E:VBScript", path.join(intercomDir, "broker-launch.vbs")]);
-    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", () => {
-  const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-"));
-
-  try {
-    const spec = getBrokerLaunchSpec(
-      "C:/repo/broker.ts",
-      "npx",
-      ["--no-install", "tsx"],
-      "C:/repo",
-      "win32",
-      intercomDir,
-      "C:/Program Files/Pi/pi.exe",
-    );
-    assert.equal(spec.kind, "windows-launcher");
-    assert.equal(spec.launcherCommandLine, `"node" "${getTsxCliPath("C:/repo")}" "C:/repo/broker.ts"`);
-  } finally {
-    rmSync(intercomDir, { recursive: true, force: true });
-  }
-});
-
-test("getBrokerLaunchSpec uses custom broker command on Windows", () => {
-  const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-"));
-
-  try {
-    const spec = getBrokerLaunchSpec("C:/repo/broker.ts", "bun", ["--smol"], "C:/repo", "win32", intercomDir, "C:/Program Files/nodejs/node.exe");
-    assert.equal(spec.command, "wscript.exe");
-    assert.deepEqual(spec.args, ["//E:VBScript", path.join(intercomDir, "broker-launch.vbs")]);
-    assert.equal(spec.kind, "windows-launcher");
-    assert.equal(spec.launcherCommandLine, `"bun" "--smol" "C:/repo/broker.ts"`);
-  } finally {
-    rmSync(intercomDir, { recursive: true, force: true });
-  }
-});
-
-test("getBrokerLaunchSpec uses node + resolved tsx for the default non-Windows launch", () => {
-  const spec = getBrokerLaunchSpec("C:/repo/broker.ts", "npx", ["--no-install", "tsx"], "C:/repo", "linux", "/tmp/intercom", "/usr/bin/node");
+test("getBrokerLaunchSpec runs the default broker in one Node process with the tsx loader", () => {
+  const spec = getBrokerLaunchSpec("/repo/broker.ts", "npx", ["--no-install", "tsx"], "/repo", "/usr/bin/node");
   assert.equal(spec.command, "/usr/bin/node");
-  assert.deepEqual(spec.args, [
-    getTsxCliPath("C:/repo"),
-    "C:/repo/broker.ts",
-  ]);
-  assert.equal(spec.kind, "direct");
+  assert.equal(spec.args.length, 3);
+  assert.equal(spec.args[0], "--import");
+  assert.match(spec.args[1], /^file:\/\/.*\/tsx\/dist\/loader\.mjs$/);
+  assert.equal(spec.args[2], "/repo/broker.ts");
   assert.equal(spec.captureStartupStderr, true);
 });
 
-test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai executable on non-Windows", () => {
-  const spec = getBrokerLaunchSpec(
-    "/repo/broker.ts",
-    "npx",
-    ["--no-install", "tsx"],
-    "/repo",
-    "darwin",
-    "/tmp/intercom",
-    "/Applications/Pi.app/Contents/MacOS/pi",
-  );
+test("getBrokerLaunchSpec falls back to PATH node for a standalone Pi executable", () => {
+  const spec = getBrokerLaunchSpec("C:/repo/broker.ts", "npx", ["--no-install", "tsx"], "C:/repo", "C:/Program Files/Pi/pi.exe");
   assert.equal(spec.command, "node");
-  assert.deepEqual(spec.args, [
-    getTsxCliPath("/repo"),
-    "/repo/broker.ts",
-  ]);
-  assert.equal(spec.kind, "direct");
+  assert.equal(spec.args[0], "--import");
 });
 
-test("getBrokerLaunchSpec uses custom broker command on non-Windows", () => {
-  const spec = getBrokerLaunchSpec("/repo/broker.ts", "bun", [], "/repo", "linux", "/tmp/intercom", "/usr/bin/node");
+test("getBrokerLaunchSpec runs a custom broker command directly", () => {
+  const spec = getBrokerLaunchSpec("/repo/broker.ts", "bun", ["--smol"], "/repo", "/usr/bin/node");
   assert.equal(spec.command, "bun");
-  assert.deepEqual(spec.args, ["/repo/broker.ts"]);
-  assert.equal(spec.kind, "direct");
+  assert.deepEqual(spec.args, ["--smol", "/repo/broker.ts"]);
   assert.equal(spec.captureStartupStderr, false);
 });
 
-test("getBrokerSpawnOptions hides the broker console window on Windows", () => {
-  const options = getBrokerSpawnOptions("C:/repo");
+test("getBrokerSpawnOptions uses the runtime directory instead of the package directory", () => {
+  const options = getBrokerSpawnOptions();
   assert.equal(options.windowsHide, true);
   assert.equal(options.detached, true);
   assert.deepEqual(options.stdio, ["ignore", "ignore", "pipe"]);
-  assert.equal(options.cwd, "C:/repo");
+  assert.equal(options.cwd, getIntercomDirPath());
 });
 
-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);
+test("getBrokerSpawnOptions honors a custom agent directory with stderr ignored", () => {
+  const agentDir = path.join(tmpdir(), "custom-agent");
+  const options = getBrokerSpawnOptions({ SELESAI_CODING_AGENT_DIR: agentDir }, false);
   assert.equal(options.detached, true);
   assert.equal(options.stdio, "ignore");
-  assert.equal(options.cwd, "/repo");
+  assert.equal(options.cwd, path.join(agentDir, "intercom"));
+  assert.equal(options.env.SELESAI_CODING_AGENT_DIR, agentDir);
 });
 
-test("getBrokerSpawnOptions passes an absolute SELESAI_CODING_AGENT_DIR to the broker", () => {
-  const options = getBrokerSpawnOptions("/repo", { SELESAI_CODING_AGENT_DIR: "relative-agent" });
-  assert.equal(options.env.SELESAI_CODING_AGENT_DIR, path.resolve("relative-agent"));
+test("getBrokerSpawnOptions resolves relative SELESAI_CODING_AGENT_DIR before changing cwd", () => {
+  const options = getBrokerSpawnOptions({ SELESAI_CODING_AGENT_DIR: "relative-agent" });
+  const agentDir = path.resolve("relative-agent");
+  assert.equal(options.cwd, path.join(agentDir, "intercom"));
+  assert.equal(options.env.SELESAI_CODING_AGENT_DIR, agentDir);
 });
 
 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 fakeTsxLoader = path.join(extensionDir, "node_modules", "tsx", "dist", "loader.mjs");
   const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
 
   try {
     mkdirSync(brokerDir, { recursive: true });
-    mkdirSync(path.dirname(fakeTsxCli), { recursive: true });
-    // No @selesai/code shim: standalone launcher/path loading must be host-independent.
+    mkdirSync(path.dirname(fakeTsxLoader), { 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");
+    writeFileSync(fakeTsxLoader, "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"]) {
@@ -265,3 +143,16 @@ test("isBrokerHealthOkMessage requires the intercom protocol marker", () => {
   assert.equal(isBrokerHealthOkMessage({ type: "health_ok", requestId: "req-2", protocol: "pi-intercom", version: 1 }, "req-1"), false);
   assert.equal(isBrokerHealthOkMessage("ok", "req-1"), false);
 });
+
+test("retains the embedded Selesai broker launcher with upstream's direct launch", () => {
+  configureNativeBrokerLauncher({ command: "/tmp/selesai", args: ["--embedded-broker"] });
+  try {
+    const launch = getBrokerLaunchSpec("/unused/broker.ts", "npx", ["--no-install", "tsx"]);
+    assert.equal(launch.command, "/tmp/selesai");
+    assert.deepEqual(launch.args, ["--embedded-broker"]);
+    assert.equal(launch.captureStartupStderr, true);
+    assert.equal(getBrokerLaunchSpec("/broker.ts", "custom", []).command, "custom");
+  } finally {
+    configureNativeBrokerLauncher();
+  }
+});

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

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 import { createRequire } from "module";
 import net from "net";
 import { randomUUID } from "crypto";
@@ -24,26 +24,40 @@ 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";
-    command: string;
-    args: string[];
-    launcherPath: string;
-    launcherCommandLine: string;
-    captureStartupStderr: boolean;
-  };
+let nativeBrokerLauncher: { command: string; args: string[] } | undefined;
+/** Native host supplies its embedded broker; explicit user launch commands remain authoritative. */
+export function configureNativeBrokerLauncher(launcher?: { command: string; args: string[] }): void {
+  nativeBrokerLauncher = launcher && { command: launcher.command, args: [...launcher.args] };
+}
+
+type BrokerLaunchSpec = {
+  command: string;
+  args: string[];
+  captureStartupStderr: boolean;
+};
 
 function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+export function getTsxLoaderPath(extensionDir: string = EXTENSION_DIR): string {
+  // Resolve tsx via Node's module resolution so it works regardless of whether
+  // tsx is bundled under extensionDir/node_modules or hoisted to a workspace
+  // root by npm. The tsx package main entry is its loader. If resolution
+  // fails, prefer the flat plugin-store layout before the legacy nested
+  // fallback.
+  try {
+    const requireFromExtension = createRequire(join(extensionDir, "package.json"));
+    return requireFromExtension.resolve("tsx");
+  } catch {
+    const siblingTsxLoader = join(extensionDir, "..", "tsx", "dist", "loader.mjs");
+    if (existsSync(siblingTsxLoader)) {
+      return siblingTsxLoader;
+    }
+    return join(extensionDir, "node_modules", "tsx", "dist", "loader.mjs");
+  }
+}
+
 export function getTsxCliPath(extensionDir: string = EXTENSION_DIR): string {
   // Resolve tsx via Node's module resolution so it works regardless of whether
   // tsx is bundled under extensionDir/node_modules or hoisted to a workspace
@@ -64,14 +78,6 @@ export function getTsxCliPath(extensionDir: string = EXTENSION_DIR): string {
   }
 }
 
-function quoteWindowsArg(value: string): string {
-  return `"${value.replace(/"/g, '""')}"`;
-}
-
-export function getWindowsHiddenLauncherPath(intercomDir: string = INTERCOM_DIR): string {
-  return join(intercomDir, "broker-launch.vbs");
-}
-
 function usesDefaultBrokerCommand(brokerCommand: string, brokerArgs: string[]): boolean {
   return brokerCommand === "npx"
     && brokerArgs.length === 2
@@ -86,29 +92,6 @@ function getNodeCommand(nodePath: string): string {
     : "node";
 }
 
-export function getWindowsBrokerCommandLine(
-  brokerPath: string,
-  extensionDir: string = EXTENSION_DIR,
-  nodePath: string = process.execPath,
-  brokerCommand = "npx",
-  brokerArgs: string[] = ["--no-install", "tsx"],
-): string {
-  if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
-    return [quoteWindowsArg(getNodeCommand(nodePath)), quoteWindowsArg(getTsxCliPath(extensionDir)), quoteWindowsArg(brokerPath)].join(" ");
-  }
-
-  return [quoteWindowsArg(brokerCommand), ...brokerArgs.map(quoteWindowsArg), quoteWindowsArg(brokerPath)].join(" ");
-}
-
-export function getWindowsHiddenLauncherScript(commandLine: string): string {
-  return [
-    'Set WshShell = CreateObject("WScript.Shell")',
-    `WshShell.Run "${commandLine.replace(/"/g, '""')}", 0, False`,
-    'Set WshShell = Nothing',
-    '',
-  ].join("\r\n");
-}
-
 export function isBrokerHealthOkMessage(message: unknown, requestId: string): boolean {
   if (typeof message !== "object" || message === null || !("type" in message)) {
     return false;
@@ -120,51 +103,26 @@ export function isBrokerHealthOkMessage(message: unknown, requestId: string): bo
     && response.version === INTERCOM_PROTOCOL_VERSION;
 }
 
-export function writeWindowsHiddenLauncher(
-  commandLine: string,
-  launcherPath: string = getWindowsHiddenLauncherPath(),
-): string {
-  ensureIntercomRuntimeDir(dirname(launcherPath));
-  writeFileSync(launcherPath, `\uFEFF${getWindowsHiddenLauncherScript(commandLine)}`, {
-    encoding: "utf16le",
-    mode: INTERCOM_RUNTIME_FILE_MODE,
-  });
-  restrictIntercomRuntimeFile(launcherPath);
-  return launcherPath;
-}
-
 export function getBrokerLaunchSpec(
   brokerPath: string,
   brokerCommand: string,
   brokerArgs: string[],
   extensionDir: string = EXTENSION_DIR,
-  platform: NodeJS.Platform = process.platform,
-  intercomDir: string = INTERCOM_DIR,
   nodePath: string = process.execPath,
 ): BrokerLaunchSpec {
-  if (platform === "win32") {
-    const launcherPath = getWindowsHiddenLauncherPath(intercomDir);
-    return {
-      kind: "windows-launcher",
-      command: "wscript.exe",
-      args: ["//E:VBScript", launcherPath],
-      launcherPath,
-      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs),
-      captureStartupStderr: false,
-    };
-  }
-
   if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
+    if (nativeBrokerLauncher) return { command: nativeBrokerLauncher.command, args: [...nativeBrokerLauncher.args], captureStartupStderr: true };
+    // Load tsx in the broker process itself. The tsx CLI would re-spawn Node
+    // without windowsHide, and that grandchild opens a visible console window
+    // on Windows because the detached broker has no console to share.
     return {
-      kind: "direct",
       command: getNodeCommand(nodePath),
-      args: [getTsxCliPath(extensionDir), brokerPath],
+      args: ["--import", pathToFileURL(getTsxLoaderPath(extensionDir)).href, brokerPath],
       captureStartupStderr: true,
     };
   }
 
   return {
-    kind: "direct",
     command: brokerCommand,
     args: [...brokerArgs, brokerPath],
     captureStartupStderr: false,
@@ -172,7 +130,6 @@ export function getBrokerLaunchSpec(
 }
 
 export function getBrokerSpawnOptions(
-  extensionDir: string = EXTENSION_DIR,
   env: NodeJS.ProcessEnv = process.env,
   captureStderr = true,
 ): {
@@ -182,11 +139,13 @@ export function getBrokerSpawnOptions(
   env: NodeJS.ProcessEnv;
   windowsHide: true;
 } {
+  const agentDir = getAgentDirPath(env);
   return {
     detached: true,
     stdio: captureStderr ? ["ignore", "ignore", "pipe"] : "ignore",
-    cwd: extensionDir,
-    env: { ...env, SELESAI_CODING_AGENT_DIR: getAgentDirPath(env), NODE_NO_WARNINGS: "1" },
+    // Windows locks a process's cwd against renames, so keep it outside the package.
+    cwd: getIntercomDirPath(agentDir),
+    env: { ...env, SELESAI_CODING_AGENT_DIR: agentDir, NODE_NO_WARNINGS: "1" },
     windowsHide: true,
   };
 }
@@ -215,10 +174,7 @@ export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: str
 
     const brokerPath = join(dirname(fileURLToPath(import.meta.url)), "broker.ts");
     const launch = getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs);
-    if (launch.kind === "windows-launcher") {
-      writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
-    }
-    const child = spawn(launch.command, launch.args, getBrokerSpawnOptions(EXTENSION_DIR, process.env, launch.captureStartupStderr));
+    const child = spawn(launch.command, launch.args, getBrokerSpawnOptions(process.env, launch.captureStartupStderr));
     let brokerStderr = "";
     const rememberBrokerStderr = (chunk: Buffer | string) => {
       brokerStderr = `${brokerStderr}${chunk.toString()}`.slice(-BROKER_STARTUP_STDERR_LIMIT);
@@ -246,9 +202,6 @@ export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: str
       };
 
       const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
-        if (launch.kind === "windows-launcher" && code === 0 && signal === null) {
-          return;
-        }
         cleanup();
         if (signal) {
           reject(brokerStartupError(`Intercom broker exited before startup with signal ${signal}`));

package/dist/extensions/pi-intercom/cli.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { register } from "tsx/esm/api";
+
+register();
+const { runMain } = await import("./cli.ts");
+process.exit(await runMain());