rl-rockcli 0.0.9 → 0.0.11

package/commands/attach/ink-repl/hooks/useResources.js

@@ -0,0 +1,132 @@
+import { useState, useEffect, useCallback } from 'react';
+
+export const REFRESH_INTERVAL = 10000; // 10 seconds (to avoid too many shell commands)
+
+/**
+ * Format bytes to human readable
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0B';
+  const k = 1024;
+  const sizes = ['B', 'K', 'M', 'G', 'T'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + sizes[i];
+}
+
+/**
+ * Parse resource info from shell command output
+ * Executes: cat /proc/loadavg; top -bn1 | head -3; free -b | head -2; df -B1 / | tail -1
+ */
+export function parseResourceOutput(output) {
+  if (!output) return null;
+
+  const resources = {};
+  const lines = output.trim().split('\n');
+
+  for (const line of lines) {
+    // Parse CPU load from /proc/loadavg
+    // Format: "0.00 0.01 0.05 1/123 4567" (1min 5min 15min running/total lastpid)
+    if (/^\d+\.\d+\s+\d+\.\d+\s+\d+\.\d+/.test(line)) {
+      const parts = line.split(/\s+/);
+      if (parts.length >= 1) {
+        const load1min = parseFloat(parts[0]);
+        if (!isNaN(load1min)) {
+          resources.load = load1min.toFixed(2);
+        }
+      }
+    }
+
+    // Parse CPU usage from top output
+    // Format: "%Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id, ..."
+    if (line.includes('Cpu') && line.includes('id')) {
+      const idleMatch = line.match(/(\d+\.?\d*)\s*id/);
+      if (idleMatch) {
+        const idle = parseFloat(idleMatch[1]);
+        const cpuUsage = (100 - idle).toFixed(0);
+        resources.cpu = `${cpuUsage}%`;
+      }
+    }
+
+    // Parse memory from 'free -b' output
+    // Format: "Mem:  total  used  free  shared  buff/cache  available"
+    if (line.startsWith('Mem:')) {
+      const parts = line.split(/\s+/);
+      if (parts.length >= 3) {
+        const total = parseInt(parts[1], 10);
+        const used = parseInt(parts[2], 10);
+        if (!isNaN(total) && !isNaN(used)) {
+          resources.memory = {
+            used: formatBytes(used),
+            total: formatBytes(total),
+          };
+        }
+      }
+    }
+
+    // Parse disk from 'df' output
+    // Format: "Filesystem  1B-blocks  Used  Available  Use%  Mounted"
+    if (line.includes('/') && !line.startsWith('Filesystem') && !line.includes('loadavg')) {
+      const parts = line.split(/\s+/);
+      if (parts.length >= 4) {
+        const total = parseInt(parts[1], 10);
+        const used = parseInt(parts[2], 10);
+        if (!isNaN(total) && !isNaN(used)) {
+          resources.disk = {
+            used: formatBytes(used),
+            total: formatBytes(total),
+          };
+        }
+      }
+    }
+  }
+
+  return Object.keys(resources).length > 0 ? resources : null;
+}
+
+/**
+ * Hook for monitoring sandbox resources via shell commands
+ * Uses client.exec() instead of sessionManager.execute() to avoid interfering with user session
+ * @param {Object} client - Sandbox client for executing commands
+ * @param {boolean} enabled - Whether to enable monitoring
+ * @returns {{ resources: Object|null, error: Error|null, refresh: Function }}
+ */
+export function useResources(client, enabled = true) {
+  const [resources, setResources] = useState(null);
+  const [error, setError] = useState(null);
+
+  const refresh = useCallback(async () => {
+    if (!client || !enabled) return;
+
+    try {
+      // Use client.execute() to run in an isolated context (not in user's session)
+      // This avoids output interference with user commands
+      const result = await client.execute('cat /proc/loadavg 2>/dev/null; top -bn1 2>/dev/null | head -3; free -b 2>/dev/null | head -2; df -B1 / 2>/dev/null | tail -1');
+      // client.execute() returns { stdout, stderr, exit_code }
+      if (result && result.stdout) {
+        const parsed = parseResourceOutput(result.stdout);
+        setResources(parsed);
+      }
+      setError(null);
+    } catch (err) {
+      setError(err);
+      // Don't clear resources on error, keep last known values
+    }
+  }, [client, enabled]);
+
+  useEffect(() => {
+    if (!enabled || !client) return;
+
+    // Initial fetch after a short delay (let REPL initialize first)
+    const initialTimer = setTimeout(refresh, 1000);
+
+    // Set up interval
+    const timer = setInterval(refresh, REFRESH_INTERVAL);
+
+    return () => {
+      clearTimeout(initialTimer);
+      clearInterval(timer);
+    };
+  }, [client, enabled, refresh]);
+
+  return { resources, error, refresh };
+}

package/commands/attach/ink-repl/hooks/useSpinner.js

@@ -0,0 +1,49 @@
+import { useState, useEffect } from 'react';
+
+export const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export const SPINNER_INTERVAL = 120; // ms (slower to reduce flicker)
+
+/**
+ * Format spinner text with command
+ * @param {string} frame - Current spinner frame
+ * @param {string} command - Command being executed
+ * @param {number} maxLength - Maximum total length
+ * @returns {string} Formatted spinner text
+ */
+export function formatSpinnerText(frame, command, maxLength = 60) {
+  const prefix = `${frame} `;
+  const availableLength = maxLength - prefix.length;
+
+  if (command.length <= availableLength) {
+    return `${prefix}${command}`;
+  }
+
+  return `${prefix}${command.slice(0, availableLength - 3)}...`;
+}
+
+/**
+ * Hook for animated spinner
+ * @param {boolean} isActive - Whether spinner should animate
+ * @returns {{ frame: string, frameIndex: number }}
+ */
+export function useSpinner(isActive = false) {
+  const [frameIndex, setFrameIndex] = useState(0);
+
+  useEffect(() => {
+    if (!isActive) {
+      setFrameIndex(0);
+      return;
+    }
+
+    const timer = setInterval(() => {
+      setFrameIndex(prev => (prev + 1) % SPINNER_FRAMES.length);
+    }, SPINNER_INTERVAL);
+
+    return () => clearInterval(timer);
+  }, [isActive]);
+
+  return {
+    frame: SPINNER_FRAMES[frameIndex],
+    frameIndex,
+  };
+}

package/commands/attach/ink-repl/index.js

@@ -0,0 +1,112 @@
+import React from 'react';
+import { render } from 'ink';
+import { InkREPL } from './InkREPL.js';
+import { ThemeProvider } from './contexts/ThemeContext.js';
+
+const h = React.createElement;
+
+/**
+ * Start the Ink-based REPL
+ *
+ * @param {Object} options
+ * @param {string} options.sandboxId - Sandbox ID
+ * @param {string} options.hostname - Hostname for prompt
+ * @param {string} options.hostIp - Host IP address
+ * @param {string} options.user - Current user
+ * @param {Object} options.client - Sandbox client
+ * @param {Object} options.sessionManager - Session manager
+ * @param {Object} options.historyManager - History manager
+ * @param {string} options.initialPrompt - Initial shell prompt
+ * @param {Array} options.triggers - Trigger definitions
+ * @param {Function} options.onExit - Callback when REPL exits
+ * @returns {Promise<void>}
+ */
+export async function startInkREPL(options) {
+  const {
+    sandboxId,
+    hostname,
+    hostIp,
+    user,
+    client,
+    sessionManager,
+    historyManager,
+    initialPrompt = '$ ',
+    version,
+    triggers = [],
+    onExit,
+    theme,
+    onThemeChange,
+  } = options;
+
+  let instance = null;
+  let cleaned = false;
+
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (onExit) onExit();
+  };
+
+  try {
+    instance = render(
+      h(ThemeProvider, { initialTheme: theme, onThemeChange },
+        h(InkREPL, {
+          sandboxId,
+          hostname,
+          hostIp,
+          user,
+          client,
+          sessionManager,
+          historyManager,
+          initialPrompt,
+          version,
+          triggers,
+          onExit: cleanup,
+        })
+      ),
+      {
+        // Disable patchConsole to prevent console output from interfering
+        patchConsole: false,
+        // We handle Ctrl+C ourselves in useInput
+        exitOnCtrlC: false,
+        // Use stdout directly for better performance
+        stdout: process.stdout,
+        stdin: process.stdin,
+        // Use Ink's built-in alternate buffer for flicker-free full-screen UI
+        alternateBuffer: true,
+        // Enable incremental rendering - only updates changed lines
+        incrementalRendering: true,
+      }
+    );
+
+    // Handle SIGTERM
+    process.on('SIGTERM', cleanup);
+
+    // Wait for the Ink instance to finish (user exits)
+    await instance.waitUntilExit();
+
+    // Ensure cleanup is called
+    cleanup();
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Create a slash command trigger
+ */
+export function createSlashTrigger(commands) {
+  return {
+    symbol: '/',
+    getItems: (prefix) => {
+      return commands.map(cmd => ({
+        label: `/${cmd.name}`,
+        value: `/${cmd.name}`,
+        description: cmd.description || '',
+      }));
+    },
+  };
+}
+
+export { InkREPL };
+export { consoleLogger } from './utils/consoleLogger.js';

package/commands/attach/ink-repl/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}