@agentmuxer/setup 0.1.1 → 0.1.2

package/README.md

@@ -14,15 +14,66 @@ automatic detection is unavailable. Repeat `--client` to select more than one.
 
 The installer registers `https://mcp.agentmuxer.com/mcp` in each selected client's global MCP
 configuration and maintains one marked instruction block in its global guidance file. Existing
-instructions are preserved. Repeat installation updates the block. Removal deletes only the standard
-AgentMuxer endpoint and marked block; a nonstandard or different MCP using the same name is reported
+instructions are preserved. Repeat installation updates the block. Removal deletes the marked block and standard
+AgentMuxer endpoint for Codex and Claude Code. OpenCode is disabled with its native `enabled: false`
+setting so its OAuth registration survives alongside its retained credentials; reinstall re-enables it. A nonstandard or different MCP using the same name is reported
 as a conflict and left untouched. The guidance requires a free catalog search before external tooling, then leaves
 the native-versus-specialized choice to fit, simplicity, and cost. Search never requires invocation.
 
-After installation, run the sign-in command printed for your client — every AgentMuxer call
-requires it; unauthenticated requests answer a standard 401 challenge that starts the host
-OAuth flow. Status verifies the MCP configuration and guidance only; OAuth state remains
-client-owned and is not inspected.
+The standard install command requests `offline_access` for Claude Code and OpenCode so WorkOS can
+issue refresh tokens. Reinstall upgrades the previous managed URL-only configuration, preserves
+comments and unrelated settings, and leaves custom OAuth configurations untouched. Existing grants
+issued without refresh tokens need one new sign-in after the scope upgrade. Codex retains its native
+OAuth configuration; this change does not fix refresh persistence bugs in older Codex versions.
+
+On first installation, setup starts each client's native browser sign-in sequentially. The native
+client owns consent, credential storage, and refresh. Setup runs these commands outside the current
+project so project-specific MCP configurations do not override the global installation. OpenCode
+configuration override environment variables are excluded from these native setup commands; an
+OpenCode session launched with those overrides can still use different configuration.
+Repeat installation preserves existing credentials. Status reports the client's own sign-in status:
+Claude Code checks the connection; Codex and OpenCode report stored credentials, which does not prove
+that a live MCP request will succeed. OpenCode's `expired` status means its stored access token
+has expired; setup preserves the credentials so OpenCode can attempt refresh on its next connection.
+Restart open clients to load the configuration.
+
+New OpenCode installations first check native status using a fixed in-memory configuration through
+OpenCode's native `OPENCODE_CONFIG_CONTENT` support, before writing the AgentMuxer entry.
+Retained credentials preserve that registration; only a signed-out new connection configures its
+native `oauth.clientId` with `client_01M1TJJ3DKJR89RPXJ5XVWSKMH`, AgentMuxer's pre-registered public
+WorkOS OAuth application for OpenCode. It uses PKCE without a client secret. OpenCode handles
+browser consent, credential storage and refresh. The fixed ID survives explicit re-login and
+represents the AgentMuxer OpenCode integration, not a device.
+Setup may retry sign-in for this configuration when OpenCode reports that it is signed out.
+
+Existing OpenCode DCR configurations keep their original registration and tokens. Setup adds the
+refresh scope without switching their client ID. Explicit DCR re-login in OpenCode 1.18.29 can create
+a new ID and therefore a new AgentMuxer principal. No automatic migration or principal relinking is
+performed. Keep the disabled OpenCode entry when removing setup: manually deleting its configured
+client ID while retaining tokens can require a new sign-in. Codex and Claude retained their CIMD IDs in the tested re-login paths, but setup does not
+infer the registration type from their credential-presence status.
+
+An unavailable status or network failure never triggers sign-in. Setup waits for native status
+before writing the AgentMuxer entry, so a failed preflight cannot leave a scope-only registration. For existing connections without
+the configured stable ID, setup prints the native reconnect command. An interrupted first sign-in
+leaves configuration saved. No API-key fallback, local token store, OAuth broker, or Blueprint
+integration is added. Owner/client principal bindings and spending restrictions remain unchanged.
+
+The acceptance criterion is silent refresh/restart during healthy operation while authorization
+remains valid. The recorded six-build matrix passed 78 ordinary forced-refresh/restart cycles.
+Credential loss beyond an issuer's replay window is an accepted limitation. Older Codex builds also
+have a reproduced persistence defect when a successful refresh is followed by an MCP 503; this is a
+known client limitation, not something setup repairs. WorkOS Connect's idle and absolute grant
+lifetimes remain unverified; do not promise that users will never need to sign in again. Full
+production idle behavior and desktop onboarding are not certified by setup's packed smoke test.
+
+The public WorkOS application must retain its client ID, PKCE requirement, and native redirect URI
+`http://127.0.0.1:19876/mcp/oauth/callback`. OpenCode 1.18.29 passed native login and a live MCP request
+against production with this application, followed by two refresh/restart cycles after actual
+300-second access-token expiration without another login or browser. The built setup CLI also
+passed remove/reinstall and reconnection without sign-in; explicit native re-login and reconnection
+passed separately. These checks do not establish long-idle behavior or desktop onboarding.
+No AgentMuxer-hosted client metadata route is required.
 
 Release maintainers must run `vp run @agentmuxer/setup#release:smoke` and publish the exact tested
 tarball it writes to `.context/release`, never publish this directory with npm.

package/dist/bin.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
-import { isDeepStrictEqual, parseArgs } from "node:util";
-import { existsSync } from "node:fs";
-import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { isDeepStrictEqual, parseArgs, promisify, stripVTControlCharacters } from "node:util";
+import { execFile, spawn } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { agents, detectGlobalAgents, listInstalledServers, removeServer, upsertServer } from "add-mcp";
-import { parse } from "jsonc-parser";
+import { existsSync } from "node:fs";
+import { agents, detectGlobalAgents, listInstalledServers, removeServer } from "add-mcp";
+import { applyEdits, modify, parse } from "jsonc-parser";
 import { parseTOML } from "toml-eslint-parser";
 //#region src/management.ts
 const agentmuxerServerName = "agentmuxer";
 const agentmuxerMcpUrl = "https://mcp.agentmuxer.com/mcp";
+const openCodeClientId = "client_01M1TJJ3DKJR89RPXJ5XVWSKMH";
 const agentmuxerConfig = {
 	type: "http",
 	url: agentmuxerMcpUrl
@@ -223,15 +226,47 @@ const agentmuxerServer = async (client) => {
 	};
 };
 const conflictError = (client) => `${clientLabel(client)} already has an ${agentmuxerServerName} configuration that setup cannot safely manage; leave it unchanged or remove it manually`;
+const nativeServerConfig = (client) => {
+	const config = agents[client].transformConfig(agentmuxerServerName, agentmuxerConfig);
+	if (typeof config !== "object" || config === null || Array.isArray(config)) throw new Error("Invalid client configuration transform");
+	const base = Object.fromEntries(Object.entries(config).filter(([, value]) => value !== void 0));
+	return client === "codex" ? base : {
+		...base,
+		oauth: client === "claude-code" ? { scopes: "offline_access" } : {
+			clientId: openCodeClientId,
+			scope: "offline_access"
+		}
+	};
+};
 const isManagedServer = (client, server) => {
 	const transformed = agents[client].transformConfig(agentmuxerServerName, agentmuxerConfig);
 	if (typeof transformed !== "object" || transformed === null || Array.isArray(transformed)) return false;
 	const expected = Object.fromEntries(Object.entries(transformed).filter(([, value]) => value !== void 0));
-	return isDeepStrictEqual(server.config, expected) || client === "codex" && isDeepStrictEqual(server.config, { url: "https://mcp.agentmuxer.com/mcp" });
+	const config = client === "opencode" && server.config["enabled"] === false ? {
+		...server.config,
+		enabled: true
+	} : server.config;
+	return isDeepStrictEqual(config, expected) || isDeepStrictEqual(config, nativeServerConfig(client)) || client === "opencode" && isDeepStrictEqual(config, {
+		...nativeServerConfig(client),
+		oauth: { scope: "offline_access" }
+	}) || client === "codex" && isDeepStrictEqual(config, { url: "https://mcp.agentmuxer.com/mcp" });
 };
 const isManagedServerAtPath = async (client, server, path) => isManagedServer(client, server) && (client !== "codex" || await readCodexLayout(path) !== void 0);
 const uninspectableConfigError = (client) => `${clientLabel(client)} configuration exists but the client was not detected; refusing to modify it`;
-const installAgentmuxer = async (client) => {
+const writeNativeServerConfig = async (client, path, config) => {
+	const original = await readOptionalFile(path) ?? "{}";
+	const next = applyEdits(original, modify(original, [client === "claude-code" ? "mcpServers" : "mcp", agentmuxerServerName], config, { formattingOptions: {
+		insertSpaces: true,
+		tabSize: 2,
+		eol: original.includes("\r\n") ? "\r\n" : "\n"
+	} }));
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, next, {
+		encoding: "utf8",
+		mode: 384
+	});
+};
+const installAgentmuxer = async (client, newOpenCodeRegistration = false) => {
 	const existing = await agentmuxerServer(client);
 	if (!existing.detected && existsSync(existing.configPath)) return {
 		success: false,
@@ -243,26 +278,37 @@ const installAgentmuxer = async (client) => {
 		path: existing.configPath,
 		error: conflictError(client)
 	};
-	if (existing.server !== void 0) return {
+	if (existing.server !== void 0 && (client === "codex" || isDeepStrictEqual(existing.server.config, nativeServerConfig(client)))) return {
 		success: true,
-		path: existing.configPath
+		path: existing.configPath,
+		stableClientId: client === "opencode"
 	};
 	if (client === "codex") {
 		await installCodexServer(existing.configPath);
 		return {
 			success: true,
-			path: existing.configPath
+			path: existing.configPath,
+			created: true
 		};
 	}
-	const configExisted = existsSync(existing.configPath);
-	const result = upsertServer(client, agentmuxerServerName, agentmuxerConfig);
-	if (result.success && client === "claude-code" && !configExisted) try {
-		await chmod(result.path, 384);
-	} catch (error) {
-		await rm(result.path, { force: true });
-		throw error;
-	}
-	return result;
+	const config = client === "opencode" && !(existing.server === void 0 && newOpenCodeRegistration) && !isDeepStrictEqual({
+		...existing.server?.config,
+		enabled: true
+	}, nativeServerConfig(client)) ? {
+		...nativeServerConfig(client),
+		oauth: { scope: "offline_access" }
+	} : nativeServerConfig(client);
+	if (existing.server !== void 0 && isDeepStrictEqual(existing.server.config, config)) return {
+		success: true,
+		path: existing.configPath
+	};
+	await writeNativeServerConfig(client, existing.configPath, config);
+	return {
+		success: true,
+		path: existing.configPath,
+		created: existing.server === void 0,
+		stableClientId: client === "opencode" && isDeepStrictEqual(config, nativeServerConfig(client))
+	};
 };
 const listAgentmuxerInstallations = async (clients = supportedClients) => {
 	configureClientPaths();
@@ -271,7 +317,7 @@ const listAgentmuxerInstallations = async (clients = supportedClients) => {
 		agents: [...clients]
 	});
 	await Promise.all(installations.flatMap(({ agentType, configPath }) => isSupportedClient(agentType) ? [validateConfigSyntax(agentType, configPath)] : []));
-	return (await Promise.all(installations.flatMap(({ agentType, displayName, servers }) => isSupportedClient(agentType) ? servers.filter(({ serverName }) => serverName === agentmuxerServerName).map(async (server) => await isManagedServerAtPath(agentType, server, server.configPath) ? {
+	return (await Promise.all(installations.flatMap(({ agentType, displayName, servers }) => isSupportedClient(agentType) ? servers.filter(({ serverName, config }) => serverName === "agentmuxer" && !(agentType === "opencode" && config["enabled"] === false)).map(async (server) => await isManagedServerAtPath(agentType, server, server.configPath) ? {
 		client: agentType,
 		displayName,
 		configPath: server.configPath
@@ -296,18 +342,51 @@ const removeAgentmuxer = async (client) => {
 		removed: false,
 		error: conflictError(client)
 	};
-	if (client === "codex") try {
-		const layout = await readCodexLayout(existing.configPath);
-		if (layout === void 0) return {
-			success: false,
-			path: existing.configPath,
-			removed: false
-		};
-		await writeFile(existing.configPath, layout, "utf8");
+	try {
+		const original = await readFile(existing.configPath, "utf8");
+		let result;
+		if (client === "codex") {
+			const layout = await readCodexLayout(existing.configPath);
+			if (layout === void 0) return {
+				success: false,
+				path: existing.configPath,
+				removed: false
+			};
+			await writeFile(existing.configPath, layout, "utf8");
+			result = {
+				success: true,
+				path: existing.configPath,
+				removed: true
+			};
+		} else if (client === "opencode") {
+			if (existing.server.config["enabled"] === false) return {
+				success: true,
+				path: existing.configPath,
+				removed: false,
+				disabled: true
+			};
+			await writeNativeServerConfig(client, existing.configPath, {
+				...existing.server.config,
+				enabled: false
+			});
+			result = {
+				success: true,
+				path: existing.configPath,
+				removed: true,
+				disabled: true
+			};
+		} else result = removeServer(client, agentmuxerServerName);
+		if (!result.success || !result.removed) return result;
+		const next = await readOptionalFile(existing.configPath);
 		return {
-			success: true,
-			path: existing.configPath,
-			removed: true
+			...result,
+			rollback: async () => {
+				if (await readOptionalFile(existing.configPath) !== next) throw new Error("MCP configuration changed during removal; refusing to overwrite it");
+				await writeFile(existing.configPath, original, {
+					encoding: "utf8",
+					mode: 384
+				});
+			}
 		};
 	} catch (error) {
 		return {
@@ -317,7 +396,6 @@ const removeAgentmuxer = async (client) => {
 			error: error instanceof Error ? error.message : "removal failed"
 		};
 	}
-	return removeServer(client, agentmuxerServerName);
 };
 const authenticationCommands = {
 	codex: `codex mcp login ${agentmuxerServerName}`,
@@ -326,14 +404,112 @@ const authenticationCommands = {
 };
 const authenticationCommand = (client) => authenticationCommands[client];
 //#endregion
+//#region src/authentication.ts
+const execute = promisify(execFile);
+const statusCommands = {
+	codex: [
+		"codex",
+		"mcp",
+		"list",
+		"--json"
+	],
+	"claude-code": [
+		"claude",
+		"mcp",
+		"list"
+	],
+	opencode: [
+		"opencode",
+		"mcp",
+		"auth",
+		"list"
+	]
+};
+const nativeEnvironment = (client) => client === "opencode" ? Object.fromEntries(Object.entries(process.env).filter(([name]) => ![
+	"OPENCODE_CONFIG",
+	"OPENCODE_CONFIG_CONTENT",
+	"OPENCODE_CONFIG_DIR"
+].includes(name.toUpperCase()))) : process.env;
+/** Read supported native CLI output, never the client's private credential store. */
+const authenticationState = async (client) => {
+	const [command, ...args] = statusCommands[client];
+	const cwd = await mkdtemp(join(tmpdir(), "agentmuxer-auth-"));
+	try {
+		const env = nativeEnvironment(client);
+		if (client === "opencode") env["OPENCODE_CONFIG_CONTENT"] = JSON.stringify({ mcp: { agentmuxer: {
+			type: "remote",
+			url: agentmuxerMcpUrl,
+			enabled: true,
+			oauth: { scope: "offline_access" }
+		} } });
+		const { stdout } = await execute(command, args, {
+			cwd,
+			env,
+			shell: process.platform === "win32",
+			timeout: 3e4,
+			maxBuffer: 1048576
+		});
+		if (client === "codex") {
+			const entries = JSON.parse(stdout);
+			if (!Array.isArray(entries)) return "unavailable";
+			const entry = entries.find((value) => typeof value === "object" && value !== null && "name" in value && value.name === "agentmuxer");
+			if (typeof entry !== "object" || entry === null || !("auth_status" in entry)) return "unavailable";
+			return entry.auth_status === "o_auth" ? "credentials-present" : entry.auth_status === "not_logged_in" ? "signed-out" : "unavailable";
+		}
+		const line = stripVTControlCharacters(stdout).split(/\r?\n/).find((value) => client === "claude-code" ? /^agentmuxer:\s/.test(value.trim()) : /^[\s│●✓✗✘✔✖○⚠]*agentmuxer\s/.test(value));
+		if (line === void 0) return "unavailable";
+		if (/\b(?:needs authentication|not authenticated)\b/i.test(line)) return "signed-out";
+		if (client === "claude-code" && /✓ Connected\s*$/i.test(line)) return "connected";
+		return client === "opencode" && /\b(?:authenticated|expired)\s*$/i.test(line) ? "credentials-present" : "unavailable";
+	} catch {
+		return "unavailable";
+	} finally {
+		await rm(cwd, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+/** The native client owns browser consent, credential storage and token refresh. */
+const signIn = async (client) => {
+	const cwd = await mkdtemp(join(tmpdir(), "agentmuxer-auth-"));
+	try {
+		await new Promise((resolve, reject) => {
+			const [command, ...args] = authenticationCommand(client).split(" ");
+			if (command === void 0) {
+				reject(/* @__PURE__ */ new Error("Missing native sign-in command"));
+				return;
+			}
+			const child = spawn(command, args, {
+				cwd,
+				env: nativeEnvironment(client),
+				stdio: "inherit",
+				shell: process.platform === "win32"
+			});
+			child.once("error", () => {
+				reject(/* @__PURE__ */ new Error(`${clientLabel(client)} sign-in could not start. Configuration is saved; run ${authenticationCommand(client)} from a terminal where the client is installed.`));
+			});
+			child.once("close", (code) => {
+				if (code === 0) resolve();
+				else reject(/* @__PURE__ */ new Error(`${clientLabel(client)} sign-in did not complete. Configuration is saved; retry ${authenticationCommand(client)}.`));
+			});
+		});
+	} finally {
+		await rm(cwd, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+//#endregion
 //#region src/cli.ts
-const version = "0.1.1";
+const version = "0.1.2";
 const help = `AgentMuxer setup ${version}
 
 Usage:
-  agentmuxer-setup install             Install AgentMuxer globally
-  agentmuxer-setup status              Verify client configuration and guidance
-  agentmuxer-setup remove              Remove AgentMuxer-managed configuration
+  npx -y @agentmuxer/setup@latest install             Install AgentMuxer globally and start native sign-in
+  npx -y @agentmuxer/setup@latest status              Check configuration and native sign-in status
+  npx -y @agentmuxer/setup@latest remove              Remove AgentMuxer-managed configuration
 
 Options:
   --client <name>                      Target codex, claude-code, or opencode; repeatable
@@ -343,13 +519,6 @@ Options:
 const fail = (message) => {
 	throw new Error(message);
 };
-const clientSetupState = async (client) => {
-	const [installations, guidance] = await Promise.all([listAgentmuxerInstallations([client]), clientGuidanceStatus(client)]);
-	return {
-		guidance: guidance.installed,
-		mcp: installations.length > 0
-	};
-};
 const withClientSetupRollback = async (client, operation) => {
 	const actions = [];
 	try {
@@ -382,21 +551,25 @@ const install = async (args) => {
 	const outcomes = await Promise.all(clients.map(async (client) => {
 		try {
 			return await withClientSetupRollback(client, async (defer) => {
+				const state = client === "opencode" ? await authenticationState(client) : void 0;
+				if (state === "unavailable") throw new Error("Native sign-in status is unavailable; retry setup. Existing configuration and credentials were preserved.");
 				const guidance = await installClientGuidance(client);
 				defer(guidance.rollback);
-				const result = await installAgentmuxer(client);
+				const result = await installAgentmuxer(client, state === "signed-out");
 				if (!result.success) throw new Error(result.error ?? "installation failed");
 				return {
-					lines: [
-						`${clientLabel(client)} MCP: ${result.path}`,
-						`${clientLabel(client)} guidance: ${guidance.path}`,
-						`${clientLabel(client)} sign-in (required): ${authenticationCommand(client)}`
-					],
+					client,
+					created: result.created === true,
+					state,
+					stableClientId: result.stableClientId === true,
+					lines: [`${clientLabel(client)} MCP: ${result.path}`, `${clientLabel(client)} guidance: ${guidance.path}`],
 					failure: void 0
 				};
 			});
 		} catch (error) {
 			return {
+				client,
+				created: false,
 				lines: [],
 				failure: `${clientLabel(client)}: ${error instanceof Error ? error.message : "installation failed"}`
 			};
@@ -404,8 +577,27 @@ const install = async (args) => {
 	}));
 	for (const line of outcomes.flatMap((outcome) => outcome.lines ?? [])) process.stdout.write(`${line}\n`);
 	const failures = outcomes.flatMap((outcome) => outcome.failure ?? []);
+	for (const outcome of outcomes) {
+		if (outcome.failure !== void 0) continue;
+		try {
+			const state = outcome.state ?? await authenticationState(outcome.client);
+			if (state === "connected" || state === "credentials-present") {
+				process.stdout.write(`${clientLabel(outcome.client)}: ${state === "connected" ? "connected" : "native credentials present; live connection not verified"}.\n`);
+				continue;
+			}
+			if (state === "unavailable") throw new Error(`${clientLabel(outcome.client)} sign-in status is unavailable. Check that the client is installed and reachable, then retry setup. Existing configuration and credentials were preserved.`);
+			if (!outcome.created && !outcome.stableClientId) throw new Error(`${clientLabel(outcome.client)} requires sign-in: ${authenticationCommand(outcome.client)}. Setup preserved the existing registration. Clients using dynamic registration may create a new agent identity on re-login.`);
+			process.stdout.write(`${clientLabel(outcome.client)}: starting native sign-in.\n`);
+			await signIn(outcome.client);
+			const after = await authenticationState(outcome.client);
+			if (after !== "connected" && after !== "credentials-present") throw new Error(`${clientLabel(outcome.client)} did not confirm native sign-in.`);
+			process.stdout.write(`${clientLabel(outcome.client)}: ${after === "connected" ? "connected" : "native sign-in completed; live connection not verified"}.\n`);
+		} catch (error) {
+			failures.push(error instanceof Error ? error.message : "Native sign-in failed");
+		}
+	}
 	if (failures.length > 0) fail(failures.join("\n"));
-	process.stdout.write("Restart open clients after setup, then run the sign-in command above — every AgentMuxer call requires it (unauthenticated requests answer a 401 challenge).\n");
+	process.stdout.write("Restart open clients to load the configuration. Native sign-in does not verify a live MCP request; check the connection in your client.\n");
 };
 const status = async (args) => {
 	const clients = parseClients(args) ?? await detectedClients();
@@ -419,30 +611,33 @@ const status = async (args) => {
 		process.stdout.write(`${clientLabel(client)} MCP: ${installation?.configPath ?? "not installed"}\n`);
 		process.stdout.write(`${clientLabel(client)} guidance: ${guidance.installed ? guidance.path : "not installed"}\n`);
 		return installation !== void 0 && guidance.installed;
-	}).every(Boolean)) fail("AgentMuxer setup is incomplete or conflicting; run agentmuxer-setup install, or remove a custom same-name MCP manually");
+	}).every(Boolean)) fail("AgentMuxer setup is incomplete or conflicting; run npx -y @agentmuxer/setup@latest install, or remove a custom same-name MCP manually");
 	process.stdout.write("AgentMuxer configuration and guidance verified.\n");
-	process.stdout.write("Not verified: sign-in. If calls answer 401, sign in:\n");
-	for (const client of clients) process.stdout.write(`  ${clientLabel(client)}: ${authenticationCommand(client)}\n`);
+	const failures = [];
+	const authStates = await Promise.all(clients.map(authenticationState));
+	for (const [index, client] of clients.entries()) {
+		const state = authStates[index] ?? "unavailable";
+		process.stdout.write(`${clientLabel(client)}: ${state === "credentials-present" ? "native credentials present; live connection not verified" : state}.\n`);
+		if (state === "signed-out" || state === "unavailable") failures.push(clientLabel(client));
+	}
+	if (failures.length > 0) fail(`Native sign-in could not be confirmed for: ${failures.join(", ")}. Check the connection in your client; existing credentials were preserved.`);
 };
 const remove = async (args) => {
 	const clients = parseClients(args) ?? supportedClients;
 	await Promise.all(clients.map(validateClientGuidance));
 	const outcomes = await Promise.all(clients.map(async (client) => {
 		try {
-			const before = await clientSetupState(client);
+			const before = await clientGuidanceStatus(client);
 			return await withClientSetupRollback(client, async (defer) => {
 				const result = await removeAgentmuxer(client);
-				if (!result.success) throw new Error(result.error ?? "removal failed");
-				if (result.removed && before.mcp) defer(async () => {
-					const rollback = await installAgentmuxer(client);
-					if (!rollback.success) throw new Error(rollback.error ?? "MCP rollback failed");
-				});
-				if (before.guidance) defer(async () => {
+				if (!result.success) throw new Error("error" in result && result.error || "removal failed");
+				if ("rollback" in result) defer(result.rollback);
+				if (before.installed) defer(async () => {
 					await installClientGuidance(client);
 				});
 				const guidanceRemoved = await removeClientGuidance(client);
 				return {
-					lines: [`${clientLabel(client)} MCP: ${result.removed ? "removed" : "not installed"}`, ...guidanceRemoved ? [`${clientLabel(client)} guidance: removed`] : []],
+					lines: [`${clientLabel(client)} MCP: ${"disabled" in result && result.disabled ? "disabled; registration retained" : result.removed ? "removed" : "not installed"}`, ...guidanceRemoved ? [`${clientLabel(client)} guidance: removed`] : []],
 					failure: void 0
 				};
 			});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmuxer/setup",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Install AgentMuxer's hosted MCP in supported coding agents",
   "keywords": [
     "agentmuxer",