rl-rockcli 0.0.9 → 0.0.11

package/commands/attach/ink-repl/utils/remotePathSafety.js

@@ -0,0 +1,56 @@
+/**
+ * Remote path safety helpers (for sandbox-executed completion commands).
+ */
+
+/**
+ * Return true if the input contains characters that are risky for shell command construction.
+ * This is a conservative deny-list for completion-only paths.
+ * @param {string} input
+ * @returns {boolean}
+ */
+export function hasDangerousShellChars(input) {
+  if (!input) return false;
+  // Reject control chars and common shell metacharacters.
+  return /[\r\n\t\0]/.test(input) || /[;&|`$()<>]/.test(input);
+}
+
+/**
+ * POSIX shell-escape a string as a single-quoted argument.
+ * @param {string} value
+ * @returns {string}
+ */
+export function shellEscapePosix(value) {
+  if (value === '') return "''";
+  // ' -> '\'' (close, escape, reopen)
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * Find the first unescaped space in a string, treating backslash as an escape character.
+ * Returns -1 if none.
+ * @param {string} input
+ * @returns {number}
+ */
+export function findFirstUnescapedSpace(input) {
+  if (!input) return -1;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === '\\') {
+      i += 1; // skip escaped char (if any)
+      continue;
+    }
+    if (ch === ' ') return i;
+  }
+  return -1;
+}
+
+/**
+ * Escape spaces for display/value insertion (keeps paths unquoted, but makes them a single arg).
+ * @param {string} input
+ * @returns {string}
+ */
+export function escapeSpaces(input) {
+  if (!input) return input;
+  return String(input).replace(/ /g, '\\ ');
+}
+

package/commands/attach/ink-repl/utils/replSelection.js

@@ -0,0 +1,205 @@
+/**
+ * REPL output selection utilities
+ * Handles mouse selection within output items, excluding borders
+ */
+
+import { truncateOutputToLines, formatTruncationHint } from './truncate.js';
+
+/**
+ * Calculate the screen position and dimensions of each output item
+ * @param {Array} outputs - Array of output items
+ * @param {number} topPadding - Top padding of the layout
+ * @param {Object} options
+ * @param {number} [options.contentWidth] - Outer width of cards (defaults to stdout columns)
+ * @param {number} [options.maxLines] - Max visual lines shown in a card (defaults to 10)
+ * @returns {Array} Array of position info for each output
+ */
+export function calculateOutputPositions(outputs, topPadding = 2, options = {}) {
+  const { contentWidth: configuredWidth, maxLines = 50 } = options || {};
+  const positions = [];
+  let currentY = topPadding;
+
+  for (const output of outputs) {
+    const { id, command, output: text, isWelcome } = output;
+
+    if (isWelcome) {
+      // Welcome message: border + padding + single line + padding + border
+      // Total height: 3 (1 border top + 1 content + 1 border bottom)
+      const height = 3;
+      positions.push({
+        id,
+        startY: currentY,
+        endY: currentY + height - 1,
+        height,
+        type: 'welcome',
+        contentStartY: currentY + 1, // Skip top border
+        contentEndY: currentY + 1,   // Single line
+        lines: [text],
+      });
+      currentY += height + 1; // Add gap between outputs
+    } else {
+      // Regular output: border + command line (with paddingBottom) + output lines + border
+      // IMPORTANT: the rendered OutputItem wraps by width and truncates by *visual* lines.
+      // For selection/positioning we must mirror that behavior, otherwise mouse coordinates drift.
+      // We approximate content width by terminal width (ShellLayout is widthFraction=1 by default).
+      const terminalWidth = process.stdout?.columns || 80;
+      const contentWidth = Math.max(20, configuredWidth || terminalWidth);
+      const boxInnerWidth = Math.max(10, contentWidth - 4);
+
+      const hasText = typeof text === 'string' ? text.length > 0 : !!text;
+      const { lines: visualLines, truncated, hiddenLines } = hasText
+        ? truncateOutputToLines(String(text), boxInnerWidth, maxLines)
+        : { lines: [], truncated: false, hiddenLines: 0 };
+
+      const outputLines = visualLines.slice();
+      if (truncated && hiddenLines > 0) {
+        outputLines.push(formatTruncationHint(hiddenLines));
+      }
+      const lines = [];
+
+      if (command) {
+        lines.push(command); // Command line (we'll prepend prompt when extracting)
+      }
+      lines.push(...outputLines);
+
+      // Height calculation:
+      // - 1 top border
+      // - 1 command line (if exists, includes paddingBottom space)
+      // - outputLines.length output lines
+      // - 1 bottom border
+      const height = 2 + lines.length;
+
+      const contentStartY = currentY + 1; // Skip top border
+      const contentEndY = contentStartY + lines.length - 1;
+
+      positions.push({
+        id,
+        startY: currentY,
+        endY: currentY + height - 1,
+        height,
+        type: 'output',
+        contentStartY,
+        contentEndY,
+        lines,
+        command,
+      });
+
+      currentY += height + 1; // Add gap (rowGap: 1) between outputs
+    }
+  }
+
+  return positions;
+}
+
+/**
+ * Find which output item contains a given Y coordinate
+ * @param {number} y - Y coordinate (1-based)
+ * @param {Array} positions - Output positions from calculateOutputPositions
+ * @returns {Object|null} Position info or null if not found
+ */
+export function findOutputAtPosition(y, positions) {
+  if (!positions || !Array.isArray(positions)) {
+    return null;
+  }
+  for (const pos of positions) {
+    if (y >= pos.contentStartY && y <= pos.contentEndY) {
+      return pos;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if a coordinate is within the content area (excluding borders)
+ * @param {number} x - X coordinate (1-based)
+ * @param {number} y - Y coordinate (1-based)
+ * @param {number} contentWidth - Content area width
+ * @param {Array} positions - Output positions
+ * @returns {boolean} True if inside content area
+ */
+export function isInsideContentArea(x, y, contentWidth, positions) {
+  if (!positions || !Array.isArray(positions)) {
+    return false;
+  }
+
+  // X must be inside border (left border at 0, right border at contentWidth-1)
+  // With paddingLeft=1, valid X range is [2, contentWidth-2]
+  if (x < 2 || x >= contentWidth - 1) {
+    return false;
+  }
+
+  // Y must be in a content area
+  return findOutputAtPosition(y, positions) !== null;
+}
+
+/**
+ * Extract selected text from output items
+ * @param {number} startX - Start X (1-based, screen coordinate)
+ * @param {number} startY - Start Y (1-based, screen coordinate)
+ * @param {number} endX - End X (1-based, screen coordinate)
+ * @param {number} endY - End Y (1-based, screen coordinate)
+ * @param {Array} positions - Output positions
+ * @param {string} shellPrompt - Shell prompt for command lines
+ * @returns {string} Selected text
+ */
+export function extractSelectionFromOutputs(startX, startY, endX, endY, positions, shellPrompt) {
+  if (!positions || !Array.isArray(positions)) {
+    return '';
+  }
+
+  // Normalize selection (ensure start <= end)
+  if (startY > endY || (startY === endY && startX > endX)) {
+    [startX, endX] = [endX, startX];
+    [startY, endY] = [endY, startY];
+  }
+
+  // Find the output containing the selection
+  const outputPos = findOutputAtPosition(startY, positions);
+  if (!outputPos) {
+    return '';
+  }
+
+  // Only support single-output selection
+  if (endY < outputPos.contentStartY || endY > outputPos.contentEndY) {
+    return '';
+  }
+
+  // Calculate line indices within the output
+  const startLineIdx = startY - outputPos.contentStartY;
+  const endLineIdx = endY - outputPos.contentStartY;
+
+  // Adjust X coordinates to account for border (left border + paddingLeft = 2)
+  const adjustedStartX = Math.max(0, startX - 2);
+  const adjustedEndX = Math.max(0, endX - 2);
+
+  const selectedLines = [];
+
+  for (let lineIdx = startLineIdx; lineIdx <= endLineIdx; lineIdx++) {
+    if (lineIdx < 0 || lineIdx >= outputPos.lines.length) {
+      continue;
+    }
+
+    let line = outputPos.lines[lineIdx];
+
+    // Prepend prompt for command line
+    if (lineIdx === 0 && outputPos.command && outputPos.type === 'output') {
+      line = shellPrompt + line;
+    }
+
+    if (lineIdx === startLineIdx && lineIdx === endLineIdx) {
+      // Single line selection
+      selectedLines.push(line.substring(adjustedStartX, adjustedEndX));
+    } else if (lineIdx === startLineIdx) {
+      // First line
+      selectedLines.push(line.substring(adjustedStartX));
+    } else if (lineIdx === endLineIdx) {
+      // Last line
+      selectedLines.push(line.substring(0, adjustedEndX));
+    } else {
+      // Middle lines
+      selectedLines.push(line);
+    }
+  }
+
+  return selectedLines.join('\n').trimEnd();
+}

package/commands/attach/ink-repl/utils/responseFormatter.js

@@ -0,0 +1,127 @@
+/**
+ * 响应格式化工具
+ * 统一处理 API 响应格式化逻辑
+ */
+
+import { getExitCodeTips } from './exitCodeTips.js';
+
+/**
+ * 响应状态码常量
+ */
+export const RESPONSE_CODE = {
+  SUCCESS: '2xxx',      // 2000-2999
+  SERVER_ERROR: '5xxx', // 5000-5999
+  CMD_ERROR: '6xxx',    // 6000-6999
+};
+
+/**
+ * 判断命令执行是否成功 (基于 exit_code)
+ * @param {Object} result - API result 对象
+ * @returns {boolean}
+ */
+export function isCommandSuccess(result) {
+  return result?.exit_code === 0;
+}
+
+/**
+ * 判断响应码类型
+ * @param {number} code - result.code
+ * @returns {string} 'success' | 'server_error' | 'cmd_error' | 'unknown'
+ */
+export function getCodeType(code) {
+  if (code === undefined || code === null) return 'success';
+  if (code >= 2000 && code < 3000) return 'success';
+  if (code >= 5000 && code < 6000) return 'server_error';
+  if (code >= 6000 && code < 7000) return 'cmd_error';
+  return 'unknown';
+}
+
+/**
+ * 提取错误信息
+ * @param {Object} response - API 响应 (从 SDK client 捕获的异常)
+ * @returns {{ error: string|null, failureReason: string|null, code: number|null }}
+ */
+export function extractError(response) {
+  const data = response?.data || {};
+  const result = data.result || {};
+  
+  return {
+    error: data.error || null,
+    failureReason: result.failure_reason || null,
+    code: result.code ?? null,
+  };
+}
+
+/**
+ * 格式化命令执行输出
+ * @param {Object} result - execute/run_in_session result
+ * @param {Object} options
+ * @param {string} options.locale - 'zh' | 'en'
+ * @returns {{ output: string, metaInfo: string|null, tips: string|null, exitCode: number|null }}
+ */
+export function formatCommandOutput(result, options = {}) {
+  const { locale = 'zh' } = options;
+  const { exit_code, stdout, stderr, output } = result;
+  
+  // 兼容两种字段名: output 或 stdout/stderr
+  const combinedOutput = output || [stderr, stdout].filter(Boolean).join('\n');
+  
+  // 成功时：不显示 metaInfo 和 tips
+  if (exit_code === 0) {
+    return { output: combinedOutput, metaInfo: null, tips: null, exitCode: 0 };
+  }
+  
+  // 没有 exit_code 时（如超时/网络错误）：显示 tips (等同于 exit_code: -1)，但不显示 metaInfo
+  if (exit_code === undefined || exit_code === null) {
+    const tips = getExitCodeTips(-1, locale);
+    return { output: combinedOutput, metaInfo: null, tips, exitCode: null };
+  }
+  
+  // 失败时（有 exit_code 且不为 0）：显示 metaInfo 和 tips
+  const metaInfo = `[exit code: ${exit_code}]`;
+  const tips = getExitCodeTips(exit_code, locale);
+  
+  return { output: combinedOutput, metaInfo, tips, exitCode: exit_code };
+}
+
+/**
+ * 格式化上传结果
+ * @param {Object} result - uploadFile 返回结果
+ * @param {Object} options
+ * @returns {{ output: string, exitCode: number }}
+ */
+export function formatUploadResult(result, options = {}) {
+  const { localPath, remotePath } = options;
+  
+  if (result.success) {
+    return {
+      output: `✓ ${localPath} → ${remotePath}`,
+      exitCode: 0,
+    };
+  }
+  
+  return {
+    output: `✗ 上传失败\n\nerror: ${result.message}`,
+    exitCode: 1,
+  };
+}
+
+/**
+ * 格式化接口错误 (5xxx 服务端错误)
+ * @param {Object} errorInfo - extractError 返回的错误信息
+ * @param {string} operation - 操作名称 (用于提示)
+ * @param {string} locale
+ * @returns {string}
+ */
+export function formatServerError(errorInfo, operation, locale = 'zh') {
+  const tips = locale === 'en' 
+    ? '💡 Server error, please retry' 
+    : '💡 服务端异常，建议重试';
+  
+  let msg = `${operation} 失败\n\n`;
+  if (errorInfo.error) msg += `error: ${errorInfo.error}\n`;
+  if (errorInfo.failureReason) msg += `${errorInfo.failureReason}\n`;
+  msg += tips;
+  
+  return msg;
+}

package/commands/attach/ink-repl/utils/textWrap.js

@@ -0,0 +1,117 @@
+/**
+ * Text wrapping utilities for Ink terminal rendering.
+ *
+ * Important: this implements a lightweight width calculation that treats a range
+ * of CJK code points as width=2. It is not a full wcwidth implementation, but
+ * is consistent with the existing OutputItem behavior.
+ */
+
+/**
+ * Slice a string by display width.
+ * @param {string} str
+ * @param {number} maxWidth
+ * @returns {{ head: string, tail: string }}
+ */
+export function sliceByWidth(str, maxWidth) {
+  if (maxWidth <= 0) return { head: '', tail: str };
+  let width = 0;
+  let idx = 0;
+  const chars = Array.from(str);
+  for (; idx < chars.length; idx++) {
+    const char = chars[idx];
+    const code = char.codePointAt(0);
+    const w =
+      (code >= 0x1100 && code <= 0x115f) ||
+      (code >= 0x2e80 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe10 && code <= 0xfe1f) ||
+      (code >= 0xfe30 && code <= 0xfe6f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      (code >= 0x20000 && code <= 0x2fffd) ||
+      (code >= 0x30000 && code <= 0x3fffd)
+        ? 2
+        : 1;
+    if (width + w > maxWidth) break;
+    width += w;
+  }
+  return { head: chars.slice(0, idx).join(''), tail: chars.slice(idx).join('') };
+}
+
+/**
+ * Get a lightweight display width for a string (same width model as sliceByWidth).
+ * @param {string} str
+ * @returns {number}
+ */
+export function getDisplayWidth(str) {
+  if (!str) return 0;
+  let width = 0;
+  for (const char of Array.from(String(str))) {
+    const code = char.codePointAt(0);
+    width +=
+      (code >= 0x1100 && code <= 0x115f) ||
+      (code >= 0x2e80 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe10 && code <= 0xfe1f) ||
+      (code >= 0xfe30 && code <= 0xfe6f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      (code >= 0x20000 && code <= 0x2fffd) ||
+      (code >= 0x30000 && code <= 0x3fffd)
+        ? 2
+        : 1;
+  }
+  return width;
+}
+
+/**
+ * Pad a line with spaces up to the given display width.
+ * This is useful in Ink to avoid leaving "stale" characters on screen when a
+ * new line is shorter than the previous frame.
+ * @param {string} line
+ * @param {number} width
+ * @returns {string}
+ */
+export function padToWidth(line, width) {
+  if (width <= 0) return '';
+  const { head } = sliceByWidth(String(line ?? ''), width);
+  const current = getDisplayWidth(head);
+  if (current >= width) return head;
+  return head + ' '.repeat(width - current);
+}
+
+/**
+ * Wrap a string to lines by display width.
+ * @param {string} text
+ * @param {number} width
+ * @returns {string[]}
+ */
+export function wrapTextToLines(text, width) {
+  if (!text && text !== '') return [''];
+  if (width <= 0) return String(text).split('\n');
+
+  const out = [];
+  for (const rawLine of String(text).split('\n')) {
+    if (rawLine === '') {
+      out.push('');
+      continue;
+    }
+    let remaining = rawLine;
+    while (remaining.length > 0) {
+      const { head, tail } = sliceByWidth(remaining, width);
+      if (tail) {
+        const lastSpace = head.lastIndexOf(' ');
+        if (lastSpace > 0) {
+          out.push(head.slice(0, lastSpace));
+          remaining = head.slice(lastSpace + 1) + tail;
+          continue;
+        }
+      }
+      out.push(head);
+      remaining = tail;
+    }
+  }
+  return out.length === 0 ? [''] : out;
+}

package/commands/attach/ink-repl/utils/truncate.js

@@ -0,0 +1,115 @@
+import { keybindingManager } from '../shortcuts/index.js';
+import { wrapTextToLines } from './textWrap.js';
+
+export const DEFAULT_MAX_LINES = 50;
+
+/**
+ * Process carriage returns (\r) in output to simulate terminal behavior.
+ * - \r\n is treated as a regular newline
+ * - \r alone moves cursor to start of line, subsequent text overwrites
+ *
+ * @param {string} output - Raw output with possible \r characters
+ * @returns {string} Processed output with \r behavior applied
+ */
+export function processCarriageReturns(output) {
+  if (!output || !output.includes('\r')) {
+    return output;
+  }
+
+  // First normalize \r\n to \n
+  let normalized = output.replace(/\r\n/g, '\n');
+
+  // Process remaining \r characters
+  // Split by \n, then process each line for \r
+  const lines = normalized.split('\n');
+  const processedLines = lines.map(line => {
+    if (!line.includes('\r')) {
+      return line;
+    }
+
+    // Split by \r and keep only the last segment that "overwrites" previous content
+    // For more accurate simulation, we'd need to handle partial overwrites,
+    // but for progress bars, usually the last segment is what matters
+    const segments = line.split('\r');
+    // Filter out empty segments and take the last non-empty one
+    const nonEmptySegments = segments.filter(s => s.length > 0);
+    return nonEmptySegments.length > 0 ? nonEmptySegments[nonEmptySegments.length - 1] : '';
+  });
+
+  return processedLines.join('\n');
+}
+
+/**
+ * Truncate output to maximum number of lines
+ * @param {string} output - Output text
+ * @param {number} maxLines - Maximum lines to show
+ * @returns {{ text: string, truncated: boolean, totalLines: number, hiddenLines: number }}
+ */
+export function truncateOutput(output, maxLines = DEFAULT_MAX_LINES) {
+  const lines = output.split('\n');
+
+  if (lines.length <= maxLines) {
+    return {
+      text: output,
+      truncated: false,
+      totalLines: lines.length,
+      hiddenLines: 0,
+    };
+  }
+
+  const visibleLines = lines.slice(0, maxLines);
+  const hiddenLines = lines.length - maxLines;
+
+  return {
+    text: visibleLines.join('\n'),
+    truncated: true,
+    totalLines: lines.length,
+    hiddenLines,
+  };
+}
+
+/**
+ * Truncate output by *visual* line count after wrapping to terminal width.
+ *
+ * This avoids a common layout issue where a single very long logical line
+ * (e.g. JSON log line) expands to many wrapped rows and breaks the page layout
+ * even when logical newline count is small.
+ *
+ * @param {string} output
+ * @param {number} width Visual line width
+ * @param {number} maxLines Max visual lines to show
+ * @returns {{ lines: string[], truncated: boolean, totalLines: number, hiddenLines: number, text: string }}
+ */
+export function truncateOutputToLines(output, width, maxLines = DEFAULT_MAX_LINES) {
+  const allLines = wrapTextToLines(output ?? '', width);
+  if (allLines.length <= maxLines) {
+    return {
+      lines: allLines,
+      text: allLines.join('\n'),
+      truncated: false,
+      totalLines: allLines.length,
+      hiddenLines: 0,
+    };
+  }
+
+  const visibleLines = allLines.slice(0, maxLines);
+  const hiddenLines = allLines.length - maxLines;
+  return {
+    lines: visibleLines,
+    text: visibleLines.join('\n'),
+    truncated: true,
+    totalLines: allLines.length,
+    hiddenLines,
+  };
+}
+
+/**
+ * Format truncation hint text
+ * @param {number} hiddenLines - Number of hidden lines
+ * @returns {string} Hint text
+ */
+export function formatTruncationHint(hiddenLines) {
+  if (hiddenLines === 0) return '';
+  const keyLabel = keybindingManager.getActionKeyLabel('viewOutput');
+  return `... [${hiddenLines} more lines] press '${keyLabel}' to view`;
+}