rl-rockcli 0.0.8 → 0.0.10

package/commands/attach/history-manager.js

@@ -0,0 +1,507 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const logger = require('../../utils/logger');
+
+function safeJsonParse(content, fallback) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return fallback;
+  }
+}
+
+function writeFileAtomicSync(filePath, data) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmpPath, data);
+  fs.renameSync(tmpPath, filePath);
+}
+
+function writeJsonAtomicSync(filePath, obj) {
+  writeFileAtomicSync(filePath, JSON.stringify(obj, null, 2));
+}
+
+class HistoryManager {
+  constructor(sandboxId, options = {}) {
+    this.sandboxId = sandboxId;
+    this.baseDir = options.baseDir || path.join(os.homedir(), '.rock');
+    this.sessionId = null;
+    this.maxHistoryPerSession = options.maxHistoryPerSession || 200;
+    this._onNotice = typeof options.onNotice === 'function' ? options.onNotice : null;
+    this._noticeShown = new Set();
+  }
+
+  _noticeOnce(key, message) {
+    if (!this._onNotice) return;
+    if (this._noticeShown.has(key)) return;
+    this._noticeShown.add(key);
+    try {
+      this._onNotice(message);
+    } catch {
+      // ignore
+    }
+  }
+
+  async _withIndexLock(fn) {
+    const lockPath = path.join(this._getSandboxDir(), 'index.json.lock');
+    const staleMs = 10_000;
+    const maxWaitMs = 2_000;
+    const start = Date.now();
+
+    while (true) {
+      try {
+        fs.mkdirSync(this._getSandboxDir(), { recursive: true });
+        const fd = fs.openSync(lockPath, 'wx');
+        try {
+          fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+        } finally {
+          fs.closeSync(fd);
+        }
+        break;
+      } catch (e) {
+        if (!e || e.code !== 'EEXIST') throw e;
+
+        // Stale lock recovery
+        try {
+          const stat = fs.statSync(lockPath);
+          if (Date.now() - stat.mtimeMs > staleMs) {
+            fs.rmSync(lockPath, { force: true });
+            continue;
+          }
+        } catch {
+          // ignore
+        }
+
+        if (Date.now() - start > maxWaitMs) {
+          throw new Error('History index is locked; please retry.');
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise(r => setTimeout(r, 25));
+      }
+    }
+
+    try {
+      return await fn();
+    } finally {
+      try {
+        fs.rmSync(lockPath, { force: true });
+      } catch {
+        // ignore
+      }
+    }
+  }
+
+  /**
+   * Switch to an existing history session (does not create a new one).
+   * Updates index.json current_session and the current symlink when possible.
+   * @param {string} sessionId
+   * @returns {Promise<string>} sessionId
+   */
+  async resume(sessionId) {
+    if (!sessionId) {
+      throw new Error('sessionId required');
+    }
+
+    const sessionDir = path.join(this._getSandboxDir(), sessionId);
+    if (!fs.existsSync(sessionDir)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    this.sessionId = sessionId;
+
+    // Ensure index exists and points to this session as current
+    const sandboxDir = this._getSandboxDir();
+    const indexFile = path.join(sandboxDir, 'index.json');
+
+    await this._withIndexLock(async () => {
+      let index = { sandbox_id: this.sandboxId, sessions: [] };
+      if (fs.existsSync(indexFile)) {
+        index = safeJsonParse(fs.readFileSync(indexFile, 'utf8'), index);
+      }
+
+      index.sandbox_id = index.sandbox_id || this.sandboxId;
+      index.sessions = Array.isArray(index.sessions) ? index.sessions : [];
+      index.current_session = sessionId;
+
+      // Add to index if missing
+      const existsInIndex = index.sessions.some(s => s.id === sessionId || s.session_id === sessionId);
+      if (!existsInIndex) {
+        let createdAt = new Date().toISOString();
+        const metaFile = path.join(sessionDir, 'meta.json');
+        if (fs.existsSync(metaFile)) {
+          const meta = safeJsonParse(fs.readFileSync(metaFile, 'utf8'), null);
+          createdAt = (meta && meta.created_at) || createdAt;
+        }
+        index.sessions.push({
+          id: sessionId,
+          created_at: createdAt,
+          ended_at: null,
+          command_count: 0,
+        });
+      }
+
+      writeJsonAtomicSync(indexFile, index);
+    });
+
+    await this._updateCurrentSymlink();
+    return this.sessionId;
+  }
+
+  /**
+   * Find a history session id by the underlying sandbox shell session name.
+   * @param {string} shellSessionName
+   * @returns {Promise<string|null>}
+   */
+  async findSessionByShellSessionName(shellSessionName) {
+    if (!shellSessionName) return null;
+    const sessions = await this.listSessions();
+    for (const session of sessions) {
+      const sessionId = session.session_id || session.id;
+      if (!sessionId) continue;
+      if (session.shell_session_name === shellSessionName) {
+        return sessionId;
+      }
+
+      // Back-compat: read meta.json if listSessions did not populate it
+      const metaFile = path.join(this._getSandboxDir(), sessionId, 'meta.json');
+      if (fs.existsSync(metaFile)) {
+        try {
+          const meta = JSON.parse(fs.readFileSync(metaFile, 'utf8'));
+          if (meta.shell_session_name === shellSessionName) {
+            return sessionId;
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Resume an existing history session by sandbox shell session name.
+   * @param {string} shellSessionName
+   * @returns {Promise<string|null>} history session id
+   */
+  async resumeByShellSessionName(shellSessionName) {
+    logger.debug(`resumeByShellSessionName: searching for shellSessionName=${shellSessionName}`);
+    const sessionId = await this.findSessionByShellSessionName(shellSessionName);
+    if (!sessionId) {
+      logger.debug(`resumeByShellSessionName: no history session found for shellSessionName=${shellSessionName}`);
+      return null;
+    }
+    logger.debug(`resumeByShellSessionName: found history sessionId=${sessionId}`);
+    await this.resume(sessionId);
+    return sessionId;
+  }
+
+  async init(options = {}) {
+    this.sessionId = this._generateSessionId();
+    const sessionDir = this._getSessionDir();
+
+    // Create directory structure
+    fs.mkdirSync(sessionDir, { recursive: true });
+
+    // Create meta.json
+    const meta = {
+      session_id: this.sessionId,
+      sandbox_id: this.sandboxId,
+      shell_session_name: options.shellSessionName || null,
+      created_at: new Date().toISOString(),
+      ended_at: null,
+      command_count: 0,
+    };
+    writeJsonAtomicSync(path.join(sessionDir, 'meta.json'), meta);
+
+    // Create empty history file
+    fs.writeFileSync(path.join(sessionDir, 'shell_history'), '');
+
+    // Update index
+    await this._updateIndex();
+
+    // Update current symlink
+    await this._updateCurrentSymlink();
+
+    return this.sessionId;
+  }
+
+  getLastShellSessionName() {
+    const indexFile = path.join(this._getSandboxDir(), 'index.json');
+    if (!fs.existsSync(indexFile)) {
+      return null;
+    }
+
+    try {
+      const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+      if (!index.current_session) {
+        return null;
+      }
+
+      const metaFile = path.join(this._getSandboxDir(), index.current_session, 'meta.json');
+      if (!fs.existsSync(metaFile)) {
+        return null;
+      }
+
+      const meta = JSON.parse(fs.readFileSync(metaFile, 'utf8'));
+      return meta.shell_session_name || null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async updateShellSessionName(shellSessionName) {
+    const metaFile = path.join(this._getSessionDir(), 'meta.json');
+    if (fs.existsSync(metaFile)) {
+      const meta = safeJsonParse(fs.readFileSync(metaFile, 'utf8'), {});
+      meta.shell_session_name = shellSessionName;
+      writeJsonAtomicSync(metaFile, meta);
+    }
+  }
+
+  async addCommand(command) {
+    // Skip if command is undefined, null, or not a string
+    if (typeof command !== 'string' || command.trim() === '') {
+      return;
+    }
+    const historyFile = path.join(this._getSessionDir(), 'shell_history');
+    fs.appendFileSync(historyFile, command + '\n');
+
+    // Update command count in meta
+    const metaFile = path.join(this._getSessionDir(), 'meta.json');
+    const meta = safeJsonParse(fs.readFileSync(metaFile, 'utf8'), {});
+    meta.command_count++;
+    writeJsonAtomicSync(metaFile, meta);
+  }
+
+  /**
+   * Save output history to disk
+   * @param {Array} outputs - Array of output items from REPL state
+   */
+  async saveOutputs(outputs) {
+    const outputFile = path.join(this._getSessionDir(), 'outputs.json');
+    try {
+      // Filter out welcome messages and only keep relevant data
+      const filteredOutputs = outputs
+        .filter(item => !item.isWelcome)
+        .map(item => ({
+          command: item.command,
+          output: item.output,
+          exitCode: item.exitCode,
+          timestamp: item.timestamp,
+          prompt: item.prompt,
+          // Save metaInfo and tips for error display
+          metaInfo: item.metaInfo,
+          tips: item.tips,
+        }));
+
+      writeJsonAtomicSync(outputFile, filteredOutputs);
+    } catch (error) {
+      logger.debug(`Failed to save outputs: ${error && error.message ? error.message : String(error)}`);
+      this._noticeOnce('history-save-failed', 'Warning: failed to save attach history (outputs).');
+    }
+  }
+
+  /**
+   * Load output history from disk
+   * @returns {Array} Array of output items
+   */
+  async loadOutputs() {
+    const outputFile = path.join(this._getSessionDir(), 'outputs.json');
+    if (!fs.existsSync(outputFile)) {
+      return [];
+    }
+
+    try {
+      const content = fs.readFileSync(outputFile, 'utf8');
+      const outputs = safeJsonParse(content, null);
+      if (!Array.isArray(outputs)) return [];
+
+      // Restore output format with IDs
+      return outputs.map((item, index) => ({
+        id: `output-${Date.now()}-${index}`,
+        command: item.command,
+        output: item.output,
+        exitCode: item.exitCode !== undefined ? item.exitCode : 0,
+        timestamp: item.timestamp ? new Date(item.timestamp) : new Date(),
+        truncated: false,
+        prompt: item.prompt || null,
+        isWelcome: false,
+        // Restore metaInfo and tips for error display
+        metaInfo: item.metaInfo || null,
+        tips: item.tips || null,
+      }));
+    } catch (error) {
+      logger.debug(`Failed to load outputs: ${error && error.message ? error.message : String(error)}`);
+      this._noticeOnce('history-load-failed', 'Warning: failed to load attach history (outputs).');
+      return [];
+    }
+  }
+
+  async getHistory() {
+    const historyFile = path.join(this._getSessionDir(), 'shell_history');
+    if (!fs.existsSync(historyFile)) {
+      return [];
+    }
+    const content = fs.readFileSync(historyFile, 'utf8');
+    return content.split('\n').filter(line => line.trim());
+  }
+
+  async listSessions() {
+    const indexFile = path.join(this._getSandboxDir(), 'index.json');
+    let index = null;
+    if (fs.existsSync(indexFile)) {
+      try {
+        index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+      } catch (e) {
+        index = null;
+      }
+    }
+
+    // Fallback: scan directories when index is missing/corrupt
+    if (!index) {
+      const sandboxDir = this._getSandboxDir();
+      if (!fs.existsSync(sandboxDir)) {
+        return [];
+      }
+      const dirs = fs.readdirSync(sandboxDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name)
+        .filter(name => name !== 'current');
+      index = { sandbox_id: this.sandboxId, sessions: dirs.map(id => ({ id })) };
+    }
+
+    // Read actual data from each session's meta.json
+    const sessions = (index.sessions || []).map(session => {
+      const metaFile = path.join(this._getSandboxDir(), session.id, 'meta.json');
+      if (fs.existsSync(metaFile)) {
+        try {
+          try {
+            const stat = fs.statSync(metaFile);
+            session.updated_at = new Date(stat.mtimeMs).toISOString();
+          } catch {
+            // ignore
+          }
+          const meta = JSON.parse(fs.readFileSync(metaFile, 'utf8'));
+          session.command_count = meta.command_count || 0;
+          session.work_dir = meta.work_dir || null;
+          session.created_at = meta.created_at || null;
+          session.ended_at = meta.ended_at || null;
+          session.shell_session_name = meta.shell_session_name || null;
+        } catch (e) {
+          // Ignore parse errors
+        }
+      }
+      return session;
+    });
+
+    // Sort by created_at descending (newest first)
+    return sessions.sort((a, b) => {
+      const timeA = a.created_at ? new Date(a.created_at).getTime() : 0;
+      const timeB = b.created_at ? new Date(b.created_at).getTime() : 0;
+      return timeB - timeA;
+    });
+  }
+
+  /**
+   * Update the work_dir in current session's meta
+   * @param {string} workDir - Current working directory
+   */
+  async updateWorkDir(workDir) {
+    const metaFile = path.join(this._getSessionDir(), 'meta.json');
+    if (fs.existsSync(metaFile)) {
+      const meta = safeJsonParse(fs.readFileSync(metaFile, 'utf8'), {});
+      meta.work_dir = workDir;
+      writeJsonAtomicSync(metaFile, meta);
+    }
+  }
+
+  /**
+   * Get history from a specific session
+   * @param {string} sessionId - The session ID to get history from
+   * @returns {string[]} Array of commands
+   */
+  async getSessionHistory(sessionId) {
+    const historyFile = path.join(this._getSandboxDir(), sessionId, 'shell_history');
+    if (!fs.existsSync(historyFile)) {
+      return [];
+    }
+    const content = fs.readFileSync(historyFile, 'utf8');
+    return content.split('\n').filter(line => line.trim());
+  }
+
+  async close() {
+    const metaFile = path.join(this._getSessionDir(), 'meta.json');
+    if (fs.existsSync(metaFile)) {
+      const meta = safeJsonParse(fs.readFileSync(metaFile, 'utf8'), {});
+      meta.ended_at = new Date().toISOString();
+      writeJsonAtomicSync(metaFile, meta);
+    }
+  }
+
+  _generateSessionId() {
+    // Use timestamp prefix for sorting + short UUID suffix to avoid collision
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_` +
+           `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const shortId = crypto.randomUUID().split('-')[0]; // 8 chars
+    return `${timestamp}_${shortId}`;
+  }
+
+  _getSandboxDir() {
+    return path.join(this.baseDir, 'history', this.sandboxId);
+  }
+
+  _getSessionDir() {
+    return path.join(this._getSandboxDir(), this.sessionId);
+  }
+
+  async _updateIndex() {
+    const sandboxDir = this._getSandboxDir();
+    const indexFile = path.join(sandboxDir, 'index.json');
+
+    await this._withIndexLock(async () => {
+      let index = { sandbox_id: this.sandboxId, sessions: [] };
+      if (fs.existsSync(indexFile)) {
+        index = safeJsonParse(fs.readFileSync(indexFile, 'utf8'), index);
+      }
+
+      index.sandbox_id = index.sandbox_id || this.sandboxId;
+      index.sessions = Array.isArray(index.sessions) ? index.sessions : [];
+      index.current_session = this.sessionId;
+
+      // Avoid duplicates if init() is retried or called concurrently
+      const exists = index.sessions.some(s => s.id === this.sessionId);
+      if (!exists) {
+        index.sessions.push({
+          id: this.sessionId,
+          created_at: new Date().toISOString(),
+          ended_at: null,
+          command_count: 0,
+        });
+      }
+
+      writeJsonAtomicSync(indexFile, index);
+    });
+  }
+
+  async _updateCurrentSymlink() {
+    const currentLink = path.join(this._getSandboxDir(), 'current');
+    try {
+      if (fs.existsSync(currentLink)) {
+        fs.unlinkSync(currentLink);
+      }
+      fs.symlinkSync(this.sessionId, currentLink);
+    } catch (error) {
+      // Symlinks may not work on all systems, ignore
+    }
+  }
+}
+
+module.exports = HistoryManager;

package/commands/attach/history-session.js

@@ -0,0 +1,48 @@
+'use strict';
+
+/**
+ * Ensure HistoryManager is pointing at the right history session for a given sandbox shell session.
+ *
+ * - If preferResume is true, try to resume an existing history session whose meta.shell_session_name
+ *   matches shellSessionName.
+ * - Otherwise (or if resume fails), create a new history session and persist shellSessionName.
+ *
+ * @param {Object} params
+ * @param {Object} params.historyManager
+ * @param {string} params.shellSessionName
+ * @param {boolean} params.preferResume
+ * @returns {Promise<string|null>} history session id
+ */
+async function ensureHistorySession({ historyManager, shellSessionName, preferResume }) {
+  if (!historyManager) {
+    throw new Error('ensureHistorySession requires historyManager');
+  }
+  if (!shellSessionName) {
+    throw new Error('ensureHistorySession requires shellSessionName');
+  }
+
+  const logger = require('../../utils/logger');
+  logger.debug(`ensureHistorySession: shellSessionName=${shellSessionName}, preferResume=${preferResume}`);
+
+  if (preferResume && typeof historyManager.resumeByShellSessionName === 'function') {
+    const resumed = await historyManager.resumeByShellSessionName(shellSessionName);
+    if (resumed) {
+      logger.debug(`History session resumed: ${resumed}`);
+      return resumed;
+    }
+    logger.debug('No history session found to resume, will create new one');
+  }
+
+  if (typeof historyManager.init !== 'function') {
+    throw new Error('HistoryManager.init not available');
+  }
+
+  const created = await historyManager.init({ shellSessionName });
+  logger.debug(`History session created: ${created}`);
+  return created || historyManager.sessionId || null;
+}
+
+module.exports = {
+  ensureHistorySession,
+};
+