@vibecodr/cli 0.1.8

package/dist/commands/config.js

@@ -0,0 +1,124 @@
+import { parseFlags } from "../cli/parse.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { defaultProfileConfig } from "../types/config.js";
+function updateProfileKey(profile, key, value) {
+    switch (key) {
+        case "server-url":
+            return { ...profile, serverUrl: value };
+        case "browser-mode":
+            return { ...profile, browserMode: value };
+        case "registration-mode":
+            return { ...profile, registrationMode: value };
+        case "default-install-scope":
+            return { ...profile, defaultInstallScope: value };
+        case "log-level":
+            return { ...profile, logLevel: value };
+        default:
+            throw new CliError("usage.unknown_config_key", `Unknown config key: ${key}`, EXIT_CODES.usage);
+    }
+}
+function unsetProfileKey(profile, key) {
+    switch (key) {
+        case "server-url":
+            return { ...profile, serverUrl: "https://openai.vibecodr.space/mcp" };
+        case "browser-mode":
+            return { ...profile, browserMode: "print" };
+        case "registration-mode":
+            return { ...profile, registrationMode: "auto" };
+        case "default-install-scope":
+            return { ...profile, defaultInstallScope: "user" };
+        case "log-level":
+            return { ...profile, logLevel: "normal" };
+        default:
+            throw new CliError("usage.unknown_config_key", `Unknown config key: ${key}`, EXIT_CODES.usage);
+    }
+}
+async function saveConfig(context, config) {
+    await context.configStore.save(config);
+}
+export async function runConfigCommand(args, context) {
+    const action = args[0];
+    const config = await context.configStore.load();
+    const currentProfileName = context.globalOptions.profile || config.currentProfile;
+    const currentProfile = config.profiles[currentProfileName] || config.profiles[config.currentProfile] || defaultProfileConfig();
+    if (action === "path") {
+        context.output.success({ schemaVersion: 1, path: context.configStore.path() }, [context.configStore.path()]);
+        return;
+    }
+    if (action === "show") {
+        context.output.success({ schemaVersion: 1, config }, [JSON.stringify(config, null, 2)]);
+        return;
+    }
+    if (action === "set") {
+        const key = args[1];
+        const value = args[2];
+        if (!key || !value)
+            throw new CliError("usage.config_set", "Usage: config set <key> <value>", EXIT_CODES.usage);
+        config.profiles[currentProfileName] = updateProfileKey(currentProfile, key, value);
+        await saveConfig(context, config);
+        context.output.success({ schemaVersion: 1, profile: currentProfileName, key, value }, [`${currentProfileName}: set ${key}=${value}`]);
+        return;
+    }
+    if (action === "unset") {
+        const key = args[1];
+        if (!key)
+            throw new CliError("usage.config_unset", "Usage: config unset <key>", EXIT_CODES.usage);
+        config.profiles[currentProfileName] = unsetProfileKey(currentProfile, key);
+        await saveConfig(context, config);
+        context.output.success({ schemaVersion: 1, profile: currentProfileName, key }, [`${currentProfileName}: unset ${key}`]);
+        return;
+    }
+    if (action === "profile") {
+        const subAction = args[1];
+        if (subAction === "list") {
+            const profiles = Object.keys(config.profiles);
+            context.output.success({ schemaVersion: 1, currentProfile: config.currentProfile, profiles }, profiles);
+            return;
+        }
+        if (subAction === "create") {
+            const name = args[2];
+            if (!name)
+                throw new CliError("usage.profile_create", "Usage: config profile create <name> [--server-url <url>]", EXIT_CODES.usage);
+            const { flags } = parseFlags(args.slice(3), { valueFlags: ["server-url"] });
+            config.profiles[name] = {
+                ...currentProfile,
+                ...(typeof flags["server-url"] === "string" ? { serverUrl: flags["server-url"] } : {})
+            };
+            await saveConfig(context, config);
+            context.output.success({ schemaVersion: 1, created: name }, [`Created profile ${name}.`]);
+            return;
+        }
+        if (subAction === "use") {
+            const name = args[2];
+            if (!name || !config.profiles[name])
+                throw new CliError("usage.profile_use", "Usage: config profile use <name>", EXIT_CODES.usage);
+            config.currentProfile = name;
+            await saveConfig(context, config);
+            context.output.success({ schemaVersion: 1, currentProfile: name }, [`Current profile: ${name}`]);
+            return;
+        }
+        if (subAction === "delete") {
+            const name = args[2];
+            const { flags } = parseFlags(args.slice(3), { booleanFlags: ["force"] });
+            if (!name || !config.profiles[name])
+                throw new CliError("usage.profile_delete", "Usage: config profile delete <name> [--force]", EXIT_CODES.usage);
+            if (config.currentProfile === name && !flags["force"]) {
+                throw new CliError("config.profile_in_use", "Cannot delete the current profile without --force.", EXIT_CODES.config);
+            }
+            delete config.profiles[name];
+            if (!Object.keys(config.profiles).length) {
+                throw new CliError("config.last_profile", "Cannot delete the last profile.", EXIT_CODES.config);
+            }
+            if (config.currentProfile === name) {
+                const nextProfile = Object.keys(config.profiles)[0];
+                if (!nextProfile)
+                    throw new CliError("config.last_profile", "Cannot delete the last profile.", EXIT_CODES.config);
+                config.currentProfile = nextProfile;
+            }
+            await saveConfig(context, config);
+            context.output.success({ schemaVersion: 1, deleted: name }, [`Deleted profile ${name}.`]);
+            return;
+        }
+    }
+    throw new CliError("usage.config", "Usage: config path|show|set|unset|profile ...", EXIT_CODES.usage);
+}

package/dist/commands/context.js

@@ -0,0 +1,5 @@
+import { Output } from "../cli/output.js";
+import { TokenManager } from "../auth/token-manager.js";
+import { ConfigStore } from "../storage/config-store.js";
+import { SecretStore } from "../storage/secret-store.js";
+import { McpRuntimeClient } from "../core/mcp-client.js";

package/dist/commands/doctor.js

@@ -0,0 +1,17 @@
+import { parseFlags } from "../cli/parse.js";
+import { runDoctor } from "../doctor/run.js";
+import { EXIT_CODES } from "../cli/errors.js";
+export async function runDoctorCommand(args, context) {
+    const { flags } = parseFlags(args, {
+        valueFlags: ["client"]
+    });
+    const checks = await runDoctor(context.globalOptions, context.tokenManager, context.secretStore, typeof flags["client"] === "string" ? flags["client"] : undefined);
+    context.output.success({
+        schemaVersion: 1,
+        ok: checks.every((check) => check.status === "pass"),
+        checks
+    }, checks.map((check) => `[${check.status.toUpperCase()}] ${check.id}: ${check.summary}`));
+    if (checks.some((check) => check.status === "fail")) {
+        process.exitCode = EXIT_CODES.runtime;
+    }
+}

package/dist/commands/install.js

@@ -0,0 +1,63 @@
+import { parseFlags } from "../cli/parse.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { InstallManifestStore } from "../storage/install-manifest.js";
+import { installCodex } from "../clients/codex.js";
+import { installCursor } from "../clients/cursor.js";
+import { installVsCode } from "../clients/vscode.js";
+import { installWindsurf } from "../clients/windsurf.js";
+function defaultName(serverUrl) {
+    return serverUrl.includes("staging") ? "vibecodr-staging" : "vibecodr";
+}
+export async function runInstallCommand(args, context) {
+    const client = args[0];
+    if (!client || !["codex", "cursor", "vscode", "windsurf"].includes(client)) {
+        throw new CliError("usage.install_client", "Usage: install <codex|cursor|vscode|windsurf> [options]", EXIT_CODES.usage);
+    }
+    const { flags } = parseFlags(args.slice(1), {
+        valueFlags: ["scope", "path", "name"],
+        booleanFlags: ["open-client", "overwrite", "dry-run"]
+    });
+    const { serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const request = {
+        serverUrl,
+        name: typeof flags["name"] === "string" ? flags["name"] : defaultName(serverUrl),
+        scope: (typeof flags["scope"] === "string" ? flags["scope"] : "user"),
+        path: typeof flags["path"] === "string" ? flags["path"] : undefined,
+        openClient: Boolean(flags["open-client"]),
+        overwrite: Boolean(flags["overwrite"]),
+        dryRun: Boolean(flags["dry-run"])
+    };
+    const result = client === "codex"
+        ? await installCodex(request)
+        : client === "cursor"
+            ? await installCursor(request)
+            : client === "vscode"
+                ? await installVsCode(request)
+                : await installWindsurf(request);
+    if (!request.dryRun) {
+        const manifest = new InstallManifestStore();
+        await manifest.upsert({
+            client: result.client,
+            scope: result.scope,
+            name: result.name,
+            location: result.location,
+            method: result.method,
+            serverUrl,
+            installedAt: new Date().toISOString()
+        });
+    }
+    context.output.success({
+        schemaVersion: 1,
+        ...result
+    }, [
+        `Client: ${result.client}`,
+        `Scope: ${result.scope}`,
+        `Method: ${result.method}`,
+        `Location: ${result.location}`,
+        `Changed: ${result.changed ? "yes" : "no"}`,
+        `Managed: yes`,
+        result.nextStep,
+        ...(result.notes || []),
+        `${result.client === "codex" ? "Codex" : result.client === "vscode" ? "VS Code" : result.client === "cursor" ? "Cursor" : "Windsurf"} config install only. CLI auth and installed-client auth remain separate.`
+    ]);
+}

package/dist/commands/login.js

@@ -0,0 +1,41 @@
+import { parseFlags } from "../cli/parse.js";
+export async function runLoginCommand(args, context) {
+    const { flags } = parseFlags(args, {
+        valueFlags: ["scope", "registration", "browser", "timeout-sec"]
+    });
+    let authorizationUrl;
+    let callbackUrl;
+    const result = await context.tokenManager.login(context.globalOptions, {
+        scope: typeof flags["scope"] === "string" ? flags["scope"] : undefined,
+        registrationMode: typeof flags["registration"] === "string" ? flags["registration"] : undefined,
+        browserMode: typeof flags["browser"] === "string" ? flags["browser"] : undefined,
+        timeoutSec: typeof flags["timeout-sec"] === "string" ? Number(flags["timeout-sec"]) : undefined,
+        onLoopbackReady: (url) => {
+            callbackUrl = url;
+            if (!context.globalOptions.json) {
+                context.output.info(`Waiting for OAuth callback on ${url}`);
+                context.output.info("Keep this terminal open until login completes.");
+            }
+        },
+        onAuthorizationUrl: (url) => {
+            authorizationUrl = url;
+            if (!context.globalOptions.json) {
+                context.output.info(url);
+            }
+        }
+    });
+    context.output.success({
+        schemaVersion: 1,
+        ...result,
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(context.globalOptions.json && authorizationUrl ? { authorizationUrl } : {})
+    }, [
+        `Profile: ${result.profile}`,
+        `Server URL: ${result.serverUrl}`,
+        `Authorization server: ${result.authorizationServerIssuer || "discovered"}`,
+        `Registration mode: ${result.registrationMode}`,
+        `Expires at: ${result.expiresAt || "unknown"}`,
+        `Refresh token: ${result.hasRefreshToken ? "available" : "not issued"}`,
+        "CLI login does not log Codex, editors, ChatGPT, or other MCP clients into MCP. Each client owns its own OAuth session."
+    ]);
+}

package/dist/commands/logout.js

@@ -0,0 +1,26 @@
+import { parseFlags } from "../cli/parse.js";
+export async function runLogoutCommand(args, context) {
+    const { flags } = parseFlags(args, {
+        booleanFlags: ["all", "no-revoke"]
+    });
+    const config = await context.configStore.load();
+    const targetProfiles = flags["all"]
+        ? Object.keys(config.profiles)
+        : [context.globalOptions.profile || config.currentProfile];
+    const results = [];
+    for (const profileName of targetProfiles) {
+        results.push({
+            profile: profileName,
+            ...(await context.tokenManager.logout(profileName, {
+                noRevoke: Boolean(flags["no-revoke"])
+            }))
+        });
+    }
+    context.output.success({
+        schemaVersion: 1,
+        results
+    }, [
+        ...results.map((result) => `${result.profile}: local tokens ${result.localTokensDeleted ? "deleted" : "not present"}, revocation ${result.revocationAttempted ? (result.revocationConfirmed ? "confirmed" : "attempted") : "skipped"}`),
+        "Editor registrations are unchanged."
+    ]);
+}

package/dist/commands/pulse-setup.js

@@ -0,0 +1,82 @@
+import { readFile } from "node:fs/promises";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { parseFlags } from "../cli/parse.js";
+import { renderToolResult } from "../core/renderers.js";
+import { callToolWithRetry } from "./call.js";
+const PULSE_SETUP_TOOL_NAME = "get_pulse_setup_guidance";
+const PULSE_DESCRIPTOR_SOURCE_OF_TRUTH = "PulseDescriptor";
+function readStructuredContent(result) {
+    const structuredContent = result && typeof result === "object"
+        ? (result.structuredContent ?? result)
+        : undefined;
+    return structuredContent && typeof structuredContent === "object" && !Array.isArray(structuredContent)
+        ? structuredContent
+        : undefined;
+}
+function assertDescriptorSetupGuidance(result, options) {
+    const structuredContent = readStructuredContent(result);
+    const descriptorMetadata = structuredContent
+        ? structuredContent["descriptorMetadata"]
+        : undefined;
+    const metadata = descriptorMetadata && typeof descriptorMetadata === "object"
+        ? descriptorMetadata
+        : undefined;
+    if (metadata?.sourceOfTruth !== PULSE_DESCRIPTOR_SOURCE_OF_TRUTH ||
+        metadata.apiVersion !== "pulse/v1") {
+        throw new CliError("mcp.pulse_setup_contract", "Pulse setup guidance response is missing PulseDescriptor metadata.", EXIT_CODES.protocol, {
+            nextStep: "Run vibecodr doctor to inspect the configured MCP server, then retry."
+        });
+    }
+    if (options?.expectsDescriptorSetup) {
+        const descriptorEvaluation = structuredContent?.["descriptorEvaluation"] && typeof structuredContent["descriptorEvaluation"] === "object"
+            ? structuredContent["descriptorEvaluation"]
+            : undefined;
+        if (descriptorEvaluation?.guidanceSource !== "descriptor_setup") {
+            throw new CliError("mcp.pulse_setup_contract", "Pulse setup guidance response did not evaluate the supplied descriptorSetup.", EXIT_CODES.protocol, {
+                nextStep: "Verify the MCP server supports get_pulse_setup_guidance descriptorSetup projection."
+            });
+        }
+    }
+}
+function parseDescriptorSetup(raw, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new CliError("usage.invalid_descriptor_setup", `${source} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODES.usage);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new CliError("usage.invalid_descriptor_setup", `${source} must be a PulseDescriptorSetupProjection object.`, EXIT_CODES.usage);
+    }
+    return parsed;
+}
+async function parsePulseSetupInput(args) {
+    const { flags } = parseFlags(args, {
+        valueFlags: ["descriptor-setup-json", "descriptor-setup-file"]
+    });
+    const hasInline = typeof flags["descriptor-setup-json"] === "string";
+    const hasFile = typeof flags["descriptor-setup-file"] === "string";
+    if (hasInline && hasFile) {
+        throw new CliError("usage.duplicate_descriptor_setup", "Use either --descriptor-setup-json or --descriptor-setup-file, not both.", EXIT_CODES.usage);
+    }
+    if (typeof flags["descriptor-setup-json"] === "string") {
+        return { descriptorSetup: parseDescriptorSetup(flags["descriptor-setup-json"], "--descriptor-setup-json") };
+    }
+    if (typeof flags["descriptor-setup-file"] === "string") {
+        const raw = await readFile(flags["descriptor-setup-file"], "utf8");
+        return { descriptorSetup: parseDescriptorSetup(raw, "--descriptor-setup-file") };
+    }
+    return {};
+}
+export async function runPulseSetupCommand(args, context) {
+    const input = await parsePulseSetupInput(args);
+    const { result } = await callToolWithRetry(context, PULSE_SETUP_TOOL_NAME, input, true);
+    assertDescriptorSetupGuidance(result, { expectsDescriptorSetup: Boolean(input["descriptorSetup"]) });
+    context.output.success({
+        schemaVersion: 1,
+        tool: PULSE_SETUP_TOOL_NAME,
+        arguments: input,
+        result
+    }, [renderToolResult(result)]);
+}

package/dist/commands/status.js

@@ -0,0 +1,64 @@
+import { access } from "node:fs/promises";
+import { parseFlags } from "../cli/parse.js";
+import { InstallManifestStore } from "../storage/install-manifest.js";
+async function inspectInstall(entry) {
+    if (entry.method !== "file") {
+        return {
+            ...entry,
+            status: "external"
+        };
+    }
+    try {
+        await access(entry.location);
+        return {
+            ...entry,
+            status: "configured"
+        };
+    }
+    catch {
+        return {
+            ...entry,
+            status: "missing"
+        };
+    }
+}
+export async function runStatusCommand(args, context) {
+    const { flags } = parseFlags(args, {
+        booleanFlags: ["probe", "show-installs"]
+    });
+    const { profileName, profile, serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const session = await context.tokenManager.getSession(profileName);
+    const sessionState = context.tokenManager.sessionState(session);
+    const installs = flags["show-installs"]
+        ? await Promise.all((await new InstallManifestStore().find(() => true)).map((entry) => inspectInstall(entry)))
+        : [];
+    let probe;
+    if (flags["probe"]) {
+        const discovery = await context.tokenManager.discover(serverUrl);
+        probe = {
+            authorizationServerUrl: discovery.authorizationServerUrl,
+            pkceS256: Boolean(discovery.authorizationServerMetadata?.code_challenge_methods_supported?.includes("S256"))
+        };
+    }
+    context.output.success({
+        schemaVersion: 1,
+        profile: profileName,
+        serverUrl,
+        sessionState,
+        registrationMode: session?.registrationMode || profile.registrationMode,
+        expiresAt: session?.expiresAt,
+        installs,
+        ...(probe ? { probe } : {})
+    }, [
+        `Profile: ${profileName}`,
+        `Server URL: ${serverUrl}`,
+        `Session state: ${sessionState}`,
+        `Registration mode: ${session?.registrationMode || profile.registrationMode}`,
+        `Expires at: ${session?.expiresAt || "not logged in"}`,
+        ...(flags["show-installs"] ? [`Managed installs: ${installs.length}`] : []),
+        ...(flags["show-installs"]
+            ? installs.map((install) => `Install: ${install.client} ${install.scope} ${install.location} [${install.status}]`)
+            : []),
+        ...(probe ? [`Authorization server: ${String(probe["authorizationServerUrl"])}`, `PKCE S256: ${probe["pkceS256"] ? "yes" : "no"}`] : [])
+    ]);
+}

package/dist/commands/tools.js

@@ -0,0 +1,82 @@
+import { formatJson, summarizeToolSchema } from "../core/renderers.js";
+import { parseFlags } from "../cli/parse.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+function challengedScope(error) {
+    if (!error.debugDetails || typeof error.debugDetails !== "object")
+        return undefined;
+    const scope = error.debugDetails["scope"];
+    return typeof scope === "string" && scope.trim() ? scope : undefined;
+}
+async function loadToolsWithRetry(context, allowLogin) {
+    const { profileName, serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const existingSession = await context.tokenManager.getSession(profileName);
+    try {
+        return {
+            tools: await context.runtimeClient.listTools(serverUrl, existingSession?.accessToken),
+            ...(existingSession ? { session: existingSession } : {})
+        };
+    }
+    catch (error) {
+        if (!(error instanceof CliError) || !["auth.required", "auth.insufficient_scope"].includes(error.machineCode))
+            throw error;
+        if (error.machineCode === "auth.required" && existingSession?.refreshToken) {
+            const refreshed = await context.tokenManager.refresh(profileName, existingSession);
+            return {
+                tools: await context.runtimeClient.listTools(serverUrl, refreshed.session.accessToken),
+                session: refreshed.session
+            };
+        }
+        if (allowLogin && !context.globalOptions.nonInteractive) {
+            await context.tokenManager.login(context.globalOptions, {
+                scope: challengedScope(error)
+            });
+            const nextSession = await context.tokenManager.getSession(profileName);
+            return {
+                tools: await context.runtimeClient.listTools(serverUrl, nextSession?.accessToken),
+                ...(nextSession ? { session: nextSession } : {})
+            };
+        }
+        throw error;
+    }
+}
+export async function runToolsCommand(args, context) {
+    const { flags, positionals } = parseFlags(args, {
+        valueFlags: ["search"],
+        booleanFlags: ["schema", "no-login"]
+    });
+    const toolName = positionals[0];
+    const { tools, session } = await loadToolsWithRetry(context, !flags["no-login"]);
+    const serverUrl = session?.serverUrl || (await context.tokenManager.resolveProfile(context.globalOptions)).serverUrl;
+    const sortedTools = tools
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const search = typeof flags["search"] === "string" ? flags["search"].toLowerCase() : "";
+    const filtered = search
+        ? sortedTools.filter((tool) => tool.name.toLowerCase().includes(search) || (tool.description || "").toLowerCase().includes(search))
+        : sortedTools;
+    if (!toolName) {
+        context.output.success({
+            schemaVersion: 1,
+            serverUrl,
+            toolCount: filtered.length,
+            tools: filtered
+        }, filtered.map((tool) => `${tool.name}${tool.description ? `: ${tool.description}` : ""}`));
+        return;
+    }
+    const tool = sortedTools.find((item) => item.name === toolName);
+    if (!tool) {
+        throw new CliError("tool.not_found", `Tool not found: ${toolName}`, EXIT_CODES.toolFailed);
+    }
+    const summary = summarizeToolSchema(tool.inputSchema);
+    context.output.success({
+        schemaVersion: 1,
+        tool
+    }, [
+        `Name: ${tool.name}`,
+        `Description: ${tool.description || ""}`,
+        `Required: ${summary.required.join(", ") || "none"}`,
+        `Optional: ${summary.optional.join(", ") || "none"}`,
+        "Input skeleton:",
+        formatJson(summary.skeleton),
+        ...(flags["schema"] ? ["Schema:", formatJson(tool.inputSchema)] : [])
+    ]);
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,55 @@
+import { parseFlags } from "../cli/parse.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { InstallManifestStore } from "../storage/install-manifest.js";
+import { uninstallCodex } from "../clients/codex.js";
+import { uninstallCursor } from "../clients/cursor.js";
+import { uninstallVsCode } from "../clients/vscode.js";
+import { uninstallWindsurf } from "../clients/windsurf.js";
+export async function runUninstallCommand(args, context) {
+    const client = args[0];
+    if (!client || !["codex", "cursor", "vscode", "windsurf"].includes(client)) {
+        throw new CliError("usage.uninstall_client", "Usage: uninstall <codex|cursor|vscode|windsurf> [options]", EXIT_CODES.usage);
+    }
+    const { flags } = parseFlags(args.slice(1), {
+        valueFlags: ["scope", "path", "name"],
+        booleanFlags: ["dry-run"]
+    });
+    const { serverUrl } = await context.tokenManager.resolveProfile(context.globalOptions);
+    const scope = (typeof flags["scope"] === "string" ? flags["scope"] : "user");
+    const name = typeof flags["name"] === "string" ? flags["name"] : (serverUrl.includes("staging") ? "vibecodr-staging" : "vibecodr");
+    const manifest = new InstallManifestStore();
+    const managedEntries = await manifest.find((entry) => entry.client === client && entry.scope === scope && entry.name === name);
+    const managed = managedEntries[0];
+    if (!managed) {
+        throw new CliError("install.not_managed", `No CLI-managed ${client} install entry was found for ${name}.`, EXIT_CODES.installConflict, {
+            nextStep: "Only CLI-managed installs can be safely removed."
+        });
+    }
+    const request = {
+        serverUrl,
+        name,
+        scope,
+        path: typeof flags["path"] === "string" ? flags["path"] : undefined,
+        dryRun: Boolean(flags["dry-run"])
+    };
+    const result = client === "codex"
+        ? await uninstallCodex(request, managed.location)
+        : client === "cursor"
+            ? await uninstallCursor(request, managed.location)
+            : client === "vscode"
+                ? await uninstallVsCode(request, managed.location, managed.method === "uri" ? "cli" : managed.method)
+                : await uninstallWindsurf(request, managed.location);
+    if (!request.dryRun && result.changed) {
+        await manifest.remove((entry) => entry.client === client && entry.scope === scope && entry.name === name && entry.location === managed.location);
+    }
+    context.output.success({
+        schemaVersion: 1,
+        ...result
+    }, [
+        `Client: ${result.client}`,
+        `Scope: ${result.scope}`,
+        `Location: ${result.location}`,
+        `Changed: ${result.changed ? "yes" : "no"}`,
+        result.nextStep
+    ]);
+}