glad-web 1.0.18 → 1.0.20

package/lib/session/session-manager.js

@@ -1,12 +1,14 @@
 const { EventEmitter } = require('events');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const { v4: uuidv4 } = require('uuid');
 const PTYManager = require('./pty-manager');
 const TextHistory = require('./text-history');
 const RenderedHistory = require('./rendered-history');
 const CircularBuffer = require('./buffer');
 const { getToolByKey } = require('../ai-tools/registry');
+const ClaudeStructuredSession = require('../claude/structured-session');
 
 function previewText(text, maxChars = 320) {
   if (!text) return '';
@@ -36,8 +38,12 @@ class SessionManager extends EventEmitter {
       tool: session.tool.displayName,
       startTime: session.startTime,
       toolKey: session.tool.key,
-      workingDirectory: session.ptyManager.workingDir,
-      hasUnreadCompletion: Boolean(session.hasUnreadCompletion)
+      workingDirectory: this.getSessionWorkingDirectory(session),
+      mode: session.kind === 'claude-structured' ? 'structured' : 'terminal',
+      hasUnreadCompletion: Boolean(session.hasUnreadCompletion),
+      timedInputCount: session.timedInputs
+        ? Array.from(session.timedInputs.values()).filter(item => item.sendAt > Date.now()).length
+        : 0
     }));
   }
 
@@ -49,7 +55,7 @@ class SessionManager extends EventEmitter {
     return this.sessions.has(id);
   }
 
-  create({ toolKey, workingDirectory, name }) {
+  create({ toolKey, workingDirectory, name, claudeOptions }) {
     this.logger.info(`Creating session: toolKey=${toolKey || ''}, workingDirectory=${workingDirectory || '(default)'}`);
     const tool = getToolByKey(toolKey);
     if (!tool) {
@@ -59,6 +65,10 @@ class SessionManager extends EventEmitter {
       throw err;
     }
 
+    if (tool.key === 'claude-code') {
+      return this.createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions });
+    }
+
     const id = uuidv4();
     const buffer = new CircularBuffer(500000);
     const textHistory = new TextHistory({ maxBytes: 20 * 1024 * 1024, debugLabel: id });
@@ -99,6 +109,7 @@ class SessionManager extends EventEmitter {
       resizeOwner: null,
       hasConnectedWebClient: false,
       hasUnreadCompletion: false,
+      timedInputs: new Map(),
       write: data => this.write(id, data),
       isRunning: () => this.has(id) && ptyManager.isRunning(),
       kill: () => this.kill(id)
@@ -121,16 +132,86 @@ class SessionManager extends EventEmitter {
     return session;
   }
 
+  createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions = {} }) {
+    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;
+      this.logger.error(`Create Claude session failed: missing directory ${sessionDir}`);
+      throw err;
+    }
+
+    const id = uuidv4();
+    const session = new ClaudeStructuredSession({
+      id,
+      tool,
+      workingDir: sessionDir,
+      name: name || tool.displayName,
+      logger: this.logger,
+      options: claudeOptions
+    });
+
+    this.sessions.set(id, session);
+    session.on('event', event => this.emit('claude-event', { sessionId: id, event, session }));
+    session.on('exit', () => this.handleExit(session));
+    this.logSessionDiagnostics('claude-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);
     return session.ptyManager.write(data);
   }
 
+  sendClaudeInput(id, text) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    this.markSessionInput(session, text);
+    return session.sendUserMessage(text);
+  }
+
+  respondClaudePermission(id, permissionId, approved) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    return session.respondPermission(permissionId, approved);
+  }
+
+  updateClaudeSettings(id, settings) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    return session.updateSettings(settings || {});
+  }
+
+  abortClaude(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    return session.abort('Aborted by user');
+  }
+
+  resumeClaude(id, resumeSessionId) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    const historyMessages = this.readClaudeTranscriptMessages(this.getSessionWorkingDirectory(session), resumeSessionId);
+    return session.selectResumeSession(resumeSessionId, historyMessages);
+  }
+
+  listClaudeResumeSessions(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    return this.scanClaudeProjectSessions(this.getSessionWorkingDirectory(session));
+  }
+
   resize(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
+    if (session.kind === 'claude-structured') return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -141,6 +222,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 (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -158,6 +240,11 @@ class SessionManager extends EventEmitter {
   markCompletionRead(id) {
     const session = this.get(id);
     if (!session) return null;
+    if (session.kind === 'claude-structured') {
+      session.markCompletionRead();
+      this.logSessionDiagnostics('completion-read', session, {}, { compact: true });
+      return session;
+    }
     session.hasUnreadCompletion = false;
     session.awaitingCompletion = false;
     session.isThinking = false;
@@ -167,12 +254,127 @@ class SessionManager extends EventEmitter {
     return session;
   }
 
+  listTimedInputs(id) {
+    const session = this.get(id);
+    if (!session) return null;
+    return Array.from(session.timedInputs.values()).map(item => ({
+      id: item.id,
+      text: item.text,
+      sendAt: item.sendAt,
+      createdAt: item.createdAt
+    })).sort((a, b) => a.sendAt - b.sendAt);
+  }
+
+  scheduleTimedInput(id, input = {}) {
+    const session = this.get(id);
+    if (!session) return null;
+
+    const { text, sendAt, delay } = this.validateTimedInput(input);
+
+    const item = {
+      id: uuidv4(),
+      text,
+      sendAt,
+      createdAt: Date.now(),
+      timer: null
+    };
+
+    item.timer = setTimeout(() => {
+      this.executeTimedInput(session.id, item.id);
+    }, delay);
+    session.timedInputs.set(item.id, item);
+    return {
+      id: item.id,
+      text: item.text,
+      sendAt: item.sendAt,
+      createdAt: item.createdAt
+    };
+  }
+
+  updateTimedInput(id, inputId, input = {}) {
+    const session = this.get(id);
+    if (!session) return null;
+    const item = session.timedInputs.get(inputId);
+    if (!item) return false;
+
+    const { text, sendAt, delay } = this.validateTimedInput(input);
+    clearTimeout(item.timer);
+    item.text = text;
+    item.sendAt = sendAt;
+    item.updatedAt = Date.now();
+    item.timer = setTimeout(() => {
+      this.executeTimedInput(session.id, item.id);
+    }, delay);
+
+    return {
+      id: item.id,
+      text: item.text,
+      sendAt: item.sendAt,
+      createdAt: item.createdAt,
+      updatedAt: item.updatedAt
+    };
+  }
+
+  validateTimedInput(input = {}) {
+    const text = String(input.text || '');
+    const sendAt = Number(input.sendAt);
+    if (!text.trim()) {
+      const err = new Error('Text is required');
+      err.statusCode = 400;
+      throw err;
+    }
+    if (!Number.isFinite(sendAt) || sendAt <= Date.now()) {
+      const err = new Error('Send time must be in the future');
+      err.statusCode = 400;
+      throw err;
+    }
+
+    const maxDelay = 30 * 24 * 60 * 60 * 1000;
+    const delay = sendAt - Date.now();
+    if (delay > maxDelay) {
+      const err = new Error('Send time must be within 30 days');
+      err.statusCode = 400;
+      throw err;
+    }
+
+    return { text, sendAt, delay };
+  }
+
+  cancelTimedInput(id, inputId) {
+    const session = this.get(id);
+    if (!session) return null;
+    const item = session.timedInputs.get(inputId);
+    if (!item) return false;
+    clearTimeout(item.timer);
+    session.timedInputs.delete(inputId);
+    return true;
+  }
+
+  executeTimedInput(id, inputId) {
+    const session = this.get(id);
+    if (!session) return false;
+    const item = session.timedInputs.get(inputId);
+    if (!item) return false;
+    session.timedInputs.delete(inputId);
+    const formatted = item.text.replace(/\n/g, '\r');
+    this.write(id, formatted);
+    setTimeout(() => {
+      if (this.has(id)) this.write(id, '\r');
+    }, 1000);
+    return true;
+  }
+
   kill(id) {
     const session = this.get(id);
     if (!session) return false;
     clearTimeout(session.completionTimer);
+    this.clearTimedInputs(session);
     this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
     this.disposeSessionHistory(session);
+    if (session.kind === 'claude-structured') {
+      session.ptyManager.kill();
+      return true;
+    }
     session.ptyManager.kill();
     this.sessions.delete(id);
     this.emit('exit', { sessionId: id, session });
@@ -182,6 +384,7 @@ class SessionManager extends EventEmitter {
   killAll() {
     for (const session of this.sessions.values()) {
       clearTimeout(session.completionTimer);
+      this.clearTimedInputs(session);
       this.disposeSessionHistory(session);
       session.ptyManager.kill();
     }
@@ -191,6 +394,7 @@ class SessionManager extends EventEmitter {
   getHistory(id) {
     const session = this.get(id);
     if (!session) return null;
+    if (session.kind === 'claude-structured') return session.getHistory();
     const historySource = session.renderedHistory || session.textHistory;
     return {
       success: true,
@@ -205,6 +409,7 @@ class SessionManager extends EventEmitter {
   getCatchupOutput(id) {
     const session = this.get(id);
     if (!session) return null;
+    if (session.kind === 'claude-structured') return session.getCatchupOutput();
 
     const bufferHistory = session.buffer.getAfter(0);
     if (bufferHistory.length > 0) {
@@ -234,6 +439,201 @@ class SessionManager extends EventEmitter {
     return session ? this.getSessionDiagnostics(session) : null;
   }
 
+  getClaudeSnapshot(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    return session.snapshot();
+  }
+
+  scanClaudeProjectSessions(workingDirectory) {
+    const projectDir = this.getClaudeProjectDir(workingDirectory);
+    if (!projectDir || !fs.existsSync(projectDir)) return [];
+    const files = fs.readdirSync(projectDir)
+      .filter(file => /^[0-9a-f-]{36}\.jsonl$/i.test(file))
+      .map(file => {
+        const fullPath = path.join(projectDir, file);
+        const stat = fs.statSync(fullPath);
+        return {
+          id: file.replace(/\.jsonl$/i, ''),
+          path: fullPath,
+          mtimeMs: stat.mtimeMs,
+          size: stat.size
+        };
+      })
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)
+      .slice(0, 40);
+
+    return files.map(file => this.describeClaudeSessionFile(file));
+  }
+
+  getClaudeProjectDir(workingDirectory) {
+    const cwd = path.resolve(workingDirectory || this.baseDir);
+    const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
+    return path.join(os.homedir(), '.claude', 'projects', encoded);
+  }
+
+  describeClaudeSessionFile(file) {
+    let cwd = '';
+    let firstText = '';
+    let lastText = '';
+    try {
+      const content = fs.readFileSync(file.path, 'utf8');
+      const lines = content.split('\n').filter(Boolean);
+      for (const line of lines) {
+        const parsed = this.parseClaudeJsonLine(line);
+        if (!parsed) continue;
+        if (!cwd && typeof parsed.cwd === 'string') cwd = parsed.cwd;
+        const text = this.extractClaudeTranscriptText(parsed);
+        if (!text) continue;
+        if (!firstText) firstText = text;
+        lastText = text;
+      }
+    } catch (error) {
+      this.logger.debugInfo?.(`[claude-resume] Failed to read ${file.path}: ${error.message}`);
+    }
+    return {
+      id: file.id,
+      cwd,
+      updatedAt: file.mtimeMs,
+      size: file.size,
+      firstText: firstText ? previewText(firstText, 120) : '',
+      lastText: lastText ? previewText(lastText, 160) : ''
+    };
+  }
+
+  readClaudeTranscriptMessages(workingDirectory, resumeSessionId) {
+    const id = String(resumeSessionId || '').trim();
+    if (!/^[0-9a-f-]{36}$/i.test(id)) return [];
+    const filePath = path.join(this.getClaudeProjectDir(workingDirectory), `${id}.jsonl`);
+    if (!fs.existsSync(filePath)) return [];
+
+    const messages = [];
+    try {
+      const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        const record = this.parseClaudeJsonLine(line);
+        if (!record || record.isSidechain) continue;
+        messages.push(...this.mapClaudeTranscriptRecord(record));
+      }
+    } catch (error) {
+      this.logger.debugInfo?.(`[claude-resume] Failed to backfill ${filePath}: ${error.message}`);
+      return [];
+    }
+
+    const maxMessages = 1000;
+    const visible = messages.filter(Boolean).slice(-maxMessages);
+    if (messages.length > maxMessages) {
+      visible.unshift({
+        id: uuidv4(),
+        kind: 'event',
+        level: 'info',
+        text: `Showing the latest ${maxMessages} resumed transcript items.`,
+        createdAt: Date.now()
+      });
+    }
+    return visible;
+  }
+
+  mapClaudeTranscriptRecord(record) {
+    const createdAt = Number.isFinite(Date.parse(record.timestamp)) ? Date.parse(record.timestamp) : Date.now();
+    const message = record.message || {};
+    const content = message.content;
+    if (record.type === 'user') {
+      if (typeof content === 'string') {
+        const text = content.trim();
+        return text ? [{ id: uuidv4(), kind: 'user', text, createdAt }] : [];
+      }
+      if (Array.isArray(content)) {
+        return content.flatMap(item => {
+          if (!item || typeof item !== 'object') return [];
+          if (item.type === 'tool_result') {
+            const text = this.textFromClaudeContent(item.content).trim();
+            return text ? [{
+              id: uuidv4(),
+              kind: 'tool-result',
+              toolUseId: item.tool_use_id,
+              text,
+              isError: Boolean(item.is_error),
+              createdAt
+            }] : [];
+          }
+          if (item.type === 'text' && typeof item.text === 'string' && item.text.trim()) {
+            return [{ id: uuidv4(), kind: 'user', text: item.text.trim(), createdAt }];
+          }
+          return [];
+        });
+      }
+    }
+
+    if (record.type === 'assistant' && Array.isArray(content)) {
+      const mapped = [];
+      const text = this.textFromClaudeContent(content).trim();
+      if (text) mapped.push({ id: uuidv4(), kind: 'assistant', text, createdAt });
+      for (const item of content) {
+        if (!item || item.type !== 'tool_use') continue;
+        mapped.push({
+          id: uuidv4(),
+          kind: 'tool',
+          name: item.name || 'tool',
+          summary: this.summarizeClaudeToolInput(item.input),
+          input: item.input,
+          toolUseId: item.id,
+          createdAt
+        });
+      }
+      return mapped;
+    }
+
+    if (record.type === 'summary' && typeof record.summary === 'string' && record.summary.trim()) {
+      return [{ id: uuidv4(), kind: 'event', level: 'info', text: `Summary: ${record.summary.trim()}`, createdAt }];
+    }
+
+    return [];
+  }
+
+  textFromClaudeContent(content) {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    return content.map(item => {
+      if (!item || typeof item !== 'object') return '';
+      if (item.type === 'text' && typeof item.text === 'string') return item.text;
+      if (item.type === 'tool_result') return this.textFromClaudeContent(item.content);
+      return '';
+    }).filter(Boolean).join('\n');
+  }
+
+  summarizeClaudeToolInput(input) {
+    if (!input || typeof input !== 'object') return '';
+    if (typeof input.command === 'string') return input.command;
+    if (typeof input.file_path === 'string') return input.file_path;
+    if (typeof input.path === 'string') return input.path;
+    const serialized = JSON.stringify(input);
+    return serialized.length > 240 ? serialized.slice(0, 240) + '...' : serialized;
+  }
+
+  parseClaudeJsonLine(line) {
+    try {
+      return JSON.parse(line);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  extractClaudeTranscriptText(record) {
+    const message = record && record.message;
+    const content = message && message.content;
+    if (typeof content === 'string') return content.trim();
+    if (Array.isArray(content)) {
+      return content.map(item => {
+        if (!item || typeof item !== 'object') return '';
+        if (item.type === 'text' && typeof item.text === 'string') return item.text;
+        if (item.type === 'tool_use') return `[tool] ${item.name || 'tool'}`;
+        return '';
+      }).filter(Boolean).join('\n').trim();
+    }
+    return '';
+  }
+
   logHistoryRequest(id, req) {
     const session = this.get(id);
     if (!session) return;
@@ -332,6 +732,7 @@ class SessionManager extends EventEmitter {
     if (!this.sessions.has(session.id)) return;
     this.logger.info(`Session ${session.id} (${session.name}) exited.`);
     clearTimeout(session.completionTimer);
+    this.clearTimedInputs(session);
     this.disposeSessionHistory(session);
     this.sessions.delete(session.id);
     this.emit('exit', { sessionId: session.id, session });
@@ -340,6 +741,14 @@ 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') {
+      session.hasUnreadCompletion = false;
+      this.logSessionDiagnostics('session-input', session, {
+        inputSeq: session.inputSeq,
+        inputPreview: previewText(data)
+      }, { compact: true });
+      return;
+    }
     session.awaitingCompletion = true;
     session.isThinking = false;
     session.hasUnreadCompletion = false;
@@ -351,13 +760,37 @@ class SessionManager extends EventEmitter {
   }
 
   disposeSessionHistory(session) {
+    if (session.kind === 'claude-structured') return;
     if (session.renderedHistory) {
       session.renderedHistory.dispose();
       session.renderedHistory = null;
     }
   }
 
+  clearTimedInputs(session) {
+    if (!session || !session.timedInputs) return;
+    for (const item of session.timedInputs.values()) {
+      clearTimeout(item.timer);
+    }
+    session.timedInputs.clear();
+  }
+
   getSessionDiagnostics(session, extra = {}) {
+    if (session.kind === 'claude-structured') {
+      return {
+        sessionId: session.id,
+        sessionName: session.name,
+        toolKey: session.tool.key,
+        kind: session.kind,
+        historyMode: 'structured',
+        status: session.status,
+        workingDirectory: this.getSessionWorkingDirectory(session),
+        messages: session.messages.length,
+        pendingPermissions: session.pendingPermissions.size,
+        timedInputCount: session.timedInputs ? session.timedInputs.size : 0,
+        ...extra
+      };
+    }
     return {
       sessionId: session.id,
       sessionName: session.name,
@@ -372,6 +805,9 @@ class SessionManager extends EventEmitter {
   }
 
   getCompactSessionDiagnostics(session, extra = {}) {
+    if (session.kind === 'claude-structured') {
+      return this.getSessionDiagnostics(session, extra);
+    }
     const buffer = session.buffer.getDebugSnapshot();
     const textHistory = session.textHistory.getDebugSnapshot();
     const renderedHistory = session.renderedHistory ? session.renderedHistory.getDebugSnapshot() : null;
@@ -425,6 +861,10 @@ class SessionManager extends EventEmitter {
       : this.getSessionDiagnostics(session, extra);
     this.logger.debugInfo(`[history-debug] ${reason} ${JSON.stringify(payload)}`);
   }
+
+  getSessionWorkingDirectory(session) {
+    return session.workingDir || (session.ptyManager && session.ptyManager.workingDir) || this.baseDir;
+  }
 }
 
 module.exports = SessionManager;