@alumbwe/anvil 1.0.0

package/src/utils/clipboard.ts

@@ -0,0 +1,397 @@
+import { spawn } from 'child_process'
+import { closeSync, openSync, writeSync } from 'fs'
+
+import type { ChildProcess } from 'child_process'
+
+import { getCliEnv } from './env'
+import { logger } from './logger'
+
+// Global renderer reference for clipboard operations.
+// Registered once by the useClipboard hook so all callers of
+// copyTextToClipboard automatically benefit from renderer-based
+// OSC 52 without threading the renderer through every call site.
+let registeredRenderer: Record<string, unknown> | null = null
+
+export function registerClipboardRenderer(
+  renderer: Record<string, unknown>,
+): void {
+  registeredRenderer = renderer
+}
+
+export function unregisterClipboardRenderer(): void {
+  registeredRenderer = null
+}
+
+type ClipboardListener = (message: string | null) => void
+
+let currentMessage: string | null = null
+const listeners = new Set<ClipboardListener>()
+let clearTimer: ReturnType<typeof setTimeout> | null = null
+
+interface ShowMessageOptions {
+  durationMs?: number
+}
+
+export function subscribeClipboardMessages(
+  listener: ClipboardListener,
+): () => void {
+  listeners.add(listener)
+  listener(currentMessage)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+function emitClipboardMessage(message: string | null) {
+  currentMessage = message
+  for (const listener of listeners) {
+    listener(message)
+  }
+}
+
+export function showClipboardMessage(
+  message: string | null,
+  options: ShowMessageOptions = {},
+) {
+  if (clearTimer) {
+    clearTimeout(clearTimer)
+    clearTimer = null
+  }
+
+  emitClipboardMessage(message)
+
+  const duration = options.durationMs ?? 3000
+  if (message && duration > 0) {
+    clearTimer = setTimeout(() => {
+      emitClipboardMessage(null)
+      clearTimer = null
+    }, duration)
+  }
+}
+
+function getDefaultSuccessMessage(text: string): string | null {
+  const preview = text.replace(/\s+/g, ' ').trim()
+  if (!preview) {
+    return null
+  }
+  const truncated = preview.length > 40 ? `${preview.slice(0, 37)}…` : preview
+  return `Copied: "${truncated}"`
+}
+
+type ClipboardCandidate = {
+  text: string
+  successMessage?: string | null
+}
+
+let activeClipboardOperation: AbortController | null = null
+
+export interface CopyToClipboardOptions {
+  successMessage?: string | null
+  errorMessage?: string | null
+  durationMs?: number
+  suppressGlobalMessage?: boolean
+  getOsc52Fallback?: () => ClipboardCandidate
+  signal?: AbortSignal
+}
+
+export async function copyTextToClipboard(
+  text: string,
+  {
+    successMessage,
+    errorMessage,
+    durationMs,
+    suppressGlobalMessage = false,
+    getOsc52Fallback,
+    signal,
+  }: CopyToClipboardOptions = {},
+) {
+  if (!text || text.trim().length === 0) {
+    return
+  }
+
+  throwIfClipboardAborted(signal)
+  const operationController = new AbortController()
+  activeClipboardOperation?.abort()
+  activeClipboardOperation = operationController
+  const operationSignal = signal
+    ? AbortSignal.any([signal, operationController.signal])
+    : operationController.signal
+
+  const osc52Blocked = isOsc52Blocked()
+  try {
+    throwIfClipboardAborted(operationSignal)
+    const tryOsc52 = (candidate: string) =>
+      !osc52Blocked &&
+      isWithinOsc52PayloadLimit(candidate) &&
+      (tryCopyViaRenderer(candidate) || tryCopyViaTtyOsc52(candidate))
+
+    const primary: ClipboardCandidate = { text, successMessage }
+    const remoteSession = isRemoteSession()
+    const tryCandidateViaOsc52 = (candidate: ClipboardCandidate) =>
+      tryOsc52(candidate.text) ? candidate : null
+    const tryFallbackViaOsc52 = () => {
+      if (!getOsc52Fallback) return null
+      const fallback = getOsc52Fallback()
+      return fallback.text.trim() && fallback.text !== text
+        ? tryCandidateViaOsc52(fallback)
+        : null
+    }
+
+    // Remote sessions need OSC 52 to reach the client clipboard. Local
+    // sessions prefer native tools because they survive tmux and have no cap.
+    let copiedCandidate = remoteSession
+      ? (tryCandidateViaOsc52(primary) ?? tryFallbackViaOsc52())
+      : null
+
+    if (
+      !copiedCandidate &&
+      (await tryCopyViaPlatformTool(text, operationSignal))
+    ) {
+      copiedCandidate = primary
+    }
+    if (!copiedCandidate && !remoteSession) {
+      copiedCandidate = tryCandidateViaOsc52(primary) ?? tryFallbackViaOsc52()
+    }
+
+    if (!copiedCandidate) {
+      throw new Error('No clipboard method available')
+    }
+
+    if (!suppressGlobalMessage) {
+      const message =
+        copiedCandidate.successMessage !== undefined
+          ? copiedCandidate.successMessage
+          : getDefaultSuccessMessage(copiedCandidate.text)
+      if (message) {
+        showClipboardMessage(message, { durationMs })
+      }
+    }
+  } catch (error) {
+    if (operationSignal.aborted) throw error
+    logger.error(error, 'Failed to copy to clipboard')
+    // When the terminal drops OSC 52 and no platform tool exists (e.g.
+    // Codespaces), the Shift+drag guidance is the only way the user can copy,
+    // so show it even for callers that suppress routine messages.
+    if (!suppressGlobalMessage || osc52Blocked) {
+      const isLinux = process.platform === 'linux'
+      const defaultErrorMessage = isLinux
+        ? LINUX_CLIPBOARD_ERROR_MESSAGE
+        : 'Failed to copy to clipboard'
+      showClipboardMessage(
+        osc52Blocked
+          ? OSC52_BLOCKED_MESSAGE
+          : (errorMessage ?? defaultErrorMessage),
+        // Give the longer guidance message extra time to be read
+        {
+          durationMs:
+            durationMs ?? (osc52Blocked || isLinux ? 6000 : undefined),
+        },
+      )
+    }
+    throw error
+  } finally {
+    if (activeClipboardOperation === operationController) {
+      activeClipboardOperation = null
+    }
+  }
+}
+
+export function clearClipboardMessage() {
+  if (clearTimer) {
+    clearTimeout(clearTimer)
+    clearTimer = null
+  }
+  emitClipboardMessage(null)
+}
+
+// =============================================================================
+// OSC52 Clipboard Support
+// =============================================================================
+// OSC52 writes to clipboard via terminal escape sequences - works over SSH
+// because the client terminal handles clipboard. Format: ESC ] 52 ; c ; <base64> BEL
+// tmux/screen require passthrough wrapping to forward the sequence.
+
+export function isRemoteSession(): boolean {
+  const env = getCliEnv()
+  return !!(env.SSH_CLIENT || env.SSH_TTY || env.SSH_CONNECTION)
+}
+
+export const OSC52_BLOCKED_MESSAGE =
+  'Copy is blocked by this terminal — hold Shift and drag to select, then copy normally'
+
+export const LINUX_CLIPBOARD_ERROR_MESSAGE =
+  'Clipboard unavailable — install wl-clipboard (Wayland) or xclip (X11)'
+
+// GitHub Codespaces and VS Code remote (SSH/tunnel) terminals silently drop
+// OSC 52 sequences, so a "successful" write never reaches the user's
+// clipboard. Local VS Code terminals (including devcontainers) honor OSC 52.
+// https://github.com/microsoft/vscode-remote-release/issues/11475
+export function isOsc52Blocked(): boolean {
+  const env = getCliEnv()
+  return (
+    env.TERM_PROGRAM === 'vscode' &&
+    (env.CODESPACES === 'true' || isRemoteSession())
+  )
+}
+
+const CLIPBOARD_TOOL_TIMEOUT_MS = 5000
+
+function throwIfClipboardAborted(signal?: AbortSignal): void {
+  if (!signal?.aborted) return
+  if (signal.reason instanceof Error) throw signal.reason
+  throw new DOMException('The clipboard operation was aborted', 'AbortError')
+}
+
+function killClipboardTool(child: ChildProcess): void {
+  try {
+    child.kill('SIGKILL')
+  } catch {
+    // The process may already have exited between an error and cleanup.
+  }
+}
+
+function writeToClipboardTool(
+  command: string,
+  args: string[],
+  text: string,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  return new Promise((resolve) => {
+    let child: ChildProcess
+    try {
+      child = spawn(command, args, {
+        stdio: ['pipe', 'ignore', 'ignore'],
+      })
+    } catch {
+      resolve(false)
+      return
+    }
+
+    let settled = false
+    let timeout: ReturnType<typeof setTimeout> | null = null
+    const finish = (copied: boolean) => {
+      if (settled) return
+      settled = true
+      if (timeout) clearTimeout(timeout)
+      signal?.removeEventListener('abort', handleAbort)
+      resolve(copied)
+    }
+    const handleAbort = () => {
+      killClipboardTool(child)
+      finish(false)
+    }
+
+    child.once('error', () => finish(false))
+    child.once('close', (code) => finish(code === 0))
+    child.stdin?.once('error', () => {
+      killClipboardTool(child)
+      finish(false)
+    })
+
+    timeout = setTimeout(() => {
+      // A backend waiting on a broken display server must not freeze the TUI.
+      // SIGKILL also prevents a timed-out process from retaining the clipboard
+      // pipe after the next backend starts.
+      killClipboardTool(child)
+      finish(false)
+    }, CLIPBOARD_TOOL_TIMEOUT_MS)
+    signal?.addEventListener('abort', handleAbort, { once: true })
+
+    try {
+      child.stdin?.end(text)
+    } catch {
+      killClipboardTool(child)
+      finish(false)
+    }
+
+    // Abort may have happened between the caller's check and listener setup.
+    if (signal?.aborted) handleAbort()
+  })
+}
+
+async function tryCopyViaPlatformTool(
+  text: string,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  const commands: [string, string[]][] = (() => {
+    if (process.platform === 'darwin') return [['pbcopy', []]]
+    if (process.platform === 'win32') return [['clip', []]]
+    if (process.platform !== 'linux') return []
+
+    const x11Commands: [string, string[]][] = [
+      ['xclip', ['-selection', 'clipboard']],
+      ['xsel', ['--clipboard', '--input']],
+    ]
+    return getCliEnv().WAYLAND_DISPLAY
+      ? [['wl-copy', ['--type', 'text/plain']], ...x11Commands]
+      : x11Commands
+  })()
+
+  for (const [command, args] of commands) {
+    throwIfClipboardAborted(signal)
+    const copied = await writeToClipboardTool(command, args, text, signal)
+    throwIfClipboardAborted(signal)
+    if (copied) return true
+  }
+
+  return false
+}
+
+function tryCopyViaRenderer(text: string): boolean {
+  if (!registeredRenderer) return false
+  const copyFn = registeredRenderer.copyToClipboardOSC52
+  if (typeof copyFn !== 'function') return false
+  try {
+    return Boolean(copyFn.call(registeredRenderer, text))
+  } catch {
+    return false
+  }
+}
+
+// 32KB is safe for all environments (tmux is the strictest)
+const OSC52_MAX_PAYLOAD = 32_000
+
+function isWithinOsc52PayloadLimit(text: string): boolean {
+  const byteLength = Buffer.byteLength(text, 'utf8')
+  const base64Length = 4 * Math.ceil(byteLength / 3)
+  return base64Length <= OSC52_MAX_PAYLOAD
+}
+
+function buildOsc52Sequence(text: string): string | null {
+  const env = getCliEnv()
+  if (env.TERM === 'dumb') return null
+  if (!isWithinOsc52PayloadLimit(text)) return null
+
+  const base64 = Buffer.from(text, 'utf8').toString('base64')
+
+  const osc = `\x1b]52;c;${base64}\x07`
+
+  // tmux: wrap in DCS passthrough with doubled ESC
+  if (env.TMUX) {
+    return `\x1bPtmux;${osc.replace(/\x1b/g, '\x1b\x1b')}\x1b\\`
+  }
+
+  // GNU screen: wrap in DCS passthrough
+  if (env.STY) {
+    return `\x1bP${osc}\x1b\\`
+  }
+
+  return osc
+}
+
+function tryCopyViaTtyOsc52(text: string): boolean {
+  const sequence = buildOsc52Sequence(text)
+  if (!sequence) return false
+
+  const ttyPath = process.platform === 'win32' ? 'CON' : '/dev/tty'
+  let fd: number | null = null
+  try {
+    fd = openSync(ttyPath, 'w')
+    writeSync(fd, sequence)
+    return true
+  } catch {
+    return false
+  } finally {
+    if (fd !== null) closeSync(fd)
+  }
+}

package/src/utils/code-search-summary.ts

@@ -0,0 +1,70 @@
+import { getAgentBaseName } from './message-block-helpers'
+
+import type {
+  AgentContentBlock,
+  ContentBlock,
+  ToolContentBlock,
+} from '../types/chat'
+
+export function countCodeSearchResults(output?: string): number {
+  if (!output) {
+    return 0
+  }
+
+  const lines = output.split('\n')
+  const matchCountLine = lines.find((line) =>
+    /^Found \d+ match(?:es)?$/.test(line.trim()),
+  )
+  const parsedTotalResults = matchCountLine
+    ?.trim()
+    .match(/^Found (\d+) match(?:es)?$/)?.[1]
+
+  if (parsedTotalResults !== undefined) {
+    return Number(parsedTotalResults)
+  }
+
+  return lines.reduce((total, line) => {
+    const trimmed = line.trim()
+    return /^(?:Line\s+)?\d+:/.test(trimmed) ? total + 1 : total
+  }, 0)
+}
+
+const pluralize = (count: number, singular: string, plural = `${singular}s`) =>
+  `${count} ${count === 1 ? singular : plural}`
+
+const isCodeSearchToolBlock = (
+  block: ContentBlock,
+): block is ToolContentBlock =>
+  block.type === 'tool' && block.toolName === 'code_search'
+
+export function getCodeSearcherCollapsedPreview(
+  agentBlock: AgentContentBlock,
+): string | undefined {
+  if (getAgentBaseName(agentBlock.agentType) !== 'code-searcher') {
+    return undefined
+  }
+
+  const toolBlocks = (agentBlock.blocks ?? []).filter(isCodeSearchToolBlock)
+  const searchQueries = Array.isArray(agentBlock.params?.searchQueries)
+    ? agentBlock.params.searchQueries
+    : []
+  const searchCount = searchQueries.length || toolBlocks.length
+
+  if (searchCount === 0) {
+    return undefined
+  }
+
+  const completedToolBlocks = toolBlocks.filter((block) => block.output)
+  const searchLabel = pluralize(searchCount, 'search', 'searches')
+
+  if (completedToolBlocks.length === 0) {
+    return searchLabel
+  }
+
+  const totalResults = completedToolBlocks.reduce(
+    (total, block) => total + countCodeSearchResults(block.output),
+    0,
+  )
+
+  return `${searchLabel} · ${pluralize(totalResults, 'result')}`
+}