glad-web 1.0.41 → 1.0.43

package/lib/codex/structured-session.js

@@ -1,7 +1,8 @@
 const { EventEmitter } = require('events');
 const { spawn } = require('child_process');
-const readline = require('readline');
+const net = require('net');
 const crypto = require('crypto');
+const WebSocket = require('ws');
 const PTYManager = require('../session/pty-manager');
 
 const PERMISSION_MODES = new Set(['untrusted', 'on-request', 'never']);
@@ -9,6 +10,10 @@ const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-acce
 const FALLBACK_EFFORTS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'ultra'];
 const DEFAULT_ABORT_GRACE_MS = 5000;
 const PROCESS_SHUTDOWN_TIMEOUT_MS = 2000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+const RESUME_REQUEST_TIMEOUT_MS = 60000;
+const RESUME_HISTORY_TURN_LIMIT = 50;
+const APP_SERVER_CONNECT_TIMEOUT_MS = 10000;
 
 function turnKey(threadId, turnId) {
   return `${String(threadId || '')}\n${String(turnId || '')}`;
@@ -56,7 +61,7 @@ function toTimestampMs(value) {
 }
 
 function appServerSpawnOptions({ cwd, env, platform = process.platform }) {
-  const options = { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] };
+  const options = { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] };
 
   // Globally installed npm CLIs expose a .cmd shim on Windows. child_process.spawn
   // does not resolve that shim without a shell, causing `spawn codex ENOENT`.
@@ -72,6 +77,50 @@ function appServerSpawnOptions({ cwd, env, platform = process.platform }) {
   return options;
 }
 
+function reserveLoopbackPort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(error => {
+        if (error) reject(error);
+        else if (!port) reject(new Error('Unable to reserve a loopback port for Codex app-server'));
+        else resolve(port);
+      });
+    });
+  });
+}
+
+async function connectAppServerWebSocket(url, timeoutMs = APP_SERVER_CONNECT_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = new Error('Codex app-server WebSocket did not become ready');
+  while (Date.now() < deadline) {
+    try {
+      return await new Promise((resolve, reject) => {
+        const socket = new WebSocket(url);
+        const onOpen = () => {
+          socket.off('error', onError);
+          resolve(socket);
+        };
+        const onError = error => {
+          socket.off('open', onOpen);
+          socket.terminate();
+          reject(error);
+        };
+        socket.once('open', onOpen);
+        socket.once('error', onError);
+      });
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+  }
+  throw lastError;
+}
+
 function forceKillProcessTree(child, options = {}) {
   const platform = options.platform || process.platform;
   const killGroup = options.killGroup || process.kill;
@@ -264,9 +313,13 @@ class CodexStructuredSession extends EventEmitter {
     this.requestId = 0;
     this.pendingRequests = new Map();
     this.process = null;
+    this.rpcSocket = null;
     this.processReady = null;
     this.processShutdown = null;
     this.needsThreadResume = false;
+    this.resuming = false;
+    this.resumePromise = null;
+    this.resumeTarget = null;
     this.aborting = false;
     this.abortTargets = new Map();
     this.abortTimer = null;
@@ -352,13 +405,13 @@ class CodexStructuredSession extends EventEmitter {
       effectivePermissionMode: this.effectivePermissionMode, effectiveSandboxMode: this.effectiveSandboxMode,
       model: this.model, effort: this.effort,
       status: this.status, threadId: this.threadId, presentation: this.presentation,
-      aborting: this.aborting,
-      canAbort: this.presentation === 'structured' && this.status !== 'idle' && !this.aborting,
+      aborting: this.aborting, resuming: this.resuming,
+      canAbort: this.presentation === 'structured' && (this.status !== 'idle' || this.resuming) && !this.aborting,
       canCompact: this.presentation === 'structured' && this.status === 'idle' && !this.compacting
-        && !this.aborting && Boolean(this.threadId),
+        && !this.aborting && !this.resuming && Boolean(this.threadId),
       compacting: this.compacting,
       canSwitchToTerminal: this.presentation === 'structured' && this.status === 'idle'
-        && !this.aborting && Boolean(this.threadId),
+        && !this.aborting && !this.resuming && Boolean(this.threadId),
       canSwitchToStructured: this.presentation === 'terminal',
       pendingPermissionCount: this.pendingPermissions.size, activeSubagentCount, models: this.models };
   }
@@ -427,23 +480,51 @@ class CodexStructuredSession extends EventEmitter {
   async ensureProcess() {
     if (this.processShutdown) await this.processShutdown;
     if (this.processReady) return this.processReady;
-    this.processReady = new Promise((resolve, reject) => {
-      const child = spawn(this.tool.command, ['app-server', '--listen', 'stdio://'], appServerSpawnOptions({
-        cwd: this.workingDir,
-        env: { ...process.env }
-      }));
-      this.process = child;
-      const fail = error => {
-        this.processReady = null;
-        this.process = null;
-        reject(error instanceof Error ? error : new Error(String(error)));
-      };
-      child.once('error', fail);
-      child.once('exit', code => {
-        if (this.process === child) {
+    let startup;
+    startup = (async () => {
+      const port = await reserveLoopbackPort();
+      return new Promise((resolve, reject) => {
+        const listenUrl = `ws://127.0.0.1:${port}`;
+        // ARM64 Docker 中的大响应可能让非阻塞 stdio pipe 返回 EAGAIN。
+        // loopback WebSocket 保持连接只在容器内部可见，同时避开该传输缺陷。
+        const child = spawn(this.tool.command, ['app-server', '--listen', listenUrl], appServerSpawnOptions({
+          cwd: this.workingDir,
+          env: { ...process.env }
+        }));
+        this.process = child;
+        const fail = error => {
+          if (this.process === child) void this.disconnectProcess(true, error);
+          if (this.processReady === startup) this.processReady = null;
+          reject(error instanceof Error ? error : new Error(String(error)));
+        };
+        const transportFailed = error => {
+          if (this.process !== child) return;
+          const failure = error instanceof Error ? error : new Error(String(error || 'Codex app-server transport closed'));
+          this.logger.debugInfo?.(`[codex-app-server] transport failed: ${failure.message}`);
+          this.needsThreadResume = Boolean(this.threadId || this.resumeTarget);
+          if (this.running && this.presentation === 'structured') {
+            const activeTurn = Boolean(this.currentTurnId || this.status === 'running' || this.status === 'waiting_approval');
+            this.clearAbortState(false);
+            this.compacting = false;
+            this.append({ kind: 'event', level: 'error', text: `Codex app-server connection failed: ${failure.message}` });
+            this.emitEvent({ type: 'runtime-disconnected', activeTurn, turnId: this.currentTurnId || null });
+            if (this.status !== 'idle') this.setStatus('idle');
+            else this.emitControlState();
+          }
+          void this.disconnectProcess(true, failure);
+        };
+        child.once('error', transportFailed);
+        child.once('exit', code => {
+          if (this.process !== child) return;
           this.process = null;
           this.processReady = null;
-          for (const request of this.pendingRequests.values()) request.reject(new Error(`Codex app-server exited (${code})`));
+          const socket = this.rpcSocket;
+          this.rpcSocket = null;
+          socket?.terminate();
+          for (const request of this.pendingRequests.values()) {
+            clearTimeout(request.timer);
+            request.reject(new Error(`Codex app-server exited (${code})`));
+          }
           this.pendingRequests.clear();
           if (this.running && this.presentation === 'structured') {
             const activeTurn = Boolean(this.currentTurnId || this.status === 'running' || this.status === 'waiting_approval');
@@ -451,48 +532,102 @@ class CodexStructuredSession extends EventEmitter {
             this.clearAbortState(false);
             this.compacting = false;
             this.append({ kind: 'event', level: 'error', text: 'Codex app-server exited.' });
-            this.emitEvent({
-              type: 'runtime-disconnected',
-              activeTurn,
-              turnId: this.currentTurnId || null
-            });
+            this.emitEvent({ type: 'runtime-disconnected', activeTurn, turnId: this.currentTurnId || null });
             this.setStatus('idle');
           }
-        }
-      });
-      child.stderr.on('data', data => this.logger.debugInfo?.(`[codex-app-server] ${String(data).trim()}`));
-      const lines = readline.createInterface({ input: child.stdout });
-      lines.on('line', line => this.handleRpcLine(line));
-      this.request('initialize', { clientInfo: { name: 'glad-web', title: 'Glad', version: '1.0' }, capabilities: { experimentalApi: true } })
-        .then(async () => {
+        });
+        const logOutput = data => this.logger.debugInfo?.(`[codex-app-server] ${String(data).trim()}`);
+        child.stdout.on('data', logOutput);
+        child.stderr.on('data', logOutput);
+        connectAppServerWebSocket(listenUrl).then(socket => {
+          if (this.process !== child) {
+            socket.terminate();
+            throw new Error('Codex app-server stopped while connecting');
+          }
+          this.rpcSocket = socket;
+          socket.on('message', data => this.handleRpcLine(String(data)));
+          socket.once('error', transportFailed);
+          socket.once('close', (code, reason) => {
+            transportFailed(new Error(`Codex app-server WebSocket closed (${code}${reason?.length ? `: ${String(reason)}` : ''})`));
+          });
+          return this.request('initialize', {
+            clientInfo: { name: 'glad-web', title: 'Glad', version: '1.0' },
+            capabilities: { experimentalApi: true }
+          }, { fatalOnTimeout: true });
+        }).then(async () => {
+          this.notify('initialized', {});
           try { await this.refreshConfigDefaults(); } catch (error) { this.logger.debugInfo?.(`[codex-app-server] config/read failed: ${error.message}`); }
           try { await this.refreshModels(); } catch (error) { this.logger.debugInfo?.(`[codex-app-server] model/list failed: ${error.message}`); }
           resolve();
         }).catch(fail);
-    });
-    return this.processReady;
+      });
+    })();
+    this.processReady = startup;
+    try {
+      return await startup;
+    } catch (error) {
+      if (this.processReady === startup) this.processReady = null;
+      throw error;
+    }
   }
 
-  request(method, params) {
-    if (!this.process || !this.process.stdin?.writable) return Promise.reject(new Error('Codex app-server is not connected'));
+  request(method, params, options = {}) {
+    if (!this.process || this.rpcSocket?.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error('Codex app-server is not connected'));
+    }
+    const child = this.process;
+    const socket = this.rpcSocket;
+    const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : DEFAULT_REQUEST_TIMEOUT_MS;
+    const fatalOnTimeout = Boolean(options.fatalOnTimeout);
     const id = ++this.requestId;
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => { this.pendingRequests.delete(id); reject(new Error(`${method} timed out`)); }, 30000);
+      const fail = error => {
+        const pending = this.pendingRequests.get(id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(id);
+        reject(error);
+      };
+      const timer = setTimeout(() => {
+        const error = new Error(`${method} timed out after ${Math.max(1, Math.round(timeoutMs / 1000))} seconds`);
+        fail(error);
+        // 生命周期请求超时后连接状态未知，必须启动新的 app-server。
+        if (fatalOnTimeout && this.process === child) void this.disconnectProcess(true, error);
+      }, timeoutMs);
       this.pendingRequests.set(id, { resolve, reject, timer });
-      this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      try {
+        socket.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }), error => {
+          if (!error) return;
+          fail(error);
+          if (this.process === child) void this.disconnectProcess(true, error);
+        });
+      } catch (error) {
+        fail(error);
+        if (this.process === child) void this.disconnectProcess(true, error);
+      }
     });
   }
 
   notify(method, params) {
-    if (!this.process || !this.process.stdin?.writable) return false;
-    this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
-    return true;
+    return this.sendRpcMessage({ jsonrpc: '2.0', method, params });
   }
 
   respond(id, result) {
-    if (!this.process || !this.process.stdin?.writable) return false;
-    this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
-    return true;
+    return this.sendRpcMessage({ jsonrpc: '2.0', id, result });
+  }
+
+  sendRpcMessage(message) {
+    if (!this.process || this.rpcSocket?.readyState !== WebSocket.OPEN) return false;
+    const child = this.process;
+    try {
+      this.rpcSocket.send(JSON.stringify(message), error => {
+        if (error && this.process === child) void this.disconnectProcess(true, error);
+      });
+      return true;
+    } catch (error) {
+      if (this.process === child) void this.disconnectProcess(true, error);
+      return false;
+    }
   }
 
   handleRpcLine(line) {
@@ -834,6 +969,37 @@ class CodexStructuredSession extends EventEmitter {
     return config;
   }
 
+  async readRecentThread(thread, limit = RESUME_HISTORY_TURN_LIMIT, options = {}) {
+    const summary = thread && typeof thread === 'object' ? thread : {};
+    const embeddedTurns = Array.isArray(summary.turns) ? summary.turns.slice(-limit) : [];
+    try {
+      const newestFirst = [];
+      let cursor = null;
+      do {
+        const result = await this.request('thread/turns/list', {
+          threadId: summary.id,
+          cursor,
+          limit: Math.min(100, limit - newestFirst.length),
+          sortDirection: 'desc',
+          itemsView: 'full'
+        }, options);
+        newestFirst.push(...(Array.isArray(result?.data) ? result.data : []));
+        cursor = result?.nextCursor || null;
+      } while (cursor && newestFirst.length < limit);
+      return {
+        ...summary,
+        // app-server 默认从新到旧返回，页面仍按时间顺序展示。
+        turns: newestFirst.slice().reverse(),
+        historyNextCursor: cursor
+      };
+    } catch (error) {
+      this.logger.debugInfo?.(`[codex-app-server] paginated history unavailable for ${summary.id || 'unknown'}: ${error.message}`);
+      const unsupported = /method.*not found|unsupported|experimental/i.test(String(error.message || ''));
+      if (options.fatalOnTimeout && !unsupported) throw error;
+      return { ...summary, turns: embeddedTurns, historyNextCursor: null };
+    }
+  }
+
   async listResumeThreads() {
     await this.ensureProcess();
     const result = await this.request('thread/list', {
@@ -849,8 +1015,8 @@ class CodexStructuredSession extends EventEmitter {
     for (const item of threads) {
       let questions = [];
       try {
-        const history = await this.request('thread/read', { threadId: item.id, includeTurns: true });
-        questions = recentUserQuestions(history?.thread);
+        const history = await this.readRecentThread(item, 8);
+        questions = recentUserQuestions(history);
       } catch (error) {
         this.logger.debugInfo?.(`[codex-app-server] unable to read resume preview for ${item.id}: ${error.message}`);
       }
@@ -892,20 +1058,24 @@ class CodexStructuredSession extends EventEmitter {
         const threads = (result?.data || []).filter(item => !item.parentThreadId);
         const histories = await Promise.all(threads.map(async item => {
           try {
-            const history = await this.request('thread/read', { threadId: item.id, includeTurns: true });
+            const history = await this.readRecentThread(item, 200);
             const fallbackTimestamp = toTimestampMs(item.updatedAt || item.createdAt);
-            return userPromptsFromThread(history?.thread || { id: item.id, turns: [] }, fallbackTimestamp)
-              .map(prompt => ({ ...prompt, threadId: prompt.threadId || item.id }));
+            return {
+              prompts: userPromptsFromThread(history || { id: item.id, turns: [] }, fallbackTimestamp)
+                .map(prompt => ({ ...prompt, threadId: prompt.threadId || item.id })),
+              capped: Boolean(history.historyNextCursor)
+            };
           } catch (error) {
             this.logger.debugInfo?.(`[codex-app-server] unable to read prompt history for ${item.id}: ${error.message}`);
-            return [];
+            return { prompts: [], capped: false };
           }
         }));
-        prompts.push(...histories.flat());
+        prompts.push(...histories.flatMap(history => history.prompts));
+        if (histories.some(history => history.capped)) capped = true;
         cursor = result?.nextCursor || null;
         pageCount += 1;
         if (prompts.length >= 200 || pageCount >= 5) {
-          capped = Boolean(cursor) || prompts.length > 200;
+          capped = capped || Boolean(cursor) || prompts.length > 200;
           break;
         }
       } while (cursor);
@@ -1028,7 +1198,10 @@ class CodexStructuredSession extends EventEmitter {
 
   async resumeThreadAfterProcessRestart() {
     if (!this.threadId || !this.needsThreadResume) return false;
-    const result = await this.request('thread/resume', this.threadResumeParams(this.threadId));
+    const result = await this.request('thread/resume', this.threadResumeParams(this.threadId), {
+      timeoutMs: RESUME_REQUEST_TIMEOUT_MS,
+      fatalOnTimeout: true
+    });
     this.needsThreadResume = false;
     this.model = result.model || result.thread?.model || this.model;
     this.effort = result.reasoningEffort || result.thread?.reasoningEffort || this.effort;
@@ -1051,7 +1224,7 @@ class CodexStructuredSession extends EventEmitter {
     const images = (Array.isArray(attachments) ? attachments : [])
       .filter(item => item && typeof item.path === 'string' && item.path);
     if ((!prompt && images.length === 0) || this.presentation !== 'structured'
-      || this.status !== 'idle' || this.aborting) return false;
+      || this.status !== 'idle' || this.aborting || this.resuming) return false;
     this.hasUnreadCompletion = false;
     this.promptHistoryCache = null;
     this.append({
@@ -1105,7 +1278,8 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   async compactContext() {
-    if (!this.threadId || this.presentation !== 'structured' || this.status !== 'idle' || this.aborting) return false;
+    if (!this.threadId || this.presentation !== 'structured' || this.status !== 'idle'
+      || this.aborting || this.resuming) return false;
     await this.ensureProcess();
     this.compacting = true;
     this.setStatus('running');
@@ -1156,8 +1330,17 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   abort(reason = 'Aborted by user') {
-    if (this.presentation !== 'structured' || this.status === 'idle') return false;
+    if (this.presentation !== 'structured' || (this.status === 'idle' && !this.resuming)) return false;
     if (this.aborting) return true;
+    if (this.resuming) {
+      this.aborting = true;
+      this.needsThreadResume = Boolean(this.threadId || this.resumeTarget);
+      this.emitControlState();
+      this.append({ kind: 'event', level: 'info', text: reason });
+      const error = new Error('Codex resume aborted by user');
+      void this.disconnectProcess(true, error);
+      return true;
+    }
     for (const pending of this.pendingPermissions.values()) {
       const response = pending.method === 'item/permissions/requestApproval'
         ? { permissions: {}, scope: 'turn' }
@@ -1232,9 +1415,27 @@ class CodexStructuredSession extends EventEmitter {
     return true;
   }
 
-  async resume(threadId = null) {
+  resume(threadId = null) {
     const target = String(threadId || this.threadId || '').trim();
     if (!target || this.presentation !== 'structured' || this.status !== 'idle' || this.aborting) return false;
+    if (this.resumePromise) return target === this.resumeTarget ? this.resumePromise : false;
+    this.resuming = true;
+    this.resumeTarget = target;
+    this.emitControlState();
+    let tracked;
+    tracked = this.performResume(target).finally(() => {
+      if (this.resumePromise !== tracked) return;
+      this.resumePromise = null;
+      this.resumeTarget = null;
+      this.resuming = false;
+      this.clearAbortState(false);
+      this.emitControlState();
+    });
+    this.resumePromise = tracked;
+    return tracked;
+  }
+
+  async performResume(target) {
     await this.ensureProcess();
     const selectedModel = this.model;
     const selectedEffort = this.effort;
@@ -1243,7 +1444,10 @@ class CodexStructuredSession extends EventEmitter {
     const params = this.threadResumeParams(target);
     this.deferredWarnings = [];
     try {
-      const result = await this.request('thread/resume', params);
+      const result = await this.request('thread/resume', params, {
+        timeoutMs: RESUME_REQUEST_TIMEOUT_MS,
+        fatalOnTimeout: true
+      });
       this.threadId = result.thread?.id || target;
       this.needsThreadResume = false;
       this.hasModelOverride = resumeWithModelOverride;
@@ -1252,8 +1456,10 @@ class CodexStructuredSession extends EventEmitter {
       this.effort = result.reasoningEffort || result.thread?.reasoningEffort || selectedEffort;
       this.effectivePermissionMode = result.approvalPolicy || this.effectivePermissionMode;
       this.effectiveSandboxMode = sandboxModeFromPolicy(result.sandbox) || this.effectiveSandboxMode;
-      const history = await this.request('thread/read', { threadId: this.threadId, includeTurns: true });
-      this.restoreThreadHistory(history?.thread, `Resumed Codex thread ${this.threadId}`, {
+      const history = await this.readRecentThread({ ...(result.thread || {}), id: this.threadId },
+        RESUME_HISTORY_TURN_LIMIT, { timeoutMs: RESUME_REQUEST_TIMEOUT_MS, fatalOnTimeout: true });
+      const historyNote = history.historyNextCursor ? ' · showing the latest 50 turns' : '';
+      this.restoreThreadHistory(history, `Resumed Codex thread ${this.threadId}${historyNote}`, {
         preserveModel: resumeWithModelOverride,
         preserveEffort: resumeWithEffortOverride
       });
@@ -1263,9 +1469,14 @@ class CodexStructuredSession extends EventEmitter {
       this.promptHistoryCache = null;
       return true;
     } catch (error) {
+      const aborted = this.aborting || /resume aborted/i.test(error.message);
       const warnings = this.deferredWarnings || [];
       this.deferredWarnings = null;
       for (const warning of warnings) this.append(warning);
+      this.needsThreadResume = Boolean(this.threadId || target);
+      await this.disconnectProcess(true, error);
+      this.append({ kind: 'event', level: aborted ? 'info' : 'error',
+        text: aborted ? 'Codex conversation recovery stopped.' : `Unable to resume Codex conversation: ${error.message}` });
       throw error;
     }
   }
@@ -1281,24 +1492,24 @@ class CodexStructuredSession extends EventEmitter {
     this.providerItemContexts.clear();
     try {
       for (const turn of thread?.turns || []) {
-      const status = turn.status === 'failed' ? 'failed' : turn.status === 'interrupted' ? 'cancelled' : 'completed';
-      const startedAt = Number(turn.startedAt || turn.createdAt || 0);
-      const completedAt = Number(turn.completedAt || turn.updatedAt || 0);
-      const toMilliseconds = value => value > 0 && value < 100000000000 ? value * 1000 : value;
-      const startedAtMs = toMilliseconds(startedAt);
-      const completedAtMs = toMilliseconds(completedAt);
-      this.append({ kind: 'turn-start', turnId: turn.id, ...(startedAtMs ? { createdAt: startedAtMs } : {}) });
-      for (const item of turn.items || []) {
-        this.applyProviderItem({ ...item, turnId: turn.id }, status === 'failed' ? 'failed' : 'completed', {
-          threadId: this.threadId,
-          startedAtMs,
-          completedAtMs
-        });
-      }
-      const durationMs = Number(turn.durationMs || turn.duration_ms || 0)
-        || (startedAtMs && completedAtMs && completedAtMs >= startedAtMs ? completedAtMs - startedAtMs : null);
-      this.append({ kind: 'turn-end', turnId: turn.id, status, durationMs,
-        ...(completedAtMs ? { createdAt: completedAtMs } : {}) });
+        const status = turn.status === 'failed' ? 'failed' : turn.status === 'interrupted' ? 'cancelled' : 'completed';
+        const startedAt = Number(turn.startedAt || turn.createdAt || 0);
+        const completedAt = Number(turn.completedAt || turn.updatedAt || 0);
+        const toMilliseconds = value => value > 0 && value < 100000000000 ? value * 1000 : value;
+        const startedAtMs = toMilliseconds(startedAt);
+        const completedAtMs = toMilliseconds(completedAt);
+        this.append({ kind: 'turn-start', turnId: turn.id, ...(startedAtMs ? { createdAt: startedAtMs } : {}) });
+        for (const item of turn.items || []) {
+          this.applyProviderItem({ ...item, turnId: turn.id }, status === 'failed' ? 'failed' : 'completed', {
+            threadId: this.threadId,
+            startedAtMs,
+            completedAtMs
+          });
+        }
+        const durationMs = Number(turn.durationMs || turn.duration_ms || 0)
+          || (startedAtMs && completedAtMs && completedAtMs >= startedAtMs ? completedAtMs - startedAtMs : null);
+        this.append({ kind: 'turn-end', turnId: turn.id, status, durationMs,
+          ...(completedAtMs ? { createdAt: completedAtMs } : {}) });
       }
       if (eventText) this.append({ kind: 'event', level: 'info', text: eventText });
     } finally {
@@ -1310,7 +1521,8 @@ class CodexStructuredSession extends EventEmitter {
 
   async forkFrom(threadId) {
     const sourceThreadId = String(threadId || '').trim();
-    if (!sourceThreadId || this.presentation !== 'structured' || this.status !== 'idle' || this.aborting) return false;
+    if (!sourceThreadId || this.presentation !== 'structured' || this.status !== 'idle'
+      || this.aborting || this.resuming) return false;
     await this.ensureProcess();
     const params = { threadId: sourceThreadId, cwd: this.workingDir, ephemeral: false, threadSource: null };
     if (this.hasModelOverride) params.model = this.model;
@@ -1331,7 +1543,8 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   async switchToTerminal() {
-    if (this.presentation !== 'structured' || this.status !== 'idle' || this.aborting || !this.threadId) throw new Error('Codex must be idle before switching to Terminal.');
+    if (this.presentation !== 'structured' || this.status !== 'idle' || this.aborting
+      || this.resuming || !this.threadId) throw new Error('Codex must be idle before switching to Terminal.');
     await this.disconnectProcess();
     this.terminalOutput = '';
     const terminal = new PTYManager(this.tool, this.workingDir, { append() {} }, { silent: true });
@@ -1362,12 +1575,16 @@ class CodexStructuredSession extends EventEmitter {
     return this.resume();
   }
 
-  async disconnectProcess(force = false) {
+  async disconnectProcess(force = false, reason = null) {
     if (!this.process) return this.processShutdown || undefined;
     const child = this.process;
     this.process = null;
     this.processReady = null;
-    for (const request of this.pendingRequests.values()) { clearTimeout(request.timer); request.reject(new Error('Codex app-server disconnected')); }
+    const socket = this.rpcSocket;
+    this.rpcSocket = null;
+    socket?.terminate();
+    const disconnectError = reason instanceof Error ? reason : new Error('Codex app-server disconnected');
+    for (const request of this.pendingRequests.values()) { clearTimeout(request.timer); request.reject(disconnectError); }
     this.pendingRequests.clear();
     const shutdown = typeof child.once === 'function'
       ? new Promise(resolve => {
@@ -1394,6 +1611,8 @@ class CodexStructuredSession extends EventEmitter {
   async kill() {
     this.running = false;
     this.clearAbortState(false);
+    this.resuming = false;
+    this.resumeTarget = null;
     this.terminalSession?.kill();
     this.terminalSession = null;
     await this.disconnectProcess(true);
@@ -1404,3 +1623,5 @@ class CodexStructuredSession extends EventEmitter {
 module.exports = CodexStructuredSession;
 module.exports.appServerSpawnOptions = appServerSpawnOptions;
 module.exports.forceKillProcessTree = forceKillProcessTree;
+module.exports.reserveLoopbackPort = reserveLoopbackPort;
+module.exports.connectAppServerWebSocket = connectAppServerWebSocket;

package/lib/session/session-manager.js

@@ -409,7 +409,7 @@ class SessionManager extends EventEmitter {
   async forkCodex(id, threadId) {
     const session = this.get(id);
     if (!session || session.kind !== 'codex-structured') return null;
-    if (session.presentation !== 'structured' || session.status !== 'idle') {
+    if (session.presentation !== 'structured' || session.status !== 'idle' || session.resuming) {
       const error = new Error('Codex must be idle in chat mode before forking');
       error.statusCode = 409;
       throw error;

package/lib/web/codex.js

@@ -1,6 +1,7 @@
         function codexText(text) { return escapeHtml(text || '').replace(/\n/g, '<br>'); }
         function codexReadyForInput() {
-            return codexState.presentation === 'structured' && codexState.status === 'idle' && !codexState.aborting;
+            return codexState.presentation === 'structured' && codexState.status === 'idle'
+                && !codexState.aborting && !codexState.resuming && !codexResumeInFlight;
         }
         function codexJson(value) {
             if (typeof value === 'string') return value;
@@ -473,6 +474,7 @@
             const subagents = Number(codexState.activeSubagentCount || 0) || 0;
             const parts = [];
             if (codexState.aborting) parts.push('<span class="claude-state-pill warn">Stopping Codex…</span>');
+            else if (codexState.resuming || codexResumeInFlight) parts.push('<span class="claude-state-pill">Resuming conversation…</span>');
             if (pending || codexState.status === 'waiting_approval') parts.push(`<button type="button" class="claude-state-pill warn codex-approval-jump" onclick="jumpToCodexApproval()" title="Jump to pending approval" aria-label="Jump to pending approval">${pending || 1} approval${pending === 1 ? '' : 's'}<span aria-hidden="true">↓</span></button>`);
             if (subagents) parts.push(`<span class="claude-state-pill">${subagents} subagent${subagents === 1 ? '' : 's'} running</span>`);
             el.innerHTML = parts.join('');
@@ -614,7 +616,10 @@
         function respondCodexPermission(id, decision) { if (currentSocket?.readyState === 1) currentSocket.send(JSON.stringify({ type: 'codex-permission', id, decision })); }
         async function toggleCodexResumePanel() {
             if (!codexReadyForInput()) return;
-            codexResumePanelOpen = !codexResumePanelOpen;
+            const panel = document.getElementById('codex-resume-panel');
+            const retryAfterFailure = panel.dataset.resumeError === 'true';
+            codexResumePanelOpen = retryAfterFailure ? true : !codexResumePanelOpen;
+            delete panel.dataset.resumeError;
             codexModelPanelOpen = false;
             codexForkPanelOpen = false;
             codexPromptPanelOpen = false;
@@ -623,7 +628,6 @@
             document.getElementById('codex-fork-panel').classList.remove('active');
             document.getElementById('codex-prompt-panel').classList.remove('active');
             document.getElementById('codex-skill-panel').classList.remove('active');
-            const panel = document.getElementById('codex-resume-panel');
             panel.classList.toggle('active', codexResumePanelOpen);
             updateTerminalControlsHeight();
             if (!codexResumePanelOpen) return;
@@ -647,6 +651,7 @@
             await loadCodexThreadPanel(panel, 'fork');
         }
         async function loadCodexThreadPanel(panel, action) {
+            delete panel.dataset.resumeError;
             panel.innerHTML = '<div class="claude-resume-meta" style="padding:12px;">Loading sessions...</div>';
             try {
                 const res = await fetchWithTimeout(`/api/sessions/${activeSessionId}/codex-resume-threads`, {}, 30000);
@@ -956,11 +961,37 @@
             applyCodexState({});
         }
         async function selectCodexResumeThread(threadId) {
-            const res = await fetchWithTimeout(`/api/sessions/${activeSessionId}/codex-resume`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ threadId }) }, 30000);
-            if (!res.ok) { alert((await res.json()).error || 'Unable to resume Codex thread'); return; }
-            codexResumePanelOpen = false;
-            document.getElementById('codex-resume-panel').classList.remove('active');
+            if (codexResumeInFlight || codexState.resuming) return;
+            codexResumeInFlight = true;
+            const panel = document.getElementById('codex-resume-panel');
+            panel.innerHTML = '<div class="claude-resume-meta" style="padding:12px;">Resuming conversation…</div>';
+            applyCodexState({ resuming: true, canAbort: true });
             updateTerminalControlsHeight();
+            let failure = '';
+            try {
+                const res = await fetchWithTimeout(`/api/sessions/${activeSessionId}/codex-resume`, {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ threadId })
+                }, 70000);
+                const data = await res.json();
+                if (!res.ok || !data.success) throw new Error(data.error || 'Unable to resume Codex thread');
+                codexResumePanelOpen = false;
+                panel.classList.remove('active');
+            } catch (error) {
+                failure = /resume aborted/i.test(error.message || '')
+                    ? 'Conversation recovery stopped.'
+                    : (error.message || 'Unable to resume Codex thread');
+            } finally {
+                codexResumeInFlight = false;
+                // 本地 in-flight 也参与控件状态，清除后必须主动重绘。
+                applyCodexState({ resuming: false, canAbort: false });
+                if (failure) {
+                    codexResumePanelOpen = true;
+                    panel.classList.add('active');
+                    panel.dataset.resumeError = 'true';
+                    panel.innerHTML = `<div class="claude-resume-meta" style="padding:12px;color:#ff6b61;">${escapeHtml(failure)}</div>`;
+                }
+                updateTerminalControlsHeight();
+            }
         }
         async function selectCodexForkThread(threadId) {
             const panel = document.getElementById('codex-fork-panel');

package/lib/web/core.js

@@ -35,7 +35,7 @@
                 permissionMode: 'default', sandboxMode: 'default',
                 effectivePermissionMode: null, effectiveSandboxMode: null,
                 model: null, effort: null, status: 'idle', threadId: null,
-                presentation: 'structured', models: [], aborting: false,
+                presentation: 'structured', models: [], aborting: false, resuming: false,
                 canAbort: false, canCompact: false, compacting: false,
                 canSwitchToTerminal: false, canSwitchToStructured: false
             };
@@ -46,6 +46,7 @@
         let codexModelPanelOpen = false;
         let codexModelCandidate = null;
         let codexResumePanelOpen = false;
+        let codexResumeInFlight = false;
         let codexForkPanelOpen = false;
         let codexPromptPanelOpen = false;
         let codexPromptItems = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glad-web",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Glad transforms terminal-based AI coding tools into a polished, mobile-friendly local Web interface.",
   "bin": {
     "glad": "bin/cli.js"