@agtnames/cli 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+/**
+ * agt — register a .agt name, publish its signed manifest, set its records and verify it, from a terminal.
+ *
+ *   agt available <name>
+ *   agt register <name> [--years N] [--to 0x…] [--dry-run] [--yes]
+ *   agt manifest init [name] [--out file.json] [--no-probe] [--shell bash|powershell] [--template]
+ *   agt manifest publish <name> <file.json> [--host agts.dev|ipfs] [--no-records] [--skip-live-check] [--dry-run]
+ *   agt records set <name> [--mcp URL] [--a2a URL] [--http URL] [--ws URL] [--wallet 0x…] [--addr 0x…] [--manifest URI] [--dry-run]
+ *   agt verify <name> [--no-endpoints] [--json]
+ *   agt keyfile create <file>        encrypt a private key into a keyfile (prompts for the key and a passphrase)
+ *   agt keyfile address <file>       print the keyfile's address (no passphrase needed)
+ *
+ * Signing (writes only):
+ *   default                  opens a local page; approve each request in MetaMask (the key never leaves the wallet)
+ *   --signer key             key from AGT_OWNER_KEY, or from the variable --key-env names
+ *   --keyfile <file>         key from an encrypted keyfile; passphrase from AGT_KEYFILE_PASSPHRASE or a prompt
+ *   --no-open                print the wallet page URL instead of opening a browser
+ *
+ * Network: --network polygon|amoy (AGT_NETWORK, default polygon), --rpc URL (AGT_RPC_URL), --site URL (AGT_SITE,
+ * default https://agtnames.com; required on amoy). --dry-run on any write signs what needs signing, prints the exact
+ * document and transactions, and sends nothing. --json prints the result as JSON on stdout.
+ *
+ * Exit codes: 0 done, 1 failed (or verify found problems), 2 usage error.
+ */
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { parseAddressFlag, parseArgs, parseHttpsFlag, parseYears, UsageError } from "./args.js";
+import { browserSigner } from "./browser.js";
+import { resolverAbi } from "./abi.js";
+import { assertOwner, describePlan, dryTx, multicallTx, nameState, nodeOf, normalizeLabel, publicClient, recordCalls, sendAndWait } from "./chain.js";
+import { networkFrom, requireSite } from "./config.js";
+import { decryptKey, encryptKey, readKeyfile, writeKeyfile } from "./keyfile.js";
+import { buildManifest, hostManifest, lintInput, MANIFEST_TEMPLATE, signManifestWith } from "./manifest.js";
+import { detectShell, interactiveInit } from "./init.js";
+import { confirm, promptHidden } from "./prompt.js";
+import { CancelledError, isInteractive } from "./tui.js";
+import { checkQuote, fetchQuote, planRegister, usdc } from "./register.js";
+import { keySigner, parsePrivateKey } from "./signer.js";
+import { checkEndpoint, verifyName } from "./verify.js";
+const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+function help() {
+    const src = readFileSync(new URL(import.meta.url), "utf8");
+    return src.slice(src.indexOf("/**") + 3, src.indexOf("*/")).replace(/^ \* ?/gm, "").trim();
+}
+async function signerFor(c) {
+    const f = c.args.flags;
+    const kind = f.keyfile ? "keyfile" : f["key-env"] ? "key" : (f.signer ?? "browser");
+    if (kind === "key") {
+        const v = f["key-env"] ?? "AGT_OWNER_KEY";
+        return keySigner(parsePrivateKey(process.env[v], v), c.net);
+    }
+    if (kind === "keyfile") {
+        if (!f.keyfile)
+            throw new UsageError("--signer keyfile needs --keyfile <file>");
+        const e = readKeyfile(f.keyfile);
+        const pass = process.env.AGT_KEYFILE_PASSPHRASE ?? await promptHidden(`Passphrase for ${f.keyfile} (${e.address}): `);
+        const s = keySigner(decryptKey(e, pass), c.net, "keyfile");
+        if (s.address.toLowerCase() !== e.address.toLowerCase())
+            throw new Error("the keyfile's stored address does not match its key; the file was edited");
+        return s;
+    }
+    if (kind !== "browser")
+        throw new UsageError("--signer must be browser, key or keyfile");
+    const noOpen = c.args.bools.has("no-open");
+    const timeout = f.timeout ? Number(f.timeout) * 60_000 : undefined;
+    c.log(`Opening the wallet page${noOpen ? "" : " in your browser"}. Keep it open until the command finishes.`);
+    const s = await browserSigner({ network: c.net, timeoutMs: timeout, open: noOpen ? () => { } : undefined, onUrl: (u) => c.log(`  ${u}`) });
+    c.log(`Connected: ${s.address}`);
+    return s;
+}
+async function withSigner(c, fn) {
+    const s = await signerFor(c);
+    try {
+        return await fn(s);
+    }
+    finally {
+        await s.close();
+    }
+}
+const labelArg = (c, i, what = "name") => {
+    const v = c.args.positionals[i];
+    if (!v)
+        throw new UsageError(`missing <${what}>`);
+    return normalizeLabel(v);
+};
+// ── available ─────────────────────────────────────────────────────────────────────────────────────────────────────
+async function available(c) {
+    const label = labelArg(c, 1);
+    const site = requireSite(c.net);
+    const r = await fetch(`${site}/api/search?name=${encodeURIComponent(label)}`);
+    const j = (await r.json().catch(() => ({})));
+    if (!r.ok || !j.success)
+        throw new Error(`lookup failed (${r.status}): ${j.error ?? "no reason given"}`);
+    const human = j.available
+        ? [`${label}.agt is available: $${j.registerUsd} for the first year, $${j.renewUsd}/year after.`, `Register it with: agt register ${label}`]
+        : [`${label}.agt is not available (${j.reserved ? "reserved" : j.status ?? "taken"}).`];
+    if (j.available && j.registrationOpen === false)
+        human.push("Registration is not open yet.");
+    c.out({ name: `${label}.agt`, available: !!j.available, status: j.status, tier: j.tier, registerUsd: j.registerUsd, renewUsd: j.renewUsd, registrationOpen: j.registrationOpen }, human);
+}
+// ── register ──────────────────────────────────────────────────────────────────────────────────────────────────────
+async function register(c) {
+    const label = labelArg(c, 1);
+    const years = parseYears(c.args.flags.years);
+    const toFlag = parseAddressFlag(c.args.flags.to, "to");
+    const site = requireSite(c.net);
+    const pc = publicClient(c.net);
+    await withSigner(c, async (s) => {
+        const to = (toFlag ?? s.address);
+        const gift = to.toLowerCase() !== s.address.toLowerCase();
+        c.log(`Getting a quote for ${label}.agt (${years} year${years === 1 ? "" : "s"})…`);
+        const q = await fetchQuote(site, { label, to, years, payToken: "usdc" });
+        const quote = checkQuote(q, { label, to }, c.net);
+        const plan = await planRegister(pc, c.net, q, quote, s.address);
+        const mins = Math.max(0, Math.floor((Number(quote.validUntil) - Date.now() / 1000) / 60));
+        c.log(`Price ${usdc(quote.price)}. Your USDC balance: ${usdc(plan.balance)}. The quote is good for about ${mins} minutes.`);
+        if (gift)
+            c.log(`Note: ${label}.agt will be owned by ${to}, not you. Only that wallet can publish its manifest or set its records.`);
+        if (c.dry) {
+            c.out({ dryRun: true, quote: q, transactions: plan.txs.map((t) => dryTx(t, s.address)) }, ["Dry run: nothing sent. Transactions:", ...plan.txs.map((t) => `  ${t.description}`)]);
+            return;
+        }
+        if (plan.balance < quote.price)
+            throw new Error(`not enough USDC: need ${usdc(quote.price)}, have ${usdc(plan.balance)} (USDC on ${c.net.chain.name}, ${c.net.usdc})`);
+        const gas = await pc.getBalance({ address: s.address });
+        if (gas === 0n)
+            throw new Error(`${s.address} has no ${c.net.chain.nativeCurrency.symbol} for gas`);
+        if (s.kind !== "browser" && !c.args.bools.has("yes") && !(await confirm(`Send ${plan.txs.length} transaction${plan.txs.length === 1 ? "" : "s"} from ${s.address}?`)))
+            throw new Error("cancelled");
+        const hashes = [];
+        for (const tx of plan.txs)
+            hashes.push(await sendAndWait(pc, c.net, s, tx, c.log));
+        const after = await nameState(pc, c.net, label);
+        if (after.owner?.toLowerCase() !== to.toLowerCase())
+            throw new Error(`registered, but ${label}.agt reads as owned by ${after.owner ?? "nobody"}; check ${hashes.at(-1)}`);
+        c.out({ name: `${label}.agt`, owner: after.owner, transactions: hashes }, [
+            `✓ ${label}.agt is registered to ${after.owner}.`,
+            ...(gift ? [] : [`Next: agt manifest init ${label}   then   agt manifest publish ${label} ${label}.manifest.json`]),
+        ]);
+    });
+}
+// ── manifest init / publish ───────────────────────────────────────────────────────────────────────────────────────
+async function manifestInit(c) {
+    const interactive = isInteractive() && !c.args.bools.has("template") && !c.json;
+    if (interactive) {
+        const shell = c.args.flags.shell ?? detectShell();
+        if (shell !== "bash" && shell !== "powershell")
+            throw new UsageError("--shell must be bash or powershell");
+        const v = c.args.positionals[2];
+        await interactiveInit({ label: v, out: c.args.flags.out, network: c.net, probe: !c.args.bools.has("no-probe"), shell, log: c.log });
+        return;
+    }
+    const label = labelArg(c, 2);
+    const file = c.args.flags.out ?? `${label}.manifest.json`;
+    if (existsSync(file))
+        throw new Error(`${file} already exists`);
+    writeFileSync(file, JSON.stringify(MANIFEST_TEMPLATE, null, 2) + "\n");
+    c.out({ file }, [`Wrote ${file}. Fill in the description and endpoints, then run:`, `  agt manifest publish ${label} ${file}`]);
+}
+async function manifestPublish(c) {
+    const label = labelArg(c, 2);
+    const file = c.args.positionals[3];
+    if (!file)
+        throw new UsageError("missing <file.json> (create one with `agt manifest init`)");
+    const host = (c.args.flags.host ?? "agts.dev");
+    if (host !== "agts.dev" && host !== "ipfs")
+        throw new UsageError("--host must be agts.dev or ipfs");
+    let input;
+    try {
+        input = JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch (e) {
+        throw new Error(`could not read ${file}: ${e.message}`);
+    }
+    const problems = lintInput(input);
+    if (problems.length)
+        throw new Error(`fix ${file} first:\n  - ${problems.join("\n  - ")}`);
+    const site = requireSite(c.net);
+    const pc = publicClient(c.net);
+    if (!c.args.bools.has("skip-live-check")) {
+        const checks = await Promise.all((input.endpoints ?? []).map((e) => checkEndpoint(e.protocol, e.url)));
+        const dead = checks.filter((x) => !x.live);
+        if (dead.length)
+            throw new Error(`these endpoints are not reachable yet, so the manifest would point at nothing:\n  - ${dead.map((d) => `${d.protocol} ${d.url} (${d.error})`).join("\n  - ")}\nDeploy them first, or pass --skip-live-check to publish anyway.`);
+    }
+    await withSigner(c, async (s) => {
+        const state = await nameState(pc, c.net, label);
+        const resolver = assertOwner(state, s.address);
+        const signed = await signManifestWith(s, buildManifest(label, s.address, input));
+        const wallet = (signed.payments ?? []).find((p) => p.address)?.address;
+        const plan = { endpoints: (signed.endpoints ?? []).map((e) => ({ protocol: e.protocol, url: e.url })), addr: s.address, wallet };
+        const current = await pc.readContract({ address: resolver, abi: resolverAbi, functionName: "agentManifest", args: [nodeOf(label)] }).catch(() => "");
+        if (c.dry) {
+            const predicted = host === "agts.dev" ? `https://agts.dev/${label}.json` : "(the ipfs:// URI returned by hosting)";
+            const calls = recordCalls(label, { ...plan, manifest: host === "agts.dev" ? predicted : undefined }, current);
+            c.out({ dryRun: true, manifest: signed, host, records: c.args.bools.has("no-records") ? null : dryTx(multicallTx(resolver, calls, "set records"), s.address) }, ["Dry run: signed, nothing hosted or sent.", JSON.stringify(signed, null, 2), ...(c.args.bools.has("no-records") ? [] : describePlan(label, { ...plan, manifest: predicted }, current))]);
+            return;
+        }
+        const pin = await hostManifest(site, signed, host);
+        c.log(`Hosted (${pin.provider}): ${pin.uri}`);
+        if (!c.args.bools.has("no-records")) {
+            const full = { ...plan, manifest: pin.uri };
+            describePlan(label, full, current).forEach((l) => c.log(l));
+            await sendAndWait(pc, c.net, s, multicallTx(resolver, recordCalls(label, full, current), `Set ${label}.agt records (manifest, endpoints, addr${wallet ? ", wallet" : ""})`), c.log);
+        }
+        const report = await verifyName(c.net, label);
+        c.out({ name: `${label}.agt`, uri: pin.uri, verify: report }, verifyLines(report));
+        if (!report.ok)
+            process.exitCode = 1;
+    });
+}
+// ── records set ───────────────────────────────────────────────────────────────────────────────────────────────────
+async function recordsSet(c) {
+    const label = labelArg(c, 2);
+    const f = c.args.flags;
+    const endpoints = ["mcp", "a2a", "http", "ws"].flatMap((p) => { const u = parseHttpsFlag(f[p], p); return u ? [{ protocol: p, url: u }] : []; });
+    const plan = { endpoints, wallet: parseAddressFlag(f.wallet, "wallet"), addr: parseAddressFlag(f.addr, "addr"), manifest: f.manifest };
+    if (plan.manifest && !/^(https|ipfs):\/\//.test(plan.manifest))
+        throw new UsageError("--manifest must be an https:// or ipfs:// URI");
+    if (!endpoints.length && !plan.wallet && !plan.addr && !plan.manifest)
+        throw new UsageError("nothing to set: pass --mcp, --a2a, --http, --ws, --wallet, --addr or --manifest");
+    const pc = publicClient(c.net);
+    await withSigner(c, async (s) => {
+        const resolver = assertOwner(await nameState(pc, c.net, label), s.address);
+        const current = plan.manifest ? await pc.readContract({ address: resolver, abi: resolverAbi, functionName: "agentManifest", args: [nodeOf(label)] }).catch(() => "") : "";
+        const calls = recordCalls(label, plan, current);
+        const tx = multicallTx(resolver, calls, `Set ${calls.length} record${calls.length === 1 ? "" : "s"} on ${label}.agt`);
+        const lines = describePlan(label, plan, current);
+        if (c.dry) {
+            c.out({ dryRun: true, transaction: dryTx(tx, s.address) }, ["Dry run: nothing sent.", ...lines]);
+            return;
+        }
+        if (!calls.length) {
+            c.out({ name: `${label}.agt`, changed: 0 }, ["Nothing to change."]);
+            return;
+        }
+        lines.forEach((l) => c.log(l));
+        const hash = await sendAndWait(pc, c.net, s, tx, c.log);
+        c.out({ name: `${label}.agt`, transaction: hash }, [`✓ ${calls.length} record${calls.length === 1 ? "" : "s"} set on ${label}.agt. Check it with: agt verify ${label}`]);
+    });
+}
+// ── verify ────────────────────────────────────────────────────────────────────────────────────────────────────────
+function verifyLines(r) {
+    return [
+        `${r.ok ? "✓" : "✗"} ${r.name}: manifest ${r.manifestStatus}${r.owner ? `, owner ${r.owner}` : ""}${r.signer ? `, signed by ${r.signer}` : ""}`,
+        ...(r.manifestUri ? [`  manifest ${r.manifestUri}`] : []),
+        ...r.endpoints.map((e) => `  ${e.live ? "live" : "DOWN"}  ${e.protocol} ${e.url}${e.live ? ` (${e.via} ${e.status})` : ` (${e.error})`}`),
+        ...r.problems.map((p) => `  problem: ${p}`),
+    ];
+}
+async function verify(c) {
+    const label = labelArg(c, 1);
+    const r = await verifyName(c.net, label, { skipEndpoints: c.args.bools.has("no-endpoints") });
+    c.out(r, verifyLines(r));
+    if (!r.ok)
+        process.exitCode = 1;
+}
+// ── keyfile ───────────────────────────────────────────────────────────────────────────────────────────────────────
+async function keyfile(c) {
+    const sub = c.args.positionals[1];
+    const file = c.args.positionals[2];
+    if (!file)
+        throw new UsageError(`missing <file>`);
+    if (sub === "address") {
+        const e = readKeyfile(file);
+        c.out({ file, address: e.address }, [e.address]);
+        return;
+    }
+    if (sub !== "create")
+        throw new UsageError("keyfile commands: create, address");
+    if (existsSync(file))
+        throw new Error(`${file} already exists`);
+    const pk = parsePrivateKey(await promptHidden("Private key (0x…, hidden): "), "the key you entered");
+    const pass = process.env.AGT_KEYFILE_PASSPHRASE ?? await promptHidden("New passphrase (12+ characters, hidden): ");
+    if (!process.env.AGT_KEYFILE_PASSPHRASE && (await promptHidden("Repeat the passphrase: ")) !== pass)
+        throw new Error("the passphrases do not match");
+    const e = encryptKey(pk, pass);
+    if (decryptKey(e, pass) !== pk.toLowerCase())
+        throw new Error("round-trip check failed; nothing written");
+    writeKeyfile(file, e);
+    c.out({ file, address: e.address }, [`Wrote ${file} for ${e.address}. Use it with --keyfile ${file}.`]);
+}
+// ── main ──────────────────────────────────────────────────────────────────────────────────────────────────────────
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.bools.has("version")) {
+        console.log(VERSION);
+        return;
+    }
+    const [cmd, sub] = args.positionals;
+    if (!cmd || args.bools.has("help") || cmd === "help") {
+        console.log(help());
+        return;
+    }
+    const json = args.bools.has("json");
+    const log = (s) => (json ? console.error(s) : console.log(s));
+    const out = (v, human) => { if (json)
+        console.log(JSON.stringify(v, (_, x) => (typeof x === "bigint" ? x.toString() : x), 2));
+    else
+        human.forEach((l) => console.log(l)); };
+    const c = { args, net: networkFrom(args.flags), json, dry: args.bools.has("dry-run"), log, out };
+    if (cmd === "available")
+        return available(c);
+    if (cmd === "register")
+        return register(c);
+    if (cmd === "verify")
+        return verify(c);
+    if (cmd === "keyfile")
+        return keyfile(c);
+    if (cmd === "manifest" && sub === "init")
+        return manifestInit(c);
+    if (cmd === "manifest" && sub === "publish")
+        return manifestPublish(c);
+    if (cmd === "records" && sub === "set")
+        return recordsSet(c);
+    throw new UsageError(`unknown command: ${args.positionals.slice(0, 2).join(" ")} (run agt --help)`);
+}
+main().catch((e) => {
+    if (e instanceof CancelledError) {
+        console.error("Stopped. Your answers so far are saved; run the same command to resume.");
+        process.exit(130);
+    }
+    const usage = e instanceof UsageError;
+    console.error(`agt: ${e instanceof Error ? e.message : String(e)}${usage ? "\nRun agt --help for usage." : ""}`);
+    process.exit(usage ? 2 : 1);
+});

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+import type { Address, Chain } from "viem";
+export type NetworkName = "polygon" | "amoy";
+export interface Network {
+    name: NetworkName;
+    chainId: number;
+    chain: Chain;
+    rpcUrls: string[];
+    registry: Address;
+    resolver: Address;
+    controller: Address;
+    usdc: Address;
+    /** Site that issues quotes and hosts manifests. Amoy has no public site: pass --site (e.g. a local `next dev`). */
+    site: string | null;
+    explorer: string;
+}
+export interface NetworkOverrides {
+    network?: string;
+    rpc?: string;
+    site?: string;
+}
+/** Flags win over the environment (AGT_NETWORK, AGT_RPC_URL, AGT_SITE), which wins over the defaults. */
+export declare function networkFrom(o: NetworkOverrides, env?: NodeJS.ProcessEnv): Network;
+export declare function requireSite(n: Network): string;
+export declare const txUrl: (n: Network, hash: string) => string;

package/dist/config.js

@@ -0,0 +1,48 @@
+/**
+ * Networks the CLI writes to. Registry and resolver come from @agtnames/resolver's CHAINS; the controller and USDC
+ * addresses are the deployed proxies (source of truth: the operator's `_internal/deployments/<network>.json`).
+ * `register` also takes the controller from the signed quote and refuses if the two disagree.
+ */
+import { CHAINS } from "@agtnames/resolver";
+import { polygon, polygonAmoy } from "viem/chains";
+const NETWORKS = {
+    polygon: {
+        name: "polygon",
+        chainId: 137,
+        chain: polygon,
+        registry: CHAINS.polygon.registry,
+        resolver: CHAINS.polygon.resolver,
+        controller: "0x875682c162eA6450b904d1A0AEe085cfb29b5C5C",
+        usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+        site: "https://agtnames.com",
+        explorer: "https://polygonscan.com",
+    },
+    amoy: {
+        name: "amoy",
+        chainId: 80002,
+        chain: polygonAmoy,
+        registry: CHAINS.amoy.registry,
+        resolver: CHAINS.amoy.resolver,
+        controller: "0xbDBC4e0E934Cf39F6B6585c964eC8436dFD98791",
+        usdc: "0xC8a4A34f1Ac295Fce267c4aCF0C5587e1061c9E4",
+        site: null,
+        explorer: "https://amoy.polygonscan.com",
+    },
+};
+/** Flags win over the environment (AGT_NETWORK, AGT_RPC_URL, AGT_SITE), which wins over the defaults. */
+export function networkFrom(o, env = process.env) {
+    const name = (o.network ?? env.AGT_NETWORK ?? "polygon").toLowerCase();
+    if (name !== "polygon" && name !== "amoy")
+        throw new Error(`unknown network "${name}" (use polygon or amoy)`);
+    const base = NETWORKS[name];
+    const rpc = o.rpc ?? env.AGT_RPC_URL;
+    const defaults = CHAINS[name].rpcUrls ?? [CHAINS[name].rpcUrl];
+    const site = (o.site ?? env.AGT_SITE ?? base.site)?.replace(/\/$/, "") ?? null;
+    return { ...base, rpcUrls: rpc ? [rpc] : [...defaults], site };
+}
+export function requireSite(n) {
+    if (!n.site)
+        throw new Error(`${n.name} has no public site: pass --site <url> (or set AGT_SITE) for quotes and manifest hosting`);
+    return n.site;
+}
+export const txUrl = (n, hash) => `${n.explorer}/tx/${hash}`;

package/dist/endpoints.d.ts

@@ -0,0 +1,42 @@
+import { type Frame, type Key, type Nav, type Widget } from "./tui.js";
+export interface EndpointRow {
+    protocol: string;
+    label: string;
+    /** Format shown in the empty input, e.g. "https://… (your MCP endpoint URL)". */
+    format: string;
+    url: string;
+    on: boolean;
+    prefill?: string;
+    prefillSource?: string;
+}
+export interface EndpointsOptions {
+    label: string;
+    rows: EndpointRow[];
+    validate: (protocol: string, url: string) => string | null;
+    /** Live status for a saved row ("✓ live · 3 tools"). */
+    status: (protocol: string, url: string) => string | null;
+    /** Called when a row's URL is saved, so it can be read in the background. */
+    onSave: (protocol: string, url: string) => void;
+    /** Background results arrive: redraw. Returns an unsubscribe. */
+    onChange: (cb: () => void) => () => void;
+}
+export declare class EndpointsInput implements Widget<Record<string, string> | Nav> {
+    private o;
+    private i;
+    private editor;
+    private error;
+    private off?;
+    get label(): string;
+    constructor(o: EndpointsOptions);
+    attach(redraw: () => void): void;
+    detach(): void;
+    private row;
+    /** A URL next to one already entered, as a prefill for an empty row: https://host/mcp → https://host/a2a. */
+    private derived;
+    private openEditor;
+    render(): Frame;
+    onKey(str: string | undefined, key: Key): {
+        done: Record<string, string> | Nav;
+    } | void;
+    summary(v: Record<string, string> | Nav): string;
+}

package/dist/endpoints.js

@@ -0,0 +1,142 @@
+/**
+ * Endpoints: one list, one URL input per protocol row.
+ *
+ *   list   ↑/↓ move between rows · Tab focuses the row's URL input · Space toggles a row with a URL · Enter continues
+ *          to the next step with every ticked row · j back · ; skip
+ *   input  the field shows the format it needs (https://…, wss://…) until you type; a known URL is a prefill (Tab
+ *          fills). Enter saves the row, ticks it, starts reading the endpoint in the background, and moves focus to
+ *          the next row. Enter on an empty input unticks the row. Esc on an empty input returns to the list.
+ *
+ * So the fast path is Tab, type, Enter for each row, then Enter again to move on.
+ */
+import { TextInput } from "./widgets.js";
+import { BACK, SKIP, style } from "./tui.js";
+const LABEL_W = 10;
+export class EndpointsInput {
+    o;
+    i = 0;
+    editor = null;
+    error = null;
+    off;
+    get label() { return this.o.label; }
+    constructor(o) {
+        this.o = o;
+    }
+    attach(redraw) { this.off = this.o.onChange(redraw); }
+    detach() { this.off?.(); this.editor?.detach(); }
+    row() { return this.o.rows[this.i]; }
+    /** A URL next to one already entered, as a prefill for an empty row: https://host/mcp → https://host/a2a. */
+    derived(r) {
+        const other = this.o.rows.find((x) => x !== r && x.on && x.url);
+        if (!other)
+            return undefined;
+        try {
+            const origin = new URL(other.url).origin;
+            return { url: r.protocol === "ws" ? `${origin.replace(/^https:/, "wss:")}/ws` : `${origin}/${r.protocol}`, source: `next to your ${other.label} endpoint` };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    openEditor() {
+        const r = this.row();
+        const d = r.url ? undefined : r.prefill ? { url: r.prefill, source: r.prefillSource ?? "" } : this.derived(r);
+        this.editor = new TextInput({
+            label: r.label, instruction: r.format, initial: r.url || undefined,
+            prefill: d?.url, prefillSource: d?.source || undefined,
+            optional: true, nav: false,
+            validate: (v) => this.o.validate(r.protocol, v),
+        });
+    }
+    render() {
+        const lines = [`${style.cyan("?")} ${style.bold(this.o.label)}  Add the URL for each protocol your agent serves`];
+        let cursor = { row: 1, col: 2 };
+        this.o.rows.forEach((r, idx) => {
+            const focused = idx === this.i;
+            const box = r.on ? style.green("[x]") : "[ ]";
+            const name = (focused ? style.bold(r.label.padEnd(LABEL_W)) : r.label.padEnd(LABEL_W));
+            const ptr = focused ? style.cyan("❯") : " ";
+            if (focused && this.editor) {
+                // The row's input, inline: the editor's field line and its hint, indented under the row.
+                const f = this.editor.render();
+                const field = f.lines[1].replace(/^› /, "");
+                const prefix = `${ptr} ${box} ${name} `;
+                lines.push(prefix + field);
+                cursor = { row: lines.length - 1, col: prefix.replace(/\x1b\[[0-9;]*m/g, "").length + (f.cursor.col - 2) };
+                for (const extra of f.lines.slice(2))
+                    lines.push("       " + extra.replace(/^ {2}/, ""));
+                return;
+            }
+            const status = r.on && r.url ? this.o.status(r.protocol, r.url) : null;
+            lines.push(`${ptr} ${box} ${name} ${r.url ? r.url : style.dim(r.format)}${status ? "  " + status : ""}`);
+            if (focused)
+                cursor = { row: lines.length - 1, col: 2 };
+        });
+        if (this.error)
+            lines.push("  " + style.red(this.error));
+        lines.push(style.dim(this.editor
+            ? "  Enter saves and moves to the next row · Tab fills the suggestion · Esc back to the list"
+            : "  ↑/↓ move · Tab edit the URL · Space tick/untick · Enter continue · j back · ; skip"));
+        return { lines, cursor };
+    }
+    onKey(str, key) {
+        this.error = null;
+        const r = this.row();
+        if (this.editor) {
+            if (key.name === "escape" && !this.editor.value) {
+                this.editor.detach();
+                this.editor = null;
+                return;
+            }
+            const res = this.editor.onKey(str, key);
+            if (res && typeof res.done === "string") {
+                const v = res.done;
+                r.url = v;
+                r.on = !!v;
+                if (v)
+                    this.o.onSave(r.protocol, v);
+                this.editor.detach();
+                this.editor = null;
+                this.i = Math.min(this.o.rows.length - 1, this.i + 1);
+            }
+            return;
+        }
+        const n = this.o.rows.length;
+        if (str === "j")
+            return { done: BACK };
+        if (str === ";")
+            return { done: SKIP };
+        if (key.name === "up") {
+            this.i = (this.i - 1 + n) % n;
+            return;
+        }
+        if (key.name === "down") {
+            this.i = (this.i + 1) % n;
+            return;
+        }
+        if (key.name === "tab" || key.name === "right") {
+            this.openEditor();
+            return;
+        }
+        if (key.name === "space" || str === " ") {
+            if (r.url)
+                r.on = !r.on;
+            else
+                this.openEditor();
+            return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+            const chosen = this.o.rows.filter((x) => x.on && x.url);
+            if (!chosen.length) {
+                this.error = "Add at least one URL (Tab to edit a row), or ; to skip";
+                return;
+            }
+            return { done: Object.fromEntries(chosen.map((x) => [x.protocol, x.url])) };
+        }
+    }
+    summary(v) {
+        if (typeof v !== "object")
+            return "";
+        return `${style.green("✔")} ${style.bold(this.o.label)} ${style.cyan(Object.entries(v).map(([p, u]) => `${p} ${u}`).join(" · "))}`;
+    }
+}

package/dist/init.d.ts

@@ -0,0 +1,47 @@
+import type { Network } from "./config.js";
+import type { ManifestInput } from "./manifest.js";
+import { CancelledError } from "./tui.js";
+export interface InitAnswers {
+    protocols?: string[];
+    endpoints?: Record<string, string>;
+    description?: string;
+    website?: string;
+    capabilities?: string[];
+    pricing?: string;
+    paid?: {
+        currency: string;
+        amount: string;
+        unit: string;
+    };
+    freeTier?: string;
+    payment?: {
+        rail: string;
+        address: string;
+    } | null;
+}
+interface Draft {
+    label: string;
+    savedAt: string;
+    answers: InitAnswers;
+}
+export type ShellKind = "powershell" | "bash";
+export declare function detectShell(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): ShellKind;
+/** Quote one argument for the shell, only when it needs it. */
+export declare function shellQuote(arg: string, shell: ShellKind): string;
+export declare function loadDraft(label: string): Draft | null;
+export declare function saveDraft(label: string, answers: InitAnswers): void;
+export declare function clearDraft(label: string): void;
+export declare function answersToInput(a: InitAnswers): ManifestInput;
+export interface InitOptions {
+    label?: string;
+    out?: string;
+    network: Network;
+    probe: boolean;
+    shell: ShellKind;
+    log: (s: string) => void;
+}
+export declare function interactiveInit(o: InitOptions): Promise<{
+    file: string;
+    label: string;
+} | null>;
+export { CancelledError };