@nils.del/supergrok 1.0.0

package/src/index.ts

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import * as dotenv from 'dotenv';
+import chalk from 'chalk';
+import { GrokAgent } from './agent/index.js';
+import { runReadlineUI } from './ui/readline-ui.js';
+import { getApiKey, getBaseURL, getCurrentModel, saveUserSettings, loadUserSettings } from './utils/settings.js';
+
+// Load environment variables
+dotenv.config();
+
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('Uncaught exception:'), error.message);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason: any) => {
+  console.error(chalk.red('Unhandled rejection:'), reason?.message || reason);
+  process.exit(1);
+});
+
+// Headless mode processing
+async function processPromptHeadless(
+  prompt: string,
+  apiKey: string,
+  baseURL?: string,
+  model?: string,
+  maxToolRounds?: number
+): Promise<void> {
+  try {
+    const agent = new GrokAgent(apiKey, baseURL, model, maxToolRounds);
+
+    console.log(chalk.gray('Processing...'));
+    console.log();
+
+    for await (const chunk of agent.processUserMessageStream(prompt)) {
+      switch (chunk.type) {
+        case 'content':
+          if (chunk.content) {
+            process.stdout.write(chunk.content);
+          }
+          break;
+
+        case 'tool_calls':
+          if (chunk.toolCalls) {
+            console.log();
+            for (const tc of chunk.toolCalls) {
+              console.log(chalk.blue(`⚡ ${tc.function.name}`));
+            }
+          }
+          break;
+
+        case 'tool_result':
+          if (chunk.toolResult) {
+            if (chunk.toolResult.success) {
+              console.log(chalk.green('✓'), chalk.gray(chunk.toolResult.output?.substring(0, 200) || 'Success'));
+            } else {
+              console.log(chalk.red('✗'), chunk.toolResult.error);
+            }
+          }
+          break;
+
+        case 'done':
+          console.log();
+          break;
+      }
+    }
+
+    await agent.shutdown();
+  } catch (error: any) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+program
+  .name('grok-fixed')
+  .description('Grok CLI (Fixed Edition) - Works properly with MCP on Linux. No Ink flickering issues.')
+  .version('1.0.0')
+  .argument('[message...]', 'Initial message to send to Grok')
+  .option('-d, --directory <dir>', 'Set working directory', process.cwd())
+  .option('-k, --api-key <key>', 'Grok API key (or set GROK_API_KEY env var)')
+  .option('-u, --base-url <url>', 'Grok API base URL (or set GROK_BASE_URL env var)')
+  .option('-m, --model <model>', 'AI model to use (or set GROK_MODEL env var)')
+  .option('-p, --prompt <prompt>', 'Process a single prompt and exit (headless mode)')
+  .option('--max-tool-rounds <rounds>', 'Maximum tool execution rounds (default: 400)', '400')
+  .action(async (message, options) => {
+    // Change working directory if specified
+    if (options.directory) {
+      try {
+        process.chdir(options.directory);
+      } catch (error: any) {
+        console.error(chalk.red(`Error changing directory: ${error.message}`));
+        process.exit(1);
+      }
+    }
+
+    try {
+      // Get API key
+      const apiKey = options.apiKey || getApiKey();
+      const baseURL = options.baseUrl || getBaseURL();
+      const model = options.model || getCurrentModel();
+      const maxToolRounds = parseInt(options.maxToolRounds) || 400;
+
+      if (!apiKey) {
+        console.error(chalk.red('Error: API key required.'));
+        console.error(chalk.gray('Set GROK_API_KEY environment variable, use --api-key flag,'));
+        console.error(chalk.gray('or add "apiKey" to ~/.grok/user-settings.json'));
+        process.exit(1);
+      }
+
+      // Save API key if provided via command line
+      if (options.apiKey) {
+        const settings = loadUserSettings();
+        settings.apiKey = options.apiKey;
+        if (options.baseUrl) {
+          settings.baseURL = options.baseUrl;
+        }
+        saveUserSettings(settings);
+        console.log(chalk.green('✓ API key saved to ~/.grok/user-settings.json'));
+      }
+
+      // Headless mode
+      if (options.prompt) {
+        await processPromptHeadless(options.prompt, apiKey, baseURL, model, maxToolRounds);
+        return;
+      }
+
+      // Interactive mode
+      const agent = new GrokAgent(apiKey, baseURL, model, maxToolRounds);
+      const initialMessage = Array.isArray(message) ? message.join(' ') : message;
+
+      await runReadlineUI(agent, initialMessage || undefined);
+    } catch (error: any) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// MCP subcommand
+const mcpCommand = program
+  .command('mcp')
+  .description('Manage MCP (Model Context Protocol) servers');
+
+mcpCommand
+  .command('list')
+  .description('List configured MCP servers')
+  .action(async () => {
+    const { loadMCPConfig } = await import('./mcp/config.js');
+    const config = loadMCPConfig();
+
+    if (config.servers.length === 0) {
+      console.log(chalk.gray('No MCP servers configured.'));
+      console.log(chalk.gray('Use "grok-fixed mcp add" to add a server.'));
+      return;
+    }
+
+    console.log(chalk.cyan('Configured MCP Servers:'));
+    for (const server of config.servers) {
+      console.log(chalk.white(`  • ${server.name}`));
+      console.log(chalk.gray(`    Transport: ${server.transport.type}`));
+      if (server.transport.type === 'stdio') {
+        console.log(chalk.gray(`    Command: ${server.transport.command} ${(server.transport.args || []).join(' ')}`));
+      } else if ('url' in server.transport) {
+        console.log(chalk.gray(`    URL: ${server.transport.url}`));
+      }
+    }
+  });
+
+mcpCommand
+  .command('add <name>')
+  .description('Add a new MCP server')
+  .option('-t, --transport <type>', 'Transport type (stdio, http, sse)', 'stdio')
+  .option('-c, --command <command>', 'Command to run (for stdio transport)')
+  .option('-a, --args <args...>', 'Arguments for the command')
+  .option('-u, --url <url>', 'URL (for http/sse transport)')
+  .option('-e, --env <env...>', 'Environment variables (KEY=value format)')
+  .action(async (name, options) => {
+    const { saveMCPServerConfig } = await import('./mcp/config.js');
+
+    let transport: any;
+
+    if (options.transport === 'stdio') {
+      if (!options.command) {
+        console.error(chalk.red('Error: --command is required for stdio transport'));
+        process.exit(1);
+      }
+
+      const env: Record<string, string> = {};
+      if (options.env) {
+        for (const e of options.env) {
+          const [key, ...valueParts] = e.split('=');
+          env[key] = valueParts.join('=');
+        }
+      }
+
+      transport = {
+        type: 'stdio',
+        command: options.command,
+        args: options.args || [],
+        env
+      };
+    } else if (options.transport === 'http' || options.transport === 'sse') {
+      if (!options.url) {
+        console.error(chalk.red(`Error: --url is required for ${options.transport} transport`));
+        process.exit(1);
+      }
+
+      transport = {
+        type: options.transport,
+        url: options.url
+      };
+    } else {
+      console.error(chalk.red(`Error: Unknown transport type: ${options.transport}`));
+      process.exit(1);
+    }
+
+    try {
+      saveMCPServerConfig({ name, transport });
+      console.log(chalk.green(`✓ MCP server "${name}" added successfully`));
+    } catch (error: any) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+mcpCommand
+  .command('remove <name>')
+  .description('Remove an MCP server')
+  .action(async (name) => {
+    const { removeMCPServerConfig } = await import('./mcp/config.js');
+
+    if (removeMCPServerConfig(name)) {
+      console.log(chalk.green(`✓ MCP server "${name}" removed`));
+    } else {
+      console.log(chalk.yellow(`Server "${name}" not found`));
+    }
+  });
+
+mcpCommand
+  .command('test [name]')
+  .description('Test connection to MCP server(s)')
+  .action(async (name) => {
+    const { loadMCPConfig } = await import('./mcp/config.js');
+    const { getMCPManager } = await import('./mcp/client.js');
+
+    const config = loadMCPConfig();
+    const serversToTest = name
+      ? config.servers.filter(s => s.name === name)
+      : config.servers;
+
+    if (serversToTest.length === 0) {
+      console.log(chalk.yellow('No servers to test.'));
+      return;
+    }
+
+    const mcpManager = getMCPManager();
+
+    for (const server of serversToTest) {
+      process.stdout.write(chalk.gray(`Testing ${server.name}... `));
+
+      try {
+        await mcpManager.addServer(server);
+        const tools = mcpManager.getTools().filter(t => t.serverName === server.name);
+        console.log(chalk.green(`✓ Connected (${tools.length} tools)`));
+      } catch (error: any) {
+        console.log(chalk.red(`✗ Failed: ${error.message}`));
+      }
+    }
+
+    await mcpManager.shutdown();
+  });
+
+program.parse();

package/src/mcp/client.ts

@@ -0,0 +1,178 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { EventEmitter } from "events";
+import { createTransport, MCPTransport, TransportType, TransportConfig } from "./transports.js";
+
+export interface MCPServerConfig {
+  name: string;
+  transport: TransportConfig;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: any;
+  serverName: string;
+}
+
+export class MCPManager extends EventEmitter {
+  private clients: Map<string, Client> = new Map();
+  private transports: Map<string, MCPTransport> = new Map();
+  private tools: Map<string, MCPTool> = new Map();
+  private initPromise: Promise<void> | null = null;
+
+  async addServer(config: MCPServerConfig): Promise<void> {
+    try {
+      let transportConfig = config.transport;
+      if (!transportConfig && config.command) {
+        transportConfig = {
+          type: 'stdio',
+          command: config.command,
+          args: config.args,
+          env: config.env
+        };
+      }
+
+      if (!transportConfig) {
+        throw new Error('Transport configuration is required');
+      }
+
+      const transport = createTransport(transportConfig);
+      this.transports.set(config.name, transport);
+
+      const client = new Client({
+        name: "grok-cli-fixed",
+        version: "1.0.0"
+      });
+
+      this.clients.set(config.name, client);
+
+      const sdkTransport = await transport.connect();
+      await client.connect(sdkTransport);
+
+      const toolsResult = await client.listTools();
+
+      for (const tool of toolsResult.tools) {
+        const mcpTool: MCPTool = {
+          name: `mcp__${config.name}__${tool.name}`,
+          description: tool.description || `Tool from ${config.name} server`,
+          inputSchema: tool.inputSchema,
+          serverName: config.name
+        };
+        this.tools.set(mcpTool.name, mcpTool);
+      }
+
+      this.emit('serverAdded', config.name, toolsResult.tools.length);
+    } catch (error) {
+      this.emit('serverError', config.name, error);
+      throw error;
+    }
+  }
+
+  async removeServer(serverName: string): Promise<void> {
+    for (const [toolName, tool] of this.tools.entries()) {
+      if (tool.serverName === serverName) {
+        this.tools.delete(toolName);
+      }
+    }
+
+    const client = this.clients.get(serverName);
+    if (client) {
+      await client.close();
+      this.clients.delete(serverName);
+    }
+
+    const transport = this.transports.get(serverName);
+    if (transport) {
+      await transport.disconnect();
+      this.transports.delete(serverName);
+    }
+
+    this.emit('serverRemoved', serverName);
+  }
+
+  async callTool(toolName: string, arguments_: any): Promise<CallToolResult> {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      throw new Error(`Tool ${toolName} not found`);
+    }
+
+    const client = this.clients.get(tool.serverName);
+    if (!client) {
+      throw new Error(`Server ${tool.serverName} not connected`);
+    }
+
+    const originalToolName = toolName.replace(`mcp__${tool.serverName}__`, '');
+
+    const result = await client.callTool({
+      name: originalToolName,
+      arguments: arguments_
+    });
+
+    // Ensure result has proper content structure
+    return {
+      content: result.content || [],
+      isError: result.isError,
+      _meta: result._meta
+    } as CallToolResult;
+  }
+
+  getTools(): MCPTool[] {
+    return Array.from(this.tools.values());
+  }
+
+  getServers(): string[] {
+    return Array.from(this.clients.keys());
+  }
+
+  async shutdown(): Promise<void> {
+    const serverNames = Array.from(this.clients.keys());
+    await Promise.all(serverNames.map(name => this.removeServer(name)));
+  }
+
+  getTransportType(serverName: string): TransportType | undefined {
+    const transport = this.transports.get(serverName);
+    return transport?.getType();
+  }
+
+  async ensureServersInitialized(): Promise<void> {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+
+    if (this.clients.size > 0) {
+      return;
+    }
+
+    this.initPromise = this.initializeServers();
+    return this.initPromise;
+  }
+
+  private async initializeServers(): Promise<void> {
+    const { loadMCPConfig } = await import('./config.js');
+    const config = loadMCPConfig();
+
+    const initPromises = config.servers.map(async (serverConfig) => {
+      try {
+        await this.addServer(serverConfig);
+      } catch (error) {
+        // Silently fail for individual servers
+      }
+    });
+
+    await Promise.all(initPromises);
+  }
+}
+
+// Singleton instance
+let mcpManager: MCPManager | null = null;
+
+export function getMCPManager(): MCPManager {
+  if (!mcpManager) {
+    mcpManager = new MCPManager();
+  }
+  return mcpManager;
+}

package/src/mcp/config.ts

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import type { TransportConfig } from './transports.js';
+
+export interface MCPServerConfig {
+  name: string;
+  transport: TransportConfig;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface MCPConfig {
+  servers: MCPServerConfig[];
+}
+
+function getProjectSettingsPath(): string {
+  return path.join(process.cwd(), '.grok', 'settings.json');
+}
+
+function getUserSettingsPath(): string {
+  return path.join(os.homedir(), '.grok', 'user-settings.json');
+}
+
+export function loadMCPConfig(): MCPConfig {
+  const config: MCPConfig = { servers: [] };
+
+  // Try loading project-level settings first
+  const projectSettingsPath = getProjectSettingsPath();
+  if (fs.existsSync(projectSettingsPath)) {
+    try {
+      const projectSettings = JSON.parse(fs.readFileSync(projectSettingsPath, 'utf-8'));
+      if (projectSettings.mcpServers) {
+        for (const [name, serverConfig] of Object.entries(projectSettings.mcpServers)) {
+          const server = serverConfig as any;
+          config.servers.push({
+            name,
+            transport: server.transport || {
+              type: 'stdio',
+              command: server.command,
+              args: server.args,
+              env: server.env
+            },
+            command: server.command,
+            args: server.args,
+            env: server.env
+          });
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to parse project MCP settings:', error);
+    }
+  }
+
+  // Also check user-level settings for global MCP servers
+  const userSettingsPath = getUserSettingsPath();
+  if (fs.existsSync(userSettingsPath)) {
+    try {
+      const userSettings = JSON.parse(fs.readFileSync(userSettingsPath, 'utf-8'));
+      if (userSettings.mcpServers) {
+        for (const [name, serverConfig] of Object.entries(userSettings.mcpServers)) {
+          // Don't duplicate if already defined in project settings
+          if (!config.servers.find(s => s.name === name)) {
+            const server = serverConfig as any;
+            config.servers.push({
+              name,
+              transport: server.transport || {
+                type: 'stdio',
+                command: server.command,
+                args: server.args,
+                env: server.env
+              },
+              command: server.command,
+              args: server.args,
+              env: server.env
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to parse user MCP settings:', error);
+    }
+  }
+
+  return config;
+}
+
+export function saveMCPServerConfig(serverConfig: MCPServerConfig): void {
+  const settingsPath = getProjectSettingsPath();
+  const settingsDir = path.dirname(settingsPath);
+
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+
+  let settings: any = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    } catch (error) {
+      // Start fresh if parsing fails
+    }
+  }
+
+  if (!settings.mcpServers) {
+    settings.mcpServers = {};
+  }
+
+  // Save the server configuration
+  const serverData: any = {
+    name: serverConfig.name,
+    transport: serverConfig.transport.type
+  };
+
+  if (serverConfig.transport.type === 'stdio') {
+    serverData.command = serverConfig.transport.command;
+    serverData.args = serverConfig.transport.args;
+    serverData.env = serverConfig.transport.env;
+  } else if (serverConfig.transport.type === 'http' || serverConfig.transport.type === 'sse') {
+    serverData.url = (serverConfig.transport as any).url;
+  }
+
+  settings.mcpServers[serverConfig.name] = serverData;
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+export function removeMCPServerConfig(serverName: string): boolean {
+  const settingsPath = getProjectSettingsPath();
+
+  if (!fs.existsSync(settingsPath)) {
+    return false;
+  }
+
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+
+    if (!settings.mcpServers || !settings.mcpServers[serverName]) {
+      return false;
+    }
+
+    delete settings.mcpServers[serverName];
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    return true;
+  } catch (error) {
+    return false;
+  }
+}