my-durable 0.0.10 → 0.0.12

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-DEFBWh1G.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Cg3vey95.css">
   </head>
   <body>

package/apps/dpi-playground/apps/dpi-playground-fe/src/components/NewSessionDialog.vue

@@ -38,6 +38,8 @@ const models = computed(() => {
 const catalogEmpty = computed(
   () => !models.value.length || (device.value?.info?.models?.length ?? 0) === 0,
 );
+/** The device lists its built-in catalog but chat needs the key (0.0.12+ devices). */
+const keyless = computed(() => !!(device.value?.info as { providerKeyMissing?: boolean } | undefined)?.providerKeyMissing);
 const key = (m: { provider: string; id: string }) => `${m.provider}/${m.id}`;
 const draft = ref({ name: "", cwd: "", model: "" });
 const pending = ref(false);
@@ -121,10 +123,10 @@ async function create() {
         </div>
         <label
           >Model<span
-            v-if="catalogEmpty"
+            v-if="catalogEmpty || keyless"
             class="hint"
-            title="The device reports no usable models — create still works with its default; add the provider key on the device (e.g. OPENROUTER_API_KEY) to see the catalog"
-            >no key on device — using default</span
+            title="The device has no provider key — it lists its built-in catalog, and chat needs OPENROUTER_API_KEY set in the device's env file"
+            >no API key on device — chat needs one</span
           ><select v-model="draft.model" aria-label="New session model">
             <option v-for="m in models" :key="key(m)" :value="key(m)">
               {{ m.tier }} / {{ m.name }}

package/apps/dpi-sdk/src/api.ts

@@ -96,6 +96,8 @@ export interface DeviceInfo {
   defaultModel: string;
   /** Provider id of this device ("openrouter" | "faux"); FE model fallback. */
   provider?: string;
+  /** No provider key on the device: the catalog shown is the built-in list and chat needs the key. */
+  providerKeyMissing?: boolean;
   storage: { dataDir: string; catalogPath: string; appStatePath: string };
   /** The checkout the backend runs from (repo root locally, `code_dir` on deployed devices). */
   codeDir?: string;

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 };
   }
 
@@ -526,6 +553,20 @@ export class App {
       this.toast = "";
       return true;
     }
+    // The slash suggestion list is a MENU while it is open: ↑/↓ steer it and
+    // enter picks — history recall waits until the list is gone. (Reported:
+    // "danh sách slash command không điều hướng được, enter không autocomplete".)
+    const sugg = input.kind === "message" ? slashSuggestions(input.value, COMMANDS) : null;
+    if (sugg && matchesKey(data, "up")) {
+      this.suggIndex = Math.max(0, this.suggIndex - 1);
+      this.requestRender();
+      return true;
+    }
+    if (sugg && matchesKey(data, "down")) {
+      this.suggIndex = Math.min(sugg.names.length - 1, this.suggIndex + 1);
+      this.requestRender();
+      return true;
+    }
     // ↑/↓ recall sent messages; the current draft survives the round-trip.
     if (input.kind === "message" && matchesKey(data, "up")) {
       if (this.inputHistory.length) {
@@ -548,13 +589,11 @@ export class App {
     }
     // Tab completes the selected slash suggestion; shift+tab cycles it.
     if (input.kind === "message" && matchesKey(data, "shift+tab")) {
-      const sugg = slashSuggestions(input.value, COMMANDS);
       if (sugg) this.suggIndex = (this.suggIndex + 1) % sugg.names.length;
       this.requestRender();
       return true;
     }
     if (input.kind === "message" && matchesKey(data, "tab")) {
-      const sugg = slashSuggestions(input.value, COMMANDS);
       if (sugg) {
         const pick = sugg.names[this.suggIndex % sugg.names.length]!;
         input.value = `/${pick} `;
@@ -572,6 +611,21 @@ export class App {
       return true;
     }
     if (matchesKey(data, "enter")) {
+      // Enter completes the highlighted suggestion (the completed text gains a
+      // trailing space, the list closes, and the NEXT enter submits). An exact
+      // command ("/model") runs immediately instead — completing it would force
+      // a pointless second enter.
+      if (
+        sugg &&
+        input.kind === "message" &&
+        !COMMANDS.some((c) => `/${c.name}` === input.value)
+      ) {
+        const pick = sugg.names[this.suggIndex % sugg.names.length]!;
+        input.value = `/${pick} `;
+        this.suggIndex = 0;
+        this.requestRender();
+        return true;
+      }
       const value = input.value;
       this.input = null;
       this.toast = "";
@@ -607,15 +661,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 +691,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 +848,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();
@@ -333,6 +333,12 @@ function chooseModel(app: App, current?: string) {
         app.closeOverlay();
         done(undefined);
       },
+      undefined,
+      // The keyless device still lists the built-in catalog — say why chat
+      // will fail, instead of letting the first request be the messenger.
+      (app.info as { providerKeyMissing?: boolean }).providerKeyMissing
+        ? "no API key on this device — chat needs OPENROUTER_API_KEY in its env file"
+        : undefined,
     );
     const index = models.findIndex((m) => m.id === current);
     if (index >= 0) picker.list.setSelectedIndex(index);

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> };