@buildautomaton/cli 0.1.64 → 0.1.66

package/dist/cli.js

@@ -5277,12 +5277,12 @@ var require_websocket = __commonJS({
     "use strict";
     var EventEmitter2 = __require("events");
     var https2 = __require("https");
-    var http2 = __require("http");
+    var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash3 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash3 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
-    var { URL: URL2 } = __require("url");
+    var { URL: URL3 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
@@ -5775,11 +5775,11 @@ var require_websocket = __commonJS({
         );
       }
       let parsedUrl;
-      if (address instanceof URL2) {
+      if (address instanceof URL3) {
         parsedUrl = address;
       } else {
         try {
-          parsedUrl = new URL2(address);
+          parsedUrl = new URL3(address);
         } catch (e) {
           throw new SyntaxError(`Invalid URL: ${address}`);
         }
@@ -5810,8 +5810,8 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes3(16).toString("base64");
-      const request = isSecure ? https2.request : http2.request;
+      const key = randomBytes4(16).toString("base64");
+      const request = isSecure ? https2.request : http3.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -5916,7 +5916,7 @@ var require_websocket = __commonJS({
           req.abort();
           let addr;
           try {
-            addr = new URL2(location, address);
+            addr = new URL3(location, address);
           } catch (e) {
             const err = new SyntaxError(`Invalid URL: ${location}`);
             emitErrorAndClose(websocket, err);
@@ -6305,7 +6305,7 @@ var require_websocket_server = __commonJS({
   "../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
     var EventEmitter2 = __require("events");
-    var http2 = __require("http");
+    var http3 = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash3 } = __require("crypto");
     var extension = require_extension();
@@ -6380,8 +6380,8 @@ var require_websocket_server = __commonJS({
           );
         }
         if (options.port != null) {
-          this._server = http2.createServer((req, res) => {
-            const body = http2.STATUS_CODES[426];
+          this._server = http3.createServer((req, res) => {
+            const body = http3.STATUS_CODES[426];
             res.writeHead(426, {
               "Content-Length": body.length,
               "Content-Type": "text/plain"
@@ -6668,7 +6668,7 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      message = message || http2.STATUS_CODES[code];
+      message = message || http3.STATUS_CODES[code];
       headers = {
         Connection: "close",
         "Content-Type": "text/html",
@@ -6677,7 +6677,7 @@ var require_websocket_server = __commonJS({
       };
       socket.once("finish", socket.destroy);
       socket.end(
-        `HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
+        `HTTP/1.1 ${code} ${http3.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
@@ -25668,11 +25668,11 @@ var require_dist2 = __commonJS({
 });
 
 // src/files/ensure-under-cwd.ts
-import path74 from "node:path";
+import path73 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path74.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path74.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path74.sep) && resolved !== cwd) {
+  const normalized = path73.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path73.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path73.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -25694,15 +25694,15 @@ var init_types2 = __esm({
 });
 
 // src/files/list-dir/map-dir-entry.ts
-import path75 from "node:path";
-import fs48 from "node:fs";
+import path74 from "node:path";
+import fs46 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path75.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path75.join(resolved, d.name);
+  const entryPath = path74.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path74.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs48.promises.stat(fullPath);
+      const targetStat = await fs46.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -25739,7 +25739,7 @@ var list_dir_exports = {};
 __export(list_dir_exports, {
   listDirAsync: () => listDirAsync
 });
-import fs49 from "node:fs";
+import fs47 from "node:fs";
 async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
   await yieldToEventLoop();
   const resolved = ensureUnderCwd(relativePath || ".", sessionParentPath);
@@ -25747,7 +25747,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs49.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs47.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -25791,7 +25791,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.64".length > 0 ? "0.1.64" : "0.0.0-dev";
+var CLI_VERSION = "0.1.66".length > 0 ? "0.1.66" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -27309,7 +27309,7 @@ function clearMainBridgeReconnectQuietOnOpen(state, log2) {
 function scheduleMainBridgeReconnect(state, connect, log2, closeMeta) {
   if (state.closedByUser || state.currentWs != null) return;
   const meta = closeMeta ?? state.lastReconnectCloseMeta ?? void 0;
-  const delay3 = applyTieredReconnectPlanAndLog(
+  const delay4 = applyTieredReconnectPlanAndLog(
     state.mainOutage,
     log2,
     BRIDGE_SERVICE_LABEL,
@@ -27318,7 +27318,7 @@ function scheduleMainBridgeReconnect(state, connect, log2, closeMeta) {
     meta?.reason
   );
   armReconnectDelayTimer({
-    delayMs: delay3,
+    delayMs: delay4,
     bumpAttempt: () => {
       state.reconnectAttempt += 1;
     },
@@ -27520,10 +27520,10 @@ function runPendingAuth(options) {
         }
         if (resolved) return;
         beginDeferredPendingCloseLog(code, reason);
-        const delay3 = pendingAuthReconnectDelayMs(reconnectAttempt);
+        const delay4 = pendingAuthReconnectDelayMs(reconnectAttempt);
         reconnectAttempt += 1;
         if (signInQuiet.verboseLogs) {
-          const delayLabel = formatReconnectDelayForLog(delay3);
+          const delayLabel = formatReconnectDelayForLog(delay4);
           logFn(
             `[Bridge service] Next sign-in connection attempt in ${delayLabel} (attempt ${reconnectAttempt}).`
           );
@@ -27531,7 +27531,7 @@ function runPendingAuth(options) {
         reconnectTimeout = setTimeout(() => {
           reconnectTimeout = null;
           connect();
-        }, delay3);
+        }, delay4);
       },
       onError: (err) => logCliWebSocketError(logFn, "[Bridge service]", err, "while waiting for sign-in"),
       onMessage: (data) => {
@@ -38692,7 +38692,9 @@ function createBridgePreviewStack(options) {
   };
   const identifyReportedPaths = {
     bridgeRootPath: path39.resolve(getBridgeRoot()),
-    worktreesRootPath: path39.resolve(options.worktreesRootPath)
+    worktreesRootPath: path39.resolve(options.worktreesRootPath),
+    localShortcutPort: 0,
+    localShortcutToken: ""
   };
   return { previewEnvironmentManager, scheduleInitialIndexBuildsOnce, identifyReportedPaths };
 }
@@ -39287,7 +39289,7 @@ function createFirehoseReconnectScheduler(ctx, reconnect) {
   function scheduleFirehoseRetryAfterDrop(closeMeta) {
     if (state.closedByUser) return;
     const meta = closeMeta ?? state.lastFirehoseReconnectCloseMeta ?? void 0;
-    const delay3 = applyTieredReconnectPlanAndLog(
+    const delay4 = applyTieredReconnectPlanAndLog(
       state.firehoseOutage,
       logFn,
       PREVIEW_TUNNEL_SERVICE_LABEL,
@@ -39296,7 +39298,7 @@ function createFirehoseReconnectScheduler(ctx, reconnect) {
       meta?.reason
     );
     armReconnectDelayTimer({
-      delayMs: delay3,
+      delayMs: delay4,
       bumpAttempt: () => {
         state.firehoseReconnectAttempt += 1;
       },
@@ -39400,6 +39402,208 @@ function createOnBridgeIdentified(opts) {
   };
 }
 
+// src/connection/create-bridge-identified-with-heartbeat.ts
+function createBridgeIdentifiedWithHeartbeat(params) {
+  const { bridgeHeartbeat, log: log2, ...identifiedOpts } = params;
+  const onBridgeIdentified = createOnBridgeIdentified({ ...identifiedOpts, logFn: log2 });
+  return (msg) => {
+    onBridgeIdentified(msg);
+    bridgeHeartbeat.start();
+  };
+}
+
+// src/connection/heartbeat/build-heartbeat-message.ts
+function buildBridgeHeartbeatMessage(seq, meanRttMs2) {
+  return meanRttMs2 !== void 0 && Number.isFinite(meanRttMs2) ? { t: "h", s: seq, m: Math.round(meanRttMs2) } : { t: "h", s: seq };
+}
+
+// src/connection/heartbeat/heartbeat-seq.ts
+function createHeartbeatSeqCursor() {
+  let seqCursor = -1;
+  return {
+    next() {
+      seqCursor = seqCursor >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : seqCursor + 1;
+      return seqCursor;
+    },
+    reset() {
+      seqCursor = -1;
+    }
+  };
+}
+
+// src/connection/heartbeat/handle-pending-heartbeat-miss.ts
+function handlePendingHeartbeatMiss(params) {
+  const { awaitingSeq, missed, log: log2, ws, onReconnect } = params;
+  if (awaitingSeq === null) return { missed, stopTick: false };
+  const nextMissed = missed + 1;
+  if (nextMissed < BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT) {
+    return { missed: nextMissed, stopTick: false };
+  }
+  try {
+    log2("[Bridge service] Heartbeat missed repeatedly; reconnecting\u2026");
+  } catch {
+  }
+  onReconnect();
+  safeCloseWebSocket(ws);
+  return { missed: 0, stopTick: true };
+}
+
+// src/connection/heartbeat/on-every-n-ticks.ts
+function createEveryNTicksRunner(onEveryNTicks) {
+  let tickCount = 0;
+  return {
+    reset() {
+      tickCount = 0;
+    },
+    onTick() {
+      if (!onEveryNTicks || onEveryNTicks.n <= 0) return;
+      tickCount++;
+      if (tickCount % onEveryNTicks.n !== 0) return;
+      try {
+        onEveryNTicks.fn();
+      } catch {
+      }
+    }
+  };
+}
+
+// src/connection/heartbeat/process-heartbeat-ack.ts
+function processHeartbeatAck(params) {
+  const { seq, awaitingSeq, sentAtMs, recordRtt } = params;
+  if (awaitingSeq === null) return { awaitingSeq, missed: 0 };
+  if (!Number.isFinite(seq)) return { awaitingSeq, missed: 0 };
+  const ack = Math.trunc(seq);
+  const pending = awaitingSeq;
+  if (ack < pending) return { awaitingSeq, missed: 0 };
+  if (ack === pending) {
+    recordRtt(Date.now() - sentAtMs);
+  }
+  return { awaitingSeq: null, missed: 0 };
+}
+
+// src/connection/heartbeat/rtt-samples.ts
+function meanRttMs(samples) {
+  if (samples.length === 0) return void 0;
+  let sum = 0;
+  for (const x of samples) sum += x;
+  return sum / samples.length;
+}
+function createRttSampleBuffer(maxSamples = BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX) {
+  const samples = [];
+  return {
+    push(rttMs) {
+      if (!Number.isFinite(rttMs) || rttMs < 0 || rttMs >= 6e5) return;
+      samples.push(rttMs);
+      if (samples.length > maxSamples) {
+        samples.splice(0, samples.length - maxSamples);
+      }
+    },
+    clear() {
+      samples.length = 0;
+    },
+    mean() {
+      return meanRttMs(samples);
+    }
+  };
+}
+
+// src/connection/heartbeat/controller.ts
+function createBridgeHeartbeatController(params) {
+  const { getWs, log: log2, onEveryNTicks } = params;
+  let interval = null;
+  let awaitingSeq = null;
+  let sentAtMs = 0;
+  let missed = 0;
+  const seqCursor = createHeartbeatSeqCursor();
+  const rttSamples = createRttSampleBuffer();
+  const everyNTicks = createEveryNTicksRunner(onEveryNTicks);
+  function clearTimer() {
+    if (interval != null) {
+      clearInterval(interval);
+      interval = null;
+    }
+  }
+  function resetPendingState() {
+    awaitingSeq = null;
+    missed = 0;
+    rttSamples.clear();
+  }
+  function tick() {
+    const ws = getWs();
+    if (!ws || ws.readyState !== wrapper_default.OPEN) return;
+    const missResult = handlePendingHeartbeatMiss({
+      awaitingSeq,
+      missed,
+      log: log2,
+      ws,
+      onReconnect: () => {
+        clearTimer();
+        resetPendingState();
+      }
+    });
+    missed = missResult.missed;
+    if (missResult.stopTick) return;
+    const seq = seqCursor.next();
+    sendWsMessage(ws, buildBridgeHeartbeatMessage(seq, rttSamples.mean()));
+    awaitingSeq = seq;
+    sentAtMs = Date.now();
+    everyNTicks.onTick();
+  }
+  return {
+    start() {
+      clearTimer();
+      everyNTicks.reset();
+      resetPendingState();
+      seqCursor.reset();
+      interval = setInterval(tick, BRIDGE_APP_HEARTBEAT_INTERVAL_MS);
+    },
+    stop() {
+      clearTimer();
+      resetPendingState();
+    },
+    onAck(seq) {
+      const result = processHeartbeatAck({
+        seq,
+        awaitingSeq,
+        sentAtMs,
+        recordRtt: rttSamples.push
+      });
+      awaitingSeq = result.awaitingSeq;
+      missed = result.missed;
+    }
+  };
+}
+
+// src/connection/send-bridge-identify.ts
+function sendBridgeIdentify(ws, params) {
+  if (!ws) return;
+  const { identifyReportedPaths, e2ee } = params;
+  sendWsMessage(ws, {
+    type: "identify",
+    role: "cli",
+    cliVersion: CLI_VERSION,
+    bridgeRootPath: identifyReportedPaths.bridgeRootPath,
+    worktreesRootPath: identifyReportedPaths.worktreesRootPath,
+    localShortcutPort: identifyReportedPaths.localShortcutPort,
+    localShortcutToken: identifyReportedPaths.localShortcutToken,
+    ...e2ee ? { e: e2ee.handshake } : {}
+  });
+}
+var BRIDGE_IDENTIFY_REFRESH_EVERY_TICKS = 6;
+
+// src/connection/create-bridge-identify-heartbeat.ts
+function createBridgeIdentifyHeartbeat(params) {
+  const { getWs, log: log2, identifyReportedPaths, e2ee } = params;
+  return createBridgeHeartbeatController({
+    getWs,
+    log: log2,
+    onEveryNTicks: {
+      n: BRIDGE_IDENTIFY_REFRESH_EVERY_TICKS,
+      fn: () => sendBridgeIdentify(getWs(), { identifyReportedPaths, e2ee })
+    }
+  });
+}
+
 // src/connection/create-bridge-message-deps.ts
 function createBridgeMessageDeps(params) {
   const {
@@ -39566,98 +39770,11 @@ function createReportAutoDetectedAgents(getWs, logFn) {
   };
 }
 
-// src/connection/heartbeat/controller.ts
-function meanRttMs(samples) {
-  if (samples.length === 0) return void 0;
-  let sum = 0;
-  for (const x of samples) sum += x;
-  return sum / samples.length;
-}
-function createBridgeHeartbeatController(params) {
-  const { getWs, log: log2 } = params;
-  let interval = null;
-  let seqCursor = -1;
-  let awaitingSeq = null;
-  let sentAtMs = 0;
-  let missed = 0;
-  const rttSamples = [];
-  function clearTimer() {
-    if (interval != null) {
-      clearInterval(interval);
-      interval = null;
-    }
-  }
-  function nextSeq() {
-    seqCursor = seqCursor >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : seqCursor + 1;
-    return seqCursor;
-  }
-  function tick() {
-    const ws = getWs();
-    if (!ws || ws.readyState !== wrapper_default.OPEN) return;
-    if (awaitingSeq !== null) {
-      missed++;
-      if (missed >= BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT) {
-        try {
-          log2("[Bridge service] Heartbeat missed repeatedly; reconnecting\u2026");
-        } catch {
-        }
-        clearTimer();
-        awaitingSeq = null;
-        missed = 0;
-        rttSamples.length = 0;
-        safeCloseWebSocket(ws);
-        return;
-      }
-    }
-    const seq = nextSeq();
-    const mean = meanRttMs(rttSamples);
-    const payload = mean !== void 0 && Number.isFinite(mean) ? { t: "h", s: seq, m: Math.round(mean) } : { t: "h", s: seq };
-    sendWsMessage(ws, payload);
-    awaitingSeq = seq;
-    sentAtMs = Date.now();
-  }
-  return {
-    start() {
-      clearTimer();
-      awaitingSeq = null;
-      missed = 0;
-      seqCursor = -1;
-      rttSamples.length = 0;
-      interval = setInterval(tick, BRIDGE_APP_HEARTBEAT_INTERVAL_MS);
-    },
-    stop() {
-      clearTimer();
-      awaitingSeq = null;
-      missed = 0;
-      rttSamples.length = 0;
-    },
-    onAck(seq) {
-      if (awaitingSeq === null) return;
-      if (!Number.isFinite(seq)) return;
-      const ack = Math.trunc(seq);
-      const pending = awaitingSeq;
-      if (ack < pending) return;
-      if (ack === pending) {
-        const rtt = Date.now() - sentAtMs;
-        if (Number.isFinite(rtt) && rtt >= 0 && rtt < 6e5) {
-          rttSamples.push(rtt);
-          if (rttSamples.length > BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX) {
-            rttSamples.splice(0, rttSamples.length - BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX);
-          }
-        }
-      }
-      awaitingSeq = null;
-      missed = 0;
-    }
-  };
-}
-
-// src/connection/create-bridge-runtime-message-setup.ts
-function createBridgeRuntimeMessageSetup(options) {
+// src/connection/create-bridge-runtime-message-deps.ts
+function createBridgeRuntimeMessageDeps(params) {
   const {
     apiUrl,
     workspaceId,
-    firehoseServerUrl,
     state,
     getWs,
     log: log2,
@@ -39666,23 +39783,11 @@ function createBridgeRuntimeMessageSetup(options) {
     sessionWorktreeManager,
     previewWorktreeManager,
     previewEnvironmentManager,
-    e2ee
-  } = options;
-  const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: log2 });
-  const baseOnBridgeIdentified = createOnBridgeIdentified({
-    previewEnvironmentManager,
-    firehoseServerUrl,
-    workspaceId,
-    state,
-    logFn: log2
-  });
-  const onBridgeIdentified = (msg) => {
-    baseOnBridgeIdentified(msg);
-    bridgeHeartbeat.start();
-  };
-  const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, log2);
-  const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, log2);
-  const messageDeps = createBridgeMessageDeps({
+    e2ee,
+    onBridgeIdentified,
+    bridgeHeartbeat
+  } = params;
+  return createBridgeMessageDeps({
     getWs,
     log: log2,
     acpManager,
@@ -39690,8 +39795,8 @@ function createBridgeRuntimeMessageSetup(options) {
     previewWorktreeManager,
     onBridgeIdentified,
     bridgeHeartbeat,
-    sendLocalSkillsReport,
-    reportAutoDetectedAgents,
+    sendLocalSkillsReport: createSendLocalSkillsReport(getWs, log2),
+    reportAutoDetectedAgents: createReportAutoDetectedAgents(getWs, log2),
     warmupAgentCapabilitiesOnConnect: createWarmupAgentCapabilitiesOnConnect({
       workspaceId,
       log: log2,
@@ -39707,6 +39812,54 @@ function createBridgeRuntimeMessageSetup(options) {
     cloudApiBaseUrl: apiUrl,
     getCloudAccessToken: () => tokens.accessToken
   });
+}
+
+// src/connection/create-bridge-runtime-message-setup.ts
+function createBridgeRuntimeMessageSetup(options) {
+  const {
+    apiUrl,
+    workspaceId,
+    firehoseServerUrl,
+    state,
+    getWs,
+    log: log2,
+    tokens,
+    acpManager,
+    sessionWorktreeManager,
+    previewWorktreeManager,
+    previewEnvironmentManager,
+    e2ee,
+    identifyReportedPaths
+  } = options;
+  const bridgeHeartbeat = createBridgeIdentifyHeartbeat({
+    getWs,
+    log: log2,
+    identifyReportedPaths,
+    e2ee
+  });
+  const onBridgeIdentified = createBridgeIdentifiedWithHeartbeat({
+    previewEnvironmentManager,
+    firehoseServerUrl,
+    workspaceId,
+    state,
+    log: log2,
+    bridgeHeartbeat
+  });
+  const messageDeps = createBridgeRuntimeMessageDeps({
+    apiUrl,
+    workspaceId,
+    state,
+    getWs,
+    log: log2,
+    tokens,
+    acpManager,
+    sessionWorktreeManager,
+    previewWorktreeManager,
+    previewEnvironmentManager,
+    e2ee,
+    onBridgeIdentified,
+    bridgeHeartbeat
+  });
   return { bridgeHeartbeat, messageDeps };
 }
 
@@ -47143,23 +47296,1353 @@ function createBridgeWorktreeManagers(options) {
   };
 }
 
-// src/connection/create-bridge-connection-runtime.ts
-async function createBridgeConnectionRuntime(options, params) {
-  const { apiUrl, workspaceId } = options;
-  const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
-  const { state, getWs, logFn } = params;
-  const tokens = {
-    accessToken: options.authToken,
-    refreshToken: options.refreshToken
+// src/local-shortcut/lib/generate-token.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+function generateShortcutToken() {
+  return randomBytes3(32).toString("base64url");
+}
+
+// src/local-shortcut/lib/start-server.ts
+import * as http2 from "node:http";
+
+// src/local-shortcut/lib/server.ts
+import { URL as URL2 } from "node:url";
+
+// src/local-shortcut/lib/cors.ts
+var LOCALHOST_ORIGIN_RE = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/;
+var FIXED_ALLOWED_ORIGINS = /* @__PURE__ */ new Set([
+  "https://app.buildautomaton.com",
+  "http://localhost:3000",
+  "http://127.0.0.1:3000"
+]);
+function resolveAllowedCorsOrigin(origin) {
+  if (!origin) return null;
+  if (FIXED_ALLOWED_ORIGINS.has(origin)) return origin;
+  if (LOCALHOST_ORIGIN_RE.test(origin)) return origin;
+  return null;
+}
+function applyCorsHeaders(req, res) {
+  const origin = typeof req.headers.origin === "string" ? req.headers.origin : void 0;
+  const allowed = resolveAllowedCorsOrigin(origin);
+  if (allowed) {
+    res.setHeader("Access-Control-Allow-Origin", allowed);
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+    res.setHeader("Access-Control-Max-Age", "86400");
+  }
+  return allowed != null;
+}
+
+// src/local-shortcut/lib/auth.ts
+function readBearerToken(req) {
+  const raw = req.headers.authorization;
+  if (typeof raw !== "string") return null;
+  const match = /^Bearer\s+(.+)$/i.exec(raw.trim());
+  return match?.[1]?.trim() ? match[1].trim() : null;
+}
+function isAuthorizedShortcutRequest(req, expectedToken) {
+  const token = readBearerToken(req);
+  return Boolean(token && expectedToken && token === expectedToken);
+}
+
+// src/local-shortcut/lib/e2ee/file-browser-fields.ts
+var SHORTCUT_FILE_BROWSER_E2EE_FIELDS = [
+  "entries",
+  "content",
+  "totalLines",
+  "size",
+  "lineOffset"
+];
+
+// src/local-shortcut/lib/e2ee/encrypt-file-browser-body.ts
+function encryptShortcutFileBrowserBody(body, e2ee) {
+  if (!e2ee) return body;
+  const encrypted = e2ee.encryptFields(body, SHORTCUT_FILE_BROWSER_E2EE_FIELDS);
+  if (encrypted.ee != null && typeof encrypted.ee === "object") {
+    return { ee: encrypted.ee };
+  }
+  return body;
+}
+
+// src/local-shortcut/lib/response.ts
+function sendShortcutJson(res, status, body) {
+  if (res.headersSent) return;
+  res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+  res.end(JSON.stringify(body));
+}
+function sendShortcutFileBrowserJson(res, status, body, e2ee) {
+  sendShortcutJson(res, status, encryptShortcutFileBrowserBody(body, e2ee));
+}
+
+// src/local-shortcut/app/api/bridges/local-shortcut/health/route.ts
+async function GET(ctx) {
+  sendShortcutJson(ctx.res, 200, { ok: true });
+}
+
+// src/local-shortcut/app/lib/assert-bridge-workspace.ts
+function assertBridgeWorkspace(ctx) {
+  const reqWorkspaceId = ctx.url.searchParams.get("workspaceId")?.trim() ?? "";
+  if (reqWorkspaceId !== ctx.workspaceId) {
+    sendShortcutJson(ctx.res, 403, { error: "workspaceId mismatch" });
+    return false;
+  }
+  return true;
+}
+
+// src/files/browser/execute-file-browser-list.ts
+init_list_dir();
+
+// src/git/tree/resolve-repo-abs-path.ts
+init_cwd();
+import * as path75 from "node:path";
+function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
+  const bridgeResolved = path75.resolve(bridgeRoot);
+  const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
+  const repoPath = rel === "" ? bridgeResolved : path75.join(bridgeResolved, rel);
+  const resolved = path75.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path75.sep) && resolved !== bridgeResolved) {
+    return null;
+  }
+  return resolved;
+}
+
+// src/git/tree/resolve-branch-commit.ts
+async function resolveBranchCommit(repoAbsPath, branch) {
+  const branchRef = branch.trim();
+  if (!branchRef) return null;
+  try {
+    return (await cliSimpleGit(repoAbsPath).revparse([`${branchRef}^{commit}`])).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/git/tree/list-git-tree-dir.ts
+init_yield_to_event_loop();
+init_types2();
+init_sort_entries();
+function parseLsTreeLine(line) {
+  const tab = line.indexOf("	");
+  if (tab < 0) return null;
+  const meta = line.slice(0, tab).trim().split(/\s+/);
+  if (meta.length < 3) return null;
+  const mode = meta[0];
+  const objectType2 = meta[1];
+  let name = line.slice(tab + 1);
+  if (name.startsWith('"') && name.endsWith('"')) {
+    name = name.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return { mode, objectType: objectType2, name };
+}
+function childPath(relativePath, name) {
+  const base = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!base || base === ".") return name;
+  return `${base}/${name}`.replace(/\\/g, "/");
+}
+function lsTreeArgs(commit, relativePath) {
+  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!rel || rel === ".") return ["ls-tree", commit];
+  return ["ls-tree", `${commit}:${rel}`];
+}
+async function listGitTreeDirAsync(repoAbsPath, branch, relativePath) {
+  await yieldToEventLoop();
+  const commit = await resolveBranchCommit(repoAbsPath, branch);
+  if (!commit) return { error: "Branch not found" };
+  try {
+    const raw = await cliSimpleGit(repoAbsPath).raw(lsTreeArgs(commit, relativePath));
+    await yieldToEventLoop();
+    const lines = String(raw ?? "").split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const entries = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
+        await yieldToEventLoop();
+      }
+      const parsed = parseLsTreeLine(lines[i]);
+      if (!parsed) continue;
+      const { mode, objectType: objectType2, name } = parsed;
+      if (!name || name === "." || name === "..") continue;
+      const isSymlink = mode === "120000";
+      const isDir = objectType2 === "tree";
+      entries.push({
+        name,
+        path: childPath(relativePath, name),
+        isDir,
+        ...isSymlink ? { isSymlink: true } : {}
+      });
+    }
+    if (entries.length >= LIST_DIR_YIELD_EVERY) {
+      await yieldToEventLoop();
+    }
+    return { entries: sortListEntries(entries) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/not a tree object|does not exist|bad revision/i.test(message)) {
+      return { error: "Path not found in branch" };
+    }
+    return { error: message };
+  }
+}
+
+// src/git/tree/file/index.ts
+init_yield_to_event_loop();
+
+// src/files/read-file/types.ts
+var LINE_CHUNK_SIZE = 64 * 1024;
+var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
+
+// src/files/read-file/guess-mime-type.ts
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  json: "application/json",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  ts: "text/typescript",
+  txt: "text/plain",
+  md: "text/markdown",
+  xml: "application/xml",
+  zip: "application/zip",
+  gz: "application/gzip",
+  wasm: "application/wasm"
+};
+function guessMimeType(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+
+// src/git/tree/file/git-blob-ref.ts
+init_yield_to_event_loop();
+async function gitBlobRef(repoAbsPath, branch, relativePath) {
+  const commit = await resolveBranchCommit(repoAbsPath, branch);
+  await yieldToEventLoop();
+  if (!commit) return null;
+  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!rel || rel === ".") return null;
+  return `${commit}:${rel}`;
+}
+
+// src/git/tree/file/is-binary-buffer.ts
+function isBinaryBuffer(buf) {
+  const sample = buf.subarray(0, Math.min(buf.length, 8192));
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0) return true;
+  }
+  return false;
+}
+
+// src/git/tree/file/read-git-blob-text-async.ts
+init_yield_to_event_loop();
+import { StringDecoder } from "node:string_decoder";
+async function countGitBlobLinesAsync(buf) {
+  if (buf.length === 0) return 1;
+  let lines = 1;
+  let bytesSinceYield = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const b = buf[i];
+    if (b === 10) {
+      lines++;
+    } else if (b === 13) {
+      if (i + 1 < buf.length && buf[i + 1] === 10) {
+        lines++;
+        i++;
+      } else {
+        lines++;
+      }
+    }
+    bytesSinceYield++;
+    if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+      await yieldToEventLoop();
+      bytesSinceYield = 0;
+    }
+  }
+  return lines;
+}
+async function readGitBlobLineRangeAsync(buf, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
+  const bufSize = 64 * 1024;
+  const decoder = new StringDecoder("utf8");
+  let currentLine = 0;
+  const resultLines = [];
+  let partial2 = "";
+  let done = false;
+  let skipLine0Chars = typeof lineOffsetIn === "number" ? lineOffsetIn : 0;
+  let line0CharsReturned = 0;
+  let line0Accum = "";
+  let bytesSinceYield = 0;
+  let position = 0;
+  const finish = async () => {
+    const totalLines = await countGitBlobLinesAsync(buf);
+    return { content: resultLines.join("\n"), totalLines };
   };
-  const { worktreesRootPath, sessionWorktreeManager, previewWorktreeManager } = createBridgeWorktreeManagers({ worktreesRootPath: options.worktreesRootPath, log: logFn });
-  const { e2ee, acpManager, bridgeAccessPromise } = await createBridgeAccessAndAcp({
-    apiUrl,
-    workspaceId,
-    tokens,
-    e2eCertificate: options.e2eCertificate,
-    getWs,
-    log: logFn
+  while (!done && position < buf.length) {
+    const chunkEnd = Math.min(position + bufSize, buf.length);
+    const bytesRead = chunkEnd - position;
+    position = chunkEnd;
+    bytesSinceYield += bytesRead;
+    if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+      await yieldToEventLoop();
+      bytesSinceYield = 0;
+    }
+    const text = partial2 + decoder.write(buf.subarray(position - bytesRead, position));
+    partial2 = "";
+    let lineStart = 0;
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === "\n") {
+        const lineContent = (() => {
+          let lineEnd = i;
+          if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
+          return text.slice(lineStart, lineEnd);
+        })();
+        if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0)) {
+          line0Accum += lineContent;
+          const totalLine0 = line0Accum.length;
+          if (skipLine0Chars > 0) {
+            if (totalLine0 <= skipLine0Chars) {
+              skipLine0Chars -= totalLine0;
+              line0Accum = "";
+              currentLine++;
+              lineStart = i + 1;
+              if (currentLine > endLine) {
+                done = true;
+                break;
+              }
+              continue;
+            }
+            const from = skipLine0Chars;
+            const take = Math.min(lineChunkSize, totalLine0 - from);
+            resultLines.push(line0Accum.slice(from, from + take));
+            line0CharsReturned += take;
+            if (from + take < totalLine0) {
+              const totalLines = await countGitBlobLinesAsync(buf);
+              return {
+                content: resultLines.join("\n"),
+                totalLines,
+                lineOffset: lineOffsetIn + line0CharsReturned
+              };
+            }
+            line0Accum = "";
+            skipLine0Chars = 0;
+            line0CharsReturned = 0;
+          } else if (totalLine0 > lineChunkSize) {
+            resultLines.push(line0Accum.slice(0, lineChunkSize));
+            const totalLines = await countGitBlobLinesAsync(buf);
+            return {
+              content: resultLines.join("\n"),
+              totalLines,
+              lineOffset: lineChunkSize
+            };
+          } else {
+            resultLines.push(line0Accum);
+            line0Accum = "";
+          }
+        } else if (currentLine >= startLine && currentLine <= endLine) {
+          resultLines.push(lineContent);
+        }
+        currentLine++;
+        lineStart = i + 1;
+        if (currentLine > endLine) {
+          done = true;
+          break;
+        }
+      }
+    }
+    if (!done) {
+      const lineContent = text.slice(lineStart);
+      if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0)) {
+        line0Accum += lineContent;
+        const totalLine0 = line0Accum.length;
+        if (skipLine0Chars > 0) {
+          if (totalLine0 <= skipLine0Chars) {
+            skipLine0Chars -= totalLine0;
+            line0Accum = "";
+          } else {
+            const from = skipLine0Chars;
+            const take = Math.min(lineChunkSize, totalLine0 - from);
+            resultLines.push(line0Accum.slice(from, from + take));
+            const totalLines = await countGitBlobLinesAsync(buf);
+            return {
+              content: resultLines.join("\n"),
+              totalLines,
+              lineOffset: (lineOffsetIn ?? 0) + take
+            };
+          }
+        } else if (totalLine0 > lineChunkSize) {
+          resultLines.push(line0Accum.slice(0, lineChunkSize));
+          const totalLines = await countGitBlobLinesAsync(buf);
+          return {
+            content: resultLines.join("\n"),
+            totalLines,
+            lineOffset: lineChunkSize
+          };
+        }
+      }
+      partial2 = text.slice(lineStart);
+    }
+  }
+  if (!done) {
+    const tail = partial2 + decoder.end();
+    if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0) && tail.length > 0) {
+      line0Accum += tail.endsWith("\r") ? tail.slice(0, -1) : tail;
+      const totalLine0 = line0Accum.length;
+      if (skipLine0Chars > 0) {
+        if (totalLine0 <= skipLine0Chars) {
+          return finish();
+        }
+        const from = skipLine0Chars;
+        const take = Math.min(lineChunkSize, totalLine0 - from);
+        resultLines.push(line0Accum.slice(from, from + take));
+        line0CharsReturned += take;
+        if (from + take < totalLine0) {
+          const totalLines = await countGitBlobLinesAsync(buf);
+          return {
+            content: resultLines.join("\n"),
+            totalLines,
+            lineOffset: (lineOffsetIn ?? 0) + line0CharsReturned
+          };
+        }
+      } else if (totalLine0 > lineChunkSize) {
+        resultLines.push(line0Accum.slice(0, lineChunkSize));
+        const totalLines = await countGitBlobLinesAsync(buf);
+        return {
+          content: resultLines.join("\n"),
+          totalLines,
+          lineOffset: lineChunkSize
+        };
+      } else {
+        resultLines.push(line0Accum);
+      }
+    } else if (tail.length > 0 && currentLine >= startLine && currentLine <= endLine) {
+      resultLines.push(tail.endsWith("\r") ? tail.slice(0, -1) : tail);
+    }
+  }
+  return finish();
+}
+async function decodeGitBlobUtf8Async(buf) {
+  await yieldToEventLoop();
+  const text = buf.toString("utf8");
+  await yieldToEventLoop();
+  return text;
+}
+async function readGitBlobUtf8FullAsync(buf) {
+  const text = await decodeGitBlobUtf8Async(buf);
+  const totalLines = await countGitBlobLinesAsync(buf);
+  return { content: text, totalLines };
+}
+
+// src/git/tree/file/index.ts
+async function readGitTreeFileAsync(repoAbsPath, branch, relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, encoding = "utf8") {
+  await yieldToEventLoop();
+  const branchRef = branch.trim();
+  if (!branchRef) return { error: "branch required" };
+  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!rel || rel === ".") return { error: "file path required" };
+  const blobRef = await gitBlobRef(repoAbsPath, branchRef, rel);
+  if (!blobRef) return { error: "Branch not found" };
+  const hasRange = typeof startLine === "number" && typeof endLine === "number";
+  try {
+    if (encoding === "base64") {
+      if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
+      const buf2 = await cliSimpleGit(repoAbsPath).showBuffer([blobRef]);
+      await yieldToEventLoop();
+      return {
+        content: buf2.toString("base64"),
+        size: buf2.length,
+        mimeType: guessMimeType(rel)
+      };
+    }
+    const buf = await cliSimpleGit(repoAbsPath).showBuffer([blobRef]);
+    await yieldToEventLoop();
+    const size = buf.length;
+    if (isBinaryBuffer(buf)) {
+      return { error: "Binary file cannot be displayed as text" };
+    }
+    if (hasRange) {
+      const ranged = await readGitBlobLineRangeAsync(buf, startLine, endLine, lineOffset, lineChunkSize);
+      return {
+        content: ranged.content,
+        totalLines: ranged.totalLines,
+        size,
+        ...ranged.lineOffset != null ? { lineOffset: ranged.lineOffset } : {}
+      };
+    }
+    const full = await readGitBlobUtf8FullAsync(buf);
+    return { content: full.content, totalLines: full.totalLines, size, mimeType: guessMimeType(rel) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/does not exist|bad revision|exists on disk, but not in/i.test(message)) {
+      return { error: "File not found in branch" };
+    }
+    return { error: message };
+  }
+}
+
+// src/files/browser/execute-file-browser-list.ts
+async function executeFileBrowserList(params) {
+  const { reqPath, sessionParentPath, gitScope } = params;
+  return gitScope ? await listGitTreeDirAsync(gitScope.repoAbsPath, gitScope.branch, reqPath) : await listDirAsync(reqPath, sessionParentPath);
+}
+
+// src/files/browser/resolve-git-branch-scope.ts
+function resolveGitBranchScope(msg) {
+  const gitBranchScope = msg.source === "git_branch" && typeof msg.repoRelPath === "string" && typeof msg.branch === "string" && msg.branch.trim().length > 0;
+  if (!gitBranchScope) return null;
+  const repoAbsPath = resolveRepoAbsPathFromBridge(msg.repoRelPath);
+  if (!repoAbsPath) return null;
+  return { repoAbsPath, branch: msg.branch.trim() };
+}
+
+// src/local-shortcut/app/lib/file-browser/parse-query.ts
+function parseOptionalInt(raw) {
+  if (raw == null) return void 0;
+  const parsed = parseInt(raw, 10);
+  return Number.isInteger(parsed) ? parsed : void 0;
+}
+function parseGitScopeFromUrl(url2) {
+  const rawSource = url2.searchParams.get("source")?.trim();
+  if (rawSource === "git_branch") {
+    return {
+      source: "git_branch",
+      repoRelPath: url2.searchParams.get("repoRelPath")?.trim() ?? ".",
+      branch: url2.searchParams.get("branch")?.trim() ?? ""
+    };
+  }
+  return { source: "filesystem" };
+}
+function parseReadParams(url2) {
+  const rawEncoding = url2.searchParams.get("encoding");
+  return {
+    startLine: parseOptionalInt(url2.searchParams.get("startLine")),
+    endLine: parseOptionalInt(url2.searchParams.get("endLine")),
+    lineOffset: parseOptionalInt(url2.searchParams.get("lineOffset")),
+    lineChunkSize: parseOptionalInt(url2.searchParams.get("lineChunkSize")),
+    encoding: rawEncoding === "base64" ? "base64" : "utf8"
+  };
+}
+function parseListPath(url2) {
+  return (url2.searchParams.get("path") ?? ".").replace(/^\/+/, "") || ".";
+}
+function parseReadPath(url2) {
+  const raw = url2.searchParams.get("path")?.trim();
+  if (!raw) return null;
+  return raw.replace(/^\/+/, "") || ".";
+}
+
+// src/files/resolve-file-browser-session-parent.ts
+init_normalize_resolved_path();
+init_cwd();
+async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
+  const sid = sessionId?.trim();
+  if (sid) {
+    await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sid);
+    const worktreeRoot = sessionWorktreeManager.getSessionWorktreeRootForSession(sid);
+    if (worktreeRoot) return normalizeResolvedPath(worktreeRoot);
+  }
+  return getBridgeRoot();
+}
+
+// src/local-shortcut/app/lib/file-browser/resolve-session-parent.ts
+async function resolveShortcutSessionParent(ctx, sessionId) {
+  if (!ctx.sessionWorktreeManager || !sessionId?.trim()) return void 0;
+  return resolveFileBrowserSessionParent(ctx.sessionWorktreeManager, sessionId.trim());
+}
+
+// src/local-shortcut/app/lib/file-browser/handle-list.ts
+async function handleShortcutFileBrowserList(ctx, sessionId) {
+  const reqPath = parseListPath(ctx.url);
+  const gitMsg = parseGitScopeFromUrl(ctx.url);
+  const gitScope = resolveGitBranchScope({ id: "shortcut", path: reqPath, ...gitMsg });
+  if (gitMsg.source === "git_branch" && typeof gitMsg.repoRelPath === "string" && typeof gitMsg.branch === "string" && gitMsg.branch.trim().length > 0 && !gitScope) {
+    sendShortcutJson(ctx.res, 400, { error: "Invalid repository path" });
+    return;
+  }
+  const sessionParentPath = await resolveShortcutSessionParent(ctx, sessionId);
+  const result = await executeFileBrowserList({ reqPath, sessionParentPath, gitScope });
+  if ("error" in result) {
+    sendShortcutJson(ctx.res, 400, { error: result.error });
+    return;
+  }
+  sendShortcutFileBrowserJson(ctx.res, 200, { entries: result.entries }, ctx.e2ee);
+}
+
+// src/local-shortcut/app/api/bridges/files/list/route.ts
+async function GET2(ctx) {
+  if (!assertBridgeWorkspace(ctx)) return;
+  await handleShortcutFileBrowserList(ctx);
+}
+
+// src/files/browser/file-browser-read-queue.ts
+var readChain = Promise.resolve();
+function withFileBrowserReadQueue(fn) {
+  const next = readChain.then(() => fn());
+  readChain = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
+
+// src/files/read-file/index.ts
+init_cwd();
+init_yield_to_event_loop();
+import fs53 from "node:fs";
+
+// src/files/read-file/resolve-file-path.ts
+init_ensure_under_cwd();
+init_cwd();
+import fs49 from "node:fs";
+
+// src/files/read-file/resolve-file-cache.ts
+import fs48 from "node:fs";
+import path76 from "node:path";
+var RESOLVE_CACHE_MAX = 4096;
+var resolveCache = /* @__PURE__ */ new Map();
+var warmedDirectories = /* @__PURE__ */ new Set();
+function resolveCacheKey(sessionParentPath, relativePath) {
+  return `${sessionParentPath}\0${relativePath}`;
+}
+function warmedDirectoryKey(sessionParentPath, directoryRelativePath) {
+  const dir = directoryRelativePath.replace(/^\/+/, "") || ".";
+  return `${path76.resolve(sessionParentPath)}\0${dir}`;
+}
+function pathStaysUnderParent(filePath, sessionParentPath) {
+  const parent = path76.resolve(sessionParentPath);
+  const resolved = path76.resolve(filePath);
+  return resolved === parent || resolved.startsWith(`${parent}${path76.sep}`);
+}
+async function statMatchesCache(entry) {
+  try {
+    const stat3 = await fs48.promises.stat(entry.path);
+    return stat3.isFile() && stat3.mtimeMs === entry.mtimeMs && stat3.size === entry.size;
+  } catch {
+    return false;
+  }
+}
+function getResolveCacheEntry(cacheKey) {
+  return resolveCache.get(cacheKey);
+}
+function deleteResolveCacheEntry(cacheKey) {
+  resolveCache.delete(cacheKey);
+}
+function storeResolveCacheEntry(cacheKey, entry) {
+  if (resolveCache.size >= RESOLVE_CACHE_MAX) resolveCache.clear();
+  resolveCache.set(cacheKey, entry);
+  return entry;
+}
+function hasResolveCacheEntry(cacheKey) {
+  return resolveCache.has(cacheKey);
+}
+function markDirectoryWarmed(dirKey) {
+  if (warmedDirectories.has(dirKey)) return false;
+  warmedDirectories.add(dirKey);
+  return true;
+}
+function unmarkDirectoryWarmed(dirKey) {
+  warmedDirectories.delete(dirKey);
+}
+
+// src/files/read-file/resolve-file-path.ts
+async function resolveFileForReadAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  const cacheKey = resolveCacheKey(sessionParentPath, relativePath);
+  const cached2 = getResolveCacheEntry(cacheKey);
+  if (cached2 != null && await statMatchesCache(cached2)) {
+    return { path: cached2.path, size: cached2.size };
+  }
+  if (cached2 != null) deleteResolveCacheEntry(cacheKey);
+  const resolved = ensureUnderCwd(relativePath, sessionParentPath);
+  if (!resolved) return { error: "Path is outside working directory" };
+  let real;
+  let size;
+  let mtimeMs;
+  try {
+    const lstat = await fs49.promises.lstat(resolved);
+    if (lstat.isSymbolicLink()) {
+      real = await fs49.promises.realpath(resolved);
+      if (!pathStaysUnderParent(real, sessionParentPath)) {
+        return { error: "Path is outside working directory" };
+      }
+      const stat3 = await fs49.promises.stat(real);
+      if (!stat3.isFile()) return { error: "Not a file" };
+      size = stat3.size;
+      mtimeMs = stat3.mtimeMs;
+    } else if (lstat.isFile()) {
+      real = resolved;
+      size = lstat.size;
+      mtimeMs = lstat.mtimeMs;
+    } else {
+      return { error: "Not a file" };
+    }
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  const entry = storeResolveCacheEntry(cacheKey, { path: real, size, mtimeMs });
+  return { path: entry.path, size: entry.size };
+}
+async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  const result = await resolveFileForReadAsync(relativePath, sessionParentPath);
+  if ("error" in result) return result;
+  return result.path;
+}
+
+// src/files/read-file/read-file-range-async.ts
+init_yield_to_event_loop();
+import fs50 from "node:fs";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+
+// src/files/read-file/read-file-range-line-zero.ts
+function createLineZeroStreamState(lineOffsetIn) {
+  return {
+    line0Accum: "",
+    skipLine0Chars: typeof lineOffsetIn === "number" ? lineOffsetIn : 0,
+    line0CharsReturned: 0
+  };
+}
+function shouldTrackLineZero(startLine, lineOffsetIn) {
+  return startLine === 0 || lineOffsetIn !== void 0;
+}
+function stripCarriageReturn(lineContent) {
+  return lineContent.endsWith("\r") ? lineContent.slice(0, -1) : lineContent;
+}
+function lineContentBeforeNewline(text, lineStart, newlineIndex) {
+  let lineEnd = newlineIndex;
+  if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
+  return text.slice(lineStart, lineEnd);
+}
+function buildLineZeroChunkResult(resultLines, fileSize, lineOffset, totalLines = 1) {
+  return {
+    content: resultLines.join("\n"),
+    size: fileSize,
+    lineOffset,
+    totalLines
+  };
+}
+function tryFinishLineZeroOnCompleteLine(state, lineContent, resultLines, fileSize, lineChunkSize, lineOffsetIn, endLine, currentLine) {
+  state.line0Accum += lineContent;
+  const totalLine0 = state.line0Accum.length;
+  if (state.skipLine0Chars > 0) {
+    if (totalLine0 <= state.skipLine0Chars) {
+      state.skipLine0Chars -= totalLine0;
+      state.line0Accum = "";
+      return currentLine + 1 > endLine ? "done" : "continue";
+    }
+    const from = state.skipLine0Chars;
+    const take = Math.min(lineChunkSize, totalLine0 - from);
+    resultLines.push(state.line0Accum.slice(from, from + take));
+    state.line0CharsReturned += take;
+    if (from + take < totalLine0) {
+      return buildLineZeroChunkResult(
+        resultLines,
+        fileSize,
+        (lineOffsetIn ?? 0) + state.line0CharsReturned
+      );
+    }
+    state.line0Accum = "";
+    state.skipLine0Chars = 0;
+    state.line0CharsReturned = 0;
+    return "continue";
+  }
+  if (totalLine0 > lineChunkSize) {
+    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
+    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
+  }
+  resultLines.push(state.line0Accum);
+  state.line0Accum = "";
+  return "continue";
+}
+function tryFinishLineZeroPartial(state, partialLine, resultLines, fileSize, lineChunkSize, lineOffsetIn) {
+  state.line0Accum += partialLine;
+  const totalLine0 = state.line0Accum.length;
+  if (state.skipLine0Chars > 0) {
+    if (totalLine0 <= state.skipLine0Chars) {
+      state.skipLine0Chars -= totalLine0;
+      state.line0Accum = "";
+      return null;
+    }
+    const from = state.skipLine0Chars;
+    const take = Math.min(lineChunkSize, totalLine0 - from);
+    resultLines.push(state.line0Accum.slice(from, from + take));
+    return buildLineZeroChunkResult(resultLines, fileSize, (lineOffsetIn ?? 0) + take);
+  }
+  if (totalLine0 > lineChunkSize) {
+    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
+    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
+  }
+  return null;
+}
+function finishLineZeroTail(state, tail, resultLines, fileSize, lineChunkSize, lineOffsetIn) {
+  if (tail.length === 0) return null;
+  state.line0Accum += stripCarriageReturn(tail);
+  const totalLine0 = state.line0Accum.length;
+  if (state.skipLine0Chars > 0) {
+    if (totalLine0 <= state.skipLine0Chars) {
+      return { content: resultLines.join("\n"), size: fileSize };
+    }
+    const from = state.skipLine0Chars;
+    const take = Math.min(lineChunkSize, totalLine0 - from);
+    resultLines.push(state.line0Accum.slice(from, from + take));
+    state.line0CharsReturned += take;
+    if (from + take < totalLine0) {
+      return buildLineZeroChunkResult(
+        resultLines,
+        fileSize,
+        (lineOffsetIn ?? 0) + state.line0CharsReturned
+      );
+    }
+    return null;
+  }
+  if (totalLine0 > lineChunkSize) {
+    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
+    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
+  }
+  resultLines.push(state.line0Accum);
+  return null;
+}
+
+// src/files/read-file/read-file-range-async.ts
+async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE, fileSizeIn) {
+  const fileSize = fileSizeIn ?? (await fs50.promises.stat(filePath)).size;
+  const fd = await fs50.promises.open(filePath, "r");
+  const bufSize = 64 * 1024;
+  const buf = Buffer.alloc(bufSize);
+  const decoder = new StringDecoder2("utf8");
+  let currentLine = 0;
+  const resultLines = [];
+  let partial2 = "";
+  let done = false;
+  const trackLineZero = shouldTrackLineZero(startLine, lineOffsetIn);
+  const lineZeroState = createLineZeroStreamState(lineOffsetIn);
+  let bytesSinceYield = 0;
+  try {
+    let position = 0;
+    while (!done) {
+      const { bytesRead } = await fd.read(buf, 0, bufSize, position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      bytesSinceYield += bytesRead;
+      if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+        await yieldToEventLoop();
+        bytesSinceYield = 0;
+      }
+      const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
+      partial2 = "";
+      let lineStart = 0;
+      for (let i = 0; i < text.length; i++) {
+        if (text[i] !== "\n") continue;
+        const lineContent2 = lineContentBeforeNewline(text, lineStart, i);
+        if (currentLine === 0 && trackLineZero) {
+          const lineZeroResult = tryFinishLineZeroOnCompleteLine(
+            lineZeroState,
+            lineContent2,
+            resultLines,
+            fileSize,
+            lineChunkSize,
+            lineOffsetIn,
+            endLine,
+            currentLine
+          );
+          if (lineZeroResult === "done") {
+            done = true;
+            break;
+          }
+          if (lineZeroResult !== "continue") return lineZeroResult;
+          currentLine++;
+          lineStart = i + 1;
+          if (currentLine > endLine) {
+            done = true;
+            break;
+          }
+          continue;
+        }
+        if (currentLine >= startLine && currentLine <= endLine) {
+          resultLines.push(lineContent2);
+        }
+        currentLine++;
+        lineStart = i + 1;
+        if (currentLine > endLine) {
+          done = true;
+          break;
+        }
+      }
+      if (done) continue;
+      const lineContent = text.slice(lineStart);
+      if (currentLine === 0 && trackLineZero) {
+        const partialResult = tryFinishLineZeroPartial(
+          lineZeroState,
+          lineContent,
+          resultLines,
+          fileSize,
+          lineChunkSize,
+          lineOffsetIn
+        );
+        if (partialResult != null) return partialResult;
+      } else {
+        partial2 = lineContent;
+      }
+    }
+    if (!done) {
+      const tail = partial2 + decoder.end();
+      if (currentLine === 0 && trackLineZero) {
+        const tailResult = finishLineZeroTail(
+          lineZeroState,
+          tail,
+          resultLines,
+          fileSize,
+          lineChunkSize,
+          lineOffsetIn
+        );
+        if (tailResult != null) return tailResult;
+      } else if (tail.length > 0 && currentLine >= startLine && currentLine <= endLine) {
+        resultLines.push(tail.endsWith("\r") ? tail.slice(0, -1) : tail);
+      }
+    }
+    return { content: resultLines.join("\n"), size: fileSize };
+  } finally {
+    await fd.close();
+  }
+}
+
+// src/files/read-file/read-small-file-range-async.ts
+import fs51 from "node:fs";
+var SMALL_FILE_RANGE_MAX_BYTES = 512 * 1024;
+function sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize) {
+  if (startLine === 0 && lineOffsetIn == null && lines[0] != null && lines[0].length > lineChunkSize) {
+    return {
+      content: lines[0].slice(0, lineChunkSize),
+      size: fileSize,
+      lineOffset: lineChunkSize,
+      totalLines: lines.length
+    };
+  }
+  if (startLine === 0 && typeof lineOffsetIn === "number") {
+    const line0 = lines[0] ?? "";
+    const from = lineOffsetIn;
+    const take = Math.min(lineChunkSize, Math.max(0, line0.length - from));
+    return {
+      content: line0.slice(from, from + take),
+      size: fileSize,
+      ...from + take < line0.length ? { lineOffset: from + take, totalLines: lines.length } : { totalLines: lines.length }
+    };
+  }
+  const slice = lines.slice(startLine, endLine + 1);
+  return {
+    content: slice.join("\n"),
+    size: fileSize,
+    totalLines: lines.length
+  };
+}
+async function readSmallFileRangeAsync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
+  const raw = await fs51.promises.readFile(filePath, "utf8");
+  const lines = raw.split(/\r?\n/);
+  return sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize);
+}
+
+// src/files/read-file/read-file-buffer-full-async.ts
+init_yield_to_event_loop();
+import fs52 from "node:fs";
+var READ_CHUNK_BYTES = 256 * 1024;
+async function readFileBufferFullAsync(filePath) {
+  const stat3 = await fs52.promises.stat(filePath);
+  const fd = await fs52.promises.open(filePath, "r");
+  const chunks = [];
+  let position = 0;
+  let bytesSinceYield = 0;
+  try {
+    while (position < stat3.size) {
+      const buf = Buffer.alloc(Math.min(READ_CHUNK_BYTES, stat3.size - position));
+      const { bytesRead } = await fd.read(buf, 0, buf.length, position);
+      if (bytesRead === 0) break;
+      chunks.push(buf.subarray(0, bytesRead));
+      position += bytesRead;
+      bytesSinceYield += bytesRead;
+      if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+        await yieldToEventLoop();
+        bytesSinceYield = 0;
+      }
+    }
+  } finally {
+    await fd.close();
+  }
+  return { buffer: Buffer.concat(chunks), size: stat3.size };
+}
+
+// src/files/read-file/read-file-full-async.ts
+async function readFileFullAsync(filePath) {
+  const { buffer, size } = await readFileBufferFullAsync(filePath);
+  const raw = buffer.toString("utf8");
+  const lines = raw.split(/\r?\n/);
+  return { content: raw, totalLines: lines.length, size };
+}
+
+// src/files/read-file/read-file-binary-full-async.ts
+async function readFileBinaryFullAsync(filePath) {
+  const { buffer, size } = await readFileBufferFullAsync(filePath);
+  return {
+    content: buffer.toString("base64"),
+    size,
+    mimeType: guessMimeType(filePath)
+  };
+}
+
+// src/files/read-file/index.ts
+async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, sessionParentPath = getBridgeRoot(), encoding = "utf8", options) {
+  if (!options?.skipInitialYield) {
+    await yieldToEventLoop();
+  }
+  try {
+    let resolvedPath;
+    let fileSize;
+    if (options?.useResolvedSize) {
+      const resolved = await resolveFileForReadAsync(relativePath, sessionParentPath);
+      if ("error" in resolved) return resolved;
+      resolvedPath = resolved.path;
+      fileSize = resolved.size;
+    } else {
+      const result = await resolveFilePathAsync(relativePath, sessionParentPath);
+      if (typeof result === "object") return result;
+      resolvedPath = result;
+    }
+    const hasRange = typeof startLine === "number" && typeof endLine === "number";
+    if (encoding === "base64") {
+      if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
+      const read2 = await readFileBinaryFullAsync(resolvedPath);
+      return { ...read2, resolvedPath };
+    }
+    if (hasRange) {
+      if (fileSize == null) {
+        const stat3 = await fs53.promises.stat(resolvedPath);
+        fileSize = stat3.size;
+      }
+      const read2 = fileSize <= SMALL_FILE_RANGE_MAX_BYTES ? await readSmallFileRangeAsync(
+        resolvedPath,
+        fileSize,
+        startLine,
+        endLine,
+        lineOffset,
+        lineChunkSize
+      ) : await readFileRangeAsync(
+        resolvedPath,
+        startLine,
+        endLine,
+        lineOffset,
+        lineChunkSize,
+        fileSize
+      );
+      return read2;
+    }
+    const read = await readFileFullAsync(resolvedPath);
+    return { ...read, resolvedPath };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/files/browser/execute-file-browser-read.ts
+async function executeFileBrowserRead(params) {
+  const { msg, reqPath, sessionParentPath, gitScope } = params;
+  const startLine = typeof msg.startLine === "number" ? msg.startLine : void 0;
+  const endLine = typeof msg.endLine === "number" ? msg.endLine : void 0;
+  const lineOffset = typeof msg.lineOffset === "number" ? msg.lineOffset : void 0;
+  const lineChunkSize = typeof msg.lineChunkSize === "number" ? msg.lineChunkSize : void 0;
+  const encoding = msg.encoding === "base64" ? "base64" : "utf8";
+  return gitScope ? await readGitTreeFileAsync(
+    gitScope.repoAbsPath,
+    gitScope.branch,
+    reqPath,
+    startLine,
+    endLine,
+    lineOffset,
+    lineChunkSize,
+    encoding
+  ) : await withFileBrowserReadQueue(
+    () => readFileAsync(
+      reqPath,
+      startLine,
+      endLine,
+      lineOffset,
+      lineChunkSize,
+      sessionParentPath,
+      encoding,
+      { skipInitialYield: true, useResolvedSize: true }
+    )
+  );
+}
+
+// src/local-shortcut/app/lib/file-browser/handle-read.ts
+async function handleShortcutFileBrowserRead(ctx, sessionId) {
+  const reqPath = parseReadPath(ctx.url);
+  if (reqPath == null) {
+    sendShortcutJson(ctx.res, 400, { error: "path required" });
+    return;
+  }
+  const gitMsg = parseGitScopeFromUrl(ctx.url);
+  const gitScope = resolveGitBranchScope({ id: "shortcut", path: reqPath, ...gitMsg });
+  if (gitMsg.source === "git_branch" && typeof gitMsg.repoRelPath === "string" && typeof gitMsg.branch === "string" && gitMsg.branch.trim().length > 0 && !gitScope) {
+    sendShortcutJson(ctx.res, 400, { error: "Invalid repository path" });
+    return;
+  }
+  const sessionParentPath = await resolveShortcutSessionParent(ctx, sessionId);
+  const result = await executeFileBrowserRead({
+    msg: parseReadParams(ctx.url),
+    reqPath,
+    sessionParentPath,
+    gitScope
+  });
+  if ("error" in result) {
+    sendShortcutJson(ctx.res, 400, { error: result.error });
+    return;
+  }
+  const body = { content: result.content };
+  if (result.totalLines != null) body.totalLines = result.totalLines;
+  if (result.size != null) body.size = result.size;
+  if (result.lineOffset != null) body.lineOffset = result.lineOffset;
+  if (result.mimeType != null) body.mimeType = result.mimeType;
+  if (result.resolvedPath != null) body.resolvedPath = result.resolvedPath;
+  sendShortcutFileBrowserJson(ctx.res, 200, body, ctx.e2ee);
+}
+
+// src/local-shortcut/app/api/bridges/files/read/route.ts
+async function GET3(ctx) {
+  if (!assertBridgeWorkspace(ctx)) return;
+  await handleShortcutFileBrowserRead(ctx);
+}
+
+// src/local-shortcut/app/api/sessions/[sessionId]/files/list/route.ts
+async function GET4(ctx) {
+  await handleShortcutFileBrowserList(ctx, ctx.params.sessionId);
+}
+
+// src/local-shortcut/app/api/sessions/[sessionId]/files/read/route.ts
+async function GET5(ctx) {
+  await handleShortcutFileBrowserRead(ctx, ctx.params.sessionId);
+}
+
+// src/local-shortcut/lib/router.ts
+var routes = [];
+function segmentsFromAppPath(appPath) {
+  const paramNames = [];
+  const segments = appPath.split("/").filter(Boolean).map((seg) => {
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      const name = seg.slice(1, -1);
+      paramNames.push(name);
+      return `:${name}`;
+    }
+    return seg;
+  });
+  return { segments, paramNames };
+}
+function addAppRoute(method, appPath, handler) {
+  const { segments, paramNames } = segmentsFromAppPath(appPath);
+  routes.push({ method, segments, paramNames, handler });
+}
+addAppRoute("GET", "api/bridges/local-shortcut/health", GET);
+addAppRoute("GET", "api/bridges/files/list", GET2);
+addAppRoute("GET", "api/bridges/files/read", GET3);
+addAppRoute("GET", "api/sessions/[sessionId]/files/list", GET4);
+addAppRoute("GET", "api/sessions/[sessionId]/files/read", GET5);
+function matchShortcutRoute(pathname, method) {
+  const pathSegments = pathname.split("/").filter(Boolean);
+  for (const route of routes) {
+    if (route.method !== method) continue;
+    if (pathSegments.length !== route.segments.length) continue;
+    const params = {};
+    let matched = true;
+    for (let i = 0; i < route.segments.length; i++) {
+      const seg = route.segments[i];
+      const value = pathSegments[i];
+      if (seg.startsWith(":")) {
+        params[seg.slice(1)] = decodeURIComponent(value);
+      } else if (seg !== value) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) return { params, handler: route.handler };
+  }
+  return null;
+}
+
+// src/local-shortcut/lib/server.ts
+function shortcutErrorMessage(err) {
+  return err instanceof Error ? err.message : "Internal shortcut server error";
+}
+function createLocalShortcutRequestHandler(ctx) {
+  return (req, res) => {
+    void (async () => {
+      try {
+        const corsOk = applyCorsHeaders(req, res);
+        if (req.method === "OPTIONS") {
+          res.writeHead(corsOk ? 204 : 403);
+          res.end();
+          return;
+        }
+        if (!corsOk) {
+          sendShortcutJson(res, 403, { error: "Origin not allowed" });
+          return;
+        }
+        if (req.method !== "GET") {
+          sendShortcutJson(res, 405, { error: "Method not allowed" });
+          return;
+        }
+        if (!isAuthorizedShortcutRequest(req, ctx.token)) {
+          sendShortcutJson(res, 401, { error: "Unauthorized" });
+          return;
+        }
+        const rawUrl = req.url ?? "/";
+        const qIndex = rawUrl.indexOf("?");
+        const pathname = qIndex >= 0 ? rawUrl.slice(0, qIndex) : rawUrl;
+        const search = qIndex >= 0 ? rawUrl.slice(qIndex) : "";
+        const url2 = new URL2(search || "", "http://local");
+        const match = matchShortcutRoute(pathname, req.method);
+        if (!match) {
+          sendShortcutJson(res, 404, { error: "Not found" });
+          return;
+        }
+        const handlerCtx = {
+          req,
+          res,
+          params: match.params,
+          url: url2,
+          workspaceId: ctx.workspaceId,
+          sessionWorktreeManager: ctx.sessionWorktreeManager,
+          e2ee: ctx.e2ee
+        };
+        await match.handler(handlerCtx);
+      } catch (err) {
+        if (!res.headersSent) {
+          sendShortcutJson(res, 500, { error: shortcutErrorMessage(err) });
+        }
+      }
+    })().catch((err) => {
+      if (!res.headersSent) {
+        sendShortcutJson(res, 500, { error: shortcutErrorMessage(err) });
+      }
+    });
+  };
+}
+
+// src/local-shortcut/lib/start-server.ts
+var RESTART_DELAY_MS = 250;
+var MAX_RESTART_ATTEMPTS = 5;
+function listenOnPort(server, port) {
+  return new Promise((resolve37, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Local shortcut server did not bind"));
+        return;
+      }
+      resolve37(addr.port);
+    });
+  });
+}
+function closeServer(server) {
+  if (!server) return Promise.resolve();
+  return new Promise((resolve37, reject) => {
+    server.close((err) => err ? reject(err) : resolve37());
+  });
+}
+function delay2(ms) {
+  return new Promise((resolve37) => setTimeout(resolve37, ms));
+}
+function startLocalShortcutServer(ctx) {
+  let closed = false;
+  let restartAttempts = 0;
+  let currentServer = null;
+  let boundPort = null;
+  let restarting = null;
+  async function bindServer(port) {
+    const server = http2.createServer(createLocalShortcutRequestHandler(ctx));
+    server.on("error", (err) => {
+      void restartAfterError(err);
+    });
+    currentServer = server;
+    const listenPort = await listenOnPort(server, port);
+    boundPort = listenPort;
+    return listenPort;
+  }
+  async function restartAfterError(_reason) {
+    if (closed || restarting) return;
+    if (restartAttempts >= MAX_RESTART_ATTEMPTS) return;
+    restartAttempts += 1;
+    restarting = (async () => {
+      await closeServer(currentServer).catch(() => {
+      });
+      currentServer = null;
+      if (closed) return;
+      await delay2(RESTART_DELAY_MS);
+      if (closed) return;
+      try {
+        await bindServer(boundPort ?? 0);
+        restartAttempts = 0;
+      } catch {
+      }
+    })().finally(() => {
+      restarting = null;
+    });
+    await restarting;
+  }
+  return bindServer(0).then((port) => ({
+    port,
+    token: ctx.token,
+    close: async () => {
+      closed = true;
+      await closeServer(currentServer);
+      currentServer = null;
+    }
+  }));
+}
+
+// src/local-shortcut/lib/create.ts
+async function createLocalShortcut(params) {
+  const token = generateShortcutToken();
+  const handle = await startLocalShortcutServer({
+    workspaceId: params.workspaceId,
+    token,
+    sessionWorktreeManager: params.sessionWorktreeManager,
+    e2ee: params.e2ee
+  });
+  return {
+    handle,
+    identify: {
+      localShortcutPort: handle.port,
+      localShortcutToken: handle.token
+    }
+  };
+}
+
+// src/connection/create-bridge-connection-runtime.ts
+async function createBridgeConnectionRuntime(options, params) {
+  const { apiUrl, workspaceId } = options;
+  const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
+  const { state, getWs, logFn } = params;
+  const tokens = {
+    accessToken: options.authToken,
+    refreshToken: options.refreshToken
+  };
+  const { worktreesRootPath, sessionWorktreeManager, previewWorktreeManager } = createBridgeWorktreeManagers({ worktreesRootPath: options.worktreesRootPath, log: logFn });
+  const { e2ee, acpManager, bridgeAccessPromise } = await createBridgeAccessAndAcp({
+    apiUrl,
+    workspaceId,
+    tokens,
+    e2eCertificate: options.e2eCertificate,
+    getWs,
+    log: logFn
+  });
+  const localShortcut = await createLocalShortcut({
+    workspaceId,
+    sessionWorktreeManager,
+    e2ee
   });
   logFn("CLI running. Press Ctrl+C to exit.");
   const { previewEnvironmentManager, scheduleInitialIndexBuildsOnce, identifyReportedPaths } = createBridgePreviewStack({
@@ -47169,6 +48652,7 @@ async function createBridgeConnectionRuntime(options, params) {
     previewWorktreeManager,
     worktreesRootPath
   });
+  Object.assign(identifyReportedPaths, localShortcut.identify);
   const { bridgeHeartbeat, messageDeps } = createBridgeRuntimeMessageSetup({
     apiUrl,
     workspaceId,
@@ -47181,7 +48665,8 @@ async function createBridgeConnectionRuntime(options, params) {
     sessionWorktreeManager,
     previewWorktreeManager,
     previewEnvironmentManager,
-    e2ee
+    e2ee,
+    identifyReportedPaths
   });
   return {
     state,
@@ -47195,7 +48680,8 @@ async function createBridgeConnectionRuntime(options, params) {
     messageDeps,
     identifyReportedPaths,
     scheduleInitialIndexBuildsOnce,
-    e2ee
+    e2ee,
+    localShortcutPromise: Promise.resolve(localShortcut.handle)
   };
 }
 
@@ -47484,15 +48970,15 @@ function syncRunningTurnQueueKeys(turns, queueKey) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs47 from "node:fs";
+import fs55 from "node:fs";
 
 // src/git/snapshot/capture.ts
-import * as fs46 from "node:fs";
-import * as path73 from "node:path";
+import * as fs54 from "node:fs";
+import * as path77 from "node:path";
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path73.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path77.resolve(p)))];
     return uniq;
   }
   try {
@@ -47500,7 +48986,7 @@ async function resolveSnapshotRepoRoots(options) {
     const mapped = repos.map((r) => r.absolutePath);
     const sid = sessionId?.trim();
     if (sid) {
-      const filtered = mapped.filter((root) => path73.basename(root) === sid);
+      const filtered = mapped.filter((root) => path77.basename(root) === sid);
       if (filtered.length > 0) return filtered;
     }
     return mapped;
@@ -47522,7 +49008,7 @@ async function capturePreTurnSnapshot(options) {
   });
   const dir = snapshotsDirForCwd(agentCwd);
   try {
-    fs46.mkdirSync(dir, { recursive: true });
+    fs54.mkdirSync(dir, { recursive: true });
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -47531,9 +49017,9 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path73.join(dir, `${runId}.json`);
+  const filePath = path77.join(dir, `${runId}.json`);
   try {
-    fs46.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    fs54.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -47546,7 +49032,7 @@ async function capturePreTurnSnapshot(options) {
 async function applyPreTurnSnapshot(filePath, log2) {
   let data;
   try {
-    const raw = fs46.readFileSync(filePath, "utf8");
+    const raw = fs54.readFileSync(filePath, "utf8");
     data = JSON.parse(raw);
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
@@ -47587,7 +49073,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs47.promises.access(file2, fs47.constants.F_OK);
+    await fs55.promises.access(file2, fs55.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -48174,416 +49660,6 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
   );
 };
 
-// src/files/resolve-file-browser-session-parent.ts
-init_normalize_resolved_path();
-init_cwd();
-async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
-  const sid = sessionId?.trim();
-  if (sid) {
-    await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sid);
-    const worktreeRoot = sessionWorktreeManager.getSessionWorktreeRootForSession(sid);
-    if (worktreeRoot) return normalizeResolvedPath(worktreeRoot);
-  }
-  return getBridgeRoot();
-}
-
-// src/files/browser/handle-file-browser-list.ts
-init_list_dir();
-
-// src/git/tree/resolve-repo-abs-path.ts
-init_cwd();
-import * as path76 from "node:path";
-function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path76.resolve(bridgeRoot);
-  const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path76.join(bridgeResolved, rel);
-  const resolved = path76.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path76.sep) && resolved !== bridgeResolved) {
-    return null;
-  }
-  return resolved;
-}
-
-// src/git/tree/resolve-branch-commit.ts
-async function resolveBranchCommit(repoAbsPath, branch) {
-  const branchRef = branch.trim();
-  if (!branchRef) return null;
-  try {
-    return (await cliSimpleGit(repoAbsPath).revparse([`${branchRef}^{commit}`])).trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/git/tree/list-git-tree-dir.ts
-init_yield_to_event_loop();
-init_types2();
-init_sort_entries();
-function parseLsTreeLine(line) {
-  const tab = line.indexOf("	");
-  if (tab < 0) return null;
-  const meta = line.slice(0, tab).trim().split(/\s+/);
-  if (meta.length < 3) return null;
-  const mode = meta[0];
-  const objectType2 = meta[1];
-  let name = line.slice(tab + 1);
-  if (name.startsWith('"') && name.endsWith('"')) {
-    name = name.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-  }
-  return { mode, objectType: objectType2, name };
-}
-function childPath(relativePath, name) {
-  const base = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
-  if (!base || base === ".") return name;
-  return `${base}/${name}`.replace(/\\/g, "/");
-}
-function lsTreeArgs(commit, relativePath) {
-  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
-  if (!rel || rel === ".") return ["ls-tree", commit];
-  return ["ls-tree", `${commit}:${rel}`];
-}
-async function listGitTreeDirAsync(repoAbsPath, branch, relativePath) {
-  await yieldToEventLoop();
-  const commit = await resolveBranchCommit(repoAbsPath, branch);
-  if (!commit) return { error: "Branch not found" };
-  try {
-    const raw = await cliSimpleGit(repoAbsPath).raw(lsTreeArgs(commit, relativePath));
-    await yieldToEventLoop();
-    const lines = String(raw ?? "").split(/\r?\n/).filter((line) => line.trim().length > 0);
-    const entries = [];
-    for (let i = 0; i < lines.length; i++) {
-      if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
-        await yieldToEventLoop();
-      }
-      const parsed = parseLsTreeLine(lines[i]);
-      if (!parsed) continue;
-      const { mode, objectType: objectType2, name } = parsed;
-      if (!name || name === "." || name === "..") continue;
-      const isSymlink = mode === "120000";
-      const isDir = objectType2 === "tree";
-      entries.push({
-        name,
-        path: childPath(relativePath, name),
-        isDir,
-        ...isSymlink ? { isSymlink: true } : {}
-      });
-    }
-    if (entries.length >= LIST_DIR_YIELD_EVERY) {
-      await yieldToEventLoop();
-    }
-    return { entries: sortListEntries(entries) };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (/not a tree object|does not exist|bad revision/i.test(message)) {
-      return { error: "Path not found in branch" };
-    }
-    return { error: message };
-  }
-}
-
-// src/git/tree/file/index.ts
-init_yield_to_event_loop();
-
-// src/files/read-file/types.ts
-var LINE_CHUNK_SIZE = 64 * 1024;
-var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
-
-// src/files/read-file/guess-mime-type.ts
-var MIME_BY_EXT = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  bmp: "image/bmp",
-  ico: "image/x-icon",
-  webp: "image/webp",
-  avif: "image/avif",
-  svg: "image/svg+xml",
-  pdf: "application/pdf",
-  json: "application/json",
-  html: "text/html",
-  htm: "text/html",
-  css: "text/css",
-  js: "text/javascript",
-  mjs: "text/javascript",
-  ts: "text/typescript",
-  txt: "text/plain",
-  md: "text/markdown",
-  xml: "application/xml",
-  zip: "application/zip",
-  gz: "application/gzip",
-  wasm: "application/wasm"
-};
-function guessMimeType(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
-  return MIME_BY_EXT[ext] ?? "application/octet-stream";
-}
-
-// src/git/tree/file/git-blob-ref.ts
-init_yield_to_event_loop();
-async function gitBlobRef(repoAbsPath, branch, relativePath) {
-  const commit = await resolveBranchCommit(repoAbsPath, branch);
-  await yieldToEventLoop();
-  if (!commit) return null;
-  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
-  if (!rel || rel === ".") return null;
-  return `${commit}:${rel}`;
-}
-
-// src/git/tree/file/is-binary-buffer.ts
-function isBinaryBuffer(buf) {
-  const sample = buf.subarray(0, Math.min(buf.length, 8192));
-  for (let i = 0; i < sample.length; i++) {
-    if (sample[i] === 0) return true;
-  }
-  return false;
-}
-
-// src/git/tree/file/read-git-blob-text-async.ts
-init_yield_to_event_loop();
-import { StringDecoder } from "node:string_decoder";
-async function countGitBlobLinesAsync(buf) {
-  if (buf.length === 0) return 1;
-  let lines = 1;
-  let bytesSinceYield = 0;
-  for (let i = 0; i < buf.length; i++) {
-    const b = buf[i];
-    if (b === 10) {
-      lines++;
-    } else if (b === 13) {
-      if (i + 1 < buf.length && buf[i + 1] === 10) {
-        lines++;
-        i++;
-      } else {
-        lines++;
-      }
-    }
-    bytesSinceYield++;
-    if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
-      await yieldToEventLoop();
-      bytesSinceYield = 0;
-    }
-  }
-  return lines;
-}
-async function readGitBlobLineRangeAsync(buf, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const bufSize = 64 * 1024;
-  const decoder = new StringDecoder("utf8");
-  let currentLine = 0;
-  const resultLines = [];
-  let partial2 = "";
-  let done = false;
-  let skipLine0Chars = typeof lineOffsetIn === "number" ? lineOffsetIn : 0;
-  let line0CharsReturned = 0;
-  let line0Accum = "";
-  let bytesSinceYield = 0;
-  let position = 0;
-  const finish = async () => {
-    const totalLines = await countGitBlobLinesAsync(buf);
-    return { content: resultLines.join("\n"), totalLines };
-  };
-  while (!done && position < buf.length) {
-    const chunkEnd = Math.min(position + bufSize, buf.length);
-    const bytesRead = chunkEnd - position;
-    position = chunkEnd;
-    bytesSinceYield += bytesRead;
-    if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
-      await yieldToEventLoop();
-      bytesSinceYield = 0;
-    }
-    const text = partial2 + decoder.write(buf.subarray(position - bytesRead, position));
-    partial2 = "";
-    let lineStart = 0;
-    for (let i = 0; i < text.length; i++) {
-      if (text[i] === "\n") {
-        const lineContent = (() => {
-          let lineEnd = i;
-          if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
-          return text.slice(lineStart, lineEnd);
-        })();
-        if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0)) {
-          line0Accum += lineContent;
-          const totalLine0 = line0Accum.length;
-          if (skipLine0Chars > 0) {
-            if (totalLine0 <= skipLine0Chars) {
-              skipLine0Chars -= totalLine0;
-              line0Accum = "";
-              currentLine++;
-              lineStart = i + 1;
-              if (currentLine > endLine) {
-                done = true;
-                break;
-              }
-              continue;
-            }
-            const from = skipLine0Chars;
-            const take = Math.min(lineChunkSize, totalLine0 - from);
-            resultLines.push(line0Accum.slice(from, from + take));
-            line0CharsReturned += take;
-            if (from + take < totalLine0) {
-              const totalLines = await countGitBlobLinesAsync(buf);
-              return {
-                content: resultLines.join("\n"),
-                totalLines,
-                lineOffset: lineOffsetIn + line0CharsReturned
-              };
-            }
-            line0Accum = "";
-            skipLine0Chars = 0;
-            line0CharsReturned = 0;
-          } else if (totalLine0 > lineChunkSize) {
-            resultLines.push(line0Accum.slice(0, lineChunkSize));
-            const totalLines = await countGitBlobLinesAsync(buf);
-            return {
-              content: resultLines.join("\n"),
-              totalLines,
-              lineOffset: lineChunkSize
-            };
-          } else {
-            resultLines.push(line0Accum);
-            line0Accum = "";
-          }
-        } else if (currentLine >= startLine && currentLine <= endLine) {
-          resultLines.push(lineContent);
-        }
-        currentLine++;
-        lineStart = i + 1;
-        if (currentLine > endLine) {
-          done = true;
-          break;
-        }
-      }
-    }
-    if (!done) {
-      const lineContent = text.slice(lineStart);
-      if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0)) {
-        line0Accum += lineContent;
-        const totalLine0 = line0Accum.length;
-        if (skipLine0Chars > 0) {
-          if (totalLine0 <= skipLine0Chars) {
-            skipLine0Chars -= totalLine0;
-            line0Accum = "";
-          } else {
-            const from = skipLine0Chars;
-            const take = Math.min(lineChunkSize, totalLine0 - from);
-            resultLines.push(line0Accum.slice(from, from + take));
-            const totalLines = await countGitBlobLinesAsync(buf);
-            return {
-              content: resultLines.join("\n"),
-              totalLines,
-              lineOffset: (lineOffsetIn ?? 0) + take
-            };
-          }
-        } else if (totalLine0 > lineChunkSize) {
-          resultLines.push(line0Accum.slice(0, lineChunkSize));
-          const totalLines = await countGitBlobLinesAsync(buf);
-          return {
-            content: resultLines.join("\n"),
-            totalLines,
-            lineOffset: lineChunkSize
-          };
-        }
-      }
-      partial2 = text.slice(lineStart);
-    }
-  }
-  if (!done) {
-    const tail = partial2 + decoder.end();
-    if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0) && tail.length > 0) {
-      line0Accum += tail.endsWith("\r") ? tail.slice(0, -1) : tail;
-      const totalLine0 = line0Accum.length;
-      if (skipLine0Chars > 0) {
-        if (totalLine0 <= skipLine0Chars) {
-          return finish();
-        }
-        const from = skipLine0Chars;
-        const take = Math.min(lineChunkSize, totalLine0 - from);
-        resultLines.push(line0Accum.slice(from, from + take));
-        line0CharsReturned += take;
-        if (from + take < totalLine0) {
-          const totalLines = await countGitBlobLinesAsync(buf);
-          return {
-            content: resultLines.join("\n"),
-            totalLines,
-            lineOffset: (lineOffsetIn ?? 0) + line0CharsReturned
-          };
-        }
-      } else if (totalLine0 > lineChunkSize) {
-        resultLines.push(line0Accum.slice(0, lineChunkSize));
-        const totalLines = await countGitBlobLinesAsync(buf);
-        return {
-          content: resultLines.join("\n"),
-          totalLines,
-          lineOffset: lineChunkSize
-        };
-      } else {
-        resultLines.push(line0Accum);
-      }
-    } else if (tail.length > 0 && currentLine >= startLine && currentLine <= endLine) {
-      resultLines.push(tail.endsWith("\r") ? tail.slice(0, -1) : tail);
-    }
-  }
-  return finish();
-}
-async function decodeGitBlobUtf8Async(buf) {
-  await yieldToEventLoop();
-  const text = buf.toString("utf8");
-  await yieldToEventLoop();
-  return text;
-}
-async function readGitBlobUtf8FullAsync(buf) {
-  const text = await decodeGitBlobUtf8Async(buf);
-  const totalLines = await countGitBlobLinesAsync(buf);
-  return { content: text, totalLines };
-}
-
-// src/git/tree/file/index.ts
-async function readGitTreeFileAsync(repoAbsPath, branch, relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, encoding = "utf8") {
-  await yieldToEventLoop();
-  const branchRef = branch.trim();
-  if (!branchRef) return { error: "branch required" };
-  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
-  if (!rel || rel === ".") return { error: "file path required" };
-  const blobRef = await gitBlobRef(repoAbsPath, branchRef, rel);
-  if (!blobRef) return { error: "Branch not found" };
-  const hasRange = typeof startLine === "number" && typeof endLine === "number";
-  try {
-    if (encoding === "base64") {
-      if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
-      const buf2 = await cliSimpleGit(repoAbsPath).showBuffer([blobRef]);
-      await yieldToEventLoop();
-      return {
-        content: buf2.toString("base64"),
-        size: buf2.length,
-        mimeType: guessMimeType(rel)
-      };
-    }
-    const buf = await cliSimpleGit(repoAbsPath).showBuffer([blobRef]);
-    await yieldToEventLoop();
-    const size = buf.length;
-    if (isBinaryBuffer(buf)) {
-      return { error: "Binary file cannot be displayed as text" };
-    }
-    if (hasRange) {
-      const ranged = await readGitBlobLineRangeAsync(buf, startLine, endLine, lineOffset, lineChunkSize);
-      return {
-        content: ranged.content,
-        totalLines: ranged.totalLines,
-        size,
-        ...ranged.lineOffset != null ? { lineOffset: ranged.lineOffset } : {}
-      };
-    }
-    const full = await readGitBlobUtf8FullAsync(buf);
-    return { content: full.content, totalLines: full.totalLines, size, mimeType: guessMimeType(rel) };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (/does not exist|bad revision|exists on disk, but not in/i.test(message)) {
-      return { error: "File not found in branch" };
-    }
-    return { error: message };
-  }
-}
-
 // src/files/browser/send-file-browser-message.ts
 function sendFileBrowserMessage(socket, e2ee, payload) {
   sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["entries", "content", "totalLines", "size", "lineOffset"]) : payload);
@@ -48592,103 +49668,6 @@ function sendFileBrowserMessage(socket, e2ee, payload) {
 // src/files/read-file/resolve-file-cache-warmup.ts
 init_yield_to_event_loop();
 import path78 from "node:path";
-
-// src/files/read-file/resolve-file-cache.ts
-import fs50 from "node:fs";
-import path77 from "node:path";
-var RESOLVE_CACHE_MAX = 4096;
-var resolveCache = /* @__PURE__ */ new Map();
-var warmedDirectories = /* @__PURE__ */ new Set();
-function resolveCacheKey(sessionParentPath, relativePath) {
-  return `${sessionParentPath}\0${relativePath}`;
-}
-function warmedDirectoryKey(sessionParentPath, directoryRelativePath) {
-  const dir = directoryRelativePath.replace(/^\/+/, "") || ".";
-  return `${path77.resolve(sessionParentPath)}\0${dir}`;
-}
-function pathStaysUnderParent(filePath, sessionParentPath) {
-  const parent = path77.resolve(sessionParentPath);
-  const resolved = path77.resolve(filePath);
-  return resolved === parent || resolved.startsWith(`${parent}${path77.sep}`);
-}
-async function statMatchesCache(entry) {
-  try {
-    const stat3 = await fs50.promises.stat(entry.path);
-    return stat3.isFile() && stat3.mtimeMs === entry.mtimeMs && stat3.size === entry.size;
-  } catch {
-    return false;
-  }
-}
-function getResolveCacheEntry(cacheKey) {
-  return resolveCache.get(cacheKey);
-}
-function deleteResolveCacheEntry(cacheKey) {
-  resolveCache.delete(cacheKey);
-}
-function storeResolveCacheEntry(cacheKey, entry) {
-  if (resolveCache.size >= RESOLVE_CACHE_MAX) resolveCache.clear();
-  resolveCache.set(cacheKey, entry);
-  return entry;
-}
-function hasResolveCacheEntry(cacheKey) {
-  return resolveCache.has(cacheKey);
-}
-function markDirectoryWarmed(dirKey) {
-  if (warmedDirectories.has(dirKey)) return false;
-  warmedDirectories.add(dirKey);
-  return true;
-}
-function unmarkDirectoryWarmed(dirKey) {
-  warmedDirectories.delete(dirKey);
-}
-
-// src/files/read-file/resolve-file-path.ts
-init_ensure_under_cwd();
-init_cwd();
-import fs51 from "node:fs";
-async function resolveFileForReadAsync(relativePath, sessionParentPath = getBridgeRoot()) {
-  const cacheKey = resolveCacheKey(sessionParentPath, relativePath);
-  const cached2 = getResolveCacheEntry(cacheKey);
-  if (cached2 != null && await statMatchesCache(cached2)) {
-    return { path: cached2.path, size: cached2.size };
-  }
-  if (cached2 != null) deleteResolveCacheEntry(cacheKey);
-  const resolved = ensureUnderCwd(relativePath, sessionParentPath);
-  if (!resolved) return { error: "Path is outside working directory" };
-  let real;
-  let size;
-  let mtimeMs;
-  try {
-    const lstat = await fs51.promises.lstat(resolved);
-    if (lstat.isSymbolicLink()) {
-      real = await fs51.promises.realpath(resolved);
-      if (!pathStaysUnderParent(real, sessionParentPath)) {
-        return { error: "Path is outside working directory" };
-      }
-      const stat3 = await fs51.promises.stat(real);
-      if (!stat3.isFile()) return { error: "Not a file" };
-      size = stat3.size;
-      mtimeMs = stat3.mtimeMs;
-    } else if (lstat.isFile()) {
-      real = resolved;
-      size = lstat.size;
-      mtimeMs = lstat.mtimeMs;
-    } else {
-      return { error: "Not a file" };
-    }
-  } catch (err) {
-    return { error: err instanceof Error ? err.message : String(err) };
-  }
-  const entry = storeResolveCacheEntry(cacheKey, { path: real, size, mtimeMs });
-  return { path: entry.path, size: entry.size };
-}
-async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
-  const result = await resolveFileForReadAsync(relativePath, sessionParentPath);
-  if ("error" in result) return result;
-  return result.path;
-}
-
-// src/files/read-file/resolve-file-cache-warmup.ts
 var WARMED_DIRECTORY_TTL_MS = 6e4;
 async function warmDirectoryResolveCache(sessionParentPath, directoryRelativePath) {
   const { listDirAsync: listDirAsync2 } = await Promise.resolve().then(() => (init_list_dir(), list_dir_exports));
@@ -48730,7 +49709,7 @@ function scheduleResolveCacheWarmupForListedEntries(sessionParentPath, listRelat
 
 // src/files/browser/handle-file-browser-list.ts
 async function handleFileBrowserList(socket, e2ee, id, reqPath, sessionParentPath, gitScope) {
-  const result = gitScope ? await listGitTreeDirAsync(gitScope.repoAbsPath, gitScope.branch, reqPath) : await listDirAsync(reqPath, sessionParentPath);
+  const result = await executeFileBrowserList({ reqPath, sessionParentPath, gitScope });
   if ("error" in result) {
     sendWsMessage(socket, { type: "file_browser_response", id, error: result.error });
     return;
@@ -48744,403 +49723,8 @@ async function handleFileBrowserList(socket, e2ee, id, reqPath, sessionParentPat
 // src/files/browser/handle-file-browser-read.ts
 import path79 from "node:path";
 init_cwd();
-
-// src/files/read-file/index.ts
-init_cwd();
-init_yield_to_event_loop();
-import fs55 from "node:fs";
-
-// src/files/read-file/read-file-range-async.ts
-init_yield_to_event_loop();
-import fs52 from "node:fs";
-import { StringDecoder as StringDecoder2 } from "node:string_decoder";
-
-// src/files/read-file/read-file-range-line-zero.ts
-function createLineZeroStreamState(lineOffsetIn) {
-  return {
-    line0Accum: "",
-    skipLine0Chars: typeof lineOffsetIn === "number" ? lineOffsetIn : 0,
-    line0CharsReturned: 0
-  };
-}
-function shouldTrackLineZero(startLine, lineOffsetIn) {
-  return startLine === 0 || lineOffsetIn !== void 0;
-}
-function stripCarriageReturn(lineContent) {
-  return lineContent.endsWith("\r") ? lineContent.slice(0, -1) : lineContent;
-}
-function lineContentBeforeNewline(text, lineStart, newlineIndex) {
-  let lineEnd = newlineIndex;
-  if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
-  return text.slice(lineStart, lineEnd);
-}
-function buildLineZeroChunkResult(resultLines, fileSize, lineOffset, totalLines = 1) {
-  return {
-    content: resultLines.join("\n"),
-    size: fileSize,
-    lineOffset,
-    totalLines
-  };
-}
-function tryFinishLineZeroOnCompleteLine(state, lineContent, resultLines, fileSize, lineChunkSize, lineOffsetIn, endLine, currentLine) {
-  state.line0Accum += lineContent;
-  const totalLine0 = state.line0Accum.length;
-  if (state.skipLine0Chars > 0) {
-    if (totalLine0 <= state.skipLine0Chars) {
-      state.skipLine0Chars -= totalLine0;
-      state.line0Accum = "";
-      return currentLine + 1 > endLine ? "done" : "continue";
-    }
-    const from = state.skipLine0Chars;
-    const take = Math.min(lineChunkSize, totalLine0 - from);
-    resultLines.push(state.line0Accum.slice(from, from + take));
-    state.line0CharsReturned += take;
-    if (from + take < totalLine0) {
-      return buildLineZeroChunkResult(
-        resultLines,
-        fileSize,
-        (lineOffsetIn ?? 0) + state.line0CharsReturned
-      );
-    }
-    state.line0Accum = "";
-    state.skipLine0Chars = 0;
-    state.line0CharsReturned = 0;
-    return "continue";
-  }
-  if (totalLine0 > lineChunkSize) {
-    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
-    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
-  }
-  resultLines.push(state.line0Accum);
-  state.line0Accum = "";
-  return "continue";
-}
-function tryFinishLineZeroPartial(state, partialLine, resultLines, fileSize, lineChunkSize, lineOffsetIn) {
-  state.line0Accum += partialLine;
-  const totalLine0 = state.line0Accum.length;
-  if (state.skipLine0Chars > 0) {
-    if (totalLine0 <= state.skipLine0Chars) {
-      state.skipLine0Chars -= totalLine0;
-      state.line0Accum = "";
-      return null;
-    }
-    const from = state.skipLine0Chars;
-    const take = Math.min(lineChunkSize, totalLine0 - from);
-    resultLines.push(state.line0Accum.slice(from, from + take));
-    return buildLineZeroChunkResult(resultLines, fileSize, (lineOffsetIn ?? 0) + take);
-  }
-  if (totalLine0 > lineChunkSize) {
-    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
-    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
-  }
-  return null;
-}
-function finishLineZeroTail(state, tail, resultLines, fileSize, lineChunkSize, lineOffsetIn) {
-  if (tail.length === 0) return null;
-  state.line0Accum += stripCarriageReturn(tail);
-  const totalLine0 = state.line0Accum.length;
-  if (state.skipLine0Chars > 0) {
-    if (totalLine0 <= state.skipLine0Chars) {
-      return { content: resultLines.join("\n"), size: fileSize };
-    }
-    const from = state.skipLine0Chars;
-    const take = Math.min(lineChunkSize, totalLine0 - from);
-    resultLines.push(state.line0Accum.slice(from, from + take));
-    state.line0CharsReturned += take;
-    if (from + take < totalLine0) {
-      return buildLineZeroChunkResult(
-        resultLines,
-        fileSize,
-        (lineOffsetIn ?? 0) + state.line0CharsReturned
-      );
-    }
-    return null;
-  }
-  if (totalLine0 > lineChunkSize) {
-    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
-    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
-  }
-  resultLines.push(state.line0Accum);
-  return null;
-}
-
-// src/files/read-file/read-file-range-async.ts
-async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE, fileSizeIn) {
-  const fileSize = fileSizeIn ?? (await fs52.promises.stat(filePath)).size;
-  const fd = await fs52.promises.open(filePath, "r");
-  const bufSize = 64 * 1024;
-  const buf = Buffer.alloc(bufSize);
-  const decoder = new StringDecoder2("utf8");
-  let currentLine = 0;
-  const resultLines = [];
-  let partial2 = "";
-  let done = false;
-  const trackLineZero = shouldTrackLineZero(startLine, lineOffsetIn);
-  const lineZeroState = createLineZeroStreamState(lineOffsetIn);
-  let bytesSinceYield = 0;
-  try {
-    let position = 0;
-    while (!done) {
-      const { bytesRead } = await fd.read(buf, 0, bufSize, position);
-      if (bytesRead === 0) break;
-      position += bytesRead;
-      bytesSinceYield += bytesRead;
-      if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
-        await yieldToEventLoop();
-        bytesSinceYield = 0;
-      }
-      const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
-      partial2 = "";
-      let lineStart = 0;
-      for (let i = 0; i < text.length; i++) {
-        if (text[i] !== "\n") continue;
-        const lineContent2 = lineContentBeforeNewline(text, lineStart, i);
-        if (currentLine === 0 && trackLineZero) {
-          const lineZeroResult = tryFinishLineZeroOnCompleteLine(
-            lineZeroState,
-            lineContent2,
-            resultLines,
-            fileSize,
-            lineChunkSize,
-            lineOffsetIn,
-            endLine,
-            currentLine
-          );
-          if (lineZeroResult === "done") {
-            done = true;
-            break;
-          }
-          if (lineZeroResult !== "continue") return lineZeroResult;
-          currentLine++;
-          lineStart = i + 1;
-          if (currentLine > endLine) {
-            done = true;
-            break;
-          }
-          continue;
-        }
-        if (currentLine >= startLine && currentLine <= endLine) {
-          resultLines.push(lineContent2);
-        }
-        currentLine++;
-        lineStart = i + 1;
-        if (currentLine > endLine) {
-          done = true;
-          break;
-        }
-      }
-      if (done) continue;
-      const lineContent = text.slice(lineStart);
-      if (currentLine === 0 && trackLineZero) {
-        const partialResult = tryFinishLineZeroPartial(
-          lineZeroState,
-          lineContent,
-          resultLines,
-          fileSize,
-          lineChunkSize,
-          lineOffsetIn
-        );
-        if (partialResult != null) return partialResult;
-      } else {
-        partial2 = lineContent;
-      }
-    }
-    if (!done) {
-      const tail = partial2 + decoder.end();
-      if (currentLine === 0 && trackLineZero) {
-        const tailResult = finishLineZeroTail(
-          lineZeroState,
-          tail,
-          resultLines,
-          fileSize,
-          lineChunkSize,
-          lineOffsetIn
-        );
-        if (tailResult != null) return tailResult;
-      } else if (tail.length > 0 && currentLine >= startLine && currentLine <= endLine) {
-        resultLines.push(tail.endsWith("\r") ? tail.slice(0, -1) : tail);
-      }
-    }
-    return { content: resultLines.join("\n"), size: fileSize };
-  } finally {
-    await fd.close();
-  }
-}
-
-// src/files/read-file/read-small-file-range-async.ts
-import fs53 from "node:fs";
-var SMALL_FILE_RANGE_MAX_BYTES = 512 * 1024;
-function sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize) {
-  if (startLine === 0 && lineOffsetIn == null && lines[0] != null && lines[0].length > lineChunkSize) {
-    return {
-      content: lines[0].slice(0, lineChunkSize),
-      size: fileSize,
-      lineOffset: lineChunkSize,
-      totalLines: lines.length
-    };
-  }
-  if (startLine === 0 && typeof lineOffsetIn === "number") {
-    const line0 = lines[0] ?? "";
-    const from = lineOffsetIn;
-    const take = Math.min(lineChunkSize, Math.max(0, line0.length - from));
-    return {
-      content: line0.slice(from, from + take),
-      size: fileSize,
-      ...from + take < line0.length ? { lineOffset: from + take, totalLines: lines.length } : { totalLines: lines.length }
-    };
-  }
-  const slice = lines.slice(startLine, endLine + 1);
-  return {
-    content: slice.join("\n"),
-    size: fileSize,
-    totalLines: lines.length
-  };
-}
-async function readSmallFileRangeAsync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const raw = await fs53.promises.readFile(filePath, "utf8");
-  const lines = raw.split(/\r?\n/);
-  return sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize);
-}
-
-// src/files/read-file/read-file-buffer-full-async.ts
-init_yield_to_event_loop();
-import fs54 from "node:fs";
-var READ_CHUNK_BYTES = 256 * 1024;
-async function readFileBufferFullAsync(filePath) {
-  const stat3 = await fs54.promises.stat(filePath);
-  const fd = await fs54.promises.open(filePath, "r");
-  const chunks = [];
-  let position = 0;
-  let bytesSinceYield = 0;
-  try {
-    while (position < stat3.size) {
-      const buf = Buffer.alloc(Math.min(READ_CHUNK_BYTES, stat3.size - position));
-      const { bytesRead } = await fd.read(buf, 0, buf.length, position);
-      if (bytesRead === 0) break;
-      chunks.push(buf.subarray(0, bytesRead));
-      position += bytesRead;
-      bytesSinceYield += bytesRead;
-      if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
-        await yieldToEventLoop();
-        bytesSinceYield = 0;
-      }
-    }
-  } finally {
-    await fd.close();
-  }
-  return { buffer: Buffer.concat(chunks), size: stat3.size };
-}
-
-// src/files/read-file/read-file-full-async.ts
-async function readFileFullAsync(filePath) {
-  const { buffer, size } = await readFileBufferFullAsync(filePath);
-  const raw = buffer.toString("utf8");
-  const lines = raw.split(/\r?\n/);
-  return { content: raw, totalLines: lines.length, size };
-}
-
-// src/files/read-file/read-file-binary-full-async.ts
-async function readFileBinaryFullAsync(filePath) {
-  const { buffer, size } = await readFileBufferFullAsync(filePath);
-  return {
-    content: buffer.toString("base64"),
-    size,
-    mimeType: guessMimeType(filePath)
-  };
-}
-
-// src/files/read-file/index.ts
-async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, sessionParentPath = getBridgeRoot(), encoding = "utf8", options) {
-  if (!options?.skipInitialYield) {
-    await yieldToEventLoop();
-  }
-  try {
-    let resolvedPath;
-    let fileSize;
-    if (options?.useResolvedSize) {
-      const resolved = await resolveFileForReadAsync(relativePath, sessionParentPath);
-      if ("error" in resolved) return resolved;
-      resolvedPath = resolved.path;
-      fileSize = resolved.size;
-    } else {
-      const result = await resolveFilePathAsync(relativePath, sessionParentPath);
-      if (typeof result === "object") return result;
-      resolvedPath = result;
-    }
-    const hasRange = typeof startLine === "number" && typeof endLine === "number";
-    if (encoding === "base64") {
-      if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
-      const read2 = await readFileBinaryFullAsync(resolvedPath);
-      return { ...read2, resolvedPath };
-    }
-    if (hasRange) {
-      if (fileSize == null) {
-        const stat3 = await fs55.promises.stat(resolvedPath);
-        fileSize = stat3.size;
-      }
-      const read2 = fileSize <= SMALL_FILE_RANGE_MAX_BYTES ? await readSmallFileRangeAsync(
-        resolvedPath,
-        fileSize,
-        startLine,
-        endLine,
-        lineOffset,
-        lineChunkSize
-      ) : await readFileRangeAsync(
-        resolvedPath,
-        startLine,
-        endLine,
-        lineOffset,
-        lineChunkSize,
-        fileSize
-      );
-      return read2;
-    }
-    const read = await readFileFullAsync(resolvedPath);
-    return { ...read, resolvedPath };
-  } catch (err) {
-    return { error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-// src/files/browser/file-browser-read-queue.ts
-var readChain = Promise.resolve();
-function withFileBrowserReadQueue(fn) {
-  const next = readChain.then(() => fn());
-  readChain = next.then(
-    () => void 0,
-    () => void 0
-  );
-  return next;
-}
-
-// src/files/browser/handle-file-browser-read.ts
 async function handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPath, gitScope) {
-  const startLine = typeof msg.startLine === "number" ? msg.startLine : void 0;
-  const endLine = typeof msg.endLine === "number" ? msg.endLine : void 0;
-  const lineOffset = typeof msg.lineOffset === "number" ? msg.lineOffset : void 0;
-  const lineChunkSize = typeof msg.lineChunkSize === "number" ? msg.lineChunkSize : void 0;
-  const encoding = msg.encoding === "base64" ? "base64" : "utf8";
-  const result = gitScope ? await readGitTreeFileAsync(
-    gitScope.repoAbsPath,
-    gitScope.branch,
-    reqPath,
-    startLine,
-    endLine,
-    lineOffset,
-    lineChunkSize,
-    encoding
-  ) : await withFileBrowserReadQueue(
-    () => readFileAsync(
-      reqPath,
-      startLine,
-      endLine,
-      lineOffset,
-      lineChunkSize,
-      sessionParentPath,
-      encoding,
-      { skipInitialYield: true, useResolvedSize: true }
-    )
-  );
+  const result = await executeFileBrowserRead({ msg, reqPath, sessionParentPath, gitScope });
   if ("error" in result) {
     sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
     return;
@@ -49162,15 +49746,6 @@ async function handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPa
   }
 }
 
-// src/files/browser/resolve-git-branch-scope.ts
-function resolveGitBranchScope(msg) {
-  const gitBranchScope = msg.source === "git_branch" && typeof msg.repoRelPath === "string" && typeof msg.branch === "string" && msg.branch.trim().length > 0;
-  if (!gitBranchScope) return null;
-  const repoAbsPath = resolveRepoAbsPathFromBridge(msg.repoRelPath);
-  if (!repoAbsPath) return null;
-  return { repoAbsPath, branch: msg.branch.trim() };
-}
-
 // src/files/browser/index.ts
 function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
   beginFileBrowserRequest();
@@ -49360,14 +49935,14 @@ function codeNavSessionKey(sessionId, sessionParentPath) {
 // src/code-nav/handlers/wait-for-symbol-index-ready.ts
 var CODE_NAV_INDEX_READY_WAIT_MS = 75;
 var CODE_NAV_INDEX_READY_POLL_MS = 15;
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve37) => setTimeout(resolve37, ms));
 }
 async function waitForSymbolIndexReady(sessionParentPath, reqPath, maxWaitMs = CODE_NAV_INDEX_READY_WAIT_MS) {
   const deadline = Date.now() + maxWaitMs;
   do {
     if (await symbolIndexFileIsReadyAsync(sessionParentPath, reqPath)) return true;
-    await delay2(CODE_NAV_INDEX_READY_POLL_MS);
+    await delay3(CODE_NAV_INDEX_READY_POLL_MS);
   } while (Date.now() < deadline);
   return await symbolIndexFileIsReadyAsync(sessionParentPath, reqPath);
 }
@@ -50293,27 +50868,6 @@ function createMainBridgeCloseHandler(params, connect) {
   };
 }
 
-// src/connection/report-git-repos.ts
-function reportGitRepos(getWs, log2) {
-  setImmediate(() => {
-    discoverGitRepos().then((repos) => {
-      if (repos.length > 0) {
-        const socket = getWs();
-        if (socket) {
-          sendWsMessage(socket, {
-            type: "git_repos",
-            repos: repos.map((r) => ({ absolutePath: r.absolutePath, remoteUrl: r.remoteUrl }))
-          });
-        }
-      }
-    }).catch((err) => {
-      log2(
-        `[Bridge service] Git repository discovery failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    });
-  });
-}
-
 // src/connection/main-bridge-ws-open-handler.ts
 function createMainBridgeOpenHandler(params) {
   const {
@@ -50338,14 +50892,7 @@ function createMainBridgeOpenHandler(params) {
     }
     const socket = getWs();
     if (socket) {
-      sendWsMessage(socket, {
-        type: "identify",
-        role: "cli",
-        cliVersion: CLI_VERSION,
-        bridgeRootPath: identifyReportedPaths.bridgeRootPath,
-        worktreesRootPath: identifyReportedPaths.worktreesRootPath,
-        ...e2ee ? { e: e2ee.handshake } : {}
-      });
+      sendBridgeIdentify(socket, { identifyReportedPaths, e2ee });
       reportGitRepos(getWs, logFn);
       try {
         onBridgeSocketOpen?.();
@@ -50470,6 +51017,7 @@ async function createBridgeConnection(options) {
   connect();
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   const bridgeAccess = await runtime.bridgeAccessPromise;
+  const localShortcut = await runtime.localShortcutPromise;
   return {
     close: async () => {
       requestCliImmediateShutdown();
@@ -50482,6 +51030,7 @@ async function createBridgeConnection(options) {
         runtime.logFn
       );
       await bridgeAccess.close();
+      await localShortcut.close();
     }
   };
 }