my-durable 0.0.13 → 0.0.15

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/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/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/bin/update.d.mts

@@ -22,3 +22,5 @@ export function daemonControl(
   dpiPath: string,
   port: number,
 ): { running: () => Promise<boolean>; stop: () => Promise<number>; start: () => Promise<number> };
+/** Below this the app cannot run at all (node:sqlite). The only hard block. */
+export const REQUIRED_NODE_FLOOR: string;

package/bin/update.mjs

@@ -31,6 +31,12 @@ export function compareVersions(a, b) {
   return 0;
 }
 
+/**
+ * The floor we KNOW breaks: below 22.5.0 there is no node:sqlite, and the
+ * device dies at boot. This — and only this — is a hard block.
+ */
+export const REQUIRED_NODE_FLOOR = "22.5.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;
@@ -94,15 +100,22 @@ export async function runUpdate(deps) {
     return 0;
   }
 
-  // Refuse before touching npm: a warned-about engine is a broken install later.
+  // pi's philosophy, which we follow: engines metadata is ADVICE. pi declares
+  // node >=22.19.0 too, npm only warns, and nothing enforces it at runtime —
+  // so an update proceeds with a visible warning. We hard-block ONLY below the
+  // floor we know is broken (no node:sqlite ⇒ the device cannot even boot).
   const required = pkg.engines?.node;
-  if (required && !satisfiesEngine(deps.nodeVersion, required)) {
+  if (compareVersions(deps.nodeVersion, REQUIRED_NODE_FLOOR) < 0) {
     printErr(
-      `dpi update: this release needs Node ${required}, you have ${deps.nodeVersion}.`,
+      `dpi update: Node ${deps.nodeVersion} is too old — durable needs Node >= ${REQUIRED_NODE_FLOOR} (node:sqlite).`,
     );
-    printErr("  Upgrade Node first (nvm install --lts / winget upgrade OpenJS.NodeJS.LTS), then retry.");
+    printErr("  Upgrade Node (nvm install --lts / winget upgrade OpenJS.NodeJS.LTS) and retry.");
     return 1;
   }
+  if (required && !satisfiesEngine(deps.nodeVersion, required)) {
+    print(`note: this release declares Node ${required}, you have ${deps.nodeVersion}.`);
+    print(`      like pi, it installs and runs anyway; upgrade Node if anything misbehaves.`);
+  }
 
   // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-durable",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "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",
   ],
 };