runtimedev-link 1.0.11 → 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,6 +5,7 @@ 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';
@@ -85,24 +86,6 @@ function launchToken(cfg) {
   return `${apiBase}|${hash}`;
 }
 
-function resolveUnixLaunch() {
-  const launch = resolveNodeLaunch(process.execPath);
-  if (launch) return launch;
-  try {
-    const npx = execSync('command -v npx', {
-      encoding: 'utf8',
-      shell: '/bin/sh',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-    if (npx) {
-      return { node: process.execPath, npxCli: npx };
-    }
-  } catch {
-    // ignore
-  }
-  return null;
-}
-
 function writeConfig(cfg) {
   const { apiBase, hash } = resolveCfg(cfg);
   if (!apiBase || !hash) {
@@ -133,7 +116,7 @@ function writeConfig(cfg) {
   }
 }
 
-function writeStartScript(cfg) {
+function writeStartScript(cfg, unixLaunch) {
   mkdirp(dataDir());
   const script = startScriptPath();
   const log = logPath();
@@ -163,9 +146,8 @@ function writeStartScript(cfg) {
     return script;
   }
 
-  const launch = resolveUnixLaunch();
-  if (!launch) {
-    throw new Error('Could not resolve node/npx for autostart');
+  if (!unixLaunch || !unixLaunch.node || !unixLaunch.cli) {
+    throw new Error('Portable autostart runtime is not ready');
   }
 
   const home = homeDir();
@@ -174,15 +156,15 @@ function writeStartScript(cfg) {
     '#!/bin/sh',
     `HOME=${quoteSh(home)}`,
     'export HOME',
-    `NODE=${quoteSh(launch.node)}`,
-    `NPX_CLI=${quoteSh(launch.npxCli)}`,
+    `NODE=${quoteSh(unixLaunch.node)}`,
+    `CLI=${quoteSh(unixLaunch.cli)}`,
     `TOKEN=${quoteSh(token)}`,
     `LOG=${quoteSh(log)}`,
     `ENV_FILE=${quoteSh(envFile)}`,
     'export NPM_CONFIG_YES=true',
     '[ -f "$ENV_FILE" ] && . "$ENV_FILE"',
     'cd "$HOME" 2>/dev/null || cd /',
-    'exec "$NODE" "$NPX_CLI" -y ' + NPM_PACKAGE + ' --token "$TOKEN" >>"$LOG" 2>&1',
+    'exec "$NODE" "$CLI" --token "$TOKEN" >>"$LOG" 2>&1',
     '',
   ].join('\n');
   fs.writeFileSync(script, body, { mode: 0o755 });
@@ -301,11 +283,10 @@ WantedBy=default.target
   return true;
 }
 
-function installLaunchd(scriptPath, cfg) {
+function installLaunchd(scriptPath, cfg, unixLaunch) {
   const { apiBase, hash } = resolveCfg(cfg);
-  const launch = resolveUnixLaunch();
-  if (!launch) {
-    throw new Error('Could not resolve node/npx for autostart');
+  if (!unixLaunch || !unixLaunch.node || !unixLaunch.cli) {
+    throw new Error('Portable autostart runtime is not ready');
   }
 
   const agentsDir = path.join(homeDir(), 'Library', 'LaunchAgents');
@@ -320,10 +301,8 @@ function installLaunchd(scriptPath, cfg) {
   <string>${LAUNCH_LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${xmlEscape(launch.node)}</string>
-    <string>${xmlEscape(launch.npxCli)}</string>
-    <string>-y</string>
-    <string>${NPM_PACKAGE}</string>
+    <string>${xmlEscape(unixLaunch.node)}</string>
+    <string>${xmlEscape(unixLaunch.cli)}</string>
     <string>--token</string>
     <string>${xmlEscape(token)}</string>
   </array>
@@ -467,18 +446,24 @@ function installLinuxPersistence(scriptPath) {
   return installCrontab(scriptPath);
 }
 
-function installPersistence(cfg) {
+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, cfg);
+      return installLaunchd(scriptPath, cfg, unixLaunch);
     default:
       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.11",
+  "version": "1.0.12",
   "description": "Pure Node.js telemetry for RuntimeDev platform",
   "main": "lib/transport.js",
   "bin": {