glad-web 1.0.28 → 1.0.30

package/lib/session/session-manager.js

@@ -1,7 +1,6 @@
 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');
@@ -10,6 +9,8 @@ const CircularBuffer = require('./buffer');
 const { getToolByKey } = require('../ai-tools/registry');
 const ClaudeStructuredSession = require('../claude/structured-session');
 const CodexStructuredSession = require('../codex/structured-session');
+const ClaudeTranscriptRepository = require('../claude/transcript-repository');
+const CodexImageStore = require('../codex/image-store');
 
 function previewText(text, maxChars = 320) {
   if (!text) return '';
@@ -21,32 +22,15 @@ function previewText(text, maxChars = 320) {
   return normalized.length > maxChars ? normalized.slice(-maxChars) : normalized;
 }
 
-const CODEX_IMAGE_MAX_BYTES = 50 * 1024 * 1024;
-const CODEX_IMAGE_MAX_PER_SESSION = 5;
-const CODEX_IMAGE_CLEANUP_DELAY_MS = 5 * 60 * 1000;
-const CODEX_IMAGE_MAX_CHUNKS = 128;
-
-function detectImageExtension(buffer) {
-  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
-  if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return 'png';
-  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return 'jpg';
-  if (buffer.subarray(0, 6).equals(Buffer.from('GIF87a')) || buffer.subarray(0, 6).equals(Buffer.from('GIF89a'))) return 'gif';
-  if (buffer.subarray(0, 4).equals(Buffer.from('RIFF')) && buffer.subarray(8, 12).equals(Buffer.from('WEBP'))) return 'webp';
-  return null;
-}
-
-function attachmentError(message, statusCode = 400) {
-  const error = new Error(message);
-  error.statusCode = statusCode;
-  return error;
-}
-
-function isSafeUploadId(value) {
-  return typeof value === 'string' && /^[a-zA-Z0-9-]{8,100}$/.test(value);
+function imageMediaType(name) {
+  const extension = path.extname(String(name || '')).toLowerCase();
+  return extension === '.png' ? 'image/png'
+    : extension === '.jpg' || extension === '.jpeg' ? 'image/jpeg'
+      : extension === '.gif' ? 'image/gif' : 'image/webp';
 }
 
 class SessionManager extends EventEmitter {
-  constructor({ baseDir, renderHistoryTools, debugHistoryEnabled = false, logger, hasConnectedSessionClient } = {}) {
+  constructor({ baseDir, renderHistoryTools, debugHistoryEnabled = false, logger, hasConnectedSessionClient, claudeTranscriptRepository, codexImageStore, claudeForkSession } = {}) {
     super();
     this.baseDir = baseDir || process.cwd();
     this.renderHistoryTools = renderHistoryTools || new Set();
@@ -54,8 +38,25 @@ class SessionManager extends EventEmitter {
     this.logger = logger || console;
     this.hasConnectedSessionClient = hasConnectedSessionClient || (() => false);
     this.sessions = new Map();
-    this.codexImageRoot = path.join(os.tmpdir(), 'glad', 'codex-images');
-    this.codexImageUploadRoot = path.join(os.tmpdir(), 'glad', 'codex-image-uploads');
+    this.codexImages = codexImageStore || new CodexImageStore({ logger: this.logger });
+    Object.defineProperties(this, {
+      codexImageRoot: {
+        get: () => this.codexImages.root,
+        set: value => { this.codexImages.root = value; }
+      },
+      codexImageUploadRoot: {
+        get: () => this.codexImages.uploadRoot,
+        set: value => { this.codexImages.uploadRoot = value; }
+      }
+    });
+    this.claudeTranscripts = claudeTranscriptRepository || new ClaudeTranscriptRepository({
+      baseDir: this.baseDir,
+      logger: this.logger
+    });
+    this.claudeForkSession = claudeForkSession || (async (sessionId, options) => {
+      const sdk = await import('@anthropic-ai/claude-agent-sdk');
+      return sdk.forkSession(sessionId, options);
+    });
   }
 
   list() {
@@ -183,6 +184,8 @@ class SessionManager extends EventEmitter {
       logger: this.logger,
       options: claudeOptions
     });
+    session.imageAttachments = new Map();
+    session.imageUploads = new Map();
 
     this.sessions.set(id, session);
     session.on('event', event => this.emit('claude-event', { sessionId: id, event, session }));
@@ -224,148 +227,71 @@ class SessionManager extends EventEmitter {
     return session.ptyManager.write(data);
   }
 
-  sendClaudeInput(id, text) {
+  async sendClaudeInput(id, text, attachmentIds = []) {
     const session = this.get(id);
     if (!session || session.kind !== 'claude-structured') return false;
-    this.markSessionInput(session, text);
-    return session.sendUserMessage(text);
+    const attachments = this.getImageAttachments(id, attachmentIds);
+    const prompt = String(text || '');
+    if (!prompt.trim() && attachments.length === 0) return false;
+    const prepared = await Promise.all(attachments.map(async attachment => ({
+      id: attachment.id,
+      name: attachment.name,
+      size: attachment.size,
+      mediaType: imageMediaType(attachment.name),
+      data: (await fs.promises.readFile(attachment.path)).toString('base64')
+    })));
+    this.markSessionInput(session, prompt || '[image attachment]');
+    const sent = session.sendUserMessage(prompt, prepared);
+    if (sent && attachments.length) this.scheduleImageCleanup(id, attachments.map(item => item.id));
+    return sent;
   }
 
-  async storeCodexImageAttachment(id, bytes) {
-    const session = this.get(id);
-    if (!session) throw attachmentError('Session not found', 404);
-    if (session.kind !== 'codex-structured' || session.presentation !== 'structured') {
-      throw attachmentError('Image attachments are available only in Codex chat mode');
-    }
-    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw attachmentError('Image data is required');
-    if (bytes.length > CODEX_IMAGE_MAX_BYTES) throw attachmentError('Image must be 50 MB or smaller');
-    if (session.imageAttachments.size >= CODEX_IMAGE_MAX_PER_SESSION) {
-      throw attachmentError(`You can attach at most ${CODEX_IMAGE_MAX_PER_SESSION} images at a time`);
-    }
+  storeImageAttachment(id, bytes) {
+    return this.codexImages.store(this.get(id), bytes);
+  }
 
-    const extension = detectImageExtension(bytes);
-    if (!extension) throw attachmentError('Only PNG, JPEG, GIF, and WebP images are supported');
+  appendImageChunk(id, input = {}, bytes) {
+    return this.codexImages.appendChunk(this.get(id), input, bytes);
+  }
 
-    const directory = path.join(this.codexImageRoot, session.id);
-    await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
-    const attachment = {
-      id: uuidv4(),
-      name: `image.${extension}`,
-      path: path.join(directory, `${uuidv4()}.${extension}`),
-      size: bytes.length,
-      createdAt: Date.now(),
-      cleanupTimer: null
-    };
-    await fs.promises.writeFile(attachment.path, bytes, { mode: 0o600, flag: 'wx' });
-    session.imageAttachments.set(attachment.id, attachment);
-    return { id: attachment.id, name: attachment.name, size: attachment.size };
+  discardImageUpload(id, uploadId) {
+    return this.codexImages.discardUpload(this.get(id), uploadId);
   }
 
-  async appendCodexImageChunk(id, input = {}, bytes) {
-    const session = this.get(id);
-    if (!session) throw attachmentError('Session not found', 404);
-    if (session.kind !== 'codex-structured' || session.presentation !== 'structured') {
-      throw attachmentError('Image attachments are available only in Codex chat mode');
-    }
-    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw attachmentError('Image chunk is required');
-    const uploadId = String(input.uploadId || '');
-    const chunkIndex = Number(input.chunkIndex);
-    const chunkTotal = Number(input.chunkTotal);
-    if (!isSafeUploadId(uploadId)) throw attachmentError('Invalid image upload id');
-    if (!Number.isInteger(chunkIndex) || !Number.isInteger(chunkTotal) || chunkIndex < 0 || chunkTotal < 1 || chunkTotal > CODEX_IMAGE_MAX_CHUNKS || chunkIndex >= chunkTotal) {
-      throw attachmentError('Invalid image chunk metadata');
-    }
+  discardImageAttachment(id, attachmentId) {
+    return this.codexImages.discardAttachment(this.get(id), attachmentId);
+  }
 
-    let upload = session.imageUploads.get(uploadId);
-    if (!upload) {
-      if (chunkIndex !== 0) throw attachmentError('Image upload must start with the first chunk');
-      const directory = path.join(this.codexImageUploadRoot, session.id);
-      await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
-      upload = {
-        id: uploadId,
-        path: path.join(directory, `${uploadId}.part`),
-        chunkTotal,
-        nextChunkIndex: 0,
-        bytes: 0
-      };
-      session.imageUploads.set(uploadId, upload);
-    }
-    if (upload.chunkTotal !== chunkTotal || upload.nextChunkIndex !== chunkIndex) {
-      throw attachmentError('Image chunks arrived out of order');
-    }
-    if (upload.bytes + bytes.length > CODEX_IMAGE_MAX_BYTES) {
-      await this.discardCodexImageUpload(id, uploadId);
-      throw attachmentError('Image must be 50 MB or smaller');
-    }
+  getImageAttachments(id, attachmentIds = []) {
+    return this.codexImages.resolve(this.get(id), attachmentIds);
+  }
 
-    if (chunkIndex === 0) await fs.promises.writeFile(upload.path, bytes, { mode: 0o600, flag: 'wx' });
-    else await fs.promises.appendFile(upload.path, bytes, { mode: 0o600 });
-    upload.bytes += bytes.length;
-    upload.nextChunkIndex += 1;
+  scheduleImageCleanup(id, attachmentIds) {
+    this.codexImages.scheduleCleanup(this.get(id), attachmentIds);
+  }
 
-    if (upload.nextChunkIndex < upload.chunkTotal) {
-      return { complete: false, receivedChunks: upload.nextChunkIndex, size: upload.bytes };
-    }
+  storeCodexImageAttachment(id, bytes) {
+    return this.storeImageAttachment(id, bytes);
+  }
 
-    session.imageUploads.delete(uploadId);
-    try {
-      const image = await fs.promises.readFile(upload.path);
-      const attachment = await this.storeCodexImageAttachment(id, image);
-      return { complete: true, attachment };
-    } finally {
-      await fs.promises.rm(upload.path, { force: true });
-    }
+  appendCodexImageChunk(id, input = {}, bytes) {
+    return this.appendImageChunk(id, input, bytes);
   }
 
-  async discardCodexImageUpload(id, uploadId) {
-    const session = this.get(id);
-    if (!session || !session.imageUploads || !isSafeUploadId(uploadId)) return false;
-    const upload = session.imageUploads.get(uploadId);
-    if (!upload) return false;
-    session.imageUploads.delete(uploadId);
-    await fs.promises.rm(upload.path, { force: true });
-    return true;
+  discardCodexImageUpload(id, uploadId) {
+    return this.discardImageUpload(id, uploadId);
   }
 
-  async discardCodexImageAttachment(id, attachmentId) {
-    const session = this.get(id);
-    if (!session || session.kind !== 'codex-structured') return false;
-    const attachment = session.imageAttachments.get(attachmentId);
-    if (!attachment) return false;
-    clearTimeout(attachment.cleanupTimer);
-    session.imageAttachments.delete(attachmentId);
-    await fs.promises.rm(attachment.path, { force: true });
-    return true;
+  discardCodexImageAttachment(id, attachmentId) {
+    return this.discardImageAttachment(id, attachmentId);
   }
 
   getCodexImageAttachments(id, attachmentIds = []) {
-    const session = this.get(id);
-    if (!session || session.kind !== 'codex-structured') throw attachmentError('Codex session not found', 404);
-    const ids = Array.isArray(attachmentIds) ? attachmentIds : [];
-    if (ids.length > CODEX_IMAGE_MAX_PER_SESSION) throw attachmentError(`You can attach at most ${CODEX_IMAGE_MAX_PER_SESSION} images at a time`);
-    const uniqueIds = [...new Set(ids.map(value => String(value)))];
-    if (uniqueIds.length !== ids.length) throw attachmentError('Duplicate image attachment');
-    return uniqueIds.map(attachmentId => {
-      const attachment = session.imageAttachments.get(attachmentId);
-      if (!attachment) throw attachmentError('Image attachment is no longer available');
-      return attachment;
-    });
+    return this.getImageAttachments(id, attachmentIds);
   }
 
   scheduleCodexImageCleanup(id, attachmentIds) {
-    const session = this.get(id);
-    if (!session || session.kind !== 'codex-structured') return;
-    for (const attachmentId of attachmentIds) {
-      const attachment = session.imageAttachments.get(attachmentId);
-      if (!attachment) continue;
-      clearTimeout(attachment.cleanupTimer);
-      attachment.cleanupTimer = setTimeout(() => {
-        this.discardCodexImageAttachment(id, attachmentId).catch(error => {
-          this.logger.debugInfo?.(`[codex-image] cleanup failed: ${error.message}`);
-        });
-      }, CODEX_IMAGE_CLEANUP_DELAY_MS);
-      attachment.cleanupTimer.unref?.();
-    }
+    this.scheduleImageCleanup(id, attachmentIds);
   }
 
   async sendCodexInput(id, text, attachmentIds = []) {
@@ -392,6 +318,18 @@ class SessionManager extends EventEmitter {
     return session.updateSettings(settings || {});
   }
 
+  showClaudeUsage(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return Promise.resolve(false);
+    return session.showUsage();
+  }
+
+  showClaudeContext(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return Promise.resolve(false);
+    return session.showContext();
+  }
+
   abortClaude(id) {
     const session = this.get(id);
     if (!session || session.kind !== 'claude-structured') return false;
@@ -405,6 +343,29 @@ class SessionManager extends EventEmitter {
     return session.selectResumeSession(resumeSessionId, historyMessages);
   }
 
+  async forkClaude(id, sourceSessionId) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    if (session.status === 'thinking') {
+      const error = new Error('Claude must be idle before forking a session');
+      error.statusCode = 409;
+      throw error;
+    }
+    const sourceId = String(sourceSessionId || session.claudeSessionId || session.resumeSessionId || '').trim();
+    if (!sourceId) {
+      const error = new Error('No Claude session is available to fork');
+      error.statusCode = 400;
+      throw error;
+    }
+    const result = await this.claudeForkSession(sourceId, { dir: this.getSessionWorkingDirectory(session) });
+    const forkedId = result?.sessionId;
+    if (!forkedId) throw new Error('Claude SDK did not return a forked session id');
+    const historyMessages = this.readClaudeTranscriptMessages(this.getSessionWorkingDirectory(session), forkedId);
+    session.selectResumeSession(forkedId, historyMessages);
+    session.appendMessage({ kind: 'event', level: 'info', text: `Forked from Claude session ${sourceId}` });
+    return { id: session.id, name: session.name, claudeSessionId: forkedId };
+  }
+
   listClaudeResumeSessions(id) {
     const session = this.get(id);
     if (!session || session.kind !== 'claude-structured') return null;
@@ -716,192 +677,11 @@ class SessionManager extends EventEmitter {
   }
 
   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) : ''
-    };
+    return this.claudeTranscripts.list(workingDirectory);
   }
 
   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 '';
+    return this.claudeTranscripts.readMessages(workingDirectory, resumeSessionId);
   }
 
   logHistoryRequest(id, req) {
@@ -1048,20 +828,11 @@ class SessionManager extends EventEmitter {
   }
 
   clearCodexImageAttachments(session) {
-    if (!session || !session.imageAttachments) return;
-    for (const attachment of session.imageAttachments.values()) clearTimeout(attachment.cleanupTimer);
-    session.imageAttachments.clear();
-    fs.promises.rm(path.join(this.codexImageRoot, session.id), { recursive: true, force: true }).catch(error => {
-      this.logger.debugInfo?.(`[codex-image] session cleanup failed: ${error.message}`);
-    });
+    this.codexImages.clearAttachments(session);
   }
 
   clearCodexImageUploads(session) {
-    if (!session || !session.imageUploads) return;
-    session.imageUploads.clear();
-    fs.promises.rm(path.join(this.codexImageUploadRoot, session.id), { recursive: true, force: true }).catch(error => {
-      this.logger.debugInfo?.(`[codex-image] upload cleanup failed: ${error.message}`);
-    });
+    this.codexImages.clearUploads(session);
   }
 
   getSessionDiagnostics(session, extra = {}) {