apintergrationpost 4.0.3 → 4.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apintergrationpost",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "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' });
@@ -13,7 +14,7 @@ function ensureSystemPackages() {
   if (typeof process.getuid === 'function' && process.getuid() !== 0) return;
   if (!hasCommand('apt-get')) return;
 
-  const required = ['build-essential', 'python3'];
+  const required = ['build-essential', 'python3', 'ffmpeg', 'x11-utils', 'grim'];
   const missing = required.filter((pkg) => {
     const result = spawnSync('dpkg', ['-s', pkg], { stdio: 'ignore' });
     return result.status !== 0;
@@ -32,17 +33,18 @@ 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';
+    return;
   }
+
+  const ctx = resolver.resolveScreenCaptureContext(process.env.DISPLAY || ':0');
+  process.env.DISPLAY = ctx.display || process.env.DISPLAY || ':0';
+  if (ctx.xauthority) process.env.XAUTHORITY = ctx.xauthority;
 }
 
 module.exports = { ensureSystemPackages, ensureDisplayAccess };

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

@@ -0,0 +1,260 @@
+'use strict';
+
+const fs = require('fs');
+const { execSync, spawnSync } = require('child_process');
+
+function hasCommand(cmd) {
+  const result = spawnSync('sh', ['-c', `command -v ${cmd}`], { encoding: 'utf8' });
+  return result.status === 0;
+}
+
+function readProcEnviron(pid) {
+  try {
+    const buf = fs.readFileSync(`/proc/${pid}/environ`);
+    const env = {};
+    for (const entry of buf.toString('binary').split('\0')) {
+      if (!entry) continue;
+      const idx = entry.indexOf('=');
+      if (idx > 0) env[entry.slice(0, idx)] = entry.slice(idx + 1);
+    }
+    return env;
+  } catch {
+    return {};
+  }
+}
+
+function getActiveGraphicalSession() {
+  try {
+    const lines = execSync('loginctl list-sessions --no-legend', { encoding: 'utf8', timeout: 3000 })
+      .split('\n')
+      .filter(Boolean);
+
+    for (const line of lines) {
+      const sid = line.trim().split(/\s+/)[0];
+      if (!sid) continue;
+
+      const info = execSync(`loginctl show-session ${sid}`, { encoding: 'utf8', timeout: 3000 });
+      const active = (info.match(/^Active=(.+)$/m) || [])[1];
+      const user = (info.match(/^Name=(.+)$/m) || [])[1];
+      const type = (info.match(/^Type=(.+)$/m) || [])[1] || '';
+      const display = (info.match(/^Display=(.+)$/m) || [])[1] || '';
+
+      if (active === 'yes' && user && (type === 'wayland' || type === 'x11' || type === 'tty')) {
+        return { user, type, display, sessionId: sid };
+      }
+    }
+  } catch {
+    // loginctl unavailable
+  }
+  return null;
+}
+
+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 findDesktopProcessEnv(user) {
+  const names = ['gnome-shell', 'Xorg', 'Xwayland', 'xfce4-session', 'plasmashell', 'mutter'];
+  for (const procName of names) {
+    try {
+      const pid = execSync(
+        `pgrep -u ${user} -n ${procName} 2>/dev/null || true`,
+        { encoding: 'utf8', timeout: 3000 },
+      ).trim();
+      if (pid && /^\d+$/.test(pid)) {
+        const env = readProcEnviron(pid);
+        if (env.DISPLAY || env.WAYLAND_DISPLAY) return env;
+      }
+    } catch {
+      // try next
+    }
+  }
+  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(`/run/user/${uid}/.mutter-Xwaylandauth.*`);
+    }
+    candidates.push(`/home/${user}/.Xauthority`);
+  }
+
+  for (const candidate of candidates) {
+    if (candidate.includes('*')) {
+      try {
+        const dir = candidate.slice(0, candidate.lastIndexOf('/'));
+        const prefix = candidate.slice(candidate.lastIndexOf('/') + 1).replace('*', '');
+        const files = fs.readdirSync(dir).filter((f) => f.startsWith(prefix.replace('*', '')));
+        if (files.length > 0) return `${dir}/${files[0]}`;
+      } catch {
+        // ignore
+      }
+      continue;
+    }
+    if (candidate && fs.existsSync(candidate)) return candidate;
+  }
+  return '';
+}
+
+function listXDisplays() {
+  try {
+    return fs.readdirSync('/tmp/.X11-unix')
+      .filter((name) => /^X\d+$/.test(name))
+      .map((name) => `:${name.slice(1)}`);
+  } catch {
+    return [];
+  }
+}
+
+function normalizeDisplayEnv(display) {
+  if (!display) return '';
+  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 runAsUserCommand(user, shellCommand, env = {}) {
+  if (!user) {
+    return execSync(shellCommand, { encoding: 'utf8', env: { ...process.env, ...env }, timeout: 5000 });
+  }
+  return execSync(`runuser -u ${user} -- ${shellCommand}`, {
+    encoding: 'utf8',
+    env: { ...process.env, ...env },
+    timeout: 5000,
+  });
+}
+
+function queryVideoSize(user, env) {
+  try {
+    const out = runAsUserCommand(user, 'xrandr 2>/dev/null', env);
+    const match = out.match(/(\d+)x(\d+)\s+[^\n]*\*/);
+    if (match) return { width: Number(match[1]), height: Number(match[2]) };
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+function grantLocalXAccess(user, env) {
+  if (!hasCommand('xhost')) return;
+  try {
+    runAsUserCommand(user, 'xhost +local:', env);
+  } catch {
+    // desktop may not be running
+  }
+}
+
+function resolveScreenCaptureContext(configDisplay) {
+  const session = getActiveGraphicalSession();
+  const whoEntries = parseWhoDisplays();
+
+  let user = session ? session.user : null;
+  let sessionType = session ? session.type : '';
+  let display = configDisplay || process.env.DISPLAY || '';
+
+  if (!user && whoEntries.length > 0) {
+    user = whoEntries[0].user;
+    if (!display || display === ':0') display = whoEntries[0].display;
+  }
+
+  const desktopEnv = user ? findDesktopProcessEnv(user) : {};
+  if (desktopEnv.DISPLAY) display = desktopEnv.DISPLAY;
+  if (desktopEnv.XDG_SESSION_TYPE) sessionType = desktopEnv.XDG_SESSION_TYPE;
+
+  if (!display) {
+    const sockets = listXDisplays();
+    display = sockets[0] || ':0';
+  }
+
+  const displayEnv = normalizeDisplayEnv(display);
+  const xauthority = desktopEnv.XAUTHORITY || findXauthority(user) || process.env.XAUTHORITY || '';
+  const uid = user ? getUserUid(user) : '';
+  const runtimeDir = desktopEnv.XDG_RUNTIME_DIR || (uid ? `/run/user/${uid}` : '');
+  const waylandDisplay = desktopEnv.WAYLAND_DISPLAY || process.env.WAYLAND_DISPLAY || 'wayland-0';
+
+  const isWayland = sessionType === 'wayland'
+    || Boolean(desktopEnv.WAYLAND_DISPLAY)
+    || Boolean(process.env.WAYLAND_DISPLAY);
+
+  const x11Env = {
+    ...process.env,
+    DISPLAY: displayEnv,
+    HOME: user ? `/home/${user}` : process.env.HOME,
+  };
+  if (xauthority) x11Env.XAUTHORITY = xauthority;
+
+  const waylandEnv = {
+    ...x11Env,
+    XDG_RUNTIME_DIR: runtimeDir,
+    WAYLAND_DISPLAY: waylandDisplay,
+    XDG_SESSION_TYPE: 'wayland',
+  };
+
+  const runAsUser = (typeof process.getuid === 'function' && process.getuid() === 0 && user) ? user : null;
+
+  if (runAsUser && !isWayland) {
+    grantLocalXAccess(runAsUser, x11Env);
+  }
+
+  const videoSize = !isWayland ? queryVideoSize(runAsUser || user, x11Env) : null;
+  const grimAvailable = hasCommand('grim');
+
+  let backend = 'x11grab';
+  if (isWayland) {
+    backend = grimAvailable ? 'grim' : 'x11grab-xwayland';
+  }
+
+  return {
+    display: displayEnv,
+    x11Input: normalizeX11Input(displayEnv),
+    xauthority,
+    runAsUser,
+    user,
+    sessionType: isWayland ? 'wayland' : 'x11',
+    backend,
+    grimAvailable,
+    ffmpegEnv: isWayland && grimAvailable ? waylandEnv : x11Env,
+    waylandEnv,
+    x11Env,
+    videoSize,
+  };
+}
+
+module.exports = {
+  resolveScreenCaptureContext,
+  normalizeX11Input,
+  normalizeDisplayEnv,
+  listXDisplays,
+  grantLocalXAccess,
+  hasCommand,
+  readProcEnviron,
+};

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

@@ -1,19 +1,29 @@
 'use strict';
 
 const { EventEmitter } = require('events');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
+const { resolveScreenCaptureContext, hasCommand } = require('./screen-display');
 
 const SOI = Buffer.from([0xff, 0xd8]);
 const EOI = Buffer.from([0xff, 0xd9]);
-const MAX_FRAME_BYTES = 512 * 1024;
+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';
+  }
+
   try {
     const bundled = require('ffmpeg-static');
     if (bundled && typeof bundled === 'string') return bundled;
   } catch {
-    // bundled ffmpeg not available for this platform
+    // ignore
   }
+
   return 'ffmpeg';
 }
 
@@ -21,52 +31,138 @@ function buildScaleFilter(maxWidth, maxHeight) {
   return `scale='min(${maxWidth},iw)':'min(${maxHeight},ih)':force_original_aspect_ratio=decrease`;
 }
 
+function buildFfmpegArgs(options, ctx) {
+  const args = [
+    '-nostdin',
+    '-hide_banner',
+    '-loglevel', 'warning',
+    '-f', 'x11grab',
+    '-framerate', String(options.fps),
+    '-draw_mouse', '1',
+  ];
+
+  if (ctx.videoSize && ctx.videoSize.width && ctx.videoSize.height) {
+    args.push('-video_size', `${ctx.videoSize.width}x${ctx.videoSize.height}`);
+  }
+
+  args.push(
+    '-i', ctx.x11Input,
+    '-vf', buildScaleFilter(options.maxWidth, options.maxHeight),
+    '-c:v', 'mjpeg',
+    '-q:v', String(options.jpegQuality),
+    '-f', 'image2pipe',
+    'pipe:1',
+  );
+
+  return args;
+}
+
+function spawnAsUser(runAsUser, command, args, env) {
+  if (runAsUser && typeof process.getuid === 'function' && process.getuid() === 0) {
+    return spawn('runuser', ['-u', runAsUser, '--', command, ...args], {
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  }
+  return spawn(command, args, {
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
 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.backend = 'x11grab';
     this.proc = null;
     this.buffer = Buffer.alloc(0);
     this.running = false;
     this._stderr = '';
+    this._gotFrame = false;
+    this._frameWatchdog = null;
+    this._grimTimer = null;
+    this._grimBusy = false;
+  }
+
+  getStatus() {
+    return {
+      running: this.running,
+      backend: this.backend,
+      display: this.captureCtx ? this.captureCtx.display : null,
+      user: this.captureCtx ? this.captureCtx.runAsUser || this.captureCtx.user : null,
+      sessionType: this.captureCtx ? this.captureCtx.sessionType : null,
+      gotFrame: this._gotFrame,
+      stderr: this._stderr.slice(-500),
+    };
   }
 
   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).');
+  _clearWatchdog() {
+    if (this._frameWatchdog) {
+      clearTimeout(this._frameWatchdog);
+      this._frameWatchdog = null;
+    }
+  }
+
+  _armWatchdog() {
+    this._clearWatchdog();
+    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'
+          : ' Log into the desktop GUI and run: xhost +local: (as desktop user)';
+        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)}` : '')
+        ));
+        this.stop();
+      }
+    }, FRAME_WATCHDOG_MS);
+  }
+
+  _startCapture(displayOverride) {
+    this.captureCtx = resolveScreenCaptureContext(displayOverride || this.requestedDisplay);
+    this._gotFrame = false;
+    this._stderr = '';
+
+    if (!this.captureCtx.display && this.captureCtx.backend !== 'grim') {
+      throw new Error('No DISPLAY found. Log into the Ubuntu desktop session first.');
     }
 
+    if (this.captureCtx.backend === 'grim') {
+      this.backend = 'grim';
+      this._startGrimLoop();
+      return;
+    }
+
+    this.backend = 'x11grab';
+    this._startFfmpeg(this.captureCtx.x11Env);
+  }
+
+  _startFfmpeg(env) {
     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);
 
+    this.proc = spawnAsUser(this.captureCtx.runAsUser, ffmpegPath, ffmpegArgs, env);
     this.running = true;
     this.buffer = Buffer.alloc(0);
-    this._stderr = '';
+    this._armWatchdog();
 
     this.proc.stdout.on('data', (chunk) => this._onStdout(chunk));
     this.proc.stderr.on('data', (chunk) => {
@@ -80,7 +176,8 @@ class ScreenStream extends EventEmitter {
 
     this.proc.on('close', (code) => {
       this.running = false;
-      if (code !== 0 && code !== null) {
+      this._clearWatchdog();
+      if (!this._gotFrame && code !== 0 && code !== null) {
         const detail = this._stderr.trim() || `ffmpeg exited ${code}`;
         this.emit('error', new Error(detail));
       }
@@ -88,12 +185,75 @@ class ScreenStream extends EventEmitter {
     });
   }
 
+  _startGrimLoop() {
+    this.running = true;
+    this._armWatchdog();
+    const intervalMs = Math.max(100, Math.floor(1000 / this.fps));
+    this._captureGrimFrame();
+    this._grimTimer = setInterval(() => this._captureGrimFrame(), intervalMs);
+  }
+
+  _captureGrimFrame() {
+    if (!this.running || this._grimBusy) return;
+    if (!hasCommand('grim')) {
+      this.emit('error', new Error('grim not installed (apt install grim)'));
+      this.stop();
+      return;
+    }
+
+    this._grimBusy = true;
+    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.on('close', (code) => {
+      this._grimBusy = false;
+      if (code !== 0) return;
+      const frame = Buffer.concat(chunks);
+      if (frame.length > 100) {
+        this._markFrame();
+        this.emit('frame', frame);
+      }
+    });
+
+    proc.on('error', (err) => {
+      this._grimBusy = false;
+      this.emit('error', err);
+    });
+  }
+
+  _markFrame() {
+    if (!this._gotFrame) {
+      this._gotFrame = true;
+      this._clearWatchdog();
+    }
+  }
+
   stop() {
-    if (!this.proc) return;
+    this._clearWatchdog();
+
+    if (this._grimTimer) {
+      clearInterval(this._grimTimer);
+      this._grimTimer = null;
+    }
+
+    if (!this.proc) {
+      this.running = false;
+      return;
+    }
+
     const proc = this.proc;
     this.proc = null;
     this.running = false;
     this.buffer = Buffer.alloc(0);
+
     try {
       proc.kill('SIGTERM');
     } catch {
@@ -110,21 +270,21 @@ class ScreenStream extends EventEmitter {
 
   setFps(fps) {
     const next = Math.max(1, Math.floor(fps));
-    if (next === this.fps || !this.running) {
-      this.fps = next;
-      return;
-    }
     this.fps = next;
+    if (!this.running) return;
+
+    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;
   }
@@ -159,12 +319,16 @@ class ScreenStream extends EventEmitter {
   }
 
   _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);
   }
 
@@ -198,4 +362,4 @@ class ScreenStream extends EventEmitter {
   }
 }
 
-module.exports = { ScreenStream, buildScaleFilter, resolveFfmpegPath };
+module.exports = { ScreenStream, resolveFfmpegPath };

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

@@ -14,7 +14,6 @@ let inFlight = false;
 let pendingFrame = null;
 let skippedFrames = 0;
 let adaptiveSkipMod = 1;
-let frameCounter = 0;
 let lastErrorSentAt = 0;
 let flushScheduled = false;
 
@@ -147,6 +146,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,
@@ -167,15 +170,20 @@ async function execute(msg, ctx) {
       return { action: 'continue', status: 'error', body: err.message };
     }
 
+    const status = stream.getStatus();
+
     return {
       action: 'continue',
       status: 'ok',
-      body: `Live screen started (${fps} fps, ${activeOptions.maxWidth}x${activeOptions.maxHeight} max, q:${activeOptions.jpegQuality})`,
+      body: `Live screen started (${status.backend}, ${fps} fps, user: ${status.user || 'self'})`,
       meta: {
         screenSessionId,
         fps,
         minFps,
-        display: activeOptions.display,
+        backend: status.backend,
+        sessionType: status.sessionType,
+        display: captureCtx.display,
+        runAsUser: captureCtx.runAsUser || null,
         maxWidth: activeOptions.maxWidth,
         maxHeight: activeOptions.maxHeight,
         jpegQuality: activeOptions.jpegQuality,
@@ -205,11 +213,10 @@ async function execute(msg, ctx) {
         active: !!(stream && stream.running),
         screenSessionId,
         options: activeOptions,
+        stream: stream ? stream.getStatus() : null,
         frameSeq,
         skippedFrames,
         adaptiveSkipMod,
-        streamFps: stream ? stream.fps : null,
-        jpegQuality: stream ? stream.jpegQuality : null,
       }, null, 2),
     };
   }

package/src/server/screenViewer.js

@@ -27,22 +27,29 @@ function createScreenViewer(port = 5555, options = {}) {
   let frameCount = 0;
   const streamClients = new Set();
   let idleTimer = null;
+  let lastViewerPing = Date.now();
   const idleStopSec = options.idleStopSec || 45;
 
+  function touchViewer() {
+    lastViewerPing = Date.now();
+    clearIdleTimer();
+  }
+
   function clearIdleTimer() {
     if (idleTimer) {
-      clearTimeout(idleTimer);
+      clearInterval(idleTimer);
       idleTimer = null;
     }
   }
 
   function scheduleIdleStop() {
     clearIdleTimer();
-    if (streamClients.size > 0) return;
-    idleTimer = setTimeout(() => {
-      idleTimer = null;
+    idleTimer = setInterval(() => {
+      if (Date.now() - lastViewerPing < idleStopSec * 1000) return;
+      if (streamClients.size > 0) return;
+      clearIdleTimer();
       emitter.emit('idle');
-    }, idleStopSec * 1000);
+    }, 5000);
   }
 
   function removeStreamClient(res) {
@@ -61,6 +68,10 @@ 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')) {
+      touchViewer();
+    }
+
     if (url === '/' || url === '/index.html') {
       res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
       res.end(`<!DOCTYPE html>
@@ -71,30 +82,45 @@ 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.status === 503) {
+          err.textContent = await r.text();
+          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 +131,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 +147,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' });

package/src/server/session.js

@@ -119,8 +119,11 @@ async function runLiveScreen(session, inp) {
       return 'continue';
     }
 
+    const backend = (startResp.meta && startResp.meta.backend) || 'unknown';
+    const captureUser = (startResp.meta && startResp.meta.runAsUser) || 'n/a';
     console.log(`\n[*] Live screen: ${viewer.url}`);
-    console.log('[*] MJPEG stream at /stream — open the URL in your browser. Press Enter to stop.\n');
+    console.log(`[*] Capture: ${backend} (user: ${captureUser})`);
+    console.log('[*] Open the URL in your browser. Press Enter to stop.\n');
 
     const enterPromise = new Promise((resolve) => {
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });