@fitlab-ai/agent-infra 0.8.1 → 0.8.3

package/lib/sandbox/clipboard/bridge.ts

@@ -30,8 +30,13 @@ type BridgeOptions = {
   createDetector?: () => CtrlVDetector;
 };
 
+type TextImageClipboardAdapter = ClipboardAdapter & {
+  readImageFromText?: (text: string) => Buffer | null;
+};
+
 const FALLBACK_PREFIX = 'Warning: clipboard image paste bridge disabled';
 const PARTIAL_ESCAPE_FLUSH_MS = 30;
+const BRACKETED_PASTE_RE = /^\x1b\[200~([\s\S]*)\x1b\[201~$/u;
 
 // Node's stdin.setRawMode(true) uses libuv's RAW mode, which (unlike the
 // cfmakeraw that `docker exec -it` applies on the non-bridge path) keeps ONLCR
@@ -147,7 +152,7 @@ async function runBridge({
     clearFlushTimer();
     for (const token of detector.feed(inputDecoder.write(chunk))) {
       if (token.kind === 'text') {
-        child.write(token.raw);
+        handleText(token.raw, child);
       } else {
         handleCtrlV(token, child);
       }
@@ -157,7 +162,7 @@ async function runBridge({
         flushTimer = null;
         for (const token of detector.flush()) {
           if (token.kind === 'text') {
-            child.write(token.raw);
+            handleText(token.raw, child);
           } else {
             handleCtrlV(token, child);
           }
@@ -169,6 +174,37 @@ async function runBridge({
   const onSigint = () => child.kill('SIGINT');
   const onSigterm = () => child.kill('SIGTERM');
 
+  function writeImagePaste(png: Buffer, target: PtyProcess): void {
+    const filename = pngClipboardFilename(png);
+    writeClipboardPngAtomic(clipboardHostDir(home), filename, png);
+    pruneClipboardDir(clipboardHostDir(home));
+    target.write(buildBracketedPaste(containerClipboardPath(filename)));
+  }
+
+  function handleText(raw: string, target: PtyProcess): void {
+    const textAdapter = adapter as TextImageClipboardAdapter;
+    const pastedText = extractSinglePathPaste(raw);
+    if (!textAdapter.readImageFromText || pastedText === null) {
+      target.write(raw);
+      return;
+    }
+
+    try {
+      const png = textAdapter.readImageFromText(pastedText);
+      if (!png) {
+        target.write(raw);
+        return;
+      }
+      writeImagePaste(png, target);
+    } catch (error) {
+      target.write(raw);
+      if (!warnedPasteFailure) {
+        warnedPasteFailure = true;
+        writeStderr(`Warning: clipboard image paste failed; forwarded pasted text (${error instanceof Error ? error.message : 'unknown error'})\n`);
+      }
+    }
+  }
+
   function handleCtrlV(match: CtrlVMatch, target: PtyProcess): void {
     try {
       // readImagePng returns null both for "no image on clipboard" and for
@@ -181,10 +217,7 @@ async function runBridge({
         target.write(match.raw);
         return;
       }
-      const filename = pngClipboardFilename(png);
-      writeClipboardPngAtomic(clipboardHostDir(home), filename, png);
-      pruneClipboardDir(clipboardHostDir(home));
-      target.write(buildBracketedPaste(containerClipboardPath(filename)));
+      writeImagePaste(png, target);
     } catch (error) {
       target.write(match.raw);
       if (!warnedPasteFailure) {
@@ -219,14 +252,14 @@ async function runBridge({
     try {
       for (const token of detector.feed(inputDecoder.end())) {
         if (token.kind === 'text') {
-          child.write(token.raw);
+          handleText(token.raw, child);
         } else {
           handleCtrlV(token, child);
         }
       }
       for (const token of detector.flush()) {
         if (token.kind === 'text') {
-          child.write(token.raw);
+          handleText(token.raw, child);
         }
       }
     } catch {
@@ -244,6 +277,15 @@ async function runBridge({
   }
 }
 
+function extractSinglePathPaste(raw: string): string | null {
+  const match = raw.match(BRACKETED_PASTE_RE);
+  const text = (match ? match[1] : raw)?.trim();
+  if (!text || /[\r\n]/u.test(text)) {
+    return null;
+  }
+  return text;
+}
+
 function onceExit(
   child: PtyProcess,
   stdin: NodeJS.ReadStream

package/lib/sandbox/clipboard/index.ts

@@ -1,7 +1,9 @@
 import { platform } from 'node:os';
 import { createDarwinClipboardAdapter, type DarwinClipboardAdapter } from './darwin.ts';
+import { createLinuxClipboardAdapter, type LinuxClipboardAdapter } from './linux.ts';
+import { createWin32ClipboardAdapter, type Win32ClipboardAdapter } from './win32.ts';
 
-export type ClipboardAdapter = DarwinClipboardAdapter;
+export type ClipboardAdapter = DarwinClipboardAdapter | LinuxClipboardAdapter | Win32ClipboardAdapter;
 
 export function createClipboardAdapter({
   platformName = platform()
@@ -10,12 +12,9 @@ export function createClipboardAdapter({
     case 'darwin':
       return createDarwinClipboardAdapter();
     case 'linux':
-      // Future work: dispatch based on $WAYLAND_DISPLAY (wl-paste) or $DISPLAY (xclip);
-      // see Issue #386 follow-up. Returning null disables the bridge for now.
-      return null;
+      return createLinuxClipboardAdapter();
     case 'win32':
-      // Future work: native Win32 clipboard reader. Returning null disables the bridge.
-      return null;
+      return createWin32ClipboardAdapter();
     default:
       return null;
   }

package/lib/sandbox/clipboard/linux.ts

@@ -0,0 +1,124 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import type { ExecFileSyncOptions } from 'node:child_process';
+
+const PROBE_TIMEOUT_MS = 2_000;
+const READ_IMAGE_TIMEOUT_MS = 5_000;
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+type ExecFn = (cmd: string, args: string[], options?: ExecFileSyncOptions) => Buffer | string;
+type ExecToFileFn = (cmd: string, args: string[], outputPath: string, timeout: number) => void;
+
+type LinuxBackend =
+  | { kind: 'wayland'; command: 'wl-paste' }
+  | { kind: 'x11'; command: 'xclip' };
+
+export type LinuxClipboardAdapter = {
+  available(): { ok: true } | { ok: false; reason: string };
+  readImagePng(): Buffer | null;
+};
+
+export function createLinuxClipboardAdapter({
+  env = process.env,
+  execFn = execFileSync,
+  execToFileFn = execToFile,
+  mkdtempFn = fs.mkdtempSync,
+  readFileFn = fs.readFileSync,
+  rmFn = fs.rmSync
+}: {
+  env?: NodeJS.ProcessEnv;
+  execFn?: ExecFn;
+  execToFileFn?: ExecToFileFn;
+  mkdtempFn?: typeof fs.mkdtempSync;
+  readFileFn?: typeof fs.readFileSync;
+  rmFn?: typeof fs.rmSync;
+} = {}): LinuxClipboardAdapter {
+  return {
+    available() {
+      const backend = selectBackend(env);
+      try {
+        execFn(backend.command, versionArgs(backend), {
+          encoding: 'utf8',
+          timeout: PROBE_TIMEOUT_MS
+        });
+        return { ok: true };
+      } catch {
+        return { ok: false, reason: unavailableReason(backend) };
+      }
+    },
+    readImagePng() {
+      const backend = selectBackend(env);
+      try {
+        const mimeTypes = String(execFn(backend.command, mimeArgs(backend), {
+          encoding: 'utf8',
+          timeout: PROBE_TIMEOUT_MS
+        }));
+        if (!hasPngMime(mimeTypes)) {
+          return null;
+        }
+
+        const tmpDir = mkdtempFn(path.join(os.tmpdir(), 'agent-infra-clipboard-'));
+        const outputPath = path.join(tmpDir, 'clipboard.png');
+        try {
+          execToFileFn(backend.command, imageArgs(backend), outputPath, READ_IMAGE_TIMEOUT_MS);
+          const png = Buffer.from(readFileFn(outputPath));
+          return isPng(png) ? png : null;
+        } finally {
+          rmFn(tmpDir, { recursive: true, force: true });
+        }
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+function selectBackend(env: NodeJS.ProcessEnv): LinuxBackend {
+  return env.WAYLAND_DISPLAY?.trim()
+    ? { kind: 'wayland', command: 'wl-paste' }
+    : { kind: 'x11', command: 'xclip' };
+}
+
+function versionArgs(backend: LinuxBackend): string[] {
+  return backend.kind === 'wayland' ? ['--version'] : ['-version'];
+}
+
+function mimeArgs(backend: LinuxBackend): string[] {
+  return backend.kind === 'wayland'
+    ? ['--list-types']
+    : ['-selection', 'clipboard', '-t', 'TARGETS', '-o'];
+}
+
+function imageArgs(backend: LinuxBackend): string[] {
+  return backend.kind === 'wayland'
+    ? ['-t', 'image/png']
+    : ['-selection', 'clipboard', '-t', 'image/png', '-o'];
+}
+
+function unavailableReason(backend: LinuxBackend): string {
+  return backend.kind === 'wayland'
+    ? 'Wayland clipboard tool wl-paste is unavailable; install wl-clipboard to enable image paste'
+    : 'X11 clipboard tool xclip is unavailable; install xclip to enable image paste';
+}
+
+function hasPngMime(output: string): boolean {
+  return output.split(/\s+/u).some((type) => type === 'image/png');
+}
+
+function execToFile(cmd: string, args: string[], outputPath: string, timeout: number): void {
+  const fd = fs.openSync(outputPath, 'w', 0o600);
+  try {
+    execFileSync(cmd, args, {
+      timeout,
+      stdio: ['ignore', fd, 'pipe']
+    });
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function isPng(buffer: Buffer): boolean {
+  return buffer.length >= PNG_MAGIC.length && PNG_MAGIC.every((byte, index) => buffer[index] === byte);
+}

package/lib/sandbox/clipboard/win32.ts

@@ -0,0 +1,173 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import type { ExecFileSyncOptions } from 'node:child_process';
+
+const PROBE_TIMEOUT_MS = 2_000;
+const READ_IMAGE_TIMEOUT_MS = 5_000;
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const POWERSHELL_ARGS = ['-NoProfile', '-NonInteractive', '-STA', '-Command'];
+
+type ExecFn = (cmd: string, args: string[], options?: ExecFileSyncOptions) => Buffer | string;
+type MkdtempFn = (prefix: string) => string;
+type ReadFileFn = (filePath: fs.PathOrFileDescriptor) => Buffer | string;
+type RmFn = (filePath: fs.PathLike, options: { recursive?: boolean; force?: boolean }) => void;
+type ExistsFn = (filePath: fs.PathLike) => boolean;
+
+export type Win32ClipboardAdapter = {
+  available(): { ok: true } | { ok: false; reason: string };
+  readImagePng(): Buffer | null;
+  readImageFromPath(imagePath: string): Buffer | null;
+  readImageFromText(text: string): Buffer | null;
+};
+
+export function createWin32ClipboardAdapter({
+  execFn = execFileSync,
+  mkdtempFn = fs.mkdtempSync,
+  readFileFn = fs.readFileSync,
+  rmFn = fs.rmSync,
+  existsFn = fs.existsSync
+}: {
+  execFn?: ExecFn;
+  mkdtempFn?: MkdtempFn;
+  readFileFn?: ReadFileFn;
+  rmFn?: RmFn;
+  existsFn?: ExistsFn;
+} = {}): Win32ClipboardAdapter {
+  return {
+    available() {
+      try {
+        execFn('powershell.exe', [...POWERSHELL_ARGS, clipboardProbeScript()], {
+          encoding: 'utf8',
+          timeout: PROBE_TIMEOUT_MS
+        });
+        return { ok: true };
+      } catch {
+        return {
+          ok: false,
+          reason: 'Windows PowerShell Get-Clipboard is unavailable; install or enable powershell.exe to use image paste'
+        };
+      }
+    },
+    readImagePng() {
+      const tmpDir = mkdtempFn(path.join(os.tmpdir(), 'agent-infra-clipboard-'));
+      const outputPath = path.join(tmpDir, 'clipboard.png');
+      try {
+        execFn('powershell.exe', [...POWERSHELL_ARGS, pngWriteScript(outputPath)], {
+          encoding: 'utf8',
+          timeout: READ_IMAGE_TIMEOUT_MS
+        });
+        const png = Buffer.from(readFileFn(outputPath));
+        return isPng(png) ? png : null;
+      } catch {
+        return null;
+      } finally {
+        rmFn(tmpDir, { recursive: true, force: true });
+      }
+    },
+    readImageFromPath(imagePath) {
+      const tmpDir = mkdtempFn(path.join(os.tmpdir(), 'agent-infra-clipboard-'));
+      const outputPath = path.join(tmpDir, 'clipboard.png');
+      try {
+        execFn('powershell.exe', [...POWERSHELL_ARGS, pngFromPathScript(imagePath, outputPath)], {
+          encoding: 'utf8',
+          timeout: READ_IMAGE_TIMEOUT_MS
+        });
+        const png = Buffer.from(readFileFn(outputPath));
+        return isPng(png) ? png : null;
+      } catch {
+        return null;
+      } finally {
+        rmFn(tmpDir, { recursive: true, force: true });
+      }
+    },
+    readImageFromText(text) {
+      const trimmed = text.trim();
+      if (!isWindowsImagePath(trimmed)) {
+        return null;
+      }
+      if (!existsFn(trimmed)) {
+        return null;
+      }
+      return this.readImageFromPath(trimmed);
+    }
+  };
+}
+
+function clipboardProbeScript(): string {
+  return 'if ($null -eq (Get-Command Get-Clipboard -ErrorAction SilentlyContinue)) { exit 1 }';
+}
+
+// Embed a filesystem path in a PowerShell single-quoted string literal.
+// Single-quoted strings in PowerShell are verbatim (no variable expansion,
+// no escape sequences). The only special character is a single quote itself,
+// which is escaped by doubling it.
+function psLiteral(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function pngWriteScript(outputPath: string): string {
+  const psOutputPath = psLiteral(outputPath);
+  return [
+    '$ErrorActionPreference = "Stop"',
+    `$outputPath = ${psOutputPath}`,
+    '$image = $null',
+    'try {',
+    '  Add-Type -AssemblyName System.Drawing',
+    '  $image = Get-Clipboard -Format Image -ErrorAction SilentlyContinue',
+    '  if ($null -ne $image) {',
+    '    $image.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Png)',
+    '    return',
+    '  }',
+    '  $files = Get-Clipboard -Format FileDropList -ErrorAction SilentlyContinue',
+    '  if ($null -ne $files) {',
+    '    $allowed = @(".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff", ".tif", ".ico")',
+    '    foreach ($file in $files) {',
+    '      if (-not (Test-Path -LiteralPath $file -PathType Leaf)) { continue }',
+    '      $ext = [System.IO.Path]::GetExtension($file)',
+    '      if ($allowed -notcontains $ext) { continue }',
+    '      try {',
+    '        $image = [System.Drawing.Image]::FromFile($file)',
+    '        $image.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Png)',
+    '        return',
+    '      } catch {}',
+    '    }',
+    '  }',
+    '  throw "clipboard has no image"',
+    '} finally {',
+    '  if ($null -ne $image -and $image -is [System.IDisposable]) { $image.Dispose() }',
+    '}'
+  ].join('\n');
+}
+
+function pngFromPathScript(imagePath: string, outputPath: string): string {
+  const psImagePath = psLiteral(imagePath);
+  const psOutputPath = psLiteral(outputPath);
+  return [
+    '$ErrorActionPreference = "Stop"',
+    `$imagePath = ${psImagePath}`,
+    `$outputPath = ${psOutputPath}`,
+    '$image = $null',
+    'try {',
+    '  Add-Type -AssemblyName System.Drawing',
+    '  if (-not (Test-Path -LiteralPath $imagePath -PathType Leaf)) { throw "file not found: $imagePath" }',
+    '  $image = [System.Drawing.Image]::FromFile($imagePath)',
+    '  $image.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Png)',
+    '} finally {',
+    '  if ($null -ne $image -and $image -is [System.IDisposable]) { $image.Dispose() }',
+    '}'
+  ].join('\n');
+}
+
+const IMAGE_EXTENSIONS_RE = /\.(png|jpg|jpeg|gif|bmp|webp|tiff?|ico)$/i;
+
+function isWindowsImagePath(text: string): boolean {
+  // Must be a Windows absolute path: drive letter + colon + backslash/slash
+  // followed by a path ending with a known image extension.
+  return /^[A-Za-z]:[\\/].+$/.test(text) && IMAGE_EXTENSIONS_RE.test(text);
+}
+
+function isPng(buffer: Buffer): boolean {
+  return buffer.length >= PNG_MAGIC.length && PNG_MAGIC.every((byte, index) => buffer[index] === byte);
+}