theclawbay 0.3.26 → 0.3.27

package/README.md

@@ -1,6 +1,6 @@
 # theclawbay
 
-CLI for connecting Codex, OpenClaw, OpenCode, Kilo, and experimental Trae to The Claw Bay.
+CLI for connecting Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and experimental Trae to The Claw Bay.
 
 ## Install
 
@@ -16,10 +16,17 @@ Get your API key from `https://theclawbay.com/dashboard`.
 theclawbay setup --api-key <apiKey>
 ```
 
-In an interactive terminal, setup shows one picker for Codex, OpenClaw, OpenCode, Kilo, and Windows Trae.
+In an interactive terminal, setup shows one picker for Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and Windows Trae.
 Detected integrations are preselected when recommended, undetected ones stay visible but cannot be selected,
 and you can toggle items with arrow keys plus `Enter` or by pressing their number.
 
+History notes:
+
+- Continue setup only updates `~/.continue/config.yaml` and leaves `~/.continue/sessions` untouched.
+- Cline setup only updates `~/.cline/data/globalState.json` and `~/.cline/data/secrets.json`; task history stays in `~/.cline/state` and `~/.cline/tasks`.
+- Roo Code setup uses a managed auto-import file plus editor settings and does not touch task history. Imported Roo profiles can persist inside Roo after first launch.
+- Aider setup appends a managed block to `~/.aider.conf.yml` and enables `restore-chat-history: true` without touching `.aider.chat.history.md`.
+
 ## Optional
 
 `theclawbay link --api-key <apiKey>`

package/dist/commands/logout.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = require("yaml");
 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");
@@ -16,10 +17,19 @@ const DEFAULT_PROVIDER_ID = "theclawbay";
 const WAN_PROVIDER_ID = "theclawbay-wan";
 const MANAGED_START = "# theclawbay-managed:start";
 const MANAGED_END = "# theclawbay-managed:end";
+const AIDER_MANAGED_START = "# theclawbay-aider-managed:start";
+const AIDER_MANAGED_END = "# theclawbay-aider-managed:end";
 const SHELL_START = "# theclawbay-shell-managed:start";
 const SHELL_END = "# theclawbay-shell-managed:end";
-const ENV_FILE = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay", "env");
+const ENV_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "env");
 const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
+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");
+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 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");
 const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
     OPENAI_PROVIDER_ID,
@@ -27,6 +37,8 @@ const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
     DEFAULT_PROVIDER_ID,
 ]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = [DEFAULT_PROVIDER_ID, WAN_PROVIDER_ID];
+const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const CONTINUE_MODEL_NAME = "The Claw Bay";
 const TRAE_PATCH_MARKER = "theclawbay-trae-patch";
 const TRAE_BUNDLE_BACKUP_SUFFIX = ".theclawbay-managed-backup";
 function removeManagedBlock(source, start, end) {
@@ -125,6 +137,61 @@ function objectRecordOr(value, fallback) {
         return { ...value };
     return fallback;
 }
+function isTheClawBayOpenAiCompatibleBaseUrl(value) {
+    return typeof value === "string" && value.trim().endsWith(THECLAWBAY_OPENAI_PROXY_SUFFIX);
+}
+async function readJsonObjectFile(filePath) {
+    const existingRaw = await readFileIfExists(filePath);
+    if (existingRaw === null || !existingRaw.trim())
+        return {};
+    try {
+        return objectRecordOr(JSON.parse(existingRaw), {});
+    }
+    catch {
+        return {};
+    }
+}
+async function writeJsonFile(filePath, value, mode) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    if (mode !== undefined)
+        await promises_1.default.chmod(filePath, mode);
+}
+function roamingAppDataDir() {
+    if (process.env.APPDATA?.trim())
+        return process.env.APPDATA;
+    return node_path_1.default.join(node_os_1.default.homedir(), "AppData", "Roaming");
+}
+function editorSettingsCandidates() {
+    const home = node_os_1.default.homedir();
+    if (node_os_1.default.platform() === "darwin") {
+        const appSupport = node_path_1.default.join(home, "Library", "Application Support");
+        return [
+            node_path_1.default.join(appSupport, "Code", "User", "settings.json"),
+            node_path_1.default.join(appSupport, "Code - Insiders", "User", "settings.json"),
+            node_path_1.default.join(appSupport, "Cursor", "User", "settings.json"),
+            node_path_1.default.join(appSupport, "Windsurf", "User", "settings.json"),
+            node_path_1.default.join(appSupport, "VSCodium", "User", "settings.json"),
+        ];
+    }
+    if (node_os_1.default.platform() === "win32") {
+        const appData = roamingAppDataDir();
+        return [
+            node_path_1.default.join(appData, "Code", "User", "settings.json"),
+            node_path_1.default.join(appData, "Code - Insiders", "User", "settings.json"),
+            node_path_1.default.join(appData, "Cursor", "User", "settings.json"),
+            node_path_1.default.join(appData, "Windsurf", "User", "settings.json"),
+            node_path_1.default.join(appData, "VSCodium", "User", "settings.json"),
+        ];
+    }
+    return [
+        node_path_1.default.join(home, ".config", "Code", "User", "settings.json"),
+        node_path_1.default.join(home, ".config", "Code - Insiders", "User", "settings.json"),
+        node_path_1.default.join(home, ".config", "Cursor", "User", "settings.json"),
+        node_path_1.default.join(home, ".config", "Windsurf", "User", "settings.json"),
+        node_path_1.default.join(home, ".config", "VSCodium", "User", "settings.json"),
+    ];
+}
 async function cleanupCodexConfig() {
     const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
     const existing = await readFileIfExists(configPath);
@@ -136,6 +203,148 @@ async function cleanupCodexConfig() {
     next = removeTopLevelProviderSelection(next);
     return writeIfChanged(configPath, next, existing);
 }
+async function cleanupContinueConfig() {
+    const existing = await readFileIfExists(CONTINUE_CONFIG_PATH);
+    if (existing === null || !existing.trim())
+        return false;
+    try {
+        const doc = (0, yaml_1.parseDocument)(existing);
+        const root = objectRecordOr(doc.toJS(), {});
+        const models = Array.isArray(root.models) ? root.models : [];
+        const filtered = models.filter((entry) => {
+            if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                return true;
+            const candidate = entry;
+            return !(candidate.provider === "openai" &&
+                candidate.name === CONTINUE_MODEL_NAME &&
+                isTheClawBayOpenAiCompatibleBaseUrl(candidate.apiBase));
+        });
+        if (filtered.length === models.length)
+            return false;
+        doc.set("models", filtered);
+        await promises_1.default.writeFile(CONTINUE_CONFIG_PATH, doc.toString(), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function cleanupClineConfig() {
+    const globalState = await readJsonObjectFile(CLINE_GLOBAL_STATE_PATH);
+    const secrets = await readJsonObjectFile(CLINE_SECRETS_PATH);
+    const snapshotRaw = await readFileIfExists(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 === OPENAI_PROVIDER_ID) {
+            delete globalState.planModeApiProvider;
+            changed = true;
+        }
+        if (globalState.actModeApiProvider === OPENAI_PROVIDER_ID) {
+            delete globalState.actModeApiProvider;
+            changed = true;
+        }
+        if (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 writeJsonFile(CLINE_GLOBAL_STATE_PATH, globalState);
+        await writeJsonFile(CLINE_SECRETS_PATH, secrets, 0o600);
+    }
+    await removeFileIfExists(CLINE_RESTORE_STATE_PATH);
+    return changed;
+}
+async function cleanupRooConfig() {
+    const snapshotRaw = await readFileIfExists(ROO_SETTINGS_STATE_PATH);
+    let changed = false;
+    if (snapshotRaw?.trim()) {
+        try {
+            const entries = JSON.parse(snapshotRaw);
+            for (const entry of entries) {
+                const settings = await readJsonObjectFile(entry.settingsPath);
+                const currentValue = settings["roo-cline.autoImportSettingsPath"];
+                if (currentValue !== ROO_IMPORT_FILE)
+                    continue;
+                if (entry.previousValue === null) {
+                    delete settings["roo-cline.autoImportSettingsPath"];
+                }
+                else {
+                    settings["roo-cline.autoImportSettingsPath"] = entry.previousValue;
+                }
+                await writeJsonFile(entry.settingsPath, settings);
+                changed = true;
+            }
+        }
+        catch {
+            // Fall back to common editor settings paths below.
+        }
+    }
+    if (!changed) {
+        for (const settingsPath of editorSettingsCandidates()) {
+            const settings = await readJsonObjectFile(settingsPath);
+            if (settings["roo-cline.autoImportSettingsPath"] !== ROO_IMPORT_FILE)
+                continue;
+            delete settings["roo-cline.autoImportSettingsPath"];
+            await writeJsonFile(settingsPath, settings);
+            changed = true;
+        }
+    }
+    const removedImport = await removeFileIfExists(ROO_IMPORT_FILE);
+    await removeFileIfExists(ROO_SETTINGS_STATE_PATH);
+    return changed || removedImport;
+}
+async function cleanupAiderConfig() {
+    const existing = await readFileIfExists(AIDER_CONFIG_PATH);
+    if (existing === null)
+        return false;
+    const next = removeManagedBlock(existing, AIDER_MANAGED_START, AIDER_MANAGED_END);
+    return writeIfChanged(AIDER_CONFIG_PATH, next, existing);
+}
 async function cleanupShellFiles() {
     const updated = [];
     const shellRcPaths = [".bashrc", ".zshrc", ".profile"].map((name) => node_path_1.default.join(node_os_1.default.homedir(), name));
@@ -296,10 +505,14 @@ class LogoutCommand extends base_command_1.BaseCommand {
             const updatedShellFiles = await cleanupShellFiles();
             const updatedVsCodeHooks = await cleanupVsCodeHooks();
             const updatedCodexConfig = await cleanupCodexConfig();
+            const updatedContinueConfig = await cleanupContinueConfig();
+            const updatedClineConfig = await cleanupClineConfig();
             const updatedOpenClawConfig = await cleanupOpenClawConfig();
             const updatedOpenCodeConfig = await cleanupOpenCodeConfig();
             const updatedKiloConfig = await cleanupKiloConfig();
+            const updatedRooConfig = await cleanupRooConfig();
             const updatedTraeBundle = await cleanupTraeBundle();
+            const updatedAiderConfig = await cleanupAiderConfig();
             const sessionMigration = await (0, codex_history_migration_1.migrateSessionProviders)({
                 codexHome: paths_1.codexDir,
                 migrationStateFile: MIGRATION_STATE_FILE,
@@ -368,10 +581,14 @@ class LogoutCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- Codex model cache: no cleanup needed.");
             }
+            this.log(`- Continue config cleaned: ${updatedContinueConfig ? "yes" : "no"}`);
+            this.log(`- Cline config cleaned: ${updatedClineConfig ? "yes" : "no"}`);
             this.log(`- OpenClaw config cleaned: ${updatedOpenClawConfig ? "yes" : "no"}`);
             this.log(`- OpenCode config cleaned: ${updatedOpenCodeConfig ? "yes" : "no"}`);
             this.log(`- Kilo config cleaned: ${updatedKiloConfig ? "yes" : "no"}`);
+            this.log(`- Roo Code setup hook cleaned: ${updatedRooConfig ? "yes" : "no"}`);
             this.log(`- Trae experimental patch cleaned: ${updatedTraeBundle ? "yes" : "no"}`);
+            this.log(`- Aider config cleaned: ${updatedAiderConfig ? "yes" : "no"}`);
             this.log("Note: restart terminals/VS Code windows to clear already-loaded shell environment.");
         });
     }

package/dist/commands/setup.js

@@ -10,6 +10,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_readline_1 = require("node:readline");
 const node_child_process_1 = require("node:child_process");
 const core_1 = require("@oclif/core");
+const yaml_1 = require("yaml");
 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");
@@ -25,22 +26,40 @@ const CLI_HTTP_USER_AGENT = "theclawbay-cli";
 const SUPPORTED_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
 const MODEL_DISPLAY_NAMES = (0, supported_models_1.getSupportedModelDisplayNames)();
 const DEFAULT_CODEX_MODEL = SUPPORTED_MODEL_IDS[0] ?? "gpt-5.4";
+const DEFAULT_CONTINUE_MODEL = DEFAULT_CODEX_MODEL;
+const DEFAULT_CLINE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_OPENCLAW_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_KILO_MODEL = DEFAULT_CODEX_MODEL;
+const DEFAULT_ROO_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_TRAE_MODEL = DEFAULT_CODEX_MODEL;
+const DEFAULT_AIDER_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_MODELS = [...SUPPORTED_MODEL_IDS];
 const PREFERRED_MODELS = [...SUPPORTED_MODEL_IDS];
 const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
-const ENV_FILE = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay", "env");
+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");
+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 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");
 const MANAGED_START = "# theclawbay-managed:start";
 const MANAGED_END = "# theclawbay-managed:end";
+const AIDER_MANAGED_START = "# theclawbay-aider-managed:start";
+const AIDER_MANAGED_END = "# theclawbay-aider-managed:end";
 const SHELL_START = "# theclawbay-shell-managed:start";
 const SHELL_END = "# theclawbay-shell-managed:end";
 const OPENCLAW_PROVIDER_ID = DEFAULT_PROVIDER_ID;
 const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set(["openai", "theclawbay-wan", DEFAULT_PROVIDER_ID]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = ["openai", "theclawbay-wan"];
-const SETUP_CLIENT_IDS = ["codex", "openclaw", "opencode", "kilo", "trae"];
+const SETUP_CLIENT_IDS = ["codex", "continue", "cline", "openclaw", "opencode", "kilo", "roo", "trae", "aider"];
+const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const CONTINUE_MODEL_NAME = "The Claw Bay";
+const ROO_PROFILE_NAME = "The Claw Bay";
+const ROO_PROFILE_ID = "theclawbay-openai-compatible";
+const ROO_MODE_SLUGS = ["architect", "code", "ask", "debug", "orchestrator"];
 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){";
@@ -175,6 +194,168 @@ function shellQuote(value) {
 function modelDisplayName(modelId) {
     return MODEL_DISPLAY_NAMES[modelId] ?? modelId;
 }
+function openAiCompatibleProxyUrl(backendUrl) {
+    return `${trimTrailingSlash(backendUrl)}${THECLAWBAY_OPENAI_PROXY_SUFFIX}`;
+}
+function isTheClawBayOpenAiCompatibleBaseUrl(value) {
+    return typeof value === "string" && value.trim().endsWith(THECLAWBAY_OPENAI_PROXY_SUFFIX);
+}
+function roamingAppDataDir() {
+    if (process.env.APPDATA?.trim())
+        return process.env.APPDATA;
+    return node_path_1.default.join(node_os_1.default.homedir(), "AppData", "Roaming");
+}
+async function readFileIfExists(filePath) {
+    try {
+        return await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function readJsonObjectFile(filePath) {
+    const existingRaw = await readFileIfExists(filePath);
+    if (existingRaw === null || !existingRaw.trim())
+        return {};
+    try {
+        return objectRecordOr(JSON.parse(existingRaw), {});
+    }
+    catch {
+        throw new Error(`invalid JSON in ${filePath}`);
+    }
+}
+async function writeJsonObjectFile(filePath, doc, mode) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    if (mode !== undefined)
+        await promises_1.default.chmod(filePath, mode);
+}
+function editorHosts() {
+    const home = node_os_1.default.homedir();
+    if (node_os_1.default.platform() === "darwin") {
+        const appSupport = node_path_1.default.join(home, "Library", "Application Support");
+        return [
+            {
+                id: "vscode",
+                label: "VS Code",
+                extensionDir: node_path_1.default.join(home, ".vscode", "extensions"),
+                userSettingsPath: node_path_1.default.join(appSupport, "Code", "User", "settings.json"),
+            },
+            {
+                id: "vscode-insiders",
+                label: "VS Code Insiders",
+                extensionDir: node_path_1.default.join(home, ".vscode-insiders", "extensions"),
+                userSettingsPath: node_path_1.default.join(appSupport, "Code - Insiders", "User", "settings.json"),
+            },
+            {
+                id: "cursor",
+                label: "Cursor",
+                extensionDir: node_path_1.default.join(home, ".cursor", "extensions"),
+                userSettingsPath: node_path_1.default.join(appSupport, "Cursor", "User", "settings.json"),
+            },
+            {
+                id: "windsurf",
+                label: "Windsurf",
+                extensionDir: node_path_1.default.join(home, ".windsurf", "extensions"),
+                userSettingsPath: node_path_1.default.join(appSupport, "Windsurf", "User", "settings.json"),
+            },
+            {
+                id: "vscodium",
+                label: "VSCodium",
+                extensionDir: node_path_1.default.join(home, ".vscode-oss", "extensions"),
+                userSettingsPath: node_path_1.default.join(appSupport, "VSCodium", "User", "settings.json"),
+            },
+        ];
+    }
+    if (node_os_1.default.platform() === "win32") {
+        const homeDir = process.env.USERPROFILE?.trim() || home;
+        const appData = roamingAppDataDir();
+        return [
+            {
+                id: "vscode",
+                label: "VS Code",
+                extensionDir: node_path_1.default.join(homeDir, ".vscode", "extensions"),
+                userSettingsPath: node_path_1.default.join(appData, "Code", "User", "settings.json"),
+            },
+            {
+                id: "vscode-insiders",
+                label: "VS Code Insiders",
+                extensionDir: node_path_1.default.join(homeDir, ".vscode-insiders", "extensions"),
+                userSettingsPath: node_path_1.default.join(appData, "Code - Insiders", "User", "settings.json"),
+            },
+            {
+                id: "cursor",
+                label: "Cursor",
+                extensionDir: node_path_1.default.join(homeDir, ".cursor", "extensions"),
+                userSettingsPath: node_path_1.default.join(appData, "Cursor", "User", "settings.json"),
+            },
+            {
+                id: "windsurf",
+                label: "Windsurf",
+                extensionDir: node_path_1.default.join(homeDir, ".windsurf", "extensions"),
+                userSettingsPath: node_path_1.default.join(appData, "Windsurf", "User", "settings.json"),
+            },
+            {
+                id: "vscodium",
+                label: "VSCodium",
+                extensionDir: node_path_1.default.join(homeDir, ".vscode-oss", "extensions"),
+                userSettingsPath: node_path_1.default.join(appData, "VSCodium", "User", "settings.json"),
+            },
+        ];
+    }
+    return [
+        {
+            id: "vscode",
+            label: "VS Code",
+            extensionDir: node_path_1.default.join(home, ".vscode", "extensions"),
+            userSettingsPath: node_path_1.default.join(home, ".config", "Code", "User", "settings.json"),
+        },
+        {
+            id: "vscode-insiders",
+            label: "VS Code Insiders",
+            extensionDir: node_path_1.default.join(home, ".vscode-insiders", "extensions"),
+            userSettingsPath: node_path_1.default.join(home, ".config", "Code - Insiders", "User", "settings.json"),
+        },
+        {
+            id: "cursor",
+            label: "Cursor",
+            extensionDir: node_path_1.default.join(home, ".cursor", "extensions"),
+            userSettingsPath: node_path_1.default.join(home, ".config", "Cursor", "User", "settings.json"),
+        },
+        {
+            id: "windsurf",
+            label: "Windsurf",
+            extensionDir: node_path_1.default.join(home, ".windsurf", "extensions"),
+            userSettingsPath: node_path_1.default.join(home, ".config", "Windsurf", "User", "settings.json"),
+        },
+        {
+            id: "vscodium",
+            label: "VSCodium",
+            extensionDir: node_path_1.default.join(home, ".vscode-oss", "extensions"),
+            userSettingsPath: node_path_1.default.join(home, ".config", "VSCodium", "User", "settings.json"),
+        },
+    ];
+}
+async function detectExtensionHosts(prefixes) {
+    const matches = [];
+    for (const host of editorHosts()) {
+        if (!(await pathExists(host.extensionDir)))
+            continue;
+        const entries = (0, node_fs_1.readdirSync)(host.extensionDir, { withFileTypes: true });
+        const found = entries.some((entry) => {
+            if (!entry.isDirectory())
+                return false;
+            const normalized = entry.name.toLowerCase();
+            return prefixes.some((prefix) => normalized.startsWith(prefix));
+        });
+        if (found)
+            matches.push(host);
+    }
+    return matches;
+}
 function parseSetupClientFlags(raw) {
     if (!raw)
         return null;
@@ -386,6 +567,35 @@ async function detectCodexClient() {
     }
     return false;
 }
+async function detectContinueClient() {
+    if (hasCommand("cn") || hasCommand("continue"))
+        return true;
+    const candidates = [
+        CONTINUE_CONFIG_PATH,
+        node_path_1.default.join(node_os_1.default.homedir(), ".continue", "config.json"),
+        node_path_1.default.join(node_os_1.default.homedir(), ".continue", "sessions"),
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate))
+            return true;
+    }
+    return (await detectExtensionHosts(["continue.continue-"])).length > 0;
+}
+async function detectClineClient() {
+    if (hasCommand("cline"))
+        return true;
+    const candidates = [
+        CLINE_GLOBAL_STATE_PATH,
+        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 pathExists(candidate))
+            return true;
+    }
+    return (await detectExtensionHosts(["saoudrizwan.claude-dev-"])).length > 0;
+}
 async function detectKiloClient() {
     if (hasCommand("kilo"))
         return true;
@@ -395,12 +605,30 @@ async function detectKiloClient() {
     }
     return false;
 }
+async function detectRooClient() {
+    return (await detectExtensionHosts(["rooveterinaryinc.roo-cline-"])).length > 0;
+}
 async function detectTraeClient() {
     const bundlePath = traeBundlePath();
     if (!bundlePath)
         return false;
     return pathExists(bundlePath);
 }
+async function detectAiderClient() {
+    if (hasCommand("aider"))
+        return true;
+    const candidates = [
+        AIDER_CONFIG_PATH,
+        node_path_1.default.join(node_os_1.default.homedir(), ".aider.conf.yaml"),
+        node_path_1.default.join(process.cwd(), ".aider.conf.yml"),
+        node_path_1.default.join(process.cwd(), ".aider.chat.history.md"),
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate))
+            return true;
+    }
+    return false;
+}
 async function resolveModels(backendUrl, apiKey) {
     const ids = await fetchBackendModelIds(backendUrl, apiKey);
     const available = new Set(ids ?? []);
@@ -468,6 +696,146 @@ async function writeCodexConfig(params) {
     await promises_1.default.writeFile(configPath, next, "utf8");
     return configPath;
 }
+function isManagedContinueModel(model, proxyUrl) {
+    if (typeof model !== "object" || model === null || Array.isArray(model))
+        return false;
+    const candidate = model;
+    return (candidate.provider === "openai" &&
+        candidate.name === CONTINUE_MODEL_NAME &&
+        candidate.apiBase === proxyUrl);
+}
+async function writeContinueConfig(params) {
+    const configPath = CONTINUE_CONFIG_PATH;
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    const existingRaw = (await readFileIfExists(configPath)) ?? "";
+    const proxyUrl = openAiCompatibleProxyUrl(params.backendUrl);
+    const doc = (0, yaml_1.parseDocument)(existingRaw);
+    const docRoot = objectRecordOr(doc.toJS(), {});
+    const models = Array.isArray(docRoot.models)
+        ? docRoot.models.filter((entry) => !isManagedContinueModel(entry, proxyUrl))
+        : [];
+    models.unshift({
+        name: CONTINUE_MODEL_NAME,
+        provider: "openai",
+        model: params.model.trim() || DEFAULT_CONTINUE_MODEL,
+        apiKey: params.apiKey,
+        apiBase: proxyUrl,
+        roles: ["chat", "edit", "apply"],
+    });
+    if (typeof docRoot.name !== "string" || !docRoot.name.trim()) {
+        doc.set("name", "Local Config");
+    }
+    if (typeof docRoot.version !== "string" || !docRoot.version.trim()) {
+        doc.set("version", "1.0.0");
+    }
+    doc.set("models", models);
+    await promises_1.default.writeFile(configPath, doc.toString(), "utf8");
+    return configPath;
+}
+function isManagedClineState(doc) {
+    return (doc.planModeApiProvider === "openai" &&
+        doc.actModeApiProvider === "openai" &&
+        isTheClawBayOpenAiCompatibleBaseUrl(doc.openAiBaseUrl));
+}
+async function writeClineConfig(params) {
+    const proxyUrl = openAiCompatibleProxyUrl(params.backendUrl);
+    const globalState = await readJsonObjectFile(CLINE_GLOBAL_STATE_PATH);
+    const secrets = await readJsonObjectFile(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 writeJsonObjectFile(CLINE_RESTORE_STATE_PATH, snapshot, 0o600);
+    }
+    globalState.planModeApiProvider = "openai";
+    globalState.actModeApiProvider = "openai";
+    globalState.openAiBaseUrl = proxyUrl;
+    globalState.planModeOpenAiModelId = params.model.trim() || DEFAULT_CLINE_MODEL;
+    globalState.actModeOpenAiModelId = params.model.trim() || DEFAULT_CLINE_MODEL;
+    secrets.openAiApiKey = params.apiKey;
+    await writeJsonObjectFile(CLINE_GLOBAL_STATE_PATH, globalState);
+    await writeJsonObjectFile(CLINE_SECRETS_PATH, secrets, 0o600);
+    return [CLINE_GLOBAL_STATE_PATH, CLINE_SECRETS_PATH];
+}
+async function writeRooConfig(params) {
+    const hosts = await detectExtensionHosts(["rooveterinaryinc.roo-cline-"]);
+    if (hosts.length === 0) {
+        throw new Error("Roo Code was not detected in a supported editor profile.");
+    }
+    const existingSnapshotRaw = await readFileIfExists(ROO_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 = [];
+    for (const host of hosts) {
+        const existed = await pathExists(host.userSettingsPath);
+        const settings = await readJsonObjectFile(host.userSettingsPath);
+        const currentValue = typeof settings["roo-cline.autoImportSettingsPath"] === "string"
+            ? settings["roo-cline.autoImportSettingsPath"]
+            : null;
+        if (currentValue !== ROO_IMPORT_FILE) {
+            snapshotByPath.set(host.userSettingsPath, {
+                settingsPath: host.userSettingsPath,
+                existed,
+                previousValue: currentValue,
+            });
+        }
+        settings["roo-cline.autoImportSettingsPath"] = ROO_IMPORT_FILE;
+        await writeJsonObjectFile(host.userSettingsPath, settings);
+        managedPaths.push(host.userSettingsPath);
+    }
+    const providerConfigId = ROO_PROFILE_ID;
+    const rooImport = {
+        providerProfiles: {
+            currentApiConfigName: ROO_PROFILE_NAME,
+            apiConfigs: {
+                [ROO_PROFILE_NAME]: {
+                    id: providerConfigId,
+                    apiProvider: "openai",
+                    openAiBaseUrl: openAiCompatibleProxyUrl(params.backendUrl),
+                    openAiApiKey: params.apiKey,
+                    openAiModelId: params.model.trim() || DEFAULT_ROO_MODEL,
+                },
+            },
+            modeApiConfigs: Object.fromEntries(ROO_MODE_SLUGS.map((slug) => [slug, providerConfigId])),
+        },
+    };
+    await writeJsonObjectFile(ROO_IMPORT_FILE, rooImport, 0o600);
+    await writeJsonObjectFile(ROO_SETTINGS_STATE_PATH, Array.from(snapshotByPath.values()), 0o600);
+    return [ROO_IMPORT_FILE, ...managedPaths];
+}
+async function writeAiderConfig(params) {
+    const existing = (await readFileIfExists(AIDER_CONFIG_PATH)) ?? "";
+    const cleaned = removeManagedBlock(existing, AIDER_MANAGED_START, AIDER_MANAGED_END);
+    const next = appendManagedBlock(cleaned, [
+        AIDER_MANAGED_START,
+        `model: ${JSON.stringify(`openai/${params.model.trim() || DEFAULT_AIDER_MODEL}`)}`,
+        `openai-api-key: ${JSON.stringify(params.apiKey)}`,
+        `openai-api-base: ${JSON.stringify(openAiCompatibleProxyUrl(params.backendUrl))}`,
+        "restore-chat-history: true",
+        AIDER_MANAGED_END,
+    ]);
+    await promises_1.default.mkdir(node_path_1.default.dirname(AIDER_CONFIG_PATH), { recursive: true });
+    await promises_1.default.writeFile(AIDER_CONFIG_PATH, next, "utf8");
+    return AIDER_CONFIG_PATH;
+}
 async function persistApiKeyEnv(apiKey) {
     const envDir = node_path_1.default.dirname(ENV_FILE);
     await promises_1.default.mkdir(envDir, { recursive: true });
@@ -743,10 +1111,14 @@ class SetupCommand extends base_command_1.BaseCommand {
                 throw new Error('API key is required. Run "theclawbay setup --api-key <key>".');
             const backendRaw = flags.backend ?? (0, api_key_1.tryInferBackendUrlFromApiKey)(apiKey) ?? managed?.backendUrl ?? DEFAULT_BACKEND_URL;
             const backendUrl = normalizeUrl(backendRaw, "--backend");
-            const [codexDetected, kiloDetected, traeDetected] = await Promise.all([
+            const [codexDetected, continueDetected, clineDetected, kiloDetected, rooDetected, traeDetected, aiderDetected] = await Promise.all([
                 detectCodexClient(),
+                detectContinueClient(),
+                detectClineClient(),
                 detectKiloClient(),
+                detectRooClient(),
                 detectTraeClient(),
+                detectAiderClient(),
             ]);
             const setupClients = [
                 {
@@ -755,6 +1127,18 @@ class SetupCommand extends base_command_1.BaseCommand {
                     detected: codexDetected,
                     recommended: true,
                 },
+                {
+                    id: "continue",
+                    label: "Continue",
+                    detected: continueDetected,
+                    recommended: true,
+                },
+                {
+                    id: "cline",
+                    label: "Cline",
+                    detected: clineDetected,
+                    recommended: true,
+                },
                 {
                     id: "openclaw",
                     label: "OpenClaw",
@@ -773,12 +1157,24 @@ class SetupCommand extends base_command_1.BaseCommand {
                     detected: kiloDetected,
                     recommended: true,
                 },
+                {
+                    id: "roo",
+                    label: "Roo Code",
+                    detected: rooDetected,
+                    recommended: true,
+                },
                 {
                     id: "trae",
                     label: "Trae (experimental)",
                     detected: traeDetected,
                     recommended: false,
                 },
+                {
+                    id: "aider",
+                    label: "Aider",
+                    detected: aiderDetected,
+                    recommended: true,
+                },
             ];
             const selectedSetupClients = await resolveSetupClientSelection({
                 setupClients,
@@ -797,11 +1193,15 @@ class SetupCommand extends base_command_1.BaseCommand {
             let authSeed = null;
             let stateDbMigration = null;
             let modelCacheMigration = null;
+            let continueConfigPath = null;
+            let clineConfigPaths = [];
             let openClawConfigPath = null;
             let openClawCliWarning = null;
             let openCodePath = null;
             let kiloConfigPath = null;
+            let rooConfigPaths = [];
             let traeBundlePathPatched = null;
+            let aiderConfigPath = null;
             if (selectedSetupClients.has("codex")) {
                 codexConfigPath = await writeCodexConfig({ backendUrl, model: resolved?.model ?? DEFAULT_CODEX_MODEL, apiKey });
                 updatedVsCodeEnvFiles = await persistVsCodeServerEnvSource();
@@ -823,6 +1223,20 @@ class SetupCommand extends base_command_1.BaseCommand {
                     codexHome: paths_1.codexDir,
                 });
             }
+            if (selectedSetupClients.has("continue")) {
+                continueConfigPath = await writeContinueConfig({
+                    backendUrl,
+                    model: resolved?.model ?? DEFAULT_CONTINUE_MODEL,
+                    apiKey,
+                });
+            }
+            if (selectedSetupClients.has("cline")) {
+                clineConfigPaths = await writeClineConfig({
+                    backendUrl,
+                    model: resolved?.model ?? DEFAULT_CLINE_MODEL,
+                    apiKey,
+                });
+            }
             if (selectedSetupClients.has("openclaw")) {
                 const openClawResult = await setupOpenClaw({
                     backendUrl,
@@ -849,6 +1263,13 @@ class SetupCommand extends base_command_1.BaseCommand {
                     apiKey,
                 });
             }
+            if (selectedSetupClients.has("roo")) {
+                rooConfigPaths = await writeRooConfig({
+                    backendUrl,
+                    model: resolved?.model ?? DEFAULT_ROO_MODEL,
+                    apiKey,
+                });
+            }
             if (selectedSetupClients.has("trae")) {
                 traeBundlePathPatched = await patchTraeBundle({
                     backendUrl,
@@ -857,6 +1278,13 @@ class SetupCommand extends base_command_1.BaseCommand {
                     models: resolved?.models ?? [{ id: DEFAULT_CODEX_MODEL, name: modelDisplayName(DEFAULT_CODEX_MODEL) }],
                 });
             }
+            if (selectedSetupClients.has("aider")) {
+                aiderConfigPath = await writeAiderConfig({
+                    backendUrl,
+                    model: resolved?.model ?? DEFAULT_AIDER_MODEL,
+                    apiKey,
+                });
+            }
             this.log("Setup complete");
             this.log(`- Managed config: ${paths_1.managedConfigPath}`);
             this.log(`- Backend: ${backendUrl}`);
@@ -919,6 +1347,26 @@ class SetupCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- Codex: not detected (skipped)");
             }
+            if (selectedSetupClients.has("continue")) {
+                this.log(`- Continue: configured (${continueConfigPath})`);
+                this.log("- Continue history: left ~/.continue/sessions untouched.");
+            }
+            else if (continueDetected) {
+                this.log("- Continue: detected but skipped");
+            }
+            else {
+                this.log("- Continue: not detected (skipped)");
+            }
+            if (selectedSetupClients.has("cline")) {
+                this.log(`- Cline: configured (${clineConfigPaths.join(", ")})`);
+                this.log("- Cline history: left ~/.cline/state and ~/.cline/tasks untouched.");
+            }
+            else if (clineDetected) {
+                this.log("- Cline: detected but skipped");
+            }
+            else {
+                this.log("- Cline: not detected (skipped)");
+            }
             const openClawDetected = setupClients.find((client) => client.id === "openclaw")?.detected ?? false;
             if (selectedSetupClients.has("openclaw")) {
                 this.log(`- OpenClaw: configured (${openClawConfigPath})`);
@@ -950,6 +1398,17 @@ class SetupCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- Kilo Code: not detected (skipped)");
             }
+            if (selectedSetupClients.has("roo")) {
+                this.log(`- Roo Code: configured (${rooConfigPaths.join(", ")})`);
+                this.log("- Roo Code history: left existing task history untouched.");
+                this.log("- Roo Code note: imported profiles can persist inside Roo after first launch even after logout.");
+            }
+            else if (rooDetected) {
+                this.log("- Roo Code: detected but skipped");
+            }
+            else {
+                this.log("- Roo Code: not detected (skipped)");
+            }
             if (selectedSetupClients.has("trae")) {
                 this.log(`- Trae: experimental bundle patch installed (${traeBundlePathPatched})`);
                 this.log(`- Trae: replaced Builder and SoloCoder model lists with ${resolved?.models.length ?? 1} TheClawBay models.`);
@@ -961,6 +1420,16 @@ class SetupCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- Trae: not detected (skipped)");
             }
+            if (selectedSetupClients.has("aider")) {
+                this.log(`- Aider: configured (${aiderConfigPath})`);
+                this.log("- Aider history: restore-chat-history enabled; existing .aider chat files were left untouched.");
+            }
+            else if (aiderDetected) {
+                this.log("- Aider: detected but skipped");
+            }
+            else {
+                this.log("- Aider: not detected (skipped)");
+            }
             if (authSeed?.action === "seeded") {
                 this.log("- Codex login state: seeded local API-key auth for Codex UI.");
             }
@@ -979,11 +1448,11 @@ class SetupCommand extends base_command_1.BaseCommand {
             else if (authSeed) {
                 this.log("- Codex login state: no change.");
             }
-            this.log("Next: restart terminal/VS Code window only if you rely on the The Claw Bay API key in your own scripts.");
+            this.log("Next: restart Continue, Cline, Roo Code, or Trae only if they were already open during setup.");
         });
     }
 }
-SetupCommand.description = "One-time setup: configure Codex and any detected OpenClaw, OpenCode, Kilo, or experimental Trae installs to use The Claw Bay";
+SetupCommand.description = "One-time setup: configure Codex plus any detected Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Trae, or Aider installs to use The Claw Bay";
 SetupCommand.flags = {
     backend: core_1.Flags.string({
         required: false,
@@ -996,7 +1465,7 @@ SetupCommand.flags = {
     }),
     clients: core_1.Flags.string({
         required: false,
-        description: "Detected local clients to configure: codex, openclaw, opencode, kilo, trae",
+        description: "Detected local clients to configure: codex, continue, cline, openclaw, opencode, kilo, roo, trae, aider",
     }),
     yes: core_1.Flags.boolean({
         required: false,

package/dist/lib/config/paths.d.ts

@@ -1,4 +1,6 @@
 export declare const codexDir: string;
+export declare const theclawbayConfigDir: string;
+export declare const theclawbayStateDir: string;
 export declare const managedConfigPath: string;
 export declare const updateCheckStatePath: string;
 export declare const legacyManagedConfigPathClayBay: string;

package/dist/lib/config/paths.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.legacyManagedConfigPathCodexAuth = exports.legacyManagedConfigPathClayBay = exports.updateCheckStatePath = exports.managedConfigPath = exports.codexDir = void 0;
+exports.legacyManagedConfigPathCodexAuth = exports.legacyManagedConfigPathClayBay = exports.updateCheckStatePath = exports.managedConfigPath = exports.theclawbayStateDir = exports.theclawbayConfigDir = exports.codexDir = void 0;
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 exports.codexDir = node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+exports.theclawbayConfigDir = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay");
+exports.theclawbayStateDir = node_path_1.default.join(exports.theclawbayConfigDir, "state");
 exports.managedConfigPath = node_path_1.default.join(exports.codexDir, "theclawbay.managed.json");
 exports.updateCheckStatePath = node_path_1.default.join(exports.codexDir, "theclawbay.update-check.json");
 exports.legacyManagedConfigPathClayBay = node_path_1.default.join(exports.codexDir, "theclaybay.managed.json");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "theclawbay",
-  "version": "0.3.26",
-  "description": "CLI for connecting Codex, OpenClaw, OpenCode, Kilo, and experimental Trae to The Claw Bay.",
+  "version": "0.3.27",
+  "description": "CLI for connecting Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and experimental Trae to The Claw Bay.",
   "license": "MIT",
   "bin": {
     "theclawbay": "dist/index.js"
@@ -32,15 +32,20 @@
     "cli",
     "setup",
     "api-key",
+    "continue",
+    "cline",
     "openclaw",
     "opencode",
     "kilo",
+    "roo",
+    "aider",
     "trae"
   ],
   "preferGlobal": true,
   "dependencies": {
     "@oclif/core": "^4.8.0",
-    "tslib": "^2.8.1"
+    "tslib": "^2.8.1",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^20.17.0",