apintergrationpost 4.0.5 → 4.0.6

package/package.json

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

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

@@ -10,23 +10,24 @@ const MAX_FRAME_BYTES = 768 * 1024;
 const FRAME_WATCHDOG_MS = 10000;
 
 function resolveFfmpegPath() {
-  const probe = spawnSync('sh', ['-c', 'ffmpeg -hide_banner -devices 2>&1 | grep x11grab || true'], {
-    encoding: 'utf8',
-  });
-  if (probe.stdout && probe.stdout.includes('x11grab')) {
-    return 'ffmpeg';
-  }
+  if (!hasCommand('ffmpeg')) return null;
 
-  try {
-    const bundled = require('ffmpeg-static');
-    if (bundled && typeof bundled === 'string') return bundled;
-  } catch {
-    // ignore
-  }
+  const devices = spawnSync('sh', ['-c', 'ffmpeg -hide_banner -devices 2>&1'], { encoding: 'utf8' });
+  if (!devices.stdout || !devices.stdout.includes('x11grab')) return null;
+
+  const encoders = spawnSync('sh', ['-c', 'ffmpeg -hide_banner -encoders 2>&1'], { encoding: 'utf8' });
+  if (!encoders.stdout || !encoders.stdout.includes('mjpeg')) return null;
 
   return 'ffmpeg';
 }
 
+function detectImageMime(buffer) {
+  if (!buffer || buffer.length < 4) return 'application/octet-stream';
+  if (buffer[0] === 0xff && buffer[1] === 0xd8) return 'image/jpeg';
+  if (buffer[0] === 0x89 && buffer[1] === 0x50) return 'image/png';
+  return 'application/octet-stream';
+}
+
 function buildScaleFilter(maxWidth, maxHeight) {
   return `scale='min(${maxWidth},iw)':'min(${maxHeight},ih)':force_original_aspect_ratio=decrease`;
 }
@@ -88,6 +89,7 @@ class ScreenStream extends EventEmitter {
     this._frameWatchdog = null;
     this._grimTimer = null;
     this._grimBusy = false;
+    this._grimFailures = 0;
   }
 
   getStatus() {
@@ -119,12 +121,13 @@ class ScreenStream extends EventEmitter {
     this._frameWatchdog = setTimeout(() => {
       if (!this._gotFrame) {
         const ctx = this.captureCtx || {};
-        const hint = ctx.sessionType === 'wayland' && !ctx.grimAvailable
-          ? ' Ubuntu Wayland detected — install grim: apt install grim'
+        const hint = ctx.sessionType === 'wayland'
+          ? ' Ensure you are logged into the desktop GUI (Wayland session).'
           : ' Log into the desktop GUI and run: xhost +local: (as desktop user)';
+        const detail = this._stderr ? this._stderr.trim().slice(0, 240) : '';
         this.emit('error', new Error(
-          `No screen frames received (${this.backend}, DISPLAY=${ctx.display || '?'}, user=${ctx.runAsUser || ctx.user || '?'}).${hint}`
-          + (this._stderr ? ` ffmpeg: ${this._stderr.trim().slice(0, 180)}` : '')
+          `No screen frames received (${this.backend}, user=${ctx.runAsUser || ctx.user || '?'}).${hint}`
+          + (detail ? ` Capture error: ${detail}` : '')
         ));
         this.stop();
       }
@@ -147,11 +150,16 @@ class ScreenStream extends EventEmitter {
     }
 
     this.backend = 'x11grab';
-    this._startFfmpeg(this.captureCtx.x11Env);
+    const ffmpegPath = resolveFfmpegPath();
+    if (!ffmpegPath) {
+      throw new Error(
+        'System ffmpeg with x11grab and mjpeg support required. Run: apt install ffmpeg'
+      );
+    }
+    this._startFfmpeg(this.captureCtx.x11Env, ffmpegPath);
   }
 
-  _startFfmpeg(env) {
-    const ffmpegPath = resolveFfmpegPath();
+  _startFfmpeg(env, ffmpegPath) {
     const ffmpegArgs = buildFfmpegArgs({
       fps: this.fps,
       maxWidth: this.maxWidth,
@@ -193,6 +201,20 @@ class ScreenStream extends EventEmitter {
     this._grimTimer = setInterval(() => this._captureGrimFrame(), intervalMs);
   }
 
+  _emitFrameObject(buffer, mime) {
+    if (buffer.length < 500) return;
+
+    if (buffer.length > MAX_FRAME_BYTES && mime === 'image/jpeg') {
+      if (this.bumpQuality()) {
+        this.emit('quality-adjusted', { jpegQuality: this.jpegQuality });
+        return;
+      }
+    }
+
+    this._markFrame();
+    this.emit('frame', { buffer, mime: mime || detectImageMime(buffer) });
+  }
+
   _captureGrimFrame() {
     if (!this.running || this._grimBusy) return;
     if (!hasCommand('grim')) {
@@ -205,21 +227,34 @@ class ScreenStream extends EventEmitter {
     const proc = spawnAsUser(
       this.captureCtx.runAsUser,
       'grim',
-      ['-t', 'jpeg', '-'],
+      ['-'],
       this.captureCtx.waylandEnv,
     );
 
     const chunks = [];
     proc.stdout.on('data', (c) => chunks.push(c));
-    proc.stderr.on('data', (c) => { this._stderr += c.toString(); });
+    proc.stderr.on('data', (c) => {
+      const line = c.toString().trim();
+      if (line) this._stderr = `${this._stderr}${line}\n`.slice(-2000);
+    });
 
     proc.on('close', (code) => {
       this._grimBusy = false;
-      if (code !== 0) return;
+      if (code !== 0) {
+        this._grimFailures += 1;
+        if (this._grimFailures >= 3) {
+          const detail = this._stderr.trim() || `grim exited ${code}`;
+          this.emit('error', new Error(
+            `grim capture failed for user ${this.captureCtx.runAsUser || this.captureCtx.user}: ${detail}`
+          ));
+          this.stop();
+        }
+        return;
+      }
+      this._grimFailures = 0;
       const frame = Buffer.concat(chunks);
       if (frame.length > 100) {
-        this._markFrame();
-        this.emit('frame', frame);
+        this._emitFrameObject(frame, 'image/png');
       }
     });
 
@@ -314,22 +349,12 @@ class ScreenStream extends EventEmitter {
 
       const frame = this.buffer.subarray(0, end + 2);
       this.buffer = this.buffer.subarray(end + 2);
-      this._emitFrame(frame);
+      this._emitFrameObject(frame, 'image/jpeg');
     }
   }
 
   _emitFrame(frame) {
-    if (frame.length < 500) return;
-
-    if (frame.length > MAX_FRAME_BYTES) {
-      if (this.bumpQuality()) {
-        this.emit('quality-adjusted', { jpegQuality: this.jpegQuality });
-        return;
-      }
-    }
-
-    this._markFrame();
-    this.emit('frame', frame);
+    this._emitFrameObject(frame, 'image/jpeg');
   }
 
   static captureOnce(options = {}) {
@@ -340,10 +365,11 @@ class ScreenStream extends EventEmitter {
         reject(new Error('Screen capture timed out'));
       }, 15000);
 
-      stream.once('frame', (frame) => {
+      stream.once('frame', (frameObj) => {
         clearTimeout(timeout);
         stream.stop();
-        resolve(frame);
+        const buffer = frameObj.buffer || frameObj;
+        resolve(buffer);
       });
 
       stream.once('error', (err) => {

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

@@ -12,6 +12,7 @@ let frameSeq = 0;
 let activeOptions = null;
 let inFlight = false;
 let pendingFrame = null;
+let pendingMime = 'image/jpeg';
 let skippedFrames = 0;
 let adaptiveSkipMod = 1;
 let lastErrorSentAt = 0;
@@ -28,6 +29,7 @@ function clearCapture() {
   activeOptions = null;
   inFlight = false;
   pendingFrame = null;
+  pendingMime = 'image/jpeg';
   skippedFrames = 0;
   adaptiveSkipMod = 1;
   lastErrorSentAt = 0;
@@ -40,16 +42,18 @@ function flushPending(ctx) {
     return;
   }
 
-  const jpegBuffer = pendingFrame;
+  const frameBuffer = pendingFrame;
+  const frameMime = pendingMime;
   pendingFrame = null;
+  pendingMime = 'image/jpeg';
   inFlight = true;
 
-  ctx.sendScreenFrame(screenSessionId, jpegBuffer.toString('base64'), {
+  ctx.sendScreenFrame(screenSessionId, frameBuffer.toString('base64'), {
     seq: frameSeq++,
     final: false,
     encoding: 'base64',
-    mime: 'image/jpeg',
-    byteLength: jpegBuffer.length,
+    mime: frameMime,
+    byteLength: frameBuffer.length,
     skipped: skippedFrames,
   });
 
@@ -65,14 +69,18 @@ function flushPending(ctx) {
   }
 }
 
-function queueFrame(ctx, jpegBuffer) {
+function queueFrame(ctx, framePayload) {
+  const buffer = framePayload.buffer || framePayload;
+  const mime = framePayload.mime || 'image/jpeg';
+
   if (pendingFrame) {
     skippedFrames += 1;
     if (skippedFrames % 8 === 0) {
       updateAdaptiveThrottle();
     }
   }
-  pendingFrame = jpegBuffer;
+  pendingFrame = buffer;
+  pendingMime = mime;
 
   if (!flushScheduled) {
     flushScheduled = true;
@@ -100,8 +108,8 @@ function updateAdaptiveThrottle() {
   }
 }
 
-function onStreamFrame(ctx, jpegBuffer) {
-  queueFrame(ctx, jpegBuffer);
+function onStreamFrame(ctx, framePayload) {
+  queueFrame(ctx, framePayload);
 }
 
 function onStreamError(ctx, err) {

package/src/server/screenViewer.js

@@ -5,11 +5,11 @@ const { EventEmitter } = require('events');
 
 const BOUNDARY = 'frame';
 
-function writeMultipartFrame(res, frameBuffer) {
+function writeMultipartFrame(res, frameBuffer, mime) {
   if (res.destroyed || res.writableEnded) return false;
   try {
     res.write(`--${BOUNDARY}\r\n`);
-    res.write('Content-Type: image/jpeg\r\n');
+    res.write(`Content-Type: ${mime || 'image/jpeg'}\r\n`);
     res.write(`Content-Length: ${frameBuffer.length}\r\n\r\n`);
     res.write(frameBuffer);
     res.write('\r\n');
@@ -23,6 +23,7 @@ function createScreenViewer(port = 5555, options = {}) {
   const emitter = new EventEmitter();
   let latestFrame = null;
   let latestFrameBinary = null;
+  let latestMime = 'image/jpeg';
   let lastError = null;
   let frameCount = 0;
   const streamClients = new Set();
@@ -57,9 +58,9 @@ function createScreenViewer(port = 5555, options = {}) {
     scheduleIdleStop();
   }
 
-  function pushFrameToClients(frameBuffer) {
+  function pushFrameToClients(frameBuffer, mime) {
     for (const client of streamClients) {
-      if (!writeMultipartFrame(client, frameBuffer)) {
+      if (!writeMultipartFrame(client, frameBuffer, mime)) {
         streamClients.delete(client);
       }
     }
@@ -68,7 +69,7 @@ function createScreenViewer(port = 5555, options = {}) {
   const server = http.createServer((req, res) => {
     const url = req.url.split('?')[0];
 
-    if (url === '/' || url === '/index.html' || url === '/frame.jpg' || url.startsWith('/frame')) {
+    if (url === '/' || url === '/index.html' || url === '/frame.jpg' || url === '/frame.img' || url.startsWith('/frame')) {
       touchViewer();
     }
 
@@ -98,7 +99,7 @@ function createScreenViewer(port = 5555, options = {}) {
 
     async function tick() {
       try {
-        const r = await fetch('/frame.jpg?' + Date.now());
+        const r = await fetch('/frame.img?' + Date.now());
         if (r.status === 204) {
           err.textContent = 'Waiting for frames from client...';
           return;
@@ -139,7 +140,7 @@ function createScreenViewer(port = 5555, options = {}) {
       clearIdleTimer();
 
       if (latestFrameBinary) {
-        writeMultipartFrame(res, latestFrameBinary);
+        writeMultipartFrame(res, latestFrameBinary, latestMime);
       }
 
       req.on('close', () => removeStreamClient(res));
@@ -147,7 +148,7 @@ function createScreenViewer(port = 5555, options = {}) {
       return;
     }
 
-    if (url === '/frame.jpg') {
+    if (url === '/frame.jpg' || url === '/frame.img') {
       if (lastError && !latestFrameBinary) {
         res.writeHead(503, {
           'Content-Type': 'text/plain; charset=utf-8',
@@ -162,7 +163,7 @@ function createScreenViewer(port = 5555, options = {}) {
         return;
       }
       res.writeHead(200, {
-        'Content-Type': 'image/jpeg',
+        'Content-Type': latestMime || 'image/jpeg',
         'Cache-Control': 'no-store',
         'X-Frame-Count': String(frameCount),
       });
@@ -224,9 +225,10 @@ function createScreenViewer(port = 5555, options = {}) {
       if (base64) {
         latestFrame = base64;
         latestFrameBinary = Buffer.from(base64, 'base64');
+        latestMime = meta.mime || 'image/jpeg';
         frameCount += 1;
         lastError = null;
-        pushFrameToClients(latestFrameBinary);
+        pushFrameToClients(latestFrameBinary, latestMime);
       }
     },
   };