my-durable 0.0.6 → 0.0.8

package/apps/dpi-playground/apps/dpi-playground-fe/dist/index.html

@@ -7,8 +7,8 @@
     <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-Dq0CZYr7.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index--aoZ5Tj0.css">
+    <script type="module" crossorigin src="/assets/index-CoYMgU-2.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Cg3vey95.css">
   </head>
   <body>
     <div id="app"></div>

package/apps/dpi-playground/apps/dpi-playground-fe/src/client/pair-handoff.ts

@@ -1,15 +1,28 @@
 /** Pair links stay in RAM and may only refer to the browser's own hub. */
-import { decodePairOffer, normalizePairCode, parsePairOfferUrl } from "../../../../../dpi-sdk/src/protocol/pairing";
+import {
+  decodePairOffer,
+  normalizePairCode,
+  parsePairOfferUrl,
+} from "../../../../../dpi-sdk/src/protocol/pairing";
 
-export type PairHandoff = { code: string; origin: string } | { error: string };
+export type PairHandoff =
+  | { code: string; origin: string; offerFragment?: string }
+  | { error: string };
 
 export function readPairHandoff(url: URL): PairHandoff | undefined {
   if (!/^\/pair\/?$/.test(url.pathname)) return undefined;
-  // v2 FIRST: the whole handoff rides the #offer= fragment, decoded client-side —
+  // v2/v3 FIRST: the whole handoff rides the #offer= fragment, decoded client-side —
   // the code never travels in a query, so it never reaches any server or CDN log.
   if (url.hash.startsWith("#offer=")) {
     const parsed = parsePairOfferUrl(url.href);
-    if (parsed) return { code: parsed.offer.code, origin: url.origin };
+    if (parsed)
+      return {
+        code: parsed.offer.code,
+        origin: url.origin,
+        // The RAW fragment, RAM-only: /pair's device-handoff card relays it to
+        // the device machine's own pairing page (127.0.0.1) without any fetch.
+        offerFragment: url.hash.slice(1),
+      };
     const offer = decodePairOffer(url.hash.slice("#offer=".length));
     if (offer && offer.hub !== url.origin)
       return {

package/apps/dpi-playground/apps/dpi-playground-fe/src/client/pair.ts

@@ -55,9 +55,38 @@ async function call<T>(
 /** The only auth failure the browser treats as "authenticate again". */
 export const needsAuth = (e: unknown): boolean => e instanceof DpiError && e.status === 401;
 
+/**
+ * The wizard QR payload (gap #3): the v2 offer link when the hub minted one —
+ * the whole handoff rides the #offer= fragment, which no server, CDN or proxy
+ * ever logs — and only a legacy hub's v1 pairUrl as the fallback. This is the
+ * exact string "Copy link" writes to the clipboard, so the QR and the copied
+ * link are always the same handoff.
+ */
+export function qrPayload(issue: PairCodeIssue): string {
+  return issue.offerUrl ?? issue.pairUrl;
+}
+
 export type RevokeReason = "user" | "compromise";
 
+/** One device-initiated request as the hub lists it (identity only — no secrets). */
+export interface PendingPairing {
+  codeId: string;
+  expiresAt: number;
+  phase: "awaiting_device" | "awaiting_proof" | "approved_ready" | "cancelled";
+  enrollmentId?: string;
+  deviceUid?: string;
+  deviceName?: string;
+  hostname?: string;
+  platform?: string;
+  keyFingerprint?: string;
+  proofVerified?: boolean;
+  startedAt?: number;
+}
+
 export const pairingAdmin = {
+  /** Machines that asked for a code themselves — the identity the operator approves. */
+  pending: (signal?: AbortSignal) =>
+    call<{ codes: PendingPairing[] }>("GET", "/pair/codes", undefined, signal),
   pairings: (signal?: AbortSignal) => call<PublicPairing[]>("GET", "/pairings", undefined, signal),
   /** Operator opens the wizard: mint a code (admin-gated upstream by Caddy). */
   createCode: (signal?: AbortSignal) => call<PairCodeIssue>("POST", "/pair/code", {}, signal),

package/apps/dpi-playground/apps/dpi-playground-fe/src/client/qrcode.ts

@@ -1,8 +1,12 @@
 /**
  * Minimal local QR encoder for the PairDeviceWizard (P2-24: "QR render local;
- * no remote QR service"). Byte mode, EC level L, versions 1–5 (pair URLs are
- * ≤ ~106 bytes). Pure function: text → boolean[size][size] module matrix.
- * Cross-validated against the reference `python-qrcode` implementation.
+ * no remote QR service"). Byte mode, EC level L, versions 1–12 — v1–5 covers
+ * legacy pair URLs (≤ ~106 bytes); v6–12 covers the v2 offer links whose whole
+ * handoff rides the #offer= fragment (~229 bytes today → v9; ~310 once the hub
+ * identity fingerprint rides the offer → v11; headroom to v12-L = 367 bytes).
+ * Pure function: text → boolean[size][size] module matrix.
+ * Cross-validated against the reference `python-qrcode` implementation
+ * (every module, every mask, every supported version).
  */
 
 // -- GF(256), poly 0x11D ------------------------------------------------------
@@ -48,20 +52,63 @@ function rsEncode(data: number[], ecLen: number): number[] {
   return rem;
 }
 
-// -- version tables (EC level L, single data block for v1–5) -------------------
+// -- version tables (EC level L, v1–12; transcribed from python-qrcode's
+//    RS_BLOCK_TABLE / PATTERN_POSITION_TABLE so encoder and cross-validation
+//    reference can never drift apart) ----------------------------------------
 
-const SIZES = [21, 25, 29, 33, 37];
-const DATA_CODEWORDS = [19, 34, 55, 80, 108];
-const EC_PER_BLOCK = [7, 10, 15, 20, 26];
-const ALIGN = [[], [6, 18], [6, 22], [6, 26], [6, 30]]; // alignment centers
-const REMAINDER_BITS = [0, 7, 7, 7, 7];
+const SIZES = [21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65];
+/** Total DATA codewords per version (all blocks summed). */
+const DATA_CODEWORDS = [19, 34, 55, 80, 108, 136, 156, 194, 232, 274, 324, 370];
+/** Total EC codewords per version (all blocks summed). */
+const EC_CODEWORDS = [7, 10, 15, 20, 26, 36, 40, 48, 60, 72, 80, 96];
+/** EC codewords per single block (equal within a version). */
+const EC_PER_BLOCK = [7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24];
+/** Block groups per version: [count, dataCodewordsPerBlock], shorter first. */
+const BLOCKS: ReadonlyArray<ReadonlyArray<readonly [number, number]>> = [
+  [[1, 19]],
+  [[1, 34]],
+  [[1, 55]],
+  [[1, 80]],
+  [[1, 108]],
+  [[2, 68]],
+  [[2, 78]],
+  [[2, 97]],
+  [[2, 116]],
+  [
+    [2, 68],
+    [2, 69],
+  ],
+  [[4, 81]],
+  [
+    [2, 92],
+    [2, 93],
+  ],
+];
+const ALIGN = [
+  [],
+  [6, 18],
+  [6, 22],
+  [6, 26],
+  [6, 30],
+  [6, 34],
+  [6, 22, 38],
+  [6, 24, 42],
+  [6, 26, 46],
+  [6, 28, 50],
+  [6, 30, 54],
+  [6, 32, 58],
+]; // alignment centers
+
+/** Byte-mode character-count indicator width: 8 bits for v1–9, 16 for v10+. */
+const countBits = (version: number): number => (version <= 9 ? 8 : 16);
 
 function selectVersion(byteLen: number): number {
-  for (let v = 1; v <= 5; v++) {
-    // byte mode: 4-bit indicator + 8-bit count (v1–9) + payload
-    if (byteLen + 2 <= DATA_CODEWORDS[v - 1]) return v;
+  for (let v = 1; v <= SIZES.length; v++) {
+    // byte mode: 4-bit indicator + count (8/16 bits) + payload; the terminator
+    // may be truncated to zero bits, so it never forces a larger version.
+    if (4 + countBits(v) + byteLen * 8 <= DATA_CODEWORDS[v - 1] * 8) return v;
   }
-  throw new Error(`qr: payload too long (${byteLen} bytes; v5L max ${DATA_CODEWORDS[4] - 2})`);
+  throw new Error(`qr: payload too long (${byteLen} bytes; v12L max ${DATA_CODEWORDS[11] - 3})`);
 }
 
 // -- bit stream ---------------------------------------------------------------
@@ -73,7 +120,7 @@ function buildCodewords(text: string, version: number): number[] {
     for (let i = len - 1; i >= 0; i--) bits.push((value >> i) & 1);
   };
   push(0b0100, 4); // byte mode
-  push(bytes.length, 8);
+  push(bytes.length, countBits(version));
   for (const b of bytes) push(b, 8);
   const dataCodewords = DATA_CODEWORDS[version - 1];
   const capacityBits = dataCodewords * 8;
@@ -91,6 +138,26 @@ function buildCodewords(text: string, version: number): number[] {
   return out;
 }
 
+/**
+ * Split the data codewords into the version's blocks, add per-block RS error
+ * correction, and interleave both block-wise (the spec's placement order for
+ * multi-block versions; for v1–5 this degenerates to the old single stream).
+ */
+function interleave(version: number, data: number[]): number[] {
+  const ecLen = EC_PER_BLOCK[version - 1];
+  const blocks: number[][] = [];
+  let offset = 0;
+  for (const [count, dataLen] of BLOCKS[version - 1])
+    for (let b = 0; b < count; b++) blocks.push(data.slice(offset, (offset += dataLen)));
+  const out: number[] = [];
+  const maxData = Math.max(...blocks.map((b) => b.length));
+  for (let i = 0; i < maxData; i++)
+    for (const block of blocks) if (i < block.length) out.push(block[i]);
+  const ecs = blocks.map((block) => rsEncode(block, ecLen));
+  for (let i = 0; i < ecLen; i++) for (const ec of ecs) out.push(ec[i]);
+  return out;
+}
+
 // -- matrix scaffolding ---------------------------------------------------------
 
 function makeMatrix(size: number): boolean[][] {
@@ -130,6 +197,21 @@ function placeFunctionPatterns(m: boolean[][], version: number): void {
     }
   // dark module
   m[size - 8][8] = true;
+  // version information (v≥7 only): 6-bit version + 12 BCH bits (G18 = 0x1f25), two copies
+  if (version >= 7) {
+    // long division of version·x¹² by G18, MSB first (same algorithm as the
+    // reference implementation's BCH_type_number)
+    let d = version << 12;
+    for (let bit = 17; bit >= 12; bit--) if ((d >> bit) & 1) d ^= 0x1f25 << (bit - 12);
+    const bits = (version << 12) | (d & 0xfff);
+    for (let i = 0; i < 18; i++) {
+      const bit = ((bits >> i) & 1) === 1;
+      const a = size - 11 + (i % 3);
+      const b = (i / 3) | 0;
+      m[a][b] = bit; // bottom-left strip: rows size-11..size-9, cols 0..5
+      m[b][a] = bit; // top-right strip: rows 0..5, cols size-11..size-9
+    }
+  }
 }
 
 // format info: EC level L (01) + mask, BCH(15,5), XOR 0x5412
@@ -177,7 +259,7 @@ function placeData(m: boolean[][], codewords: number[], version: number, mask: n
       const row = upward ? size - 1 - step : step;
       for (const c of [col, col - 1]) {
         if (isFunctionModule(row, c, version)) continue;
-        if (bitIndex >= (DATA_CODEWORDS[version - 1] + EC_PER_BLOCK[version - 1]) * 8) {
+        if (bitIndex >= (DATA_CODEWORDS[version - 1] + EC_CODEWORDS[version - 1]) * 8) {
           // past data+ec bits → remainder modules (decoders ignore them)
           bitIndex++;
           continue;
@@ -220,6 +302,14 @@ function isFunctionModule(row: number, col: number, version: number): boolean {
   if (row >= size - 8 && col <= 8) return true;
   // timing
   if (row === 6 || col === 6) return true;
+  // version information (v≥7): the two 3×6 strips beside the top-right and
+  // bottom-left finders
+  if (
+    version >= 7 &&
+    ((row >= size - 11 && row <= size - 9 && col <= 5) ||
+      (col >= size - 11 && col <= size - 9 && row <= 5))
+  )
+    return true;
   // alignment
   const centers = ALIGN[version - 1];
   for (const r of centers)
@@ -286,8 +376,7 @@ function matrixWithMask(text: string, mask: number): boolean[][] {
   const version = selectVersion(new TextEncoder().encode(text).length);
   const size = SIZES[version - 1];
   const data = buildCodewords(text, version);
-  const ec = rsEncode(data, EC_PER_BLOCK[version - 1]);
-  const all = [...data, ...ec];
+  const all = interleave(version, data);
   const m = makeMatrix(size);
   placeFunctionPatterns(m, version);
   placeData(m, all, version, mask);
@@ -295,7 +384,7 @@ function matrixWithMask(text: string, mask: number): boolean[][] {
   return m;
 }
 
-/** Encode text into a QR matrix (true = dark module), EC level L, versions 1–5. */
+/** Encode text into a QR matrix (true = dark module), EC level L, versions 1–12. */
 export function qrMatrix(text: string, maskOverride?: number): boolean[][] {
   if (maskOverride !== undefined) return matrixWithMask(text, maskOverride);
   let best: { m: boolean[][]; score: number } | undefined;

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

@@ -162,7 +162,7 @@ watch(
               <span class="crumb-kind">device</span>
               <span class="crumb-main"
                 ><DeviceIcon :device="device" :size="18" /><span class="device-chip">{{
-                  device?.id
+                  device?.name ?? device?.id
                 }}</span></span
               >
             </button>

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

@@ -0,0 +1,132 @@
+<script setup lang="ts">
+/**
+ * The no-admin "Pair THIS device" card (gap #4): when /pair carries an
+ * #offer= fragment, the machine whose BROWSER opened it can relay the offer —
+ * unchanged, fragment-only — to its own dpi backend's pairing page. No login,
+ * no hub API: the hub wizard stays the operator side (mint + approve).
+ */
+import { computed, ref } from "vue";
+import { MonitorSmartphone, Copy, ExternalLink } from "lucide-vue-next";
+
+const props = defineProps<{ offerFragment: string }>();
+const port = ref("4780");
+const copied = ref(false);
+
+const deviceUrl = computed(() => {
+  const p = /^\d{1,5}$/.test(port.value) ? Number(port.value) : 0;
+  if (!p || p < 1 || p > 65535) return undefined;
+  return `http://127.0.0.1:${p}/pair#${props.offerFragment}`;
+});
+
+function open() {
+  const url = deviceUrl.value;
+  if (url) window.open(url, "_blank", "noopener");
+}
+
+async function copy() {
+  const url = deviceUrl.value;
+  if (!url) return;
+  try {
+    await navigator.clipboard.writeText(url);
+    copied.value = true;
+    setTimeout(() => (copied.value = false), 1600);
+  } catch {
+    /* clipboard denied: the open button still works */
+  }
+}
+</script>
+
+<template>
+  <section class="device-handoff" aria-label="Pair this machine">
+    <header>
+      <MonitorSmartphone :size="18" />
+      <h3>Pair THIS machine</h3>
+    </header>
+    <p class="what">
+      If this browser runs on the device itself, open its local pairing page — the offer is relayed
+      inside the link, nothing is sent to the hub. Start <code>dpi device</code> there first.
+    </p>
+    <div class="row">
+      <label>
+        local port
+        <input
+          v-model="port"
+          inputmode="numeric"
+          spellcheck="false"
+          aria-label="Local dpi backend port"
+        />
+      </label>
+      <button class="primary" type="button" :disabled="!deviceUrl" @click="open">
+        <ExternalLink :size="15" />Open the device page
+      </button>
+      <button class="secondary" type="button" :disabled="!deviceUrl" @click="copy">
+        <Copy :size="15" />{{ copied ? "Copied" : "Copy link" }}
+      </button>
+    </div>
+    <p class="target" v-if="deviceUrl" data-testid="device-url">{{ deviceUrl }}</p>
+    <p class="err" v-if="!deviceUrl">port must be 1–65535</p>
+  </section>
+</template>
+
+<style scoped>
+.device-handoff {
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 14px 16px;
+  margin-bottom: 14px;
+  background: var(--panel);
+}
+header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-weight: 650;
+  margin-bottom: 6px;
+}
+h3 {
+  margin: 0;
+  font-size: 14.5px;
+}
+.what {
+  margin: 0 0 10px;
+  font-size: 13px;
+  color: var(--muted);
+}
+code {
+  font-family: ui-monospace, monospace;
+  font-size: 12px;
+}
+.row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: end;
+}
+label {
+  display: grid;
+  gap: 4px;
+  font-size: 12px;
+  color: var(--muted);
+}
+input {
+  width: 90px;
+  padding: 7px 9px;
+  border-radius: 8px;
+  border: 1px solid var(--border);
+  background: var(--panel);
+  color: inherit;
+  font: inherit;
+}
+.err {
+  color: var(--danger, #f28b82);
+  font-size: 12.5px;
+  margin: 8px 0 0;
+}
+.target {
+  margin: 10px 0 0;
+  font-family: ui-monospace, monospace;
+  font-size: 12px;
+  color: var(--muted);
+  word-break: break-all;
+}
+</style>

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

@@ -239,7 +239,7 @@ const offeredTools = computed(() => detail.value?.tools.filter((t) => t.offered)
               <span class="status-pill" :class="{ working: busy }"
                 ><i />{{ busy ? "Working" : "Idle" }}</span
               ><span v-if="background" class="background-pill">{{ background }} background</span
-              ><span class="saved"><Server :size="18" />{{ device?.id }}</span>
+              ><span class="saved" :title="device?.id"><Server :size="18" />{{ device?.name ?? device?.id }}</span>
               <TunnelStatusBar v-if="device" :device="device" />
             </div>
           </section>
@@ -318,7 +318,7 @@ const offeredTools = computed(() => detail.value?.tools.filter((t) => t.offered)
             <Braces :size="18" />
           </div>
           <p class="hint app-state-description">
-            One shared JSON object for every agent, session and fork on {{ device?.id }}. You and
+            One shared JSON object for every agent, session and fork on {{ device?.name ?? device?.id }}. You and
             your agents can read, create, update or delete values and fields. Changes appear live
             and persist across closed browsers, interrupted agents and backend restarts.
           </p>

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

@@ -13,7 +13,31 @@ const deviceId = ref(
   devices.value.find((d) => d.id === props.deviceId)?.id ?? devices.value[0]?.id ?? "",
 );
 const device = computed(() => devices.value.find((d) => d.id === deviceId.value));
-const models = computed(() => device.value?.info?.models ?? []);
+const models = computed(() => {
+  const list = device.value?.info?.models ?? [];
+  if (list.length) return list;
+  // No usable catalog (device has no provider key): still offer the device's
+  // default so a session can be created — chatting needs the key, creating
+  // must not. Caught live: the dropdown went empty and create always failed.
+  const info = device.value?.info;
+  if (info?.defaultModel && info.provider)
+    return [
+      {
+        id: info.defaultModel,
+        provider: info.provider,
+        name: `${info.defaultModel} (device default)`,
+        tier: "—",
+        icon: "lab.png",
+        contextWindow: 0,
+        reasoning: false,
+        cost: { input: 0, output: 0 },
+      },
+    ];
+  return [];
+});
+const catalogEmpty = computed(
+  () => !models.value.length || (device.value?.info?.models?.length ?? 0) === 0,
+);
 const key = (m: { provider: string; id: string }) => `${m.provider}/${m.id}`;
 const draft = ref({ name: "", cwd: "", model: "" });
 const pending = ref(false);
@@ -22,8 +46,9 @@ const error = ref("");
 watch(
   device,
   (d) => {
+    const list = models.value;
     const fallback =
-      d?.info?.models.find((m) => m.id === d.info?.defaultModel) ?? d?.info?.models[0];
+      list.find((m) => m.id === d?.info?.defaultModel) ?? list[0];
     draft.value.model = fallback ? key(fallback) : "";
     draft.value.cwd = "";
   },
@@ -35,7 +60,7 @@ async function create() {
   pending.value = true;
   error.value = "";
   try {
-    const model = models.value.find((m) => key(m) === draft.value.model);
+    const model = models.value.find((m) => key(m) === draft.value.model) ?? models.value[0];
     if (!model) throw Error("Choose a model");
     const created = await deviceClient(device.value.id).createSession({
       name: draft.value.name.trim() || "New session",
@@ -79,7 +104,7 @@ async function create() {
         <label
           >Device<select v-model="deviceId" aria-label="Device">
             <option v-for="d in devices" :key="d.id" :value="d.id">
-              {{ d.id }} · {{ d.info?.hostname ?? d.url }}
+              {{ d.name }}{{ d.info?.hostname && d.info.hostname !== d.name ? ` · ${d.info.hostname}` : "" }}
             </option>
           </select></label
         >
@@ -91,11 +116,16 @@ async function create() {
             maxlength="100"
         /></label>
         <div class="field">
-          <span>Working directory on {{ deviceId }}</span>
+          <span>Working directory on {{ devices.find((d) => d.id === deviceId)?.name ?? deviceId }}</span>
           <DirBrowser v-model="draft.cwd" :device-id="deviceId" />
         </div>
         <label
-          >Model<select v-model="draft.model" aria-label="New session model">
+          >Model<span
+            v-if="catalogEmpty"
+            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
+          ><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 }}
             </option>