codex-linux 1.0.0

package/packages/npm-installer/bin/codex-linux

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+/**
+ * Codex Linux Launcher
+ * Launches the AppImage after ensuring it's downloaded
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const APP_NAME = 'Codex Linux';
+const BINARY_NAME = 'codex-linux';
+const REPO = 'ranker-org/codex-linux-app';
+
+function getArch() {
+    const arch = process.arch;
+    switch (arch) {
+        case 'x64': return 'x64';
+        case 'arm64': return 'arm64';
+        default:
+            console.error(`Unsupported architecture: ${arch}`);
+            process.exit(1);
+    }
+}
+
+function getAppImagePath() {
+    const installDir = path.join(os.homedir(), '.local', 'bin');
+    return path.join(installDir, `${BINARY_NAME}.AppImage`);
+}
+
+function checkAppImageExists() {
+    const appImagePath = getAppImagePath();
+    return fs.existsSync(appImagePath);
+}
+
+function launchAppImage(args) {
+    const appImagePath = getAppImagePath();
+
+    if (!fs.existsSync(appImagePath)) {
+        console.error(`${APP_NAME} is not installed.`);
+        console.error('Run: npm install -g codex-linux');
+        process.exit(1);
+    }
+
+    // Launch the AppImage
+    const child = spawn(appImagePath, args, {
+        detached: true,
+        stdio: 'ignore'
+    });
+
+    child.unref();
+    console.log(`${APP_NAME} launched!`);
+}
+
+function showHelp() {
+    console.log(`${APP_NAME} - Multi-agent AI coding command center`);
+    console.log('');
+    console.log('Usage: codex-linux [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --version    Show version');
+    console.log('  --help       Show this help');
+    console.log('  --update     Update to latest version');
+    console.log('  --uninstall  Remove Codex Linux');
+    console.log('');
+    console.log('For more info: https://github.com/' + REPO);
+}
+
+function showVersion() {
+    const pkgPath = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    console.log(`${APP_NAME} v${pkg.version}`);
+}
+
+function main() {
+    const args = process.argv.slice(2);
+
+    if (args.includes('--help') || args.includes('-h')) {
+        showHelp();
+        return;
+    }
+
+    if (args.includes('--version') || args.includes('-v')) {
+        showVersion();
+        return;
+    }
+
+    if (args.includes('--uninstall')) {
+        const uninstallScript = path.join(os.homedir(), '.local', 'bin', 'uninstall-codex-linux.sh');
+        if (fs.existsSync(uninstallScript)) {
+            spawn('bash', [uninstallScript], { stdio: 'inherit' });
+        } else {
+            console.error('Uninstall script not found. Run manually:');
+            console.error('rm ~/.local/bin/codex-linux ~/.local/bin/codex-linux.AppImage');
+        }
+        return;
+    }
+
+    if (args.includes('--update')) {
+        console.log('Updating Codex Linux...');
+        const downloadScript = path.join(__dirname, '..', 'lib', 'download.js');
+        spawn('node', [downloadScript, '--force'], { stdio: 'inherit' });
+        return;
+    }
+
+    if (!checkAppImageExists()) {
+        console.error(`${APP_NAME} AppImage not found.`);
+        console.error('Running post-install download...');
+        const downloadScript = path.join(__dirname, '..', 'lib', 'download.js');
+        spawn('node', [downloadScript], { stdio: 'inherit' }).on('close', (code) => {
+            if (code === 0) {
+                launchAppImage(args);
+            } else {
+                console.error('Download failed. Please check your internet connection.');
+                process.exit(1);
+            }
+        });
+        return;
+    }
+
+    launchAppImage(args);
+}
+
+main();

package/packages/npm-installer/lib/download.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+
+/**
+ * Download script for Codex Linux NPM package
+ * Downloads the latest AppImage from GitHub releases
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const REPO = 'ranker-org/codex-linux-app';
+const APP_NAME = 'Codex Linux';
+const BINARY_NAME = 'codex-linux';
+
+// Colors for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    blue: '\x1b[34m'
+};
+
+function log(message) {
+    console.log(message);
+}
+
+function success(message) {
+    console.log(`${colors.green}✓${colors.reset} ${message}`);
+}
+
+function info(message) {
+    console.log(`${colors.blue}→${colors.reset} ${message}`);
+}
+
+function warn(message) {
+    console.log(`${colors.yellow}⚠${colors.reset} ${message}`);
+}
+
+function error(message) {
+    console.error(`${colors.red}✗${colors.reset} ${message}`);
+}
+
+function getArch() {
+    const arch = process.arch;
+    switch (arch) {
+        case 'x64': return 'x64';
+        case 'arm64': return 'arm64';
+        default:
+            error(`Unsupported architecture: ${arch}`);
+            process.exit(1);
+    }
+}
+
+function getPlatform() {
+    if (process.platform !== 'linux') {
+        error(`${APP_NAME} is only available for Linux`);
+        error(`Your platform: ${process.platform}`);
+        process.exit(1);
+    }
+    return 'linux';
+}
+
+async function fetchLatestVersion() {
+    const apiUrl = `https://api.github.com/repos/${REPO}/releases/latest`;
+
+    return new Promise((resolve, reject) => {
+        const req = https.get(apiUrl, {
+            headers: {
+                'User-Agent': 'CodexLinux-Installer'
+            }
+        }, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                // Follow redirect
+                const newUrl = res.headers.location;
+                https.get(newUrl, { headers: { 'User-Agent': 'CodexLinux-Installer' } }, (res2) => {
+                    handleResponse(res2, resolve, reject);
+                }).on('error', reject);
+            } else {
+                handleResponse(res, resolve, reject);
+            }
+        });
+
+        req.on('error', (err) => {
+            reject(new Error(`Failed to fetch version: ${err.message}`));
+        });
+
+        req.setTimeout(10000, () => {
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+    });
+}
+
+function handleResponse(res, resolve, reject) {
+    let data = '';
+    res.on('data', chunk => data += chunk);
+    res.on('end', () => {
+        try {
+            const json = JSON.parse(data);
+            if (json.tag_name) {
+                resolve(json.tag_name);
+            } else {
+                reject(new Error('Invalid response from GitHub API'));
+            }
+        } catch (err) {
+            reject(new Error(`Failed to parse response: ${err.message}`));
+        }
+    });
+    res.on('error', reject);
+}
+
+function downloadFile(url, dest, onProgress) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        let downloaded = 0;
+        let total = 0;
+
+        https.get(url, { headers: { 'User-Agent': 'CodexLinux-Installer' } }, (response) => {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                // Follow redirect
+                file.close();
+                fs.unlinkSync(dest);
+                downloadFile(response.headers.location, dest, onProgress)
+                    .then(resolve)
+                    .catch(reject);
+                return;
+            }
+
+            if (response.statusCode !== 200) {
+                file.close();
+                fs.unlinkSync(dest);
+                reject(new Error(`HTTP ${response.statusCode}`));
+                return;
+            }
+
+            total = parseInt(response.headers['content-length'], 10);
+
+            response.on('data', (chunk) => {
+                downloaded += chunk.length;
+                if (onProgress && total) {
+                    const percent = Math.round((downloaded / total) * 100);
+                    onProgress(percent, downloaded, total);
+                }
+            });
+
+            response.pipe(file);
+
+            file.on('finish', () => {
+                file.close(resolve);
+            });
+        }).on('error', (err) => {
+            fs.unlinkSync(dest);
+            reject(err);
+        });
+    });
+}
+
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+async function main() {
+    const forceDownload = process.argv.includes('--force');
+
+    log('');
+    log(`${colors.blue}╔══════════════════════════════════════╗${colors.reset}`);
+    log(`${colors.blue}║${colors.reset}      ${APP_NAME} Installer      ${colors.blue}║${colors.reset}`);
+    log(`${colors.blue}╚══════════════════════════════════════╝${colors.reset}`);
+    log('');
+
+    // Check platform
+    getPlatform();
+
+    const installDir = path.join(os.homedir(), '.local', 'bin');
+    const appImagePath = path.join(installDir, `${BINARY_NAME}.AppImage`);
+    const versionFile = path.join(installDir, `.${BINARY_NAME}-version`);
+
+    // Check if already installed
+    if (!forceDownload && fs.existsSync(appImagePath)) {
+        let currentVersion = '';
+        if (fs.existsSync(versionFile)) {
+            currentVersion = fs.readFileSync(versionFile, 'utf8').trim();
+        }
+
+        if (currentVersion) {
+            info(`Already installed: ${currentVersion}`);
+            info('Use --force to reinstall or npm update -g codex-linux');
+            return;
+        }
+    }
+
+    // Get latest version
+    info('Fetching latest version...');
+    let version;
+    try {
+        version = await fetchLatestVersion();
+        info(`Latest version: ${version}`);
+    } catch (err) {
+        error(`Failed to fetch version: ${err.message}`);
+        warn('Using fallback version v1.0.0');
+        version = 'v1.0.0';
+    }
+
+    const arch = getArch();
+    const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/Codex-Linux-${version}-${arch}.AppImage`;
+
+    // Create install directory
+    if (!fs.existsSync(installDir)) {
+        fs.mkdirSync(installDir, { recursive: true });
+    }
+
+    // Download
+    const tempPath = `${appImagePath}.tmp`;
+
+    info(`Downloading ${APP_NAME} ${version} (${arch})...`);
+    info(`URL: ${downloadUrl}`);
+
+    let lastPercent = -1;
+    try {
+        await downloadFile(downloadUrl, tempPath, (percent, downloaded, total) => {
+            if (percent !== lastPercent) {
+                process.stdout.write(`\r${colors.blue}→${colors.reset} Progress: ${percent}% (${formatBytes(downloaded)}/${formatBytes(total)})`);
+                lastPercent = percent;
+            }
+        });
+        process.stdout.write('\n');
+    } catch (err) {
+        error(`Download failed: ${err.message}`);
+        process.exit(1);
+    }
+
+    // Move to final location
+    fs.renameSync(tempPath, appImagePath);
+    fs.chmodSync(appImagePath, 0o755);
+
+    // Save version
+    fs.writeFileSync(versionFile, version);
+
+    // Create symlink
+    const symlinkPath = path.join(installDir, BINARY_NAME);
+    if (fs.existsSync(symlinkPath)) {
+        fs.unlinkSync(symlinkPath);
+    }
+    fs.symlinkSync(appImagePath, symlinkPath);
+
+    success(`Installed ${APP_NAME} ${version}`);
+    success(`Location: ${appImagePath}`);
+
+    // Check if in PATH
+    const envPath = process.env.PATH || '';
+    if (!envPath.includes(installDir)) {
+        warn(`${installDir} is not in your PATH`);
+        info('Add to your shell profile:');
+        log(`  export PATH="${installDir}:$PATH"`);
+    }
+
+    log('');
+    log(`${colors.green}${APP_NAME} is ready!${colors.reset}`);
+    log(`Run: ${colors.yellow}codex-linux${colors.reset}`);
+    log('');
+}
+
+main().catch(err => {
+    error(`Unexpected error: ${err.message}`);
+    process.exit(1);
+});

package/packages/npm-installer/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "codex-linux",
+  "version": "1.0.0",
+  "description": "Multi-agent AI coding command center for Linux",
+  "main": "./lib/download.js",
+  "bin": {
+    "codex-linux": "./bin/codex-linux"
+  },
+  "scripts": {
+    "postinstall": "node lib/download.js",
+    "test": "echo \"No tests\" && exit 0"
+  },
+  "keywords": [
+    "codex",
+    "ai",
+    "coding",
+    "agent",
+    "electron",
+    "linux"
+  ],
+  "author": "Codex Linux Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ranker-org/codex-linux-app.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ranker-org/codex-linux-app/issues"
+  },
+  "homepage": "https://github.com/ranker-org/codex-linux-app#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {}
+}

package/packages/vscode-extension/package.json

@@ -0,0 +1,167 @@
+{
+  "name": "codex-linux",
+  "displayName": "Codex Linux",
+  "description": "VS Code extension for Codex Linux - Multi-agent AI coding",
+  "version": "1.0.0",
+  "publisher": "codex-linux",
+  "engines": {
+    "vscode": "^1.74.0"
+  },
+  "categories": [
+    "Machine Learning",
+    "Programming Languages",
+    "Snippets"
+  ],
+  "keywords": [
+    "ai",
+    "codex",
+    "chatgpt",
+    "claude",
+    "code generation"
+  ],
+  "activationEvents": [
+    "onCommand:codex.start",
+    "onView:codex.agents"
+  ],
+  "main": "./out/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "codex.start",
+        "title": "Start Codex",
+        "category": "Codex"
+      },
+      {
+        "command": "codex.chat",
+        "title": "Chat with Agent",
+        "category": "Codex"
+      },
+      {
+        "command": "codex.explain",
+        "title": "Explain Code",
+        "category": "Codex"
+      },
+      {
+        "command": "codex.refactor",
+        "title": "Refactor Code",
+        "category": "Codex"
+      },
+      {
+        "command": "codex.test",
+        "title": "Generate Tests",
+        "category": "Codex"
+      },
+      {
+        "command": "codex.createAgent",
+        "title": "Create Agent",
+        "category": "Codex"
+      },
+      {
+        "command": "codex.refreshAgents",
+        "title": "Refresh Agents",
+        "category": "Codex",
+        "icon": "$(refresh)"
+      }
+    ],
+    "views": {
+      "explorer": [
+        {
+          "id": "codex.agents",
+          "name": "Codex Agents",
+          "when": "codex.enabled"
+        }
+      ]
+    },
+    "menus": {
+      "commandPalette": [
+        {
+          "command": "codex.start"
+        },
+        {
+          "command": "codex.chat"
+        },
+        {
+          "command": "codex.createAgent"
+        }
+      ],
+      "editor/context": [
+        {
+          "command": "codex.explain",
+          "group": "codex@1",
+          "when": "editorHasSelection"
+        },
+        {
+          "command": "codex.refactor",
+          "group": "codex@2",
+          "when": "editorHasSelection"
+        },
+        {
+          "command": "codex.test",
+          "group": "codex@3"
+        }
+      ],
+      "view/title": [
+        {
+          "command": "codex.refreshAgents",
+          "when": "view == codex.agents",
+          "group": "navigation"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "Codex Linux",
+      "properties": {
+        "codex.api.host": {
+          "type": "string",
+          "default": "localhost",
+          "description": "Codex API host"
+        },
+        "codex.api.port": {
+          "type": "number",
+          "default": 3001,
+          "description": "Codex API port"
+        },
+        "codex.api.key": {
+          "type": "string",
+          "default": "",
+          "description": "Codex API key"
+        }
+      }
+    },
+    "keybindings": [
+      {
+        "command": "codex.chat",
+        "key": "ctrl+shift+c",
+        "mac": "cmd+shift+c"
+      },
+      {
+        "command": "codex.explain",
+        "key": "ctrl+shift+e",
+        "mac": "cmd+shift+e"
+      }
+    ]
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run compile",
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./",
+    "pretest": "npm run compile && npm run lint",
+    "lint": "eslint src --ext ts",
+    "test": "node ./out/test/runTest.js",
+    "package": "vsce package"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.74.0",
+    "@types/node": "20.x",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "eslint": "^8.56.0",
+    "typescript": "^5.3.3",
+    "@vscode/test-electron": "^2.3.8",
+    "vsce": "^2.15.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.2",
+    "ws": "^8.16.0"
+  }
+}

package/packages/vscode-extension/src/api.ts

@@ -0,0 +1,68 @@
+import * as vscode from 'vscode';
+import axios, { AxiosInstance } from 'axios';
+
+export class CodexAPI {
+  private client: AxiosInstance;
+  private host: string;
+  private port: number;
+
+  constructor(host: string, port: number, apiKey: string) {
+    this.host = host;
+    this.port = port;
+
+    this.client = axios.create({
+      baseURL: `http://${host}:${port}/api`,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': apiKey,
+      },
+      timeout: 30000,
+    });
+  }
+
+  async checkHealth(): Promise<boolean> {
+    try {
+      const response = await this.client.get('/health');
+      return response.data.status === 'ok';
+    } catch {
+      return false;
+    }
+  }
+
+  async getAgents(): Promise<any[]> {
+    const response = await this.client.get('/agents');
+    return response.data;
+  }
+
+  async getAgent(agentId: string): Promise<any> {
+    const response = await this.client.get(`/agents/${agentId}`);
+    return response.data;
+  }
+
+  async createAgent(config: any): Promise<any> {
+    const response = await this.client.post('/agents', config);
+    return response.data;
+  }
+
+  async deleteAgent(agentId: string): Promise<void> {
+    await this.client.delete(`/agents/${agentId}`);
+  }
+
+  async sendMessage(agentId: string, message: string): Promise<any> {
+    const response = await this.client.post(`/agents/${agentId}/messages`, {
+      message,
+    });
+    return response.data;
+  }
+
+  async executeTask(agentId: string, task: string): Promise<any> {
+    const response = await this.client.post(`/agents/${agentId}/tasks`, {
+      task,
+    });
+    return response.data;
+  }
+
+  getBaseUrl(): string {
+    return `http://${this.host}:${this.port}`;
+  }
+}