@quo-systems/dock 0.1.0

package/dist/human/tab.js

@@ -0,0 +1,68 @@
+import { BrowserHarbor } from '../harbor/browser.js';
+import { Avatar, USER } from '../beings/avatar.js';
+import { screenSide } from './screen.js';
+import { domSurface } from './dom.js';
+const el = (tag, text = '', attrs = {}) => {
+    const e = document.createElement(tag);
+    if (text)
+        e.textContent = text;
+    for (const [k, v] of Object.entries(attrs))
+        e.setAttribute(k, v);
+    return e;
+};
+export async function start(cfg, root = document.body) {
+    const status = el('p', 'booting');
+    const screen = el('div');
+    root.append(status, screen);
+    const say = (s) => (status.textContent = s);
+    // The harbor in the tab: one database, one ward, one avatar, for good.
+    const harbor = new BrowserHarbor('quo');
+    await harbor.boot();
+    const main = harbor.wards.get('main') ?? (await harbor.create('main', 'me'));
+    if (!main.being('me'))
+        await main.ask('boot', { key: 'me', class: 'Avatar' });
+    const me = main.being('me');
+    harbor.dial(cfg.quo);
+    // The screen: every call rotates her keys and a same-ward ask never
+    // crosses the harbor, so the side saves after each one.
+    const show = async (notice) => {
+        status.remove();
+        await screenSide(me, domSurface(screen), () => main.save(), notice);
+    };
+    // Already in: reconnect, nothing minted.
+    const had = await me.tools();
+    if ('asks' in had)
+        return show('in, as before');
+    // The exchange, once: the owner password for a nonce, the nonce for an
+    // invitation the user being mints, the invitation for a standing.
+    const form = el('form');
+    const identity = el('input', '', { name: 'identity', value: 'tab', placeholder: 'identity' });
+    const password = el('input', '', { name: 'password', type: 'password', placeholder: 'owner password' });
+    const go = el('button', 'enter');
+    form.append(identity, password, go);
+    root.insertBefore(form, screen);
+    say(`not in (${had.error}): the owner password opens the world`);
+    form.onsubmit = async (ev) => {
+        ev.preventDefault();
+        say('asking the world');
+        let res;
+        try {
+            res = await fetch(`${cfg.web}/tab/login`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ password: password.value, identity: identity.value }) });
+        }
+        catch (e) {
+            return say(`the world did not answer: ${e.message}`);
+        }
+        if (!res.ok)
+            return say(`refused: ${(await res.json().catch(() => ({ error: res.status }))).error ?? res.status}`);
+        const { nonce, ward } = (await res.json());
+        password.value = '';
+        say('knocking');
+        const got = await me.enter({ ward }, { kind: 'tab', nonce });
+        await main.save(); // the knock went through her own door, which the harbor never sees
+        if (!('asks' in got))
+            return say(`not in: ${got.error}`);
+        form.remove();
+        await show(`in, as ${identity.value}`);
+    };
+}
+export { USER };

package/dist/mcp/agent.d.ts

@@ -0,0 +1,10 @@
+import type { Json, JsonObject } from '@quo-systems/quo';
+import type { Avatar } from '../beings/avatar.ts';
+import { type Serving } from '../beings/side.ts';
+export type Run = (event: JsonObject) => Promise<Json>;
+export declare const REPORT = "report";
+export declare function processRun(command: string, args: string[], dir: string): Run;
+export type Agent = Serving & {
+    idle(): Promise<void>;
+};
+export declare function agentSide(avatar: Avatar, run: Run, after?: () => Promise<void>): Agent;

package/dist/mcp/agent.js

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: Apache-2.0
+// The model side as an event-driven agent: the world is the loop. The user
+// being holds a standing to the agent's avatar and asks her when something
+// happens; that ask is a push, and her `notify` answers at once, so the ask
+// is never held open. The push lands in her inbox, which is the queue, in
+// her cells. This side drains the inbox one event at a time: it starts a
+// run with the event, and when the run ends she asks the user being back on
+// her own standing with the result. One run at a time, in the order the
+// events came, across a restart too, because the queue is in the partition
+// and not in this process. What a run may do is the gate; how it behaves
+// is its constitution, the folder it runs in.
+import { spawn } from 'node:child_process';
+import { word, wordText, SILENCE_TEXT, UNREACHED_TEXT } from '../beings/side.js';
+// The ask on the user being that takes the result. Gated to devices; the
+// agent's client identity is what the gate reads.
+export const REPORT = 'report';
+// `claude -p` or any CLI agent: the command runs in the agent's folder with
+// the event, as JSON, as its last argument. The result is what it printed.
+// A non-zero exit is an error object with what it said on stderr.
+export function processRun(command, args, dir) {
+    return (event) => new Promise((ok) => {
+        const child = spawn(command, [...args, JSON.stringify(event)], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', (c) => (out += c.toString()));
+        child.stderr.on('data', (c) => (err += c.toString()));
+        child.on('error', (e) => ok({ error: e.message }));
+        child.on('close', (code) => ok(code === 0 ? { output: out.trim() } : { error: `exit ${code}`, stderr: err.trim() }));
+    });
+}
+// `after` runs when her cells changed and when an ask is done, as in the
+// other sides: a harbor that must write what the ward changed hooks it.
+export function agentSide(avatar, run, after = async () => { }) {
+    let draining = Promise.resolve();
+    let open = true;
+    const inbox = () => avatar.cells.inbox;
+    async function one(event) {
+        let result;
+        try {
+            result = await run(event);
+        }
+        catch (e) {
+            result = { error: e instanceof Error ? e.message : String(e) };
+        }
+        // The report is an ask like any other. Silence and unreached are told
+        // apart and dropped: a report is never retried, and never held.
+        const w = word(await avatar.call(REPORT, { event, result }));
+        if (w.word === 'silence' || w.word === 'unreached' || w.word === 'quo')
+            say({ dropped: w.word === 'silence' ? SILENCE_TEXT : w.word === 'quo' ? wordText(w.name) : UNREACHED_TEXT });
+        await after();
+    }
+    // One at a time, first in first out, until the inbox is empty.
+    function drain() {
+        draining = draining.then(async () => {
+            while (open && inbox().length > 0) {
+                const event = inbox().shift();
+                await after(); // the event left the queue before the run starts: a crash mid-run loses it, and never runs it twice
+                await one(event);
+            }
+        });
+        return draining;
+    }
+    // A dropped report is told to her other sides, if any: the agent itself has no ear for it.
+    const say = (object) => { for (const ear of avatar.ears)
+        if (ear !== ear0)
+            ear(object); };
+    const ear0 = () => void drain();
+    avatar.ears.add(ear0);
+    void drain(); // whatever waited while no side was up
+    return {
+        idle: () => draining,
+        close: async () => {
+            open = false;
+            avatar.ears.delete(ear0);
+            await draining;
+        },
+    };
+}

package/dist/mcp/http.d.ts

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { Avatar } from '../beings/avatar.ts';
+import type { Serving } from '../beings/side.ts';
+export type Session = {
+    identity: string;
+    transport: StreamableHTTPServerTransport;
+    serving: Serving;
+    touched: number;
+};
+export declare const SESSION_IDLE: number;
+export type Resolve = (identity: string) => Promise<{
+    avatar?: Avatar;
+    error?: string;
+}>;
+export declare class McpHttp {
+    readonly sessions: Map<string, Session>;
+    readonly resolve: Resolve;
+    readonly after: () => Promise<void>;
+    now: () => number;
+    gone: (identity: string) => Promise<void>;
+    constructor(resolve: Resolve, after?: () => Promise<void>);
+    handle(req: IncomingMessage, res: ServerResponse, identity: string): Promise<void>;
+    sweep(): void;
+    drop(sid: string): void;
+    close(): Promise<void>;
+}

package/dist/mcp/http.js

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+// The MCP endpoint on the mcp route: streamable HTTP, one session per
+// client connection, one avatar per client identity. A bearer names the
+// identity, the identity names the avatar, and the side from `server.ts`
+// runs beside her exactly as it does over stdio. A session belongs to the
+// identity that opened it; a bearer of another identity on the same session
+// is refused. Sessions live in memory and die with the daemon, which is
+// what a reconnect is for: the standing is the state, and it is on disk. A
+// client that goes away without a DELETE leaves a session behind; one idle
+// for an hour is dropped, since HTTP tells the server nothing else.
+import { randomUUID } from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { mcpSide } from './server.js';
+export const SESSION_IDLE = 60 * 60 * 1000;
+export class McpHttp {
+    sessions = new Map();
+    resolve;
+    after;
+    now = () => Date.now();
+    // What to do with an identity the user being has removed: the route's
+    // revoke, so the client's tokens go with the occupant. Set by whoever
+    // mounts the route beside the credential exchange.
+    gone = async () => { };
+    constructor(resolve, after = async () => { }) {
+        this.resolve = resolve;
+        this.after = after;
+    }
+    // `identity` is what the bearer named; the caller has already turned a
+    // stranger away. A request on a known session goes to it. A request with
+    // no session opens one, if it is an initialize; anything else is 400.
+    async handle(req, res, identity) {
+        const id = req.headers['mcp-session-id'];
+        const sid = Array.isArray(id) ? id[0] : id;
+        const json = (status, body) => {
+            res.writeHead(status, { 'content-type': 'application/json' });
+            res.end(JSON.stringify(body));
+        };
+        this.sweep();
+        if (sid !== undefined) {
+            const s = this.sessions.get(sid);
+            if (!s)
+                return json(404, { jsonrpc: '2.0', error: { code: -32001, message: 'no such session' }, id: null });
+            if (s.identity !== identity)
+                return json(403, { jsonrpc: '2.0', error: { code: -32003, message: 'not your session' }, id: null });
+            s.touched = this.now();
+            await s.transport.handleRequest(req, res);
+            if (req.method === 'DELETE')
+                this.drop(sid);
+            return;
+        }
+        if (req.method !== 'POST')
+            return json(400, { jsonrpc: '2.0', error: { code: -32000, message: 'no session' }, id: null });
+        const found = await this.resolve(identity);
+        // A session opens on her describe, and admit already asked it. The one
+        // word the door says for an identity the user being removed is
+        // `removed`, under the key it bound for her avatar: in MCP's vocabulary
+        // that is 401, the client drops its token and starts the exchange again,
+        // and the route forgets the grant.
+        if (found.error === 'removed') {
+            await this.gone(identity);
+            for (const [sid, s] of this.sessions)
+                if (s.identity === identity)
+                    this.drop(sid);
+            res.writeHead(401, { 'content-type': 'application/json' });
+            return void res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32001, message: 'removed: the user being removed this identity' }, id: null }));
+        }
+        if (!found.avatar)
+            return json(500, { jsonrpc: '2.0', error: { code: -32002, message: found.error ?? 'no avatar' }, id: null });
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (s) => {
+                this.sessions.set(s, { identity, transport, serving, touched: this.now() });
+            },
+            onsessionclosed: (s) => this.drop(s),
+        });
+        const serving = await mcpSide(found.avatar, transport, this.after);
+        await transport.handleRequest(req, res);
+    }
+    sweep() {
+        const now = this.now();
+        for (const [sid, s] of this.sessions)
+            if (now - s.touched > SESSION_IDLE)
+                this.drop(sid);
+    }
+    drop(sid) {
+        const s = this.sessions.get(sid);
+        if (!s)
+            return;
+        this.sessions.delete(sid);
+        void s.serving.close().catch(() => { });
+    }
+    async close() {
+        for (const sid of [...this.sessions.keys()])
+            this.drop(sid);
+    }
+}

package/dist/mcp/oauth.d.ts

@@ -0,0 +1,98 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare const CODE_TTL: number;
+export declare const ACCESS_TTL: number;
+export declare const REFRESH_TTL: number;
+export type Client = {
+    client_id: string;
+    client_name: string;
+    redirect_uris: string[];
+};
+export type Pending = {
+    client_id: string;
+    redirect_uri: string;
+    challenge: string;
+    state: string | null;
+    resource: string | null;
+    exp: number;
+};
+export type Grant = {
+    identity: string;
+    client_id: string;
+    exp: number;
+};
+export type Store = {
+    clients: Record<string, Client>;
+    pending: Record<string, Pending>;
+    codes: Record<string, Pending & {
+        identity: string;
+    }>;
+    access: Record<string, Grant>;
+    refresh: Record<string, Grant>;
+};
+export declare const emptyStore: () => Store;
+export type Options = {
+    issuer: string;
+    resource: string;
+    finish: (request: string) => string;
+    store: Store;
+    persist: (store: Store) => Promise<void>;
+    now?: () => number;
+};
+export declare class OAuth {
+    readonly o: Options;
+    constructor(o: Options);
+    get store(): Store;
+    now(): number;
+    metadata(): {
+        issuer: string;
+        authorization_endpoint: string;
+        token_endpoint: string;
+        registration_endpoint: string;
+        response_types_supported: string[];
+        grant_types_supported: string[];
+        code_challenge_methods_supported: string[];
+        token_endpoint_auth_methods_supported: string[];
+        scopes_supported: string[];
+    };
+    protectedResource(): {
+        resource: string;
+        authorization_servers: string[];
+        bearer_methods_supported: string[];
+    };
+    register(body: unknown): Promise<Client | {
+        error: string;
+    }>;
+    authorize(q: URLSearchParams): Promise<{
+        redirect: string;
+    } | {
+        error: string;
+    }>;
+    pending(id: string): (Pending & {
+        client: Client;
+    }) | null;
+    complete(id: string, identity: string): Promise<{
+        redirect: string;
+    } | {
+        error: string;
+    }>;
+    deny(id: string): Promise<{
+        redirect: string;
+    } | {
+        error: string;
+    }>;
+    token(body: URLSearchParams): Promise<Record<string, unknown>>;
+    issue(identity: string, client_id: string): Promise<{
+        access_token: string;
+        token_type: string;
+        expires_in: number;
+        refresh_token: string;
+        scope: string;
+    }>;
+    bearer(req: IncomingMessage): string | null;
+    revoke(identity: string): Promise<void>;
+    sweep(): void;
+    handle(req: IncomingMessage, res: ServerResponse, rest: string): Promise<boolean>;
+    challenge(res: ServerResponse): void;
+}
+export declare function readBody(req: IncomingMessage, limit?: number): Promise<string>;
+export declare function readForm(req: IncomingMessage): Promise<URLSearchParams>;

package/dist/mcp/oauth.js

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: Apache-2.0
+// OAuth on the mcp route: the credential exchange for a remote MCP client.
+// An authorization server small enough to read, and nothing a client does
+// not need: metadata, dynamic registration, PKCE with S256, the code grant,
+// refresh, opaque tokens. It is a route, not Quo. Its one job is to end with
+// a client identity, which the front desk trades for an invitation and the
+// avatar knocks with; the tokens it keeps map a bearer to that identity and
+// nothing else. No secret of Quo's is ever here.
+//
+//   GET  /.well-known/oauth-authorization-server     who issues, and where
+//   GET  /.well-known/oauth-protected-resource[/mcp] which issuer guards the MCP endpoint
+//   POST /register                                    a client names itself and its redirects
+//   GET  /authorize                                   starts a request; sent to the web route to finish
+//   POST /token                                       code or refresh for an access token
+//
+// The web route finishes a request by calling `complete(request, identity)`
+// after its own login and allow pages; that returns the redirect that
+// carries the code back to the client. Step 8 builds those pages.
+import { randomBytes, createHash } from 'node:crypto';
+// A token, a code, a client id: every key here is a string the far side chose,
+// and a bare lookup would find `__proto__` and hand back an object with no
+// identity. Own keys only.
+const own = (rec, key) => (Object.hasOwn(rec, key) ? rec[key] : undefined);
+export const CODE_TTL = 10 * 60 * 1000; // a code, and a pending request, live ten minutes
+export const ACCESS_TTL = 60 * 60 * 1000; // an access token, one hour
+export const REFRESH_TTL = 30 * 24 * 60 * 60 * 1000; // a refresh token, thirty days
+export const emptyStore = () => ({ clients: {}, pending: {}, codes: {}, access: {}, refresh: {} });
+const token = () => randomBytes(32).toString('base64url');
+const s256 = (v) => createHash('sha256').update(v).digest('base64url');
+export class OAuth {
+    o;
+    constructor(o) {
+        this.o = o;
+    }
+    get store() {
+        return this.o.store;
+    }
+    now() {
+        return this.o.now?.() ?? Date.now();
+    }
+    metadata() {
+        const i = this.o.issuer;
+        return {
+            issuer: i,
+            authorization_endpoint: `${i}/authorize`,
+            token_endpoint: `${i}/token`,
+            registration_endpoint: `${i}/register`,
+            response_types_supported: ['code'],
+            grant_types_supported: ['authorization_code', 'refresh_token'],
+            code_challenge_methods_supported: ['S256'],
+            token_endpoint_auth_methods_supported: ['none'],
+            scopes_supported: ['quo'],
+        };
+    }
+    protectedResource() {
+        return { resource: this.o.resource, authorization_servers: [this.o.issuer], bearer_methods_supported: ['header'] };
+    }
+    async register(body) {
+        const b = body;
+        const uris = Array.isArray(b.redirect_uris) ? b.redirect_uris.filter((u) => typeof u === 'string' && /^https?:\/\//.test(u)) : [];
+        if (uris.length === 0)
+            return { error: 'invalid_redirect_uri' };
+        const client = { client_id: token(), client_name: typeof b.client_name === 'string' ? b.client_name.slice(0, 80) : 'client', redirect_uris: uris };
+        this.store.clients[client.client_id] = client;
+        await this.o.persist(this.store);
+        return client;
+    }
+    // Start a request. What comes back is where to send the browser: the web
+    // route with the request id, or the client's redirect with an error.
+    async authorize(q) {
+        const client = own(this.store.clients, q.get('client_id') ?? '');
+        const redirect = q.get('redirect_uri') ?? client?.redirect_uris[0] ?? null;
+        if (!client || redirect === null || !client.redirect_uris.includes(redirect))
+            return { error: 'invalid_client' };
+        const back = (error) => ({ redirect: withQuery(redirect, { error, state: q.get('state') }) });
+        if (q.get('response_type') !== 'code')
+            return back('unsupported_response_type');
+        const challenge = q.get('code_challenge');
+        if (!challenge || q.get('code_challenge_method') !== 'S256')
+            return back('invalid_request');
+        const id = token();
+        this.store.pending[id] = { client_id: client.client_id, redirect_uri: redirect, challenge, state: q.get('state'), resource: q.get('resource'), exp: this.now() + CODE_TTL };
+        this.sweep();
+        await this.o.persist(this.store);
+        return { redirect: this.o.finish(id) };
+    }
+    // What the web route shows: who is asking. Null if the request is gone.
+    pending(id) {
+        const p = own(this.store.pending, id);
+        if (!p || p.exp < this.now())
+            return null;
+        const client = own(this.store.clients, p.client_id);
+        return client ? { ...p, client } : null;
+    }
+    // The web route's last step: the human allowed this client as this identity.
+    async complete(id, identity) {
+        const p = this.pending(id);
+        if (!p)
+            return { error: 'expired' };
+        delete this.store.pending[id];
+        const code = token();
+        this.store.codes[code] = { ...p, identity, exp: this.now() + CODE_TTL };
+        await this.o.persist(this.store);
+        return { redirect: withQuery(p.redirect_uri, { code, state: p.state }) };
+    }
+    // The human refused, or the request died: the client hears that.
+    async deny(id) {
+        const p = this.pending(id);
+        if (!p)
+            return { error: 'expired' };
+        delete this.store.pending[id];
+        await this.o.persist(this.store);
+        return { redirect: withQuery(p.redirect_uri, { error: 'access_denied', state: p.state }) };
+    }
+    async token(body) {
+        const grant = body.get('grant_type');
+        if (grant === 'authorization_code') {
+            const c = own(this.store.codes, body.get('code') ?? '');
+            if (!c || c.exp < this.now())
+                return { error: 'invalid_grant' };
+            delete this.store.codes[body.get('code') ?? '']; // a code is spent the first time it is offered, right or wrong
+            const verifier = body.get('code_verifier') ?? '';
+            if (s256(verifier) !== c.challenge || (body.get('client_id') ?? c.client_id) !== c.client_id || (body.get('redirect_uri') ?? c.redirect_uri) !== c.redirect_uri) {
+                await this.o.persist(this.store);
+                return { error: 'invalid_grant' };
+            }
+            return this.issue(c.identity, c.client_id);
+        }
+        if (grant === 'refresh_token') {
+            const rt = body.get('refresh_token') ?? '';
+            const r = own(this.store.refresh, rt);
+            if (!r || r.exp < this.now())
+                return { error: 'invalid_grant' };
+            delete this.store.refresh[rt]; // rotated: the old one is gone with the new one's birth
+            return this.issue(r.identity, r.client_id);
+        }
+        return { error: 'unsupported_grant_type' };
+    }
+    async issue(identity, client_id) {
+        const access_token = token(), refresh_token = token();
+        this.store.access[access_token] = { identity, client_id, exp: this.now() + ACCESS_TTL };
+        this.store.refresh[refresh_token] = { identity, client_id, exp: this.now() + REFRESH_TTL };
+        this.sweep();
+        await this.o.persist(this.store);
+        return { access_token, token_type: 'Bearer', expires_in: ACCESS_TTL / 1000, refresh_token, scope: 'quo' };
+    }
+    // The bearer on an MCP request, to a client identity. Null is 401.
+    bearer(req) {
+        const h = req.headers.authorization ?? '';
+        const t = h.startsWith('Bearer ') ? h.slice(7) : '';
+        const g = own(this.store.access, t);
+        return g && g.exp >= this.now() && typeof g.identity === 'string' ? g.identity : null;
+    }
+    // Every grant an identity holds, gone: the route's half of revocation.
+    // The other half is the user being removing the occupant.
+    async revoke(identity) {
+        for (const k of ['access', 'refresh'])
+            for (const [t, g] of Object.entries(this.store[k]))
+                if (g.identity === identity)
+                    delete this.store[k][t];
+        await this.o.persist(this.store);
+    }
+    sweep() {
+        const now = this.now();
+        for (const k of ['pending', 'codes', 'access', 'refresh'])
+            for (const [t, g] of Object.entries(this.store[k]))
+                if (g.exp < now)
+                    delete this.store[k][t];
+    }
+    // The HTTP face. `rest` is the path under the route.
+    async handle(req, res, rest) {
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        const json = (status, body, headers = {}) => {
+            res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store', ...headers });
+            res.end(JSON.stringify(body));
+        };
+        if (rest === '/.well-known/oauth-authorization-server' && req.method === 'GET')
+            return json(200, this.metadata()), true;
+        if ((rest === '/.well-known/oauth-protected-resource' || rest === '/.well-known/oauth-protected-resource/mcp') && req.method === 'GET')
+            return json(200, this.protectedResource()), true;
+        if (rest === '/register' && req.method === 'POST') {
+            const out = await this.register(await readJson(req));
+            return json('error' in out ? 400 : 201, out), true;
+        }
+        if (rest === '/authorize' && req.method === 'GET') {
+            const out = await this.authorize(url.searchParams);
+            if ('error' in out)
+                return json(400, out), true;
+            res.writeHead(302, { location: out.redirect, 'cache-control': 'no-store' });
+            res.end();
+            return true;
+        }
+        if (rest === '/token' && req.method === 'POST') {
+            const out = await this.token(await readForm(req));
+            return json('error' in out ? 400 : 200, out), true;
+        }
+        return false;
+    }
+    // What an unauthenticated MCP request is told: where to go.
+    challenge(res) {
+        res.writeHead(401, { 'www-authenticate': `Bearer resource_metadata="${this.o.issuer}/.well-known/oauth-protected-resource/mcp"`, 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: 'unauthorized' }));
+    }
+}
+function withQuery(base, params) {
+    const u = new URL(base);
+    for (const [k, v] of Object.entries(params))
+        if (v !== null)
+            u.searchParams.set(k, v);
+    return u.toString();
+}
+export async function readBody(req, limit = 64 * 1024) {
+    let s = '';
+    for await (const chunk of req) {
+        s += chunk;
+        if (s.length > limit)
+            throw new Error('too large');
+    }
+    return s;
+}
+async function readJson(req) {
+    try {
+        return JSON.parse(await readBody(req));
+    }
+    catch {
+        return {};
+    }
+}
+export async function readForm(req) {
+    const body = await readBody(req);
+    if ((req.headers['content-type'] ?? '').includes('application/json')) {
+        try {
+            const o = JSON.parse(body);
+            return new URLSearchParams(Object.entries(o).map(([k, v]) => [k, String(v)]));
+        }
+        catch {
+            return new URLSearchParams();
+        }
+    }
+    return new URLSearchParams(body);
+}

package/dist/mcp/pilot.d.ts

@@ -0,0 +1,6 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { type Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { Serving } from '../beings/side.ts';
+export declare const PILOT_TOOLS: Tool[];
+export type Log = (line: string) => void;
+export declare function pilotSide(dir: string, ward: string, transport: Transport, log?: Log, via?: string): Promise<Serving>;