@hanzo/build 0.2.10 → 0.2.11

package/lib/api/billing.js

@@ -0,0 +1,300 @@
+/**
+ * The organization's money: its plan, the cards it pays with, its invoices, its
+ * balance and credits, what it has spent this month, and the caps on that spend.
+ *
+ *   GET    /v1/billing/plans                     the catalog the serving brand sells (public)
+ *   GET    /v1/billing/subscriptions             {count, subscriptions}
+ *   POST   /v1/billing/subscribe/card            buy a plan with a saved card; one paid plan at a time (409)
+ *   POST   /v1/billing/subscriptions/{id}/cancel     at the end of the paid period
+ *   POST   /v1/billing/subscriptions/{id}/reactivate
+ *   GET    /v1/billing/methods                   saved cards, newest first
+ *   POST   /v1/billing/methods                   save a card from the processor's single-use token
+ *   DELETE /v1/billing/methods/{id}
+ *   GET    /v1/billing/settings                  the processor a browser tokenizes a card against
+ *   GET    /v1/billing/invoices                  {count, cursor, invoices}
+ *   GET    /v1/billing/invoices/{id}/pdf         the invoice as a PDF
+ *   GET    /v1/billing/balance                   prepaid balance, whole cents
+ *   GET    /v1/billing/credit-balance            granted credit, per currency
+ *   POST   /v1/billing/topup                     charge a saved card into the balance
+ *   GET    /v1/billing/usage/rollup              the plan's month: included spend and request windows
+ *   GET    /v1/usage/summary?range=month         this month's spend, by category
+ *   GET    /v1/billing/alerts                    spend caps (bare array)
+ *   POST   /v1/billing/alerts                    open a cap (org admin)
+ *   PATCH  /v1/billing/alerts/{id}               change one (org admin)
+ *   DELETE /v1/billing/alerts/{id}               lift one (org admin)
+ *
+ * Every figure is whole cents. The wallet, the caps and the cards are the
+ * caller's own, resolved by the platform from the credential; nothing here names
+ * an org or a subject. No card number passes through this file: a card is saved
+ * from the token the processor's own form returns.
+ */
+import { call, headers, reason, Refusal, seg } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+const arr = (v) => (Array.isArray(v) ? v : []);
+const words = (v) => arr(v).filter((s) => typeof s === 'string' && s !== '');
+/** `$1,234.56` from whole cents; whole dollars drop the cents. */
+export function money(cents, currency = 'usd') {
+    const whole = cents % 100 === 0;
+    try {
+        return new Intl.NumberFormat('en-US', {
+            style: 'currency',
+            currency: (currency || 'usd').toUpperCase(),
+            minimumFractionDigits: whole ? 0 : 2,
+            maximumFractionDigits: 2,
+        }).format(cents / 100);
+    }
+    catch {
+        return `${(cents / 100).toFixed(whole ? 0 : 2)} ${currency.toUpperCase()}`;
+    }
+}
+/** Whole cents from what a person typed as dollars — `25`, `$25.50` — or null. */
+export function cents(typed) {
+    const s = typed.replace(/[$,\s]/g, '');
+    if (!/^\d+(\.\d{1,2})?$/.test(s))
+        return null;
+    const c = Math.round(Number(s) * 100);
+    return c > 0 ? c : null;
+}
+export function plan(raw) {
+    const p = obj(raw);
+    return {
+        id: str(p.slug) || str(p.id),
+        name: str(p.name),
+        description: str(p.description),
+        category: str(p.category),
+        monthly: num(p.price),
+        yearly: num(p.priceAnnual),
+        currency: str(p.currency) || 'usd',
+        perSeat: p.perSeat === true,
+        sales: p.contactSales === true,
+        popular: p.popular === true,
+        features: words(p.features),
+    };
+}
+/** The plans a person can hold. The catalog also carries add-ons (DNS, storage) that are not. */
+const HELD = ['personal', 'team', 'enterprise'];
+export async function plans(t) {
+    const raw = await call(t, 'GET', '/v1/billing/plans');
+    const rows = Array.isArray(raw) ? raw : arr(obj(raw).plans);
+    return rows.map(plan).filter((p) => p.id && p.name && (!p.category || HELD.includes(p.category)));
+}
+export function subscription(raw) {
+    const s = obj(raw);
+    const p = obj(s.plan);
+    return {
+        id: str(s.id),
+        plan: str(s.planId) || str(p.id),
+        name: str(p.name) || str(s.planId),
+        price: num(p.price),
+        interval: str(p.interval) || 'month',
+        currency: str(p.currency) || 'usd',
+        seats: num(s.quantity) || 1,
+        status: str(s.status),
+        ends: str(s.currentPeriodEnd),
+        ending: s.cancelAtPeriodEnd === true,
+        method: str(s.defaultPaymentMethod),
+    };
+}
+/** Only these confer the plan. */
+const LIVE = ['active', 'trialing', 'past_due'];
+/** The plan the org is on, or null for none (the free tier). */
+export function current(list) {
+    return list.find((s) => LIVE.includes(s.status)) ?? null;
+}
+export async function subscriptions(t) {
+    const raw = obj(await call(t, 'GET', '/v1/billing/subscriptions'));
+    return arr(raw.subscriptions).map(subscription).filter((s) => s.id);
+}
+/** Buy a plan. No amount is sent: the catalog prices it, and the platform charges that. */
+export async function subscribe(t, p) {
+    if (!p.method)
+        throw new Error('Add a card before choosing a paid plan');
+    const raw = obj(await call(t, 'POST', '/v1/billing/subscribe/card', { planId: p.plan, paymentMethodId: p.method, interval: p.interval }));
+    return { subscription: str(raw.subscriptionId), charged: num(raw.amountCents) };
+}
+/** End a plan when its paid period does, not before. */
+export async function cancel(t, id) {
+    return subscription(await call(t, 'POST', `/v1/billing/subscriptions/${seg(id)}/cancel`, { atPeriodEnd: true }));
+}
+export async function reactivate(t, id) {
+    return subscription(await call(t, 'POST', `/v1/billing/subscriptions/${seg(id)}/reactivate`, {}));
+}
+export function method(raw) {
+    const m = obj(raw);
+    const c = obj(m.card);
+    const month = num(c.expMonth);
+    const year = num(c.expYear);
+    return {
+        id: str(m.id),
+        type: str(m.type) || 'card',
+        brand: str(c.brand),
+        last4: str(c.last4),
+        expires: month && year ? `${String(month).padStart(2, '0')}/${String(year % 100).padStart(2, '0')}` : '',
+        default: m.isDefault === true,
+        name: str(m.name),
+    };
+}
+/** How a saved method reads in a row: `Visa •••• 4242`. */
+export function label(m) {
+    if (m.last4)
+        return `${m.brand ? m.brand.charAt(0).toUpperCase() + m.brand.slice(1) : 'Card'} •••• ${m.last4}`;
+    return m.name || m.type;
+}
+export async function methods(t) {
+    const raw = await call(t, 'GET', '/v1/billing/methods');
+    const rows = Array.isArray(raw) ? raw : arr(obj(raw).data);
+    return rows.map(method).filter((m) => m.id);
+}
+/** The card a charge uses: the default, or the newest. */
+export function chosen(list) {
+    return list.find((m) => m.default) ?? list[0] ?? null;
+}
+/** Save a card from the single-use token the processor's form returned. */
+export async function save(t, token) {
+    if (!token)
+        throw new Error('The card form returned no token');
+    return method(await call(t, 'POST', '/v1/billing/methods', { type: 'card', providerRef: token }));
+}
+export async function detach(t, id) {
+    await call(t, 'DELETE', `/v1/billing/methods/${seg(id)}`);
+}
+export async function processor(t) {
+    const p = obj(await call(t, 'GET', '/v1/billing/settings'));
+    return {
+        provider: str(p.provider),
+        application: str(p.applicationId),
+        location: str(p.locationId),
+        environment: str(p.environment),
+        live: p.live === true,
+    };
+}
+export function invoice(raw) {
+    const i = obj(raw);
+    const subtotal = num(i.subtotal);
+    const tax = num(i.tax);
+    const discount = num(i.discount);
+    return {
+        id: str(i.id),
+        number: str(i.numberStr) || (num(i.number) ? String(num(i.number)) : ''),
+        date: str(i.createdAt),
+        status: str(i.status),
+        currency: str(i.currency) || 'usd',
+        subtotal,
+        tax,
+        discount,
+        credit: num(i.creditApplied),
+        paid: num(i.amountPaid),
+        due: num(i.amountDue),
+        total: subtotal - discount + tax,
+        start: str(i.periodStart),
+        end: str(i.periodEnd),
+        lines: arr(i.lineItems)
+            .map(obj)
+            .map((l) => ({ description: str(l.description) || str(l.planName), amount: num(l.amount) })),
+    };
+}
+export async function invoices(t) {
+    const raw = obj(await call(t, 'GET', '/v1/billing/invoices'));
+    return arr(raw.invoices).map(invoice).filter((i) => i.id);
+}
+/** The invoice as a PDF, read with the caller's bearer. */
+export async function pdf(t, id) {
+    const res = await fetch(`${t.api}/v1/billing/invoices/${seg(id)}/pdf`, { headers: headers(t), cache: 'no-store' });
+    if (!res.ok)
+        throw new Refusal(res.status, (await reason(res)) || `The invoice answered ${res.status}`);
+    return res.blob();
+}
+// ── balance, credit, spend ───────────────────────────────────────────────────
+/** What the org can still spend from its prepaid balance, in cents. */
+export async function balance(t) {
+    const b = obj(await call(t, 'GET', '/v1/billing/balance'));
+    return num(b.available ?? b.balance);
+}
+/** Granted credit the org can spend, in US cents. */
+export async function credit(t) {
+    const raw = obj(await call(t, 'GET', '/v1/billing/credit-balance'));
+    return arr(raw.balances)
+        .map(obj)
+        .filter((b) => (str(b.currency) || 'usd').toLowerCase() === 'usd')
+        .reduce((sum, b) => sum + num(b.available), 0);
+}
+/** Charge a saved card and add the amount to the balance; answers the balance after. */
+export async function topup(t, amount, card) {
+    if (!Number.isInteger(amount) || amount <= 0)
+        throw new Error('Enter an amount to add');
+    if (!card)
+        throw new Error('Add a card before buying more');
+    const r = obj(await call(t, 'POST', '/v1/billing/topup', { amountCents: amount, paymentMethodId: card }));
+    return num(r.balanceCents);
+}
+export async function month(t) {
+    const r = obj(await call(t, 'GET', '/v1/billing/usage/rollup'));
+    const inc = obj(r.included);
+    return {
+        plan: str(r.plan),
+        period: str(r.period),
+        included: num(inc.monthlyCents) + num(inc.grantedCents),
+        used: num(inc.consumedCents),
+        overage: num(r.overageCents),
+        windows: arr(r.windows)
+            .map(obj)
+            .map((w) => ({ span: str(w.span), limit: num(w.limit), used: num(w.used), resets: str(w.resets) }))
+            .filter((w) => w.span),
+    };
+}
+export async function spend(t) {
+    const r = obj(await call(t, 'GET', '/v1/usage/summary?range=month'));
+    const s = obj(r.spend);
+    return {
+        known: s.available === true,
+        total: num(s.mtdCents) || num(s.totalCents),
+        categories: arr(s.byCategory)
+            .map(obj)
+            .map((c) => ({ name: str(c.category) || 'Uncategorized', cents: num(c.cents) }))
+            .filter((c) => c.cents > 0),
+    };
+}
+export function cap(raw) {
+    const a = obj(raw);
+    return {
+        id: str(a.id),
+        title: str(a.title),
+        threshold: num(a.threshold),
+        enforce: a.enforce === true,
+        project: str(a.project),
+        service: str(a.service),
+        spent: typeof a.periodSpentCents === 'number' ? a.periodSpentCents : null,
+        resets: str(a.resetsAt),
+    };
+}
+export async function caps(t) {
+    const raw = await call(t, 'GET', '/v1/billing/alerts');
+    return arr(raw).map(cap).filter((c) => c.id);
+}
+/** The org-wide monthly cap: no project, no service, a ceiling. */
+export function monthly(list) {
+    return list.find((c) => !c.project && !c.service && c.threshold > 0) ?? null;
+}
+/** Set the org's monthly cap: change the one there is, or open one that refuses spend past it. */
+export async function limit(t, list, threshold) {
+    if (!Number.isInteger(threshold) || threshold <= 0)
+        throw new Error('Enter a monthly limit');
+    const was = monthly(list);
+    if (was)
+        return cap(await call(t, 'PATCH', `/v1/billing/alerts/${seg(was.id)}`, { threshold }));
+    return cap(await call(t, 'POST', '/v1/billing/alerts', {
+        title: 'Monthly limit',
+        threshold,
+        currency: 'usd',
+        project: '',
+        service: '',
+        enforce: true,
+        softPct: 80,
+        rateLimitRpm: 0,
+    }));
+}
+export async function lift(t, id) {
+    await call(t, 'DELETE', `/v1/billing/alerts/${seg(id)}`);
+}

package/lib/api/call.d.ts

@@ -36,3 +36,9 @@ export declare const seg: (s: string) => string;
 export declare function call<T>(t: Target, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, body?: unknown, init?: {
     signal?: AbortSignal;
 }): Promise<T>;
+/**
+ * The `{status, msg, data}` envelope IAM and the model service answer with. A
+ * refusal there is `status: "error"` with its sentence in `msg`, whatever the
+ * HTTP status was — often 200 — so it is read here and thrown like any other.
+ */
+export declare function unwrap(raw: unknown): unknown;

package/lib/api/call.js

@@ -73,3 +73,14 @@ export async function call(t, method, path, body, init) {
     const text = await res.text();
     return (text ? JSON.parse(text) : undefined);
 }
+/**
+ * The `{status, msg, data}` envelope IAM and the model service answer with. A
+ * refusal there is `status: "error"` with its sentence in `msg`, whatever the
+ * HTTP status was — often 200 — so it is read here and thrown like any other.
+ */
+export function unwrap(raw) {
+    const r = (raw && typeof raw === 'object' ? raw : {});
+    if (r.status === 'error')
+        throw new Refusal(400, typeof r.msg === 'string' && r.msg ? r.msg : 'The platform refused that');
+    return r.data;
+}

package/lib/api/capabilities.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What the agent may use: every tool the org can reach, and which of them are
+ * switched on.
+ *
+ *   GET /v1/tool → {tools: [{name, source, description, dispatchable, activated}]}
+ *   PUT /v1/tool/activation  {activate: [], deactivate: []} → {enabled: []}
+ *
+ * Activation is per org (and project): a tool that is off is listed but
+ * refused when an agent calls it. At most 256 names go in one request, so a
+ * larger change is sent in turns.
+ */
+import { type Target } from './call.ts';
+/** Where a tool comes from, in the order the platform ranks them. */
+export declare const SOURCES: readonly ['connector', 'function', 'zap-service', 'agent', 'skill', 'mcp'];
+export type Source = (typeof SOURCES)[number];
+export interface Tool {
+    name: string;
+    source: Source;
+    description: string;
+    activated: boolean;
+}
+export declare function toolOf(raw: unknown): Tool | null;
+export declare function tools(t: Target): Promise<Tool[]>;
+/** Switch every tool in `names` on (or off), and answer the org's activated set. */
+export declare function activate(t: Target, names: string[], on: boolean): Promise<string[]>;

package/lib/api/capabilities.js

@@ -0,0 +1,40 @@
+/**
+ * What the agent may use: every tool the org can reach, and which of them are
+ * switched on.
+ *
+ *   GET /v1/tool → {tools: [{name, source, description, dispatchable, activated}]}
+ *   PUT /v1/tool/activation  {activate: [], deactivate: []} → {enabled: []}
+ *
+ * Activation is per org (and project): a tool that is off is listed but
+ * refused when an agent calls it. At most 256 names go in one request, so a
+ * larger change is sent in turns.
+ */
+import { call } from './call.js';
+/** Where a tool comes from, in the order the platform ranks them. */
+export const SOURCES = ['connector', 'function', 'zap-service', 'agent', 'skill', 'mcp'];
+const BATCH = 256;
+const str = (v) => (typeof v === 'string' ? v : '');
+export function toolOf(raw) {
+    const o = (raw && typeof raw === 'object' ? raw : {});
+    const name = str(o.name);
+    const source = str(o.source);
+    if (!name || !SOURCES.includes(source))
+        return null;
+    return { name, source, description: str(o.description), activated: o.activated === true };
+}
+export async function tools(t) {
+    const r = await call(t, 'GET', '/v1/tool');
+    return (Array.isArray(r?.tools) ? r.tools : []).map(toolOf).filter((x) => x !== null);
+}
+/** Switch every tool in `names` on (or off), and answer the org's activated set. */
+export async function activate(t, names, on) {
+    if (!names.length)
+        throw new Error('There is nothing to switch');
+    let enabled = [];
+    for (let i = 0; i < names.length; i += BATCH) {
+        const part = names.slice(i, i + BATCH);
+        const r = await call(t, 'PUT', '/v1/tool/activation', on ? { activate: part, deactivate: [] } : { activate: [], deactivate: part });
+        enabled = Array.isArray(r?.enabled) ? r.enabled.filter((n) => typeof n === 'string') : [];
+    }
+    return enabled;
+}

package/lib/api/coding.d.ts

@@ -30,7 +30,11 @@ export declare const unhonoured: (mode: Mode | undefined, target?: string) => st
 export interface Ask {
     /** The task, in the words you would use with a colleague. */
     prompt: string;
-    /** The repository's name in the caller's org. A slash is not a name. Omitted starts something new. */
+    /**
+     * The repository: its name in the caller's org, or `owner/name` as a run's
+     * record states it, which the engine resolves as it did for that run.
+     * Omitted starts something new.
+     */
     repo?: string;
     /** The branch to start from. Omitted takes the repository's default. */
     base?: string;
@@ -59,3 +63,29 @@ export interface Run {
  */
 export declare function body(ask: Ask): Record<string, string | boolean>;
 export declare function start(t: Target, ask: Ask): Promise<Run>;
+/** A run a follow-up continues, as its record states it. */
+export interface Earlier {
+    id: string;
+    title: string;
+    /** `owner/name`, as the record states it. */
+    repo: string;
+    /** The branch it started from, or '' for the repository's default. */
+    base: string;
+    /** 'sandbox', or the id of the machine it ran on. */
+    environment: string;
+    project: string;
+    mode: string;
+    /** Its work is on its own branch (turn.ts `settled`). */
+    pushed: boolean;
+}
+/** The earlier run's ask, without the codebase its title leads with (`universe: add the widget`). */
+export declare function headline(title: string, repo: string): string;
+/**
+ * A new run continuing an earlier one in its mode: what the person said, and
+ * which run it follows, because the new run's agent reads nothing else. With
+ * nothing said it goes on with the earlier ask, in the words the platform uses
+ * when it carries a paused run on (apps/coding steer.go followUp).
+ */
+export declare function followUp(e: Earlier, said: string): Ask;
+/** A build of what a plan run answered: its ask as the title, and the plan to carry out. */
+export declare function approve(e: Earlier, plan: string): Ask;

package/lib/api/coding.js

@@ -26,7 +26,7 @@
 import { call, Refusal } from './call.js';
 /** Why this mode cannot run where it is sent, or '' when it can. */
 export const unhonoured = (mode, target) => (mode === 'plan' || mode === 'setup') && target?.trim()
-    ? `A ${mode} runs in the Hanzo sandbox: a machine clones and pushes with its own credential. Choose Default, or switch to Build.`
+    ? `A ${mode} runs in the Hanzo sandbox: a machine clones and pushes with its own credential. Choose Cloud, or switch to Build.`
     : '';
 /**
  * The request body: only what was asked, with no empty strings sent as values.
@@ -63,3 +63,52 @@ export async function start(t, ask) {
         target: s('targetId'),
     };
 }
+/** The earlier run's ask, without the codebase its title leads with (`universe: add the widget`). */
+export function headline(title, repo) {
+    const name = repo.split('/').filter(Boolean).pop() ?? '';
+    const t = title.trim();
+    return name && t.startsWith(`${name}: `) ? t.slice(name.length + 2).trim() : t;
+}
+/**
+ * The same codebase, place and project as the earlier run, starting from its
+ * branch when it pushed one. `after` IS that branch as the base (BaseOf,
+ * apps/coding coding.go), so it is named only then: a plan, a setup, or a build
+ * that changed nothing pushed no branch to clone, and its follow-up starts where
+ * it did.
+ */
+function from(e) {
+    const place = e.environment && e.environment !== 'sandbox' ? e.environment : undefined;
+    return {
+        repo: e.repo || undefined,
+        project: e.project || undefined,
+        targetId: place,
+        ...(e.pushed ? { after: e.id } : { base: e.base || undefined }),
+    };
+}
+const modeOf = (m) => (m === 'plan' || m === 'setup' ? m : 'build');
+/**
+ * A new run continuing an earlier one in its mode: what the person said, and
+ * which run it follows, because the new run's agent reads nothing else. With
+ * nothing said it goes on with the earlier ask, in the words the platform uses
+ * when it carries a paused run on (apps/coding steer.go followUp).
+ */
+export function followUp(e, said) {
+    const head = headline(e.title, e.repo);
+    const words = said.trim();
+    let prompt;
+    if (words) {
+        const was = head ? `This follows an earlier run on this codebase: “${head}”.` : 'This follows an earlier run on this codebase.';
+        prompt = `${words}\n\n${was}${e.pushed ? ' Its work so far is on this branch; build on it.' : ''}`;
+    }
+    else {
+        const kept = e.pushed ? 'An earlier run already worked on this; its work so far is on this branch. Build on it. ' : '';
+        prompt = `${head}\n\n${kept}Continue where the earlier run left off.`.trim();
+    }
+    return { ...from(e), prompt, mode: modeOf(e.mode) };
+}
+/** A build of what a plan run answered: its ask as the title, and the plan to carry out. */
+export function approve(e, plan) {
+    const head = headline(e.title, e.repo);
+    const ask = `Carry out this plan:\n\n${plan.trim()}`;
+    return { ...from(e), prompt: head ? `${head}\n\n${ask}` : ask, mode: 'build' };
+}

package/lib/api/connectors.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Connectors: the MCP servers an org adds, and the shelf it picks them from.
+ *
+ *   GET    /v1/tool/mcp/servers        {servers: [server]}
+ *   POST   /v1/tool/mcp/servers        {name, url} or {listing, name?}, with {authHeader, secret} → 201 server
+ *   DELETE /v1/tool/mcp/servers/{id}   204
+ *   GET    /v1/tool/catalog?q=&limit=&offset=   {catalog: [listing], total, limit, offset}
+ *   GET    /v1/tool/catalog/{id}       one listing in full
+ *
+ * A server's secret is sealed in KMS by the platform and never answered again;
+ * a record says only whether it has one. Its tools are GET /v1/tool?source=mcp
+ * (tools.ts), named `<server id>_<tool>`, and each is called only once it is on.
+ * A listing can be added here only when it serves streamable HTTP; one that
+ * ships only a package needs somewhere to run first. The fleet's own servers,
+ * on for every run, are mcp.ts.
+ */
+import { type Target } from './call.ts';
+export interface Server {
+    /** The server's id in the org, and the prefix of every tool it brings. */
+    id: string;
+    name: string;
+    url: string;
+    /** The header the sealed secret is sent in, or ''. */
+    header: string;
+    /** Whether a secret is sealed for it. */
+    secret: boolean;
+    /** The catalog listing it was added from, or '' for a URL typed in. */
+    listing: string;
+    created: number;
+}
+export interface Remote {
+    transport: string;
+    url: string;
+}
+export interface Package {
+    registry: string;
+    identifier: string;
+    runtime: string;
+    version: string;
+}
+export interface Listing {
+    id: string;
+    /** The publisher's reverse-DNS name, `com.stripe/mcp`. */
+    name: string;
+    title: string;
+    description: string;
+    vendor: string;
+    version: string;
+    logo: string;
+    featured: boolean;
+    official: boolean;
+    transports: string[];
+    remotes: Remote[];
+    packages: Package[];
+    repo: string;
+    site: string;
+}
+export interface Page {
+    listings: Listing[];
+    total: number;
+    offset: number;
+}
+export declare function server(raw: unknown): Server;
+export declare function listing(raw: unknown): Listing;
+/** What a listing is called on screen. */
+export declare const titleOf: (l: Listing) => string;
+/** Whether a listing can be added here and now: the platform dials its streamable-HTTP remote. */
+export declare const ready: (l: Listing) => boolean;
+/** A server's tools among the plane's, by the prefix its id gives them. */
+export declare const owns: (s: Server, toolName: string) => boolean;
+export declare function servers(t: Target): Promise<Server[]>;
+export interface Adding {
+    /** Required with a URL; a listing takes its own title when this is empty. */
+    name?: string;
+    url?: string;
+    listing?: string;
+    header?: string;
+    secret?: string;
+}
+/** Why a server cannot be added as it stands, or '' when it can. */
+export declare function refuse(a: Adding): string;
+export declare function add(t: Target, a: Adding): Promise<Server>;
+export declare function remove(t: Target, id: string): Promise<void>;
+/** A page of the shelf, featured first, then by name. */
+export declare function shelf(t: Target, q?: {
+    text?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<Page>;
+export declare function one(t: Target, id: string): Promise<Listing>;