latex-stickies 1.4.0 → 1.4.1

package/README.md

@@ -23,6 +23,11 @@ npm install -g latex-stickies
 latex-stickies
 ```
 
+If a launch fails, the launcher says so and shows the runtime's own output;
+the full log is kept at `~/Library/Logs/latex-stickies/launch.log` on macOS,
+`%LOCALAPPDATA%\latex-stickies\` on Windows, and `$XDG_STATE_HOME` (or
+`~/.local/state/latex-stickies/`) on Linux.
+
 Requires Node 22.12 or newer. The first run downloads the Electron runtime
 (~230 MB), so give it a minute; later launches are instant. On a Mac it also
 keeps a copy of the runtime carrying this app's name and icon in

package/bin/latex-stickies.js

@@ -6,10 +6,26 @@
  * We spawn it against this package's own directory, detached, so the notes
  * keep running after the terminal that started them is closed -- a sticky
  * note that dies with your shell is not a sticky note.
+ *
+ * Detached, but not unwatched. This used to print "LaTeX Stickies is running"
+ * the instant it had spawned something, with output going to /dev/null, so a
+ * runtime that started and died a moment later -- a missing shared library, a
+ * half-downloaded Electron, root without --no-sandbox -- reported success and
+ * left nothing behind to read. The launcher now keeps the child for a couple
+ * of seconds and says what happened if it does not survive.
  */
 const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
 const path = require('path');
 
+/** How long a launch has to survive before we call it a launch. */
+const STARTUP_MS = 2000;
+/** How much of the log to show when it does not. */
+const LOG_TAIL_LINES = 20;
+/** Kept from growing without bound: each launch starts a fresh log. */
+const LOG_NAME = 'launch.log';
+
 // Brand before resolving anything: this returns the path to a copy of the
 // Electron shell carrying our name and icon, kept outside node_modules so it
 // survives npx cache churn and npm ci. Falls back to the plain shell, which
@@ -37,16 +53,108 @@ if (!electron) {
   }
 }
 
+/** Where this platform expects a log to live. */
+function logDirectory() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Logs', 'latex-stickies');
+  }
+  if (process.platform === 'win32') {
+    const base = process.env.LOCALAPPDATA
+      || path.join(os.homedir(), 'AppData', 'Local');
+    return path.join(base, 'latex-stickies');
+  }
+  const base = process.env.XDG_STATE_HOME
+    || path.join(os.homedir(), '.local', 'state');
+  return path.join(base, 'latex-stickies');
+}
+
+/**
+ * Opens the log the app's output goes to.
+ *
+ * Truncated on every launch rather than appended to: it exists to explain the
+ * launch that just failed, and that keeps it bounded without any rotation.
+ * If it cannot be opened -- a read-only home, an odd container -- the launch
+ * still goes ahead with the output discarded, because a missing log is a far
+ * smaller problem than refusing to start.
+ */
+function openLog() {
+  try {
+    const dir = logDirectory();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, LOG_NAME);
+    return { file, fd: fs.openSync(file, 'w') };
+  } catch (_) {
+    return { file: null, fd: 'ignore' };
+  }
+}
+
+/** The tail of the log, for a failure message. */
+function logTail(file) {
+  if (!file) return '';
+  try {
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+    return lines.slice(-LOG_TAIL_LINES).join('\n');
+  } catch (_) {
+    return '';
+  }
+}
+
+const { file: logFile, fd: logFd } = openLog();
+
 const appDir = path.join(__dirname, '..');
 const child = spawn(electron, [appDir, ...process.argv.slice(2)], {
   detached: true,
-  stdio: 'ignore',
+  stdio: ['ignore', logFd, logFd],
 });
 
+// The child has its own handle on the log now; this one would otherwise keep
+// the descriptor open for the life of the parent.
+if (typeof logFd === 'number') {
+  try { fs.closeSync(logFd); } catch (_) { /* already gone */ }
+}
+
 child.on('error', (err) => {
-  console.error('Failed to launch LaTeX Stickies:', err.message);
+  console.error(`Failed to launch LaTeX Stickies: ${err.message}`);
   process.exit(1);
 });
 
-child.unref();
-console.log('LaTeX Stickies is running. Close the notes to quit.');
+/**
+ * Electron will not run as root without --no-sandbox, and says so only in the
+ * output nobody was reading. Naming it beats adding the flag quietly: turning
+ * off the sandbox is a decision for whoever is running as root to make.
+ */
+function rootHint() {
+  if (process.getuid && process.getuid() === 0) {
+    return '\nRunning as root: Electron refuses to start without a sandbox.'
+      + '\nRun it as an ordinary user, or pass --no-sandbox if you mean it:'
+      + '\n  latex-stickies --no-sandbox';
+  }
+  return '';
+}
+
+const onEarlyExit = (code, signal) => {
+  clearTimeout(timer);
+  const tail = logTail(logFile);
+  console.error(
+    `LaTeX Stickies exited immediately (code=${code}, signal=${signal}).`
+    + rootHint()
+    + (tail ? `\n\nLast ${LOG_TAIL_LINES} lines of the log:\n${tail}` : '')
+    + (logFile ? `\n\nFull log: ${logFile}` : '\n\nNo log could be written.')
+  );
+  process.exit(1);
+};
+
+child.on('exit', onEarlyExit);
+
+// Survived the window: let go of it and let this process end, so the terminal
+// is not held open by a note that is running perfectly well.
+const timer = setTimeout(() => {
+  child.removeListener('exit', onEarlyExit);
+  child.removeAllListeners('error');
+  child.unref();
+  console.log('LaTeX Stickies is running. Close the notes to quit.');
+}, STARTUP_MS);
+
+// Watching must not become waiting: an unreferenced timer still fires, but it
+// no longer holds the event loop open on its own.
+timer.unref();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latex-stickies",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Sticky notes for your desktop that render LaTeX and Markdown.",
   "main": "src/main.js",
   "scripts": {

package/scripts/brand-electron.js

@@ -63,6 +63,12 @@ function source() {
   const binary = require(path.join(dir, 'index.js'));
   // .../Electron.app/Contents/MacOS/Electron -> .../Electron.app
   const app = path.resolve(path.dirname(binary), '..', '..');
+  // Make sure that really is a bundle before anything is built from it. A
+  // stub or an odd install resolves to something that is not an .app, and the
+  // build then fails partway and takes the existing branded copy with it.
+  if (!app.endsWith('.app') || !fs.existsSync(path.join(app, 'Contents', 'MacOS'))) {
+    throw new Error(`the Electron runtime at ${app} is not an app bundle`);
+  }
   const { version } = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
   return { app, version };
 }
@@ -173,8 +179,12 @@ function ensure() {
     return binary;
   } catch (err) {
     // Leave nothing half-built: a bundle with a broken signature will not
-    // launch at all, which is far worse than the wrong name.
-    fs.rmSync(TARGET, { recursive: true, force: true });
+    // launch at all, which is far worse than the wrong name. Only what this
+    // run was building, though -- a failure part way through is no reason to
+    // remove a copy that was working before it.
+    if (!isCurrent(version)) {
+      fs.rmSync(TARGET, { recursive: true, force: true });
+    }
     report(`could not brand the app (${first(err)})`);
     return null;
   }