@fitlab-ai/agent-infra 0.8.2 → 0.8.3

package/dist/bin/cli.js

@@ -7,7 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { VERSION } from "../lib/version.js";
+import { VERSION } from '../lib/version.js';
 // Node.js version check
 const [major = 0, minor = 0] = process.versions.node.split('.').map((part) => parseInt(part, 10));
 if (major < 22 || (major === 22 && minor < 9)) {

package/dist/lib/cp.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import { platform as currentPlatform, tmpdir as defaultTmpdir } from 'node:os';
 import path from 'node:path';
 import { parseArgs } from 'node:util';
-import { createClipboardAdapter } from "./sandbox/clipboard/index.js";
+import { createClipboardAdapter } from './sandbox/clipboard/index.js';
 const USAGE = 'Usage: ai cp <ssh-alias>\n\nCopy the local clipboard image (PNG) to a remote macOS NSPasteboard over ssh/scp.\n';
 const COMMAND_TIMEOUT_MS = 30_000;
 export function runCommand(cmd, args, input) {

package/dist/lib/decide.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { VERSION } from "./version.js";
-import { resolveTaskRef } from "./task/resolve-ref.js";
+import { VERSION } from './version.js';
+import { resolveTaskRef } from './task/resolve-ref.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 function detectRepoRoot() {
     return execFileSync('git', ['rev-parse', '--show-toplevel'], {

package/dist/lib/defaults.json

@@ -14,6 +14,7 @@
       "gemini-cli",
       "opencode"
     ],
+    "refreshIntervalDays": 7,
     "dockerfile": null,
     "vm": {
       "cpu": null,

package/dist/lib/init.js

@@ -2,13 +2,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 import { platform } from 'node:os';
-import { info, ok, err } from "./log.js";
-import { prompt, select, multiSelect, closePrompt } from "./prompt.js";
-import { resolveTemplateDir } from "./paths.js";
-import { renderFile, copySkillDir, KNOWN_PLATFORMS } from "./render.js";
-import { enginesForPlatform } from "./sandbox/engines/index.js";
-import { VERSION } from "./version.js";
-import { BUILTIN_TUI_IDS, BUILTIN_TUI_DISPLAY, isPathOwnedByDisabledTUI, resolveEnabledTUIs } from "./builtin-tuis.js";
+import { info, ok, err } from './log.js';
+import { prompt, select, multiSelect, closePrompt } from './prompt.js';
+import { resolveTemplateDir } from './paths.js';
+import { renderFile, copySkillDir, KNOWN_PLATFORMS } from './render.js';
+import { enginesForPlatform } from './sandbox/engines/index.js';
+import { VERSION } from './version.js';
+import { BUILTIN_TUI_IDS, BUILTIN_TUI_DISPLAY, isPathOwnedByDisabledTUI, resolveEnabledTUIs } from './builtin-tuis.js';
 const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
 const PLATFORM_DEFAULT_ENGINES = Object.freeze({
     linux: 'native',

package/dist/lib/merge.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { info, ok } from "./log.js";
+import { info, ok } from './log.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 const TITLE_RE = /^# (.+)$/m;

package/dist/lib/prompt.js

@@ -1,5 +1,5 @@
 import readline from 'node:readline';
-import { ask } from "./log.js";
+import { ask } from './log.js';
 let _rl = null;
 let _lines = [];
 let _lineResolve = null;

package/dist/lib/run/index.js

@@ -1,12 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadServerConfig } from "../server/config.js";
-import { resolveTaskBranch } from "../sandbox/task-resolver.js";
-import { createRunId, runInSandbox } from "../sandbox/capture.js";
-import { loadShortIdByTaskId, normalizeShortIdInput } from "../task/short-id.js";
-import { buildTuiCommand, renderPrompt, selectTui } from "./tui.js";
-import { getSkillRunSpec } from "./skills.js";
-import { runHostCommand } from "./host.js";
+import { loadServerConfig } from '../server/config.js';
+import { resolveTaskBranch } from '../sandbox/task-resolver.js';
+import { createRunId, runInSandbox } from '../sandbox/capture.js';
+import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.js';
+import { buildTuiCommand, renderPrompt, selectTui } from './tui.js';
+import { getSkillRunSpec } from './skills.js';
+import { runHostCommand } from './host.js';
 const USAGE = `Usage: ai run <skill> [task-ref] [args...] [--tui <name>]
 
 Task skills are scheduled inside the sandbox tmux session; ai run returns once

package/dist/lib/run/prompt.js

@@ -1,2 +1,2 @@
-export { renderPrompt } from "./tui.js";
+export { renderPrompt } from './tui.js';
 //# sourceMappingURL=prompt.js.map

package/dist/lib/sandbox/capture.js

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
-import { loadConfig } from "./config.js";
-import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from "./constants.js";
-import { detectEngine } from "./engine.js";
-import { hostTimezoneEnvFlags, terminalEnvFlags } from "./commands/enter.js";
-import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from "./commands/list-running.js";
+import { loadConfig } from './config.js';
+import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from './constants.js';
+import { detectEngine } from './engine.js';
+import { hostTimezoneEnvFlags, terminalEnvFlags } from './commands/enter.js';
+import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
 async function spawnCapture(file, args) {
     return new Promise((resolve, reject) => {
         const child = spawn(file, args, { stdio: ['ignore', 'pipe', 'pipe'] });

package/dist/lib/sandbox/clipboard/bridge.js

@@ -1,12 +1,13 @@
 import { StringDecoder } from 'node:string_decoder';
 import { spawnSync } from 'node:child_process';
-import { createClipboardAdapter } from "./index.js";
-import { buildBracketedPaste, CtrlVDetector } from "./keys.js";
-import { clipboardHostDir, containerClipboardPath, pngClipboardFilename, pruneClipboardDir, writeClipboardPngAtomic } from "./paths.js";
-import { commandForEngine, restoreTerminal, runInteractiveEngine, runOkEngine } from "../shell.js";
-import { loadNodePty } from "./node-pty.js";
+import { createClipboardAdapter } from './index.js';
+import { buildBracketedPaste, CtrlVDetector } from './keys.js';
+import { clipboardHostDir, containerClipboardPath, pngClipboardFilename, pruneClipboardDir, writeClipboardPngAtomic } from './paths.js';
+import { commandForEngine, restoreTerminal, runInteractiveEngine, runOkEngine } from '../shell.js';
+import { loadNodePty } from './node-pty.js';
 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
 // set on the shared host TTY. With ONLCR on, the kernel rewrites the bare \n
@@ -83,7 +84,7 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
         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);
@@ -94,7 +95,7 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
                 flushTimer = null;
                 for (const token of detector.flush()) {
                     if (token.kind === 'text') {
-                        child.write(token.raw);
+                        handleText(token.raw, child);
                     }
                     else {
                         handleCtrlV(token, child);
@@ -106,6 +107,35 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
     const onResize = () => child.resize(stdout.columns || 120, stdout.rows || 40);
     const onSigint = () => child.kill('SIGINT');
     const onSigterm = () => child.kill('SIGTERM');
+    function writeImagePaste(png, target) {
+        const filename = pngClipboardFilename(png);
+        writeClipboardPngAtomic(clipboardHostDir(home), filename, png);
+        pruneClipboardDir(clipboardHostDir(home));
+        target.write(buildBracketedPaste(containerClipboardPath(filename)));
+    }
+    function handleText(raw, target) {
+        const textAdapter = adapter;
+        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, target) {
         try {
             // readImagePng returns null both for "no image on clipboard" and for
@@ -118,10 +148,7 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
                 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);
@@ -155,7 +182,7 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
         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);
@@ -163,7 +190,7 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
             }
             for (const token of detector.flush()) {
                 if (token.kind === 'text') {
-                    child.write(token.raw);
+                    handleText(token.raw, child);
                 }
             }
         }
@@ -181,6 +208,14 @@ async function runBridge({ child, home, adapter, writeStderr, stdin, stdout, det
         restoreTerminal();
     }
 }
+function extractSinglePathPaste(raw) {
+    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, stdin) {
     return new Promise((resolve) => {
         let settled = false;

package/dist/lib/sandbox/clipboard/index.js

@@ -1,16 +1,15 @@
 import { platform } from 'node:os';
-import { createDarwinClipboardAdapter } from "./darwin.js";
+import { createDarwinClipboardAdapter } from './darwin.js';
+import { createLinuxClipboardAdapter } from './linux.js';
+import { createWin32ClipboardAdapter } from './win32.js';
 export function createClipboardAdapter({ platformName = platform() } = {}) {
     switch (platformName) {
         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/dist/lib/sandbox/clipboard/linux.js

@@ -0,0 +1,91 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+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]);
+export function createLinuxClipboardAdapter({ env = process.env, execFn = execFileSync, execToFileFn = execToFile, mkdtempFn = fs.mkdtempSync, readFileFn = fs.readFileSync, rmFn = fs.rmSync } = {}) {
+    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) {
+    return env.WAYLAND_DISPLAY?.trim()
+        ? { kind: 'wayland', command: 'wl-paste' }
+        : { kind: 'x11', command: 'xclip' };
+}
+function versionArgs(backend) {
+    return backend.kind === 'wayland' ? ['--version'] : ['-version'];
+}
+function mimeArgs(backend) {
+    return backend.kind === 'wayland'
+        ? ['--list-types']
+        : ['-selection', 'clipboard', '-t', 'TARGETS', '-o'];
+}
+function imageArgs(backend) {
+    return backend.kind === 'wayland'
+        ? ['-t', 'image/png']
+        : ['-selection', 'clipboard', '-t', 'image/png', '-o'];
+}
+function unavailableReason(backend) {
+    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) {
+    return output.split(/\s+/u).some((type) => type === 'image/png');
+}
+function execToFile(cmd, args, outputPath, timeout) {
+    const fd = fs.openSync(outputPath, 'w', 0o600);
+    try {
+        execFileSync(cmd, args, {
+            timeout,
+            stdio: ['ignore', fd, 'pipe']
+        });
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function isPng(buffer) {
+    return buffer.length >= PNG_MAGIC.length && PNG_MAGIC.every((byte, index) => buffer[index] === byte);
+}
+//# sourceMappingURL=linux.js.map

package/dist/lib/sandbox/clipboard/paths.js

@@ -1,7 +1,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { hostJoin } from "../engines/wsl2-paths.js";
+import { hostJoin } from '../engines/wsl2-paths.js';
 export const CONTAINER_CLIPBOARD_MOUNT = '/clipboard';
 const DEFAULT_KEEP = 20;
 const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000;

package/dist/lib/sandbox/clipboard/win32.js

@@ -0,0 +1,144 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+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'];
+export function createWin32ClipboardAdapter({ execFn = execFileSync, mkdtempFn = fs.mkdtempSync, readFileFn = fs.readFileSync, rmFn = fs.rmSync, existsFn = fs.existsSync } = {}) {
+    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() {
+    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) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function pngWriteScript(outputPath) {
+    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, outputPath) {
+    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) {
+    // 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) {
+    return buffer.length >= PNG_MAGIC.length && PNG_MAGIC.every((byte, index) => buffer[index] === byte);
+}
+//# sourceMappingURL=win32.js.map