scenri 0.8.3 → 0.9.1

package/dist/cli-FYWM4HBN.js

@@ -0,0 +1,526 @@
+import { adoptRunningInstall } from './chunk-ECS5LRHB.js';
+import { detectInstallKind } from './chunk-PAIAXRAC.js';
+import { readMeta } from './chunk-Y3ZPBPLP.js';
+import { defaultHome, newestStaged, listStaged, compareSemver, entryOf } from './chunk-4MAFHYAD.js';
+import { removeDesktop, installDesktop, POWERSHELL_ARGS } from './chunk-SDVL5OJF.js';
+import { launcherDir, logsDir, powershellPath } from './chunk-2IGINCPU.js';
+import { execFile, spawn } from 'child_process';
+import { existsSync, closeSync, readFileSync, writeFileSync, mkdirSync, openSync, rmSync, statSync, renameSync, appendFileSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname, delimiter, win32 } from 'path';
+import { createServer } from 'http';
+
+var HELPER_TIMEOUT_MS = 1e4;
+async function openInBrowser(url, platform, env, impl = {}) {
+  const timeoutMs = impl.timeoutMs ?? HELPER_TIMEOUT_MS;
+  if (platform === "win32") {
+    const spawnImpl = impl.spawn ?? spawn;
+    const root = env.SystemRoot || env.SYSTEMROOT || env.windir || "C:\\Windows";
+    const helpers = [
+      {
+        cmd: powershellPath(env),
+        args: [...POWERSHELL_ARGS, "Start-Process $env:SCENRI_URL"],
+        env: { ...env, SCENRI_URL: url },
+        ok: (code) => code === 0
+      },
+      {
+        cmd: win32.join(root, "System32", "rundll32.exe"),
+        args: ["url.dll,FileProtocolHandler", url],
+        ok: (c) => c === 0
+      },
+      // explorer.exe answers 1 even when it did the job; only a failure to start counts.
+      { cmd: win32.join(root, "explorer.exe"), args: [url], ok: (code) => code !== null }
+    ];
+    const reasons = [];
+    for (const helper of helpers) {
+      const result = await runHelper(spawnImpl, helper, env, timeoutMs);
+      if (result.ok) return;
+      reasons.push(`${win32.basename(helper.cmd)}: ${result.reason}`);
+    }
+    throw new Error(`no helper could open the browser (${reasons.join("; ")})`);
+  }
+  const openImpl = impl.open ?? (async (u) => await (await import('open')).default(u));
+  const child = await openImpl(url);
+  child.ref?.();
+  await new Promise((resolve, reject) => {
+    let done = false;
+    const finish = (err) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      err ? reject(err) : resolve();
+    };
+    const timer = setTimeout(() => finish(), timeoutMs);
+    child.once("error", (err) => finish(err));
+    child.once(
+      "close",
+      (code) => finish(code === 0 || code === null ? void 0 : new Error(`the opener exited with ${code}`))
+    );
+  });
+}
+function runHelper(spawnImpl, helper, env, timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false;
+    let stderr = "";
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    let child;
+    try {
+      child = spawnImpl(helper.cmd, helper.args, {
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true,
+        env: helper.env ?? env
+      });
+    } catch (err) {
+      return finish({ ok: false, reason: err instanceof Error ? err.message : String(err) });
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      finish({ ok: false, reason: `no answer within ${Math.round(timeoutMs / 1e3)} s` });
+    }, timeoutMs);
+    child.stderr?.on("data", (d) => {
+      stderr += String(d);
+    });
+    child.once("error", (err) => finish({ ok: false, reason: err.message }));
+    child.once("close", (code) => {
+      if (helper.ok(code)) return finish({ ok: true });
+      const detail = stderr.trim().split(/\r?\n/)[0];
+      finish({ ok: false, reason: `exit ${code}${detail ? `: ${detail}` : ""}` });
+    });
+  });
+}
+var MESSAGE_BOX = "Add-Type -AssemblyName System.Windows.Forms | Out-Null; [System.Windows.Forms.MessageBox]::Show($env:SCENRI_MESSAGE, 'Scenri') | Out-Null";
+function showDialog(platform, message, env, spawnImpl = spawn) {
+  if (env.SCENRI_NO_DIALOG === "1") return Promise.resolve();
+  let cmd;
+  let args;
+  let opts;
+  if (platform === "darwin") {
+    cmd = "/usr/bin/osascript";
+    args = [
+      "-e",
+      "on run argv",
+      "-e",
+      'display dialog (item 1 of argv) with title "Scenri" buttons {"OK"} default button 1 with icon stop',
+      "-e",
+      "end run",
+      "--",
+      message
+    ];
+    opts = { stdio: "ignore" };
+  } else if (platform === "win32") {
+    cmd = powershellPath(env);
+    args = [...POWERSHELL_ARGS, MESSAGE_BOX];
+    opts = { stdio: "ignore", windowsHide: true, env: { ...env, SCENRI_MESSAGE: message } };
+  } else {
+    console.error(`
+  ${message}
+`);
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    try {
+      const child = spawnImpl(cmd, args, opts);
+      child.once("error", () => resolve());
+      child.once("exit", () => resolve());
+    } catch {
+      resolve();
+    }
+  });
+}
+var DEFAULT_MAX = 1024 * 1024;
+function rotate(path, maxBytes) {
+  try {
+    if (statSync(path).size > maxBytes) renameSync(path, `${path}.1`);
+  } catch {
+  }
+}
+function appendLog(path, line, opts = {}) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    rotate(path, opts.maxBytes ?? DEFAULT_MAX);
+    appendFileSync(path, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+function openLogFd(path, opts = {}) {
+  mkdirSync(dirname(path), { recursive: true });
+  rotate(path, opts.maxBytes ?? 5 * DEFAULT_MAX);
+  return openSync(path, "a");
+}
+var LOCK_FRESH_MS = 6e4;
+var READY_TIMEOUT_MS = 18e4;
+var PAGE_FETCH_GRACE_MS = 15e3;
+var QUICK_DEATH_MS = 1e4;
+var NATIVE_MARKERS = ["NODE_MODULE_VERSION", "Could not locate the bindings file", "ERR_DLOPEN_FAILED"];
+async function showBrowser(deps, url) {
+  try {
+    await deps.openBrowser(url);
+  } catch (err) {
+    deps.log(`open: the browser could not be opened (${err instanceof Error ? err.message : String(err)})`);
+    const message = `Scenri is running at ${url} but the browser could not be opened. Open that address in your browser.`;
+    deps.log(`open: dialog: ${message}`);
+    await deps.showDialog(message);
+  }
+}
+async function openScenri(deps) {
+  const port = Number(deps.env.SCENRI_PORT || 4747);
+  const url = `http://127.0.0.1:${port}/`;
+  const noOpen = deps.env.SCENRI_NO_OPEN === "1";
+  deps.log(
+    `open: invoked by ${deps.version} (${deps.execPath}, node ${process.version}, ${process.platform}, cwd ${process.cwd()}) for port ${port}`
+  );
+  let page = null;
+  if (!takeLock(deps)) {
+    const running = await deps.probe(`${url}api/version`, 2e3);
+    if (running?.name === deps.pkg) {
+      deps.log("open: another launch is in progress and Scenri already answers, opening the browser");
+      if (!noOpen) await showBrowser(deps, url);
+      return 0;
+    }
+    deps.log("open: another launch is in progress, stepping aside");
+    return 0;
+  }
+  try {
+    const running = await deps.probe(`${url}api/version`, 2e3);
+    if (running?.name === deps.pkg) {
+      deps.log(`open: Scenri ${running.version ?? ""} already running, opening the browser`);
+      if (!noOpen) await showBrowser(deps, url);
+      return 0;
+    }
+    const fd = openLogFd(deps.serverLogPath);
+    const started = deps.now();
+    let exit = null;
+    let spawnError = null;
+    let child;
+    try {
+      child = deps.spawnImpl(deps.execPath, [deps.ownEntry], {
+        detached: true,
+        stdio: ["ignore", fd, fd],
+        windowsHide: true,
+        env: {
+          ...deps.env,
+          SCENRI_NO_OPEN: "1",
+          SCENRI_HEADLESS: "1",
+          // npm sits beside node for nvm, fnm, Volta, Homebrew and the installer,
+          // and a Finder or Explorer PATH has none of them: without this the
+          // server boots but one-click updates report no npm.
+          PATH: [dirname(deps.execPath), deps.env.PATH].filter(Boolean).join(delimiter)
+        }
+      });
+    } catch (err) {
+      closeSync(fd);
+      return await couldNotStart(deps, err);
+    }
+    child.unref();
+    closeSync(fd);
+    child.on("error", (err) => {
+      spawnError = err;
+      exit = { code: null };
+    });
+    child.on("exit", (code) => {
+      exit = { code };
+    });
+    deps.log(`open: started the supervisor, pid ${child.pid ?? "unknown"}, log ${deps.serverLogPath}`);
+    let shown = false;
+    if (!noOpen && deps.startingTemplate && existsSync(deps.startingTemplate) && deps.startingServer) {
+      try {
+        page = await deps.startingServer(renderStartingPage(readFileSync(deps.startingTemplate, "utf8"), url));
+        deps.log(`open: serving the starting page at ${page.url}`);
+        await deps.openBrowser(page.url);
+        shown = true;
+        deps.log("open: showing the starting page");
+      } catch (err) {
+        deps.log(`open: could not show the starting page (${err instanceof Error ? err.message : String(err)})`);
+      }
+    }
+    const deadline = started + (deps.readyTimeoutMs ?? READY_TIMEOUT_MS);
+    for (; ; ) {
+      const info = await deps.probe(`${url}api/version`, 1e3);
+      if (info?.name === deps.pkg) {
+        deps.log(`open: ready in ${deps.now() - started}ms`);
+        if (!noOpen) await handOver(deps, url, shown ? page : null);
+        return 0;
+      }
+      if (exit) break;
+      if (deps.now() >= deadline) {
+        const message2 = "Scenri is taking too long to start. Open Terminal and run npx scenri to see what it is doing.";
+        deps.log(`open: dialog: ${message2}`);
+        await deps.showDialog(message2);
+        return 1;
+      }
+      await deps.sleep(deps.pollMs ?? 250);
+    }
+    if (spawnError) return await couldNotStart(deps, spawnError);
+    const lived = deps.now() - started;
+    deps.log(`open: the server exited with ${exit.code} after ${lived}ms`);
+    const previous = deps.previousEntries[0];
+    if (lived < QUICK_DEATH_MS && previous && !deps.env.SCENRI_DESKTOP_FALLBACK) {
+      deps.log(`open: falling back to ${previous}`);
+      releaseLock(deps.lockPath);
+      const fallback = deps.spawnImpl(deps.execPath, [previous, "open"], {
+        stdio: "inherit",
+        // This process has no console; without the hint Windows would give
+        // the fallback a visible one.
+        windowsHide: true,
+        env: {
+          ...deps.env,
+          SCENRI_DESKTOP_FALLBACK: deps.version,
+          // the page is already up and polling; a second tab would be noise
+          ...shown ? { SCENRI_NO_OPEN: "1" } : {}
+        }
+      });
+      return await new Promise((resolve) => {
+        fallback.on("error", (err) => {
+          deps.log(`open: could not start the fallback (${err.message})`);
+          resolve(1);
+        });
+        fallback.on("exit", (code) => resolve(code ?? 1));
+      });
+    }
+    const message = explain(deps.readLogTail(), port);
+    deps.log(`open: dialog: ${message}`);
+    await deps.showDialog(message);
+    return 1;
+  } finally {
+    page?.close();
+    releaseLock(deps.lockPath);
+  }
+}
+async function handOver(deps, url, page) {
+  if (!page) return showBrowser(deps, url);
+  const until = deps.now() + PAGE_FETCH_GRACE_MS;
+  while (!page.wasFetched() && deps.now() < until) await deps.sleep(deps.pollMs ?? 250);
+  if (page.wasFetched()) {
+    deps.log(`open: the browser fetched the starting page (${page.userAgent() ?? "unknown browser"})`);
+    return;
+  }
+  deps.log("open: the browser never fetched the starting page, opening the studio directly");
+  await showBrowser(deps, url);
+}
+var STUDIO_URL = /^http:\/\/127\.0\.0\.1:\d{2,5}\/$/;
+var STUDIO_META = '<meta name="scenri-studio" content="">';
+function renderStartingPage(template, url) {
+  if (!STUDIO_URL.test(url)) throw new Error(`not a studio URL: ${url}`);
+  if (!template.includes(STUDIO_META)) throw new Error("starting page template has no scenri-studio meta");
+  return template.replace(STUDIO_META, `<meta name="scenri-studio" content="${url}">`);
+}
+function explain(tail2, port) {
+  if (/Port \d+ is in use by another app/.test(tail2)) {
+    return `Port ${port} is in use by another app. Quit that app, or open Terminal and start Scenri on another port: SCENRI_PORT=${port + 1} npx scenri`;
+  }
+  const newer = tail2.match(/This library was written by a newer Scenri[^\n]*/);
+  if (newer) return newer[0];
+  if (tail2.includes("a native component failed to load") || NATIVE_MARKERS.some((m) => tail2.includes(m))) {
+    return "Node.js changed since Scenri was installed. Open Terminal and run: npx scenri@latest";
+  }
+  return "Scenri could not start. Open Terminal and run npx scenri to see why.";
+}
+async function couldNotStart(deps, err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  deps.log(`open: could not start the supervisor (${reason})`);
+  const message = `Scenri could not start (${reason}). Open Terminal and run npx scenri to see why.`;
+  deps.log(`open: dialog: ${message}`);
+  await deps.showDialog(message);
+  return 1;
+}
+function takeLock(deps) {
+  try {
+    const held = JSON.parse(readFileSync(deps.lockPath, "utf8"));
+    const fresh = typeof held.at === "number" && deps.now() - held.at < LOCK_FRESH_MS;
+    if (fresh && typeof held.pid === "number" && held.pid !== process.pid && deps.pidAlive(held.pid)) return false;
+  } catch {
+  }
+  try {
+    writeFileSync(deps.lockPath, JSON.stringify({ pid: process.pid, at: deps.now() }));
+  } catch {
+  }
+  return true;
+}
+function releaseLock(path) {
+  try {
+    const held = JSON.parse(readFileSync(path, "utf8"));
+    if (held.pid === process.pid) rmSync(path, { force: true });
+  } catch {
+  }
+}
+function serveStartingPage(html) {
+  let fetched = false;
+  let agent = null;
+  const server = createServer((req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD" || req.url !== "/") {
+      res.statusCode = 404;
+      res.end();
+      return;
+    }
+    fetched = true;
+    const ua = req.headers["user-agent"];
+    agent = typeof ua === "string" ? ua : null;
+    res.setHeader("content-type", "text/html; charset=utf-8");
+    res.setHeader("cache-control", "no-store");
+    res.end(html);
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      resolve({
+        url: `http://127.0.0.1:${port}/`,
+        wasFetched: () => fetched,
+        userAgent: () => agent,
+        close: () => {
+          server.close();
+          server.closeAllConnections();
+        }
+      });
+    });
+  });
+}
+
+// src/desktop/cli.ts
+var assetsDirFor = (ownEntry) => join(dirname(ownEntry), "..", "launcher");
+var runExecFile = (cmd, args, opts) => new Promise((resolve, reject) => {
+  execFile(
+    cmd,
+    args,
+    { env: { ...process.env, ...opts?.env ?? {} }, windowsHide: true, encoding: "utf8", timeout: 3e4 },
+    (err, stdout) => err ? reject(err) : resolve(stdout)
+  );
+});
+function installDeps(ownEntry) {
+  return {
+    platform: process.platform,
+    homedir: homedir(),
+    home: defaultHome(),
+    execPath: process.execPath,
+    env: process.env,
+    version: readMeta().version,
+    assetsDir: assetsDirFor(ownEntry),
+    runImpl: runExecFile
+  };
+}
+async function runDesktopCommand(opts, ownEntry) {
+  if (opts.remove) {
+    const deps = installDeps(ownEntry);
+    const res = await removeDesktop(deps);
+    console.log(res.removed ? `  Removed Scenri from your desktop (${res.path}).` : "  Nothing to remove.");
+    if (res.message) console.log(`  ${res.message}`);
+    await rememberDecline(deps.home);
+    return 0;
+  }
+  return (await addToDesktop(ownEntry)).ok ? 0 : 1;
+}
+async function addToDesktop(ownEntry, say = console.log, over = {}) {
+  const deps = { ...installDeps(ownEntry), ...over };
+  const pkg = over.pkg ?? readMeta().name;
+  const installKind = over.installKind ?? detectInstallKind(ownEntry, deps.home);
+  if (installKind === "dev") {
+    const message = "Running from a source checkout; there is no installed build to put on a desktop.";
+    say(`  ${message}`);
+    return { ok: false, reason: "unsupported", message };
+  }
+  const adopted = await adoptRunningInstall({
+    home: deps.home,
+    pkg,
+    version: deps.version,
+    ownEntry,
+    installKind,
+    verifyImpl: over.verifyImpl
+  });
+  if (adopted.adopted) {
+    say(`  keeping a copy of Scenri ${deps.version} in ${join(deps.home, "app")} so the icon works offline`);
+  }
+  if (!newestStaged(deps.home, pkg)) {
+    const message = "Scenri could not keep a runnable copy of this build for the icon. Run npx scenri once in a terminal, then try again.";
+    say(`  ${message}`);
+    return { ok: false, reason: "failed", message };
+  }
+  const res = await installDesktop(deps);
+  if (res.ok) {
+    say(`  Added Scenri to your desktop: ${res.path}`);
+    say("  Next time, double-click it; no terminal needed.");
+  } else {
+    say(`  ${res.message}`);
+  }
+  return res;
+}
+async function rememberDecline(home) {
+  try {
+    const { createCore } = await import('./src-CSR34EBZ.js');
+    const core = createCore(home);
+    try {
+      core.store.setSetting("desktop.prompt", "declined");
+    } finally {
+      core.close();
+    }
+  } catch {
+  }
+}
+async function runOpenCommand(ownEntry) {
+  const meta = readMeta();
+  const home = defaultHome();
+  const support = launcherDir(homedir());
+  const logs = logsDir(home);
+  const serverLogPath = join(logs, "scenri.log");
+  const platform = process.platform;
+  const previous = listStaged(home, meta.name).filter((v) => compareSemver(v, meta.version) < 0).reverse().map((v) => entryOf(home, meta.name, v));
+  return openScenri({
+    home,
+    pkg: meta.name,
+    version: meta.version,
+    ownEntry,
+    env: process.env,
+    execPath: process.execPath,
+    probe: async (url, timeoutMs) => {
+      try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+        return res.ok ? await res.json() : null;
+      } catch {
+        return null;
+      }
+    },
+    spawnImpl: spawn,
+    openBrowser: (url) => openInBrowser(url, platform, process.env),
+    showDialog: (message) => showDialog(platform, message, process.env),
+    log: (line) => appendLog(join(logs, "launcher.log"), line),
+    now: Date.now,
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    lockPath: join(support, "open.lock"),
+    pidAlive,
+    serverLogPath,
+    readLogTail: () => tail(serverLogPath),
+    startingTemplate: join(assetsDirFor(ownEntry), "starting.html"),
+    startingServer: serveStartingPage,
+    previousEntries: previous
+  });
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function tail(path, bytes = 4096) {
+  try {
+    const size = statSync(path).size;
+    const buf = readFileSync(path);
+    return buf.subarray(Math.max(0, size - bytes)).toString("utf8");
+  } catch {
+    return "";
+  }
+}
+var supportInstalled = () => existsSync(join(launcherDir(homedir()), "launcher.json"));
+
+export { addToDesktop, assetsDirFor, installDeps, runDesktopCommand, runExecFile, runOpenCommand, supportInstalled };
+//# sourceMappingURL=cli-FYWM4HBN.js.map
+//# sourceMappingURL=cli-FYWM4HBN.js.map

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { bootErrorLines } from './chunk-WGIZJXNE.js';
+import { bootErrorLines } from './chunk-CMLJGPYC.js';
 import { fileURLToPath } from 'url';
 
 // src/args.ts
@@ -10,6 +10,15 @@ function parseArgs(argv) {
   if (first === "--help" || first === "-h") return { cmd: "help" };
   if (first === "serve") return { cmd: "serve" };
   if (first === "verify") return { cmd: "verify" };
+  if (first === "open") return { cmd: "open" };
+  if (first === "desktop") {
+    let remove = false;
+    for (const a of rest) {
+      if (a === "--remove") remove = true;
+      else return { cmd: "error", message: `unknown option '${a}' (try --help)` };
+    }
+    return { cmd: "desktop", remove };
+  }
   if (first === "update") {
     let check = false;
     let from;
@@ -33,12 +42,14 @@ Usage
   scenri serve          start this exact build, no supervision
   scenri update         download and stage the newest version
     --check             only check, do not download
+  scenri desktop        add Scenri to your desktop (or repair the icon)
+    --remove            take it off again
   scenri --version      print the installed version
   scenri --help         this text
 
 Configuration is via environment variables: SCENRI_PORT, SCENRI_HOST,
 SCENRI_HOME, SCENRI_NO_OPEN, SCENRI_NO_UPDATE_CHECK, SCENRI_NO_CONTENT_FETCH,
-SCENRI_CONTENT_URL.
+SCENRI_CONTENT_URL, SCENRI_NO_DESKTOP.
 `;
 }
 
@@ -74,13 +85,23 @@ try {
       process.exit(await runUpdateCommand(command));
       break;
     }
+    case "desktop": {
+      const { runDesktopCommand } = await import('./cli-FYWM4HBN.js');
+      process.exit(await runDesktopCommand(command, fileURLToPath(import.meta.url)));
+      break;
+    }
+    case "open": {
+      const { runOpenCommand } = await import('./cli-FYWM4HBN.js');
+      process.exit(await runOpenCommand(fileURLToPath(import.meta.url)));
+      break;
+    }
     case "launch": {
       const ownEntry = fileURLToPath(import.meta.url);
       if (!isBuiltEntry(ownEntry)) {
         await (await import('./serve.js')).serve();
         break;
       }
-      const { runLauncher } = await import('./launcher-DIZ4MQRF.js');
+      const { runLauncher } = await import('./launcher-IVFIYHPN.js');
       const { readMeta } = await import('./meta-MPQPBPBK.js');
       const { defaultHome } = await import('./versionsDir-ILQ4CI7B.js');
       const meta = readMeta();

package/dist/install-4W6AARK6.js

@@ -0,0 +1,4 @@
+export { UNSUPPORTED, desktopStatus, installDesktop, removeDesktop, runningNodeMajor, stableExecPath, writeSupportFiles } from './chunk-SDVL5OJF.js';
+import './chunk-2IGINCPU.js';
+//# sourceMappingURL=install-4W6AARK6.js.map
+//# sourceMappingURL=install-4W6AARK6.js.map

package/dist/{launcher-DIZ4MQRF.js → launcher-IVFIYHPN.js}

@@ -38,6 +38,10 @@ async function runLauncher(deps) {
     }
     child = spawnImpl(process.execPath, [entry, "serve"], {
       stdio: "inherit",
+      // A supervisor the desktop icon started has no console; without this
+      // Windows would open one for serve, the very window the icon avoids.
+      // Under a terminal the console stays shared so Ctrl-C reaches serve.
+      windowsHide: baseEnv.SCENRI_HEADLESS === "1",
       env: {
         ...baseEnv,
         SCENRI_SUPERVISED: "1",
@@ -61,5 +65,5 @@ async function runLauncher(deps) {
 }
 
 export { LAUNCHER_PROTOCOL, RESTART_EXIT_CODE, runLauncher };
-//# sourceMappingURL=launcher-DIZ4MQRF.js.map
-//# sourceMappingURL=launcher-DIZ4MQRF.js.map
+//# sourceMappingURL=launcher-IVFIYHPN.js.map
+//# sourceMappingURL=launcher-IVFIYHPN.js.map

package/dist/offer-IVTNHIDJ.js

@@ -0,0 +1,47 @@
+import { createInterface } from 'readline';
+
+// src/desktop/offer.ts
+function shouldOfferDesktop(i) {
+  if (i.env.SCENRI_NO_DESKTOP === "1") return false;
+  if (!i.stdinTTY || !i.stdoutTTY) return false;
+  if (i.env.CI) return false;
+  if (i.env.SSH_TTY) return false;
+  if (i.platform !== "darwin" && i.platform !== "win32") return false;
+  if (i.installKind === "dev") return false;
+  if (i.launcherInstalled) return false;
+  if (i.declined) return false;
+  return true;
+}
+var OFFER_QUESTION = "  Add Scenri to your desktop? Then you can open it without a terminal. [Y/n] ";
+async function offerDesktop(deps) {
+  let answer;
+  try {
+    answer = (await deps.ask(OFFER_QUESTION)).trim().toLowerCase();
+  } catch {
+    return;
+  }
+  if (answer === "" || answer.startsWith("y")) {
+    await deps.add();
+    return;
+  }
+  deps.decline();
+  deps.say("  Not now. Add it later with: npx scenri desktop, or from Settings > About.");
+}
+function askOnTerminal(question) {
+  return new Promise((resolve, reject) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+    let done = false;
+    rl.question(question, (answer) => {
+      done = true;
+      rl.close();
+      resolve(answer);
+    });
+    rl.once("close", () => {
+      if (!done) reject(new Error("stdin closed"));
+    });
+  });
+}
+
+export { OFFER_QUESTION, askOnTerminal, offerDesktop, shouldOfferDesktop };
+//# sourceMappingURL=offer-IVTNHIDJ.js.map
+//# sourceMappingURL=offer-IVTNHIDJ.js.map

package/dist/paths-6ZXRZUHY.js

@@ -0,0 +1,3 @@
+export { LAUNCHER_SCHEMA, PS_UTF8, desktopDir, isSupportedPlatform, launcherDir, launcherInstalled, launcherRecordPath, logsDir, powershellPath, readLauncherRecord, recordedEnv, writeLauncherRecord } from './chunk-2IGINCPU.js';
+//# sourceMappingURL=paths-6ZXRZUHY.js.map
+//# sourceMappingURL=paths-6ZXRZUHY.js.map