vibe-coding-master 0.7.11 → 0.7.13

package/README.md

@@ -228,6 +228,34 @@ such as a Dev Container or VM.
 Model and effort can be selected before start/resume/restart. Changes affect the
 next launched process, not a currently running Claude Code process.
 
+### GPT Through Claude Code Router
+
+VCM can launch its normal Claude Code sessions with `GPT-5.6 Sol (CCR)` through
+a host-running [Claude Code Router](https://github.com/musistudio/claude-code-router).
+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:
+
+```text
+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:
+
+1. enter and save the CCR API key;
+2. enable `CCR GPT models`;
+3. confirm the status is `available`;
+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 and is never returned by the settings API. CCR settings are applied
+only to the child Claude Code process being launched. Native Claude selections
+remain unchanged. 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
 
 The launch template stores per-role defaults:

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

@@ -0,0 +1,149 @@
+import { CCR_GATEWAY_BASE_URL, 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 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}.`);
+                }
+                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)}`
+                };
+            }
+        }
+    };
+}
+async function requestJson(fetchImpl, url, timeoutMs, headers = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                ...headers
+            },
+            signal: controller.signal
+        });
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            payload = undefined;
+        }
+        return { response, payload };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function isCcrGateway(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    return value.name === "claude-code-router"
+        || value.plugin === "claude-code-router"
+        || value.core === "next-ai-gateway";
+}
+function readModelDescriptors(value) {
+    if (!isObject(value) || !Array.isArray(value.data)) {
+        return undefined;
+    }
+    const models = [];
+    for (const item of value.data) {
+        if (!isObject(item) || typeof item.id !== "string" || !item.id.trim()) {
+            return undefined;
+        }
+        models.push({
+            id: item.id.trim(),
+            ...(typeof item.display_name === "string" && item.display_name.trim()
+                ? { displayName: item.display_name.trim() }
+                : {})
+        });
+    }
+    return models;
+}
+function isRequiredModel(model) {
+    if (model.id === CCR_GPT_MODEL_ID) {
+        return true;
+    }
+    const target = normalizeModelName(CCR_GPT_MODEL_ID);
+    return normalizeModelName(model.displayName) === target
+        || normalizeModelName(decodeCcrModelId(model.id)) === target;
+}
+function decodeCcrModelId(modelId) {
+    if (!modelId.startsWith(CCR_ENCODED_MODEL_PREFIX)) {
+        return undefined;
+    }
+    const encoded = modelId.slice(CCR_ENCODED_MODEL_PREFIX.length);
+    if (!encoded || encoded.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(encoded)) {
+        return undefined;
+    }
+    return Buffer.from(encoded, "hex").toString("utf8");
+}
+function normalizeModelName(value) {
+    return (value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function invalidResponse(error) {
+    return {
+        connectionState: "invalid-response",
+        modelAvailable: false,
+        error
+    };
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -1,3 +1,4 @@
+import { isCcrSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 export function createClaudeAdapter(runner) {
     return {
@@ -22,7 +23,9 @@ export function createClaudeAdapter(runner) {
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
-            args.push("--model", model);
+            if (!isCcrSessionModel(model)) {
+                args.push("--model", model);
+            }
             if (effort === "ultracode") {
                 args.push("--settings", JSON.stringify({ ultracode: true }));
             }

package/dist/backend/adapters/filesystem.js

@@ -89,6 +89,9 @@ export function createNodeFileSystemAdapter() {
                 await fs.rename(tempPath, targetPath);
             });
         },
+        async chmod(targetPath, mode) {
+            await runFileOperation(() => fs.chmod(targetPath, mode));
+        },
         async ensureFile(targetPath, content, options = {}) {
             if (!options.overwrite && await this.pathExists(targetPath)) {
                 return false;

package/dist/backend/api/app-settings-routes.js

@@ -5,4 +5,13 @@ export function registerAppSettingsRoutes(app, deps) {
     app.put("/api/settings/preferences", async (request) => {
         return deps.appSettings.updatePreferences(request.body ?? {});
     });
+    app.get("/api/settings/ccr", async () => {
+        return deps.ccrIntegration.getStatus();
+    });
+    app.put("/api/settings/ccr", async (request) => {
+        return deps.ccrIntegration.updateSettings(request.body ?? {});
+    });
+    app.post("/api/settings/ccr/check", async () => {
+        return deps.ccrIntegration.checkConnection();
+    });
 }

package/dist/backend/api/session-routes.js

@@ -22,6 +22,7 @@ export function registerSessionRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
         const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
+        await deps.sessionService.assertModelLaunchReady(request.body?.model ?? existing?.model);
         if (existing) {
             await deps.translationService.stopSession(existing.id, { clearCache: true });
             deps.roundService.stopSession(existing.id);

package/dist/backend/api/translation-worker-routes.js

@@ -40,6 +40,7 @@ export function registerTranslationWorkerRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Translator");
         const existing = await deps.sessionService.getRoleSession(project.repoRoot, taskSlug, "translator");
+        await deps.sessionService.assertModelLaunchReady(request.body?.model ?? existing?.model);
         if (existing) {
             await deps.translationService.stopSession(existing.id, { clearCache: true });
         }

package/dist/backend/server.js

@@ -4,11 +4,13 @@ import Fastify from "fastify";
 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 { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
+import { createCcrIntegrationService } from "./services/ccr-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
@@ -78,7 +80,10 @@ export async function createServer(deps, options = {}) {
         });
     });
     registerDiagnosticsRoutes(app, { diagnosticsService: deps.diagnosticsService });
-    registerAppSettingsRoutes(app, { appSettings: deps.appSettings });
+    registerAppSettingsRoutes(app, {
+        appSettings: deps.appSettings,
+        ccrIntegration: deps.ccrIntegration
+    });
     registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
     registerGateReviewRoutes(app, {
         projectService: deps.projectService,
@@ -156,6 +161,7 @@ export async function createServer(deps, options = {}) {
         onManualInterrupt: (sessionId) => deps.terminalInterruptService.handleManualInterrupt(sessionId)
     });
     app.addHook("onReady", async () => {
+        await deps.ccrIntegration.initialize();
         await cleanupRecentTranslationRuntime(deps);
         deps.runtimeCoordinator.start();
         await deps.gatewayService.start();
@@ -202,6 +208,10 @@ export function createDefaultServerDeps(options = {}) {
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
     const appSettings = createAppSettingsService({ fs });
+    const ccrIntegration = createCcrIntegrationService({
+        settings: appSettings,
+        gateway: createCcrGatewayAdapter()
+    });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
     const artifactService = createArtifactService(fs);
@@ -217,6 +227,7 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         taskWorkflowService,
+        ccrIntegration,
         apiUrl: options.apiUrl
     });
     const harnessService = createHarnessService({
@@ -396,6 +407,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     return {
         appSettings,
+        ccrIntegration,
         projectService,
         taskService,
         taskCloseService,

package/dist/backend/services/app-settings-service.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
 import { createDefaultLaunchTemplate, DEFAULT_TRANSLATION_OUTPUT_MODE, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
-import { CLAUDE_MODEL_OPTIONS, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
+import { CLAUDE_MODEL_OPTIONS, CCR_GPT_SESSION_MODEL, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
 export function createAppSettingsService(deps) {
@@ -20,6 +20,7 @@ export function createAppSettingsService(deps) {
         let shouldSave = false;
         if (await deps.fs.pathExists(settingsPath)) {
             raw = await deps.fs.readJson(settingsPath);
+            await deps.fs.chmod?.(settingsPath, 0o600);
         }
         else {
             shouldSave = true;
@@ -33,6 +34,7 @@ export function createAppSettingsService(deps) {
     async function saveSettings(settings) {
         cachedSettings = settings;
         await deps.fs.writeJsonAtomic(settingsPath, settings);
+        await deps.fs.chmod?.(settingsPath, 0o600);
     }
     async function loadProjectIndex() {
         if (cachedProjectIndex) {
@@ -144,6 +146,21 @@ export function createAppSettingsService(deps) {
                 requiredGates: normalizedRequiredGates
             };
         },
+        async getCcrIntegrationSettings() {
+            return normalizeCcrIntegrationSettings((await loadSettings()).ccr);
+        },
+        async updateCcrIntegrationSettings(input) {
+            const current = await loadSettings();
+            const ccr = normalizeCcrIntegrationSettings({
+                ...current.ccr,
+                ...input
+            });
+            await saveSettings({
+                ...current,
+                ccr
+            });
+            return ccr;
+        },
         getSettingsPath() {
             return settingsPath;
         },
@@ -229,8 +246,18 @@ function normalizeSettingsFile(input) {
     if (gateReview) {
         settings.gateReview = gateReview;
     }
+    settings.ccr = normalizeCcrIntegrationSettings(input.ccr);
     return settings;
 }
+function normalizeCcrIntegrationSettings(input) {
+    const candidate = isObject(input) ? input : {};
+    const apiKey = typeof candidate.apiKey === "string" ? candidate.apiKey.trim() : "";
+    return {
+        version: 1,
+        enabled: candidate.enabled === true && apiKey.length > 0,
+        apiKey
+    };
+}
 function normalizePreferences(input) {
     const candidate = isObject(input) ? input : {};
     const rawFlowPauseAlerts = "flowPauseAlerts" in candidate
@@ -304,6 +331,9 @@ function normalizeClaudeModel(input, fallback) {
     if (typeof input !== "string") {
         return fallback;
     }
+    if (input === CCR_GPT_SESSION_MODEL) {
+        return input;
+    }
     const model = CLAUDE_MODEL_OPTIONS.find((option) => option.value === input);
     return model?.value ?? fallback;
 }

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

@@ -0,0 +1,194 @@
+import { CCR_GATEWAY_BASE_URL, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
+import { VcmError } from "../errors.js";
+const DEFAULT_CACHE_TTL_MS = 10_000;
+export function createCcrIntegrationService(deps) {
+    const now = deps.now ?? (() => new Date());
+    const cacheTtlMs = deps.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    let cachedProbe;
+    let inFlight;
+    async function probe(force = false) {
+        const settings = await deps.settings.getCcrIntegrationSettings();
+        if (!settings.apiKey) {
+            throw missingApiKeyError();
+        }
+        const currentTime = now();
+        if (!force && cachedProbe && currentTime.getTime() - cachedProbe.checkedAtMs <= cacheTtlMs) {
+            return cachedProbe;
+        }
+        if (inFlight) {
+            return inFlight;
+        }
+        inFlight = deps.gateway.probe(settings.apiKey).then((result) => {
+            const checkedAtDate = now();
+            cachedProbe = {
+                result,
+                checkedAt: checkedAtDate.toISOString(),
+                checkedAtMs: checkedAtDate.getTime()
+            };
+            return cachedProbe;
+        }).finally(() => {
+            inFlight = undefined;
+        });
+        return inFlight;
+    }
+    async function buildStatus(options = {}) {
+        const settings = await deps.settings.getCcrIntegrationSettings();
+        if (!settings.enabled) {
+            return createStatus({
+                enabled: false,
+                apiKeyConfigured: Boolean(settings.apiKey),
+                connectionState: "disabled",
+                modelAvailable: false,
+                error: settings.apiKey ? undefined : "Save a CCR API key before enabling CCR GPT models."
+            });
+        }
+        if (!cachedProbe && options.refreshIfMissing) {
+            await probe();
+        }
+        if (!cachedProbe) {
+            return createStatus({
+                enabled: true,
+                apiKeyConfigured: true,
+                connectionState: "checking",
+                modelAvailable: false
+            });
+        }
+        return createStatus({
+            enabled: true,
+            apiKeyConfigured: true,
+            connectionState: cachedProbe.result.connectionState,
+            modelAvailable: cachedProbe.result.modelAvailable,
+            checkedAt: cachedProbe.checkedAt,
+            error: cachedProbe.result.error
+        });
+    }
+    return {
+        async initialize() {
+            const settings = await deps.settings.getCcrIntegrationSettings();
+            if (settings.enabled) {
+                await probe(true);
+            }
+        },
+        async getStatus() {
+            return buildStatus({ refreshIfMissing: true });
+        },
+        async updateSettings(input) {
+            if (input.apiKey !== undefined && typeof input.apiKey !== "string") {
+                throw invalidSettingsError("CCR API key must be a string.");
+            }
+            if (input.enabled !== undefined && typeof input.enabled !== "boolean") {
+                throw invalidSettingsError("CCR enabled state must be a boolean.");
+            }
+            if (input.clearApiKey !== undefined && typeof input.clearApiKey !== "boolean") {
+                throw invalidSettingsError("CCR clear-key state must be a boolean.");
+            }
+            const current = await deps.settings.getCcrIntegrationSettings();
+            const clearApiKey = input.clearApiKey === true;
+            const nextApiKey = clearApiKey
+                ? ""
+                : input.apiKey === undefined
+                    ? current.apiKey
+                    : input.apiKey.trim();
+            const nextEnabled = clearApiKey ? false : input.enabled ?? current.enabled;
+            if (nextEnabled && !nextApiKey) {
+                throw missingApiKeyError();
+            }
+            await deps.settings.updateCcrIntegrationSettings({
+                enabled: nextEnabled,
+                apiKey: nextApiKey
+            });
+            if (clearApiKey || !nextEnabled) {
+                cachedProbe = undefined;
+                return buildStatus();
+            }
+            if (input.apiKey !== undefined || input.enabled === true) {
+                cachedProbe = undefined;
+                await probe(true);
+            }
+            return buildStatus();
+        },
+        async checkConnection() {
+            const settings = await deps.settings.getCcrIntegrationSettings();
+            if (!settings.enabled) {
+                throw new VcmError({
+                    code: "CCR_DISABLED",
+                    message: "CCR GPT models are disabled.",
+                    statusCode: 409,
+                    hint: "Save the CCR API key and enable CCR GPT models before checking the connection."
+                });
+            }
+            await probe(true);
+            return buildStatus();
+        },
+        async getLaunchEnvironment(model) {
+            if (!isCcrSessionModel(model)) {
+                return {};
+            }
+            const settings = await deps.settings.getCcrIntegrationSettings();
+            if (!settings.enabled) {
+                throw new VcmError({
+                    code: "CCR_DISABLED",
+                    message: "CCR GPT models are disabled.",
+                    statusCode: 409,
+                    hint: "Enable CCR GPT models in VCM Settings before starting this session."
+                });
+            }
+            const checked = await probe();
+            if (checked.result.connectionState !== "available" || !checked.result.modelAvailable) {
+                throw new VcmError({
+                    code: "CCR_MODEL_UNAVAILABLE",
+                    message: checked.result.error ?? `CCR model ${CCR_GPT_MODEL_ID} is unavailable.`,
+                    statusCode: 409,
+                    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");
+            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_AUTH_TOKEN: settings.apiKey,
+                ANTHROPIC_MODEL: CCR_GPT_MODEL_ID,
+                CCR_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
+                CODEXL_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
+                ANTHROPIC_SMALL_FAST_MODEL: CCR_GPT_MODEL_ID,
+                CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+                NO_PROXY: noProxy,
+                no_proxy: noProxy
+            };
+        }
+    };
+}
+function createStatus(input) {
+    const reason = input.error
+        ?? (input.enabled ? "CCR GPT-5.6 Sol is unavailable." : "Enable CCR GPT models in Settings.");
+    return {
+        ...input,
+        modelOptions: createSessionModelOptions(input.enabled && input.modelAvailable, reason)
+    };
+}
+function missingApiKeyError() {
+    return new VcmError({
+        code: "CCR_API_KEY_MISSING",
+        message: "CCR API key is not configured.",
+        statusCode: 400,
+        hint: "Save the CCR API key before enabling CCR GPT models."
+    });
+}
+function invalidSettingsError(message) {
+    return new VcmError({
+        code: "CCR_SETTINGS_INVALID",
+        message,
+        statusCode: 400
+    });
+}
+export function mergeNoProxy(current, host) {
+    const values = (current ?? "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (!values.includes(host)) {
+        values.push(host);
+    }
+    return values.join(",");
+}