theclawbay 0.3.77 → 0.3.79

package/dist/commands/setup.js

@@ -13,6 +13,7 @@ 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 backups_1 = require("../lib/backups");
 const codex_auth_seeding_1 = require("../lib/codex-auth-seeding");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
 const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
@@ -672,7 +673,66 @@ function powerShellQuote(value) {
     return `'${value.replace(/'/g, "''")}'`;
 }
 function modelDisplayName(modelId) {
-    return MODEL_DISPLAY_NAMES[modelId] ?? modelId;
+    return MODEL_DISPLAY_NAMES[modelId] ?? prettyModelId(modelId);
+}
+function supportedModelProviderMap() {
+    return new Map((0, supported_models_1.getSupportedModels)().map((model) => [model.id, model.provider]));
+}
+function groupForModelId(modelId) {
+    const knownProvider = supportedModelProviderMap().get(modelId);
+    if (knownProvider === "openai") {
+        return { id: "openai", label: "OpenAI / Codex", icon: "◎", order: 0 };
+    }
+    if (knownProvider === "google") {
+        return { id: "google", label: "Google Gemini", icon: "◈", order: 1 };
+    }
+    if (knownProvider === "deepseek") {
+        return { id: "deepseek", label: "DeepSeek", icon: "◉", order: 2 };
+    }
+    if (modelId.startsWith("claude-")) {
+        return { id: "anthropic", label: "Anthropic Claude", icon: "✳", order: 3 };
+    }
+    if (modelId.startsWith("gemini-")) {
+        return { id: "google", label: "Google Gemini", icon: "◈", order: 1 };
+    }
+    if (modelId.startsWith("deepseek-")) {
+        return { id: "deepseek", label: "DeepSeek", icon: "◉", order: 2 };
+    }
+    if (modelId.startsWith("gpt-") || modelId.startsWith("codex-")) {
+        return { id: "openai", label: "OpenAI / Codex", icon: "◎", order: 0 };
+    }
+    return { id: "other", label: "Other models", icon: "•", order: 9 };
+}
+function groupModelOptions(models) {
+    return models.map((model) => ({
+        ...model,
+        provider: groupForModelId(model.id),
+    }));
+}
+function groupModelSections(models) {
+    const sections = new Map();
+    for (const model of groupModelOptions(models)) {
+        const existing = sections.get(model.provider.id);
+        if (existing) {
+            existing.models.push(model);
+            continue;
+        }
+        sections.set(model.provider.id, { provider: model.provider, models: [model] });
+    }
+    return [...sections.values()]
+        .sort((left, right) => left.provider.order - right.provider.order || left.provider.label.localeCompare(right.provider.label))
+        .map((section) => ({
+        provider: section.provider,
+        models: [...section.models].sort((left, right) => left.name.localeCompare(right.name)),
+    }));
+}
+function prettyModelId(modelId) {
+    return modelId
+        .replace(/^claude-/, "Claude ")
+        .replace(/^gemini-/, "Gemini ")
+        .replace(/^deepseek-/, "DeepSeek ")
+        .replace(/-/g, " ")
+        .replace(/\b\w/g, (match) => match.toUpperCase());
 }
 function publicApiOriginForBackendUrl(backendUrl) {
     const trimmed = trimTrailingSlash(backendUrl);
@@ -690,6 +750,39 @@ function publicApiOriginForBackendUrl(backendUrl) {
         return trimmed;
     }
 }
+function isPrivateHostname(hostname) {
+    const normalized = hostname.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (normalized === "localhost" ||
+        normalized === "127.0.0.1" ||
+        normalized === "::1" ||
+        normalized === "[::1]" ||
+        normalized === "0.0.0.0") {
+        return true;
+    }
+    if (normalized.startsWith("10.") || normalized.startsWith("192.168.") || normalized.startsWith("127.")) {
+        return true;
+    }
+    const match = normalized.match(/^172\.(\d{1,3})\./);
+    if (!match)
+        return false;
+    const secondOctet = Number.parseInt(match[1] ?? "", 10);
+    return Number.isInteger(secondOctet) && secondOctet >= 16 && secondOctet <= 31;
+}
+function shouldPreferPublicSetupBackend(backendUrl) {
+    const trimmed = backendUrl?.trim();
+    if (!trimmed)
+        return false;
+    try {
+        const parsed = new URL(trimmed);
+        const hostname = parsed.hostname.toLowerCase();
+        return hostname !== THECLAWBAY_CANONICAL_API_HOST && !THECLAWBAY_WEBSITE_HOSTS.has(hostname) && isPrivateHostname(hostname);
+    }
+    catch {
+        return false;
+    }
+}
 function isTheClawBayChatgptBaseUrl(value) {
     const trimmed = trimTrailingSlash(value.trim());
     if (!trimmed)
@@ -1228,6 +1321,319 @@ async function resolveDeviceLabel(params) {
         rl.close();
     }
 }
+async function promptForGroupedModelSelection(params) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || params.models.length <= 1) {
+        return uniqueStrings(params.defaultSelectedIds);
+    }
+    const sections = groupModelSections(params.models);
+    const knownIds = new Set(params.models.map((model) => model.id));
+    const selected = new Set(uniqueStrings(params.defaultSelectedIds).filter((modelId) => knownIds.has(modelId)));
+    const rows = [];
+    for (const [sectionIndex, section] of sections.entries()) {
+        rows.push({ kind: "group", sectionIndex });
+        for (const [modelIndex] of section.models.entries()) {
+            rows.push({ kind: "model", sectionIndex, modelIndex });
+        }
+    }
+    rows.push({ kind: "apply" });
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const wasRaw = stdin.isRaw;
+    const ansi = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+        inverse: "\x1b[7m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        gray: "\x1b[90m",
+    };
+    const paint = (text, ...codes) => `${codes.join("")}${text}${ansi.reset}`;
+    const clearScreen = () => {
+        stdout.write("\x1b[2J\x1b[H");
+    };
+    const rowForModel = (sectionIndex, modelIndex) => rows.findIndex((row) => row.kind === "model" && row.sectionIndex === sectionIndex && row.modelIndex === modelIndex);
+    let settled = false;
+    let hint = "Use ↑/↓ to move. Press Enter or Space to toggle a model or a provider header.";
+    let cursor = Math.max(0, rows.findIndex((row) => {
+        if (row.kind !== "model")
+            return false;
+        const model = sections[row.sectionIndex]?.models[row.modelIndex];
+        return model?.id === params.defaultSelectedIds[0];
+    }));
+    const groupState = (sectionIndex) => {
+        const models = sections[sectionIndex]?.models ?? [];
+        const selectedCount = models.filter((model) => selected.has(model.id)).length;
+        if (selectedCount === 0)
+            return "[ ]";
+        if (selectedCount === models.length)
+            return "[x]";
+        return "[-]";
+    };
+    const setGroupSelection = (sectionIndex, nextValue) => {
+        for (const model of sections[sectionIndex]?.models ?? []) {
+            if (nextValue)
+                selected.add(model.id);
+            else
+                selected.delete(model.id);
+        }
+    };
+    const toggleCurrent = () => {
+        const current = rows[cursor];
+        if (!current)
+            return;
+        if (current.kind === "apply") {
+            finish();
+            return;
+        }
+        if (current.kind === "group") {
+            const state = groupState(current.sectionIndex);
+            const nextValue = state !== "[x]";
+            setGroupSelection(current.sectionIndex, nextValue);
+            hint = `${sections[current.sectionIndex]?.provider.label ?? "Group"} ${nextValue ? "selected" : "cleared"}.`;
+            render();
+            return;
+        }
+        const model = sections[current.sectionIndex]?.models[current.modelIndex];
+        if (!model)
+            return;
+        if (selected.has(model.id))
+            selected.delete(model.id);
+        else
+            selected.add(model.id);
+        hint = `${model.name} ${selected.has(model.id) ? "selected" : "cleared"}.`;
+        render();
+    };
+    const finish = () => {
+        if (settled)
+            return;
+        settled = true;
+        stdin.off("keypress", onKeypress);
+        if (stdin.isTTY)
+            stdin.setRawMode(Boolean(wasRaw));
+        stdout.write("\x1b[?25h");
+        clearScreen();
+        resolvePromise([...selected].filter((modelId) => knownIds.has(modelId)));
+    };
+    const render = () => {
+        clearScreen();
+        stdout.write(`${paint(params.title, ansi.bold)}\n`);
+        stdout.write(`${paint("Each provider header toggles that provider on or off. Press A to toggle all models.", ansi.dim, ansi.gray)}\n`);
+        stdout.write(`${paint("Move to Apply and press Enter when you're ready.", ansi.dim, ansi.gray)}\n\n`);
+        for (const [sectionIndex, section] of sections.entries()) {
+            const currentRow = rows[cursor];
+            const groupCursor = currentRow?.kind === "group" && currentRow.sectionIndex === sectionIndex;
+            const groupPointer = groupCursor ? paint("→", ansi.bold, ansi.yellow) : " ";
+            const groupMark = groupState(sectionIndex);
+            stdout.write(`${groupPointer} ${paint(groupMark, groupMark === "[x]" ? ansi.green : ansi.gray)} ${section.provider.icon} ${paint(`${section.provider.label} — Select all`, ansi.bold)}\n`);
+            for (const [modelIndex, model] of section.models.entries()) {
+                const activeRow = rows[cursor];
+                const isActive = activeRow?.kind === "model" &&
+                    activeRow.sectionIndex === sectionIndex &&
+                    activeRow.modelIndex === modelIndex;
+                const pointer = isActive ? paint("→", ansi.bold, ansi.yellow) : " ";
+                const mark = selected.has(model.id) ? paint("[x]", ansi.green) : paint("[ ]", ansi.gray);
+                stdout.write(`${pointer}   ${mark} ${model.name} ${paint(`(${model.id})`, ansi.dim, ansi.gray)}\n`);
+            }
+            stdout.write("\n");
+        }
+        const applyActive = rows[cursor]?.kind === "apply";
+        const applyStyled = applyActive
+            ? paint(` ${params.applyLabel} (${selected.size} selected) `, ansi.inverse, ansi.bold, ansi.green)
+            : paint(`${params.applyLabel} (${selected.size} selected)`, ansi.bold, ansi.green);
+        stdout.write(`${applyActive ? "→" : " "} ${applyStyled}\n`);
+        stdout.write(`\n${paint(hint, ansi.dim, ansi.gray)}\n`);
+    };
+    const onKeypress = (_str, key) => {
+        if (key.ctrl && key.name === "c") {
+            stdout.write("\x1b[?25h");
+            process.exit(130);
+        }
+        if (key.name === "up" || key.name === "k") {
+            cursor = (cursor - 1 + rows.length) % rows.length;
+            render();
+            return;
+        }
+        if (key.name === "down" || key.name === "j") {
+            cursor = (cursor + 1) % rows.length;
+            render();
+            return;
+        }
+        if (key.name === "space" || key.name === "return" || key.name === "enter") {
+            toggleCurrent();
+            return;
+        }
+        if (key.name === "a") {
+            const nextValue = sections.some((section) => section.models.some((model) => !selected.has(model.id)));
+            for (const [sectionIndex] of sections.entries())
+                setGroupSelection(sectionIndex, nextValue);
+            hint = `${nextValue ? "Selected" : "Cleared"} all available models.`;
+            render();
+            return;
+        }
+        if (key.name === "c") {
+            finish();
+        }
+    };
+    let resolvePromise = () => { };
+    const result = new Promise((resolve) => {
+        resolvePromise = resolve;
+    });
+    (0, node_readline_1.emitKeypressEvents)(stdin);
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdout.write("\x1b[?25l");
+    stdin.on("keypress", onKeypress);
+    render();
+    return result;
+}
+async function promptForPrimaryModel(models, defaultModel) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || models.length <= 1) {
+        return defaultModel;
+    }
+    const sections = groupModelSections(models);
+    const flattened = sections.flatMap((section) => section.models);
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const wasRaw = stdin.isRaw;
+    const ansi = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        gray: "\x1b[90m",
+    };
+    const paint = (text, ...codes) => `${codes.join("")}${text}${ansi.reset}`;
+    const clearScreen = () => {
+        stdout.write("\x1b[2J\x1b[H");
+    };
+    let cursor = Math.max(0, flattened.findIndex((model) => model.id === defaultModel));
+    let settled = false;
+    let resolvePromise = () => { };
+    const finish = (modelId) => {
+        if (settled)
+            return;
+        settled = true;
+        stdin.off("keypress", onKeypress);
+        if (stdin.isTTY)
+            stdin.setRawMode(Boolean(wasRaw));
+        stdout.write("\x1b[?25h");
+        clearScreen();
+        resolvePromise(modelId);
+    };
+    const render = () => {
+        clearScreen();
+        stdout.write(`${paint("Choose the default model for local setup", ansi.bold)}\n`);
+        stdout.write(`${paint("Use ↑/↓ to move and Enter to select the default model.", ansi.dim, ansi.gray)}\n\n`);
+        let index = 0;
+        for (const section of sections) {
+            stdout.write(`${paint(`${section.provider.icon} ${section.provider.label}`, ansi.bold)}\n`);
+            for (const model of section.models) {
+                const active = index === cursor;
+                const pointer = active ? paint("→", ansi.bold, ansi.yellow) : " ";
+                const defaultSuffix = model.id === defaultModel ? paint(" default", ansi.dim, ansi.gray) : "";
+                stdout.write(`${pointer} ${model.name} ${paint(`(${model.id})`, ansi.dim, ansi.gray)}${defaultSuffix}\n`);
+                index += 1;
+            }
+            stdout.write("\n");
+        }
+    };
+    const onKeypress = (_str, key) => {
+        if (key.ctrl && key.name === "c") {
+            stdout.write("\x1b[?25h");
+            process.exit(130);
+        }
+        if (key.name === "up" || key.name === "k") {
+            cursor = (cursor - 1 + flattened.length) % flattened.length;
+            render();
+            return;
+        }
+        if (key.name === "down" || key.name === "j") {
+            cursor = (cursor + 1) % flattened.length;
+            render();
+            return;
+        }
+        if (key.name === "return" || key.name === "enter" || key.name === "space") {
+            finish(flattened[cursor]?.id ?? defaultModel);
+        }
+    };
+    const result = new Promise((resolve) => {
+        resolvePromise = resolve;
+    });
+    (0, node_readline_1.emitKeypressEvents)(stdin);
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdout.write("\x1b[?25l");
+    stdin.on("keypress", onKeypress);
+    render();
+    return result;
+}
+async function resolveConfiguredModelSelection(params) {
+    const requestedModel = params.requestedModel?.trim();
+    const requestedModels = params.requestedModels
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    const availableIds = new Set(params.resolved.models.map((entry) => entry.id));
+    if (requestedModel && availableIds.size > 0 && !availableIds.has(requestedModel)) {
+        throw new Error(`Requested model "${requestedModel}" is not advertised by the live backend.`);
+    }
+    if (requestedModels?.length) {
+        for (const modelId of requestedModels) {
+            if (availableIds.size > 0 && !availableIds.has(modelId)) {
+                throw new Error(`Requested model "${modelId}" is not advertised by the live backend.`);
+            }
+        }
+    }
+    let selectedModels;
+    if (requestedModels?.length) {
+        selectedModels = params.resolved.models.filter((entry) => requestedModels.includes(entry.id));
+    }
+    else if (params.skipPrompt || !process.stdin.isTTY || !process.stdout.isTTY) {
+        selectedModels = params.resolved.models;
+    }
+    else if (params.resolved.models.length > 1) {
+        const selectedIds = new Set(await promptForGroupedModelSelection({
+            title: "Choose the OpenAI-compatible models to save into local tools",
+            models: params.resolved.models,
+            defaultSelectedIds: params.resolved.models.map((entry) => entry.id),
+            applyLabel: "Apply model selection",
+        }));
+        selectedModels = params.resolved.models.filter((entry) => selectedIds.has(entry.id));
+    }
+    else {
+        selectedModels = params.resolved.models;
+    }
+    const fallbackModels = selectedModels.length > 0 ? selectedModels : params.resolved.models;
+    const selectedModelId = requestedModel && fallbackModels.some((entry) => entry.id === requestedModel)
+        ? requestedModel
+        : params.skipPrompt || !process.stdin.isTTY || !process.stdout.isTTY
+            ? fallbackModels.some((entry) => entry.id === params.resolved.model)
+                ? params.resolved.model
+                : fallbackModels[0]?.id ?? params.resolved.model
+            : await promptForPrimaryModel(fallbackModels, fallbackModels.some((entry) => entry.id === params.resolved.model)
+                ? params.resolved.model
+                : (fallbackModels[0]?.id ?? params.resolved.model));
+    const noteParts = [];
+    if (requestedModels?.length) {
+        noteParts.push(`Configured ${requestedModels.length} OpenAI-compatible models.`);
+    }
+    else if (selectedModels.length > 0 && selectedModels.length < params.resolved.models.length) {
+        noteParts.push(`Configured ${selectedModels.length} OpenAI-compatible models for local tools.`);
+    }
+    if (selectedModelId !== params.resolved.model) {
+        noteParts.push(`Using ${selectedModelId} as the default configured model for local tools.`);
+    }
+    if (availableIds.size === 0 && requestedModel && params.resolved.failure) {
+        noteParts.push(`Could not verify requested model ${requestedModel} against the live backend (${params.resolved.failure}).`);
+    }
+    return {
+        model: selectedModelId,
+        models: fallbackModels,
+        note: noteParts.join(" ").trim() || undefined,
+    };
+}
 function summarizeModelFetchFailure(detail) {
     const normalized = detail.replace(/\s+/g, " ").trim();
     if (!normalized)
@@ -1540,6 +1946,12 @@ async function detectHermesClient() {
     }
     return false;
 }
+function isOpenAiCompatibleSetupModelId(modelId) {
+    const trimmed = modelId.trim();
+    if (!trimmed)
+        return false;
+    return !trimmed.startsWith("claude-");
+}
 function formatDotEnvValue(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
@@ -1621,7 +2033,8 @@ async function writeHermesConfig(params) {
 }
 async function resolveModels(backendUrl, apiKey) {
     const { ids, failure } = await fetchBackendModelIds(backendUrl, apiKey);
-    const available = new Set(ids ?? []);
+    const filteredIds = (ids ?? []).filter(isOpenAiCompatibleSetupModelId);
+    const available = new Set(filteredIds);
     let selected = DEFAULT_CODEX_MODEL;
     let note;
     const authRejected = isCredentialRejectedFailure(failure);
@@ -1631,29 +2044,29 @@ async function resolveModels(backendUrl, apiKey) {
             break;
         }
     }
-    if (ids?.length && !available.has(selected)) {
-        selected = ids[0] ?? DEFAULT_CODEX_MODEL;
+    if (filteredIds.length && !available.has(selected)) {
+        selected = filteredIds[0] ?? DEFAULT_CODEX_MODEL;
         note = "No preferred Codex model advertised by backend; selected first available model.";
     }
-    else if (!ids) {
+    else if (!filteredIds.length) {
         note = failure
             ? `Unable to query backend model list (${failure}); defaulted to ${DEFAULT_CODEX_MODEL}.`
             : `Unable to query backend model list; defaulted to ${DEFAULT_CODEX_MODEL}.`;
     }
     const unique = [];
     const pushUnique = (modelId) => {
-        if (!modelId || unique.includes(modelId))
+        if (!modelId || !isOpenAiCompatibleSetupModelId(modelId) || unique.includes(modelId))
             return;
         unique.push(modelId);
     };
     pushUnique(selected);
     for (const modelId of DEFAULT_MODELS)
         pushUnique(modelId);
-    for (const modelId of ids ?? [])
+    for (const modelId of filteredIds)
         pushUnique(modelId);
     return {
         model: selected,
-        models: unique.map((modelId) => ({ id: modelId, name: modelDisplayName(modelId) })),
+        models: unique.map((modelId) => ({ id: modelId, name: modelDisplayName(modelId) || prettyModelId(modelId) })),
         note,
         failure,
         authRejected,
@@ -1678,6 +2091,45 @@ async function resolveClaudeAccess(backendUrl, apiKey) {
         authRejected,
     };
 }
+async function resolveConfiguredClaudeModels(params) {
+    const requestedModels = params.requestedModels
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (!requestedModels?.length || !params.access.enabled) {
+        const selectedModels = !requestedModels?.length &&
+            params.access.enabled &&
+            !params.skipPrompt &&
+            process.stdin.isTTY &&
+            process.stdout.isTTY &&
+            params.access.models.length > 1
+            ? await promptForGroupedModelSelection({
+                title: "Choose the Claude models to save into Claude-compatible tools",
+                models: params.access.models.map((modelId) => ({
+                    id: modelId,
+                    name: prettyModelId(modelId),
+                })),
+                defaultSelectedIds: params.access.models,
+                applyLabel: "Apply Claude selection",
+            })
+            : params.access.models;
+        return {
+            ...params.access,
+            selectedModels,
+        };
+    }
+    const available = new Set(params.access.models);
+    for (const modelId of requestedModels) {
+        if (!available.has(modelId)) {
+            throw new Error(`Requested Claude model "${modelId}" is not advertised by the live Claude endpoint.`);
+        }
+    }
+    return {
+        ...params.access,
+        selectedModels: requestedModels,
+        note: `Configured Claude-compatible clients with ${requestedModels.join(", ")}.`,
+    };
+}
 async function writeCodexConfig(params) {
     const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
     await promises_1.default.mkdir(paths_1.codexDir, { recursive: true });
@@ -2993,13 +3445,25 @@ class SetupCommand extends base_command_1.BaseCommand {
             let deviceLabel = managedAuthType === "device-session"
                 ? managed?.deviceLabel ?? null
                 : null;
+            const inferredBackend = explicitApiKey || managedAuthType === "api-key"
+                ? (0, api_key_1.tryInferBackendUrlFromApiKey)(explicitApiKey || managedCredential)
+                : null;
+            const managedBackendUrl = managed?.backendUrl ?? null;
             const backendRaw = flags.backend ??
-                (explicitApiKey || managedAuthType === "api-key"
-                    ? (0, api_key_1.tryInferBackendUrlFromApiKey)(explicitApiKey || managedCredential)
-                    : null) ??
-                managed?.backendUrl ??
+                inferredBackend ??
+                (shouldPreferPublicSetupBackend(managedBackendUrl) ? DEFAULT_BACKEND_URL : managedBackendUrl) ??
                 DEFAULT_BACKEND_URL;
             const backendUrl = normalizeUrl(backendRaw, "--backend");
+            const reusingLocalManagedCredential = !explicitApiKey &&
+                !flags.backend &&
+                shouldPreferPublicSetupBackend(managedBackendUrl) &&
+                authCredential.length > 0;
+            if (reusingLocalManagedCredential) {
+                authType = "device-session";
+                authCredential = "";
+                deviceSessionId = null;
+                deviceLabel = null;
+            }
             const [codexDetected, claudeDetected, continueDetected, clineDetected, gsdDetected, openCodeDetected, kiloDetected, rooDetected, traeDetected, aiderDetected, zoDetected, hermesDetected] = await Promise.all([
                 detectCodexClient(),
                 detectClaudeClient(),
@@ -3176,6 +3640,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             const progress = this.createProgressHandle(!debugOutput);
             let resolved = null;
             let claudeAccess = null;
+            let backupSummary = null;
             let updatedShellFiles = [];
             let updatedFishFiles = [];
             let updatedPowerShellProfiles = [];
@@ -3208,14 +3673,56 @@ class SetupCommand extends base_command_1.BaseCommand {
                     if (resolved.authRejected) {
                         throw new Error(describeCredentialRejection(authType, resolved.failure));
                     }
+                    progress.stop();
+                    const configuredModel = await resolveConfiguredModelSelection({
+                        resolved,
+                        requestedModel: flags.model,
+                        requestedModels: flags.models,
+                        skipPrompt: flags.yes,
+                    });
+                    resolved = {
+                        ...resolved,
+                        model: configuredModel.model,
+                        models: configuredModel.models,
+                        note: [resolved.note, configuredModel.note].filter(Boolean).join(" ").trim() || undefined,
+                    };
                 }
                 progress.update("Checking Claude access");
                 claudeAccess = await resolveClaudeAccess(backendUrl, authCredential);
                 if (!resolved?.authRejected && claudeAccess.authRejected) {
                     throw new Error(describeCredentialRejection(authType, claudeAccess.failure));
                 }
+                progress.stop();
+                claudeAccess = await resolveConfiguredClaudeModels({
+                    access: claudeAccess,
+                    requestedModels: flags["claude-models"],
+                    skipPrompt: flags.yes,
+                });
+                if (flags["list-models"]) {
+                    if (resolved) {
+                        this.log("\nOpenAI-compatible models:");
+                        for (const section of groupModelSections(resolved.models)) {
+                            this.log(`${section.provider.icon} ${section.provider.label}`);
+                            for (const model of section.models) {
+                                const marker = model.id === resolved.model ? " (default)" : "";
+                                this.log(`  - ${model.id}${marker}`);
+                            }
+                        }
+                    }
+                    if (claudeAccess.models.length > 0) {
+                        this.log("\nClaude models:");
+                        for (const modelId of claudeAccess.models) {
+                            const marker = claudeAccess.selectedModels?.includes(modelId) ? " (selected)" : "";
+                            this.log(`  - ${modelId}${marker}`);
+                        }
+                    }
+                }
                 const claudeSelected = selectedSetupClients.has("claude");
                 const claudeEnvEnabled = claudeSelected && claudeAccess.enabled;
+                if (flags.backup) {
+                    progress.update("Creating local config backup");
+                    backupSummary = await (0, backups_1.createBackup)("pre-setup backup");
+                }
                 progress.update("Saving shared machine config");
                 await (0, config_1.writeManagedConfig)({
                     backendUrl,
@@ -3257,7 +3764,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                         claudeDesktop3pConfigPathManaged = await writeClaudeDesktop3pConfig({
                             backendUrl,
                             apiKey: authCredential,
-                            claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
+                            claudeModels: claudeAccess?.enabled ? (claudeAccess.selectedModels ?? claudeAccess.models) : [],
                         });
                     }
                     else {
@@ -3345,7 +3852,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                         backendUrl,
                         model: resolved?.model ?? DEFAULT_CODEX_MODEL,
                         models: resolved?.models ?? [{ id: DEFAULT_CODEX_MODEL, name: modelDisplayName(DEFAULT_CODEX_MODEL) }],
-                        claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
+                        claudeModels: claudeAccess?.enabled ? (claudeAccess.selectedModels ?? claudeAccess.models) : [],
                         apiKey: authCredential,
                     });
                 }
@@ -3413,6 +3920,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             const summaryNotes = new Set();
             if (resolved?.note)
                 summaryNotes.add(resolved.note);
+            if (backupSummary) {
+                summaryNotes.add(`Created a local backup snapshot (${backupSummary.id}) before changing client configs.`);
+            }
             if (selectedSetupClients.has("claude") && claudeAccess?.enabled) {
                 summaryNotes.add("Claude Code: exported ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY.");
                 if (claudeDesktop3pConfigPathManaged) {
@@ -3467,6 +3977,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             this.log(`- Managed config: ${paths_1.managedConfigPath}`);
             this.log(`- Backend: ${backendUrl}`);
             this.log(`- Auth mode: ${authType}`);
+            if (backupSummary) {
+                this.log(`- Backup: ${backupSummary.id} (${backupSummary.directory})`);
+            }
             if (authType === "device-session") {
                 this.log(`- Device session id: ${deviceSessionId ?? "n/a"}`);
                 this.log(`- Device label: ${deviceLabel ?? "n/a"}`);
@@ -3724,6 +4237,29 @@ SetupCommand.flags = {
         required: false,
         description: "Detected local clients to configure: codex, claude, continue, cline, gsd, openclaw, opencode, kilo, roo, trae, aider, zo, hermes",
     }),
+    model: core_1.Flags.string({
+        required: false,
+        description: "Default OpenAI-compatible model to configure for local tools",
+    }),
+    models: core_1.Flags.string({
+        required: false,
+        description: "Comma-separated OpenAI-compatible model ids to save into local tools",
+    }),
+    "claude-models": core_1.Flags.string({
+        required: false,
+        description: "Comma-separated Claude model ids to configure for Claude-compatible tools",
+    }),
+    "list-models": core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "Print the live OpenAI-compatible and Claude model ids discovered during setup",
+    }),
+    backup: core_1.Flags.boolean({
+        required: false,
+        allowNo: true,
+        default: true,
+        description: "Create a local backup before changing client configs",
+    }),
     yes: core_1.Flags.boolean({
         required: false,
         char: "y",