theclawbay 0.3.85 → 0.4.0

package/dist/lib/clients/claude.js

@@ -0,0 +1,400 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_DESKTOP_3P_STATE_PATH = exports.CLAUDE_EDITOR_SETTINGS_STATE_PATH = exports.MANAGED_CLAUDE_ENV_NAMES = exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING = exports.CLAUDE_CODE_EDITOR_ENV_SETTING = exports.CLAUDE_ENV_ENABLE_TELEMETRY_NAME = exports.CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME = exports.CLAUDE_ENV_SIMPLE_MODE_NAME = void 0;
+exports.claudeDesktop3pConfigPath = claudeDesktop3pConfigPath;
+exports.claudeDesktopLogCandidates = claudeDesktopLogCandidates;
+exports.claudeDesktopAppCandidatePaths = claudeDesktopAppCandidatePaths;
+exports.detectClaudeCodeClient = detectClaudeCodeClient;
+exports.detectClaudeClient = detectClaudeClient;
+exports.buildManagedClaudeEditorEnv = buildManagedClaudeEditorEnv;
+exports.persistClaudeEditorSettings = persistClaudeEditorSettings;
+exports.cleanupClaudeEditorSettings = cleanupClaudeEditorSettings;
+exports.cleanupClaudeDesktop3pConfig = cleanupClaudeDesktop3pConfig;
+exports.cleanupLegacyClaudeEditorTerminalEnvSettings = cleanupLegacyClaudeEditorTerminalEnvSettings;
+exports.expandClaudeDesktopInferenceModels = expandClaudeDesktopInferenceModels;
+exports.discoverClaudeDesktopDeploymentOrganizationUuid = discoverClaudeDesktopDeploymentOrganizationUuid;
+exports.writeClaudeDesktop3pConfig = writeClaudeDesktop3pConfig;
+const env_persist_1 = require("../shared/env-persist");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../config/paths");
+const node_os_1 = __importDefault(require("node:os"));
+const fsx_1 = require("../shared/fsx");
+const platform_1 = require("../shared/platform");
+const node_fs_1 = require("node:fs");
+const urls_1 = require("../shared/urls");
+const editor_env_1 = require("../shared/editor-env");
+const promises_1 = __importDefault(require("node:fs/promises"));
+// Extracted from src/commands/setup.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+exports.CLAUDE_ENV_SIMPLE_MODE_NAME = "CLAUDE_CODE_SIMPLE";
+exports.CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME = "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC";
+exports.CLAUDE_ENV_ENABLE_TELEMETRY_NAME = "CLAUDE_CODE_ENABLE_TELEMETRY";
+exports.CLAUDE_CODE_EDITOR_ENV_SETTING = "claudeCode.environmentVariables";
+exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING = "claudeCode.disableLoginPrompt";
+exports.MANAGED_CLAUDE_ENV_NAMES = [
+    env_persist_1.CLAUDE_ENV_API_KEY_NAME,
+    env_persist_1.CLAUDE_ENV_BASE_URL_NAME,
+    exports.CLAUDE_ENV_SIMPLE_MODE_NAME,
+    exports.CLAUDE_ENV_DISABLE_NONESSENTIAL_TRAFFIC_NAME,
+    exports.CLAUDE_ENV_ENABLE_TELEMETRY_NAME,
+];
+exports.CLAUDE_EDITOR_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "claude-editor-settings.restore.json");
+exports.CLAUDE_DESKTOP_3P_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "claude-desktop-3p.restore.json");
+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 (0, fsx_1.uniqueStrings)([
+        "/Applications/Claude.app",
+        node_path_1.default.join(home, "Applications", "Claude.app"),
+    ]);
+}
+async function detectClaudeCodeClient() {
+    if ((0, platform_1.hasCommand)("claude"))
+        return true;
+    const candidates = [
+        node_path_1.default.join(node_os_1.default.homedir(), ".claude"),
+        node_path_1.default.join(node_os_1.default.homedir(), ".claude.json"),
+        node_path_1.default.join(node_os_1.default.homedir(), ".config", "claude"),
+    ];
+    for (const candidate of candidates) {
+        if (await (0, fsx_1.pathExists)(candidate))
+            return true;
+    }
+    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 (0, fsx_1.pathExists)(configPath)) || (await (0, fsx_1.pathExists)(node_path_1.default.dirname(configPath)));
+}
+function buildManagedClaudeEditorEnv(params) {
+    return {
+        [env_persist_1.CLAUDE_ENV_API_KEY_NAME]: params.apiKey,
+        [env_persist_1.CLAUDE_ENV_BASE_URL_NAME]: (0, urls_1.anthropicCompatibleProxyUrl)(params.backendUrl),
+    };
+}
+async function persistClaudeEditorSettings(params) {
+    const existingSnapshotRaw = await (0, fsx_1.readFileIfExists)(exports.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 (0, editor_env_1.editorHosts)()) {
+        const settingsPath = host.userSettingsPath;
+        const hostPresent = (await (0, fsx_1.pathExists)(host.extensionDir)) ||
+            (await (0, fsx_1.pathExists)(settingsPath)) ||
+            (await (0, fsx_1.pathExists)(node_path_1.default.dirname(settingsPath)));
+        if (!hostPresent)
+            continue;
+        const existed = await (0, fsx_1.pathExists)(settingsPath);
+        const settings = await (0, fsx_1.readJsonObjectFile)(settingsPath);
+        const currentEnvValue = settings[exports.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, exports.CLAUDE_CODE_EDITOR_ENV_SETTING),
+                envPreviousValue: currentEnvValue ?? null,
+                disableLoginPromptHadKey: Object.prototype.hasOwnProperty.call(settings, exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING),
+                disableLoginPromptPreviousValue: settings[exports.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;
+            }
+            for (const name of exports.MANAGED_CLAUDE_ENV_NAMES) {
+                if (name in desiredEnv || !(name in nextEnv))
+                    continue;
+                delete nextEnv[name];
+                changed = true;
+            }
+            settings[exports.CLAUDE_CODE_EDITOR_ENV_SETTING] = nextEnv;
+            if (settings[exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] !== true) {
+                settings[exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] = true;
+                changed = true;
+            }
+        }
+        else {
+            if (Object.prototype.hasOwnProperty.call(settings, exports.CLAUDE_CODE_EDITOR_ENV_SETTING)) {
+                delete settings[exports.CLAUDE_CODE_EDITOR_ENV_SETTING];
+                changed = true;
+            }
+            if (Object.prototype.hasOwnProperty.call(settings, exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING)) {
+                delete settings[exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING];
+                changed = true;
+            }
+        }
+        if (!changed)
+            continue;
+        await (0, fsx_1.writeJsonObjectFile)(settingsPath, settings);
+        managedPaths.push(settingsPath);
+    }
+    await (0, fsx_1.writeJsonObjectFile)(exports.CLAUDE_EDITOR_SETTINGS_STATE_PATH, Array.from(snapshotByPath.values()), 0o600);
+    return managedPaths;
+}
+async function cleanupClaudeEditorSettings() {
+    const snapshotRaw = await (0, fsx_1.readFileIfExists)(exports.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 (0, fsx_1.readJsonObjectFile)(entry.settingsPath);
+        if (!entry.envHadKey) {
+            delete settings[exports.CLAUDE_CODE_EDITOR_ENV_SETTING];
+        }
+        else {
+            settings[exports.CLAUDE_CODE_EDITOR_ENV_SETTING] = entry.envPreviousValue;
+        }
+        if (!entry.disableLoginPromptHadKey) {
+            delete settings[exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING];
+        }
+        else {
+            settings[exports.CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] = entry.disableLoginPromptPreviousValue;
+        }
+        if (entry.existed || Object.keys(settings).length > 0) {
+            await (0, fsx_1.writeJsonObjectFile)(entry.settingsPath, settings);
+            updated.push(entry.settingsPath);
+            continue;
+        }
+        if (await (0, fsx_1.removeFileIfExists)(entry.settingsPath)) {
+            updated.push(entry.settingsPath);
+        }
+    }
+    await (0, fsx_1.removeFileIfExists)(exports.CLAUDE_EDITOR_SETTINGS_STATE_PATH);
+    return updated;
+}
+async function cleanupClaudeDesktop3pConfig() {
+    const snapshotRaw = await (0, fsx_1.readFileIfExists)(exports.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 (0, fsx_1.removeFileIfExists)(exports.CLAUDE_DESKTOP_3P_STATE_PATH);
+        return false;
+    }
+    if (!snapshot.existed) {
+        const removed = await (0, fsx_1.removeFileIfExists)(snapshot.configPath);
+        await (0, fsx_1.removeFileIfExists)(exports.CLAUDE_DESKTOP_3P_STATE_PATH);
+        return removed;
+    }
+    const previousRaw = snapshot.previousRaw ?? "";
+    const existingRaw = await (0, fsx_1.readFileIfExists)(snapshot.configPath);
+    if (existingRaw === previousRaw) {
+        await (0, fsx_1.removeFileIfExists)(exports.CLAUDE_DESKTOP_3P_STATE_PATH);
+        return false;
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(snapshot.configPath), { recursive: true });
+    await promises_1.default.writeFile(snapshot.configPath, previousRaw, "utf8");
+    await (0, fsx_1.removeFileIfExists)(exports.CLAUDE_DESKTOP_3P_STATE_PATH);
+    return true;
+}
+async function cleanupLegacyClaudeEditorTerminalEnvSettings(params) {
+    const snapshotRaw = await (0, fsx_1.readFileIfExists)(editor_env_1.EDITOR_TERMINAL_ENV_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return [];
+    let entries = [];
+    try {
+        entries = JSON.parse(snapshotRaw);
+    }
+    catch {
+        return [];
+    }
+    const settingsKey = (0, editor_env_1.terminalIntegratedEnvSettingsKey)();
+    const managedClaudeEnv = {
+        [env_persist_1.CLAUDE_ENV_API_KEY_NAME]: params.apiKey,
+        [env_persist_1.CLAUDE_ENV_BASE_URL_NAME]: (0, urls_1.anthropicCompatibleProxyUrl)(params.backendUrl),
+    };
+    const updated = [];
+    for (const entry of entries) {
+        const settings = await (0, fsx_1.readJsonObjectFile)(entry.settingsPath);
+        const currentValue = settings[settingsKey];
+        if (typeof currentValue !== "object" || currentValue === null || Array.isArray(currentValue))
+            continue;
+        const currentEnv = { ...currentValue };
+        const previousEnv = typeof entry.previousValue === "object" &&
+            entry.previousValue !== null &&
+            !Array.isArray(entry.previousValue)
+            ? { ...entry.previousValue }
+            : {};
+        let changed = false;
+        for (const name of exports.MANAGED_CLAUDE_ENV_NAMES) {
+            const expectedManagedValue = managedClaudeEnv[name];
+            const currentManagedValue = currentEnv[name];
+            const currentMatchesManaged = typeof expectedManagedValue === "string" ? currentManagedValue === expectedManagedValue : false;
+            if (!currentMatchesManaged)
+                continue;
+            if (Object.prototype.hasOwnProperty.call(previousEnv, name)) {
+                currentEnv[name] = previousEnv[name];
+            }
+            else {
+                delete currentEnv[name];
+            }
+            changed = true;
+        }
+        if (!changed)
+            continue;
+        settings[settingsKey] = currentEnv;
+        await (0, fsx_1.writeJsonObjectFile)(entry.settingsPath, settings);
+        updated.push(entry.settingsPath);
+    }
+    return updated;
+}
+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 = (0, fsx_1.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 (0, fsx_1.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 (0, fsx_1.pathExists)(configPath)) ||
+        (await (0, fsx_1.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 (0, fsx_1.readFileIfExists)(exports.CLAUDE_DESKTOP_3P_STATE_PATH);
+    if (!existingSnapshotRaw?.trim()) {
+        const snapshot = {
+            version: 1,
+            configPath,
+            existed,
+            previousRaw: existed ? existingRaw : null,
+        };
+        await (0, fsx_1.writeJsonObjectFile)(exports.CLAUDE_DESKTOP_3P_STATE_PATH, snapshot, 0o600);
+    }
+    let doc = {};
+    if (existingRaw.trim()) {
+        try {
+            doc = (0, fsx_1.objectRecordOr)(JSON.parse(existingRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in Claude Desktop config: ${configPath}`);
+        }
+    }
+    const enterpriseConfig = (0, fsx_1.objectRecordOr)(doc.enterpriseConfig, {});
+    enterpriseConfig.inferenceProvider = "gateway";
+    enterpriseConfig.inferenceGatewayBaseUrl = (0, urls_1.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 (0, fsx_1.writeJsonObjectFile)(configPath, doc);
+    return configPath;
+}

package/dist/lib/clients/cline-cleanup.d.ts

@@ -0,0 +1 @@
+export declare function cleanupClineConfig(): Promise<boolean>;

package/dist/lib/clients/cline-cleanup.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupClineConfig = cleanupClineConfig;
+const fsx_cleanup_1 = require("../shared/fsx-cleanup");
+const cline_1 = require("./cline");
+const fsx_1 = require("../shared/fsx");
+const providers_1 = require("../shared/providers");
+const urls_1 = require("../shared/urls");
+// Extracted from src/commands/logout.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+async function cleanupClineConfig() {
+    const globalState = await (0, fsx_cleanup_1.readJsonObjectFile)(cline_1.CLINE_GLOBAL_STATE_PATH);
+    const secrets = await (0, fsx_cleanup_1.readJsonObjectFile)(cline_1.CLINE_SECRETS_PATH);
+    const snapshotRaw = await (0, fsx_1.readFileIfExists)(cline_1.CLINE_RESTORE_STATE_PATH);
+    let changed = false;
+    if (snapshotRaw?.trim()) {
+        try {
+            const snapshot = JSON.parse(snapshotRaw);
+            for (const [key, value] of Object.entries(snapshot.globalState ?? {})) {
+                if (value === null) {
+                    if (key in globalState) {
+                        delete globalState[key];
+                        changed = true;
+                    }
+                    continue;
+                }
+                if (globalState[key] !== value) {
+                    globalState[key] = value;
+                    changed = true;
+                }
+            }
+            for (const [key, value] of Object.entries(snapshot.secrets ?? {})) {
+                if (value === null) {
+                    if (key in secrets) {
+                        delete secrets[key];
+                        changed = true;
+                    }
+                    continue;
+                }
+                if (secrets[key] !== value) {
+                    secrets[key] = value;
+                    changed = true;
+                }
+            }
+        }
+        catch {
+            // Fall through to best-effort cleanup below.
+        }
+    }
+    else {
+        if (globalState.planModeApiProvider === providers_1.OPENAI_PROVIDER_ID) {
+            delete globalState.planModeApiProvider;
+            changed = true;
+        }
+        if (globalState.actModeApiProvider === providers_1.OPENAI_PROVIDER_ID) {
+            delete globalState.actModeApiProvider;
+            changed = true;
+        }
+        if ((0, urls_1.isTheClawBayOpenAiCompatibleBaseUrl)(globalState.openAiBaseUrl)) {
+            delete globalState.openAiBaseUrl;
+            changed = true;
+        }
+        for (const key of ["planModeOpenAiModelId", "actModeOpenAiModelId"]) {
+            if (typeof globalState[key] === "string") {
+                delete globalState[key];
+                changed = true;
+            }
+        }
+        if (typeof secrets.openAiApiKey === "string") {
+            delete secrets.openAiApiKey;
+            changed = true;
+        }
+    }
+    if (changed) {
+        await (0, fsx_cleanup_1.writeJsonFile)(cline_1.CLINE_GLOBAL_STATE_PATH, globalState);
+        await (0, fsx_cleanup_1.writeJsonFile)(cline_1.CLINE_SECRETS_PATH, secrets, 0o600);
+    }
+    await (0, fsx_1.removeFileIfExists)(cline_1.CLINE_RESTORE_STATE_PATH);
+    return changed;
+}

package/dist/lib/clients/cline.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_CLINE_MODEL: string;
+export declare const CLINE_GLOBAL_STATE_PATH: string;
+export declare const CLINE_SECRETS_PATH: string;
+export declare const CLINE_RESTORE_STATE_PATH: string;
+export type ClineRestoreSnapshot = {
+    globalState: Record<string, unknown>;
+    secrets: Record<string, string | null>;
+};
+export declare function detectClineClient(): Promise<boolean>;
+export declare function isManagedClineState(doc: Record<string, unknown>): boolean;
+export declare function writeClineConfig(params: {
+    backendUrl: string;
+    model: string;
+    apiKey: string;
+}): Promise<string[]>;

package/dist/lib/clients/cline.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLINE_RESTORE_STATE_PATH = exports.CLINE_SECRETS_PATH = exports.CLINE_GLOBAL_STATE_PATH = exports.DEFAULT_CLINE_MODEL = void 0;
+exports.detectClineClient = detectClineClient;
+exports.isManagedClineState = isManagedClineState;
+exports.writeClineConfig = writeClineConfig;
+const models_1 = require("../shared/models");
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const paths_1 = require("../config/paths");
+const platform_1 = require("../shared/platform");
+const fsx_1 = require("../shared/fsx");
+const editor_env_1 = require("../shared/editor-env");
+const urls_1 = require("../shared/urls");
+// Extracted from src/commands/setup.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+exports.DEFAULT_CLINE_MODEL = models_1.DEFAULT_CODEX_MODEL;
+exports.CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "globalState.json");
+exports.CLINE_SECRETS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "secrets.json");
+exports.CLINE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "cline.restore.json");
+async function detectClineClient() {
+    if ((0, platform_1.hasCommand)("cline"))
+        return true;
+    const candidates = [
+        exports.CLINE_GLOBAL_STATE_PATH,
+        exports.CLINE_SECRETS_PATH,
+        node_path_1.default.join(node_os_1.default.homedir(), ".cline", "state", "taskHistory.json"),
+        node_path_1.default.join(node_os_1.default.homedir(), ".cline", "tasks"),
+    ];
+    for (const candidate of candidates) {
+        if (await (0, fsx_1.pathExists)(candidate))
+            return true;
+    }
+    return (await (0, editor_env_1.detectExtensionHosts)(["saoudrizwan.claude-dev-"])).length > 0;
+}
+function isManagedClineState(doc) {
+    return (doc.planModeApiProvider === "openai" &&
+        doc.actModeApiProvider === "openai" &&
+        (0, urls_1.isTheClawBayOpenAiCompatibleBaseUrl)(doc.openAiBaseUrl));
+}
+async function writeClineConfig(params) {
+    const proxyUrl = (0, urls_1.openAiCompatibleProxyUrl)(params.backendUrl);
+    const globalState = await (0, fsx_1.readJsonObjectFile)(exports.CLINE_GLOBAL_STATE_PATH);
+    const secrets = await (0, fsx_1.readJsonObjectFile)(exports.CLINE_SECRETS_PATH);
+    const alreadyManaged = isManagedClineState(globalState) && typeof secrets.openAiApiKey === "string";
+    if (!alreadyManaged) {
+        const snapshot = {
+            globalState: {
+                planModeApiProvider: "planModeApiProvider" in globalState ? globalState.planModeApiProvider : null,
+                actModeApiProvider: "actModeApiProvider" in globalState ? globalState.actModeApiProvider : null,
+                openAiBaseUrl: "openAiBaseUrl" in globalState ? globalState.openAiBaseUrl : null,
+                planModeOpenAiModelId: "planModeOpenAiModelId" in globalState ? globalState.planModeOpenAiModelId : null,
+                actModeOpenAiModelId: "actModeOpenAiModelId" in globalState ? globalState.actModeOpenAiModelId : null,
+            },
+            secrets: {
+                openAiApiKey: typeof secrets.openAiApiKey === "string" ? secrets.openAiApiKey : null,
+            },
+        };
+        await (0, fsx_1.writeJsonObjectFile)(exports.CLINE_RESTORE_STATE_PATH, snapshot, 0o600);
+    }
+    globalState.planModeApiProvider = "openai";
+    globalState.actModeApiProvider = "openai";
+    globalState.openAiBaseUrl = proxyUrl;
+    globalState.planModeOpenAiModelId = params.model.trim() || exports.DEFAULT_CLINE_MODEL;
+    globalState.actModeOpenAiModelId = params.model.trim() || exports.DEFAULT_CLINE_MODEL;
+    secrets.openAiApiKey = params.apiKey;
+    await (0, fsx_1.writeJsonObjectFile)(exports.CLINE_GLOBAL_STATE_PATH, globalState);
+    await (0, fsx_1.writeJsonObjectFile)(exports.CLINE_SECRETS_PATH, secrets, 0o600);
+    return [exports.CLINE_GLOBAL_STATE_PATH, exports.CLINE_SECRETS_PATH];
+}

package/dist/lib/clients/codex-cleanup.d.ts

@@ -0,0 +1,7 @@
+export declare const WAN_PROVIDER_ID = "theclawbay-wan";
+export declare const HISTORY_PROVIDER_DB_MIGRATE_SOURCES: string[];
+export declare function removeTopLevelProviderSelection(source: string): string;
+export declare function setTopLevelTableKey(source: string, tableName: string, key: string, tomlValue: string): string;
+export declare function isTheClawBayCodexNativeBaseUrl(value: unknown): value is string;
+export declare function cleanupCodexConfig(): Promise<boolean>;
+export declare function cleanupCodexFeatureFlags(): Promise<boolean>;