pi-subagent-windows 0.0.0-stage → 0.1.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

@@ -0,0 +1,345 @@
+import { spawn } from "node:child_process";
+import { existsSync, chmodSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DynamicBorder, type ExtensionAPI, type ExtensionContext, keyHint } from "@earendil-works/pi-coding-agent";
+import { Container, type SelectItem, SelectList, Text, type TUI } from "@earendil-works/pi-tui";
+import {
+	effectiveRunState,
+	findRuntimeFile,
+	getAgentDir,
+	inboxDir,
+	isRunAlive,
+	killRun,
+	launchRun,
+	listRuns,
+	readMetadata,
+	removeRunDir,
+	runDisplayName,
+	type InboxMessage,
+	type RunMetadata,
+	updateMetadata,
+	waitForRunShutdown,
+} from "./shared.ts";
+
+const packageDir = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * On Windows, keep `subagent.cmd` (cmd/PowerShell) and an extensionless `subagent`
+ * sh script (Git Bash, which does not resolve bare names through PATHEXT) in the
+ * agent bin directory so the CLI is on PATH after install. Never clobbers a file
+ * this extension did not write.
+ */
+function ensureCliShim(): void {
+	if (process.platform !== "win32") return;
+	try {
+		const binDir = join(getAgentDir(), "bin");
+		const cliPath = findRuntimeFile("subagent");
+		const cliPathUnix = cliPath.replace(/\\/g, "/");
+
+		const cmdMarker = "rem pi-subagent-windows shim";
+		const cmdContent = `@ECHO off\r\n${cmdMarker}\r\nnode "${cliPath}" %*\r\n`;
+
+		const shMarker = "# pi-subagent-windows shim";
+		const shContent = `#!/bin/sh\n${shMarker}\nexec node "${cliPathUnix}" "$@"\n`;
+
+		mkdirSync(binDir, { recursive: true });
+		const writeShim = (path: string, marker: string, content: string, mode?: number): void => {
+			let shouldWrite = true;
+			if (existsSync(path)) {
+				const current = readFileSync(path, "utf8");
+				if (!current.includes(marker)) return; // foreign file: leave it alone
+				if (current === content) shouldWrite = false;
+			}
+			if (shouldWrite) writeFileSync(path, content, { encoding: "utf8" });
+			if (mode !== undefined) chmodSync(path, mode);
+		};
+		writeShim(join(binDir, "subagent.cmd"), cmdMarker, cmdContent);
+		writeShim(join(binDir, "subagent"), shMarker, shContent, 0o755);
+	} catch {
+		// The shim is a convenience; extension loading must never fail over it.
+	}
+}
+
+function isInboxMessage(value: unknown): value is InboxMessage {
+	if (typeof value !== "object" || value === null) return false;
+	const message = value as Record<string, unknown>;
+	return typeof message.message === "string" && (message.delivery === "auto" || message.delivery === "followUp");
+}
+
+function displayState(metadata: RunMetadata): string {
+	return effectiveRunState(metadata).padEnd(8);
+}
+
+export default function subagentExtension(pi: ExtensionAPI) {
+	const runDir = process.env.PI_SUBAGENT_RUN_DIR;
+	if (!runDir) {
+		pi.on("resources_discover", () => ({ skillPaths: [join(packageDir, "skills")] }));
+		ensureCliShim();
+	}
+
+	pi.registerCommand("subagent", {
+		description: "Select a subagent spawned by this session",
+		handler: async (_args, ctx) => {
+			const runs = listRuns(ctx.sessionManager.getSessionId()).filter((run) => effectiveRunState(run) !== "exited");
+			if (runs.length === 0) {
+				ctx.ui.notify("No active subagents spawned by this session", "info");
+				return;
+			}
+
+			const items: SelectItem[] = runs.map((run) => ({
+				value: run.handle,
+				label: `${runDisplayName(run)}  ${displayState(run)}  ${run.provider}/${run.model}  ${run.thinking}`,
+			}));
+			let tui: TUI | undefined;
+			const selected = await ctx.ui.custom<string | undefined>((customTui, theme, _keybindings, done) => {
+				tui = customTui;
+				const list = new SelectList(items, Math.min(items.length, 10), {
+					selectedPrefix: (text) => theme.fg("accent", text),
+					selectedText: (text) => theme.fg("accent", text),
+					description: (text) => theme.fg("muted", text),
+					scrollInfo: (text) => theme.fg("dim", text),
+					noMatch: (text) => theme.fg("warning", text),
+				});
+				list.onSelect = (item) => done(item.value);
+				list.onCancel = () => done(undefined);
+
+				const container = new Container();
+				container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+				container.addChild(
+					new Text(theme.fg("accent", theme.bold(process.platform === "win32" ? "Subagent status" : "Attach to subagent")), 1, 0),
+				);
+				container.addChild(list);
+				container.addChild(
+					new Text(
+						theme.fg(
+							"dim",
+							`${keyHint("tui.select.confirm", process.platform === "win32" ? "status" : "attach")}  ${keyHint("tui.select.cancel", "cancel")}`,
+						),
+						1,
+						0,
+					),
+				);
+				container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+
+				return {
+					render: (width) => container.render(width),
+					invalidate: () => container.invalidate(),
+					handleInput: (data) => {
+						list.handleInput(data);
+						customTui.requestRender();
+					},
+				};
+			});
+			if (!selected || !tui) return;
+			const run = runs.find((candidate) => candidate.handle === selected);
+			if (!run) return;
+
+			if (process.platform === "win32") {
+				ctx.ui.notify(
+					`${runDisplayName(run)}: ${effectiveRunState(run)} — session: ${run.sessionFile}`,
+					"info",
+				);
+				return;
+			}
+
+			if (process.env.TMUX) {
+				const exitCode = await new Promise<number | null>((resolveExit) => {
+					const child = spawn("tmux", ["switch-client", "-t", run.tmuxSession], { stdio: "inherit" });
+					child.on("error", () => resolveExit(null));
+					child.on("close", resolveExit);
+				});
+				if (exitCode !== 0) ctx.ui.notify(`Could not switch to ${run.handle}`, "error");
+				return;
+			}
+
+			tui.stop();
+			try {
+				const exitCode = await new Promise<number | null>((resolveExit) => {
+					const child = spawn("tmux", ["attach-session", "-t", run.tmuxSession], { stdio: "inherit" });
+					child.on("error", () => resolveExit(null));
+					child.on("close", resolveExit);
+				});
+				if (exitCode !== 0) process.stderr.write(`Could not attach to ${run.handle}\n`);
+			} finally {
+				tui.start();
+				tui.requestRender(true);
+			}
+		},
+	});
+
+	if (!runDir) {
+		let widgetTimer: ReturnType<typeof setInterval> | undefined;
+		let widgetContext: ExtensionContext | undefined;
+
+		const refreshWidget = (): void => {
+			if (!widgetContext) return;
+			const activeRuns = listRuns(widgetContext.sessionManager.getSessionId())
+				.map((run) => ({ run, state: effectiveRunState(run) }))
+				.filter(({ state }) => state !== "exited");
+			if (activeRuns.length === 0) {
+				widgetContext.ui.setWidget("subagents", undefined);
+				return;
+			}
+
+			const visible = activeRuns.slice(0, 5).map(({ run, state }) => {
+				const color =
+					state === "busy" ? "warning" : state === "idle" ? "success" : state === "error" ? "error" : "muted";
+				return widgetContext!.ui.theme.fg(color, `${run.name ?? run.handle}:${state}`);
+			});
+			if (activeRuns.length > visible.length) {
+				visible.push(widgetContext.ui.theme.fg("muted", `+${activeRuns.length - visible.length}`));
+			}
+			widgetContext.ui.setWidget(
+				"subagents",
+				[widgetContext.ui.theme.fg("dim", "subagents: ") + visible.join(widgetContext.ui.theme.fg("dim", " | "))],
+				{ placement: "belowEditor" },
+			);
+		};
+
+		pi.on("session_start", (_event, ctx) => {
+			// Relaunch children that were suspended when this session was last quit or switched away from.
+			for (const run of listRuns(ctx.sessionManager.getSessionId())) {
+				if (!run.suspended || isRunAlive(run)) continue;
+				if (!existsSync(run.sessionFile)) {
+					removeRunDir(run.runDir);
+					continue;
+				}
+				const starting = updateMetadata(run.runDir, { state: "starting", error: undefined }) ?? run;
+				try {
+					launchRun(starting);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					updateMetadata(run.runDir, { state: "error", error: message });
+					if (ctx.hasUI) ctx.ui.notify(`Could not resume subagent ${runDisplayName(run)}: ${message}`, "error");
+				}
+			}
+
+			if (!ctx.hasUI) return;
+			widgetContext = ctx;
+			refreshWidget();
+			widgetTimer = setInterval(refreshWidget, 1000);
+			widgetTimer.unref();
+		});
+
+		pi.on("session_shutdown", async (event, ctx) => {
+			if (widgetTimer) clearInterval(widgetTimer);
+			widgetTimer = undefined;
+			widgetContext = undefined;
+			ctx.ui.setWidget("subagents", undefined);
+			if (event.reason === "reload") return;
+			// Suspend running children: stop the process but keep transcript and metadata so resuming this
+			// session relaunches them. Children that already exited on their own are discarded.
+			for (const run of listRuns(ctx.sessionManager.getSessionId())) {
+				if (!isRunAlive(run)) {
+					if (!run.suspended) removeRunDir(run.runDir);
+					continue;
+				}
+				updateMetadata(run.runDir, { suspended: true });
+				killRun(run);
+				await waitForRunShutdown(run.runDir);
+			}
+		});
+		return;
+	}
+
+	let currentContext: ExtensionContext | undefined;
+	let timer: ReturnType<typeof setInterval> | undefined;
+	let processing = false;
+	let sessionName: string | undefined;
+
+	const syncSessionName = (): void => {
+		const metadata = readMetadata(runDir);
+		if (!metadata) return;
+		const next = `subagent ${metadata.name ?? metadata.handle}`;
+		if (next === sessionName) return;
+		pi.setSessionName(next);
+		sessionName = next;
+	};
+
+	const processInbox = async (): Promise<void> => {
+		if (processing || !currentContext) return;
+		syncSessionName();
+		const queueDir = inboxDir(runDir);
+		if (!existsSync(queueDir)) return;
+		processing = true;
+		try {
+			for (const name of readdirSync(queueDir)
+				.filter((entry) => entry.endsWith(".json"))
+				.sort()) {
+				const path = join(queueDir, name);
+				let payload: InboxMessage;
+				try {
+					const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+					if (!isInboxMessage(value)) throw new Error("Invalid inbox message");
+					payload = value;
+				} catch (error) {
+					unlinkSync(path);
+					updateMetadata(runDir, {
+						state: "error",
+						error: error instanceof Error ? error.message : String(error),
+					});
+					continue;
+				}
+
+				updateMetadata(runDir, { state: "busy", error: undefined });
+				try {
+					if (currentContext.isIdle()) {
+						pi.sendUserMessage(payload.message);
+					} else {
+						pi.sendUserMessage(payload.message, {
+							deliverAs: payload.delivery === "followUp" ? "followUp" : "steer",
+						});
+					}
+					unlinkSync(path);
+				} catch (error) {
+					updateMetadata(runDir, {
+						state: currentContext.isIdle() ? "idle" : "busy",
+						error: error instanceof Error ? error.message : String(error),
+					});
+					return;
+				}
+			}
+		} finally {
+			processing = false;
+		}
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		currentContext = ctx;
+		const metadata = readMetadata(runDir);
+		if (!metadata) return;
+		updateMetadata(runDir, {
+			childSessionId: ctx.sessionManager.getSessionId(),
+			sessionFile: ctx.sessionManager.getSessionFile() ?? metadata.sessionFile,
+			state: ctx.isIdle() ? "idle" : "busy",
+			suspended: undefined,
+			error: undefined,
+		});
+		syncSessionName();
+		if (!timer) {
+			timer = setInterval(() => void processInbox(), 250);
+			timer.unref();
+		}
+		void processInbox();
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		currentContext = ctx;
+		updateMetadata(runDir, { state: "busy", hasStarted: true, error: undefined });
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		currentContext = ctx;
+		if (ctx.isIdle()) updateMetadata(runDir, { state: "idle" });
+	});
+
+	pi.on("session_shutdown", (event) => {
+		currentContext = undefined;
+		if (timer) {
+			clearInterval(timer);
+			timer = undefined;
+		}
+		if (event.reason === "quit") updateMetadata(runDir, { state: "exited" });
+	});
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "pi-subagent-windows",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Windows port of pi-subagent: hidden, persistent Pi subagents without tmux",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "subagent",
+    "windows"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "author": "Muntasim Ul Haque",
+  "homepage": "https://github.com/muntasimulhaque/pi-subagent-windows#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/muntasimulhaque/pi-subagent-windows.git"
+  },
+  "bugs": {
+    "url": "https://github.com/muntasimulhaque/pi-subagent-windows/issues"
+  },
+  "files": [
+    "dist",
+    "index.ts",
+    "shared.ts",
+    "subagent.ts",
+    "supervisor.ts",
+    "skills"
+  ],
+  "bin": {
+    "subagent": "./dist/subagent.js"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.2"
+  }
+}