@agentorg/cli 0.0.3 → 0.0.4

package/{node_modules → dist/node_modules}/@agentorg/shell/package.json

@@ -24,6 +24,7 @@
   },
   "devDependencies": {
     "@agentorg/interfaces": "0.0.0",
+    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",

package/{node_modules → dist/node_modules}/@agentorg/wire/dist/src/index.d.ts

@@ -1,4 +1,4 @@
 export { encodeFrame, FrameError, FrameReader, MAX_FRAME } from "./frames.js";
-export { type Body, eventBody, type Header, HeaderError, input, parseBody, parseHeader, result, type WireError, type WireErrorName, wireError, } from "./ops.js";
+export { type Body, type Exposure, eventBody, type Header, HeaderError, input, parseBody, parseHeader, result, type WireError, type WireErrorName, wireError, } from "./ops.js";
 export { MAX_UNREAD, memoryPair, type WebSocketLike, webSocketChannel } from "./transports.js";
 export { type Duplex, GO_AWAY, Session, type SessionOptions, YamuxError, type YamuxStream, } from "./yamux.js";

package/{node_modules → dist/node_modules}/@agentorg/wire/dist/src/ops.d.ts

@@ -69,11 +69,16 @@ export type Header =
     op: "withdraw";
     name: string;
 }
-/** From the Hub to an Actor: one of its slots was bound or unbound. */
+/**
+ * From the Hub to an Actor: one of its slots was bound or unbound. A slot made at run time (an
+ * export exposed to this Actor) carries `exposed` while bound: the export's described interface
+ * and which Actor's export it is. Unbound, it is gone.
+ */
  | {
     op: "slot";
     name: string;
     bound: boolean;
+    exposed?: Exposure;
 }
 /**
  * From the Hub to a provider: the same four, naming its export, who is calling, and through which
@@ -89,6 +94,14 @@ export type Header =
     event?: string;
     params?: unknown;
 };
+/** A slot made at run time, as the Hub describes it: the export's interface, and whose it is. */
+export interface Exposure {
+    interface: unknown;
+    provider: {
+        actor: string;
+        export: string;
+    };
+}
 export type WireErrorName = "NotConnected" | "Refused" | "OutcomeUnknown";
 /** How a refusal crosses the wire; the SDK maps it to its error classes. */
 export interface WireError {

package/{node_modules → dist/node_modules}/@agentorg/wire/dist/src/ops.js

@@ -37,10 +37,30 @@ export function parseHeader(value) {
             return { op: "offer", name: text(value, "name"), interface: value.interface };
         case "withdraw":
             return { op: "withdraw", name: text(value, "name") };
-        case "slot":
+        case "slot": {
             if (typeof value.bound !== "boolean")
                 throw new HeaderError("A slot header needs bound.");
-            return { op: "slot", name: text(value, "name"), bound: value.bound };
+            if (!("exposed" in value))
+                return { op: "slot", name: text(value, "name"), bound: value.bound };
+            const exposed = value.exposed;
+            if (!value.bound ||
+                !isRecord(exposed) ||
+                !isRecord(exposed.interface) ||
+                !isRecord(exposed.provider))
+                throw new HeaderError("A slot header's exposed is a bound slot's {interface, provider}.");
+            return {
+                op: "slot",
+                name: text(value, "name"),
+                bound: true,
+                exposed: {
+                    interface: exposed.interface,
+                    provider: {
+                        actor: text(exposed.provider, "actor"),
+                        export: text(exposed.provider, "export"),
+                    },
+                },
+            };
+        }
         case "serve": {
             const kind = value.kind;
             if (kind !== "call" && kind !== "subscribe" && kind !== "open" && kind !== "http")

package/dist/src/cli.js

@@ -6,6 +6,7 @@ import { parseArgs } from "node:util";
 import { hubHome, personCall, UsageError } from "@agentorg/sdk/person-commands";
 import WebSocket from "ws";
 const USAGE = `Usage: agentorg [command] [--home DIR]
+       agentorg --version
 
   (no command) [--port N] [--no-open]       run AgentOrg: the Hub, your gateway and the shell
   open                                      sign a browser in to the running app
@@ -37,11 +38,33 @@ const { values, positionals } = parseArgs({
         port: { type: "string" },
         "no-open": { type: "boolean" },
         help: { type: "boolean", short: "h" },
+        version: { type: "boolean" },
     },
     allowPositionals: true,
     strict: false,
 });
 const [command, ...rest] = positionals;
+// `build` and `hub` are the SDK's, which reads their 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") {
+    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 --.`);
+    // A value is a word of its own: an option in its place means the value is missing.
+    for (const [name, what] of [
+        ["home", "a directory"],
+        ["port", "a port number"],
+    ]) {
+        const value = values[name];
+        if (typeof value === "boolean" || value?.startsWith("-"))
+            usage(`--${name} takes ${what}.`);
+    }
+}
+if (values.version && command === undefined) {
+    const own = new URL("../../package.json", import.meta.url);
+    write(process.stdout, JSON.parse(readFileSync(own, "utf8")).version);
+    process.exit(0);
+}
 if (values.help && command === undefined) {
     process.stdout.write(USAGE);
     process.exit(0);

package/dist/src/gateway.js

@@ -4,7 +4,7 @@ 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, hubActors, hubAudit, hubBindings, hubExports, hubGrants, hubPackages, installer, kv, layout, } from "@agentorg/interfaces";
+import { accountLogin, appRules, hubActors, hubAudit, hubBindings, hubExports, hubGrants, hubPackages, installer, kv, layout, } from "@agentorg/interfaces";
 import { Refused } from "@agentorg/sdk";
 import { connect } from "@agentorg/sdk/client";
 import { WebSocketServer } from "ws";
@@ -12,6 +12,7 @@ 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 { SignIn } from "./signin.js";
 import { MAX_TRANSFER, packageArchive, pinnedHashes, readSystem, withTemporaryFile, writeSystem, } from "./transfer.js";
 /**
@@ -64,6 +65,8 @@ export async function startApp(options) {
     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 {
@@ -128,6 +131,24 @@ export async function startApp(options) {
     /** The person's side of `/api`: its slots, and `layout`, its own export, served here. */
     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]
@@ -154,6 +175,13 @@ export async function startApp(options) {
             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.");
@@ -194,6 +222,18 @@ export async function startApp(options) {
             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,
+        log: (message) => process.stderr.write(`${message}\n`),
+        changed: () => {
+            for (const tell of [...ruleChanges])
+                tell();
+        },
+    });
+    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'",
@@ -461,6 +501,7 @@ export async function startApp(options) {
         closing ??= (async () => {
             // A first run still going finishes first, so it isn't cut off half way.
             await ran;
+            rules.close();
             const ours = (file, text) => {
                 if (file === "cli-token")
                     return text.trim() === signIn.cliToken;

package/dist/src/rules.d.ts

@@ -0,0 +1,71 @@
+import type { PersonSide } from "./api.js";
+/** Where the rules that are on are kept, in the person's store: `{<id>: {on}}`. */
+export declare const RULES_KEY = "app/rules";
+/** An exposure a request asks for: `provider`'s `export`, as a slot on `to`. */
+export interface Exposure {
+    provider: string;
+    export: string;
+    to: string;
+    as?: string;
+}
+/** An exposure as a request asks for it: by whom, and which side it lacks. */
+export interface Asked extends Exposure {
+    requestedBy?: string;
+    /** The side the requester lacks: `export` when it holds the slot side, as `to` does. */
+    needs?: string;
+}
+/** An open request, as `hub.grants` tells it. */
+export interface Request {
+    requestId: string;
+    [field: string]: unknown;
+}
+/**
+ * The exposure an open request asks for, if it asks for one. The one place that reads the Hub's
+ * request shape for exposures.
+ */
+export declare function exposureOf(request: Request): Asked | undefined;
+interface Definition {
+    id: string;
+    name: string;
+    says: string;
+    /** Whether this rule approves the exposure, read from the Hub as the person. */
+    approves(asked: Asked, person: PersonSide): Promise<boolean>;
+}
+/** The rules the app knows, in the order Settings lists them. */
+export declare const DEFINITIONS: readonly Definition[];
+export interface RulesOptions {
+    person: PersonSide;
+    /** Where the rules say what they approved, and what they couldn't. */
+    log?: (message: string) => void;
+    /** Told after a rule is turned on or off. */
+    changed?: () => void;
+}
+/**
+ * The rules, for `app.rules@1`, and their engine: it hears each request the person could approve,
+ * and goes through the open ones at start and whenever a rule is turned on. It approves a request a
+ * rule that is on matches, as an approver does, with the call the request asked for; the Hub checks
+ * that the person could grant it. It never declines: anything no rule matches stays for the person.
+ */
+export declare class Rules {
+    #private;
+    constructor(options: RulesOptions);
+    list(): Promise<{
+        rules: {
+            id: string;
+            name: string;
+            says: string;
+            on: boolean;
+        }[];
+    }>;
+    set({ id, on }: {
+        id: string;
+        on: boolean;
+    }): Promise<Record<string, never>>;
+    /** Hear each new request, and settle the open ones. */
+    start(): Promise<void>;
+    /** Stop: nothing more is heard, and a sweep under way approves nothing more. */
+    close(): void;
+    /** Go through every open request the person could approve. */
+    sweep(): Promise<void>;
+}
+export {};

package/dist/src/rules.js

@@ -0,0 +1,157 @@
+// The person's named rules: conveniences the person turns on, held by the gateway, which acts on a
+// rule that is on as the person (a manager) and only within what the person could grant. Each rule
+// is named and visible, and off until the person turns it on; nothing else acts on provenance.
+import { Refused } from "@agentorg/sdk";
+/** Where the rules that are on are kept, in the person's store: `{<id>: {on}}`. */
+export const RULES_KEY = "app/rules";
+/**
+ * The exposure an open request asks for, if it asks for one. The one place that reads the Hub's
+ * request shape for exposures.
+ */
+export function exposureOf(request) {
+    const { exposed, provider, export: name, consumer, slot, requestedBy, needs, } = request;
+    if (exposed !== true)
+        return undefined;
+    if (typeof provider !== "string" || typeof name !== "string" || typeof consumer !== "string")
+        return undefined;
+    return {
+        provider,
+        export: name,
+        to: consumer,
+        ...(typeof slot === "string" ? { as: slot } : {}),
+        ...(typeof requestedBy === "string" ? { requestedBy } : {}),
+        ...(typeof needs === "string" ? { needs } : {}),
+    };
+}
+/** The rules the app knows, in the order Settings lists them. */
+export const DEFINITIONS = [
+    {
+        id: "agents-use-what-they-install",
+        name: "Let an agent use what it installs",
+        says: "When an agent asks to use an Actor it installed, approve it.",
+        async approves(asked, person) {
+            // The agent asked for itself: it holds its slot side and lacks the export side.
+            if (asked.requestedBy !== asked.to || asked.needs !== "export")
+                return false;
+            // Provenance only: who the installer installed it for. The Hub grants nothing from it.
+            const actor = (await person.call("actors", "get", { actorId: asked.provider }));
+            return actor.state !== "closed" && actor.installedFor === asked.to;
+        },
+    },
+];
+/**
+ * The rules, for `app.rules@1`, and their engine: it hears each request the person could approve,
+ * and goes through the open ones at start and whenever a rule is turned on. It approves a request a
+ * rule that is on matches, as an approver does, with the call the request asked for; the Hub checks
+ * that the person could grant it. It never declines: anything no rule matches stays for the person.
+ */
+export class Rules {
+    #person;
+    #log;
+    #changed;
+    /** Requests being settled, so an event and a sweep don't settle one twice. */
+    #settling = new Set();
+    #stop;
+    #closed = false;
+    /** Turning rules on and off, one at a time, so none is lost. */
+    #setting = Promise.resolve();
+    constructor(options) {
+        this.#person = options.person;
+        this.#log = options.log ?? (() => { });
+        this.#changed = options.changed ?? (() => { });
+    }
+    /** The ids of the rules that are on. */
+    async #on() {
+        const { value } = (await this.#person.call("store", "get", { key: RULES_KEY }));
+        const held = typeof value === "object" && value !== null ? value : {};
+        return new Set(DEFINITIONS.filter((rule) => held[rule.id]?.on === true).map((rule) => rule.id));
+    }
+    async list() {
+        const on = await this.#on();
+        return {
+            rules: DEFINITIONS.map(({ id, name, says }) => ({ id, name, says, on: on.has(id) })),
+        };
+    }
+    set({ id, on }) {
+        if (!DEFINITIONS.some((rule) => rule.id === id))
+            return Promise.reject(new Refused("unknown", `There is no rule ${id}.`));
+        const done = this.#setting.then(async () => {
+            const now = await this.#on();
+            if (on)
+                now.add(id);
+            else
+                now.delete(id);
+            await this.#person.call("store", "set", {
+                key: RULES_KEY,
+                value: Object.fromEntries([...now].map((ruleId) => [ruleId, { on: true }])),
+            });
+            this.#changed();
+            // Turned on, it settles what already waits for it; a sweep that fails is logged, as the
+            // rule is on either way.
+            if (on)
+                await this.sweep().catch((error) => this.#log(`The rules couldn't go through what waits: ${messageOf(error)}`));
+            return {};
+        });
+        this.#setting = done.catch(() => { });
+        return done;
+    }
+    /** Hear each new request, and settle the open ones. */
+    async start() {
+        await this.sweep();
+    }
+    /** Hear each new request, once; heard again after a subscription that ended. */
+    #listen() {
+        if (this.#closed)
+            return;
+        this.#stop ??= this.#person.subscribe("grants", "requested", (request) => void this.#settle(request), () => {
+            this.#stop = undefined;
+        });
+    }
+    /** Stop: nothing more is heard, and a sweep under way approves nothing more. */
+    close() {
+        this.#closed = true;
+        this.#stop?.();
+        this.#stop = undefined;
+    }
+    /** Go through every open request the person could approve. */
+    async sweep() {
+        this.#listen();
+        for (const request of await this.#open())
+            await this.#settle(request);
+    }
+    async #open() {
+        if (this.#closed)
+            return [];
+        return (await this.#person.call("grants", "requests", {}))
+            .requests;
+    }
+    async #settle(request) {
+        const asked = exposureOf(request);
+        if (!asked || this.#closed || this.#settling.has(request.requestId))
+            return;
+        this.#settling.add(request.requestId);
+        try {
+            const on = await this.#on();
+            for (const rule of DEFINITIONS) {
+                if (!on.has(rule.id) || !(await rule.approves(asked, this.#person)))
+                    continue;
+                // Still open just before: one the person declined, or that was settled meanwhile, is left.
+                if (!(await this.#open()).some((open) => open.requestId === request.requestId))
+                    return;
+                const { provider, export: name, to, as } = asked;
+                const exposure = { provider, export: name, to, ...(as ? { as } : {}) };
+                // As an approver approves: the call the request asked for, checked by the Hub.
+                await this.#person.call("grants", "expose", exposure);
+                this.#log(`Rule "${rule.name}" approved ${exposure.provider}'s ${exposure.export} for ${exposure.to}.`);
+                return;
+            }
+        }
+        catch (error) {
+            this.#log(`A rule couldn't settle request ${request.requestId}: ${messageOf(error)}`);
+        }
+        finally {
+            this.#settling.delete(request.requestId);
+        }
+    }
+}
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/cli",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "AgentOrg as one app: the Hub, the person's gateway and the shell, on loopback.",
   "license": "MIT",
   "repository": {
@@ -24,27 +24,24 @@
   "files": [
     "dist/src",
     "dist/bundled",
-    "static"
+    "static",
+    "dist/node_modules"
   ],
   "dependencies": {
-    "@agentorg/hub": "0.0.0",
-    "@agentorg/interfaces": "0.0.0",
-    "@agentorg/sdk": "0.0.0",
-    "@agentorg/shell": "0.0.0",
+    "@assistant-ui/react": "^0.15.32",
     "ajv": "^8.20.0",
     "esbuild": "0.28.2",
+    "radix-ui": "^1.8.1",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "react-markdown": "^10.1.0",
+    "react-resizable-panels": "^4.19.1",
+    "remark-gfm": "^4.0.1",
+    "remend": "^1.4.0",
     "ws": "^8.22.1",
-    "zod": "^4.6.7",
-    "@agentorg/wire": "0.0.0"
+    "zod": "^4.6.7"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "bundleDependencies": [
-    "@agentorg/wire",
-    "@agentorg/sdk",
-    "@agentorg/interfaces",
-    "@agentorg/hub",
-    "@agentorg/shell"
-  ]
+  }
 }

package/node_modules/@agentorg/sdk/dist/src/testing.js

@@ -1,51 +0,0 @@
-import { Refused } from "./errors.js";
-import { createRuntime } from "./runtime.js";
-export function createTestContext(definition, options = {}) {
-    const emitted = [];
-    const logs = [];
-    const line = (level) => (message, fields) => void logs.push(fields === undefined ? { level, message } : { level, message, fields });
-    const log = { info: line("info"), warn: line("warn"), error: line("error") };
-    const self = options.actorId ?? "test-actor";
-    const runtime = createRuntime(definition, {
-        self: { actorId: self, module: options.module ?? "main" },
-        log,
-        onEmit: (exportName, event, payload, to) => void emitted.push({
-            export: exportName,
-            event,
-            payload,
-            ...(to === undefined ? {} : { to }),
-        }),
-    });
-    return {
-        ...runtime,
-        call: (exportName, method, input, caller = self) => runtime.call(exportName, method, input, caller),
-        bind(slot, fake) {
-            const iface = definition.slots[slot];
-            let provider;
-            if (iface.kind === "rpc") {
-                const handlers = fake;
-                // The module itself is the caller of its own slot.
-                const call = { caller: self };
-                provider = {
-                    async call(method, input) {
-                        const handler = Object.hasOwn(handlers, method) ? handlers[method] : undefined;
-                        if (!handler)
-                            throw new Refused("unimplemented", `${slot}.${method} isn't faked.`);
-                        return handler(input, call);
-                    },
-                };
-            }
-            else if (iface.kind === "stream") {
-                const open = fake;
-                provider = { open: async (params) => open(params) };
-            }
-            else {
-                const fetch = fake;
-                provider = { fetch: async (request) => fetch(request) };
-            }
-            return runtime.bind(slot, provider);
-        },
-        emitted,
-        logs,
-    };
-}