glad-web 1.0.21 → 1.0.23

package/lib/commands/web.js

@@ -93,6 +93,9 @@ async function webCommand(options) {
   sessionManager.on('claude-event', ({ sessionId, event }) => {
     broadcastToSession(sessionId, { type: 'claude-event', event });
   });
+  sessionManager.on('codex-event', ({ sessionId, event }) => {
+    broadcastToSession(sessionId, { type: 'codex-event', event });
+  });
   sessionManager.on('exit', ({ sessionId }) => {
     broadcastToSession(sessionId, { type: 'exit' });
   });
@@ -301,6 +304,46 @@ async function webCommand(options) {
     res.json({ success: true });
   });
 
+  app.patch('/api/sessions/:id/codex-settings', async (req, res) => {
+    try {
+      const state = await sessionManager.updateCodexSettings(req.params.id, req.body || {});
+      if (!state) return res.status(404).json({ error: 'Codex session not found' });
+      res.json({ success: true, state });
+    } catch (e) { res.status(400).json({ error: e.message }); }
+  });
+
+  app.get('/api/sessions/:id/codex-resume-threads', async (req, res) => {
+    try {
+      const items = await sessionManager.listCodexResumeThreads(req.params.id);
+      if (!items) return res.status(404).json({ error: 'Codex session not found' });
+      res.json({ success: true, items });
+    } catch (e) { res.status(400).json({ error: e.message }); }
+  });
+
+  app.post('/api/sessions/:id/codex-abort', (req, res) => {
+    const success = sessionManager.abortCodex(req.params.id);
+    if (!success) return res.status(409).json({ error: 'Codex session is idle or unavailable' });
+    res.json({ success: true });
+  });
+
+  app.post('/api/sessions/:id/codex-resume', async (req, res) => {
+    try {
+      const success = await sessionManager.resumeCodex(req.params.id, req.body && req.body.threadId);
+      if (!success) return res.status(409).json({ error: 'Codex session is busy or no thread is available' });
+      res.json({ success: true });
+    } catch (e) { res.status(400).json({ error: e.message }); }
+  });
+
+  app.post('/api/sessions/:id/codex-presentation', async (req, res) => {
+    const presentation = req.body && req.body.presentation;
+    if (!['terminal', 'structured'].includes(presentation)) return res.status(400).json({ error: 'Invalid presentation' });
+    try {
+      const success = await sessionManager.switchCodexPresentation(req.params.id, presentation);
+      if (!success) return res.status(409).json({ error: 'Codex session cannot switch presentation now' });
+      res.json({ success: true });
+    } catch (e) { res.status(409).json({ error: e.message }); }
+  });
+
   app.post('/api/debug/client-log', (req, res) => {
     const { sessionId, event, payload } = req.body || {};
     sessionManager.logClientDebug(sessionId, event, payload);
@@ -435,16 +478,19 @@ async function webCommand(options) {
     if (session.kind === 'claude-structured') {
       ws.send(JSON.stringify({ type: 'claude-snapshot', snapshot: sessionManager.getClaudeSnapshot(sessionId) }));
     }
+    if (session.kind === 'codex-structured' && session.presentation === 'structured') {
+      ws.send(JSON.stringify({ type: 'codex-snapshot', snapshot: sessionManager.getCodexSnapshot(sessionId) }));
+    }
     
     // Send catchup output. TUI tools may skip the raw circular buffer, so fall
     // back to the rendered/text history snapshot instead of reconnecting blank.
     const catchup = sessionManager.getCatchupOutput(sessionId);
-    ws.needsTuiRedraw = session.kind !== 'claude-structured'
+    ws.needsTuiRedraw = !['claude-structured', 'codex-structured'].includes(session.kind)
       && ['antigravity', 'claude-code', 'codex'].includes(session.tool.key)
       && (isReconnect || (catchup && catchup.source === 'rendered-history'));
     if (ws.needsTuiRedraw) {
       ws.send(JSON.stringify({ type: 'reset' }));
-    } else if (session.kind !== 'claude-structured' && catchup && catchup.data) {
+    } else if (!(session.kind === 'claude-structured' || (session.kind === 'codex-structured' && session.presentation === 'structured')) && catchup && catchup.data) {
       sessionManager.logWsCatchupOutput(sessionId, catchup);
       ws.send(JSON.stringify({ type: 'output', data: catchup.data }));
     }
@@ -467,6 +513,21 @@ async function webCommand(options) {
         if (payload.type === 'claude-abort') {
           sessionManager.abortClaude(sessionId);
         }
+        if (payload.type === 'codex-input') {
+          sessionManager.write(sessionId, payload.text || '');
+        }
+        if (payload.type === 'codex-permission') {
+          const codex = sessionManager.get(sessionId);
+          if (codex && codex.kind === 'codex-structured') {
+            codex.respondPermission(payload.id, payload.decision || Boolean(payload.approved));
+          }
+        }
+        if (payload.type === 'codex-settings') {
+          sessionManager.updateCodexSettings(sessionId, payload.settings || {}).catch(error => logger.error(`Codex settings error: ${error.message}`));
+        }
+        if (payload.type === 'codex-abort') {
+          sessionManager.abortCodex(sessionId);
+        }
         if (payload.type === 'claude-resume') {
           sessionManager.resumeClaude(sessionId, payload.resumeSessionId || '');
         }

package/lib/session/session-manager.js

@@ -9,6 +9,7 @@ const RenderedHistory = require('./rendered-history');
 const CircularBuffer = require('./buffer');
 const { getToolByKey } = require('../ai-tools/registry');
 const ClaudeStructuredSession = require('../claude/structured-session');
+const CodexStructuredSession = require('../codex/structured-session');
 
 function previewText(text, maxChars = 320) {
   if (!text) return '';
@@ -39,7 +40,7 @@ class SessionManager extends EventEmitter {
       startTime: session.startTime,
       toolKey: session.tool.key,
       workingDirectory: this.getSessionWorkingDirectory(session),
-      mode: session.kind === 'claude-structured' ? 'structured' : 'terminal',
+      mode: ['claude-structured', 'codex-structured'].includes(session.kind) ? (session.presentation || 'structured') : 'terminal',
       hasUnreadCompletion: Boolean(session.hasUnreadCompletion),
       timedInputCount: session.timedInputs
         ? Array.from(session.timedInputs.values()).filter(item => item.sendAt > Date.now()).length
@@ -68,6 +69,9 @@ class SessionManager extends EventEmitter {
     if (tool.key === 'claude-code') {
       return this.createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions });
     }
+    if (tool.key === 'codex') {
+      return this.createCodexStructuredSession({ tool, workingDirectory, name });
+    }
 
     const id = uuidv4();
     const buffer = new CircularBuffer(500000);
@@ -162,11 +166,33 @@ class SessionManager extends EventEmitter {
     return session;
   }
 
+  createCodexStructuredSession({ tool, workingDirectory, name, codexOptions = {} }) {
+    const sessionDir = workingDirectory && String(workingDirectory).trim()
+      ? path.resolve(this.baseDir, String(workingDirectory).trim())
+      : this.baseDir;
+    if (!fs.existsSync(sessionDir)) {
+      const err = new Error(`Directory does not exist: ${sessionDir}`);
+      err.statusCode = 400;
+      throw err;
+    }
+    const id = uuidv4();
+    const session = new CodexStructuredSession({ id, tool, workingDir: sessionDir, name: name || tool.displayName, logger: this.logger, options: codexOptions });
+    this.sessions.set(id, session);
+    session.on('event', event => this.emit('codex-event', { sessionId: id, event, session }));
+    session.on('output', data => this.emit('output', { sessionId: id, data, session }));
+    session.on('exit', () => this.handleExit(session));
+    session.ensureProcess().catch(error => {
+      session.append({ kind: 'event', level: 'error', text: `Unable to start Codex app-server: ${error.message}` });
+    });
+    this.logSessionDiagnostics('codex-session-created', session, {}, { compact: true });
+    return session;
+  }
+
   write(id, data) {
     const session = this.get(id);
     if (!session) return false;
     this.markSessionInput(session, data);
-    if (session.kind === 'claude-structured') return session.write(data);
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.write(data);
     return session.ptyManager.write(data);
   }
 
@@ -208,10 +234,47 @@ class SessionManager extends EventEmitter {
     return this.scanClaudeProjectSessions(this.getSessionWorkingDirectory(session));
   }
 
+  getCodexSnapshot(id) {
+    const session = this.get(id);
+    return session && session.kind === 'codex-structured' ? session.snapshot() : null;
+  }
+
+  updateCodexSettings(id, settings) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'codex-structured') return null;
+    return session.updateSettings(settings || {});
+  }
+
+  abortCodex(id) {
+    const session = this.get(id);
+    return session && session.kind === 'codex-structured' ? session.abort('Aborted by user') : false;
+  }
+
+  resumeCodex(id, threadId) {
+    const session = this.get(id);
+    return session && session.kind === 'codex-structured' ? session.resume(threadId) : false;
+  }
+
+  listCodexResumeThreads(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'codex-structured') return null;
+    return session.listResumeThreads();
+  }
+
+  switchCodexPresentation(id, presentation) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'codex-structured') return Promise.resolve(false);
+    return presentation === 'terminal' ? session.switchToTerminal() : session.switchToStructured();
+  }
+
   resize(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
     if (session.kind === 'claude-structured') return true;
+    if (session.kind === 'codex-structured') {
+      if (session.presentation === 'terminal') session.ptyManager.resize(cols, rows);
+      return true;
+    }
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -222,7 +285,7 @@ class SessionManager extends EventEmitter {
   redraw(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
-    if (session.kind === 'claude-structured') return true;
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -240,7 +303,7 @@ class SessionManager extends EventEmitter {
   markCompletionRead(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (session.kind === 'claude-structured') {
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
       session.markCompletionRead();
       this.logSessionDiagnostics('completion-read', session, {}, { compact: true });
       return session;
@@ -371,7 +434,7 @@ class SessionManager extends EventEmitter {
     this.clearTimedInputs(session);
     this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
     this.disposeSessionHistory(session);
-    if (session.kind === 'claude-structured') {
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
       session.ptyManager.kill();
       return true;
     }
@@ -394,7 +457,7 @@ class SessionManager extends EventEmitter {
   getHistory(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (session.kind === 'claude-structured') return session.getHistory();
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.getHistory();
     const historySource = session.renderedHistory || session.textHistory;
     return {
       success: true,
@@ -409,7 +472,7 @@ class SessionManager extends EventEmitter {
   getCatchupOutput(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (session.kind === 'claude-structured') return session.getCatchupOutput();
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.getCatchupOutput();
 
     const bufferHistory = session.buffer.getAfter(0);
     if (bufferHistory.length > 0) {
@@ -741,7 +804,7 @@ class SessionManager extends EventEmitter {
   markSessionInput(session, data) {
     if (typeof data !== 'string' || data.length === 0) return;
     session.inputSeq = (session.inputSeq || 0) + 1;
-    if (session.kind === 'claude-structured') {
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
       session.hasUnreadCompletion = false;
       this.logSessionDiagnostics('session-input', session, {
         inputSeq: session.inputSeq,
@@ -760,7 +823,7 @@ class SessionManager extends EventEmitter {
   }
 
   disposeSessionHistory(session) {
-    if (session.kind === 'claude-structured') return;
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) return;
     if (session.renderedHistory) {
       session.renderedHistory.dispose();
       session.renderedHistory = null;
@@ -776,7 +839,7 @@ class SessionManager extends EventEmitter {
   }
 
   getSessionDiagnostics(session, extra = {}) {
-    if (session.kind === 'claude-structured') {
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
       return {
         sessionId: session.id,
         sessionName: session.name,
@@ -805,7 +868,7 @@ class SessionManager extends EventEmitter {
   }
 
   getCompactSessionDiagnostics(session, extra = {}) {
-    if (session.kind === 'claude-structured') {
+    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
       return this.getSessionDiagnostics(session, extra);
     }
     const buffer = session.buffer.getDebugSnapshot();