leglas 0.7.1 → 0.7.2

package/dist/index.js

@@ -783,7 +783,7 @@ ${AGENTS_SECTION}`
 }
 
 // src/keep.ts
-import { basename as basename3, extname as extname4, normalize as normalize2 } from "path";
+import { basename as basename4, extname as extname4, normalize as normalize2 } from "path";
 
 // ../server/dist/config.js
 var DEFAULT_DEV_SERVER = "http://localhost:3000";
@@ -1555,8 +1555,8 @@ function findConfigFile(startDir) {
   const { root } = parse(startDir);
   let dir = startDir;
   for (; ; ) {
-    for (const basename6 of CONFIG_BASENAMES) {
-      const candidate = join2(dir, basename6);
+    for (const basename7 of CONFIG_BASENAMES) {
+      const candidate = join2(dir, basename7);
       if (existsSync(candidate))
         return candidate;
     }
@@ -4602,6 +4602,10 @@ function startRunner(options) {
     stopping: false,
     waiting: null
   };
+  const setState = (next) => {
+    state = typeof next === "function" ? next(state) : next;
+    options.onChange?.();
+  };
   let stopped = false;
   let ticking = null;
   let pendingNudges = 0;
@@ -4653,7 +4657,7 @@ function startRunner(options) {
     return session !== void 0 && session.turns < SESSION_TURNS_CAP ? session.id : null;
   };
   const idle = () => {
-    state = {
+    setState({
       running: false,
       requestId: null,
       agent: null,
@@ -4661,7 +4665,7 @@ function startRunner(options) {
       startedAt: null,
       stopping: false,
       waiting: null
-    };
+    });
   };
   const rememberLine = (lines2, line) => {
     lines2.push(line);
@@ -4769,14 +4773,15 @@ function startRunner(options) {
         if (retry !== null) {
           observed.retry = retry;
           if (active === current)
-            state = { ...state, waiting: retry };
+            setState((value) => ({ ...value, waiting: retry }));
         }
         const activity = activityFrom(resolved.agent, line, options.cwd);
         if (activity !== null) {
           if (activity.startsWith("editing"))
             observed.edited = true;
-          if (active === current)
-            state = { ...state, activity, waiting: null };
+          if (active === current) {
+            setState((value) => ({ ...value, activity, waiting: null }));
+          }
         }
       });
       const stderrFlush = lineReader(child.stderr, (line) => rememberLine(lines2, line));
@@ -4823,7 +4828,7 @@ function startRunner(options) {
         await reportFailure(request, classifyFailure({ agent: resolved.name, error: "stopped by shutdown" }), []);
         return;
       }
-      state = {
+      setState({
         running: true,
         requestId: request.id,
         agent: resolved.name,
@@ -4831,7 +4836,7 @@ function startRunner(options) {
         startedAt: Date.now(),
         stopping: false,
         waiting: null
-      };
+      });
       const observed = {
         sessionId: null,
         edited: false,
@@ -4862,7 +4867,7 @@ function startRunner(options) {
           resolved = cold;
           observed.sessionId = null;
           observed.retry = null;
-          state = { ...state, activity: null, waiting: null };
+          setState((value) => ({ ...value, activity: null, waiting: null }));
           outcome = await runChild(request, resolved, lines2, observed);
           failure = verdict();
         }
@@ -4936,7 +4941,7 @@ function startRunner(options) {
     const current = active;
     current.cancelled = true;
     failed.add(current.requestId);
-    state = { ...state, stopping: true, waiting: null };
+    setState((value) => ({ ...value, stopping: true, waiting: null }));
     current.controller.abort();
     try {
       current.child?.kill("SIGTERM");
@@ -4979,6 +4984,193 @@ function startRunner(options) {
   };
 }
 
+// ../server/dist/live.js
+import { createHash } from "crypto";
+var LIVE_PATH = "/leglas/api/live";
+var WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function encodeFrame(opcode, payload) {
+  const body = typeof payload === "string" ? Buffer.from(payload) : payload;
+  let header;
+  if (body.length < 126) {
+    header = Buffer.allocUnsafe(2);
+    header[1] = body.length;
+  } else if (body.length <= 65535) {
+    header = Buffer.allocUnsafe(4);
+    header[1] = 126;
+    header.writeUInt16BE(body.length, 2);
+  } else {
+    header = Buffer.allocUnsafe(10);
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(body.length), 2);
+  }
+  header[0] = 128 | opcode & 15;
+  return Buffer.concat([header, body], header.length + body.length);
+}
+var LIVE_DEBOUNCE_MS = 50;
+function createCoalescer(emit, options = {}) {
+  const windowMs = options.windowMs ?? LIVE_DEBOUNCE_MS;
+  const setLater = options.setTimeout ?? ((callback, ms) => {
+    const timer = setTimeout(callback, ms);
+    timer.unref?.();
+    return timer;
+  });
+  const clearLater = options.clearTimeout ?? ((handle) => clearTimeout(handle));
+  const pending = /* @__PURE__ */ new Map();
+  let closed = false;
+  return {
+    schedule(change) {
+      if (closed)
+        return;
+      const waiting = pending.get(change);
+      if (waiting !== void 0)
+        clearLater(waiting);
+      pending.set(change, setLater(() => {
+        pending.delete(change);
+        if (!closed)
+          emit(change);
+      }, windowMs));
+    },
+    close() {
+      closed = true;
+      for (const handle of pending.values())
+        clearLater(handle);
+      pending.clear();
+    }
+  };
+}
+function createLiveHub(_options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const drop = (listener) => {
+    listeners.delete(listener);
+  };
+  const write2 = (listener, opcode, payload) => {
+    if (listener.socket.destroyed || !listener.socket.writable) {
+      drop(listener);
+      return false;
+    }
+    try {
+      listener.socket.write(encodeFrame(opcode, payload));
+      return true;
+    } catch {
+      drop(listener);
+      listener.socket.destroy();
+      return false;
+    }
+  };
+  const read = (listener, chunk) => {
+    const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    listener.buffered = listener.buffered.length === 0 ? incoming : Buffer.concat([listener.buffered, incoming]);
+    while (listener.buffered.length >= 2) {
+      const first = listener.buffered[0] ?? 0;
+      const second = listener.buffered[1] ?? 0;
+      let length = second & 127;
+      let offset = 2;
+      if (length === 126) {
+        if (listener.buffered.length < 4)
+          return;
+        length = listener.buffered.readUInt16BE(2);
+        offset = 4;
+      } else if (length === 127) {
+        if (listener.buffered.length < 10)
+          return;
+        const wide = listener.buffered.readBigUInt64BE(2);
+        if (wide > BigInt(Number.MAX_SAFE_INTEGER)) {
+          drop(listener);
+          listener.socket.destroy();
+          return;
+        }
+        length = Number(wide);
+        offset = 10;
+      }
+      const masked = (second & 128) !== 0;
+      if (!masked) {
+        drop(listener);
+        listener.socket.destroy();
+        return;
+      }
+      if (listener.buffered.length < offset + 4 + length)
+        return;
+      const mask = listener.buffered.subarray(offset, offset + 4);
+      offset += 4;
+      const payload = Buffer.from(listener.buffered.subarray(offset, offset + length));
+      for (let index = 0; index < payload.length; index += 1) {
+        payload[index] = (payload[index] ?? 0) ^ (mask[index % 4] ?? 0);
+      }
+      listener.buffered = listener.buffered.subarray(offset + length);
+      const opcode = first & 15;
+      if (opcode === 8) {
+        write2(listener, 8, payload);
+        drop(listener);
+        listener.socket.destroy();
+        return;
+      }
+      if (opcode === 9)
+        write2(listener, 10, payload);
+    }
+  };
+  return {
+    nudge: (change) => {
+      if (listeners.size === 0)
+        return;
+      const frame = encodeFrame(1, JSON.stringify({ changed: change }));
+      for (const listener of [...listeners]) {
+        if (listener.socket.destroyed || !listener.socket.writable) {
+          drop(listener);
+          continue;
+        }
+        try {
+          listener.socket.write(frame);
+        } catch {
+          drop(listener);
+          listener.socket.destroy();
+        }
+      }
+    },
+    upgrade: (req, socket, head) => {
+      const path = (req.url ?? "/").split("?")[0] ?? "/";
+      if (req.method !== "GET" || path !== LIVE_PATH)
+        return false;
+      const upgrade = req.headers.upgrade;
+      const key = req.headers["sec-websocket-key"];
+      if (typeof upgrade !== "string" || upgrade.toLowerCase() !== "websocket" || typeof key !== "string" || key.trim() === "") {
+        socket.destroy();
+        return false;
+      }
+      const accept = createHash("sha1").update(key + WEBSOCKET_GUID).digest("base64");
+      try {
+        socket.write(`HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: ${accept}\r
+\r
+`);
+      } catch {
+        socket.destroy();
+        return false;
+      }
+      const listener = { socket, buffered: Buffer.alloc(0) };
+      listeners.add(listener);
+      socket.on("data", (chunk) => read(listener, chunk));
+      socket.once("error", () => drop(listener));
+      socket.once("end", () => drop(listener));
+      socket.once("close", () => drop(listener));
+      if (head.length > 0)
+        read(listener, head);
+      return true;
+    },
+    close: async () => {
+      for (const listener of [...listeners]) {
+        write2(listener, 8, Buffer.alloc(0));
+        drop(listener);
+        listener.socket.destroy();
+      }
+    },
+    get listening() {
+      return listeners.size;
+    }
+  };
+}
+
 // ../server/dist/renames.js
 import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname6, join as join10 } from "path";
@@ -5012,11 +5204,11 @@ function resolveTitle(input, titles, renames) {
 }
 
 // ../server/dist/server.js
-import { createReadStream, existsSync as existsSync3, statSync } from "fs";
+import { createReadStream, existsSync as existsSync3, statSync, unwatchFile, watch as watchFs, watchFile } from "fs";
 import { mkdir as mkdir8, readdir as readdir3, writeFile as writeFile8 } from "fs/promises";
 import http2 from "http";
 import net3 from "net";
-import { extname as extname3, join as join12, normalize, relative as relative3 } from "path";
+import { basename as basename3, dirname as dirname8, extname as extname3, join as join12, normalize, relative as relative3 } from "path";
 
 // ../server/dist/server-info.js
 import { lstat as lstat2, mkdir as mkdir7, readFile as readFile11, rename as rename2, rm as rm4, writeFile as writeFile7 } from "fs/promises";
@@ -5201,6 +5393,204 @@ function serveShellFile(res, shellDir, urlPath) {
   const isRoot = relative6 === "" || relative6 === "." || relative6 === "/";
   return serveFrom(res, shellDir, isRoot ? "index.html" : relative6);
 }
+var HEALTH_PROBE_MS = 3e3;
+function fileStamp(path) {
+  try {
+    const stat5 = statSync(path);
+    return `${stat5.dev}:${stat5.ino}:${stat5.size}:${stat5.mtimeMs}:${stat5.ctimeMs}`;
+  } catch {
+    return null;
+  }
+}
+function watchLiveFiles(cwd, configPath, live) {
+  const leglasDir = join12(cwd, ".leglas");
+  const targets = [
+    { path: join12(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
+    { path: join12(cwd, REQUESTS_PATH), change: "requests" },
+    { path: join12(cwd, ANNOTATIONS_PATH), change: "requests" }
+  ];
+  const byName = new Map(targets.map((target) => [basename3(target.path), target]));
+  const known = new Map(targets.map((target) => [target.path, fileStamp(target.path)]));
+  const coalescer = createCoalescer((change) => live.nudge(change));
+  const watchers = /* @__PURE__ */ new Set();
+  const fallback = /* @__PURE__ */ new Map();
+  let leglasWatcher = null;
+  let retry = null;
+  let closed = false;
+  const nudgeSoon = (change) => coalescer.schedule(change);
+  const scanLeglas = (notify) => {
+    for (const target of targets) {
+      const next = fileStamp(target.path);
+      if (next === known.get(target.path))
+        continue;
+      known.set(target.path, next);
+      if (notify)
+        nudgeSoon(target.change);
+    }
+  };
+  const fallbackWatch = (target) => {
+    if (closed || fallback.has(target.path))
+      return;
+    const listener = () => {
+      const next = fileStamp(target.path);
+      if (next === known.get(target.path))
+        return;
+      known.set(target.path, next);
+      nudgeSoon(target.change);
+    };
+    fallback.set(target.path, listener);
+    watchFile(target.path, { persistent: false, interval: 250 }, listener);
+  };
+  const fallbackLeglas = () => {
+    for (const target of targets)
+      fallbackWatch(target);
+  };
+  const retryLeglas = () => {
+    if (closed || retry !== null)
+      return;
+    retry = setTimeout(() => {
+      retry = null;
+      armLeglas(true);
+    }, 250);
+    retry.unref?.();
+  };
+  const armLeglas = (notify) => {
+    if (closed)
+      return;
+    scanLeglas(notify);
+    let directory = false;
+    try {
+      directory = statSync(leglasDir).isDirectory();
+    } catch {
+      directory = false;
+    }
+    if (!directory) {
+      if (leglasWatcher !== null) {
+        watchers.delete(leglasWatcher);
+        leglasWatcher.close();
+        leglasWatcher = null;
+      }
+      retryLeglas();
+      return;
+    }
+    if (leglasWatcher !== null)
+      return;
+    try {
+      const watcher = watchFs(leglasDir, { persistent: false }, (_event, filename) => {
+        if (filename === null) {
+          scanLeglas(true);
+          return;
+        }
+        const name = Buffer.isBuffer(filename) ? filename.toString() : filename;
+        const target = byName.get(name);
+        if (target === void 0)
+          return;
+        known.set(target.path, fileStamp(target.path));
+        nudgeSoon(target.change);
+      });
+      watcher.on("error", () => {
+        if (leglasWatcher !== watcher)
+          return;
+        watchers.delete(watcher);
+        watcher.close();
+        leglasWatcher = null;
+        fallbackLeglas();
+        retryLeglas();
+      });
+      leglasWatcher = watcher;
+      watchers.add(watcher);
+    } catch {
+      fallbackLeglas();
+      retryLeglas();
+    }
+  };
+  try {
+    const watcher = watchFs(cwd, { persistent: false }, (_event, filename) => {
+      const name = filename === null ? null : Buffer.isBuffer(filename) ? filename.toString() : filename;
+      if (name === null || name === ".leglas")
+        armLeglas(true);
+    });
+    watcher.on("error", () => {
+      watchers.delete(watcher);
+      watcher.close();
+      fallbackLeglas();
+    });
+    watchers.add(watcher);
+  } catch {
+    fallbackLeglas();
+  }
+  if (configPath !== null) {
+    try {
+      const directory = dirname8(configPath);
+      const name = basename3(configPath);
+      const target = { path: configPath, change: "config" };
+      known.set(configPath, fileStamp(configPath));
+      const watcher = watchFs(directory, { persistent: false }, (_event, filename) => {
+        const changed = filename === null ? null : Buffer.isBuffer(filename) ? filename.toString() : filename;
+        if (changed === null || changed === name)
+          nudgeSoon("config");
+      });
+      watcher.on("error", () => {
+        watchers.delete(watcher);
+        watcher.close();
+        fallbackWatch(target);
+      });
+      watchers.add(watcher);
+    } catch {
+      fallbackWatch({ path: configPath, change: "config" });
+    }
+  }
+  armLeglas(false);
+  return {
+    close: () => {
+      if (closed)
+        return;
+      closed = true;
+      if (retry !== null)
+        clearTimeout(retry);
+      coalescer.close();
+      for (const watcher of watchers)
+        watcher.close();
+      watchers.clear();
+      for (const [path, listener] of fallback)
+        unwatchFile(path, listener);
+      fallback.clear();
+      leglasWatcher = null;
+    }
+  };
+}
+function watchHealth(target, live) {
+  let previous = null;
+  let probing = false;
+  let closed = false;
+  const timer = setInterval(() => {
+    if (live.listening === 0) {
+      previous = null;
+      return;
+    }
+    if (probing)
+      return;
+    probing = true;
+    void probe(target).then((reachable) => {
+      if (closed || live.listening === 0) {
+        previous = null;
+        return;
+      }
+      if (previous !== null && previous !== reachable)
+        live.nudge("health");
+      previous = reachable;
+    }).finally(() => {
+      probing = false;
+    });
+  }, HEALTH_PROBE_MS);
+  timer.unref?.();
+  return {
+    close: () => {
+      closed = true;
+      clearInterval(timer);
+    }
+  };
+}
 function snapshotConfig(cwd) {
   const path = findConfigFile(cwd);
   if (path === null)
@@ -5271,12 +5661,14 @@ async function bind(server, requested) {
 async function startServer(options) {
   const { config, configErrors = [], configWarnings = [], shellDir = null, project = "", cwd = process.cwd(), leglasCommand = "npx -y leglas", fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents() } = options;
   const browserPool = options.pool ?? createBrowserPool();
+  const live = options.live ?? createLiveHub();
   if (options.pool === void 0) {
     void reapOrphanedBrowsers().catch(() => {
     });
   }
   const target = config?.devServer ?? "http://localhost:3000";
   const proxy = createProxyHandler({ target });
+  const bootConfigPath = findConfigFile(cwd);
   const bootConfigSnapshot = snapshotConfig(cwd);
   let lastSeen = null;
   const externallyAttached = () => lastSeen !== null && Date.now() - lastSeen < ATTACHED_WINDOW_MS;
@@ -5501,14 +5893,14 @@ async function startServer(options) {
           return sendJson(res, 400, { ok: false, error: "Unknown preview, or empty request." });
         }
         const intent = (parsed.intent ?? "").trim();
-        const live = (await readRequests(cwd).catch(() => [])).filter((entry) => entry.status === "queued" || entry.status === "picked-up");
+        const live2 = (await readRequests(cwd).catch(() => [])).filter((entry) => entry.status === "queued" || entry.status === "picked-up");
         const sameNotes = (entry) => {
           const before = [...entry.notes ?? []].sort().join(",");
           return before === notes.map((note) => note.id).sort().join(",");
         };
         const compare = typeof parsed.compare === "string" && parsed.compare !== preview.title ? previews.find((entry) => entry.title === parsed.compare) ?? null : null;
         const sameContext = (entry) => (entry.compare ?? null) === (compare?.title ?? null) && [...entry.references ?? []].sort().join(",") === [...references].sort().join(",");
-        if (live.some((entry) => entry.title === preview.title && entry.intent === intent && // The same words in the other mode are not the same request:
+        if (live2.some((entry) => entry.title === preview.title && entry.intent === intent && // The same words in the other mode are not the same request:
         // one forks the direction and the other rewrites it. Only a
         // genuine repeat is refused.
         (entry.mode ?? "replace") === mode && sameNotes(entry) && sameContext(entry))) {
@@ -6019,12 +6411,16 @@ async function startServer(options) {
     socket.once("close", () => sockets.delete(socket));
   });
   server.on("upgrade", (req, socket, head) => {
+    if (live.upgrade(req, socket, head))
+      return;
     const path = (req.url ?? "/").split("?")[0] ?? "/";
     if (path.startsWith(`${LEGLAS_PREFIX}/`))
       return socket.destroy();
     proxy.upgrade(req, socket, head);
   });
   const port = await bind(server, options.port ?? DEFAULT_PORT);
+  const liveFiles = watchLiveFiles(cwd, bootConfigPath, live);
+  const liveHealth = watchHealth(target, live);
   await pruneCaptures(cwd, (await readRequests(cwd).catch(() => [])).map((request) => request.id)).catch(() => {
   });
   await writeServerInfo(cwd, {
@@ -6036,6 +6432,7 @@ async function startServer(options) {
   runner = startRunner({
     cwd,
     externallyAttached,
+    onChange: () => live.nudge("requests"),
     leglasCommand,
     ...options.codexAppServer === void 0 ? {} : { codexAppServer: options.codexAppServer },
     ...options.claudeAgentSession === void 0 ? {} : { claudeAgentSession: options.claudeAgentSession }
@@ -6047,7 +6444,9 @@ async function startServer(options) {
     close: () => {
       if (closePromise !== null)
         return closePromise;
-      closePromise = Promise.all([runner.stop(), browserPool.close()]).then(() => new Promise((done) => {
+      liveFiles.close();
+      liveHealth.close();
+      closePromise = Promise.all([runner.stop(), browserPool.close(), live.close()]).then(() => new Promise((done) => {
         for (const socket of sockets)
           socket.destroy();
         sockets.clear();
@@ -6070,7 +6469,7 @@ function surfaceOf(url) {
   return null;
 }
 function exportNameFor(to) {
-  const stem = basename3(to, extname4(to));
+  const stem = basename4(to, extname4(to));
   return stem.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
 }
 function planKeep(options) {
@@ -6159,7 +6558,7 @@ async function runInit(options, deps) {
 // src/run-keep.ts
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir9, readFile as readFile13, rm as rm5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname8, join as join14 } from "path";
+import { dirname as dirname9, join as join14 } from "path";
 
 // src/resolve-title.ts
 function resolveOrExplain(input, titles, renames) {
@@ -6212,7 +6611,7 @@ async function runKeep(options, deps) {
     return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
   }
   const source = await readFile13(from, "utf8");
-  await mkdir9(dirname8(to), { recursive: true });
+  await mkdir9(dirname9(to), { recursive: true });
   await writeFile10(to, renameExport(source, plan.exportName), "utf8");
   await rm5(join14(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
@@ -6250,7 +6649,7 @@ async function runKeep(options, deps) {
 // src/run-new.ts
 import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir10, readFile as readFile14, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname9, join as join15 } from "path";
+import { dirname as dirname10, join as join15 } from "path";
 async function readIfPresent2(path) {
   try {
     return await readFile14(path, "utf8");
@@ -6303,7 +6702,7 @@ async function runNew(options, deps) {
   const written = [];
   for (const write2 of plan.writes) {
     const target = join15(options.cwd, write2.path);
-    await mkdir10(dirname9(target), { recursive: true });
+    await mkdir10(dirname10(target), { recursive: true });
     await writeFile11(target, write2.contents, "utf8");
     written.push(write2.path);
   }
@@ -6664,7 +7063,7 @@ async function runShow(options, deps) {
 // src/run-watch.ts
 import { spawn as spawn3 } from "child_process";
 import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname10, join as join17 } from "path";
+import { dirname as dirname11, join as join17 } from "path";
 var POLL_MS2 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
 async function saveTemplate(cwd, run4) {
@@ -6678,7 +7077,7 @@ async function saveTemplate(cwd, run4) {
   } catch {
   }
   config.run = run4;
-  await mkdir11(dirname10(path), { recursive: true });
+  await mkdir11(dirname11(path), { recursive: true });
   await writeFile13(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
@@ -6852,13 +7251,13 @@ async function runClassify(options, deps) {
 import { existsSync as existsSync6 } from "fs";
 import { realpath as realpath4 } from "fs/promises";
 import { createRequire } from "module";
-import { basename as basename5, dirname as dirname11, join as join19, relative as relative5, resolve as resolve4 } from "path";
+import { basename as basename6, dirname as dirname12, join as join19, relative as relative5, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/dev-server-owner.ts
 import { execFile as execFile2 } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve3 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve3 } from "path";
 import { promisify as promisify2 } from "util";
 var run2 = promisify2(execFile2);
 var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
@@ -6931,18 +7330,18 @@ function devServerOwnerWarning(origin, projectRoot, owners) {
   const port = localDevServerPort(origin);
   if (port === null || owners.length === 0) return null;
   if (owners.some((owner2) => isInside(projectRoot, owner2.cwd))) return null;
-  const owner = basename4(resolve3(owners[0]?.cwd ?? "")) || "another project";
-  const project = basename4(resolve3(projectRoot)) || "this project";
+  const owner = basename5(resolve3(owners[0]?.cwd ?? "")) || "another project";
+  const project = basename5(resolve3(projectRoot)) || "this project";
   return `Port ${port} appears to be served from ${owner}, outside this project (${project}). Check devServer in your Leglas config or use --user-port.`;
 }
 
 // src/run.ts
 function findShellDir() {
-  const bundled = join19(dirname11(fileURLToPath(import.meta.url)), "shell");
+  const bundled = join19(dirname12(fileURLToPath(import.meta.url)), "shell");
   if (existsSync6(join19(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
-    return dirname11(require2.resolve("@leglas/shell/dist/index.html"));
+    return dirname12(require2.resolve("@leglas/shell/dist/index.html"));
   } catch {
     return null;
   }
@@ -6953,7 +7352,7 @@ function shellWord(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function embeddedLeglasCommand() {
-  const entry = join19(dirname11(fileURLToPath(import.meta.url)), "bin.js");
+  const entry = join19(dirname12(fileURLToPath(import.meta.url)), "bin.js");
   if (!existsSync6(entry)) return "npx -y leglas";
   return [process.execPath, entry].map(shellWord).join(" ");
 }
@@ -6997,10 +7396,10 @@ async function run3(options, deps) {
       for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
         slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
       }
-      fileMounts.set(slug, dirname11(absolute));
+      fileMounts.set(slug, dirname12(absolute));
       previews.push({
         ...preview,
-        url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename5(absolute))}`
+        url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename6(absolute))}`
       });
       continue;
     }
@@ -7030,8 +7429,8 @@ async function run3(options, deps) {
   }
   const config = merged === null ? null : { ...merged, previews };
   const configWarnings = [];
-  const projectRoot = await realpath4(loaded.path === null ? options.cwd : dirname11(loaded.path)).catch(
-    () => resolve4(loaded.path === null ? options.cwd : dirname11(loaded.path))
+  const projectRoot = await realpath4(loaded.path === null ? options.cwd : dirname12(loaded.path)).catch(
+    () => resolve4(loaded.path === null ? options.cwd : dirname12(loaded.path))
   );
   const ownerWarning = needsApp && app === null ? inspectLocalDevServer(devServer).then((owners) => devServerOwnerWarning(devServer, projectRoot, owners)).catch(() => null) : Promise.resolve(null);
   const serverPromise = startServer({