@thomas.f/prnext 0.1.0-alpha.1 → 0.1.1-alpha

package/runtime/persistent/startup.mjs

@@ -0,0 +1,71 @@
+import { mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const execute = promisify(execFile);
+const ps = value => `'${value.replaceAll("'", "''")}'`;
+const xml = value => value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+const systemd = value => '"' + value.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%').replaceAll('$', () => '$$') + '"';
+// Windows CommandLineToArgvW quoting, followed separately by PowerShell quoting.
+const windows = value => '"' + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1') + '"';
+
+export function startupDefinition({ platform = process.platform, home, node = process.execPath, watchdog = fileURLToPath(new URL('./watchdog.mjs', import.meta.url)), userHome = homedir(), remove = false }) {
+  for (const value of [home, node, watchdog, userHome]) if (/[\x00-\x1f\x7f]/.test(value)) throw new Error('Startup paths cannot contain control characters');
+  const id = createHash('sha256').update(platform === 'win32' ? home.toLowerCase() : home).digest('hex').slice(0, 16);
+  const marker = `PRNext persistent supervisor ${id}`;
+  const name = `prnext-${id}`;
+  if (platform === 'linux') {
+    const file = path.join(userHome, '.config/systemd/user', `${name}.service`);
+    return { marker, file, content: `# ${marker}\n[Unit]\nDescription=${marker}\n\n[Service]\nType=simple\nExecStart=${[node, watchdog, home].map(systemd).join(' ')}\nRestart=on-failure\nRestartSec=5\nTimeoutStopSec=70\nKillMode=control-group\n\n[Install]\nWantedBy=default.target\n`,
+      commands: remove ? [['systemctl', ['--user', 'disable', `${name}.service`]]] : [['systemctl', ['--user', 'daemon-reload']], ['systemctl', ['--user', 'enable', `${name}.service`]]],
+      note: 'Restoration enabled for your next user login. For startup before login on a server, an administrator can enable linger for this account (loginctl enable-linger). No linger setting was changed.' };
+  }
+  if (platform === 'darwin') {
+    const file = path.join(userHome, 'Library/LaunchAgents', `dev.prnext.${id}.plist`);
+    return { marker, file, content: `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>\n<key>Label</key><string>dev.prnext.${id}</string>\n<key>Description</key><string>${marker}</string>\n<key>ProgramArguments</key><array>${[node, watchdog, home].map(value => '<string>' + xml(value) + '</string>').join('')}</array>\n<key>RunAtLoad</key><true/>\n<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>\n<key>ThrottleInterval</key><integer>5</integer>\n<key>ExitTimeOut</key><integer>70</integer>\n</dict></plist>\n`, commands: [],
+      note: 'Restoration enabled for your next macOS login. The LaunchAgent restarts a failed supervisor while your session is active.' };
+  }
+  if (platform === 'win32') {
+    const file = path.join(home, 'startup.ps1');
+    const launch = path.join(home, 'launch.ps1');
+    const launcher = `# ${marker}\n$ErrorActionPreference = 'Stop'\n$prnextProcess = Start-Process -FilePath ${ps(node)} -ArgumentList ${ps([watchdog, home].map(windows).join(' '))} -WindowStyle Hidden -Wait -PassThru\nexit $prnextProcess.ExitCode\n`;
+    const args = `-NoLogo -NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File ${windows(launch)}`;
+    const content = `# ${marker}\n$ErrorActionPreference = 'Stop'\n$prnextTaskName = ${ps(name)}\n$prnextExisting = Get-ScheduledTask -TaskName $prnextTaskName -ErrorAction SilentlyContinue\nif ($prnextExisting -and $prnextExisting.Description -ne ${ps(marker)}) { throw 'This task name belongs to another application.' }\n` + (remove
+      ? `if ($prnextExisting) { Unregister-ScheduledTask -TaskName $prnextTaskName -Confirm:$false }\n`
+      : `$prnextUser = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name\n$prnextAction = New-ScheduledTaskAction -Execute (Join-Path $PSHOME 'powershell.exe') -Argument ${ps(args)}\n$prnextTrigger = New-ScheduledTaskTrigger -AtLogOn -User $prnextUser\n$prnextPrincipal = New-ScheduledTaskPrincipal -UserId $prnextUser -LogonType Interactive -RunLevel Limited\n$prnextSettings = New-ScheduledTaskSettingsSet -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit ([TimeSpan]::Zero) -MultipleInstances IgnoreNew -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries\nRegister-ScheduledTask -TaskName $prnextTaskName -Description ${ps(marker)} -Action $prnextAction -Trigger $prnextTrigger -Principal $prnextPrincipal -Settings $prnextSettings -Force | Out-Null\n`);
+    return { marker, file, content, extra: { file: launch, content: launcher }, commands: [['powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', file]]],
+      note: 'Restoration enabled for your next Windows login, using a hidden task for your account. It retries supervisor failures every minute. This is not a service that runs before login.' };
+  }
+  throw new Error('Automatic startup supports Windows, macOS and Linux with systemd.');
+}
+async function owned(file, marker) {
+  try { if (!(await readFile(file, 'utf8')).includes(marker)) throw new Error(`Refusing to replace a startup file not owned by PRNext: ${file}`); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+}
+export async function startup(home, { remove = false } = {}) {
+  const definition = startupDefinition({ home, remove });
+  await owned(definition.file, definition.marker);
+  if (definition.extra) await owned(definition.extra.file, definition.marker);
+  if (!remove || process.platform === 'win32') {
+    await mkdir(path.dirname(definition.file), { recursive: true, mode: 0o700 });
+    // Windows PowerShell 5.1 needs a UTF-8 BOM to preserve non-ASCII paths.
+    const encodingMarker = process.platform === 'win32' ? '\ufeff' : '';
+    await writeFile(definition.file, encodingMarker + definition.content, { mode: 0o600 });
+    if (definition.extra && !remove) await writeFile(definition.extra.file, encodingMarker + definition.extra.content, { mode: 0o600 });
+  }
+  for (const [file, args] of definition.commands) {
+    try { await execute(file, args, { windowsHide: true, timeout: 30000, maxBuffer: 1024 * 1024 }); }
+    catch (error) { throw new Error(`Unable to ${remove ? 'remove' : 'enable'} startup: ${error.stderr?.trim() || error.message}. The generated definition is at ${definition.file}.`); }
+  }
+  if (remove) {
+    await rm(definition.file, { force: true });
+    if (definition.extra) await rm(definition.extra.file, { force: true });
+    if (process.platform === 'linux') await execute('systemctl', ['--user', 'daemon-reload'], { timeout: 30000 });
+    return 'Automatic startup removed. Running apps remain available; use prn pstop to stop them.';
+  }
+  return definition.note + '\nRun prn pstartup again after moving or upgrading Node or PRNext.';
+}

package/runtime/persistent/watchdog.mjs

@@ -0,0 +1,109 @@
+import { fork } from 'node:child_process';
+import { createServer } from 'node:net';
+import { timingSafeEqual } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { initializeHome, environment, delay } from './common.mjs';
+import { RotatingLog } from './logger.mjs';
+
+const connection = await initializeHome(process.argv[2]);
+const log = new RotatingLog(path.join(connection.home, 'logs', 'supervisor.log'));
+const pending = new Map(), children = new Set(), sockets = new Set();
+const shutdownReplies = [];
+let daemon, ready = false, closing = false, counter = 0, heartbeat = Date.now(), failures = 0, restartTimer;
+const server = createServer(socket => {
+  socket.setEncoding('utf8');
+  sockets.add(socket); socket.once('close', () => sockets.delete(socket));
+  socket.setTimeout(125000, () => socket.destroy());
+  let buffer = '', received = false;
+  socket.on('error', () => {});
+  socket.on('data', chunk => {
+    if (received) return;
+    buffer += chunk.toString();
+    if (buffer.length > 65536) { socket.destroy(); return; }
+    if (!buffer.includes('\n')) return;
+    received = true;
+    let message;
+    const reply = result => socket.end(JSON.stringify(result) + '\n');
+    try {
+      message = JSON.parse(buffer.slice(0, buffer.indexOf('\n')));
+      const supplied = Buffer.from(typeof message.token === 'string' ? message.token : '');
+      const expected = Buffer.from(connection.token);
+      if (supplied.length !== expected.length || !timingSafeEqual(supplied, expected)) throw new Error('Invalid supervisor credentials');
+      delete message.token;
+      if (message.command === 'ping') { reply({ ok: true, value: { version: 1, pid: process.pid, daemonPid: daemon?.pid || null, ready } }); return; }
+      if (message.command === 'shutdown') { shutdownReplies.push(reply); void shutdown(); return; }
+      if (!ready || !daemon?.connected) throw new Error('Supervisor is recovering. Retry shortly.');
+      if (pending.size >= 32) throw new Error('Supervisor is busy. Retry shortly.');
+      const id = ++counter;
+      pending.set(id, reply);
+      socket.once('close', () => pending.delete(id));
+      daemon.send({ type: 'request', id, request: message }, error => { if (error) { pending.delete(id); reply({ ok: false, error: error.message }); } });
+    } catch (error) { reply({ ok: false, error: error.message }); }
+  });
+});
+server.maxConnections = 64;
+try { await new Promise((resolve, reject) => { server.once('error', reject); server.listen(connection.port, '127.0.0.1', resolve); }); }
+catch (error) {
+  // Concurrent pstart calls can create two candidates. Only the listener owner
+  // starts a daemon; a losing candidate never writes into the shared log.
+  console.error(`Cannot bind supervisor control port ${connection.port}: ${error.message}`);
+  log.destroy(); process.exit(1);
+}
+function killChildren() {
+  for (const pid of children) { try { process.kill(process.platform === 'win32' ? pid : -pid, 'SIGKILL'); } catch {} }
+  children.clear();
+}
+function launch() {
+  if (closing) return;
+  ready = false; heartbeat = Date.now();
+  const child = fork(fileURLToPath(new URL('./daemon.mjs', import.meta.url)), [connection.home], {
+    cwd: connection.home, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe', 'ipc'], env: environment(), execArgv: [],
+  });
+  daemon = child;
+  log.attach(child.stdout, 'supervisor'); log.attach(child.stderr, 'supervisor');
+  const started = Date.now();
+  child.on('message', message => {
+    if (message.type === 'ready') { ready = true; log.message(`Supervisor ready: watchdog ${process.pid}, daemon ${child.pid}`); }
+    if (message.type === 'heartbeat') heartbeat = Date.now();
+    if (message.type === 'child') { if (message.running) children.add(message.pid); else children.delete(message.pid); }
+    if (message.type === 'reply') { pending.get(message.id)?.(message); pending.delete(message.id); }
+  });
+  child.on('error', error => log.message(error.message));
+  child.once('exit', (code, signal) => {
+    ready = false; killChildren();
+    for (const reply of pending.values()) reply({ ok: false, error: 'Supervisor restarted during the command. Check prn pstatus before retrying.' });
+    pending.clear();
+    if (closing) return;
+    failures = Date.now() - started > 60000 ? 1 : failures + 1;
+    const wait = Math.min(30000, 500 * 2 ** Math.min(failures - 1, 6));
+    log.message(`Supervisor exited (${signal || code}); restart in ${wait} ms.`);
+    restartTimer = setTimeout(launch, wait);
+  });
+}
+const pulse = setInterval(() => {
+  if (!daemon?.connected || closing) return;
+  if (Date.now() - heartbeat > 15000) { log.message('Supervisor stopped responding; restarting.'); daemon.kill('SIGKILL'); }
+  else daemon.send({ type: 'heartbeat' }, () => {});
+}, 1000);
+async function shutdown() {
+  if (closing) return; closing = true; ready = false;
+  clearTimeout(restartTimer); clearInterval(pulse);
+  if (daemon?.connected) {
+    const exited = new Promise(resolve => daemon.once('exit', resolve));
+    daemon.send({ type: 'shutdown' }, () => {});
+    await Promise.race([exited, delay(65000)]);
+    if (daemon.exitCode === null && !daemon.signalCode) daemon.kill('SIGKILL');
+    await exited;
+  }
+  killChildren();
+  log.message('Supervisor stopped.');
+  await new Promise(resolve => log.end(resolve));
+  server.close();
+  for (const reply of shutdownReplies) reply({ ok: true, value: 'Supervisor stopped; enabled apps will return on the next launch.' });
+  await delay(50);
+  for (const socket of sockets) socket.destroy();
+  process.exit(0);
+}
+process.once('SIGTERM', () => void shutdown()); process.once('SIGINT', () => void shutdown());
+launch();

package/runtime/watch-project.mjs

@@ -1,4 +1,4 @@
-import { watch as watchDirectory } from 'node:fs';
+import { watch as watchDirectory, statSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import path from 'node:path';
 import { shouldWatchProjectFile } from './env.mjs';
@@ -9,13 +9,20 @@ const missing = error => error.code === 'ENOENT' || error.code === 'ENOTDIR';
 // including ignored build trees. Atomic build swaps can delete a descendant
 // during that scan. Watch only source directories, and handle removal races
 // in our own traversal. No file contents or node_modules watches are retained.
-export async function watchProject(root, { onChange, onError, ignore = () => false, watch = watchDirectory, maxDirectories = 8192, nativeRecursive = process.platform === 'darwin' }) {
-  // macOS has native recursive FSEvents support. Retain that backend: separate
-  // directory subscriptions can lose coalesced events during rapid renames.
+export async function watchProject(root, { onChange, onError, ignore = () => false, watch = watchDirectory, maxDirectories = 8192, nativeRecursive = process.platform === 'darwin' || process.platform === 'win32' }) {
+  // macOS and Windows have native recursive backends. Separate directory
+  // subscriptions can lose coalesced events during rapid renames.
   if (nativeRecursive) {
-    const watcher = watch(root, { recursive: true }, (_event, filename) => {
+    const watcher = watch(root, { recursive: true }, (event, filename) => {
       const relative = filename && String(filename).replaceAll(path.sep, '/');
-      if (relative && !ignore(relative) && shouldWatchProjectFile(relative)) onChange(relative);
+      if (!relative || ignore(relative) || !shouldWatchProjectFile(relative)) return;
+      if (process.platform === 'win32' && event === 'change') {
+        // ReadDirectoryChangesW reports directory metadata changes while the
+        // compiler reads sources. Creation/removal still arrives as rename.
+        // Rebuilding on those reads restarts the server (and its SSE stream).
+        try { if (statSync(path.join(root, relative)).isDirectory()) return; } catch {}
+      }
+      onChange(relative);
     });
     watcher.on('error', error => { watcher.close(); onError(error); });
     return { close: () => watcher.close(), async refresh() {} };