codex-linux 1.0.0

package/package.json

@@ -0,0 +1,180 @@
+{
+  "name": "codex-linux",
+  "version": "1.0.0",
+  "description": "A Linux port of OpenAI Codex - Multi-agent AI coding command center",
+  "main": "dist/main/main.js",
+  "author": "Codex Linux Team",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "dev": "concurrently \"npm run dev:renderer\" \"npm run dev:main\"",
+    "dev:main": "tsc -p tsconfig.main.json --watch",
+    "dev:renderer": "vite",
+    "build": "npm run build:main && npm run build:renderer",
+    "build:main": "tsc -p tsconfig.main.json --skipLibCheck --noEmit false || true",
+    "build:renderer": "vite build",
+    "package": "electron-builder",
+    "package:linux": "electron-builder --linux",
+    "package:appimage": "electron-builder --linux AppImage",
+    "package:deb": "electron-builder --linux deb",
+    "package:rpm": "electron-builder --linux rpm",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:e2e": "cd tests/e2e && npx playwright test",
+    "test:e2e:ui": "cd tests/e2e && npx playwright test --ui",
+    "test:e2e:report": "cd tests/e2e && npx playwright show-report",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "typecheck": "tsc -p tsconfig.main.json --noEmit",
+    "postinstall": "electron-builder install-app-deps"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.32.0",
+    "@monaco-editor/react": "^4.6.0",
+    "@octokit/rest": "^20.0.2",
+    "@slack/web-api": "^7.14.1",
+    "@supabase/supabase-js": "^2.97.0",
+    "axios": "^1.6.2",
+    "better-sqlite3": "^9.4.0",
+    "chokidar": "^3.5.3",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.0.0",
+    "cors": "^2.8.6",
+    "date-fns": "^3.0.6",
+    "diff": "^5.1.0",
+    "electron-log": "^5.0.1",
+    "electron-store": "^8.1.0",
+    "electron-updater": "^6.1.7",
+    "express": "^4.18.2",
+    "express-rate-limit": "^8.2.1",
+    "fuse.js": "^7.0.0",
+    "glob": "^10.3.10",
+    "helmet": "^8.1.0",
+    "ignore": "^5.3.0",
+    "isomorphic-git": "^1.25.6",
+    "lodash": "^4.17.21",
+    "lucide-react": "^0.303.0",
+    "monaco-editor": "^0.55.1",
+    "mongodb": "^7.1.0",
+    "mysql2": "^3.17.5",
+    "node-cron": "^3.0.3",
+    "node-fetch": "^3.3.2",
+    "openai": "^4.28.0",
+    "pg": "^8.18.0",
+    "playwright": "^1.58.2",
+    "prismjs": "^1.29.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.21.1",
+    "react-virtualized": "^9.22.5",
+    "semver": "^7.5.4",
+    "simple-git": "^3.22.0",
+    "socket.io": "^4.7.4",
+    "socket.io-client": "^4.7.4",
+    "tailwind-merge": "^2.2.0",
+    "tailwindcss-animate": "^1.0.7",
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0",
+    "xterm": "^5.3.0",
+    "xterm-addon-fit": "^0.8.0",
+    "xterm-addon-web-links": "^0.9.0",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4",
+    "zustand": "^4.4.7"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/diff": "^5.0.9",
+    "@types/jest": "^30.0.0",
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^20.10.6",
+    "@types/node-cron": "^3.0.11",
+    "@types/prismjs": "^1.26.3",
+    "@types/react": "^18.2.46",
+    "@types/react-dom": "^18.2.18",
+    "@types/react-virtualized": "^9.21.29",
+    "@types/semver": "^7.5.6",
+    "@types/uuid": "^9.0.7",
+    "@types/ws": "^8.5.10",
+    "@typescript-eslint/eslint-plugin": "^6.16.0",
+    "@typescript-eslint/parser": "^6.16.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "autoprefixer": "^10.4.16",
+    "concurrently": "^8.2.2",
+    "electron": "^28.1.1",
+    "electron-builder": "^24.9.1",
+    "eslint": "^8.56.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.5",
+    "jest": "^29.7.0",
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.4.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.10",
+    "vite-plugin-electron": "^0.28.0",
+    "vite-plugin-electron-renderer": "^0.14.5"
+  },
+  "build": {
+    "appId": "com.codex-linux.app",
+    "productName": "Codex Linux",
+    "directories": {
+      "output": "release"
+    },
+    "files": [
+      "dist/**/*",
+      "assets/**/*",
+      "node_modules/**/*"
+    ],
+    "linux": {
+      "target": [
+        {
+          "target": "AppImage",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "deb",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "rpm",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "tar.gz",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "category": "Development",
+      "icon": "assets/icon.png",
+      "maintainer": "Codex Linux Team",
+      "vendor": "Codex Linux Team",
+      "synopsis": "Multi-agent AI coding command center",
+      "description": "A Linux port of OpenAI Codex featuring parallel agent orchestration, worktrees, skills, and automations"
+    },
+    "deb": {
+      "depends": [
+        "git",
+        "nodejs"
+      ]
+    },
+    "rpm": {
+      "depends": [
+        "git",
+        "nodejs"
+      ]
+    }
+  }
+}

package/packages/cli/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@codex-linux/cli",
+  "version": "1.0.0",
+  "description": "CLI tool for Codex Linux",
+  "main": "dist/index.js",
+  "bin": {
+    "codex": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "test": "jest"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "axios": "^1.6.2",
+    "chalk": "^4.1.2",
+    "inquirer": "^9.2.12",
+    "ora": "^5.4.1",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.6",
+    "@types/ws": "^8.5.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/packages/cli/src/commands/agents.ts

@@ -0,0 +1,199 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import WebSocket from 'ws';
+import { getAPIClient } from '../utils/api';
+
+export const AgentCommands = {
+  list: new Command('list')
+    .description('List all agents')
+    .action(async (options) => {
+      const spinner = ora('Loading agents...').start();
+      
+      try {
+        const api = getAPIClient(options);
+        const response = await api.get('/agents');
+        const agents = response.data;
+        
+        spinner.stop();
+        
+        if (agents.length === 0) {
+          console.log(chalk.yellow('No agents found'));
+          return;
+        }
+        
+        console.log(chalk.bold('\nAgents:'));
+        agents.forEach((agent: any) => {
+          const statusColor = {
+            idle: chalk.gray,
+            running: chalk.green,
+            paused: chalk.yellow,
+            error: chalk.red,
+          }[agent.status] || chalk.white;
+          
+          console.log(`  ${chalk.cyan(agent.id.slice(0, 8))} ${agent.name} ${statusColor(`[${agent.status}]`)}`);
+        });
+      } catch (error) {
+        spinner.fail('Failed to load agents');
+        console.error(chalk.red((error as Error).message));
+      }
+    }),
+
+  create: new Command('create')
+    .description('Create a new agent')
+    .option('-n, --name <name>', 'Agent name')
+    .option('-p, --project <path>', 'Project path')
+    .option('--provider <provider>', 'AI provider', 'openai')
+    .option('--model <model>', 'Model name', 'gpt-4o')
+    .action(async (cmdOptions, program) => {
+      const options = { ...program.opts(), ...cmdOptions };
+      
+      try {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'name',
+            message: 'Agent name:',
+            when: !options.name,
+          },
+          {
+            type: 'input',
+            name: 'projectPath',
+            message: 'Project path:',
+            when: !options.project,
+          },
+        ]);
+        
+        const config = {
+          name: options.name || answers.name,
+          projectPath: options.project || answers.projectPath,
+          providerId: options.provider,
+          model: options.model,
+        };
+        
+        const spinner = ora('Creating agent...').start();
+        const api = getAPIClient(options);
+        const response = await api.post('/agents', config);
+        
+        spinner.succeed('Agent created successfully');
+        console.log(chalk.cyan('Agent ID:'), response.data.id);
+      } catch (error) {
+        console.error(chalk.red('Failed to create agent:'), (error as Error).message);
+      }
+    }),
+
+  get: new Command('get <id>')
+    .description('Get agent details')
+    .action(async (id, options) => {
+      try {
+        const api = getAPIClient(options);
+        const response = await api.get(`/agents/${id}`);
+        const agent = response.data;
+        
+        console.log(chalk.bold('\nAgent Details:'));
+        console.log(`  ID: ${chalk.cyan(agent.id)}`);
+        console.log(`  Name: ${agent.name}`);
+        console.log(`  Status: ${agent.status}`);
+        console.log(`  Model: ${agent.model}`);
+        console.log(`  Project: ${agent.projectPath}`);
+        console.log(`  Messages: ${agent.messages.length}`);
+        console.log(`  Tasks: ${agent.tasks.length}`);
+      } catch (error) {
+        console.error(chalk.red('Failed to get agent:'), (error as Error).message);
+      }
+    }),
+
+  delete: new Command('delete <id>')
+    .description('Delete an agent')
+    .option('-f, --force', 'Force deletion without confirmation')
+    .action(async (id, cmdOptions, program) => {
+      const options = { ...program.opts(), ...cmdOptions };
+      
+      if (!options.force) {
+        const { confirm } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: `Are you sure you want to delete agent ${id}?`,
+          default: false,
+        }]);
+        
+        if (!confirm) {
+          console.log(chalk.yellow('Cancelled'));
+          return;
+        }
+      }
+      
+      try {
+        const spinner = ora('Deleting agent...').start();
+        const api = getAPIClient(options);
+        await api.delete(`/agents/${id}`);
+        
+        spinner.succeed('Agent deleted');
+      } catch (error) {
+        console.error(chalk.red('Failed to delete agent:'), (error as Error).message);
+      }
+    }),
+
+  chat: new Command('chat <id>')
+    .description('Send a message to an agent')
+    .argument('<message>', 'Message to send')
+    .action(async (id, message, options) => {
+      try {
+        const spinner = ora('Sending message...').start();
+        const api = getAPIClient(options);
+        const response = await api.post(`/agents/${id}/messages`, { message });
+        
+        spinner.stop();
+        console.log(chalk.cyan('\nAgent:'));
+        console.log(response.data.content);
+      } catch (error) {
+        console.error(chalk.red('Failed to send message:'), (error as Error).message);
+      }
+    }),
+
+  chatInteractive: async (agentId: string, options: any) => {
+    console.log(chalk.cyan(`Starting chat with agent ${agentId}`));
+    console.log(chalk.gray('Type "exit" to quit\n'));
+    
+    const api = getAPIClient(options);
+    
+    // Connect via WebSocket for real-time updates
+    const ws = new WebSocket(`ws://${options.host}:${options.port}`);
+    
+    ws.on('open', () => {
+      ws.send(JSON.stringify({ type: 'subscribe_agent', agentId }));
+    });
+    
+    ws.on('message', (data) => {
+      const event = JSON.parse(data.toString());
+      if (event.type === 'agent_message') {
+        console.log(chalk.cyan('\nAgent:'), event.data.message.content);
+        process.stdout.write('> ');
+      }
+    });
+    
+    const askQuestion = async () => {
+      const { message } = await inquirer.prompt([{
+        type: 'input',
+        name: 'message',
+        message: '>',
+      }]);
+      
+      if (message.toLowerCase() === 'exit') {
+        ws.close();
+        process.exit(0);
+      }
+      
+      try {
+        await api.post(`/agents/${agentId}/messages`, { message });
+      } catch (error) {
+        console.error(chalk.red('Error:'), (error as Error).message);
+      }
+      
+      askQuestion();
+    };
+    
+    askQuestion();
+  },
+};

package/packages/cli/src/commands/tasks.ts

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getAPIClient } from '../utils/api';
+
+export const TaskCommands = {
+  execute: async (agentId: string, task: string, options: any) => {
+    try {
+      const spinner = ora('Creating task...').start();
+      const api = getAPIClient(options);
+      
+      const response = await api.post(`/agents/${agentId}/tasks`, { task });
+      const taskData = response.data;
+      
+      spinner.succeed(`Task created: ${taskData.id}`);
+      
+      if (options.watch) {
+        console.log(chalk.cyan('\nWatching task progress...'));
+        
+        // Poll for updates
+        const interval = setInterval(async () => {
+          try {
+            const statusRes = await api.get(`/agents/${agentId}`);
+            const taskInfo = statusRes.data.tasks.find((t: any) => t.id === taskData.id);
+            
+            if (taskInfo) {
+              process.stdout.write(`\rProgress: ${taskInfo.progress}%`);
+              
+              if (taskInfo.status === 'completed') {
+                clearInterval(interval);
+                console.log(chalk.green('\n✓ Task completed'));
+                if (taskInfo.result) {
+                  console.log(chalk.cyan('\nResult:'));
+                  console.log(taskInfo.result);
+                }
+              } else if (taskInfo.status === 'failed') {
+                clearInterval(interval);
+                console.log(chalk.red('\n✗ Task failed'));
+                if (taskInfo.error) {
+                  console.log(chalk.red('Error:'), taskInfo.error);
+                }
+              }
+            }
+          } catch (error) {
+            clearInterval(interval);
+            console.error(chalk.red('\nFailed to get task status:'), (error as Error).message);
+          }
+        }, 1000);
+        
+        // Stop after 5 minutes
+        setTimeout(() => {
+          clearInterval(interval);
+          console.log(chalk.yellow('\nTimeout: Stopping progress monitoring'));
+        }, 5 * 60 * 1000);
+      } else {
+        console.log(chalk.gray('Use --watch to monitor progress'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to execute task:'), (error as Error).message);
+    }
+  },
+};

package/packages/cli/src/index.ts

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { AgentCommands } from './commands/agents';
+import { TaskCommands } from './commands/tasks';
+import { ConfigCommands } from './commands/config';
+
+const program = new Command();
+
+program
+  .name('codex')
+  .description('CLI tool for Codex Linux - Multi-agent AI coding command center')
+  .version('1.0.0');
+
+// Global options
+program
+  .option('-h, --host <host>', 'API host', 'localhost')
+  .option('-p, --port <port>', 'API port', '3001')
+  .option('-k, --api-key <key>', 'API key')
+  .option('-v, --verbose', 'Enable verbose logging');
+
+// Agent commands
+program
+  .command('agents')
+  .description('Manage agents')
+  .addCommand(AgentCommands.list)
+  .addCommand(AgentCommands.create)
+  .addCommand(AgentCommands.get)
+  .addCommand(AgentCommands.delete)
+  .addCommand(AgentCommands.chat);
+
+// Task commands
+program
+  .command('task')
+  .description('Execute tasks')
+  .argument('<agent-id>', 'Agent ID')
+  .argument('<task>', 'Task description')
+  .option('-w, --watch', 'Watch task progress')
+  .action(TaskCommands.execute);
+
+// Config commands
+program
+  .command('config')
+  .description('Manage configuration')
+  .addCommand(ConfigCommands.set)
+  .addCommand(ConfigCommands.get)
+  .addCommand(ConfigCommands.list);
+
+// Quick commands
+program
+  .command('chat <agent-id>')
+  .description('Start interactive chat with agent')
+  .action(async (agentId, options) => {
+    await AgentCommands.chatInteractive(agentId, options);
+  });
+
+program
+  .command('status')
+  .description('Check server status')
+  .action(async (options) => {
+    try {
+      const { getAPIClient } = await import('./utils/api');
+      const api = getAPIClient(options);
+      const response = await api.get('/health');
+      
+      if (response.data.status === 'ok') {
+        console.log(chalk.green('✓'), 'Server is running');
+        console.log(chalk.gray('  Timestamp:'), response.data.timestamp);
+      } else {
+        console.log(chalk.red('✗'), 'Server returned unexpected status');
+      }
+    } catch (error) {
+      console.log(chalk.red('✗'), 'Cannot connect to server');
+      console.log(chalk.gray('  Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// Error handling
+program.configureOutput({
+  writeErr: (str) => process.stderr.write(chalk.red(str)),
+});
+
+program.exitOverride();
+
+try {
+  program.parse();
+} catch (err) {
+  // Commander handles errors internally
+}

package/packages/cli/src/utils/api.ts

@@ -0,0 +1,45 @@
+import axios, { AxiosInstance } from 'axios';
+import { getConfig } from './config';
+
+export function getAPIClient(options: any): AxiosInstance {
+  const config = getConfig();
+  
+  const client = axios.create({
+    baseURL: `http://${options.host || config.host || 'localhost'}:${options.port || config.port || '3001'}`,
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': options.apiKey || config.apiKey,
+    },
+    timeout: 30000,
+  });
+
+  // Add response interceptor for error handling
+  client.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (error.code === 'ECONNREFUSED') {
+        throw new Error('Cannot connect to Codex Linux server. Is it running?');
+      }
+      
+      if (error.response?.status === 401) {
+        throw new Error('Invalid API key');
+      }
+      
+      if (error.response?.data?.error) {
+        throw new Error(error.response.data.error);
+      }
+      
+      throw error;
+    }
+  );
+
+  // Add request interceptor for logging
+  if (options.verbose) {
+    client.interceptors.request.use((request) => {
+      console.log(`[API] ${request.method?.toUpperCase()} ${request.url}`);
+      return request;
+    });
+  }
+
+  return client;
+}

package/packages/cli/src/utils/config.ts

@@ -0,0 +1,61 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'codex');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'cli-config.json');
+
+interface CLIConfig {
+  host?: string;
+  port?: number;
+  apiKey?: string;
+  defaultAgent?: string;
+  defaultProject?: string;
+}
+
+export function getConfig(): CLIConfig {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+  } catch {
+    // Ignore errors
+  }
+  return {};
+}
+
+export function saveConfig(config: CLIConfig): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export const ConfigCommands = {
+  set: new Command('set <key> <value>')
+    .description('Set configuration value')
+    .action((key, value) => {
+      const config = getConfig();
+      (config as any)[key] = value;
+      saveConfig(config);
+      console.log(`Set ${key} = ${value}`);
+    }),
+
+  get: new Command('get <key>')
+    .description('Get configuration value')
+    .action((key) => {
+      const config = getConfig();
+      const value = (config as any)[key];
+      console.log(value || '(not set)');
+    }),
+
+  list: new Command('list')
+    .description('List all configuration')
+    .action(() => {
+      const config = getConfig();
+      console.log(JSON.stringify(config, null, 2));
+    }),
+};
+
+import { Command } from 'commander';