@boundless.network/setup 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @boundless.network/setup
+
+The Boundless setup wizard for your terminal.
+
+```sh
+npx -y @boundless.network/setup@latest
+```
+
+It does what [boundless.md](https://boundless.md) asks a coding agent to do, as a full-screen terminal app:
+
+1. Inspects the machine: OS, shell, remote session, installed harnesses, an existing key.
+2. Signs you in through your browser with the OAuth device grant, or shows a code when there is no browser.
+3. Exchanges that approval for one inference key on your account. The secret is never printed.
+4. Stores the key in the macOS Keychain, the Linux Secret Service, or a private 0600 file, and exports `BOUNDLESS_API_KEY` from your shell profile without ever writing the key into the profile.
+5. Lets you pick a default and a background model from the live catalog, with prices.
+6. Backs up and merges configuration for Claude Code, Codex CLI, OpenCode, Hermes and omp, and prints the steps for Cursor and GitHub Copilot.
+7. Sends one small request per model and wire format, with the exact cost, and optionally runs each installed harness once from a scratch directory.
+
+Project-only scope keeps the key in `.boundless/api-key` (git-ignored) and writes project-level configuration where the harness supports it.
+
+## Development
+
+```sh
+npm install
+npm run build
+BOUNDLESS_CONSOLE=http://localhost:3000 node dist/cli.js
+```
+
+`BOUNDLESS_CONSOLE` points the wizard at another console; it reads the OAuth client, issuer and gateway from `GET /api/setup` there. Plain HTTP is accepted for loopback only.
+
+```sh
+npm test
+```
+
+## Publishing
+
+```sh
+npm version patch
+npm publish
+```
+
+The package is public under the `@boundless.network` npm organisation. `npm publish` runs `prepublishOnly`, which builds `dist/`.

package/dist/app.js

@@ -0,0 +1,471 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput } from "ink";
+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 { CONSOLE, KEY_ENV, KEYS_URL, discoverSetup, SetupError } from "./lib/config.js";
+import { inspectEnvironment } from "./lib/env.js";
+import { exchangeForKey } from "./lib/exchange.js";
+import { tilde } from "./lib/files.js";
+import { approvalUrl, startDeviceGrant, waitForAccessToken } from "./lib/oauth.js";
+import { runSmoke } from "./lib/smoke.js";
+import { availableStores, exposeInShell, findExistingKey, projectKeyFile, saveKey, saveProjectKey, } from "./lib/store.js";
+import { testRequest } from "./lib/test.js";
+import { headline } from "./summary.js";
+import { Facts } from "./ui/facts.js";
+import { Frame, Muted, Para, Title } from "./ui/frame.js";
+import { MultiSelect, Select } from "./ui/menu.js";
+import { Spinner } from "./ui/spinner.js";
+import { ModelTable } from "./ui/table.js";
+import { TextInput } from "./ui/text-input.js";
+import { BAD, BRAND, MUTED, OK, WARN } from "./ui/theme.js";
+const NAV = "↑↓ navigate  enter select";
+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 wizard = useRef({
+        background: "",
+        backups: [],
+        catalog: [],
+        changed: [],
+        config: null,
+        installed: new Set(),
+        env: null,
+        existing: null,
+        harnesses: [],
+        key: null,
+        keyFile: null,
+        keyName: null,
+        keyStore: "",
+        plans: [],
+        primary: "",
+        scope: "user",
+        smokes: [],
+        store: null,
+        stores: [],
+        tests: [],
+    }).current;
+    const fail = (error, retry) => setScreen({ kind: "error", message: message(error), retry });
+    const chosen = () => HARNESSES.filter((harness) => wizard.harnesses.includes(harness.id));
+    const planInput = () => ({
+        background: wizard.background,
+        catalog: wizard.catalog,
+        env: wizard.env,
+        gatewayUrl: wizard.config.gatewayUrl,
+        key: wizard.key,
+        keyFile: wizard.keyFile,
+        primary: wizard.primary,
+        scope: wizard.scope,
+        store: wizard.store,
+    });
+    const summary = () => ({
+        background: wizard.background,
+        backups: wizard.backups,
+        changed: wizard.changed,
+        harnesses: chosen().map(({ id, name }) => ({ id, name })),
+        keyName: wizard.keyName,
+        keyStore: wizard.keyStore,
+        manual: wizard.plans.filter(({ plan }) => plan.manual.length > 0).map(({ harness, plan }) => ({ name: harness.name, steps: plan.manual })),
+        primary: wizard.primary,
+        scope: wizard.scope,
+        smokes: wizard.smokes,
+        tests: wizard.tests,
+    });
+    const hasBackgroundSlot = () => chosen().some((harness) => harness.backgroundDefault !== null);
+    const chooseModel = (role, id) => {
+        if (role === "primary") {
+            wizard.primary = id;
+            if (hasBackgroundSlot()) {
+                setScreen({ kind: "model", role: "background" });
+                return;
+            }
+        }
+        wizard.background = id;
+        setScreen({ kind: "review" });
+    };
+    const finish = () => {
+        onFinish(summary());
+        exit();
+    };
+    switch (screen.kind) {
+        case "boot":
+            return (_jsx(Boot, { onDone: () => setScreen({ kind: "welcome" }), onError: (error) => fail(error, null), wizard: wizard }));
+        case "welcome":
+            return (_jsx(Welcome, { onSelect: (choice) => {
+                    if (choice === "continue") {
+                        setScreen(wizard.existing?.valid ? { kind: "existing" } : { kind: "signin" });
+                    }
+                    else if (choice === "cancel") {
+                        exit();
+                    }
+                    else {
+                        setScreen({ kind: "info", topic: choice });
+                    }
+                }, wizard: wizard }));
+        case "info":
+            return _jsx(Info, { onBack: () => setScreen({ kind: "welcome" }), topic: screen.topic });
+        case "existing":
+            return (_jsx(Existing, { onSelect: (choice) => {
+                    if (choice === "reuse") {
+                        wizard.key = wizard.existing?.key ?? null;
+                        wizard.keyStore = wizard.existing?.source ?? "";
+                        setScreen({ kind: "harnesses" });
+                    }
+                    else if (choice === "new") {
+                        setScreen({ 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 }) }));
+        case "exchange":
+            return (_jsx(Exchange, { onDone: (key, name) => {
+                    wizard.key = key;
+                    wizard.keyName = name;
+                    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) => {
+                    wizard.harnesses = ids;
+                    setScreen({ kind: "scope" });
+                } }));
+        case "scope":
+            return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "Where should this apply?" }), _jsx(Select, { 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" });
+                            }
+                            else {
+                                setScreen({ 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) => {
+                            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" });
+                        }, options: wizard.stores.map((store, index) => ({
+                            hint: index === 0 ? "recommended" : undefined,
+                            label: store.label,
+                            value: store.kind,
+                        })) })] }));
+        case "catalog":
+            return (_jsx(Catalog, { onDone: (catalog) => {
+                    wizard.catalog = catalog;
+                    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) }));
+        case "review":
+            return (_jsx(Review, { harnesses: chosen(), input: planInput(), onCancel: () => exit(), onPlans: (plans) => {
+                    wizard.plans = plans;
+                }, onProceed: () => 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":
+            return _jsx(Manual, { onContinue: () => setScreen({ kind: "test" }), plans: wizard.plans });
+        case "test":
+            return (_jsx(Test, { harnesses: chosen(), onDone: (tests) => {
+                    wizard.tests = tests;
+                    setScreen({ kind: "tested" });
+                }, wizard: wizard }));
+        case "tested":
+            return (_jsx(Tested, { harnesses: chosen(), onSelect: (choice) => setScreen(choice === "smoke" ? { kind: "smoke" } : { kind: "done" }), tests: wizard.tests }));
+        case "smoke":
+            return (_jsx(Smoke, { harnesses: chosen(), input: planInput(), onDone: (smokes) => {
+                    wizard.smokes = smokes;
+                    setScreen({ kind: "done" });
+                } }));
+        case "done":
+            return _jsx(Done, { onExit: finish, summary: summary() });
+    }
+}
+function Boot({ onDone, onError, wizard }) {
+    useEffect(() => {
+        (async () => {
+            const [env, config] = await Promise.all([inspectEnvironment(), discoverSetup()]);
+            wizard.env = env;
+            wizard.config = config;
+            const detections = await Promise.all(HARNESSES.map(async (harness) => [harness.id, await harness.detect(env)]));
+            wizard.installed = new Set(detections.filter(([, found]) => found).map(([id]) => id));
+            wizard.stores = await availableStores(env);
+            const existing = await findExistingKey(env);
+            wizard.existing = existing ? { ...existing, valid: await keyWorks(config.gatewayUrl, existing.key) } : null;
+            onDone();
+        })().catch(onError);
+    }, []);
+    return (_jsx(Frame, { hints: "", children: _jsx(Spinner, { label: "Inspecting this machine" }) }));
+}
+function Welcome({ onSelect, wizard }) {
+    const env = wizard.env;
+    const installed = HARNESSES.filter((harness) => wizard.installed.has(harness.id)).map((harness) => harness.name);
+    const facts = [
+        { label: "Directory", value: tilde(env.cwd) },
+        { label: "System", value: `${env.osLabel} (${env.arch})` },
+        { label: "Shell", state: env.shell === "other" ? "warn" : "ok", value: env.shellLabel },
+        { label: "Harnesses", state: installed.length > 0 ? "ok" : "warn", value: installed.length > 0 ? installed.join(", ") : "none detected" },
+        {
+            label: "Key",
+            state: wizard.existing ? (wizard.existing.valid ? "ok" : "warn") : "none",
+            value: wizard.existing ? `${wizard.existing.valid ? "found" : "found but rejected"} (${wizard.existing.source})` : "none configured yet",
+        },
+    ];
+    if (env.remote) {
+        facts.splice(2, 0, { label: "Remote", state: "warn", value: env.remote });
+    }
+    return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: "Boundless Setup" }), _jsxs(Muted, { center: true, children: ["Signs you in through your browser, creates an inference key on your account,", "\n", "configures your coding harnesses, and sends one small test request.", "\n", "The key is never printed. Nothing is purchased."] }), _jsx(Facts, { facts: facts }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: onSelect, options: [
+                        { label: "Continue", value: "continue" },
+                        { label: "What this does", value: "what" },
+                        { label: "Privacy & data", value: "privacy" },
+                        { label: "Cancel", value: "cancel" },
+                    ] }) })] }));
+}
+function Info({ onBack, topic }) {
+    useInput((_, key) => {
+        if (key.return || key.escape) {
+            onBack();
+        }
+    });
+    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: [
+                        { hint: "recommended", label: "Reuse it", value: "reuse" },
+                        { label: "Sign in and create a separate key", value: "new" },
+                        { label: "Cancel", value: "cancel" },
+                    ] }) })] }));
+}
+function SignIn({ config, env, onCancel, onError, onToken, }) {
+    const [grant, setGrant] = useState(null);
+    const [opened, setOpened] = useState(null);
+    const controller = useRef(new AbortController()).current;
+    useInput((_, key) => {
+        if (key.escape) {
+            controller.abort();
+            onCancel();
+        }
+    });
+    useEffect(() => {
+        (async () => {
+            const started = await startDeviceGrant(config);
+            setGrant(started);
+            const shown = env.remote ? false : await openBrowser(approvalUrl(started));
+            setOpened(shown);
+            const token = await waitForAccessToken(config, started, controller.signal);
+            onToken(token);
+        })().catch((error) => {
+            if (!(error instanceof SetupError && error.code === "cancelled")) {
+                onError(error);
+            }
+        });
+    }, []);
+    const fallback = grant && opened === false;
+    return (_jsxs(Frame, { hints: "esc cancel", children: [_jsx(Title, { children: "Sign in through your browser" }), grant === null ? (_jsx(Spinner, { label: "Starting browser sign-in" })) : (_jsxs(_Fragment, { children: [fallback ? (_jsxs(_Fragment, { children: [_jsx(Para, { children: env.remote ? `Remote environment (${env.remote}). Open this on any device:` : "Your browser could not be opened. Open this on any device:" }), _jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Text, { color: BRAND, children: grant.verificationUri }) }), _jsxs(Box, { justifyContent: "center", marginBottom: 1, children: [_jsx(Text, { children: "and enter code " }), _jsx(Text, { bold: true, color: BRAND, children: grant.userCode })] })] })) : (_jsx(Para, { children: "Sign in (signup works too) and approve \"Boundless local setup\". The browser tab has the code already applied." })), _jsx(Spinner, { label: "Waiting for approval" }), _jsxs(Muted, { center: true, children: ["Expires ", new Date(grant.expiresAt).toLocaleTimeString()] })] }))] }));
+}
+function Exchange({ onDone, onError, token }) {
+    useEffect(() => {
+        const controller = new AbortController();
+        exchangeForKey(token, controller.signal)
+            .then((issued) => onDone(issued.key, issued.name))
+            .catch(onError);
+        return () => controller.abort();
+    }, []);
+    return (_jsx(Frame, { hints: "", children: _jsx(Spinner, { label: "Creating your inference key" }) }));
+}
+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 }) {
+    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] }));
+}
+function Catalog({ onDone, onError, wizard }) {
+    useEffect(() => {
+        listModels(wizard.config.gatewayUrl, wizard.key).then(onDone).catch(onError);
+    }, []);
+    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 Review({ harnesses, input, onCancel, onPlans, onProceed, wizard, }) {
+    const [plans, setPlans] = useState(null);
+    useEffect(() => {
+        Promise.all(harnesses.map(async (harness) => ({ harness, plan: await harness.plan(input) }))).then((planned) => {
+            onPlans(planned);
+            setPlans(planned);
+        });
+    }, []);
+    if (plans === null) {
+        return (_jsx(Frame, { hints: "", children: _jsx(Spinner, { label: "Planning changes" }) }));
+    }
+    const env = wizard.env;
+    const exposure = wizard.scope === "project"
+        ? "private project file, ignored by git"
+        : 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: [
+                    { 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: [
+                        { label: "Apply", value: "apply" },
+                        { label: "Cancel", value: "cancel" },
+                    ] }) })] }));
+}
+function Apply({ onDone, onError, wizard }) {
+    const [step, setStep] = useState("Storing the key");
+    useEffect(() => {
+        (async () => {
+            const env = wizard.env;
+            const key = wizard.key;
+            const changed = [];
+            const backups = [];
+            if (wizard.scope === "project") {
+                const { ignored, path } = await saveProjectKey(env.cwd, key);
+                changed.push(tilde(path));
+                if (ignored) {
+                    changed.push(`${tilde(env.cwd)}/.gitignore (.boundless/ added)`);
+                }
+            }
+            else if (wizard.store && wizard.existing?.key !== key) {
+                await saveKey(wizard.store, key);
+                changed.push(wizard.store.path ? tilde(wizard.store.path) : wizard.store.label);
+            }
+            if (wizard.scope === "user" && wizard.store) {
+                setStep("Updating your shell profile");
+                changed.push(...(await exposeInShell(env, wizard.store)));
+            }
+            for (const { harness, plan } of wizard.plans) {
+                setStep(`Configuring ${harness.name}`);
+                for (const change of plan.changes) {
+                    const { backup } = await change.apply();
+                    changed.push(tilde(change.path));
+                    if (backup) {
+                        backups.push(tilde(backup));
+                    }
+                }
+            }
+            wizard.changed = changed;
+            wizard.backups = backups;
+            onDone();
+        })().catch(onError);
+    }, []);
+    return (_jsx(Frame, { hints: "", children: _jsx(Spinner, { label: step }) }));
+}
+function Manual({ onContinue, plans }) {
+    useInput((_, key) => {
+        if (key.return) {
+            onContinue();
+        }
+    });
+    return (_jsxs(Frame, { hints: "enter continue", children: [_jsx(Title, { children: "Finish these by hand" }), plans
+                .filter(({ plan }) => plan.manual.length > 0)
+                .map(({ harness, plan }) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, children: harness.name }), plan.manual.map((line, index) => (_jsxs(Text, { children: ["  ", index + 1, ". ", line] }, line)))] }, harness.id)))] }));
+}
+function Test({ harnesses, onDone, wizard }) {
+    useEffect(() => {
+        (async () => {
+            const gateway = wizard.config.gatewayUrl;
+            const key = wizard.key;
+            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) {
+                    pairs.set(`${harness.wire}:${wizard.background}`, { model: wizard.background, wire: harness.wire });
+                }
+            }
+            const results = [];
+            for (const { model, wire } of pairs.values()) {
+                results.push(await testRequest(gateway, key, wire, model, wizard.catalog));
+            }
+            onDone(results);
+        })();
+    }, []);
+    return (_jsxs(Frame, { hints: "", children: [_jsx(Spinner, { label: "Sending test requests" }), _jsx(Muted, { center: true, children: "One small request per model and wire format. This uses account credits." })] }));
+}
+function TestFacts({ tests }) {
+    return (_jsx(Facts, { facts: tests.map((test) => test.kind === "ok"
+            ? {
+                label: `${test.model} (${test.wire})`,
+                value: `"${test.reply.slice(0, 24)}" · ${test.inputTokens} in / ${test.outputTokens} out${test.cost ? ` · ${test.cost}` : ""}`,
+            }
+            : { label: `${test.model} (${test.wire})`, state: "bad", value: `${test.reason}: ${test.message}` }) }));
+}
+function Tested({ harnesses, onSelect, tests }) {
+    const smokeable = harnesses.filter((harness) => harness.smoke);
+    const allOk = tests.every((test) => test.kind === "ok");
+    return (_jsxs(Frame, { hints: NAV, children: [_jsx(Title, { children: allOk ? "The API test passed" : "A test failed" }), _jsx(TestFacts, { tests: tests }), smokeable.length > 0 ? (_jsx(Muted, { center: true, children: "Optionally run each installed harness once from a scratch directory to prove the configuration end to end. This also uses credits." })) : null, _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: onSelect, options: smokeable.length > 0 && allOk
+                        ? [
+                            { label: `Run ${smokeable.map((harness) => harness.name).join(", ")}`, value: "smoke" },
+                            { label: "Finish", value: "finish" },
+                        ]
+                        : [{ label: "Finish", value: "finish" }] }) })] }));
+}
+function Smoke({ harnesses, input, onDone }) {
+    const [current, setCurrent] = useState("");
+    useEffect(() => {
+        (async () => {
+            const results = [];
+            for (const harness of harnesses) {
+                if (!harness.smoke) {
+                    continue;
+                }
+                setCurrent(harness.name);
+                results.push({ name: harness.name, result: await runSmoke(harness.smoke(input), input.key) });
+            }
+            onDone(results);
+        })();
+    }, []);
+    return (_jsxs(Frame, { hints: "", children: [_jsx(Spinner, { label: `Running ${current}` }), _jsx(Muted, { center: true, children: "Up to three minutes per harness." })] }));
+}
+function Done({ onExit, summary }) {
+    const ok = headline(summary).startsWith("Success");
+    return (_jsxs(Frame, { hints: "enter exit", children: [_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Text, { bold: true, color: ok ? OK : WARN, children: headline(summary) }) }), _jsx(Facts, { facts: [
+                    { label: "Harnesses", value: summary.harnesses.map((harness) => harness.name).join(", ") },
+                    { label: "Model", value: summary.primary },
+                    ...(summary.background !== summary.primary ? [{ label: "Background", value: summary.background }] : []),
+                    { label: "Scope", value: summary.scope === "user" ? "user account" : "this project" },
+                    { label: "Key", value: summary.keyName ? `${summary.keyName} in ${summary.keyStore}` : summary.keyStore },
+                    ...summary.smokes.map(({ name, result }) => ({ label: name, state: result.kind === "ok" ? "ok" : "bad", value: result.kind === "ok" ? "ran a real tool call" : result.output.split("\n").at(-1) ?? "failed" })),
+                ] }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: MUTED, children: "Changed" }), summary.changed.map((path) => (_jsxs(Text, { children: ["  ", path] }, path)))] }), summary.backups.length > 0 ? (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: MUTED, children: "Backups (restore by moving one back over its original)" }), summary.backups.map((path) => (_jsxs(Text, { children: ["  ", path] }, path)))] })) : null, _jsxs(Muted, { children: ["Open a new terminal so the shell picks up ", KEY_ENV, "; already-running apps need a restart. Manage or revoke the key at ", KEYS_URL, "."] }), _jsx(Box, { justifyContent: "center", children: _jsx(Select, { onSelect: onExit, options: [{ label: "Exit", value: "exit" }] }) })] }));
+}

package/dist/cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./app.js";
+import { CONSOLE, KEYS_URL } from "./lib/config.js";
+import { headline } from "./summary.js";
+import { VERSION } from "./version.js";
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    process.stdout.write(`${VERSION}\n`);
+    process.exit(0);
+}
+if (!(process.stdout.isTTY && process.stdin.isTTY)) {
+    process.stderr.write(`boundless-setup needs an interactive terminal. Run it directly, or paste "curl -fsSL https://boundless.md" into your agent.\n`);
+    process.exit(1);
+}
+let summary = null;
+const app = render(_jsx(App, { onFinish: (finished) => (summary = finished) }), { alternateScreen: true, exitOnCtrlC: true });
+await app.waitUntilExit();
+if (summary !== null) {
+    const done = summary;
+    const lines = [
+        headline(done),
+        `Harnesses: ${done.harnesses.map((harness) => harness.name).join(", ")}`,
+        `Model: ${done.primary}${done.background !== done.primary ? ` (background ${done.background})` : ""}`,
+        `Key: ${done.keyName ? `${done.keyName} in ` : ""}${done.keyStore}`,
+        ...done.changed.map((path) => `Changed: ${path}`),
+        ...done.backups.map((path) => `Backup: ${path}`),
+        ...done.tests.map((test) => test.kind === "ok"
+            ? `Test ${test.model} (${test.wire}): ok, ${test.inputTokens} in / ${test.outputTokens} out${test.cost ? `, ${test.cost}` : ""}`
+            : `Test ${test.model} (${test.wire}): ${test.reason} — ${test.message}`),
+        ...done.smokes.map(({ name, result }) => `${name}: ${result.kind === "ok" ? "ran a real tool call" : `failed — ${result.output.split("\n").at(-1)}`}`),
+        ...done.manual.flatMap(({ name, steps }) => [`${name} (by hand):`, ...steps.map((step, index) => `  ${index + 1}. ${step}`)]),
+        "Open a new terminal so BOUNDLESS_API_KEY is available; restart running apps.",
+        `Console ${CONSOLE}/ · keys ${KEYS_URL}`,
+    ];
+    process.stdout.write(`${lines.join("\n")}\n`);
+}

package/dist/harnesses/claude-code.js

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+import { claudeHome } from "../lib/env.js";
+import { installed } from "../lib/files.js";
+import { backup, merge, readJson, tilde, writePrivate } from "../lib/files.js";
+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",
+    detect: () => installed("claude"),
+    id: "claude-code",
+    name: "Claude Code",
+    plan: (input) => {
+        const path = settingsPath(input);
+        return Promise.resolve({
+            changes: [
+                {
+                    apply: async () => {
+                        const current = await readJson(path);
+                        const next = merge(current, {
+                            env: {
+                                ANTHROPIC_AUTH_TOKEN: input.key,
+                                ANTHROPIC_BASE_URL: input.gatewayUrl,
+                                ANTHROPIC_DEFAULT_HAIKU_MODEL: input.background,
+                                ANTHROPIC_DEFAULT_OPUS_MODEL: input.primary,
+                                ANTHROPIC_DEFAULT_SONNET_MODEL: input.primary,
+                                ANTHROPIC_MODEL: input.primary,
+                                CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+                                CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT: "1",
+                            },
+                            model: input.primary,
+                        });
+                        const saved = await backup(path);
+                        await writePrivate(path, `${JSON.stringify(next, null, 2)}\n`);
+                        return { backup: saved };
+                    },
+                    path,
+                    summary: `model ${input.primary}, background ${input.background}, ANTHROPIC_BASE_URL → ${input.gatewayUrl}, ANTHROPIC_AUTH_TOKEN (key kept in this 0600 file)`,
+                },
+            ],
+            manual: [],
+            notes: [
+                "Exit any running Claude Code before this file is written; start a fresh session afterwards.",
+                `The credential in ${tilde(path)} replaces your claude.ai login while set. Remove ANTHROPIC_AUTH_TOKEN to go back.`,
+            ],
+        });
+    },
+    smoke: (input) => ({
+        args: ["--model", input.primary, "-p", "Use the Bash tool to run printf boundless, then report the output."],
+        command: "claude",
+        expect: /boundless/i,
+    }),
+    wire: "anthropic",
+};