pinomad 0.10.0 → 0.12.0

package/dist/{chunk-4sepcfpy.js → chunk-np4jd070.js}

@@ -15,7 +15,7 @@ import {
   organize,
   parseRtcMaxMessageSize,
   rtcSelectedPair
-} from "./chunk-jgd38rna.js";
+} from "./chunk-47ff1d1t.js";
 import {
   SECURE_PROLOGUE,
   SecureSession,
@@ -24,7 +24,7 @@ import {
   initiateIK,
   isLoopbackUrl,
   parseEndpointSet
-} from "./chunk-sygeb9qb.js";
+} from "./chunk-pqe7q1s7.js";
 
 // packages/protocol/src/remote-durable.ts
 import { applyImmutable } from "@earendil-works/chord/delta";
@@ -286,6 +286,13 @@ function webSocketTransport(url, token) {
   };
 }
 
+// packages/protocol/src/terminals.ts
+function isTerminalsHello(value) {
+  return value !== null && typeof value === "object" && typeof value.limit === "number";
+}
+var terminalsStream = (id) => `terminals:${id}`;
+var terminalStream = (id) => `terminal:${id}`;
+
 // packages/protocol/src/transcript.ts
 function isBusy(view) {
   const live = view.docs?.["pi.live"];
@@ -458,6 +465,11 @@ class RemoteClient {
   #helloModels = [];
   #helloDefaults = {};
   #hostVersion;
+  #hostTerminals;
+  #terminalWatchers = new Map;
+  #terminalSinks = new Map;
+  #terminalPositions = new Map;
+  #terminalSizes = new Map;
   #attempt = 0;
   #rtcAttemptNonce = randomHex(8);
   #closed = false;
@@ -710,6 +722,7 @@ class RemoteClient {
     this.#helloModels = frame.models;
     this.#helloDefaults = frame.defaults ?? {};
     this.#hostVersion = frame.hostVersion;
+    this.#hostTerminals = isTerminalsHello(frame.terminals) ? frame.terminals : undefined;
     this.#fresh.clear();
     const covered = new Set(hostStreams(hostMinor));
     for (const name of HOST_STREAM_NAMES) {
@@ -727,6 +740,7 @@ class RemoteClient {
     if (this.#side !== undefined)
       for (const stream of this.#conversationStreams(this.#side))
         this.#wanted.add(stream);
+    this.#terminalsAvailability();
     for (const stream of this.#wanted)
       this.#subscribe(stream);
     if (frame.endpointSet !== undefined) {
@@ -815,6 +829,7 @@ class RemoteClient {
       this.#resolveReady({
         view: this.#viewSource(),
         controller: this.#controller(),
+        terminals: this.#terminals(),
         setConnectionMode: (mode) => this.setConnectionMode(mode),
         rtcDiagnostics: () => this.rtcDiagnostics(),
         close: () => this.#close()
@@ -828,6 +843,9 @@ class RemoteClient {
     await this.#recoverSubmissions();
     if (!this.#isActive(dial))
       return;
+    for (const [terminalId, size] of this.#terminalSizes) {
+      this.#callNow("resizeTerminal", { terminalId, ...size }).catch(() => {});
+    }
     this.#finishSyncGate();
     this.#afterCarrierReady(dial);
   }
@@ -1961,6 +1979,11 @@ class RemoteClient {
       case "snapshot":
         if (!this.#wanted.has(frame.stream))
           return;
+        if (frame.stream.startsWith("terminals:")) {
+          this.#values.set(frame.stream, frame.value);
+          this.#notifyTerminals(frame.stream, { kind: "ready", list: frame.value });
+          return;
+        }
         this.#values.set(frame.stream, frame.value);
         this.#fresh.add(frame.stream);
         this.#streamVersions.set(frame.stream, (this.#streamVersions.get(frame.stream) ?? 0) + 1);
@@ -1974,7 +1997,19 @@ class RemoteClient {
         this.#values.set(frame.stream, applyImmutable(this.#values.get(frame.stream), frame.ops));
         this.#refresh();
         return;
+      case "output": {
+        const sink = this.#terminalSinks.get(frame.stream);
+        if (sink === undefined || !this.#wanted.has(frame.stream))
+          return;
+        this.#terminalPositions.set(frame.stream, frame.seq);
+        sink.output(frame.data, frame.reset === true);
+        return;
+      }
       case "ended": {
+        if (frame.stream.startsWith("terminals:") || frame.stream.startsWith("terminal:")) {
+          this.#endTerminalStream(frame.stream, frame.reason);
+          return;
+        }
         this.#wanted.delete(frame.stream);
         this.#values.delete(frame.stream);
         this.#fresh.delete(frame.stream);
@@ -2070,7 +2105,124 @@ class RemoteClient {
   }
   #subscribe(stream) {
     const refs = stream.startsWith("conversation:") && hostSupportsFeature(this.#hostMinor, "imageRefs");
-    this.#send({ type: "subscribe", stream, ...refs ? { images: "ref" } : {} });
+    const since = this.#terminalPositions.get(stream);
+    this.#send({
+      type: "subscribe",
+      stream,
+      ...refs ? { images: "ref" } : {},
+      ...since === undefined ? {} : { since }
+    });
+  }
+  #terminalsUnavailable() {
+    if (!hostSupportsFeature(this.#hostMinor, "terminals")) {
+      return "The host is too old for terminals (needs protocol 5.27); run `pinomad upgrade` on the host";
+    }
+    if (this.#hostTerminals === undefined)
+      return "The host couldn't load its terminal module; its log says which package is missing";
+    return;
+  }
+  #terminalsAvailability() {
+    const reason = this.#terminalsUnavailable();
+    if (reason === undefined) {
+      for (const stream of this.#terminalWatchers.keys())
+        this.#wanted.add(stream);
+      for (const stream of this.#terminalSinks.keys())
+        this.#wanted.add(stream);
+      return;
+    }
+    for (const stream of [...this.#terminalWatchers.keys()]) {
+      this.#wanted.delete(stream);
+      this.#values.delete(stream);
+      this.#notifyTerminals(stream, { kind: "unavailable", reason });
+    }
+    for (const stream of [...this.#terminalSinks.keys()])
+      this.#endTerminalStream(stream, reason);
+  }
+  #notifyTerminals(stream, state) {
+    for (const listener of [...this.#terminalWatchers.get(stream) ?? []])
+      listener(state);
+  }
+  #endTerminalStream(stream, reason) {
+    this.#wanted.delete(stream);
+    this.#values.delete(stream);
+    if (stream.startsWith("terminals:")) {
+      this.#notifyTerminals(stream, { kind: "unavailable", reason });
+      return;
+    }
+    const sink = this.#terminalSinks.get(stream);
+    this.#terminalSinks.delete(stream);
+    this.#terminalPositions.delete(stream);
+    this.#terminalSizes.delete(stream.slice("terminal:".length));
+    sink?.ended(reason);
+  }
+  #terminalCall(method, args) {
+    const reason = this.#terminalsUnavailable();
+    return reason === undefined ? this.#call(method, args) : Promise.reject(new Error(reason));
+  }
+  #terminals() {
+    return {
+      watch: (conversationId, listener) => {
+        const stream = terminalsStream(conversationId);
+        let listeners = this.#terminalWatchers.get(stream);
+        const first = listeners === undefined;
+        if (listeners === undefined)
+          this.#terminalWatchers.set(stream, listeners = new Set);
+        listeners.add(listener);
+        const reason = this.#terminalsUnavailable();
+        const list = this.#values.get(stream);
+        listener(reason !== undefined ? { kind: "unavailable", reason } : list !== undefined ? { kind: "ready", list } : { kind: "loading" });
+        if (first && reason === undefined) {
+          this.#wanted.add(stream);
+          if (this.#helloReceived)
+            this.#subscribe(stream);
+        }
+        return () => {
+          if (!listeners.delete(listener) || listeners.size > 0)
+            return;
+          this.#terminalWatchers.delete(stream);
+          if (!this.#wanted.delete(stream))
+            return;
+          this.#values.delete(stream);
+          this.#send({ type: "unsubscribe", stream });
+        };
+      },
+      attach: (terminalId, sink) => {
+        const stream = terminalStream(terminalId);
+        const reason = this.#terminalsUnavailable();
+        if (reason !== undefined) {
+          sink.ended(reason);
+          return () => {};
+        }
+        if (this.#terminalSinks.has(stream) && this.#wanted.has(stream))
+          this.#send({ type: "unsubscribe", stream });
+        this.#terminalSinks.set(stream, sink);
+        this.#terminalPositions.delete(stream);
+        this.#wanted.add(stream);
+        if (this.#helloReceived)
+          this.#subscribe(stream);
+        return () => {
+          if (this.#terminalSinks.get(stream) !== sink)
+            return;
+          this.#terminalSinks.delete(stream);
+          this.#terminalPositions.delete(stream);
+          this.#terminalSizes.delete(terminalId);
+          if (this.#wanted.delete(stream))
+            this.#send({ type: "unsubscribe", stream });
+        };
+      },
+      open: (conversationId, size) => this.#terminalCall("openTerminal", { conversationId, ...size }).then(({ terminalId }) => terminalId),
+      input: (terminalId, data) => {
+        this.#terminalCall("terminalInput", { terminalId, data }).catch(() => {});
+      },
+      resize: (terminalId, size) => {
+        if (this.#terminalSinks.has(terminalStream(terminalId)))
+          this.#terminalSizes.set(terminalId, size);
+        this.#terminalCall("resizeTerminal", { terminalId, ...size }).catch(() => {});
+      },
+      rename: (terminalId, name) => this.#terminalCall("renameTerminal", { terminalId, name }).then(() => {}),
+      restart: (terminalId, size) => this.#terminalCall("restartTerminal", { terminalId, ...this.#terminalSizes.get(terminalId) ?? size }).then(() => {}),
+      close: (terminalId) => this.#terminalCall("closeTerminal", { terminalId }).then(() => {})
+    };
   }
   #host(name) {
     return this.#values.get(name);

package/dist/{chunk-v414b5pp.js → chunk-nppgxh6c.js}

@@ -1,13 +1,13 @@
 import {
   RTC_DEFAULT_STUN
-} from "./chunk-jgd38rna.js";
+} from "./chunk-47ff1d1t.js";
 import {
   HOST_SETTING_KEYS,
   cleanHostName,
   isQueueMode,
   isThinkingLevel,
   normalizeHostName
-} from "./chunk-sygeb9qb.js";
+} from "./chunk-pqe7q1s7.js";
 
 // apps/host/src/host-value.ts
 function constantValue(value) {

package/dist/chunk-nq57fdnq.js

@@ -0,0 +1,106 @@
+// apps/host/src/server-config.ts
+import { randomBytes } from "node:crypto";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var SERVER_CONFIG_FILE = "server.json";
+var REMOVAL_NOTICE_FILE = "server-removed.json";
+var normalizeOrigin = (origin) => origin.replace(/\/+$/, "");
+async function readServerConfig(dataDir) {
+  const config = await readServerConfigAt(join(dataDir, SERVER_CONFIG_FILE));
+  if (config === undefined)
+    return;
+  const notice = await readRemovalNotice(dataDir).catch(() => {
+    return;
+  });
+  return notice !== undefined && endsJoin(notice, config) ? undefined : config;
+}
+var endsJoin = (notice, config) => normalizeOrigin(notice.origin) === normalizeOrigin(config.origin) && notice.binding === config.binding;
+async function readServerConfigAt(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`${path} is not valid JSON — delete it or run \`pinomad leave\``);
+  }
+  const origin = value?.origin;
+  if (typeof origin !== "string" || origin.trim() === "") {
+    throw new Error(`${path} is missing a string "origin"`);
+  }
+  const { binding, username } = value;
+  return {
+    origin,
+    ...typeof binding === "string" && binding !== "" ? { binding } : {},
+    ...typeof username === "string" && username !== "" ? { username } : {}
+  };
+}
+async function writeJsonFile(path, value) {
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile(tmp, `${JSON.stringify(value)}
+`, { mode: 384 });
+  await rename(tmp, path);
+}
+async function writeServerConfig(dataDir, config) {
+  await writeJsonFile(join(dataDir, SERVER_CONFIG_FILE), {
+    origin: normalizeOrigin(config.origin),
+    binding: randomBytes(16).toString("base64url"),
+    ...config.username === undefined ? {} : { username: config.username }
+  });
+  await rm(join(dataDir, REMOVAL_NOTICE_FILE), { force: true });
+}
+async function markRemoved(dataDir, removed, removedAt = Date.now()) {
+  await writeJsonFile(join(dataDir, REMOVAL_NOTICE_FILE), {
+    origin: normalizeOrigin(removed.origin),
+    ...removed.binding === undefined ? {} : { binding: removed.binding },
+    ...removed.username === undefined ? {} : { username: removed.username },
+    removedAt
+  });
+}
+async function readRemovalNotice(dataDir) {
+  const path = join(dataDir, REMOVAL_NOTICE_FILE);
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`${path} is not valid JSON — delete it`);
+  }
+  const { origin, binding, username, removedAt } = value ?? {};
+  if (typeof origin !== "string" || typeof removedAt !== "number")
+    throw new Error(`${path} is missing "origin" or "removedAt" — delete it`);
+  return {
+    origin,
+    ...typeof binding === "string" && binding !== "" ? { binding } : {},
+    ...typeof username === "string" && username !== "" ? { username } : {},
+    removedAt
+  };
+}
+async function removeServerConfig(dataDir) {
+  await rm(join(dataDir, SERVER_CONFIG_FILE), { force: true });
+  await rm(join(dataDir, REMOVAL_NOTICE_FILE), { force: true });
+}
+async function readServerBinding(dataDir) {
+  return (await readServerConfig(dataDir))?.binding;
+}
+function resolveRelayOrigin(flag, config) {
+  if (flag !== undefined && config !== undefined && normalizeOrigin(flag) !== normalizeOrigin(config.origin)) {
+    throw new Error(`--relay ${flag} disagrees with ${SERVER_CONFIG_FILE} (${config.origin}) — remove one`);
+  }
+  return flag ?? config?.origin;
+}
+
+export { REMOVAL_NOTICE_FILE, normalizeOrigin, readServerConfig, writeServerConfig, markRemoved, readRemovalNotice, removeServerConfig, readServerBinding, resolveRelayOrigin };

package/dist/{chunk-sygeb9qb.js → chunk-pqe7q1s7.js}

@@ -427,4 +427,4 @@ function concatParts(parts) {
   return out;
 }
 
-export { ENDPOINT_SET_SCHEMA_VERSION, MAX_HOST_ENDPOINT_URL_LENGTH, isLoopbackUrl, parseEndpointSet, encodeEndpointSetParam, HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_NAME_MAX_UNITS, cleanHostName, normalizeHostName, generateKeyPair, keyPairFromPrivate, initiateIK, respondIK, SECURE_PROLOGUE, SIGNAL_PROLOGUE, encodeClientHello, encodeHostHello, decodeClientHello, decodeHostHello, toBase64Url, fromBase64Url, SecureSession };
+export { ENDPOINT_SET_SCHEMA_VERSION, MAX_HOST_ENDPOINT_URL_LENGTH, isLoopbackUrl, parseEndpointSet, encodeEndpointSetParam, generateKeyPair, keyPairFromPrivate, initiateIK, respondIK, SECURE_PROLOGUE, SIGNAL_PROLOGUE, encodeClientHello, encodeHostHello, decodeClientHello, decodeHostHello, toBase64Url, fromBase64Url, SecureSession, HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_NAME_MAX_UNITS, cleanHostName, normalizeHostName };