@agentorg/cli 0.0.5 → 0.0.7

package/dist/node_modules/@agentorg/shell/dist/agent-bindings.js

@@ -1,59 +0,0 @@
-const AGENT_GRANTS = [
-  { slot: "model", what: "ChatGPT", iface: "llm.session@1", fixed: true },
-  { slot: "store", what: "its own storage", iface: "kv@1", fixed: true },
-  { slot: "layout", what: "your home", iface: "layout@1", fixed: false },
-  { slot: "packages", what: "install packages", iface: "hub.packages@1", fixed: false },
-  { slot: "actors", what: "create and run Actors", iface: "hub.actors@1", fixed: false },
-  { slot: "grants", what: "ask for connections", iface: "hub.grants@1", fixed: false },
-  { slot: "exports", what: "see what's offered", iface: "hub.exports@1", fixed: false },
-  {
-    slot: "installer",
-    what: "install Actors",
-    iface: "installer@1",
-    fixed: false,
-    needs: "actors"
-  }
-];
-const FIRST_RUN = "app/first-run";
-const PROVIDERS = {
-  model: (ids) => ({ provider: ids.chatgpt, export: "model.session" }),
-  store: () => ({ provider: "storage", export: "kv" }),
-  layout: () => ({ provider: "person", export: "layout" }),
-  packages: () => ({ provider: "hub", export: "packages" }),
-  actors: () => ({ provider: "hub", export: "actors" }),
-  grants: () => ({ provider: "hub", export: "grants" }),
-  exports: () => ({ provider: "hub", export: "exports" }),
-  installer: (ids) => ({ provider: ids.installer, export: "installer.installer" })
-};
-function agentConnections(ids, off = /* @__PURE__ */ new Set()) {
-  return Object.fromEntries(
-    AGENT_GRANTS.filter((grant) => grant.fixed || !off.has(grant.slot)).map((grant) => {
-      const { provider, export: name } = PROVIDERS[grant.slot](ids);
-      return [`logic.${grant.slot}`, { actor: provider, export: name }];
-    })
-  );
-}
-async function agentProviders(call) {
-  const { bindings } = await call("bindings", "list", { actor: "person" });
-  const of = (slot) => bindings.find((b) => b.consumer === "person" && b.slot === slot)?.provider;
-  const chatgpt = of("login");
-  const installer = of("installer");
-  if (!chatgpt || !installer)
-    throw new Error("AgentOrg isn't set up yet. Restart it to finish setting up.");
-  return { chatgpt, installer };
-}
-async function installAgent(call, agent) {
-  return await call("installer", "install", {
-    package: agent.assistant,
-    name: agent.name,
-    connections: agentConnections(await agentProviders(call), agent.off),
-    start: true
-  });
-}
-export {
-  AGENT_GRANTS,
-  FIRST_RUN,
-  agentConnections,
-  agentProviders,
-  installAgent
-};

package/dist/node_modules/@agentorg/shell/src/agent-bindings.ts

@@ -1,107 +0,0 @@
-/**
- * What a new agent gets: the assistant package's slots, each bound at creation (step 5, §4). The
- * slots are its `logic` module's; `model` and `store` it always gets, and the person decides the
- * rest in New agent's dialog. A grant that `needs` another is off while that one is: installing
- * creates and starts Actors.
- */
-export const AGENT_GRANTS = [
-  { slot: "model", what: "ChatGPT", iface: "llm.session@1", fixed: true },
-  { slot: "store", what: "its own storage", iface: "kv@1", fixed: true },
-  { slot: "layout", what: "your home", iface: "layout@1", fixed: false },
-  { slot: "packages", what: "install packages", iface: "hub.packages@1", fixed: false },
-  { slot: "actors", what: "create and run Actors", iface: "hub.actors@1", fixed: false },
-  { slot: "grants", what: "ask for connections", iface: "hub.grants@1", fixed: false },
-  { slot: "exports", what: "see what's offered", iface: "hub.exports@1", fixed: false },
-  {
-    slot: "installer",
-    what: "install Actors",
-    iface: "installer@1",
-    fixed: false,
-    needs: "actors",
-  },
-] as const;
-
-export type AgentSlot = (typeof AGENT_GRANTS)[number]["slot"];
-
-/**
- * Where the app's first run records what it made, in the person's store: its `assistant` is the
- * package New agent installs, by hash, never a package found by its name.
- */
-export const FIRST_RUN = "app/first-run";
-
-/**
- * The Actors a new agent's slots reach beside the built-ins: the person's own ChatGPT (what its
- * `login` is bound to) and installer (what its `installer` is bound to).
- */
-export interface AgentProviders {
-  chatgpt: string;
-  installer: string;
-}
-
-/** Where each slot is served: ChatGPT's session, the installer, the built-ins, the person's layout. */
-const PROVIDERS: Record<AgentSlot, (ids: AgentProviders) => { provider: string; export: string }> =
-  {
-    model: (ids) => ({ provider: ids.chatgpt, export: "model.session" }),
-    store: () => ({ provider: "storage", export: "kv" }),
-    layout: () => ({ provider: "person", export: "layout" }),
-    packages: () => ({ provider: "hub", export: "packages" }),
-    actors: () => ({ provider: "hub", export: "actors" }),
-    grants: () => ({ provider: "hub", export: "grants" }),
-    exports: () => ({ provider: "hub", export: "exports" }),
-    installer: (ids) => ({ provider: ids.installer, export: "installer.installer" }),
-  };
-
-/**
- * A new agent's connections for `installer.install`: every grant but the ones switched off, which
- * can't be `model` or `store`.
- */
-export function agentConnections(
-  ids: AgentProviders,
-  off: ReadonlySet<string> = new Set(),
-): Record<string, { actor: string; export: string }> {
-  return Object.fromEntries(
-    AGENT_GRANTS.filter((grant) => grant.fixed || !off.has(grant.slot)).map((grant) => {
-      const { provider, export: name } = PROVIDERS[grant.slot](ids);
-      return [`logic.${grant.slot}`, { actor: provider, export: name }];
-    }),
-  );
-}
-
-type Call = (slot: string, method: string, input: unknown) => Promise<unknown>;
-
-/**
- * The person's ChatGPT and installer: the Actors the person's `login` and `installer` are bound to,
- * as the app's first run binds them (never an Actor found by its package's name).
- */
-export async function agentProviders(call: Call): Promise<AgentProviders> {
-  const { bindings } = (await call("bindings", "list", { actor: "person" })) as {
-    bindings: { consumer: string; slot: string; provider: string }[];
-  };
-  const of = (slot: string) =>
-    bindings.find((b) => b.consumer === "person" && b.slot === slot)?.provider;
-  const chatgpt = of("login");
-  const installer = of("installer");
-  // Both are bound by the app's first run at its start; one that didn't finish tries again then.
-  if (!chatgpt || !installer)
-    throw new Error("AgentOrg isn't set up yet. Restart it to finish setting up.");
-  return { chatgpt, installer };
-}
-
-/**
- * New agent itself: install the assistant package `assistant` named `name` through the person's
- * `installer`, with `agentConnections` to the person's own ChatGPT and installer, and start it, all
- * or nothing. `call` is the person's call (the shell's `/api`, or a test's). Returns the installer's
- * answer: its id, the slots left unbound (the switched-off ones among them) and the seeds that
- * didn't land.
- */
-export async function installAgent(
-  call: Call,
-  agent: { assistant: string; name: string; off?: ReadonlySet<string> },
-): Promise<{ actorId: string; unbound: string[]; unseeded: string[] }> {
-  return (await call("installer", "install", {
-    package: agent.assistant,
-    name: agent.name,
-    connections: agentConnections(await agentProviders(call), agent.off),
-    start: true,
-  })) as { actorId: string; unbound: string[]; unseeded: string[] };
-}

package/dist/src/frames.d.ts

@@ -1,23 +0,0 @@
-export interface Served {
-    status: number;
-    headers: Record<string, string>;
-    body: string | Uint8Array;
-}
-/** Where a view module's bundle is: its file, if `module` is a `view` module of that package. */
-export type ViewBundle = (hash: string, module: string) => string | undefined;
-/**
- * A frame's policy, on every `/frames/` response: sandboxed with scripts only, so its origin is
- * opaque however it is loaded, and nothing in it can reach the shell origin's storage, where the
- * session is. Scripts only from the gateway's `/frames/`, nothing fetched, no forms, no frames
- * inside. The origin being opaque, `'self'` would match nothing: the gateway's is named. Styles may
- * be inline, as a view sets its own.
- */
-export declare const frameCsp: (origin: string) => string;
-/**
- * Serve `/frames/`: the runtime, a view's frame document and its bundle. A frame has an opaque
- * origin, so a module script it loads is a CORS request from `Origin: null`: only that one is
- * answered `Access-Control-Allow-Origin: null`, and no other origin is allowed to read a script.
- * No request here reads or needs the session. A bundle is served only for a `view` module, by
- * hash, and never changes. `from` is the request's `Origin` header.
- */
-export declare function serveFrame(path: string, origin: string, bundle: ViewBundle, from?: string): Served | undefined;

package/dist/src/frames.js

@@ -1,78 +0,0 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-const HASH = /^sha256-[0-9a-f]{64}$/;
-const MODULE = /^[a-z][A-Za-z0-9_]{0,63}$/;
-/** The SDK's frame runtime, the one script every frame loads first. */
-const runtime = () => readFileSync(createRequire(import.meta.url).resolve("@agentorg/sdk/frame/runtime.js"));
-/**
- * A frame's policy, on every `/frames/` response: sandboxed with scripts only, so its origin is
- * opaque however it is loaded, and nothing in it can reach the shell origin's storage, where the
- * session is. Scripts only from the gateway's `/frames/`, nothing fetched, no forms, no frames
- * inside. The origin being opaque, `'self'` would match nothing: the gateway's is named. Styles may
- * be inline, as a view sets its own.
- */
-export const frameCsp = (origin) => [
-    "default-src 'none'",
-    `script-src ${origin}/frames/`,
-    "style-src 'unsafe-inline'",
-    "img-src data: blob:",
-    "font-src data:",
-    "connect-src 'none'",
-    "form-action 'none'",
-    "base-uri 'none'",
-    `frame-ancestors ${origin}`,
-    // However it's loaded, top-level included, its origin is opaque: nothing runs as the shell's.
-    "sandbox allow-scripts",
-].join("; ");
-/**
- * The frame document: nothing but the runtime, which waits for the shell's port, and the shell's
- * base text, from the theme's tokens once the view is mounted.
- */
-const DOCUMENT = '<!doctype html><html><head><meta charset="utf-8"><style>html,body{margin:0}body{font:14px/1.45 var(--font, ui-sans-serif, system-ui, sans-serif);color:var(--fg)}</style><script type="module" src="/frames/runtime.js"></script></head><body></body></html>';
-/**
- * Serve `/frames/`: the runtime, a view's frame document and its bundle. A frame has an opaque
- * origin, so a module script it loads is a CORS request from `Origin: null`: only that one is
- * answered `Access-Control-Allow-Origin: null`, and no other origin is allowed to read a script.
- * No request here reads or needs the session. A bundle is served only for a `view` module, by
- * hash, and never changes. `from` is the request's `Origin` header.
- */
-export function serveFrame(path, origin, bundle, from) {
-    const base = {
-        "Content-Security-Policy": frameCsp(origin),
-        "X-Content-Type-Options": "nosniff",
-        "Referrer-Policy": "no-referrer",
-    };
-    const script = {
-        ...base,
-        "Content-Type": "text/javascript; charset=utf-8",
-        // A sandboxed frame's own request: nothing else needs to read a script across origins.
-        ...(from === "null" ? { "Access-Control-Allow-Origin": "null" } : {}),
-        Vary: "Origin",
-    };
-    if (path === "/frames/runtime.js")
-        return { status: 200, headers: { ...script, "Cache-Control": "no-cache" }, body: runtime() };
-    const match = /^\/frames\/([^/]+)\/([^/]+)\.(html|js)$/.exec(path);
-    if (!match)
-        return undefined;
-    const [, hash = "", module = "", kind] = match;
-    if (!HASH.test(hash) || !MODULE.test(module))
-        return undefined;
-    const file = bundle(hash, module);
-    if (!file)
-        return undefined;
-    if (kind === "html")
-        return {
-            status: 200,
-            headers: {
-                ...base,
-                "Content-Type": "text/html; charset=utf-8",
-                "Cache-Control": "no-cache",
-            },
-            body: DOCUMENT,
-        };
-    return {
-        status: 200,
-        headers: { ...script, "Cache-Control": "public, max-age=31536000, immutable" },
-        body: readFileSync(file),
-    };
-}

package/dist/src/layout.d.ts

@@ -1,44 +0,0 @@
-import type { Placement } from "@agentorg/interfaces";
-import type { z } from "zod";
-export type PlacementRecord = z.output<typeof Placement>;
-/** Where the layout is kept: the person's `kv@1` slot, under one key. */
-export interface LayoutStore {
-    get(key: string): Promise<{
-        value?: unknown;
-    }>;
-    set(key: string, value: unknown): Promise<unknown>;
-}
-/** The key the layout is kept under, in the person's store. */
-export declare const LAYOUT_KEY = "layout";
-/**
- * `layout@1`'s logic: what the person has placed, in order, kept in its own store, so it is state
- * like any other Actor's. Writes run one at a time; each one tells `changed`. `isView` says whether
- * a module is a `view` module of an Actor's package, the only thing `place` accepts.
- */
-export declare class Layout {
-    #private;
-    constructor(options: {
-        store: () => LayoutStore;
-        isView(actor: string, module: string): boolean;
-        changed(): void;
-    });
-    get(): Promise<{
-        home: PlacementRecord[];
-    }>;
-    /** Place a view, recording `by`, the Actor that asked, as the call's caller says. */
-    place(input: {
-        actor: string;
-        module: string;
-        title?: string;
-        after?: string;
-    }, by: string): Promise<{
-        id: string;
-    }>;
-    remove(input: {
-        id: string;
-    }): Promise<{}>;
-    move(input: {
-        id: string;
-        after?: string;
-    }): Promise<{}>;
-}

package/dist/src/layout.js

@@ -1,90 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { Refused } from "@agentorg/sdk";
-/** The key the layout is kept under, in the person's store. */
-export const LAYOUT_KEY = "layout";
-/** Placements one layout holds; past it, `place` is refused. */
-const MAX_PLACEMENTS = 200;
-/**
- * `layout@1`'s logic: what the person has placed, in order, kept in its own store, so it is state
- * like any other Actor's. Writes run one at a time; each one tells `changed`. `isView` says whether
- * a module is a `view` module of an Actor's package, the only thing `place` accepts.
- */
-export class Layout {
-    #store;
-    #isView;
-    #changed;
-    #queue = Promise.resolve();
-    constructor(options) {
-        this.#store = options.store;
-        this.#isView = options.isView;
-        this.#changed = options.changed;
-    }
-    async get() {
-        return { home: await this.#read() };
-    }
-    /** Place a view, recording `by`, the Actor that asked, as the call's caller says. */
-    place(input, by) {
-        return this.#write((home) => {
-            if (!this.#isView(input.actor, input.module))
-                throw new Refused("invalid", `${input.actor}.${input.module} isn't a view module of a running package Actor.`);
-            if (home.length >= MAX_PLACEMENTS)
-                throw new Refused("quota", `A layout holds ${MAX_PLACEMENTS} placements at most.`);
-            const placement = {
-                id: randomBytes(9).toString("base64url"),
-                actor: input.actor,
-                module: input.module,
-                ...(input.title === undefined ? {} : { title: input.title }),
-                by,
-            };
-            return { home: insert(home, placement, input.after), result: { id: placement.id } };
-        });
-    }
-    remove(input) {
-        return this.#write((home) => {
-            at(home, input.id);
-            return { home: home.filter((placement) => placement.id !== input.id), result: {} };
-        });
-    }
-    move(input) {
-        return this.#write((home) => {
-            const placement = at(home, input.id);
-            if (input.after === input.id)
-                throw new Refused("invalid", "A placement can't follow itself.");
-            const rest = home.filter((other) => other.id !== input.id);
-            // Moved with no `after`, it goes first; placed with none, last.
-            return { home: insert(rest, placement, input.after ?? null), result: {} };
-        });
-    }
-    async #read() {
-        const { value } = await this.#store().get(LAYOUT_KEY);
-        return Array.isArray(value) ? value : [];
-    }
-    /** One write at a time: read, change, write back, then tell. */
-    #write(change) {
-        const run = this.#queue.then(async () => {
-            const { home, result } = change(await this.#read());
-            await this.#store().set(LAYOUT_KEY, home);
-            this.#changed();
-            return result;
-        });
-        this.#queue = run.catch(() => { });
-        return run;
-    }
-}
-function at(home, id) {
-    const found = home.find((placement) => placement.id === id);
-    if (!found)
-        throw new Refused("unknown", `No placement ${id}.`);
-    return found;
-}
-/** `placement` after the one with id `after`: first for `null`, last for `undefined`. */
-function insert(home, placement, after) {
-    if (after === undefined)
-        return [...home, placement];
-    if (after === null)
-        return [placement, ...home];
-    const index = home.findIndex((other) => other.id === after);
-    if (index < 0)
-        throw new Refused("unknown", `No placement ${after}.`);
-    return [...home.slice(0, index + 1), placement, ...home.slice(index + 1)];
-}

package/dist/src/model.d.ts

@@ -1,54 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-/**
- * How the first run reaches the Hub: the person's own calls, as `/api` makes them. A call that
- * doesn't reach its provider rejects with an error named `NotConnected`, as `/api` names it.
- */
-export interface PersonCalls {
-    call(slot: string, method: string, input: unknown): Promise<unknown>;
-}
-/** An export of a running Actor. */
-export interface Target {
-    actor: string;
-    export: string;
-}
-export interface FirstRunOptions {
-    /** Where the bundled archives and their `index.json` are; the app's own by default. */
-    bundled?: string;
-    /** What the model Actor's `web` connects to: the built-in `net`'s `egress` by default. */
-    egress?: Target;
-    /** Where the first run says what it did, and what it couldn't. */
-    log?: (message: string) => void;
-    /**
-     * Whether an Actor's process is connected (the Hub's `connected`): the first run waits for the
-     * installer's before it installs through it. Without it, it installs at once.
-     */
-    connected?: (actorId: string) => boolean;
-}
-export interface FirstRun {
-    /** The bundled packages by name, each added. */
-    packages: Record<string, string>;
-    /** The installer Actor and the model Actor, when they exist. */
-    installer?: string;
-    chatgpt?: string;
-}
-/**
- * The first run, at every start after the person's store is bound: add the bundled packages,
- * ensure the installer (made by the person, with its bindings, started), bind the person's
- * `installer` to it, ensure the model Actor installed through it (`web` to `egress`, `store` to
- * storage's `kv`, started), and bind the person's `login` to the model's. What earlier runs made
- * (recorded in the person's store) is kept and brought to this build: an installer or model Actor
- * on another package is upgraded in place, with its id, its store and its bindings; so is an agent
- * on an assistant build an earlier run bundled (by the hashes recorded, never by a package's
- * name). A binding an upgrade drops, its interface having changed, is made again where its ends
- * match now. A step that fails is logged and the rest still runs where it can; the next start
- * tries again.
- */
-export declare function firstRun(person: PersonCalls, options?: FirstRunOptions): Promise<FirstRun>;
-/**
- * `/oauth/chatgpt`: where ChatGPT sends the browser back. It hands the whole callback address to
- * the person's `login.complete`, then sends the tab on to `?result=<outcome>`, an address without
- * the sign-in's code, so the code stays out of the tab's address and history; that page says how
- * it went and links back to the shell. The code is never logged or shown, and no page sends a
- * referrer.
- */
-export declare function oauthRoute(person: PersonCalls): (request: IncomingMessage, response: ServerResponse, url: URL) => void;