glad-web 1.0.35 → 1.0.37

package/lib/codex/structured-session.js

@@ -4,8 +4,6 @@ const readline = require('readline');
 const crypto = require('crypto');
 const PTYManager = require('../session/pty-manager');
 
-const CODEX_MESSAGE_PAGE_BYTES = 200 * 1024;
-
 const PERMISSION_MODES = new Set(['untrusted', 'on-request', 'never']);
 const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
 const FALLBACK_EFFORTS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'ultra'];
@@ -199,6 +197,7 @@ class CodexStructuredSession extends EventEmitter {
     this.status = 'idle';
     this.presentation = 'structured';
     this.messages = [];
+    this.replayingHistory = false;
     this.pendingPermissions = new Map();
     this.completedPermissions = [];
     this.threadId = options.resume || null;
@@ -252,58 +251,51 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   snapshot() {
-    const historyPage = this.getMessagePage();
-    const { messages, ...historyPageMeta } = historyPage;
     return { id: this.id, name: this.name, tool: this.tool.displayName, toolKey: this.tool.key,
-      status: this.status, state: this.getControlState(), messages, historyPage: historyPageMeta,
+      status: this.status, state: this.getControlState(), messages: this.messages.map(item => this.toPublicMessage(item)),
       pendingPermissions: [
         ...this.completedPermissions,
         ...Array.from(this.pendingPermissions.values()).map(item => item.public)
       ] };
   }
 
-  getMessagePage(beforeId = null, maxBytes = CODEX_MESSAGE_PAGE_BYTES) {
-    const requestedBeforeId = beforeId == null ? '' : String(beforeId);
-    let end = this.messages.length;
-    if (requestedBeforeId) {
-      const beforeIndex = this.messages.findIndex(item => String(item.id || '') === requestedBeforeId);
-      if (beforeIndex < 0) {
-        return { messages: [], hasMore: false, beforeId: null, bytes: 2, maxBytes };
-      }
-      end = beforeIndex;
-    }
-
-    if (end <= 0) return { messages: [], hasMore: false, beforeId: null, bytes: 2, maxBytes };
+  toPublicMessage(item) {
+    if (!item || typeof item !== 'object') return item;
+    const message = { ...item };
+    const isSubagent = Boolean(message.threadId && this.threadId && message.threadId !== this.threadId);
+    let hasDetail = false;
 
-    const groupStarts = [0];
-    for (let i = 1; i < end; i++) {
-      const item = this.messages[i];
-      if (item.kind === 'turn-start' && (!item.threadId || item.threadId === this.threadId)) {
-        groupStarts.push(i);
+    if (message.kind === 'tool') {
+      for (const field of ['result', 'input', 'changes', 'error', 'agentsStates']) {
+        const value = message[field];
+        if (value != null && value !== '' && (!Array.isArray(value) || value.length)) hasDetail = true;
+        delete message[field];
       }
+      if (item.error) message.hasError = true;
     }
-    groupStarts.push(end);
-
-    let start = end;
-    let selectedBytes = 2;
-    for (let groupIndex = groupStarts.length - 2; groupIndex >= 0; groupIndex--) {
-      const candidateStart = groupStarts[groupIndex];
-      const candidate = this.messages.slice(candidateStart, end);
-      const candidateBytes = Buffer.byteLength(JSON.stringify(candidate), 'utf8');
-      if (start < end && candidateBytes > maxBytes) break;
-      start = candidateStart;
-      selectedBytes = candidateBytes;
-      if (candidateBytes >= maxBytes) break;
+    if (isSubagent && ['user', 'assistant', 'reasoning', 'event'].includes(message.kind)) {
+      if (message.text) hasDetail = true;
+      delete message.text;
+      delete message.skills;
+    }
+    if (message.kind === 'reasoning') {
+      if (message.text) hasDetail = true;
+      delete message.text;
     }
+    message.hasDetail = hasDetail;
+    message.detailRevision = Number(item.updatedAt || item.createdAt || 0);
+    return message;
+  }
 
-    const messages = this.messages.slice(start, end);
-    return {
-      messages,
-      hasMore: start > 0,
-      beforeId: messages[0]?.id || null,
-      bytes: selectedBytes,
-      maxBytes
-    };
+  getMessageDetails({ ids = [], threadId = null } = {}) {
+    const requestedIds = new Set((Array.isArray(ids) ? ids : [])
+      .map(value => String(value || '')).filter(Boolean));
+    const requestedThreadId = threadId == null ? '' : String(threadId);
+    const messages = this.messages.filter(item => {
+      if (requestedThreadId && String(item.threadId || '') === requestedThreadId) return true;
+      return requestedIds.has(String(item.id || ''));
+    }).map(item => ({ ...item, detailLoaded: true }));
+    return { messages, threadId: requestedThreadId || null };
   }
 
   getControlState() {
@@ -340,12 +332,17 @@ class CodexStructuredSession extends EventEmitter {
   isRunning() { return this.running && (this.presentation !== 'terminal' || Boolean(this.terminalSession)); }
 
   createItem(item) { return { id: crypto.randomUUID(), createdAt: Date.now(), ...item }; }
-  append(item) { const next = this.createItem(item); this.messages.push(next); this.emitEvent({ type: 'message', message: next }); return next; }
+  append(item) {
+    const next = this.createItem(item);
+    this.messages.push(next);
+    if (!this.replayingHistory) this.emitEvent({ type: 'message', message: this.toPublicMessage(next) });
+    return next;
+  }
   patch(id, patch) {
     const item = this.messages.find(message => message.id === id);
     if (!item) return null;
     Object.assign(item, { updatedAt: Date.now() }, patch);
-    this.emitEvent({ type: 'message-updated', message: item });
+    if (!this.replayingHistory) this.emitEvent({ type: 'message-updated', message: this.toPublicMessage(item) });
     return item;
   }
   emitEvent(event) { this.emit('event', event); }
@@ -379,8 +376,14 @@ class CodexStructuredSession extends EventEmitter {
           for (const request of this.pendingRequests.values()) 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');
             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.setStatus('idle');
           }
         }
@@ -979,10 +982,12 @@ class CodexStructuredSession extends EventEmitter {
       this.currentTurnId = started?.turn?.id || started?.turnId || this.currentTurnId;
       return true;
     } catch (error) {
+      const failedAt = Date.now();
       this.currentTurnId = null;
       this.currentTurnStartedAt = null;
       this.setStatus('idle');
       this.append({ kind: 'event', level: 'error', text: `Unable to send message: ${error.message}` });
+      this.emitEvent({ type: 'turn-failed', createdAt: failedAt });
       throw error;
     }
   }
@@ -1112,10 +1117,12 @@ class CodexStructuredSession extends EventEmitter {
     if (!options.preserveEffort) this.effort = thread?.reasoningEffort || thread?.reasoning_effort || this.effort;
     this.tokenUsage = thread?.tokenUsage || thread?.token_usage || this.tokenUsage;
     this.messages = [];
+    this.replayingHistory = true;
     this.completedPermissions = [];
     this.turnContexts.clear();
     this.providerItemContexts.clear();
-    for (const turn of thread?.turns || []) {
+    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);
@@ -1134,11 +1141,12 @@ class CodexStructuredSession extends EventEmitter {
         || (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 {
+      this.replayingHistory = false;
     }
-    if (eventText) this.append({ kind: 'event', level: 'info', text: eventText });
-    const historyPage = this.getMessagePage();
-    const { messages, ...historyPageMeta } = historyPage;
-    this.emitEvent({ type: 'history-reset', messages, historyPage: historyPageMeta });
+    this.emitEvent({ type: 'history-reset', messages: this.messages.map(item => this.toPublicMessage(item)) });
     this.emitEvent({ type: 'state', state: this.getControlState() });
   }
 

package/lib/commands/web.js

@@ -46,6 +46,10 @@ const { getClaudeRuntimeConfig } = require('../claude/config');
 const registerScheduleRoutes = require('../server/routes/schedules');
 const registerWorkspaceRoutes = require('../server/routes/workspace');
 const registerProviderRoutes = require('../server/routes/providers');
+const registerNotificationRoutes = require('../server/routes/notifications');
+const { ServerChanSettingsStore } = require('../notifications/serverchan-settings-store');
+const ServerChanClient = require('../notifications/serverchan-client');
+const NotificationService = require('../notifications/notification-service');
 
 async function webCommand(options) {
   const port = parseInt(options.port) || 3000;
@@ -90,6 +94,13 @@ async function webCommand(options) {
     logger,
     hasConnectedSessionClient
   });
+  const serverChanSettings = new ServerChanSettingsStore();
+  const notificationService = new NotificationService({
+    sessionManager,
+    settingsStore: serverChanSettings,
+    channel: new ServerChanClient(),
+    logger
+  });
   sessionManager.on('output', ({ sessionId, data }) => {
     broadcastToSession(sessionId, { type: 'output', data });
   });
@@ -128,6 +139,10 @@ async function webCommand(options) {
   });
 
   registerScheduleRoutes(app, { jobStore, jobRunner });
+  registerNotificationRoutes(app, {
+    settingsStore: serverChanSettings,
+    notificationService
+  });
 
   // API: List all active sessions
   app.get('/api/sessions', (req, res) => {
@@ -377,10 +392,14 @@ async function webCommand(options) {
         if (payload.type === 'codex-compact') {
           sessionManager.compactCodexContext(sessionId).catch(error => logger.error(`Codex compact error: ${error.message}`));
         }
-        if (payload.type === 'codex-history-before') {
+        if (payload.type === 'codex-detail-request') {
           const codex = sessionManager.get(sessionId);
           if (codex && codex.kind === 'codex-structured' && codex.presentation === 'structured') {
-            ws.send(JSON.stringify({ type: 'codex-history-page', page: codex.getMessagePage(payload.beforeId) }));
+            ws.send(JSON.stringify({
+              type: 'codex-detail-response',
+              requestId: payload.requestId || null,
+              detail: codex.getMessageDetails({ ids: payload.ids, threadId: payload.threadId })
+            }));
           }
         }
         if (payload.type === 'codex-abort') {
@@ -453,6 +472,7 @@ async function webCommand(options) {
     'gitgraph.js',
     'styles.css',
     'core.js',
+    'notifications.js',
     'claude.js',
     'schedules.js',
     'shell.js',
@@ -514,6 +534,7 @@ async function webCommand(options) {
 
   process.on('SIGINT', () => { 
     schedulerService.stop();
+    notificationService.stop();
     sessionManager.killAll();
     process.exit(0); 
   });

package/lib/config/manager.js

@@ -8,6 +8,24 @@ const schema = {
     type: 'string',
     default: ''
   },
+  serverChan: {
+    type: 'object',
+    properties: {
+      sendKey: {
+        type: 'string',
+        default: ''
+      },
+      clientType: {
+        type: 'string',
+        enum: ['wechat', 'pushdeer'],
+        default: 'wechat'
+      }
+    },
+    default: {
+      sendKey: '',
+      clientType: 'wechat'
+    }
+  },
   version: {
     type: 'string',
     default: '1.0.0'

package/lib/notifications/message-formatter.js

@@ -0,0 +1,94 @@
+const path = require('path');
+
+const TITLE_LABELS = {
+  approval: '待审批',
+  completed: '已完成',
+  failed: '执行失败',
+  disconnected: '连接中断',
+  test: '通知测试'
+};
+
+function compactText(value, maxLength = 20) {
+  const text = String(value || '').replace(/[\r\n]+/g, ' ').trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(1, maxLength - 1))}…`;
+}
+
+function formatLocalDateTime(value) {
+  const date = new Date(Number(value) || Date.now());
+  const pad = number => String(number).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+    + `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+function formatDuration(durationMs) {
+  const totalSeconds = Math.max(0, Math.round(Number(durationMs) / 1000));
+  if (!Number.isFinite(totalSeconds) || totalSeconds <= 0) return '';
+  if (totalSeconds < 60) return `${totalSeconds}秒`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return seconds ? `${minutes}分${seconds}秒` : `${minutes}分`;
+}
+
+function escapeMarkdown(value) {
+  return String(value || '').replace(/([\\`*_{}\[\]()#+\-.!|>])/g, '\\$1');
+}
+
+function providerName(provider, session) {
+  if (provider === 'claude') return 'Claude';
+  if (provider === 'codex') return 'Codex';
+  return session?.tool?.displayName || 'AI';
+}
+
+function sessionDirectory(session) {
+  return session?.workingDir || session?.workingDirectory || session?.ptyManager?.workingDir || process.cwd();
+}
+
+function formatNotification({ kind, provider, session, durationMs = null }, clientType = 'wechat') {
+  const name = String(session?.name || providerName(provider, session));
+  const directory = sessionDirectory(session);
+  const type = providerName(provider, session);
+  const title = `${TITLE_LABELS[kind] || '通知'}｜${compactText(name)}`;
+  const details = [
+    ['类型', type],
+    ['会话', name],
+    ['创建', formatLocalDateTime(session?.startTime)],
+    ['目录', directory]
+  ];
+  const duration = formatDuration(durationMs);
+  if (duration) details.push(['本轮耗时', duration]);
+
+  if (clientType === 'pushdeer') {
+    return {
+      title,
+      description: details
+        .map(([label, value]) => label === '目录'
+          ? `**${label}：** \`${escapeMarkdown(value)}\``
+          : `**${label}：** ${escapeMarkdown(value)}`)
+        .join('\n\n')
+    };
+  }
+
+  return {
+    title,
+    description: details.map(([label, value]) => `${label}：${value}`).join('\n\n')
+  };
+}
+
+function createTestSession(session = null) {
+  if (session) return session;
+  return {
+    name: 'Glad 测试会话',
+    startTime: Date.now(),
+    workingDir: path.resolve(process.cwd()),
+    tool: { displayName: 'Glad' }
+  };
+}
+
+module.exports = {
+  formatNotification,
+  createTestSession,
+  compactText,
+  formatLocalDateTime,
+  formatDuration
+};

package/lib/notifications/notification-service.js

@@ -0,0 +1,143 @@
+const { formatNotification, createTestSession } = require('./message-formatter');
+
+class NotificationService {
+  constructor({ sessionManager, settingsStore, channel, logger = console }) {
+    this.sessionManager = sessionManager;
+    this.settingsStore = settingsStore;
+    this.channel = channel;
+    this.logger = logger;
+    this.seenEvents = new Map();
+    this.handlers = {
+      claude: payload => this.handleProviderEvent('claude', payload),
+      codex: payload => this.handleProviderEvent('codex', payload),
+      exit: payload => this.clearSession(payload.sessionId)
+    };
+    sessionManager.on('claude-event', this.handlers.claude);
+    sessionManager.on('codex-event', this.handlers.codex);
+    sessionManager.on('exit', this.handlers.exit);
+  }
+
+  stop() {
+    this.sessionManager.off('claude-event', this.handlers.claude);
+    this.sessionManager.off('codex-event', this.handlers.codex);
+    this.sessionManager.off('exit', this.handlers.exit);
+    this.seenEvents.clear();
+  }
+
+  getSessionState(sessionId) {
+    const session = this.sessionManager.get(sessionId);
+    if (!session) return null;
+    return {
+      enabled: Boolean(session.serverChanNotificationEnabled),
+      configured: this.settingsStore.getPublic().configured
+    };
+  }
+
+  async setSessionEnabled(sessionId, enabled) {
+    const session = this.sessionManager.get(sessionId);
+    if (!session) {
+      const error = new Error('Session not found');
+      error.statusCode = 404;
+      throw error;
+    }
+    if (enabled && !this.settingsStore.getPublic().configured) {
+      const error = new Error('请先配置 Server酱');
+      error.statusCode = 409;
+      error.code = 'SERVERCHAN_NOT_CONFIGURED';
+      throw error;
+    }
+    session.serverChanNotificationEnabled = Boolean(enabled);
+    if (enabled && session.pendingPermissions?.size > 0) {
+      await this.sendEvent({
+        kind: 'approval',
+        provider: session.kind === 'claude-structured' ? 'claude' : 'codex',
+        session
+      });
+    }
+    return this.getSessionState(sessionId);
+  }
+
+  disableAllSessions() {
+    for (const session of this.sessionManager.sessions.values()) {
+      session.serverChanNotificationEnabled = false;
+    }
+  }
+
+  async sendTest(input = {}) {
+    const settings = this.settingsStore.resolve(input);
+    const session = createTestSession(
+      input.sessionId ? this.sessionManager.get(input.sessionId) : null
+    );
+    const provider = session?.kind === 'claude-structured'
+      ? 'claude'
+      : session?.kind === 'codex-structured' ? 'codex' : null;
+    const message = formatNotification({ kind: 'test', provider, session }, settings.clientType);
+    await this.channel.send({ ...settings, ...message });
+    return { success: true };
+  }
+
+  handleProviderEvent(provider, payload = {}) {
+    const { session, event, sessionId } = payload;
+    if (!session || !event || !session.serverChanNotificationEnabled) return;
+
+    if (event.type === 'permission-request') {
+      const requestId = event.request?.id || event.request?.toolUseId || 'pending';
+      if (!this.markSeen(sessionId, `approval:${requestId}`)) return;
+      this.sendEvent({ kind: 'approval', provider, session });
+      return;
+    }
+
+    if (event.type === 'runtime-disconnected') {
+      if (!event.activeTurn || !this.markSeen(sessionId, `disconnected:${event.turnId || 'active'}`)) return;
+      this.sendEvent({ kind: 'disconnected', provider, session });
+      return;
+    }
+
+    if (event.type === 'turn-failed') {
+      if (!this.markSeen(sessionId, `failed:${event.turnId || event.createdAt || 'start'}`)) return;
+      this.sendEvent({ kind: 'failed', provider, session, durationMs: event.durationMs });
+      return;
+    }
+
+    const message = event.type === 'message' ? event.message : null;
+    if (!message || message.kind !== 'turn-end') return;
+    if (provider === 'codex' && message.threadId && session.threadId && message.threadId !== session.threadId) return;
+
+    const status = String(message.turnStatus || message.status || 'completed');
+    if (status === 'cancelled' || status === 'interrupted') return;
+    const turnId = message.turnId || message.id;
+    if (!this.markSeen(sessionId, `turn:${turnId}`)) return;
+    this.sendEvent({
+      kind: status === 'failed' ? 'failed' : 'completed',
+      provider,
+      session,
+      durationMs: message.durationMs
+    });
+  }
+
+  markSeen(sessionId, key) {
+    const seen = this.seenEvents.get(sessionId) || new Set();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    if (seen.size > 100) seen.delete(seen.values().next().value);
+    this.seenEvents.set(sessionId, seen);
+    return true;
+  }
+
+  clearSession(sessionId) {
+    this.seenEvents.delete(sessionId);
+  }
+
+  async sendEvent(event) {
+    try {
+      const settings = this.settingsStore.get();
+      if (!settings.sendKey) return;
+      const message = formatNotification(event, settings.clientType);
+      await this.channel.send({ ...settings, ...message });
+    } catch (error) {
+      this.logger.error?.(`[serverchan] notification failed: ${error.message}`);
+    }
+  }
+}
+
+module.exports = NotificationService;

package/lib/notifications/serverchan-client.js

@@ -0,0 +1,58 @@
+const API_BASE = 'https://sctapi.ftqq.com';
+
+function sanitizeServerChanError(payload, fallback) {
+  const message = payload && typeof payload === 'object'
+    ? payload.message || payload.error || payload.data?.error
+    : '';
+  const text = String(message || fallback || 'Server酱发送失败').trim();
+  return text.slice(0, 300);
+}
+
+class ServerChanClient {
+  constructor({ fetchImpl = globalThis.fetch, timeoutMs = 10_000 } = {}) {
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+  }
+
+  async send({ sendKey, title, description = '' }) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchImpl(`${API_BASE}/${encodeURIComponent(sendKey)}.send`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams({
+          title: String(title || '').replace(/[\r\n]+/g, ' ').trim().slice(0, 64),
+          desp: String(description || '')
+        }),
+        signal: controller.signal
+      });
+      const text = await response.text();
+      let payload = null;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch (_) {
+        payload = null;
+      }
+      if (!response.ok || (payload && Number(payload.code) !== 0)) {
+        const error = new Error(sanitizeServerChanError(payload, `HTTP ${response.status}`));
+        error.statusCode = 502;
+        throw error;
+      }
+      return payload || { code: 0 };
+    } catch (error) {
+      if (error && error.name === 'AbortError') {
+        const timeoutError = new Error('Server酱请求超时');
+        timeoutError.statusCode = 504;
+        throw timeoutError;
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+module.exports = ServerChanClient;