@agentorg/cli 0.0.5 → 0.0.7

package/dist/src/gateway.js

@@ -3,33 +3,32 @@ import { createServer } from "node:http";
 import { createRequire } from "node:module";
 import { dirname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Hub, listen, PERSON, STORAGE } from "@agentorg/hub";
-import { accountLogin, appRules, hubActors, hubAudit, hubBindings, hubExports, hubGrants, hubPackages, installer, kv, layout, } from "@agentorg/interfaces";
-import { Refused } from "@agentorg/sdk";
+import { Hub, listen, PERSON } from "@agentorg/hub";
+import { accountLogin, agents, connections, hubActors, hubAudit, hubBindings, hubExports, hubGrants, llmSession, skills, } from "@agentorg/interfaces";
+import { describeInterface, Refused } from "@agentorg/sdk";
 import { connect } from "@agentorg/sdk/client";
 import { WebSocketServer } from "ws";
 import { serveSocket } from "./api.js";
-import { serveFrame } from "./frames.js";
-import { Layout } from "./layout.js";
-import { firstRun, oauthRoute } from "./model.js";
-import { Rules } from "./rules.js";
+import { callFolders } from "./folders.js";
+import { LIVE_MAX, pipeLive } from "./live.js";
+import { Notes } from "./notes.js";
+import { oauthRoute } from "./oauth.js";
+import { closePackageActors, startPrograms, } from "./programs.js";
 import { SignIn } from "./signin.js";
-import { MAX_TRANSFER, packageArchive, pinnedHashes, readSystem, withTemporaryFile, writeSystem, } from "./transfer.js";
 /**
- * The person's slots the gateway declares: every `hub.*` it holds, its own store, and the two the
- * first run binds (either may be unbound): `installer`, and `login`, the model's account sign-in.
+ * The person's slots the gateway declares: every `hub.*` it holds, and what the first run binds
+ * (any may be unbound): `login`, the model's account sign-in, and management's three.
  */
 const SLOTS = {
-    packages: hubPackages,
     actors: hubActors,
     bindings: hubBindings,
     grants: hubGrants,
     exports: hubExports,
     audit: hubAudit,
-    store: kv,
     login: accountLogin,
-    /** The installer, bound by the app's first run: plans, installs, exports and imports. */
-    installer,
+    agents,
+    connections,
+    skills,
 };
 const STATIC = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "static");
 /** The shell's built files, `@agentorg/shell`'s `dist`. */
@@ -42,6 +41,21 @@ const MAX_MESSAGE = 1024 * 1024;
 const HELLO_TIMEOUT_MS = 10_000;
 /** The close code for a socket with no live session: the tab signs in again. */
 const SIGN_IN_AGAIN = 4401;
+/** A model's reply can take minutes; every other interface keeps the Hub's own limit. */
+export const HUB_OPTIONS = {
+    answerTimeoutsMs: { [describeInterface(llmSession).id]: 10 * 60_000 },
+};
+/** The port the kept sessions were given at, if any are kept. */
+function keptPort(sessions) {
+    try {
+        const { at } = JSON.parse(readFileSync(sessions, "utf8"));
+        const port = /^http:\/\/127\.0\.0\.1:(\d+)$/.exec(String(at))?.[1];
+        return port === undefined ? undefined : Number(port);
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Write a file only its owner reads, all at once. */
 function writePrivate(file, text) {
     writeFileSync(`${file}.tmp`, text, { mode: 0o600 });
@@ -52,146 +66,79 @@ function writePrivate(file, text) {
  * The app: a Hub in this process, and the person's gateway, its single running instance. The
  * gateway holds the person's one channel to the Hub. Browser tabs and the CLI are the person's UIs,
  * not channels: they reach the gateway at `/api`, and their calls run through the person's slots,
- * or as a view's Actor for a view's. The gateway exports `layout@1`, kept in the person's store.
+ * and the person's notes are the app's own file.
  */
 export async function startApp(options) {
     const home = resolve(options.home);
     mkdirSync(home, { recursive: true, mode: 0o700 });
-    const hub = Hub.open(home);
+    closePackageActors(home);
+    const hub = Hub.open(home, HUB_OPTIONS);
     const listener = await listen(hub, {}).catch((error) => {
         hub.close();
         throw error;
     });
     writePrivate(join(home, "url"), `${listener.url}\n`);
-    const signIn = new SignIn();
-    const changes = new Set();
-    /** Who hears that a rule was turned on or off. */
-    const ruleChanges = new Set();
-    let emitChanged = () => { };
-    const isView = (actorId, module) => {
-        try {
-            const actor = hub.state.actor(actorId);
-            if (actor.package === "external" || actor.package === "builtin" || actor.state === "closed")
-                return false;
-            const { modules } = hub.state.package(actor.package).manifest;
-            return Object.hasOwn(modules, module) && modules[module]?.placement === "view";
-        }
-        catch {
-            return false;
-        }
-    };
+    // A tab signed in before the app last stopped is still signed in, if the app is at the address
+    // it was then: what is kept is each session's hash, in a file only its owner reads. At another
+    // address they are dropped. A tab keeps its session by address, so it couldn't say one here, and
+    // a tab left open on the old address goes on saying its session to whatever answers there.
+    const sessions = join(home, "sessions.json");
+    const signIn = new SignIn({
+        kept: {
+            read() {
+                try {
+                    return JSON.parse(readFileSync(sessions, "utf8")).hashes;
+                }
+                catch {
+                    // None kept, or none that reads back.
+                    return undefined;
+                }
+            },
+            write(hashes) {
+                try {
+                    writePrivate(sessions, `${JSON.stringify({ at: origin, hashes })}\n`);
+                }
+                catch {
+                    // A home that can't be written still signs the tab in: only the next start forgets it.
+                }
+            },
+        },
+    });
     const credential = readFileSync(join(home, "person-credential"), "utf8").trim();
-    let logic;
+    /** The app's own notes: what the shell remembers. */
+    const notes = new Notes(join(home, "app-notes.json"));
     const person = await connect({
         hubUrl: listener.url,
         actorId: PERSON,
         credential,
         slots: SLOTS,
-        exports: { layout },
-        start(ctx) {
-            logic = new Layout({
-                store: () => ({
-                    get: (key) => ctx.slots.store.call.get({ key }),
-                    set: (key, value) => ctx.slots.store.call.set({ key, value: value }),
-                }),
-                isView,
-                changed: () => emitChanged(),
-            });
-            const served = logic;
-            ctx.exports.layout.implement({
-                get: () => served.get(),
-                // Who placed it is the caller the Hub names, never the input.
-                place: (input, { caller }) => served.place(input, caller),
-                remove: (input) => served.remove(input),
-                move: (input) => served.move(input),
-            });
-            emitChanged = () => {
-                ctx.exports.layout.emit("changed", {});
-                for (const tell of [...changes])
-                    tell();
-            };
-        },
     }).catch((error) => {
         void listener.close();
         hub.close();
         throw error;
     });
-    const layoutLogic = logic;
-    // The person's store, where the layout is kept, is the built-in storage's: bound at each start,
-    // explicitly, as the Hub binds nothing by default.
-    if (!hub.state.binding(PERSON, "store"))
-        await person.slots.grants.call
-            .bind({ consumer: PERSON, slot: "store", provider: STORAGE, export: "kv" })
-            .catch((error) => {
-            person.close();
-            void listener.close();
-            hub.close();
-            throw error;
-        });
-    /** The person's side of `/api`: its slots, and `layout`, its own export, served here. */
+    /** A slot exposed to the person at run time: here exactly while it is bound. */
+    const exposedSlot = (slot) => person.exposed().find((one) => one.slot === slot);
     const personSide = {
         async call(slot, method, input) {
-            if (slot === "rules") {
-                // The person's named rules, the gateway's own, checked as a call through the Hub would be.
-                const spec = Object.hasOwn(appRules.methods, method)
-                    ? appRules.methods[method]
-                    : undefined;
-                if (!spec)
-                    throw new Refused("invalid", `rules has no method ${method}.`);
-                const parsed = spec.input.safeParse(input);
-                if (!parsed.success)
-                    throw new Refused("invalid", `rules.${method}: ${parsed.error.message}`);
-                const result = method === "set"
-                    ? await rules.set(parsed.data)
-                    : await rules.list();
-                const checked = spec.output.safeParse(result);
-                if (!checked.success)
-                    throw new Refused("bad_output", `rules.${method}: ${checked.error.message}`);
-                return checked.data;
-            }
-            if (slot === "layout") {
-                const spec = Object.hasOwn(layout.methods, method)
-                    ? layout.methods[method]
-                    : undefined;
-                if (!spec)
-                    throw new Refused("invalid", `layout has no method ${method}.`);
-                const parsed = spec.input.safeParse(input);
-                if (!parsed.success)
-                    throw new Refused("invalid", `layout.${method}: ${parsed.error.message}`);
-                // Through /api, the caller is the person.
-                const result = await layoutLogic[method](parsed.data, PERSON);
-                // Checked as a call through the Hub would be: what's stored may not fit.
-                const checked = spec.output.safeParse(result);
-                if (!checked.success)
-                    throw new Refused("bad_output", `layout.${method}: ${checked.error.message}`);
-                return checked.data;
-            }
-            if (!Object.hasOwn(SLOTS, slot))
+            if (slot === "store")
+                return notes.call(method, input);
+            if (slot === "folders")
+                return callFolders(method, input);
+            const exposed = Object.hasOwn(SLOTS, slot) ? undefined : exposedSlot(slot);
+            if (!exposed && !Object.hasOwn(SLOTS, slot))
                 throw new Refused("invalid", `The person has no slot ${slot}.`);
-            const calls = person.slots[slot].call;
+            const calls = (exposed?.call ?? person.slots[slot].call);
             const call = Object.hasOwn(calls, method) ? calls[method] : undefined;
             if (!call)
                 throw new Refused("invalid", `${slot} has no method ${method}.`);
             return call(input);
         },
         subscribe(slot, event, send) {
-            if (slot === "rules") {
-                if (event !== "changed")
-                    throw new Refused("invalid", "rules has one event, changed.");
-                const tell = () => send({});
-                ruleChanges.add(tell);
-                return () => void ruleChanges.delete(tell);
-            }
-            if (slot === "layout") {
-                if (event !== "changed")
-                    throw new Refused("invalid", "layout has one event, changed.");
-                const tell = () => send({});
-                changes.add(tell);
-                return () => void changes.delete(tell);
-            }
-            if (!Object.hasOwn(SLOTS, slot))
+            const exposed = Object.hasOwn(SLOTS, slot) ? undefined : exposedSlot(slot);
+            if (!exposed && !Object.hasOwn(SLOTS, slot))
                 throw new Refused("invalid", `The person has no slot ${slot}.`);
-            const handle = person.slots[slot];
+            const handle = (exposed ?? person.slots[slot]);
             try {
                 return handle.on(event, send);
             }
@@ -200,40 +147,17 @@ export async function startApp(options) {
             }
         },
     };
-    const views = {
-        call: (view, slot, method, input) => hub.viewCall(view.actor, view.module, slot, method, input),
-        subscribe: (view, slot, event, send, end) => hub.viewSubscribe(view.actor, view.module, slot, event, send, () => end()),
-        slots: (view, onSlot) => hub.viewSlots(view.actor, view.module, onSlot),
-        log: (view, level, message, fields) => hub.viewLog(view.actor, view.module, {
-            level,
-            message,
-            ...(fields ? { data: fields } : {}),
-        }),
-    };
     // The first run, beside serving: the shell follows the person's bindings as they're made, so it
     // needn't wait. What it can't do is logged and tried at the next start.
-    const ran = options.firstRun === false
-        ? undefined
-        : firstRun(personSide, {
-            log: (message) => process.stderr.write(`${message}\n`),
-            connected: (actorId) => hub.connected(actorId),
-            ...options.firstRun,
-        }).catch((error) => {
-            process.stderr.write(`First run didn't work: ${error instanceof Error ? error.message : String(error)}\n`);
-            return undefined;
-        });
-    // The person's named rules: off until turned on; their engine starts once the first run is done.
-    const rules = new Rules({
-        person: personSide,
+    const ran = startPrograms(personSide, {
+        home,
+        hubUrl: listener.url,
         log: (message) => process.stderr.write(`${message}\n`),
-        changed: () => {
-            for (const tell of [...ruleChanges])
-                tell();
-        },
+        ...options.firstRun,
+    }).catch((error) => {
+        process.stderr.write(`First run didn't work: ${error instanceof Error ? error.message : String(error)}\n`);
+        return undefined;
     });
-    void Promise.resolve(ran)
-        .then(() => rules.start())
-        .catch((error) => process.stderr.write(`The rules didn't start: ${error instanceof Error ? error.message : String(error)}\n`));
     /** The app's own pages: scripts and styles from here only, framed by nothing. */
     const appCsp = [
         "default-src 'self'",
@@ -241,7 +165,7 @@ export async function startApp(options) {
         "style-src 'self' 'unsafe-inline'",
         "img-src 'self' data:",
         "connect-src 'self'",
-        "frame-src 'self'",
+        "frame-src 'none'",
         "object-src 'none'",
         "base-uri 'none'",
         "form-action 'self'",
@@ -266,15 +190,6 @@ export async function startApp(options) {
         const route = routes.get(url.pathname);
         if (route)
             return route(request, response, url);
-        if (url.pathname.startsWith("/frames/")) {
-            const served = request.method === "GET"
-                ? serveFrame(url.pathname, origin, bundleOf, request.headers.origin)
-                : undefined;
-            if (!served)
-                return void response.writeHead(404).end();
-            response.writeHead(served.status, served.headers).end(served.body);
-            return;
-        }
         if (url.pathname === "/api/session" && request.method === "POST") {
             // Same-origin only: a cross-site form can't trade a code it saw.
             if (request.headers.origin !== origin)
@@ -294,14 +209,6 @@ export async function startApp(options) {
             response.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
             return void response.end(JSON.stringify({ session }));
         }
-        // A package's archive, and a system's file, both ways: for the person's UIs only, a tab by its
-        // session and the CLI by its token, as a bearer, which no other page can send.
-        if (url.pathname.startsWith("/packages") || url.pathname === "/system") {
-            const bearer = /^Bearer (\S+)$/.exec(request.headers.authorization ?? "")?.[1];
-            if (!signIn.isCli(request.headers.authorization) && !signIn.isSession(bearer))
-                return void response.writeHead(401).end();
-            return transfer(request, response, url);
-        }
         if (url.pathname === "/api/code" && request.method === "POST") {
             // The CLI's way to sign a browser in again: a fresh code, for its token only.
             if (!signIn.isCli(request.headers.authorization))
@@ -333,115 +240,37 @@ export async function startApp(options) {
         });
         response.end(request.method === "HEAD" ? undefined : body);
     };
-    /** Answer a transfer's failure as `/api` answers a call's: `{error}`, with a fitting status. */
-    const failure = (response, error) => {
-        const body = error instanceof Refused
-            ? { name: "Refused", message: error.message, code: error.code }
-            : error instanceof Error &&
-                (error.name === "NotConnected" || error.name === "OutcomeUnknown")
-                ? { name: error.name, message: error.message }
-                : { name: "Refused", message: "The gateway couldn't handle this.", code: "internal" };
-        const status = body.code === "too_large"
-            ? 413
-            : body.code === "invalid" || body.code === "unknown"
-                ? 400
-                : 409;
-        response.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
-        response.end(JSON.stringify({ error: body }));
-    };
-    const sendFile = (response, name, bytes) => {
-        response.writeHead(200, {
-            "Content-Type": "application/octet-stream",
-            "Content-Disposition": `attachment; filename="${name.replace(/[^\w.@-]/g, "_")}"`,
-            "Cache-Control": "no-store",
-            "X-Content-Type-Options": "nosniff",
-        });
-        response.end(bytes);
-    };
-    /**
-     * `GET /packages/<hash>.agentorg`: a stored package's archive. `POST /packages`: an archive to
-     * add, verified by the Hub. `GET /system`: the system's file, its composition and every package
-     * it pins. `POST /system`: a system file, its packages added (each one's hash checked against
-     * its name), then imported with the person's authority.
-     */
-    const transfer = async (request, response, url) => {
-        try {
-            const archive = /^\/packages\/(sha256-[0-9a-f]{64})\.agentorg$/.exec(url.pathname);
-            if (archive && request.method === "GET") {
-                const hash = archive[1];
-                const bytes = packageArchive(home, hash);
-                if (!bytes)
-                    throw new Refused("unknown", `No package ${hash}.`);
-                const { manifest } = hub.state.package(hash);
-                return sendFile(response, `${manifest.name}-${manifest.version}.agentorg`, bytes);
-            }
-            if (url.pathname === "/packages" && request.method === "POST") {
-                const bytes = await readBytes(request, MAX_TRANSFER);
-                const added = await withTemporaryFile(home, "upload.agentorg", bytes, (path) => person.slots.packages.call.add({ path }));
-                response.writeHead(200, {
-                    "Content-Type": "application/json",
-                    "Cache-Control": "no-store",
-                });
-                return void response.end(JSON.stringify(added));
-            }
-            if (url.pathname === "/system" && request.method === "GET") {
-                const { composition } = await person.slots.installer.call.exportSystem({});
-                const archives = new Map();
-                for (const hash of pinnedHashes(composition)) {
-                    const bytes = packageArchive(home, hash);
-                    if (bytes)
-                        archives.set(hash, bytes);
-                }
-                return sendFile(response, "system.agentorg-system", writeSystem(composition, archives));
-            }
-            if (url.pathname === "/system" && request.method === "POST") {
-                const { composition, packages } = readSystem(await readBytes(request, MAX_TRANSFER));
-                // Named by its hash, so the Hub refuses an archive whose hash isn't its name.
-                for (const [hash, bytes] of packages)
-                    await withTemporaryFile(home, `${hash}.agentorg`, bytes, (path) => person.slots.packages.call.add({ path }));
-                const imported = await person.slots.installer.call.importSystem({ composition });
-                response.writeHead(200, {
-                    "Content-Type": "application/json",
-                    "Cache-Control": "no-store",
-                });
-                return void response.end(JSON.stringify(imported));
-            }
-            response.writeHead(405).end();
-        }
-        catch (error) {
-            failure(response, error);
-        }
-    };
-    const bundleOf = (hash, module) => {
-        try {
-            const entry = hub.state.package(hash).manifest.modules[module];
-            if (entry?.placement !== "view")
-                return undefined;
-            const dir = join(home, "packages", hash);
-            const file = resolve(dir, entry.entry);
-            return file.startsWith(dir + sep) ? file : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    };
     const sockets = new WebSocketServer({ noServer: true, maxPayload: MAX_MESSAGE });
+    const lives = new WebSocketServer({ noServer: true, maxPayload: LIVE_MAX });
     server.on("upgrade", (request, socket, head) => {
         // An upgraded socket has no error handler of its own: a client that resets would crash the app.
         socket.on("error", () => socket.destroy());
         const url = new URL(request.url ?? "/", origin);
         const cli = signIn.isCli(request.headers.authorization);
         const allowed = request.headers.host === host() &&
-            url.pathname === "/api" &&
+            (url.pathname === "/api" || url.pathname === "/live") &&
             (cli || request.headers.origin === origin);
         if (!allowed) {
             socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
             return;
         }
+        if (url.pathname === "/live") {
+            const query = url.searchParams;
+            return lives.handleUpgrade(request, socket, head, (ws) => pipeLive(ws, {
+                cli,
+                isSession: (session) => signIn.isSession(session),
+                ticket: async () => (await personSide.call("agents", "live", {
+                    agent: query.get("agent"),
+                    instance: query.get("instance"),
+                    surface: query.get("surface"),
+                    mode: query.get("mode") ?? "watch",
+                })),
+            }));
+        }
         sockets.handleUpgrade(request, socket, head, (ws) => {
             let served;
             const serve = () => {
-                served = serveSocket({ send: (text) => ws.send(text), close: (code, reason) => ws.close(code, reason) }, { person: personSide, views });
+                served = serveSocket({ send: (text) => ws.send(text), close: (code, reason) => ws.close(code, reason) }, { person: personSide });
             };
             // The CLI is in by its token; a tab says its session first, or is closed.
             if (cli)
@@ -473,35 +302,44 @@ export async function startApp(options) {
             });
         });
     });
-    await new Promise((done, failed) => {
+    const listenOn = (port) => new Promise((done, failed) => {
         server.once("error", failed);
-        server.listen(options.port ?? 0, "127.0.0.1", () => done());
-    }).catch(async (error) => {
+        server.listen(port, "127.0.0.1", () => done());
+    });
+    // With no port asked for, the one the kept sessions were given at, so a tab left open is still
+    // signed in. If that one can't be had, any free one, as on a first start.
+    await (options.port === undefined
+        ? listenOn(keptPort(sessions) ?? 0).catch(() => listenOn(0))
+        : listenOn(options.port)).catch(async (error) => {
         person.close();
         await listener.close();
         hub.close();
         throw error;
     });
-    origin = `http://127.0.0.1:${server.address().port}`;
+    const { port } = server.address();
+    // At another address the kept sessions are dropped, before anything is answered.
+    if (keptPort(sessions) !== port)
+        rmSync(sessions, { force: true });
+    origin = `http://127.0.0.1:${port}`;
     writePrivate(join(home, "cli-token"), `${signIn.cliToken}\n`);
     writePrivate(join(home, "app.json"), `${JSON.stringify({ url: origin, pid: process.pid })}\n`);
     let closing;
     let stopped = () => { };
+    let lost = false;
     const closed = new Promise((done) => {
-        stopped = () => done({ lost: false });
+        stopped = () => done({ lost });
         // The person's channel gone (taken over, or the Hub gone): the gateway can't serve, so it stops.
         void person.closed.then(() => {
             if (!closing) {
+                lost = true;
                 void close();
-                done({ lost: true });
             }
         });
     });
     const close = () => {
         closing ??= (async () => {
             // A first run still going finishes first, so it isn't cut off half way.
-            await ran;
-            rules.close();
+            const programs = await ran;
             const ours = (file, text) => {
                 if (file === "cli-token")
                     return text.trim() === signIn.cliToken;
@@ -523,14 +361,17 @@ export async function startApp(options) {
                 catch {
                     // Already gone.
                 }
-            for (const client of sockets.clients)
-                client.terminate();
-            sockets.close();
+            for (const server of [sockets, lives]) {
+                for (const client of server.clients)
+                    client.terminate();
+                server.close();
+            }
             // server.close waits for every open connection; a tab still connected (a keep-alive request,
             // a socket reconnecting) would hold the app open, so they are all closed now.
             const serverClosed = new Promise((done) => server.close(() => done()));
             server.closeAllConnections();
             await serverClosed;
+            await programs?.close();
             person.close();
             await person.closed;
             await listener.close();
@@ -543,7 +384,7 @@ export async function startApp(options) {
         url: origin,
         hubUrl: listener.url,
         hub,
-        ...(ran ? { firstRun: ran } : {}),
+        firstRun: ran,
         signInUrl: () => `${origin}/signin#${signIn.code()}`,
         route: (path, route) => void routes.set(path, route),
         close,
@@ -574,24 +415,6 @@ function contentType(file) {
         return "image/svg+xml";
     return "application/octet-stream";
 }
-/** A request's body as bytes, up to `max`: past it, `Refused("too_large")`. */
-function readBytes(request, max) {
-    return new Promise((done, failed) => {
-        const chunks = [];
-        let size = 0;
-        request.on("data", (chunk) => {
-            size += chunk.length;
-            if (size > max) {
-                request.destroy();
-                failed(new Refused("too_large", `A file here is ${max / 1024 / 1024} MiB at most.`));
-            }
-            else
-                chunks.push(chunk);
-        });
-        request.on("end", () => done(new Uint8Array(Buffer.concat(chunks))));
-        request.on("error", failed);
-    });
-}
 function readBody(request) {
     return new Promise((done, failed) => {
         let body = "";

package/dist/src/index.d.ts

@@ -1,7 +1,6 @@
-export { type PersonSide, type Socket, serveSocket, type View, type ViewCalls } from "./api.js";
-export { frameCsp, serveFrame, type ViewBundle } from "./frames.js";
+export { type PersonSide, type Socket, serveSocket } from "./api.js";
 export { type App, type AppOptions, type Route, startApp } from "./gateway.js";
-export { LAYOUT_KEY, Layout, type LayoutStore, type PlacementRecord } from "./layout.js";
-export { type FirstRun, type FirstRunOptions, firstRun, oauthRoute, type PersonCalls, type Target, } from "./model.js";
+export { Notes } from "./notes.js";
+export { oauthRoute, type PersonCalls } from "./oauth.js";
+export { type Programs, type ProgramsOptions, startPrograms } from "./programs.js";
 export { SignIn } from "./signin.js";
-export { MAX_TRANSFER, packageArchive, pinnedHashes, readSystem, type SystemComposition, withTemporaryFile, writeSystem, } from "./transfer.js";

package/dist/src/index.js

@@ -1,7 +1,6 @@
 export { serveSocket } from "./api.js";
-export { frameCsp, serveFrame } from "./frames.js";
 export { startApp } from "./gateway.js";
-export { LAYOUT_KEY, Layout } from "./layout.js";
-export { firstRun, oauthRoute, } from "./model.js";
+export { Notes } from "./notes.js";
+export { oauthRoute } from "./oauth.js";
+export { startPrograms } from "./programs.js";
 export { SignIn } from "./signin.js";
-export { MAX_TRANSFER, packageArchive, pinnedHashes, readSystem, withTemporaryFile, writeSystem, } from "./transfer.js";

package/dist/src/live.d.ts

@@ -0,0 +1,17 @@
+import WebSocket from "ws";
+/** What one live frame can be, either way. */
+export declare const LIVE_MAX: number;
+export interface Ticket {
+    url: string;
+    protocol: string;
+}
+/**
+ * Pipe a page's socket to a surface. A tab says its session first, as on `/api`, and is then
+ * answered `{"op":"live","protocol"}`; after that every frame is the surface's own. The CLI is in
+ * by its token.
+ */
+export declare function pipeLive(page: WebSocket, options: {
+    cli: boolean;
+    isSession(session: unknown): boolean;
+    ticket(): Promise<Ticket>;
+}): void;