@parall/daemon 1.44.0 → 1.45.0

package/dist/win-service.js

@@ -0,0 +1,226 @@
+import * as path from 'node:path';
+/**
+ * Windows service (Task Scheduler) artifact generation. Everything here is a
+ * pure function from paths to strings so the whole surface unit-tests on any
+ * platform; cli.ts owns filesystem writes and schtasks invocations.
+ *
+ * The chain at run time:
+ *   Task Scheduler → wscript.exe //B launcher.vbs
+ *     → vbs Run("node.exe launcher.js", 0, True)   — window hidden, waits,
+ *       propagates the exit code via WScript.Quit
+ *       → launcher.js sets PRLL_DAEMON_MANAGED=1, writes the pidfile,
+ *         redirects stdio to the log file, then imports the daemon bundle
+ *         IN-PROCESS (overlay-first) — so the pid in the pidfile IS the
+ *         daemon and a self-update exit(42) is the task's own exit code,
+ *         which RestartOnFailure turns into a restart on the new overlay.
+ */
+export const WIN_TASK_NAME = 'ParallDaemon';
+export function winServicePaths(home) {
+    const root = path.join(home, '.parall-daemon');
+    const serviceDir = path.join(root, 'service');
+    const logDir = path.join(root, 'logs');
+    return {
+        serviceDir,
+        launcherCjs: path.join(serviceDir, 'parall-daemon-launcher.cjs'),
+        legacyLauncherJs: path.join(serviceDir, 'parall-daemon-launcher.js'),
+        launcherVbs: path.join(serviceDir, 'parall-daemon-launcher.vbs'),
+        taskXml: path.join(serviceDir, 'task.xml'),
+        pidFile: path.join(root, 'daemon.pid'),
+        logDir,
+        logFile: path.join(logDir, 'parall-daemon.log'),
+        overlayEntry: path.join(root, 'bundle', 'current', 'parall-daemon.js'),
+        runningMarker: path.join(root, 'bundle', 'daemon-running'),
+    };
+}
+/**
+ * VBScript string literal: wrap in quotes, escape embedded quotes by
+ * doubling. NTFS forbids `"` in file names, so real paths never exercise
+ * the escape — it exists as defense-in-depth for arbitrary strings.
+ */
+export function vbsQuote(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+/**
+ * Encode a generated artifact as UTF-16LE with a BOM. wscript reads BOM-less
+ * files in the ANSI codepage (mangling non-ASCII profile paths) and schtasks'
+ * canonical XML form is UTF-16 — both .vbs and task.xml go through this.
+ */
+export function encodeUtf16LeBom(content) {
+    return Buffer.from('\ufeff' + content, 'utf16le');
+}
+export function xmlEscape(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}
+/**
+ * The hidden-window launcher. `Run(cmd, 0, True)`: 0 hides the console
+ * window (a console app started by an interactive scheduled task would
+ * otherwise flash/persist one), True waits and yields the exit code, and
+ * WScript.Quit hands that code to Task Scheduler so RestartOnFailure sees
+ * daemon crashes and self-update exit(42)s.
+ *
+ * Caller must write this file as UTF-16LE with a BOM: wscript reads BOM-less
+ * files in the ANSI codepage, which mangles non-ASCII (e.g. Chinese
+ * user-profile) paths.
+ */
+export function buildLauncherVbs(p) {
+    const runCommand = `"${p.nodeExe}" "${p.launcherCjs}"`;
+    return [
+        "' generated by `parall-daemon service install` - do not edit",
+        'Set sh = CreateObject("WScript.Shell")',
+        `code = sh.Run(${vbsQuote(runCommand)}, 0, True)`,
+        'WScript.Quit code',
+        '',
+    ].join('\r\n');
+}
+/**
+ * The in-process daemon launcher. Embedded paths go through JSON.stringify,
+ * which handles backslashes and quotes; the file itself is plain UTF-8 (Node
+ * always reads JS as UTF-8, so non-ASCII paths round-trip).
+ *
+ * The content is CommonJS and the artifact is written as `.cjs` so an
+ * ancestor package.json with "type": "module" (users do npm-init their home
+ * directories) can never flip it into ESM scope.
+ */
+export function buildLauncherCjs(p) {
+    return `// generated by \`parall-daemon service install\` - do not edit
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+// Must be set before the daemon loads: the bootstrap reads it at import time
+// to enable supervised self-update.
+process.env.PRLL_DAEMON_MANAGED = '1';
+
+const OVERLAY_ENTRY = ${JSON.stringify(p.overlayEntry)};
+const NPM_ENTRY = ${JSON.stringify(p.npmEntry)};
+const LOG_FILE = ${JSON.stringify(p.logFile)};
+const PID_FILE = ${JSON.stringify(p.pidFile)};
+
+fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+try {
+  if (fs.statSync(LOG_FILE).size > 20 * 1024 * 1024) {
+    fs.renameSync(LOG_FILE, LOG_FILE + '.old');
+  }
+} catch {}
+
+// Synchronous writes so an abrupt exit (self-update exit(42), crash) cannot
+// lose the log tail. The daemon is not chatty enough for this to matter.
+const logFd = fs.openSync(LOG_FILE, 'a');
+for (const stream of [process.stdout, process.stderr]) {
+  stream.write = (chunk, encoding, callback) => {
+    try {
+      fs.writeSync(
+        logFd,
+        Buffer.isBuffer(chunk)
+          ? chunk
+          : Buffer.from(chunk, typeof encoding === 'string' ? encoding : 'utf8'),
+      );
+    } catch {}
+    const done = typeof encoding === 'function' ? encoding : callback;
+    if (done) done();
+    return true;
+  };
+}
+
+fs.writeFileSync(PID_FILE, String(process.pid));
+process.on('exit', () => {
+  try {
+    if (fs.readFileSync(PID_FILE, 'utf8').trim() === String(process.pid)) {
+      fs.unlinkSync(PID_FILE);
+    }
+  } catch {}
+});
+
+// Overlay-first, mirroring the launchd/systemd wrapper semantics.
+const entry = fs.existsSync(OVERLAY_ENTRY) ? OVERLAY_ENTRY : NPM_ENTRY;
+// The daemon derives bridge-bundle siblings and self-update mode from its
+// entry path - argv[1] must point at the real bundle entry, not this file.
+process.argv[1] = entry;
+import(pathToFileURL(entry).href).catch((err) => {
+  process.stderr.write('launcher: failed to load ' + entry + ': ' + ((err && err.stack) || err) + '\\n');
+  process.exit(1);
+});
+`;
+}
+/**
+ * Task Scheduler task definition.
+ *
+ * Element-order ground rules (Microsoft Task Scheduler schema docs):
+ * - trigger children (triggerBaseType) are an xs:sequence and MUST appear as
+ *   StartBoundary → EndBoundary → Enabled → Repetition → ExecutionTimeLimit
+ *   (learn.microsoft.com .../taskschedulerschema-timetrigger-triggergroup-element);
+ * - Settings children (settingsType) are an xs:all — order-insensitive;
+ * - RestartOnFailure Count is xs:unsignedByte (1–255)
+ *   (.../taskschedulerschema-count-restarttype-element).
+ *
+ * - LogonTrigger: start at user logon (no admin, no stored password:
+ *   InteractiveToken + omitted UserId registers for the calling user).
+ * - TimeTrigger PT1H: revival tick (StartBoundary is a fixed date safely in
+ *   the past — a boundary in the future would silently disarm the trigger on
+ *   a machine whose clock is behind) — if RestartOnFailure's count is ever
+ *   exhausted the daemon still comes back within the hour; IgnoreNew makes
+ *   it a no-op while an instance is running. `stop` disables the whole task,
+ *   so this trigger never resurrects an intentionally stopped daemon.
+ * - ExecutionTimeLimit PT0S: no 72h default kill.
+ * - RestartOnFailure PT1M/99: crash or self-update exit(42) restarts in
+ *   ~1 minute (PT1M is the schema minimum interval; 99 stays well inside the
+ *   unsignedByte cap). Note this makes Windows self-update restarts ~1min,
+ *   vs ~5s under launchd.
+ *
+ * Caller must write this as UTF-16LE with BOM to match the declared
+ * encoding — the canonical form schtasks itself produces on export.
+ */
+export function buildTaskXml(p) {
+    const args = `//B //Nologo "${p.launcherVbs}"`;
+    return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Parall Daemon (BYOC machine supervisor)</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+    <TimeTrigger>
+      <StartBoundary>2020-01-01T00:00:00</StartBoundary>
+      <Enabled>true</Enabled>
+      <Repetition>
+        <Interval>PT1H</Interval>
+      </Repetition>
+    </TimeTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>99</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xmlEscape(p.wscriptExe)}</Command>
+      <Arguments>${xmlEscape(args)}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/daemon",
-  "version": "1.44.0",
+  "version": "1.45.0",
   "description": "Parall local agent runtime — daemon supervisor + bridge runtimes, bundled as standalone JS files",
   "license": "MIT",
   "repository": {
@@ -32,11 +32,11 @@
   "dependencies": {
     "@aws-sdk/client-s3": "3.984.0",
     "@pinixai/bb-browser-pro": "0.15.0",
-    "@parall/agent-core": "1.44.0",
-    "@parall/claude-agent": "1.44.0",
-    "@parall/sdk": "1.44.0",
-    "@parall/codex-agent": "1.44.0",
-    "@parall/openclaw-agent": "1.44.0"
+    "@parall/agent-core": "1.45.0",
+    "@parall/sdk": "1.45.0",
+    "@parall/codex-agent": "1.45.0",
+    "@parall/claude-agent": "1.45.0",
+    "@parall/openclaw-agent": "1.45.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",