scenri 0.8.2 → 0.9.0

package/dist/chunk-PAIAXRAC.js

@@ -0,0 +1,20 @@
+import { realpathSync } from 'fs';
+import { sep, join } from 'path';
+
+// src/installKind.ts
+function detectInstallKind(entryPath, home) {
+  if (!entryPath.includes(`${sep}dist${sep}`) && !entryPath.endsWith(`${sep}dist`)) return "dev";
+  let homeReal = home;
+  try {
+    homeReal = realpathSync(home);
+  } catch {
+  }
+  if (entryPath.startsWith(join(homeReal, "app", "versions") + sep)) return "managed";
+  if (entryPath.includes(`${sep}_npx${sep}`)) return "npx";
+  if (entryPath.includes(`${sep}node_modules${sep}`)) return "global";
+  return "unknown";
+}
+
+export { detectInstallKind };
+//# sourceMappingURL=chunk-PAIAXRAC.js.map
+//# sourceMappingURL=chunk-PAIAXRAC.js.map

package/dist/chunk-QDODTMSN.js

@@ -0,0 +1,62 @@
+import { isValidVersionDir, stagingDir, versionsDir, pruneStaged } from './chunk-4MAFHYAD.js';
+import { execFile } from 'child_process';
+import { existsSync, rmSync, mkdirSync, cpSync, renameSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+async function adoptRunningInstall(deps) {
+  if (deps.installKind === "dev") return { adopted: false, reason: "dev" };
+  if (deps.installKind === "managed") return { adopted: false, reason: "managed" };
+  if (isValidVersionDir(deps.home, deps.pkg, deps.version)) return { adopted: false, reason: "present" };
+  const pkgRoot = dirname(dirname(deps.ownEntry));
+  if (!existsSync(deps.ownEntry) || manifestVersion(pkgRoot) !== deps.version) {
+    return { adopted: false, reason: "no-source" };
+  }
+  const nested = existsSync(join(pkgRoot, "node_modules", "fastify"));
+  const source = nested ? pkgRoot : dirname(pkgRoot);
+  const work = join(stagingDir(deps.home), `adopt-${deps.version}`);
+  rmSync(work, { recursive: true, force: true });
+  const dest = nested ? join(work, "node_modules", deps.pkg) : join(work, "node_modules");
+  mkdirSync(dirname(dest), { recursive: true });
+  try {
+    cpSync(source, dest, { recursive: true, verbatimSymlinks: true });
+    const copied = join(work, "node_modules", deps.pkg, "dist", "index.js");
+    if (!await (deps.verifyImpl ?? verifyEntry)(copied)) return { adopted: false, reason: "no-source" };
+    const target = join(versionsDir(deps.home), deps.version);
+    mkdirSync(dirname(target), { recursive: true });
+    rmSync(target, { recursive: true, force: true });
+    renameSync(work, target);
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+  pruneStaged(deps.home, deps.pkg, /* @__PURE__ */ new Set([deps.version]));
+  return { adopted: true };
+}
+function verifyEntry(entry) {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      [entry, "verify"],
+      { encoding: "utf8", timeout: 12e4, windowsHide: true, maxBuffer: 4 * 1024 * 1024 },
+      (err, stdout) => {
+        if (err) return resolve(false);
+        const line = String(stdout).trim().split("\n").reverse().find((l) => l.startsWith("{"));
+        try {
+          resolve(Boolean(line && JSON.parse(line).ok === true));
+        } catch {
+          resolve(false);
+        }
+      }
+    );
+  });
+}
+function manifestVersion(pkgRoot) {
+  try {
+    return JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export { adoptRunningInstall };
+//# sourceMappingURL=chunk-QDODTMSN.js.map
+//# sourceMappingURL=chunk-QDODTMSN.js.map

package/dist/cli-BVPVS4V5.js

@@ -0,0 +1,376 @@
+import { adoptRunningInstall } from './chunk-QDODTMSN.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, POWERSHELL } from './chunk-HLMR33DT.js';
+import { launcherDir, logsDir } from './chunk-4NQKRVO2.js';
+import { execFile, spawn } from 'child_process';
+import { existsSync, closeSync, mkdirSync, writeFileSync, readFileSync, openSync, rmSync, statSync, renameSync, appendFileSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname, delimiter } from 'path';
+import { pathToFileURL } from 'url';
+
+async function openInBrowser(url, platform, env) {
+  if (platform === "win32") {
+    await new Promise((resolve) => {
+      const child = spawn(POWERSHELL, [...POWERSHELL_ARGS, "Start-Process $env:SCENRI_URL"], {
+        stdio: "ignore",
+        windowsHide: true,
+        detached: true,
+        env: { ...env, SCENRI_URL: url }
+      });
+      child.once("error", () => resolve());
+      child.once("spawn", () => resolve());
+      child.unref();
+    });
+    return;
+  }
+  const { default: open } = await import('open');
+  await open(url);
+}
+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) {
+  if (env.SCENRI_NO_DIALOG === "1") return Promise.resolve();
+  let cmd;
+  let args;
+  let childEnv;
+  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
+    ];
+  } else if (platform === "win32") {
+    cmd = POWERSHELL;
+    args = [...POWERSHELL_ARGS, MESSAGE_BOX];
+    childEnv = { ...env, SCENRI_MESSAGE: message };
+  } else {
+    console.error(`
+  ${message}
+`);
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(cmd, args, { stdio: "ignore", windowsHide: true, env: childEnv });
+      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 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} for port ${port}`);
+  if (!takeLock(deps)) {
+    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 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)
+      }
+    });
+    child.unref();
+    closeSync(fd);
+    const started = deps.now();
+    let exit = 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)) {
+      try {
+        mkdirSync(dirname(deps.startingPage), { recursive: true });
+        writeFileSync(deps.startingPage, renderStartingPage(readFileSync(deps.startingTemplate, "utf8"), url));
+        await deps.openBrowser(pathToFileURL(deps.startingPage).href);
+        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 ?? 9e4);
+    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 && !shown) await showBrowser(deps, url);
+        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);
+    }
+    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",
+        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("exit", (code) => resolve(code ?? 1)));
+    }
+    const message = explain(deps.readLogTail(), port);
+    deps.log(`open: dialog: ${message}`);
+    await deps.showDialog(message);
+    return 1;
+  } finally {
+    releaseLock(deps.lockPath);
+  }
+}
+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";
+  }
+  if (NATIVE_MARKERS.some((m) => tail2.includes(m))) {
+    return "Scenri\u2019s files do not match this Node.js. Open Terminal and run: npx scenri";
+  }
+  return "Scenri could not start. Open Terminal and run npx scenri to see why.";
+}
+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 {
+  }
+}
+
+// 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"),
+    startingPage: join(support, "starting.html"),
+    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-BVPVS4V5.js.map
+//# sourceMappingURL=cli-BVPVS4V5.js.map

package/dist/index.js

@@ -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-BVPVS4V5.js');
+      process.exit(await runDesktopCommand(command, fileURLToPath(import.meta.url)));
+      break;
+    }
+    case "open": {
+      const { runOpenCommand } = await import('./cli-BVPVS4V5.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-V6DAA7TT.js

@@ -0,0 +1,4 @@
+export { UNSUPPORTED, desktopStatus, installDesktop, removeDesktop, runningNodeMajor, writeSupportFiles } from './chunk-HLMR33DT.js';
+import './chunk-4NQKRVO2.js';
+//# sourceMappingURL=install-V6DAA7TT.js.map
+//# sourceMappingURL=install-V6DAA7TT.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-36Y73GGY.js

@@ -0,0 +1,3 @@
+export { LAUNCHER_SCHEMA, desktopDir, isSupportedPlatform, launcherDir, launcherInstalled, launcherRecordPath, logsDir, readLauncherRecord, recordedEnv, writeLauncherRecord } from './chunk-4NQKRVO2.js';
+//# sourceMappingURL=paths-36Y73GGY.js.map
+//# sourceMappingURL=paths-36Y73GGY.js.map

package/dist/refresh-7HXPUHLQ.js

@@ -0,0 +1,91 @@
+import { adoptRunningInstall } from './chunk-QDODTMSN.js';
+import { newestStaged, compareSemver } from './chunk-4MAFHYAD.js';
+import { isOurMacBundle, runningNodeMajor, MAC_SCRIPT, macPlist, writeSupportFiles, writeMacBundle, writeLnk } from './chunk-HLMR33DT.js';
+import { readLauncherRecord, launcherDir, LAUNCHER_SCHEMA, writeLauncherRecord } from './chunk-4NQKRVO2.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+var ASSETS = ["launch.mjs", "Scenri.icns", "scenri.ico"];
+async function refreshLauncher(deps) {
+  if (deps.env.SCENRI_NO_DESKTOP === "1") return {};
+  const record = readLauncherRecord(deps.homedir);
+  if (!record) return {};
+  const out = {};
+  if (deps.installKind === "npx" || deps.installKind === "global") {
+    const newest = newestStaged(deps.home, deps.pkg);
+    if (!newest || compareSemver(deps.version, newest) > 0) {
+      const r = await adoptRunningInstall({
+        home: deps.home,
+        pkg: deps.pkg,
+        version: deps.version,
+        ownEntry: deps.ownEntry,
+        installKind: deps.installKind,
+        verifyImpl: deps.verifyImpl
+      });
+      if (r.adopted) out.adopted = true;
+    }
+  }
+  const support = launcherDir(deps.homedir);
+  const artifact = record.artifact.path;
+  const ours = existsSync(artifact) && (record.artifact.kind === "macos-app" ? isOurMacBundle(artifact) : true);
+  const schemaStale = record.schema !== LAUNCHER_SCHEMA;
+  const nodeGone = !existsSync(record.nodePath);
+  const nodePath = nodeGone ? deps.execPath : record.nodePath;
+  const nodeMajor = nodeGone ? runningNodeMajor() : record.nodeMajor ?? runningNodeMajor();
+  const nodeFilesStale = deps.platform === "darwin" && (readText(join(support, "node-path")) !== `${nodePath}
+` || readText(join(support, "node-major")) !== `${nodeMajor}
+`);
+  const supportStale = nodeFilesStale || ASSETS.some((f) => !sameFile(join(support, f), join(deps.assetsDir, f)));
+  const mac = ours && record.artifact.kind === "macos-app";
+  const iconStale = mac && !sameFile(join(artifact, "Contents", "Resources", "Scenri.icns"), join(deps.assetsDir, "Scenri.icns"));
+  const bundleStale = mac && (readText(join(artifact, "Contents", "MacOS", "Scenri")) !== MAC_SCRIPT || readText(join(artifact, "Contents", "Info.plist")) !== macPlist({ version: deps.version, schema: LAUNCHER_SCHEMA }));
+  if (schemaStale || supportStale || nodeGone) {
+    writeSupportFiles({ assetsDir: deps.assetsDir, execPath: nodePath, platform: deps.platform, nodeMajor }, support);
+  }
+  if (mac && (schemaStale || iconStale || bundleStale)) {
+    writeMacBundle({
+      path: artifact,
+      icns: join(support, "Scenri.icns"),
+      version: deps.version,
+      schema: LAUNCHER_SCHEMA
+    });
+  }
+  if (ours && record.artifact.kind === "windows-lnk" && (schemaStale || nodeGone)) {
+    await writeLnk(deps.runImpl, {
+      path: artifact,
+      target: nodePath,
+      args: `"${join(support, "launch.mjs")}"`,
+      workdir: support,
+      icon: `${join(support, "scenri.ico")},0`
+    });
+  }
+  if (schemaStale || supportStale || nodeGone || iconStale || bundleStale) {
+    writeLauncherRecord(deps.homedir, {
+      ...record,
+      schema: LAUNCHER_SCHEMA,
+      createdBy: deps.version,
+      nodePath,
+      nodeMajor
+    });
+    out.refreshed = true;
+  }
+  return out;
+}
+function readText(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function sameFile(a, b) {
+  try {
+    return readFileSync(a).equals(readFileSync(b));
+  } catch {
+    return false;
+  }
+}
+
+export { refreshLauncher };
+//# sourceMappingURL=refresh-7HXPUHLQ.js.map
+//# sourceMappingURL=refresh-7HXPUHLQ.js.map