@boundless.network/setup 0.1.0

package/dist/lib/smoke.js

@@ -0,0 +1,36 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { KEY_ENV } from "./config.js";
+export async function runSmoke(smoke, key) {
+    const cwd = await mkdtemp(join(tmpdir(), "boundless-setup-"));
+    try {
+        return await new Promise((resolve) => {
+            const child = spawn(smoke.command, smoke.args, {
+                cwd,
+                env: { ...process.env, [KEY_ENV]: key },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let output = "";
+            const collect = (chunk) => {
+                output += chunk.toString();
+            };
+            child.stdout.on("data", collect);
+            child.stderr.on("data", collect);
+            const timer = setTimeout(() => child.kill("SIGKILL"), 180_000);
+            child.once("error", (error) => {
+                clearTimeout(timer);
+                resolve({ kind: "failed", output: error.message });
+            });
+            child.once("close", () => {
+                clearTimeout(timer);
+                const trimmed = output.trim().slice(-400);
+                resolve({ kind: smoke.expect.test(output) ? "ok" : "failed", output: trimmed });
+            });
+        });
+    }
+    finally {
+        await rm(cwd, { force: true, recursive: true });
+    }
+}

package/dist/lib/store.js

@@ -0,0 +1,157 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { KEY_ENV } from "./config.js";
+import { ensureIgnored, exists, gitTracked, home, readText, run, tilde, which, writeKeepingMode, writePrivate } from "./files.js";
+const SERVICE = "boundless";
+function stdinCommand(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["pipe", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", reject);
+        child.once("close", (code) => (code === 0 ? resolve() : reject(new Error(stderr.trim() || `${command} exited ${code}`))));
+        child.stdin.end(input);
+    });
+}
+export function userKeyFile(env) {
+    return env.os === "windows"
+        ? join(process.env.LOCALAPPDATA ?? home("AppData", "Local"), "Boundless", "api-key")
+        : home(".config", "boundless", "api-key");
+}
+export const projectKeyFile = (cwd) => join(cwd, ".boundless", "api-key");
+export async function availableStores(env) {
+    const stores = [];
+    if (env.os === "macos" && (await which("security"))) {
+        stores.push({ kind: "keychain", label: "macOS Keychain", path: null });
+    }
+    if (env.os === "linux" && (await which("secret-tool"))) {
+        stores.push({ kind: "secret-service", label: "Secret Service (secret-tool)", path: null });
+    }
+    stores.push({ kind: "file", label: `Private file ${tilde(userKeyFile(env))}`, path: userKeyFile(env) });
+    return stores;
+}
+export async function saveKey(store, key) {
+    switch (store.kind) {
+        case "keychain":
+            // `security -i` reads commands from stdin, so the secret never appears in process arguments.
+            await stdinCommand("security", ["-i"], `add-generic-password -a ${KEY_ENV} -s ${SERVICE} -U -w "${key}"\n`);
+            return;
+        case "secret-service":
+            await stdinCommand("secret-tool", ["store", "--label=Boundless API key", "service", SERVICE, "account", KEY_ENV], key);
+            return;
+        case "file":
+            await writePrivate(store.path, `${key}\n`);
+            return;
+    }
+}
+/** A shell expression that yields the key at shell start, so no profile ever contains it. */
+export function readExpression(store) {
+    const quoted = tilde(store.path ?? "").replace("~", "$HOME");
+    switch (store.kind) {
+        case "keychain":
+            return `security find-generic-password -a ${KEY_ENV} -s ${SERVICE} -w 2>/dev/null`;
+        case "secret-service":
+            return `secret-tool lookup service ${SERVICE} account ${KEY_ENV} 2>/dev/null`;
+        case "file":
+            return `cat "${quoted}" 2>/dev/null`;
+    }
+}
+export async function readStoredKey(store) {
+    try {
+        switch (store.kind) {
+            case "keychain": {
+                const { stdout } = await run("security", ["find-generic-password", "-a", KEY_ENV, "-s", SERVICE, "-w"]);
+                return stdout.trim() || null;
+            }
+            case "secret-service": {
+                const { stdout } = await run("secret-tool", ["lookup", "service", SERVICE, "account", KEY_ENV]);
+                return stdout.trim() || null;
+            }
+            case "file": {
+                const text = await readText(store.path);
+                return text?.trim() || null;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+}
+export async function findExistingKey(env) {
+    const fromEnv = process.env[KEY_ENV]?.trim();
+    if (fromEnv) {
+        return { key: fromEnv, source: `${KEY_ENV} in your environment` };
+    }
+    for (const store of await availableStores(env)) {
+        const key = await readStoredKey(store);
+        if (key) {
+            return { key, source: store.label };
+        }
+    }
+    const project = projectKeyFile(env.cwd);
+    const text = await readText(project);
+    if (text?.trim()) {
+        return { key: text.trim(), source: tilde(project) };
+    }
+    return null;
+}
+const MARK_START = "# >>> boundless setup >>>";
+const MARK_END = "# <<< boundless setup <<<";
+export function profilePath(env) {
+    switch (env.shell) {
+        case "zsh":
+            return home(".zshrc");
+        case "bash":
+            return env.os === "macos" ? home(".bash_profile") : home(".bashrc");
+        case "fish":
+            return home(".config", "fish", "conf.d", "boundless.fish");
+        case "powershell":
+            return null;
+        case "other":
+            return home(".profile");
+    }
+}
+export async function exposeInShell(env, store) {
+    const changed = [];
+    if (env.os === "windows") {
+        // A user-scoped environment variable read from the private file, so the key never appears in a command line.
+        const path = store.path;
+        await run("powershell", [
+            "-NoProfile",
+            "-Command",
+            `[Environment]::SetEnvironmentVariable('${KEY_ENV}', (Get-Content -Raw -LiteralPath '${path.replaceAll("'", "''")}').Trim(), 'User')`,
+        ]);
+        changed.push("User environment variable BOUNDLESS_API_KEY");
+        return changed;
+    }
+    const path = profilePath(env);
+    if (!path) {
+        return changed;
+    }
+    const line = env.shell === "fish"
+        ? `set -gx ${KEY_ENV} (${readExpression(store)})`
+        : `export ${KEY_ENV}="$(${readExpression(store)})"`;
+    const block = `${MARK_START}\n${line}\n${MARK_END}\n`;
+    const current = (await readText(path)) ?? "";
+    const start = current.indexOf(MARK_START);
+    const end = current.indexOf(MARK_END);
+    const next = start >= 0 && end > start
+        ? `${current.slice(0, start)}${block}${current.slice(end + MARK_END.length).replace(/^\n/, "")}`
+        : `${current}${current === "" ? "" : current.endsWith("\n") ? "\n" : "\n\n"}${block}`;
+    if (next !== current) {
+        await writeKeepingMode(path, next);
+        changed.push(tilde(path));
+    }
+    return changed;
+}
+export async function saveProjectKey(cwd, key) {
+    const path = projectKeyFile(cwd);
+    if (await gitTracked(".boundless/api-key", cwd)) {
+        throw new Error(`${tilde(path)} is tracked by git; untrack it before storing a key there.`);
+    }
+    await writePrivate(path, `${key}\n`);
+    const ignored = (await exists(join(cwd, ".git"))) ? await ensureIgnored(cwd, ".boundless/") : false;
+    return { ignored, path };
+}

package/dist/lib/test.js

@@ -0,0 +1,56 @@
+import { usd } from "./catalog.js";
+import { request } from "./config.js";
+const PROMPT = "Reply with exactly: ok";
+function classify(status, body) {
+    if (status === 401 || status === 403) {
+        return { message: "The key was rejected (authentication).", reason: "auth" };
+    }
+    if (status === 402 || /budget|credit|balance/i.test(body)) {
+        return { message: "The account has no credit for this request.", reason: "credit" };
+    }
+    if (status === 429) {
+        return { message: "Rate limited; try again in a minute.", reason: "rate_limit" };
+    }
+    if (status === 404 || status === 400) {
+        return { message: `The model or request was refused (HTTP ${status}): ${body.slice(0, 160)}`, reason: "model" };
+    }
+    return { message: `HTTP ${status}: ${body.slice(0, 160)}`, reason: "config" };
+}
+function cost(model, inputTokens, outputTokens) {
+    if (!model) {
+        return null;
+    }
+    return usd((inputTokens * model.inputPerMillionTokens + outputTokens * model.outputPerMillionTokens) / 1_000_000);
+}
+export async function testRequest(gatewayUrl, key, wire, model, catalog) {
+    const url = wire === "anthropic" ? `${gatewayUrl}/v1/messages` : `${gatewayUrl}/v1/chat/completions`;
+    const headers = wire === "anthropic"
+        ? { "anthropic-version": "2023-06-01", "content-type": "application/json", "x-api-key": key }
+        : { authorization: `Bearer ${key}`, "content-type": "application/json" };
+    try {
+        const response = await request(url, {
+            body: JSON.stringify({ max_tokens: 1024, messages: [{ content: PROMPT, role: "user" }], model }),
+            headers,
+            method: "POST",
+            signal: AbortSignal.timeout(120_000),
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            return { kind: "failed", model, wire, ...classify(response.status, text) };
+        }
+        const body = JSON.parse(text);
+        const reply = wire === "anthropic"
+            ? (body.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("")
+            : (body.choices?.[0]?.message?.content ?? "");
+        const inputTokens = body.usage?.prompt_tokens ?? body.usage?.input_tokens ?? 0;
+        const outputTokens = body.usage?.completion_tokens ?? body.usage?.output_tokens ?? 0;
+        if (reply.trim() === "") {
+            return { kind: "failed", message: "The model returned an empty reply.", model, reason: "model", wire };
+        }
+        const entry = catalog.find((candidate) => candidate.id === model);
+        return { cost: cost(entry, inputTokens, outputTokens), inputTokens, kind: "ok", model, outputTokens, reply: reply.trim(), wire };
+    }
+    catch (error) {
+        return { kind: "failed", message: error.message, model, reason: "config", wire };
+    }
+}

package/dist/summary.js

@@ -0,0 +1,14 @@
+export function succeeded(summary) {
+    return summary.tests.every((test) => test.kind === "ok") && summary.smokes.every((smoke) => smoke.result.kind === "ok");
+}
+export function headline(summary) {
+    if (summary.tests.length === 0) {
+        return "Boundless is configured, but nothing was tested.";
+    }
+    if (succeeded(summary)) {
+        return summary.smokes.length > 0
+            ? "Success — Boundless is configured and tested"
+            : "Success — Boundless is configured and the API test passed";
+    }
+    return "Boundless is configured, but a test failed";
+}

package/dist/ui/facts.js

@@ -0,0 +1,19 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { BAD, MUTED, OK, WARN } from "./theme.js";
+export function Facts({ facts }) {
+    const width = Math.max(...facts.map((fact) => fact.label.length));
+    return (_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Box, { flexDirection: "column", children: facts.map((fact) => (_jsxs(Box, { children: [_jsxs(Box, { flexShrink: 0, width: width + 3, children: [_jsxs(Text, { color: MUTED, children: [fact.label.padStart(width), " "] }), _jsx(Mark, { state: fact.state ?? "ok" })] }), _jsx(Box, { flexShrink: 1, children: _jsx(Text, { wrap: "wrap", children: fact.value }) })] }, fact.label))) }) }));
+}
+function Mark({ state }) {
+    switch (state) {
+        case "ok":
+            return _jsx(Text, { color: OK, children: "\u2714 " });
+        case "warn":
+            return _jsx(Text, { color: WARN, children: "! " });
+        case "bad":
+            return _jsx(Text, { color: BAD, children: "\u2718 " });
+        case "none":
+            return _jsx(Text, { color: MUTED, children: "\u00B7 " });
+    }
+}

package/dist/ui/frame.js

@@ -0,0 +1,21 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useWindowSize } from "ink";
+import { VERSION } from "../version.js";
+import { BRAND, MUTED } from "./theme.js";
+export function Frame({ children, hints }) {
+    const { columns, rows } = useWindowSize();
+    const width = Math.min(Math.max(columns - 4, 40), 88);
+    const title = ` Boundless Setup v${VERSION}`;
+    const right = "boundless.md ";
+    const pad = Math.max(columns - title.length - right.length, 1);
+    return (_jsxs(Box, { flexDirection: "column", height: rows, width: columns, children: [_jsxs(Text, { backgroundColor: BRAND, color: "black", children: [title, " ".repeat(pad), right] }), _jsx(Box, { alignItems: "center", flexDirection: "column", flexGrow: 1, justifyContent: "center", children: _jsx(Box, { flexDirection: "column", width: width, children: children }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { color: MUTED, children: hints }) })] }));
+}
+export function Title({ children }) {
+    return (_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Text, { bold: true, color: BRAND, children: children }) }));
+}
+export function Muted({ children, center }) {
+    return (_jsx(Box, { justifyContent: center ? "center" : "flex-start", marginBottom: 1, children: _jsx(Text, { color: MUTED, children: children }) }));
+}
+export function Para({ children }) {
+    return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: children }) }));
+}

package/dist/ui/menu.js

@@ -0,0 +1,74 @@
+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);
+    const move = (delta) => {
+        let next = index;
+        for (let step = 0; step < options.length; step += 1) {
+            next = (next + delta + options.length) % options.length;
+            if (!options[next]?.disabled) {
+                break;
+            }
+        }
+        setIndex(next);
+    };
+    useInput((input, key) => {
+        if (key.upArrow || input === "k") {
+            move(-1);
+        }
+        else if (key.downArrow || input === "j") {
+            move(1);
+        }
+        else if (key.return) {
+            const chosen = options[index];
+            if (chosen && !chosen.disabled) {
+                onSelect(chosen.value);
+            }
+        }
+        else if (key.escape && onCancel) {
+            onCancel();
+        }
+    });
+    return (_jsx(Box, { alignItems: "flex-start", flexDirection: "column", children: options.map((option, position) => {
+            const active = position === index;
+            return (_jsxs(Box, { children: [_jsx(Text, { color: BRAND, children: active ? "▸ " : "  " }), _jsx(Text, { bold: active, color: option.disabled ? MUTED : active ? BRAND : undefined, dimColor: option.disabled, children: option.label }), option.hint ? _jsxs(Text, { color: MUTED, children: [" ", option.hint] }) : null] }, option.value));
+        }) }));
+}
+export function MultiSelect({ initial, onCancel, onSubmit, options, }) {
+    const [index, setIndex] = useState(0);
+    const [chosen, setChosen] = useState(new Set(initial));
+    useInput((input, key) => {
+        if (key.upArrow || input === "k") {
+            setIndex((index + options.length - 1) % options.length);
+        }
+        else if (key.downArrow || input === "j") {
+            setIndex((index + 1) % options.length);
+        }
+        else if (input === " ") {
+            const value = options[index]?.value;
+            if (value !== undefined) {
+                const next = new Set(chosen);
+                if (next.has(value)) {
+                    next.delete(value);
+                }
+                else {
+                    next.add(value);
+                }
+                setChosen(next);
+            }
+        }
+        else if (key.return) {
+            onSubmit(options.map((option) => option.value).filter((value) => chosen.has(value)));
+        }
+        else if (key.escape && onCancel) {
+            onCancel();
+        }
+    });
+    return (_jsx(Box, { alignItems: "flex-start", flexDirection: "column", children: options.map((option, position) => {
+            const active = position === index;
+            const on = chosen.has(option.value);
+            return (_jsxs(Box, { children: [_jsx(Text, { color: BRAND, children: active ? "▸ " : "  " }), _jsx(Text, { color: on ? BRAND : MUTED, children: on ? "◉ " : "○ " }), _jsx(Text, { bold: active, color: active ? BRAND : undefined, children: option.label }), option.hint ? _jsxs(Text, { color: MUTED, children: [" ", option.hint] }) : null] }, option.value));
+        }) }));
+}

package/dist/ui/spinner.js

@@ -0,0 +1,13 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import { BRAND } from "./theme.js";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function Spinner({ label }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => setFrame((current) => (current + 1) % FRAMES.length), 80);
+        return () => clearInterval(timer);
+    }, []);
+    return (_jsxs(Box, { justifyContent: "center", marginBottom: 1, children: [_jsxs(Text, { color: BRAND, children: [FRAMES[frame], " "] }), _jsx(Text, { children: label })] }));
+}

package/dist/ui/table.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { usd } from "../lib/catalog.js";
+import { MUTED } from "./theme.js";
+const columns = (model) => [
+    model.id,
+    usd(model.inputPerMillionTokens),
+    usd(model.outputPerMillionTokens),
+    model.contextTokens.toLocaleString("en-US"),
+];
+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])))] }));
+}

package/dist/ui/text-input.js

@@ -0,0 +1,22 @@
+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 TextInput({ onCancel, onSubmit, placeholder, }) {
+    const [value, setValue] = useState("");
+    useInput((input, key) => {
+        if (key.return) {
+            onSubmit(value.trim());
+        }
+        else if (key.escape) {
+            onCancel();
+        }
+        else if (key.backspace || key.delete) {
+            setValue(value.slice(0, -1));
+        }
+        else if (!(key.ctrl || key.meta) && input) {
+            setValue(value + input);
+        }
+    });
+    return (_jsxs(Box, { children: [_jsx(Text, { color: BRAND, children: "\u25B8 " }), value ? _jsx(Text, { children: value }) : _jsx(Text, { color: MUTED, children: placeholder }), _jsx(Text, { color: BRAND, children: "\u258F" })] }));
+}

package/dist/ui/theme.js

@@ -0,0 +1,5 @@
+export const BRAND = "#9B87F5";
+export const MUTED = "gray";
+export const OK = "green";
+export const WARN = "yellow";
+export const BAD = "red";

package/dist/version.js

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module";
+const { version } = createRequire(import.meta.url)("../package.json");
+export const VERSION = version;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@boundless.network/setup",
+  "version": "0.1.0",
+  "description": "Set up Boundless as the inference provider for your coding harness. Run: npx -y @boundless.network/setup@latest",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "boundless-setup": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "start": "node dist/cli.js",
+    "test": "tsc -p tsconfig.test.json && node --test \".test-dist/**/*.test.js\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ink": "^7.1.1",
+    "react": "^19.3.0",
+    "smol-toml": "^1.9.0",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.3.0",
+    "typescript": "^5.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/boundless-network/inference-serving.git",
+    "directory": "setup"
+  },
+  "homepage": "https://boundless.md"
+}