@agentorg/cli 0.0.5 → 0.0.7

package/dist/src/api.d.ts

@@ -1,31 +1,9 @@
-/** A view the person has open: an Actor's `view` module. */
-export interface View {
-    actor: string;
-    module: string;
-}
-/** The person's own side: its slots, and `layout`, its own export, which the gateway serves. */
+/** The person's own side: the slots the gateway serves `/api` from. */
 export interface PersonSide {
     call(slot: string, method: string, input: unknown): Promise<unknown>;
     /** Events until the returned stop; `end` when the subscription can't go on. */
     subscribe(slot: string, event: string, send: (payload: unknown) => void, end: () => void): () => void;
 }
-/**
- * Calls run as a view's Actor through its `module.slot` bindings: the Hub's in-process view path
- * (`hub.viewCall` and `hub.viewSubscribe`), validated and audited like any call. The Hub refuses a
- * module that isn't one of the Actor's views, so any view of the Actor's package is open to the
- * person, and nothing else is.
- */
-export interface ViewCalls {
-    call(view: View, slot: string, method: string, input: unknown): Promise<unknown>;
-    subscribe(view: View, slot: string, event: string, send: (payload: unknown) => void, end: () => void): () => void;
-    /**
-     * The view's slots: `onSlot` hears each bound one at once, then every change (bound again when
-     * it's usable again). Returns how to stop. Refused for a module that isn't a view.
-     */
-    slots(view: View, onSlot: (slot: string, bound: boolean) => void): () => void;
-    /** A line for the view's Actor's log, which the Hub bounds as it does a frame's. */
-    log(view: View, level: "info" | "warn" | "error", message: string, fields?: Record<string, unknown>): void;
-}
 /** The socket a tab or the CLI holds: text messages in, text messages out. */
 export interface Socket {
     send(text: string): void;
@@ -34,21 +12,14 @@ export interface Socket {
 /**
  * One `/api` socket: the same calls a channel carries, as JSON.
  *
- * - `{id, op: "call", slot, method, input}`, or with `view: {actor, module}` for a view's slot;
- *   answered `{id, result}` or `{id, error}`.
- * - `{sub, op: "subscribe", slot, event}` (or with `view`): then `{sub, payload}` per event, and
- *   `{sub, end: true}` once it can't go on. `{sub, op: "unsubscribe"}` stops it.
- * - `{sub, op: "slots", view}`: the view's slots. First `{sub, payload: {bound: [slot]}}`, every
- *   one bound now, then `{sub, payload: {slot, bound}}` per change, `bound` again for a slot that's
- *   usable again. `{sub, op: "unsubscribe"}` stops it, as a subscription.
- * - `{op: "log", view, level, message, fields?}`: a line for the view's Actor's log, unanswered.
+ * - `{id, op: "call", slot, method, input}`: answered `{id, result}` or `{id, error}`.
+ * - `{sub, op: "subscribe", slot, event}`: then `{sub, payload}` per event, and `{sub, end: true}`
+ *   once it can't go on. `{sub, op: "unsubscribe"}` stops it.
  *
- * A view's calls run as its Actor, for one of its views only, which the Hub checks. Everything else
- * runs as the person: through its own slots, and `layout`, its own export.
+ * Everything runs as the person, through their slots.
  */
 export declare function serveSocket(socket: Socket, deps: {
     person: PersonSide;
-    views: ViewCalls;
 }): {
     receive(text: string): void;
     closed(): void;

package/dist/src/api.js

@@ -18,17 +18,11 @@ function errorBody(error) {
 /**
  * One `/api` socket: the same calls a channel carries, as JSON.
  *
- * - `{id, op: "call", slot, method, input}`, or with `view: {actor, module}` for a view's slot;
- *   answered `{id, result}` or `{id, error}`.
- * - `{sub, op: "subscribe", slot, event}` (or with `view`): then `{sub, payload}` per event, and
- *   `{sub, end: true}` once it can't go on. `{sub, op: "unsubscribe"}` stops it.
- * - `{sub, op: "slots", view}`: the view's slots. First `{sub, payload: {bound: [slot]}}`, every
- *   one bound now, then `{sub, payload: {slot, bound}}` per change, `bound` again for a slot that's
- *   usable again. `{sub, op: "unsubscribe"}` stops it, as a subscription.
- * - `{op: "log", view, level, message, fields?}`: a line for the view's Actor's log, unanswered.
+ * - `{id, op: "call", slot, method, input}`: answered `{id, result}` or `{id, error}`.
+ * - `{sub, op: "subscribe", slot, event}`: then `{sub, payload}` per event, and `{sub, end: true}`
+ *   once it can't go on. `{sub, op: "unsubscribe"}` stops it.
  *
- * A view's calls run as its Actor, for one of its views only, which the Hub checks. Everything else
- * runs as the person: through its own slots, and `layout`, its own export.
+ * Everything runs as the person, through their slots.
  */
 export function serveSocket(socket, deps) {
     const subscriptions = new Map();
@@ -41,13 +35,6 @@ export function serveSocket(socket, deps) {
             // The socket is gone; its close stops the rest.
         }
     };
-    const viewOf = (value) => {
-        if (value === undefined)
-            return undefined;
-        if (!isRecord(value) || !isName(value.actor) || !isName(value.module))
-            throw new Refused("invalid", "A view is {actor, module}.");
-        return { actor: value.actor, module: value.module };
-    };
     const receive = (text) => {
         let message;
         try {
@@ -72,10 +59,11 @@ export function serveSocket(socket, deps) {
                 void (async () => {
                     if (!isName(slot) || !isName(method))
                         throw new Refused("invalid", "A call names its slot and method.");
-                    const view = viewOf(message.view);
-                    return view
-                        ? deps.views.call(view, slot, method, input)
-                        : deps.person.call(slot, method, input);
+                    // A live ticket is for the gateway's own pipe at `/live`, never for a page to hold, under
+                    // whatever slot a page might expose it at.
+                    if (method === "live")
+                        throw new Refused("forbidden", "Open a live surface at /live.");
+                    return deps.person.call(slot, method, input);
                 })()
                     .then((result) => send({ id, result }), (error) => send({ id, error: errorBody(error) }))
                     .finally(() => calls--);
@@ -99,14 +87,11 @@ export function serveSocket(socket, deps) {
                         throw new Refused("invalid", "A subscription names its slot and event.");
                     if (subscriptions.size >= MAX_SUBSCRIPTIONS)
                         throw new Refused("quota", `A socket holds ${MAX_SUBSCRIPTIONS} subscriptions at most.`);
-                    const view = viewOf(message.view);
                     const forward = (payload) => {
                         if (!ended)
                             send({ sub, payload });
                     };
-                    const stop = view
-                        ? deps.views.subscribe(view, slot, event, forward, end)
-                        : deps.person.subscribe(slot, event, forward, end);
+                    const stop = deps.person.subscribe(slot, event, forward, end);
                     if (ended)
                         stop();
                     else
@@ -118,49 +103,6 @@ export function serveSocket(socket, deps) {
                 }
                 return;
             }
-            case "slots": {
-                const { sub } = message;
-                if (!isId(sub) || subscriptions.has(sub))
-                    return;
-                try {
-                    if (subscriptions.size >= MAX_SUBSCRIPTIONS)
-                        throw new Refused("quota", `A socket holds ${MAX_SUBSCRIPTIONS} subscriptions at most.`);
-                    const view = viewOf(message.view);
-                    if (!view)
-                        throw new Refused("invalid", "A slots watch names its view.");
-                    // The Hub tells the bound slots at once, within the call: gathered, they're one snapshot.
-                    let snapshot = [];
-                    const stop = deps.views.slots(view, (slot, bound) => {
-                        if (snapshot && bound)
-                            snapshot.push(slot);
-                        else if (!snapshot)
-                            send({ sub, payload: { slot, bound } });
-                    });
-                    send({ sub, payload: { bound: snapshot } });
-                    snapshot = undefined;
-                    subscriptions.set(sub, stop);
-                }
-                catch (error) {
-                    send({ sub, end: true, error: errorBody(error) });
-                }
-                return;
-            }
-            case "log": {
-                const { level, message: text, fields } = message;
-                if (level !== "info" && level !== "warn" && level !== "error")
-                    return;
-                if (typeof text !== "string")
-                    return;
-                try {
-                    const view = viewOf(message.view);
-                    if (view)
-                        deps.views.log(view, level, text, isRecord(fields) ? fields : undefined);
-                }
-                catch {
-                    // Not one of an Actor's views: nothing is logged, and nothing answers.
-                }
-                return;
-            }
             case "unsubscribe": {
                 const stop = isId(message.sub) ? subscriptions.get(message.sub) : undefined;
                 if (!stop)

package/dist/src/cli.js

@@ -10,11 +10,7 @@ const USAGE = `Usage: agentorg [command] [--home DIR]
 
   (no command) [--port N] [--no-open]       run AgentOrg: the Hub, your gateway and the shell
   open                                      sign a browser in to the running app
-  build [package-dir]                       build a package into a .agentorg archive, in a
-                                            checkout of this repository; installed, use
-                                            call packages build '{"files": {...}}'
   hub [--port N]                            run a bare Hub, without the shell
-  add <file.agentorg>                       hub.packages.add
   actors | bindings | exports | audit       each one's list
   bind <consumer.slot> <provider.export>    hub.grants.bind
   call <slot> <method> [json]               call one of the person's slots
@@ -44,9 +40,9 @@ const { values, positionals } = parseArgs({
     strict: false,
 });
 const [command, ...rest] = positionals;
-// `build` and `hub` are the SDK's, which reads their options itself, strictly. Everything else is
+// `hub` is the SDK's, which reads its options itself, strictly. Everything else is
 // this command's: an option it doesn't know is a mistake, never a reason to start the app.
-if (command !== "build" && command !== "hub") {
+if (command !== "hub") {
     const unknown = Object.keys(values).find((name) => !["home", "port", "no-open", "help", "version"].includes(name));
     if (unknown !== undefined)
         usage(`Unknown option ${unknown.length === 1 ? "-" : "--"}${unknown}. An argument that starts with - goes after --.`);
@@ -202,7 +198,7 @@ else if (command === "open") {
         process.exit(1);
     }
 }
-else if (command === "build" || command === "hub")
+else if (command === "hub")
     await import("@agentorg/sdk/cli");
 else {
     let call;

package/dist/src/folders.d.ts

@@ -0,0 +1,2 @@
+/** One `folders@1` call, checked as a call through the Hub would be. */
+export declare function callFolders(method: string, input: unknown): Promise<unknown>;

package/dist/src/folders.js

@@ -0,0 +1,45 @@
+import { readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, normalize } from "node:path";
+import { FOLDERS_MAX, folders } from "@agentorg/interfaces";
+import { Refused } from "@agentorg/sdk";
+async function isFolder(at, entry) {
+    if (entry.isDirectory())
+        return true;
+    if (!entry.isSymbolicLink())
+        return false;
+    return stat(join(at, entry.name)).then((found) => found.isDirectory(), () => false);
+}
+async function list(path) {
+    if (path !== undefined && !isAbsolute(path))
+        throw new Refused("invalid", "A folder's path starts at the top of the disk.");
+    const at = path === undefined ? homedir() : normalize(path);
+    const entries = await readdir(at, { withFileTypes: true }).catch((error) => {
+        if (error.code === "ENOENT" || error.code === "ENOTDIR")
+            throw new Refused("unknown", "There's no such folder.");
+        throw new Refused("invalid", "That folder can't be read.");
+    });
+    // Dot folders stay out of the list, as in a file picker; a path can still be typed.
+    const shown = entries.filter((entry) => !entry.name.startsWith("."));
+    const kept = await Promise.all(shown.map((entry) => isFolder(at, entry)));
+    const names = shown
+        .filter((_, i) => kept[i])
+        .map((entry) => entry.name)
+        .sort((a, b) => a.localeCompare(b))
+        .slice(0, FOLDERS_MAX);
+    const parent = dirname(at);
+    return {
+        path: at,
+        ...(parent === at ? {} : { parent }),
+        folders: names.map((name) => ({ name })),
+    };
+}
+/** One `folders@1` call, checked as a call through the Hub would be. */
+export function callFolders(method, input) {
+    if (method !== "list")
+        throw new Refused("invalid", `folders has no method ${method}.`);
+    const parsed = folders.methods.list.input.safeParse(input);
+    if (!parsed.success)
+        throw new Refused("invalid", `folders.list: ${parsed.error.message}`);
+    return list(parsed.data.path);
+}

package/dist/src/gateway.d.ts

@@ -1,20 +1,25 @@
 import { type IncomingMessage, type ServerResponse } from "node:http";
 import { Hub } from "@agentorg/hub";
-import { type FirstRun, type FirstRunOptions } from "./model.js";
+import { type Programs, type ProgramsOptions } from "./programs.js";
+/** A model's reply can take minutes; every other interface keeps the Hub's own limit. */
+export declare const HUB_OPTIONS: {
+    answerTimeoutsMs: {
+        [x: string]: number;
+    };
+};
 /** A route another part of the app adds, such as the model Actor's sign-in callback (step 5). */
 export type Route = (request: IncomingMessage, response: ServerResponse, url: URL) => void;
 export interface AppOptions {
     /** The Hub home. */
     home: string;
-    /** The gateway's port on 127.0.0.1; any free one by default. */
+    /** The gateway's port on 127.0.0.1; by default the kept sessions' if it can, else any free one. */
     port?: number;
     /** Where the shell's static files are; `@agentorg/shell`'s build by default. */
     shell?: string;
     /**
-     * The first run, at each start after the person's store is bound: on by default; `false` leaves
-     * the home as it is.
+     * How the first run, at each start, logs and reaches ChatGPT: the app's own by default.
      */
-    firstRun?: FirstRunOptions | false;
+    firstRun?: Pick<ProgramsOptions, "fetch" | "log">;
 }
 export interface App {
     /** The gateway's origin, `http://127.0.0.1:<port>`. */
@@ -22,8 +27,8 @@ export interface App {
     /** Where external Actors reach the Hub. */
     readonly hubUrl: string;
     readonly hub: Hub;
-    /** This start's first run: what it found or made, once it's done; none when it was off. */
-    readonly firstRun?: Promise<FirstRun | undefined>;
+    /** This start's first run: the programs it started, once it's done. */
+    readonly firstRun: Promise<Programs | undefined>;
     /** A fresh one-time sign-in address, `<url>/signin#<code>`. */
     signInUrl(): string;
     /** Serve `path` with `route`, for another part of the app. */
@@ -41,6 +46,6 @@ export interface App {
  * 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 declare function startApp(options: AppOptions): Promise<App>;