@f5-sales-demo/xcsh 19.60.0 → 19.61.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "19.60.0",
+	"version": "19.61.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -55,13 +55,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5-sales-demo/xcsh-stats": "19.60.0",
-		"@f5-sales-demo/pi-agent-core": "19.60.0",
-		"@f5-sales-demo/pi-ai": "19.60.0",
-		"@f5-sales-demo/pi-natives": "19.60.0",
-		"@f5-sales-demo/pi-resource-management": "19.60.0",
-		"@f5-sales-demo/pi-tui": "19.60.0",
-		"@f5-sales-demo/pi-utils": "19.60.0",
+		"@f5-sales-demo/xcsh-stats": "19.61.0",
+		"@f5-sales-demo/pi-agent-core": "19.61.0",
+		"@f5-sales-demo/pi-ai": "19.61.0",
+		"@f5-sales-demo/pi-natives": "19.61.0",
+		"@f5-sales-demo/pi-resource-management": "19.61.0",
+		"@f5-sales-demo/pi-tui": "19.61.0",
+		"@f5-sales-demo/pi-utils": "19.61.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/cli/chrome-cli.ts

@@ -7,14 +7,30 @@
  */
 
 import * as fs from "node:fs";
+import { homedir } from "node:os";
 import * as path from "node:path";
 import { acquirePage, type BrowserProviderStatus, CdpBrowserProvider } from "../browser";
 import { PORT_RANGE_END, PORT_RANGE_START, resolveForcedPort } from "../browser/extension-bridge";
 import { installNativeHost } from "../services/native-host-install";
 
+/** Ask a running manager to step down (control-socket `shutdown` frame). Resolves
+ * true if a manager answered the socket, false if none was running. Best-effort. */
+async function requestManagerShutdown(reason: "updated"): Promise<boolean> {
+	const sock = process.env.XCSH_MANAGER_SOCK ?? path.join(homedir(), ".xcsh", "manager.sock");
+	try {
+		const c = await Bun.connect({ unix: sock, socket: { data() {} } });
+		c.write(`${JSON.stringify({ type: "shutdown", reason })}\n`);
+		await Bun.sleep(50);
+		c.end();
+		return true;
+	} catch {
+		return false; // no manager listening
+	}
+}
+
 type Settings = { get(key: string): unknown };
 
-export type ChromeAction = "status" | "relaunch" | "setup" | "install-host";
+export type ChromeAction = "status" | "relaunch" | "setup" | "install-host" | "recycle";
 
 export const EXTENSION_ID = "klajkjdoehjidngligegnpknogmjjhkc";
 
@@ -116,6 +132,18 @@ export async function runChromeCommand(action: ChromeAction, settings: Settings)
 		const manifestPath = installNativeHost({ launchCommand, extensionIds: [EXTENSION_ID] });
 		return `Native-messaging host manifest written to:\n  ${manifestPath}`;
 	}
+	if (action === "recycle") {
+		// Proactive post-upgrade recycle (#1874 Task 7): refresh the wrapper to the
+		// version-stable launcher, then ask any running (old) manager to step down so
+		// the new version takes effect NOW instead of on the next Chrome launch. The
+		// successor re-adopts live workers (zero-downtime). Both best-effort.
+		const launchCommand = nativeHostLaunchCommand();
+		installNativeHost({ launchCommand, extensionIds: [EXTENSION_ID] });
+		const stepped = await requestManagerShutdown("updated");
+		return stepped
+			? "Refreshed native-host wrapper; asked the running manager to recycle to this version."
+			: "Refreshed native-host wrapper; no manager was running (it will start fresh on next use).";
+	}
 	// relaunch: self-consented rung 3 — force allowRelaunch regardless of the setting.
 	const { mode } = await acquirePage({ settings, allowRelaunch: true });
 	return `Chrome ready (${mode}). Your real, logged-in session is now debuggable for xcsh.`;

package/src/cli/update-cli.ts

@@ -315,6 +315,10 @@ function updateViaBrew(targetPath: string, expectedVersion: string): void {
 	console.log(chalk.yellow(`To update to ${expectedVersion}, run:`));
 	console.log(chalk.cyan(`  brew upgrade ${APP_NAME}`));
 	console.log(chalk.dim("\nThis ensures the update goes through your organization's Homebrew tap."));
+	// #1874 Task 7: brew upgrade runs out-of-band, so we can't recycle automatically.
+	// Nudge the one command that applies it to the Chrome extension immediately.
+	console.log(chalk.dim(`Then run  ${APP_NAME} chrome recycle  to apply it to the extension now`));
+	console.log(chalk.dim("(otherwise it takes effect the next time you open Chrome)."));
 }
 
 /**
@@ -413,6 +417,18 @@ export async function runUpdateCommand(opts: { force: boolean; check: boolean })
 				await updateViaBinaryAt(target.path, release.version);
 				break;
 		}
+
+		// #1874 Task 7: the binary just changed under a possibly-running OLD manager.
+		// Proactively recycle so the new version takes effect now instead of on the
+		// next Chrome launch — refresh the native-host wrapper + step the old manager
+		// down (its successor re-adopts live workers, zero-downtime). The just-updated
+		// `xcsh` on PATH is the new version. Best-effort, non-blocking; passive
+		// supersede covers it if this is skipped.
+		try {
+			Bun.spawn(["xcsh", "chrome", "recycle"], { stdout: "ignore", stderr: "ignore" });
+		} catch {
+			/* recycle is a convenience — never fail an update on it */
+		}
 	} catch (err) {
 		console.error(chalk.red(`Update failed: ${err}`));
 		process.exit(1);

package/src/commands/chrome.ts

@@ -5,7 +5,7 @@ import { Args, Command } from "@f5-sales-demo/pi-utils/cli";
 import { type ChromeAction, runChromeCommand } from "../cli/chrome-cli";
 import { Settings, settings } from "../config/settings";
 
-const ACTIONS: ChromeAction[] = ["status", "relaunch", "setup", "install-host"];
+const ACTIONS: ChromeAction[] = ["status", "relaunch", "setup", "install-host", "recycle"];
 
 export default class Chrome extends Command {
 	static description = "Inspect or arrange the Chrome session xcsh drives for console automation";

package/src/commands/manager.ts

@@ -54,6 +54,66 @@ function isPortFree(port: number): boolean {
 	}
 }
 
+/** The PID listening on a loopback bridge port, or 0 if unknown (best-effort via
+ * lsof). Used only to give a re-adopted worker a reapable pid; 0 means "manage by
+ * socket liveness, never signal" (see killPid's pid<=0 guard). */
+function pidListeningOn(port: number): number {
+	try {
+		const out = Bun.spawnSync(["lsof", "-t", `-iTCP:${port}`, "-sTCP:LISTEN"])
+			.stdout.toString()
+			.trim()
+			.split("\n")[0];
+		const pid = Number(out);
+		return Number.isInteger(pid) && pid > 0 ? pid : 0;
+	} catch {
+		return 0; // lsof unavailable — leave unknown
+	}
+}
+
+/** Complete the extension `hello` handshake against a bridge port (with the
+ * origin header the bridge requires), resolving the `hello_ack` frame or null.
+ * EXTENSION_ID is lazy-required so it stays off the manager's cold-start path. */
+function bridgeHello(port: number, timeoutMs = 400): Promise<Record<string, unknown> | null> {
+	return new Promise(resolve => {
+		let done = false;
+		const finish = (v: Record<string, unknown> | null) => {
+			if (done) return;
+			done = true;
+			resolve(v);
+		};
+		let ws: WebSocket;
+		try {
+			const { EXTENSION_ID } = require("../cli/chrome-cli");
+			ws = new WebSocket(`ws://127.0.0.1:${port}`, {
+				headers: { Origin: `chrome-extension://${EXTENSION_ID}` },
+			} as unknown as string[]);
+		} catch {
+			return finish(null);
+		}
+		const close = () => {
+			try {
+				ws.close();
+			} catch {
+				/* already closing */
+			}
+		};
+		ws.onopen = () => ws.send(JSON.stringify({ type: "hello" }));
+		ws.onmessage = e => {
+			try {
+				finish(JSON.parse(String(e.data)) as Record<string, unknown>);
+			} catch {
+				finish(null);
+			}
+			close();
+		};
+		ws.onerror = () => finish(null);
+		setTimeout(() => {
+			close();
+			finish(null);
+		}, timeoutMs);
+	});
+}
+
 /**
  * The argv (AFTER `process.execPath`) to re-run THIS binary in `mode`.
  *
@@ -195,6 +255,34 @@ export default class Manager extends Command {
 			for (let i = 0; i < n; i++) spawnSpare();
 		};
 
+		/** Zero-downtime handoff (#1874 Task 6): on startup, discover bridge workers a
+		 * PRIOR (superseded) manager left running and re-register them, so a tab's
+		 * session survives the manager swap. Probes the whole range in parallel; a
+		 * bridge answering with a real per-tab sessionId (not the "spare" sentinel) and
+		 * a tenant+env is re-adopted. Spares/unknowns are ignored (the pool refills
+		 * them). Best-effort — never throws. */
+		const readoptWorkers = async (): Promise<void> => {
+			const found = await Promise.all(range.map(async port => ({ port, ack: await bridgeHello(port) })));
+			for (const { port, ack } of found) {
+				if (!ack) continue;
+				const sid = ack.sessionId;
+				const tenant = ack.tenant;
+				const env = ack.env;
+				if (typeof sid !== "string" || sid === "spare" || typeof tenant !== "string" || typeof env !== "string") {
+					continue; // spare sentinel or tenant-less bridge — not a re-adoptable session
+				}
+				if (reg.has(sid)) continue;
+				reg.set(sid, {
+					sessionId: sid,
+					tenant: `${tenant}|${env}`,
+					port,
+					pid: pidListeningOn(port),
+					lastSeen: Date.now(),
+				});
+				console.error(`[xcsh manager] re-adopted worker ${sid} (${tenant}|${env}) on port ${port}`);
+			}
+		};
+
 		/** Adopt a warm spare for a provision (bind over IPC). Returns false if none available. */
 		const adoptSpare = (msg: { sessionId: string; tenant: string }): boolean => {
 			const rec = pool.shift();
@@ -219,18 +307,8 @@ export default class Manager extends Command {
 			return true;
 		};
 
-		const reap = (sessionId: string): void => {
-			const w = reg.get(sessionId);
-			if (!w) return;
-			try {
-				process.kill(w.pid);
-			} catch {
-				/* already gone */
-			}
-			reg.delete(sessionId);
-		};
-
 		const killPid = (pid: number): void => {
+			if (pid <= 0) return; // 0/negative = unknown (re-adopted worker) — NEVER signal (kill(0) hits the group)
 			try {
 				process.kill(pid); // SIGTERM — spares exit at once; bound workers self-drain (worker.ts)
 			} catch {
@@ -238,21 +316,35 @@ export default class Manager extends Command {
 			}
 		};
 
+		const reap = (sessionId: string): void => {
+			const w = reg.get(sessionId);
+			if (!w) return;
+			killPid(w.pid);
+			reg.delete(sessionId);
+		};
+
 		/** Graceful teardown (#1874): stop accepting, terminate the (session-less)
-		 * spare pool at once, SIGTERM bound workers so they drain their in-flight turn,
-		 * drop the socket + liveness record, and exit. Idempotent. Bounded by each
-		 * worker's own drain ceiling — the manager frees the socket immediately so a
-		 * successor can bind without waiting on drains. */
+		 * spare pool at once, drop the socket + liveness record, and exit. Idempotent.
+		 *
+		 * Bound workers depend on the reason: on a HANDOFF (superseded/updated — a
+		 * successor manager is about to bind and re-adopt them), we LEAVE them running
+		 * so tab sessions survive the swap (zero-downtime, Task 6). Otherwise (manual
+		 * operator SIGTERM — no successor) we SIGTERM them so they drain + exit rather
+		 * than leak. The manager frees the socket immediately either way. */
 		const gracefulShutdown = (reason: string): void => {
 			if (shuttingDown) return;
 			shuttingDown = true;
 			accepting = false;
+			const handoff = reason === "superseded" || reason === "updated";
 			console.error(
-				`[xcsh manager] graceful shutdown (${reason}); reaping ${pool.length} spare(s) + ${reg.size} worker(s)`,
+				`[xcsh manager] graceful shutdown (${reason}); reaping ${pool.length} spare(s)` +
+					(handoff ? `, leaving ${reg.size} worker(s) for re-adoption` : ` + ${reg.size} worker(s)`),
 			);
 			for (const s of pool.splice(0)) killPid(s.pid);
-			for (const w of reg.values()) killPid(w.pid);
-			reg.clear();
+			if (!handoff) {
+				for (const w of reg.values()) killPid(w.pid);
+				reg.clear();
+			}
 			removeManagerState(sockPath);
 			try {
 				fs.rmSync(sockPath, { force: true });
@@ -409,6 +501,11 @@ export default class Manager extends Command {
 		process.on("SIGTERM", () => gracefulShutdown("manual"));
 		process.on("SIGINT", () => gracefulShutdown("manual"));
 
+		// Zero-downtime handoff: re-adopt any bound workers a superseded manager left
+		// running BEFORE filling the pool (so their ports aren't mistaken for free).
+		// Awaited but bounded (~parallel 400ms); the socket already accepts connections.
+		await readoptWorkers();
+
 		// Pre-warm the spare pool so provisions can adopt instead of cold-spawn.
 		if (poolTarget > 0) maintainPool();
 

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "19.60.0",
-	"commit": "37266bce39f1c2714a947ebfcbd9dbae46b312a0",
-	"shortCommit": "37266bc",
+	"version": "19.61.0",
+	"commit": "54faf1b4029f7a7a4251c5cc6776c789b3e1af5c",
+	"shortCommit": "54faf1b",
 	"branch": "main",
-	"tag": "v19.60.0",
-	"commitDate": "2026-07-05T19:32:50Z",
-	"buildDate": "2026-07-05T20:00:48.862Z",
+	"tag": "v19.61.0",
+	"commitDate": "2026-07-05T20:10:34Z",
+	"buildDate": "2026-07-05T20:32:34.362Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/37266bce39f1c2714a947ebfcbd9dbae46b312a0",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v19.60.0"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/54faf1b4029f7a7a4251c5cc6776c789b3e1af5c",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v19.61.0"
 };