@spencerboucher/switchyard 0.6.0 → 0.8.0

package/README.md

@@ -111,15 +111,15 @@ npm install -g @spencerboucher/switchyard
 switchyard up
 ```
 
-`up` runs the coordinator and a host in one process at `http://localhost:7400`, sets the server up on first start and opens a single-use sign-in link in your browser. Add a project in Settings › Projects (a path to a git repository), then start a session or create a task.
+`up` runs the coordinator and a host in one process at `http://localhost:7400`, prints and opens a single-use sign-in link in your browser on first start. Add a project in Settings › Projects (a path to a git repository), then start a session or create a task.
 
 **Run it as a server** with the container image (it runs only the coordinator):
 
 ```sh
 docker run -d --name switchyard -p 127.0.0.1:7400:7400 -v switchyard-data:/data \
   -e SWITCHYARD_PUBLIC_URL=https://switchyard.example.com \
-  ghcr.io/justmytwospence/switchyard:0.6.0
-docker exec switchyard switchyard init    # prints a single-use sign-in link for your first device
+  ghcr.io/justmytwospence/switchyard:0.8.0
+# Single sign-on is required off localhost: see docs/auth.md
 ```
 
 Put HTTPS in front of it (a reverse proxy, or a VPN or tailnet; the installed phone app, notifications and passkeys need HTTPS). Then, on each machine that should run agents, create a host token in Settings › Hosts › Add host and run:
@@ -136,8 +136,8 @@ Settings › Hosts › Add host shows these three commands with your token fille
 
 ## Security model
 
-- **A server is owned before it serves anything.** Ownership comes from `switchyard init` on the server, or from an owner declared in an OpenID Connect configuration. There is never an "unclaimed" web page.
-- **Only you add devices.** A new device gets in by a pairing link or QR code made from a device you already use, by a passkey, or by single sign-on that matches the configured owner. Each device has its own credential that you can revoke; signing out of an identity provider never breaks an installed app.
+- **A server is owned before it serves anything.** Off localhost, the owner is declared in an OpenID Connect configuration (required). There is never an "unclaimed" web page.
+- **Only you add devices.** A browser gets in by single sign-on that matches the configured owner or by a passkey; a terminal is approved from a browser that is already signed in. Each device has its own credential that you can revoke; signing out of an identity provider never breaks an installed app.
 - **Hosts dial out** with their own revocable credentials; the coordinator holds no provider credentials and needs no access to your home directory or Docker socket.
 - **Agents run with the host user's privileges.** Running the coordinator in a container does not sandbox the agents; run hosts as a user whose access you are comfortable giving an agent.
 
@@ -155,7 +155,7 @@ Switchyard is young and moving quickly. It is tested against Pi `>=1.4.0 <1.6.0`
 | Guide | Covers |
 |---|---|
 | [Deployment](docs/deployment.md) | Single machine, server, reverse proxies, VPNs, hosts, environment reference, privilege model |
-| [Sign-in and devices](docs/auth.md) | The owner model, pairing, passkeys, single sign-on, host enrollment, revocation |
+| [Sign-in and devices](docs/auth.md) | The owner model, single sign-on, passkeys, terminal approval, single sign-on, host enrollment, revocation |
 | [CLI](docs/cli.md) | Every `switchyard` command and credentials |
 | [Terminal sessions](docs/terminal-sessions.md) | Pi's own TUI for every session, from any terminal, and the herdr integration |
 | [Operations](docs/operations.md) | Backup, restore, migrations, retention, logs, health, diagnostics |

package/dist/bridge/switchyard-terminal.js

@@ -11,12 +11,16 @@
  * Dialogs: every extension's `ctx.ui` is the same object, so replacing `select`, `confirm`,
  * `input` and `editor` on it routes all dialogs through the race below. When that object cannot be
  * patched, `remoteDialogs` is false and the host tells remote clients to answer in the terminal.
+ *
+ * Other extensions that draw a custom terminal dialog can also ask the same question as a
+ * web-only dialog through `switchyard.remote-ui.v1` on `pi.events`; the first answer wins.
  */
 import { randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
 import { modelInfo } from "./pi-model.js";
 const PATCHED = Symbol.for("switchyard.terminal");
 const WRAPPED = Symbol.for("switchyard.terminal.wrapped");
+const REMOTE_UI_CHANNEL = "switchyard.remote-ui.v1";
 function messageText(message) {
     const content = message?.content;
     if (typeof content === "string")
@@ -76,12 +80,36 @@ export default function switchyardTerminal(pi) {
     if (!socketPath)
         return;
     let ctx = null;
+    let completer = null;
+    // Work that needs a command context (reload, plugin web views) runs inside a hidden command.
+    const internal = new Map();
+    const runInternal = (fn) => {
+        const token = randomUUID();
+        internal.set(token, fn);
+        // Without expandPromptTemplates Pi sends the text to the model instead of running the command.
+        pi.sendUserMessage(`/switchyard-internal ${token}`, { expandPromptTemplates: true });
+    };
+    try {
+        pi.registerCommand?.("switchyard-internal", {
+            description: "Used by Switchyard's web app",
+            handler: async (args, c) => {
+                const key = String(args ?? "").trim();
+                const run = internal.get(key);
+                internal.delete(key);
+                await run?.(c);
+            },
+        });
+    }
+    catch {
+        // an older Pi: no web views or reload
+    }
     let remoteDialogs = false;
     let entryCount = 0;
     const pending = new Map();
     const early = [];
     const queue = { steering: [], followUp: [] };
     let socket = null;
+    let remoteBacked = 0;
     const send = (obj) => {
         try {
             if (!socket || socket.destroyed)
@@ -219,6 +247,44 @@ export default function switchyardTerminal(pi) {
             });
         });
     };
+    /** A dialog shown only to remote clients (the caller shows its own in the terminal). */
+    const remoteOnly = (method, title, fields, signal) => {
+        const dflt = method === "confirm" ? false : undefined;
+        if (signal?.aborted)
+            return Promise.resolve(dflt);
+        const id = randomUUID();
+        const request = { type: "extension_ui_request", id, method, title, ...fields };
+        return new Promise((resolve) => {
+            let done = false;
+            const onAbort = () => {
+                send({
+                    type: "extension_ui_closed",
+                    id,
+                    by: signal?.reason === "pi" ? "pi" : "terminal",
+                });
+                finish(dflt);
+            };
+            const finish = (value) => {
+                if (done)
+                    return;
+                done = true;
+                remoteBacked--;
+                pending.delete(id);
+                signal?.removeEventListener("abort", onAbort);
+                resolve(value);
+            };
+            remoteBacked++;
+            pending.set(id, { request, onRemote: (body) => finish(parseBody(method, body)) });
+            signal?.addEventListener("abort", onAbort, { once: true });
+            send(request);
+        });
+    };
+    const remoteUi = {
+        select: (title, options, opts) => remoteOnly("select", title, { options }, opts?.signal),
+        confirm: (title, message, opts) => remoteOnly("confirm", title, { message }, opts?.signal),
+        input: (title, placeholder, opts) => remoteOnly("input", title, placeholder !== undefined ? { placeholder } : {}, opts?.signal),
+        editor: (title, prefill, opts) => remoteOnly("editor", title, prefill !== undefined ? { prefill } : {}, opts?.signal),
+    };
     const fire = (method, fields) => send({ type: "extension_ui_request", id: randomUUID(), method, ...fields });
     const patchUi = (c) => {
         try {
@@ -334,6 +400,33 @@ export default function switchyardTerminal(pi) {
                         const name = message.slice(1).split(/\s/)[0];
                         const known = (pi.getCommands?.() ?? []).find((c) => c.name === name);
                         if (known?.source === "extension") {
+                            const args = message.slice(1 + name.length).trim();
+                            const probe = { version: 1, name, args, probe: true };
+                            try {
+                                pi.events?.emit?.("switchyard.web-command.v1", probe);
+                            }
+                            catch {
+                                // no web view
+                            }
+                            if (probe.accept === true) {
+                                runInternal(async (c) => {
+                                    const req = { version: 1, name, args, probe: false, ctx: c };
+                                    try {
+                                        pi.events.emit("switchyard.web-command.v1", req);
+                                        const view = await Promise.race([
+                                            Promise.resolve(req.view),
+                                            new Promise((_, rej) => setTimeout(() => rej(new Error("timed out")), 15000)),
+                                        ]);
+                                        if (!view)
+                                            throw new Error(`/${name} returned no view`);
+                                        respond(id, type, { disposition: "view", view });
+                                    }
+                                    catch (e) {
+                                        respond(id, type, undefined, `/${name} failed: ${e?.message ?? e}`);
+                                    }
+                                });
+                                return;
+                            }
                             pi.sendUserMessage(message, { expandPromptTemplates: true });
                             respond(id, type, { disposition: "handled" });
                             return;
@@ -403,10 +496,13 @@ export default function switchyardTerminal(pi) {
                     return;
                 case "get_commands":
                     respond(id, type, {
-                        commands: (pi.getCommands?.() ?? []).map((c) => ({
+                        commands: (pi.getCommands?.() ?? [])
+                            .filter((c) => c.name !== "switchyard-internal")
+                            .map((c) => ({
                             name: c.name,
                             description: c.description ?? null,
                             source: c.source,
+                            sourceInfo: c.sourceInfo ?? null,
                         })),
                     });
                     return;
@@ -455,6 +551,38 @@ export default function switchyardTerminal(pi) {
                         }
                     });
                     return;
+                case "reload":
+                    if (!ctx) {
+                        respond(id, type, undefined, "Session is not ready");
+                        return;
+                    }
+                    respond(id, type);
+                    runInternal((c) => c.reload());
+                    return;
+                case "complete": {
+                    const text = String(cmd.text ?? "");
+                    if (!completer?.getSuggestions || !/^\/\S+ /.test(text) || text.includes("\n")) {
+                        respond(id, type, { items: [], prefix: "" });
+                        return;
+                    }
+                    const ac = new AbortController();
+                    const timer = setTimeout(() => ac.abort(), 2000);
+                    Promise.resolve(completer.getSuggestions([text], 0, text.length, { signal: ac.signal }))
+                        .then((s) => respond(id, type, {
+                        items: (Array.isArray(s?.items) ? s.items : [])
+                            .filter((i) => typeof i?.value === "string")
+                            .slice(0, 50)
+                            .map((i) => ({
+                            value: i.value,
+                            label: typeof i.label === "string" ? i.label : i.value,
+                            description: typeof i.description === "string" ? i.description : null,
+                        })),
+                        prefix: typeof s?.prefix === "string" ? s.prefix : "",
+                    }))
+                        .catch(() => respond(id, type, { items: [], prefix: "" }))
+                        .finally(() => clearTimeout(timer));
+                    return;
+                }
                 default:
                     respond(id, type, undefined, `Unknown command: ${type}`);
             }
@@ -515,6 +643,18 @@ export default function switchyardTerminal(pi) {
     catch {
         socket = null;
     }
+    try {
+        pi.events?.on?.(REMOTE_UI_CHANNEL, (data) => {
+            const r = data;
+            if (r?.version !== 1 || r.ui || !socket)
+                return;
+            r.ui = remoteUi;
+            r.provider = "switchyard";
+        });
+    }
+    catch {
+        // optional service
+    }
     // ---- events ----
     const on = (name, fn) => {
         try {
@@ -534,6 +674,16 @@ export default function switchyardTerminal(pi) {
     on("session_start", (event, c) => {
         ctx = c;
         patchUi(c);
+        completer = null;
+        try {
+            c.ui?.addAutocompleteProvider?.((current) => {
+                completer = current;
+                return current;
+            });
+        }
+        catch {
+            // RPC or an older Pi: no completions
+        }
         entryCount = c.sessionManager.getEntries().length;
         const sessionId = c.sessionManager.getSessionId();
         const sessionFile = c.sessionManager.getSessionFile() ?? null;
@@ -596,7 +746,13 @@ export default function switchyardTerminal(pi) {
     on("model_select", () => sendModelState());
     on("thinking_level_select", () => sendModelState());
     on("session_before_compact", (event) => send({ type: "compaction_start", reason: event?.reason ?? "manual" }));
-    on("ui_prompt_start", (event) => send({ type: "ui_prompt", event: event.type, kind: event.kind, title: event.title ?? null }));
+    on("ui_prompt_start", (event) => send({
+        type: "ui_prompt",
+        event: event.type,
+        kind: event.kind,
+        title: event.title ?? null,
+        remoteBacked: event.kind === "custom" && remoteBacked > 0,
+    }));
     on("ui_prompt_end", (event) => send({ type: "ui_prompt", event: event.type, kind: event.kind, title: event.title ?? null }));
     on("input", (event) => {
         if (event?.source !== "interactive" || !event.streamingBehavior)