rl-rockcli 0.0.8 → 0.0.10

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

@@ -0,0 +1,120 @@
+/**
+ * Output selection utilities
+ * Handles text extraction from output items, filtering out borders and padding
+ */
+
+/**
+ * Build a line map for outputs, tracking which lines belong to which output
+ * and filtering out border characters
+ * @param {Array} outputs - Array of output items
+ * @param {string} shellPrompt - Current shell prompt
+ * @returns {Object} { lines: string[], lineMap: Array<{outputId, lineType, originalLine}> }
+ */
+export function buildOutputLineMap(outputs, shellPrompt) {
+  const lines = [];
+  const lineMap = [];
+
+  for (const output of outputs) {
+    const { id, command, output: text, exitCode, isWelcome } = output;
+
+    if (isWelcome) {
+      // Welcome message - single line, no border filtering needed
+      lines.push(text);
+      lineMap.push({ outputId: id, lineType: 'content', originalLine: text });
+      continue;
+    }
+
+    // Command line: prompt + command
+    const commandLine = `${shellPrompt}${command}`;
+    lines.push(commandLine);
+    lineMap.push({ outputId: id, lineType: 'command', originalLine: commandLine });
+
+    // Output text - split by newlines
+    if (text) {
+      const outputLines = text.split('\n');
+      for (const line of outputLines) {
+        lines.push(line);
+        lineMap.push({ outputId: id, lineType: 'output', originalLine: line });
+      }
+    }
+  }
+
+  return { lines, lineMap };
+}
+
+/**
+ * Filter border characters from selected text
+ * Removes box drawing characters commonly used for borders
+ * @param {string} text - Selected text
+ * @returns {string} Filtered text
+ */
+export function filterBorderCharacters(text) {
+  // Box drawing characters used by Ink borders
+  const borderChars = /[─│┌┐└┘├┤┬┴┼╭╮╰╯═║╔╗╚╝╠╣╦╩╬]/g;
+
+  return text
+    .split('\n')
+    .map(line => {
+      // Remove border characters
+      let cleaned = line.replace(borderChars, '');
+      // Trim excessive whitespace but preserve meaningful indentation
+      return cleaned.trimEnd();
+    })
+    .filter(line => line.length > 0) // Remove empty lines that were just borders
+    .join('\n');
+}
+
+/**
+ * Extract text from a screen region, considering the rendered layout
+ * This function is aware of the OutputItem layout with borders
+ * @param {number} startX - Start X coordinate (1-based)
+ * @param {number} startY - Start Y coordinate (1-based)
+ * @param {number} endX - End X coordinate (1-based)
+ * @param {number} endY - End Y coordinate (1-based)
+ * @param {Array} outputs - Array of output items
+ * @param {string} shellPrompt - Current shell prompt
+ * @returns {string} Selected text with borders filtered
+ */
+export function extractOutputText(startX, startY, endX, endY, outputs, shellPrompt) {
+  const { lines } = buildOutputLineMap(outputs, shellPrompt);
+
+  if (!lines || lines.length === 0) return '';
+
+  // Normalize coordinates (ensure start <= end)
+  if (startY > endY || (startY === endY && startX > endX)) {
+    [startX, endX] = [endX, startX];
+    [startY, endY] = [endY, startY];
+  }
+
+  // Convert 1-based to 0-based
+  const startRow = Math.max(0, startY - 1);
+  const endRow = Math.min(lines.length - 1, endY - 1);
+  const startCol = Math.max(0, startX - 1);
+  const endCol = Math.max(0, endX - 1);
+
+  if (startRow > endRow) return '';
+  if (startRow === endRow && startCol > endCol) return '';
+
+  const selectedLines = [];
+
+  for (let row = startRow; row <= endRow; row++) {
+    const line = lines[row] || '';
+
+    if (row === startRow && row === endRow) {
+      // Single line selection
+      selectedLines.push(line.substring(startCol, endCol));
+    } else if (row === startRow) {
+      // First line of multi-line selection
+      selectedLines.push(line.substring(startCol));
+    } else if (row === endRow) {
+      // Last line of multi-line selection
+      selectedLines.push(line.substring(0, endCol));
+    } else {
+      // Middle lines - select entire line
+      selectedLines.push(line);
+    }
+  }
+
+  const rawText = selectedLines.join('\n');
+  return filterBorderCharacters(rawText);
+}

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

@@ -0,0 +1,77 @@
+import { truncateOutputToLines } from './truncate.js';
+
+/**
+ * Estimate the rendered height (rows) of an OutputItem card in the OutputArea.
+ *
+ * This mirrors the structure in `components/OutputItem.js`:
+ * - Welcome item: 1 row (best-effort; welcome is rare after first render)
+ * - Normal item: top border + command line + (N output lines) + (optional hint) + bottom border
+ *
+ * Note: OutputArea applies `rowGap: 1` between items, which is handled by the caller.
+ *
+ * @param {Object} item
+ * @param {number} contentWidth Outer card width
+ * @param {number} maxLines Max visual output lines to show
+ * @returns {number}
+ */
+export function estimateOutputItemHeight(item, contentWidth, maxLines = 50) {
+  if (!item) return 0;
+  if (item.isWelcome) {
+    return 1;
+  }
+
+  const boxInnerWidth = Math.max(10, contentWidth - 4);
+  const hasOutput = typeof item.output === 'string' ? item.output.length > 0 : !!item.output;
+  const { lines, truncated, hiddenLines } = hasOutput
+    ? truncateOutputToLines(String(item.output), boxInnerWidth, maxLines)
+    : { lines: [], truncated: false, hiddenLines: 0 };
+
+  const outputLineCount = lines.length;
+  const hintLineCount = truncated && hiddenLines > 0 ? 1 : 0;
+
+  // borders(2) + command line(1) + output lines + hint line (optional)
+  return 3 + outputLineCount + hintLineCount;
+}
+
+/**
+ * Pick the tail of outputs that best fits within a target height.
+ * Always returns at least 1 item if outputs is non-empty.
+ *
+ * @param {Array<Object>} outputs
+ * @param {Object} options
+ * @param {number} options.contentWidth Outer card width
+ * @param {number} options.maxLines Max visual output lines to show per card
+ * @param {number} options.maxHeight Max rows available for cards (excluding fixed UI)
+ * @param {number} [options.rowGap=1] Gap rows between cards
+ * @returns {Array<Object>}
+ */
+export function pickVisibleOutputsByHeight(
+  outputs,
+  { contentWidth, maxLines, maxHeight, rowGap = 1 } = {},
+) {
+  const list = Array.isArray(outputs) ? outputs : [];
+  if (list.length === 0) return [];
+
+  const heightLimit = Math.max(1, Number(maxHeight || 1));
+  let used = 0;
+  let start = list.length;
+
+  for (let i = list.length - 1; i >= 0; i--) {
+    const itemHeight = estimateOutputItemHeight(list[i], contentWidth, maxLines);
+    const needed = used === 0 ? itemHeight : itemHeight + rowGap;
+
+    // Always include at least one (the most recent) item.
+    if (used > 0 && used + needed > heightLimit) {
+      break;
+    }
+
+    used += needed;
+    start = i;
+
+    if (used >= heightLimit) {
+      break;
+    }
+  }
+
+  return list.slice(start);
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Utilities for paginated file loading
+ */
+
+/**
+ * Extract file path from cat command
+ * @param {string} command - Shell command
+ * @returns {string|null} - File path or null
+ */
+export function extractCatFilePath(command) {
+  const trimmed = command.trim();
+  const match = trimmed.match(/^cat\s+(.+)$/);
+  return match ? match[1].trim() : null;
+}
+
+/**
+ * Check if command should enable pagination
+ * @param {string} command - Shell command
+ * @returns {boolean}
+ */
+export function shouldEnablePagination(command) {
+  const trimmed = command.trim();
+  // Must be pure cat command (no pipes, no -n option)
+  return /^cat\s+[^\|]+$/.test(trimmed) && !/-n\s+/.test(trimmed);
+}
+
+/**
+ * Calculate line range for previous page (prepend)
+ * @param {number} currentStartLine
+ * @param {number} pageSize
+ * @returns {{newStartLine: number, newEndLine: number}}
+ */
+export function calculatePreviousPageRange(currentStartLine, pageSize) {
+  const newStartLine = Math.max(1, currentStartLine - pageSize);
+  const newEndLine = currentStartLine - 1;
+  return { newStartLine, newEndLine };
+}
+
+/**
+ * Calculate line range for next page (append)
+ * @param {number} currentEndLine
+ * @param {number} totalLines
+ * @param {number} pageSize
+ * @returns {{newStartLine: number, newEndLine: number}}
+ */
+export function calculateNextPageRange(currentEndLine, totalLines, pageSize) {
+  const newStartLine = currentEndLine + 1;
+  const newEndLine = Math.min(totalLines, currentEndLine + pageSize);
+  return { newStartLine, newEndLine };
+}
+
+/**
+ * Check if should trigger previous page load (near top)
+ * @param {number} scrollOffset - Current scroll position
+ * @param {number} threshold - Lines from top to trigger
+ * @param {number} loadedStartLine - Currently loaded start line
+ * @returns {boolean}
+ */
+export function shouldLoadPreviousPage(scrollOffset, threshold, loadedStartLine) {
+  return scrollOffset < threshold && loadedStartLine > 1;
+}
+
+/**
+ * Check if should trigger next page load (near bottom)
+ * @param {number} scrollOffset - Current scroll position
+ * @param {number} totalVisibleLines - Total lines in content
+ * @param {number} viewportHeight - Visible height in lines
+ * @param {number} threshold - Lines from bottom to trigger
+ * @param {number} loadedEndLine - Currently loaded end line
+ * @param {number} totalLines - Total lines in file
+ * @returns {boolean}
+ */
+export function shouldLoadNextPage(scrollOffset, totalVisibleLines, viewportHeight, threshold, loadedEndLine, totalLines) {
+  const distanceFromBottom = totalVisibleLines - scrollOffset - viewportHeight;
+  return distanceFromBottom < threshold && loadedEndLine < totalLines;
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Parameter hint calculation for inline placeholder display
+ * 
+ * Shows placeholder text (e.g., "@<local> @<remote>") when user is typing
+ * /upload or /download commands to help them remember the parameter format.
+ */
+
+import { COMMAND_PARAM_TEMPLATES } from '../builtinCommands.js';
+
+/**
+ * Calculate placeholder text to display
+ * 
+ * Key logic:
+ * 1. Cursor must be at end of buffer (FR-006)
+ * 2. Command must be /upload or /download with space after
+ * 3. Show remaining @ parameters based on how many have been started
+ * 
+ * @param {string} buffer - Full input buffer
+ * @param {number} cursorPosition - Current cursor position
+ * @returns {string|null} Placeholder text or null if not applicable
+ */
+export function getPlaceholderText(buffer, cursorPosition) {
+  // FR-006: Cursor must be at end of buffer
+  if (cursorPosition !== buffer.length) {
+    return null;
+  }
+  
+  // Parse command - must have space after command name
+  const match = buffer.match(/^\/(upload|download)\s+/);
+  if (!match) {
+    // No space after command = don't show placeholder (might be typing other command)
+    return null;
+  }
+  
+  const command = match[1];
+  const template = COMMAND_PARAM_TEMPLATES[command];
+  if (!template) {
+    return null;
+  }
+  
+  // Get input after command (including the space)
+  const afterCommand = buffer.slice(match[0].length);
+  
+  // Count @ symbols that have been started
+  let startedParams = 0;
+  for (let i = 0; i < afterCommand.length; i++) {
+    if (afterCommand[i] === '@') {
+      startedParams++;
+    }
+  }
+  
+  // If all params started, no placeholder needed
+  if (startedParams >= template.params.length) {
+    return null;
+  }
+  
+  // Show remaining params
+  const remainingParams = template.params.slice(startedParams);
+  return remainingParams.map(p => `${p.prefix}${p.placeholder}`).join(' ');
+}

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

@@ -0,0 +1,174 @@
+/**
+ * 底层错误消息友好化映射表
+ * 将底层技术错误转换为用户友好的提示信息
+ */
+const ERROR_FRIENDLY_MAP = {
+  // Bun/运行时兼容性问题
+  'First argument must be an Error object': '网络连接异常，请检查网络后重试',
+
+  // Node 网络错误
+  'ECONNREFUSED': '无法连接到服务器',
+  'ETIMEDOUT': '请求超时，请重试',
+  'ENOTFOUND': '无法解析服务器地址',
+  'ECONNRESET': '网络连接已断开',
+  'EPIPE': '连接已关闭',
+  'EHOSTUNREACH': '无法访问服务器',
+  'ENETUNREACH': '网络不可达',
+
+  // HTTP 错误
+  'socket hang up': '网络连接已断开',
+  'network error': '网络异常',
+  'Network Error': '网络异常',
+  'request aborted': '请求被中断',
+  'canceled': '请求已取消',
+
+  // SSL/TLS 错误
+  'UNABLE_TO_VERIFY_LEAF_SIGNATURE': 'SSL证书验证失败',
+  'CERT_HAS_EXPIRED': 'SSL证书已过期',
+  'DEPTH_ZERO_SELF_SIGNED_CERT': 'SSL证书不受信任',
+};
+
+/**
+ * 错误消息友好化转换
+ * 将底层技术错误转换为用户友好的提示
+ *
+ * @param {string} message - 原始错误消息
+ * @returns {string} 友好化后的错误消息
+ */
+export function friendlyErrorMessage(message) {
+  if (!message || typeof message !== 'string') {
+    return '未知错误';
+  }
+
+  // 1. 精确匹配
+  if (ERROR_FRIENDLY_MAP[message]) {
+    return ERROR_FRIENDLY_MAP[message];
+  }
+
+  // 2. 部分匹配（处理包含错误码的消息）
+  for (const [key, friendly] of Object.entries(ERROR_FRIENDLY_MAP)) {
+    if (message.includes(key)) {
+      return friendly;
+    }
+  }
+
+  // 3. HTTP 状态码错误处理
+  const statusMatch = message.match(/status code (\d+)/i);
+  if (statusMatch) {
+    const code = parseInt(statusMatch[1], 10);
+    if (code >= 500) {
+      return '服务暂时不可用，请稍后重试';
+    }
+    if (code === 401 || code === 403) {
+      return '认证失败，请检查登录状态';
+    }
+    if (code === 404) {
+      return '请求的资源不存在';
+    }
+    if (code === 429) {
+      return '请求过于频繁，请稍后重试';
+    }
+    return `请求失败 (${code})`;
+  }
+
+  // 4. JSON 解析错误
+  if (message.includes('Unexpected token') || message.includes('JSON')) {
+    return '服务器响应格式异常';
+  }
+
+  // 5. 超时相关
+  if (message.toLowerCase().includes('timeout') || message.includes('超时')) {
+    return '请求超时，请重试';
+  }
+
+  // 6. 网络相关关键词
+  const networkKeywords = ['network', 'socket', 'connection', 'connect', '网络'];
+  const lowerMessage = message.toLowerCase();
+  if (networkKeywords.some(kw => lowerMessage.includes(kw))) {
+    return '网络连接异常，请检查网络后重试';
+  }
+
+  // 7. 返回原始消息（如果已经是用户友好的）
+  return message;
+}
+
+/**
+ * Parse execution error to extract meaningful output
+ *
+ * Handles errors like:
+ * Error: Failed to run in session: {"status":"Failed","error":"Command 'aaa' failed with exit code 127. Here is the output:\n'bash: aaa: command not found'","result":null}
+ *
+ * Exit codes:
+ * - 0: Success
+ * - 1-255: Command exit codes
+ * - -1: Timeout/Network/Session errors (returned by SDK, not parsed from error message)
+ *
+ * @param {Error} error - The error object
+ * @returns {{ output: string, exitCode: number }}
+ */
+export function parseExecutionError(error) {
+  const message = error?.message || '';
+
+  if (!message) {
+    return { output: 'Unknown error', exitCode: 1 };
+  }
+
+  // Try to extract JSON from the error message first
+  const jsonMatch = message.match(/\{[\s\S]*\}/);
+
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+
+      if (parsed.error) {
+        // Extract exit code from error message
+        const exitCodeMatch = parsed.error.match(/exit code (\d+)/);
+        const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
+
+        // Extract the actual shell output from the error
+        // Pattern 1: "Here is the output:\n'actual message'"
+        let outputMatch = parsed.error.match(/Here is the output:\s*\n'(.+?)'/s);
+        
+        if (outputMatch) {
+          // Extract just the command output, remove extra formatting
+          let output = outputMatch[1];
+          
+          // If output contains "---- Stderr ----" sections, simplify it
+          const stderrMatch = output.match(/---- Stderr ----\s*([\s\S]*?)(?:---- Stdout ----)?/);
+          if (stderrMatch && stderrMatch[1].trim()) {
+            // Only show stderr content for syntax errors
+            output = stderrMatch[1].trim();
+          }
+          
+          return {
+            output,
+            exitCode,
+          };
+        }
+
+        // Pattern 2: Extract just the bash error message
+        const bashErrorMatch = parsed.error.match(/bash: .+/);
+        if (bashErrorMatch) {
+          return {
+            output: bashErrorMatch[0],
+            exitCode,
+          };
+        }
+
+        // Fallback: use the error field directly
+        return {
+          output: parsed.error,
+          exitCode,
+        };
+      }
+    } catch (e) {
+      // JSON parsing failed, fall through to default handling
+    }
+  }
+
+  // 对底层错误消息进行友好化转换
+  return {
+    output: friendlyErrorMessage(message),
+    exitCode: 1,
+  };
+}

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

@@ -0,0 +1,167 @@
+/**
+ * Path Completion Utilities
+ * Provides path auto-completion for shell commands in the REPL
+ */
+
+import { hasDangerousShellChars, shellEscapePosix } from './remotePathSafety.js';
+
+/**
+ * Commands that typically take path arguments
+ */
+export const PATH_COMMANDS = [
+  'cd', 'cat', 'ls', 'less', 'more', 'head', 'tail',
+  'vi', 'vim', 'nano', 'emacs',
+  'rm', 'cp', 'mv', 'mkdir', 'rmdir', 'touch',
+  'chmod', 'chown', 'chgrp',
+  'source', '.',
+  'python', 'python3', 'node', 'bash', 'sh',
+  'file', 'stat', 'du', 'find',
+];
+
+/**
+ * Check if a command typically takes path arguments
+ * @param {string} cmd - Command name
+ * @returns {boolean}
+ */
+export function isPathCommand(cmd) {
+  if (!cmd) return false;
+  return PATH_COMMANDS.includes(cmd);
+}
+
+/**
+ * Parse input to extract path completion context
+ * @param {string} input - Current input buffer
+ * @returns {Object} Parsed path info
+ */
+export function parsePathInput(input) {
+  if (!input || !input.trim()) {
+    return { needsCompletion: false };
+  }
+
+  // Check if input ends with whitespace (user wants to complete from current dir)
+  const endsWithSpace = /\s$/.test(input);
+  const parts = input.split(/\s+/).filter(Boolean);
+  const command = parts[0];
+
+  // Skip path completion for built-in commands (starting with /)
+  // These commands use @ for path completion instead
+  if (command && command.startsWith('/')) {
+    return { needsCompletion: false };
+  }
+
+  // Handle trailing space case: "cd " should trigger current directory completion
+  if (endsWithSpace && isPathCommand(command)) {
+    return {
+      command,
+      prefix: input,
+      dirPath: './',
+      filePrefix: '',
+      needsCompletion: true,
+    };
+  }
+
+  const lastPart = parts[parts.length - 1] || '';
+
+  // No argument to complete
+  if (parts.length < 2 || !lastPart) {
+    return { needsCompletion: false };
+  }
+
+  // Check if completion is needed
+  const looksLikePath = lastPart.includes('/') || lastPart.startsWith('.') || lastPart.startsWith('~');
+  const isPathCmd = isPathCommand(command);
+
+  if (!looksLikePath && !isPathCmd) {
+    return { needsCompletion: false };
+  }
+
+  // Parse the path
+  let dirPath, filePrefix;
+
+  if (lastPart.endsWith('/')) {
+    dirPath = lastPart;
+    filePrefix = '';
+  } else if (lastPart.includes('/')) {
+    const lastSlash = lastPart.lastIndexOf('/');
+    dirPath = lastPart.substring(0, lastSlash + 1);
+    filePrefix = lastPart.substring(lastSlash + 1);
+  } else {
+    // No slash - complete in current directory
+    dirPath = './';
+    filePrefix = lastPart;
+  }
+
+  // Build prefix (everything before the path argument)
+  const prefix = parts.slice(0, -1).join(' ') + ' ';
+
+  return {
+    command,
+    prefix,
+    dirPath,
+    filePrefix,
+    needsCompletion: true,
+  };
+}
+
+/**
+ * Build completion menu items from file list
+ * @param {Object} parsed - Parsed path info from parsePathInput
+ * @param {string[]} files - List of files in directory
+ * @returns {Array<{label: string, value: string, description: string}>}
+ */
+export function buildCompletions(parsed, files) {
+  const { prefix, dirPath, filePrefix } = parsed;
+
+  // Filter files by prefix
+  const matches = files.filter(f => f.startsWith(filePrefix));
+
+  // Build completion items
+  // For current directory (./) don't include the ./ in the result
+  const pathPrefix = dirPath === './' ? '' : dirPath;
+
+  return matches.map(f => ({
+    label: f,
+    value: `${prefix}${pathPrefix}${f}`,
+    description: '',
+  }));
+}
+
+/**
+ * Get path completions from sandbox (async)
+ * @param {Object} sessionManager - Session manager for sandbox communication
+ * @param {string} input - Current input buffer
+ * @returns {Promise<Array>} Completion items
+ */
+export async function getPathCompletions(sessionManager, input) {
+  if (hasDangerousShellChars(input)) {
+    return [];
+  }
+
+  const parsed = parsePathInput(input);
+
+  if (!parsed.needsCompletion) {
+    return [];
+  }
+
+  try {
+    const combined = `${parsed.dirPath || ''}${parsed.filePrefix || ''}`;
+    if (hasDangerousShellChars(combined)) {
+      return [];
+    }
+
+    // Query sandbox for directory contents
+    const result = await sessionManager.execute(`ls -1Ap -- ${shellEscapePosix(parsed.dirPath)} 2>/dev/null`);
+
+    if (!result.output) {
+      return [];
+    }
+
+    // Parse file list
+    const files = result.output.split(/[\r\n]+/).filter(f => f.trim()).slice(0, 200);
+
+    return buildCompletions(parsed, files);
+  } catch (e) {
+    // Silently fail - don't interrupt user input
+    return [];
+  }
+}