centaurus-cli 3.0.1 → 3.1.0

package/dist/index.js

@@ -1,414 +1,391 @@
 #!/usr/bin/env node
-/**
- * Centaurus CLI Entry Point
- *
- * NOTE: NO .env file loading! All configuration is baked in at build time.
- * See config/build-config.ts for the compile-time configuration.
- */
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+import { fileURLToPath } from "url";
+import { dirname } from "path";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Import logger early for error handlers
-import { logError, logWarning, logInfo } from './utils/logger.js';
-import { quickLog } from './utils/conversation-logger.js';
-// Global handler for EPIPE errors from MCP servers during shutdown
-// This prevents crashes when MCP server processes try to write to closed pipes
-process.stdout.on('error', (err) => {
-    if (err.code === 'EPIPE') {
-        // Silently ignore EPIPE errors - these happen during graceful shutdown
-        logWarning(`stdout EPIPE error (suppressed): ${err.message}`);
-        return;
-    }
-    logError('stdout error', err);
+import { logError, logWarning, logInfo } from "./utils/logger.js";
+import { quickLog } from "./utils/conversation-logger.js";
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") {
+    logWarning(`stdout EPIPE error (suppressed): ${err.message}`);
+    return;
+  }
+  logError("stdout error", err);
 });
-process.stderr.on('error', (err) => {
-    if (err.code === 'EPIPE') {
-        logWarning(`stderr EPIPE error (suppressed): ${err.message}`);
-        return;
-    }
-    logError('stderr error', err);
+process.stderr.on("error", (err) => {
+  if (err.code === "EPIPE") {
+    logWarning(`stderr EPIPE error (suppressed): ${err.message}`);
+    return;
+  }
+  logError("stderr error", err);
 });
-process.stdin.on('error', (err) => {
-    if (err.code === 'EPIPE' || err.code === 'EOF') {
-        logWarning(`stdin error (suppressed): ${err.code} - ${err.message}`);
-        return;
-    }
-    logError('stdin error', err);
+process.stdin.on("error", (err) => {
+  if (err.code === "EPIPE" || err.code === "EOF") {
+    logWarning(`stdin error (suppressed): ${err.code} - ${err.message}`);
+    return;
+  }
+  logError("stdin error", err);
 });
-// Handle uncaught errors from child processes (MCP servers)
-process.on('uncaughtException', (err) => {
-    // EPIPE, ECONNRESET, and similar errors from MCP/network operations - log and continue
-    if (err.code === 'EPIPE' || err.code === 'ECONNRESET' || err.code === 'ENOTCONN') {
-        logWarning(`Uncaught exception (suppressed): ${err.code} - ${err.message}`);
-        return;
-    }
-    // Yoga WASM memory access errors - these occur during rapid layout recalculations
-    // in agent control mode and are non-fatal (the app can continue)
-    if (err.name === 'RuntimeError' && err.message?.includes('memory access out of bounds')) {
-        // Log to file only, not terminal
-        quickLog(`[${new Date().toISOString()}] [WASM] Yoga memory error suppressed: ${err.message}\n`);
-        return;
-    }
-    // For critical errors, log and exit
-    logError('Uncaught exception (fatal)', err);
-    process.exit(1);
+process.on("uncaughtException", (err) => {
+  if (err.code === "EPIPE" || err.code === "ECONNRESET" || err.code === "ENOTCONN") {
+    logWarning(`Uncaught exception (suppressed): ${err.code} - ${err.message}`);
+    return;
+  }
+  if (err.name === "RuntimeError" && err.message?.includes("memory access out of bounds")) {
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [WASM] Yoga memory error suppressed: ${err.message}
+`);
+    return;
+  }
+  logError("Uncaught exception (fatal)", err);
+  process.exit(1);
 });
-// Handle unhandled promise rejections
-process.on('unhandledRejection', (reason, promise) => {
-    const error = reason instanceof Error ? reason : new Error(String(reason));
-    const errnoError = error;
-    // Suppress common non-fatal errors from MCP/network operations
-    if (errnoError.code === 'EPIPE' || errnoError.code === 'ECONNRESET' ||
-        errnoError.code === 'ENOTCONN' || errnoError.code === 'ERR_STREAM_DESTROYED') {
-        logWarning(`Unhandled rejection (suppressed): ${errnoError.code} - ${error.message}`);
-        return;
-    }
-    logError('Unhandled rejection', error);
+process.on("unhandledRejection", (reason, promise) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  const errnoError = error;
+  if (errnoError.code === "EPIPE" || errnoError.code === "ECONNRESET" || errnoError.code === "ENOTCONN" || errnoError.code === "ERR_STREAM_DESTROYED") {
+    logWarning(`Unhandled rejection (suppressed): ${errnoError.code} - ${error.message}`);
+    return;
+  }
+  logError("Unhandled rejection", error);
 });
-import React from 'react';
-import { render } from 'ink';
-import { App } from './ui/components/App.js';
-import { ErrorBoundary } from './ui/components/ErrorBoundary.js';
-import { AuthWelcomeScreen } from './ui/components/AuthWelcomeScreen.js';
-import { CentaurusCLI } from './cli-adapter.js';
-import { apiClient } from './services/api-client.js';
-import { authenticateWithGoogle } from './services/auth-handler.js';
+import React from "react";
+import { render } from "ink";
+import { App } from "./ui/components/App.js";
+import { ErrorBoundary } from "./ui/components/ErrorBoundary.js";
+import { AuthWelcomeScreen } from "./ui/components/AuthWelcomeScreen.js";
+import { CentaurusCLI } from "./cli-adapter.js";
+import { apiClient } from "./services/api-client.js";
+import { authenticateWithGoogle } from "./services/auth-handler.js";
 async function handleAuthentication() {
-    // Check if already authenticated and verify session is valid
-    if (apiClient.isAuthenticated()) {
-        try {
-            // Verify the session is actually valid by checking with backend
-            await apiClient.getCurrentUser();
-            return true; // Session is valid
-        }
-        catch (error) {
-            // Session is invalid/expired, clear it and continue to auth flow
-            logWarning('Session expired. User needs to sign in again.');
-        }
-    }
-    // Check if backend is reachable
-    let backendReachable = false;
+  if (apiClient.isAuthenticated()) {
     try {
-        await apiClient.healthCheck();
-        backendReachable = true;
-    }
-    catch (error) {
-        // Backend is not reachable - we'll still show auth screen but inform user
-        logWarning('Backend API is not reachable during authentication.');
+      await apiClient.getCurrentUser();
+      return true;
+    } catch (error) {
+      logWarning("Session expired. User needs to sign in again.");
     }
-    // Show authentication welcome screen with picker
-    return new Promise((resolve) => {
-        const { waitUntilExit, clear } = render(React.createElement(AuthWelcomeScreen, {
-            onSignIn: async () => {
-                clear();
-                logInfo('Starting authentication process...');
-                // Attempt authentication via web app
-                // The auth handler will open the browser and wait for callback
-                const result = await authenticateWithGoogle();
-                if (result.success) {
-                    logInfo('Authentication successful!');
-                    resolve(true);
-                }
-                else {
-                    logWarning(`Authentication failed: ${result.error || 'Unknown error'}`);
-                    process.exit(1);
-                }
-            },
-            onExit: () => {
-                clear();
-                logInfo('User exited authentication screen.');
-                process.exit(0);
-            },
-        }), {
-            patchConsole: false,
-            exitOnCtrlC: true,
-        });
-    });
+  }
+  let backendReachable = false;
+  try {
+    await apiClient.healthCheck();
+    backendReachable = true;
+  } catch (error) {
+    logWarning("Backend API is not reachable during authentication.");
+  }
+  return new Promise((resolve) => {
+    const { waitUntilExit, clear } = render(
+      React.createElement(AuthWelcomeScreen, {
+        onSignIn: async () => {
+          clear();
+          logInfo("Starting authentication process...");
+          const result = await authenticateWithGoogle();
+          if (result.success) {
+            logInfo("Authentication successful!");
+            resolve(true);
+          } else {
+            logWarning(`Authentication failed: ${result.error || "Unknown error"}`);
+            process.exit(1);
+          }
+        },
+        onExit: () => {
+          clear();
+          logInfo("User exited authentication screen.");
+          process.exit(0);
+        }
+      }),
+      {
+        patchConsole: false,
+        exitOnCtrlC: true
+      }
+    );
+  });
 }
 async function main() {
-    // Handle authentication
-    await handleAuthentication();
-    const cli = new CentaurusCLI();
-    // Initialize CLI (load config, register tools)
-    await cli.initialize();
-    // Check if configuration migration occurred and show message
-    const migrationMessage = cli.getMigrationMessage();
-    if (migrationMessage) {
-        logInfo(`Configuration migration: ${migrationMessage}`);
-        // Wait for user to press Enter, but only if interactive
-        if (process.stdin.isTTY) {
-            await new Promise((resolve) => {
-                const onData = () => {
-                    process.stdin.removeListener('end', onEnd);
-                    resolve();
-                };
-                const onEnd = () => {
-                    process.stdin.removeListener('data', onData);
-                    resolve();
-                };
-                process.stdin.once('data', onData);
-                process.stdin.once('end', onEnd);
-            });
-        }
+  await handleAuthentication();
+  const cli = new CentaurusCLI();
+  await cli.initialize();
+  const migrationMessage = cli.getMigrationMessage();
+  if (migrationMessage) {
+    logInfo(`Configuration migration: ${migrationMessage}`);
+    if (process.stdin.isTTY) {
+      await new Promise((resolve) => {
+        const onData = () => {
+          process.stdin.removeListener("end", onEnd);
+          resolve();
+        };
+        const onEnd = () => {
+          process.stdin.removeListener("data", onData);
+          resolve();
+        };
+        process.stdin.once("data", onData);
+        process.stdin.once("end", onEnd);
+      });
     }
-    // Clear the terminal before starting the UI
-    process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
-    // Render Ink app with error boundary
-    // patchConsole: false prevents console.log from interfering with Ink's rendering
-    // This is CRITICAL for Static component to work properly
-    // debug: false reduces flickering by disabling debug output
-    const { waitUntilExit } = render(React.createElement(ErrorBoundary, null, React.createElement(App, {
+  }
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+  const { waitUntilExit } = render(
+    React.createElement(
+      ErrorBoundary,
+      null,
+      React.createElement(App, {
         onMessage: (msg) => cli.handleMessage(msg),
         onCancelRequest: () => cli.cancelCurrentRequest(),
         initialModel: cli.getModel(),
         initialPlanMode: cli.getPlanMode(),
         onResponseReceived: (callback) => {
-            cli.setOnResponseCallback(callback);
+          cli.setOnResponseCallback(callback);
         },
         onDirectMessage: (callback) => {
-            cli.setOnDirectMessageCallback(callback);
+          cli.setOnDirectMessageCallback(callback);
         },
         onResponseStream: (callback) => {
-            cli.setOnResponseStreamCallback(callback);
+          cli.setOnResponseStreamCallback(callback);
         },
         onClearStreamedResponse: (callback) => {
-            cli.setOnClearStreamedResponse(callback);
+          cli.setOnClearStreamedResponse(callback);
         },
         onThoughtStream: (callback) => {
-            cli.setOnThoughtStreamCallback(callback);
+          cli.setOnThoughtStreamCallback(callback);
         },
         onThoughtComplete: (callback) => {
-            cli.setOnThoughtCompleteCallback(callback);
+          cli.setOnThoughtCompleteCallback(callback);
         },
         onPickerSetup: (callback) => {
-            cli.setOnShowPickerCallback(callback);
+          cli.setOnShowPickerCallback(callback);
         },
         onPickerSelection: (selection, type) => {
-            return cli.handlePickerSelection(selection, type);
+          return cli.handlePickerSelection(selection, type);
         },
         onToolExecutionUpdate: (callback) => {
-            cli.setOnToolExecutionUpdate(callback);
+          cli.setOnToolExecutionUpdate(callback);
         },
         onToolApprovalRequest: (callback) => {
-            cli.setOnToolApprovalRequest(callback);
+          cli.setOnToolApprovalRequest(callback);
         },
         onToolStreamingOutput: (callback) => {
-            cli.setOnToolStreamingOutput(callback);
+          cli.setOnToolStreamingOutput(callback);
         },
         onPlanModeChange: (callback) => {
-            cli.setOnPlanModeChange(callback);
+          cli.setOnPlanModeChange(callback);
         },
         onPlanApprovalRequest: (callback) => {
-            cli.setOnPlanApprovalRequest(callback);
+          cli.setOnPlanApprovalRequest(callback);
         },
         onPlanCreated: (callback) => {
-            cli.setOnPlanCreated(callback);
+          cli.setOnPlanCreated(callback);
         },
         onTaskCompleted: (callback) => {
-            cli.setOnTaskCompleted(callback);
+          cli.setOnTaskCompleted(callback);
+        },
+        onFileChangeSummary: (callback) => {
+          cli.setOnFileChangeSummaryCallback(callback);
         },
         onCommandModeChange: (callback) => {
-            cli.setOnCommandModeChange(callback);
+          cli.setOnCommandModeChange(callback);
         },
         onToggleCommandMode: () => {
-            cli.toggleCommandMode();
+          cli.toggleCommandMode();
         },
         onBackgroundModeChange: (callback) => {
-            cli.setOnBackgroundModeChange(callback);
+          cli.setOnBackgroundModeChange(callback);
         },
         onToggleBackgroundMode: () => {
-            cli.toggleBackgroundMode();
+          cli.toggleBackgroundMode();
         },
         onBackgroundTaskCountChange: (callback) => {
-            cli.setOnBackgroundTaskCountChange(callback);
+          cli.setOnBackgroundTaskCountChange(callback);
         },
         onSubAgentCountChange: (callback) => {
-            cli.setOnSubAgentCountChange(callback);
+          cli.setOnSubAgentCountChange(callback);
         },
         onSetAutoModeSetup: (callback) => {
-            cli.setOnSetAutoMode(callback);
+          cli.setOnSetAutoMode(callback);
         },
         onCwdChange: (callback) => {
-            cli.setOnCwdChange(callback);
+          cli.setOnCwdChange(callback);
         },
         onModelChange: (callback) => {
-            cli.setOnModelChange(callback);
+          cli.setOnModelChange(callback);
         },
         onSubshellContextChange: (callback) => {
-            cli.setOnSubshellContextChange(callback);
+          cli.setOnSubshellContextChange(callback);
         },
         onPasswordRequest: (callback) => {
-            cli.setOnPasswordRequest(callback);
+          cli.setOnPasswordRequest(callback);
         },
         onShellInput: (input) => {
-            cli.writeToShellStdin(input);
+          cli.writeToShellStdin(input);
         },
         onShellSignal: (signal) => {
-            cli.sendSignalToShell(signal);
+          cli.sendSignalToShell(signal);
         },
         onKillProcess: () => {
-            cli.killCurrentProcess();
+          cli.killCurrentProcess();
         },
         onInteractiveEditorMode: (callback) => {
-            cli.setOnInteractiveEditorMode(callback);
+          cli.setOnInteractiveEditorMode(callback);
         },
         onConnectionStatusUpdate: (callback) => {
-            cli.setOnConnectionStatusUpdate(callback);
+          cli.setOnConnectionStatusUpdate(callback);
         },
         onTokenCountUpdate: (callback) => {
-            cli.setOnTokenCountUpdate(callback);
+          cli.setOnTokenCountUpdate(callback);
         },
         onContextLimitReached: (callback) => {
-            cli.setOnContextLimitReached(callback);
+          cli.setOnContextLimitReached(callback);
         },
         onChatPickerSetup: (callback) => {
-            cli.setOnShowChatPickerCallback(callback);
+          cli.setOnShowChatPickerCallback(callback);
         },
         onChatPickerSelection: (chatId) => {
-            return cli.handleChatPickerSelection(chatId);
+          return cli.handleChatPickerSelection(chatId);
         },
         onChatDeletePickerSetup: (callback) => {
-            cli.setOnShowChatDeletePickerCallback(callback);
+          cli.setOnShowChatDeletePickerCallback(callback);
         },
         onChatDeletePickerSelection: (chatId) => {
-            return cli.handleChatDeleteSelection(chatId);
+          return cli.handleChatDeleteSelection(chatId);
         },
         onChatListSetup: (callback) => {
-            cli.setOnShowChatListCallback(callback);
+          cli.setOnShowChatListCallback(callback);
         },
         onChatRenamePickerSetup: (callback) => {
-            cli.setOnShowChatRenamePickerCallback(callback);
+          cli.setOnShowChatRenamePickerCallback(callback);
         },
         onChatRename: (chatId, newTitle) => {
-            cli.handleChatRename(chatId, newTitle);
+          cli.handleChatRename(chatId, newTitle);
         },
         onRestoreMessagesSetup: (callback) => {
-            cli.setOnRestoreMessagesCallback(callback);
+          cli.setOnRestoreMessagesCallback(callback);
         },
         onUIMessageHistoryUpdate: (messages) => {
-            cli.updateUIMessageHistory(messages);
+          cli.updateUIMessageHistory(messages);
         },
         onBackgroundTaskListSetup: (callback) => {
-            cli.setOnShowBackgroundTaskPickerCallback(callback);
+          cli.setOnShowBackgroundTaskPickerCallback(callback);
         },
         onBackgroundTaskSelection: (taskId) => {
-            cli.handleBackgroundTaskSelection(taskId);
+          cli.handleBackgroundTaskSelection(taskId);
         },
         onBackgroundTaskCancelSetup: (callback) => {
-            cli.setOnShowBackgroundTaskCancelPickerCallback(callback);
+          cli.setOnShowBackgroundTaskCancelPickerCallback(callback);
         },
         onBackgroundTaskCancel: (taskId) => {
-            cli.handleBackgroundTaskCancel(taskId);
+          cli.handleBackgroundTaskCancel(taskId);
         },
         onBackgroundTaskViewSetup: (callback) => {
-            cli.setOnBackgroundTaskViewCallback(callback);
+          cli.setOnBackgroundTaskViewCallback(callback);
         },
         onSessionQuotaUpdate: (callback) => {
-            cli.setOnSessionQuotaUpdate(callback);
+          cli.setOnSessionQuotaUpdate(callback);
         },
         // MCP management callbacks
         onMCPAddScreenSetup: (callback) => {
-            cli.setOnMCPAddScreenSetup(callback);
+          cli.setOnMCPAddScreenSetup(callback);
         },
         onMCPRemoveScreenSetup: (callback) => {
-            cli.setOnMCPRemoveScreenSetup(callback);
+          cli.setOnMCPRemoveScreenSetup(callback);
         },
         onMCPEnableScreenSetup: (callback) => {
-            cli.setOnMCPEnableScreenSetup(callback);
+          cli.setOnMCPEnableScreenSetup(callback);
         },
         onMCPDisableScreenSetup: (callback) => {
-            cli.setOnMCPDisableScreenSetup(callback);
+          cli.setOnMCPDisableScreenSetup(callback);
         },
         onMCPListScreenSetup: (callback) => {
-            cli.setOnMCPListScreenSetup(callback);
+          cli.setOnMCPListScreenSetup(callback);
         },
         onMCPAddServer: (config) => {
-            return cli.mcpAddServer(config);
+          return cli.mcpAddServer(config);
         },
         onMCPRemoveServer: (name) => {
-            cli.mcpRemoveServer(name);
+          cli.mcpRemoveServer(name);
         },
         onMCPEnableServer: (name) => {
-            cli.mcpEnableServer(name);
+          cli.mcpEnableServer(name);
         },
         onMCPDisableServer: (name) => {
-            cli.mcpDisableServer(name);
+          cli.mcpDisableServer(name);
         },
         onMCPValidateConfig: (jsonString) => {
-            return cli.mcpValidateConfig(jsonString);
+          return cli.mcpValidateConfig(jsonString);
         },
         onPromptAnswered: (callback) => {
-            cli.setOnPromptAnswered(callback);
+          cli.setOnPromptAnswered(callback);
         },
         getMainConversation: () => {
-            return cli.getConversationHistory();
+          return cli.getConversationHistory();
         },
         onWarpifySession: (command, type, connectionString) => {
-            return cli.warpifySession(command, type, connectionString);
+          return cli.warpifySession(command, type, connectionString);
         },
         onAiAutoSuggestChange: (callback) => {
-            cli.setOnAiAutoSuggestChange(callback);
+          cli.setOnAiAutoSuggestChange(callback);
         },
         // Workflow callbacks
         onWorkflowCreatorSetup: (callback) => {
-            cli.setOnShowWorkflowCreator(callback);
+          cli.setOnShowWorkflowCreator(callback);
         },
         onWorkflowSave: (name, steps, description) => {
-            cli.saveWorkflow(name, steps, description);
+          cli.saveWorkflow(name, steps, description);
+        },
+        onRulesEditorSetup: (callback) => {
+          cli.setOnShowRulesEditor(callback);
+        },
+        onRuleSave: (name, content, previousName) => {
+          return cli.saveRule(name, content, previousName);
         },
         getCheckpoints: () => {
-            return cli.getCheckpointsForAutocomplete();
+          return cli.getCheckpointsForAutocomplete();
         },
         onRevertToCheckpointSetup: (callback) => {
-            cli.setOnRevertToCheckpoint(callback);
+          cli.setOnRevertToCheckpoint(callback);
         },
         onSetInputSetup: (callback) => {
-            cli.setOnSetInput(callback);
+          cli.setOnSetInput(callback);
         },
         onInterruptQueueUpdate: (callback) => {
-            cli.setOnInterruptQueueUpdate(callback);
+          cli.setOnInterruptQueueUpdate(callback);
         },
         onQueuedMessageDispatched: (callback) => {
-            cli.setOnQueuedMessageDispatched(callback);
+          cli.setOnQueuedMessageDispatched(callback);
+        },
+        onCommandQueueUpdate: (callback) => {
+          cli.setOnCommandQueueUpdate(callback);
+        },
+        onQueuedCommandDispatched: (callback) => {
+          cli.setOnQueuedCommandDispatched(callback);
         }
-    })), {
-        patchConsole: false,
-        exitOnCtrlC: false,
-        debug: false
-    });
-    // Wait for user to exit, with a fallback mechanism
-    // If the React component tree crashes silently or the Ink runtime enters an unexpected state,
-    // waitUntilExit() may never resolve. This fallback ensures we can still exit via signals.
-    const exitPromise = waitUntilExit();
-    const fallbackPromise = new Promise((resolve) => {
-        const signals = ['SIGINT', 'SIGTERM'];
-        // We don't want to immediately exit on the first SIGINT if Ink is healthy 
-        // and processing it to gracefully unmount. We add a short timeout, 
-        // or just rely on the fact that if this resolves first, we exit.
-        const signalHandler = (sig) => {
-            logWarning(`Received ${sig} (Fallback handler triggered)`);
-            // Give Ink a small window to gracefully exit first before we force it
-            setTimeout(() => {
-                resolve();
-            }, 500).unref();
-            signals.forEach(s => process.removeListener(s, signalHandler));
-        };
-        signals.forEach(sig => process.once(sig, signalHandler));
-    });
-    try {
-        await Promise.race([exitPromise, fallbackPromise]);
-    }
-    catch (err) {
-        logError('Ink render error', err);
-    }
-    finally {
-        // Ensure all background processes and timers are terminated
-        process.exit(0);
+      })
+    ),
+    {
+      patchConsole: false,
+      exitOnCtrlC: false,
+      debug: false
     }
+  );
+  const exitPromise = waitUntilExit();
+  const fallbackPromise = new Promise((resolve) => {
+    const signals = ["SIGINT", "SIGTERM"];
+    const signalHandler = (sig) => {
+      logWarning(`Received ${sig} (Fallback handler triggered)`);
+      setTimeout(() => {
+        resolve();
+      }, 500).unref();
+      signals.forEach((s) => process.removeListener(s, signalHandler));
+    };
+    signals.forEach((sig) => process.once(sig, signalHandler));
+  });
+  try {
+    await Promise.race([exitPromise, fallbackPromise]);
+  } catch (err) {
+    logError("Ink render error", err);
+  } finally {
+    process.exit(0);
+  }
 }
 main().catch((error) => {
-    logError('Fatal error in main()', error);
-    process.exit(1);
+  logError("Fatal error in main()", error);
+  process.exit(1);
 });
 //# sourceMappingURL=index.js.map