@herdingchats/friday 0.1.663 → 0.1.670

package/herd.mjs

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_HERD_PACKAGE_default;
 var init_define_HERD_PACKAGE = __esm({
   "<define:HERD_PACKAGE>"() {
-    define_HERD_PACKAGE_default = { version: "0.1.663", gitHead: "8ba46f6a5262b074559ade9422eb6ff6a3326b3f" };
+    define_HERD_PACKAGE_default = { version: "0.1.670", gitHead: "ec9dd13ab4eb2461db3f70f5798e1444a4ab281f" };
   }
 });
 
@@ -515,6 +515,9 @@ var init_terminals = __esm({
       z6.object({ type: z6.literal("input"), data: z6.string().max(64 * 1024) }),
       z6.object({ type: z6.literal("resize"), ...size }),
       z6.object({ type: z6.literal("drive") }),
+      // The browser's socket is open, so the screen can be sent: frames sent before a browser's
+      // socket has finished opening can be lost on the way, so it asks once it's ready.
+      z6.object({ type: z6.literal("ready") }),
       z6.object({ type: z6.literal("watch") }),
       z6.object({
         type: z6.literal("closed"),
@@ -611,6 +614,7 @@ var init_workers = __esm({
     "use strict";
     init_define_HERD_PACKAGE();
     init_activation();
+    init_terminals();
     CAPABILITIES = [
       "macos",
       "linux",
@@ -685,6 +689,7 @@ var init_workers = __esm({
       avoid: phrases.optional(),
       harnesses: z8.record(z8.string().regex(/^[a-z][a-z0-9-]*$/), harnessConfigSchema).optional(),
       builds: buildsSettingSchema.optional(),
+      terminals: z8.object({ remote: terminalAccessSchema.optional() }).strict().optional(),
       repos: z8.array(configRepoSchema).max(CONFIG_REPOS_MAX, `at most ${CONFIG_REPOS_MAX} repos`).optional()
     }).strict();
     HERD_CONFIG_TYPE = `type HerdConfig = {
@@ -698,6 +703,11 @@ var init_workers = __esm({
    * a build runner with its owner's approval, and a registered runner without it takes one.
    */
   builds?: true | { max: number };
+  /**
+   * What the web may do with this machine's terminals: "drive" (the default) to watch and type,
+   * "watch" to only watch, or "off".
+   */
+  terminals?: { remote?: "drive" | "watch" | "off" };
   /**
    * Repos the owner works in, so \`herd repos\` can tell an agent which one "the frontend" is. At
    * most ${CONFIG_REPOS_MAX}. Listing one clones nothing, and agents can add repos that aren't listed.
@@ -4524,7 +4534,9 @@ function registration(config, clis, facts = {}, cloned = []) {
     ...facts.configError ? { configError: facts.configError.slice(0, 1e3) } : {},
     ...facts.gh ? { gh: facts.gh } : {},
     ...facts.folderUnavailable ? { folderUnavailable: facts.folderUnavailable } : {},
-    herdVersion: HERD_VERSION
+    herdVersion: HERD_VERSION,
+    // Saying what it allows also says this daemon dials terminal sessions.
+    terminals: { remote: facts.config?.terminals?.remote ?? "drive" }
   };
 }
 function describeCli(name, version) {
@@ -10397,6 +10409,7 @@ var Daemon = class {
   async onFrame(frame) {
     if (frame.type === "offer") return this.onOffer(frame.offer);
     if (frame.type === "sign_in") return this.options.onSignIn?.(frame);
+    if (frame.type === "terminal_open") return this.options.onTerminalOpen?.(frame);
     if (frame.type === "message") {
       if (this.options.folderUnavailable?.()) {
         if (this.held.get(frame.conversationId) !== "interrupt") {
@@ -10849,6 +10862,207 @@ var MachineChecks = class {
   }
 };
 
+// src/remote-terminal.ts
+init_define_HERD_PACKAGE();
+init_src();
+import { connect as connect3 } from "node:net";
+var BATCH_MS = 16;
+var BEHIND_BYTES = 1024 * 1024;
+var RemoteTerminals = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  open = /* @__PURE__ */ new Set();
+  async opened(frame) {
+    const { options } = this;
+    const access = options.access();
+    const resolved = await options.resolve(frame.target).catch((error) => ({
+      refused: `herd couldn't find the terminal: ${error}`
+    }));
+    const refusal = access === "off" ? "This machine doesn't allow its terminals to be opened from the web." : "refused" in resolved ? resolved.refused : null;
+    const mode = frame.mode === "drive" && access === "drive" ? "drive" : "watch";
+    const target = await options.target(frame.sessionId);
+    const Impl = options.WebSocketImpl ?? WebSocket;
+    const socket = new Impl(target.url, { headers: target.headers });
+    const session = new Session(socket, {
+      ...options,
+      allowDrive: access === "drive",
+      onEnd: () => this.open.delete(session)
+    });
+    this.open.add(session);
+    socket.addEventListener("open", () => {
+      if (refusal || "refused" in resolved) {
+        session.refuse(refusal ?? "herd couldn't open that terminal.");
+        return;
+      }
+      session.attach(resolved.terminal, resolved.socketPath, mode);
+    });
+  }
+  /** Ends every session, as when the daemon stops. The terminals keep running. */
+  stop() {
+    for (const session of [...this.open]) session.end("machine_gone");
+  }
+};
+var Session = class {
+  constructor(socket, options) {
+    this.socket = socket;
+    this.options = options;
+    socket.addEventListener("message", (event2) => this.fromSession(String(event2.data)));
+    socket.addEventListener("close", () => this.end());
+    socket.addEventListener("error", () => this.end());
+  }
+  socket;
+  options;
+  host = null;
+  terminal = "";
+  socketPath = "";
+  pending = "";
+  flushTimer = null;
+  behind = false;
+  drainTimer = null;
+  ended = false;
+  mode = "watch";
+  refuse(detail2) {
+    this.options.log?.(`A terminal session was refused: ${detail2}`);
+    this.send({ type: "closed", reason: "refused", detail: detail2 });
+    this.end();
+  }
+  /** Attaches to the terminal's host, watching or driving, which sends a fresh screen. */
+  attach(terminal, socketPath, mode) {
+    this.terminal = terminal;
+    this.socketPath = socketPath;
+    this.mode = mode;
+    this.detachHost();
+    const host = connect3(socketPath);
+    this.host = host;
+    let buffer = "";
+    let answered = false;
+    host.on(
+      "connect",
+      () => host.write(
+        `${JSON.stringify(mode === "drive" ? { op: "attach", name: terminal } : { op: "watch", name: terminal })}
+`
+      )
+    );
+    host.on("data", (chunk) => {
+      buffer += chunk;
+      let end = buffer.indexOf("\n");
+      while (end >= 0) {
+        const line2 = buffer.slice(0, end);
+        buffer = buffer.slice(end + 1);
+        end = buffer.indexOf("\n");
+        let message;
+        try {
+          message = JSON.parse(line2);
+        } catch {
+          continue;
+        }
+        if (!answered) {
+          answered = true;
+          if (message.ok === false) {
+            this.refuse(message.error ?? "The terminal's host wouldn't open it.");
+            return;
+          }
+          this.send({ type: "mode", mode });
+          if (message.ok === true) continue;
+        }
+        this.fromHost(message);
+      }
+    });
+    host.on("error", (error) => {
+      if (host === this.host)
+        this.refuse(`The terminal's host couldn't be reached: ${error.message}`);
+    });
+  }
+  fromHost(message) {
+    if (message.type === "snapshot") {
+      this.pending = "";
+      this.send({ type: "snapshot", data: message.data ?? "" });
+    } else if (message.type === "data") {
+      if (this.behind) return;
+      this.pending += message.data ?? "";
+      this.flushTimer ??= setTimeout(() => this.flush(), this.options.batchMs ?? BATCH_MS);
+    } else if (message.type === "exit") {
+      this.flush();
+      this.send({ type: "exit", exitCode: message.exitCode ?? null });
+      this.end();
+    }
+  }
+  flush() {
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.flushTimer = null;
+    if (!this.pending) return;
+    const data = this.pending;
+    this.pending = "";
+    this.send({ type: "data", data });
+    if (this.socket.bufferedAmount > (this.options.behindBytes ?? BEHIND_BYTES)) {
+      this.behind = true;
+      this.drainTimer = setInterval(() => {
+        if (this.socket.bufferedAmount > 0) return;
+        if (this.drainTimer) clearInterval(this.drainTimer);
+        this.drainTimer = null;
+        this.behind = false;
+        this.attach(this.terminal, this.socketPath, this.mode);
+      }, this.options.drainPollMs ?? 100);
+    }
+  }
+  fromSession(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const frame = terminalFrameSchema.safeParse(parsed);
+    if (!frame.success) return;
+    const { data } = frame;
+    if (data.type === "closed") {
+      this.end();
+      return;
+    }
+    if (data.type === "drive" || data.type === "watch") {
+      this.mode = data.type === "drive" && this.options.allowDrive ? "drive" : "watch";
+      if (this.terminal) this.attach(this.terminal, this.socketPath, this.mode);
+      return;
+    }
+    if (this.mode !== "drive" || !this.host) return;
+    if (data.type === "input")
+      this.host.write(`${JSON.stringify({ type: "input", data: data.data })}
+`);
+    if (data.type === "resize") {
+      this.host.write(`${JSON.stringify({ type: "resize", cols: data.cols, rows: data.rows })}
+`);
+    }
+  }
+  send(frame) {
+    if (this.socket.readyState !== WebSocket.OPEN) return;
+    try {
+      this.socket.send(JSON.stringify(frame));
+    } catch {
+      this.end();
+    }
+  }
+  detachHost() {
+    const host = this.host;
+    this.host = null;
+    host?.destroy();
+  }
+  end(reason) {
+    if (this.ended) return;
+    this.ended = true;
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    if (this.drainTimer) clearInterval(this.drainTimer);
+    this.detachHost();
+    if (reason) this.send({ type: "closed", reason });
+    try {
+      this.socket.close(1e3);
+    } catch {
+    }
+    this.options.onEnd();
+  }
+};
+
 // src/usage-reporter.ts
 init_define_HERD_PACKAGE();
 var USAGE_REPORT_MS = 5 * 60 * 1e3;
@@ -13933,13 +14147,33 @@ async function runDaemon(args) {
   const api = apiUrl();
   const terminals = new HostTerminals({ log: (line2) => console.log(line2) });
   await terminals.ensureHost();
+  const signIn = async () => isLocal(api) ? localSignIn() : { Authorization: `Bearer ${await accessToken()}` };
   const daemonApi = {
     fetch: apiFetch,
     connection: async (machineId) => ({
       url: `${api.replace(/^http/, "ws")}/api/machines/${encodeURIComponent(machineId)}/connect`,
-      headers: isLocal(api) ? localSignIn() : { Authorization: `Bearer ${await accessToken()}` }
+      headers: await signIn()
     })
   };
+  const remoteTerminals = new RemoteTerminals({
+    target: async (sessionId) => ({
+      url: `${api.replace(/^http/, "ws")}/api/terminal-sessions/${sessionId}/machine?machine=${encodeURIComponent(loadConfig().machineId)}`,
+      headers: await signIn()
+    }),
+    access: () => daemon?.configuration().config?.terminals?.remote ?? "drive",
+    resolve: async (target) => {
+      if (target.kind !== "conversation") {
+        return { refused: "This machine can't open an agent's sign-in terminal from the web yet." };
+      }
+      const workspace = workspaces.get(target.conversationId);
+      if (!workspace) return { refused: "This machine doesn't hold that conversation." };
+      const lead = (await terminals.list()).find((t) => t.name === workspace.lead && !t.exited);
+      if (!lead)
+        return { refused: "The conversation's agent isn't running in a terminal right now." };
+      return { terminal: lead.name, socketPath: await terminals.pathOf(lead.name) };
+    },
+    log: (line2) => console.log(line2)
+  });
   let activator = null;
   let checks = null;
   const log = (line2) => console.log(line2);
@@ -14066,6 +14300,7 @@ async function runDaemon(args) {
     activations: () => activator?.states() ?? {},
     gh: () => checks?.gh ?? null,
     onSignIn: (frame) => void checks?.signIn(frame),
+    onTerminalOpen: (frame) => void remoteTerminals.opened(frame).catch((error) => console.log(`A terminal session didn't open: ${error}`)),
     onConfigChanged: () => checks?.activateChosen(),
     folderUnavailable: () => folders.problem
   });
@@ -14301,7 +14536,7 @@ async function runAgyHook(event2, stdin, env, options = {}) {
 init_define_HERD_PACKAGE();
 import { spawn as spawn13 } from "node:child_process";
 import { readFileSync as readFileSync22 } from "node:fs";
-import { connect as connect3 } from "node:net";
+import { connect as connect4 } from "node:net";
 import { homedir as homedir9 } from "node:os";
 import { join as join36 } from "node:path";
 var MAX_INPUT = 64 * 1024;
@@ -14397,7 +14632,7 @@ function runOwnCommand(command, input, cwd, timeoutMs = OWN_COMMAND_TIMEOUT_MS)
 }
 function tellDaemon(path, request, timeoutMs = REPORT_TIMEOUT_MS) {
   return new Promise((resolve8) => {
-    const socket = connect3(path);
+    const socket = connect4(path);
     const done = () => {
       clearTimeout(timer);
       socket.destroy();
@@ -14680,11 +14915,11 @@ init_define_HERD_PACKAGE();
 
 // src/attach.ts
 init_define_HERD_PACKAGE();
-import { connect as connect4 } from "node:net";
+import { connect as connect5 } from "node:net";
 var DETACH_KEY = "";
 function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: process.stdout }, path = currentHostSocketPath(), { watch: watch2 = false } = {}) {
   return new Promise((resolve8, reject) => {
-    const socket = connect4(path);
+    const socket = connect5(path);
     const size2 = () => ({ cols: stdout.columns || 120, rows: stdout.rows || 40 });
     let buffer = "";
     let started = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herdingchats/friday",
-  "version": "0.1.663",
+  "version": "0.1.670",
   "description": "Friday, HerdingChats' agent daemon, and the herd command it runs agents with.",
   "license": "MIT",
   "type": "module",
@@ -22,5 +22,5 @@
     "satori": "0.32.0",
     "zod": "4.6.7"
   },
-  "gitHead": "8ba46f6a5262b074559ade9422eb6ff6a3326b3f"
+  "gitHead": "ec9dd13ab4eb2461db3f70f5798e1444a4ab281f"
 }