waitspin 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { constants as fsConstants } from "node:fs";
-import { access, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { access, chmod, cp, mkdir, readFile, rm, writeFile, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 const DEFAULT_BASE_URL = process.env.WAITSPIN_BASE_URL?.trim() || "https://api.waitspin.com";
+const PRODUCTION_API_ORIGIN = "https://api.waitspin.com";
 const REQUEST_TIMEOUT_MS = 30_000;
+const DEV_API_BASE_OPT_IN_ENV = "WAITSPIN_ALLOW_DEV_API_BASE";
+const DEV_EXTENSION_ASSETS_OPT_IN_ENV = "WAITSPIN_ALLOW_DEV_EXTENSION_ASSETS";
+const CLAUDE_CODE_BIN_ENV = "WAITSPIN_CLAUDE_CODE_BIN";
+const CLAUDE_CODE_MIN_VERSION = "2.1.97";
+const CLAUDE_CODE_PUBLISHER_TARGET = "claude-code";
+const CLAUDE_CODE_REFRESH_INTERVAL_SECONDS = 5;
 const extensionTargets = {
     vscode: "vscode",
 };
@@ -16,7 +24,7 @@ export function usageText() {
         "  waitspin init --email you@example.com [--code CODE] [--key-profile control|publisher-extension] [--base-url URL]",
         "  waitspin bid create --line TEXT --url https://example.com --price-per-block CENTS --blocks N [--base-url URL] [--api-key KEY]",
         "  waitspin bids list [--base-url URL] [--api-key KEY]",
-        "  waitspin bid checkout <campaign-id> [--base-url URL] [--api-key KEY]",
+        "  waitspin bid checkout CAMPAIGN_ID [--base-url URL] [--api-key KEY]",
         "  waitspin market [--base-url URL]",
         "  waitspin wallet status [--base-url URL] [--api-key KEY]",
         "  waitspin wallet connect [--base-url URL] [--api-key KEY]",
@@ -26,11 +34,23 @@ export function usageText() {
         "  waitspin extension install [--target vscode] [--base-url URL] [--api-key KEY] [--dry-run]",
         "  waitspin extension status [--target vscode]",
         "  waitspin extension uninstall [--target vscode] [--dry-run]",
+        "  waitspin claude-code install [--base-url URL] [--api-key KEY] [--dry-run] [--compose-existing]",
+        "  waitspin claude-code status",
+        "  waitspin claude-code uninstall [--dry-run]",
         "",
         "Defaults:",
         "  API base: https://api.waitspin.com",
         "  API key: WAITSPIN_API_KEY env var",
-        "  Public extension target: VS Code status-bar fallback",
+        "  Public install targets: VS Code status-bar fallback, Claude Code statusline",
+        "",
+        "Publisher install targets:",
+        "  VS Code:",
+        "    waitspin extension install --target vscode",
+        "    waitspin extension status --target vscode",
+        "",
+        "  Claude Code:",
+        "    waitspin claude-code install --compose-existing",
+        "    waitspin claude-code status",
     ].join("\n") + "\n");
 }
 function usage(exitCode = 1) {
@@ -67,7 +87,10 @@ function parseArgs(argv) {
         }
         if (key === "dry-run" ||
             key === "allow-debug-auto-verify" ||
-            key === "confirm-test-transfer") {
+            key === "allow-dev-api-base" ||
+            key === "allow-dev-extension-assets" ||
+            key === "confirm-test-transfer" ||
+            key === "compose-existing") {
             flags.set(key, ["true"]);
             continue;
         }
@@ -99,6 +122,51 @@ function booleanFlag(flags, name) {
 function resolveBaseUrl(flags) {
     return optionalFlag(flags, "base-url") || DEFAULT_BASE_URL;
 }
+function allowDevApiBase(flags) {
+    return (booleanFlag(flags, "allow-dev-api-base") ||
+        process.env[DEV_API_BASE_OPT_IN_ENV] === "1");
+}
+function allowDevExtensionAssets(flags) {
+    return (booleanFlag(flags, "allow-dev-extension-assets") ||
+        process.env[DEV_EXTENSION_ASSETS_OPT_IN_ENV] === "1");
+}
+function isLoopbackApiHostname(hostname) {
+    const normalized = hostname.toLowerCase().replace(/\.$/, "");
+    return (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "[::1]" ||
+        /^127(?:\.\d{1,3}){3}$/.test(normalized));
+}
+function normalizeOriginUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error("Invalid WaitSpin API base URL. Use an http(s) origin without credentials, path, query, or fragment.");
+    }
+    if ((parsed.protocol !== "https:" && parsed.protocol !== "http:") ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash ||
+        (parsed.pathname !== "" && parsed.pathname !== "/")) {
+        throw new Error("Invalid WaitSpin API base URL. Use an http(s) origin without credentials, path, query, or fragment.");
+    }
+    return parsed;
+}
+function resolveCredentialedBaseUrl(flags) {
+    const parsed = normalizeOriginUrl(resolveBaseUrl(flags));
+    if (parsed.protocol === "https:" && parsed.origin === PRODUCTION_API_ORIGIN) {
+        return parsed.origin;
+    }
+    if (allowDevApiBase(flags) &&
+        (parsed.protocol === "http:" || parsed.protocol === "https:") &&
+        isLoopbackApiHostname(parsed.hostname)) {
+        return parsed.origin;
+    }
+    throw new Error(`Refusing to send WaitSpin credentials to a non-production API origin. Use ${PRODUCTION_API_ORIGIN} or set ${DEV_API_BASE_OPT_IN_ENV}=1 / --allow-dev-api-base with a loopback http(s) origin for local development.`);
+}
 function resolveApiKey(flags) {
     return optionalFlag(flags, "api-key") || process.env.WAITSPIN_API_KEY?.trim();
 }
@@ -118,7 +186,11 @@ function resolveKeyIntendedUse(flags) {
 function requireApiKey(flags) {
     const apiKey = resolveApiKey(flags);
     if (!apiKey) {
-        throw new Error("Missing API key. Set WAITSPIN_API_KEY or pass --api-key");
+        throw new Error([
+            "Missing API key. Set WAITSPIN_API_KEY or pass --api-key.",
+            "Next command:",
+            "  export WAITSPIN_API_KEY='PASTE_KEY_HERE'",
+        ].join("\n"));
     }
     return apiKey;
 }
@@ -156,6 +228,57 @@ async function requestJson(input, init) {
 function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function keyProfileFromIntendedUse(intendedUse) {
+    if (intendedUse === "key_profile:publisher_extension") {
+        return "publisher_extension";
+    }
+    if (intendedUse === "key_profile:control") {
+        return "control";
+    }
+    return null;
+}
+function keyProfileFlagFromIntendedUse(intendedUse) {
+    const profile = keyProfileFromIntendedUse(intendedUse);
+    if (profile === "publisher_extension") {
+        return " --key-profile publisher-extension";
+    }
+    if (profile === "control") {
+        return " --key-profile control";
+    }
+    return "";
+}
+function waitspinInitVerifyCommand(input) {
+    return `waitspin init --email ${input.email} --code CODE_FROM_EMAIL${keyProfileFlagFromIntendedUse(input.intendedUse)}`;
+}
+function nextCommandsForVerifiedKey(input) {
+    const scopes = input.scopes ?? [];
+    const publisherKey = keyProfileFromIntendedUse(input.intendedUse) === "publisher_extension" ||
+        (scopes.includes("publishers:write") &&
+            scopes.includes("serve:read") &&
+            scopes.includes("events:write") &&
+            !scopes.includes("campaigns:write"));
+    if (publisherKey) {
+        return {
+            next: "install_publisher_target",
+            next_commands: [
+                "export WAITSPIN_API_KEY='PASTE_KEY_HERE'",
+                "waitspin claude-code install --compose-existing",
+                "waitspin claude-code status",
+                "claude",
+            ],
+            human_message: "Use this publisher-extension key only for publisher install, serve polling, and impressions. Rotate it if it appears in logs.",
+        };
+    }
+    return {
+        next: "create_campaign_or_inspect_market",
+        next_commands: [
+            "export WAITSPIN_API_KEY='PASTE_KEY_HERE'",
+            "waitspin market",
+            'waitspin bid create --line "Your ad" --url https://example.com --price-per-block 500 --blocks 1',
+        ],
+        human_message: "Use this control key for advertiser and wallet commands. Keep it out of shell history and logs.",
+    };
+}
 async function runInit(flags) {
     const baseUrl = resolveBaseUrl(flags);
     const email = requireFlag(flags, "email");
@@ -172,7 +295,15 @@ async function runInit(flags) {
                 ...(intendedUse ? { intended_use: intendedUse } : {}),
             }),
         });
-        printJson({ ok: true, base_url: baseUrl, ...body });
+        printJson({
+            ok: true,
+            base_url: baseUrl,
+            ...body,
+            ...nextCommandsForVerifiedKey({
+                intendedUse,
+                scopes: body?.scopes,
+            }),
+        });
         return;
     }
     const { body: requestResult } = await requestJson(`${baseUrl}/v1/keys/request`, {
@@ -189,10 +320,13 @@ async function runInit(flags) {
     if (!code || !allowDebugAutoVerify) {
         printJson({
             ok: true,
-            next: "check_email_for_code",
+            next: "enter_email_code",
             delivery: requestResult?.delivery,
             email,
-            debug_code_available: Boolean(code),
+            expires_in_seconds: requestResult?.expires_in_seconds ?? 900,
+            next_command: waitspinInitVerifyCommand({ email, intendedUse }),
+            human_message: "Check your email for the 6-digit WaitSpin code. Paste it as CODE_FROM_EMAIL.",
+            ...(code ? { debug_code_available: true } : {}),
         });
         return;
     }
@@ -205,10 +339,18 @@ async function runInit(flags) {
             ...(intendedUse ? { intended_use: intendedUse } : {}),
         }),
     });
-    printJson({ ok: true, base_url: baseUrl, ...verifyResult });
+    printJson({
+        ok: true,
+        base_url: baseUrl,
+        ...verifyResult,
+        ...nextCommandsForVerifiedKey({
+            intendedUse,
+            scopes: verifyResult?.scopes,
+        }),
+    });
 }
 async function runBidCreate(flags) {
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const adLine = requireFlag(flags, "line");
     const destinationUrl = requireFlag(flags, "url");
@@ -237,7 +379,7 @@ async function runBidCreate(flags) {
     printJson({ ok: true, ...body });
 }
 async function runBidsList(flags) {
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const { body } = await requestJson(`${baseUrl}/v1/campaigns`, {
         method: "GET",
@@ -248,9 +390,9 @@ async function runBidsList(flags) {
 async function runBidCheckout(flags, positionals) {
     const campaignId = positionals[0]?.trim();
     if (!campaignId) {
-        throw new Error("Usage: waitspin bid checkout <campaign-id>");
+        throw new Error("Usage: waitspin bid checkout CAMPAIGN_ID");
     }
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const { body } = await requestJson(`${baseUrl}/v1/blocks/checkout`, {
         method: "POST",
@@ -266,7 +408,7 @@ async function runBidCheckout(flags, positionals) {
         checkout_disclosure: {
             terms_url: "https://waitspin.com/waitspin/terms",
             privacy_url: "https://waitspin.com/waitspin/privacy",
-            refund_policy: "Unused prepaid blocks are account credit unless a cash refund is required by law or approved through support review. Self-serve cash refund requests are not shipped.",
+            refund_policy: "Unused prepaid block handling is support-reviewed. No automated account-credit balance, redemption flow, or self-serve cash refund request flow is shipped.",
         },
     });
 }
@@ -276,7 +418,7 @@ async function runMarket(flags) {
     printJson({ ok: true, ...body });
 }
 async function runWalletStatus(flags) {
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const { body } = await requestJson(`${baseUrl}/v1/wallet/status`, {
         method: "GET",
@@ -285,7 +427,7 @@ async function runWalletStatus(flags) {
     printJson({ ok: true, ...body });
 }
 async function runWalletConnect(flags) {
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const { body } = await requestJson(`${baseUrl}/v1/wallet/connect`, {
         method: "POST",
@@ -294,7 +436,7 @@ async function runWalletConnect(flags) {
     printJson({ ok: true, ...body });
 }
 async function runWalletLedger(flags) {
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const limit = optionalFlag(flags, "limit");
     const url = new URL(`${baseUrl}/v1/wallet/ledger`);
@@ -308,7 +450,7 @@ async function runWalletLedger(flags) {
     printJson({ ok: true, ...body });
 }
 async function runWalletPayout(flags) {
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const apiKey = requireApiKey(flags);
     const dryRun = booleanFlag(flags, "dry-run");
     const confirmTestTransfer = booleanFlag(flags, "confirm-test-transfer");
@@ -342,7 +484,16 @@ function extensionInstallDir(_target) {
     return path.join(os.homedir(), ".vscode", "extensions");
 }
 function vscodeExtensionInstallDir(manifest) {
-    return path.join(extensionInstallDir("vscode"), `waitspin.${manifest.name}-${manifest.version}`);
+    const extensionRoot = path.resolve(extensionInstallDir("vscode"));
+    const installName = `${manifest.publisher}.${manifest.name}-${manifest.version}`;
+    if (!/^[a-z0-9][a-z0-9.-]*$/.test(installName)) {
+        throw new Error("Refusing to install extension with unsafe manifest name.");
+    }
+    const installPath = path.resolve(extensionRoot, installName);
+    if (!installPath.startsWith(`${extensionRoot}${path.sep}`)) {
+        throw new Error("Refusing to install extension outside the VS Code root.");
+    }
+    return installPath;
 }
 function installStatePath(target) {
     return path.join(os.homedir(), ".waitspin", `${target}-install.json`);
@@ -389,40 +540,77 @@ function assertManagedVscodeExtensionPath(input) {
     return resolved;
 }
 async function registerPublisherInstall(input) {
-    const { body } = await requestJson(`${input.baseUrl}/v1/publishers/register`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${input.apiKey}`,
-        },
-        body: JSON.stringify({
-            install_id: input.installId,
-            target: input.target,
-        }),
-    });
+    let body = null;
+    try {
+        ({ body } = await requestJson(`${input.baseUrl}/v1/publishers/register`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`,
+            },
+            body: JSON.stringify({
+                install_id: input.installId,
+                target: input.target,
+            }),
+        }));
+    }
+    catch (error) {
+        if (input.target === CLAUDE_CODE_PUBLISHER_TARGET &&
+            error instanceof WaitSpinCliHttpError &&
+            error.status === 400 &&
+            /status-bar-fallback|Invalid input|Validation error/.test(error.message)) {
+            throw new Error([
+                'WaitSpin API rejected target "claude-code".',
+                "Your local CLI supports Claude Code, but the selected API base does not.",
+                "",
+                "For production:",
+                "  deploy the backend target allowlist, then rerun:",
+                "  waitspin claude-code install --compose-existing",
+                "",
+                "For developer-local acceptance only, use an explicit loopback API with --allow-dev-api-base.",
+            ].join("\n"));
+        }
+        throw error;
+    }
     if (!body) {
         throw new Error("Publisher registration returned empty body");
     }
     return body;
 }
-async function resolveExtensionDir() {
+async function resolveExtensionDir(flags) {
     const packageRoot = resolveCliPackageRoot();
     const candidates = [
-        path.join(process.cwd(), "packages/waitspin/assets/waitspin-vscode"),
-        path.join(process.cwd(), "extensions/waitspin-vscode"),
         path.join(packageRoot, "assets", "waitspin-vscode"),
-        path.join(packageRoot, "../../extensions/waitspin-vscode"),
     ];
+    if (allowDevExtensionAssets(flags)) {
+        candidates.push(path.join(packageRoot, "../../extensions/waitspin-vscode"));
+    }
     for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
         try {
-            await access(path.join(candidate, "package.json"), fsConstants.F_OK);
-            return candidate;
+            await access(path.join(resolved, "package.json"), fsConstants.F_OK);
+            return resolved;
         }
         catch {
             continue;
         }
     }
-    throw new Error("WaitSpin extension package not found. Install from the WaitSpin checkout or use a build that ships assets/waitspin-vscode.");
+    throw new Error(`WaitSpin extension package not found. Use a build that ships assets/waitspin-vscode or set ${DEV_EXTENSION_ASSETS_OPT_IN_ENV}=1 / --allow-dev-extension-assets from a trusted checkout.`);
+}
+function parseVscodeExtensionManifest(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error("Extension manifest must be a JSON object.");
+    }
+    const manifest = value;
+    const name = typeof manifest.name === "string" ? manifest.name.trim() : "";
+    const publisher = typeof manifest.publisher === "string" ? manifest.publisher.trim() : "";
+    const version = typeof manifest.version === "string" ? manifest.version.trim() : "";
+    if (name !== "waitspin-vscode" ||
+        publisher !== "waitspin" ||
+        !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new Error("Unexpected WaitSpin VS Code extension manifest. Refusing to construct install path.");
+    }
+    return { name, publisher, version };
 }
 function resolveCliPackageRoot() {
     if (!process.argv[1])
@@ -451,17 +639,18 @@ async function installVscodeExtensionRuntime(input) {
 }
 export async function runExtensionInstall(flags) {
     const target = resolveExtensionTarget(flags);
-    const baseUrl = resolveBaseUrl(flags);
+    const baseUrl = resolveCredentialedBaseUrl(flags);
     const publisherTarget = publisherTargetForExtension(target);
-    const extensionDir = await resolveExtensionDir();
+    const extensionDir = await resolveExtensionDir(flags);
     const manifestPath = path.join(extensionDir, "package.json");
-    let manifest;
+    let manifestJson;
     try {
-        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        manifestJson = JSON.parse(await readFile(manifestPath, "utf8"));
     }
     catch {
         throw new Error(`Extension package not found at ${extensionDir}.`);
     }
+    const manifest = parseVscodeExtensionManifest(manifestJson);
     const installDir = extensionInstallDir(target);
     const statePath = installStatePath(target);
     const existingState = await loadInstallState(statePath);
@@ -482,10 +671,9 @@ export async function runExtensionInstall(flags) {
             set_vscode_settings: {
                 "waitspin.installId": installId,
             },
-            credential_storage: "The VS Code extension migrates waitspin.apiKey user settings into SecretStorage; WAITSPIN_API_KEY remains env-only.",
+            credential_storage: "The VS Code extension migrates a one-time waitspin.apiKey user setting into SecretStorage; runtime polling reads SecretStorage only.",
             optional_bootstrap_env: {
                 WAITSPIN_INSTALL_ID: installId,
-                WAITSPIN_API_KEY: "<temporary publisher-extension key for first activation>",
             },
         },
     };
@@ -612,6 +800,859 @@ export async function runExtensionUninstall(flags) {
         install_marker_error: installedPathStatus.error,
     });
 }
+function claudeCodeInstallDir() {
+    return path.join(os.homedir(), ".waitspin");
+}
+function claudeCodeStatePath() {
+    return path.join(claudeCodeInstallDir(), "claude-code-install.json");
+}
+function claudeCodeRuntimePath() {
+    return path.join(claudeCodeInstallDir(), "claude-code-statusline.mjs");
+}
+function claudeCodeCachePath() {
+    return path.join(claudeCodeInstallDir(), "claude-code-statusline-cache.json");
+}
+function claudeCodeSettingsPath() {
+    return path.join(os.homedir(), ".claude", "settings.json");
+}
+function claudeCodeProjectSettingsCandidates(startDir = process.cwd()) {
+    const candidates = [];
+    const homeDir = path.resolve(os.homedir());
+    let currentDir = path.resolve(startDir);
+    while (currentDir !== homeDir) {
+        candidates.push({
+            scope: "local",
+            path: path.join(currentDir, ".claude", "settings.local.json"),
+        });
+        candidates.push({
+            scope: "project",
+            path: path.join(currentDir, ".claude", "settings.json"),
+        });
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return candidates;
+}
+function claudeCodeBinary() {
+    return process.env[CLAUDE_CODE_BIN_ENV]?.trim() || "claude";
+}
+function execFileText(file, args, options) {
+    return new Promise((resolve, reject) => {
+        execFile(file, args, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({
+                stdout: String(stdout || ""),
+                stderr: String(stderr || ""),
+            });
+        });
+    });
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function windowsPath(value) {
+    return value.replace(/\\/g, "/");
+}
+function powerShellQuote(value) {
+    return `'${windowsPath(value).replace(/'/g, "''")}'`;
+}
+function powerShellCommandArgument(value) {
+    return `"${value.replace(/[`"$]/g, "`$&")}"`;
+}
+function claudeCodeStatusLineCommand(input) {
+    if (process.platform === "win32") {
+        const command = [
+            "&",
+            powerShellQuote(process.execPath),
+            powerShellQuote(input.runtimePath),
+            "--state",
+            powerShellQuote(input.statePath),
+        ].join(" ");
+        return [
+            "powershell",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            powerShellCommandArgument(command),
+        ].join(" ");
+    }
+    return `${shellQuote(process.execPath)} ${shellQuote(input.runtimePath)} --state ${shellQuote(input.statePath)}`;
+}
+function managedClaudeCodeStatusLine(input) {
+    return {
+        type: "command",
+        command: claudeCodeStatusLineCommand(input),
+        padding: 2,
+        refreshInterval: CLAUDE_CODE_REFRESH_INTERVAL_SECONDS,
+    };
+}
+function parseVersionParts(value) {
+    const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isVersionAtLeast(value, minimum) {
+    const current = parseVersionParts(value);
+    const target = parseVersionParts(minimum);
+    if (!current || !target)
+        return false;
+    for (let index = 0; index < target.length; index += 1) {
+        if (current[index] > target[index])
+            return true;
+        if (current[index] < target[index])
+            return false;
+    }
+    return true;
+}
+async function readClaudeCodeVersion() {
+    try {
+        const result = await execFileText(claudeCodeBinary(), ["--version"], {
+            encoding: "utf8",
+            timeout: 5_000,
+        });
+        return `${result.stdout || result.stderr || ""}`.trim();
+    }
+    catch (error) {
+        throw new Error(`Unable to run Claude Code. Install Claude Code or set ${CLAUDE_CODE_BIN_ENV} to its executable path before installing WaitSpin Claude Code support.`, { cause: error });
+    }
+}
+async function assertSupportedClaudeCodeVersion() {
+    const version = await readClaudeCodeVersion();
+    if (!isVersionAtLeast(version, CLAUDE_CODE_MIN_VERSION)) {
+        throw new Error(`Unsupported Claude Code version: ${version || "unknown"}. WaitSpin Claude Code statusline support requires Claude Code ${CLAUDE_CODE_MIN_VERSION} or newer.`);
+    }
+    return version;
+}
+function isErrno(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === code);
+}
+async function readJsonObjectFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        if (!raw.trim())
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`${filePath} must contain a JSON object.`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT")) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeJsonObjectFile(filePath, value, mode) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: "utf8",
+        mode,
+    });
+    if (mode) {
+        await chmod(filePath, mode);
+    }
+}
+async function loadClaudeCodeSettings() {
+    const parsed = await readJsonObjectFile(claudeCodeSettingsPath());
+    return (parsed ?? {});
+}
+async function findClaudeCodeScopedStatusLine() {
+    for (const candidate of claudeCodeProjectSettingsCandidates()) {
+        const parsed = await readJsonObjectFile(candidate.path);
+        if (parsed &&
+            Object.prototype.hasOwnProperty.call(parsed, "statusLine")) {
+            return {
+                scope: candidate.scope,
+                path: candidate.path,
+                statusLine: parsed.statusLine,
+            };
+        }
+    }
+    return null;
+}
+async function loadClaudeCodeInstallState() {
+    const parsed = await readJsonObjectFile(claudeCodeStatePath());
+    if (!parsed?.install_id || parsed.target !== CLAUDE_CODE_PUBLISHER_TARGET) {
+        return null;
+    }
+    return parsed;
+}
+function isCommandStatusLine(value) {
+    return (Boolean(value) &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        value.type === "command" &&
+        typeof value.command === "string" &&
+        value.command.trim().length > 0);
+}
+function statusLineEquals(left, right) {
+    if (isCommandStatusLine(left) && isCommandStatusLine(right)) {
+        return (left.type === right.type &&
+            left.command === right.command &&
+            left.padding === right.padding &&
+            left.refreshInterval === right.refreshInterval);
+    }
+    return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function claudeCodeScopedStatusLineBlocker(scopedStatusLine, managedStatusLine) {
+    if (!scopedStatusLine)
+        return null;
+    if (statusLineEquals(scopedStatusLine.statusLine, managedStatusLine)) {
+        return null;
+    }
+    return `Claude Code ${scopedStatusLine.scope} settings at ${scopedStatusLine.path} define a higher-priority statusLine. User-level WaitSpin install would not be used in this project. Remove or compose that statusLine first, then retry.`;
+}
+function resolveClaudeCodeSettingsUpdate(input) {
+    const current = input.settings.statusLine;
+    const isAlreadyManaged = statusLineEquals(current, input.managedStatusLine) ||
+        (input.existingState?.managed_status_line &&
+            statusLineEquals(current, input.existingState.managed_status_line));
+    if (!current || isAlreadyManaged) {
+        return {
+            nextSettings: { ...input.settings, statusLine: input.managedStatusLine },
+            previousStatusLine: input.existingState?.previous_status_line,
+            composedExistingStatusLine: Boolean(input.existingState?.composed_existing_status_line),
+            action: isAlreadyManaged ? "refresh-managed" : "install",
+        };
+    }
+    if (!input.composeExisting) {
+        throw new Error("Claude Code already has a statusLine configured. Re-run with --compose-existing to preserve it and append the WaitSpin sponsor line, or remove it first.");
+    }
+    if (!isCommandStatusLine(current)) {
+        throw new Error("Claude Code statusLine exists but is not a command status line; refusing to compose because restore would be ambiguous.");
+    }
+    if (current.command === input.managedStatusLine.command) {
+        return {
+            nextSettings: { ...input.settings, statusLine: input.managedStatusLine },
+            composedExistingStatusLine: false,
+            action: "refresh-managed",
+        };
+    }
+    return {
+        nextSettings: { ...input.settings, statusLine: input.managedStatusLine },
+        previousStatusLine: current,
+        composedExistingStatusLine: true,
+        action: "compose-existing",
+    };
+}
+function redactedClaudeCodeState(state) {
+    if (!state)
+        return null;
+    return {
+        target: state.target,
+        install_id: state.install_id,
+        publisher_id: state.publisher_id,
+        publisher_target: state.publisher_target,
+        registered_at: state.registered_at,
+        base_url: state.base_url,
+        runtime_path: state.runtime_path,
+        cache_path: state.cache_path,
+        settings_path: state.settings_path,
+        composed_existing_status_line: Boolean(state.composed_existing_status_line),
+        has_previous_status_line: state.previous_status_line !== undefined,
+        claude_version: state.claude_version,
+        installed_at: state.installed_at,
+        api_key_present: Boolean(state.api_key),
+    };
+}
+function claudeCodeStatuslineRuntimeSource() {
+    return String.raw `#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import {
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+
+const FETCH_INTERVAL_MS = 15_000;
+const FETCH_TIMEOUT_MS = 2_500;
+const PREVIOUS_TIMEOUT_MS = 1_000;
+const MAX_ACTIVE_AGE_MS = 60_000;
+const LOCK_RETRY_MS = 40;
+const LOCK_TIMEOUT_MS = 2_000;
+const LOCK_STALE_MS = 10_000;
+
+function argValue(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+async function writeJson(filePath, value) {
+  const tmp = filePath + "." + process.pid + ".tmp";
+  await writeFile(tmp, JSON.stringify(value, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  await rename(tmp, filePath);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireCacheLock(cachePath) {
+  const lockPath = cachePath + ".lock";
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
+    try {
+      await mkdir(lockPath);
+      return async () => {
+        await rm(lockPath, { recursive: true, force: true });
+      };
+    } catch {
+      try {
+        const lockStat = await stat(lockPath);
+        if (Date.now() - lockStat.mtimeMs > LOCK_STALE_MS) {
+          await rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        // Another process may have released the lock between mkdir/stat.
+      }
+      await sleep(LOCK_RETRY_MS);
+    }
+  }
+
+  throw new Error("Timed out waiting for WaitSpin statusline cache lock.");
+}
+
+async function withCacheLock(cachePath, callback) {
+  const release = await acquireCacheLock(cachePath);
+  try {
+    return await callback();
+  } finally {
+    await release();
+  }
+}
+
+function cleanLine(value) {
+  return String(value || "")
+    .replace(/[\r\n\u0000-\u001F\u007F]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 120);
+}
+
+async function runPreviousStatusLine(command, input) {
+  if (!command) return "";
+  return await new Promise((resolve) => {
+    const child = spawn(command, {
+      shell: true,
+      stdio: ["pipe", "pipe", "ignore"],
+      env: process.env,
+    });
+    let stdout = "";
+    let settled = false;
+    let killTimer = null;
+    function finish(value) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      resolve(value);
+    }
+    const timer = setTimeout(() => {
+      child.stdout.destroy();
+      child.stdin.destroy();
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, 100);
+      killTimer.unref?.();
+      child.unref?.();
+      finish("");
+    }, PREVIOUS_TIMEOUT_MS);
+    timer.unref?.();
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      if (stdout.length > 4000) stdout = stdout.slice(0, 4000);
+    });
+    child.on("error", () => {
+      finish("");
+    });
+    child.on("close", () => {
+      finish(stdout.trimEnd());
+    });
+    child.stdin.end(input);
+  });
+}
+
+async function waitspinFetch(url, init) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function parseServe(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const creative = payload.creative;
+  if (!creative || typeof creative !== "object") return null;
+  const line = cleanLine(creative.line);
+  if (!line) return null;
+  if (
+    typeof payload.serve_id !== "string" ||
+    typeof payload.serve_receipt !== "string"
+  ) {
+    return null;
+  }
+  const parsedExpiresAt = Date.parse(payload.expires_at || "");
+  return {
+    serveId: payload.serve_id,
+    serveReceipt: payload.serve_receipt,
+    line,
+    shownAt: Date.now(),
+    expiresAtMs: Number.isFinite(parsedExpiresAt)
+      ? parsedExpiresAt
+      : Date.now() + MAX_ACTIVE_AGE_MS,
+    minVisibleMs:
+      typeof payload.min_visible_ms === "number" && payload.min_visible_ms >= 5000
+        ? payload.min_visible_ms
+        : 5000,
+    impressionRecorded: false,
+  };
+}
+
+function serveIsExpired(serve) {
+  return (
+    Date.now() >= (serve.expiresAtMs || 0) ||
+    Date.now() - serve.shownAt > MAX_ACTIVE_AGE_MS
+  );
+}
+
+async function fetchNextServe(state, session) {
+  const response = await waitspinFetch(state.base_url + "/v1/serve/next", {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + state.api_key,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ install_id: state.install_id }),
+  });
+  session.lastFetchAt = Date.now();
+  if (response.status === 204) {
+    session.activeServe = null;
+    return;
+  }
+  if (!response.ok) return;
+  const parsed = parseServe(await response.json());
+  if (parsed) session.activeServe = parsed;
+}
+
+async function recordImpression(state, session) {
+  const serve = session.activeServe;
+  if (!serve || serve.impressionRecorded) return;
+  const visibleMs = Date.now() - serve.shownAt;
+  if (visibleMs < serve.minVisibleMs) return;
+  const response = await waitspinFetch(state.base_url + "/v1/events/impression", {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + state.api_key,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      serve_id: serve.serveId,
+      serve_receipt: serve.serveReceipt,
+      install_id: state.install_id,
+      visible_ms: Math.max(visibleMs, serve.minVisibleMs),
+    }),
+  });
+  if (response.ok) serve.impressionRecorded = true;
+}
+
+function sessionKey(inputJson) {
+  return (
+    inputJson.session_id ||
+    inputJson.transcript_path ||
+    inputJson.cwd ||
+    "claude-code"
+  );
+}
+
+function pruneSessions(cache) {
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  for (const [key, value] of Object.entries(cache.sessions || {})) {
+    if ((value.lastSeenAt || 0) < cutoff) delete cache.sessions[key];
+  }
+}
+
+async function main() {
+  const statePath = argValue("--state");
+  if (!statePath) return;
+  const stdin = await readStdin();
+  let inputJson = {};
+  try {
+    inputJson = stdin.trim() ? JSON.parse(stdin) : {};
+  } catch {
+    inputJson = {};
+  }
+  const state = await readJson(statePath, null);
+  if (!state?.api_key || !state.install_id || !state.base_url || !state.cache_path) {
+    return;
+  }
+
+  const previous = await runPreviousStatusLine(
+    state.previous_status_line?.type === "command"
+      ? state.previous_status_line.command
+      : "",
+    stdin,
+  );
+  let renderedSession = null;
+
+  try {
+    renderedSession = await withCacheLock(state.cache_path, async () => {
+      const cache = await readJson(state.cache_path, { sessions: {} });
+      if (!cache.sessions || typeof cache.sessions !== "object") cache.sessions = {};
+      const key = sessionKey(inputJson);
+      const session = cache.sessions[key] || {};
+      session.lastSeenAt = Date.now();
+      cache.sessions[key] = session;
+
+      if (session.activeServe && serveIsExpired(session.activeServe)) {
+        session.activeServe = null;
+      }
+      await recordImpression(state, session);
+      const shouldFetchNext = !session.activeServe
+        ? Date.now() - (session.lastFetchAt || 0) >= FETCH_INTERVAL_MS
+        : session.activeServe.impressionRecorded &&
+          Date.now() - (session.lastFetchAt || 0) >= FETCH_INTERVAL_MS;
+      if (shouldFetchNext) {
+        await fetchNextServe(state, session);
+      }
+      pruneSessions(cache);
+      await writeJson(state.cache_path, cache);
+      return session;
+    });
+  } catch {
+    // Statusline rendering must never interrupt Claude Code.
+  }
+
+  const sponsor = renderedSession?.activeServe?.line
+    ? "Sponsored: " + renderedSession.activeServe.line
+    : "";
+  const lines = [previous, sponsor].filter(Boolean);
+  if (lines.length > 0) process.stdout.write(lines.join("\n"));
+}
+
+main().catch(() => {});
+`;
+}
+async function writeClaudeCodeRuntime(runtimePath) {
+    await mkdir(path.dirname(runtimePath), { recursive: true });
+    await writeFile(runtimePath, claudeCodeStatuslineRuntimeSource(), {
+        encoding: "utf8",
+        mode: 0o755,
+    });
+    await chmod(runtimePath, 0o755);
+}
+function assertSafeClaudeCodeManagedPath(filePath) {
+    const installRoot = path.resolve(claudeCodeInstallDir());
+    const resolved = path.resolve(filePath);
+    if (!resolved.startsWith(`${installRoot}${path.sep}`) ||
+        !path.basename(resolved).startsWith("claude-code-")) {
+        throw new Error("Refusing to manage a Claude Code WaitSpin file outside ~/.waitspin.");
+    }
+    return resolved;
+}
+export async function runClaudeCodeInstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const baseUrl = resolveCredentialedBaseUrl(flags);
+    const statePath = claudeCodeStatePath();
+    const runtimePath = claudeCodeRuntimePath();
+    const cachePath = claudeCodeCachePath();
+    const settingsPath = claudeCodeSettingsPath();
+    const existingState = await loadClaudeCodeInstallState();
+    const installId = existingState?.install_id || generateInstallId();
+    const managedStatusLine = managedClaudeCodeStatusLine({
+        runtimePath,
+        statePath,
+    });
+    const settings = await loadClaudeCodeSettings();
+    const scopedStatusLine = await findClaudeCodeScopedStatusLine();
+    const scopedStatusLineBlockedReason = claudeCodeScopedStatusLineBlocker(scopedStatusLine, managedStatusLine);
+    let settingsUpdate = null;
+    let settingsBlockedReason = null;
+    try {
+        settingsUpdate = resolveClaudeCodeSettingsUpdate({
+            settings,
+            managedStatusLine,
+            existingState,
+            composeExisting: booleanFlag(flags, "compose-existing"),
+        });
+    }
+    catch (error) {
+        if (!dryRun)
+            throw error;
+        settingsBlockedReason =
+            error instanceof Error ? error.message : String(error);
+    }
+    if (scopedStatusLineBlockedReason && !dryRun) {
+        throw new Error(scopedStatusLineBlockedReason);
+    }
+    const summary = {
+        ok: true,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        mode: "statusline-command",
+        install_id: installId,
+        publisher_target: CLAUDE_CODE_PUBLISHER_TARGET,
+        state_path: statePath,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        settings_path: settingsPath,
+        settings_action: settingsUpdate?.action ?? "blocked",
+        composed_existing_status_line: settingsUpdate?.composedExistingStatusLine ?? false,
+        note: "Installs WaitSpin through Claude Code's official statusLine.command surface.",
+        next: "check_status",
+        next_command: "waitspin claude-code status",
+    };
+    if (dryRun) {
+        const blockedReason = settingsBlockedReason ?? scopedStatusLineBlockedReason;
+        printJson({
+            ...summary,
+            dry_run: true,
+            publisher_registered: false,
+            has_existing_status_line: Boolean(settings.statusLine),
+            ...(scopedStatusLine
+                ? {
+                    scoped_status_line: {
+                        scope: scopedStatusLine.scope,
+                        path: scopedStatusLine.path,
+                        overrides_user_settings: Boolean(scopedStatusLineBlockedReason),
+                    },
+                }
+                : {}),
+            ...(blockedReason
+                ? {
+                    would_fail: true,
+                    settings_blocked_reason: blockedReason,
+                    next: settingsBlockedReason
+                        ? "resolve_status_line_conflict"
+                        : "resolve_project_status_line_override",
+                    ...(settingsBlockedReason
+                        ? {
+                            next_command: "waitspin claude-code install --compose-existing",
+                        }
+                        : {
+                            human_message: "Current project/local Claude Code settings override user-level statusLine. Remove or compose that statusLine before installing WaitSpin for this project.",
+                        }),
+                }
+                : {}),
+        });
+        return;
+    }
+    if (!settingsUpdate) {
+        throw new Error("Unable to resolve Claude Code settings update.");
+    }
+    const claudeVersion = await assertSupportedClaudeCodeVersion();
+    const apiKey = requireApiKey(flags);
+    const registration = await registerPublisherInstall({
+        baseUrl,
+        apiKey,
+        installId,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+    });
+    const installedAt = new Date().toISOString();
+    const installState = {
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        install_id: registration.install_id,
+        publisher_id: registration.publisher_id,
+        publisher_target: registration.target,
+        registered_at: installedAt,
+        base_url: baseUrl,
+        api_key: apiKey,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        settings_path: settingsPath,
+        managed_status_line: managedStatusLine,
+        previous_status_line: settingsUpdate.previousStatusLine,
+        composed_existing_status_line: settingsUpdate.composedExistingStatusLine,
+        claude_version: claudeVersion,
+        installed_at: installedAt,
+    };
+    try {
+        await writeClaudeCodeRuntime(runtimePath);
+        await writeJsonObjectFile(statePath, installState, 0o600);
+        await writeJsonObjectFile(settingsPath, settingsUpdate.nextSettings);
+    }
+    catch (error) {
+        if (existingState) {
+            await writeJsonObjectFile(statePath, existingState, 0o600).catch(() => { });
+        }
+        else {
+            await Promise.resolve(rm(statePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(runtimePath, { force: true, recursive: true })).catch(() => { });
+        }
+        throw error;
+    }
+    printJson({
+        ...summary,
+        ...redactedClaudeCodeState(installState),
+        publisher_registered: true,
+        claude_version: claudeVersion,
+        next: "launch_claude_code",
+        next_command: "claude",
+        acceptance_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+    });
+}
+export async function runClaudeCodeStatus() {
+    const state = await loadClaudeCodeInstallState();
+    const settings = await loadClaudeCodeSettings();
+    const managedStatusLine = state?.managed_status_line ?? null;
+    const currentStatusLine = settings.statusLine;
+    const statusLineConfigured = Boolean(managedStatusLine && statusLineEquals(currentStatusLine, managedStatusLine));
+    const scopedStatusLine = await findClaudeCodeScopedStatusLine();
+    const scopedStatusLineOverridden = Boolean(managedStatusLine &&
+        scopedStatusLine &&
+        !statusLineEquals(scopedStatusLine.statusLine, managedStatusLine));
+    const effectiveStatusLineConfigured = statusLineConfigured && !scopedStatusLineOverridden;
+    const runtimeInstalled = state
+        ? await pathExists(assertSafeClaudeCodeManagedPath(state.runtime_path))
+        : false;
+    const installed = Boolean(state && runtimeInstalled && effectiveStatusLineConfigured);
+    printJson({
+        ok: true,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        mode: "statusline-command",
+        installed,
+        publisher_registered: Boolean(state?.publisher_id),
+        install_id: state?.install_id ?? null,
+        publisher_id: state?.publisher_id ?? null,
+        publisher_target: state?.publisher_target ?? CLAUDE_CODE_PUBLISHER_TARGET,
+        state_path: claudeCodeStatePath(),
+        runtime_path: state?.runtime_path ?? claudeCodeRuntimePath(),
+        cache_path: state?.cache_path ?? claudeCodeCachePath(),
+        settings_path: claudeCodeSettingsPath(),
+        runtime_installed: runtimeInstalled,
+        status_line_configured: statusLineConfigured,
+        effective_status_line_configured: effectiveStatusLineConfigured,
+        status_line_overridden: scopedStatusLineOverridden,
+        ...(scopedStatusLineOverridden && scopedStatusLine
+            ? {
+                status_line_override_scope: scopedStatusLine.scope,
+                status_line_override_path: scopedStatusLine.path,
+            }
+            : {}),
+        composed_existing_status_line: Boolean(state?.composed_existing_status_line),
+        has_previous_status_line: Boolean(state?.previous_status_line),
+        claude_version: state?.claude_version ?? null,
+        ...(installed
+            ? {
+                next: "launch_claude_code",
+                next_command: "claude",
+                acceptance_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+            }
+            : {
+                next: "install_claude_code",
+                next_command: "waitspin claude-code install --compose-existing",
+                human_message: scopedStatusLineOverridden
+                    ? "Claude Code WaitSpin support is installed in user settings, but a higher-priority project/local statusLine overrides it in this directory."
+                    : "Claude Code WaitSpin statusline support is not installed for this user.",
+            }),
+    });
+}
+export async function runClaudeCodeUninstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const state = await loadClaudeCodeInstallState();
+    const settings = await loadClaudeCodeSettings();
+    const declaredRemovePaths = state
+        ? [
+            state.runtime_path,
+            state.cache_path,
+            claudeCodeStatePath(),
+        ]
+        : [claudeCodeStatePath()];
+    let nextSettings = null;
+    let settingsAction = "not-managed";
+    let settingsWarning = null;
+    if (state?.managed_status_line) {
+        if (!statusLineEquals(settings.statusLine, state.managed_status_line)) {
+            settingsAction = "skip-user-settings";
+            settingsWarning =
+                "Claude Code statusLine is no longer the WaitSpin managed command; leaving user settings unchanged while removing WaitSpin-managed files.";
+        }
+        else {
+            nextSettings = { ...settings };
+            if (state.previous_status_line !== undefined) {
+                nextSettings.statusLine = state.previous_status_line;
+                settingsAction = "restore-previous";
+            }
+            else {
+                delete nextSettings.statusLine;
+                settingsAction = "remove-managed";
+            }
+        }
+    }
+    if (dryRun) {
+        printJson({
+            ok: true,
+            target: CLAUDE_CODE_PUBLISHER_TARGET,
+            dry_run: true,
+            installed: Boolean(state),
+            settings_action: settingsAction,
+            would_remove: declaredRemovePaths,
+            path_validation: state ? "deferred_until_apply" : "not_needed",
+            ...(settingsWarning
+                ? {
+                    settings_warning: settingsWarning,
+                }
+                : {}),
+        });
+        return;
+    }
+    const removePaths = state
+        ? [
+            assertSafeClaudeCodeManagedPath(state.runtime_path),
+            assertSafeClaudeCodeManagedPath(state.cache_path),
+            claudeCodeStatePath(),
+        ]
+        : [claudeCodeStatePath()];
+    if (nextSettings) {
+        await writeJsonObjectFile(claudeCodeSettingsPath(), nextSettings);
+    }
+    await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
+    printJson({
+        ok: true,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        uninstalled: true,
+        settings_action: settingsAction,
+        removed: removePaths,
+        ...(settingsWarning ? { settings_warning: settingsWarning } : {}),
+    });
+}
 export async function main(argv = process.argv.slice(2)) {
     const { command, flags, positionals } = parseArgs(argv);
     if (command === "init") {
@@ -662,6 +1703,18 @@ export async function main(argv = process.argv.slice(2)) {
         await runExtensionUninstall(flags);
         return;
     }
+    if (command === "claude-code" && positionals[0] === "install") {
+        await runClaudeCodeInstall(flags);
+        return;
+    }
+    if (command === "claude-code" && positionals[0] === "status") {
+        await runClaudeCodeStatus();
+        return;
+    }
+    if (command === "claude-code" && positionals[0] === "uninstall") {
+        await runClaudeCodeUninstall(flags);
+        return;
+    }
     usage();
 }
 function isDirectEntrypoint() {