my-durable 0.0.4 → 0.0.6

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

@@ -1,16 +1,23 @@
 // dpi-tui: a pi-like terminal client for one Durable Agent Network device.
+//   dpi-tui                                        the app; welcome screen when nothing to connect to,
+//                                                  the single saved device when there is exactly one
 //   dpi-tui <device>[:<session>[:<agent>]]        device from ~/.dpi/network.sqlite (seeded from dpi-network.yaml)
 //   dpi-tui --url <url> --token <token> [--save <id>]
 //   dpi-tui mac-mini --new triage                 create a session (in the device's first start dir) and attach
 import { parseArgs } from "node:util";
 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";
 import { NetworkRegistry } from "../../dpi-sdk/src/node/registry.ts";
 import { syncConfigToRegistry, tryLoadNetworkConfig } from "../../dpi-sdk/src/node/config.ts";
 import { App, type DeviceRef } from "./app.ts";
+import { pickDevice } from "./pickers.ts";
+import { emptyDeviceInfo, resolveStartupAction, showWelcome, WELCOME_DEVICE } from "./welcome.ts";
 
-const USAGE = `usage: dpi-tui <device>[:<session>[:<agent>]] [options]
+const USAGE = `usage: dpi-tui [device[:session[:agent]]] [options]
        dpi-tui --url <url> --token <token> [--save <id>]
+       dpi-tui                 no arguments: the app opens (welcome screen when no
+                               device is saved; the one saved device when there is one)
 
   -s, --session <ref>   session id or name (else a picker opens)
   -a, --agent <ref>     agent id, "main" or name (default: the session's root agent)
@@ -59,64 +66,121 @@ const [deviceRef = "", sessionRef = values.session, agentRef = values.agent] = (
   positionals[0] ?? (url ? "" : (process.env.DPI_DEVICE ?? ""))
 ).split(":");
 
-let device: DeviceRef;
-if (url) {
-  const token = values.token ?? process.env.DPI_TOKEN ?? "";
-  if (!token) fail("--url needs --token (or DPI_TOKEN)");
-  device = { id: values.save ?? "adhoc", name: values.save ?? new URL(url).host, url: url.replace(/\/+$/, ""), token };
-} else {
-  const known = registry.list().map((d) => d.id);
-  if (!deviceRef) fail(`${USAGE}\n\nKnown devices: ${known.join(", ") || "none"}`);
-  const row = registry.get(deviceRef);
-  if (!row) fail(`Unknown device "${deviceRef}". Known: ${known.join(", ") || "none (add one to dpi-network.yaml)"}`);
-  if (!row.token) fail(`No token for ${row.id}. Run: just net register ${row.id}`);
-  if (!row.url)
-    fail(`Device ${row.id} is paired over the tunnel — it has no LAN URL. Attach through the hub web UI, or pair this machine directly.`);
-  device = { id: row.id, name: row.name, url: row.url, token: row.token };
-}
+/** The shared tail of every path that has a device: --save, --new, the App, --pair, open. */
+async function start(device: DeviceRef, client: DpiClient, info: DeviceInfo, opts: { devicePicker?: boolean } = {}) {
+  if (values.save && url)
+    registry.upsert({ id: values.save, name: values.save, url: device.url, kind: "url", source: "ui", token: device.token });
 
-const client = new DpiClient(device.url, device.token);
-const info = await client.device({ timeoutMs: 8000 }).catch((e: unknown) =>
-  fail(
-    isDpiError(e) && e.code === "unauthorized"
-      ? `${device.id}: token rejected by ${device.url}`
-      : `${device.id} is offline at ${device.url} (${(e as Error).message})`,
-  ),
-);
-if (values.save && url)
-  registry.upsert({ id: values.save, name: values.save, url: device.url, kind: "url", source: "ui", token: device.token });
+  let session = sessionRef;
+  if (values.new) {
+    const cwd = values.cwd ?? (await client.dirs("")).dirs[0]?.path;
+    if (!cwd) fail(`${device.id} has no start dirs; pass --cwd`);
+    const modelId = values.model ?? info.defaultModel;
+    const model = info.models.find((m) => m.id === modelId);
+    if (!model) fail(`Unknown model ${modelId}. Available: ${info.models.map((m) => m.id).join(", ")}`);
+    const created = await client
+      .createSession({ name: values.new, cwd, model: { provider: model.provider, modelId: model.id } })
+      .catch((e: Error) => fail(`Could not create the session: ${e.message}`));
+    session = created.id;
+  }
+
+  const app = new App(device, client, info, registry);
 
-let session = sessionRef;
-if (values.new) {
-  const cwd = values.cwd ?? (await client.dirs("")).dirs[0]?.path;
-  if (!cwd) fail(`${device.id} has no start dirs; pass --cwd`);
-  const modelId = values.model ?? info.defaultModel;
-  const model = info.models.find((m) => m.id === modelId);
-  if (!model) fail(`Unknown model ${modelId}. Available: ${info.models.map((m) => m.id).join(", ")}`);
-  const created = await client
-    .createSession({ name: values.new, cwd, model: { provider: model.provider, modelId: model.id } })
-    .catch((e: Error) => fail(`Could not create the session: ${e.message}`));
-  session = created.id;
+  // Bootstrap local pairing (--pair CODE --hub ORIGIN [--force]): runs the same
+  // controller as /pair, against the LOCAL backend, before the UI opens. A bare
+  // --pair without a value points at the slash command instead of guessing.
+  if (values.pair !== undefined || values.hub !== undefined) {
+    const { runPairing, parsePairArgs, LocalPairing } = await import("./pairing.ts");
+    if (!values.pair) {
+      process.stdout.write("--pair needs the code from the hub wizard (or its pair URL).\nInside dpi-tui, run: /pair <CODE> --hub <origin>\n");
+      process.exit(1);
+    }
+    try {
+      LocalPairing.fromEnv();
+    } catch (e) {
+      fail((e as Error).message);
+    }
+    await app.open(session, agentRef);
+    await runPairing(app, parsePairArgs([values.pair, ...(values.hub ? ["--hub", values.hub] : []), ...(values.force ? ["--force"] : [])].join(" ")));
+    return;
+  }
+  await app.open(session, agentRef);
+  if (opts.devicePicker) pickDevice(app);
 }
 
-const app = new App(device, client, info, registry);
+// 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.
+const startup = resolveStartupAction({ devices: registry.list(), env: process.env, args: { deviceRef, url, pair: values.pair } });
 
-// Bootstrap local pairing (--pair CODE --hub ORIGIN [--force]): runs the same
-// controller as /pair, against the LOCAL backend, before the UI opens. A bare
-// --pair without a value points at the slash command instead of guessing.
-if (values.pair !== undefined || values.hub !== undefined) {
-  const { runPairing, parsePairArgs, LocalPairing } = await import("./pairing.ts");
-  if (!values.pair) {
-    process.stdout.write("--pair needs the code from the hub wizard (or its pair URL).\nInside dpi-tui, run: /pair <CODE> --hub <origin>\n");
-    process.exit(1);
-  }
+if (startup.kind === "welcome") {
+  showWelcome(new App(WELCOME_DEVICE, new DpiClient(WELCOME_DEVICE.url, WELCOME_DEVICE.token), emptyDeviceInfo(), registry));
+} else if (startup.kind === "auto-open" || startup.kind === "picker") {
+  const row = startup.kind === "auto-open" ? startup.device : startup.devices[0]!;
+  const device: DeviceRef = { id: row.id, name: row.name, url: row.url!, token: row.token! };
+  const client = new DpiClient(device.url, device.token);
   try {
-    LocalPairing.fromEnv();
+    const info = await client.device({ timeoutMs: 8000 });
+    await start(device, client, info, { devicePicker: startup.kind === "picker" });
   } catch (e) {
-    fail((e as Error).message);
+    // 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), {
+      notice:
+        isDpiError(e) && e.code === "unauthorized"
+          ? `${device.id}: token rejected by ${device.url}`
+          : `${device.id} is offline at ${device.url} (${(e as Error).message})`,
+    });
   }
-  await app.open(session, agentRef);
-  await runPairing(app, parsePairArgs([values.pair, ...(values.hub ? ["--hub", values.hub] : []), ...(values.force ? ["--force"] : [])].join(" ")));
+} else if (url) {
+  const token = values.token ?? process.env.DPI_TOKEN ?? "";
+  if (!token) fail("--url needs --token (or DPI_TOKEN)");
+  const device: DeviceRef = { id: values.save ?? "adhoc", name: values.save ?? new URL(url).host, url: url.replace(/\/+$/, ""), token };
+  const client = new DpiClient(device.url, device.token);
+  const info = await client.device({ timeoutMs: 8000 }).catch((e: unknown) =>
+    fail(
+      isDpiError(e) && e.code === "unauthorized"
+        ? `${device.id}: token rejected by ${device.url}`
+        : `${device.id} is offline at ${device.url} (${(e as Error).message})`,
+    ),
+  );
+  await start(device, client, info);
 } else {
-  await app.open(session, agentRef);
+  const known = registry.list().map((d) => d.id);
+  if (!deviceRef && (values.pair !== undefined || values.hub !== undefined)) {
+    // Fresh-install flow: an explicit --pair (a pasted code, pair URL or offer link IS
+    // the whole configuration) must never die on usage text — pair this machine's LOCAL
+    // backend first, then the app opens on it. Mirrors the welcome screen's [p] action.
+    const { applyBackendEnv } = await import("./welcome.ts");
+    applyBackendEnv();
+    const { LocalPairing } = await import("./pairing.ts");
+    try {
+      LocalPairing.fromEnv();
+    } catch (e) {
+      fail((e as Error).message);
+    }
+    const port = Number(process.env.DPI_PORT ?? "4780");
+    const url = `http://127.0.0.1:${port}`;
+    const device: DeviceRef = { id: "local", name: "This machine", url, token: process.env.DPI_TOKEN ?? "" };
+    const client = new DpiClient(url, device.token);
+    const info = await client.device({ timeoutMs: 8000 }).catch((e: unknown) =>
+      fail(`no local dpi-backend on ${url} — start one with: dpi device (${(e as Error).message})`),
+    );
+    await start(device, client, info);
+  } else if (!deviceRef) fail(`${USAGE}\n\nKnown devices: ${known.join(", ") || "none"}`);
+  const row = registry.get(deviceRef);
+  if (!row) fail(`Unknown device "${deviceRef}". Known: ${known.join(", ") || "none (add one to dpi-network.yaml)"}`);
+  if (!row.token) fail(`No token for ${row.id}. Run: just net register ${row.id}`);
+  if (!row.url)
+    fail(`Device ${row.id} is paired over the tunnel — it has no LAN URL. Attach through the hub web UI, or pair this machine directly.`);
+  const device: DeviceRef = { id: row.id, name: row.name, url: row.url, token: row.token };
+  const client = new DpiClient(device.url, device.token);
+  const info = await client.device({ timeoutMs: 8000 }).catch((e: unknown) =>
+    fail(
+      isDpiError(e) && e.code === "unauthorized"
+        ? `${device.id}: token rejected by ${device.url}`
+        : `${device.id} is offline at ${device.url} (${(e as Error).message})`,
+    ),
+  );
+  await start(device, client, info);
 }

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

@@ -4,6 +4,7 @@ import {
   Container,
   Input,
   matchesKey,
+  renderFakeCursor,
   SelectList,
   truncateToWidth,
   type Component,
@@ -35,6 +36,7 @@ export class Picker extends Box {
     onPick: (item: SelectItem) => void,
     onCancel: () => void,
     hint = "↑↓ move │ enter select │ type to filter │ esc close",
+    subtitle?: string,
   ) {
     super(1, 0, panelBg);
     this.title = new Title(c.bold(c.accent(label)));
@@ -42,6 +44,7 @@ export class Picker extends Box {
     this.list.onSelect = onPick;
     this.list.onCancel = onCancel;
     this.addChild(this.title);
+    if (subtitle) this.addChild(new Title(subtitle));
     this.addChild(this.list);
     this.addChild(new Title(c.muted(hint)));
   }
@@ -79,6 +82,101 @@ export class Prompt extends Box implements Focusable {
   }
 }
 
+/** A single-line input that never renders its value — for tokens. */
+export class SecretInput implements Component, Focusable {
+  private value = "";
+  private cursor = 0;
+  private pasteBuffer?: string;
+  focused = false;
+  onSubmit?: (value: string) => void;
+  onEscape?: () => void;
+  getValue() {
+    return this.value;
+  }
+  handleInput(data: string) {
+    if (this.pasteBuffer !== undefined) {
+      this.pasteBuffer += data;
+      const end = this.pasteBuffer.indexOf("\x1b[201~");
+      if (end === -1) return;
+      const pasted = this.pasteBuffer.slice(0, end);
+      const rest = this.pasteBuffer.slice(end + 6);
+      this.pasteBuffer = undefined;
+      if (pasted) this.insert(pasted);
+      if (rest) this.handleInput(rest);
+      return;
+    }
+    if (data.startsWith("\x1b[200~")) {
+      const end = data.indexOf("\x1b[201~");
+      if (end === -1) {
+        this.pasteBuffer = data.slice(6);
+        return;
+      }
+      const pasted = data.slice(6, end);
+      const rest = data.slice(end + 6);
+      if (pasted) this.insert(pasted);
+      if (rest) this.handleInput(rest);
+      return;
+    }
+    if (matchesKey(data, "escape")) return this.onEscape?.();
+    if (data === "\n" || matchesKey(data, "enter")) return this.onSubmit?.(this.value);
+    if (matchesKey(data, "backspace")) {
+      if (this.cursor > 0) this.value = this.value.slice(0, this.cursor - 1) + this.value.slice(this.cursor--);
+      return;
+    }
+    if (matchesKey(data, "delete")) {
+      this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
+      return;
+    }
+    if (matchesKey(data, "left")) return (this.cursor = Math.max(0, this.cursor - 1));
+    if (matchesKey(data, "right")) return (this.cursor = Math.min(this.value.length, this.cursor + 1));
+    if (matchesKey(data, "home") || data === "\x01") return (this.cursor = 0);
+    if (matchesKey(data, "end") || data === "\x05") return (this.cursor = this.value.length);
+    if (data === "\x15") {
+      this.value = "";
+      this.cursor = 0;
+      return;
+    }
+    this.insert(data);
+  }
+  private insert(text: string) {
+    let clean = "";
+    for (const ch of text) if (ch >= " " && ch !== "\x7f") clean += ch;
+    if (!clean) return;
+    this.value = this.value.slice(0, this.cursor) + clean + this.value.slice(this.cursor);
+    this.cursor += clean.length;
+  }
+  render(width: number): string[] {
+    const bullets = "•".repeat(this.value.length);
+    const at = this.focused ? renderFakeCursor(bullets.slice(this.cursor, this.cursor + 1) || " ") : bullets.slice(this.cursor, this.cursor + 1) || " ";
+    return [truncateToWidth(bullets.slice(0, this.cursor) + at + bullets.slice(this.cursor + 1), width)];
+  }
+  invalidate() {}
+}
+
+/** Like Prompt, but the typed value is only ever shown as bullets. */
+export class SecretPrompt extends Box implements Focusable {
+  readonly input = new SecretInput();
+  private _focused = false;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value: boolean) {
+    this._focused = value;
+    this.input.focused = value;
+  }
+  constructor(label: string, onSubmit: (value: string) => void, onCancel: () => void) {
+    super(1, 0, panelBg);
+    this.addChild(new Title(c.bold(c.accent(label))));
+    this.input.onSubmit = onSubmit;
+    this.input.onEscape = onCancel;
+    this.addChild(this.input);
+    this.addChild(new Title(c.muted("paste or type the token │ enter confirm │ esc cancel")));
+  }
+  handleInput(data: string) {
+    this.input.handleInput(data);
+  }
+}
+
 /** A read-only panel that closes on Esc or Enter (help, tasks). */
 export class Panel extends Box {
   private body = new Container();