leglas 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export { runWatch } from "./run-watch.js";
 export type { TemplateResult, WatchTemplate } from "./watch.js";
 export type { WatchDeps } from "./run-watch.js";
 export { CAPTURES_DIR, DEFAULT_PORT, LEGLAS_PREFIX, NO_BROWSER, REFERENCES_DIR, SERVER_INFO_PATH, findBrowser, isOwnCapture, readRequests, readServerInfo, } from "@leglas/server";
-export type { Attachment, AttachmentKind, Failure, FailureCode, PendingRequest, RequestStatus, ServerInfo, } from "@leglas/server";
+export type { Attachment, AttachmentKind, Failure, FailureCode, PendingRequest, RequestStatus, ServerInfo, UpdateService, UpdateStatus, } from "@leglas/server";
 export { runClassify } from "./run-classify.js";
 export { run } from "./run.js";
 export type { ParseResult, RunOptions } from "./args.js";

package/dist/index.js

@@ -1247,13 +1247,21 @@ var KNOWN_AGENTS = {
     name: "Cursor",
     binary: "cursor-agent",
     efforts: [],
+    // `--trust` on every invocation. Without it, print mode stops at a
+    // "Workspace Trust Required" prompt nothing can answer and exits 1 with
+    // no events, in any directory Cursor has not been trusted for by hand:
+    // measured against cursor-agent 2026.09.02, one second, zero output. The
+    // project is the one the user pointed Leglas at, which is the trust the
+    // flag grants. It is the only permission the run needs: with it alone,
+    // the edit and the shell command in the same run both executed.
     args: (prompt, _effort = null, _images = []) => [
       "-p",
       prompt,
       "--output-format",
-      "stream-json"
+      "stream-json",
+      "--trust"
     ],
-    terminalArgs: (prompt, _effort = null, _images = []) => ["-p", prompt],
+    terminalArgs: (prompt, _effort = null, _images = []) => ["-p", prompt, "--trust"],
     // `--resume [chatId]` is documented alongside `--continue` in the CLI
     // parameter reference, and every stream-json event carries the
     // `session_id` to feed it. Cursor exposes no persistent transport the way
@@ -1264,11 +1272,16 @@ var KNOWN_AGENTS = {
     // Images are accepted and ignored, like its other argument builders:
     // `cursor-agent` documents no flag for them, and the capture paths reach
     // it as text in the prompt either way.
-    resumeArgs: (sessionId, prompt, _effort = null, _images = []) => ["-p", "--resume", sessionId, prompt, "--output-format", "stream-json"],
+    resumeArgs: (sessionId, prompt, _effort = null, _images = []) => ["-p", "--resume", sessionId, prompt, "--output-format", "stream-json", "--trust"],
     sessionFrom: (event) => typeof event.session_id === "string" && event.session_id !== "" ? event.session_id : null,
+    // Read against cursor-agent 2026.09.02: every event carries the id, a
+    // resume in this argument order answers under the same id and remembers
+    // the earlier turn.
+    activityVerified: true,
     authArgs: ["status"],
-    // UNVERIFIED: cursor-agent was not available on the build machine. The
-    // reading is deliberately loose, and anything ambiguous stays unknown.
+    // The signed-in form was read from the CLI: "✓ Logged in as <email>",
+    // exit 0. The signed-out form has not been, so that side of the reading
+    // stays loose, and anything ambiguous stays unknown.
     authVerdict: (result) => {
       if (/logged in|signed in/i.test(result.stdout))
         return "ok";
@@ -1472,15 +1485,15 @@ function cursorActivity(event, cwd) {
   const wrapper = record(event.tool_call);
   if (wrapper === null)
     return null;
-  const key = Object.keys(wrapper)[0];
+  const key = Object.keys(wrapper).find((name) => name.endsWith("ToolCall"));
   if (key === void 0)
     return null;
   const call = record(wrapper[key]);
   const args = record(call?.args);
   const tool = key.replace(/ToolCall$/, "");
-  if (tool === "write") {
+  if (tool === "edit" || tool === "write") {
     const path2 = shownPath(args?.path, cwd);
-    return path2 === null ? "using write" : `editing ${path2}`;
+    return path2 === null ? "editing a file" : `editing ${path2}`;
   }
   if (tool === "read") {
     const path2 = shownPath(args?.path, cwd);
@@ -7514,6 +7527,39 @@ async function startServer(options) {
     if (context.remote && path.startsWith(`${LEGLAS_PREFIX}/api/`)) {
       return sendJson2(res, 403, { error: "Not available to viewers." });
     }
+    if (path === `${LEGLAS_PREFIX}/api/update` && req.method === "GET" || req.method === "POST" && ["check", "skip", "install"].some((action) => path === `${LEGLAS_PREFIX}/api/update/${action}`)) {
+      const updates = options.updates;
+      if (updates === void 0) {
+        return sendJson2(res, 404, { ok: false, error: "Updates are not available here." });
+      }
+      if (req.method === "GET")
+        return sendJson2(res, 200, updates.status());
+      if (path.endsWith("/check")) {
+        return void updates.check({ force: true }).then((status) => sendJson2(res, 200, status));
+      }
+      if (path.endsWith("/install")) {
+        return void updates.update().then((status) => sendJson2(res, 200, status), (error) => sendJson2(res, 409, {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+      }
+      if (!hasJsonBody(req))
+        return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", () => {
+        const parsed = jsonBody(body);
+        if (parsed === null)
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+        if (typeof parsed.version !== "string" || parsed.version.trim() === "") {
+          return sendJson2(res, 400, { ok: false, error: "Body needs a version." });
+        }
+        void updates.skip(parsed.version).then((status) => sendJson2(res, 200, status), (error) => sendJson2(res, 400, {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+      });
+    }
     if (!context.remote && path === `${LEGLAS_PREFIX}/api/share` && req.method === "GET") {
       return void shares?.tunnels().then((tunnels) => sendJson2(res, 200, { share: shares?.status() ?? null, tunnels }));
     }
@@ -8360,6 +8406,7 @@ async function startServer(options) {
     ...options.startTunnel === void 0 ? {} : { startTunnel: options.startTunnel }
   });
   port = await bind2(server, options.port ?? DEFAULT_PORT);
+  options.updates?.setPort(port);
   const liveFiles = watchLiveFiles(cwd, bootConfigPath, live);
   liveHealth = watchHealth(target, live);
   await pruneCaptures(cwd, (await readRequests(cwd).catch(() => [])).map((request) => request.id)).catch(() => {
@@ -8378,6 +8425,8 @@ async function startServer(options) {
     ...options.codexAppServer === void 0 ? {} : { codexAppServer: options.codexAppServer },
     ...options.claudeAgentSession === void 0 ? {} : { claudeAgentSession: options.claudeAgentSession }
   });
+  options.updates?.onBusy(() => runner?.snapshot().running ?? false);
+  options.updates?.onChange(() => live.nudge("update"));
   let closePromise = null;
   return {
     port,
@@ -8388,6 +8437,7 @@ async function startServer(options) {
       closePromise = (async () => {
         liveFiles.close();
         liveHealth?.close();
+        await options.updates?.close();
         await Promise.all([
           shares?.close() ?? Promise.resolve(),
           branches.stop(),
@@ -8410,6 +8460,15 @@ async function startServer(options) {
   };
 }
 
+// ../server/dist/update.js
+import { spawn as spawnChild2 } from "child_process";
+import { existsSync as existsSync4, readFileSync, realpathSync } from "fs";
+import { lstat as lstat3, mkdir as mkdir9, mkdtemp, rename as rename3, rm as rm5, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname9, join as join13, posix as posix2, win32 } from "path";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var INSTALL_DEADLINE_MS = 5 * 60 * 1e3;
+
 // src/keep.ts
 function surfaceOf(url) {
   if (!url.startsWith("/") || !url.includes("?")) return null;
@@ -8465,8 +8524,8 @@ function planKeep(options) {
 }
 
 // src/run-init.ts
-import { readFile as readFile12, writeFile as writeFile9 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { join as join14 } from "path";
 async function readIfPresent(path) {
   try {
     return await readFile12(path, "utf8");
@@ -8477,18 +8536,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join13(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join14(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join13(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join14(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write2 of plan.writes) {
-    await writeFile9(join13(options.cwd, write2.path), write2.contents, "utf8");
+    await writeFile10(join14(options.cwd, write2.path), write2.contents, "utf8");
     touched.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile9(join13(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile10(join14(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -8507,9 +8566,9 @@ async function runInit(options, deps) {
 }
 
 // src/run-keep.ts
-import { existsSync as existsSync4 } from "fs";
-import { copyFile as copyFile2, mkdir as mkdir9, readFile as readFile13, rm as rm5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname9, join as join14 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir10, readFile as readFile13, rm as rm6, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname10, join as join15 } from "path";
 
 // src/resolve-title.ts
 function resolveOrExplain(input, titles, renames) {
@@ -8545,15 +8604,15 @@ async function writeLogEntry(options) {
     annotations: await readAnnotations(options.cwd),
     date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
   });
-  const dir = join14(options.cwd, options.logDir);
-  await mkdir9(dir, { recursive: true });
-  const file = join14(dir, `${entry.slug}.md`);
-  await writeFile10(file, entry.markdown, "utf8");
+  const dir = join15(options.cwd, options.logDir);
+  await mkdir10(dir, { recursive: true });
+  const file = join15(dir, `${entry.slug}.md`);
+  await writeFile11(file, entry.markdown, "utf8");
   if (entry.pictures.length > 0) {
-    const pictureDir = join14(dir, entry.slug);
-    await mkdir9(pictureDir, { recursive: true });
+    const pictureDir = join15(dir, entry.slug);
+    await mkdir10(pictureDir, { recursive: true });
     for (const picture of entry.pictures) {
-      await copyFile2(join14(options.cwd, picture.from), join14(pictureDir, picture.to)).catch(() => {
+      await copyFile2(join15(options.cwd, picture.from), join15(pictureDir, picture.to)).catch(() => {
       });
     }
   }
@@ -8576,17 +8635,17 @@ async function runKeep(options, deps) {
   if (!resolved.ok) return fail(resolved.error);
   const plan = planKeep({ title: resolved.title, previews, to: options.to });
   if (!plan.ok) return fail(plan.error);
-  const from = join14(options.cwd, plan.move.from);
-  const to = join14(options.cwd, plan.move.to);
-  if (!existsSync4(from)) {
+  const from = join15(options.cwd, plan.move.from);
+  const to = join15(options.cwd, plan.move.to);
+  if (!existsSync5(from)) {
     return fail(`${plan.move.from} does not exist. Nothing to keep.`);
   }
-  if (existsSync4(to)) {
+  if (existsSync5(to)) {
     return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
   }
   const source = await readFile13(from, "utf8");
-  await mkdir9(dirname9(to), { recursive: true });
-  await writeFile10(to, renameExport(source, plan.exportName), "utf8");
+  await mkdir10(dirname10(to), { recursive: true });
+  await writeFile11(to, renameExport(source, plan.exportName), "utf8");
   const surface = plan.removeDir.slice(plan.removeDir.lastIndexOf("/") + 1);
   let logged = null;
   let logError = null;
@@ -8601,7 +8660,7 @@ async function runKeep(options, deps) {
   } catch (error) {
     logError = error instanceof Error ? error.message : String(error);
   }
-  await rm5(join14(options.cwd, plan.removeDir), { recursive: true, force: true });
+  await rm6(join15(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
   if (options.json) {
     deps.log(
@@ -8639,9 +8698,9 @@ 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 dirname10, join as join15 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname11, join as join16 } from "path";
 async function readIfPresent2(path) {
   try {
     return await readFile14(path, "utf8");
@@ -8652,7 +8711,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join15(options.cwd, options.from));
+    const contents = await readIfPresent2(join16(options.cwd, options.from));
     if (contents === null) {
       const message2 = `${options.from} does not exist, so there is nothing to use as the baseline.`;
       if (options.json) deps.log(JSON.stringify({ ok: false, error: message2 }));
@@ -8663,8 +8722,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join15(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join15(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join16(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join16(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -8687,19 +8746,19 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write2) => existsSync5(join15(options.cwd, write2.path)));
+  const existing = plan.writes.filter((write2) => existsSync6(join16(options.cwd, write2.path)));
   if (existing.length > 0) {
     return fail(`${existing[0]?.path} already exists. Delete it first, or pick another surface name.`);
   }
   const written = [];
   for (const write2 of plan.writes) {
-    const target = join15(options.cwd, write2.path);
-    await mkdir10(dirname10(target), { recursive: true });
-    await writeFile11(target, write2.contents, "utf8");
+    const target = join16(options.cwd, write2.path);
+    await mkdir11(dirname11(target), { recursive: true });
+    await writeFile12(target, write2.contents, "utf8");
     written.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile11(join15(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile12(join16(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -8720,13 +8779,13 @@ async function runNew(options, deps) {
 }
 
 // src/run-previews.ts
-import { readFile as readFile15, writeFile as writeFile12 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile15, writeFile as writeFile13 } from "fs/promises";
+import { join as join17 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join16(cwd, ".gitignore");
+  const path = join17(cwd, ".gitignore");
   let current = null;
   try {
     current = await readFile15(path, "utf8");
@@ -8734,7 +8793,7 @@ async function ensureIgnored(cwd) {
     current = null;
   }
   const next = ignoreEntry(current);
-  if (next !== null) await writeFile12(path, next, "utf8");
+  if (next !== null) await writeFile13(path, next, "utf8");
 }
 async function runAdd(options, deps) {
   const loaded = await loadConfig(options.cwd);
@@ -9064,12 +9123,12 @@ 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 dirname11, join as join17 } from "path";
+import { mkdir as mkdir12, readFile as readFile16, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname12, join as join18 } from "path";
 var POLL_MS2 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
 async function saveTemplate(cwd, run4) {
-  const path = join17(cwd, WATCH_PATH);
+  const path = join18(cwd, WATCH_PATH);
   let config = {};
   try {
     const parsed = JSON.parse(await readFile16(path, "utf8"));
@@ -9079,8 +9138,8 @@ async function saveTemplate(cwd, run4) {
   } catch {
   }
   config.run = run4;
-  await mkdir11(dirname11(path), { recursive: true });
-  await writeFile13(path, `${JSON.stringify(config, null, 2)}
+  await mkdir12(dirname12(path), { recursive: true });
+  await writeFile14(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 function spawnAgent(command, args, cwd) {
@@ -9219,12 +9278,12 @@ async function runWatch(options, deps) {
 
 // src/run-classify.ts
 import { stat as stat4 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat4(join18(options.cwd, change.path)).then(
+      exists: await stat4(join19(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -9250,10 +9309,10 @@ async function runClassify(options, deps) {
 }
 
 // src/run.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { realpath as realpath4 } from "fs/promises";
 import { createRequire } from "module";
-import { basename as basename6, dirname as dirname12, join as join19, relative as relative5, resolve as resolve4 } from "path";
+import { basename as basename6, dirname as dirname13, join as join20, relative as relative5, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/dev-server-owner.ts
@@ -9339,11 +9398,11 @@ function devServerOwnerWarning(origin, projectRoot, owners) {
 
 // src/run.ts
 function findShellDir() {
-  const bundled = join19(dirname12(fileURLToPath(import.meta.url)), "shell");
-  if (existsSync6(join19(bundled, "index.html"))) return bundled;
+  const bundled = join20(dirname13(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync7(join20(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
-    return dirname12(require2.resolve("@leglas/shell/dist/index.html"));
+    return dirname13(require2.resolve("@leglas/shell/dist/index.html"));
   } catch {
     return null;
   }
@@ -9354,10 +9413,14 @@ function shellWord(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function embeddedLeglasCommand() {
-  const entry = join19(dirname12(fileURLToPath(import.meta.url)), "bin.js");
-  if (!existsSync6(entry)) return "npx -y leglas";
+  const entry = join20(dirname13(fileURLToPath(import.meta.url)), "bin.js");
+  if (!existsSync7(entry)) return "npx -y leglas";
   return [process.execPath, entry].map(shellWord).join(" ");
 }
+function skipStartupCheck(env) {
+  const off = (value) => value === void 0 || value === "" || value === "0" || value === "false";
+  return env.CI !== void 0 && env.CI !== "" && env.CI !== "false" || !off(env.LEGLAS_NO_UPDATE_CHECK);
+}
 async function run3(options, deps) {
   const loaded = await loadConfig(options.cwd);
   const local = await readLocalPreviews(options.cwd);
@@ -9386,8 +9449,8 @@ async function run3(options, deps) {
   const fileMounts = /* @__PURE__ */ new Map();
   for (const preview of merged?.previews ?? []) {
     if (preview.file !== void 0) {
-      const absolute = join19(options.cwd, preview.file);
-      if (!existsSync6(absolute)) {
+      const absolute = join20(options.cwd, preview.file);
+      if (!existsSync7(absolute)) {
         previewErrors.push(
           `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
         );
@@ -9397,7 +9460,7 @@ async function run3(options, deps) {
       for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
         slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
       }
-      fileMounts.set(slug, dirname12(absolute));
+      fileMounts.set(slug, dirname13(absolute));
       previews.push({
         ...preview,
         url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename6(absolute))}`
@@ -9408,8 +9471,8 @@ async function run3(options, deps) {
   }
   const config = merged === null ? null : { ...merged, previews };
   const configWarnings = [];
-  const projectRoot = await realpath4(loaded.path === null ? options.cwd : dirname12(loaded.path)).catch(
-    () => resolve4(loaded.path === null ? options.cwd : dirname12(loaded.path))
+  const projectRoot = await realpath4(loaded.path === null ? options.cwd : dirname13(loaded.path)).catch(
+    () => resolve4(loaded.path === null ? options.cwd : dirname13(loaded.path))
   );
   const ownerWarning = needsApp && app === null ? inspectLocalDevServer(devServer).then((owners) => devServerOwnerWarning(devServer, projectRoot, owners)).catch(() => null) : Promise.resolve(null);
   const serverPromise = startServer({
@@ -9423,6 +9486,7 @@ async function run3(options, deps) {
     project: loaded.path ?? options.cwd,
     cwd: options.cwd,
     leglasCommand: embeddedLeglasCommand(),
+    ...deps.updates === void 0 ? {} : { updates: deps.updates },
     ...options.port === void 0 ? {} : { port: options.port }
   });
   const [server, warning] = await Promise.all([serverPromise, ownerWarning]);
@@ -9472,12 +9536,26 @@ async function run3(options, deps) {
     }
   }
   if (options.open) await deps.open(url);
+  let stopped = false;
+  let updateTimer = null;
+  if (!options.json && deps.updates !== void 0 && !skipStartupCheck(process.env)) {
+    void deps.updates.check().then(() => {
+      if (stopped) return;
+      const line = deps.updates?.notice();
+      if (line !== null && line !== void 0) deps.log(line);
+    });
+    const updates = deps.updates;
+    updateTimer = setInterval(() => void updates.check(), 60 * 6e4);
+    updateTimer.unref?.();
+  }
   return {
     exitCode: 0,
     url,
     devServer,
     previewCount,
     stop: async () => {
+      stopped = true;
+      if (updateTimer !== null) clearInterval(updateTimer);
       await app?.stop().catch(() => {
       });
       await server.close();

package/dist/restart.d.ts

@@ -0,0 +1,13 @@
+import type { spawn as spawnChild } from "node:child_process";
+import type { RestartCommand } from "@leglas/server";
+import { type ShutdownSignal, type SignalTarget } from "./shutdown.js";
+export declare function createHandoff(): {
+    handOff: (command: RestartCommand, stop: () => Promise<void>, deps: {
+        spawn: typeof spawnChild;
+        exit: (code: number) => void;
+        target: SignalTarget & {
+            off(signal: ShutdownSignal, listener: () => void): unknown;
+        };
+    }) => Promise<void>;
+    handedOff: () => boolean;
+};

package/dist/run.d.ts

@@ -1,8 +1,13 @@
+import { type UpdateService } from "@leglas/server";
 import type { RunOptions } from "./args.js";
 export type RunDeps = {
     open(url: string): Promise<void>;
     log(line: string): void;
+    /** The CLI supplies updates; programmatic hosts can omit them. */
+    updates?: UpdateService;
 };
+/** Automated runs and an explicit opt-out should never ask npm at startup. */
+export declare function skipStartupCheck(env: NodeJS.ProcessEnv): boolean;
 export type RunResult = {
     exitCode: number;
     /** Where the interface lives, which is what gets opened and reported. */