@f5-sales-demo/xcsh 19.56.0 → 19.56.2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "19.56.0",
+	"version": "19.56.2",
 	"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.56.0",
-		"@f5-sales-demo/pi-agent-core": "19.56.0",
-		"@f5-sales-demo/pi-ai": "19.56.0",
-		"@f5-sales-demo/pi-natives": "19.56.0",
-		"@f5-sales-demo/pi-resource-management": "19.56.0",
-		"@f5-sales-demo/pi-tui": "19.56.0",
-		"@f5-sales-demo/pi-utils": "19.56.0",
+		"@f5-sales-demo/xcsh-stats": "19.56.2",
+		"@f5-sales-demo/pi-agent-core": "19.56.2",
+		"@f5-sales-demo/pi-ai": "19.56.2",
+		"@f5-sales-demo/pi-natives": "19.56.2",
+		"@f5-sales-demo/pi-resource-management": "19.56.2",
+		"@f5-sales-demo/pi-tui": "19.56.2",
+		"@f5-sales-demo/pi-utils": "19.56.2",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/scripts/worker-tools-harness.ts

@@ -0,0 +1,151 @@
+// Headless worker-tool harness — no Chrome, no F5 login.
+//
+// Spawns a real `xcsh worker`, connects a MOCK extension bridge client (exactly
+// the hello handshake + origin the real service worker uses), sends a chat_request
+// asking it to navigate, and observes:
+//   (a) which tools the worker's agent actually has (from the daily log), and
+//   (b) whether the agent emits a `navigate` tool_request over the bridge.
+//
+// This isolates the "agent responds but never drives" bug to the WORKER's tool
+// registration, deterministically and repeatably.
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// XCSH_DEV=1 → run the local source build (`bun src/cli.ts worker`) so source
+// edits are testable; otherwise the installed Homebrew binary.
+const XCSH_REPO = new URL("..", import.meta.url).pathname; // packages/coding-agent
+const DEV = process.env.XCSH_DEV === "1";
+const SPAWN_CMD = DEV ? ["bun", "src/cli.ts", "worker"] : ["/opt/homebrew/bin/xcsh", "worker"];
+const SPAWN_CWD = DEV ? XCSH_REPO : process.cwd();
+const EXT_ID = "klajkjdoehjidngligegnpknogmjjhkc";
+const ORIGIN = `chrome-extension://${EXT_ID}`; // bridge origin check: exact, no trailing slash
+const PORT = 19260; // away from the real backend range (19222-19241)
+const TENANT = process.env.HARNESS_TENANT ?? "f5-sales-demo|production";
+const PROMPT = process.env.HARNESS_PROMPT ?? "Navigate the browser to the origin pools list.";
+
+function log(...a: unknown[]) {
+	console.log("[harness]", ...a);
+}
+
+// 1) Spawn the worker with a forced bridge port + tenant identity.
+const worker = Bun.spawn(SPAWN_CMD, {
+	cwd: SPAWN_CWD,
+	env: {
+		...process.env,
+		XCSH_BRIDGE_PORT: String(PORT),
+		XCSH_SESSION_ID: "tab-9999",
+		XCSH_SESSION_TENANT: TENANT,
+	},
+	stdout: "pipe",
+	stderr: "pipe",
+});
+log(`spawned worker pid=${worker.pid} (${DEV ? "DEV build" : "homebrew"}), port=${PORT}, tenant=${TENANT}`);
+
+// Stream worker stderr; resolve when the bridge is listening.
+let bridgeUp = false;
+const decoder = new TextDecoder();
+(async () => {
+	for await (const chunk of worker.stderr) {
+		const s = decoder.decode(chunk);
+		for (const line of s.split("\n")) {
+			if (line.trim()) log("worker⟩", line.trim());
+			if (line.includes("extension bridge listening")) bridgeUp = true;
+		}
+	}
+})();
+
+// Wait for the bridge, then give the (heavier) agent session time to init + attach
+// the chat handler (chatHandler.attach() runs AFTER createAgentSession).
+for (let i = 0; i < 120 && !bridgeUp; i++) await Bun.sleep(250);
+if (!bridgeUp) {
+	log("FAIL: bridge never came up");
+	worker.kill();
+	process.exit(1);
+}
+log("bridge up; waiting 12s for agent session init…");
+await Bun.sleep(12_000);
+
+// 2) Connect the mock extension client with the correct Origin.
+const toolRequests: string[] = [];
+let chatText = "";
+let chatErr: string | null = null;
+let done = false;
+
+const ws = new WebSocket(`ws://127.0.0.1:${PORT}`, { headers: { Origin: ORIGIN } } as unknown as string[]);
+ws.onopen = () => {
+	log("client connected; sending hello");
+	ws.send(JSON.stringify({ type: "hello", contractVersion: "1.5.0", extensionId: "harness" }));
+};
+ws.onerror = () => log("client ws error (origin rejected?)");
+ws.onmessage = e => {
+	let m: Record<string, unknown>;
+	try {
+		m = JSON.parse(e.data as string);
+	} catch {
+		return;
+	}
+	switch (m.type) {
+		case "hello_ack":
+			log(`hello_ack: tenant=${m.tenant} sessionId=${m.sessionId} contractVersion=${m.contractVersion}`);
+			log(`sending chat_request: "${PROMPT}"`);
+			ws.send(
+				JSON.stringify({
+					type: "chat_request",
+					id: "c-harness-1",
+					text: PROMPT,
+					context: null,
+					mode: "configuration",
+				}),
+			);
+			break;
+		case "tool_request":
+			log(`◆ TOOL_REQUEST from agent: tool="${m.tool}" id=${m.id}`);
+			toolRequests.push(m.tool as string);
+			// Reply so the agent's turn can proceed.
+			ws.send(JSON.stringify({ type: "tool_result", id: m.id, content: "ok (harness stub)", is_error: false }));
+			break;
+		case "chat_delta":
+			chatText += (m.delta as string) ?? "";
+			break;
+		case "chat_done":
+			done = true;
+			break;
+		case "chat_error":
+			chatErr = (m.error as string) ?? "unknown";
+			done = true;
+			break;
+	}
+};
+
+// 3) Wait for the turn to finish (or time out).
+for (let i = 0; i < 240 && !done; i++) await Bun.sleep(250);
+
+// 4) Read the worker's actual tool set from the daily log.
+let activeTools = "(not found in daily log)";
+try {
+	const logPath = join(homedir(), ".xcsh", "logs", `xcsh.${new Date().toISOString().slice(0, 10)}.log`);
+	const text = await Bun.file(logPath).text();
+	const lines = text.split("\n").filter(l => l.includes(`"pid":${worker.pid}`) && l.includes("activeToolNames"));
+	if (lines.length) {
+		const parsed = JSON.parse(lines[lines.length - 1]);
+		activeTools = JSON.stringify(parsed.activeToolNames);
+	}
+} catch {}
+
+console.log("\n==================== RESULT ====================");
+console.log("agent tool_requests emitted :", toolRequests.length ? toolRequests.join(", ") : "(none)");
+console.log("worker activeToolNames       :", activeTools);
+console.log("has navigate tool?           :", activeTools.includes('"navigate"') ? "YES" : "NO");
+console.log("emitted a navigate?          :", toolRequests.includes("navigate") ? "YES" : "NO");
+console.log("chat error                   :", chatErr ?? "(none)");
+console.log("agent said (first 240 chars) :", chatText.slice(0, 240).replace(/\n/g, " "));
+if (toolRequests.includes("navigate")) console.log("\n[PASS] worker agent HAS + CALLS navigate — tool registration OK");
+else console.log("\n[FAIL] worker never called navigate — browser tools missing from the agent");
+console.log("===============================================");
+
+try {
+	ws.close();
+} catch {}
+worker.kill();
+await Bun.sleep(300);
+process.exit(0);

package/src/browser/extension-bridge-tools.ts

@@ -0,0 +1,71 @@
+/**
+ * Agent tools for the Chrome extension's browser actions.
+ *
+ * The extension advertises a fixed set of tools (EXTENSION_CAPABILITIES.tools:
+ * navigate, click, read_ax, type_text, …). Before this factory, those names were
+ * requested by the worker (BROWSER_TOOL_NAMES) but never registered as agent
+ * tools — so the agent could only run the form-driven `catalog_workflow_runner`
+ * and had no way to `navigate`/`click`, i.e. it replied "Navigating…" and never
+ * drove the browser. This turns each advertised tool into a `CustomTool` whose
+ * `execute` proxies the call to the connected extension over the bridge.
+ */
+import type { AgentToolResult, AgentToolUpdateCallback } from "@f5-sales-demo/pi-agent-core";
+import type { TSchema } from "@sinclair/typebox";
+import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
+import { EXTENSION_CAPABILITIES, type ExtensionToolDef } from "./capabilities.generated";
+import type { BridgeServer } from "./extension-bridge";
+
+/**
+ * Extension tools that are transport/diagnostic plumbing, not agent actions —
+ * never exposed to the LLM. Everything else in EXTENSION_CAPABILITIES becomes a
+ * callable agent tool.
+ */
+const INTERNAL_TOOLS = new Set<string>([
+	"ping",
+	"capabilities",
+	"reload",
+	"debug_exec",
+	"detach",
+	"set_bridge_port",
+	"diag_suspension",
+	"diag_bridges",
+]);
+
+/** Build a CustomTool that proxies one extension tool to `bridge.request`. */
+function bridgeTool(bridge: BridgeServer, def: ExtensionToolDef): CustomTool<TSchema, unknown> {
+	return {
+		name: def.name,
+		label: def.name,
+		description: def.summary,
+		// The extension's JSON-Schema `params` is a TypeBox-compatible schema object.
+		parameters: (def.params ?? { type: "object", properties: {} }) as unknown as TSchema,
+		async execute(
+			_toolCallId: string,
+			params: unknown,
+			_onUpdate: AgentToolUpdateCallback<unknown, TSchema> | undefined,
+			_ctx: CustomToolContext,
+			_signal?: AbortSignal,
+		): Promise<AgentToolResult<unknown, TSchema>> {
+			const res = await bridge.request(def.name, (params ?? {}) as Record<string, unknown>);
+			const raw = typeof res.content === "string" ? res.content : JSON.stringify(res.content);
+			// AgentToolResult has no isError flag — surface the extension's error in the
+			// text so the model sees the failure and can react.
+			const text = res.is_error ? `Error: ${raw}` : raw;
+			return { content: [{ type: "text" as const, text }] };
+		},
+	};
+}
+
+/**
+ * Every agent-facing extension tool as a bridge-proxying CustomTool. Pass the
+ * result to `createAgentSession({ customTools })` so the worker's agent can drive
+ * the browser. Requires `bridge` (the worker's live extension-bridge server).
+ */
+export function createExtensionBridgeTools(bridge: BridgeServer): CustomTool<TSchema, unknown>[] {
+	return EXTENSION_CAPABILITIES.tools.filter(def => !INTERNAL_TOOLS.has(def.name)).map(def => bridgeTool(bridge, def));
+}
+
+/** Names of the agent-facing extension tools (for tool-scoping / tests). */
+export const EXTENSION_AGENT_TOOL_NAMES: readonly string[] = EXTENSION_CAPABILITIES.tools
+	.filter(def => !INTERNAL_TOOLS.has(def.name))
+	.map(def => def.name);

package/src/commands/manager.ts

@@ -76,6 +76,50 @@ export function workerArgv(): string[] {
 	return reexecArgv("worker");
 }
 
+/**
+ * Acquire the manager control socket, robust across Bun runtimes.
+ *
+ * The single-manager invariant needs three things at once: (1) never clobber a
+ * LIVE manager's socket, (2) reclaim a STALE socket left by a crashed/killed
+ * manager, and (3) survive a concurrent cold-start race. Bun's unix `listen` is
+ * NOT a reliable oracle here — dev `bun run` silently unlinks-and-rebinds a
+ * stale socket, while the COMPILED binary throws EADDRINUSE (xcsh #1846), which
+ * previously crashed the manager and silently killed all automation. So we drive
+ * it explicitly:
+ *
+ *   1. Probe for a live owner. If one answers → we lost; bail ("already-live").
+ *   2. Try to listen. If it binds → done ("bound").
+ *   3. On EADDRINUSE, RE-PROBE: a live answer now means a rival bound between
+ *      our probe and our listen → bail WITHOUT touching its socket. Otherwise
+ *      the file is confirmed stale → unlink it and retry listen once. A still-
+ *      failing retry (or any non-EADDRINUSE error) propagates loudly.
+ *
+ * Effects are injected so the branch logic is unit-tested deterministically
+ * (the compiled-only EADDRINUSE path is unreachable from a dev test otherwise).
+ */
+export async function acquireControlSocket(opts: {
+	sockPath: string;
+	probeLive: (sockPath: string) => Promise<boolean>;
+	listen: () => void;
+	unlink: (sockPath: string) => void;
+	isAddrInUse: (err: unknown) => boolean;
+}): Promise<"bound" | "already-live"> {
+	const { sockPath, probeLive, listen, unlink, isAddrInUse } = opts;
+	if (await probeLive(sockPath)) return "already-live";
+	try {
+		listen();
+		return "bound";
+	} catch (err) {
+		if (!isAddrInUse(err)) throw err;
+		// Bind collided. Distinguish a live rival (lost a cold-start race) from a
+		// stale file left by a crashed manager.
+		if (await probeLive(sockPath)) return "already-live";
+		unlink(sockPath); // confirmed stale → reclaim it
+		listen(); // retry once; a real failure now propagates
+		return "bound";
+	}
+}
+
 export default class Manager extends Command {
 	static description = "Run the detached control server that spawns/reaps per-tab workers; blocks forever";
 
@@ -180,39 +224,35 @@ export default class Manager extends Command {
 			},
 		};
 
-		// Single-manager invariant — probe liveness BEFORE binding.
-		//
-		// Two chrome-hosts can cold-start concurrently, both find no socket, and
-		// both spawn a manager. `Bun.listen({unix})` SILENTLY unlinks and rebinds
-		// any existing socket path — it does NOT throw EADDRINUSE even when a live
-		// manager is accepting on it (verified on Bun 1.3.x, in- and cross-process).
-		// So a naive `listen` would clobber the first manager's socket, leaving it
-		// orphaned on an unlinked path (blocking forever, leaking its worker ports)
-		// while a second live manager takes over — breaking "at most one manager".
-		//
-		// Guard by CONNECTING first: if a live manager answers, this process lost
-		// the race and exits WITHOUT touching the socket file (it belongs to the
-		// live manager). If nothing answers, the path is free or a STALE file from
-		// a crashed manager — either way `Bun.listen` safely (re)binds it (its own
-		// unlink-and-rebind reclaims the stale file; no explicit rm needed).
-		let liveOwner = false;
-		try {
-			const probe = await Promise.race([
-				Bun.connect({ unix: sockPath, socket: { data() {} } }),
-				new Promise<never>((_, reject) =>
-					setTimeout(() => reject(new Error("manager liveness probe timeout")), 500),
-				),
-			]);
-			liveOwner = true;
-			probe.end();
-		} catch {
-			/* nothing accepting → free path, or a stale socket file from a crashed manager */
-		}
-		if (liveOwner) {
+		// Single-manager invariant + stale-socket reclamation. A live manager is
+		// never clobbered (we probe first and again on collision); a stale socket
+		// from a crashed/killed manager is reclaimed rather than crashing on
+		// EADDRINUSE. See acquireControlSocket for the full rationale (xcsh #1846).
+		const probeLive = async (p: string): Promise<boolean> => {
+			try {
+				const probe = await Promise.race([
+					Bun.connect({ unix: p, socket: { data() {} } }),
+					new Promise<never>((_, reject) =>
+						setTimeout(() => reject(new Error("manager liveness probe timeout")), 500),
+					),
+				]);
+				probe.end();
+				return true;
+			} catch {
+				return false; // nothing accepting → free path, or a stale socket file
+			}
+		};
+		const outcome = await acquireControlSocket({
+			sockPath,
+			probeLive,
+			listen: () => Bun.listen(socketConfig),
+			unlink: p => fs.rmSync(p, { force: true }),
+			isAddrInUse: err => (err as { code?: string } | null)?.code === "EADDRINUSE",
+		});
+		if (outcome === "already-live") {
 			console.error(`[xcsh manager] another manager already live at ${sockPath}; exiting`);
 			process.exit(0);
 		}
-		Bun.listen(socketConfig);
 		console.error(`[xcsh manager] control socket listening at ${sockPath}`);
 
 		// Idle sweep: reap workers untouched for longer than the TTL.

package/src/commands/worker.ts

@@ -17,6 +17,7 @@ import { getProjectDir, getXCSHConfigDir } from "@f5-sales-demo/pi-utils";
 import { Command } from "@f5-sales-demo/pi-utils/cli";
 import { ChatHandler } from "../browser/chat-handler";
 import { startBridgeServer } from "../browser/extension-bridge";
+import { createExtensionBridgeTools, EXTENSION_AGENT_TOOL_NAMES } from "../browser/extension-bridge-tools";
 import { setSharedBridgeServer } from "../browser/provider";
 import { initializeWithSettings } from "../discovery";
 import { createAgentSession } from "../sdk";
@@ -118,10 +119,16 @@ export default class Worker extends Command {
 		bridge.setSessionInfo(sessionInfoForWorker);
 		ContextService.onContextChange(() => bridge.broadcastTenantChanged());
 
+		// The extension's browser actions (navigate/click/read_ax/…) are not builtin
+		// tools — turn each into a bridge-proxying CustomTool so the agent can drive
+		// the browser (without this the agent only has catalog_workflow_runner and
+		// merely narrates "Navigating…"). Include their names in the tool scope.
+		const extensionTools = createExtensionBridgeTools(bridge);
 		const { session } = await createAgentSession({
 			cwd,
 			hasUI: false,
-			toolNames: BROWSER_TOOL_NAMES,
+			toolNames: [...new Set([...BROWSER_TOOL_NAMES, ...EXTENSION_AGENT_TOOL_NAMES])],
+			customTools: extensionTools,
 			// Headless worker: no MCP discovery, no LSP warmup, no extension discovery —
 			// keep startup lean and free of network calls / blocking prompts.
 			enableMCP: false,

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

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "19.56.0",
-	"commit": "34e6ed88ab9aea762a9819b7ad53dfa6b7807f9a",
-	"shortCommit": "34e6ed8",
+	"version": "19.56.2",
+	"commit": "864f91ecbd26a814dda896b5c402a0a30494e942",
+	"shortCommit": "864f91e",
 	"branch": "main",
-	"tag": "v19.56.0",
-	"commitDate": "2026-07-03T13:11:30Z",
-	"buildDate": "2026-07-03T13:33:05.007Z",
+	"tag": "v19.56.2",
+	"commitDate": "2026-07-04T00:19:20Z",
+	"buildDate": "2026-07-04T00:42:34.771Z",
 	"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/34e6ed88ab9aea762a9819b7ad53dfa6b7807f9a",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v19.56.0"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/864f91ecbd26a814dda896b5c402a0a30494e942",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v19.56.2"
 };