@longleash/cli 0.1.0-rc.11 → 0.1.0-rc.12

package/runtime/daemon/bin/longleashd.mjs

@@ -12,8 +12,8 @@ import { dirname as dirname4, join as join10, resolve as resolve6 } from "node:p
 import { fileURLToPath } from "node:url";
 
 // ../daemon/src/daemon.ts
-import { accessSync, constants, mkdirSync as mkdirSync3, existsSync as existsSync6, writeFileSync as writeFileSync2 } from "node:fs";
-import { randomBytes as randomBytes6 } from "node:crypto";
+import { accessSync, constants, mkdirSync as mkdirSync3, existsSync as existsSync6, writeFileSync as writeFileSync2, renameSync, rmSync } from "node:fs";
+import { randomBytes as randomBytes7 } from "node:crypto";
 
 // ../daemon/src/delegation-handoff.ts
 async function pauseCurrentSessionOwner(managed, external, session, actor, reason) {
@@ -5425,6 +5425,79 @@ var IdeOpenSessionResultSchema = external_exports.object({
   }
 });
 
+// ../protocol/src/pairing.ts
+var VERIFIED_PAIRING_VERSION = 2;
+var PairingNonce = external_exports.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var PairingDeviceName = external_exports.string().min(1).max(64).refine(
+  (name) => name.trim().length > 0 && !/[\p{Cc}\p{Cf}]/u.test(name),
+  "Device name must be visible text without control characters"
+);
+var PairingTranscript = external_exports.object({
+  v: external_exports.literal(VERIFIED_PAIRING_VERSION),
+  challengeId: external_exports.string().min(1).max(128),
+  attemptId: PairingNonce,
+  phoneNonce: PairingNonce,
+  daemonNonce: PairingNonce,
+  deviceName: PairingDeviceName,
+  expiresAt: external_exports.number().int().positive().safe()
+}).strict();
+var utf8 = (value) => new TextEncoder().encode(value);
+var hex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+function deriveVerifiedPairing(secret, raw) {
+  PairingNonce.parse(secret);
+  const t = PairingTranscript.parse(raw);
+  const transcript = JSON.stringify([
+    "longleash-pairing-v2",
+    t.v,
+    t.challengeId,
+    t.attemptId,
+    ["phone", t.phoneNonce, t.deviceName],
+    ["daemon", t.daemonNonce],
+    t.expiresAt
+  ]);
+  const salt = sha256(utf8(transcript));
+  const derive = (purpose) => hkdf(sha256, utf8(secret), salt, utf8(`longleash-pairing-v2/${purpose}`), 32);
+  const digits = (BigInt(`0x${hex(derive("display-code"))}`) % 100000000n).toString().padStart(8, "0");
+  return {
+    code: `${digits.slice(0, 4)} ${digits.slice(4)}`,
+    identity: { roomTag: hex(derive("room-tag")), frameKey: derive("frame-key") }
+  };
+}
+var PairingBegin = external_exports.object({
+  v: external_exports.literal(2),
+  type: external_exports.literal("pair-begin"),
+  challengeId: external_exports.string().min(1).max(128),
+  phoneNonce: PairingNonce,
+  deviceName: PairingDeviceName
+}).strict();
+var PairingDecision = external_exports.object({
+  v: external_exports.literal(2),
+  type: external_exports.enum(["pair-confirm", "pair-reject", "pair-ping"]),
+  attemptId: PairingNonce
+}).strict();
+var PairingReply = external_exports.discriminatedUnion("type", [
+  external_exports.object({ v: external_exports.literal(2), type: external_exports.literal("pair-transcript"), transcript: PairingTranscript, remainingMs: external_exports.number().int().min(1).max(3e5) }).strict(),
+  external_exports.object({ v: external_exports.literal(2), type: external_exports.literal("pair-waiting"), attemptId: PairingNonce }).strict(),
+  external_exports.object({
+    v: external_exports.literal(2),
+    type: external_exports.literal("paired"),
+    attemptId: PairingNonce,
+    token: external_exports.string().regex(/^llt_[A-Za-z0-9_-]{43}$/),
+    relaySecret: PairingNonce,
+    deviceId: external_exports.string().min(1).max(128)
+  }).strict(),
+  external_exports.object({ v: external_exports.literal(2), type: external_exports.literal("pair-error"), reason: external_exports.enum([
+    "update-required",
+    "invalid-input",
+    "expired",
+    "competing-attempt",
+    "cancelled",
+    "disconnected",
+    "unavailable"
+  ]) }).strict()
+]);
+var PAIRING_FRAME_LIMIT = 8192;
+
 // ../protocol/src/index.ts
 var PROTOCOL_VERSION = 1;
 var AgentKind = external_exports.enum(["claude", "gemini", "codex", "terminal"]);
@@ -6041,6 +6114,13 @@ var completePairingInput = external_exports.object({
   deviceName: external_exports.string().min(1).max(64),
   publicKey: external_exports.string().min(1).optional()
 });
+var beginVerifiedInput = external_exports.object({
+  v: external_exports.literal(2),
+  challengeId: external_exports.string().min(1).max(128),
+  secret: PairingNonce,
+  deviceName: PairingDeviceName,
+  phoneNonce: PairingNonce
+}).strict();
 var id = (prefix) => `${prefix}_${randomBytes(12).toString("base64url")}`;
 var sha256Hex = (value) => createHash("sha256").update(value).digest("hex");
 var hashesMatch = (a, b) => timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
@@ -6050,6 +6130,7 @@ var DeviceRegistry = class {
   challengeTtlMs;
   // Ephemeral by design: a daemon restart voids pending pairing QR codes.
   challenges = /* @__PURE__ */ new Map();
+  pairingResults = /* @__PURE__ */ new Map();
   revokedListeners = /* @__PURE__ */ new Set();
   pairedListeners = /* @__PURE__ */ new Set();
   constructor(path, opts = {}) {
@@ -6072,17 +6153,22 @@ var DeviceRegistry = class {
     this.now = opts.now ?? Date.now;
     this.challengeTtlMs = opts.challengeTtlMs ?? DEFAULT_CHALLENGE_TTL_MS;
   }
-  createPairingChallenge() {
+  createPairingChallenge(opts = {}) {
     this.sweepExpiredChallenges();
+    const version = opts.version ?? PAIRING_QR_VERSION;
+    if (version !== 1 && version !== 2) throw new PairingError("invalid-input", "Unsupported pairing version");
+    if (version === 2 && [...this.challenges.values()].filter((c) => c.version === 2).length >= 8) {
+      throw new PairingError("pending-limit", "Too many pending verifications \u2014 finish or wait for expiry");
+    }
     const challengeId = id("chl");
     const secret = randomBytes(32).toString("base64url");
     const expiresAt = this.now() + this.challengeTtlMs;
-    this.challenges.set(challengeId, { secretHash: sha256Hex(secret), expiresAt });
+    this.challenges.set(challengeId, { secretHash: sha256Hex(secret), expiresAt, version });
     return {
       challengeId,
       secret,
       expiresAt,
-      qrPayload: JSON.stringify({ v: PAIRING_QR_VERSION, challengeId, secret })
+      qrPayload: JSON.stringify({ v: version, challengeId, secret })
     };
   }
   completePairing(raw) {
@@ -6091,24 +6177,114 @@ var DeviceRegistry = class {
       throw new PairingError("invalid-input", parsed.error.message);
     }
     const input = parsed.data;
-    const challenge = this.challenges.get(input.challengeId);
-    if (!challenge) {
-      throw new PairingError("unknown-challenge", "Unknown or already-used pairing challenge");
+    const challenge = this.authorizeChallenge(input.challengeId, input.secret);
+    if (challenge.version !== 1) {
+      throw new PairingError("verification-required", "This QR requires verification on the phone and laptop");
     }
-    if (this.now() > challenge.expiresAt) {
+    this.challenges.delete(input.challengeId);
+    return this.commitDevice(input.deviceName, input.publicKey);
+  }
+  /** Foundation only: transport adapters must authenticate/decrypt BEFORE calling this. */
+  beginVerifiedPairing(raw, owner) {
+    const parsed = beginVerifiedInput.safeParse(raw);
+    if (!parsed.success) throw new PairingError("invalid-input", "Invalid v2 pairing request");
+    const input = parsed.data;
+    const challenge = this.authorizeChallenge(input.challengeId, input.secret);
+    if (challenge.version !== 2) {
+      throw new PairingError("update-required", "Update LongLeash and generate a new verified QR code");
+    }
+    if (challenge.pending) {
+      const previous = challenge.pending.transcript;
+      if (challenge.pending.owner === owner && previous.phoneNonce === input.phoneNonce && previous.deviceName === input.deviceName) {
+        return { ...previous };
+      }
       this.challenges.delete(input.challengeId);
+      throw new PairingError("competing-attempt", "A competing pairing attempt was detected \u2014 generate a new QR code");
+    }
+    const transcript = {
+      v: 2,
+      challengeId: input.challengeId,
+      attemptId: randomBytes(32).toString("base64url"),
+      phoneNonce: input.phoneNonce,
+      daemonNonce: randomBytes(32).toString("base64url"),
+      deviceName: input.deviceName,
+      expiresAt: challenge.expiresAt
+    };
+    const { code } = deriveVerifiedPairing(input.secret, transcript);
+    challenge.pending = { transcript, code, localConfirmed: false, ...owner ? { owner } : {} };
+    return { ...transcript };
+  }
+  getPairingResult(challengeId) {
+    this.sweepExpiredChallenges();
+    const result = this.pairingResults.get(challengeId);
+    return result ? { deviceId: result.deviceId } : null;
+  }
+  hasPairingChallenge(challengeId) {
+    this.sweepExpiredChallenges();
+    return this.challenges.has(challengeId);
+  }
+  /** Local operator cancellation also works before a phone has connected. */
+  cancelPairingChallenge(challengeId) {
+    this.challenges.delete(challengeId);
+  }
+  /** LOCAL ONLY. Never expose the laptop display code through a phone-facing route. */
+  getPairingVerification(challengeId) {
+    this.sweepExpiredChallenges();
+    const pending = this.challenges.get(challengeId)?.pending;
+    if (!pending) return null;
+    const { attemptId, deviceName, expiresAt } = pending.transcript;
+    return { attemptId, code: pending.code, deviceName, expiresAt };
+  }
+  /** LOCAL ONLY: a secret-authenticated loopback/CLI action, never a remote message. */
+  confirmPairingLocally(challengeId, attemptId) {
+    this.requireAttempt(challengeId, attemptId).localConfirmed = true;
+  }
+  /** Call only for an explicit phone 'Codes match' on this attempt's encrypted channel. */
+  finishVerifiedPairing(challengeId, attemptId) {
+    const pending = this.requireAttempt(challengeId, attemptId);
+    if (!pending.localConfirmed) {
+      throw new PairingError("local-confirmation-required", "Compare and confirm the code on your laptop first");
+    }
+    this.challenges.delete(challengeId);
+    const result = this.commitDevice(pending.transcript.deviceName);
+    this.pairingResults.set(challengeId, { deviceId: result.device.deviceId, expiresAt: this.now() + 6e4 });
+    return result;
+  }
+  /** Rejection and transport disconnect share the same terminal transition. */
+  cancelVerifiedPairing(challengeId, attemptId) {
+    this.requireAttempt(challengeId, attemptId);
+    this.challenges.delete(challengeId);
+  }
+  requireAttempt(challengeId, attemptId) {
+    const challenge = this.requireChallenge(challengeId);
+    if (!challenge.pending || challenge.pending.transcript.attemptId !== attemptId) {
+      throw new PairingError("unknown-attempt", "Unknown pairing attempt");
+    }
+    return challenge.pending;
+  }
+  requireChallenge(challengeId) {
+    const challenge = this.challenges.get(challengeId);
+    if (!challenge) throw new PairingError("unknown-challenge", "Unknown or already-used pairing challenge");
+    if (this.now() >= challenge.expiresAt) {
+      this.challenges.delete(challengeId);
       throw new PairingError("expired", "Pairing challenge expired \u2014 generate a new QR code");
     }
-    if (!hashesMatch(sha256Hex(input.secret), challenge.secretHash)) {
+    return challenge;
+  }
+  authorizeChallenge(challengeId, secret) {
+    const challenge = this.requireChallenge(challengeId);
+    if (!hashesMatch(sha256Hex(secret), challenge.secretHash)) {
       throw new PairingError("bad-secret", "Wrong pairing secret");
     }
-    this.challenges.delete(input.challengeId);
+    return challenge;
+  }
+  commitDevice(deviceName, publicKey) {
     const token = `llt_${randomBytes(32).toString("base64url")}`;
     const relaySecret = randomBytes(32).toString("base64url");
     const device = {
       deviceId: id("dev"),
-      name: input.deviceName,
-      publicKey: input.publicKey ?? null,
+      name: deviceName,
+      publicKey: publicKey ?? null,
       createdAt: this.now(),
       lastSeenAt: null,
       revokedAt: null
@@ -6176,12 +6352,15 @@ var DeviceRegistry = class {
     return rows.map((row) => this.toDevice(row));
   }
   close() {
+    this.challenges.clear();
+    this.pairingResults.clear();
     this.rawDb.close();
   }
   sweepExpiredChallenges() {
     const now = this.now();
+    for (const [id2, result] of this.pairingResults) if (now >= result.expiresAt) this.pairingResults.delete(id2);
     for (const [challengeId, challenge] of this.challenges) {
-      if (now > challenge.expiresAt) this.challenges.delete(challengeId);
+      if (now >= challenge.expiresAt) this.challenges.delete(challengeId);
     }
   }
   toDevice(row) {
@@ -7884,7 +8063,7 @@ import { join as join2 } from "node:path";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import websocket from "@fastify/websocket";
-import { randomBytes as randomBytes5, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 
 // ../daemon/src/external.ts
 import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
@@ -8806,6 +8985,139 @@ function transcriptDeltas(line) {
   return out;
 }
 
+// ../daemon/src/pairing-session.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+function createPairingSession(opts) {
+  const owner = randomBytes4(32).toString("base64url");
+  const rendezvous = derivePairingIdentity(opts.challenge.secret);
+  let transcript = null;
+  let identity = null;
+  let confirmed = false;
+  let disposed = false;
+  let committed = false;
+  let lastSeen = Date.now();
+  let windowAt = Date.now();
+  let frames = 0;
+  let queued = 0;
+  let chain = Promise.resolve();
+  let closing;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clearInterval(timer);
+    clearTimeout(closing);
+    if (transcript && !committed) opts.registry.cancelPairingChallenge(opts.challenge.challengeId);
+    opts.close();
+  };
+  const send = async (body, key = identity) => {
+    const payload = await seal(key ?? await rendezvous, JSON.stringify(body));
+    if (!disposed) opts.send(payload);
+  };
+  const fail = async (reason) => {
+    await send({ v: 2, type: "pair-error", reason });
+    dispose();
+  };
+  const tick = async () => {
+    if (disposed || committed) return;
+    if (Date.now() >= opts.challenge.expiresAt) return fail("expired");
+    if (!opts.registry.hasPairingChallenge(opts.challenge.challengeId)) return fail("cancelled");
+    if (transcript && Date.now() - lastSeen > 3e4) return fail("disconnected");
+    if (!confirmed || !transcript) return;
+    try {
+      const { device, token, relaySecret } = opts.registry.finishVerifiedPairing(opts.challenge.challengeId, transcript.attemptId);
+      committed = true;
+      await send({ v: 2, type: "paired", attemptId: transcript.attemptId, deviceId: device.deviceId, token, relaySecret });
+      clearInterval(timer);
+      closing = setTimeout(dispose, 500);
+      closing.unref?.();
+    } catch (err) {
+      if (err instanceof PairingError && err.reason === "local-confirmation-required") return;
+      await fail("unavailable");
+    }
+  };
+  const processFrame = async (payload) => {
+    if (disposed || committed) return;
+    const text = await open(identity ?? await rendezvous, payload);
+    if (disposed || committed) return;
+    if (text === null) {
+      if (identity) {
+        const competing = await open(await rendezvous, payload);
+        if (competing !== null) {
+          try {
+            const begin = PairingBegin.safeParse(JSON.parse(competing));
+            if (begin.success && begin.data.challengeId === opts.challenge.challengeId) {
+              opts.registry.cancelPairingChallenge(opts.challenge.challengeId);
+              await fail("competing-attempt");
+            }
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+    let raw;
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!transcript) {
+      if (raw?.v === 1) {
+        await send({ v: 1, type: "pair-error", reason: "update-required" });
+        dispose();
+        return;
+      }
+      const parsed2 = PairingBegin.safeParse(raw);
+      if (!parsed2.success || parsed2.data.challengeId !== opts.challenge.challengeId) return;
+      try {
+        transcript = opts.registry.beginVerifiedPairing({
+          v: 2,
+          challengeId: parsed2.data.challengeId,
+          secret: opts.challenge.secret,
+          deviceName: parsed2.data.deviceName,
+          phoneNonce: parsed2.data.phoneNonce
+        }, owner);
+        await send({ v: 2, type: "pair-transcript", transcript, remainingMs: Math.max(1, Math.min(3e5, opts.challenge.expiresAt - Date.now())) }, await rendezvous);
+        identity = deriveVerifiedPairing(opts.challenge.secret, transcript).identity;
+        lastSeen = Date.now();
+      } catch (err) {
+        await fail(err instanceof PairingError && err.reason === "competing-attempt" ? "competing-attempt" : "unavailable");
+      }
+      return;
+    }
+    const parsed = PairingDecision.safeParse(raw);
+    if (!parsed.success || parsed.data.attemptId !== transcript.attemptId) return;
+    lastSeen = Date.now();
+    if (parsed.data.type === "pair-reject") return fail("cancelled");
+    if (parsed.data.type === "pair-confirm") {
+      confirmed = true;
+      await send({ v: 2, type: "pair-waiting", attemptId: transcript.attemptId });
+      await tick();
+    }
+  };
+  const receive = (payload) => {
+    if (disposed || committed) return Promise.resolve();
+    if (Date.now() - windowAt >= 6e4) {
+      windowAt = Date.now();
+      frames = 0;
+    }
+    if (payload.length > PAIRING_FRAME_LIMIT || ++frames > 60 || queued >= 8) {
+      dispose();
+      return Promise.resolve();
+    }
+    queued++;
+    chain = chain.then(() => processFrame(payload)).catch(() => dispose()).finally(() => {
+      queued--;
+    });
+    return chain;
+  };
+  const timer = setInterval(() => {
+    chain = chain.then(tick).catch(() => dispose());
+  }, 250);
+  timer.unref?.();
+  return { receive, dispose, tick };
+}
+
 // ../daemon/src/relay-link.ts
 import WebSocket from "ws";
 function withRoom(endpoint, roomTag, role) {
@@ -9170,7 +9482,7 @@ var BriefingBuilder = class {
 };
 
 // ../daemon/src/delegations.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 var DelegationError = class extends Error {
   constructor(reason, message) {
     super(message);
@@ -9180,7 +9492,7 @@ var DelegationError = class extends Error {
 };
 var TARGET_AGENTS = /* @__PURE__ */ new Set(["claude", "codex"]);
 var TERMINAL = /* @__PURE__ */ new Set(["returned", "cancelled", "failed"]);
-var newId3 = () => `del_${randomBytes4(9).toString("base64url")}`;
+var newId3 = () => `del_${randomBytes5(9).toString("base64url")}`;
 var DelegationStore = class {
   db;
   now;
@@ -10156,6 +10468,10 @@ var LongLeashServer = class {
   delegations = null;
   hookSecret = null;
   localPairing = null;
+  pairingChallenges = /* @__PURE__ */ new Map();
+  pairingSockets = /* @__PURE__ */ new Set();
+  pairingRequests = [];
+  pairingCleanups = /* @__PURE__ */ new Set();
   staticRoot;
   /** Captured at process start so updating files on disk cannot impersonate a daemon restart. */
   expectedBuild;
@@ -10182,6 +10498,7 @@ var LongLeashServer = class {
       ok: true,
       name: "longleash",
       protocol: PROTOCOL_VERSION,
+      pairingVersion: 2,
       // A version is not machine data. Exposing it turns "connection refused / is this old?"
       // from guesswork into a doctor check and prevents testing a daemon that never restarted.
       build: this.expectedBuild
@@ -10257,7 +10574,7 @@ var LongLeashServer = class {
     });
     const localOnly = (request) => {
       const presented = request.headers["x-longleash-hook"];
-      return this.hookSecret !== null && typeof presented === "string" && presented.length === this.hookSecret.length && timingSafeEqual2(Buffer.from(presented), Buffer.from(this.hookSecret));
+      return !request.headers.origin && this.hookSecret !== null && typeof presented === "string" && Buffer.byteLength(presented) === Buffer.byteLength(this.hookSecret) && timingSafeEqual2(Buffer.from(presented), Buffer.from(this.hookSecret));
     };
     this.app.get("/devices", async (request, reply) => {
       if (!localOnly(request)) return reply.code(401).send({ reason: "unauthorized" });
@@ -10285,13 +10602,82 @@ var LongLeashServer = class {
     });
     this.app.post("/local/pairing", async (request, reply) => {
       if (!localOnly(request)) return reply.code(401).send({ reason: "unauthorized" });
+      this.pairingRequests = this.pairingRequests.filter((at) => Date.now() - at < 6e4);
+      if (this.pairingRequests.length >= 10) return reply.code(429).send({ reason: "rate-limited" });
+      this.pairingRequests.push(Date.now());
       if (this.localPairing === null) return reply.code(503).send({ reason: "pairing-unavailable" });
       try {
-        return { url: this.localPairing() };
+        const url2 = this.localPairing();
+        const challengeId = new URLSearchParams(new URL(url2).hash.slice(1)).get("c");
+        const challenge = challengeId ? this.pairingChallenges.get(challengeId) : void 0;
+        return { url: url2, version: 2, challengeId, expiresAt: challenge?.expiresAt };
       } catch {
         return reply.code(503).send({ reason: "pairing-failed" });
       }
     });
+    const localPairingInput = external_exports.object({
+      challengeId: external_exports.string().min(1).max(128),
+      attemptId: external_exports.string().regex(/^[A-Za-z0-9_-]{43}$/).optional()
+    }).strict();
+    for (const action of ["status", "confirm", "cancel"]) {
+      this.app.post(`/local/pairing/${action}`, async (request, reply) => {
+        if (!localOnly(request)) return reply.code(401).send({ reason: "unauthorized" });
+        const input = localPairingInput.safeParse(request.body);
+        if (!input.success) return reply.code(400).send({ reason: "invalid-input" });
+        const { challengeId, attemptId } = input.data;
+        if (action === "cancel") {
+          this.registry.cancelPairingChallenge(challengeId);
+          return { cancelled: true };
+        }
+        const result = this.registry.getPairingResult(challengeId);
+        if (action === "status" && result) return { state: "paired", deviceId: result.deviceId };
+        if (!this.registry.hasPairingChallenge(challengeId)) return reply.code(410).send({ reason: "ended" });
+        if (action === "status") return { verification: this.registry.getPairingVerification(challengeId) };
+        if (!attemptId) return reply.code(400).send({ reason: "invalid-input" });
+        try {
+          this.registry.confirmPairingLocally(challengeId, attemptId);
+          return { confirmed: true };
+        } catch {
+          return reply.code(409).send({ reason: "attempt-ended" });
+        }
+      });
+    }
+    this.app.get("/pair/v2", { websocket: true }, (socket, request) => {
+      const challengeId = request.query.c ?? "";
+      const challenge = this.pairingChallenges.get(challengeId);
+      if (!challenge || !this.registry.hasPairingChallenge(challengeId) || this.pairingSockets.size >= 16) {
+        socket.close(4403, "Pairing unavailable; generate a fresh QR");
+        return;
+      }
+      this.pairingSockets.add(socket);
+      const session = createPairingSession({
+        registry: this.registry,
+        challenge,
+        send: (payload) => {
+          if (socket.readyState === socket.OPEN) socket.send(JSON.stringify({ v: 1, type: "frame", payload }));
+        },
+        close: () => socket.close()
+      });
+      this.pairingCleanups.add(session.dispose);
+      socket.on("message", (raw) => {
+        if (String(raw).length > 9e3) {
+          session.dispose();
+          return;
+        }
+        try {
+          const message = JSON.parse(String(raw));
+          if (message.type === "frame" && typeof message.payload === "string") void session.receive(message.payload);
+        } catch {
+        }
+      });
+      socket.on("close", () => {
+        session.dispose();
+        this.pairingSockets.delete(socket);
+        this.pairingCleanups.delete(session.dispose);
+      });
+      socket.on("error", session.dispose);
+      socket.send(JSON.stringify({ v: 2, type: "pair-ready" }));
+    });
     this.app.get("/pair", async (_request, reply) => reply.code(405).send({ reason: "use-post" }));
     this.app.post("/pair", async (request, reply) => {
       const query2 = request.query;
@@ -10397,7 +10783,7 @@ var LongLeashServer = class {
    */
   async rebind(host) {
     const wanted = this.boundPort;
-    await new Promise((resolve7) => this.app.server.close(() => resolve7()));
+    if (this.app.server.listening) await new Promise((resolve7) => this.app.server.close(() => resolve7()));
     const tryListen = (port) => new Promise((resolve7, reject) => {
       const onError = (err) => {
         this.app.server.removeListener("listening", onListening);
@@ -10434,6 +10820,21 @@ var LongLeashServer = class {
   attachLocalPairing(create) {
     this.localPairing = create;
   }
+  /** Only transient memory; URLs/secrets must never reach logs or the event database. */
+  registerPairingChallenge(challenge) {
+    for (const [id2, previous] of this.pairingChallenges) {
+      if (previous.expiresAt <= Date.now() || !this.registry.hasPairingChallenge(id2)) this.pairingChallenges.delete(id2);
+    }
+    this.pairingChallenges.set(challenge.challengeId, challenge);
+    const cleanup = () => {
+      clearTimeout(timer);
+      this.pairingChallenges.delete(challenge.challengeId);
+      this.pairingCleanups.delete(cleanup);
+    };
+    const timer = setTimeout(cleanup, Math.max(0, challenge.expiresAt - Date.now()));
+    timer.unref?.();
+    this.pairingCleanups.add(cleanup);
+  }
   /** Persist an event, then fan it out to every subscriber of that session. */
   publish(sessionId, input) {
     const event2 = this.eventLog.append(sessionId, input);
@@ -10454,6 +10855,9 @@ var LongLeashServer = class {
     return this.connections.size;
   }
   async close() {
+    for (const cleanup of this.pairingCleanups) cleanup();
+    for (const socket of this.pairingSockets) socket.terminate();
+    this.pairingChallenges.clear();
     if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
     this.heartbeatTimer = null;
     this.unsubscribeRevoked?.();
@@ -11061,7 +11465,7 @@ var LongLeashServer = class {
       return;
     }
     if (message.type === "takeOver") {
-      const reservationId = `takeover-${randomBytes5(9).toString("base64url")}`;
+      const reservationId = `takeover-${randomBytes6(9).toString("base64url")}`;
       const sessions = this.sessions;
       void (async () => {
         const conflict = this.workspaceConflictMessage(message.sessionId);
@@ -12599,7 +13003,7 @@ var CodexSessionWatcher = class {
     this.timer = null;
   }
   scan(initial = false) {
-    const root = this.options.sessionsRoot ?? join6(homedir3(), ".codex", "sessions");
+    const root = this.options.sessionsRoot ?? join6(process.env.CODEX_HOME || join6(homedir3(), ".codex"), "sessions");
     const now = this.options.now?.() ?? Date.now();
     let observed = 0;
     for (const path of jsonlFiles(root)) {
@@ -12611,7 +13015,7 @@ var CodexSessionWatcher = class {
       }
       const previous = this.mtimes.get(path);
       this.mtimes.set(path, modified);
-      const changed = previous !== void 0 && modified > previous;
+      const changed = previous === void 0 ? !initial : modified !== previous;
       const recentlyActive = initial && now - modified <= this.options.initialRecentMs;
       if (!changed && !recentlyActive) continue;
       const previousSession = this.known.get(path);
@@ -12851,14 +13255,20 @@ async function startDaemon(options) {
     pauseSession: (session, actor, reason) => pauseCurrentSessionOwner(sessions, external, session, actor, reason)
   });
   server.attachDelegations(delegationManager);
-  const hookSecret = randomBytes6(24).toString("base64url");
+  const hookSecret = randomBytes7(24).toString("base64url");
   server.attachExternal(external, hookSecret);
   const { port } = await server.listen();
-  writeFileSync2(
-    join7(dataDir2, "hook-endpoint.json"),
-    JSON.stringify({ url: `http://${options.host}:${port}/hook`, secret: hookSecret }, null, 2) + "\n",
-    { mode: 384 }
-  );
+  const endpointPath = join7(dataDir2, "hook-endpoint.json");
+  const publishHookEndpoint = (host, boundPort) => {
+    const staged = `${endpointPath}.${randomBytes7(8).toString("hex")}.tmp`;
+    try {
+      writeFileSync2(staged, JSON.stringify({ url: `http://${host}:${boundPort}/hook`, secret: hookSecret }, null, 2) + "\n", { mode: 384 });
+      renameSync(staged, endpointPath);
+    } finally {
+      rmSync(staged, { force: true });
+    }
+  };
+  publishHookEndpoint(options.host, port);
   const stopMaintenance = sessions.startMaintenance();
   let bridge = null;
   if (options.relayUrl !== void 0) {
@@ -12868,6 +13278,11 @@ async function startDaemon(options) {
   }
   return {
     server,
+    rebindLocal: async (host) => {
+      const reboundPort = await server.rebind(host);
+      publishHookEndpoint(host, reboundPort);
+      return reboundPort;
+    },
     sessions,
     registry,
     eventLog,
@@ -12927,7 +13342,62 @@ function save(path, config) {
 }
 
 // ../daemon/src/pairing-host.ts
+import WebSocket3 from "ws";
+
+// ../daemon/src/pairing-relay-v2.ts
 import WebSocket2 from "ws";
+function hostVerifiedPairing(opts) {
+  let socket = null;
+  let session = null;
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clearTimeout(deadline);
+    clearInterval(keepalive);
+    session?.dispose();
+    opts.registry.cancelPairingChallenge(opts.challenge.challengeId);
+    socket?.close();
+  };
+  const deadline = setTimeout(dispose, Math.max(0, opts.challenge.expiresAt - Date.now()));
+  deadline.unref?.();
+  const keepalive = setInterval(() => {
+    if (!opts.registry.hasPairingChallenge(opts.challenge.challengeId)) {
+      dispose();
+      return;
+    }
+    if (socket?.readyState === WebSocket2.OPEN) socket.send(JSON.stringify({ v: 1, type: "ping" }));
+  }, 1e4);
+  keepalive.unref?.();
+  void derivePairingIdentity(opts.challenge.secret).then((identity) => {
+    if (disposed) return;
+    const ws = new WebSocket2(withRoom(opts.relayUrl, identity.roomTag, "host"), { maxPayload: 1e4 });
+    socket = ws;
+    session = createPairingSession({
+      registry: opts.registry,
+      challenge: opts.challenge,
+      send: (payload) => {
+        if (ws.readyState === WebSocket2.OPEN) ws.send(JSON.stringify({ v: 1, type: "frame", payload }));
+      },
+      close: dispose
+    });
+    ws.on("open", () => ws.send(JSON.stringify({ v: 1, type: "join", room: identity.roomTag, role: "host" })));
+    ws.on("close", dispose);
+    ws.on("error", dispose);
+    ws.on("message", (raw) => {
+      if (disposed) return;
+      try {
+        const message = JSON.parse(String(raw));
+        if (message.type === "frame" && typeof message.payload === "string") void session?.receive(message.payload);
+        if (message.type === "peer" && message.role === "guest" && message.event === "left") dispose();
+      } catch {
+      }
+    });
+  }).catch(dispose);
+  return dispose;
+}
+
+// ../daemon/src/pairing-host.ts
 var CompletePairing = external_exports.object({
   v: external_exports.literal(1),
   type: external_exports.literal("completePairing"),
@@ -12936,6 +13406,7 @@ var CompletePairing = external_exports.object({
   deviceName: external_exports.string().min(1).max(64)
 });
 function hostPairing(opts) {
+  if (JSON.parse(opts.challenge.qrPayload).v === 2) return hostVerifiedPairing(opts);
   const log = opts.log ?? (() => {
   });
   let socket = null;
@@ -12954,7 +13425,7 @@ function hostPairing(opts) {
       return;
     }
     if (disposed) return;
-    const ws = new WebSocket2(withRoom(opts.relayUrl, identity.roomTag, "host"));
+    const ws = new WebSocket3(withRoom(opts.relayUrl, identity.roomTag, "host"));
     socket = ws;
     ws.on("open", () => {
       ws.send(JSON.stringify({ v: 1, type: "join", room: identity.roomTag, role: "host" }));
@@ -12997,7 +13468,7 @@ function hostPairing(opts) {
             reason: err instanceof PairingError ? err.reason : "error"
           };
         }
-        if (ws.readyState === WebSocket2.OPEN) {
+        if (ws.readyState === WebSocket3.OPEN) {
           ws.send(JSON.stringify({ v: 1, type: "frame", payload: await seal(identity, JSON.stringify(reply)) }));
         }
         if (succeeded) setTimeout(dispose, 500);
@@ -13010,10 +13481,10 @@ function hostPairing(opts) {
 }
 
 // ../daemon/src/pairing-url.ts
-function pairingUrl(appOrigin, challengeId, secret) {
+function pairingUrl(appOrigin, challengeId, secret, version = 1) {
   const url2 = new URL(appOrigin);
   url2.search = "";
-  url2.hash = new URLSearchParams({ c: challengeId, s: secret }).toString();
+  url2.hash = new URLSearchParams({ c: challengeId, s: secret, ...version === 2 ? { v: "2" } : {} }).toString();
   return url2.toString();
 }
 
@@ -13161,7 +13632,7 @@ function noAddressReason(interfaces = networkInterfaces()) {
 }
 
 // ../daemon/src/instance-lock.ts
-import { closeSync as closeSync3, lstatSync, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { closeSync as closeSync3, lstatSync, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join as join9 } from "node:path";
 var LOCK_NAME = "daemon.lock";
@@ -13195,7 +13666,7 @@ function acquireDaemonInstance(dataDir2) {
     if (processAlive(owner.pid)) {
       throw new Error(`LongLeash already owns this data directory in process ${owner.pid}. Use \`longleash service status\` before starting another instance.`);
     }
-    rmSync(path);
+    rmSync2(path);
     create();
   }
   let held = true;
@@ -13206,7 +13677,7 @@ function acquireDaemonInstance(dataDir2) {
       held = false;
       try {
         const owner = JSON.parse(readFileSync5(path, "utf8"));
-        if (owner.token === token) rmSync(path);
+        if (owner.token === token) rmSync2(path);
       } catch {
       }
     }
@@ -13357,20 +13828,61 @@ function relayAppOrigin(wsUrl) {
   parsed.pathname = "/";
   return parsed.toString();
 }
-function freshPairingUrl() {
-  const challenge = daemon.registry.createPairingChallenge();
+var foregroundChallenge = null;
+var displayedAttempt = null;
+var relayPairings = /* @__PURE__ */ new Set();
+function freshPairingUrl(foreground = false) {
+  if (foreground && foregroundChallenge) daemon.registry.cancelPairingChallenge(foregroundChallenge);
+  const challenge = daemon.registry.createPairingChallenge({ version: 2 });
+  daemon.server.registerPairingChallenge(challenge);
+  if (foreground) {
+    foregroundChallenge = challenge.challengeId;
+    displayedAttempt = null;
+  }
   if (relay !== null) {
-    hostPairing({ registry: daemon.registry, relayUrl: relay.url, challenge, log: (line) => daemonLog(`[pair] ${line}`) });
-    return pairingUrl(relayAppOrigin(relay.url), challenge.challengeId, challenge.secret);
+    const dispose = hostPairing({ registry: daemon.registry, relayUrl: relay.url, challenge });
+    relayPairings.add(dispose);
+    setTimeout(() => {
+      dispose();
+      relayPairings.delete(dispose);
+    }, Math.max(0, challenge.expiresAt - Date.now())).unref?.();
+    return pairingUrl(relayAppOrigin(relay.url), challenge.challengeId, challenge.secret, 2);
   }
   return pairingUrl(
     `http://${servingHost}:${servingPort}/`,
     challenge.challengeId,
-    challenge.secret
+    challenge.secret,
+    2
   );
 }
-daemon.server.attachLocalPairing(freshPairingUrl);
-var url = serviceMode ? null : freshPairingUrl();
+daemon.server.attachLocalPairing(() => freshPairingUrl());
+var interactivePairing = !serviceMode && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var url = interactivePairing ? freshPairingUrl(true) : null;
+var pairingWatch = setInterval(() => {
+  if (!foregroundChallenge) return;
+  const result = daemon.registry.getPairingResult(foregroundChallenge);
+  if (result) {
+    console.log(`Paired ${result.deviceId}. Keep the QR private.`);
+    foregroundChallenge = null;
+    displayedAttempt = null;
+    return;
+  }
+  if (!daemon.registry.hasPairingChallenge(foregroundChallenge)) {
+    console.log("Pairing ended. Press n + Enter for a fresh QR.");
+    foregroundChallenge = null;
+    displayedAttempt = null;
+    return;
+  }
+  const verification = daemon.registry.getPairingVerification(foregroundChallenge);
+  if (verification && verification.attemptId !== displayedAttempt) {
+    displayedAttempt = verification.attemptId;
+    console.log(`
+Compare with your phone:  ${verification.code}
+Type y + Enter only if every digit matches, or x + Enter to reject.
+`);
+  }
+}, 250);
+pairingWatch.unref?.();
 console.log("\n=== LongLeash ===\n");
 var warn = vpnWarning();
 if (warn) console.log(`!!! ${warn}
@@ -13414,23 +13926,28 @@ Listening on ${servedHost}:${daemon.port} (no local network \u2014 relay only)`
   console.log(
     relay !== null ? `Relay: ${relay.url} \u2014 your phone can reach this laptop from anywhere.` : "Relay: not configured (LAN only). Set LONGLEASH_RELAY_URL once to enable remote access \u2014 it is remembered."
   );
-  console.log("\nScan this with your phone, then add it to your home screen:\n");
-  console.log(terminalQr(url));
-  console.log(`
+  if (url) {
+    console.log("\nScan this with your phone, then compare both verification codes. Keep this terminal open:\n");
+    console.log(terminalQr(url));
+    console.log(`
   ${url}
 `);
-  if (relay !== null && servedOnLan) {
-    console.log(`(LAN fallback for pairing at home: http://${servedHost}:${daemon.port}/#c=\u2026&s=\u2026 \u2014 same code)`);
-  }
+    if (relay !== null && servedOnLan) {
+      console.log("Use this same QR for the encrypted relay pairing flow.");
+    }
+  } else console.log("Run longleash pair in an interactive terminal to pair. No QR is printed to redirected output.");
 }
 var NETWORK_WATCH_MS = 5e3;
+var networkRebindInFlight = false;
 var networkWatch = setInterval(() => {
+  if (networkRebindInFlight) return;
   const nextBest = findCandidates()[0];
   const nextHost = nextBest?.address ?? "127.0.0.1";
   if (nextHost === servingHost) return;
   const was = servingHost;
-  servingHost = nextHost;
-  void daemon.server.rebind(nextHost).then((port) => {
+  networkRebindInFlight = true;
+  void daemon.rebindLocal(nextHost).then((port) => {
+    servingHost = nextHost;
     servingPort = port;
     console.log(serviceMode ? "\nNetwork changed; the local listener recovered." : `
 Network changed: ${was} -> ${nextHost}. Now serving ${nextHost}:${port}.`);
@@ -13441,6 +13958,8 @@ Network changed: ${was} -> ${nextHost}. Now serving ${nextHost}:${port}.`);
     console.log(serviceMode ? "\nNetwork changed but local listener recovery failed; details omitted." : `
 Network changed but rebinding failed (${String(err)}).`);
     console.log(relay !== null ? "The relay is unaffected." : "Restart the daemon to recover.");
+  }).finally(() => {
+    networkRebindInFlight = false;
   });
 }, NETWORK_WATCH_MS);
 networkWatch.unref?.();
@@ -13448,20 +13967,38 @@ if (!serviceMode) console.log("Press n + Enter for a fresh pairing QR, r + Enter
 process.stdin.setEncoding("utf8");
 process.stdin.on("data", (chunk) => {
   const key = chunk.trim().toLowerCase();
-  if (key === "n" && !serviceMode) {
-    const next = freshPairingUrl();
+  if (key === "n" && interactivePairing) {
+    let next;
+    try {
+      next = freshPairingUrl(true);
+    } catch {
+      console.log("Too many pending QRs. Wait for expiry before trying again.");
+      return;
+    }
     console.log("\nScan this with your phone:\n");
     console.log(terminalQr(next));
     console.log(`
   ${next}
 `);
   }
+  if ((key === "y" || key === "x") && foregroundChallenge && displayedAttempt && interactivePairing) {
+    try {
+      if (key === "y") {
+        daemon.registry.confirmPairingLocally(foregroundChallenge, displayedAttempt);
+        console.log("Laptop confirmed. Choose Codes match on your phone to finish.");
+      } else daemon.registry.cancelPairingChallenge(foregroundChallenge);
+    } catch {
+      console.log("That pairing ended. Press n + Enter for a fresh QR.");
+    }
+  }
   if (key === "r") {
     const active = daemon.registry.listDevices().filter((d) => d.revokedAt === null);
     for (const device of active) daemon.registry.revokeDevice(device.deviceId);
     console.log(`>>> revoked ${active.length} device(s); their live connections are cut`);
   }
   if (key === "q") {
+    clearInterval(pairingWatch);
+    for (const dispose of relayPairings) dispose();
     clearInterval(networkWatch);
     void daemon.stop().then(() => {
       instanceLock.release();
@@ -13470,6 +14007,8 @@ process.stdin.on("data", (chunk) => {
   }
 });
 var shutdown = () => {
+  clearInterval(pairingWatch);
+  for (const dispose of relayPairings) dispose();
   clearInterval(networkWatch);
   void daemon.stop().then(() => {
     instanceLock.release();