@agtnames/cli 0.0.0-stage → 0.1.0

package/dist/picker.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The capability picker. Ranked results (best match first and highlighted, @agtnames/resolver rankCapabilities), a
+ * fixed viewport with "N more", the highlighted item's description on its own line, suggestions read from the
+ * agent's own tools pre-ticked and labelled with where they came from, a category drill-down, and custom ids with
+ * "did you mean" (spec §4.2: custom ids allowed, lowercase hyphenated).
+ */
+import { type CapabilityVocabulary } from "@agtnames/resolver";
+import { type Frame, type Key, type Nav, type Widget } from "./tui.js";
+export interface CapabilitySuggestion {
+    id: string;
+    from: string[];
+}
+export interface CapabilitySource {
+    vocabulary(): CapabilityVocabulary;
+    usage(): Record<string, number>;
+    suggestions(): CapabilitySuggestion[];
+    /** Register a callback for when background data (vocabulary refresh, endpoint probes) arrives. */
+    onChange(cb: () => void): (() => void) | void;
+}
+export declare class CapabilityPicker implements Widget<string[] | Nav> {
+    private src;
+    private o;
+    get label(): string;
+    private query;
+    private selected;
+    private i;
+    private top;
+    private mode;
+    private category;
+    private catIndex;
+    private flash;
+    private seenSuggestions;
+    constructor(src: CapabilitySource, o: {
+        label: string;
+        initial?: string[];
+    });
+    /** New suggestions are pre-ticked once; unticking one sticks. */
+    private absorbSuggestions;
+    private off?;
+    attach(redraw: () => void): void;
+    detach(): void;
+    private capOf;
+    private uses;
+    private rows;
+    private selectable;
+    private clampCursor;
+    private move;
+    private toggle;
+    private topMatch;
+    render(): Frame;
+    onKey(str: string | undefined, key: Key): {
+        done: string[] | Nav;
+    } | void;
+    summary(v: string[] | Nav): string;
+}

package/dist/picker.js

@@ -0,0 +1,330 @@
+/**
+ * The capability picker. Ranked results (best match first and highlighted, @agtnames/resolver rankCapabilities), a
+ * fixed viewport with "N more", the highlighted item's description on its own line, suggestions read from the
+ * agent's own tools pre-ticked and labelled with where they came from, a category drill-down, and custom ids with
+ * "did you mean" (spec §4.2: custom ids allowed, lowercase hyphenated).
+ */
+import { nearestCapability, rankCapabilities, toCapabilityId } from "@agtnames/resolver";
+import { BACK, copyToClipboard, SKIP, style } from "./tui.js";
+const VIEW = 8;
+export class CapabilityPicker {
+    src;
+    o;
+    get label() { return this.o.label; }
+    query = "";
+    selected;
+    i = 0;
+    top = 0;
+    mode = "search";
+    category = null;
+    catIndex = 0;
+    flash = null;
+    seenSuggestions = new Set();
+    constructor(src, o) {
+        this.src = src;
+        this.o = o;
+        this.selected = [...(o.initial ?? [])];
+        this.absorbSuggestions();
+    }
+    /** New suggestions are pre-ticked once; unticking one sticks. */
+    absorbSuggestions() {
+        for (const s of this.src.suggestions()) {
+            if (this.seenSuggestions.has(s.id))
+                continue;
+            this.seenSuggestions.add(s.id);
+            if (!this.selected.includes(s.id))
+                this.selected.push(s.id);
+        }
+    }
+    off;
+    attach(redraw) { this.off = this.src.onChange(() => { this.absorbSuggestions(); redraw(); }); }
+    detach() { if (this.off)
+        this.off(); }
+    capOf(id) { return this.src.vocabulary().capabilities.find((c) => c.id === id); }
+    uses(id) { return this.src.usage()[id] ?? 0; }
+    rows() {
+        const vocab = this.src.vocabulary();
+        const usage = this.src.usage();
+        if (this.mode === "categories") {
+            return vocab.categories.map((c) => ({ kind: "category", id: c.id, label: c.label, count: vocab.capabilities.filter((x) => x.category === c.id && !x.deprecated).length }));
+        }
+        if (this.mode === "category") {
+            return vocab.capabilities.filter((c) => c.category === this.category && !c.deprecated).sort((a, b) => (usage[b.id] ?? 0) - (usage[a.id] ?? 0)).map((cap) => ({ kind: "cap", cap }));
+        }
+        const q = this.query.trim();
+        if (!q) {
+            const sugg = this.src.suggestions();
+            const rows = [];
+            if (sugg.length) {
+                rows.push({ kind: "heading", text: "Suggested from your agent's own description" });
+                for (const s of sugg) {
+                    const cap = this.capOf(s.id);
+                    if (cap)
+                        rows.push({ kind: "cap", cap, from: s.from });
+                }
+            }
+            const others = this.selected.filter((id) => !sugg.some((s) => s.id === id));
+            if (others.length) {
+                rows.push({ kind: "heading", text: "Selected" });
+                for (const id of others) {
+                    const cap = this.capOf(id);
+                    rows.push(cap ? { kind: "cap", cap } : { kind: "custom", id });
+                }
+            }
+            rows.push({ kind: "heading", text: "Most used" });
+            const shown = new Set(rows.flatMap((r) => (r.kind === "cap" ? [r.cap.id] : [])));
+            for (const r of rankCapabilities("", { vocabulary: vocab, usage }))
+                if (!shown.has(r.capability.id))
+                    rows.push({ kind: "cap", cap: r.capability });
+            return rows;
+        }
+        const ranked = rankCapabilities(q, { vocabulary: vocab, usage });
+        const rows = ranked.map((r) => ({ kind: "cap", cap: r.capability }));
+        const id = toCapabilityId(q);
+        const exact = ranked.some((r) => r.capability.id === id);
+        if (id && !exact) {
+            const near = nearestCapability(id, vocab);
+            if (near && !ranked.slice(0, 3).some((r) => r.capability.id === near.id))
+                rows.unshift({ kind: "cap", cap: near, from: [`did you mean ${near.id}?`] });
+            rows.push({ kind: "custom", id, known: near ?? undefined });
+        }
+        return rows;
+    }
+    selectable = (r) => r.kind !== "heading";
+    clampCursor(rows) {
+        if (!rows.length) {
+            this.i = 0;
+            return;
+        }
+        this.i = Math.max(0, Math.min(this.i, rows.length - 1));
+        if (!this.selectable(rows[this.i])) {
+            const next = rows.findIndex((r, k) => k > this.i && this.selectable(r));
+            this.i = next >= 0 ? next : rows.findIndex(this.selectable);
+        }
+        if (this.i < this.top)
+            this.top = this.i;
+        if (this.i >= this.top + VIEW)
+            this.top = this.i - VIEW + 1;
+        this.top = Math.max(0, Math.min(this.top, Math.max(0, rows.length - VIEW)));
+        if (this.top > 0 && rows[this.top - 1]?.kind === "heading" && this.i - (this.top - 1) < VIEW)
+            this.top--;
+    }
+    move(rows, d) {
+        let k = this.i;
+        for (let n = 0; n < rows.length; n++) {
+            k = (k + d + rows.length) % rows.length;
+            if (this.selectable(rows[k])) {
+                this.i = k;
+                return;
+            }
+        }
+    }
+    toggle(id) {
+        const at = this.selected.indexOf(id);
+        if (at >= 0)
+            this.selected.splice(at, 1);
+        else
+            this.selected.push(id);
+    }
+    topMatch() {
+        const q = this.query.trim();
+        return q ? rankCapabilities(q, { vocabulary: this.src.vocabulary(), usage: this.src.usage(), limit: 1 })[0]?.capability : undefined;
+    }
+    render() {
+        const rows = this.rows();
+        this.clampCursor(rows);
+        const vocab = this.src.vocabulary();
+        const lines = [];
+        const where = this.mode === "categories" ? style.dim("  · categories") : this.mode === "category" ? style.dim(`  · ${vocab.categories.find((c) => c.id === this.category)?.label ?? ""}`) : "";
+        lines.push(`${style.cyan("?")} ${style.bold(this.o.label)}  Choose what your agent can do${where}`);
+        // Input line: the instruction sits in the field until you type; then the top match completes dimly after the cursor.
+        const tm = this.topMatch();
+        let field;
+        if (this.mode !== "search")
+            field = style.dim("← back to search");
+        else if (!this.query)
+            field = style.dim("Search capabilities");
+        else
+            field = this.query + (tm && tm.id.startsWith(this.query.toLowerCase()) && tm.id.length > this.query.length ? style.dim(tm.id.slice(this.query.length)) : "");
+        lines.push("› " + field);
+        const cursorCol = 2 + (this.mode === "search" ? this.query.length : 0);
+        const view = rows.slice(this.top, this.top + VIEW);
+        if (this.top > 0)
+            lines.push(style.dim(`   ↑ ${this.top} more`));
+        view.forEach((r, k) => {
+            const idx = this.top + k;
+            const on = idx === this.i;
+            const ptr = on ? style.cyan("❯") : " ";
+            if (r.kind === "heading") {
+                lines.push(" " + style.dim(r.text));
+                return;
+            }
+            if (r.kind === "category") {
+                lines.push(`${ptr} ${on ? style.bold(r.label) : r.label} ${style.dim(`(${r.count})`)}  ${style.dim("→")}`);
+                return;
+            }
+            if (r.kind === "custom") {
+                const sel = this.selected.includes(r.id);
+                lines.push(`${ptr} ${sel ? style.green("[x]") : "[ ]"} ${on ? style.bold(r.id) : r.id}  ${style.yellow("custom")}${sel ? "" : style.dim("  Enter adds it as your own capability")}`);
+                return;
+            }
+            const sel = this.selected.includes(r.cap.id);
+            const n = this.uses(r.cap.id);
+            const from = r.from?.length ? style.dim(`  ← ${r.from.slice(0, 2).join(", ")}${r.from.length > 2 ? "…" : ""}`) : "";
+            lines.push(`${ptr} ${sel ? style.green("[x]") : "[ ]"} ${on ? style.bold(r.cap.id.padEnd(22)) : r.cap.id.padEnd(22)} ${style.dim(n ? `${n} agent${n === 1 ? "" : "s"}` : "")}${from}`);
+        });
+        const below = rows.length - (this.top + VIEW);
+        if (below > 0)
+            lines.push(style.dim(`   ↓ ${below} more`));
+        if (!rows.length)
+            lines.push(style.dim("   no matches"));
+        // Detail of the highlighted row, on its own line so the list never has to cram it.
+        const cur = rows[this.i];
+        if (cur?.kind === "cap")
+            lines.push(`  ${style.bold(cur.cap.label)}: ${cur.cap.description} ${style.dim(`· ${vocab.categories.find((c) => c.id === cur.cap.category)?.label ?? cur.cap.category}`)}`);
+        else if (cur?.kind === "custom")
+            lines.push(`  ${style.yellow("custom")}: not in the shared list. Other agents searching for it won't find it unless they use the same id.${cur.known ? ` Closest shared term: ${cur.known.id}.` : ""}`);
+        else if (cur?.kind === "category")
+            lines.push(`  ${vocab.categories.find((c) => c.id === cur.id)?.description ?? ""}`);
+        else
+            lines.push("");
+        lines.push(`  ${style.dim("Selected:")} ${this.selected.length ? style.cyan(this.selected.join(", ")) : style.dim("none yet")}${this.flash ? "  " + style.green(this.flash) : ""}`);
+        const hint = this.mode !== "search"
+            ? "↑/↓ move · Space or Enter toggles · ← categories · Esc search · j back · ; skip"
+            : this.query
+                ? "↑/↓ move · Enter toggles the highlighted row · Tab completes · Esc clears · ^Y copies the id"
+                : "type to search · ↑/↓ move · Space toggles · → categories · Enter when done · ^Y copy id · j back · ; skip";
+        lines.push(style.dim("  " + hint));
+        return { lines, cursor: { row: 1, col: cursorCol } };
+    }
+    onKey(str, key) {
+        this.flash = null;
+        if (!this.query && !key.ctrl && !key.meta) {
+            if (str === "j")
+                return { done: BACK };
+            if (str === ";")
+                return { done: SKIP };
+        }
+        const rows = this.rows();
+        this.clampCursor(rows);
+        const cur = rows[this.i];
+        const idOf = (r) => (r?.kind === "cap" ? r.cap.id : r?.kind === "custom" ? r.id : null);
+        if (key.ctrl && key.name === "y") {
+            const id = idOf(cur);
+            if (id) {
+                copyToClipboard(id);
+                this.flash = `copied ${id}`;
+            }
+            return;
+        }
+        if (key.name === "up")
+            return this.move(rows, -1);
+        if (key.name === "down")
+            return this.move(rows, 1);
+        if (key.name === "pageup") {
+            this.i = Math.max(0, this.i - VIEW);
+            return;
+        }
+        if (key.name === "pagedown") {
+            this.i = Math.min(rows.length - 1, this.i + VIEW);
+            return;
+        }
+        if (this.mode === "categories") {
+            if (key.name === "escape" || key.name === "left") {
+                this.mode = "search";
+                this.i = 0;
+                this.top = 0;
+                return;
+            }
+            if ((key.name === "return" || key.name === "right") && cur?.kind === "category") {
+                this.catIndex = this.i;
+                this.category = cur.id;
+                this.mode = "category";
+                this.i = 0;
+                this.top = 0;
+            }
+            return;
+        }
+        if (this.mode === "category") {
+            if (key.name === "left") {
+                this.mode = "categories";
+                this.i = this.catIndex;
+                this.top = 0;
+                return;
+            }
+            if (key.name === "escape") {
+                this.mode = "search";
+                this.i = 0;
+                this.top = 0;
+                return;
+            }
+            if (key.name === "space" || str === " " || key.name === "return") {
+                const id = idOf(cur);
+                if (id)
+                    this.toggle(id);
+            }
+            return;
+        }
+        // search mode
+        if (key.name === "escape") {
+            this.query = "";
+            this.i = 0;
+            this.top = 0;
+            return;
+        }
+        if (key.name === "right" && !this.query) {
+            this.mode = "categories";
+            this.i = 0;
+            this.top = 0;
+            return;
+        }
+        if (key.name === "tab") {
+            const tm = this.topMatch();
+            if (tm)
+                this.query = tm.id;
+            this.i = 0;
+            return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+            if (!this.query.trim())
+                return { done: [...this.selected] };
+            const id = idOf(cur);
+            if (id) {
+                this.toggle(id);
+                this.flash = this.selected.includes(id) ? `added ${id}` : `removed ${id}`;
+            }
+            this.query = "";
+            this.i = 0;
+            this.top = 0;
+            return;
+        }
+        if ((key.name === "space" || str === " ") && !this.query) {
+            const id = idOf(cur);
+            if (id)
+                this.toggle(id);
+            return;
+        }
+        if (key.name === "backspace") {
+            this.query = this.query.slice(0, -1);
+            this.i = 0;
+            this.top = 0;
+            return;
+        }
+        if (key.ctrl && key.name === "u") {
+            this.query = "";
+            this.i = 0;
+            this.top = 0;
+            return;
+        }
+        if (str && !key.ctrl && !key.meta && !/[\x00-\x1f\x7f]/.test(str)) {
+            this.query += str;
+            this.i = 0;
+            this.top = 0;
+        }
+    }
+    summary(v) {
+        if (!Array.isArray(v))
+            return "";
+        return `${style.green("✔")} ${style.bold(this.o.label)} ${v.length ? style.cyan(v.join(", ")) : style.dim("(none)")}`;
+    }
+}

package/dist/probe.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Read what an agent says about itself (RATIONALE R-3): an MCP server's name, instructions and tools over Streamable
+ * HTTP, or an A2A agent card's description and skills. Read-only, short timeouts, and only for endpoints the user
+ * just entered. The result feeds the description prefill and the capability suggestions.
+ */
+export interface SelfDescription {
+    protocol: string;
+    url: string;
+    live: boolean;
+    name?: string;
+    description?: string;
+    items: {
+        kind: "tool" | "skill";
+        name: string;
+        description?: string;
+        tags?: string[];
+        inputSchema?: unknown;
+    }[];
+    error?: string;
+}
+export declare function probeMcp(url: string, fetchImpl?: typeof fetch): Promise<SelfDescription>;
+export declare function probeA2a(url: string, fetchImpl?: typeof fetch): Promise<SelfDescription>;
+export declare function probeHttp(url: string, fetchImpl?: typeof fetch): Promise<SelfDescription>;
+export declare function probe(protocol: string, url: string, fetchImpl?: typeof fetch): Promise<SelfDescription>;

package/dist/probe.js

@@ -0,0 +1,105 @@
+/**
+ * Read what an agent says about itself (RATIONALE R-3): an MCP server's name, instructions and tools over Streamable
+ * HTTP, or an A2A agent card's description and skills. Read-only, short timeouts, and only for endpoints the user
+ * just entered. The result feeds the description prefill and the capability suggestions.
+ */
+const TIMEOUT = 8000;
+async function rpc(url, body, session, fetchImpl) {
+    const headers = { "content-type": "application/json", accept: "application/json, text/event-stream", "mcp-protocol-version": "2025-06-18" };
+    if (session)
+        headers["mcp-session-id"] = session;
+    const r = await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body), signal: AbortSignal.timeout(TIMEOUT) });
+    const sid = r.headers.get("mcp-session-id") ?? session;
+    if (!r.ok)
+        throw new Error(`HTTP ${r.status}`);
+    const type = r.headers.get("content-type") ?? "";
+    const text = await r.text();
+    let msg;
+    if (type.includes("text/event-stream")) {
+        const data = text.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).filter(Boolean);
+        msg = data.map((d) => { try {
+            return JSON.parse(d);
+        }
+        catch {
+            return null;
+        } }).find((m) => m && "id" in m && m.id === body.id);
+    }
+    else
+        msg = text ? JSON.parse(text) : null;
+    if (!msg)
+        throw new Error("no JSON-RPC response");
+    if (msg.error)
+        throw new Error(msg.error.message ?? "JSON-RPC error");
+    return { result: msg.result, session: sid };
+}
+export async function probeMcp(url, fetchImpl = fetch) {
+    try {
+        const init = await rpc(url, { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "agt-cli", version: "0" } } }, null, fetchImpl);
+        const headers = { "content-type": "application/json", accept: "application/json, text/event-stream" };
+        if (init.session)
+            headers["mcp-session-id"] = init.session;
+        await fetchImpl(url, { method: "POST", headers, body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }), signal: AbortSignal.timeout(TIMEOUT) }).then((r) => r.body?.cancel()).catch(() => { });
+        const tools = await rpc(url, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }, init.session, fetchImpl).catch(() => ({ result: { tools: [] } }));
+        const info = init.result?.serverInfo ?? {};
+        return {
+            protocol: "mcp", url, live: true,
+            name: info.title ?? info.name,
+            description: typeof init.result?.instructions === "string" ? firstSentence(init.result.instructions) : info.description,
+            items: (tools.result?.tools ?? []).map((t) => ({ kind: "tool", name: String(t.name), description: t.description, inputSchema: t.inputSchema })),
+        };
+    }
+    catch (e) {
+        return { protocol: "mcp", url, live: false, items: [], error: e.message };
+    }
+}
+export async function probeA2a(url, fetchImpl = fetch) {
+    let origin;
+    try {
+        origin = new URL(url).origin;
+    }
+    catch {
+        return { protocol: "a2a", url, live: false, items: [], error: "not a URL" };
+    }
+    const candidates = url.endsWith(".json") ? [url] : [`${origin}/.well-known/agent-card.json`, `${origin}/.well-known/agent.json`];
+    let lastError = "no agent card";
+    for (const c of candidates) {
+        try {
+            const r = await fetchImpl(c, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(TIMEOUT) });
+            if (!r.ok) {
+                lastError = `HTTP ${r.status}`;
+                continue;
+            }
+            const card = await r.json();
+            return {
+                protocol: "a2a", url, live: true, name: card.name, description: card.description,
+                items: (card.skills ?? []).map((s) => ({ kind: "skill", name: String(s.name ?? s.id), description: s.description, tags: Array.isArray(s.tags) ? s.tags : undefined })),
+            };
+        }
+        catch (e) {
+            lastError = e.message;
+        }
+    }
+    return { protocol: "a2a", url, live: false, items: [], error: lastError };
+}
+export async function probeHttp(url, fetchImpl = fetch) {
+    try {
+        const r = await fetchImpl(url, { signal: AbortSignal.timeout(TIMEOUT) });
+        await r.body?.cancel().catch(() => { });
+        return { protocol: "http", url, live: r.status < 500, items: [], error: r.status < 500 ? undefined : `HTTP ${r.status}` };
+    }
+    catch (e) {
+        return { protocol: "http", url, live: false, items: [], error: e.message };
+    }
+}
+export function probe(protocol, url, fetchImpl = fetch) {
+    if (protocol === "mcp")
+        return probeMcp(url, fetchImpl);
+    if (protocol === "a2a")
+        return probeA2a(url, fetchImpl);
+    return probeHttp(url, fetchImpl);
+}
+function firstSentence(s) {
+    const t = s.trim().split(/\r?\n/)[0];
+    const m = /^(.{20,200}?[.!?])(\s|$)/.exec(t);
+    return (m ? m[1] : t).slice(0, 200);
+}

package/dist/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function promptHidden(question: string): Promise<string>;
+export declare function confirm(question: string): Promise<boolean>;

package/dist/prompt.js

@@ -0,0 +1,45 @@
+/** Terminal prompts. Hidden input needs a TTY; without one the caller must pass the value through the environment. */
+import { createInterface } from "node:readline";
+export function promptHidden(question) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return Promise.reject(new Error(`${question.trim()} needs an interactive terminal; set the value in the environment instead`));
+    return new Promise((resolve, reject) => {
+        process.stderr.write(question);
+        let value = "";
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        const done = (err) => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+            process.stderr.write("\n");
+            if (err)
+                reject(err);
+            else
+                resolve(value);
+        };
+        const onData = (chunk) => {
+            for (const ch of chunk) {
+                if (ch === "\r" || ch === "\n")
+                    return done();
+                if (ch === "\u0003")
+                    return done(new Error("cancelled"));
+                if (ch === "\u007f" || ch === "\b") {
+                    value = value.slice(0, -1);
+                    continue;
+                }
+                if (ch >= " ")
+                    value += ch;
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+export function confirm(question) {
+    if (!process.stdin.isTTY)
+        return Promise.resolve(false);
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => rl.question(`${question} [y/N] `, (a) => { rl.close(); resolve(/^y(es)?$/i.test(a.trim())); }));
+}

package/dist/register.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Register: the site signs an EIP-712 quote (the controller only accepts quotes from its quote signer), the buyer
+ * approves the USDC amount and calls AGTController.register(quote, sig) from their own wallet. Same flow as the
+ * browser checkout (site: src/lib/migration-client.ts registerWithQuote). The quote binds label, recipient, token,
+ * price and term, and expires (about 15 minutes), so approve and register go out back to back.
+ */
+import { type Address, type Hex, type PublicClient } from "viem";
+import type { Network } from "./config.js";
+import type { TxRequest } from "./signer.js";
+export interface SignedQuote {
+    chainId: number;
+    controller: Address;
+    currency: "USDC" | "native";
+    usd?: number;
+    years?: number;
+    quote: {
+        label: string;
+        to: Address;
+        payToken: Address;
+        price: string;
+        duration: string;
+        validUntil: string;
+        nonce: Hex;
+    };
+    signature: Hex;
+}
+export interface Quote {
+    label: string;
+    to: Address;
+    payToken: Address;
+    price: bigint;
+    duration: bigint;
+    validUntil: bigint;
+    nonce: Hex;
+}
+export declare function fetchQuote(site: string, body: {
+    label: string;
+    to: Address;
+    years: number;
+    payToken: "usdc";
+}, fetchImpl?: typeof fetch): Promise<SignedQuote>;
+/** Everything the quote binds must match what was asked for and the network we are on; otherwise refuse to pay. */
+export declare function checkQuote(q: SignedQuote, want: {
+    label: string;
+    to: Address;
+}, n: Network, nowSec?: number): Quote;
+export declare const usdc: (units: bigint) => string;
+export interface RegisterPlan {
+    quote: Quote;
+    signature: Hex;
+    balance: bigint;
+    allowance: bigint;
+    txs: TxRequest[];
+}
+export declare function planRegister(pc: PublicClient, n: Network, q: SignedQuote, quote: Quote, payer: Address): Promise<RegisterPlan>;

package/dist/register.js

@@ -0,0 +1,54 @@
+/**
+ * Register: the site signs an EIP-712 quote (the controller only accepts quotes from its quote signer), the buyer
+ * approves the USDC amount and calls AGTController.register(quote, sig) from their own wallet. Same flow as the
+ * browser checkout (site: src/lib/migration-client.ts registerWithQuote). The quote binds label, recipient, token,
+ * price and term, and expires (about 15 minutes), so approve and register go out back to back.
+ */
+import { encodeFunctionData, formatUnits, getAddress, zeroAddress } from "viem";
+import { controllerAbi, erc20Abi } from "./abi.js";
+export async function fetchQuote(site, body, fetchImpl = fetch) {
+    const r = await fetchImpl(`${site}/api/v2/quote`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    const j = (await r.json().catch(() => ({})));
+    if (!r.ok)
+        throw new Error(`quote refused (${r.status}): ${j.error ?? "no reason given"}`);
+    return j;
+}
+/** Everything the quote binds must match what was asked for and the network we are on; otherwise refuse to pay. */
+export function checkQuote(q, want, n, nowSec = Math.floor(Date.now() / 1000)) {
+    if (q.chainId !== n.chainId)
+        throw new Error(`the quote is for chain ${q.chainId}, not ${n.name} (${n.chainId})`);
+    if (getAddress(q.controller) !== getAddress(n.controller))
+        throw new Error(`the quote names controller ${q.controller}, expected ${n.controller}`);
+    if (q.quote.label !== want.label)
+        throw new Error(`the quote is for ${q.quote.label}.agt, not ${want.label}.agt`);
+    if (getAddress(q.quote.to) !== getAddress(want.to))
+        throw new Error(`the quote mints to ${q.quote.to}, not ${want.to}`);
+    if (q.currency !== "USDC" || getAddress(q.quote.payToken) !== getAddress(n.usdc))
+        throw new Error(`the quote asks for ${q.currency} at ${q.quote.payToken}; the CLI pays in USDC (${n.usdc})`);
+    const quote = { ...q.quote, price: BigInt(q.quote.price), duration: BigInt(q.quote.duration), validUntil: BigInt(q.quote.validUntil) };
+    if (quote.validUntil <= BigInt(nowSec + 60))
+        throw new Error("the quote expires in under a minute; run the command again");
+    return quote;
+}
+export const usdc = (units) => `${formatUnits(units, 6)} USDC`;
+export async function planRegister(pc, n, q, quote, payer) {
+    const [balance, allowance] = await Promise.all([
+        pc.readContract({ address: n.usdc, abi: erc20Abi, functionName: "balanceOf", args: [payer] }),
+        pc.readContract({ address: n.usdc, abi: erc20Abi, functionName: "allowance", args: [payer, n.controller] }),
+    ]);
+    const years = Number(quote.duration / (365n * 86400n));
+    const txs = [];
+    if (allowance < quote.price)
+        txs.push({
+            to: n.usdc,
+            data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [n.controller, quote.price] }),
+            description: `Approve ${usdc(quote.price)} for the .agt controller`,
+        });
+    txs.push({
+        to: n.controller,
+        data: encodeFunctionData({ abi: controllerAbi, functionName: "register", args: [quote, q.signature] }),
+        value: quote.payToken === zeroAddress ? quote.price : 0n,
+        description: `Register ${quote.label}.agt for ${years} year${years === 1 ? "" : "s"} (${usdc(quote.price)}) to ${quote.to}`,
+    });
+    return { quote, signature: q.signature, balance, allowance, txs };
+}