@docyrus/docyrus 0.0.21 → 0.0.22

package/resources/pi-agent/extensions/pi-bash-live-view/terminal-emulator.ts

@@ -0,0 +1,439 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+type StyleMode = 'default' | 'rgb' | 'palette';
+
+type CellStyle = {
+  bold: boolean;
+  dim: boolean;
+  italic: boolean;
+  underline: boolean;
+  inverse: boolean;
+  invisible: boolean;
+  strikethrough: boolean;
+  fgMode: StyleMode;
+  fg: number;
+  bgMode: StyleMode;
+  bg: number;
+};
+
+type SnapshotCell = {
+  ch: string;
+  style: CellStyle;
+};
+
+type SnapshotLine = SnapshotCell[];
+export type TerminalSnapshot = SnapshotLine[];
+
+type TerminalUpdatePayload = {
+  elapsedMs: number;
+  snapshot: TerminalSnapshot;
+  inAltScreen: boolean;
+  inSyncRender: boolean;
+};
+
+type XtermCellLike = {
+  isBold?: () => boolean;
+  isDim?: () => boolean;
+  isItalic?: () => boolean;
+  isUnderline?: () => boolean;
+  isInverse?: () => boolean;
+  isInvisible?: () => boolean;
+  isStrikethrough?: () => boolean;
+  isFgDefault?: () => boolean;
+  isFgRGB?: () => boolean;
+  isFgPalette?: () => boolean;
+  isBgDefault?: () => boolean;
+  isBgRGB?: () => boolean;
+  isBgPalette?: () => boolean;
+  getFgColor?: () => number;
+  getBgColor?: () => number;
+  getWidth: () => number;
+  getChars: () => string;
+};
+
+type XtermBufferLineLike = {
+  isWrapped?: boolean;
+  translateToString: (trimRight?: boolean) => string;
+  getCell: (x: number, cell?: XtermCellLike) => XtermCellLike | undefined;
+};
+
+type XtermBufferLike = {
+  baseY: number;
+  length: number;
+  getLine: (y: number) => XtermBufferLineLike | undefined;
+  getNullCell: () => XtermCellLike;
+};
+
+type XtermTerminalLike = {
+  rows: number;
+  cols: number;
+  buffer: {
+    active: XtermBufferLike;
+    normal: XtermBufferLike;
+  };
+  write: (data: string, callback: () => void) => void;
+  dispose?: () => void;
+};
+
+type XtermTerminalCtor = new (options: {
+  cols: number;
+  rows: number;
+  scrollback: number;
+  allowProposedApi: boolean;
+  convertEol: boolean;
+}) => XtermTerminalLike;
+
+let TerminalCtor: XtermTerminalCtor | null = null;
+
+function ensureXtermHeadlessLoaded(): XtermTerminalCtor {
+  if (!globalThis.window) {
+    (globalThis as typeof globalThis & { window: object }).window = {};
+  }
+  if (!TerminalCtor) {
+    ({ Terminal: TerminalCtor } = require('@xterm/headless') as { Terminal: XtermTerminalCtor });
+  }
+  return TerminalCtor;
+}
+
+function defaultStyle(): CellStyle {
+  return {
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false,
+    inverse: false,
+    invisible: false,
+    strikethrough: false,
+    fgMode: 'default',
+    fg: 0,
+    bgMode: 'default',
+    bg: 0,
+  };
+}
+
+function cloneStyle(style: CellStyle): CellStyle {
+  return {
+    bold: style.bold,
+    dim: style.dim,
+    italic: style.italic,
+    underline: style.underline,
+    inverse: style.inverse,
+    invisible: style.invisible,
+    strikethrough: style.strikethrough,
+    fgMode: style.fgMode,
+    fg: style.fg,
+    bgMode: style.bgMode,
+    bg: style.bg,
+  };
+}
+
+function cloneSnapshot(snapshot: TerminalSnapshot): TerminalSnapshot {
+  return snapshot.map((line) => line.map((cell) => ({ ...cell, style: cloneStyle(cell.style ?? defaultStyle()) })));
+}
+
+function styleKey(style: CellStyle): string {
+  return [
+    style.bold ? 'b' : '-',
+    style.dim ? 'd' : '-',
+    style.italic ? 'i' : '-',
+    style.underline ? 'u' : '-',
+    style.inverse ? 'v' : '-',
+    style.invisible ? 'x' : '-',
+    style.strikethrough ? 's' : '-',
+    `fg:${style.fgMode}:${style.fg}`,
+    `bg:${style.bgMode}:${style.bg}`,
+  ].join('');
+}
+
+function rgbToSgr(isForeground: boolean, value: number): string {
+  const r = (value >> 16) & 255;
+  const g = (value >> 8) & 255;
+  const b = value & 255;
+  return isForeground ? `38;2;${r};${g};${b}` : `48;2;${r};${g};${b}`;
+}
+
+function paletteToSgr(isForeground: boolean, index: number): string {
+  return isForeground ? `38;5;${index}` : `48;5;${index}`;
+}
+
+function styleToAnsi(style: CellStyle): string {
+  const codes = ['0'];
+  if (style.bold) codes.push('1');
+  if (style.dim) codes.push('2');
+  if (style.italic) codes.push('3');
+  if (style.underline) codes.push('4');
+  if (style.inverse) codes.push('7');
+  if (style.invisible) codes.push('8');
+  if (style.strikethrough) codes.push('9');
+  if (style.fgMode === 'rgb') codes.push(rgbToSgr(true, style.fg));
+  else if (style.fgMode === 'palette') codes.push(paletteToSgr(true, style.fg));
+  if (style.bgMode === 'rgb') codes.push(rgbToSgr(false, style.bg));
+  else if (style.bgMode === 'palette') codes.push(paletteToSgr(false, style.bg));
+  return `\x1b[${codes.join(';')}m`;
+}
+
+export function snapshotToAnsiContentLines(snapshot: TerminalSnapshot): string[] {
+  return snapshot.map((line) => {
+    let out = '';
+    let current = defaultStyle();
+    let currentKey = styleKey(current);
+    for (const cell of line) {
+      const style = cell.style ?? defaultStyle();
+      const nextKey = styleKey(style);
+      if (nextKey !== currentKey) {
+        out += styleToAnsi(style);
+        current = cloneStyle(style);
+        currentKey = nextKey;
+      }
+      out += cell.ch;
+    }
+    return `${out}\x1b[0m`.replace(/\s+\x1b\[0m$/, '\x1b[0m');
+  });
+}
+
+function sanitizeOutput(text: string): string {
+  return text.replace(/\r/g, '').replace(/\u0000/g, '').replace(/\p{Cf}/gu, '');
+}
+
+function extractTextFromBuffer(buffer: XtermBufferLike): string {
+  const logicalLines: string[] = [];
+
+  for (let i = 0; i < buffer.length; i += 1) {
+    const line = buffer.getLine(i);
+    const text = sanitizeOutput(line?.translateToString(true) ?? '');
+    if (line?.isWrapped && logicalLines.length > 0) {
+      logicalLines[logicalLines.length - 1] += text;
+    } else {
+      logicalLines.push(text);
+    }
+  }
+
+  while (logicalLines.length > 0 && logicalLines[logicalLines.length - 1] === '') {
+    logicalLines.pop();
+  }
+
+  const text = logicalLines.join('\n').trimEnd();
+  return text.length === 0 ? '(no output)' : `${text}\n`;
+}
+
+function normalizePaletteColor(mode: StyleMode, value: number): { mode: StyleMode; value: number } {
+  if (mode !== 'palette') return { mode, value };
+  if (value < 0 || value > 255) {
+    return { mode: 'default', value: 0 };
+  }
+  return { mode: 'palette', value };
+}
+
+function styleFromCell(cell: XtermCellLike | undefined): CellStyle {
+  const rawFgMode: StyleMode = cell?.isFgDefault?.()
+    ? 'default'
+    : cell?.isFgRGB?.()
+      ? 'rgb'
+      : cell?.isFgPalette?.()
+        ? 'palette'
+        : 'default';
+  const rawBgMode: StyleMode = cell?.isBgDefault?.()
+    ? 'default'
+    : cell?.isBgRGB?.()
+      ? 'rgb'
+      : cell?.isBgPalette?.()
+        ? 'palette'
+        : 'default';
+
+  const fg = normalizePaletteColor(rawFgMode, cell?.getFgColor?.() ?? 0);
+  const bg = normalizePaletteColor(rawBgMode, cell?.getBgColor?.() ?? 0);
+
+  return {
+    bold: Boolean(cell?.isBold?.()),
+    dim: Boolean(cell?.isDim?.()),
+    italic: Boolean(cell?.isItalic?.()),
+    underline: Boolean(cell?.isUnderline?.()),
+    inverse: Boolean(cell?.isInverse?.()),
+    invisible: Boolean(cell?.isInvisible?.()),
+    strikethrough: Boolean(cell?.isStrikethrough?.()),
+    fgMode: fg.mode,
+    fg: fg.value,
+    bgMode: bg.mode,
+    bg: bg.value,
+  };
+}
+
+function createXterm(cols: number, rows: number, scrollback: number): XtermTerminalLike {
+  const Terminal = ensureXtermHeadlessLoaded();
+  return new Terminal({
+    cols,
+    rows,
+    scrollback,
+    allowProposedApi: true,
+    convertEol: true,
+  });
+}
+
+function snapshotTerminal(term: XtermTerminalLike): TerminalSnapshot {
+  const buffer = term.buffer.active;
+  const start = buffer.baseY;
+  const lines: TerminalSnapshot = [];
+  const scratchCell = buffer.getNullCell();
+  for (let y = 0; y < term.rows; y++) {
+    const row: SnapshotLine = [];
+    const line = buffer.getLine(start + y);
+    for (let x = 0; x < term.cols; x++) {
+      const cell = line?.getCell(x, scratchCell);
+      if (!cell) {
+        row.push({ ch: ' ', style: defaultStyle() });
+        continue;
+      }
+      if (cell.getWidth() === 0) continue;
+      row.push({
+        ch: cell.getChars() || ' ',
+        style: styleFromCell(cell),
+      });
+    }
+    lines.push(row);
+  }
+  return lines;
+}
+
+function createDecPrivateModeTracker(onModeChange: (mode: number, enabled: boolean) => void) {
+  let state: 'ground' | 'escape' | 'csi' = 'ground';
+  let privateMarker = false;
+  let params = '';
+
+  function reset() {
+    state = 'ground';
+    privateMarker = false;
+    params = '';
+  }
+
+  function finalize(finalByte: string) {
+    if (!privateMarker || (finalByte !== 'h' && finalByte !== 'l')) {
+      reset();
+      return;
+    }
+    const enabled = finalByte === 'h';
+    for (const part of params.split(';')) {
+      if (!part) continue;
+      const mode = Number(part);
+      if (!Number.isInteger(mode)) continue;
+      onModeChange(mode, enabled);
+    }
+    reset();
+  }
+
+  return {
+    push(text: string) {
+      for (const ch of text) {
+        if (state === 'ground') {
+          if (ch === '\x1b') state = 'escape';
+          continue;
+        }
+        if (state === 'escape') {
+          if (ch === '[') {
+            state = 'csi';
+            privateMarker = false;
+            params = '';
+            continue;
+          }
+          state = ch === '\x1b' ? 'escape' : 'ground';
+          continue;
+        }
+        if (state === 'csi') {
+          if (ch === '?') {
+            if (params.length === 0 && !privateMarker) {
+              privateMarker = true;
+              continue;
+            }
+            reset();
+            continue;
+          }
+          if ((ch >= '0' && ch <= '9') || ch === ';') {
+            params += ch;
+            continue;
+          }
+          if (ch >= '@' && ch <= '~') {
+            finalize(ch);
+            continue;
+          }
+          reset();
+        }
+      }
+    },
+  };
+}
+
+export function createTerminalEmulator({ cols, rows, scrollback = 10_000 }: { cols: number; rows: number; scrollback?: number }) {
+  const term = createXterm(cols, rows, scrollback);
+  const listeners = new Set<(payload: TerminalUpdatePayload) => void>();
+  let writeChain: Promise<void | TerminalUpdatePayload> = Promise.resolve();
+  let inAltScreen = false;
+  let inSyncRender = false;
+  let lastCompletedSnapshot = snapshotTerminal(term);
+  let latestSnapshot = cloneSnapshot(lastCompletedSnapshot);
+  let lastElapsedMs = 0;
+  const modeTracker = createDecPrivateModeTracker((mode, enabled) => {
+    if (mode === 2026) {
+      inSyncRender = enabled;
+      return;
+    }
+    if (mode === 1049 || mode === 1047 || mode === 47) {
+      inAltScreen = enabled;
+    }
+  });
+
+  function emitUpdate(payload: TerminalUpdatePayload) {
+    for (const listener of listeners) listener(payload);
+  }
+
+  async function consumeProcessStdout(chunk: string, { elapsedMs = lastElapsedMs }: { elapsedMs?: number } = {}) {
+    lastElapsedMs = elapsedMs;
+    modeTracker.push(chunk);
+    writeChain = writeChain.then(() => new Promise<TerminalUpdatePayload>((resolve) => {
+      term.write(chunk, () => {
+        latestSnapshot = snapshotTerminal(term);
+        const renderableSnapshot = inSyncRender ? lastCompletedSnapshot : latestSnapshot;
+        if (!inSyncRender) lastCompletedSnapshot = cloneSnapshot(latestSnapshot);
+        const payload: TerminalUpdatePayload = {
+          elapsedMs: lastElapsedMs,
+          snapshot: cloneSnapshot(renderableSnapshot),
+          inAltScreen,
+          inSyncRender,
+        };
+        emitUpdate(payload);
+        resolve(payload);
+      });
+    }));
+    return writeChain;
+  }
+
+  function getViewportSnapshot(): TerminalSnapshot {
+    return cloneSnapshot(inSyncRender ? lastCompletedSnapshot : latestSnapshot);
+  }
+
+  function getStrippedTextIncludingEntireScrollback(): string {
+    return extractTextFromBuffer(term.buffer.normal);
+  }
+
+  return {
+    cols,
+    rows,
+    consumeProcessStdout,
+    whenIdle() {
+      return writeChain.then(() => undefined);
+    },
+    subscribe(listener: (payload: TerminalUpdatePayload) => void) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getState() {
+      return { inAltScreen, inSyncRender, elapsedMs: lastElapsedMs };
+    },
+    getViewportSnapshot,
+    getStrippedTextIncludingEntireScrollback,
+    dispose() {
+      term.dispose?.();
+      listeners.clear();
+    },
+  };
+}

package/resources/pi-agent/extensions/pi-bash-live-view/truncate.ts

@@ -0,0 +1,68 @@
+import { randomBytes } from 'node:crypto';
+import { writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_MAX_BYTES, formatSize, truncateTail } from '@mariozechner/pi-coding-agent';
+
+function getTempFilePath() {
+  const id = randomBytes(8).toString('hex');
+  return join(tmpdir(), `pi-bash-${id}.log`);
+}
+
+function maybePersistFullOutput(fullOutput: string) {
+  if (Buffer.byteLength(fullOutput, 'utf-8') <= DEFAULT_MAX_BYTES) return undefined;
+  const tempFilePath = getTempFilePath();
+  writeFileSync(tempFilePath, fullOutput, 'utf-8');
+  return tempFilePath;
+}
+
+function buildTruncationNotice(truncation: ReturnType<typeof truncateTail>, fullOutput: string, tempFilePath?: string) {
+  const startLine = truncation.totalLines - truncation.outputLines + 1;
+  const endLine = truncation.totalLines;
+
+  if (truncation.lastLinePartial) {
+    const lastLineSize = formatSize(Buffer.byteLength(fullOutput.split('\n').pop() || '', 'utf-8'));
+    return `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${tempFilePath}]`;
+  }
+  if (truncation.truncatedBy === 'lines') {
+    return `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+  }
+  return `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+}
+
+export function buildSuccessfulBashResult(fullOutput: string) {
+  const truncation = truncateTail(fullOutput);
+  let outputText = truncation.content || '(no output)';
+  const tempFilePath = truncation.truncated ? maybePersistFullOutput(fullOutput) : undefined;
+  let details;
+
+  if (truncation.truncated) {
+    details = {
+      truncation,
+      fullOutputPath: tempFilePath,
+    };
+    outputText += buildTruncationNotice(truncation, fullOutput, tempFilePath);
+  }
+
+  return {
+    content: [{ type: 'text' as const, text: outputText }],
+    details,
+  };
+}
+
+export function buildExitCodeError(fullOutput: string, exitCode: number) {
+  const result = buildSuccessfulBashResult(fullOutput);
+  const outputText = result.content[0]?.text || '(no output)';
+  return new Error(`${outputText}\n\nCommand exited with code ${exitCode}`);
+}
+
+export function buildAbortError(fullOutput: string) {
+  const output = fullOutput === '(no output)' ? '' : fullOutput;
+  return new Error(output ? `${output}\n\nCommand aborted` : 'Command aborted');
+}
+
+export function buildTimeoutError(fullOutput: string, timeout: number) {
+  const output = fullOutput === '(no output)' ? '' : fullOutput;
+  return new Error(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
+}
+

package/resources/pi-agent/extensions/pi-bash-live-view/widget.ts

@@ -0,0 +1,114 @@
+import type { ExtensionContext } from '@mariozechner/pi-coding-agent';
+import { snapshotToAnsiContentLines } from './terminal-emulator.ts';
+import type { PtyTerminalSession } from './pty-session.ts';
+
+export const WIDGET_PREFIX = 'pi-bash-live-view/live/';
+const DEFAULT_TITLE = 'Live terminal';
+const DEFAULT_ACCENT_COLOR = '77;163;255';
+
+export type LiveSession = {
+  id: string;
+  startedAt: number;
+  rows: number;
+  visible: boolean;
+  disposed: boolean;
+  timer?: NodeJS.Timeout;
+  session: PtyTerminalSession;
+  requestRender?: () => void;
+};
+
+export function formatElapsed(ms: number): string {
+  const totalSeconds = Math.max(0, ms / 1000);
+  if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`;
+  const wholeSeconds = Math.floor(totalSeconds);
+  const hours = Math.floor(wholeSeconds / 3600);
+  const minutes = Math.floor((wholeSeconds % 3600) / 60);
+  const seconds = wholeSeconds % 60;
+  if (hours > 0) return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+  return `${minutes}:${String(seconds).padStart(2, '0')}`;
+}
+
+export function buildTopBorder(title: string, innerWidth: number, elapsedMs: number): string {
+  const timer = ` ${formatElapsed(elapsedMs)} `;
+  const rawTitle = title ? ` ${title} ` : '';
+  const titleText = rawTitle.slice(0, Math.max(0, innerWidth - timer.length));
+  const fill = '─'.repeat(Math.max(0, innerWidth - titleText.length - timer.length));
+  return `${titleText}${fill}${timer}`.padEnd(innerWidth, '─').slice(0, innerWidth);
+}
+
+function fitAnsiLine(line: string, width: number): string {
+  let out = '';
+  let visible = 0;
+  let i = 0;
+  while (i < line.length && visible < width) {
+    if (line[i] === '\x1b' && line[i + 1] === '[') {
+      const match = line.slice(i).match(/^\x1b\[[0-9;]*m/);
+      if (match) {
+        out += match[0];
+        i += match[0].length;
+        continue;
+      }
+    }
+    out += line[i];
+    visible += 1;
+    i += 1;
+  }
+  return `${out}\x1b[0m${' '.repeat(Math.max(0, width - visible))}`;
+}
+
+export function buildWidgetAnsiLines({
+  title = DEFAULT_TITLE,
+  snapshot,
+  width,
+  rows,
+  elapsedMs = 0,
+  accentColor = DEFAULT_ACCENT_COLOR,
+}: {
+  title?: string;
+  snapshot: ReturnType<PtyTerminalSession['getViewportSnapshot']>;
+  width: number;
+  rows: number;
+  elapsedMs?: number;
+  accentColor?: string;
+}): string[] {
+  const accent = `\x1b[38;2;${accentColor}m`;
+  const reset = '\x1b[0m';
+  const innerWidth = Math.max(10, width - 2);
+  const top = `${accent}╭${buildTopBorder(title, innerWidth, elapsedMs)}╮${reset}`;
+  const bottom = `${accent}╰${'─'.repeat(innerWidth)}╯${reset}`;
+  const bodySource = snapshotToAnsiContentLines(snapshot).slice(-rows);
+  const body = [];
+  for (let i = 0; i < rows; i += 1) {
+    const line = fitAnsiLine(bodySource[i] ?? '', innerWidth);
+    body.push(`${accent}│${reset}${line}${accent}│${reset}`);
+  }
+  return [top, ...body, bottom];
+}
+
+function makeWidgetFactory(session: LiveSession) {
+  return (tui: any) => {
+    session.requestRender = () => tui.requestRender();
+    return {
+      invalidate() {},
+      render(width: number) {
+        return buildWidgetAnsiLines({
+          snapshot: session.session.getViewportSnapshot(),
+          width,
+          rows: session.rows,
+          elapsedMs: Date.now() - session.startedAt,
+        });
+      },
+    };
+  };
+}
+
+export function showWidget(ctx: ExtensionContext, session: LiveSession) {
+  if (!ctx.hasUI || session.visible || session.disposed) return;
+  session.visible = true;
+  ctx.ui.setWidget(`${WIDGET_PREFIX}${session.id}`, makeWidgetFactory(session));
+}
+
+export function hideWidget(ctx: ExtensionContext | null, session: LiveSession) {
+  if (!ctx || !ctx.hasUI) return;
+  ctx.ui.setWidget(`${WIDGET_PREFIX}${session.id}`, undefined);
+}