vibe-coding-master 0.7.14 → 0.7.15

package/README.md

@@ -235,14 +235,16 @@ a host-running [Claude Code Router](https://github.com/musistudio/claude-code-ro
 CCR must already be installed, authenticated, configured, and running on the
 host. VCM does not manage the CCR process.
 
-VCM uses this fixed Dev Container endpoint:
+VCM automatically checks the local-host and DevContainer endpoints:
 
 ```text
+http://127.0.0.1:3456
 http://host.docker.internal:3456
 ```
 
-Configure CCR to listen on port `3456` with an API key and make it reachable
-from the container. In the VCM `Settings` section:
+Configure CCR to listen on port `3456` with an API key. When VCM runs in a
+DevContainer, make the second endpoint reachable from the container. In the VCM
+`Settings` section:
 
 1. enter and save the CCR API key;
 2. enable `CCR GPT models`;
@@ -250,13 +252,15 @@ from the container. In the VCM `Settings` section:
 4. select `GPT-5.6 Sol (CCR)` in any Session model control.
 
 The key is stored in global VCM state (`~/.vcm/settings.json`) with owner-only
-permissions, is used only to check CCR and discover models, and is never
-returned by the settings API. GPT sessions use the CCR-managed Claude Code
-`apiKeyHelper`; VCM removes inherited Anthropic token variables only from those
-child processes. Native Claude selections retain their existing launch and
-authentication behavior. If CCR is disabled, unreachable, rejects the key, or
-does not expose `Codex API/gpt-5.6-sol`, VCM blocks the new Start, Resume, or
-Restart and does not fall back to another model.
+permissions and is never returned by the settings API. It is used for CCR
+checks, model discovery, and the GPT-only `apiKeyHelper`. GPT sessions receive a
+child-only `--settings` override; VCM removes inherited Anthropic token
+variables only from those child processes. VCM removes CCR-owned takeover
+entries from global Claude settings, so native Claude selections keep their
+normal launch and account authentication. If CCR is disabled, unreachable,
+rejects the key, or does not expose
+`Codex API/gpt-5.6-sol`, VCM blocks the new Start, Resume, or Restart and does
+not fall back to another model.
 
 ## Launch Template
 

package/dist/backend/adapters/ccr-gateway-adapter.js

@@ -1,62 +1,84 @@
-import { CCR_GATEWAY_BASE_URL, CCR_GPT_MODEL_ID } from "../../shared/types/session.js";
+import { CCR_GATEWAY_BASE_URLS, CCR_GPT_MODEL_ID } from "../../shared/types/session.js";
 const DEFAULT_TIMEOUT_MS = 3_000;
 const CCR_ENCODED_MODEL_PREFIX = "anthropic/claude-ccr-h";
 export function createCcrGatewayAdapter(deps = {}) {
-    const baseUrl = (deps.baseUrl ?? CCR_GATEWAY_BASE_URL).replace(/\/+$/, "");
+    const baseUrls = (deps.baseUrl ? [deps.baseUrl] : CCR_GATEWAY_BASE_URLS)
+        .map((baseUrl) => baseUrl.replace(/\/+$/, ""));
     const fetchImpl = deps.fetch ?? globalThis.fetch;
     const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     return {
         async probe(apiKey) {
-            try {
-                const root = await requestJson(fetchImpl, `${baseUrl}/`, timeoutMs);
-                if (!root.response.ok) {
-                    return invalidResponse(`CCR gateway root returned HTTP ${root.response.status}.`);
+            const failures = [];
+            for (const baseUrl of baseUrls) {
+                const result = await probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs);
+                if (result.baseUrl) {
+                    return result;
                 }
-                if (!isCcrGateway(root.payload)) {
-                    return {
-                        connectionState: "not-ccr",
-                        modelAvailable: false,
-                        error: `The fixed CCR endpoint ${baseUrl} did not identify a Claude Code Router gateway.`
-                    };
-                }
-                const models = await requestJson(fetchImpl, `${baseUrl}/v1/models`, timeoutMs, {
-                    authorization: `Bearer ${apiKey}`,
-                    "user-agent": "Claude Code"
-                });
-                if (models.response.status === 401 || models.response.status === 403) {
-                    return {
-                        connectionState: "unauthorized",
-                        modelAvailable: false,
-                        error: "CCR rejected the configured API key."
-                    };
-                }
-                if (!models.response.ok) {
-                    return invalidResponse(`CCR model discovery returned HTTP ${models.response.status}.`);
-                }
-                const modelDescriptors = readModelDescriptors(models.payload);
-                if (!modelDescriptors) {
-                    return invalidResponse("CCR returned an invalid /v1/models response.");
-                }
-                const modelAvailable = modelDescriptors.some(isRequiredModel);
-                return {
-                    connectionState: "available",
-                    modelAvailable,
-                    ...(modelAvailable
-                        ? {}
-                        : { error: `CCR does not expose the required model ${CCR_GPT_MODEL_ID}.` })
-                };
-            }
-            catch (error) {
-                const timedOut = isAbortError(error);
-                return {
-                    connectionState: "unreachable",
-                    modelAvailable: false,
-                    error: timedOut
-                        ? `CCR connection timed out after ${timeoutMs} ms at ${baseUrl}.`
-                        : `CCR could not be reached from the VCM container backend at ${baseUrl}. Reason: ${errorMessage(error)}`
-                };
+                failures.push(result);
             }
+            return combineProbeFailures(baseUrls, failures);
+        }
+    };
+}
+async function probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs) {
+    try {
+        const root = await requestJson(fetchImpl, `${baseUrl}/`, timeoutMs);
+        if (!root.response.ok) {
+            return invalidResponse(`Gateway root at ${baseUrl} returned HTTP ${root.response.status}.`);
+        }
+        if (!isCcrGateway(root.payload)) {
+            return {
+                connectionState: "not-ccr",
+                modelAvailable: false,
+                error: `${baseUrl} did not identify a Claude Code Router gateway.`
+            };
         }
+        const models = await requestJson(fetchImpl, `${baseUrl}/v1/models`, timeoutMs, {
+            authorization: `Bearer ${apiKey}`,
+            "user-agent": "Claude Code"
+        });
+        if (models.response.status === 401 || models.response.status === 403) {
+            return {
+                connectionState: "unauthorized",
+                modelAvailable: false,
+                baseUrl,
+                error: "CCR rejected the configured API key."
+            };
+        }
+        if (!models.response.ok) {
+            return invalidResponse(`CCR model discovery at ${baseUrl} returned HTTP ${models.response.status}.`, baseUrl);
+        }
+        const modelDescriptors = readModelDescriptors(models.payload);
+        if (!modelDescriptors) {
+            return invalidResponse("CCR returned an invalid /v1/models response.", baseUrl);
+        }
+        const modelAvailable = modelDescriptors.some(isRequiredModel);
+        return {
+            connectionState: "available",
+            modelAvailable,
+            baseUrl,
+            ...(modelAvailable
+                ? {}
+                : { error: `CCR does not expose the required model ${CCR_GPT_MODEL_ID}.` })
+        };
+    }
+    catch (error) {
+        const timedOut = isAbortError(error);
+        return {
+            connectionState: "unreachable",
+            modelAvailable: false,
+            error: timedOut
+                ? `CCR connection timed out after ${timeoutMs} ms at ${baseUrl}.`
+                : `CCR could not be reached from the VCM backend at ${baseUrl}. Reason: ${errorMessage(error)}`
+        };
+    }
+}
+function combineProbeFailures(baseUrls, failures) {
+    const lastFailure = failures.at(-1);
+    return {
+        connectionState: lastFailure?.connectionState ?? "unreachable",
+        modelAvailable: false,
+        error: `CCR was not found at ${baseUrls.join(" or ")}. ${failures.map((failure) => failure.error).filter(Boolean).join(" ")}`.trim()
     };
 }
 async function requestJson(fetchImpl, url, timeoutMs, headers = {}) {
@@ -131,10 +153,11 @@ function decodeCcrModelId(modelId) {
 function normalizeModelName(value) {
     return (value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "");
 }
-function invalidResponse(error) {
+function invalidResponse(error, baseUrl) {
     return {
         connectionState: "invalid-response",
         modelAvailable: false,
+        ...(baseUrl ? { baseUrl } : {}),
         error
     };
 }

package/dist/backend/adapters/claude-adapter.js

@@ -18,8 +18,9 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default") {
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride) {
             const args = ["--agent", role];
+            const sessionSettings = { ...settingsOverride };
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
@@ -27,11 +28,14 @@ export function createClaudeAdapter(runner) {
                 args.push("--model", model);
             }
             if (effort === "ultracode") {
-                args.push("--settings", JSON.stringify({ ultracode: true }));
+                sessionSettings.ultracode = true;
             }
             else if (effort !== "default") {
                 args.push("--effort", effort);
             }
+            if (Object.keys(sessionSettings).length > 0) {
+                args.push("--settings", JSON.stringify(sessionSettings));
+            }
             if (permissionMode !== "default") {
                 args.push("--permission-mode", permissionMode);
             }

package/dist/backend/adapters/claude-settings-adapter.js

@@ -0,0 +1,79 @@
+import { homedir } from "node:os";
+import path from "node:path";
+const CCR_ENV_KEYS = [
+    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_API_BASE_URL",
+    "CLAUDE_AGENT_API_BASE_URL",
+    "ANTHROPIC_MODEL",
+    "CCR_CLAUDE_CODE_MODEL",
+    "CODEXL_CLAUDE_CODE_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL"
+];
+export function createClaudeSettingsAdapter(deps) {
+    const settingsPath = deps.settingsPath ?? resolveClaudeSettingsPath(deps.env ?? process.env);
+    return {
+        async restoreNativeSettings() {
+            if (!(await deps.fs.pathExists(settingsPath))) {
+                return false;
+            }
+            const current = await deps.fs.readJson(settingsPath);
+            const restored = restoreNativeClaudeSettings(current);
+            if (!restored.changed) {
+                return false;
+            }
+            await deps.fs.writeJsonAtomic(settingsPath, restored.settings);
+            return true;
+        }
+    };
+}
+export function restoreNativeClaudeSettings(value) {
+    const settings = isObject(value) ? structuredClone(value) : {};
+    const helperIsCcr = typeof settings.apiKeyHelper === "string"
+        && settings.apiKeyHelper.includes(".claude-code-router");
+    const env = isObject(settings.env) ? settings.env : undefined;
+    const envUsesCcr = env
+        ? ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_BASE_URL", "CLAUDE_AGENT_API_BASE_URL"]
+            .some((key) => isCcrGatewayUrl(env[key]))
+        : false;
+    if (!helperIsCcr && !envUsesCcr) {
+        return { changed: false, settings };
+    }
+    let changed = false;
+    if (helperIsCcr) {
+        delete settings.apiKeyHelper;
+        changed = true;
+    }
+    if (env) {
+        for (const key of CCR_ENV_KEYS) {
+            if (key in env) {
+                delete env[key];
+                changed = true;
+            }
+        }
+        if (Object.keys(env).length === 0) {
+            delete settings.env;
+        }
+    }
+    return { changed, settings };
+}
+function resolveClaudeSettingsPath(env) {
+    const configDir = env.CLAUDE_CONFIG_DIR?.trim();
+    return path.join(configDir ? path.resolve(configDir) : path.join(homedir(), ".claude"), "settings.json");
+}
+function isCcrGatewayUrl(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    try {
+        const url = new URL(value);
+        return url.port === "3456"
+            && ["127.0.0.1", "localhost", "host.docker.internal"].includes(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/backend/server.js

@@ -5,6 +5,7 @@ import fastifyStatic from "@fastify/static";
 import { createArtifactService } from "./services/artifact-service.js";
 import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCcrGatewayAdapter } from "./adapters/ccr-gateway-adapter.js";
+import { createClaudeSettingsAdapter } from "./adapters/claude-settings-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
@@ -208,9 +209,11 @@ export function createDefaultServerDeps(options = {}) {
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
     const appSettings = createAppSettingsService({ fs });
+    const claudeSettings = createClaudeSettingsAdapter({ fs });
     const ccrIntegration = createCcrIntegrationService({
         settings: appSettings,
-        gateway: createCcrGatewayAdapter()
+        gateway: createCcrGatewayAdapter(),
+        restoreNativeClaudeSettings: () => claudeSettings.restoreNativeSettings()
     });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();

package/dist/backend/services/ccr-integration-service.js

@@ -1,6 +1,8 @@
 import { CCR_GATEWAY_BASE_URL, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
+import { fileURLToPath } from "node:url";
 import { VcmError } from "../errors.js";
 const DEFAULT_CACHE_TTL_MS = 10_000;
+const DEFAULT_API_KEY_HELPER_PATH = fileURLToPath(new URL("../../../scripts/ccr-api-key-helper.mjs", import.meta.url));
 export function createCcrIntegrationService(deps) {
     const now = deps.now ?? (() => new Date());
     const cacheTtlMs = deps.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
@@ -65,6 +67,9 @@ export function createCcrIntegrationService(deps) {
     return {
         async initialize() {
             const settings = await deps.settings.getCcrIntegrationSettings();
+            if (settings.apiKey) {
+                await deps.restoreNativeClaudeSettings?.();
+            }
             if (settings.enabled) {
                 await probe(true);
             }
@@ -97,6 +102,9 @@ export function createCcrIntegrationService(deps) {
                 enabled: nextEnabled,
                 apiKey: nextApiKey
             });
+            if (nextApiKey) {
+                await deps.restoreNativeClaudeSettings?.();
+            }
             if (clearApiKey || !nextEnabled) {
                 cachedProbe = undefined;
                 return buildStatus();
@@ -142,11 +150,13 @@ export function createCcrIntegrationService(deps) {
                     hint: "Check that host CCR is running on port 3456 and exposes GPT-5.6 Sol."
                 });
             }
-            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, "host.docker.internal");
+            const gatewayBaseUrl = checked.result.baseUrl ?? CCR_GATEWAY_BASE_URL;
+            const gatewayHost = new URL(gatewayBaseUrl).hostname;
+            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, gatewayHost);
             return {
-                ANTHROPIC_BASE_URL: CCR_GATEWAY_BASE_URL,
-                ANTHROPIC_API_BASE_URL: CCR_GATEWAY_BASE_URL,
-                CLAUDE_AGENT_API_BASE_URL: CCR_GATEWAY_BASE_URL,
+                ANTHROPIC_BASE_URL: gatewayBaseUrl,
+                ANTHROPIC_API_BASE_URL: gatewayBaseUrl,
+                CLAUDE_AGENT_API_BASE_URL: gatewayBaseUrl,
                 ANTHROPIC_AUTH_TOKEN: undefined,
                 ANTHROPIC_API_KEY: undefined,
                 ANTHROPIC_MODEL: CCR_GPT_MODEL_ID,
@@ -157,6 +167,18 @@ export function createCcrIntegrationService(deps) {
                 NO_PROXY: noProxy,
                 no_proxy: noProxy
             };
+        },
+        async getLaunchSettingsOverride(model) {
+            const settings = await deps.settings.getCcrIntegrationSettings();
+            if (settings.apiKey) {
+                await deps.restoreNativeClaudeSettings?.();
+            }
+            if (!isCcrSessionModel(model)) {
+                return undefined;
+            }
+            return {
+                apiKeyHelper: buildApiKeyHelperCommand(deps.apiKeyHelperPath ?? DEFAULT_API_KEY_HELPER_PATH)
+            };
         }
     };
 }
@@ -193,3 +215,12 @@ export function mergeNoProxy(current, host) {
     }
     return values.join(",");
 }
+export function buildApiKeyHelperCommand(helperPath) {
+    if (process.platform === "win32") {
+        return `${JSON.stringify(process.execPath)} ${JSON.stringify(helperPath)}`;
+    }
+    return `${quotePosixShell(process.execPath)} ${quotePosixShell(helperPath)}`;
+}
+function quotePosixShell(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/backend/services/session-service.js

@@ -55,7 +55,10 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort);
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         const resumeClaudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : undefined;
@@ -74,7 +77,7 @@ export function createSessionService(deps) {
                 ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId)
                 : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: taskRepoRoot
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -160,7 +163,10 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort ?? "medium");
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         const resumeClaudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : undefined;
@@ -191,7 +197,7 @@ export function createSessionService(deps) {
             ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId)
             : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort),
+            ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -270,7 +276,10 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort ?? "medium");
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         const resumeClaudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : undefined;
@@ -297,7 +306,7 @@ export function createSessionService(deps) {
             ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId)
             : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort),
+            ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -480,14 +489,17 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(session.permissionMode);
         const model = normalizeClaudeModel(session.model);
         const effort = normalizeClaudeEffort(session.effort);
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         // Spawn (`claude --resume`) always anchors at the base repoRoot so resume works
         // even if the persisted task cwd was deleted. `--resume` then restores the
         // session's own last cwd (tracked on `session.cwd`), so the `/cd` migrate below
         // fires only when that restored cwd differs from the target worktree.
         const launchCwd = repoRoot;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(session.role, config.claudeCommand, permissionMode, session.claudeSessionId, true, model, effort),
+            ...deps.claude.buildRoleStartCommand(session.role, config.claudeCommand, permissionMode, session.claudeSessionId, true, model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -561,6 +573,9 @@ export function createSessionService(deps) {
         }
         return deps.ccrIntegration.getLaunchEnvironment(model);
     }
+    async function getModelLaunchSettingsOverride(model) {
+        return deps.ccrIntegration?.getLaunchSettingsOverride(model);
+    }
     function isRuntimeSessionAlive(session) {
         if (!session || isExitedStatus(session.status) || session.pid === undefined) {
             return false;

package/dist/shared/types/session.js

@@ -45,7 +45,13 @@ export const CLAUDE_MODEL_OPTIONS = [
         available: true
     }
 ];
-export const CCR_GATEWAY_BASE_URL = "http://host.docker.internal:3456";
+export const CCR_LOCAL_GATEWAY_BASE_URL = "http://127.0.0.1:3456";
+export const CCR_CONTAINER_GATEWAY_BASE_URL = "http://host.docker.internal:3456";
+export const CCR_GATEWAY_BASE_URL = CCR_CONTAINER_GATEWAY_BASE_URL;
+export const CCR_GATEWAY_BASE_URLS = [
+    CCR_LOCAL_GATEWAY_BASE_URL,
+    CCR_CONTAINER_GATEWAY_BASE_URL
+];
 export const CCR_GPT_MODEL_ID = "Codex API/gpt-5.6-sol";
 export const CCR_GPT_SESSION_MODEL = `ccr:${CCR_GPT_MODEL_ID}`;
 export function isCcrSessionModel(model) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.7.14",
+  "version": "0.7.15",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [

package/scripts/ccr-api-key-helper.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const dataDir = process.env.VCM_DATA_DIR?.trim()
+  ? path.resolve(process.env.VCM_DATA_DIR)
+  : path.join(homedir(), ".vcm");
+
+try {
+  const settings = JSON.parse(await readFile(path.join(dataDir, "settings.json"), "utf8"));
+  const apiKey = settings?.ccr?.apiKey;
+  if (typeof apiKey !== "string" || !apiKey.trim()) {
+    process.exitCode = 1;
+  } else {
+    process.stdout.write(`${apiKey.trim()}\n`);
+  }
+} catch {
+  process.exitCode = 1;
+}