jaitus 0.3.3 → 0.3.5

package/src/tui/clipboard.js

@@ -0,0 +1,161 @@
+// ─── Reading the system clipboard ───────────────────────────────────────────────
+//
+// The app takes the mouse, so a terminal's own right-click paste never happens — the
+// click is reported to the app instead, and it used to be thrown away: "paste does not
+// work". Ctrl+V is the terminal's in some terminals and the app's in others. So the app
+// reads the clipboard itself for right-click and Ctrl+V, and for Alt+V (an image, which
+// no terminal can type in).
+//
+// Asynchronous on purpose: PowerShell takes a few hundred milliseconds to start, and a
+// synchronous read froze the whole interface for that long.
+
+import { spawn } from 'node:child_process';
+
+function capture(cmd, args, { timeout = 4000, binary = false } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try { child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }); } catch { resolve(null); return; }
+    const chunks = [];
+    const timer = setTimeout(() => { try { child.kill(); } catch { /* gone */ } resolve(null); }, timeout);
+    timer.unref?.();
+    child.stdout.on('data', (d) => chunks.push(d));
+    child.on('error', () => { clearTimeout(timer); resolve(null); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) return resolve(null);
+      const buf = Buffer.concat(chunks);
+      resolve(binary ? buf : buf.toString('utf8'));
+    });
+  });
+}
+
+// A stand-in clipboard for the terminal tests: when JAITUS_CLIPBOARD_DIR names a folder,
+// text comes from text.txt and an image from image.png in it, and the system clipboard
+// is never read. Tests drive the real app in a real terminal, and they must not read or
+// overwrite whatever the person running them has copied.
+async function standIn(kind) {
+  const dir = process.env.JAITUS_CLIPBOARD_DIR;
+  if (!dir) return undefined;
+  const fs = await import('node:fs');
+  const path = await import('node:path');
+  try {
+    if (kind === 'text') return fs.readFileSync(path.join(dir, 'text.txt'), 'utf8') || null;
+    const bytes = fs.readFileSync(path.join(dir, 'image.png'));
+    return bytes.length ? { bytes, mime: 'image/png', ext: '.png' } : null;
+  } catch { return null; }
+}
+
+/** Plain text on the clipboard, or null (empty, not text, or no clipboard tool). */
+export async function readClipboardText({ platform = process.platform, run = capture } = {}) {
+  const fake = await standIn('text');
+  if (fake !== undefined) return fake;
+  let text = null;
+  if (platform === 'win32') {
+    // UTF-8 out, or anything outside the console code page (quotes, dashes, non-Latin
+    // text) arrives as '?'. -Raw keeps line breaks as they were copied.
+    text = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      '[Console]::OutputEncoding=[Text.Encoding]::UTF8; $t = Get-Clipboard -Raw; if ($null -ne $t) { [Console]::Out.Write($t) }']);
+  } else if (platform === 'darwin') {
+    text = await run('pbpaste', []);
+  } else {
+    for (const [cmd, args] of [['wl-paste', ['--no-newline']], ['xclip', ['-selection', 'clipboard', '-o']], ['xsel', ['--clipboard', '--output']]]) {
+      text = await run(cmd, args);
+      if (text != null) break;
+    }
+  }
+  return text ? text : null;
+}
+
+// The largest image the gateway path takes comfortably (see imageBlock in tools.js).
+export const IMAGE_MAX_BYTES = 3_500_000;
+// Vision models downscale anything larger than about this themselves; sending more
+// pixels only costs tokens and upload time.
+const MAX_SIDE = 2048;
+
+// PowerShell: scale an image down to MAX_SIDE on its long side, then PNG if that fits
+// the limit (text in screenshots stays crisp), JPEG otherwise. Writes base64 to stdout.
+const PS_ENCODE = `
+function Emit($img) {
+  $w = $img.Width; $h = $img.Height; $s = [Math]::Min(1.0, ${MAX_SIDE} / [Math]::Max($w, $h))
+  if ($s -lt 1.0) {
+    $b = New-Object Drawing.Bitmap ([int]($w * $s)), ([int]($h * $s))
+    $g = [Drawing.Graphics]::FromImage($b); $g.InterpolationMode = 'HighQualityBicubic'
+    $g.DrawImage($img, 0, 0, $b.Width, $b.Height); $g.Dispose(); $img = $b
+  }
+  $m = New-Object IO.MemoryStream; $img.Save($m, [Drawing.Imaging.ImageFormat]::Png)
+  if ($m.Length -gt ${IMAGE_MAX_BYTES}) {
+    $m = New-Object IO.MemoryStream
+    $enc = [Drawing.Imaging.ImageCodecInfo]::GetImageEncoders() | Where-Object { $_.MimeType -eq 'image/jpeg' }
+    $p = New-Object Drawing.Imaging.EncoderParameters 1
+    $p.Param[0] = New-Object Drawing.Imaging.EncoderParameter ([Drawing.Imaging.Encoder]::Quality), 85L
+    $img.Save($m, $enc, $p); [Console]::Out.Write('jpeg:')
+  } else { [Console]::Out.Write('png:') }
+  [Console]::Out.Write([Convert]::ToBase64String($m.ToArray()))
+}`;
+
+const decodeEmitted = (out) => {
+  const m = /^(png|jpeg):([A-Za-z0-9+/=\s]+)$/.exec(String(out || '').trim());
+  return m ? { bytes: Buffer.from(m[2].replace(/\s/g, ''), 'base64'), mime: `image/${m[1]}`, ext: m[1] === 'png' ? '.png' : '.jpg' } : null;
+};
+
+/**
+ * An image file ready to attach: itself when it is already within the limit, otherwise a
+ * smaller copy in the temp folder (null if it cannot be made small enough). Dragging a
+ * 4K screenshot onto the terminal is the common case — rejecting those would make
+ * attaching screenshots fail most of the time.
+ */
+export async function shrinkImageFile(file, { platform = process.platform, run = capture } = {}) {
+  const fs = await import('node:fs');
+  const os = await import('node:os');
+  const path = await import('node:path');
+  let size = 0;
+  try { size = fs.statSync(file).size; } catch { return null; }
+  if (size <= IMAGE_MAX_BYTES) return file;
+  const out = path.join(os.tmpdir(), `jaitus-img-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`);
+  if (platform === 'win32') {
+    const lit = file.replace(/'/g, "''");
+    const r = decodeEmitted(await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      `Add-Type -AssemblyName System.Drawing; ${PS_ENCODE}; $i = [Drawing.Image]::FromFile('${lit}'); Emit $i; $i.Dispose()`], { timeout: 20000 }));
+    if (!r) return null;
+    fs.writeFileSync(out + r.ext, r.bytes);
+    return r.bytes.length <= IMAGE_MAX_BYTES ? out + r.ext : null;
+  }
+  if (platform === 'darwin') {
+    const ok = await run('sips', ['-Z', String(MAX_SIDE), '-s', 'format', 'jpeg', '-s', 'formatOptions', '85', file, '--out', `${out}.jpg`], { timeout: 20000 });
+    return ok != null && fs.existsSync(`${out}.jpg`) && fs.statSync(`${out}.jpg`).size <= IMAGE_MAX_BYTES ? `${out}.jpg` : null;
+  }
+  for (const cmd of ['magick', 'convert']) {
+    const ok = await run(cmd, [file, '-resize', `${MAX_SIDE}x${MAX_SIDE}>`, '-quality', '85', `${out}.jpg`], { timeout: 20000 });
+    if (ok != null && fs.existsSync(`${out}.jpg`)) return fs.statSync(`${out}.jpg`).size <= IMAGE_MAX_BYTES ? `${out}.jpg` : null;
+  }
+  return null;
+}
+
+/** An image on the clipboard as { bytes, mime, ext }, already sized to attach, or null. */
+export async function readClipboardImage({ platform = process.platform, run = capture } = {}) {
+  const fake = await standIn('image');
+  if (fake !== undefined) return fake;
+  if (platform === 'win32') {
+    return decodeEmitted(await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      `Add-Type -AssemblyName System.Windows.Forms,System.Drawing; ${PS_ENCODE}; $i = [Windows.Forms.Clipboard]::GetImage(); if (!$i) { exit 1 }; Emit $i`],
+    { timeout: 12000 }));
+  }
+  // Elsewhere the raw PNG; the caller writes it out and shrinks it with shrinkImageFile.
+  if (platform === 'darwin') {
+    // pngpaste is not built in; osascript is, and can write the clipboard's PNG itself.
+    const bytes = await run('pngpaste', ['-'], { timeout: 8000, binary: true });
+    if (bytes?.length) return { bytes, mime: 'image/png', ext: '.png' };
+    const os = await import('node:os');
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const out = path.join(os.tmpdir(), `jaitus-clip-${Date.now()}.png`);
+    const ok = await run('osascript', ['-e', `set f to open for access POSIX file "${out}" with write permission`, '-e', 'write (the clipboard as «class PNGf») to f', '-e', 'close access f'], { timeout: 8000 });
+    if (ok != null && fs.existsSync(out) && fs.statSync(out).size > 0) return { bytes: fs.readFileSync(out), mime: 'image/png', ext: '.png' };
+    return null;
+  }
+  for (const [cmd, args] of [['wl-paste', ['--type', 'image/png']], ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o']]]) {
+    const bytes = await run(cmd, args, { timeout: 8000, binary: true });
+    if (bytes?.length) return { bytes, mime: 'image/png', ext: '.png' };
+  }
+  return null;
+}

package/src/tui/entries.js

@@ -139,7 +139,7 @@ const BUILDERS = {
     const p = palette();
     const bar = { t: pick(['▌', '|']), color: p.brand };
     const inner = Math.max(12, width - 2);
-    const body = wrapRow([{ t: String(data.text || ''), color: p.text, bold: true }], inner);
+    const body = wrapRow([{ t: String(data.text || ''), color: p.body, bold: true }], inner);
     const rows = body.map((row) => [bar, { t: ' ' }, ...row]);
     if (data.attachments?.length) {
       rows.push([bar, { t: ' ' }, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
@@ -173,7 +173,7 @@ const BUILDERS = {
       { t: `${icon} `, color: data.status === 'ok' ? p.dim : style.color },
       { t: prettyName(data.name), color: data.status === 'failed' ? p.red : p.muted, bold: data.status === 'running' },
       { t: '  ' },
-      { t: String(data.label || ''), color: data.status === 'ok' ? p.dim : p.text },
+      { t: String(data.label || ''), color: data.status === 'ok' ? p.dim : p.body },
     ];
     if (data.took != null) head.push({ t: `  ${data.took}s`, color: p.faint });
     if (data.status === 'running') head.push({ t: '  …', color: p.brand });
@@ -214,7 +214,7 @@ const BUILDERS = {
 
     rows.push([
       { t: `${pick(['◈', '~'])} `, color: p.brand },
-      { t: String(data.file || 'diff'), color: p.text, bold: true },
+      { t: String(data.file || 'diff'), color: p.body, bold: true },
       { t: '  ' },
       { t: `+${added}`, color: p.addFg },
       { t: ' ' },
@@ -259,7 +259,7 @@ const BUILDERS = {
     const inner = Math.max(12, width - 2);
 
     rows.push([bar, { t: ' ' }, { t: `${pick(['✗', 'x'])} ${data.title || 'Error'}`, color: p.red, bold: true }]);
-    for (const row of wrapRow([{ t: String(data.message || ''), color: p.text }], inner)) {
+    for (const row of wrapRow([{ t: String(data.message || ''), color: p.body }], inner)) {
       rows.push([bar, { t: ' ' }, ...row]);
     }
     if (data.hint) {
@@ -302,7 +302,7 @@ const BUILDERS = {
       const mark = status === 'completed' ? pick(['✔', 'x']) : status === 'in_progress' ? pick(['◐', '>']) : pick(['○', ' ']);
       const color = status === 'completed' ? p.teal : status === 'in_progress' ? p.brand : p.dim;
       const text = String(item?.task || item?.content || '');
-      const body = wrapRow([{ t: text, color: status === 'completed' ? p.dim : p.text, strikethrough: status === 'completed' }], Math.max(10, width - 6));
+      const body = wrapRow([{ t: text, color: status === 'completed' ? p.dim : p.body, strikethrough: status === 'completed' }], Math.max(10, width - 6));
       body.forEach((row, index) => rows.push(index === 0
         ? [{ t: '  ' }, { t: `${mark} `, color }, ...row]
         : [{ t: '    ' }, ...row]));

package/src/tui/highlight.js

@@ -108,7 +108,7 @@ export function highlightLine(line, language, state = {}) {
   const p = palette();
   const lang = spec(language);
   const text = String(line ?? '');
-  if (!lang) return { spans: text ? [{ t: text, color: p.text }] : [], state };
+  if (!lang) return { spans: text ? [{ t: text, color: p.body }] : [], state };
 
   const spans = [];
   let i = 0;
@@ -176,7 +176,7 @@ export function highlightLine(line, language, state = {}) {
         : lang.typeSet.has(w) ? p.synType
         : /^\s*\(/.test(after) ? p.synFunc
         : /^[A-Z]/.test(w) ? p.synType
-        : p.text;
+        : p.body;
       push(w, color, lang.keywordSet.has(w) ? { bold: true } : undefined);
       i += w.length;
       continue;
@@ -186,9 +186,9 @@ export function highlightLine(line, language, state = {}) {
     if (punct) { push(punct[0], p.synPunct); i += punct[0].length; continue; }
 
     const space = /^\s+/.exec(rest);
-    if (space) { push(space[0], p.text); i += space[0].length; continue; }
+    if (space) { push(space[0], p.body); i += space[0].length; continue; }
 
-    push(rest[0], p.text);
+    push(rest[0], p.body);
     i += 1;
   }
 

package/src/tui/markdown.js

@@ -116,7 +116,7 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
     const heading = HEADING.exec(line);
     if (heading) {
       const level = heading[1].length;
-      const color = level === 1 ? p.brand : level === 2 ? p.tealSoft : p.text;
+      const color = level === 1 ? p.brand : level === 2 ? p.tealSoft : p.body;
       if (!compact) blank();
       const content = inlineSpans(heading[2].replace(/\s+#+\s*$/, ''), { color, bold: level <= 3 });
       for (const row of wrapRow(content, w)) rows.push(row);

package/src/tui/theme.js

@@ -129,6 +129,14 @@ const DALTONIZED = {
   synKeyword: '#f0c97a',
 };
 
+// `body` is text drawn straight on the terminal's own background: the composer, your
+// prompts, code, plain rows. It is deliberately NO colour — the terminal's own
+// foreground, which contrasts with its own background by construction — because the app
+// cannot see that background and a guess can be wrong (the dark theme's near-white text
+// was invisible in a light macOS Terminal). `text` stays for text on a surface the app
+// paints itself (dialogs, panels, the selected row), where it knows both colours.
+for (const theme of [DARK, LIGHT, OCEAN, DALTONIZED]) theme.body = undefined;
+
 const THEMES = { dark: DARK, light: LIGHT, ocean: OCEAN, daltonized: DALTONIZED };
 
 /**

package/src/tui/widgets.js

@@ -194,8 +194,12 @@ export function Reveal({ children, rows, duration = 140 }) {
 /** Rows of spans → Ink text. The single place span objects become pixels. */
 export function Rows({ rows, maxRows }) {
   const visible = maxRows && rows.length > maxRows ? rows.slice(rows.length - maxRows) : rows;
-  return h(Box, { flexDirection: 'column' }, visible.map((row, index) =>
-    h(Text, { key: index, wrap: 'truncate-end' }, row.length
+  // flexShrink 0, on the column and on every row: inside a box with a fixed height,
+  // Yoga otherwise SHRINKS rows to fit, and shrunk rows in a terminal are drawn on top
+  // of each other — two lines of a reply painted onto one ("while it arrives.is a
+  // reply…", measured). Rows that do not fit must be clipped by the parent, never merged.
+  return h(Box, { flexDirection: 'column', flexShrink: 0 }, visible.map((row, index) =>
+    h(Text, { key: index, wrap: 'truncate-end', flexShrink: 0 }, row.length
       ? row.map((span, i) => h(Text, {
         key: i,
         color: span.color,