my-durable 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,164 @@
+// Transcript items (from the SDK, same as the web client) → pi-tui components, cached by item id.
+// Only items whose content changed are rebuilt; the live assistant reuses its Markdown blocks.
+import {
+  Container,
+  Markdown,
+  truncateToWidth,
+  wrapTextWithAnsi,
+  type Component,
+} from "@earendil-works/pi-tui";
+import type { ToolCallView, TranscriptItem } from "../../dpi-sdk/src/transcript.ts";
+import { c, markdownTheme } from "./theme.ts";
+
+const SPIN = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Advanced by the app while a tool runs; running tool rows read it at render time. */
+export const spinner = { frame: 0 };
+const TAIL = 6;
+
+/** One styled line, cut to the width. */
+export class Line implements Component {
+  constructor(public text: string) {}
+  render(width: number) {
+    return [truncateToWidth(this.text, width)];
+  }
+  invalidate() {}
+}
+
+/** Wrapped text with a first-line prefix and a hanging indent. */
+class Wrapped implements Component {
+  constructor(
+    private text: string,
+    private prefix: string,
+    private style: (s: string) => string,
+    private indent = "  ",
+  ) {}
+  render(width: number) {
+    const inner = Math.max(1, width - 2);
+    const lines = this.text.split("\n").flatMap((l) => (l ? wrapTextWithAnsi(l, inner) : [""]));
+    return lines.map((l, i) => truncateToWidth((i ? this.indent : this.prefix) + this.style(l), width));
+  }
+  invalidate() {}
+}
+
+function argsPreview(call: ToolCallView) {
+  const args = call.args as Record<string, unknown> | undefined;
+  if (args && typeof args === "object") {
+    for (const key of ["command", "path", "file_path", "pattern", "task", "query"])
+      if (typeof args[key] === "string") return (args[key] as string).replace(/\s+/g, " ");
+  }
+  const json = JSON.stringify(call.args ?? {});
+  return json === "{}" ? "" : json;
+}
+
+export class ToolRow implements Component {
+  constructor(
+    private call: ToolCallView,
+    private expand: boolean,
+  ) {}
+  render(width: number) {
+    const s = this.call.status;
+    const icon =
+      s === "running" ? c.warn(SPIN[spinner.frame % SPIN.length]) : s === "done" ? c.ok("✓") : s === "error" ? c.err("✗") : c.muted("○");
+    const head = truncateToWidth(`${icon} ${c.bold(this.call.name)} ${c.muted(argsPreview(this.call))}`, width);
+    const body = (this.call.result ?? this.call.output ?? "").replace(/\s+$/, "");
+    if (!body) return [head];
+    const all = body.split("\n");
+    const shown = this.expand ? all : all.slice(-TAIL);
+    const gutter = c.muted("  │ ");
+    const lines = this.expand
+      ? shown.flatMap((l) => (l ? wrapTextWithAnsi(l, Math.max(1, width - 4)) : [""]))
+      : shown;
+    const out = [head, ...lines.map((l) => truncateToWidth(gutter + (s === "error" ? c.err(l) : l), width))];
+    if (all.length > shown.length)
+      out.splice(1, 0, truncateToWidth(c.muted(`  │ … ${all.length - shown.length} earlier lines (ctrl+o)`), width));
+    return out;
+  }
+  invalidate() {}
+}
+
+class Stack implements Component {
+  constructor(public parts: Component[] = []) {}
+  render(width: number) {
+    return this.parts.flatMap((p) => p.render(width));
+  }
+  invalidate() {
+    for (const p of this.parts) p.invalidate();
+  }
+}
+
+/** Assistant message: Markdown text blocks (reused across deltas), thinking, tool rows, errors. */
+class AssistantView extends Stack {
+  private markdown = new Map<number, Markdown>();
+  update(item: Extract<TranscriptItem, { kind: "assistant" }>, expand: boolean) {
+    const parts: Component[] = [new Line("")];
+    item.blocks.forEach((block, i) => {
+      if (block.type === "text") {
+        let md = this.markdown.get(i);
+        if (!md) {
+          md = new Markdown(block.text, 0, 0, markdownTheme);
+          this.markdown.set(i, md);
+        } else md.setText(block.text);
+        parts.push(md);
+      } else if (block.type === "thinking") {
+        parts.push(
+          expand
+            ? new Wrapped(block.text, c.muted("∴ "), (s) => c.italic(c.muted(s)))
+            : new Line(c.italic(c.muted(`∴ ${block.text.replace(/\s+/g, " ")}`))),
+        );
+      } else parts.push(new ToolRow(block.call, expand));
+    });
+    if (item.streaming && !item.blocks.length) parts.push(new Line(c.muted("…")));
+    if (item.error) parts.push(new Line(c.err(`! ${item.error}`)));
+    this.parts = parts;
+  }
+}
+
+export function itemComponent(item: TranscriptItem, expand: boolean): Component {
+  switch (item.kind) {
+    case "user":
+      return new Stack([new Line(""), new Wrapped(item.text, c.user("› "), c.user)]);
+    case "assistant": {
+      const view = new AssistantView();
+      view.update(item, expand);
+      return view;
+    }
+    case "tool-result":
+      return new ToolRow(
+        { callId: String(item.id), name: item.name, args: undefined, status: item.isError ? "error" : "done", result: item.text },
+        expand,
+      );
+    case "tool":
+      return new ToolRow(item.call, expand);
+    default:
+      return new Line(c.muted(`── ${item.text} `));
+  }
+}
+
+export class TranscriptView extends Container {
+  private cache = new Map<string, { sig: string; component: Component }>();
+  expand = false;
+
+  update(items: readonly TranscriptItem[]) {
+    const next = new Map<string, { sig: string; component: Component }>();
+    this.clear();
+    for (const item of items) {
+      const key = `${item.kind}:${item.id}`;
+      const sig = `${this.expand}|${JSON.stringify(item)}`;
+      let entry = this.cache.get(key);
+      if (!entry || entry.sig !== sig) {
+        if (entry && item.kind === "assistant" && entry.component instanceof AssistantView)
+          entry.component.update(item, this.expand);
+        else entry = { sig, component: itemComponent(item, this.expand) };
+        entry.sig = sig;
+      }
+      next.set(key, entry);
+      this.addChild(entry.component);
+    }
+    this.cache = next;
+  }
+
+  reset() {
+    this.cache.clear();
+    this.clear();
+  }
+}

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

@@ -0,0 +1,57 @@
+// Colors mirror the FE brand tokens exactly (apps/dpi-playground-fe/src/style.css :root):
+// fg #f2eeee, accent #ff8997, secondary/muted #c9a87c, faint #8d7778, ok #6fcf97,
+// warn #f2c94c, err #ff6b6b, line-soft #2a2021, primary #b9283c, primary-line #df5363.
+import type { EditorTheme, MarkdownTheme, SelectListTheme } from "@earendil-works/pi-tui";
+
+const rgb = (hex: string) => {
+  const n = parseInt(hex.slice(1), 16);
+  return `${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}`;
+};
+const fg = (hex: string) => (s: string) => `\x1b[38;2;${rgb(hex)}m${s}\x1b[39m`;
+const wrap = (on: string, off: string) => (s: string) => `\x1b[${on}m${s}\x1b[${off}m`;
+
+export const c = {
+  accent: fg("#ff8997"),
+  muted: fg("#8d7778"),
+  secondary: fg("#c9a87c"),
+  text: fg("#f2eeee"),
+  ok: fg("#6fcf97"),
+  warn: fg("#f2c94c"),
+  err: fg("#ff6b6b"),
+  user: fg("#8ec5ff"),
+  primary: fg("#b9283c"),
+  primaryLine: fg("#df5363"),
+  bold: wrap("1", "22"),
+  dim: wrap("2", "22"),
+  italic: wrap("3", "23"),
+  underline: wrap("4", "24"),
+  strike: wrap("9", "29"),
+  userBg: (s: string) => `\x1b[48;2;42;32;33m${s}\x1b[49m`,
+};
+
+export const markdownTheme: MarkdownTheme = {
+  heading: (s) => c.bold(c.accent(s)),
+  link: c.user,
+  linkUrl: c.muted,
+  code: c.secondary,
+  codeBlock: c.text,
+  codeBlockBorder: c.muted,
+  quote: c.muted,
+  quoteBorder: c.muted,
+  hr: c.muted,
+  listBullet: c.accent,
+  bold: c.bold,
+  italic: c.italic,
+  strikethrough: c.strike,
+  underline: c.underline,
+};
+
+export const selectTheme: SelectListTheme = {
+  selectedPrefix: c.accent,
+  selectedText: (s) => c.bold(c.accent(s)),
+  description: c.muted,
+  scrollInfo: c.muted,
+  noMatch: c.muted,
+};
+
+export const editorTheme: EditorTheme = { borderColor: c.muted, selectList: selectTheme };

package/apps/dpi-tui/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/bin/device.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Run the device daemon TypeScript entry through tsx so `my-durable-device` works without a build step.
+import { register } from "tsx/esm/api";
+register();
+await import("../apps/dpi-backend/src/main.ts");

package/bin/hub.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Run the hub TypeScript entry through tsx so `my-durable-hub` works without a build step.
+import { register } from "tsx/esm/api";
+register();
+await import("../apps/dpi-playground/apps/dpi-playground-hub/src/main.ts");

package/bin/tui.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Run the TUI TypeScript entry through tsx so `my-durable-tui` works without a build step.
+import { register } from "tsx/esm/api";
+register();
+await import("../apps/dpi-tui/src/main.ts");

package/deploy/Caddyfile

@@ -0,0 +1,120 @@
+# Reference Caddy deployment — Durable Agent Network (P2-21, spec 05 §4).
+#
+# Placeholders (Caddy {$ENV} substitution, set by the operator environment):
+#   DPI_PUBLIC_HOST  host:port Caddy listens on (the public origin)
+#   DPI_TLS_CERT     full-chain PEM
+#   DPI_TLS_KEY      private key (0600, managed outside the repo)
+#   DPI_HUB_ADDR     loopback address of the hub process (e.g. 127.0.0.1:4781)
+#   DPI_ADMIN_HASH   bcrypt hash for the single admin user (caddy hash-password;
+#                    the PLAINTEXT never lives in this repo or in env logs)
+#
+# Auth matrix (05):
+#   exempt (exact path/method): GET /healthz · POST /api/pair/start ·
+#   POST /api/pair/verify · GET /api/tunnel (WS) — everything else requires
+#   HTTP Basic auth, and the Authorization header is STRIPPED before the hub
+#   so device tokens and admin credentials can never mix. Client-supplied
+#   XFF/XFP are overwritten from the real connection.
+{
+	admin off
+	auto_https off
+	servers {
+		protocols h1 h2
+	}
+}
+
+https://{$DPI_PUBLIC_HOST} {
+	# TLS 1.2 is the declared floor (05 §4) rather than a Caddy default that a
+	# future build could change. Caddy adds a catch-all policy for handshakes whose
+	# SNI does not match; that one keeps Caddy's own default (also 1.2), and
+	# tests/caddy-tls.test.ts proves both paths refuse TLS 1.0/1.1.
+	tls {$DPI_TLS_CERT} {$DPI_TLS_KEY} {
+		protocols tls1.2 tls1.3
+	}
+
+	header {
+		Strict-Transport-Security "max-age=15552000; includeSubDomains"
+		X-Content-Type-Options "nosniff"
+		Referrer-Policy "no-referrer"
+		-Server
+		-X-Powered-By
+	}
+
+	# CSP is deliberately NOT set here. The hub owns content security per
+	# response: the app shell is served with a restrictive document CSP
+	# (script-src/style-src 'self' + fonts.googleapis.com, connect-src 'self',
+	# frame-ancestors 'none', X-Frame-Options: DENY — hub main.ts) while
+	# proxied device answers are locked down harder still (default-src 'none';
+	# sandbox — hub proxy.ts). This block runs after proxying, so a CSP line
+	# here would overwrite both of those per-route policies with one blanket
+	# value: either it weakens device responses or it breaks the app shell.
+	# Do not "harden" this file by adding one; the harness also runs without
+	# Caddy, so the hub must be correct on its own either way.
+
+	# Admin surface = everything except the four exact exemptions below.
+	@admin {
+		not path /api/tunnel /api/pair/start /api/pair/verify /healthz
+	}
+	@tunnel path /api/tunnel
+	@pairstart {
+		method POST
+		path /api/pair/start
+	}
+	@pairverify {
+		method POST
+		path /api/pair/verify
+	}
+	@healthz {
+		method GET
+		path /healthz
+	}
+
+	# 1. Tunnel WebSocket: exempt from basic auth, Bearer preserved.
+	handle @tunnel {
+		reverse_proxy {$DPI_HUB_ADDR} {
+			header_up X-Forwarded-For {remote_host}
+			header_up X-Forwarded-Proto https
+			flush_interval -1
+		}
+	}
+
+	# 2-4. Exempt pairing entry points — strip any caller Authorization so
+	# credentials never mix (04 §9).
+	handle @pairstart {
+		reverse_proxy {$DPI_HUB_ADDR} {
+			header_up X-Forwarded-For {remote_host}
+			header_up X-Forwarded-Proto https
+			header_up -Authorization
+			flush_interval -1
+		}
+	}
+
+	handle @pairverify {
+		reverse_proxy {$DPI_HUB_ADDR} {
+			header_up X-Forwarded-For {remote_host}
+			header_up X-Forwarded-Proto https
+			header_up -Authorization
+			flush_interval -1
+		}
+	}
+
+	handle @healthz {
+		reverse_proxy {$DPI_HUB_ADDR} {
+			header_up X-Forwarded-For {remote_host}
+			header_up X-Forwarded-Proto https
+			header_up -Authorization
+		}
+	}
+
+	# Everything else: basic auth, then STRIP Authorization before the hub.
+	handle @admin {
+		basic_auth {
+			admin {$DPI_ADMIN_HASH}
+		}
+		reverse_proxy {$DPI_HUB_ADDR} {
+			header_up X-Forwarded-For {remote_host}
+			header_up X-Forwarded-Proto https
+			header_up -Authorization
+			flush_interval -1
+		}
+	}
+}

package/docs/verification.md

@@ -0,0 +1,102 @@
+# Local verification and release gates
+
+Run from the repository root after installing the four apps:
+
+```sh
+just test verify              # full local matrix
+just test verify P2           # core checks without lint/browser/PTY
+node scripts/verify.mjs --phase all
+node --test scripts/verify.test.mjs
+```
+
+Phase names are case-insensitive. A missing value after `--phase`, an unknown
+phase, a failed check or a check that cannot run produces a nonzero exit.
+Every command runs with an explicit working directory.
+
+## What each command covers
+
+All phases run the verification CLI regressions and five build/type/contract
+checks. The CLI tests execute the real runner in an isolated filesystem and
+replace only its external commands.
+
+| Selector | Additional checks |
+|---|---|
+| `P0` | SDK tests (a focused selector, not a G0 decision) |
+| `P1` | SDK and playground tests (not a G1 decision) |
+| `P2` (default) | SDK, backend, playground and TUI tests |
+| `all` | P2 plus the R-1/M4 SIGKILL recovery timing, both lint groups, the network/mobile browser, pairing/offline-credential browser and real PTY pairing/resize tests |
+
+The Web build runs before browser tests. Lint/browser/PTY checks are **NOT_RUN**
+in `P2`, not implicitly passed. `all` requires the installed playground lint
+toolchain, system Chrome (`channel: "chrome"` in Playwright) and `tuistory`.
+Core integration tests also need `tools/caddy`. Test providers are faux and
+servers bind loopback; no paid-model or deployment commands run.
+
+## Recovery timing (R-1/M4)
+
+```sh
+just test timing              # or: cd apps/dpi-backend && npm run test:timing
+DPI_M4_REPORT=/path/m4.json npm run test:timing   # also keep the JSON report
+```
+
+This suite SIGKILLs a real device server mid-run and measures how long it takes
+to be back at verified durable progress. Every sample is asserted **strictly
+under 2 s**, measured from *before* the kill (the interval includes a fixed
+kill-position wait, so it is an upper bound, not a stopwatch on the restart
+alone). The runner prints every sample, including the ones before a failure.
+
+It is a **this-machine** measurement and it is load-sensitive: run it on a
+quiet machine, never in parallel with the rest of the matrix. On the reference
+laptop (i5-6300HQ ×4, Node 22) quiet samples land around 1.0–1.4 s; background
+load pushes individual samples up, so a failure under load is rerun on an idle
+machine before it counts. A green run here is **not** the P2-29 M4 acceptance:
+that target is defined over NAT with the current daemon and is measured
+separately.
+
+## Regression suites for the Gate A remediation
+
+All run inside the phase suites above; each is also runnable on its own with
+`npx tsx --test tests/<file>` from the owning app.
+
+- `apps/dpi-backend`: `connector-backoff`, `connector-hardening`,
+  `connector-limits`, `connector-tls`, `pairing-lifecycle`, `private-dir`,
+  `rest-allowlist`, `token-script`, `timing/m4-resume.timing.ts`.
+- `apps/dpi-playground`: `client-ip`, `http-errors`, `pairing-limits`,
+  `audit`, `guards-audit`, `hub-errors`, `tunnel-gate-a`, `pairing-gate-a`,
+  `device-lifecycle` (R-2 tunnel reconnect, T-2 bounded backoff), the
+  `fe-*` client suites, and the GA-* cases appended to `rotation`,
+  `rotation-ack`, `revoke` and `tls-policy`.
+- `apps/dpi-sdk`: `registry-migration` with the `fixtures/registry-v0`
+  builder, `registry-writers` (writer exclusion), `backoff`, `private-dir`,
+  `sse-limits`.
+- `apps/dpi-tui`: `pairing-ui.mjs` covers the offline-credential scan (S-7)
+  in a real PTY.
+
+The runner prints command/status/count/duration summaries and bounded failure
+output. It does **not** automatically save a report or source manifest.
+Capture output to a new local evidence file and keep the command's exit code;
+do not pipe it through a command that hides failure. Evidence needs the Git HEAD
+and hashes of uncommitted source, not just a commit name.
+
+## What a green local run does not establish
+
+- **P2-29:** real NAT pairing and current-daemon M1–M4 targets are
+  **NOT_MEASURED**. M3 includes human fingerprint approval; M4 starts before
+  SIGKILL and ends at verified durable resumed progress.
+- **D-4 (P3):** the disaster restore/quarantine/re-pair drill is
+  **NOT_MEASURED**. D-4 is not the NAT test.
+- **Gate A / Gate B:** **NOT_EVALUATED**. A green runner is neither an independent
+  security verdict nor owner authorization to expose or deploy anything.
+- Soak/capacity, real-model/provider acceptance and untested platforms remain
+  separate work. Historical records do not become current acceptance results.
+
+## Memory units
+
+The M1 contract is **150 MB = 150,000,000 bytes**, not 150 MiB.
+Convert Linux `VmHWM` KiB to bytes by multiplying by 1024, then compare bytes
+before rounding. Report both decimal MB and binary MiB.
+
+The original P0 samples remain historical inputs. Their `targetMiB: 150` field
+was incorrect contract metadata and must not determine the verdict. The first
+sample is 153,256 KiB = 156,934,144 bytes, so that baseline misses M1 despite
+rounding to 149.7 MiB. This correction is not a fresh P2 performance measurement.

package/dpi-network.example.yaml

@@ -0,0 +1,62 @@
+# dpi-network.example.yaml → copy to dpi-network.yaml (gitignored) and add your own machines.
+#
+#   cp dpi-network.example.yaml dpi-network.yaml
+#
+# Every device runs apps/dpi-backend. Clients (the web hub, dpi-tui, curl) connect with a URL and a
+# bearer token. No code or recipe names a machine: `just net <verb> <id>` looks the id up here and
+# runs the driver for its `kind`.
+#
+#   just net up <id>        provision → deploy → env → service → (expose) → register, idempotent
+#   just net status         probe every device
+#   just net logs <id> | just net restart <id> | just net down <id> | just net deploy <id>
+#   just net destroy <id>   exe-dev only; refuses any VM not named in this file
+#
+# Kinds
+#   local    this machine; `just backend run` runs it in a terminal, or set `service: launchd|systemd`
+#   ssh      any host reachable with `ssh <ssh>`; nvm + rsync + launchd (macOS) or systemd (Linux)
+#   exe-dev  an exe.dev VM: the ssh driver at <vm>.exe.xyz plus VM create and HTTPS proxy exposure
+#   url      connect only (someone else runs the backend); `just net register <id> --token <t>`
+#
+# Tokens never live here. Each device generates its own in <home_dir>/backend.env, and
+# `just net register <id>` copies it into ~/.dpi/network.sqlite on this machine.
+
+# Each device's <home_dir>/backend.env is written from this file and nothing else:
+#   DPI_TOKEN        generated on the first `just net up`, kept after (new one: just net rotate <id>)
+#   DPI_DEVICE_NAME  the device id
+#   DPI_PORT         port
+#   DPI_HOST         host (default 127.0.0.1 for kind local, 0.0.0.0 otherwise)
+#   DPI_START_DIRS   start_dirs, colon-separated
+#   <NAME>=<value>   for each name in env_keys, with its value read from this checkout's .env
+#   <NAME>=<value>   for each entry in env (defaults.env merged with the device's env)
+
+defaults:
+  port: 4780                       # dpi-backend port on every device
+  node: 24                         # Node major installed with nvm on ssh / exe-dev devices
+  code_dir: ~/dpi                  # where apps/dpi-backend + apps/dpi-sdk are synced (ssh / exe-dev)
+  home_dir: ~/.dpi                 # backend.env, data and logs; deploys never touch it
+  start_dirs: ["~/dpi-work"]       # where new sessions start (created if missing); any existing folder works as a cwd
+  env_keys: [OPENROUTER_API_KEY]   # secrets: copied by name from .env, never written here
+  # env:                           # plain settings, written as-is
+  #   DPI_PROVIDER: faux           # the free deterministic model, for tests
+
+devices:
+  local:
+    name: Laptop
+    kind: local
+
+  # A Mac or Linux box you can reach with passwordless ssh.
+  # mac-mini:
+  #   name: Mac mini
+  #   kind: ssh
+  #   ssh: me@my-mac-mini.local
+  #   service: launchd               # systemd on Linux (needs passwordless sudo)
+  #   url: http://my-mac-mini.local:4780
+  #   start_dirs: ["~/dpi-work"]
+
+  # An exe.dev VM (https://exe.dev). `just net up` creates it if missing and exposes it over HTTPS.
+  # vm-1:
+  #   name: exe.dev VM
+  #   kind: exe-dev
+  #   vm: my-dpi-vm-1                # VM name, also the public host: https://my-dpi-vm-1.exe.xyz
+  #   create: { cpu: 2, memory: 4GB, disk: 20GB }
+  #   start_dirs: ["~/work"]