@agentorg/cli 0.0.3 → 0.0.4

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/runtime.js

@@ -135,6 +135,113 @@ export function createRuntime(definition, options) {
             throw new Refused("unimplemented", `${name} hasn't been implemented yet.`);
         return state.impl;
     };
+    const exposed = new Map();
+    const exposedWatchers = new Set();
+    /** Run the `onExposed` handlers; one that throws is logged and the rest still run. */
+    const exposedChanged = () => {
+        const failed = (error) => options.log.error("An onExposed handler threw.", { error: String(error) });
+        for (const fn of [...exposedWatchers])
+            try {
+                const done = fn();
+                if (done instanceof Promise)
+                    done.catch(failed);
+            }
+            catch (error) {
+                failed(error);
+            }
+    };
+    /** Subscribe to an exposed slot's event while the module listens and nothing is live. */
+    const listenExposed = (slot, state, event) => {
+        const entry = state.events.get(event);
+        if (state.gone || !entry || entry.stop || !entry.fns.size)
+            return;
+        // A subscription may end before `subscribe` returns: then nothing is live.
+        let ended = false;
+        let stop;
+        stop = state.source.subscribe(event, (payload) => {
+            for (const fn of [...entry.fns])
+                try {
+                    fn(payload);
+                }
+                catch (error) {
+                    options.log.error("An event handler threw.", { slot, event, error: String(error) });
+                }
+        }, 
+        // Ended by the provider going: the interest stays for when it is usable again.
+        () => {
+            ended = true;
+            if (entry.stop === stop)
+                entry.stop = undefined;
+        });
+        if (!ended)
+            entry.stop = stop;
+    };
+    const exposedHandle = (slot, state) => {
+        const { described, provider } = state.source;
+        return Object.freeze({
+            slot,
+            described,
+            provider: Object.freeze({ actor: provider.actor, export: provider.export }),
+            call: Object.freeze(Object.fromEntries((described.kind === "rpc" ? Object.keys(described.methods) : []).map((method) => [
+                method,
+                async (input) => {
+                    if (state.gone)
+                        throw new NotConnected(slot);
+                    return state.source.call(method, input);
+                },
+            ]))),
+            on(event, fn) {
+                if (described.kind !== "rpc" || !own(described.events, event))
+                    throw new TypeError(`${slot} has no event ${event}.`);
+                const entry = state.events.get(event) ?? { fns: new Set() };
+                state.events.set(event, entry);
+                entry.fns.add(fn);
+                listenExposed(slot, state, event);
+                return () => {
+                    entry.fns.delete(fn);
+                    if (entry.fns.size)
+                        return;
+                    entry.stop?.();
+                    entry.stop = undefined;
+                };
+            },
+        });
+    };
+    const unexpose = (slot) => {
+        const state = exposed.get(slot);
+        if (!state)
+            return;
+        exposed.delete(slot);
+        state.gone = true;
+        for (const entry of state.events.values()) {
+            entry.stop?.();
+            entry.stop = undefined;
+        }
+        exposedChanged();
+    };
+    const expose = (slot, source) => {
+        const here = exposed.get(slot);
+        if (here &&
+            here.source.described.hash === source.described.hash &&
+            here.source.provider.actor === source.provider.actor &&
+            here.source.provider.export === source.provider.export) {
+            // Usable again: the same export, its provider back. What was listened to resumes.
+            here.source = source;
+            for (const [event, entry] of here.events) {
+                entry.stop?.();
+                entry.stop = undefined;
+                listenExposed(slot, here, event);
+            }
+            return;
+        }
+        if (here)
+            unexpose(slot);
+        // The handle reads the state, so it is made after; nothing reads it in between.
+        const state = { source, gone: false, events: new Map() };
+        state.handle = exposedHandle(slot, state);
+        exposed.set(slot, state);
+        exposedChanged();
+    };
     const ctx = {
         slots: Object.fromEntries(Object.entries(definition.slots).map(([name, iface]) => [name, slotHandle(name, iface)])),
         exports: Object.assign(Object.fromEntries(Object.entries(definition.exports).map(([name, iface]) => [
@@ -154,6 +261,11 @@ export function createRuntime(definition, options) {
         }),
         self: options.self,
         log: options.log,
+        exposed: () => Object.freeze([...exposed.values()].map((state) => state.handle)),
+        onExposed(fn) {
+            exposedWatchers.add(fn);
+            return () => void exposedWatchers.delete(fn);
+        },
     };
     const serving = (exportName) => {
         const state = target(exportName, "http");
@@ -226,6 +338,8 @@ export function createRuntime(definition, options) {
             if (state.binding)
                 notify(slot, state.binds);
         },
+        expose,
+        unexpose,
         async call(exportName, method, input, caller) {
             const state = target(exportName, "rpc");
             const spec = own(state.iface.methods, method);

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/testing.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import type { Interface, RpcInterface, StreamInterface } from "./interface.js";
+import { type Interface, type RpcInterface, type StreamInterface } from "./interface.js";
 import type { Duplex, Handlers, InterfaceMap, ModuleDefinition } from "./module.js";
 import { type Binding, type ModuleRuntime } from "./runtime.js";
 /** A fake bound to a slot in a test: handlers for `rpc`, a function for `stream` and `http`. */
@@ -22,8 +22,20 @@ export interface LogLine {
  * as the Hub validates it: bad input is `Refused` with code `invalid`, and an unbound slot or a
  * withdrawn export throws `NotConnected`.
  */
-export interface TestContext<S extends InterfaceMap, X extends InterfaceMap> extends Omit<ModuleRuntime<S, X>, "bind" | "call"> {
+export interface TestContext<S extends InterfaceMap, X extends InterfaceMap> extends Omit<ModuleRuntime<S, X>, "bind" | "call" | "expose"> {
     bind<K extends keyof S & string>(slot: K, provider: Provider<S[K]>): Binding;
+    /**
+     * Make a slot at run time, as `hub.grants.expose` does: an `rpc` export faked by `handlers`,
+     * whose values are checked against `iface` as the Hub checks them. `provider` names whose
+     * export it is (by default a made-up Actor's, `export`). Exposing the same slot again with the
+     * same interface and provider makes it usable again; `emit` sends its events.
+     */
+    expose<I extends RpcInterface>(slot: string, iface: I, handlers: Provider<I>, provider?: {
+        actor: string;
+        export: string;
+    }): Binding;
+    /** The slot made at run time goes, as when its binding is removed. */
+    unexpose(slot: string): void;
     /** Call an export as `caller`; by default as the module's own Actor. */
     call(exportName: string, method: string, input: unknown, caller?: string): Promise<unknown>;
     readonly emitted: Emitted[];

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

@@ -0,0 +1,89 @@
+import { Refused } from "./errors.js";
+import { describeInterface, } from "./interface.js";
+import { check, 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);
+        },
+        expose(slot, iface, fake, provider = { actor: "test-provider", export: "export" }) {
+            const handlers = fake;
+            const listeners = new Map();
+            runtime.expose(slot, {
+                described: describeInterface(iface),
+                provider,
+                async call(method, input) {
+                    const spec = Object.hasOwn(iface.methods, method) ? iface.methods[method] : undefined;
+                    if (!spec)
+                        throw new Refused("unknown", `${slot} has no method ${method}.`);
+                    // JSON both ways, as through the Hub, and checked as JSON.
+                    const parsed = check(spec.input, JSON.parse(JSON.stringify(input ?? null)), `${slot}.${method} input`);
+                    const handler = Object.hasOwn(handlers, method) ? handlers[method] : undefined;
+                    if (!handler)
+                        throw new Refused("unimplemented", `${slot}.${method} isn't faked.`);
+                    const output = check(spec.output, await handler(parsed, { caller: self }), `${slot}.${method} output`, "bad_output");
+                    return JSON.parse(JSON.stringify(output ?? null));
+                },
+                subscribe(event, onEvent) {
+                    const set = listeners.get(event) ?? new Set();
+                    listeners.set(event, set);
+                    set.add(onEvent);
+                    return () => void set.delete(onEvent);
+                },
+            });
+            return {
+                emit(event, payload) {
+                    const spec = Object.hasOwn(iface.events, event) ? iface.events[event] : undefined;
+                    if (!spec)
+                        throw new TypeError(`${slot} has no event ${event}.`);
+                    const value = JSON.parse(JSON.stringify(check(spec.payload, payload, `${slot}.${event}`, "bad_output")));
+                    for (const fn of [...(listeners.get(event) ?? [])])
+                        fn(value);
+                },
+            };
+        },
+        unexpose: (slot) => runtime.unexpose(slot),
+        emitted,
+        logs,
+    };
+}

package/{node_modules → dist/node_modules}/@agentorg/shell/dist/app.css

@@ -333,9 +333,22 @@ a {
 .stage {
   flex: 1;
   min-height: 0;
-  display: flex;
   gap: 8px;
 }
+/* The resizable panels hold the chat and the column: what's inside fills them. */
+.panel {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+}
+.panel > * {
+  flex: 1;
+  min-height: 0;
+}
+/* In the gap between the chat and the widgets: it takes no room, and only its line shows. */
+.stage > .kit-resize-handle {
+  margin: 0 -8px;
+}
 .container {
   background: var(--surface);
   border-radius: var(--radius);
@@ -349,40 +362,16 @@ a {
   flex: 1;
 }
 .widgets {
-  /* Its width is the divider's, and never more than half the stage. */
-  max-width: 50%;
-  flex: none;
   display: flex;
   flex-direction: column;
   gap: 8px;
   min-height: 0;
 }
+/* The column's height is shared: each widget fills its share, at least 220 px, never its content's. */
 .widgets .container {
-  flex: none;
-}
-/* In the gap between the chat and the widgets: it takes no room, and only its line shows. */
-.divider {
-  width: 8px;
-  margin: 0 -8px;
-  flex: none;
-  cursor: col-resize;
-  touch-action: none;
-  display: flex;
-  justify-content: center;
-  outline: 0;
-}
-.divider::after {
-  content: "";
-  width: 2px;
-  border-radius: 1px;
-  background: transparent;
-}
-.divider:hover::after,
-.divider:focus-visible::after,
-.divider:active::after {
-  background: var(--ring);
+  flex: 1 1 0;
+  min-height: 220px;
 }
-
 /* A placed view's frame: its header is the shell's, the body is the view's own DOM. */
 .view-head {
   height: 40px;
@@ -398,18 +387,16 @@ a {
   color: var(--muted);
   font-weight: 400;
 }
-.view-head .icon-btn {
+.view-head .kit-icon-button {
   margin-left: auto;
   width: 26px;
   height: 26px;
 }
+/* The frame fills what its placement leaves under the header. */
 .view-body {
   padding: 4px 14px 14px;
-  height: 260px;
-}
-/* Its view reported its height: the frame takes it, and the body fits the frame. */
-.view-body.sized {
-  height: auto;
+  flex: 1;
+  min-height: 0;
 }
 /*
  * A view's own frame. Its color scheme is the frame document's, so the browser paints no backdrop
@@ -434,36 +421,11 @@ a {
   color: var(--muted);
   font-size: 13px;
 }
-.menu {
-  position: absolute;
-  right: 8px;
-  top: 38px;
-  background: var(--raised);
-  border-radius: 10px;
-  padding: 4px;
-  min-width: 150px;
-  z-index: 5;
-  box-shadow: 0 12px 28px rgb(0 0 0 / 0.35);
-}
-.menu button {
-  display: block;
-  width: 100%;
-  text-align: left;
-  border: 0;
-  background: transparent;
-  padding: 7px 10px;
-  border-radius: 7px;
-  font-size: 13px;
-}
-.menu button:hover {
-  background: var(--hover);
-}
-.menu button:disabled,
 .ghost:disabled {
   opacity: 0.6;
   cursor: default;
 }
-.menu-note {
+.kit-menu .menu-note {
   text-align: left;
   padding: 4px 10px 6px;
   max-width: 200px;
@@ -478,10 +440,14 @@ a {
   align-content: start;
   align-items: start;
 }
+/* Home's placements have a height of their own; the view fills it. */
 .home .placed {
   background: var(--card);
   border-radius: 12px;
   position: relative;
+  height: 300px;
+  display: flex;
+  flex-direction: column;
 }
 .home-empty {
   margin: auto;
@@ -537,28 +503,6 @@ a {
   flex: 1;
   min-height: 0;
 }
-.tabs {
-  display: inline-flex;
-  gap: 2px;
-  background: var(--hover);
-  padding: 3px;
-  border-radius: 10px;
-  align-self: flex-start;
-}
-.tabs button {
-  border: 0;
-  background: transparent;
-  padding: 5px 12px;
-  border-radius: 8px;
-  font-size: 13px;
-  color: var(--muted);
-}
-.tabs button[aria-selected="true"] {
-  background: var(--surface);
-  color: var(--fg);
-  font-weight: 600;
-  box-shadow: 0 1px 2px rgb(0 0 0 / 0.2);
-}
 table {
   width: 100%;
   border-collapse: collapse;
@@ -603,29 +547,6 @@ tr:hover td {
 }
 
 /* ---------- Dialog ---------- */
-.scrim {
-  position: fixed;
-  inset: 0;
-  background: rgb(0 0 0 / 0.5);
-  display: grid;
-  place-items: center;
-  z-index: 20;
-  padding: 16px;
-}
-.dialog {
-  width: min(440px, 100%);
-  background: var(--surface);
-  border-radius: 18px;
-  padding: 20px;
-  display: flex;
-  flex-direction: column;
-  gap: 16px;
-  box-shadow: 0 24px 60px rgb(0 0 0 / 0.45);
-}
-.dialog h2 {
-  margin: 0;
-  font-size: 16px;
-}
 .field {
   height: 38px;
   border-radius: 10px;
@@ -658,38 +579,6 @@ tr:hover td {
 .grants .mono {
   margin-left: auto;
 }
-.toggle {
-  width: 30px;
-  height: 18px;
-  border-radius: 9px;
-  background: var(--raised);
-  border: 0;
-  position: relative;
-  padding: 0;
-  flex: none;
-}
-.toggle::after {
-  content: "";
-  position: absolute;
-  top: 2px;
-  left: 2px;
-  width: 14px;
-  height: 14px;
-  border-radius: 50%;
-  background: var(--faint);
-  transition: left 0.12s;
-}
-.toggle[aria-checked="true"] {
-  background: var(--ok);
-}
-.toggle[aria-checked="true"]::after {
-  left: 14px;
-  background: white;
-}
-.toggle:disabled {
-  opacity: 0.5;
-  cursor: default;
-}
 .actions {
   display: flex;
   justify-content: flex-end;
@@ -712,12 +601,6 @@ tr:hover td {
   font-size: 13px;
 }
 
-@media (max-width: 1100px) {
-  .widgets,
-  .divider {
-    display: none;
-  }
-}
 @media (max-width: 760px) {
   .sidebar {
     display: none;
@@ -858,7 +741,7 @@ tr:hover td {
   color: var(--muted);
   font-size: 13px;
 }
-.dialog .steps {
+.kit-dialog .steps {
   display: flex;
   flex-direction: column;
   gap: 14px;