@9thprotocol/cli 0.1.0

package/dist/shared.js

@@ -0,0 +1,192 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { AUTO_MODEL, } from "@9thprotocol/agent-core";
+export const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+export const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+export const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+export const red = (s) => `\x1b[31m${s}\x1b[0m`;
+/** Auto routing is the product default (PLAN.md §5.5); `/model <id>` pins a model. */
+export const DEFAULT_MODEL = AUTO_MODEL;
+const BIASES = ["economy", "balanced", "quality"];
+/** Auto bias from NINEP_AUTO_BIAS or ~/.9p/config.json; defaults to balanced. */
+export function getAutoBias() {
+    const fromEnv = process.env.NINEP_AUTO_BIAS;
+    if (fromEnv && BIASES.includes(fromEnv))
+        return fromEnv;
+    try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".9p", "config.json"), "utf8"));
+        if (cfg.autoBias && BIASES.includes(cfg.autoBias))
+            return cfg.autoBias;
+    }
+    catch {
+        // no config file
+    }
+    return "balanced";
+}
+export function setAutoBias(bias) {
+    const dir = path.join(os.homedir(), ".9p");
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, "config.json");
+    let cfg = {};
+    try {
+        cfg = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        // fresh config
+    }
+    cfg.autoBias = bias;
+    fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n");
+}
+export const AUTO_BIASES = BIASES;
+/**
+ * Catalog with plan locks for the Auto router. Platform-only: BYOK has no plan
+ * gating, so the router falls back to its built-in ladders.
+ */
+export async function fetchCatalog(auth) {
+    if (!auth.platform)
+        return undefined;
+    try {
+        const res = await fetch(`${auth.platform.baseUrl}/models`, {
+            headers: { Authorization: `Bearer ${auth.apiKey}` },
+        });
+        if (!res.ok)
+            return undefined;
+        const data = (await res.json());
+        // contextLength feeds compaction, without it every model falls back to a
+        // generic default and a 32k model would blow past its window.
+        return data.models?.map((m) => ({
+            id: m.id,
+            tier: m.tier,
+            locked: m.locked,
+            contextLength: m.contextLength ?? null,
+        }));
+    }
+    catch {
+        // Routing must never block a session on a catalog fetch, ladders still work.
+        return undefined;
+    }
+}
+/**
+ * Auth resolution order:
+ * 1. NINEP_API_URL + NINEP_TOKEN (platform, metered)
+ * 2. ~/.9p/auth.json {"apiUrl", "token"} (platform)
+ * 3. OPENROUTER_API_KEY or ~/.9p/auth.json {"openrouterApiKey"} (BYOK, direct)
+ */
+export function getAuth() {
+    if (process.env.NINEP_API_URL && process.env.NINEP_TOKEN) {
+        return { apiKey: process.env.NINEP_TOKEN, platform: { baseUrl: process.env.NINEP_API_URL } };
+    }
+    let file = {};
+    try {
+        file = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".9p", "auth.json"), "utf8"));
+    }
+    catch {
+        // no auth file
+    }
+    if (file.apiUrl && file.token)
+        return { apiKey: file.token, platform: { baseUrl: file.apiUrl } };
+    if (process.env.OPENROUTER_API_KEY)
+        return { apiKey: process.env.OPENROUTER_API_KEY };
+    if (file.openrouterApiKey)
+        return { apiKey: file.openrouterApiKey };
+    return null;
+}
+const authFilePath = () => path.join(os.homedir(), ".9p", "auth.json");
+/** Seconds of remaining life below which we refresh rather than risk a mid-turn 401. */
+const REFRESH_SKEW_S = 120;
+/** `exp` from a JWT payload without verifying. We only need the expiry hint. */
+function tokenExpiry(token) {
+    try {
+        const payload = JSON.parse(Buffer.from(token.split(".")[1] ?? "", "base64url").toString("utf8"));
+        return typeof payload.exp === "number" ? payload.exp : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Exchange the stored refresh token for a fresh pair and persist it.
+ *
+ * Access tokens live 15 minutes, so without this a `9p login` session would 401
+ * partway through the first real task. Refresh tokens rotate server-side, so the
+ * new one must be written back or the next refresh fails.
+ */
+async function refreshStoredAuth() {
+    let file = {};
+    try {
+        file = JSON.parse(fs.readFileSync(authFilePath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+    const { apiUrl, refreshToken } = file;
+    if (typeof apiUrl !== "string" || typeof refreshToken !== "string")
+        return null;
+    try {
+        const res = await fetch(`${apiUrl}/auth/refresh`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken }),
+        });
+        if (!res.ok)
+            return null;
+        const next = (await res.json());
+        fs.writeFileSync(authFilePath(), JSON.stringify({ ...file, token: next.accessToken, refreshToken: next.refreshToken }, null, 2) + "\n", { mode: 0o600 });
+        return { apiKey: next.accessToken, platform: { baseUrl: apiUrl } };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve credentials, refreshing an expiring platform token first.
+ *
+ * Returns a reason rather than exiting, so hosts that are not a terminal (the
+ * desktop app) can surface it in their own UI. A library that calls
+ * `process.exit` kills an Electron app with a message nobody ever sees.
+ */
+export async function resolveAuth() {
+    const auth = getAuth();
+    if (auth?.platform && !process.env.NINEP_TOKEN) {
+        const exp = tokenExpiry(auth.apiKey);
+        if (exp !== null && exp - Date.now() / 1000 < REFRESH_SKEW_S) {
+            const refreshed = await refreshStoredAuth();
+            if (refreshed)
+                return { ok: true, auth: refreshed };
+            return { ok: false, reason: "expired" };
+        }
+    }
+    if (!auth)
+        return { ok: false, reason: "none" };
+    return { ok: true, auth };
+}
+/** CLI entry point: resolve credentials, or print and exit. */
+export async function requireAuth() {
+    const result = await resolveAuth();
+    if (result.ok)
+        return result.auth;
+    console.error(result.reason === "expired"
+        ? red("Session expired.") + ` Run ${cyan("9p login")} to sign in again.`
+        : red("No credentials.") +
+            ` Run ${cyan("9p login")}, or set OPENROUTER_API_KEY for BYOK.`);
+    process.exit(1);
+}
+const k = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
+export function usageLine(u) {
+    return `${u.requests} calls · ${k(u.inputTokens)} in (${k(u.cachedTokens)} cached) · ${k(u.outputTokens)} out`;
+}
+/**
+ * What delegation kept out of the context. Empty when nothing was delegated,
+ * so callers can append it unconditionally without printing a zero every turn.
+ *
+ * Phrased as context rather than money on purpose: those tokens are not merely
+ * unspent once, they are tokens that never get resent on any later turn, which
+ * is the whole reason a session window lasts longer with delegation on.
+ */
+export function delegationLine(d) {
+    if (!d.calls)
+        return "";
+    return `⇢ ${d.calls} delegated · ${k(d.contextTokensSaved)} tokens kept out of context`;
+}
+//# sourceMappingURL=shared.js.map

package/dist/tui/app.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import type { AgentEvent, DelegationTotals, PermissionMode, Skill, UsageTotals } from "@9thprotocol/agent-core";
+/** What the TUI needs from a session, narrow so tests can inject a fake. */
+export interface AgentLike {
+    model: string;
+    mode: PermissionMode;
+    readonly usage: UsageTotals;
+    readonly delegated: DelegationTotals;
+    send(text: string): AsyncGenerator<AgentEvent>;
+    clear(): void;
+}
+export interface AppMeta {
+    cwd: string;
+    authLabel: string;
+    vault: string | null;
+    skills: Skill[];
+    mcpSummary: string | null;
+}
+export interface AppBridge {
+    requestPermission: (summary: string) => Promise<boolean>;
+    requestAnswer: (question: string, options: string[]) => Promise<string>;
+}
+export declare function App({ session, meta, register, }: {
+    session: AgentLike;
+    meta: AppMeta;
+    /** Called on mount with the UI bridge for permission/ask prompts. */
+    register?: (bridge: AppBridge) => void;
+}): React.JSX.Element;

package/dist/tui/app.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Static, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { skillMessage } from "@9thprotocol/agent-core";
+const kfmt = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
+const MODES = ["default", "accept-edits", "plan", "bypass"];
+export function App({ session, meta, register, }) {
+    const { exit } = useApp();
+    const [items, setItems] = useState(() => {
+        const banner = [
+            { id: -4, kind: "banner", text: "9th Protocol (9p)" },
+            {
+                id: -3,
+                kind: "info",
+                text: `auth: ${meta.authLabel} · cwd: ${meta.cwd}` +
+                    (meta.vault ? " · vault linked" : "") +
+                    (meta.mcpSummary ? ` · mcp: ${meta.mcpSummary}` : ""),
+            },
+        ];
+        if (meta.skills.length) {
+            banner.push({ id: -2, kind: "info", text: `skills: ${meta.skills.map((s) => "/" + s.name).join(" ")}` });
+        }
+        banner.push({ id: -1, kind: "info", text: "/help for commands" });
+        return banner;
+    });
+    const [activeText, setActiveText] = useState("");
+    const [input, setInput] = useState("");
+    const [busy, setBusy] = useState(false);
+    const [statusTick, setStatusTick] = useState(0); // re-render statusline after /model etc.
+    const [pendingPerm, setPendingPerm] = useState(null);
+    const [pendingAsk, setPendingAsk] = useState(null);
+    const nextId = useRef(1);
+    const activeRef = useRef("");
+    const push = useCallback((kind, text) => {
+        setItems((prev) => [...prev, { id: nextId.current++, kind, text }]);
+    }, []);
+    const flushActive = useCallback(() => {
+        if (activeRef.current.trim())
+            push("assistant", activeRef.current.trimEnd());
+        activeRef.current = "";
+        setActiveText("");
+    }, [push]);
+    const runMessage = useCallback(async (message) => {
+        setBusy(true);
+        try {
+            for await (const ev of session.send(message)) {
+                switch (ev.type) {
+                    case "text_delta":
+                        activeRef.current += ev.text;
+                        setActiveText(activeRef.current);
+                        break;
+                    case "tool_start":
+                        flushActive();
+                        push("tool", `⚙ ${ev.summary}`);
+                        break;
+                    case "tool_end":
+                        if (ev.isError)
+                            push("warn", `  ✗ ${ev.output.split("\n")[0] ?? ""}`);
+                        break;
+                    case "permission_denied":
+                        flushActive();
+                        push("warn", `✗ denied: ${ev.summary}`);
+                        break;
+                    case "turn_end":
+                        flushActive();
+                        break;
+                    case "error":
+                        flushActive();
+                        push("error", `error: ${ev.message}`);
+                        if (ev.code === "window_limit" || ev.code === "weekly_limit") {
+                            push("warn", "session limit hit, buy a reset from the web UI, or wait for the window to roll");
+                        }
+                        break;
+                }
+            }
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [session, push, flushActive]);
+    const handleSlash = useCallback((line) => {
+        const [cmd = "", ...rest] = line.slice(1).split(/\s+/);
+        const arg = rest.join(" ").trim();
+        switch (cmd) {
+            case "help":
+                push("info", "/models /model [id] /mode [default|accept-edits|plan|bypass] /skills /<skill> [args] /clear /usage /exit");
+                return;
+            case "model":
+                if (arg) {
+                    session.model = arg;
+                    setStatusTick((t) => t + 1);
+                }
+                push("info", `model: ${session.model}`);
+                return;
+            case "mode":
+                if (arg && MODES.includes(arg)) {
+                    session.mode = arg;
+                    setStatusTick((t) => t + 1);
+                }
+                push("info", `mode: ${session.mode}`);
+                return;
+            case "skills":
+                push("info", meta.skills.length
+                    ? meta.skills.map((s) => `/${s.name}  ${s.description}`).join("\n")
+                    : "no skills found (~/.9p/skills or .9p/skills)");
+                return;
+            case "clear":
+                session.clear();
+                push("info", "context cleared");
+                return;
+            case "usage": {
+                const u = session.usage;
+                push("info", `${u.requests} calls · ${u.inputTokens} in (${u.cachedTokens} cached) · ${u.outputTokens} out`);
+                const d = session.delegated;
+                if (d.calls) {
+                    push("info", `⇢ ${d.calls} delegated · ${d.contextTokensSaved} tokens kept out of context ` +
+                        `(worker: ${d.workerUsage.inputTokens} in / ${d.workerUsage.outputTokens} out)`);
+                }
+                return;
+            }
+            case "exit":
+            case "quit":
+                exit();
+                return;
+            default: {
+                const skill = meta.skills.find((s) => s.name === cmd);
+                if (skill) {
+                    push("user", line);
+                    void runMessage(skillMessage(skill, arg));
+                    return;
+                }
+                push("error", `unknown command: /${cmd}`);
+            }
+        }
+    }, [session, meta.skills, push, exit, runMessage]);
+    const submit = useCallback((value) => {
+        const line = value.trim();
+        setInput("");
+        if (!line)
+            return;
+        if (pendingAsk && !pendingAsk.options.length) {
+            const { resolve } = pendingAsk;
+            setPendingAsk(null);
+            push("info", `answered: ${line}`);
+            resolve(line);
+            return;
+        }
+        if (line.startsWith("/")) {
+            handleSlash(line);
+            return;
+        }
+        push("user", line);
+        void runMessage(line);
+    }, [pendingAsk, handleSlash, push, runMessage]);
+    useInput((char) => {
+        if (pendingPerm) {
+            const allow = /^y$/i.test(char);
+            if (/^[yn]$/i.test(char)) {
+                const { resolve, summary } = pendingPerm;
+                setPendingPerm(null);
+                push(allow ? "info" : "warn", `${allow ? "✓ allowed" : "✗ denied"}: ${summary}`);
+                resolve(allow);
+            }
+            return;
+        }
+        if (pendingAsk?.options.length) {
+            const idx = Number(char);
+            const pick = pendingAsk.options[idx - 1];
+            if (pick !== undefined) {
+                const { resolve } = pendingAsk;
+                setPendingAsk(null);
+                push("info", `answered: ${pick}`);
+                resolve(pick);
+            }
+        }
+    }, { isActive: pendingPerm !== null || (pendingAsk?.options.length ?? 0) > 0 });
+    useEffect(() => {
+        register?.({
+            requestPermission: (summary) => new Promise((resolve) => setPendingPerm({ summary, resolve })),
+            requestAnswer: (question, options) => new Promise((resolve) => setPendingAsk({ question, options, resolve })),
+        });
+    }, [register]);
+    const u = session.usage;
+    void statusTick;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item) => (_jsxs(Box, { marginBottom: item.kind === "assistant" || item.kind === "user" ? 1 : 0, children: [item.kind === "banner" && (_jsx(Text, { color: "magenta", bold: true, children: item.text })), item.kind === "user" && _jsx(Text, { color: "cyan", children: `❯ ${item.text}` }), item.kind === "assistant" && _jsx(Text, { children: item.text }), item.kind === "tool" && _jsx(Text, { dimColor: true, children: item.text }), item.kind === "info" && _jsx(Text, { dimColor: true, children: item.text }), item.kind === "warn" && _jsx(Text, { color: "yellow", children: item.text }), item.kind === "error" && _jsx(Text, { color: "red", children: item.text })] }, item.id)) }), activeText !== "" && _jsx(Text, { children: activeText }), pendingPerm && (_jsx(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: _jsx(Text, { color: "yellow", children: `● permission: ${pendingPerm.summary}, allow? [y/n]` }) })), pendingAsk && (_jsxs(Box, { borderStyle: "round", borderColor: "magenta", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "magenta", children: `● ${pendingAsk.question}` }), pendingAsk.options.map((o, i) => (_jsx(Text, { dimColor: true, children: `  ${i + 1}. ${o}` }, o))), pendingAsk.options.length > 0 && _jsx(Text, { dimColor: true, children: "press a number to choose" })] })), !pendingPerm && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: busy ? "… " : "9p ❯ " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: submit, focus: !pendingPerm })] })), _jsx(Text, { dimColor: true, children: `${session.model} · ${session.mode} · ${u.requests} calls · ${u.inputTokens} in · ${u.outputTokens} out` +
+                    (session.delegated.calls
+                        ? ` · ⇢ ${kfmt(session.delegated.contextTokensSaved)} saved`
+                        : "") })] }));
+}
+//# sourceMappingURL=app.js.map

package/dist/tui/index.d.ts

@@ -0,0 +1,2 @@
+/** `9p` in a TTY, the Ink TUI host. */
+export declare function runTui(cwd: string): Promise<void>;

package/dist/tui/index.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { AgentSession, McpManager, loadSkills, resolveVault, } from "@9thprotocol/agent-core";
+import { requireAuth, DEFAULT_MODEL, fetchCatalog, getAutoBias } from "../shared.js";
+import { App } from "./app.js";
+/** `9p` in a TTY, the Ink TUI host. */
+export async function runTui(cwd) {
+    const auth = await requireAuth();
+    const mcp = await McpManager.fromCwd(cwd);
+    const skills = loadSkills(cwd);
+    const vault = resolveVault(cwd);
+    let bridge = null;
+    const catalog = await fetchCatalog(auth);
+    const session = new AgentSession({
+        apiKey: auth.apiKey,
+        ...(auth.platform ? { platform: auth.platform } : {}),
+        mcp,
+        model: process.env.NINEP_MODEL ?? DEFAULT_MODEL,
+        autoRouter: { bias: getAutoBias(), ...(catalog ? { catalog } : {}) },
+        cwd,
+        mode: "default",
+        decide: async (req) => (bridge ? bridge.requestPermission(req.summary) : false),
+        askUser: async (q) => bridge ? bridge.requestAnswer(q.question, q.options ?? []) : "",
+    });
+    const { waitUntilExit } = render(_jsx(App, { session: session, meta: {
+            cwd,
+            authLabel: auth.platform ? "platform" : "byok",
+            vault,
+            skills,
+            mcpSummary: mcp.servers.length ? `${mcp.servers.join(",")} (${mcp.tools.length})` : null,
+        }, register: (b) => (bridge = b) }));
+    await waitUntilExit();
+    await mcp.close();
+}
+//# sourceMappingURL=index.js.map

package/dist/webui.d.ts

@@ -0,0 +1,13 @@
+/**
+ * HTML for the local session (`9p serve`) and the desktop app window.
+ *
+ * Deliberately one self-contained file with no build step and no dependencies:
+ * it is served by the CLI itself, so a bundler here would mean a second build
+ * pipeline for a single page.
+ *
+ * Layout: a full-height left sidebar, a breadcrumb bar over the main column,
+ * and a composer that owns its own controls. The sidebar runs to the top of the
+ * window on purpose. On macOS the desktop app hides the title bar, so the
+ * traffic lights sit in the sidebar's header strip instead of over the content.
+ */
+export declare function chatHtml(): string;