my-durable 0.0.14 → 0.0.16

package/apps/dpi-backend/src/daemon.ts

@@ -242,25 +242,37 @@ function pidFrom(paths: DaemonPaths): number | undefined {
 
 // ---------------------------------------------------------------- commands
 
-async function cmdStart(io: Io, rest: string[]): Promise<number> {
-  const paths = daemonPaths(io.env);
-  if ((await health(io))?.ok) {
-    io.print(`already running (pid ${pidFrom(paths) ?? "?"}) on port ${portOf(io)}`);
-    return 0;
-  }
-  const dpi = io.env.DPI_BIN ?? (process.argv[1]?.endsWith(".mjs") ? process.argv[1] : "");
+/** The spawn `dpi device start` performs — exported so the TUI can bring the
+ *  local backend up itself instead of telling the user to open another shell. */
+export function startBackendDetached(
+  env: Record<string, string | undefined>,
+  rest: string[] = [],
+): { ok: boolean; pid?: number; log: string; reason?: string } {
+  const paths = daemonPaths(env);
+  const dpi = env.DPI_BIN ?? (process.argv[1]?.endsWith(".mjs") ? process.argv[1] : "");
   if (!dpi || !existsSync(dpi))
-    return io.print("start needs the dpi launcher (run via `dpi device start`)"), 1;
+    return { ok: false, log: paths.log, reason: "no dpi launcher found" };
   mkdirSync(paths.home, { recursive: true, mode: 0o700 });
   const fd = openSync(paths.log, "a");
   const child = spawn(process.execPath, [dpi, "device", ...rest], {
     detached: true,
     stdio: ["ignore", fd, fd],
-    env: cleanChildEnv(io.env),
+    env: cleanChildEnv(env),
     cwd: dirname(dpi),
   });
   child.unref();
   closeSync(fd);
+  return { ok: true, pid: child.pid, log: paths.log };
+}
+
+async function cmdStart(io: Io, rest: string[]): Promise<number> {
+  const paths = daemonPaths(io.env);
+  if ((await health(io))?.ok) {
+    io.print(`already running (pid ${pidFrom(paths) ?? "?"}) on port ${portOf(io)}`);
+    return 0;
+  }
+  const started = startBackendDetached(io.env, rest);
+  if (!started.ok) return io.print(started.reason ?? "start failed"), 1;
   io.print(`starting dpi device … (log: ${paths.log})`);
   if (await waitHealthUp(io, 20_000)) {
     io.print(`running on http://127.0.0.1:${portOf(io)} (pid ${pidFrom(paths) ?? "?"})`);

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

@@ -551,6 +551,12 @@ export class App {
     if (matchesKey(data, "escape")) {
       this.input = null;
       this.toast = "";
+      // esc aborts the filter line: a half-typed needle must not linger.
+      if (input.kind === "filter" && this.filter) {
+        this.filter = "";
+        this.cursor = 0;
+        this.notify("filter cleared");
+      }
       return true;
     }
     // The slash suggestion list is a MENU while it is open: ↑/↓ steer it and
@@ -652,6 +658,13 @@ export class App {
       const chunk = data.replace(/\r\n?/g, "\n");
       if (chunk >= " " || [...chunk].some((ch) => ch >= " ") || chunk.includes("\n")) (input.value += chunk), (this.suggIndex = 0);
     }
+    // The filter narrows the list LIVE, on every keystroke — enter merely
+    // closes the line. Waiting for enter made "f" feel dead for a beat.
+    if (input.kind === "filter") {
+      this.filter = input.value.trim();
+      if (!this.filter && this.cursor) this.cursor = 0;
+      this.requestRender();
+    }
     return true;
   }
 
@@ -717,8 +730,19 @@ export class App {
     this.openCursor();
   }
 
+  /**
+   * Tab/Shift+Tab cycle whatever tab strip is on screen — pi's exact
+   * semantics: the four VIEWS on herd/network/log, the agent's own tabs in
+   * the conversation. Before, "tab" outside the agent view did nothing at
+   * all, which on the outermost session list reads as "navigation is dead"
+   * (reported: "không điều hướng xem tab khác ngoài tab session đầu tiên").
+   */
   private cycleTab(delta: number) {
-    if (this.view !== "agent") return;
+    if (this.view !== "agent") {
+      const index = VIEW_TABS.findIndex((t) => t.id === this.view);
+      this.setView(VIEW_TABS[(index + delta + VIEW_TABS.length) % VIEW_TABS.length]!.id);
+      return;
+    }
     const index = AGENT_TABS.findIndex((t) => t.id === this.tab);
     this.tab = AGENT_TABS[(index + delta + AGENT_TABS.length) % AGENT_TABS.length]!.id;
     this.scrollOffset = 0;

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

@@ -112,6 +112,16 @@ async function start(device: DeviceRef, client: DpiClient, info: DeviceInfo, opt
   if (opts.devicePicker) pickDevice(app);
 }
 
+/** Loopback = the device this very machine runs; the TUI may start it itself. */
+function isLoopbackUrl(url: string): boolean {
+  try {
+    const h = new URL(url).hostname.toLowerCase();
+    return h === "127.0.0.1" || h === "localhost" || h === "[::1]" || h === "::1";
+  } catch {
+    return false;
+  }
+}
+
 // The app opens first; connection is a state, not a precondition. With no explicit
 // device/url/pair: one saved device opens it directly, several open on the first
 // with the device picker on top, none open the welcome screen.
@@ -127,6 +137,19 @@ if (startup.kind === "welcome") {
     const info = await client.device({ timeoutMs: 8000 });
     await start(device, client, info, { devicePicker: startup.kind === "picker" });
   } catch (e) {
+    // The device this machine itself runs is loopback: nobody else can start
+    // it, so we do — exactly what `dpi device start` would, without leaving
+    // the TUI. A remote (tunnel) device stays an offline notice.
+    let info2: Awaited<ReturnType<typeof client.device>> | undefined;
+    if (isLoopbackUrl(device.url)) {
+      const { ensureLocalBackend } = await import("./welcome.ts");
+      const port = Number(new URL(device.url).port) || 4780;
+      const r = await ensureLocalBackend({ port, token: device.token });
+      if (r.probe.ok) info2 = await client.device({ timeoutMs: 8000 });
+    }
+    if (info2) {
+      await start(device, client, info2, { devicePicker: startup.kind === "picker" });
+    } else {
     // An auto-connected device that is unreachable falls back to a screen that says
     // so and offers the picker + welcome actions — never back to usage text.
     showWelcome(new App(WELCOME_DEVICE, new DpiClient(WELCOME_DEVICE.url, WELCOME_DEVICE.token), emptyDeviceInfo(), registry), {
@@ -135,6 +158,7 @@ if (startup.kind === "welcome") {
           ? `${device.id}: token rejected by ${device.url}`
           : `${device.id} is offline at ${device.url} (${(e as Error).message})`,
     });
+    }
   }
 } else if (url) {
   const token = values.token ?? process.env.DPI_TOKEN ?? "";

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

@@ -242,7 +242,7 @@ export function renderStatusbar(
     ? ["tab complete", "↑ history", "enter send", "esc cancel"]
     : opts.view === "agent"
       ? ["g herd", "N network", "L log", "[ ] tabs", "m message"]
-      : ["j/k move", "↵ open", "1-9 jump", "g/N/L views", "esc agent"];
+      : ["j/k move", "↵ open", "1-9 jump", "⇥ views", "esc agent"];
   const right = `${c.muted("ctx")} ${opts.ctxLeft === undefined ? c.muted("—") : c.text(`${opts.ctxLeft}%`)}${opts.background ? c.muted(` · ${opts.background} bg`) : ""}  ${c.muted("dev")} ${c.text(fit(opts.device, 18))}`;
   const left = `${chip} ${keys.map((k) => c.muted(k)).join(c.muted(" • "))}`;
   const gap = Math.max(1, w - visibleWidth(left) - visibleWidth(right));

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

@@ -12,6 +12,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { matchesKey, type SelectItem } from "@earendil-works/pi-tui";
+import { startBackendDetached } from "../../dpi-backend/src/daemon.ts";
 import { DpiClient } from "../../dpi-sdk/src/client.ts";
 import type { DeviceInfo } from "../../dpi-sdk/src/api.ts";
 import { isDpiError } from "../../dpi-sdk/src/errors.ts";
@@ -156,7 +157,41 @@ export function describeLocalProbe(probe: LocalProbe, port: number): string {
   if (probe.ok) return `local dpi-backend on 127.0.0.1:${port}: ${probe.info.name || probe.info.hostname || "unnamed device"}`;
   if (probe.reason === "unauthorized")
     return `the local dpi-backend on 127.0.0.1:${port} rejected the token — check DPI_TOKEN (env or ${join(dpiHome(), "backend.env")})`;
-  return `no local dpi-backend on 127.0.0.1:${port} — start one with: dpi device`;
+  return `no local dpi-backend on 127.0.0.1:${port} — auto-start failed; run \`dpi device start\` and check ${join(dpiHome(), "device.log")}`;
+}
+
+export type EnsureStarter = () => { ok: boolean; log: string; pid?: number; reason?: string };
+export type EnsureResult = { probe: LocalProbe; started: boolean; log?: string; reason?: string };
+
+/**
+ * Probe the local backend and, if nothing answers, START one the way
+ * `dpi device start` does (detached, log to <home>/device.log) and wait for it.
+ * herdr spawns its own server; we do the same for the loopback device. A token
+ * rejection is never auto-started away — that's a credential problem.
+ */
+export async function ensureLocalBackend(
+  opts: { port?: number; token?: string; fetchImpl?: typeof fetch; start?: EnsureStarter; waitMs?: number } = {},
+): Promise<EnsureResult> {
+  const port = opts.port ?? applyBackendEnv().port;
+  const probeOf = async (): Promise<LocalProbe> => {
+    // a first boot WRITES backend.env, so the token can appear mid-wait
+    const token = opts.token ?? applyBackendEnv({ ...process.env, ...(opts.token ? { DPI_TOKEN: opts.token } : {}) }).token;
+    if (!token) return { ok: false, reason: "unreachable" };
+    return probeLocalBackend(localBackendUrl(port), token, opts.fetchImpl);
+  };
+  const first = await probeOf();
+  if (first.ok || first.reason === "unauthorized") return { probe: first, started: false };
+  const start: EnsureStarter = opts.start ?? (() => startBackendDetached(process.env));
+  const r = start();
+  if (!r.ok) return { probe: first, started: false, reason: r.reason, log: r.log };
+  const deadline = Date.now() + (opts.waitMs ?? 15_000);
+  let last: LocalProbe = first;
+  while (Date.now() < deadline) {
+    await new Promise((res) => setTimeout(res, 400));
+    last = await probeOf();
+    if (last.ok) return { probe: last, started: true, log: r.log, reason: `pid ${r.pid}` };
+  }
+  return { probe: last, started: true, log: r.log };
 }
 
 // ------------------------------------------------------------------ ids and device input
@@ -354,20 +389,22 @@ async function welcomeAddUrl(app: App) {
 async function welcomeLocal(app: App) {
   const local = applyBackendEnv();
   app.flash(`Probing 127.0.0.1:${local.port}…`);
-  const probe = local.token
-    ? await probeLocalBackend(localBackendUrl(local.port), local.token)
-    : ({ ok: false, reason: "unreachable" } as const);
-  if (!probe.ok) {
-    app.flash(describeLocalProbe(probe, local.port), true);
+  const ensured = await ensureLocalBackend({ port: local.port, token: local.token });
+  if (ensured.started && ensured.probe.ok) app.flash(`started the local dpi-backend (${ensured.reason})`);
+  if (!ensured.probe.ok) {
+    app.flash(describeLocalProbe(ensured.probe, local.port), true);
     return showWelcome(app);
   }
+  const probe = ensured.probe;
   const url = localBackendUrl(local.port);
   const id = suggestDeviceId(probe.info.hostname, probe.info.name);
   stepPicker(
     app,
     `Local backend: ${probe.info.name || probe.info.hostname || url}`,
     [{ value: "open", label: `Save as "${id}" and open`, description: `${url} │ token from DPI_TOKEN / backend.env` }],
-    () => void saveAndOpen(app, id, url, local.token!, probe.info.name),
+    // local.token was read BEFORE a first boot may have written backend.env —
+    // re-resolve, the file exists now.
+    () => void saveAndOpen(app, id, url, applyBackendEnv().token!, probe.info.name),
   );
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-durable",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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": {

package/scripts/verify.mjs

@@ -151,6 +151,11 @@ const SUITES = {
     cmd: ["node", "tests/welcome-ui.mjs"],
     title: "real PTY welcome screen, detect-local and quit",
   },
+  "ui:tui-ensure": {
+    cwd: "apps/dpi-tui",
+    cmd: ["node", "tests/ensure-ui.mjs"],
+    title: "real PTY [d] auto-starts the local dpi-backend and opens it",
+  },
 };
 
 const PHASE_GATES = ["test:verification", "check:sdk", "check:backend", "contract:backend", "build:playground", "check:tui"];
@@ -172,6 +177,7 @@ const PHASE_SUITES = {
     "ui:tui-session",
     "ui:tui-keymap",
     "ui:tui-welcome",
+    "ui:tui-ensure",
   ],
 };