theclawbay 0.3.37 → 0.3.38

package/README.md

@@ -18,6 +18,7 @@ theclawbay setup --api-key <apiKey>
 
 In an interactive terminal, setup shows one picker for Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, Windows Trae, and Zo.
 Each row includes a terminal-friendly icon plus the tool's official site, and you can toggle items with arrow keys plus `Enter` or by pressing `1-9` and `0`.
+Re-running setup also migrates legacy OpenCode and Kilo patches to the current reasoning-capable provider path and refreshes OpenClaw model metadata.
 
 ## Optional
 

package/dist/commands/logout.js

@@ -12,6 +12,7 @@ const base_command_1 = require("../lib/base-command");
 const codex_auth_seeding_1 = require("../lib/codex-auth-seeding");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
 const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
+const supported_models_1 = require("../lib/supported-models");
 const paths_1 = require("../lib/config/paths");
 const OPENAI_PROVIDER_ID = "openai";
 const DEFAULT_PROVIDER_ID = "theclawbay";
@@ -29,6 +30,8 @@ const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homed
 const CLINE_SECRETS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "secrets.json");
 const AIDER_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".aider.conf.yml");
 const CLINE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "cline.restore.json");
+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 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");
@@ -39,6 +42,7 @@ const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
 ]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = [DEFAULT_PROVIDER_ID, WAN_PROVIDER_ID];
 const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const SUPPORTED_MODEL_IDS = new Set((0, supported_models_1.getSupportedModelIds)());
 const CONTINUE_MODEL_NAME = "The Claw Bay";
 const TRAE_PATCH_MARKER = "theclawbay-trae-patch";
 const TRAE_BUNDLE_BACKUP_SUFFIX = ".theclawbay-managed-backup";
@@ -162,6 +166,57 @@ function objectRecordOr(value, fallback) {
 function isTheClawBayOpenAiCompatibleBaseUrl(value) {
     return typeof value === "string" && value.trim().endsWith(THECLAWBAY_OPENAI_PROXY_SUFFIX);
 }
+function uniqueStrings(values) {
+    const output = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = value.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        output.push(normalized);
+    }
+    return output;
+}
+function xdgConfigHomeDir() {
+    const raw = process.env.XDG_CONFIG_HOME?.trim();
+    if (raw)
+        return raw;
+    return node_path_1.default.join(node_os_1.default.homedir(), ".config");
+}
+function configDirCandidates(appName) {
+    const home = node_os_1.default.homedir();
+    const dirs = [node_path_1.default.join(xdgConfigHomeDir(), appName)];
+    if (node_os_1.default.platform() === "darwin") {
+        dirs.push(node_path_1.default.join(home, "Library", "Application Support", appName));
+    }
+    else if (node_os_1.default.platform() === "win32") {
+        dirs.push(node_path_1.default.join(roamingAppDataDir(), appName));
+    }
+    return uniqueStrings(dirs);
+}
+function openCodeConfigCleanupTargets() {
+    const home = node_os_1.default.homedir();
+    const dirs = configDirCandidates("opencode");
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(node_path_1.default.join(dir, "opencode.json"));
+        candidates.push(node_path_1.default.join(dir, ".opencode.json"));
+        candidates.push(node_path_1.default.join(dir, "config.json"));
+    }
+    candidates.push(node_path_1.default.join(home, ".opencode.json"));
+    return uniqueStrings(candidates);
+}
+function kiloConfigCleanupTargets() {
+    const home = node_os_1.default.homedir();
+    const dirs = uniqueStrings([...configDirCandidates("kilo"), node_path_1.default.join(home, ".kilo")]);
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(node_path_1.default.join(dir, "opencode.json"));
+        candidates.push(node_path_1.default.join(dir, "config.json"));
+    }
+    return uniqueStrings(candidates);
+}
 async function readJsonObjectFile(filePath) {
     const existingRaw = await readFileIfExists(filePath);
     if (existingRaw === null || !existingRaw.trim())
@@ -179,6 +234,18 @@ async function writeJsonFile(filePath, value, mode) {
     if (mode !== undefined)
         await promises_1.default.chmod(filePath, mode);
 }
+function isManagedOpenCodeModel(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.startsWith(`${OPENAI_PROVIDER_ID}/`))
+        return false;
+    return SUPPORTED_MODEL_IDS.has(value.slice(`${OPENAI_PROVIDER_ID}/`.length));
+}
+function isManagedOpenCodeProvider(value) {
+    const provider = objectRecordOr(value, {});
+    const options = objectRecordOr(provider.options, {});
+    return isTheClawBayOpenAiCompatibleBaseUrl(options.baseURL);
+}
 function roamingAppDataDir() {
     if (process.env.APPDATA?.trim())
         return process.env.APPDATA;
@@ -433,67 +500,189 @@ async function cleanupOpenClawConfig() {
     await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
     return true;
 }
-async function cleanupOpenCodeConfig() {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
-    const existingRaw = await readFileIfExists(configPath);
-    if (existingRaw === null || !existingRaw.trim())
-        return false;
-    let doc;
-    try {
-        doc = objectRecordOr(JSON.parse(existingRaw), {});
-    }
-    catch {
-        return false;
-    }
-    let changed = false;
-    const providerRoot = objectRecordOr(doc.provider, {});
-    for (const id of [DEFAULT_PROVIDER_ID]) {
-        if (id in providerRoot) {
-            delete providerRoot[id];
-            changed = true;
+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)) {
+        const targets = [];
+        for (const entry of obj.targets) {
+            if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                continue;
+            const candidate = entry;
+            const configPath = typeof candidate.configPath === "string" ? candidate.configPath.trim() : "";
+            if (!configPath)
+                continue;
+            targets.push({
+                configPath,
+                existed: candidate.existed === true,
+                openAiProvider: typeof candidate.openAiProvider === "object" &&
+                    candidate.openAiProvider !== null &&
+                    !Array.isArray(candidate.openAiProvider)
+                    ? candidate.openAiProvider
+                    : null,
+                model: typeof candidate.model === "string" ? candidate.model : null,
+                schema: typeof candidate.schema === "string" ? candidate.schema : null,
+                plugin: "plugin" in candidate
+                    ? Array.isArray(candidate.plugin)
+                        ? candidate.plugin
+                        : null
+                    : undefined,
+            });
         }
+        return { version: 2, targets };
     }
-    doc.provider = providerRoot;
-    const model = doc.model;
-    if (typeof model === "string" && model.startsWith(`${DEFAULT_PROVIDER_ID}/`)) {
-        delete doc.model;
-        changed = true;
-    }
-    if (!changed)
-        return false;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return true;
+    const looksLikeV1 = "openAiProvider" in obj || "model" in obj || "schema" in obj;
+    if (!looksLikeV1)
+        return null;
+    return {
+        version: 2,
+        targets: [
+            {
+                configPath: fallbackConfigPath,
+                existed: true,
+                openAiProvider: typeof obj.openAiProvider === "object" && obj.openAiProvider !== null && !Array.isArray(obj.openAiProvider)
+                    ? obj.openAiProvider
+                    : null,
+                model: typeof obj.model === "string" ? obj.model : null,
+                schema: typeof obj.schema === "string" ? obj.schema : null,
+            },
+        ],
+    };
 }
-async function cleanupKiloConfig() {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "kilo", "opencode.json");
-    const existingRaw = await readFileIfExists(configPath);
+async function readOpenCodeRestoreSnapshot(restoreStatePath, fallbackConfigPath) {
+    const existingRaw = await readFileIfExists(restoreStatePath);
     if (existingRaw === null || !existingRaw.trim())
-        return false;
-    let doc;
+        return null;
     try {
-        doc = objectRecordOr(JSON.parse(existingRaw), {});
+        return normalizeOpenCodeRestoreSnapshot(JSON.parse(existingRaw), fallbackConfigPath);
     }
     catch {
-        return false;
+        return null;
     }
+}
+async function cleanupOpenCodeFamilyConfigs(params) {
+    const configPaths = uniqueStrings(params.configPaths);
+    const fallbackConfigPath = configPaths[0] ?? node_path_1.default.join(xdgConfigHomeDir(), "opencode", "opencode.json");
+    const snapshot = await readOpenCodeRestoreSnapshot(params.restoreStatePath, fallbackConfigPath);
+    const snapshotTargets = snapshot?.targets ?? [];
     let changed = false;
-    const providerRoot = objectRecordOr(doc.provider, {});
-    for (const id of [DEFAULT_PROVIDER_ID]) {
-        if (id in providerRoot) {
-            delete providerRoot[id];
+    const restoreConfig = async (target) => {
+        if (!target.existed) {
+            changed = (await removeFileIfExists(target.configPath)) || changed;
+            return;
+        }
+        const existingRaw = await readFileIfExists(target.configPath);
+        if (existingRaw === null || !existingRaw.trim()) {
+            return;
+        }
+        let doc;
+        try {
+            doc = objectRecordOr(JSON.parse(existingRaw), {});
+        }
+        catch {
+            return;
+        }
+        const providerRoot = objectRecordOr(doc.provider, {});
+        if (DEFAULT_PROVIDER_ID in providerRoot) {
+            delete providerRoot[DEFAULT_PROVIDER_ID];
+            changed = true;
+        }
+        if (Object.prototype.hasOwnProperty.call(target, "plugin")) {
+            if (target.plugin === null) {
+                if ("plugin" in doc) {
+                    delete doc.plugin;
+                    changed = true;
+                }
+            }
+            else {
+                doc.plugin = target.plugin;
+                changed = true;
+            }
+        }
+        if (target.openAiProvider) {
+            providerRoot[OPENAI_PROVIDER_ID] = target.openAiProvider;
+        }
+        else if (OPENAI_PROVIDER_ID in providerRoot) {
+            delete providerRoot[OPENAI_PROVIDER_ID];
+        }
+        doc.provider = providerRoot;
+        if (target.model === null) {
+            if (isManagedOpenCodeModel(doc.model) || (typeof doc.model === "string" && doc.model.startsWith(`${DEFAULT_PROVIDER_ID}/`))) {
+                delete doc.model;
+                changed = true;
+            }
+        }
+        else {
+            doc.model = target.model;
             changed = true;
         }
+        if (target.schema === null) {
+            if (typeof doc.$schema === "string") {
+                delete doc.$schema;
+                changed = true;
+            }
+        }
+        else {
+            doc.$schema = target.schema;
+            changed = true;
+        }
+        await promises_1.default.writeFile(target.configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    };
+    if (snapshotTargets.length > 0) {
+        for (const target of snapshotTargets) {
+            await restoreConfig(target);
+        }
+        await removeFileIfExists(params.restoreStatePath);
+        return changed;
     }
-    doc.provider = providerRoot;
-    const model = doc.model;
-    if (typeof model === "string" && model.startsWith(`${DEFAULT_PROVIDER_ID}/`)) {
-        delete doc.model;
+    for (const configPath of configPaths) {
+        const existingRaw = await readFileIfExists(configPath);
+        if (existingRaw === null || !existingRaw.trim())
+            continue;
+        let doc;
+        try {
+            doc = objectRecordOr(JSON.parse(existingRaw), {});
+        }
+        catch {
+            continue;
+        }
+        let fileChanged = false;
+        const providerRoot = objectRecordOr(doc.provider, {});
+        if (DEFAULT_PROVIDER_ID in providerRoot) {
+            delete providerRoot[DEFAULT_PROVIDER_ID];
+            fileChanged = true;
+        }
+        const model = doc.model;
+        if (typeof model === "string" &&
+            (model.startsWith(`${DEFAULT_PROVIDER_ID}/`) || isManagedOpenCodeModel(model))) {
+            delete doc.model;
+            fileChanged = true;
+        }
+        if (isManagedOpenCodeProvider(providerRoot[OPENAI_PROVIDER_ID])) {
+            delete providerRoot[OPENAI_PROVIDER_ID];
+            fileChanged = true;
+        }
+        if (!fileChanged)
+            continue;
         changed = true;
+        doc.provider = providerRoot;
+        await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
     }
-    if (!changed)
-        return false;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return true;
+    await removeFileIfExists(params.restoreStatePath);
+    return changed;
+}
+async function cleanupOpenCodeConfig() {
+    return cleanupOpenCodeFamilyConfigs({
+        configPaths: openCodeConfigCleanupTargets(),
+        restoreStatePath: OPENCODE_RESTORE_STATE_PATH,
+    });
+}
+async function cleanupKiloConfig() {
+    return cleanupOpenCodeFamilyConfigs({
+        configPaths: kiloConfigCleanupTargets(),
+        restoreStatePath: KILO_RESTORE_STATE_PATH,
+    });
 }
 async function cleanupTraeBundle() {
     const bundlePath = traeBundlePath();

package/dist/commands/setup.js

@@ -43,6 +43,8 @@ const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homed
 const CLINE_SECRETS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "secrets.json");
 const AIDER_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".aider.conf.yml");
 const CLINE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "cline.restore.json");
+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 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");
@@ -65,6 +67,9 @@ const TRAE_PATCH_MARKER = "theclawbay-trae-patch";
 const TRAE_BUNDLE_BACKUP_SUFFIX = ".theclawbay-managed-backup";
 const TRAE_TARGET_FUNCTION_START = "async setOriginModelListMapAndCache(e,t=!0){";
 const TRAE_TARGET_FUNCTION_END = "}async refreshModelListConfig";
+const OPENAI_PROVIDER_ID = "openai";
+const OPENCODE_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
+const KILO_CONFIG_SCHEMA_URL = "https://kilo.ai/config.json";
 const ZO_CONFIG_NAME_PREFIX = "The Claw Bay";
 const ZO_COOKIE_HOST = ".zo.computer";
 const ZO_ACCESS_TOKEN_COOKIE = "access_token";
@@ -437,6 +442,56 @@ function openAiCompatibleProxyUrl(backendUrl) {
 function isTheClawBayOpenAiCompatibleBaseUrl(value) {
     return typeof value === "string" && value.trim().endsWith(THECLAWBAY_OPENAI_PROXY_SUFFIX);
 }
+function uniqueStrings(values) {
+    const output = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = value.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        output.push(normalized);
+    }
+    return output;
+}
+function xdgConfigHomeDir() {
+    const raw = process.env.XDG_CONFIG_HOME?.trim();
+    if (raw)
+        return raw;
+    return node_path_1.default.join(node_os_1.default.homedir(), ".config");
+}
+function configFileCandidatesForDir(dir, basenames) {
+    return basenames.map((basename) => node_path_1.default.join(dir, basename));
+}
+function findProjectConfigFile(params) {
+    let current = node_path_1.default.resolve(params.startDir);
+    const root = node_path_1.default.parse(current).root;
+    while (true) {
+        for (const candidate of configFileCandidatesForDir(current, params.basenames)) {
+            if ((0, node_fs_1.existsSync)(candidate))
+                return candidate;
+        }
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(current, ".git")))
+            return null;
+        if (current === root)
+            return null;
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function configDirCandidates(appName) {
+    const home = node_os_1.default.homedir();
+    const dirs = [node_path_1.default.join(xdgConfigHomeDir(), appName)];
+    if (node_os_1.default.platform() === "darwin") {
+        dirs.push(node_path_1.default.join(home, "Library", "Application Support", appName));
+    }
+    else if (node_os_1.default.platform() === "win32") {
+        dirs.push(node_path_1.default.join(roamingAppDataDir(), appName));
+    }
+    return uniqueStrings(dirs);
+}
 async function readFileIfExists(filePath) {
     try {
         return await promises_1.default.readFile(filePath, "utf8");
@@ -1203,7 +1258,7 @@ async function patchOpenClawConfigFile(params) {
         baseUrl: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
         apiKey: params.apiKey,
         api: "openai-responses",
-        models: params.models,
+        models: buildOpenClawModels(params.models),
     };
     const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
     await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
@@ -1235,6 +1290,9 @@ async function patchOpenClawConfigFile(params) {
     const defaultsRoot = objectRecordOr(agentsRoot.defaults, {});
     const modelRoot = objectRecordOr(defaultsRoot.model, {});
     modelRoot.primary = resolveOpenClawPrimaryModel(params);
+    if (typeof defaultsRoot.thinkingDefault !== "string") {
+        defaultsRoot.thinkingDefault = "medium";
+    }
     defaultsRoot.model = modelRoot;
     agentsRoot.defaults = defaultsRoot;
     doc.agents = agentsRoot;
@@ -1251,87 +1309,302 @@ function objectRecordOr(value, fallback) {
     }
     return fallback;
 }
-function openCodeModelsObject(models) {
+function modelContextLimit(modelId) {
+    if (modelId === "gpt-5.4")
+        return 1050000;
+    return 272000;
+}
+function modelOutputLimit(modelId) {
+    if (modelId === "gpt-5.4")
+        return 128000;
+    return 65536;
+}
+function buildOpenClawModels(models) {
+    const supportedModelMap = new Map((0, supported_models_1.getSupportedModels)().map((model) => [model.id, model]));
+    return models
+        .filter((model) => Boolean(model.id))
+        .map((model) => {
+        const pricing = supportedModelMap.get(model.id);
+        return {
+            id: model.id,
+            name: model.name || model.id,
+            api: "openai-responses",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: pricing?.inputPer1M ?? 0,
+                output: pricing?.outputPer1M ?? 0,
+                cacheRead: pricing?.cachedInputPer1M ?? 0,
+                cacheWrite: pricing?.inputPer1M ?? 0,
+            },
+            contextWindow: modelContextLimit(model.id),
+            maxTokens: modelOutputLimit(model.id),
+        };
+    });
+}
+function buildOpenCodeModelConfig(model) {
+    return {
+        name: model.name || model.id,
+        reasoning: true,
+        tool_call: true,
+        attachment: true,
+        modalities: {
+            input: ["text", "image"],
+            output: ["text"],
+        },
+        limit: {
+            context: modelContextLimit(model.id),
+            output: modelOutputLimit(model.id),
+        },
+    };
+}
+function buildOpenCodeModelsObject(models) {
     const result = {};
     for (const model of models) {
         if (!model.id)
             continue;
-        result[model.id] = { name: model.name || model.id };
+        result[model.id] = buildOpenCodeModelConfig(model);
     }
     return result;
 }
-async function writeOpenCodeConfig(params) {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
-    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
-    let existingRaw = "";
-    try {
-        existingRaw = await promises_1.default.readFile(configPath, "utf8");
-    }
-    catch (error) {
-        const err = error;
-        if (err.code !== "ENOENT")
-            throw error;
-    }
-    let doc = {};
-    if (existingRaw.trim()) {
-        try {
-            doc = objectRecordOr(JSON.parse(existingRaw), {});
-        }
-        catch {
-            throw new Error(`invalid JSON in OpenCode config: ${configPath}`);
+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)) {
+        const targets = [];
+        for (const entry of obj.targets) {
+            if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                continue;
+            const candidate = entry;
+            const configPath = typeof candidate.configPath === "string" ? candidate.configPath.trim() : "";
+            if (!configPath)
+                continue;
+            targets.push({
+                configPath,
+                existed: candidate.existed === true,
+                openAiProvider: typeof candidate.openAiProvider === "object" &&
+                    candidate.openAiProvider !== null &&
+                    !Array.isArray(candidate.openAiProvider)
+                    ? candidate.openAiProvider
+                    : null,
+                model: typeof candidate.model === "string" ? candidate.model : null,
+                schema: typeof candidate.schema === "string" ? candidate.schema : null,
+                plugin: "plugin" in candidate
+                    ? Array.isArray(candidate.plugin)
+                        ? candidate.plugin
+                        : null
+                    : undefined,
+            });
         }
+        return { version: 2, targets };
     }
-    const providerRoot = objectRecordOr(doc.provider, {});
-    providerRoot[DEFAULT_PROVIDER_ID] = {
-        npm: "@ai-sdk/openai-compatible",
-        name: DEFAULT_PROVIDER_ID,
-        options: {
-            baseURL: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
-            apiKey: params.apiKey,
-        },
-        models: openCodeModelsObject(params.models),
+    const looksLikeV1 = "openAiProvider" in obj || "model" in obj || "schema" in obj;
+    if (!looksLikeV1)
+        return null;
+    return {
+        version: 2,
+        targets: [
+            {
+                configPath: fallbackConfigPath,
+                existed: true,
+                openAiProvider: typeof obj.openAiProvider === "object" && obj.openAiProvider !== null && !Array.isArray(obj.openAiProvider)
+                    ? obj.openAiProvider
+                    : null,
+                model: typeof obj.model === "string" ? obj.model : null,
+                schema: typeof obj.schema === "string" ? obj.schema : null,
+            },
+        ],
     };
-    doc.provider = providerRoot;
-    doc.model = `${DEFAULT_PROVIDER_ID}/${params.model}`;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return configPath;
 }
-async function writeKiloConfig(params) {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "kilo", "opencode.json");
-    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
-    let existingRaw = "";
+async function readOpenCodeRestoreSnapshot(restoreStatePath, fallbackConfigPath) {
+    const existingRaw = await readFileIfExists(restoreStatePath);
+    if (existingRaw === null || !existingRaw.trim())
+        return null;
     try {
-        existingRaw = await promises_1.default.readFile(configPath, "utf8");
+        return normalizeOpenCodeRestoreSnapshot(JSON.parse(existingRaw), fallbackConfigPath);
     }
-    catch (error) {
-        const err = error;
-        if (err.code !== "ENOENT")
-            throw error;
+    catch {
+        return null;
     }
-    let doc = {};
-    if (existingRaw.trim()) {
+}
+function openCodeConfigFileCandidates() {
+    const home = node_os_1.default.homedir();
+    const dirs = configDirCandidates("opencode");
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(node_path_1.default.join(dir, "opencode.json"));
+        candidates.push(node_path_1.default.join(dir, ".opencode.json"));
+        candidates.push(node_path_1.default.join(dir, "config.json"));
+    }
+    candidates.push(node_path_1.default.join(home, ".opencode.json"));
+    return uniqueStrings(candidates);
+}
+function findOpenCodeProjectConfigFile() {
+    return findProjectConfigFile({
+        startDir: process.cwd(),
+        basenames: ["opencode.json", "opencode.jsonc", ".opencode.json", ".opencode.jsonc"],
+    });
+}
+function isOpenCodeAuthPlugin(value) {
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    return normalized.startsWith("opencode-openai-codex-auth");
+}
+function filteredOpenCodePlugins(value) {
+    if (!Array.isArray(value))
+        return { next: value, changed: false };
+    const filtered = value.filter((entry) => !isOpenCodeAuthPlugin(entry));
+    if (filtered.length === value.length)
+        return { next: value, changed: false };
+    return { next: filtered, changed: true };
+}
+function kiloConfigFileCandidates() {
+    const home = node_os_1.default.homedir();
+    const dirs = uniqueStrings([...configDirCandidates("kilo"), node_path_1.default.join(home, ".kilo")]);
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(node_path_1.default.join(dir, "opencode.json"));
+        candidates.push(node_path_1.default.join(dir, "config.json"));
+    }
+    return uniqueStrings(candidates);
+}
+function resolveOpenCodeConfigTargets() {
+    const candidates = openCodeConfigFileCandidates();
+    const existing = candidates.filter((candidate) => (0, node_fs_1.existsSync)(candidate));
+    if (existing.length)
+        return existing;
+    const primaryDir = configDirCandidates("opencode")[0] ?? node_path_1.default.join(xdgConfigHomeDir(), "opencode");
+    return uniqueStrings([node_path_1.default.join(primaryDir, "opencode.json"), node_path_1.default.join(primaryDir, ".opencode.json")]);
+}
+function resolveKiloConfigTargets() {
+    const candidates = kiloConfigFileCandidates();
+    const existing = candidates.filter((candidate) => (0, node_fs_1.existsSync)(candidate));
+    if (existing.length)
+        return existing;
+    const home = node_os_1.default.homedir();
+    const primaryDir = uniqueStrings([...configDirCandidates("kilo"), node_path_1.default.join(home, ".kilo")])[0] ??
+        node_path_1.default.join(xdgConfigHomeDir(), "kilo");
+    return uniqueStrings([node_path_1.default.join(primaryDir, "opencode.json")]);
+}
+function isManagedOpenCodeProvider(provider) {
+    const options = objectRecordOr(provider.options, {});
+    return isTheClawBayOpenAiCompatibleBaseUrl(options.baseURL);
+}
+function isManagedOpenCodeModel(value, supportedModelIds) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.startsWith(`${OPENAI_PROVIDER_ID}/`))
+        return false;
+    return supportedModelIds.has(value.slice(`${OPENAI_PROVIDER_ID}/`.length));
+}
+async function writeOpenCodeFamilyConfig(params) {
+    const normalizedConfigPaths = uniqueStrings(params.configPaths);
+    const fallbackConfigPath = normalizedConfigPaths[0] ?? node_path_1.default.join(xdgConfigHomeDir(), "opencode", "opencode.json");
+    const restoreState = (await readOpenCodeRestoreSnapshot(params.restoreStatePath, fallbackConfigPath)) ??
+        {
+            version: 2,
+            targets: [],
+        };
+    const supportedModelIds = new Set(params.models.map((entry) => entry.id).filter(Boolean));
+    const restoreHasTarget = (configPath) => restoreState.targets.some((entry) => entry.configPath === configPath);
+    let restoreStateChanged = false;
+    const ensureRestorePluginSnapshot = (configPath, plugin) => {
+        const target = restoreState.targets.find((entry) => entry.configPath === configPath);
+        if (!target)
+            return;
+        if (Object.prototype.hasOwnProperty.call(target, "plugin"))
+            return;
+        target.plugin = Array.isArray(plugin) ? plugin : null;
+        restoreStateChanged = true;
+    };
+    for (const configPath of normalizedConfigPaths) {
+        await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+        let existed = true;
+        let existingRaw = "";
         try {
-            doc = objectRecordOr(JSON.parse(existingRaw), {});
+            existingRaw = await promises_1.default.readFile(configPath, "utf8");
         }
-        catch {
-            throw new Error(`invalid JSON in Kilo config: ${configPath}`);
+        catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT")
+                throw error;
+            existed = false;
+        }
+        let doc = {};
+        if (existingRaw.trim()) {
+            try {
+                doc = objectRecordOr(JSON.parse(existingRaw), {});
+            }
+            catch {
+                throw new Error(`invalid JSON in config: ${configPath}`);
+            }
+        }
+        const providerRoot = objectRecordOr(doc.provider, {});
+        const openAiProvider = objectRecordOr(providerRoot[OPENAI_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,
+                model: typeof doc.model === "string" && !doc.model.startsWith(`${DEFAULT_PROVIDER_ID}/`)
+                    ? doc.model
+                    : null,
+                schema: typeof doc.$schema === "string" ? doc.$schema : null,
+                plugin: Array.isArray(doc.plugin) ? doc.plugin : null,
+            });
+            restoreStateChanged = true;
+        }
+        else if (!alreadyManaged) {
+            ensureRestorePluginSnapshot(configPath, doc.plugin);
+        }
+        const pluginFilter = filteredOpenCodePlugins(doc.plugin);
+        if (pluginFilter.changed) {
+            doc.plugin = pluginFilter.next;
+        }
+        const managedOpenAiProvider = objectRecordOr(providerRoot[OPENAI_PROVIDER_ID], {});
+        const optionsRoot = objectRecordOr(managedOpenAiProvider.options, {});
+        optionsRoot.baseURL = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`;
+        optionsRoot.apiKey = params.apiKey;
+        managedOpenAiProvider.options = optionsRoot;
+        managedOpenAiProvider.models = buildOpenCodeModelsObject(params.models);
+        managedOpenAiProvider.whitelist = params.models.map((entry) => entry.id).filter(Boolean);
+        if ("blacklist" in managedOpenAiProvider) {
+            delete managedOpenAiProvider.blacklist;
+        }
+        providerRoot[OPENAI_PROVIDER_ID] = managedOpenAiProvider;
+        if (DEFAULT_PROVIDER_ID in providerRoot) {
+            delete providerRoot[DEFAULT_PROVIDER_ID];
         }
+        doc.$schema = params.schemaUrl;
+        doc.provider = providerRoot;
+        doc.model = `${OPENAI_PROVIDER_ID}/${params.model}`;
+        await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
     }
-    const providerRoot = objectRecordOr(doc.provider, {});
-    providerRoot[DEFAULT_PROVIDER_ID] = {
-        npm: "@ai-sdk/openai-compatible",
-        name: DEFAULT_PROVIDER_ID,
-        options: {
-            baseURL: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
-            apiKey: params.apiKey,
-        },
-        models: openCodeModelsObject(params.models),
-    };
-    doc.$schema = "https://kilo.ai/config.json";
-    doc.provider = providerRoot;
-    doc.model = `${DEFAULT_PROVIDER_ID}/${params.model || DEFAULT_KILO_MODEL}`;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return configPath;
+    if (restoreState.targets.length > 0 && restoreStateChanged) {
+        await writeJsonObjectFile(params.restoreStatePath, restoreState, 0o600);
+    }
+    return normalizedConfigPaths;
+}
+async function writeOpenCodeConfig(params) {
+    return writeOpenCodeFamilyConfig({
+        configPaths: resolveOpenCodeConfigTargets(),
+        restoreStatePath: OPENCODE_RESTORE_STATE_PATH,
+        schemaUrl: OPENCODE_CONFIG_SCHEMA_URL,
+        ...params,
+    });
+}
+async function writeKiloConfig(params) {
+    return writeOpenCodeFamilyConfig({
+        configPaths: resolveKiloConfigTargets(),
+        restoreStatePath: KILO_RESTORE_STATE_PATH,
+        schemaUrl: KILO_CONFIG_SCHEMA_URL,
+        ...params,
+    });
 }
 function traePatchSnippet(params) {
     const patchedModels = params.models.length
@@ -1512,8 +1785,8 @@ class SetupCommand extends base_command_1.BaseCommand {
             let clineConfigPaths = [];
             let openClawConfigPath = null;
             let openClawCliWarning = null;
-            let openCodePath = null;
-            let kiloConfigPath = null;
+            let openCodeConfigPaths = [];
+            let kiloConfigPaths = [];
             let rooConfigPaths = [];
             let traeBundlePathPatched = null;
             let aiderConfigPath = null;
@@ -1577,7 +1850,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                 }
                 if (selectedSetupClients.has("opencode")) {
                     progress.update("Configuring OpenCode");
-                    openCodePath = await writeOpenCodeConfig({
+                    openCodeConfigPaths = await writeOpenCodeConfig({
                         backendUrl,
                         model: resolved?.model ?? DEFAULT_CODEX_MODEL,
                         models: resolved?.models ?? [{ id: DEFAULT_CODEX_MODEL, name: modelDisplayName(DEFAULT_CODEX_MODEL) }],
@@ -1586,7 +1859,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                 }
                 if (selectedSetupClients.has("kilo")) {
                     progress.update("Configuring Kilo Code");
-                    kiloConfigPath = await writeKiloConfig({
+                    kiloConfigPaths = await writeKiloConfig({
                         backendUrl,
                         model: resolved?.model ?? DEFAULT_CODEX_MODEL,
                         models: resolved?.models ?? [{ id: DEFAULT_CODEX_MODEL, name: modelDisplayName(DEFAULT_CODEX_MODEL) }],
@@ -1761,7 +2034,15 @@ class SetupCommand extends base_command_1.BaseCommand {
             }
             const openCodeDetected = setupClients.find((client) => client.id === "opencode")?.detected ?? false;
             if (selectedSetupClients.has("opencode")) {
-                this.log(`- OpenCode: configured (${openCodePath})`);
+                this.log(`- OpenCode: configured (${openCodeConfigPaths.join(", ")})`);
+                const openCodeProjectConfig = findOpenCodeProjectConfigFile();
+                const openCodeConfigEnv = process.env.OPENCODE_CONFIG?.trim() || "";
+                if (openCodeConfigEnv) {
+                    this.log(`- OpenCode note: OPENCODE_CONFIG is set (${openCodeConfigEnv}). OpenCode may load that file and override your global config.`);
+                }
+                if (openCodeProjectConfig) {
+                    this.log(`- OpenCode note: found project-level ${node_path_1.default.basename(openCodeProjectConfig)} at ${openCodeProjectConfig} which overrides global config.`);
+                }
             }
             else if (openCodeDetected) {
                 this.log("- OpenCode: detected but skipped");
@@ -1770,7 +2051,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                 this.log("- OpenCode: not detected (skipped)");
             }
             if (selectedSetupClients.has("kilo")) {
-                this.log(`- Kilo Code: configured (${kiloConfigPath})`);
+                this.log(`- Kilo Code: configured (${kiloConfigPaths.join(", ")})`);
             }
             else if (kiloDetected) {
                 this.log("- Kilo Code: detected but skipped");

package/package.json

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