pi-subagent-windows 0.1.0 → 0.1.2

package/README.md

@@ -23,6 +23,12 @@ On non-Windows platforms the upstream tmux behavior is kept, so the fork stays m
 
 ## Install
 
+```sh
+pi install npm:pi-subagent-windows
+```
+
+Or install straight from GitHub:
+
 ```sh
 pi install git:github.com/muntasimulhaque/pi-subagent-windows
 ```

package/dist/subagent.js

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+
+// subagent.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// shared.ts
+import { spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import {
+  accessSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function findRuntimeFile(name) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join(here, "dist", `${name}.js`), join(here, `${name}.ts`), join(here, `${name}.js`)];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Could not locate the ${name} runtime file`);
+}
+function getAgentDir() {
+  return process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+}
+function getRunsDir() {
+  return join(getAgentDir(), "subagents");
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function supervisorPidPath(runDir) {
+  return join(runDir, "supervisor.pid");
+}
+function readSupervisorPid(runDir) {
+  try {
+    const value = Number.parseInt(readFileSync(supervisorPidPath(runDir), "utf8").trim(), 10);
+    return Number.isInteger(value) && value > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function isRunAlive(metadata) {
+  if (isWindows()) {
+    const pid = readSupervisorPid(metadata.runDir);
+    return pid !== void 0 && processIsAlive(pid);
+  }
+  return tmuxSessionExists(metadata.tmuxSession);
+}
+function killRun(metadata) {
+  if (isWindows()) {
+    const pid = readSupervisorPid(metadata.runDir);
+    if (pid !== void 0 && processIsAlive(pid)) {
+      spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+    }
+    return;
+  }
+  spawnSync("tmux", ["kill-session", "-t", metadata.tmuxSession], { stdio: "ignore" });
+}
+function writeInboxMessage(runDir, payload) {
+  const queueDir = inboxDir(runDir);
+  mkdirSync(queueDir, { recursive: true, mode: 448 });
+  const id = `${Date.now()}-${randomBytes(4).toString("hex")}`;
+  const target = join(queueDir, `${id}.json`);
+  const temporary = `${target}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(payload)}
+`, { encoding: "utf8", mode: 384 });
+  renameSync(temporary, target);
+}
+function metadataPath(runDir) {
+  return join(runDir, "metadata.json");
+}
+function inboxDir(runDir) {
+  return join(runDir, "inbox");
+}
+function isValidRunName(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 64 && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function runDisplayName(metadata) {
+  return metadata.name ? `${metadata.name} (${metadata.handle})` : metadata.handle;
+}
+function readMetadata(runDir) {
+  try {
+    const value = JSON.parse(readFileSync(metadataPath(runDir), "utf8"));
+    if (typeof value !== "object" || value === null) return void 0;
+    const metadata = value;
+    if (metadata.version !== 1 || typeof metadata.handle !== "string" || metadata.name !== void 0 && !isValidRunName(metadata.name) || typeof metadata.tmuxSession !== "string" || typeof metadata.sessionFile !== "string" || typeof metadata.runDir !== "string") {
+      return void 0;
+    }
+    return metadata;
+  } catch {
+    return void 0;
+  }
+}
+function writeMetadata(metadata) {
+  mkdirSync(dirname(metadataPath(metadata.runDir)), { recursive: true, mode: 448 });
+  const target = metadataPath(metadata.runDir);
+  const temporary = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(metadata, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  renameSync(temporary, target);
+}
+function updateMetadata(runDir, patch) {
+  const current = readMetadata(runDir);
+  if (!current) return void 0;
+  const next = {
+    ...current,
+    ...patch,
+    version: 1,
+    handle: current.handle,
+    runDir: current.runDir,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeMetadata(next);
+  return next;
+}
+async function waitForRunShutdown(runDir, timeoutMs = 2e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const metadata = readMetadata(runDir);
+    if (!metadata || metadata.state === "exited" || !isRunAlive(metadata)) return;
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 50));
+  }
+}
+function removeRunDir(runDir) {
+  rmSync(runDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+}
+function tmuxSessionExists(session) {
+  return spawnSync("tmux", ["has-session", "-t", session], { stdio: "ignore" }).status === 0;
+}
+function launchRun(metadata, initialArgs = []) {
+  if (isWindows()) {
+    const supervisorPath = findRuntimeFile("supervisor");
+    const child = spawn(process.execPath, [supervisorPath, metadata.runDir], {
+      cwd: metadata.cwd,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: { ...process.env }
+    });
+    child.unref();
+    if (!child.pid) throw new Error("Failed to start the subagent supervisor");
+    return;
+  }
+  let launcher = "pi";
+  const testLauncher = join(metadata.cwd, "pi-test.sh");
+  try {
+    accessSync(testLauncher, constants.X_OK);
+    launcher = testLauncher;
+  } catch {
+  }
+  const result = spawnSync(
+    "tmux",
+    [
+      "new-session",
+      "-d",
+      "-s",
+      metadata.tmuxSession,
+      "-x",
+      "120",
+      "-y",
+      "40",
+      "-c",
+      metadata.cwd,
+      "--",
+      "env",
+      `PI_SUBAGENT_RUN_DIR=${metadata.runDir}`,
+      launcher,
+      "--session",
+      metadata.sessionFile,
+      "--provider",
+      metadata.provider,
+      "--model",
+      metadata.model,
+      "--thinking",
+      metadata.thinking,
+      ...metadata.launchArgs ?? [],
+      ...initialArgs
+    ],
+    { encoding: "utf8" }
+  );
+  if (result.status !== 0) throw new Error(result.stderr.trim() || "Failed to create tmux session");
+}
+function effectiveRunState(metadata) {
+  if ((metadata.state === "starting" || metadata.state === "busy" || metadata.state === "idle") && !isRunAlive(metadata)) {
+    return "exited";
+  }
+  return metadata.state;
+}
+function listRuns(parentSessionId) {
+  const root = getRunsDir();
+  if (!existsSync(root)) return [];
+  const runs = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const metadata = readMetadata(join(root, entry.name));
+    if (!metadata) continue;
+    if (parentSessionId && metadata.parentSessionId !== parentSessionId) continue;
+    runs.push(metadata);
+  }
+  return runs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function isSessionEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const entry = value;
+  return typeof entry.type === "string" && typeof entry.id === "string" && (entry.parentId === null || typeof entry.parentId === "string");
+}
+function activeBranch(entries) {
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const branch = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = entries.at(-1);
+  while (current && !seen.has(current.id)) {
+    branch.push(current);
+    seen.add(current.id);
+    current = current.parentId === null ? void 0 : byId.get(current.parentId);
+  }
+  return branch.reverse();
+}
+function isAssistantEntry(entry) {
+  if (entry.type !== "message" || typeof entry.message !== "object" || entry.message === null) return false;
+  return entry.message.role === "assistant";
+}
+function readLatestAssistant(sessionFile) {
+  let content;
+  try {
+    content = readFileSync(sessionFile, "utf8");
+  } catch {
+    return void 0;
+  }
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (isSessionEntry(value)) entries.push(value);
+    } catch {
+    }
+  }
+  return activeBranch(entries).findLast(isAssistantEntry)?.message;
+}
+function assistantText(message) {
+  if (!Array.isArray(message.content)) return message.errorMessage ?? "(no response text)";
+  const parts = [];
+  for (const item of message.content) {
+    if (typeof item !== "object" || item === null) continue;
+    const block = item;
+    if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+  }
+  return parts.join("\n").trim() || message.errorMessage || "(no response text)";
+}
+
+// subagent.ts
+var VALID_THINKING_LEVELS = /* @__PURE__ */ new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var moduleDir = dirname2(fileURLToPath2(import.meta.url));
+var packageRoot = existsSync2(join2(moduleDir, "index.ts")) ? moduleDir : dirname2(moduleDir);
+var extensionPath = join2(packageRoot, "index.ts");
+function fail(message) {
+  throw new Error(message);
+}
+function usage() {
+  fail(`Usage:
+  subagent spawn [--name <name>] [--provider <provider>] [--model <model>] [--thinking <level>]
+    [--cwd <dir>] [--tools <names>] [--no-extensions] [--no-skills]
+    [--no-prompt-templates] [--no-context-files] (--prompt <text> | --file <path>)...
+  subagent status <handle>
+  subagent rename <handle> <name>
+  subagent send <handle> [--follow-up] <message>
+  subagent wait <handle> [--timeout <seconds>]
+  subagent stop <handle>
+  subagent list`);
+}
+function valueAfter(args, index, option) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) fail(`${option} requires a value`);
+  return value;
+}
+function normalizeRunName(value) {
+  const name = value.trim();
+  if (!isValidRunName(name)) fail("Subagent name must be a single line of 1 to 64 characters");
+  return name;
+}
+function buildInitialMessage(prompts, files) {
+  const parts = [];
+  for (const file of files) {
+    try {
+      const buffer = readFileSync2(file);
+      if (buffer.includes(0) || buffer.byteLength > 1e6) {
+        parts.push(`A file is available at ${file}. Inspect it with the read tool before proceeding.`);
+      } else {
+        parts.push(`<file name="${file}">
+${buffer.toString("utf8")}
+</file>`);
+      }
+    } catch {
+      parts.push(`A file was requested at ${file}, but it could not be read.`);
+    }
+  }
+  if (prompts.length > 0) parts.push(`Task:
+${prompts.join("\n\n")}`);
+  return parts.join("\n\n");
+}
+function runDirForHandle(handle) {
+  if (!/^[a-z0-9]+$/.test(handle)) fail(`Invalid subagent handle: ${handle}`);
+  return join2(getRunsDir(), handle);
+}
+function getRun(handle) {
+  const metadata = readMetadata(runDirForHandle(handle));
+  if (!metadata) fail(`Unknown subagent: ${handle}`);
+  return metadata;
+}
+function generateHandle() {
+  mkdirSync2(getRunsDir(), { recursive: true, mode: 448 });
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const handle = randomBytes2(3).toString("hex");
+    if (!existsSync2(runDirForHandle(handle))) return handle;
+  }
+  fail("Could not allocate a unique subagent handle");
+}
+function spawnSubagent(args) {
+  if (process.env.PI_SUBAGENT_RUN_DIR) fail("Nested subagents are disabled");
+  let name;
+  let provider = process.env.PI_PROVIDER;
+  let model = process.env.PI_MODEL;
+  let thinking = process.env.PI_REASONING_LEVEL || "medium";
+  let cwd = process.cwd();
+  let tools;
+  let noExtensions = false;
+  let noSkills = false;
+  let noPromptTemplates = false;
+  let noContextFiles = false;
+  const prompts = [];
+  const files = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--name":
+        name = normalizeRunName(valueAfter(args, i, arg));
+        i++;
+        break;
+      case "--provider":
+        provider = valueAfter(args, i, arg);
+        i++;
+        break;
+      case "--model":
+        model = valueAfter(args, i, arg);
+        i++;
+        break;
+      case "--thinking":
+        thinking = valueAfter(args, i, arg);
+        i++;
+        break;
+      case "--cwd":
+        cwd = resolve2(valueAfter(args, i, arg));
+        i++;
+        break;
+      case "--tools":
+        tools = valueAfter(args, i, arg);
+        i++;
+        break;
+      case "--no-extensions":
+        noExtensions = true;
+        break;
+      case "--no-skills":
+        noSkills = true;
+        break;
+      case "--no-prompt-templates":
+        noPromptTemplates = true;
+        break;
+      case "--no-context-files":
+        noContextFiles = true;
+        break;
+      case "--prompt":
+        prompts.push(valueAfter(args, i, arg));
+        i++;
+        break;
+      case "--file": {
+        const file = resolve2(valueAfter(args, i, arg));
+        if (!existsSync2(file)) fail(`File not found: ${file}`);
+        files.push(file);
+        i++;
+        break;
+      }
+      default:
+        fail(`Unknown spawn argument: ${arg}`);
+    }
+  }
+  if (!provider) fail("No provider specified and PI_PROVIDER is not set");
+  if (!model) fail("No model specified and PI_MODEL is not set");
+  if (!VALID_THINKING_LEVELS.has(thinking)) fail(`Invalid thinking level: ${thinking}`);
+  if (tools !== void 0 && !tools.split(",").some((name2) => name2.trim()))
+    fail("--tools requires at least one tool name");
+  if (prompts.length === 0 && files.length === 0) fail("spawn requires at least one --prompt or --file");
+  if (!existsSync2(cwd)) fail(`Working directory not found: ${cwd}`);
+  const handle = generateHandle();
+  const runDir = runDirForHandle(handle);
+  const sessionFile = join2(runDir, "session.jsonl");
+  const tmuxSession = `pi-subagent-${handle}`;
+  mkdirSync2(inboxDir(runDir), { recursive: true, mode: 448 });
+  writeFileSync2(sessionFile, "", { mode: 384 });
+  const launchArgs = [];
+  if (tools) launchArgs.push("--tools", tools);
+  if (noExtensions) launchArgs.push("--no-extensions", "--extension", extensionPath);
+  if (noSkills) launchArgs.push("--no-skills");
+  if (noPromptTemplates) launchArgs.push("--no-prompt-templates");
+  if (noContextFiles) launchArgs.push("--no-context-files");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = {
+    version: 1,
+    handle,
+    name,
+    parentSessionId: process.env.PI_SESSION_ID || void 0,
+    parentSessionFile: process.env.PI_SESSION_FILE || void 0,
+    tmuxSession,
+    runDir,
+    sessionFile,
+    cwd,
+    provider,
+    model,
+    thinking,
+    launchArgs,
+    state: "starting",
+    hasStarted: false,
+    createdAt: now,
+    updatedAt: now
+  };
+  writeMetadata(metadata);
+  try {
+    if (process.platform === "win32") {
+      writeInboxMessage(runDir, { message: buildInitialMessage(prompts, files), delivery: "auto" });
+      launchRun(metadata);
+    } else {
+      const initialArgs = files.map((file) => `@${file}`);
+      if (prompts.length > 0) initialArgs.push(`Task:
+${prompts.join("\n\n")}`);
+      launchRun(metadata, initialArgs);
+    }
+  } catch (error) {
+    removeRunDir(runDir);
+    throw error;
+  }
+  const attachLine = process.platform === "win32" ? `Session: ${sessionFile}
+` : `Attach: tmux attach -t ${tmuxSession}
+`;
+  process.stdout.write(`Spawned ${runDisplayName(metadata)}
+State: busy
+${attachLine}`);
+}
+function statusSubagent(args) {
+  if (args.length !== 1) usage();
+  const metadata = getRun(args[0]);
+  const attachLine = process.platform === "win32" ? `Session: ${metadata.sessionFile}
+` : `Attach: tmux attach -t ${metadata.tmuxSession}
+`;
+  process.stdout.write(
+    `${runDisplayName(metadata)}: ${effectiveRunState(metadata)} (${metadata.provider}/${metadata.model}, ${metadata.thinking})
+${attachLine}`
+  );
+}
+function renameSubagent(args) {
+  if (args.length !== 2) usage();
+  const metadata = getRun(args[0]);
+  const name = normalizeRunName(args[1]);
+  const updated = updateMetadata(metadata.runDir, { name });
+  if (!updated) fail(`Could not rename subagent: ${metadata.handle}`);
+  process.stdout.write(`Renamed ${runDisplayName(updated)}
+`);
+}
+function sendSubagent(args) {
+  const handle = args.shift();
+  if (!handle) usage();
+  let followUp = false;
+  const messageParts = [];
+  for (const arg of args) {
+    if (arg === "--follow-up") followUp = true;
+    else if (arg.startsWith("--")) fail(`Unknown send argument: ${arg}`);
+    else messageParts.push(arg);
+  }
+  const message = messageParts.join(" ").trim();
+  if (!message) fail("send requires a message");
+  const metadata = getRun(handle);
+  if (!isRunAlive(metadata)) fail(`${handle} is not running`);
+  const payload = { message, delivery: followUp ? "followUp" : "auto" };
+  writeInboxMessage(metadata.runDir, payload);
+  const state = effectiveRunState(metadata);
+  const verb = followUp && state === "busy" ? "Queued follow-up for" : state === "idle" || state === "starting" ? "Prompted" : "Steered";
+  process.stdout.write(`${verb} ${runDisplayName(metadata)}
+`);
+}
+function parseTimeout(args) {
+  if (args.length === 0) return 1800;
+  if (args.length !== 2 || args[0] !== "--timeout") usage();
+  const timeout = Number(args[1]);
+  if (!Number.isInteger(timeout) || timeout <= 0) fail("--timeout must be a positive integer");
+  return timeout;
+}
+async function waitSubagent(args) {
+  const handle = args.shift();
+  if (!handle) usage();
+  const timeoutSeconds = parseTimeout(args);
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  while (Date.now() < deadline) {
+    const metadata = getRun(handle);
+    const pending = existsSync2(inboxDir(metadata.runDir)) ? readdirSync2(inboxDir(metadata.runDir)).some((file) => file.endsWith(".json")) : false;
+    const state = effectiveRunState(metadata);
+    if (state === "error") fail(metadata.error || `${handle} failed`);
+    if (state === "exited") fail(`${handle} exited before finishing`);
+    if (metadata.hasStarted && state === "idle" && !pending) {
+      const message = readLatestAssistant(metadata.sessionFile);
+      if (!message) fail(`${handle} finished without an assistant response`);
+      process.stdout.write(`${handle} finished
+
+${assistantText(message)}
+`);
+      if (message.stopReason === "error" || message.stopReason === "aborted") process.exitCode = 1;
+      return;
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
+  }
+  fail(`Timed out after ${timeoutSeconds}s waiting for ${handle}`);
+}
+async function stopSubagent(args) {
+  if (args.length !== 1) usage();
+  const metadata = getRun(args[0]);
+  const wasRunning = isRunAlive(metadata);
+  killRun(metadata);
+  if (wasRunning) await waitForRunShutdown(metadata.runDir);
+  removeRunDir(metadata.runDir);
+  process.stdout.write(`Stopped ${runDisplayName(metadata)}
+`);
+}
+function listSubagents(args) {
+  if (args.length !== 0) usage();
+  const runs = listRuns(process.env.PI_SESSION_ID || void 0);
+  if (runs.length === 0) {
+    process.stdout.write("No subagents\n");
+    return;
+  }
+  for (const metadata of runs) {
+    process.stdout.write(
+      `${runDisplayName(metadata)}  ${effectiveRunState(metadata).padEnd(8)}  ${metadata.provider}/${metadata.model}  ${metadata.thinking}
+`
+    );
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args.shift();
+  switch (command) {
+    case "spawn":
+      spawnSubagent(args);
+      break;
+    case "status":
+      statusSubagent(args);
+      break;
+    case "rename":
+      renameSubagent(args);
+      break;
+    case "send":
+      sendSubagent(args);
+      break;
+    case "wait":
+      await waitSubagent(args);
+      break;
+    case "stop":
+      await stopSubagent(args);
+      break;
+    case "list":
+      listSubagents(args);
+      break;
+    default:
+      usage();
+  }
+}
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});

package/dist/supervisor.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+// supervisor.ts
+import { appendFileSync, createWriteStream, writeFileSync as writeFileSync2 } from "node:fs";
+import { spawn } from "node:child_process";
+import { join as join2 } from "node:path";
+
+// shared.ts
+import {
+  accessSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function getAgentDir() {
+  return process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+}
+function supervisorPidPath(runDir2) {
+  return join(runDir2, "supervisor.pid");
+}
+function resolvePiCliPath() {
+  const installRoot2 = join(getAgentDir(), "install");
+  const currentVersion = readFileSync(join(installRoot2, "current-version"), "utf8").trim();
+  if (!currentVersion || !/^[0-9A-Za-z._+-]+$/.test(currentVersion)) {
+    throw new Error("The managed Pi version file is invalid");
+  }
+  const packageDirectory = join(installRoot2, "releases", currentVersion, "node_modules", "@earendil-works", "pi-coding-agent");
+  const manifest = JSON.parse(readFileSync(join(packageDirectory, "package.json"), "utf8"));
+  const bin = manifest.bin;
+  const binPath = typeof bin === "string" ? bin : bin?.pi;
+  if (!binPath) throw new Error("The installed Pi package does not declare a pi bin");
+  return resolve(packageDirectory, binPath);
+}
+function metadataPath(runDir2) {
+  return join(runDir2, "metadata.json");
+}
+function isValidRunName(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 64 && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function readMetadata(runDir2) {
+  try {
+    const value = JSON.parse(readFileSync(metadataPath(runDir2), "utf8"));
+    if (typeof value !== "object" || value === null) return void 0;
+    const metadata2 = value;
+    if (metadata2.version !== 1 || typeof metadata2.handle !== "string" || metadata2.name !== void 0 && !isValidRunName(metadata2.name) || typeof metadata2.tmuxSession !== "string" || typeof metadata2.sessionFile !== "string" || typeof metadata2.runDir !== "string") {
+      return void 0;
+    }
+    return metadata2;
+  } catch {
+    return void 0;
+  }
+}
+function writeMetadata(metadata2) {
+  mkdirSync(dirname(metadataPath(metadata2.runDir)), { recursive: true, mode: 448 });
+  const target = metadataPath(metadata2.runDir);
+  const temporary = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(metadata2, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  renameSync(temporary, target);
+}
+function updateMetadata(runDir2, patch) {
+  const current = readMetadata(runDir2);
+  if (!current) return void 0;
+  const next = {
+    ...current,
+    ...patch,
+    version: 1,
+    handle: current.handle,
+    runDir: current.runDir,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeMetadata(next);
+  return next;
+}
+
+// supervisor.ts
+var runDir = process.argv[2];
+if (!runDir) {
+  process.stderr.write("pi-subagent-windows supervisor: missing run directory\n");
+  process.exit(1);
+}
+var metadata = readMetadata(runDir);
+if (!metadata) {
+  process.stderr.write(`pi-subagent-windows supervisor: no valid metadata in ${runDir}
+`);
+  process.exit(1);
+}
+var logPath = join2(runDir, "supervisor.log");
+var log = (message) => {
+  try {
+    appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`, { encoding: "utf8" });
+  } catch {
+  }
+};
+writeFileSync2(supervisorPidPath(runDir), `${process.pid}
+`, { encoding: "utf8", mode: 384 });
+var installRoot = join2(getAgentDir(), "install");
+var cliPath;
+try {
+  cliPath = resolvePiCliPath();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  log(`could not resolve the Pi CLI: ${message}`);
+  updateMetadata(runDir, { state: "error", error: message });
+  process.exit(1);
+}
+var args = [
+  cliPath,
+  "--mode",
+  "rpc",
+  "--session",
+  metadata.sessionFile,
+  "--provider",
+  metadata.provider,
+  "--model",
+  metadata.model,
+  "--thinking",
+  metadata.thinking,
+  ...metadata.launchArgs ?? []
+];
+log(`supervisor pid=${process.pid} starting child: ${JSON.stringify(args)}`);
+var child = spawn(process.execPath, args, {
+  cwd: metadata.cwd,
+  windowsHide: true,
+  stdio: ["pipe", "pipe", "pipe"],
+  env: {
+    ...process.env,
+    PI_SUBAGENT_RUN_DIR: runDir,
+    PI_MANAGED_INSTALL_ROOT: installRoot
+  }
+});
+if (!child.pid || !child.stdin || !child.stdout) {
+  log("failed to spawn the Pi RPC child");
+  updateMetadata(runDir, { state: "error", error: "Failed to spawn the Pi RPC child" });
+  process.exit(1);
+}
+log(`child pid=${child.pid}`);
+child.stderr.pipe(createWriteStream(logPath, { flags: "a" }));
+function respond(id, payload) {
+  try {
+    child.stdin.write(`${JSON.stringify({ type: "extension_ui_response", id, ...payload })}
+`);
+  } catch {
+  }
+}
+var stdoutBuffer = "";
+child.stdout.on("data", (data) => {
+  stdoutBuffer += data.toString("utf8");
+  let index;
+  while ((index = stdoutBuffer.indexOf("\n")) !== -1) {
+    const line = stdoutBuffer.slice(0, index).replace(/\r$/, "");
+    stdoutBuffer = stdoutBuffer.slice(index + 1);
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.type !== "extension_ui_request" || typeof record.id !== "string") continue;
+    switch (record.method) {
+      case "confirm":
+        log("auto-declined an extension confirm dialog (no interactive UI in hidden subagents)");
+        respond(record.id, { confirmed: false });
+        break;
+      case "select":
+      case "input":
+      case "editor":
+        log(`auto-cancelled an extension ${record.method} dialog (no interactive UI in hidden subagents)`);
+        respond(record.id, { cancelled: true });
+        break;
+      default:
+        break;
+    }
+  }
+});
+child.on("error", (error) => {
+  log(`child process error: ${error.message}`);
+  updateMetadata(runDir, { state: "error", error: error.message });
+  process.exit(1);
+});
+child.on("exit", (code, signal) => {
+  log(`child exited code=${code} signal=${signal}`);
+  const current = readMetadata(runDir);
+  if (current && current.state !== "exited" && current.state !== "error") {
+    updateMetadata(
+      runDir,
+      code === 0 ? { state: "exited" } : { state: "error", error: `Subagent process exited unexpectedly (code=${code}, signal=${signal})` }
+    );
+  }
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  try {
+    child.stdin.end();
+  } catch {
+  }
+});

package/index.ts

@@ -6,6 +6,7 @@ import { DynamicBorder, type ExtensionAPI, type ExtensionContext, keyHint } from
 import { Container, type SelectItem, SelectList, Text, type TUI } from "@earendil-works/pi-tui";
 import {
 	effectiveRunState,
+	findRuntimeFile,
 	getAgentDir,
 	inboxDir,
 	isRunAlive,
@@ -33,7 +34,7 @@ function ensureCliShim(): void {
 	if (process.platform !== "win32") return;
 	try {
 		const binDir = join(getAgentDir(), "bin");
-		const cliPath = join(packageDir, "subagent.ts");
+		const cliPath = findRuntimeFile("subagent");
 		const cliPathUnix = cliPath.replace(/\\/g, "/");
 
 		const cmdMarker = "rem pi-subagent-windows shim";

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "pi-subagent-windows",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Windows port of pi-subagent: hidden, persistent Pi subagents without tmux",
-  "keywords": ["pi-package", "pi-extension", "subagent", "windows"],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "subagent",
+    "windows"
+  ],
   "type": "module",
   "license": "MIT",
   "author": "Muntasim Ul Haque",
@@ -15,7 +20,7 @@
     "url": "https://github.com/muntasimulhaque/pi-subagent-windows/issues"
   },
   "files": [
-    "bin",
+    "dist",
     "index.ts",
     "shared.ts",
     "subagent.ts",
@@ -23,10 +28,17 @@
     "skills"
   ],
   "bin": {
-    "subagent": "./bin/subagent.js"
+    "subagent": "dist/subagent.js"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "smoke": "node scripts/smoke.mjs",
+    "prepare": "npm run build"
   },
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "engines": {
     "node": ">=22.19.0"
@@ -34,5 +46,8 @@
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.2"
   }
 }

package/shared.ts

@@ -15,7 +15,19 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const packageDir = dirname(fileURLToPath(import.meta.url));
+/**
+ * Locate a runtime entry point, preferring the compiled `dist/` output.
+ * Compiled files are required when the package is installed under `node_modules`,
+ * where Node refuses to strip TypeScript types.
+ */
+export function findRuntimeFile(name: string): string {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const candidates = [join(here, "dist", `${name}.js`), join(here, `${name}.ts`), join(here, `${name}.js`)];
+	for (const candidate of candidates) {
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error(`Could not locate the ${name} runtime file`);
+}
 
 export type RunState = "starting" | "busy" | "idle" | "exited" | "error";
 
@@ -246,7 +258,7 @@ export function tmuxSessionExists(session: string): boolean {
  */
 export function launchRun(metadata: RunMetadata, initialArgs: string[] = []): void {
 	if (isWindows()) {
-		const supervisorPath = join(packageDir, "supervisor.ts");
+		const supervisorPath = findRuntimeFile("supervisor");
 		const child = spawn(process.execPath, [supervisorPath, metadata.runDir], {
 			cwd: metadata.cwd,
 			detached: true,

package/subagent.ts

@@ -27,7 +27,9 @@ import {
 } from "./shared.ts";
 
 const VALID_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-const extensionPath = join(dirname(fileURLToPath(import.meta.url)), "index.ts");
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = existsSync(join(moduleDir, "index.ts")) ? moduleDir : dirname(moduleDir);
+const extensionPath = join(packageRoot, "index.ts");
 
 function fail(message: string): never {
 	throw new Error(message);

package/bin/subagent.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-/**
- * npm/npx bin entry. Node cannot link a `.ts` file as a global command, so this
- * thin wrapper forwards to the real CLI, which runs under Node's type stripping.
- */
-import { spawnSync } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const entry = join(dirname(fileURLToPath(import.meta.url)), "..", "subagent.ts");
-const result = spawnSync(process.execPath, [entry, ...process.argv.slice(2)], { stdio: "inherit" });
-if (result.error) {
-	process.stderr.write(`${result.error.message}\n`);
-	process.exit(1);
-}
-process.exit(result.status ?? 1);