rl-rockcli 0.0.9 → 0.0.11

package/commands/attach/basic-repl.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const readline = require('readline');
+
+/**
+ * 底层错误消息友好化（简化版）
+ * 用于 CommonJS 模块
+ */
+function friendlyErrorMessage(message) {
+  if (!message || typeof message !== 'string') {
+    return '未知错误';
+  }
+
+  // 常见底层错误映射
+  const errorMap = {
+    'First argument must be an Error object': '网络连接异常，请检查网络后重试',
+    'ECONNREFUSED': '无法连接到服务器',
+    'ETIMEDOUT': '请求超时，请重试',
+    'ENOTFOUND': '无法解析服务器地址',
+    'ECONNRESET': '网络连接已断开',
+    'socket hang up': '网络连接已断开',
+    'Network Error': '网络异常',
+  };
+
+  // 精确匹配
+  if (errorMap[message]) {
+    return errorMap[message];
+  }
+
+  // 部分匹配
+  for (const [key, friendly] of Object.entries(errorMap)) {
+    if (message.includes(key)) {
+      return friendly;
+    }
+  }
+
+  // 网络相关关键词
+  const networkKeywords = ['network', 'socket', 'connection', 'connect', '网络'];
+  const lowerMessage = message.toLowerCase();
+  if (networkKeywords.some(kw => lowerMessage.includes(kw))) {
+    return '网络连接异常，请检查网络后重试';
+  }
+
+  return message;
+}
+
+function normalizeLine(line) {
+  if (typeof line !== 'string') return '';
+  return line.replace(/\r?\n/g, '').trim();
+}
+
+function isExitCommand(line) {
+  return line === 'exit' || line === 'quit' || line === '/exit' || line === '/quit';
+}
+
+function isCloseCommand(line) {
+  return line === 'close' || line === '/close';
+}
+
+function isHelpCommand(line) {
+  return line === 'help' || line === '/help' || line === '?';
+}
+
+function printHelp() {
+  console.log('');
+  console.log('  Basic attach REPL');
+  console.log('  - Type any shell command to run it in the sandbox session');
+  console.log('  - Builtins: help, exit, close');
+  console.log('');
+}
+
+/**
+ * Start a minimal readline-based REPL.
+ *
+ * This mode intentionally avoids importing Ink/React so `attach` can still work
+ * on older Node runtimes.
+ */
+async function startBasicREPL(options) {
+  const {
+    initialPrompt = '$ ',
+    sessionManager,
+    historyManager,
+    onExit,
+  } = options || {};
+
+  if (!sessionManager) {
+    throw new Error('startBasicREPL requires sessionManager');
+  }
+
+  let closed = false;
+  let pending = Promise.resolve();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    historySize: 500,
+  });
+
+  // Restore input history if available (best-effort)
+  if (historyManager && typeof historyManager.getHistory === 'function') {
+    try {
+      const history = await historyManager.getHistory();
+      if (Array.isArray(history) && history.length > 0) {
+        // Node readline expects most-recent-first.
+        rl.history = history.slice().reverse();
+      }
+    } catch (e) {
+      // ignore history restore errors
+    }
+  }
+
+  const cleanup = async () => {
+    if (closed) return;
+    closed = true;
+    try {
+      rl.close();
+    } catch (e) {
+      // ignore
+    }
+    if (onExit) {
+      await onExit();
+    }
+  };
+
+  rl.on('SIGINT', () => {
+    // Keep behavior simple and predictable
+    process.stdout.write('\n');
+    cleanup().catch(() => {});
+  });
+
+  rl.on('close', () => {
+    closed = true;
+  });
+
+  rl.setPrompt(initialPrompt);
+  rl.prompt();
+
+  return new Promise((resolve) => {
+    rl.on('line', (rawLine) => {
+      const line = normalizeLine(rawLine);
+
+      pending = pending.then(async () => {
+        if (closed) return;
+
+        if (!line) {
+          rl.prompt();
+          return;
+        }
+
+        // Save command to history before processing
+        try {
+          if (historyManager && typeof historyManager.addCommand === 'function') {
+            await historyManager.addCommand(line);
+          }
+        } catch (e) {
+          // ignore history errors
+        }
+
+        if (isHelpCommand(line)) {
+          printHelp();
+          rl.prompt();
+          return;
+        }
+
+        if (isExitCommand(line) || isCloseCommand(line)) {
+          await cleanup();
+          resolve();
+          return;
+        }
+
+        try {
+          const result = await sessionManager.execute(line);
+          const exitCode = result?.exit_code ?? 0;
+          let output = result?.output || '';
+          
+          // Handle abnormal exit codes with helpful messages
+          if (exitCode === -1) {
+            const hint = output ? '' : 'Command terminated abnormally (exit code -1). This may indicate a timeout, signal termination, or internal error.';
+            output = output || hint;
+          } else if (exitCode === 137) {
+            output += output ? '\n' : '';
+            output += '[Process killed (exit code 137). Possibly OOM or manually terminated.]';
+          } else if (exitCode === 143) {
+            output += output ? '\n' : '';
+            output += '[Process terminated (exit code 143). Received SIGTERM.]';
+          }
+          
+          if (output && typeof output === 'string' && output.length > 0) {
+            process.stdout.write(output);
+            if (!output.endsWith('\n')) {
+              process.stdout.write('\n');
+            }
+          }
+        } catch (error) {
+          const message = error && error.message ? error.message : String(error);
+          process.stderr.write(`Error: ${friendlyErrorMessage(message)}\n`);
+        }
+
+        rl.prompt();
+      });
+    });
+
+    rl.on('close', () => {
+      pending.finally(() => resolve());
+    });
+  });
+}
+
+module.exports = {
+  startBasicREPL,
+};

package/commands/attach/cleanup-history.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../../utils/logger');
+
+class CleanupHistoryHandler {
+  constructor(historyManager, options = {}) {
+    this.historyManager = historyManager;
+    this.sandboxId = options.targetSandboxId || historyManager.sandboxId;
+    this.targetSandboxId = options.targetSandboxId || null;
+    this.terminal = options.terminal || null;
+    this.os = require('os');
+  }
+
+  async getSessionsToCleanup() {
+    const index = await this._getIndex();
+    const currentSessionId = index.current_session || this.historyManager.sessionId;
+
+    if (!currentSessionId) {
+      throw new Error('No current session found');
+    }
+
+    const currentExists = await this._sessionExists(currentSessionId);
+    if (!currentExists) {
+      throw new Error('Current session does not exist');
+    }
+
+    const sessions = index.sessions || [];
+    return sessions
+      .filter(session => session.id !== currentSessionId)
+      .map(session => session.id);
+  }
+
+  async _getIndex() {
+    const sandboxDir = this._getSandboxDir();
+    const indexFile = path.join(sandboxDir, 'index.json');
+
+    if (!fs.existsSync(indexFile)) {
+      return { current_session: null, sessions: [] };
+    }
+
+    try {
+      const content = fs.readFileSync(indexFile, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      logger.debug(`Failed to read index.json: ${error.message}`);
+      return { current_session: null, sessions: [] };
+    }
+  }
+
+  async _sessionExists(sessionId) {
+    const sessionDir = path.join(this._getSandboxDir(), sessionId);
+    return fs.existsSync(sessionDir);
+  }
+
+  _getSandboxDir() {
+    if (this.targetSandboxId) {
+      return path.join(this.os.homedir(), '.rock', 'history', this.targetSandboxId);
+    }
+    return this.historyManager._getSandboxDir();
+  }
+
+  async confirmCleanup(sessions) {
+    if (!sessions || sessions.length === 0) {
+      if (this.terminal) {
+        this.terminal.yellow('无需清理的历史 session\n');
+      }
+      return false;
+    }
+
+    if (this.terminal) {
+      this.terminal.yellow(`找到 ${sessions.length} 个历史 session 将被清理\n`);
+      this.terminal.green('确认清理? (y/N): ');
+    }
+
+    return new Promise((resolve) => {
+      if (!this.terminal) {
+        resolve(true);
+        return;
+      }
+
+      this.terminal.inputField({ cancelable: true }, (error, input) => {
+        if (error || !input) {
+          resolve(false);
+          return;
+        }
+        const trimmed = input.trim().toLowerCase();
+        resolve(trimmed === 'y' || trimmed === 'yes');
+      });
+    });
+  }
+
+  async deleteSessions(sessions) {
+    const result = { success: 0, failed: 0, failedSessions: [] };
+
+    if (!sessions || sessions.length === 0) {
+      return result;
+    }
+
+    const sandboxDir = this.historyManager._getSandboxDir();
+
+    for (const sessionId of sessions) {
+      const sessionDir = path.join(sandboxDir, sessionId);
+      try {
+        if (fs.existsSync(sessionDir)) {
+          fs.rmSync(sessionDir, { recursive: true, force: true });
+          result.success++;
+        }
+      } catch (error) {
+        logger.debug(`Failed to delete session ${sessionId}: ${error.message}`);
+        result.failed++;
+        result.failedSessions.push(sessionId);
+      }
+    }
+
+    return result;
+  }
+
+  async updateIndex(currentSessionId) {
+    const sandboxDir = this.historyManager._getSandboxDir();
+    const indexFile = path.join(sandboxDir, 'index.json');
+
+    await this.historyManager._withIndexLock(async () => {
+      let index = { sandbox_id: this.sandboxId, current_session: currentSessionId, sessions: [] };
+
+      if (fs.existsSync(indexFile)) {
+        try {
+          const content = fs.readFileSync(indexFile, 'utf8');
+          index = JSON.parse(content);
+        } catch (error) {
+          logger.debug(`Failed to read index.json: ${error.message}`);
+        }
+      }
+
+      index.current_session = currentSessionId;
+      index.sessions = index.sessions.filter(session =>
+        session.id === currentSessionId || session.session_id === currentSessionId
+      );
+
+      fs.writeFileSync(indexFile, JSON.stringify(index, null, 2));
+    });
+  }
+
+  async execute() {
+    const sessions = await this.getSessionsToCleanup();
+
+    if (sessions.length === 0) {
+      if (this.terminal) {
+        this.terminal.yellow('无需清理的历史 session\n');
+      }
+      return;
+    }
+
+    const confirmed = await this.confirmCleanup(sessions);
+    if (!confirmed) {
+      return;
+    }
+
+    const result = await this.deleteSessions(sessions);
+
+    if (result.failed > 0) {
+      if (this.terminal) {
+        this.terminal.yellow(`清理完成：成功 ${result.success} 个，失败 ${result.failed} 个\n`);
+        if (result.failedSessions.length > 0) {
+          this.terminal.yellow(`失败的 session: ${result.failedSessions.join(', ')}\n`);
+        }
+      }
+      logger.warn(`Cleanup completed with failures: ${result.success} succeeded, ${result.failed} failed`);
+    } else {
+      if (this.terminal) {
+        this.terminal.green(`清理完成：成功 ${result.success} 个 session\n`);
+      }
+    }
+
+    // Only update index if cleaning current sandbox
+    if (!this.targetSandboxId) {
+      await this.updateIndex(this.historyManager.sessionId);
+    } else {
+      // For other sandboxes, update index to empty or keep only current
+      const index = await this._getIndex();
+      if (index.current_session) {
+        await this.updateIndex(index.current_session);
+      }
+    }
+  }
+}
+
+module.exports = CleanupHistoryHandler;

package/commands/attach/cleanup-manager.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const logger = require('../../utils/logger');
+
+let syncCleanups = [];
+let asyncCleanups = [];
+
+let installed = false;
+let installedSignalHandlers = [];
+
+let cleanupStarted = false;
+let cleanupPromise = null;
+
+function registerSyncCleanup(fn) {
+  if (typeof fn !== 'function') {
+    throw new Error('registerSyncCleanup(fn) requires a function');
+  }
+  syncCleanups.push(fn);
+}
+
+function registerCleanup(fn) {
+  if (typeof fn !== 'function') {
+    throw new Error('registerCleanup(fn) requires a function');
+  }
+  asyncCleanups.push(fn);
+}
+
+async function drainStdin({ durationMs = 30 } = {}) {
+  const stdin = process.stdin;
+  if (!stdin || !stdin.isTTY) return;
+
+  try {
+    if (typeof stdin.setEncoding === 'function') {
+      stdin.setEncoding('utf8');
+    }
+  } catch {
+    // ignore
+  }
+
+  // Best-effort drain: resume stdin and briefly swallow any buffered/pasted input.
+  await new Promise((resolve) => {
+    let resolved = false;
+    const finish = () => {
+      if (resolved) return;
+      resolved = true;
+      if (typeof stdin.off === 'function') {
+        stdin.off('data', onData);
+      } else if (typeof stdin.removeListener === 'function') {
+        stdin.removeListener('data', onData);
+      }
+      resolve();
+    };
+
+    const onData = () => {};
+
+    try {
+      if (typeof stdin.on === 'function') {
+        stdin.on('data', onData);
+      }
+      if (typeof stdin.resume === 'function') {
+        stdin.resume();
+      }
+    } catch {
+      return finish();
+    }
+
+    setTimeout(finish, durationMs);
+  });
+}
+
+async function runExitCleanup({ reason = 'unknown', exitCode } = {}) {
+  if (cleanupStarted) {
+    return cleanupPromise;
+  }
+  cleanupStarted = true;
+
+  cleanupPromise = (async () => {
+    try {
+      await drainStdin();
+    } catch (e) {
+      logger.debug(`attach cleanup: drain stdin failed (${reason}): ${e && e.message ? e.message : String(e)}`);
+    }
+
+    for (const fn of syncCleanups) {
+      try {
+        fn();
+      } catch (e) {
+        logger.debug(`attach cleanup: sync cleanup failed (${reason}): ${e && e.message ? e.message : String(e)}`);
+      }
+    }
+
+    for (const fn of asyncCleanups) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await fn();
+      } catch (e) {
+        logger.debug(`attach cleanup: async cleanup failed (${reason}): ${e && e.message ? e.message : String(e)}`);
+      }
+    }
+
+    if (typeof exitCode === 'number') {
+      process.exitCode = exitCode;
+    }
+  })();
+
+  return cleanupPromise;
+}
+
+function installSignalHandlers() {
+  if (installed) return;
+  installed = true;
+
+  const register = (event, handler, opts = {}) => {
+    const { once = false } = opts;
+    if (once && typeof process.once === 'function') {
+      process.once(event, handler);
+    } else if (typeof process.on === 'function') {
+      process.on(event, handler);
+    }
+    installedSignalHandlers.push({ event, handler });
+  };
+
+  register('SIGINT', () => void runExitCleanup({ reason: 'SIGINT', exitCode: 0 }), { once: true });
+  register('SIGTERM', () => void runExitCleanup({ reason: 'SIGTERM', exitCode: 143 }), { once: true });
+
+  // Best-effort: 'exit' does not wait for async work, but running sync cleanups helps restore TTY.
+  register('exit', () => {
+    for (const fn of syncCleanups) {
+      try {
+        fn();
+      } catch {
+        // ignore
+      }
+    }
+  });
+}
+
+async function resetForTesting() {
+  for (const { event, handler } of installedSignalHandlers) {
+    if (typeof process.off === 'function') {
+      process.off(event, handler);
+    } else if (typeof process.removeListener === 'function') {
+      process.removeListener(event, handler);
+    }
+  }
+
+  syncCleanups = [];
+  asyncCleanups = [];
+  installed = false;
+  installedSignalHandlers = [];
+  cleanupStarted = false;
+  cleanupPromise = null;
+}
+
+module.exports = {
+  registerSyncCleanup,
+  registerCleanup,
+  drainStdin,
+  runExitCleanup,
+  installSignalHandlers,
+  resetForTesting,
+};
+