@boundless.network/setup 0.1.2 → 0.1.4

package/dist/app.js

@@ -4,7 +4,7 @@ import { useEffect, useRef, useState } from "react";
 // Async screens run their task exactly once, on mount; the wizard object is mutable and shared.
 import { HARNESSES } from "./harnesses/index.js";
 import { openBrowser } from "./lib/browser.js";
-import { keyWorks, listModels } from "./lib/catalog.js";
+import { keyWorks, listModels, RECOMMENDED_BACKGROUND, RECOMMENDED_MODEL } from "./lib/catalog.js";
 import { CONSOLE, KEY_ENV, KEYS_URL, discoverSetup, SetupError } from "./lib/config.js";
 import { inspectEnvironment } from "./lib/env.js";
 import { exchangeForKey } from "./lib/exchange.js";
@@ -22,12 +22,30 @@ import { LOGO, LOGO_COLUMNS, LOGO_ROWS } from "./ui/logo.js";
 import { ModelSelect } from "./ui/table.js";
 import { BAD, BRAND, MUTED, OK, WARN } from "./ui/theme.js";
 const NAV = "↑↓ navigate  enter select";
+const STEPS = new Set(["welcome", "existing", "harnesses", "scope", "store", "model", "review"]);
+const withBack = (hints, canBack) => (canBack ? `${hints}  esc back` : hints);
 function message(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export function App({ onFinish }) {
     const { exit } = useApp();
     const [screen, setScreen] = useState({ kind: "boot" });
+    const history = useRef([]).current;
+    const canBack = history.length > 0;
+    const go = (next) => {
+        if (STEPS.has(screen.kind)) {
+            history.push(screen);
+        }
+        setScreen(next);
+    };
+    const back = () => {
+        const previous = history.pop();
+        if (previous) {
+            setScreen(previous);
+        }
+    };
+    const forget = () => history.splice(0);
+    const pickModels = () => go(wizard.catalog.length > 0 ? { kind: "model", role: "primary" } : { kind: "catalog" });
     const wizard = useRef({
         background: "",
         backups: [],
@@ -76,17 +94,17 @@ export function App({ onFinish }) {
         smokes: wizard.smokes,
         tests: wizard.tests,
     });
-    const hasBackgroundSlot = () => chosen().some((harness) => harness.backgroundDefault !== null);
+    const hasBackgroundSlot = () => chosen().some((harness) => harness.backgroundSlot);
     const chooseModel = (role, id) => {
         if (role === "primary") {
             wizard.primary = id;
             if (hasBackgroundSlot()) {
-                setScreen({ kind: "model", role: "background" });
+                go({ kind: "model", role: "background" });
                 return;
             }
         }
         wizard.background = id;
-        setScreen({ kind: "review" });
+        go({ kind: "review" });
     };
     const finish = () => {
         onFinish(summary());
@@ -98,69 +116,70 @@ export function App({ onFinish }) {
         case "welcome":
             return (_jsx(Welcome, { onSelect: (choice) => {
                     if (choice === "continue") {
-                        setScreen(wizard.existing?.valid ? { kind: "existing" } : { kind: "signin" });
+                        go(wizard.key ? { kind: "harnesses" } : wizard.existing?.valid ? { kind: "existing" } : { kind: "signin" });
                     }
                     else if (choice === "cancel") {
                         exit();
                     }
                     else {
-                        setScreen({ kind: "info", topic: choice });
+                        go({ kind: "info", topic: choice });
                     }
                 }, wizard: wizard }));
         case "info":
-            return _jsx(Info, { onBack: () => setScreen({ kind: "welcome" }), topic: screen.topic });
+            return _jsx(Info, { onBack: back, topic: screen.topic });
         case "existing":
-            return (_jsx(Existing, { onSelect: (choice) => {
+            return (_jsx(Existing, { canBack: canBack, onBack: back, onSelect: (choice) => {
                     if (choice === "reuse") {
                         wizard.key = wizard.existing?.key ?? null;
                         wizard.keyStore = wizard.existing?.source ?? "";
-                        setScreen({ kind: "harnesses" });
+                        go({ kind: "harnesses" });
                     }
                     else if (choice === "new") {
-                        setScreen({ kind: "signin" });
+                        go({ kind: "signin" });
                     }
                     else {
                         exit();
                     }
                 }, source: wizard.existing?.source ?? "" }));
         case "signin":
-            return (_jsx(SignIn, { config: wizard.config, env: wizard.env, onCancel: () => setScreen({ kind: "welcome" }), onError: (error) => fail(error, { kind: "signin" }), onToken: (token) => setScreen({ kind: "exchange", token }) }));
+            return (_jsx(SignIn, { config: wizard.config, env: wizard.env, onCancel: back, onError: (error) => fail(error, { kind: "signin" }), onToken: (token) => setScreen({ kind: "exchange", token }) }));
         case "exchange":
             return (_jsx(Exchange, { onDone: (key, name) => {
                     wizard.key = key;
                     wizard.keyName = name;
+                    forget();
                     setScreen({ kind: "harnesses" });
                 }, onError: (error) => fail(error, error instanceof SetupError && error.code === "setup_recovery_required" ? null : screen), token: screen.token }));
         case "error":
             return (_jsx(ErrorScreen, { message: screen.message, onSelect: (choice) => (choice === "retry" && screen.retry ? setScreen(screen.retry) : exit()), retry: screen.retry !== null }));
         case "harnesses":
-            return (_jsx(Harnesses, { initial: wizard.harnesses.length > 0 ? wizard.harnesses : [...wizard.installed], installed: wizard.installed, onSubmit: (ids) => {
+            return (_jsx(Harnesses, { canBack: canBack, initial: wizard.harnesses.length > 0 ? wizard.harnesses : [...wizard.installed], installed: wizard.installed, onBack: back, onSubmit: (ids) => {
                     wizard.harnesses = ids;
-                    setScreen({ kind: "scope" });
+                    go({ kind: "scope" });
                 } }));
         case "scope":
-            return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "Where should this apply?" }), _jsx(Select, { onSelect: (scope) => {
+            return (_jsxs(Frame, { hints: withBack(NAV, canBack), children: [_jsx(Title, { children: "Where should this apply?" }), _jsx(Select, { initial: wizard.scope, onCancel: back, onSelect: (scope) => {
                             wizard.scope = scope;
                             if (scope === "project") {
                                 wizard.store = null;
                                 wizard.keyFile = projectKeyFile(wizard.env.cwd);
                                 wizard.keyStore = tilde(wizard.keyFile);
-                                setScreen({ kind: "catalog" });
+                                pickModels();
                             }
                             else {
-                                setScreen({ kind: "store" });
+                                go({ kind: "store" });
                             }
                         }, options: [
                             { hint: "recommended", label: "My user account", value: "user" },
                             { hint: tilde(wizard.env.cwd), label: "Only this project", value: "project" },
                         ] })] }));
         case "store":
-            return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "Where should I keep the key?" }), _jsx(Muted, { center: true, children: "Your shell profile will read it from there; the key itself never goes into a profile." }), _jsx(Select, { onSelect: (kind) => {
+            return (_jsxs(Frame, { hints: withBack(NAV, canBack), children: [_jsx(Title, { children: "Where should I keep the key?" }), _jsx(Muted, { center: true, children: "Your shell profile will read it from there; the key itself never goes into a profile." }), _jsx(Select, { initial: wizard.store?.kind, onCancel: back, onSelect: (kind) => {
                             const store = wizard.stores.find((candidate) => candidate.kind === kind) ?? null;
                             wizard.store = store;
                             wizard.keyFile = store?.path ?? null;
                             wizard.keyStore = store?.label ?? "";
-                            setScreen({ kind: "catalog" });
+                            pickModels();
                         }, options: wizard.stores.map((store, index) => ({
                             hint: index === 0 ? "recommended" : undefined,
                             label: store.label,
@@ -172,11 +191,14 @@ export function App({ onFinish }) {
                     setScreen({ kind: "model", role: "primary" });
                 }, onError: (error) => fail(error, { kind: "catalog" }), wizard: wizard }));
         case "model":
-            return (_jsx(ModelPicker, { catalog: wizard.catalog, harnesses: chosen(), onSelect: (id) => chooseModel(screen.role, id), role: screen.role }));
+            return (_jsx(ModelPicker, { canBack: canBack, catalog: wizard.catalog, initial: screen.role === "primary" ? wizard.primary : wizard.background, onBack: back, onSelect: (id) => chooseModel(screen.role, id), role: screen.role }));
         case "review":
-            return (_jsx(Review, { harnesses: chosen(), input: planInput(), onCancel: () => exit(), onPlans: (plans) => {
+            return (_jsx(Review, { harnesses: chosen(), input: planInput(), canBack: canBack, onBack: back, onCancel: () => exit(), onPlans: (plans) => {
                     wizard.plans = plans;
-                }, onProceed: () => setScreen({ kind: "apply" }), wizard: wizard }));
+                }, onProceed: () => {
+                    forget();
+                    setScreen({ kind: "apply" });
+                }, wizard: wizard }));
         case "apply":
             return (_jsx(Apply, { onDone: () => setScreen(wizard.plans.some(({ plan }) => plan.manual.length > 0) ? { kind: "manual" } : { kind: "test" }), onError: (error) => fail(error, { kind: "review" }), wizard: wizard }));
         case "manual":
@@ -247,8 +269,8 @@ function Info({ onBack, topic }) {
     });
     return (_jsxs(Frame, { hints: "enter back", children: [_jsx(Title, { children: topic === "what" ? "What this does" : "Privacy & data" }), topic === "what" ? (_jsxs(_Fragment, { children: [_jsxs(Para, { children: ["1. Opens ", CONSOLE, "/authorize in your browser. You sign in (or sign up) and approve \"Boundless local setup\"."] }), _jsx(Para, { children: "2. Exchanges that approval for one inference key named setup-\u2026 on your account. The secret is shown once, to this program only." }), _jsxs(Para, { children: ["3. Stores the key in your credential store or a private 0600 file, and points your shell at it via ", KEY_ENV, "."] }), _jsx(Para, { children: "4. Backs up and merges each chosen harness's configuration, preserving unrelated providers and settings." }), _jsx(Para, { children: "5. Sends one small request per model to prove it works. That request uses account credits; nothing is purchased." })] })) : (_jsxs(_Fragment, { children: [_jsxs(Para, { children: ["Nothing from this directory is uploaded. The only network calls are to ", CONSOLE, ", its authorization server, and the inference gateway."] }), _jsx(Para, { children: "The sign-in token is used once for the key exchange and then discarded; no refresh token is kept." }), _jsx(Para, { children: "The API key is written only to the store you pick and to harness files that need it, all with owner-only permissions. It never appears in command arguments, shell history, logs, or this screen." }), _jsxs(Para, { children: ["Manage or revoke the key at ", KEYS_URL, "."] })] }))] }));
 }
-function Existing({ onSelect, source }) {
-    return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "A Boundless key is already configured" }), _jsxs(Muted, { center: true, children: ["Found in ", source, ", and the gateway accepts it."] }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: onSelect, options: [
+function Existing({ canBack, onBack, onSelect, source, }) {
+    return (_jsxs(Frame, { hints: withBack(NAV, canBack), children: [_jsx(Title, { children: "A Boundless key is already configured" }), _jsxs(Muted, { center: true, children: ["Found in ", source, ", and the gateway accepts it."] }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onCancel: onBack, onSelect: onSelect, options: [
                         { hint: "recommended", label: "Reuse it", value: "reuse" },
                         { label: "Sign in and create a separate key", value: "new" },
                         { label: "Cancel", value: "cancel" },
@@ -294,14 +316,14 @@ function Exchange({ onDone, onError, token }) {
 function ErrorScreen({ message: text, onSelect, retry }) {
     return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "Something went wrong" }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: BAD, children: text }) }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: onSelect, options: retry ? [{ label: "Try again", value: "retry" }, { label: "Cancel", value: "cancel" }] : [{ label: "Exit", value: "cancel" }] }) })] }));
 }
-function Harnesses({ initial, installed, onSubmit }) {
+function Harnesses({ canBack, initial, installed, onBack, onSubmit, }) {
     const [empty, setEmpty] = useState(false);
     const options = HARNESSES.map((harness) => ({
         hint: installed.has(harness.id) ? "installed" : "not found",
         label: harness.name,
         value: harness.id,
     }));
-    return (_jsxs(Frame, { hints: "space toggle  enter continue", children: [_jsx(Title, { children: "Which harnesses should I configure?" }), _jsx(Muted, { center: true, children: "Installed ones are preselected. Harnesses that are not installed get their configuration written for when they are." }), _jsx(Box, { justifyContent: "center", children: _jsx(MultiSelect, { initial: initial, onSubmit: (ids) => (ids.length === 0 ? setEmpty(true) : onSubmit(ids)), options: options }) }), empty ? (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { color: WARN, children: "Pick at least one." }) })) : null] }));
+    return (_jsxs(Frame, { hints: withBack("space toggle  a all/none  enter continue", canBack), children: [_jsx(Title, { children: "Which harnesses should I configure?" }), _jsx(Muted, { center: true, children: "Installed ones are preselected. Harnesses that are not installed get their configuration written for when they are." }), _jsx(Box, { justifyContent: "center", children: _jsx(MultiSelect, { initial: initial, onCancel: onBack, onSubmit: (ids) => (ids.length === 0 ? setEmpty(true) : onSubmit(ids)), options: options }) }), empty ? (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { color: WARN, children: "Pick at least one." }) })) : null] }));
 }
 function Catalog({ onDone, onError, wizard }) {
     useEffect(() => {
@@ -309,12 +331,10 @@ function Catalog({ onDone, onError, wizard }) {
     }, []);
     return (_jsx(Frame, { hints: "", children: _jsx(Spinner, { label: "Reading the model catalog" }) }));
 }
-function ModelPicker({ catalog, harnesses, onSelect, role, }) {
-    const lead = harnesses.find((harness) => role === "primary" || harness.backgroundDefault !== null) ?? harnesses[0];
-    const recommended = role === "primary" ? lead?.defaultModel : lead?.backgroundDefault;
-    return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: role === "primary" ? "Which model should be the default?" : "Which model for background work?" }), _jsxs(Muted, { center: true, children: [role === "primary" ? "Every configured harness gets this model." : "Cheap, fast tasks (Claude Code haiku slot, OpenCode small_model, omp tiny).", " Prices are USD per 1M tokens from the live catalog", lead ? `; the recommendation is ${lead.name}'s documented default.` : "."] }), _jsx(ModelSelect, { models: catalog, onSelect: onSelect, recommended: recommended ?? undefined }, role)] }));
+function ModelPicker({ canBack, catalog, initial, onBack, onSelect, role, }) {
+    return (_jsxs(Frame, { hints: withBack(NAV, canBack), children: [_jsx(Title, { children: role === "primary" ? "Which model should be the default?" : "Which model for background work?" }), _jsxs(Muted, { center: true, children: [role === "primary" ? "Every configured harness gets this model." : "Cheap, fast tasks (Claude Code haiku slot, OpenCode small_model, omp tiny).", " Prices are USD per 1M tokens from the live catalog."] }), _jsx(ModelSelect, { initial: initial, models: catalog, onBack: onBack, onSelect: onSelect, recommended: role === "primary" ? RECOMMENDED_MODEL : RECOMMENDED_BACKGROUND }, role)] }));
 }
-function Review({ harnesses, input, onCancel, onPlans, onProceed, wizard, }) {
+function Review({ canBack, harnesses, input, onBack, onCancel, onPlans, onProceed, wizard, }) {
     const [plans, setPlans] = useState(null);
     useEffect(() => {
         Promise.all(harnesses.map(async (harness) => ({ harness, plan: await harness.plan(input) }))).then((planned) => {
@@ -331,11 +351,11 @@ function Review({ harnesses, input, onCancel, onPlans, onProceed, wizard, }) {
         : env.os === "windows"
             ? "user environment variable"
             : `exported as ${KEY_ENV} by your shell profile`;
-    return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "Review" }), _jsx(Facts, { facts: [
+    return (_jsxs(Frame, { hints: withBack(NAV, canBack), children: [_jsx(Title, { children: "Review" }), _jsx(Facts, { facts: [
                     { label: "Key", value: `${wizard.keyStore} · ${exposure}` },
                     { label: "Model", value: wizard.primary },
                     ...(wizard.background !== wizard.primary ? [{ label: "Background", value: wizard.background }] : []),
-                ] }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: plans.map(({ harness, plan }) => (_jsxs(Box, { children: [_jsx(Text, { children: harness.name.padEnd(16) }), _jsx(Text, { color: plan.changes.length > 0 ? BRAND : MUTED, children: plan.changes.length > 0 ? plan.changes.map((change) => tilde(change.path)).join(", ") : "manual steps, shown after apply" })] }, harness.id))) }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: plans.flatMap(({ plan }) => plan.notes.slice(0, 1)).map((note) => (_jsx(Text, { color: MUTED, children: note }, note))) }), _jsx(Muted, { children: "Existing files are backed up next to themselves before they change. Credentials are never displayed." }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: (choice) => (choice === "apply" ? onProceed() : onCancel()), options: [
+                ] }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: plans.map(({ harness, plan }) => (_jsxs(Box, { children: [_jsx(Text, { children: harness.name.padEnd(16) }), _jsx(Text, { color: plan.changes.length > 0 ? BRAND : MUTED, children: plan.changes.length > 0 ? plan.changes.map((change) => tilde(change.path)).join(", ") : "manual steps, shown after apply" })] }, harness.id))) }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: plans.flatMap(({ plan }) => plan.notes.slice(0, 1)).map((note) => (_jsx(Text, { color: MUTED, children: note }, note))) }), _jsx(Muted, { children: "Existing files are backed up next to themselves before they change. Credentials are never displayed." }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onCancel: onBack, onSelect: (choice) => (choice === "apply" ? onProceed() : onCancel()), options: [
                         { label: "Apply", value: "apply" },
                         { label: "Cancel", value: "cancel" },
                     ] }) })] }));
@@ -398,7 +418,7 @@ function Test({ harnesses, onDone, wizard }) {
             const pairs = new Map();
             for (const harness of harnesses) {
                 pairs.set(`${harness.wire}:${wizard.primary}`, { model: wizard.primary, wire: harness.wire });
-                if (harness.backgroundDefault !== null) {
+                if (harness.backgroundSlot) {
                     pairs.set(`${harness.wire}:${wizard.background}`, { model: wizard.background, wire: harness.wire });
                 }
             }

package/dist/harnesses/claude-code.js

@@ -6,8 +6,7 @@ function settingsPath(input) {
     return input.scope === "user" ? join(claudeHome(), "settings.json") : join(input.env.cwd, ".claude", "settings.local.json");
 }
 export const claudeCode = {
-    backgroundDefault: "dsv4",
-    defaultModel: "glm-5.2",
+    backgroundSlot: true,
     detect: () => installed("claude"),
     id: "claude-code",
     name: "Claude Code",

package/dist/harnesses/codebuddy.js

@@ -0,0 +1,48 @@
+import { KEY_ENV } from "../lib/config.js";
+import { backup, home, installed, readJson, writePrivate } from "../lib/files.js";
+const VENDOR = "Boundless";
+export const codebuddy = {
+    backgroundSlot: false,
+    detect: () => installed("codebuddy"),
+    id: "codebuddy",
+    name: "CodeBuddy",
+    plan: (input) => {
+        const path = home(".codebuddy", "models.json");
+        return Promise.resolve({
+            changes: [
+                {
+                    apply: async () => {
+                        const current = await readJson(path);
+                        const others = (Array.isArray(current.models) ? current.models : []).filter((entry) => !(typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.vendor === VENDOR));
+                        const ours = input.catalog.map((model) => ({
+                            apiKey: `\${${KEY_ENV}}`,
+                            id: model.id,
+                            maxInputTokens: model.contextTokens,
+                            maxOutputTokens: 32_000,
+                            name: model.id,
+                            supportsReasoning: model.supports.includes("reasoning"),
+                            supportsToolCall: model.supports.includes("tool-use"),
+                            url: `${input.gatewayUrl}/v1/chat/completions`,
+                            vendor: VENDOR,
+                        }));
+                        const available = Array.isArray(current.availableModels) ? current.availableModels : [];
+                        const ids = new Set(input.catalog.map((model) => model.id));
+                        const next = {
+                            ...current,
+                            availableModels: [...available.filter((id) => typeof id !== "string" || !ids.has(id)), ...ids],
+                            models: [...others, ...ours],
+                        };
+                        const saved = await backup(path);
+                        await writePrivate(path, `${JSON.stringify(next, null, 2)}\n`);
+                        return { backup: saved };
+                    },
+                    path,
+                    summary: `${input.catalog.length} Boundless models at ${input.gatewayUrl}/v1/chat/completions, key read from ${KEY_ENV}`,
+                },
+            ],
+            manual: [],
+            notes: [`CodeBuddy has no default-model setting: start it with codebuddy --model "${input.primary}" or pick it in the IDE (tagged custom).`],
+        });
+    },
+    wire: "openai",
+};

package/dist/harnesses/codex.js

@@ -5,8 +5,7 @@ import { codexHome } from "../lib/env.js";
 import { installed } from "../lib/files.js";
 import { backup, readText, tilde, writePrivate } from "../lib/files.js";
 export const codex = {
-    backgroundDefault: null,
-    defaultModel: "qwen3.6",
+    backgroundSlot: false,
     detect: () => installed("codex"),
     id: "codex",
     name: "Codex CLI",

package/dist/harnesses/gui.js

@@ -1,4 +1,4 @@
-import { anyExists, home } from "../lib/files.js";
+import { anyExists, home, installed } from "../lib/files.js";
 import { readExpression } from "../lib/store.js";
 function reveal(input) {
     if (input.keyFile) {
@@ -7,8 +7,7 @@ function reveal(input) {
     return input.store ? readExpression(input.store) : "echo $BOUNDLESS_API_KEY";
 }
 export const cursor = {
-    backgroundDefault: null,
-    defaultModel: "glm-5.2",
+    backgroundSlot: false,
     detect: () => anyExists(["/Applications/Cursor.app", home(".cursor")]),
     id: "cursor",
     name: "Cursor",
@@ -25,8 +24,7 @@ export const cursor = {
     wire: "openai",
 };
 export const copilot = {
-    backgroundDefault: null,
-    defaultModel: "glm-5.2",
+    backgroundSlot: false,
     detect: () => anyExists([home(".vscode"), home(".copilot")]),
     id: "copilot",
     name: "GitHub Copilot",
@@ -41,3 +39,50 @@ export const copilot = {
     }),
     wire: "openai",
 };
+export const cline = {
+    backgroundSlot: false,
+    detect: () => anyExists([home(".vscode", "extensions"), home(".cursor", "extensions")]),
+    id: "cline",
+    name: "Cline",
+    plan: (input) => Promise.resolve({
+        changes: [],
+        manual: [
+            'In Cline choose "OpenAI Compatible" as the API provider.',
+            `Base URL ${input.gatewayUrl}/v1, model ID ${input.primary}, key revealed with: ${reveal(input)}`,
+            "In Model Configuration set the context window and max output tokens from the model lineup; Cline's defaults are conservative.",
+        ],
+        notes: [],
+    }),
+    wire: "openai",
+};
+export const cherryStudio = {
+    backgroundSlot: false,
+    detect: () => anyExists(["/Applications/Cherry Studio.app", home(".config", "CherryStudio")]),
+    id: "cherry-studio",
+    name: "Cherry Studio",
+    plan: (input) => Promise.resolve({
+        changes: [],
+        manual: [
+            "Settings → Model Provider → Add Provider, endpoint type OpenAI.",
+            `API address ${input.gatewayUrl} (without /v1; Cherry appends it), key revealed with: ${reveal(input)}`,
+            `In the provider wizard select all models under "Choose models", then "Verify and enable"; start on ${input.primary}.`,
+            "Settings → Default Model: point Default Assistant Model, Quick Model and the translate model at this provider.",
+        ],
+        notes: ["Cherry Studio stores the key in its own database; it cannot read an environment variable."],
+    }),
+    wire: "openai",
+};
+export const muse = {
+    backgroundSlot: false,
+    detect: () => installed("muse"),
+    id: "muse",
+    name: "Muse",
+    plan: (input) => Promise.resolve({
+        changes: [],
+        manual: [
+            `Muse has no provider setting; run it as: META_API_KEY="$BOUNDLESS_API_KEY" muse --provider meta --base-url "${input.gatewayUrl}/v1" --model "${input.primary}"`,
+        ],
+        notes: ["Both Muse flags are undocumented and unverified against this gateway."],
+    }),
+    wire: "openai",
+};

package/dist/harnesses/hermes.js

@@ -3,8 +3,7 @@ import { KEY_ENV } from "../lib/config.js";
 import { installed } from "../lib/files.js";
 import { backup, home, readText, writePrivate } from "../lib/files.js";
 export const hermes = {
-    backgroundDefault: null,
-    defaultModel: "qwen3.6",
+    backgroundSlot: false,
     detect: () => installed("hermes"),
     id: "hermes",
     name: "Hermes",

package/dist/harnesses/index.js

@@ -1,7 +1,28 @@
 import { claudeCode } from "./claude-code.js";
+import { codebuddy } from "./codebuddy.js";
 import { codex } from "./codex.js";
-import { copilot, cursor } from "./gui.js";
+import { cherryStudio, cline, copilot, cursor, muse } from "./gui.js";
 import { hermes } from "./hermes.js";
 import { omp } from "./omp.js";
-import { opencode } from "./opencode.js";
-export const HARNESSES = [claudeCode, codex, opencode, hermes, omp, cursor, copilot];
+import { openclaw } from "./openclaw.js";
+import { kiloCode, mimoCode, opencode } from "./opencode.js";
+import { openhands } from "./openhands.js";
+import { qwenCode } from "./qwen-code.js";
+export const HARNESSES = [
+    claudeCode,
+    codex,
+    opencode,
+    hermes,
+    omp,
+    cursor,
+    copilot,
+    openhands,
+    cline,
+    openclaw,
+    kiloCode,
+    cherryStudio,
+    codebuddy,
+    mimoCode,
+    qwenCode,
+    muse,
+];

package/dist/harnesses/omp.js

@@ -3,8 +3,7 @@ import { KEY_ENV } from "../lib/config.js";
 import { installed } from "../lib/files.js";
 import { backup, home, readText, writePrivate } from "../lib/files.js";
 export const omp = {
-    backgroundDefault: "dsv4",
-    defaultModel: "glm-5.2",
+    backgroundSlot: true,
     detect: () => installed("omp"),
     id: "omp",
     name: "omp (Oh My Pi)",

package/dist/harnesses/openclaw.js

@@ -0,0 +1,47 @@
+import { KEY_ENV } from "../lib/config.js";
+import { backup, home, installed, merge, readJson, writePrivate } from "../lib/files.js";
+export const openclaw = {
+    backgroundSlot: false,
+    detect: () => installed("openclaw"),
+    id: "openclaw",
+    name: "OpenClaw",
+    plan: (input) => {
+        const path = home(".openclaw", "openclaw.json");
+        return Promise.resolve({
+            changes: [
+                {
+                    apply: async () => {
+                        const current = await readJson(path);
+                        const next = merge(current, {
+                            agents: { defaults: { model: { primary: `boundless/${input.primary}` } } },
+                            models: {
+                                providers: {
+                                    boundless: {
+                                        api: "openai-completions",
+                                        apiKey: `\${${KEY_ENV}}`,
+                                        baseUrl: `${input.gatewayUrl}/v1`,
+                                        models: input.catalog.map((model) => ({
+                                            contextWindow: model.contextTokens,
+                                            id: model.id,
+                                            maxTokens: 32_000,
+                                            name: model.name,
+                                            reasoning: model.supports.includes("reasoning"),
+                                        })),
+                                    },
+                                },
+                            },
+                        });
+                        const saved = await backup(path);
+                        await writePrivate(path, `${JSON.stringify(next, null, 2)}\n`);
+                        return { backup: saved };
+                    },
+                    path,
+                    summary: `provider boundless with ${input.catalog.length} models, primary boundless/${input.primary}, key read from ${KEY_ENV}`,
+                },
+            ],
+            manual: [],
+            notes: [`OpenClaw reads the key from ${KEY_ENV} in your shell environment.`],
+        });
+    },
+    wire: "openai",
+};

package/dist/harnesses/opencode.js

@@ -1,7 +1,6 @@
 import { join } from "node:path";
 import { KEY_ENV } from "../lib/config.js";
-import { installed } from "../lib/files.js";
-import { backup, home, merge, readJson, writePrivate } from "../lib/files.js";
+import { backup, home, installed, merge, readJson, writePrivate } from "../lib/files.js";
 function modelEntry(model) {
     const inputs = ["text", ...["image", "audio", "video"].filter((kind) => model.supports.includes(`${kind} input`))];
     return {
@@ -12,55 +11,79 @@ function modelEntry(model) {
         ...(inputs.length > 1 ? { modalities: { input: inputs } } : {}),
     };
 }
-function configPath(input) {
-    if (input.scope === "project") {
-        return join(input.env.cwd, "opencode.json");
-    }
-    return join(process.env.XDG_CONFIG_HOME ?? home(".config"), "opencode", "opencode.json");
+/** OpenCode and its forks share one config format: a provider block plus model/small_model. */
+function opencodeFamily(family) {
+    const configPath = (input) => input.scope === "project"
+        ? join(input.env.cwd, family.file)
+        : join(process.env.XDG_CONFIG_HOME ?? home(".config"), family.dir, family.file);
+    return {
+        backgroundSlot: true,
+        detect: () => installed(family.binary),
+        id: family.id,
+        name: family.name,
+        plan: (input) => {
+            const path = configPath(input);
+            const apiKey = input.scope === "project" && input.keyFile ? `{file:${input.keyFile}}` : `{env:${KEY_ENV}}`;
+            return Promise.resolve({
+                changes: [
+                    {
+                        apply: async () => {
+                            const current = await readJson(path);
+                            const next = merge(current, {
+                                $schema: family.schema,
+                                model: `boundless/${input.primary}`,
+                                provider: {
+                                    boundless: {
+                                        models: Object.fromEntries(input.catalog.map((model) => [model.id, modelEntry(model)])),
+                                        name: "Boundless",
+                                        npm: "@ai-sdk/openai-compatible",
+                                        options: { apiKey, baseURL: `${input.gatewayUrl}/v1` },
+                                    },
+                                },
+                                small_model: `boundless/${input.background}`,
+                            });
+                            const saved = await backup(path);
+                            await writePrivate(path, `${JSON.stringify(next, null, 2)}\n`);
+                            return { backup: saved };
+                        },
+                        path,
+                        summary: `provider boundless with ${input.catalog.length} models, model boundless/${input.primary}, small_model boundless/${input.background}, apiKey ${apiKey}`,
+                    },
+                ],
+                manual: [],
+                notes: family.file.endsWith(".jsonc") ? [`Comments in an existing ${family.file} are not preserved; the backup keeps the original.`] : [],
+            });
+        },
+        smoke: family.smoke,
+        wire: "openai",
+    };
 }
-export const opencode = {
-    backgroundDefault: "dsv4",
-    defaultModel: "qwen3.6",
-    detect: () => installed("opencode"),
+export const opencode = opencodeFamily({
+    binary: "opencode",
+    dir: "opencode",
+    file: "opencode.json",
     id: "opencode",
     name: "OpenCode",
-    plan: (input) => {
-        const path = configPath(input);
-        const apiKey = input.scope === "project" && input.keyFile ? `{file:${input.keyFile}}` : `{env:${KEY_ENV}}`;
-        return Promise.resolve({
-            changes: [
-                {
-                    apply: async () => {
-                        const current = await readJson(path);
-                        const next = merge(current, {
-                            $schema: "https://opencode.ai/config.json",
-                            model: `boundless/${input.primary}`,
-                            provider: {
-                                boundless: {
-                                    models: Object.fromEntries(input.catalog.map((model) => [model.id, modelEntry(model)])),
-                                    name: "Boundless",
-                                    npm: "@ai-sdk/openai-compatible",
-                                    options: { apiKey, baseURL: `${input.gatewayUrl}/v1` },
-                                },
-                            },
-                            small_model: `boundless/${input.background}`,
-                        });
-                        const saved = await backup(path);
-                        await writePrivate(path, `${JSON.stringify(next, null, 2)}\n`);
-                        return { backup: saved };
-                    },
-                    path,
-                    summary: `provider boundless with ${input.catalog.length} models, model boundless/${input.primary}, small_model boundless/${input.background}, apiKey ${apiKey}`,
-                },
-            ],
-            manual: [],
-            notes: [],
-        });
-    },
+    schema: "https://opencode.ai/config.json",
     smoke: (input) => ({
         args: ["run", "--model", `boundless/${input.primary}`, "Use the bash tool to run printf boundless, then report the output."],
         command: "opencode",
         expect: /boundless/i,
     }),
-    wire: "openai",
-};
+});
+export const kiloCode = opencodeFamily({
+    binary: "kilo",
+    dir: "kilo",
+    file: "kilo.jsonc",
+    id: "kilo-code",
+    name: "Kilo Code",
+    schema: "https://app.kilo.ai/config.json",
+});
+export const mimoCode = opencodeFamily({
+    binary: "mimo",
+    dir: "mimocode",
+    file: "mimocode.jsonc",
+    id: "mimo-code",
+    name: "MiMo Code",
+    schema: "https://mimo.xiaomi.com/mimocode/config.json",
+});

package/dist/harnesses/openhands.js

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+import { parse, stringify } from "smol-toml";
+import { backup, installed, readText, tilde, writePrivate } from "../lib/files.js";
+export const openhands = {
+    backgroundSlot: false,
+    detect: () => installed("openhands"),
+    id: "openhands",
+    name: "OpenHands",
+    plan: (input) => {
+        const path = join(input.env.cwd, "config.toml");
+        return Promise.resolve({
+            changes: [
+                {
+                    apply: async () => {
+                        const current = parse((await readText(path)) ?? "");
+                        const llm = (current.llm ?? {});
+                        const next = {
+                            ...current,
+                            llm: { ...llm, api_key: input.key, base_url: `${input.gatewayUrl}/v1`, model: `openai/${input.primary}` },
+                        };
+                        const saved = await backup(path);
+                        await writePrivate(path, stringify(next));
+                        return { backup: saved };
+                    },
+                    path,
+                    summary: `[llm] model openai/${input.primary}, base_url ${input.gatewayUrl}/v1, api_key (key kept in this 0600 file)`,
+                },
+            ],
+            manual: [],
+            notes: [
+                `OpenHands reads config.toml from the working directory, so it is written to ${tilde(path)} and holds the key itself; keep it out of git.`,
+            ],
+        });
+    },
+    wire: "openai",
+};

package/dist/harnesses/qwen-code.js

@@ -0,0 +1,40 @@
+import { KEY_ENV } from "../lib/config.js";
+import { backup, home, installed, merge, readJson, writePrivate } from "../lib/files.js";
+export const qwenCode = {
+    backgroundSlot: false,
+    detect: () => installed("qwen"),
+    id: "qwen-code",
+    name: "Qwen Code",
+    plan: (input) => {
+        const path = home(".qwen", "settings.json");
+        const baseUrl = `${input.gatewayUrl}/v1`;
+        return Promise.resolve({
+            changes: [
+                {
+                    apply: async () => {
+                        const current = await readJson(path);
+                        const providers = current.modelProviders;
+                        const existing = typeof providers === "object" && providers !== null && !Array.isArray(providers) && Array.isArray(providers.openai)
+                            ? providers.openai
+                            : [];
+                        const others = existing.filter((entry) => !(typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.baseUrl === baseUrl));
+                        const ours = input.catalog.map((model) => ({ baseUrl, envKey: KEY_ENV, id: model.id, name: model.id }));
+                        const next = merge(current, {
+                            model: { name: input.primary },
+                            modelProviders: { openai: [...others, ...ours] },
+                            security: { auth: { selectedType: "openai" } },
+                        });
+                        const saved = await backup(path);
+                        await writePrivate(path, `${JSON.stringify(next, null, 2)}\n`);
+                        return { backup: saved };
+                    },
+                    path,
+                    summary: `${input.catalog.length} models under modelProviders.openai, model ${input.primary}, key read from ${KEY_ENV}`,
+                },
+            ],
+            manual: [],
+            notes: [`Qwen Code reads the key from ${KEY_ENV} in your shell environment (or ~/.qwen/.env).`],
+        });
+    },
+    wire: "openai",
+};

package/dist/lib/catalog.js

@@ -1,4 +1,7 @@
 import { CONSOLE, request, SetupError } from "./config.js";
+/** One recommendation for every harness: the default model, and the model for cheap background slots. */
+export const RECOMMENDED_MODEL = "deepseek-v4.1-flash";
+export const RECOMMENDED_BACKGROUND = "dsv4";
 export async function listModels(gatewayUrl, key) {
     const [catalog, served] = await Promise.all([
         request(`${CONSOLE}/api/catalog`),
@@ -24,6 +27,7 @@ export async function keyWorks(gatewayUrl, key) {
     }
 }
 /** Exact USD, never rounded away: trailing zeros trimmed, up to twelve decimals. */
+export const usdPerMillion = (amount) => `$${amount.toFixed(2)}`;
 export function usd(amount) {
     return `$${amount.toFixed(12).replace(/0+$/, "").replace(/\.$/, "")}`;
 }

package/dist/lib/files.js

@@ -85,12 +85,41 @@ export function merge(base, patch) {
     }
     return patch;
 }
+// Drops line and block comments outside strings so a .jsonc file parses. Comments are not written back.
+export function stripComments(text) {
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < text.length && text[j] !== '"') {
+                j += text[j] === "\\" ? 2 : 1;
+            }
+            out += text.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (ch === "/" && text[i + 1] === "/") {
+            i = text.indexOf("\n", i);
+            i = i === -1 ? text.length : i;
+        }
+        else if (ch === "/" && text[i + 1] === "*") {
+            const end = text.indexOf("*/", i + 2);
+            i = end === -1 ? text.length : end + 2;
+        }
+        else {
+            out += ch;
+            i += 1;
+        }
+    }
+    return out;
+}
 export async function readJson(path) {
     const text = await readText(path);
     if (text === null || text.trim() === "") {
         return {};
     }
-    const parsed = JSON.parse(text);
+    const parsed = JSON.parse(stripComments(text).replace(/,(\s*[}\]])/g, "$1"));
     if (!isObject(parsed)) {
         throw new Error(`${path} is not a JSON object`);
     }

package/dist/ui/menu.js

@@ -2,8 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from "ink";
 import { useState } from "react";
 import { BRAND, MUTED } from "./theme.js";
-export function Select({ onCancel, onSelect, options, }) {
-    const [index, setIndex] = useState(0);
+export function Select({ initial, onCancel, onSelect, options, }) {
+    const [index, setIndex] = useState(Math.max(options.findIndex((option) => option.value === initial), 0));
     const move = (delta) => {
         let next = index;
         for (let step = 0; step < options.length; step += 1) {
@@ -46,6 +46,9 @@ export function MultiSelect({ initial, onCancel, onSubmit, options, }) {
         else if (key.downArrow || input === "j") {
             setIndex((index + 1) % options.length);
         }
+        else if (input === "a") {
+            setChosen(chosen.size === options.length ? new Set() : new Set(options.map((option) => option.value)));
+        }
         else if (input === " ") {
             const value = options[index]?.value;
             if (value !== undefined) {

package/dist/ui/table.js

@@ -1,21 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from "ink";
 import { useState } from "react";
-import { usd } from "../lib/catalog.js";
+import { usdPerMillion } from "../lib/catalog.js";
 import { BRAND, MUTED } from "./theme.js";
 const HEADER = ["ID", "Input /1M", "Output /1M", "Context", ""];
 const cells = (model, recommended) => [
     model.id,
-    usd(model.inputPerMillionTokens),
-    usd(model.outputPerMillionTokens),
+    usdPerMillion(model.inputPerMillionTokens),
+    usdPerMillion(model.outputPerMillionTokens),
     model.contextTokens.toLocaleString("en-US"),
     model.id === recommended ? "recommended" : "",
 ];
-export function ModelSelect({ models, onSelect, recommended, }) {
-    const start = Math.max(models.findIndex((model) => model.id === recommended), 0);
+export function ModelSelect({ initial, models, onBack, onSelect, recommended, }) {
+    const start = Math.max(models.findIndex((model) => model.id === initial), models.findIndex((model) => model.id === recommended), 0);
     const [index, setIndex] = useState(start);
     useInput((input, key) => {
-        if (key.upArrow || input === "k") {
+        if (key.escape) {
+            onBack();
+        }
+        else if (key.upArrow || input === "k") {
             setIndex((index + models.length - 1) % models.length);
         }
         else if (key.downArrow || input === "j") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boundless.network/setup",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Set up Boundless as the inference provider for your coding harness. Run: npx -y @boundless.network/setup@latest",
   "license": "MIT",
   "type": "module",