@hncode/hncode 0.1.7 → 0.1.9

package/src/clipboard.js

@@ -9,6 +9,9 @@
 // Non-Windows paths (pbcopy/pbpaste/xclip) are cheap enough to run per call.
 
 import cp from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 const SENT = '@@HNCODE_CLIP@@';
 let helper = null;      // long-lived PowerShell child
@@ -59,10 +62,10 @@ function helperRun(script, timeoutMs) {
   warmClipboard();
   if (!helper) return Promise.resolve(null);
   return new Promise((resolve) => {
-    const timer = setTimeout(() => { resolve(null); }, timeoutMs);
+    const timer = setTimeout(() => { helperBusy = false; resolve(null); }, timeoutMs);
     helperQueue.push((out) => { clearTimeout(timer); resolve(out); });
     try { helper.stdin.write(script + `\n'${SENT}'\n`); }
-    catch { clearTimeout(timer); resolve(null); }
+    catch { clearTimeout(timer); helperBusy = false; resolve(null); }
   });
 }
 
@@ -98,17 +101,117 @@ export async function readText(timeoutMs = 3000) {
   try { return { text: readOnce(), via: 'oneshot' }; } catch { return { text: '', via: 'none' }; }
 }
 
-// Read clipboard as image (base64 PNG). Returns null if clipboard has no image.
-export function readImage() {
-  if (!win()) return null;
+// Unified clipboard read: returns text to insert into the composer, handling
+// three clipboard shapes:
+//   1. copied FILES          -> absolute path(s)
+//   2. plain TEXT            -> the text itself
+//   3. an IMAGE (screenshot) -> saved to a temp .png, returns its path
+//
+// SPEED: a cold PowerShell costs ~2.9s on Windows (measured), while a command on
+// the already-warm, long-lived helper (see warmClipboard) costs ~10ms. The TUI
+// pre-warms the helper at start, so we run this probe on THAT shell. Only if the
+// helper is unavailable do we fall back to a one-shot PowerShell.
+//
+// The probe prints a tagged result that can be parsed cheaply:
+//   F::<path>   a copied file path (one line per file)
+//   T::<base64> base64-encoded clipboard text
+//   I::<path>   a clipboard image saved to a temp png
+//   (empty)     nothing usable on the clipboard
+//
+// NOTE: no `-join` here. A backtick-n inside the JS string produced a broken
+// PowerShell expression (silently returned nothing), which made FILE pastes fall
+// back to the slow cold spawn. Emitting one F:: line per file is simpler and
+// also supports multi-file copies.
+const CLIP_PROBE = [
+  "$ErrorActionPreference='SilentlyContinue'",
+  "$f=Get-Clipboard -Format FileDropList",
+  "if($f -and $f.Count -gt 0){$f|ForEach-Object{'F::'+$_.FullName};return}",
+  "$t=Get-Clipboard -Raw",
+  "if($t){'T::'+[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($t));return}",
+  "$i=Get-Clipboard -Image",
+  "if($null -ne $i){$p=Join-Path $env:TEMP ('hncode-paste-'+[guid]::NewGuid().ToString('N')+'.png');$i.Save($p,[System.Drawing.Imaging.ImageFormat]::Png);'I::'+$p}",
+].join('; ');
+
+// Parse the probe output into { text, via }. Handles one-or-more F:: lines.
+function parseClipResult(out) {
+  const lines = String(out == null ? '' : out).replace(/\r/g, '').split('\n').map((l) => l.trim()).filter(Boolean);
+  if (!lines.length) return null;
+  const fileLines = lines.filter((l) => l.startsWith('F::'));
+  if (fileLines.length) return { text: fileLines.map((l) => l.slice(3).trim()).join('\n'), via: 'files' };
+  const imgLine = lines.find((l) => l.startsWith('I::'));
+  if (imgLine) return { text: imgLine.slice(3).trim(), via: 'image' };
+  const txtLine = lines.find((l) => l.startsWith('T::'));
+  if (txtLine) {
+    try { return { text: Buffer.from(txtLine.slice(3).trim(), 'base64').toString('utf8'), via: 'text' }; }
+    catch { return null; }
+  }
+  return null;
+}
+
+// Run the probe on the warm helper (fast path). Resolves null if it is not ready.
+async function readViaHelper() {
+  warmClipboard();
+  if (!helper) return null;
+  // Wait briefly for any in-flight command (e.g. a concurrent readText) to drain,
+  // so we still hit the warm shell instead of falling back to a cold spawn.
+  for (let i = 0; i < 20 && helperBusy; i++) {
+    await new Promise((r) => setTimeout(r, 25));
+  }
+  if (helperBusy) return null;
+  helperBusy = true;
+  const out = await helperRun(CLIP_PROBE, 3000);
+  return out == null ? null : parseClipResult(out);
+}
+
+export function readClipboardContent() {
+  if (!win()) {
+    try { return { text: readOnce(), via: 'oneshot' }; } catch { return { text: '', via: 'none' }; }
+  }
+  // Synchronous API is required by the caller, so use a one-shot PowerShell here
+  // and let the async path (readClipboardContentAsync) use the warm helper.
+  const scriptFile = clipScriptPath();
+  if (!scriptFile) return { text: '', via: 'none' };
   try {
-    // PowerShell: Get-Clipboard -Image, save to temp file, read as base64
-    const b64 = cp.execSync(
-      'powershell -NoProfile -Command "$img = Get-Clipboard -Image; if ($null -ne $img) { $path = [System.IO.Path]::GetTempFileName() + \'.png\'; $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png); $bytes = [System.IO.File]::ReadAllBytes($path); Remove-Item $path; Write-Host ([Convert]::ToBase64String($bytes)) }"',
-      { encoding: 'ascii', windowsHide: true, timeout: 8000 },
+    const out = cp.execSync(
+      `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptFile}"`,
+      { encoding: 'utf8', windowsHide: true, timeout: 8000 },
     );
-    const s = String(b64).replace(/[^A-Za-z0-9+/=]/g, '');
-    if (s.length > 0) return s;
-    return null;
-  } catch { return null; }
+    return parseClipResult(out) || { text: '', via: 'none' };
+  } catch { return { text: '', via: 'none' }; }
+}
+
+// Async version that prefers the warm helper (~10ms) over a cold spawn (~2.9s).
+export async function readClipboardContentAsync() {
+  if (!win()) {
+    try { return { text: readOnce(), via: 'oneshot' }; } catch { return { text: '', via: 'none' }; }
+  }
+  const viaHelper = await readViaHelper();
+  if (viaHelper) return viaHelper;
+  return readClipboardContent();
+}
+
+// The PowerShell logic for the one-shot fallback lives in a temp .ps1 file:
+// passing a multi-line script via -Command "..." mangles its own quotes on
+// Windows, so we write the script once and re-use it by path.
+let _clipScript = null;
+function clipScriptPath() {
+  if (_clipScript) return _clipScript;
+  const p = path.join(os.tmpdir(), 'hncode-clipread.ps1');
+  const script = [
+    "$ErrorActionPreference = 'SilentlyContinue'",
+    '$files = Get-Clipboard -Format FileDropList',
+    'if ($files -and $files.Count -gt 0) { $files | ForEach-Object { "F::" + $_.FullName }; exit }',
+    '$txt = Get-Clipboard -Raw',
+    'if ($txt) { "T::" + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($txt)); exit }',
+    '$img = Get-Clipboard -Image',
+    'if ($null -ne $img) {',
+    '  $path = Join-Path $env:TEMP ("hncode-paste-" + [guid]::NewGuid().ToString("N") + ".png")',
+    '  $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png)',
+    '  "I::" + $path',
+    '}',
+    '',
+  ].join('\n');
+  try { fs.writeFileSync(p, script, 'utf8'); } catch { return null; }
+  _clipScript = p;
+  return p;
 }

package/src/colors.js

@@ -81,11 +81,14 @@ export const C = {
   selBg: TRUECOLOR ? brgb(0, 70, 84) : '\x1b[48;5;23m', // Original dark cyan background
   scrollTrack: '\x1b[90m',          // dim gutter
   scrollThumb: TRUECOLOR ? rgb(0, 184, 219) : '\x1b[38;5;37m', // brand cyan-blue
-  // Scrollbar interaction states. hover: a touch whiter/brighter than the brand
-  // colour; active (pressed/dragging): a touch darker. Idle returns to
-  // scrollThumb (the brand colour) — the caller swaps back automatically.
+  // Scrollbar interaction states:
+  //   hover  -> a touch whiter/brighter than the brand colour
+  //   active -> BOLD + the brand colour (pressed/dragging)
+  // The pressed state used to be a DARKER colour, which on a dark background
+  // read as "the thumb disappeared". Making it bold-and-bright means a press is
+  // always unmistakably visible. Idle swaps back to scrollThumb automatically.
   scrollThumbHover: TRUECOLOR ? rgb(120, 226, 245) : '\x1b[38;5;123m',
-  scrollThumbActive: TRUECOLOR ? rgb(0, 140, 168) : '\x1b[38;5;31m',
+  scrollThumbActive: '\x1b[1m' + (TRUECOLOR ? rgb(0, 220, 255) : '\x1b[38;5;51m'),
   // Hover highlight for clickable rows (menu items, picker options, form
   // fields, composer rows). An explicit bright foreground + BOLD rather than a
   // bare BOLD: BOLD only brightens the 16-colour palette (it does nothing to a
@@ -129,12 +132,17 @@ export function setTheme(name) {
   C.bgPanel = brgb(...t.bg);
   C.selBg = brgb(...t.selBg);
   
-  // Scrollbar colors - adjust based on theme brightness
-  const isLight = t.bg[0] > 128; // Simple brightness check
-  C.scrollTrack = isLight ? '\x1b[90m' : '\x1b[90m'; // dim gutter (works for both)
+  // Scrollbar colours. The active (pressed/dragging) thumb is BOLD + a brighter
+  // shade of the theme colour. It used to be a DARKER shade, which on a dark
+  // background read as "the thumb vanished" mid-drag.
+  C.scrollTrack = '\x1b[90m'; // dim gutter
   C.scrollThumb = rgb(...t.teal);
   C.scrollThumbHover = rgb(...t.hover);
-  C.scrollThumbActive = rgb(t.teal[0] * 0.7, t.teal[1] * 0.7, t.teal[2] * 0.7);
+  C.scrollThumbActive = '\x1b[1m' + rgb(
+    Math.min(255, Math.round(t.teal[0] * 0.6 + 255 * 0.4)),
+    Math.min(255, Math.round(t.teal[1] * 0.6 + 255 * 0.4)),
+    Math.min(255, Math.round(t.teal[2] * 0.6 + 255 * 0.4)),
+  );
 
   // Hover stays visible on this theme's background (bright on dark, dark on light).
   C.hover = '\x1b[1m' + rgb(...(t.hover || [190, 245, 255]));

package/src/index.js

@@ -11,7 +11,7 @@ import { setToolsList } from './llm.js';
 
 export const VERSION = '0.1.0';
 
-const HELP = `hncode ${VERSION} — a kimi-code-cli-style coding agent.
+const HELP = `hncode ${VERSION} — a Kimi Code-style coding agent.
 
 Usage: hncode [options] [command]