theclawbay 0.3.55 → 0.3.57

package/dist/commands/logout.js

@@ -17,6 +17,7 @@ const errors_1 = require("../lib/managed/errors");
 const supported_models_1 = require("../lib/supported-models");
 const paths_1 = require("../lib/config/paths");
 const OPENAI_PROVIDER_ID = "openai";
+const ANTHROPIC_PROVIDER_ID = "anthropic";
 const DEFAULT_PROVIDER_ID = "theclawbay";
 const WAN_PROVIDER_ID = "theclawbay-wan";
 const MANAGED_START = "# theclawbay-managed:start";
@@ -27,6 +28,13 @@ const SHELL_START = "# theclawbay-shell-managed:start";
 const SHELL_END = "# theclawbay-shell-managed:end";
 const ENV_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "env");
 const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
+const CLAUDE_ENV_API_KEY_NAME = "ANTHROPIC_API_KEY";
+const CLAUDE_ENV_BASE_URL_NAME = "ANTHROPIC_BASE_URL";
+const CLAUDE_ENV_SIMPLE_MODE_NAME = "CLAUDE_CODE_SIMPLE";
+const CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME = "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC";
+const CLAUDE_ENV_ENABLE_TELEMETRY_NAME = "CLAUDE_CODE_ENABLE_TELEMETRY";
+const CLAUDE_CODE_EDITOR_ENV_SETTING = "claudeCode.environmentVariables";
+const CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING = "claudeCode.disableLoginPrompt";
 const CONTINUE_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".continue", "config.yaml");
 const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "globalState.json");
 const CLINE_SECRETS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "secrets.json");
@@ -40,6 +48,10 @@ const GSD_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateD
 const OPENCODE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "opencode.restore.json");
 const KILO_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "kilo.restore.json");
 const ROO_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "roo-settings.restore.json");
+const EDITOR_TERMINAL_ENV_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "editor-terminal-env.restore.json");
+const CLAUDE_EDITOR_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "claude-editor-settings.restore.json");
+const CLAUDE_DESKTOP_3P_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "claude-desktop-3p.restore.json");
+const CODEX_FEATURE_FLAGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "codex-features.restore.json");
 const ROO_IMPORT_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "roo-code-settings.json");
 const MIGRATION_STATE_FILE = node_path_1.default.join(paths_1.codexDir, "theclawbay.migration.json");
 const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
@@ -126,6 +138,118 @@ function removeTopLevelProviderSelection(source) {
     }
     return `${filtered.join("\n").trimEnd()}\n`;
 }
+function removeTopLevelKeyLineIf(source, key, shouldRemove) {
+    const lines = source.split(/\r?\n/);
+    const filtered = [];
+    let removed = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*\[/.test(line)) {
+            filtered.push(...lines.slice(i));
+            break;
+        }
+        if (/^\s*#/.test(line) || !line.trim()) {
+            filtered.push(line);
+            continue;
+        }
+        const match = line.match(new RegExp(`^\\s*${key}\\s*=\\s*\"([^\"]*)\"\\s*$`));
+        if (!match) {
+            filtered.push(line);
+            continue;
+        }
+        if (shouldRemove(match[1] ?? "")) {
+            removed = true;
+            continue;
+        }
+        filtered.push(line);
+    }
+    if (!removed)
+        return source;
+    return `${filtered.join("\n").trimEnd()}\n`;
+}
+function setTopLevelTableKey(source, tableName, key, tomlValue) {
+    const header = `[${tableName}]`;
+    const lines = source.split(/\r?\n/);
+    let tableStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if ((lines[i] ?? "").trim() === header) {
+            tableStart = i;
+            break;
+        }
+    }
+    if (tableStart < 0) {
+        const block = `${header}\n${key} = ${tomlValue}\n`;
+        if (!source.trim())
+            return block;
+        return `${source.trimEnd()}\n\n${block}`;
+    }
+    let tableEnd = lines.length;
+    for (let i = tableStart + 1; i < lines.length; i++) {
+        if (/^\s*\[[^\]]+\]\s*$/.test(lines[i] ?? "")) {
+            tableEnd = i;
+            break;
+        }
+    }
+    for (let i = tableStart + 1; i < tableEnd; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*#/.test(line))
+            continue;
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            lines[i] = `${key} = ${tomlValue}`;
+            return `${lines.join("\n").trimEnd()}\n`;
+        }
+    }
+    lines.splice(tableEnd, 0, `${key} = ${tomlValue}`);
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function removeTopLevelTableKey(source, tableName, key) {
+    const header = `[${tableName}]`;
+    const lines = source.split(/\r?\n/);
+    let tableStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if ((lines[i] ?? "").trim() === header) {
+            tableStart = i;
+            break;
+        }
+    }
+    if (tableStart < 0)
+        return source;
+    let tableEnd = lines.length;
+    for (let i = tableStart + 1; i < lines.length; i++) {
+        if (/^\s*\[[^\]]+\]\s*$/.test(lines[i] ?? "")) {
+            tableEnd = i;
+            break;
+        }
+    }
+    let removed = false;
+    const nextLines = [...lines];
+    for (let i = tableStart + 1; i < tableEnd; i++) {
+        const line = nextLines[i] ?? "";
+        if (/^\s*#/.test(line))
+            continue;
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            nextLines.splice(i, 1);
+            removed = true;
+            break;
+        }
+    }
+    if (!removed)
+        return source;
+    return `${nextLines.join("\n").trimEnd()}\n`;
+}
+function isTheClawBayChatgptBaseUrl(value) {
+    const trimmed = value.trim().replace(/\/+$/g, "");
+    if (!trimmed)
+        return false;
+    try {
+        const parsed = new URL(trimmed);
+        const hostname = parsed.hostname.toLowerCase();
+        return hostname === THECLAWBAY_CANONICAL_API_HOST || THECLAWBAY_WEBSITE_HOSTS.has(hostname);
+    }
+    catch {
+        return false;
+    }
+}
 async function readFileIfExists(filePath) {
     try {
         return await promises_1.default.readFile(filePath, "utf8");
@@ -197,6 +321,22 @@ function isTheClawBayOpenAiCompatibleBaseUrl(value) {
         return false;
     }
 }
+function isTheClawBayAnthropicCompatibleBaseUrl(value) {
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        const hostname = parsed.hostname.toLowerCase();
+        const pathname = parsed.pathname.replace(/\/+$/g, "");
+        return hostname === THECLAWBAY_CANONICAL_API_HOST && pathname === "/anthropic/v1";
+    }
+    catch {
+        return false;
+    }
+}
 function uniqueStrings(values) {
     const output = [];
     const seen = new Set();
@@ -226,6 +366,11 @@ function configDirCandidates(appName) {
     }
     return uniqueStrings(dirs);
 }
+function claudeDesktop3pConfigPath() {
+    if (node_os_1.default.platform() !== "darwin")
+        return null;
+    return node_path_1.default.join(node_os_1.default.homedir(), "Library", "Application Support", "Claude-3p", "claude_desktop_config.json");
+}
 function openCodeConfigCleanupTargets() {
     const home = node_os_1.default.homedir();
     const dirs = configDirCandidates("opencode");
@@ -277,6 +422,11 @@ function isManagedOpenCodeProvider(value) {
     const options = objectRecordOr(provider.options, {});
     return isTheClawBayOpenAiCompatibleBaseUrl(options.baseURL);
 }
+function isManagedOpenCodeAnthropicProvider(value) {
+    const provider = objectRecordOr(value, {});
+    const options = objectRecordOr(provider.options, {});
+    return isTheClawBayAnthropicCompatibleBaseUrl(options.baseURL);
+}
 function roamingAppDataDir() {
     if (process.env.APPDATA?.trim())
         return process.env.APPDATA;
@@ -321,6 +471,7 @@ async function cleanupCodexConfig() {
     next = removeManagedBlock(next, MANAGED_START, MANAGED_END);
     next = removeProviderTable(next, DEFAULT_PROVIDER_ID);
     next = removeTopLevelProviderSelection(next);
+    next = removeTopLevelKeyLineIf(next, "chatgpt_base_url", isTheClawBayChatgptBaseUrl);
     return writeIfChanged(configPath, next, existing);
 }
 async function cleanupContinueConfig() {
@@ -675,6 +826,162 @@ async function cleanupVsCodeHooks() {
     }
     return updated;
 }
+function terminalIntegratedEnvSettingsKey() {
+    if (node_os_1.default.platform() === "darwin")
+        return "terminal.integrated.env.osx";
+    if (node_os_1.default.platform() === "win32")
+        return "terminal.integrated.env.windows";
+    return "terminal.integrated.env.linux";
+}
+async function cleanupEditorTerminalEnvSettings() {
+    const snapshotRaw = await readFileIfExists(EDITOR_TERMINAL_ENV_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return [];
+    let entries = [];
+    try {
+        entries = JSON.parse(snapshotRaw);
+    }
+    catch {
+        return [];
+    }
+    const settingsKey = terminalIntegratedEnvSettingsKey();
+    const updated = [];
+    for (const entry of entries) {
+        const settings = await readJsonObjectFile(entry.settingsPath);
+        if (!entry.hadKey) {
+            if (Object.prototype.hasOwnProperty.call(settings, settingsKey)) {
+                delete settings[settingsKey];
+            }
+        }
+        else {
+            settings[settingsKey] = entry.previousValue;
+        }
+        if (entry.existed || Object.keys(settings).length > 0) {
+            const next = `${JSON.stringify(settings, null, 2)}\n`;
+            const existing = await readFileIfExists(entry.settingsPath);
+            if (existing !== next) {
+                await promises_1.default.mkdir(node_path_1.default.dirname(entry.settingsPath), { recursive: true });
+                await promises_1.default.writeFile(entry.settingsPath, next, "utf8");
+                updated.push(entry.settingsPath);
+            }
+            continue;
+        }
+        if (await removeFileIfExists(entry.settingsPath)) {
+            updated.push(entry.settingsPath);
+        }
+    }
+    await removeFileIfExists(EDITOR_TERMINAL_ENV_STATE_PATH);
+    return updated;
+}
+async function cleanupClaudeEditorSettings() {
+    const snapshotRaw = await readFileIfExists(CLAUDE_EDITOR_SETTINGS_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return [];
+    let entries = [];
+    try {
+        entries = JSON.parse(snapshotRaw);
+    }
+    catch {
+        return [];
+    }
+    const updated = [];
+    for (const entry of entries) {
+        const settings = await readJsonObjectFile(entry.settingsPath);
+        if (!entry.envHadKey) {
+            delete settings[CLAUDE_CODE_EDITOR_ENV_SETTING];
+        }
+        else {
+            settings[CLAUDE_CODE_EDITOR_ENV_SETTING] = entry.envPreviousValue;
+        }
+        if (!entry.disableLoginPromptHadKey) {
+            delete settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING];
+        }
+        else {
+            settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] = entry.disableLoginPromptPreviousValue;
+        }
+        if (entry.existed || Object.keys(settings).length > 0) {
+            const next = `${JSON.stringify(settings, null, 2)}\n`;
+            const existing = await readFileIfExists(entry.settingsPath);
+            if (existing !== next) {
+                await promises_1.default.mkdir(node_path_1.default.dirname(entry.settingsPath), { recursive: true });
+                await promises_1.default.writeFile(entry.settingsPath, next, "utf8");
+                updated.push(entry.settingsPath);
+            }
+            continue;
+        }
+        if (await removeFileIfExists(entry.settingsPath)) {
+            updated.push(entry.settingsPath);
+        }
+    }
+    await removeFileIfExists(CLAUDE_EDITOR_SETTINGS_STATE_PATH);
+    return updated;
+}
+async function cleanupClaudeDesktop3pConfig() {
+    const snapshotRaw = await readFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return false;
+    let snapshot = null;
+    try {
+        snapshot = JSON.parse(snapshotRaw);
+    }
+    catch {
+        snapshot = null;
+    }
+    if (!snapshot?.configPath) {
+        await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+        return false;
+    }
+    if (!snapshot.existed) {
+        const removed = await removeFileIfExists(snapshot.configPath);
+        await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+        return removed;
+    }
+    const previousRaw = snapshot.previousRaw ?? "";
+    await promises_1.default.mkdir(node_path_1.default.dirname(snapshot.configPath), { recursive: true });
+    const existingRaw = await readFileIfExists(snapshot.configPath);
+    if (existingRaw === previousRaw) {
+        await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+        return false;
+    }
+    await promises_1.default.writeFile(snapshot.configPath, previousRaw, "utf8");
+    await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+    return true;
+}
+async function cleanupCodexFeatureFlags() {
+    const snapshotRaw = await readFileIfExists(CODEX_FEATURE_FLAGS_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return false;
+    let snapshot = null;
+    try {
+        snapshot = JSON.parse(snapshotRaw);
+    }
+    catch {
+        snapshot = null;
+    }
+    if (!snapshot)
+        return false;
+    const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
+    const existing = await readFileIfExists(configPath);
+    if (existing === null) {
+        await removeFileIfExists(CODEX_FEATURE_FLAGS_STATE_PATH);
+        return false;
+    }
+    let next = existing;
+    if (snapshot.appsHadKey && snapshot.appsPreviousValue !== null) {
+        next = setTopLevelTableKey(next, "features", "apps", snapshot.appsPreviousValue);
+    }
+    else {
+        next = removeTopLevelTableKey(next, "features", "apps");
+    }
+    if (snapshot.appsMcpGatewayHadKey && snapshot.appsMcpGatewayPreviousValue !== null) {
+        next = setTopLevelTableKey(next, "features", "apps_mcp_gateway", snapshot.appsMcpGatewayPreviousValue);
+    }
+    else {
+        next = removeTopLevelTableKey(next, "features", "apps_mcp_gateway");
+    }
+    await removeFileIfExists(CODEX_FEATURE_FLAGS_STATE_PATH);
+    return writeIfChanged(configPath, next, existing);
+}
 async function cleanupOpenClawConfig() {
     const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
     const existingRaw = await readFileIfExists(configPath);
@@ -718,7 +1025,7 @@ function normalizeOpenCodeRestoreSnapshot(snapshot, fallbackConfigPath) {
     if (typeof snapshot !== "object" || snapshot === null || Array.isArray(snapshot))
         return null;
     const obj = snapshot;
-    if (obj.version === 2 && Array.isArray(obj.targets)) {
+    if ((obj.version === 2 || obj.version === 3) && Array.isArray(obj.targets)) {
         const targets = [];
         for (const entry of obj.targets) {
             if (typeof entry !== "object" || entry === null || Array.isArray(entry))
@@ -735,6 +1042,11 @@ function normalizeOpenCodeRestoreSnapshot(snapshot, fallbackConfigPath) {
                     !Array.isArray(candidate.openAiProvider)
                     ? candidate.openAiProvider
                     : null,
+                anthropicProvider: typeof candidate.anthropicProvider === "object" &&
+                    candidate.anthropicProvider !== null &&
+                    !Array.isArray(candidate.anthropicProvider)
+                    ? candidate.anthropicProvider
+                    : null,
                 model: typeof candidate.model === "string" ? candidate.model : null,
                 schema: typeof candidate.schema === "string" ? candidate.schema : null,
                 plugin: "plugin" in candidate
@@ -744,13 +1056,13 @@ function normalizeOpenCodeRestoreSnapshot(snapshot, fallbackConfigPath) {
                     : undefined,
             });
         }
-        return { version: 2, targets };
+        return { version: 3, targets };
     }
     const looksLikeV1 = "openAiProvider" in obj || "model" in obj || "schema" in obj;
     if (!looksLikeV1)
         return null;
     return {
-        version: 2,
+        version: 3,
         targets: [
             {
                 configPath: fallbackConfigPath,
@@ -819,6 +1131,15 @@ async function cleanupOpenCodeFamilyConfigs(params) {
         }
         else if (OPENAI_PROVIDER_ID in providerRoot) {
             delete providerRoot[OPENAI_PROVIDER_ID];
+            changed = true;
+        }
+        if (target.anthropicProvider) {
+            providerRoot[ANTHROPIC_PROVIDER_ID] = target.anthropicProvider;
+            changed = true;
+        }
+        else if (ANTHROPIC_PROVIDER_ID in providerRoot) {
+            delete providerRoot[ANTHROPIC_PROVIDER_ID];
+            changed = true;
         }
         doc.provider = providerRoot;
         if (target.model === null) {
@@ -877,6 +1198,10 @@ async function cleanupOpenCodeFamilyConfigs(params) {
             delete providerRoot[OPENAI_PROVIDER_ID];
             fileChanged = true;
         }
+        if (isManagedOpenCodeAnthropicProvider(providerRoot[ANTHROPIC_PROVIDER_ID])) {
+            delete providerRoot[ANTHROPIC_PROVIDER_ID];
+            fileChanged = true;
+        }
         if (!fileChanged)
             continue;
         changed = true;
@@ -937,7 +1262,11 @@ class LogoutCommand extends base_command_1.BaseCommand {
             let updatedShellFiles = [];
             let updatedPowerShellProfiles = [];
             let updatedVsCodeHooks = [];
+            let updatedEditorTerminalSettings = [];
+            let updatedClaudeEditorSettings = [];
+            let updatedClaudeDesktopConfig = false;
             let updatedCodexConfig = false;
+            let updatedCodexFeatures = false;
             let updatedContinueConfig = false;
             let updatedClineConfig = false;
             let updatedGsdConfig = false;
@@ -986,8 +1315,12 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 updatedShellFiles = await cleanupShellFiles();
                 updatedPowerShellProfiles = await cleanupPowerShellProfiles();
                 updatedVsCodeHooks = await cleanupVsCodeHooks();
+                updatedEditorTerminalSettings = await cleanupEditorTerminalEnvSettings();
+                updatedClaudeEditorSettings = await cleanupClaudeEditorSettings();
+                updatedClaudeDesktopConfig = await cleanupClaudeDesktop3pConfig();
                 progress.update("Reverting Codex");
                 updatedCodexConfig = await cleanupCodexConfig();
+                updatedCodexFeatures = await cleanupCodexFeatureFlags();
                 sessionMigration = await (0, codex_history_migration_1.migrateSessionProviders)({
                     codexHome: paths_1.codexDir,
                     migrationStateFile: MIGRATION_STATE_FILE,
@@ -1028,8 +1361,11 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 throw error;
             }
             delete process.env[ENV_KEY_NAME];
-            delete process.env.ANTHROPIC_API_KEY;
-            delete process.env.ANTHROPIC_BASE_URL;
+            delete process.env[CLAUDE_ENV_API_KEY_NAME];
+            delete process.env[CLAUDE_ENV_BASE_URL_NAME];
+            delete process.env[CLAUDE_ENV_SIMPLE_MODE_NAME];
+            delete process.env[CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME];
+            delete process.env[CLAUDE_ENV_ENABLE_TELEMETRY_NAME];
             if (!debugOutput && process.stdout.isTTY) {
                 progress.succeed("Logout complete");
             }
@@ -1037,8 +1373,12 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 this.log("Logout complete");
             }
             const revertedTargets = [];
+            const claudeChanged = updatedClaudeEditorSettings.length > 0 ||
+                updatedClaudeDesktopConfig;
             const codexChanged = updatedCodexConfig ||
+                updatedCodexFeatures ||
                 updatedVsCodeHooks.length > 0 ||
+                updatedEditorTerminalSettings.length > 0 ||
                 sessionMigration.rewritten > 0 ||
                 sessionMigration.retimed > 0 ||
                 stateDbMigration.updated > 0 ||
@@ -1047,6 +1387,8 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 modelCacheCleanup.action === "removed";
             if (codexChanged)
                 revertedTargets.push("Codex");
+            if (claudeChanged)
+                revertedTargets.push("Claude");
             if (updatedContinueConfig)
                 revertedTargets.push("Continue");
             if (updatedClineConfig)
@@ -1086,7 +1428,10 @@ class LogoutCommand extends base_command_1.BaseCommand {
                         removedEnvFile ||
                         updatedShellFiles.length > 0 ||
                         updatedPowerShellProfiles.length > 0 ||
-                        updatedVsCodeHooks.length > 0,
+                        updatedVsCodeHooks.length > 0 ||
+                        updatedEditorTerminalSettings.length > 0 ||
+                        updatedClaudeEditorSettings.length > 0 ||
+                        updatedClaudeDesktopConfig,
                     notes: Array.from(summaryNotes),
                 });
                 return;
@@ -1102,7 +1447,11 @@ class LogoutCommand extends base_command_1.BaseCommand {
             this.log(`- Shell profiles updated: ${updatedShellFiles.length ? updatedShellFiles.join(", ") : "none"}`);
             this.log(`- PowerShell profiles updated: ${updatedPowerShellProfiles.length ? updatedPowerShellProfiles.join(", ") : "none"}`);
             this.log(`- VS Code env hooks updated: ${updatedVsCodeHooks.length ? updatedVsCodeHooks.join(", ") : "none"}`);
+            this.log(`- Editor terminal env updated: ${updatedEditorTerminalSettings.length ? updatedEditorTerminalSettings.join(", ") : "none"}`);
+            this.log(`- Claude editor settings updated: ${updatedClaudeEditorSettings.length ? updatedClaudeEditorSettings.join(", ") : "none"}`);
+            this.log(`- Claude Desktop 3P config cleaned: ${updatedClaudeDesktopConfig ? "yes" : "no"}`);
             this.log(`- Codex config cleaned: ${updatedCodexConfig ? "yes" : "no"}`);
+            this.log(`- Codex Apps feature flags restored: ${updatedCodexFeatures ? "yes" : "no"}`);
             if (sessionMigration.rewritten > 0) {
                 this.log(`- Conversations: updated ${sessionMigration.rewritten}/${sessionMigration.scanned} local sessions for cross-provider visibility.`);
             }

package/dist/commands/setup.js

@@ -42,6 +42,19 @@ const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
 const CLAUDE_ENV_API_KEY_NAME = "ANTHROPIC_API_KEY";
 const CLAUDE_ENV_BASE_URL_NAME = "ANTHROPIC_BASE_URL";
 const CLAUDE_ENV_SIMPLE_MODE_NAME = "CLAUDE_CODE_SIMPLE";
+const CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME = "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC";
+const CLAUDE_ENV_ENABLE_TELEMETRY_NAME = "CLAUDE_CODE_ENABLE_TELEMETRY";
+const CLAUDE_CODE_EDITOR_ENV_SETTING = "claudeCode.environmentVariables";
+const CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING = "claudeCode.disableLoginPrompt";
+const ANTHROPIC_PROVIDER_ID = "anthropic";
+const MANAGED_EDITOR_TERMINAL_ENV_NAMES = [
+    ENV_KEY_NAME,
+    CLAUDE_ENV_API_KEY_NAME,
+    CLAUDE_ENV_BASE_URL_NAME,
+    CLAUDE_ENV_SIMPLE_MODE_NAME,
+    CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME,
+    CLAUDE_ENV_ENABLE_TELEMETRY_NAME,
+];
 const ENV_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "env");
 const CONTINUE_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".continue", "config.yaml");
 const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "globalState.json");
@@ -56,6 +69,10 @@ const GSD_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateD
 const OPENCODE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "opencode.restore.json");
 const KILO_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "kilo.restore.json");
 const ROO_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "roo-settings.restore.json");
+const EDITOR_TERMINAL_ENV_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "editor-terminal-env.restore.json");
+const CLAUDE_EDITOR_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "claude-editor-settings.restore.json");
+const CLAUDE_DESKTOP_3P_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "claude-desktop-3p.restore.json");
+const CODEX_FEATURE_FLAGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "codex-features.restore.json");
 const ROO_IMPORT_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "roo-code-settings.json");
 const MIGRATION_STATE_FILE = node_path_1.default.join(paths_1.codexDir, "theclawbay.migration.json");
 const MANAGED_START = "# theclawbay-managed:start";
@@ -455,6 +472,99 @@ function upsertFirstKeyLine(source, key, tomlValue) {
     }
     return `${`${key} = ${tomlValue}\n${source}`.trimEnd()}\n`;
 }
+function parseTomlScalarValue(line) {
+    const match = line.match(/^\s*[A-Za-z0-9_.-]+\s*=\s*(.+?)\s*$/);
+    return match?.[1]?.trim() ?? null;
+}
+function upsertTopLevelTableKey(source, tableName, key, tomlValue) {
+    const header = `[${tableName}]`;
+    const lines = source.split(/\r?\n/);
+    let tableStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if ((lines[i] ?? "").trim() === header) {
+            tableStart = i;
+            break;
+        }
+    }
+    if (tableStart < 0) {
+        const block = `${header}\n${key} = ${tomlValue}\n`;
+        if (!source.trim())
+            return block;
+        return `${source.trimEnd()}\n\n${block}`;
+    }
+    let tableEnd = lines.length;
+    for (let i = tableStart + 1; i < lines.length; i++) {
+        if (/^\s*\[[^\]]+\]\s*$/.test(lines[i] ?? "")) {
+            tableEnd = i;
+            break;
+        }
+    }
+    for (let i = tableStart + 1; i < tableEnd; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*#/.test(line))
+            continue;
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            lines[i] = `${key} = ${tomlValue}`;
+            return `${lines.join("\n").trimEnd()}\n`;
+        }
+    }
+    lines.splice(tableEnd, 0, `${key} = ${tomlValue}`);
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function readTopLevelTableKeyValue(source, tableName, key) {
+    const header = `[${tableName}]`;
+    const lines = source.split(/\r?\n/);
+    let tableStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if ((lines[i] ?? "").trim() === header) {
+            tableStart = i;
+            break;
+        }
+    }
+    if (tableStart < 0) {
+        return { hadTable: false, hadKey: false, value: null };
+    }
+    for (let i = tableStart + 1; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*\[[^\]]+\]\s*$/.test(line))
+            break;
+        if (/^\s*#/.test(line) || !line.trim())
+            continue;
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            return { hadTable: true, hadKey: true, value: parseTomlScalarValue(line) };
+        }
+    }
+    return { hadTable: true, hadKey: false, value: null };
+}
+function removeTopLevelKeyLineIf(source, key, shouldRemove) {
+    const lines = source.split(/\r?\n/);
+    const filtered = [];
+    let removed = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*\[/.test(line)) {
+            filtered.push(...lines.slice(i));
+            break;
+        }
+        if (/^\s*#/.test(line) || !line.trim()) {
+            filtered.push(line);
+            continue;
+        }
+        const match = line.match(new RegExp(`^\\s*${key}\\s*=\\s*\"([^\"]*)\"\\s*$`));
+        if (!match) {
+            filtered.push(line);
+            continue;
+        }
+        if (shouldRemove(match[1] ?? "")) {
+            removed = true;
+            continue;
+        }
+        filtered.push(line);
+    }
+    if (!removed)
+        return source;
+    return `${filtered.join("\n").trimEnd()}\n`;
+}
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -480,12 +590,28 @@ function publicApiOriginForBackendUrl(backendUrl) {
         return trimmed;
     }
 }
+function isTheClawBayChatgptBaseUrl(value) {
+    const trimmed = trimTrailingSlash(value.trim());
+    if (!trimmed)
+        return false;
+    try {
+        const parsed = new URL(trimmed);
+        const hostname = parsed.hostname.toLowerCase();
+        return hostname === THECLAWBAY_CANONICAL_API_HOST || THECLAWBAY_WEBSITE_HOSTS.has(hostname);
+    }
+    catch {
+        return false;
+    }
+}
 function openAiCompatibleProxyUrl(backendUrl) {
     return `${publicApiOriginForBackendUrl(backendUrl)}${CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX}`;
 }
 function anthropicCompatibleProxyUrl(backendUrl) {
     return `${publicApiOriginForBackendUrl(backendUrl)}/anthropic`;
 }
+function anthropicCompatibleProxyV1Url(backendUrl) {
+    return `${anthropicCompatibleProxyUrl(backendUrl)}/v1`;
+}
 function isTheClawBayOpenAiCompatibleBaseUrl(value) {
     if (typeof value !== "string")
         return false;
@@ -510,6 +636,22 @@ function isTheClawBayOpenAiCompatibleBaseUrl(value) {
         return false;
     }
 }
+function isTheClawBayAnthropicCompatibleBaseUrl(value) {
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        const hostname = parsed.hostname.toLowerCase();
+        const pathname = trimTrailingSlash(parsed.pathname);
+        return hostname === THECLAWBAY_CANONICAL_API_HOST && pathname === "/anthropic/v1";
+    }
+    catch {
+        return false;
+    }
+}
 function uniqueStrings(values) {
     const output = [];
     const seen = new Set();
@@ -560,6 +702,29 @@ function configDirCandidates(appName) {
     }
     return uniqueStrings(dirs);
 }
+function claudeDesktop3pConfigPath() {
+    if (node_os_1.default.platform() !== "darwin")
+        return null;
+    return node_path_1.default.join(node_os_1.default.homedir(), "Library", "Application Support", "Claude-3p", "claude_desktop_config.json");
+}
+function claudeDesktopLogCandidates() {
+    if (node_os_1.default.platform() !== "darwin")
+        return [];
+    const home = node_os_1.default.homedir();
+    return [
+        node_path_1.default.join(home, "Library", "Logs", "Claude-3p", "main.log"),
+        node_path_1.default.join(home, "Library", "Logs", "Claude", "main.log"),
+    ];
+}
+function claudeDesktopAppCandidatePaths() {
+    if (node_os_1.default.platform() !== "darwin")
+        return [];
+    const home = node_os_1.default.homedir();
+    return uniqueStrings([
+        "/Applications/Claude.app",
+        node_path_1.default.join(home, "Applications", "Claude.app"),
+    ]);
+}
 async function readFileIfExists(filePath) {
     try {
         return await promises_1.default.readFile(filePath, "utf8");
@@ -1168,6 +1333,33 @@ async function detectClaudeCodeClient() {
     }
     return false;
 }
+async function detectClaudeClient() {
+    if (await detectClaudeCodeClient())
+        return true;
+    if (claudeDesktopAppCandidatePaths().some((candidate) => (0, node_fs_1.existsSync)(candidate)))
+        return true;
+    const configPath = claudeDesktop3pConfigPath();
+    if (!configPath)
+        return false;
+    return (await pathExists(configPath)) || (await pathExists(node_path_1.default.dirname(configPath)));
+}
+async function detectOpenCodeClient() {
+    if (hasCommand("opencode"))
+        return true;
+    const candidates = [
+        ...resolveOpenCodeConfigTargets(),
+        node_path_1.default.join(node_os_1.default.homedir(), ".opencode.json"),
+    ];
+    if (node_os_1.default.platform() === "darwin") {
+        candidates.push("/Applications/OpenCode.app");
+        candidates.push(node_path_1.default.join(node_os_1.default.homedir(), "Applications", "OpenCode.app"));
+    }
+    for (const candidate of candidates) {
+        if (await pathExists(candidate))
+            return true;
+    }
+    return false;
+}
 async function detectClineClient() {
     if (hasCommand("cline"))
         return true;
@@ -1305,7 +1497,22 @@ async function writeCodexConfig(params) {
     next = removeProviderTable(next, DEFAULT_PROVIDER_ID);
     next = upsertFirstKeyLine(next, "model_provider", `"${DEFAULT_PROVIDER_ID}"`);
     next = upsertFirstKeyLine(next, "model", `"${params.model}"`);
-    next = upsertFirstKeyLine(next, "chatgpt_base_url", `"${proxyRoot}"`);
+    next = removeTopLevelKeyLineIf(next, "chatgpt_base_url", isTheClawBayChatgptBaseUrl);
+    const existingFeatureSnapshot = await readFileIfExists(CODEX_FEATURE_FLAGS_STATE_PATH);
+    if (!existingFeatureSnapshot?.trim()) {
+        const appsState = readTopLevelTableKeyValue(next, "features", "apps");
+        const appsMcpGatewayState = readTopLevelTableKeyValue(next, "features", "apps_mcp_gateway");
+        const snapshot = {
+            hadFeaturesTable: appsState.hadTable || appsMcpGatewayState.hadTable,
+            appsHadKey: appsState.hadKey,
+            appsPreviousValue: appsState.value,
+            appsMcpGatewayHadKey: appsMcpGatewayState.hadKey,
+            appsMcpGatewayPreviousValue: appsMcpGatewayState.value,
+        };
+        await writeJsonObjectFile(CODEX_FEATURE_FLAGS_STATE_PATH, snapshot, 0o600);
+    }
+    next = upsertTopLevelTableKey(next, "features", "apps", "false");
+    next = upsertTopLevelTableKey(next, "features", "apps_mcp_gateway", "false");
     const managedBlock = appendManagedBlock("", [
         MANAGED_START,
         `[model_providers.${DEFAULT_PROVIDER_ID}]`,
@@ -1563,7 +1770,7 @@ async function persistApiKeyEnv(params) {
         `export ${ENV_KEY_NAME}=${shellQuote(params.apiKey)}`,
     ];
     if (params.claudeEnabled) {
-        envLines.push("", "# Official Claude Code CLI", `export ${CLAUDE_ENV_API_KEY_NAME}=${shellQuote(params.apiKey)}`, `export ${CLAUDE_ENV_BASE_URL_NAME}=${shellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`, `export ${CLAUDE_ENV_SIMPLE_MODE_NAME}=1`);
+        envLines.push("", "# Official Claude Code CLI", `export ${CLAUDE_ENV_API_KEY_NAME}=${shellQuote(params.apiKey)}`, `export ${CLAUDE_ENV_BASE_URL_NAME}=${shellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`, `export ${CLAUDE_ENV_SIMPLE_MODE_NAME}=1`, `export ${CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME}=1`, `export ${CLAUDE_ENV_ENABLE_TELEMETRY_NAME}=0`);
     }
     const envContents = `${envLines.join("\n")}\n`;
     await promises_1.default.writeFile(ENV_FILE, envContents, "utf8");
@@ -1599,11 +1806,15 @@ async function persistApiKeyEnv(params) {
         process.env[CLAUDE_ENV_API_KEY_NAME] = params.apiKey;
         process.env[CLAUDE_ENV_BASE_URL_NAME] = anthropicCompatibleProxyUrl(params.backendUrl);
         process.env[CLAUDE_ENV_SIMPLE_MODE_NAME] = "1";
+        process.env[CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME] = "1";
+        process.env[CLAUDE_ENV_ENABLE_TELEMETRY_NAME] = "0";
     }
     else {
         delete process.env[CLAUDE_ENV_API_KEY_NAME];
         delete process.env[CLAUDE_ENV_BASE_URL_NAME];
         delete process.env[CLAUDE_ENV_SIMPLE_MODE_NAME];
+        delete process.env[CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME];
+        delete process.env[CLAUDE_ENV_ENABLE_TELEMETRY_NAME];
     }
     return updated;
 }
@@ -1615,7 +1826,7 @@ async function persistFishEnv(params) {
         `set -gx ${ENV_KEY_NAME} ${shellQuote(params.apiKey)}`,
     ];
     if (params.claudeEnabled) {
-        lines.push("", "# Official Claude Code CLI", `set -gx ${CLAUDE_ENV_API_KEY_NAME} ${shellQuote(params.apiKey)}`, `set -gx ${CLAUDE_ENV_BASE_URL_NAME} ${shellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`, `set -gx ${CLAUDE_ENV_SIMPLE_MODE_NAME} 1`);
+        lines.push("", "# Official Claude Code CLI", `set -gx ${CLAUDE_ENV_API_KEY_NAME} ${shellQuote(params.apiKey)}`, `set -gx ${CLAUDE_ENV_BASE_URL_NAME} ${shellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`, `set -gx ${CLAUDE_ENV_SIMPLE_MODE_NAME} 1`, `set -gx ${CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME} 1`, `set -gx ${CLAUDE_ENV_ENABLE_TELEMETRY_NAME} 0`);
     }
     await promises_1.default.writeFile(fishConfPath, `${lines.join("\n")}\n`, "utf8");
     return [fishConfPath];
@@ -1640,7 +1851,7 @@ async function persistPowerShellEnv(params) {
             `$env:${ENV_KEY_NAME} = ${powerShellQuote(params.apiKey)}`,
         ];
         if (params.claudeEnabled) {
-            lines.push(`$env:${CLAUDE_ENV_API_KEY_NAME} = ${powerShellQuote(params.apiKey)}`, `$env:${CLAUDE_ENV_BASE_URL_NAME} = ${powerShellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`, `$env:${CLAUDE_ENV_SIMPLE_MODE_NAME} = "1"`);
+            lines.push(`$env:${CLAUDE_ENV_API_KEY_NAME} = ${powerShellQuote(params.apiKey)}`, `$env:${CLAUDE_ENV_BASE_URL_NAME} = ${powerShellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`, `$env:${CLAUDE_ENV_SIMPLE_MODE_NAME} = "1"`, `$env:${CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME} = "1"`, `$env:${CLAUDE_ENV_ENABLE_TELEMETRY_NAME} = "0"`);
         }
         lines.push(SHELL_END);
         const next = appendManagedBlock(cleaned, lines);
@@ -1677,6 +1888,269 @@ async function persistVsCodeServerEnvSource() {
     }
     return updated;
 }
+function terminalIntegratedEnvSettingsKey() {
+    if (node_os_1.default.platform() === "darwin")
+        return "terminal.integrated.env.osx";
+    if (node_os_1.default.platform() === "win32")
+        return "terminal.integrated.env.windows";
+    return "terminal.integrated.env.linux";
+}
+function buildManagedEditorTerminalEnv(params) {
+    const env = {
+        [ENV_KEY_NAME]: params.apiKey,
+    };
+    if (params.claudeEnabled) {
+        env[CLAUDE_ENV_API_KEY_NAME] = params.apiKey;
+        env[CLAUDE_ENV_BASE_URL_NAME] = anthropicCompatibleProxyUrl(params.backendUrl);
+        env[CLAUDE_ENV_SIMPLE_MODE_NAME] = "1";
+        env[CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME] = "1";
+        env[CLAUDE_ENV_ENABLE_TELEMETRY_NAME] = "0";
+    }
+    return env;
+}
+function buildManagedClaudeEditorEnv(params) {
+    return {
+        [CLAUDE_ENV_API_KEY_NAME]: params.apiKey,
+        [CLAUDE_ENV_BASE_URL_NAME]: anthropicCompatibleProxyUrl(params.backendUrl),
+        [CLAUDE_ENV_SIMPLE_MODE_NAME]: "1",
+        [CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME]: "1",
+        [CLAUDE_ENV_ENABLE_TELEMETRY_NAME]: "0",
+    };
+}
+async function persistEditorTerminalEnvSettings(params) {
+    const settingsKey = terminalIntegratedEnvSettingsKey();
+    const desiredEnv = buildManagedEditorTerminalEnv(params);
+    const existingSnapshotRaw = await readFileIfExists(EDITOR_TERMINAL_ENV_STATE_PATH);
+    let existingSnapshot = [];
+    if (existingSnapshotRaw?.trim()) {
+        try {
+            existingSnapshot = JSON.parse(existingSnapshotRaw);
+        }
+        catch {
+            existingSnapshot = [];
+        }
+    }
+    const snapshotByPath = new Map(existingSnapshot.map((entry) => [entry.settingsPath, entry]));
+    const managedPaths = [];
+    for (const host of editorHosts()) {
+        const settingsPath = host.userSettingsPath;
+        const hostPresent = (await pathExists(host.extensionDir)) ||
+            (await pathExists(settingsPath)) ||
+            (await pathExists(node_path_1.default.dirname(settingsPath)));
+        if (!hostPresent)
+            continue;
+        const existed = await pathExists(settingsPath);
+        const settings = await readJsonObjectFile(settingsPath);
+        const currentValue = settings[settingsKey];
+        const currentEnv = typeof currentValue === "object" && currentValue !== null && !Array.isArray(currentValue)
+            ? { ...currentValue }
+            : {};
+        let changed = false;
+        for (const [name, value] of Object.entries(desiredEnv)) {
+            if (currentEnv[name] === value)
+                continue;
+            currentEnv[name] = value;
+            changed = true;
+        }
+        for (const name of MANAGED_EDITOR_TERMINAL_ENV_NAMES) {
+            if (name in desiredEnv || !(name in currentEnv))
+                continue;
+            delete currentEnv[name];
+            changed = true;
+        }
+        if (!changed)
+            continue;
+        if (!snapshotByPath.has(settingsPath)) {
+            snapshotByPath.set(settingsPath, {
+                settingsPath,
+                existed,
+                hadKey: Object.prototype.hasOwnProperty.call(settings, settingsKey),
+                previousValue: currentValue ?? null,
+            });
+        }
+        settings[settingsKey] = currentEnv;
+        await writeJsonObjectFile(settingsPath, settings);
+        managedPaths.push(settingsPath);
+    }
+    await writeJsonObjectFile(EDITOR_TERMINAL_ENV_STATE_PATH, Array.from(snapshotByPath.values()), 0o600);
+    return managedPaths;
+}
+async function persistClaudeEditorSettings(params) {
+    const existingSnapshotRaw = await readFileIfExists(CLAUDE_EDITOR_SETTINGS_STATE_PATH);
+    let existingSnapshot = [];
+    if (existingSnapshotRaw?.trim()) {
+        try {
+            existingSnapshot = JSON.parse(existingSnapshotRaw);
+        }
+        catch {
+            existingSnapshot = [];
+        }
+    }
+    const snapshotByPath = new Map(existingSnapshot.map((entry) => [entry.settingsPath, entry]));
+    const managedPaths = [];
+    const desiredEnv = params.claudeEnabled
+        ? buildManagedClaudeEditorEnv({ apiKey: params.apiKey, backendUrl: params.backendUrl })
+        : null;
+    for (const host of editorHosts()) {
+        const settingsPath = host.userSettingsPath;
+        const hostPresent = (await pathExists(host.extensionDir)) ||
+            (await pathExists(settingsPath)) ||
+            (await pathExists(node_path_1.default.dirname(settingsPath)));
+        if (!hostPresent)
+            continue;
+        const existed = await pathExists(settingsPath);
+        const settings = await readJsonObjectFile(settingsPath);
+        const currentEnvValue = settings[CLAUDE_CODE_EDITOR_ENV_SETTING];
+        const currentEnv = typeof currentEnvValue === "object" && currentEnvValue !== null && !Array.isArray(currentEnvValue)
+            ? { ...currentEnvValue }
+            : {};
+        let changed = false;
+        if (!snapshotByPath.has(settingsPath)) {
+            snapshotByPath.set(settingsPath, {
+                settingsPath,
+                existed,
+                envHadKey: Object.prototype.hasOwnProperty.call(settings, CLAUDE_CODE_EDITOR_ENV_SETTING),
+                envPreviousValue: currentEnvValue ?? null,
+                disableLoginPromptHadKey: Object.prototype.hasOwnProperty.call(settings, CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING),
+                disableLoginPromptPreviousValue: settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] ?? null,
+            });
+        }
+        if (desiredEnv) {
+            const nextEnv = { ...currentEnv };
+            for (const [name, value] of Object.entries(desiredEnv)) {
+                if (nextEnv[name] === value)
+                    continue;
+                nextEnv[name] = value;
+                changed = true;
+            }
+            settings[CLAUDE_CODE_EDITOR_ENV_SETTING] = nextEnv;
+            if (settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] !== true) {
+                settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] = true;
+                changed = true;
+            }
+        }
+        else {
+            if (Object.prototype.hasOwnProperty.call(settings, CLAUDE_CODE_EDITOR_ENV_SETTING)) {
+                delete settings[CLAUDE_CODE_EDITOR_ENV_SETTING];
+                changed = true;
+            }
+            if (Object.prototype.hasOwnProperty.call(settings, CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING)) {
+                delete settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING];
+                changed = true;
+            }
+        }
+        if (!changed)
+            continue;
+        await writeJsonObjectFile(settingsPath, settings);
+        managedPaths.push(settingsPath);
+    }
+    await writeJsonObjectFile(CLAUDE_EDITOR_SETTINGS_STATE_PATH, Array.from(snapshotByPath.values()), 0o600);
+    return managedPaths;
+}
+function expandClaudeDesktopInferenceModels(modelIds) {
+    const expanded = [];
+    const add = (value) => {
+        const normalized = value.trim();
+        if (!normalized || expanded.includes(normalized))
+            return;
+        expanded.push(normalized);
+    };
+    for (const modelId of modelIds) {
+        add(modelId);
+        const datedMatch = modelId.match(/^(claude-[a-z]+-\d+(?:-\d+)?)-(\d{8})$/);
+        if (datedMatch?.[1])
+            add(datedMatch[1]);
+        const base = datedMatch?.[1] ?? modelId;
+        const dottedMatch = base.match(/^(claude-[a-z]+-\d+)-(\d+)$/);
+        if (dottedMatch?.[1] && dottedMatch?.[2]) {
+            add(`${dottedMatch[1]}.${dottedMatch[2]}`);
+        }
+    }
+    return expanded;
+}
+async function discoverClaudeDesktopDeploymentOrganizationUuid(existing) {
+    const enterpriseConfig = objectRecordOr(existing.enterpriseConfig, {});
+    const existingValue = enterpriseConfig.deploymentOrganizationUuid;
+    if (typeof existingValue === "string" && existingValue.trim()) {
+        return existingValue.trim();
+    }
+    const uuidPattern = /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/i;
+    const logPattern = /(deploymentOrganizationUuid|organizationUuid|organization uuid|org uuid)/i;
+    for (const logPath of claudeDesktopLogCandidates()) {
+        const logRaw = await readFileIfExists(logPath);
+        if (!logRaw)
+            continue;
+        const tail = logRaw.slice(-200000);
+        for (const line of tail.split(/\r?\n/).reverse()) {
+            if (!logPattern.test(line))
+                continue;
+            const match = line.match(uuidPattern);
+            if (match?.[0])
+                return match[0];
+        }
+    }
+    return null;
+}
+async function writeClaudeDesktop3pConfig(params) {
+    const configPath = claudeDesktop3pConfigPath();
+    if (!configPath || params.claudeModels.length === 0)
+        return null;
+    const desktopPresent = claudeDesktopAppCandidatePaths().some((candidate) => (0, node_fs_1.existsSync)(candidate)) ||
+        (await pathExists(configPath)) ||
+        (await pathExists(node_path_1.default.dirname(configPath))) ||
+        claudeDesktopLogCandidates().some((candidate) => (0, node_fs_1.existsSync)(candidate));
+    if (!desktopPresent)
+        return null;
+    let existed = true;
+    let existingRaw = "";
+    try {
+        existingRaw = await promises_1.default.readFile(configPath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT")
+            throw error;
+        existed = false;
+    }
+    const existingSnapshotRaw = await readFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+    if (!existingSnapshotRaw?.trim()) {
+        const snapshot = {
+            version: 1,
+            configPath,
+            existed,
+            previousRaw: existed ? existingRaw : null,
+        };
+        await writeJsonObjectFile(CLAUDE_DESKTOP_3P_STATE_PATH, snapshot, 0o600);
+    }
+    let doc = {};
+    if (existingRaw.trim()) {
+        try {
+            doc = objectRecordOr(JSON.parse(existingRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in Claude Desktop config: ${configPath}`);
+        }
+    }
+    const enterpriseConfig = objectRecordOr(doc.enterpriseConfig, {});
+    enterpriseConfig.inferenceProvider = "gateway";
+    enterpriseConfig.inferenceGatewayBaseUrl = anthropicCompatibleProxyUrl(params.backendUrl);
+    enterpriseConfig.inferenceGatewayApiKey = params.apiKey;
+    enterpriseConfig.inferenceModels = expandClaudeDesktopInferenceModels(params.claudeModels);
+    enterpriseConfig.isDesktopExtensionEnabled = true;
+    enterpriseConfig.isDesktopExtensionDirectoryEnabled = true;
+    enterpriseConfig.isDesktopExtensionSignatureRequired = false;
+    enterpriseConfig.isLocalDevMcpEnabled = true;
+    enterpriseConfig.isClaudeCodeForDesktopEnabled = true;
+    const deploymentOrganizationUuid = await discoverClaudeDesktopDeploymentOrganizationUuid(doc);
+    if (deploymentOrganizationUuid) {
+        enterpriseConfig.deploymentOrganizationUuid = deploymentOrganizationUuid;
+    }
+    doc.enterpriseConfig = enterpriseConfig;
+    doc.isUsingBuiltInNodeForMcp = true;
+    doc.isDxtAutoUpdatesEnabled = true;
+    await writeJsonObjectFile(configPath, doc);
+    return configPath;
+}
 function runOpenClawConfigCommand(args) {
     const run = (0, node_child_process_1.spawnSync)("openclaw", args, {
         encoding: "utf8",
@@ -1818,7 +2292,7 @@ function normalizeOpenCodeRestoreSnapshot(snapshot, fallbackConfigPath) {
     if (typeof snapshot !== "object" || snapshot === null || Array.isArray(snapshot))
         return null;
     const obj = snapshot;
-    if (obj.version === 2 && Array.isArray(obj.targets)) {
+    if ((obj.version === 2 || obj.version === 3) && Array.isArray(obj.targets)) {
         const targets = [];
         for (const entry of obj.targets) {
             if (typeof entry !== "object" || entry === null || Array.isArray(entry))
@@ -1835,6 +2309,11 @@ function normalizeOpenCodeRestoreSnapshot(snapshot, fallbackConfigPath) {
                     !Array.isArray(candidate.openAiProvider)
                     ? candidate.openAiProvider
                     : null,
+                anthropicProvider: typeof candidate.anthropicProvider === "object" &&
+                    candidate.anthropicProvider !== null &&
+                    !Array.isArray(candidate.anthropicProvider)
+                    ? candidate.anthropicProvider
+                    : null,
                 model: typeof candidate.model === "string" ? candidate.model : null,
                 schema: typeof candidate.schema === "string" ? candidate.schema : null,
                 plugin: "plugin" in candidate
@@ -1844,13 +2323,13 @@ function normalizeOpenCodeRestoreSnapshot(snapshot, fallbackConfigPath) {
                     : undefined,
             });
         }
-        return { version: 2, targets };
+        return { version: 3, targets };
     }
     const looksLikeV1 = "openAiProvider" in obj || "model" in obj || "schema" in obj;
     if (!looksLikeV1)
         return null;
     return {
-        version: 2,
+        version: 3,
         targets: [
             {
                 configPath: fallbackConfigPath,
@@ -1941,6 +2420,10 @@ function isManagedOpenCodeProvider(provider) {
     const options = objectRecordOr(provider.options, {});
     return isTheClawBayOpenAiCompatibleBaseUrl(options.baseURL);
 }
+function isManagedOpenCodeAnthropicProvider(provider) {
+    const options = objectRecordOr(provider.options, {});
+    return isTheClawBayAnthropicCompatibleBaseUrl(options.baseURL);
+}
 function isManagedOpenCodeModel(value, supportedModelIds) {
     if (typeof value !== "string")
         return false;
@@ -1953,7 +2436,7 @@ async function writeOpenCodeFamilyConfig(params) {
     const fallbackConfigPath = normalizedConfigPaths[0] ?? node_path_1.default.join(xdgConfigHomeDir(), "opencode", "opencode.json");
     const restoreState = (await readOpenCodeRestoreSnapshot(params.restoreStatePath, fallbackConfigPath)) ??
         {
-            version: 2,
+            version: 3,
             targets: [],
         };
     const supportedModelIds = new Set(params.models.map((entry) => entry.id).filter(Boolean));
@@ -1992,12 +2475,14 @@ async function writeOpenCodeFamilyConfig(params) {
         }
         const providerRoot = objectRecordOr(doc.provider, {});
         const openAiProvider = objectRecordOr(providerRoot[OPENAI_PROVIDER_ID], {});
+        const anthropicProvider = objectRecordOr(providerRoot[ANTHROPIC_PROVIDER_ID], {});
         const alreadyManaged = isManagedOpenCodeProvider(openAiProvider) && isManagedOpenCodeModel(doc.model, supportedModelIds);
         if (!alreadyManaged && !restoreHasTarget(configPath)) {
             restoreState.targets.push({
                 configPath,
                 existed,
                 openAiProvider: Object.keys(openAiProvider).length > 0 ? openAiProvider : null,
+                anthropicProvider: Object.keys(anthropicProvider).length > 0 ? anthropicProvider : null,
                 model: typeof doc.model === "string" && !doc.model.startsWith(`${DEFAULT_PROVIDER_ID}/`)
                     ? doc.model
                     : null,
@@ -2017,6 +2502,7 @@ async function writeOpenCodeFamilyConfig(params) {
         const optionsRoot = objectRecordOr(managedOpenAiProvider.options, {});
         optionsRoot.baseURL = openAiCompatibleProxyUrl(params.backendUrl);
         optionsRoot.apiKey = params.apiKey;
+        optionsRoot.setCacheKey = true;
         managedOpenAiProvider.options = optionsRoot;
         managedOpenAiProvider.models = buildOpenCodeModelsObject(params.models);
         managedOpenAiProvider.whitelist = params.models.map((entry) => entry.id).filter(Boolean);
@@ -2024,6 +2510,18 @@ async function writeOpenCodeFamilyConfig(params) {
             delete managedOpenAiProvider.blacklist;
         }
         providerRoot[OPENAI_PROVIDER_ID] = managedOpenAiProvider;
+        if ((params.claudeModels?.length ?? 0) > 0) {
+            const managedAnthropicProvider = objectRecordOr(providerRoot[ANTHROPIC_PROVIDER_ID], {});
+            const anthropicOptions = objectRecordOr(managedAnthropicProvider.options, {});
+            anthropicOptions.baseURL = anthropicCompatibleProxyV1Url(params.backendUrl);
+            anthropicOptions.apiKey = params.apiKey;
+            managedAnthropicProvider.options = anthropicOptions;
+            managedAnthropicProvider.whitelist = uniqueStrings(params.claudeModels ?? []);
+            if ("blacklist" in managedAnthropicProvider) {
+                delete managedAnthropicProvider.blacklist;
+            }
+            providerRoot[ANTHROPIC_PROVIDER_ID] = managedAnthropicProvider;
+        }
         if (DEFAULT_PROVIDER_ID in providerRoot) {
             delete providerRoot[DEFAULT_PROVIDER_ID];
         }
@@ -2129,12 +2627,13 @@ class SetupCommand extends base_command_1.BaseCommand {
                 managed?.backendUrl ??
                 DEFAULT_BACKEND_URL;
             const backendUrl = normalizeUrl(backendRaw, "--backend");
-            const [codexDetected, claudeDetected, continueDetected, clineDetected, gsdDetected, kiloDetected, rooDetected, traeDetected, aiderDetected, zoDetected] = await Promise.all([
+            const [codexDetected, claudeDetected, continueDetected, clineDetected, gsdDetected, openCodeDetected, kiloDetected, rooDetected, traeDetected, aiderDetected, zoDetected] = await Promise.all([
                 detectCodexClient(),
-                detectClaudeCodeClient(),
+                detectClaudeClient(),
                 detectContinueClient(),
                 detectClineClient(),
                 detectGsdClient(),
+                detectOpenCodeClient(),
                 detectKiloClient(),
                 detectRooClient(),
                 detectTraeClient(),
@@ -2144,7 +2643,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             const setupClients = [
                 {
                     id: "codex",
-                    label: "Codex CLI, VS Code extension, and Codex app",
+                    label: "Codex CLI and VS Code extension",
                     summaryLabel: "Codex",
                     detected: codexDetected,
                     recommended: true,
@@ -2153,8 +2652,8 @@ class SetupCommand extends base_command_1.BaseCommand {
                 },
                 {
                     id: "claude",
-                    label: "Claude Code CLI",
-                    summaryLabel: "Claude Code",
+                    label: "Claude Code / Claude Desktop",
+                    summaryLabel: "Claude",
                     detected: claudeDetected,
                     recommended: true,
                     icon: "✳",
@@ -2200,7 +2699,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                     id: "opencode",
                     label: "OpenCode",
                     summaryLabel: "OpenCode",
-                    detected: hasCommand("opencode"),
+                    detected: openCodeDetected,
                     recommended: true,
                     icon: "⌘",
                     siteUrl: "https://opencode.ai",
@@ -2299,6 +2798,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             let updatedPowerShellProfiles = [];
             let codexConfigPath = null;
             let updatedVsCodeEnvFiles = [];
+            let updatedEditorTerminalSettings = [];
+            let updatedClaudeEditorSettings = [];
+            let claudeDesktop3pConfigPathManaged = null;
             let sessionMigration = null;
             let authSeed = null;
             let authSeedCleanup = null;
@@ -2355,6 +2857,23 @@ class SetupCommand extends base_command_1.BaseCommand {
                 });
                 if (selectedSetupClients.has("codex") || selectedSetupClients.has("claude")) {
                     updatedVsCodeEnvFiles = await persistVsCodeServerEnvSource();
+                    updatedEditorTerminalSettings = await persistEditorTerminalEnvSettings({
+                        apiKey: authCredential,
+                        backendUrl,
+                        claudeEnabled: claudeEnvEnabled,
+                    });
+                    if (selectedSetupClients.has("claude")) {
+                        updatedClaudeEditorSettings = await persistClaudeEditorSettings({
+                            apiKey: authCredential,
+                            backendUrl,
+                            claudeEnabled: claudeEnvEnabled,
+                        });
+                        claudeDesktop3pConfigPathManaged = await writeClaudeDesktop3pConfig({
+                            backendUrl,
+                            apiKey: authCredential,
+                            claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
+                        });
+                    }
                 }
                 if (selectedSetupClients.has("codex")) {
                     progress.update("Configuring Codex");
@@ -2430,6 +2949,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                         backendUrl,
                         model: resolved?.model ?? DEFAULT_CODEX_MODEL,
                         models: resolved?.models ?? [{ id: DEFAULT_CODEX_MODEL, name: modelDisplayName(DEFAULT_CODEX_MODEL) }],
+                        claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
                         apiKey: authCredential,
                     });
                 }
@@ -2490,7 +3010,10 @@ class SetupCommand extends base_command_1.BaseCommand {
             if (resolved?.note)
                 summaryNotes.add(resolved.note);
             if (selectedSetupClients.has("claude") && claudeAccess?.enabled) {
-                summaryNotes.add("Claude Code: exported ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY, and CLAUDE_CODE_SIMPLE=1 for the official client.");
+                summaryNotes.add("Claude Code: exported ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY, CLAUDE_CODE_SIMPLE=1, disabled nonessential traffic, and disabled telemetry.");
+                if (claudeDesktop3pConfigPathManaged) {
+                    summaryNotes.add("Claude Desktop: configured hidden Claude-3p gateway mode with the /anthropic base URL for The Claw Bay.");
+                }
                 summaryNotes.add("If Claude Code is already open, restart it so the custom-key env takes effect cleanly. `claude auth status` should show `authMethod: api_key` once the new env is loaded.");
             }
             else if (selectedSetupClients.has("claude") && claudeAccess?.note) {
@@ -2547,6 +3070,9 @@ class SetupCommand extends base_command_1.BaseCommand {
                 this.log(resolved.note);
             if (selectedSetupClients.has("claude") && claudeAccess?.enabled) {
                 this.log(`- Claude Code base URL: ${anthropicCompatibleProxyUrl(backendUrl)}`);
+                if (claudeDesktop3pConfigPathManaged) {
+                    this.log(`- Claude Desktop 3P config: ${claudeDesktop3pConfigPathManaged}`);
+                }
             }
             else if (selectedSetupClients.has("claude") && claudeAccess?.note) {
                 this.log(`- Claude Code: ${claudeAccess.note}`);
@@ -2559,6 +3085,12 @@ class SetupCommand extends base_command_1.BaseCommand {
             if (updatedPowerShellProfiles.length > 0) {
                 this.log(`- PowerShell profiles updated: ${updatedPowerShellProfiles.join(", ")}`);
             }
+            if (updatedEditorTerminalSettings.length > 0) {
+                this.log(`- Editor terminal env updated: ${updatedEditorTerminalSettings.join(", ")}`);
+            }
+            if (updatedClaudeEditorSettings.length > 0) {
+                this.log(`- Claude editor settings updated: ${updatedClaudeEditorSettings.join(", ")}`);
+            }
             if (selectedSetupClients.has("codex")) {
                 this.log(`- Codex: configured (${codexConfigPath})`);
                 if (resolved)
@@ -2656,9 +3188,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- OpenClaw: not detected (skipped)");
             }
-            const openCodeDetected = setupClients.find((client) => client.id === "opencode")?.detected ?? false;
             if (selectedSetupClients.has("opencode")) {
                 this.log(`- OpenCode: configured (${openCodeConfigPaths.join(", ")})`);
+                this.log("- OpenCode note: configured the OpenAI-compatible /v1 route and, when Claude access is available, the Anthropic-compatible /anthropic/v1 route.");
                 this.log("- OpenCode note: plain OpenAI-compatible config is preferred. If you add a quota/auth plugin manually, use /api/codex-auth/v1/quota?format=legacy_codex for legacy Codex-style quota responses.");
                 const openCodeProjectConfig = findOpenCodeProjectConfigFile();
                 const openCodeConfigEnv = process.env.OPENCODE_CONFIG?.trim() || "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.55",
+  "version": "0.3.57",
   "description": "CLI for connecting Codex, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
   "bin": {