@ian2018cs/agenthub 0.1.16 → 0.1.17

package/dist/index.html

@@ -25,7 +25,7 @@
     
     <!-- Prevent zoom on iOS -->
     <meta name="format-detection" content="telephone=no" />
-    <script type="module" crossorigin src="/assets/index-DuyUUXPp.js"></script>
+    <script type="module" crossorigin src="/assets/index-DzJ3SGxJ.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BeVl62c0.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-C_VWDoZS.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-utils-00TdZexr.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian2018cs/agenthub",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "A web-based UI for AI Agents",
   "type": "module",
   "main": "server/index.js",

package/server/index.js

@@ -54,9 +54,9 @@ import adminRoutes from './routes/admin.js';
 import usageRoutes from './routes/usage.js';
 import skillsRoutes from './routes/skills.js';
 import settingsRoutes from './routes/settings.js';
-import { initializeDatabase } from './database/db.js';
+import { initializeDatabase, userDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
-import { getUserPaths } from './services/user-directories.js';
+import { getUserPaths, initCodexDirectories } from './services/user-directories.js';
 import { startUsageScanner } from './services/usage-scanner.js';
 
 // File system watcher for projects folder - per user
@@ -183,6 +183,7 @@ const app = express();
 const server = http.createServer(app);
 
 const ptySessionsMap = new Map();
+const codexPtySessionsMap = new Map();
 const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
 
 // Single WebSocket server that handles both paths
@@ -599,6 +600,8 @@ wss.on('connection', (ws, request) => {
 
     if (pathname === '/shell') {
         handleShellConnection(ws, userData);
+    } else if (pathname === '/codex') {
+        handleCodexConnection(ws, userData);
     } else if (pathname === '/ws') {
         handleChatConnection(ws, userData);
     } else {
@@ -1047,7 +1050,225 @@ function handleShellConnection(ws, userData) {
         console.error('[ERROR] Shell WebSocket error:', error);
     });
 }
-// Audio transcription endpoint
+
+function handleCodexConnection(ws, userData) {
+    console.log('🤖 Codex client connected');
+    const userUuid = userData?.uuid || null;
+    let codexProcess = null;
+    let ptySessionKey = null;
+    let outputBuffer = [];
+
+    ws.on('message', async (message) => {
+        try {
+            const data = JSON.parse(message);
+            console.log('📨 Codex message received:', data.type);
+
+            if (data.type === 'init') {
+                const projectPath = data.projectPath || process.cwd();
+
+                ptySessionKey = `codex_${projectPath}_${userUuid || 'default'}`;
+
+                const existingSession = codexPtySessionsMap.get(ptySessionKey);
+                if (existingSession) {
+                    console.log('♻️  Reconnecting to existing Codex PTY session:', ptySessionKey);
+                    codexProcess = existingSession.pty;
+                    clearTimeout(existingSession.timeoutId);
+
+                    ws.send(JSON.stringify({
+                        type: 'output',
+                        data: `\x1b[36m[Reconnected to existing Codex session]\x1b[0m\r\n`
+                    }));
+
+                    if (existingSession.buffer && existingSession.buffer.length > 0) {
+                        console.log(`📜 Sending ${existingSession.buffer.length} buffered Codex messages`);
+                        existingSession.buffer.forEach(bufferedData => {
+                            ws.send(JSON.stringify({ type: 'output', data: bufferedData }));
+                        });
+                    }
+
+                    existingSession.ws = ws;
+                    return;
+                }
+
+                console.log('[INFO] Starting Codex in:', projectPath);
+
+                ws.send(JSON.stringify({
+                    type: 'output',
+                    data: `\x1b[36mStarting Codex in: ${projectPath}\x1b[0m\r\n`
+                }));
+
+                try {
+                    const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
+                    const shellCommand = os.platform() === 'win32'
+                        ? `Set-Location -Path "${projectPath}"; codex`
+                        : `cd "${projectPath}" && codex`;
+                    const shellArgs = os.platform() === 'win32'
+                        ? ['-Command', shellCommand]
+                        : ['-c', shellCommand];
+
+                    const termCols = data.cols || 80;
+                    const termRows = data.rows || 24;
+                    console.log('📐 Codex terminal dimensions:', termCols, 'x', termRows);
+
+                    // Build environment with per-user isolated HOME for codex config isolation
+                    const codexEnv = {
+                        ...process.env,
+                        TERM: 'xterm-256color',
+                        COLORTERM: 'truecolor',
+                        FORCE_COLOR: '3',
+                        BROWSER: 'echo "OPEN_URL:"'
+                    };
+
+                    if (userUuid) {
+                        const userPaths = getUserPaths(userUuid);
+                        // Set HOME to per-user fake home so codex reads <codexHomeDir>/.codex/
+                        // This completely isolates from the host user's ~/.codex
+                        codexEnv.HOME = userPaths.codexHomeDir;
+                        console.log('🔐 Set HOME for Codex user isolation:', userPaths.codexHomeDir);
+                    }
+
+                    // Inject API credentials from server environment variables
+                    if (process.env.OPENAI_API_KEY) {
+                        codexEnv.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+                    }
+                    if (process.env.OPENAI_BASE_URL) {
+                        codexEnv.OPENAI_BASE_URL = process.env.OPENAI_BASE_URL;
+                    }
+
+                    codexProcess = pty.spawn(shell, shellArgs, {
+                        name: 'xterm-256color',
+                        cols: termCols,
+                        rows: termRows,
+                        cwd: os.homedir(),
+                        env: codexEnv
+                    });
+
+                    console.log('🟢 Codex process started with PTY, PID:', codexProcess.pid);
+
+                    codexPtySessionsMap.set(ptySessionKey, {
+                        pty: codexProcess,
+                        ws: ws,
+                        buffer: [],
+                        timeoutId: null,
+                        projectPath
+                    });
+
+                    codexProcess.onData((rawData) => {
+                        const session = codexPtySessionsMap.get(ptySessionKey);
+                        if (!session) return;
+
+                        if (session.buffer.length < 5000) {
+                            session.buffer.push(rawData);
+                        } else {
+                            session.buffer.shift();
+                            session.buffer.push(rawData);
+                        }
+
+                        if (session.ws && session.ws.readyState === WebSocket.OPEN) {
+                            let outputData = rawData;
+
+                            // URL detection
+                            const patterns = [
+                                /(?:xdg-open|open|start)\s+(https?:\/\/[^\s\x1b\x07]+)/g,
+                                /OPEN_URL:\s*(https?:\/\/[^\s\x1b\x07]+)/g,
+                                /Opening\s+(https?:\/\/[^\s\x1b\x07]+)/gi,
+                                /Visit:\s*(https?:\/\/[^\s\x1b\x07]+)/gi,
+                            ];
+
+                            patterns.forEach(pattern => {
+                                let match;
+                                while ((match = pattern.exec(rawData)) !== null) {
+                                    const url = match[1];
+                                    session.ws.send(JSON.stringify({ type: 'url_open', url }));
+                                    if (pattern.source.includes('OPEN_URL')) {
+                                        outputData = outputData.replace(match[0], `[INFO] Opening in browser: ${url}`);
+                                    }
+                                }
+                            });
+
+                            session.ws.send(JSON.stringify({ type: 'output', data: outputData }));
+                        }
+                    });
+
+                    codexProcess.onExit((exitCode) => {
+                        console.log('🔚 Codex process exited with code:', exitCode.exitCode);
+                        const session = codexPtySessionsMap.get(ptySessionKey);
+                        if (session && session.ws && session.ws.readyState === WebSocket.OPEN) {
+                            session.ws.send(JSON.stringify({
+                                type: 'output',
+                                data: `\r\n\x1b[33mCodex exited with code ${exitCode.exitCode}${exitCode.signal ? ` (${exitCode.signal})` : ''}\x1b[0m\r\n`
+                            }));
+                        }
+                        if (session && session.timeoutId) {
+                            clearTimeout(session.timeoutId);
+                        }
+                        codexPtySessionsMap.delete(ptySessionKey);
+                        codexProcess = null;
+                    });
+
+                } catch (spawnError) {
+                    console.error('[ERROR] Error spawning Codex process:', spawnError);
+                    ws.send(JSON.stringify({
+                        type: 'output',
+                        data: `\r\n\x1b[31mError starting Codex: ${spawnError.message}\x1b[0m\r\n`
+                    }));
+                }
+
+            } else if (data.type === 'input') {
+                if (codexProcess && codexProcess.write) {
+                    try {
+                        codexProcess.write(data.data);
+                    } catch (error) {
+                        console.error('Error writing to Codex process:', error);
+                    }
+                }
+            } else if (data.type === 'resize') {
+                if (codexProcess && codexProcess.resize) {
+                    codexProcess.resize(data.cols, data.rows);
+                }
+            } else if (data.type === 'terminate') {
+                console.log('🛑 Codex terminate request for session:', ptySessionKey);
+                const session = codexPtySessionsMap.get(ptySessionKey);
+                if (session) {
+                    if (session.timeoutId) clearTimeout(session.timeoutId);
+                    if (session.pty && session.pty.kill) session.pty.kill();
+                    codexPtySessionsMap.delete(ptySessionKey);
+                }
+                codexProcess = null;
+            }
+        } catch (error) {
+            console.error('[ERROR] Codex WebSocket error:', error.message);
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'output',
+                    data: `\r\n\x1b[31mError: ${error.message}\x1b[0m\r\n`
+                }));
+            }
+        }
+    });
+
+    ws.on('close', () => {
+        console.log('🔌 Codex client disconnected');
+        if (ptySessionKey) {
+            const session = codexPtySessionsMap.get(ptySessionKey);
+            if (session) {
+                console.log('⏳ Codex PTY session kept alive, will timeout in 30 minutes:', ptySessionKey);
+                session.ws = null;
+                session.timeoutId = setTimeout(() => {
+                    console.log('⏰ Codex PTY session timeout, killing process:', ptySessionKey);
+                    if (session.pty && session.pty.kill) {
+                        session.pty.kill();
+                    }
+                    codexPtySessionsMap.delete(ptySessionKey);
+                }, PTY_SESSION_TIMEOUT);
+            }
+        }
+    });
+
+    ws.on('error', (error) => {
+        console.error('[ERROR] Codex WebSocket error:', error);
+    });
+}
 app.post('/api/transcribe', authenticateToken, async (req, res) => {
     try {
         const multer = (await import('multer')).default;
@@ -1698,6 +1919,22 @@ async function startServer() {
             // Start usage scanner service
             startUsageScanner();
 
+            // Migrate existing users: ensure codex directories and config files exist
+            try {
+                const allUsers = userDb.getAllUsers();
+                for (const user of allUsers) {
+                    if (!user.uuid) continue;
+                    try {
+                        await initCodexDirectories(user.uuid);
+                    } catch (err) {
+                        console.error(`[WARN] Failed to init codex dirs for user ${user.uuid}:`, err.message);
+                    }
+                }
+                console.log(`[INFO] Codex directory migration complete for ${allUsers.length} user(s)`);
+            } catch (err) {
+                console.error('[WARN] Codex migration error:', err.message);
+            }
+
             // Projects watcher is now per-user, initialized when user connects via WebSocket
         });
     } catch (error) {

package/server/services/user-directories.js

@@ -26,6 +26,7 @@ export function getUserPaths(userUuid) {
     skillsDir: path.join(DATA_DIR, 'user-data', userUuid, '.claude', 'skills'),
     skillsImportDir: path.join(DATA_DIR, 'user-data', userUuid, 'skills-import'),
     skillsRepoDir: path.join(DATA_DIR, 'user-data', userUuid, 'skills-repo'),
+    codexHomeDir: path.join(DATA_DIR, 'user-data', userUuid, 'codex-home'),
   };
 }
 
@@ -38,6 +39,44 @@ export function getPublicPaths() {
   };
 }
 
+/**
+ * Initialize codex home directory and config files for a user.
+ * Safe to call multiple times - only creates files that don't already exist.
+ */
+export async function initCodexDirectories(userUuid) {
+  validateUuid(userUuid);
+  const paths = getUserPaths(userUuid);
+  const codexDir = path.join(paths.codexHomeDir, '.codex');
+
+  await fs.mkdir(codexDir, { recursive: true });
+
+  // Write config.toml (overwrite to keep in sync with env)
+  const baseUrl = process.env.OPENAI_BASE_URL || '';
+  const configToml = `model_provider = "custom"
+
+[model_providers.custom]
+name = "custom"
+wire_api = "responses"
+requires_openai_auth = true
+base_url = "${baseUrl}"
+`;
+  await fs.writeFile(path.join(codexDir, 'config.toml'), configToml, 'utf8');
+
+  // Write auth.json only if it doesn't exist, to avoid overwriting user tokens
+  const authJsonPath = path.join(codexDir, 'auth.json');
+  try {
+    await fs.access(authJsonPath);
+    // File exists - skip to preserve any user-level overrides
+  } catch {
+    const apiKey = process.env.OPENAI_API_KEY || '';
+    const authJson = JSON.stringify({ OPENAI_API_KEY: apiKey }, null, 2);
+    await fs.writeFile(authJsonPath, authJson, 'utf8');
+  }
+
+  console.log(`[Codex] Initialized codex directories for user ${userUuid}`);
+  return codexDir;
+}
+
 /**
  * Initialize directories for a new user
  */
@@ -49,6 +88,9 @@ export async function initUserDirectories(userUuid) {
   await fs.mkdir(paths.claudeDir, { recursive: true });
   await fs.mkdir(paths.projectsDir, { recursive: true });
 
+  // Initialize codex home directory with config files
+  await initCodexDirectories(userUuid);
+
   // Create projects directory for Claude session files
   const projectsDir = path.join(paths.claudeDir, 'projects');
   await fs.mkdir(projectsDir, { recursive: true });