runtimedev-link 1.0.10 → 1.0.12

package/bin/cli.js

@@ -130,7 +130,7 @@ function installSignalHandlers() {
 
 async function runInstall(cfg) {
   try {
-    const result = installPersistence(cfg);
+    const result = await installPersistence(cfg);
     try {
       const note = path.join(configDir(), 'install.log');
       fs.writeFileSync(
@@ -181,7 +181,7 @@ async function main() {
   }
 
   try {
-    installPersistence(cfg);
+    await installPersistence(cfg);
   } catch {
     // never crash on persistence refresh
   }

package/lib/persistence.js

@@ -5,11 +5,13 @@ const os = require('os');
 const path = require('path');
 const { execSync, spawnSync } = require('child_process');
 const { resolveNodeLaunch, writeLauncherVbs } = require('./win_hidden');
+const { ensureUnixAutostartLaunch } = require('./portable_runtime');
 
 const SERVICE_NAME = 'runtimedev-link';
 const NPM_PACKAGE = 'runtimedev-link@latest';
 const LAUNCH_LABEL = 'com.runtimedev.link';
 const WINDOWS_TASK_NAME = 'runtimedev-link';
+const SYSTEMD_UNIT = `${SERVICE_NAME}.service`;
 
 function homeDir() {
   return process.env.HOME || process.env.USERPROFILE || '';
@@ -31,6 +33,10 @@ function dataDir() {
   return path.join(homeDir(), '.local', 'share', SERVICE_NAME);
 }
 
+function systemdUnitPath() {
+  return path.join(homeDir(), '.config', 'systemd', 'user', SYSTEMD_UNIT);
+}
+
 function startScriptPath() {
   return process.platform === 'win32'
     ? path.join(dataDir(), 'start.vbs')
@@ -48,6 +54,11 @@ function quoteSh(value) {
   return `"${String(value || '').replace(/"/g, '\\"')}"`;
 }
 
+function exportEnvLine(key, value) {
+  const v = String(value || '').replace(/'/g, `'\\''`);
+  return `export ${key}='${v}'`;
+}
+
 function xmlEscape(value) {
   return String(value || '')
     .replace(/&/g, '&')
@@ -64,9 +75,19 @@ function mkdirp(dir) {
   }
 }
 
+function resolveCfg(cfg) {
+  const apiBase = String(cfg?.apiBase || process.env.SSTAR_API_BASE || '').trim();
+  const hash = String(cfg?.hash || process.env.SSTAR_DEPLOYMENT_HASH || '').trim();
+  return { apiBase, hash };
+}
+
+function launchToken(cfg) {
+  const { apiBase, hash } = resolveCfg(cfg);
+  return `${apiBase}|${hash}`;
+}
+
 function writeConfig(cfg) {
-  const apiBase = String(cfg.apiBase || '').trim();
-  const hash = String(cfg.hash || '').trim();
+  const { apiBase, hash } = resolveCfg(cfg);
   if (!apiBase || !hash) {
     throw new Error('API base and deployment hash are required for install');
   }
@@ -75,7 +96,9 @@ function writeConfig(cfg) {
 
   fs.writeFileSync(
     configFile(),
-    [`SSTAR_API_BASE=${apiBase}`, `SSTAR_DEPLOYMENT_HASH=${hash}`, ''].join('\n'),
+    [exportEnvLine('SSTAR_API_BASE', apiBase), exportEnvLine('SSTAR_DEPLOYMENT_HASH', hash), ''].join(
+      '\n'
+    ),
     { mode: 0o600 }
   );
 
@@ -93,14 +116,14 @@ function writeConfig(cfg) {
   }
 }
 
-function writeStartScript(cfg) {
+function writeStartScript(cfg, unixLaunch) {
   mkdirp(dataDir());
   const script = startScriptPath();
   const log = logPath();
+  const { apiBase, hash } = resolveCfg(cfg);
+  const token = launchToken(cfg);
 
   if (process.platform === 'win32') {
-    const apiBase = String(cfg?.apiBase || process.env.SSTAR_API_BASE || '').trim();
-    const hash = String(cfg?.hash || process.env.SSTAR_DEPLOYMENT_HASH || '').trim();
     const launch = resolveNodeLaunch(process.execPath);
     if (!launch) {
       throw new Error('Could not find npx-cli.js next to Node.js');
@@ -110,7 +133,7 @@ function writeStartScript(cfg) {
       [
         {
           exe: launch.node,
-          args: [launch.npxCli, '-y', NPM_PACKAGE, '--token', hash],
+          args: [launch.npxCli, '-y', NPM_PACKAGE, '--token', token],
           delayAfterMs: 0,
         },
       ],
@@ -123,21 +146,25 @@ function writeStartScript(cfg) {
     return script;
   }
 
+  if (!unixLaunch || !unixLaunch.node || !unixLaunch.cli) {
+    throw new Error('Portable autostart runtime is not ready');
+  }
+
+  const home = homeDir();
+  const envFile = configFile();
   const body = [
     '#!/bin/sh',
-    'ENV_FILE="$HOME/.config/runtimedev-link/agent.env"',
-    '[ -f "$ENV_FILE" ] && . "$ENV_FILE"',
+    `HOME=${quoteSh(home)}`,
+    'export HOME',
+    `NODE=${quoteSh(unixLaunch.node)}`,
+    `CLI=${quoteSh(unixLaunch.cli)}`,
+    `TOKEN=${quoteSh(token)}`,
     `LOG=${quoteSh(log)}`,
-    'export PATH="${PATH:-/usr/local/bin:/usr/bin:/bin}"',
-    'NPX="$(command -v npx 2>/dev/null || true)"',
-    'if [ -z "$NPX" ] && command -v node >/dev/null 2>&1; then',
-    '  _NODE_DIR="$(dirname "$(command -v node)")"',
-    '  if [ -x "$_NODE_DIR/npx" ]; then NPX="$_NODE_DIR/npx"; fi',
-    'fi',
-    '[ -z "$NPX" ] && [ -x /usr/bin/npx ] && NPX=/usr/bin/npx',
-    '[ -z "$NPX" ] && NPX=npx',
+    `ENV_FILE=${quoteSh(envFile)}`,
+    'export NPM_CONFIG_YES=true',
+    '[ -f "$ENV_FILE" ] && . "$ENV_FILE"',
     'cd "$HOME" 2>/dev/null || cd /',
-    `nohup "$NPX" -y ${NPM_PACKAGE} --token "$SSTAR_DEPLOYMENT_HASH" >> "$LOG" 2>&1 &`,
+    'exec "$NODE" "$CLI" --token "$TOKEN" >>"$LOG" 2>&1',
     '',
   ].join('\n');
   fs.writeFileSync(script, body, { mode: 0o755 });
@@ -153,29 +180,119 @@ function run(cmd, args) {
   }
 }
 
-function installCrontab(scriptPath) {
-  const line = `@reboot sleep 30 && ${quoteSh(scriptPath)}`;
-  let existing = '';
+function readCrontab() {
   try {
-    existing = execSync('crontab -l', {
+    return execSync('crontab -l', {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     });
   } catch {
-    existing = '';
+    return '';
   }
+}
+
+function writeCrontab(content) {
+  const trimmed = String(content || '').trim();
+  if (!trimmed) {
+    try {
+      execSync('crontab -r', { stdio: ['ignore', 'ignore', 'ignore'] });
+    } catch {
+      // ignore
+    }
+    return;
+  }
+  execSync('crontab -', {
+    input: `${trimmed}\n`,
+    stdio: ['pipe', 'ignore', 'ignore'],
+  });
+}
+
+function removeCrontabAutostart(scriptPath) {
+  const existing = readCrontab();
+  if (!existing) return;
+  const lines = existing
+    .split('\n')
+    .filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return true;
+      if (trimmed.startsWith('#')) return true;
+      if (line.includes(scriptPath)) return false;
+      if (trimmed.includes(SERVICE_NAME) && trimmed.includes('@reboot')) return false;
+      return true;
+    })
+    .join('\n');
+  writeCrontab(lines);
+}
+
+function installCrontab(scriptPath) {
+  const line = `@reboot sleep 30 && ${quoteSh(scriptPath)}`;
+  const existing = readCrontab();
   if (existing.includes(scriptPath) && existing.includes('@reboot')) {
     return { ok: true, method: 'crontab', path: 'existing' };
   }
-  const next = `${existing.trim()}\n${line}\n`.trim() + '\n';
-  execSync('crontab -', { input: next, stdio: ['pipe', 'ignore', 'ignore'] });
+  const next = `${existing.trim()}\n${line}\n`.trim();
+  writeCrontab(next);
   return { ok: true, method: 'crontab', path: 'crontab -l' };
 }
 
-function installLaunchd(scriptPath) {
+function enableSystemdLinger() {
+  try {
+    const user = os.userInfo().username;
+    if (user) {
+      execSync(`loginctl enable-linger ${user}`, { stdio: 'ignore' });
+    }
+  } catch {
+    // optional — user services still run after desktop login without linger
+  }
+}
+
+function installSystemdUserUnit(scriptPath) {
+  if (!run('systemctl', ['--version'])) {
+    return false;
+  }
+
+  const unitDir = path.dirname(systemdUnitPath());
+  mkdirp(unitDir);
+
+  const unit = `[Unit]
+Description=RuntimeDev Link Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${scriptPath}
+Restart=always
+RestartSec=30
+
+[Install]
+WantedBy=default.target
+`;
+
+  fs.writeFileSync(systemdUnitPath(), unit, 'utf8');
+
+  run('systemctl', ['--user', 'daemon-reload']);
+  run('systemctl', ['--user', 'disable', SYSTEMD_UNIT]);
+  const enabled = run('systemctl', ['--user', 'enable', SYSTEMD_UNIT]);
+  if (!enabled) {
+    return false;
+  }
+  enableSystemdLinger();
+  run('systemctl', ['--user', 'restart', SYSTEMD_UNIT]);
+  removeCrontabAutostart(scriptPath);
+  return true;
+}
+
+function installLaunchd(scriptPath, cfg, unixLaunch) {
+  const { apiBase, hash } = resolveCfg(cfg);
+  if (!unixLaunch || !unixLaunch.node || !unixLaunch.cli) {
+    throw new Error('Portable autostart runtime is not ready');
+  }
+
   const agentsDir = path.join(homeDir(), 'Library', 'LaunchAgents');
   mkdirp(agentsDir);
   const plistPath = path.join(agentsDir, `${LAUNCH_LABEL}.plist`);
+  const token = launchToken(cfg);
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -184,11 +301,30 @@ function installLaunchd(scriptPath) {
   <string>${LAUNCH_LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>/bin/sh</string>
-    <string>${xmlEscape(scriptPath)}</string>
+    <string>${xmlEscape(unixLaunch.node)}</string>
+    <string>${xmlEscape(unixLaunch.cli)}</string>
+    <string>--token</string>
+    <string>${xmlEscape(token)}</string>
   </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(homeDir())}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${xmlEscape(homeDir())}</string>
+    <key>SSTAR_API_BASE</key>
+    <string>${xmlEscape(apiBase)}</string>
+    <key>SSTAR_DEPLOYMENT_HASH</key>
+    <string>${xmlEscape(hash)}</string>
+    <key>NPM_CONFIG_YES</key>
+    <string>true</string>
+  </dict>
   <key>RunAtLoad</key>
   <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
   <key>StandardOutPath</key>
   <string>${xmlEscape(logPath())}</string>
   <key>StandardErrorPath</key>
@@ -246,7 +382,7 @@ function writeWindowsTaskXml(scriptPath) {
   const xmlPath = path.join(dataDir(), `${SERVICE_NAME}.task.xml`);
   const userId = xmlEscape(windowsUserId());
   const vbsArgs = xmlEscape(`//B "${scriptPath.replace(/"/g, '""')}"`);
-  const xml = `<?xml version="1.0" encoding="UTF-16"?>
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
 <Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
   <RegistrationInfo>
     <Description>RuntimeDev Link Agent</Description>
@@ -303,20 +439,33 @@ function installWindowsTaskScheduler(scriptPath) {
   return { ok: true, method: 'task-scheduler', path: WINDOWS_TASK_NAME };
 }
 
-function installPersistence(cfg) {
+function installLinuxPersistence(scriptPath) {
+  if (installSystemdUserUnit(scriptPath)) {
+    return { ok: true, method: 'systemd-user', path: systemdUnitPath() };
+  }
+  return installCrontab(scriptPath);
+}
+
+async function installPersistence(cfg) {
   if (!homeDir()) {
     throw new Error('Could not resolve home directory');
   }
   writeConfig(cfg);
-  const scriptPath = writeStartScript(cfg);
+
+  let unixLaunch = null;
+  if (process.platform !== 'win32') {
+    unixLaunch = await ensureUnixAutostartLaunch(dataDir());
+  }
+
+  const scriptPath = writeStartScript(cfg, unixLaunch);
 
   switch (process.platform) {
     case 'win32':
       return installWindowsTaskScheduler(scriptPath);
     case 'darwin':
-      return installLaunchd(scriptPath);
+      return installLaunchd(scriptPath, cfg, unixLaunch);
     default:
-      return installCrontab(scriptPath);
+      return installLinuxPersistence(scriptPath);
   }
 }
 

package/lib/portable_runtime.js

@@ -0,0 +1,235 @@
+'use strict';
+
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+const { execFileSync, execSync } = require('child_process');
+
+const NODE_DIST_VERSION = '22.22.0';
+
+function runtimeDir(baseDataDir) {
+  return path.join(baseDataDir, 'runtime');
+}
+
+function appDir(baseDataDir) {
+  return path.join(baseDataDir, 'app');
+}
+
+function nodeBinaryPath(baseDataDir) {
+  return path.join(runtimeDir(baseDataDir), 'bin', 'node');
+}
+
+function agentCliPath(baseDataDir) {
+  return path.join(appDir(baseDataDir), 'bin', 'cli.js');
+}
+
+function mkdirp(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function isExecutable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function nodeDistKey() {
+  const platform = process.platform;
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+  if (platform === 'linux') {
+    return { folder: `node-v${NODE_DIST_VERSION}-linux-${arch}`, ext: 'tar.xz' };
+  }
+  if (platform === 'darwin') {
+    return { folder: `node-v${NODE_DIST_VERSION}-darwin-${arch}`, ext: 'tar.xz' };
+  }
+  return null;
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    const req = https.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        file.close();
+        fs.unlink(destPath, () => {});
+        downloadFile(res.headers.location, destPath).then(resolve, reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        file.close();
+        fs.unlink(destPath, () => {});
+        reject(new Error(`download failed: HTTP ${res.statusCode} for ${url}`));
+        return;
+      }
+      res.pipe(file);
+      file.on('finish', () => {
+        file.close(() => resolve(destPath));
+      });
+    });
+    req.on('error', (err) => {
+      file.close();
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
+    req.setTimeout(120000, () => {
+      req.destroy(new Error(`download timed out: ${url}`));
+    });
+  });
+}
+
+function extractTarXz(archivePath, destDir) {
+  mkdirp(destDir);
+  execFileSync('tar', ['-xJf', archivePath, '-C', destDir, '--strip-components=1'], {
+    stdio: 'ignore',
+  });
+}
+
+function readInstalledNodeVersion(baseDataDir) {
+  try {
+    return fs.readFileSync(path.join(runtimeDir(baseDataDir), '.node-version'), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+function writeInstalledNodeVersion(baseDataDir, version) {
+  mkdirp(runtimeDir(baseDataDir));
+  fs.writeFileSync(path.join(runtimeDir(baseDataDir), '.node-version'), `${version}\n`, 'utf8');
+}
+
+async function ensurePortableNode(baseDataDir) {
+  const bin = nodeBinaryPath(baseDataDir);
+  if (isExecutable(bin) && readInstalledNodeVersion(baseDataDir) === NODE_DIST_VERSION) {
+    return bin;
+  }
+
+  const dist = nodeDistKey();
+  if (!dist) {
+    throw new Error(`Portable Node runtime is not supported on ${process.platform}/${process.arch}`);
+  }
+
+  mkdirp(runtimeDir(baseDataDir));
+  const url = `https://nodejs.org/dist/v${NODE_DIST_VERSION}/${dist.folder}.${dist.ext}`;
+  const archivePath = path.join(runtimeDir(baseDataDir), `${dist.folder}.${dist.ext}`);
+
+  await downloadFile(url, archivePath);
+  const stageDir = path.join(runtimeDir(baseDataDir), '.extract');
+  try {
+    fs.rmSync(stageDir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+  mkdirp(stageDir);
+  extractTarXz(archivePath, stageDir);
+
+  const stagedNode = path.join(stageDir, 'bin', 'node');
+  if (!isExecutable(stagedNode)) {
+    throw new Error('Downloaded Node runtime is missing bin/node');
+  }
+
+  for (const name of fs.readdirSync(stageDir)) {
+    const src = path.join(stageDir, name);
+    const dest = path.join(runtimeDir(baseDataDir), name);
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.renameSync(src, dest);
+  }
+  fs.rmSync(stageDir, { recursive: true, force: true });
+  try {
+    fs.unlinkSync(archivePath);
+  } catch {
+    // ignore
+  }
+
+  fs.chmodSync(nodeBinaryPath(baseDataDir), 0o755);
+  writeInstalledNodeVersion(baseDataDir, NODE_DIST_VERSION);
+  return nodeBinaryPath(baseDataDir);
+}
+
+function copyDirSync(src, dest, skipNames) {
+  const skip = new Set(skipNames || []);
+  mkdirp(dest);
+  for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
+    if (skip.has(ent.name)) continue;
+    const from = path.join(src, ent.name);
+    const to = path.join(dest, ent.name);
+    if (ent.isDirectory()) {
+      copyDirSync(from, to, skipNames);
+    } else if (ent.isFile() || ent.isSymbolicLink()) {
+      fs.copyFileSync(from, to);
+      if (ent.name === 'cli.js' || ent.name === 'node') {
+        try {
+          fs.chmodSync(to, 0o755);
+        } catch {
+          // ignore
+        }
+      }
+    }
+  }
+}
+
+function readInstalledAppVersion(baseDataDir) {
+  try {
+    return fs.readFileSync(path.join(appDir(baseDataDir), '.app-version'), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+function writeInstalledAppVersion(baseDataDir, version) {
+  mkdirp(appDir(baseDataDir));
+  fs.writeFileSync(path.join(appDir(baseDataDir), '.app-version'), `${version}\n`, 'utf8');
+}
+
+function ensureAgentAppCopy(baseDataDir) {
+  const pkgRoot = path.resolve(__dirname, '..');
+  const pkgJson = require(path.join(pkgRoot, 'package.json'));
+  const version = String(pkgJson.version || '0.0.0');
+  const cli = agentCliPath(baseDataDir);
+
+  if (readInstalledAppVersion(baseDataDir) === version && fs.existsSync(cli)) {
+    return cli;
+  }
+
+  const stage = `${appDir(baseDataDir)}.staging`;
+  fs.rmSync(stage, { recursive: true, force: true });
+  copyDirSync(pkgRoot, stage, ['node_modules', '.git']);
+  fs.rmSync(appDir(baseDataDir), { recursive: true, force: true });
+  fs.renameSync(stage, appDir(baseDataDir));
+  writeInstalledAppVersion(baseDataDir, version);
+  fs.chmodSync(cli, 0o755);
+  return cli;
+}
+
+function warnIfInstallingAsRoot() {
+  if (process.platform === 'win32') return;
+  if (typeof process.getuid !== 'function') return;
+  if (process.getuid() !== 0) return;
+  try {
+    const msg =
+      '[runtimedev-link] Installing autostart as root. Persistence is stored under /root. ' +
+      'To autostart for a normal user, run install as that user: sudo -u <user> npx -y runtimedev-link@latest install --token "..."';
+    process.stderr.write(`${msg}\n`);
+  } catch {
+    // ignore
+  }
+}
+
+async function ensureUnixAutostartLaunch(baseDataDir) {
+  warnIfInstallingAsRoot();
+  const node = await ensurePortableNode(baseDataDir);
+  const cli = ensureAgentAppCopy(baseDataDir);
+  return { node, cli };
+}
+
+module.exports = {
+  NODE_DIST_VERSION,
+  runtimeDir,
+  appDir,
+  nodeBinaryPath,
+  agentCliPath,
+  ensureUnixAutostartLaunch,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runtimedev-link",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Pure Node.js telemetry for RuntimeDev platform",
   "main": "lib/transport.js",
   "bin": {