rl-rockcli 0.0.9 → 0.0.10

package/commands/attach/sandbox-id-resolver.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Resolve an abbreviated sandbox ID to a full ID
+ * @param {string} sandboxId - The sandbox ID (can be abbreviated or full)
+ * @param {Object} options - Options
+ * @param {string} options.baseDir - Base directory for history (default: ~/.rock)
+ * @returns {Promise<string>} The resolved full sandbox ID
+ */
+async function resolveSandboxId(sandboxId, options = {}) {
+  const baseDir = options.baseDir || path.join(os.homedir(), '.rock');
+  const historyDir = path.join(baseDir, 'history');
+
+  // If the ID looks like a complete ID (length >= 32, typical MD5 hash length),
+  // allow it even if not in history (new sandbox case)
+  if (sandboxId.length >= 32) {
+    return sandboxId;
+  }
+
+  // Check if history directory exists
+  if (!fs.existsSync(historyDir)) {
+    throw new Error(`No sandbox found matching: ${sandboxId}`);
+  }
+
+  // Get all sandbox directories
+  const sandboxDirs = fs.readdirSync(historyDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+
+  // If the provided ID is already a full ID and exists, return it
+  if (sandboxDirs.includes(sandboxId)) {
+    return sandboxId;
+  }
+
+  // Try to find a match for abbreviated ID
+  const matches = sandboxDirs.filter(id => id.startsWith(sandboxId));
+
+  if (matches.length === 0) {
+    throw new Error(`No sandbox found matching: ${sandboxId}`);
+  }
+
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous sandbox ID: ${sandboxId} matches multiple sandboxes:\n` +
+      matches.map(m => `  - ${m}`).join('\n')
+    );
+  }
+
+  return matches[0];
+}
+
+module.exports = { resolveSandboxId };

package/commands/attach/session-manager.js

@@ -0,0 +1,307 @@
+'use strict';
+
+const crypto = require('crypto');
+const logger = require('../../utils/logger');
+
+class SessionManager {
+  constructor(client, sandboxId) {
+    this.client = client;
+    this.sandboxId = sandboxId;
+    this.sessionId = null;
+    this.heartbeatInterval = null;
+  }
+
+  /**
+   * Wait for sandbox to be ready (alive)
+   * @param {Object} options - Wait options
+   * @param {number} options.maxAttempts - Maximum number of attempts (default: 30)
+   * @param {number} options.intervalMs - Interval between attempts in ms (default: 1000)
+   * @param {Function} options.onProgress - Optional callback for progress updates
+   * @param {AbortSignal} options.signal - Optional AbortSignal to cancel waiting
+   * @returns {Promise<boolean>} True if sandbox is ready, false if timeout or aborted
+   */
+  async waitForReady({ maxAttempts = 30, intervalMs = 1000, onProgress = null, signal = null } = {}) {
+    // Set sandboxId on client (required by SandboxClient)
+    this.client._sandboxId = this.sandboxId;
+    let lastError = null;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      // Check if aborted
+      if (signal?.aborted) {
+        logger.debug('Wait aborted by signal');
+        return { ready: false, error: lastError };
+      }
+
+      try {
+        const status = await this.client.getStatus();
+        logger.debug(`[waitForReady] Status response: ${JSON.stringify(status)}`);
+        
+        if (status.isAlive) {
+          return { ready: true, error: null };
+        }
+
+        // Check if sandbox is in Failed state (destroyed or not exist)
+        // The 'status' field in response is an object with stage details
+        // Check for any indication of failure in the status object
+        const statusObj = status.status;
+        logger.debug(`[waitForReady] Sandbox isAlive: ${status.isAlive}, status: ${JSON.stringify(statusObj)}`);
+        
+        if (statusObj && typeof statusObj === 'object') {
+          // Check if any stage indicates failure
+          const stages = Object.values(statusObj);
+          const hasFailedStage = stages.some(stage => 
+            stage && (stage.status === 'failed' || stage.status === 'error')
+          );
+          if (hasFailedStage) {
+            logger.debug(`[waitForReady] Sandbox has failed stage (attempt ${attempt}/${maxAttempts})`);
+            return { ready: false, error: new Error('Sandbox has been destroyed or does not exist'), status: 'Failed' };
+          }
+        }
+        
+        logger.debug(`[waitForReady] Sandbox not ready (attempt ${attempt}/${maxAttempts})`);
+      } catch (error) {
+        lastError = error; // Store the last error
+        logger.debug(`[waitForReady] Status check failed (attempt ${attempt}/${maxAttempts}): ${error.message}`);
+        // Check if error indicates sandbox not found
+        const errorMsg = error.message || '';
+        if (errorMsg.toLowerCase().includes('not found') || 
+            errorMsg.toLowerCase().includes('does not exist') ||
+            errorMsg.toLowerCase().includes('sandbox') && errorMsg.toLowerCase().includes('not')) {
+          return { ready: false, error: error, status: 'Failed' };
+        }
+      }
+
+      if (onProgress) {
+        onProgress(attempt, maxAttempts);
+      }
+
+      if (attempt < maxAttempts) {
+        await this._sleepWithSignal(intervalMs, signal);
+      }
+    }
+
+    return { ready: false, error: lastError };
+  }
+
+  _sleepWithSignal(ms, signal) {
+    return new Promise(resolve => {
+      const timeout = setTimeout(resolve, ms);
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          clearTimeout(timeout);
+          resolve();
+        }, { once: true });
+      }
+    });
+  }
+
+  async connect(options = {}) {
+    // Set sandboxId on client (required by SandboxClient)
+    this.client._sandboxId = this.sandboxId;
+
+    const { reuseSession } = options;
+
+    // Try to reuse existing session if specified
+    if (reuseSession) {
+      logger.debug(`Attempting to reuse session: ${reuseSession}`);
+      try {
+        // Try running a simple command to verify session is alive
+        const testResult = await this.client.runInSession({
+          command: 'echo SESSION_ALIVE',
+          session: reuseSession,
+          check: 'silent',
+        });
+
+        if (testResult.output && testResult.output.includes('SESSION_ALIVE')) {
+          this.sessionId = reuseSession;
+          // Get current user and pwd
+          const [whoamiResult, pwdResult] = await Promise.all([
+            this.client.runInSession({
+              command: 'whoami',
+              session: reuseSession,
+              check: 'silent',
+            }),
+            this.client.runInSession({
+              command: 'pwd',
+              session: reuseSession,
+              check: 'silent',
+            }),
+          ]);
+          const user = whoamiResult.output?.trim() || 'root';
+          const cwd = pwdResult.output?.trim() || '/';
+          const hostname = this.sandboxId;
+          this.initialPrompt = `${user}@${hostname}:${cwd}# `;
+          logger.debug(`Reused existing session: ${this.sessionId}`);
+          return {
+            sessionId: this.sessionId,
+            initialPrompt: this.initialPrompt,
+            user,
+            reused: true,
+          };
+        }
+      } catch (error) {
+        logger.debug(`Failed to reuse session ${reuseSession}: ${error.message}`);
+        // Fall through to create new session
+      }
+    }
+
+    // Create new session
+    logger.debug(`Creating session for sandbox ${this.sandboxId}`);
+
+    // Use UUID to ensure unique session name and avoid collision
+    // If session already exists, API returns empty output
+    const sessionName = `repl-${crypto.randomUUID()}`;
+
+    // Create session - API returns { session_type, output }
+    // The output contains the initial shell prompt (e.g., "root@host:/# ")
+    const result = await this.client.createSession({
+      session: sessionName,
+      sessionType: 'bash',
+      envEnable: true,
+    });
+
+    // Use the session name we passed as our sessionId
+    this.sessionId = sessionName;
+    this.initialPrompt = result.output || '';
+    logger.debug(`Session created: ${this.sessionId}`);
+    logger.debug(`Initial prompt: ${this.initialPrompt}`);
+
+    // Get current user
+    let user = 'root';
+    try {
+      const whoamiResult = await this.client.runInSession({
+        command: 'whoami',
+        session: sessionName,
+        check: 'silent',
+      });
+      user = whoamiResult.output?.trim() || 'root';
+    } catch (e) {
+      logger.debug('Failed to get user:', e.message);
+    }
+
+    return {
+      sessionId: this.sessionId,
+      initialPrompt: this.initialPrompt,
+      user,
+      reused: false,
+    };
+  }
+
+  async execute(command, options = {}) {
+    if (!this.sessionId) {
+      throw new Error('Not connected. Call connect() first.');
+    }
+
+    // SandboxClient.runInSession expects { command, session }
+    const runOpts = {
+      command: command,
+      session: this.sessionId,
+      check: 'silent',
+    };
+
+    // Forward AbortSignal for cancellation support
+    if (options.signal) {
+      runOpts.signal = options.signal;
+    }
+
+    const result = await this.client.runInSession(runOpts);
+
+    // Mark as background command if specified
+    if (options.background) {
+      result._background = true;
+    }
+
+    return result;
+  }
+
+  async executeWithRetry(command, maxRetries = 3, delayMs = 2000) {
+    let lastError;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await this.execute(command);
+      } catch (error) {
+        lastError = error;
+        logger.warn(`Command failed (attempt ${attempt}/${maxRetries}): ${error.message}`);
+
+        if (attempt < maxRetries) {
+          await this._sleep(delayMs);
+        }
+      }
+    }
+
+    throw lastError;
+  }
+
+  _sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async disconnect() {
+    this.stopHeartbeat();
+    // Don't close session - keep it alive for resume
+    // Session will be auto-cleared by sandbox timeout
+    logger.debug(`Disconnected from session ${this.sessionId} (session kept alive for resume)`);
+  }
+
+  /**
+   * Interrupt the current session and create a new one.
+   * Used when a running command is cancelled (ESC / Ctrl+C) to unblock
+   * the session, since the server-side process may still be running.
+   *
+   * @param {string} cwd - Working directory to restore in the new session
+   */
+  async interruptSession(cwd) {
+    const oldSessionId = this.sessionId;
+
+    // Create a new session immediately (don't wait for old one to close)
+    const sessionName = `repl-${crypto.randomUUID()}`;
+    await this.client.createSession({
+      session: sessionName,
+      sessionType: 'bash',
+      envEnable: true,
+    });
+    this.sessionId = sessionName;
+    logger.debug(`Interrupted session ${oldSessionId}, new session: ${sessionName}`);
+
+    // Restore working directory (skip for root /)
+    if (cwd && cwd !== '/') {
+      try {
+        await this.client.runInSession({
+          command: `cd ${cwd}`,
+          session: this.sessionId,
+          check: 'silent',
+        });
+      } catch (e) {
+        logger.debug(`Failed to restore cwd after interrupt: ${e.message}`);
+      }
+    }
+
+    // Best-effort close of old session in background
+    if (oldSessionId) {
+      this.client.closeSession(oldSessionId).catch((e) => {
+        logger.debug(`Failed to close interrupted session ${oldSessionId}: ${e.message}`);
+      });
+    }
+  }
+
+  startHeartbeat(intervalMs = 150000) {
+    this.heartbeatInterval = setInterval(async () => {
+      try {
+        await this.client.getStatus();
+        logger.debug('Heartbeat sent');
+      } catch (error) {
+        logger.warn('Heartbeat failed:', error.message);
+      }
+    }, intervalMs);
+  }
+
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+}
+
+module.exports = SessionManager;

package/commands/attach/ui-mode.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const INK_MIN_NODE_MAJOR = 20;
+
+function parseNodeMajor(nodeVersion) {
+  if (!nodeVersion || typeof nodeVersion !== 'string') return null;
+  const majorStr = nodeVersion.split('.')[0];
+  const major = Number.parseInt(majorStr, 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+function normalizeMode(value) {
+  if (!value || typeof value !== 'string') return null;
+  const mode = value.trim().toLowerCase();
+  if (mode === 'ink' || mode === 'basic' || mode === 'copy' || mode === 'opentui') return mode;
+  return null;
+}
+
+/**
+ * Check if the current process is running under Bun runtime.
+ */
+function isBunRuntime() {
+  return typeof globalThis.Bun !== 'undefined';
+}
+
+/**
+ * Find the bun binary path.
+ * Checks (in order):
+ *   1. node_modules/.bin/bun (installed via npm)
+ *   2. ~/.bun/bin/bun (curl installed)
+ *   3. System-level bun (via `which bun`)
+ * Returns the resolved path, or null if not found.
+ */
+function findBunBinary() {
+  const path = require('path');
+  const fs = require('fs');
+  const os = require('os');
+  const { execSync } = require('child_process');
+
+  // 1. Check node_modules/.bin/bun relative to this project
+  const candidates = [
+    // From project root (two levels up from commands/attach/)
+    path.resolve(__dirname, '..', '..', 'node_modules', '.bin', 'bun'),
+    // From cwd
+    path.resolve(process.cwd(), 'node_modules', '.bin', 'bun'),
+    // ~/.bun/bin/bun (curl 安装的默认路径)
+    path.join(os.homedir(), '.bun', 'bin', 'bun'),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // 2. Check system bun via PATH
+  try {
+    const systemBun = execSync('which bun', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    if (systemBun && fs.existsSync(systemBun)) {
+      return systemBun;
+    }
+  } catch {
+    // not found
+  }
+
+  return null;
+}
+
+/**
+ * Get Bun version from binary path.
+ * @param {string} bunPath - Path to bun binary
+ * @returns {{major: number, version: string, valid: boolean}|null} Version info or null
+ */
+function getBunVersion(bunPath) {
+  try {
+    const { execSync } = require('child_process');
+    const versionStr = execSync(`"${bunPath}" --version`, { 
+      encoding: 'utf8', 
+      stdio: ['pipe', 'pipe', 'ignore'] 
+    }).trim();
+    
+    const match = versionStr.match(/(\d+\.\d+\.\d+)/);
+    if (match) {
+      const major = parseInt(match[1].split('.')[0], 10);
+      return { major, version: match[1], valid: true };
+    }
+    
+    return { major: 0, version: versionStr, valid: false };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Decide which UI to use for `attach`.
+ *
+ * Ink UI (React/Ink) requires a modern Node runtime; on older Node versions it can
+ * fail with a SyntaxError (e.g. `Unexpected token '.'`) while importing `ink`.
+ */
+function selectAttachUiMode(options) {
+  const argv = options && options.argv ? options.argv : {};
+  const env = options && options.env ? options.env : {};
+  const nodeVersion = options && options.nodeVersion ? options.nodeVersion : process.versions.node;
+
+  const forcedByArgv = normalizeMode(argv.ui);
+  if (forcedByArgv) {
+    return { mode: forcedByArgv, reason: 'forced by argv.ui', nodeVersion, nodeMajor: parseNodeMajor(nodeVersion) };
+  }
+
+  const forcedByEnv = normalizeMode(env.ROCK_ATTACH_UI);
+  if (forcedByEnv) {
+    return { mode: forcedByEnv, reason: 'forced by env ROCK_ATTACH_UI', nodeVersion, nodeMajor: parseNodeMajor(nodeVersion) };
+  }
+
+  const nodeMajor = parseNodeMajor(nodeVersion);
+
+  // Bun runtime (>= 1.0 guaranteed by all.js bootstrap) reports a low
+  // process.versions.node for compat, but fully supports modern JS features.
+  if (isBunRuntime()) {
+    return { mode: 'opentui', reason: 'default (bun)', nodeVersion, nodeMajor };
+  }
+
+  if (nodeMajor !== null && nodeMajor < INK_MIN_NODE_MAJOR) {
+    return {
+      mode: 'basic',
+      reason: `Ink UI requires Node >= ${INK_MIN_NODE_MAJOR} (current ${nodeVersion})`,
+      nodeVersion,
+      nodeMajor,
+      minNodeMajor: INK_MIN_NODE_MAJOR,
+    };
+  }
+
+  return { mode: 'opentui', reason: 'default', nodeVersion, nodeMajor: nodeMajor };
+}
+
+module.exports = {
+  INK_MIN_NODE_MAJOR,
+  selectAttachUiMode,
+  isBunRuntime,
+  findBunBinary,
+  getBunVersion,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rl-rockcli",
-    "version": "0.0.9",
+    "version": "0.0.10",
     "description": "Open-source ROCK CLI - Sandbox and Log management tool",
     "bin": {
         "rockcli": "./index.js"