my-durable 0.0.10 → 0.0.11

package/apps/dpi-playground/apps/dpi-playground-fe/dist/index.html

@@ -7,7 +7,7 @@
     <meta name="referrer" content="no-referrer" />
     <link rel="icon" type="image/svg+xml" href="/icons/durable-pi.svg" />
     <title>Durable Pi | Network</title>
-    <script type="module" crossorigin src="/assets/index-CoYMgU-2.js"></script>
+    <script type="module" crossorigin src="/assets/index-Ct_cPQy9.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Cg3vey95.css">
   </head>
   <body>

package/apps/dpi-sdk/src/protocol/pairing.ts

@@ -383,7 +383,12 @@ export function parseHubOrigin(
     return { ok: false, error: "origin: not a valid URL" };
   }
   if (url.protocol !== "https:") {
-    return { ok: false, error: "origin: HTTPS origin required" };
+    // Loopback dev hubs (one machine running both ends) speak plain HTTP. The
+    // same rule as the device's own origin check: only 127.0.0.1/[::1]/localhost
+    // qualify, so a hub another machine can reach is still HTTPS-only.
+    const loopback =
+      url.protocol === "http:" && /^(127\.0\.0\.1|\[::1\]|localhost)$/.test(url.hostname);
+    if (!loopback) return { ok: false, error: "origin: HTTPS origin required" };
   }
   if (url.username || url.password) {
     return { ok: false, error: "origin: userinfo not allowed" };

package/apps/dpi-tui/src/app.ts

@@ -28,6 +28,7 @@ import type { DeviceRow, NetworkRegistry } from "../../dpi-sdk/src/node/registry
 import { COMMANDS, runCommand } from "./commands.ts";
 import { Prompt, SecretPrompt, pickModel, newSession } from "./pickers.ts";
 import { renderHeader, renderHerd, renderHerdPanel, renderNetwork, renderStatusbar, renderViewbar, herdRows, joinPanel, networkRows } from "./views.ts";
+import { appendFileSync } from "node:fs";
 import { fetchHubNetwork } from "./hub-feed.ts";
 import { HubMux } from "./hub-mux.ts";
 import { box, c, STATE_COLOR, STATE_GLYPH, type RowState } from "./theme.ts";
@@ -358,7 +359,13 @@ export class App {
     ];
   }
 
-  private rows(): Array<{ sessionId?: string; deviceId?: string; label: string }> {
+  /** Herd and network rows share a shape; `kind` tells a header from an entry. */
+  private rows(): Array<{
+    kind: "group" | "session" | "device";
+    sessionId?: string;
+    deviceId?: string;
+    label: string;
+  }> {
     if (this.view === "herd") return herdRows(this.sessions, this.filter);
     if (this.view === "network") return networkRows(this.devicesCache, this.device.id, this.filter);
     return [];
@@ -368,6 +375,14 @@ export class App {
     const rows = this.rows();
     const row = rows[this.cursor] ?? rows.find((r) => r.sessionId);
     if (row?.sessionId) return this.openSession(row.sessionId, row.deviceId);
+    // A group header opens its first session — pressing enter on a header used
+    // to do literally nothing.
+    if (row?.kind === "group") {
+      // The next session row after the header belongs to that group.
+      const at = rows.indexOf(row);
+      const target = rows.slice(at + 1).find((r) => r.kind !== "group");
+      if (target?.sessionId) return this.openSession(target.sessionId, target.deviceId);
+    }
     if (row?.deviceId && this.view === "network") {
       const target = this.devicesCache.find((d) => d.id === row.deviceId);
       if (!target) return;
@@ -402,7 +417,11 @@ export class App {
 
   /** 1-9 jump: the nth session row of the current view. */
   private jump(n: number) {
-    const rows = this.rows().filter((r) => r.sessionId);
+    // Digits address sessions, so they work from the agent view as well — that
+    // is the fastest way out of a session you no longer want.
+    const rows = (this.view === "herd" ? this.rows() : herdRows(this.sessions, this.filter)).filter(
+      (r): r is { kind: "session"; sessionId: string; deviceId?: string; label: string } => !!r.sessionId,
+    );
     const nth = rows[n - 1];
     if (nth?.sessionId) this.openSession(nth.sessionId, nth.deviceId);
     else this.notify(`no session #${n} in this view`);
@@ -454,6 +473,17 @@ export class App {
   // ------------------------------------------------------------------- input
 
   handleInput(data: string): TuiInputListenerResult {
+    // DPI_TUI_KEYS=<file> traces every key the app receives — the fastest way to
+    // tell "the terminal never sent it" from "a branch swallowed it".
+    if (process.env.DPI_TUI_KEYS)
+      try {
+        appendFileSync(
+          process.env.DPI_TUI_KEYS,
+          `${JSON.stringify({ data, view: this.view, tab: this.tab, input: this.input?.kind ?? null, overlays: this.overlays.length })}\n`,
+        );
+      } catch {
+        /* tracing must never break input */
+      }
     // pi-tui overlays (welcome screen, pickers, prompts) own the keyboard while
     // open; only ctrl+c still closes them from here.
     if (this.overlays.length) {
@@ -489,7 +519,7 @@ export class App {
     else if (data === "/") {
       this.beginInput("message", "follow-up ❯ ");
       this.input!.value = "/";
-    } else if (data === "f") this.beginInput("filter", "/ ");
+    } else if (data === "f") this.beginInput("filter", "filter ❯ ");
     else if (data === "n") this.beginInput("new", "new session › ");
     else if (data === "x") this.beginInput("kill", `reset ${this.sessionSummary()?.name ?? "context"}? y/n`);
     else if (data === "g") this.setView("herd");
@@ -508,12 +538,9 @@ export class App {
     else if (data === "]" || matchesKey(data, "tab")) this.cycleTab(1);
     else if (data === "[" || matchesKey(data, "shift+tab")) this.cycleTab(-1);
     else if (/^[1-9]$/.test(data)) this.jump(Number(data));
-    // Agent view keeps pi muscle memory: any other printable char opens the
-    // message line seeded with itself (herdr requires "m"; typing talks here).
-    else if (this.view === "agent" && /^[^\x00-\x1f]$/.test(data)) {
-      this.beginInput("message", "follow-up ❯ ");
-      this.input!.value = data;
-    }
+    // No catch-all: a stray letter used to jump views or open the composer with
+    // itself as the first character. herdr and piggery both require an explicit
+    // key (m, / or enter), and so do we now.
     return { consume: true };
   }
 
@@ -607,15 +634,27 @@ export class App {
     this.requestRender();
   }
 
+  /**
+   * esc is BACK, the way every list/detail client behaves (piggery: "esc back").
+   * Interrupting a running turn is a destructive action and keeps its own key
+   * (i) — folding it into esc meant "leave this screen" did nothing at all while
+   * an agent was idle.
+   */
   private escape() {
     if (this.filter) {
       this.filter = "";
       this.notify("filter cleared");
-    } else if (this.view === "agent") {
-      if (this.busy()) void this.interrupt();
-    } else this.setView("agent");
+    } else if (this.view === "agent" || this.view === "log") {
+      this.setView("herd");
+    }
   }
 
+  /**
+   * Move the cursor. Group rows ("~/project/ · 3 agents") are headers, not
+   * entries: stepping onto one left the marker and the OVERVIEW panel frozen on
+   * the previous session, which reads as "navigation is dead". Skip them, the
+   * way piggery's list only ever has real rows under the cursor.
+   */
   private move(delta: number) {
     if (this.view === "agent" && this.tab === "transcript") {
       // Scroll the transcript instead of moving a cursor (herdr H04's lesson).
@@ -625,9 +664,24 @@ export class App {
     }
     const rows = this.rows();
     if (!rows.length) return;
-    this.cursor = Math.max(0, Math.min(this.cursor + delta, rows.length - 1));
-    const row = rows[this.cursor];
-    if (row?.sessionId) this.selectedId = row.sessionId;
+    const selectable = (i: number) => !!rows[i] && rows[i].kind !== "group";
+    let next = this.cursor;
+    for (let step = 0; step < rows.length; step += 1) {
+      next += delta;
+      if (next < 0 || next >= rows.length) break;
+      if (selectable(next)) {
+        this.cursor = next;
+        this.selectedId = rows[next]!.sessionId ?? this.selectedId;
+        this.requestRender();
+        return;
+      }
+    }
+    // Nothing selectable in that direction: still clamp to a valid row so the
+    // highlight never points past the list.
+    if (!selectable(this.cursor)) {
+      const first = rows.findIndex((_, i) => selectable(i));
+      if (first >= 0) this.cursor = first;
+    }
     this.requestRender();
   }
 
@@ -767,7 +821,9 @@ export class App {
 
   tick() {
     if (this.toastTicks > 0 && --this.toastTicks === 0) this.toast = "";
-    if (this.hub && ++this.hubTick >= 125) {
+    // Live network: refresh the hub feed every ~5 s (tick = 120 ms), so a device
+    // paired from the CLI shows up while the operator is looking at the list.
+    if (this.hub && ++this.hubTick >= 42) {
       this.hubTick = 0;
       void fetchHubNetwork(this.hub.url, this.hub.token).then((rows) => {
         if (rows) {

package/apps/dpi-tui/src/pickers.ts

@@ -323,7 +323,7 @@ function chooseModel(app: App, current?: string) {
   return new Promise<(typeof app.info.models)[number] | undefined>((done) => {
     const models = app.info.models;
     const picker = new Picker(
-      `Model (${app.device.id})`,
+      `Model (${app.device.name})`,
       models.map((m) => ({ value: `${m.provider}/${m.id}`, label: m.name, description: `${m.tier} │ ${m.provider}` })),
       (item) => {
         app.closeOverlay();

package/apps/dpi-tui/src/views.ts

@@ -121,9 +121,10 @@ export function renderHerd(
     if (row.kind === "group") {
       const group = sessions.filter((s) => basename(s.cwd) === row.label);
       const busy = group.filter((s) => s.busy).length;
-      lines.push(
-        `${c.muted("~/")}${c.text(row.label)}${c.muted("/")}  ${c.muted(`· ${group.length} agent${group.length === 1 ? "" : "s"} · ${busy} busy`)}`,
-      );
+      const header = `${c.muted("~/")}${c.text(row.label)}${c.muted("/")}  ${c.muted(`· ${group.length} agent${group.length === 1 ? "" : "s"} · ${busy} busy`)}`;
+      // The cursor is drawn on headers too: a keypress must always be visible,
+      // even though j/k skips them (they are not selectable entries).
+      lines.push(cursorRow === row ? c.inverse(fit(header, w)) : fit(header, w));
       continue;
     }
     const s = sessions.find((x) => x.id === row.sessionId);

package/bin/dpi.mjs

@@ -23,6 +23,10 @@ Usage:
   dpi device start | stop | status                    background daemon without a terminal
   dpi device install | uninstall                      OS service (systemd/launchd); Windows: no
                                                       autostart — run "dpi device start" after login
+  dpi pair <code|link> [--hub <origin>]               pair THIS machine from the CLI (no browser)
+  dpi pair --hub <origin>                             this machine asks the hub itself
+  dpi pair offer|list|approve|revoke                  operator side, from the CLI (dpi pair --help)
+  dpi devices [--watch] [--hub <origin>]              paired machines + live status (CLI, no web)
   dpi tui
       Terminal admin client.
   dpi help | dpi --help | dpi -h
@@ -88,75 +92,48 @@ if (command === "version" || command === "--version" || command === "-v") {
 
 if (command === "update" || command === "upgrade") {
   const { readFileSync } = await import("node:fs");
-  const { spawn } = await import("node:child_process");
+  const { runUpdate, fetchLatestVersion, spawnNpm, daemonControl } = await import("./update.mjs");
   const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-  const current = pkg.version;
-  const checkOnly = commandRest.includes("--check") || commandRest.includes("-c");
-
-  let latest;
-  try {
-    const res = await fetch("https://registry.npmjs.org/my-durable/latest", {
-      headers: { accept: "application/json" },
-    });
-    if (!res.ok) throw new Error(`registry responded ${res.status}`);
-    latest = (await res.json()).version;
-    // This string is later interpolated into a command line (shell on Windows):
-    // anything that is not a plain semver must stop the update, not run.
-    if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z.]+)?$/.test(String(latest)))
-      throw new Error(`registry returned a malformed version: ${latest}`);
-  } catch (error) {
-    process.stderr.write(`dpi update: cannot reach the npm registry (${error.message})\n`);
-    process.exit(1);
-  }
-
-  // Numeric triple compare; a prerelease tag on either side counts as older.
-  const rank = (v) => {
-    const [core, ...pre] = String(v).split("-");
-    const nums = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
-    return { nums: [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0], pre: pre.length > 0 };
-  };
-  const a = rank(current);
-  const b = rank(latest);
-  let order = 0;
-  for (let i = 0; i < 3; i += 1) {
-    if (a.nums[i] !== b.nums[i]) {
-      order = a.nums[i] < b.nums[i] ? -1 : 1;
-      break;
-    }
-  }
-  if (order === 0 && a.pre !== b.pre) order = a.pre ? -1 : 1;
-
-  if (order >= 0) {
-    process.stdout.write(`dpi ${current} is up to date (latest ${latest}).\n`);
-    process.exit(0);
-  }
-  process.stdout.write(`dpi ${current} -> ${latest} available.\n`);
-  if (checkOnly) {
-    process.stdout.write("Run `dpi update` to install it.\n");
-    process.exit(0);
-  }
-
-  // Windows: npm is npm.cmd and cmd.exe only executes batch files through a
-  // shell — a bare spawn("npm") dies with ENOENT (CreateProcess does no
-  // PATHEXT resolution). Args are literals plus the strictly-validated
-  // version above, so shell: true has no injection surface here.
-  const onWindows = process.platform === "win32";
-  const child = spawn(onWindows ? "npm.cmd" : "npm", ["install", "-g", `my-durable@${latest}`], {
-    stdio: "inherit",
-    shell: onWindows,
-  });
-  child.on("error", (error) => {
-    process.stderr.write(`dpi update: cannot run npm (${error.message})\n`);
-    process.exit(1);
+  const port = Number(process.env.DPI_PORT ?? "4780");
+  const code = await runUpdate({
+    argv: commandRest,
+    pkg,
+    nodeVersion: process.versions.node,
+    fetchLatest: fetchLatestVersion,
+    // Stop/start through this same launcher: the daemon must not block npm's
+    // rename on Windows, and it must come back afterwards.
+    daemon: daemonControl(fileURLToPath(import.meta.url), port),
+    runNpm: (version) => spawnNpm(["install", "-g", `my-durable@${version}`]),
+    print: (line) => process.stdout.write(`${line}\n`),
+    printErr: (line) => process.stderr.write(`${line}\n`),
   });
-  child.on("exit", (code) => {
-    if (code !== 0) {
-      process.stderr.write(`dpi update: npm exited ${code}; still on ${current}.\n`);
-      process.exit(code ?? 1);
-    }
-    process.stdout.write(`dpi updated ${current} -> ${latest}.\n`);
+  process.exit(code);
+} else if (command === "devices") {
+  // The CLI view of the network: same data the web sidebar and the TUI show.
+  process.argv = [process.argv[0], process.argv[1], ...commandRest];
+  const { register } = await loadTsx();
+  register();
+  const { listDevices } = await import("../apps/dpi-backend/src/pair-cli.ts");
+  const hubIdx = commandRest.indexOf("--hub");
+  process.exit(
+    await listDevices({}, hubIdx >= 0 ? commandRest[hubIdx + 1] : undefined, commandRest.includes("--watch")),
+  );
+} else if (command === "pair") {
+  // Pairing is its own surface: it runs headless (no TUI, no browser) and both
+  // directions live in one command — this machine, and the operator's side.
+  if (commandRest.includes("--help") || commandRest.includes("-h")) {
+    process.argv = [process.argv[0], process.argv[1], ...commandRest];
+    const { register } = await loadTsx();
+    register();
+    const { PAIR_USAGE } = await import("../apps/dpi-backend/src/pair-cli.ts");
+    process.stdout.write(PAIR_USAGE);
     process.exit(0);
-  });
+  }
+  process.argv = [process.argv[0], process.argv[1], ...commandRest];
+  const { register } = await loadTsx();
+  register();
+  const { runPairCommand } = await import("../apps/dpi-backend/src/pair-cli.ts");
+  process.exit(await runPairCommand(commandRest));
 } else if (!Object.hasOwn(COMMANDS, command)) {
   process.stderr.write(`dpi: unknown command '${command}'\n\n${HELP}`);
   process.exit(2);

package/bin/update.d.mts

@@ -0,0 +1,24 @@
+// Types for bin/update.mjs — the updater is plain JS (it must run before any
+// TS toolchain is available), so its public surface is declared here.
+export interface UpdateDeps {
+  argv: string[];
+  pkg: { version: string; engines?: { node?: string } };
+  nodeVersion: string;
+  fetchLatest: () => Promise<string>;
+  daemon: { running: () => Promise<boolean>; stop: () => Promise<unknown>; start: () => Promise<unknown> };
+  runNpm: (version: string) => Promise<{ code: number; output: string }>;
+  print: (line: string) => void;
+  printErr: (line: string) => void;
+}
+export function rank(version: string): { nums: number[]; pre: boolean };
+export function compareVersions(a: string, b: string): -1 | 0 | 1;
+export function satisfiesEngine(current: string, required: string): boolean;
+export function normalizeExitCode(code: number | undefined): number;
+export function isBusyFailure(text: string): boolean;
+export function runUpdate(deps: UpdateDeps): Promise<number>;
+export function spawnNpm(args: string[]): Promise<{ code: number; output: string }>;
+export function fetchLatestVersion(): Promise<string>;
+export function daemonControl(
+  dpiPath: string,
+  port: number,
+): { running: () => Promise<boolean>; stop: () => Promise<number>; start: () => Promise<number> };

package/bin/update.mjs

@@ -0,0 +1,198 @@
+// `dpi update` — self-update with the two Windows hazards handled explicitly:
+//
+//  1. EBUSY: the running daemon (and a running TUI) hold files inside
+//     `…\npm\node_modules\my-durable\bin`, so npm cannot rename the package
+//     folder while they live. The updater therefore stops the device daemon
+//     first and starts it again afterwards — a background daemon must not be
+//     the reason an update fails, and it must not silently stay down either.
+//  2. EBADENGINE: our dependencies need Node >= 22.19.0. npm only WARNS, then
+//     installs something that can fail at runtime. The updater refuses up front
+//     with an actionable message instead.
+//
+// Everything here is dependency-injected so it can be tested without npm, a
+// network, or a real daemon.
+import { spawn } from "node:child_process";
+
+/** Numeric triple + prerelease flag. A prerelease counts as older. */
+export function rank(version) {
+  const [core, ...pre] = String(version).trim().split("-");
+  const nums = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  return { nums: [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0], pre: pre.length > 0 };
+}
+
+/** -1 | 0 | 1 — semver-ish ordering, enough for "is there a newer release". */
+export function compareVersions(a, b) {
+  const x = rank(a);
+  const y = rank(b);
+  for (let i = 0; i < 3; i += 1) {
+    if (x.nums[i] !== y.nums[i]) return x.nums[i] < y.nums[i] ? -1 : 1;
+  }
+  if (x.pre !== y.pre) return x.pre ? -1 : 1;
+  return 0;
+}
+
+/**
+ * Does `current` satisfy `required` when required looks like ">=22.19.0" /
+ * ">=22" / "22.x"? Only the forms our own package.json can carry are supported;
+ * an unknown form is treated as satisfied so a future syntax never blocks an
+ * update for no reason.
+ */
+export function satisfiesEngine(current, required) {
+  const m = /^>=\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?$/.exec(String(required).trim());
+  if (!m) return true;
+  const want = [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+  const have = rank(current).nums;
+  for (let i = 0; i < 3; i += 1) {
+    if (have[i] !== want[i]) return have[i] > want[i];
+  }
+  return true;
+}
+
+/** npm on Windows reports negative errno values as huge unsigned ints. */
+export function normalizeExitCode(code) {
+  if (typeof code !== "number") return 1;
+  return code > 2 ** 31 ? code - 2 ** 32 : code;
+}
+
+/** A failed install that means "a process still holds the package folder". */
+export function isBusyFailure(text) {
+  return /EBUSY|EPERM|resource busy or locked/i.test(String(text));
+}
+
+/**
+ * Run the update. Deps:
+ *   argv          — process argv (for --check)
+ *   pkg           — this package's package.json contents
+ *   platform      — process.platform
+ *   nodeVersion   — process.versions.node
+ *   fetchLatest   — async () => version string
+ *   daemon        — { running(): Promise<boolean>, stop(): Promise<void>, start(): Promise<void> }
+ *   runNpm        — (version) => Promise<{ code: number; output: string }>
+ *   print / printErr
+ */
+export async function runUpdate(deps) {
+  const { pkg, print, printErr } = deps;
+  const current = pkg.version;
+  const checkOnly = deps.argv.includes("--check") || deps.argv.includes("-c");
+
+  let latest;
+  try {
+    latest = await deps.fetchLatest();
+  } catch (error) {
+    printErr(`dpi update: cannot reach the npm registry (${error.message})`);
+    return 1;
+  }
+
+  const order = compareVersions(current, latest);
+  if (order >= 0) {
+    print(`dpi ${current} is up to date (latest ${latest}).`);
+    return 0;
+  }
+  print(`dpi ${current} -> ${latest} available.`);
+  if (checkOnly) {
+    print("Run `dpi update` to install it.");
+    return 0;
+  }
+
+  // Refuse before touching npm: a warned-about engine is a broken install later.
+  const required = pkg.engines?.node;
+  if (required && !satisfiesEngine(deps.nodeVersion, required)) {
+    printErr(
+      `dpi update: this release needs Node ${required}, you have ${deps.nodeVersion}.`,
+    );
+    printErr("  Upgrade Node first (nvm install --lts / winget upgrade OpenJS.NodeJS.LTS), then retry.");
+    return 1;
+  }
+
+  // Windows: the daemon (and a TUI) hold files inside the package folder, so npm
+  // cannot rename it. Stop the daemon, install, then bring it back.
+  const wasRunning = await deps.daemon.running();
+  if (wasRunning) {
+    print("stopping the device daemon so npm can replace the package…");
+    await deps.daemon.stop();
+  }
+
+  let result = await deps.runNpm(latest);
+
+  // A stale TUI can still hold the folder; retry once with the reason spelled out.
+  if (result.code !== 0 && isBusyFailure(result.output)) {
+    printErr("dpi update: the package folder is still in use — close any running `dpi tui` window.");
+    printErr("  Retrying once…");
+    result = await deps.runNpm(latest);
+  }
+
+  if (result.code !== 0) {
+    printErr(`dpi update: npm failed (exit ${normalizeExitCode(result.code)}); still on ${current}.`);
+    if (isBusyFailure(result.output))
+      printErr("  Close every dpi window (tui + device) and run `dpi update` again.");
+    if (wasRunning) await deps.daemon.start();
+    return 1;
+  }
+
+  print(`dpi updated ${current} -> ${latest}.`);
+  if (wasRunning) {
+    print("restarting the device daemon…");
+    await deps.daemon.start();
+  }
+  return 0;
+}
+
+// ------------------------------------------------------------------ real deps
+
+/** Spawn npm correctly on every platform (npm is npm.cmd on Windows). */
+export function spawnNpm(args) {
+  return new Promise((resolve) => {
+    const onWindows = process.platform === "win32";
+    const child = spawn(onWindows ? "npm.cmd" : "npm", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: onWindows,
+    });
+    let output = "";
+    child.stdout?.on("data", (x) => {
+      output += x;
+      process.stdout.write(x);
+    });
+    child.stderr?.on("data", (x) => {
+      output += x;
+      process.stderr.write(x);
+    });
+    child.on("error", (error) => resolve({ code: 1, output: `${output}${error.message}` }));
+    child.on("exit", (code) => resolve({ code: code ?? 1, output }));
+  });
+}
+
+export async function fetchLatestVersion() {
+  const res = await fetch("https://registry.npmjs.org/my-durable/latest", {
+    headers: { accept: "application/json" },
+  });
+  if (!res.ok) throw new Error(`registry responded ${res.status}`);
+  const version = (await res.json()).version;
+  // This string reaches a command line (shell on Windows): a malformed value
+  // must stop the update instead of running.
+  if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z.]+)?$/.test(String(version)))
+    throw new Error(`registry returned a malformed version: ${version}`);
+  return version;
+}
+
+/** Daemon control through the same CLI, so update needs no TS import. */
+export function daemonControl(dpiPath, port) {
+  const call = (args) =>
+    new Promise((resolve) => {
+      const child = spawn(process.execPath, [dpiPath, ...args], { stdio: "ignore" });
+      child.on("error", () => resolve(1));
+      child.on("exit", (code) => resolve(code ?? 1));
+    });
+  const running = async () => {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(800) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    running,
+    stop: () => call(["device", "stop"]),
+    start: () => call(["device", "start"]),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-durable",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Durable Pi \u2014 the durable agent network: hub web UI, device backend daemon, TUI admin and the shared SDK, packaged as one runnable monorepo install",
   "license": "MIT",
   "repository": {
@@ -12,7 +12,7 @@
   },
   "homepage": "https://github.com/baphuongna/my-durable#readme",
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.19.0"
   },
   "bin": {
     "dpi": "bin/dpi.mjs"

package/scripts/verify.mjs

@@ -141,6 +141,11 @@ const SUITES = {
     cmd: ["node", "tests/newsession-ui.mjs"],
     title: "real PTY session creation on a keyless device + empty-state layout",
   },
+  "ui:tui-keymap": {
+    cwd: "apps/dpi-tui",
+    cmd: ["node", "tests/keymap-ui.mjs"],
+    title: "real PTY keymap: every advertised key drives a real backend",
+  },
   "ui:tui-welcome": {
     cwd: "apps/dpi-tui",
     cmd: ["node", "tests/welcome-ui.mjs"],
@@ -165,6 +170,7 @@ const PHASE_SUITES = {
     "ui:pairing",
     "ui:tui",
     "ui:tui-session",
+    "ui:tui-keymap",
     "ui:tui-welcome",
   ],
 };