@spencerboucher/switchyard 0.5.0 → 0.7.0

package/README.md

@@ -76,7 +76,7 @@ sequenceDiagram
 
 | Area | What you get |
 |---|---|
-| **Sessions** | Persistent Pi conversations on any host; the same live session in every client; steer or queue follow-ups; take over and return to automation; resume after crashes with the same conversation (never a silent new one); import existing Pi sessions |
+| **Sessions** | Persistent Pi conversations on any host; the same live session in every client; steer or queue follow-ups; take over and return to automation; resume after crashes with the same conversation (never a silent new one); import existing Pi sessions; switch model and effort, see context use and compact, a slash-command picker |
 | **Workspaces** | A git worktree per task or session inside the repository, discovery of worktrees you made yourself, setup commands, removal that refuses to lose uncommitted or unmerged work, and project folders per host whose repositories are added automatically |
 | **Tasks and board** | Backlog, Ready, In progress, Review, Done; dependencies with cycle detection; priorities; per-project concurrency limits; a Now view explaining why queued work waits |
 | **Review** | Changed files and diffs on desktop and phone, line comments sent as one follow-up, request changes, accept |
@@ -100,6 +100,8 @@ sequenceDiagram
 | **Device** | A signed-in client: a browser, an installed web app or a terminal |
 | **Adapter** | Code that renders a specific Pi plugin's questions and state as structured UI |
 
+A seeded **Vanilla** profile runs stock Pi (no extensions, skills or prompt templates).
+
 ## Quick start
 
 **Try it on one machine** (Node 24 or newer, git, and Pi 1.4 or 1.5 on your PATH):
@@ -109,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.5.0
-docker exec switchyard switchyard init    # prints a single-use sign-in link for your first device
+  ghcr.io/justmytwospence/switchyard:0.7.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:
@@ -134,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.
 
@@ -153,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/pi-model.js

@@ -0,0 +1,44 @@
+/**
+ * Model and thinking-level helpers shared by the Switchyard Pi extensions and `ManagedSession`.
+ * Imports nothing, so it can be loaded by Pi next to the extensions.
+ */
+/** Pi 1.4's thinking levels (pi-ai EXTENDED_THINKING_LEVELS), in order. */
+export const PI_THINKING_LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/** Pi 1.4 `getSupportedThinkingLevels` (pi-ai dist/models.js:693); passes through an already-mapped `thinkingLevels`. */
+export function supportedThinkingLevels(model) {
+    const known = PI_THINKING_LEVELS;
+    if (Array.isArray(model?.thinkingLevels)) {
+        return model.thinkingLevels.filter((l) => typeof l === "string" && known.includes(l));
+    }
+    if (!model?.reasoning)
+        return ["off"];
+    return PI_THINKING_LEVELS.filter((level) => {
+        const mapped = model.thinkingLevelMap?.[level];
+        if (mapped === null)
+            return false;
+        if (level === "xhigh" || level === "max")
+            return mapped !== undefined;
+        return true;
+    });
+}
+export function modelInfo(model) {
+    if (!model || typeof model.provider !== "string" || typeof model.id !== "string")
+        return null;
+    return {
+        provider: model.provider,
+        id: model.id,
+        name: typeof model.name === "string" && model.name ? model.name : null,
+        contextWindow: typeof model.contextWindow === "number" ? model.contextWindow : null,
+        reasoning: model.reasoning === true,
+        thinkingLevels: supportedThinkingLevels(model),
+    };
+}
+//# sourceMappingURL=pi-model.js.map

package/dist/bridge/switchyard-bridge.js

@@ -8,6 +8,7 @@
  * never throws: any socket error disables forwarding for the rest of the process.
  */
 import { createConnection } from "node:net";
+import { modelInfo } from "./pi-model.js";
 export default function switchyardBridge(pi) {
     const socketPath = process.env.SWITCHYARD_BRIDGE_SOCKET;
     if (!socketPath)
@@ -46,8 +47,9 @@ export default function switchyardBridge(pi) {
             return null;
         }
     };
-    const send = (s, msg) => {
+    const send = (s, msg, extra = {}) => {
         const full = {
+            ...extra,
             type: msg.type,
             ...(msg.kind !== undefined ? { kind: msg.kind } : {}),
             title: msg.title ?? null,
@@ -77,15 +79,35 @@ export default function switchyardBridge(pi) {
             disabled = true;
         }
     };
+    const sendModelState = (ctx) => {
+        try {
+            const s = ensureSocket();
+            if (!s)
+                return;
+            send(s, { type: "model_state" }, {
+                model: modelInfo(ctx?.model),
+                thinkingLevel: ctx?.thinkingLevel ?? null,
+                scoped: (ctx?.scopedModels ?? [])
+                    .map((s) => s?.model?.provider && s?.model?.id ? `${s.model.provider}/${s.model.id}` : null)
+                    .filter(Boolean),
+            });
+        }
+        catch {
+            disabled = true;
+        }
+    };
     try {
-        pi.on("session_start", () => {
+        pi.on("session_start", (_event, ctx) => {
             try {
                 ensureSocket();
             }
             catch {
                 disabled = true;
             }
+            sendModelState(ctx);
         });
+        pi.on("model_select", (_event, ctx) => sendModelState(ctx));
+        pi.on("thinking_level_select", (_event, ctx) => sendModelState(ctx));
         pi.on("ui_prompt_start", forward);
         pi.on("ui_prompt_end", forward);
         pi.on("session_shutdown", () => {

package/dist/bridge/switchyard-terminal.js

@@ -11,11 +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")
@@ -81,6 +86,7 @@ export default function switchyardTerminal(pi) {
     const early = [];
     const queue = { steering: [], followUp: [] };
     let socket = null;
+    let remoteBacked = 0;
     const send = (obj) => {
         try {
             if (!socket || socket.destroyed)
@@ -91,6 +97,14 @@ export default function switchyardTerminal(pi) {
             // never throw into Pi
         }
     };
+    const sendModelState = () => send({
+        type: "model_state",
+        model: modelInfo(ctx?.model),
+        thinkingLevel: ctx?.thinkingLevel ?? pi.getThinkingLevel?.() ?? null,
+        scoped: (ctx?.scopedModels ?? [])
+            .map((s) => s?.model?.provider && s?.model?.id ? `${s.model.provider}/${s.model.id}` : null)
+            .filter(Boolean),
+    });
     const sendQueue = () => send({ type: "queue_update", ...queue });
     const flushEntries = () => {
         try {
@@ -210,6 +224,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 {
@@ -314,14 +366,30 @@ export default function switchyardTerminal(pi) {
                         sessionFile: ctx.sessionManager.getSessionFile() ?? null,
                         sessionName: pi.getSessionName?.() ?? null,
                         isStreaming: !ctx.isIdle(),
+                        model: modelInfo(ctx.model),
+                        thinkingLevel: ctx.thinkingLevel ?? pi.getThinkingLevel?.() ?? null,
                         pendingMessageCount: ctx.hasPendingMessages() ? 1 : 0,
                     });
                     return;
                 case "prompt": {
                     const message = String(cmd.message ?? "");
                     if (message.startsWith("/")) {
-                        respond(id, type, undefined, "Slash commands from Switchyard need the terminal in terminal sessions: type it there");
-                        return;
+                        const name = message.slice(1).split(/\s/)[0];
+                        const known = (pi.getCommands?.() ?? []).find((c) => c.name === name);
+                        if (known?.source === "extension") {
+                            pi.sendUserMessage(message, { expandPromptTemplates: true });
+                            respond(id, type, { disposition: "handled" });
+                            return;
+                        }
+                        if (known) {
+                            if (!ctx.isIdle()) {
+                                respond(id, type, undefined, "Session is running: choose Steer or Queue follow-up");
+                                return;
+                            }
+                            pi.sendUserMessage(content(message, cmd.images), { expandPromptTemplates: true });
+                            respond(id, type, { disposition: "started" });
+                            return;
+                        }
                     }
                     if (!ctx.isIdle()) {
                         respond(id, type, undefined, "Session is running: choose Steer or Queue follow-up");
@@ -364,9 +432,61 @@ export default function switchyardTerminal(pi) {
                 }
                 case "get_session_stats": {
                     const totals = sessionTotals(ctx.sessionManager.getEntries());
-                    respond(id, type, { tokens: { total: totals.tokens }, cost: totals.cost });
+                    respond(id, type, {
+                        tokens: { total: totals.tokens },
+                        cost: totals.cost,
+                        contextUsage: ctx.getContextUsage?.() ?? undefined,
+                    });
                     return;
                 }
+                case "get_available_models":
+                    respond(id, type, {
+                        models: (ctx.modelRegistry?.getAvailable?.() ?? []).map(modelInfo).filter(Boolean),
+                    });
+                    return;
+                case "get_commands":
+                    respond(id, type, {
+                        commands: (pi.getCommands?.() ?? []).map((c) => ({
+                            name: c.name,
+                            description: c.description ?? null,
+                            source: c.source,
+                        })),
+                    });
+                    return;
+                case "set_model": {
+                    const provider = String(cmd.provider ?? "");
+                    const modelId = String(cmd.modelId ?? "");
+                    const model = ctx.modelRegistry?.find?.(provider, modelId);
+                    if (!model) {
+                        respond(id, type, undefined, `Model not found: ${provider}/${modelId}`);
+                        return;
+                    }
+                    Promise.resolve(pi.setModel(model)).then((ok) => {
+                        if (ok === false)
+                            respond(id, type, undefined, `No API key for ${provider}/${modelId}`);
+                        else
+                            respond(id, type, modelInfo(ctx.model));
+                    }, (err) => respond(id, type, undefined, err instanceof Error ? err.message : String(err)));
+                    return;
+                }
+                case "set_thinking_level":
+                    pi.setThinkingLevel(String(cmd.level));
+                    respond(id, type);
+                    return;
+                case "compact":
+                    if (!ctx.isIdle()) {
+                        respond(id, type, undefined, "Session is running: wait for it to finish before compacting");
+                        return;
+                    }
+                    ctx.compact({
+                        customInstructions: typeof cmd.customInstructions === "string" && cmd.customInstructions
+                            ? cmd.customInstructions
+                            : undefined,
+                        onComplete: () => { },
+                        onError: () => { },
+                    });
+                    respond(id, type, { started: true });
+                    return;
                 case "shutdown":
                     respond(id, type);
                     setImmediate(() => {
@@ -438,6 +558,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 {
@@ -461,6 +593,7 @@ export default function switchyardTerminal(pi) {
         const sessionId = c.sessionManager.getSessionId();
         const sessionFile = c.sessionManager.getSessionFile() ?? null;
         send({ type: "extension_hello", pid: process.pid, remoteDialogs, sessionId, sessionFile });
+        sendModelState();
         if (event?.reason && event.reason !== "startup") {
             send({ type: "switchyard_native", sessionId, sessionFile });
         }
@@ -515,7 +648,16 @@ export default function switchyardTerminal(pi) {
         aborted: event?.aborted === true,
         errorMessage: event?.errorMessage ?? "unknown error",
     }));
-    on("ui_prompt_start", (event) => send({ type: "ui_prompt", event: event.type, kind: event.kind, title: event.title ?? null }));
+    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,
+        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)