@spencerboucher/switchyard 0.7.0 → 0.9.0

package/README.md

@@ -68,7 +68,7 @@ sequenceDiagram
 1. **You describe the work.** A task has an objective, acceptance criteria, dependencies and a priority. Moving it to Ready lets Switchyard start it.
 2. **Switchyard starts it on a host.** The coordinator picks an eligible host, the host creates a git worktree for the task inside the repository (`<repo>/.worktrees/<branch>` by default), and Pi starts there with your normal extensions. A launch is recorded before it is sent, so a lost connection or a coordinator restart never starts it twice.
 3. **The agent asks, you answer anywhere.** Questions and approvals from Pi and its plugins appear as cards in every client and as a notification on the device you are most likely to see. Answer once; every client shows the result.
-4. **You can step in.** Join from any client to watch and send messages, steer the current turn or queue a follow-up. *Take over* pauses automation (no automatic continuations or retries) until you *return it*. *Stop* aborts the run. Detaching never stops anything.
+4. **You can step in.** Join from any client to watch and send messages, steer the current turn or queue a follow-up. *Take over* pauses automation (no automatic continuations or retries) until you *return it*. *Stop* aborts the run. Detaching never stops anything. Interrupting a turn in Pi does not pause automation.
 5. **It ends in Review, not in Done.** When the agent finishes, your configured checks run (tests, linters). If they pass, the task waits in Review with its diff; you can comment line by line, send all comments as one follow-up, request changes or accept. Accepting never merges or pushes for you.
 6. **Background work uses the same path.** An automation can open a task on a schedule, from a webhook or when another task finishes, then continue it, append to it, or report only when something changed.
 
@@ -78,7 +78,7 @@ sequenceDiagram
 |---|---|
 | **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 |
+| **Tasks and board** | Backlog, Ready, In progress, Review, Done; dependencies with cycle detection; priorities; per-project concurrency limits; a Queue 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 |
 | **Bounded continuation** | Optional: keep the agent working toward an objective, within a maximum number of continuations, a time limit and token or cost caps, ending in your checks and your review |
 | **Automations** | Cron (time-zone aware), one-time, webhook and dependency triggers; fresh, continue or watch modes; skip, queue or append when work overlaps; skip or catch up missed runs; a preview of the resulting task |
@@ -118,7 +118,7 @@ switchyard up
 ```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.7.0
+  ghcr.io/justmytwospence/switchyard:0.9.0
 # Single sign-on is required off localhost: see docs/auth.md
 ```
 

package/dist/bridge/lines.js

@@ -0,0 +1,33 @@
+/**
+ * Splits text into lines on LF only (never on U+2028/U+2029, valid inside JSON strings), strips
+ * one trailing CR and skips empty lines. Imports nothing: the terminal extension loads it from
+ * next to itself, and the holder and JsonlReader share it.
+ */
+export class LineSplitter {
+    onLine;
+    buffer = "";
+    constructor(onLine) {
+        this.onLine = onLine;
+    }
+    push(text) {
+        const buf = this.buffer + text;
+        let start = 0;
+        for (let nl = buf.indexOf("\n"); nl >= 0; nl = buf.indexOf("\n", start)) {
+            this.emit(buf.slice(start, nl));
+            start = nl + 1;
+        }
+        this.buffer = buf.slice(start);
+    }
+    /** Return and clear the unterminated rest (CR stripped). */
+    end() {
+        const rest = this.buffer;
+        this.buffer = "";
+        return rest.endsWith("\r") ? rest.slice(0, -1) : rest;
+    }
+    emit(raw) {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (line)
+            this.onLine(line);
+    }
+}
+//# sourceMappingURL=lines.js.map

package/dist/bridge/switchyard-terminal.js

@@ -6,7 +6,7 @@
  * dialogs while they are also shown in the terminal (whichever answer comes first wins).
  *
  * It connects to the holder's socket named by `SWITCHYARD_CONTROL_SOCKET`, imports only Node
- * built-ins, and never throws: without the variable it does nothing.
+ * built-ins and its sibling modules, and never throws: without the variable it does nothing.
  *
  * 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
@@ -17,6 +17,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
+import { LineSplitter } from "./lines.js";
 import { modelInfo } from "./pi-model.js";
 const PATCHED = Symbol.for("switchyard.terminal");
 const WRAPPED = Symbol.for("switchyard.terminal.wrapped");
@@ -80,6 +81,29 @@ 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();
@@ -106,6 +130,23 @@ export default function switchyardTerminal(pi) {
             .filter(Boolean),
     });
     const sendQueue = () => send({ type: "queue_update", ...queue });
+    /** Announce this session (and whether dialogs are remote-backed) to the host. */
+    const hello = () => {
+        if (!ctx)
+            return;
+        try {
+            send({
+                type: "extension_hello",
+                pid: process.pid,
+                remoteDialogs,
+                sessionId: ctx.sessionManager.getSessionId(),
+                sessionFile: ctx.sessionManager.getSessionFile() ?? null,
+            });
+        }
+        catch {
+            // never throw into Pi
+        }
+    };
     const flushEntries = () => {
         try {
             const entries = ctx?.sessionManager?.getEntries?.() ?? [];
@@ -377,6 +418,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;
@@ -446,10 +514,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;
@@ -498,6 +569,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}`);
             }
@@ -506,6 +609,16 @@ export default function switchyardTerminal(pi) {
             respond(id, type, undefined, err instanceof Error ? err.message : String(err));
         }
     };
+    /** Tell a (re)attached controller who we are, then re-send the dialogs it has not answered. */
+    const announce = () => {
+        if (ctx) {
+            hello();
+            sendModelState();
+            sendQueue();
+        }
+        for (const p of pending.values())
+            send(p.request);
+    };
     const onLine = (line) => {
         let msg;
         try {
@@ -521,43 +634,52 @@ export default function switchyardTerminal(pi) {
             return;
         }
         if (msg.type === "control_attached") {
-            for (const p of pending.values())
-                send(p.request);
+            // A controller re-attached (host agent restart): it starts from scratch, so announce the
+            // session again before re-sending the dialogs it has not answered.
+            announce();
             return;
         }
         if (typeof msg.type === "string" && msg.id !== undefined)
             handleCommand(msg);
     };
     // ---- socket ----
-    try {
-        const s = createConnection(socketPath);
+    // The holder listens before it starts Pi, but retry a few times anyway (a slow or restarting holder).
+    const CONNECT_ATTEMPTS = 5;
+    const CONNECT_RETRY_MS = 200;
+    const connect = (attempt) => {
+        let s;
+        try {
+            s = createConnection(socketPath);
+        }
+        catch {
+            socket = null;
+            return;
+        }
         socket = s;
-        let buf = "";
+        let connected = false;
+        const lines = new LineSplitter(onLine);
         s.setEncoding("utf8");
-        s.on("data", (chunk) => {
-            buf += chunk;
-            let nl = buf.indexOf("\n");
-            while (nl >= 0) {
-                const line = buf.slice(0, nl).replace(/\r$/, "");
-                buf = buf.slice(nl + 1);
-                if (line)
-                    onLine(line);
-                nl = buf.indexOf("\n");
-            }
+        s.on("data", (chunk) => lines.push(chunk));
+        s.once("connect", () => {
+            connected = true;
+            if (attempt > 1)
+                announce();
         });
         s.on("error", () => {
-            socket = null;
+            if (socket === s)
+                socket = null;
         });
         s.on("close", () => {
             if (socket === s)
                 socket = null;
+            if (!connected && attempt < CONNECT_ATTEMPTS) {
+                setTimeout(() => connect(attempt + 1), CONNECT_RETRY_MS).unref();
+            }
         });
         s.unref();
         s.write(`${JSON.stringify({ role: "extension" })}\n`);
-    }
-    catch {
-        socket = null;
-    }
+    };
+    connect(1);
     try {
         pi.events?.on?.(REMOTE_UI_CHANNEL, (data) => {
             const r = data;
@@ -589,10 +711,20 @@ 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;
-        send({ type: "extension_hello", pid: process.pid, remoteDialogs, sessionId, sessionFile });
+        hello();
         sendModelState();
         if (event?.reason && event.reason !== "startup") {
             send({ type: "switchyard_native", sessionId, sessionFile });