theclawbay 0.3.26 → 0.3.28

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,9 +16,15 @@ 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.
-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.
+In an interactive terminal, setup shows one picker for Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and Windows Trae.
+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 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
 

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){";
@@ -62,6 +81,49 @@ function hasCommand(name) {
     const result = (0, node_child_process_1.spawnSync)(lookupCommand, [name], { stdio: "ignore" });
     return result.status === 0;
 }
+function supportsTerminalHyperlinks() {
+    if (!process.stdout.isTTY)
+        return false;
+    if (process.env.FORCE_HYPERLINK === "1")
+        return true;
+    if (process.env.NO_HYPERLINK === "1")
+        return false;
+    const term = (process.env.TERM ?? "").toLowerCase();
+    if (!term || term === "dumb")
+        return false;
+    const termProgram = (process.env.TERM_PROGRAM ?? "").toLowerCase();
+    if (termProgram === "iterm.app" || termProgram === "wezterm" || termProgram === "vscode") {
+        return true;
+    }
+    if (process.env.WT_SESSION ||
+        process.env.KITTY_WINDOW_ID ||
+        process.env.KONSOLE_VERSION ||
+        process.env.VTE_VERSION ||
+        process.env.DOMTERM ||
+        process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm") {
+        return true;
+    }
+    return term.includes("xterm-kitty") || term.includes("foot") || term.includes("wezterm");
+}
+function formatTerminalHyperlink(label, url) {
+    return `\u001B]8;;${url}\u0007${label}\u001B]8;;\u0007`;
+}
+function formatDim(value) {
+    return `\u001B[2m${value}\u001B[0m`;
+}
+function officialSiteLabel(siteUrl) {
+    const parsed = new URL(siteUrl);
+    const hostname = parsed.hostname.replace(/^www\./, "");
+    const pathname = parsed.pathname.replace(/\/+$/g, "");
+    return pathname && pathname !== "/" ? `${hostname}${pathname}` : hostname;
+}
+function formatSetupClientLabel(client, hyperlinksEnabled) {
+    const iconAndLabel = `${client.icon} ${client.label}`;
+    if (hyperlinksEnabled) {
+        return `${formatTerminalHyperlink(iconAndLabel, client.siteUrl)} ${formatDim(`(${officialSiteLabel(client.siteUrl)})`)}`;
+    }
+    return `${iconAndLabel} - ${client.siteUrl}`;
+}
 function localAppDataDir() {
     if (process.env.LOCALAPPDATA?.trim())
         return process.env.LOCALAPPDATA;
@@ -175,6 +237,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;
@@ -205,12 +429,13 @@ async function promptForSetupClients(clients) {
         let cursor = 0;
         let settled = false;
         let hint = clients.some((client) => client.detected)
-            ? "Detected integrations are preselected. Undetected ones stay visible but disabled."
-            : "No supported local clients are detected yet. Continue will just save your managed config and API key env.";
+            ? "Choose the tools you want to configure."
+            : "No supported local clients are detected yet. Apply setup will just save your managed config and API key env.";
         const stdin = process.stdin;
         const stdout = process.stdout;
         const wasRaw = stdin.isRaw;
-        const continueIndex = options.length;
+        const applyIndex = options.length;
+        const hyperlinksEnabled = supportsTerminalHyperlinks();
         const clearScreen = () => {
             stdout.write("\x1b[2J\x1b[H");
         };
@@ -219,15 +444,16 @@ async function promptForSetupClients(clients) {
             clearScreen();
             stdout.write("Choose local clients to configure\n");
             stdout.write(`Use ↑/↓ to move, Enter to toggle the highlighted integration, or press 1-${options.length} to toggle directly.\n`);
-            stdout.write("Move to Continue and press Enter when you're ready.\n\n");
+            stdout.write("Each tool name links to its official site when your terminal supports it.\n");
+            stdout.write("Move to Apply setup and press Enter when you're ready.\n\n");
             for (const [index, option] of options.entries()) {
                 const pointer = index === cursor ? ">" : " ";
                 const mark = option.detected ? (option.checked ? "[x]" : "[ ]") : "[-]";
                 const badge = option.detected ? (option.recommended ? "recommended" : "optional") : "not detected";
-                stdout.write(`${pointer} ${index + 1}. ${mark} ${option.label}  ${badge}\n`);
+                stdout.write(`${pointer} ${index + 1}. ${mark} ${formatSetupClientLabel(option, hyperlinksEnabled)}  ${badge}\n`);
             }
-            const continuePointer = cursor === continueIndex ? ">" : " ";
-            stdout.write(`${continuePointer} Continue with ${selectedCount()} selected integration${selectedCount() === 1 ? "" : "s"}\n`);
+            const applyPointer = cursor === applyIndex ? ">" : " ";
+            stdout.write(`${applyPointer} Apply setup with ${selectedCount()} selected integration${selectedCount() === 1 ? "" : "s"}\n`);
             stdout.write(`\n${hint}\n`);
         };
         const finish = () => {
@@ -273,7 +499,7 @@ async function promptForSetupClients(clients) {
                 return;
             }
             if (key.name === "space") {
-                if (cursor === continueIndex) {
+                if (cursor === applyIndex) {
                     finish();
                     return;
                 }
@@ -295,7 +521,7 @@ async function promptForSetupClients(clients) {
                 return;
             }
             if (key.name === "return" || key.name === "enter") {
-                if (cursor === continueIndex) {
+                if (cursor === applyIndex) {
                     finish();
                     return;
                 }
@@ -386,6 +612,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 +650,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 +741,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 +1156,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 = [
                 {
@@ -754,30 +1171,72 @@ class SetupCommand extends base_command_1.BaseCommand {
                     label: "Codex CLI, VS Code extension, and Codex app",
                     detected: codexDetected,
                     recommended: true,
+                    icon: "◎",
+                    siteUrl: "https://openai.com/codex",
+                },
+                {
+                    id: "continue",
+                    label: "Continue",
+                    detected: continueDetected,
+                    recommended: true,
+                    icon: "▶",
+                    siteUrl: "https://continue.dev",
+                },
+                {
+                    id: "cline",
+                    label: "Cline",
+                    detected: clineDetected,
+                    recommended: true,
+                    icon: "◈",
+                    siteUrl: "https://cline.bot",
                 },
                 {
                     id: "openclaw",
                     label: "OpenClaw",
                     detected: hasCommand("openclaw"),
                     recommended: true,
+                    icon: "🦞",
+                    siteUrl: "https://openclaw.ai",
                 },
                 {
                     id: "opencode",
                     label: "OpenCode",
                     detected: hasCommand("opencode"),
                     recommended: true,
+                    icon: "⌘",
+                    siteUrl: "https://opencode.ai",
                 },
                 {
                     id: "kilo",
                     label: "Kilo Code",
                     detected: kiloDetected,
                     recommended: true,
+                    icon: "⚡",
+                    siteUrl: "https://kilo.ai",
+                },
+                {
+                    id: "roo",
+                    label: "Roo Code",
+                    detected: rooDetected,
+                    recommended: true,
+                    icon: "🦘",
+                    siteUrl: "https://roocode.com",
                 },
                 {
                     id: "trae",
                     label: "Trae (experimental)",
                     detected: traeDetected,
                     recommended: false,
+                    icon: "△",
+                    siteUrl: "https://www.trae.ai",
+                },
+                {
+                    id: "aider",
+                    label: "Aider",
+                    detected: aiderDetected,
+                    recommended: true,
+                    icon: "✦",
+                    siteUrl: "https://aider.chat",
                 },
             ];
             const selectedSetupClients = await resolveSetupClientSelection({
@@ -797,11 +1256,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 +1286,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 +1326,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 +1341,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 +1410,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 +1461,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 +1483,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 +1511,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 +1528,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.28",
+  "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",