vibe-coding-master 0.7.44 → 0.7.45

package/README.md

@@ -243,18 +243,18 @@ Open `Usage Analytics` in the sidebar `Task` section to inspect native Claude
 Code usage for the active task. The report shows task totals and breakdowns by
 role and model for input, output, cache-read, and cache-creation tokens plus
 estimated USD cost. It combines every restart and resumed Claude session for
-all seven roles. CCR/GPT usage is excluded.
+all seven roles. Codex Bridge usage is excluded.
 
 VCM retains only aggregate task data in
 `<task-worktree>/.ai/vcm/telemetry/usage.json`. The file is temporary runtime
 state and is removed with the task worktree when the task is closed.
 
-### GPT Through Claude Code Router
+### GPT Through Codex Bridge
 
-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 can launch its normal Claude Code sessions with models provided by a
+host-running Codex Bridge. The Bridge must already be installed and running,
+and Codex must be logged in on the host. VCM does not manage the Bridge process
+or Codex login.
 
 VCM automatically checks the local-host and DevContainer endpoints:
 
@@ -263,36 +263,34 @@ http://127.0.0.1:3456
 http://host.docker.internal:3456
 ```
 
-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:
+Configure Codex Bridge to listen on port `3456`. When VCM runs in a
+DevContainer, start it with a container-reachable bind address such as
+`codex-bridge serve --host 0.0.0.0 --port 3456`. In the VCM `Settings` section:
 
-1. enter and save the CCR API key;
-2. enable `CCR GPT models`;
+1. enter and save the Codex Bridge API key;
+2. enable `Codex Bridge models`;
 3. confirm the status is `available`;
-4. select `GPT-5.6 Sol (CCR)` in any Session model control.
+4. select any discovered Codex Bridge model in a 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. It is used for CCR
-checks, model discovery, and the GPT-only `apiKeyHelper`. GPT sessions receive a
+permissions and is never returned by the settings API. It is used for Bridge
+checks, model discovery, and the Bridge-only `apiKeyHelper`. Bridge sessions receive a
 child-only `--settings` override and use the isolated Claude configuration root
-`~/.vcm/claude/ccr`. VCM never edits `~/.claude/settings.json`. Native Claude
+`~/.vcm/claude/codex-bridge`. VCM never edits `~/.claude/settings.json`. Native Claude
 sessions keep their normal configuration and account authentication; VCM only
-removes inherited environment variables that clearly point at the local CCR
-gateway from the native child process. Configure CCR without enabling its
-global Claude Code or Claude App takeover if those clients should remain on
-Anthropic.
+removes inherited environment variables that clearly point at the local Bridge
+from the native child process.
 
-CCR/GPT child processes use a hard context limit and auto-compaction window of
+Codex Bridge child processes use a hard context limit and auto-compaction window of
 `258400` tokens. VCM sets Claude Code's proactive compaction threshold to `90%`
-(about `232560` tokens), leaving headroom before the gateway limit. Native
+(about `232560` tokens), leaving headroom before the Codex API limit. Native
 Claude sessions receive no VCM-owned context override.
 
 Resume keeps the provider recorded by the existing Session. Use Restart when
-switching between a native Claude model and `GPT-5.6 Sol (CCR)`. 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.
+switching between native Claude and Codex Bridge. If the Bridge is disabled,
+unreachable, rejects the key, has unavailable Codex credentials, or no longer
+exposes the selected model, VCM blocks the new Start, Resume, or Restart and
+does not fall back to another model.
 
 ## Launch Template
 
@@ -482,7 +480,7 @@ Use it to:
   appropriate
 
 VCM bundles the Claude Code LSP bridge and loads it only for Architect sessions,
-including CCR launches. The project environment must still
+including Codex Bridge launches. The project environment must still
 provide the language server for each detected language: `rust-analyzer`,
 `typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
 `jdtls`. Architect preloads `vcm-code-navigation` and uses LSP for semantic

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

@@ -1,5 +1,5 @@
 import { roleRuntimeDisallowedTools, roleUsesLsp } from "../role-tool-policy.js";
-import { isCcrSessionModel } from "../../shared/types/session.js";
+import { isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 export function createClaudeAdapter(runner) {
     return {
@@ -33,7 +33,7 @@ export function createClaudeAdapter(runner) {
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
-            if (!isCcrSessionModel(model)) {
+            if (!isCodexBridgeSessionModel(model)) {
                 args.push("--model", model);
             }
             if (effort === "ultracode") {

package/dist/backend/adapters/codex-bridge-adapter.js

@@ -0,0 +1,213 @@
+import { CODEX_BRIDGE_BASE_URLS } from "../../shared/types/session.js";
+const DEFAULT_TIMEOUT_MS = 3_000;
+export function createCodexBridgeAdapter(deps = {}) {
+    const baseUrls = (deps.baseUrl ? [deps.baseUrl] : CODEX_BRIDGE_BASE_URLS)
+        .map((baseUrl) => baseUrl.replace(/\/+$/, ""));
+    const fetchImpl = deps.fetch ?? globalThis.fetch;
+    const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return {
+        async probe(apiKey) {
+            const failures = [];
+            for (const baseUrl of baseUrls) {
+                const result = await probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs);
+                if (result.baseUrl) {
+                    return result;
+                }
+                failures.push(result);
+            }
+            return combineProbeFailures(baseUrls, failures);
+        }
+    };
+}
+async function probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs) {
+    try {
+        const health = await requestJson(fetchImpl, `${baseUrl}/health`, timeoutMs);
+        if (!health.response.ok) {
+            return invalidResponse(`Codex Bridge health check at ${baseUrl} returned HTTP ${health.response.status}.`);
+        }
+        if (!isCodexBridgeHealth(health.payload)) {
+            return {
+                connectionState: "not-codex-bridge",
+                modelAvailable: false,
+                models: [],
+                error: `${baseUrl} did not identify as Codex Bridge.`
+            };
+        }
+        const headers = {
+            authorization: `Bearer ${apiKey}`,
+            "user-agent": "VibeCodingMaster"
+        };
+        const auth = await requestJson(fetchImpl, `${baseUrl}/auth/status`, timeoutMs, headers);
+        if (auth.response.status === 401 || auth.response.status === 403) {
+            return {
+                connectionState: "unauthorized",
+                modelAvailable: false,
+                models: [],
+                baseUrl,
+                error: "Codex Bridge rejected the configured API key."
+            };
+        }
+        if (!auth.response.ok) {
+            return invalidResponse(responseError("Codex Bridge auth status", baseUrl, auth.response, auth.payload), baseUrl);
+        }
+        const authState = readAuthState(auth.payload);
+        if (!authState) {
+            return invalidResponse("Codex Bridge returned an invalid /auth/status response.", baseUrl);
+        }
+        if (authState.state !== "ready") {
+            return {
+                connectionState: "codex-auth-unavailable",
+                modelAvailable: false,
+                models: [],
+                baseUrl,
+                error: authState.message
+                    ?? `Codex authentication is ${authState.state}. Open Codex or run codex login, then retry.`
+            };
+        }
+        const modelsResponse = await requestJson(fetchImpl, `${baseUrl}/v1/models`, timeoutMs, headers);
+        if (!modelsResponse.response.ok) {
+            const code = readErrorCode(modelsResponse.payload);
+            const connectionState = code?.startsWith("CODEX_AUTH_")
+                ? "codex-auth-unavailable"
+                : modelsResponse.response.status === 401 || modelsResponse.response.status === 403
+                    ? "unauthorized"
+                    : "invalid-response";
+            return {
+                connectionState,
+                modelAvailable: false,
+                models: [],
+                baseUrl,
+                error: responseError("Codex Bridge model discovery", baseUrl, modelsResponse.response, modelsResponse.payload)
+            };
+        }
+        const models = readModelDescriptors(modelsResponse.payload);
+        if (!models) {
+            return invalidResponse("Codex Bridge returned an invalid /v1/models response.", baseUrl);
+        }
+        return {
+            connectionState: "available",
+            modelAvailable: models.length > 0,
+            models,
+            baseUrl,
+            ...(models.length > 0 ? {} : { error: "Codex Bridge did not expose any models." })
+        };
+    }
+    catch (error) {
+        const timedOut = isAbortError(error);
+        return {
+            connectionState: "unreachable",
+            modelAvailable: false,
+            models: [],
+            error: timedOut
+                ? `Codex Bridge connection timed out after ${timeoutMs} ms at ${baseUrl}.`
+                : `Codex Bridge 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,
+        models: [],
+        error: `Codex Bridge was not found at ${baseUrls.join(" or ")}. ${failures
+            .map((failure) => failure.error)
+            .filter(Boolean)
+            .join(" ")}`.trim()
+    };
+}
+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 isCodexBridgeHealth(value) {
+    return isObject(value)
+        && value.status === "ok"
+        && value.service === "codex-bridge";
+}
+function readAuthState(value) {
+    if (!isObject(value) || typeof value.state !== "string" || !value.state.trim()) {
+        return undefined;
+    }
+    return {
+        state: value.state.trim(),
+        ...(typeof value.message === "string" && value.message.trim()
+            ? { message: value.message.trim() }
+            : {})
+    };
+}
+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 responseError(operation, baseUrl, response, payload) {
+    const message = readErrorMessage(payload);
+    return `${operation} at ${baseUrl} returned HTTP ${response.status}.${message ? ` Reason: ${message}` : ""}`;
+}
+function readErrorCode(value) {
+    return isObject(value)
+        && isObject(value.error)
+        && typeof value.error.code === "string"
+        ? value.error.code
+        : undefined;
+}
+function readErrorMessage(value) {
+    return isObject(value)
+        && isObject(value.error)
+        && typeof value.error.message === "string"
+        ? value.error.message
+        : undefined;
+}
+function invalidResponse(error, baseUrl) {
+    return {
+        connectionState: "invalid-response",
+        modelAvailable: false,
+        models: [],
+        ...(baseUrl ? { baseUrl } : {}),
+        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/api/app-settings-routes.js

@@ -5,13 +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.get("/api/settings/codex-bridge", async () => {
+        return deps.codexBridgeIntegration.getStatus();
     });
-    app.put("/api/settings/ccr", async (request) => {
-        return deps.ccrIntegration.updateSettings(request.body ?? {});
+    app.put("/api/settings/codex-bridge", async (request) => {
+        return deps.codexBridgeIntegration.updateSettings(request.body ?? {});
     });
-    app.post("/api/settings/ccr/check", async () => {
-        return deps.ccrIntegration.checkConnection();
+    app.post("/api/settings/codex-bridge/check", async () => {
+        return deps.codexBridgeIntegration.checkConnection();
     });
 }

package/dist/backend/server.js

@@ -4,13 +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 { createCodexBridgeAdapter } from "./adapters/codex-bridge-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 { createCodexBridgeIntegrationService } from "./services/codex-bridge-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createArchitectRestartService } from "./services/architect-restart-service.js";
 import { createRoleStallDetectorService } from "./services/role-stall-detector-service.js";
@@ -88,7 +88,7 @@ export async function createServer(deps, options = {}) {
     registerDiagnosticsRoutes(app, { diagnosticsService: deps.diagnosticsService });
     registerAppSettingsRoutes(app, {
         appSettings: deps.appSettings,
-        ccrIntegration: deps.ccrIntegration
+        codexBridgeIntegration: deps.codexBridgeIntegration
     });
     registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
     registerGateReviewRoutes(app, {
@@ -186,7 +186,7 @@ export async function createServer(deps, options = {}) {
         onManualInterrupt: (sessionId) => deps.terminalInterruptService.handleManualInterrupt(sessionId)
     });
     app.addHook("onReady", async () => {
-        await deps.ccrIntegration.initialize();
+        await deps.codexBridgeIntegration.initialize();
         await cleanupRecentTranslationRuntime(deps);
         deps.terminalProcessExitService.start();
         deps.runtimeCoordinator.start();
@@ -235,9 +235,9 @@ export function createDefaultServerDeps(options = {}) {
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
     const appSettings = createAppSettingsService({ fs });
-    const ccrIntegration = createCcrIntegrationService({
+    const codexBridgeIntegration = createCodexBridgeIntegrationService({
         settings: appSettings,
-        gateway: createCcrGatewayAdapter()
+        bridge: createCodexBridgeAdapter()
     });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
@@ -255,7 +255,7 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         taskWorkflowService,
-        ccrIntegration,
+        codexBridgeIntegration,
         apiUrl: options.apiUrl
     });
     const harnessService = createHarnessService({
@@ -458,7 +458,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     return {
         appSettings,
-        ccrIntegration,
+        codexBridgeIntegration,
         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, createDefaultToolSessionDefaults, 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, CCR_GPT_SESSION_MODEL, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
+import { CLAUDE_MODEL_OPTIONS, isCodexBridgeSessionModel, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
 export function createAppSettingsService(deps) {
@@ -161,20 +161,20 @@ export function createAppSettingsService(deps) {
                 requiredGates: normalizedRequiredGates
             };
         },
-        async getCcrIntegrationSettings() {
-            return normalizeCcrIntegrationSettings((await loadSettings()).ccr);
+        async getCodexBridgeIntegrationSettings() {
+            return normalizeCodexBridgeIntegrationSettings((await loadSettings()).codexBridge);
         },
-        async updateCcrIntegrationSettings(input) {
+        async updateCodexBridgeIntegrationSettings(input) {
             const current = await loadSettings();
-            const ccr = normalizeCcrIntegrationSettings({
-                ...current.ccr,
+            const codexBridge = normalizeCodexBridgeIntegrationSettings({
+                ...current.codexBridge,
                 ...input
             });
             await saveSettings({
                 ...current,
-                ccr
+                codexBridge
             });
-            return ccr;
+            return codexBridge;
         },
         getSettingsPath() {
             return settingsPath;
@@ -261,10 +261,10 @@ function normalizeSettingsFile(input) {
     if (gateReview) {
         settings.gateReview = gateReview;
     }
-    settings.ccr = normalizeCcrIntegrationSettings(input.ccr);
+    settings.codexBridge = normalizeCodexBridgeIntegrationSettings(input.codexBridge);
     return settings;
 }
-function normalizeCcrIntegrationSettings(input) {
+function normalizeCodexBridgeIntegrationSettings(input) {
     const candidate = isObject(input) ? input : {};
     const apiKey = typeof candidate.apiKey === "string" ? candidate.apiKey.trim() : "";
     return {
@@ -355,7 +355,7 @@ function normalizeClaudeModel(input, fallback) {
     if (typeof input !== "string") {
         return fallback;
     }
-    if (input === CCR_GPT_SESSION_MODEL) {
+    if (isCodexBridgeSessionModel(input)) {
         return input;
     }
     const model = CLAUDE_MODEL_OPTIONS.find((option) => option.value === input);