@boundless.network/setup 0.1.1 → 0.1.3

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";
@@ -19,8 +19,7 @@ import { Frame, Muted, Para, Title } from "./ui/frame.js";
 import { MultiSelect, Select } from "./ui/menu.js";
 import { Spinner } from "./ui/spinner.js";
 import { LOGO, LOGO_COLUMNS, LOGO_ROWS } from "./ui/logo.js";
-import { ModelTable } from "./ui/table.js";
-import { TextInput } from "./ui/text-input.js";
+import { ModelSelect } from "./ui/table.js";
 import { BAD, BRAND, MUTED, OK, WARN } from "./ui/theme.js";
 const NAV = "↑↓ navigate  enter select";
 function message(error) {
@@ -77,7 +76,7 @@ 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;
@@ -173,9 +172,7 @@ 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(), onOther: () => setScreen({ kind: "type-model", role: screen.role }), onSelect: (id) => chooseModel(screen.role, id), role: screen.role }));
-        case "type-model":
-            return (_jsx(TypeModel, { catalog: wizard.catalog, onCancel: () => setScreen({ kind: "model", role: screen.role }), onSubmit: (id) => chooseModel(screen.role, id) }));
+            return (_jsx(ModelPicker, { catalog: wizard.catalog, onSelect: (id) => chooseModel(screen.role, id), role: screen.role }));
         case "review":
             return (_jsx(Review, { harnesses: chosen(), input: planInput(), onCancel: () => exit(), onPlans: (plans) => {
                     wizard.plans = plans;
@@ -312,22 +309,8 @@ function Catalog({ onDone, onError, wizard }) {
     }, []);
     return (_jsx(Frame, { hints: "", children: _jsx(Spinner, { label: "Reading the model catalog" }) }));
 }
-function ModelPicker({ catalog, harnesses, onOther, onSelect, role, }) {
-    const lead = harnesses.find((harness) => role === "primary" || harness.backgroundDefault !== null) ?? harnesses[0];
-    const recommended = role === "primary" ? lead?.defaultModel : lead?.backgroundDefault;
-    const ids = new Set(catalog.map((model) => model.id));
-    const cheapest = [...catalog].sort((a, b) => a.outputPerMillionTokens - b.outputPerMillionTokens).map((model) => model.id);
-    const picks = [recommended, ...cheapest].filter((id) => typeof id === "string" && ids.has(id));
-    const options = [...new Set(picks)].slice(0, 4).map((id, index) => ({
-        hint: index === 0 ? `recommended for ${lead?.name ?? "you"}` : undefined,
-        label: id,
-        value: id,
-    }));
-    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."] }), _jsx(ModelTable, { models: catalog }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: (id) => (id === "__other" ? onOther() : onSelect(id)), options: [...options, { label: "Another model from the table", value: "__other" }] }) })] }));
-}
-function TypeModel({ catalog, onCancel, onSubmit }) {
-    const [rejected, setRejected] = useState(null);
-    return (_jsxs(Frame, { hints: "enter confirm  esc back", children: [_jsx(Title, { children: "Type a model ID" }), _jsx(ModelTable, { models: catalog }), _jsx(Box, { justifyContent: "center", children: _jsx(TextInput, { onCancel: onCancel, onSubmit: (id) => (catalog.some((model) => model.id === id) ? onSubmit(id) : setRejected(id)), placeholder: "model id" }) }), rejected ? (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsxs(Text, { color: WARN, children: [rejected, " is not served right now."] }) })) : null] }));
+function ModelPicker({ catalog, onSelect, role, }) {
+    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."] }), _jsx(ModelSelect, { models: catalog, onSelect: onSelect, recommended: role === "primary" ? RECOMMENDED_MODEL : RECOMMENDED_BACKGROUND }, role)] }));
 }
 function Review({ harnesses, input, onCancel, onPlans, onProceed, wizard, }) {
     const [plans, setPlans] = useState(null);
@@ -413,7 +396,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`),

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/table.js

@@ -1,17 +1,40 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
 import { usd } from "../lib/catalog.js";
-import { MUTED } from "./theme.js";
-const columns = (model) => [
+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),
     model.contextTokens.toLocaleString("en-US"),
+    model.id === recommended ? "recommended" : "",
 ];
-export function ModelTable({ models }) {
-    const header = ["ID", "Input /1M", "Output /1M", "Context"];
-    const rows = models.map(columns);
-    const widths = header.map((cell, column) => Math.max(cell.length, ...rows.map((row) => row[column]?.length ?? 0)));
-    const line = (cells) => cells.map((cell, column) => (column === 0 ? cell.padEnd(widths[column] ?? 0) : cell.padStart(widths[column] ?? 0))).join("  ");
-    return (_jsxs(Box, { alignItems: "center", flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: MUTED, children: line(header) }), rows.map((row) => (_jsx(Text, { children: line(row) }, row[0])))] }));
+export function ModelSelect({ models, onSelect, recommended, }) {
+    const start = Math.max(models.findIndex((model) => model.id === recommended), 0);
+    const [index, setIndex] = useState(start);
+    useInput((input, key) => {
+        if (key.upArrow || input === "k") {
+            setIndex((index + models.length - 1) % models.length);
+        }
+        else if (key.downArrow || input === "j") {
+            setIndex((index + 1) % models.length);
+        }
+        else if (key.return) {
+            const chosen = models[index];
+            if (chosen) {
+                onSelect(chosen.id);
+            }
+        }
+    });
+    const rows = models.map((model) => cells(model, recommended));
+    const widths = HEADER.map((cell, column) => Math.max(cell.length, ...rows.map((row) => row[column]?.length ?? 0)));
+    const line = (row) => row
+        .map((cell, column) => (column === 0 || column === 4 ? cell.padEnd(widths[column] ?? 0) : cell.padStart(widths[column] ?? 0)))
+        .join("  ");
+    return (_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: MUTED, children: `  ${line(HEADER)}` }), rows.map((row, position) => {
+                    const active = position === index;
+                    return (_jsxs(Text, { bold: active, color: active ? BRAND : undefined, children: [active ? "▸ " : "  ", line(row)] }, row[0]));
+                })] }) }));
 }

package/package.json

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