glad-web 1.0.28 → 1.0.30

package/lib/claude/transcript-repository.js

@@ -0,0 +1,216 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+function previewText(text, maxChars) {
+  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+  return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}...` : normalized;
+}
+
+function isLocalCommandTranscript(text) {
+  const value = String(text || '').trim();
+  return value.startsWith('<command-name>/') || value.startsWith('<local-command-caveat>');
+}
+
+class ClaudeTranscriptRepository {
+  constructor({ baseDir, logger } = {}) {
+    this.baseDir = baseDir || process.cwd();
+    this.logger = logger || console;
+  }
+
+  list(workingDirectory) {
+    const projectDir = this.getProjectDirectory(workingDirectory);
+    if (!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.describe(file));
+  }
+
+  readMessages(workingDirectory, resumeSessionId) {
+    const id = String(resumeSessionId || '').trim();
+    if (!/^[0-9a-f-]{36}$/i.test(id)) return [];
+    const filePath = path.join(this.getProjectDirectory(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.parseLine(line);
+        if (!record || record.isSidechain) continue;
+        messages.push(...this.mapRecord(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;
+  }
+
+  getProjectDirectory(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);
+  }
+
+  describe(file) {
+    let cwd = '';
+    let firstText = '';
+    let lastText = '';
+    const userQuestions = [];
+    try {
+      const lines = fs.readFileSync(file.path, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        const parsed = this.parseLine(line);
+        if (!parsed) continue;
+        if (!cwd && typeof parsed.cwd === 'string') cwd = parsed.cwd;
+        const userText = this.extractUserText(parsed);
+        if (userText && userQuestions.at(-1) !== userText) userQuestions.push(userText);
+        const text = this.extractText(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,
+      questions: userQuestions.slice(-2).reverse().map(text => previewText(text, 120)),
+      firstText: firstText ? previewText(firstText, 120) : '',
+      lastText: lastText ? previewText(lastText, 160) : ''
+    };
+  }
+
+  mapRecord(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 && !isLocalCommandTranscript(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.textFromContent(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()) {
+            const text = item.text.trim();
+            return isLocalCommandTranscript(text) ? [] : [{ id: uuidv4(), kind: 'user', text, createdAt }];
+          }
+          return [];
+        });
+      }
+    }
+
+    if (record.type === 'assistant' && Array.isArray(content)) {
+      const mapped = [];
+      const text = this.textFromContent(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.summarizeToolInput(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 [];
+  }
+
+  textFromContent(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.textFromContent(item.content);
+      return '';
+    }).filter(Boolean).join('\n');
+  }
+
+  summarizeToolInput(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;
+  }
+
+  parseLine(line) {
+    try {
+      return JSON.parse(line);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  extractText(record) {
+    const content = record?.message?.content;
+    if (typeof content === 'string') return content.trim();
+    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_use') return `[tool] ${item.name || 'tool'}`;
+      return '';
+    }).filter(Boolean).join('\n').trim();
+  }
+
+  extractUserText(record) {
+    if (record?.type !== 'user') return '';
+    const content = record?.message?.content;
+    if (typeof content === 'string') {
+      const text = content.trim();
+      return isLocalCommandTranscript(text) ? '' : text;
+    }
+    if (!Array.isArray(content)) return '';
+    return content.map(item => item?.type === 'text' && typeof item.text === 'string' && !isLocalCommandTranscript(item.text) ? item.text : '')
+      .filter(Boolean).join('\n').trim();
+  }
+}
+
+module.exports = ClaudeTranscriptRepository;

package/lib/codex/image-store.js

@@ -0,0 +1,175 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+const MAX_BYTES = 50 * 1024 * 1024;
+const MAX_PER_SESSION = 5;
+const CLEANUP_DELAY_MS = 5 * 60 * 1000;
+const MAX_CHUNKS = 128;
+
+function imageExtension(buffer) {
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return 'png';
+  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return 'jpg';
+  if (buffer.length >= 6 && ['GIF87a', 'GIF89a'].includes(buffer.subarray(0, 6).toString('ascii'))) return 'gif';
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString('ascii') === 'RIFF' && buffer.subarray(8, 12).toString('ascii') === 'WEBP') return 'webp';
+  return null;
+}
+
+function inputError(message, statusCode = 400) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+
+function safeUploadId(value) {
+  return typeof value === 'string' && /^[a-zA-Z0-9-]{8,100}$/.test(value);
+}
+
+class CodexImageStore {
+  constructor({ logger, root, uploadRoot } = {}) {
+    this.logger = logger || console;
+    this.root = root || path.join(os.tmpdir(), 'glad', 'codex-images');
+    this.uploadRoot = uploadRoot || path.join(os.tmpdir(), 'glad', 'codex-image-uploads');
+  }
+
+  assertSession(session) {
+    if (!session) throw inputError('Session not found', 404);
+    const structured = session.kind === 'claude-structured'
+      || (session.kind === 'codex-structured' && session.presentation === 'structured');
+    if (!structured) {
+      throw inputError('Image attachments are available only in structured chat mode');
+    }
+  }
+
+  async store(session, bytes) {
+    this.assertSession(session);
+    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw inputError('Image data is required');
+    if (bytes.length > MAX_BYTES) throw inputError('Image must be 50 MB or smaller');
+    if (session.imageAttachments.size >= MAX_PER_SESSION) throw inputError(`You can attach at most ${MAX_PER_SESSION} images at a time`);
+
+    const extension = imageExtension(bytes);
+    if (!extension) throw inputError('Only PNG, JPEG, GIF, and WebP images are supported');
+    const directory = path.join(this.root, 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 };
+  }
+
+  async appendChunk(session, input = {}, bytes) {
+    this.assertSession(session);
+    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw inputError('Image chunk is required');
+    const uploadId = String(input.uploadId || '');
+    const chunkIndex = Number(input.chunkIndex);
+    const chunkTotal = Number(input.chunkTotal);
+    if (!safeUploadId(uploadId)) throw inputError('Invalid image upload id');
+    if (!Number.isInteger(chunkIndex) || !Number.isInteger(chunkTotal) || chunkIndex < 0 || chunkTotal < 1 || chunkTotal > MAX_CHUNKS || chunkIndex >= chunkTotal) {
+      throw inputError('Invalid image chunk metadata');
+    }
+
+    let upload = session.imageUploads.get(uploadId);
+    if (!upload) {
+      if (chunkIndex !== 0) throw inputError('Image upload must start with the first chunk');
+      const directory = path.join(this.uploadRoot, 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 inputError('Image chunks arrived out of order');
+    if (upload.bytes + bytes.length > MAX_BYTES) {
+      await this.discardUpload(session, uploadId);
+      throw inputError('Image must be 50 MB or smaller');
+    }
+
+    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;
+    if (upload.nextChunkIndex < upload.chunkTotal) {
+      return { complete: false, receivedChunks: upload.nextChunkIndex, size: upload.bytes };
+    }
+
+    session.imageUploads.delete(uploadId);
+    try {
+      const attachment = await this.store(session, await fs.promises.readFile(upload.path));
+      return { complete: true, attachment };
+    } finally {
+      await fs.promises.rm(upload.path, { force: true });
+    }
+  }
+
+  async discardUpload(session, uploadId) {
+    if (!session?.imageUploads || !safeUploadId(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;
+  }
+
+  async discardAttachment(session, attachmentId) {
+    if (!session || !['claude-structured', 'codex-structured'].includes(session.kind)) 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;
+  }
+
+  resolve(session, attachmentIds = []) {
+    if (!session || !['claude-structured', 'codex-structured'].includes(session.kind)) throw inputError('Structured session not found', 404);
+    const ids = Array.isArray(attachmentIds) ? attachmentIds : [];
+    if (ids.length > MAX_PER_SESSION) throw inputError(`You can attach at most ${MAX_PER_SESSION} images at a time`);
+    const uniqueIds = [...new Set(ids.map(String))];
+    if (uniqueIds.length !== ids.length) throw inputError('Duplicate image attachment');
+    return uniqueIds.map(attachmentId => {
+      const attachment = session.imageAttachments.get(attachmentId);
+      if (!attachment) throw inputError('Image attachment is no longer available');
+      return attachment;
+    });
+  }
+
+  scheduleCleanup(session, attachmentIds) {
+    if (!session || !['claude-structured', 'codex-structured'].includes(session.kind)) return;
+    for (const attachmentId of attachmentIds) {
+      const attachment = session.imageAttachments.get(attachmentId);
+      if (!attachment) continue;
+      clearTimeout(attachment.cleanupTimer);
+      attachment.cleanupTimer = setTimeout(() => {
+        this.discardAttachment(session, attachmentId).catch(error => {
+          this.logger.debugInfo?.(`[structured-image] cleanup failed: ${error.message}`);
+        });
+      }, CLEANUP_DELAY_MS);
+      attachment.cleanupTimer.unref?.();
+    }
+  }
+
+  clearAttachments(session) {
+    if (!session?.imageAttachments) return;
+    for (const attachment of session.imageAttachments.values()) clearTimeout(attachment.cleanupTimer);
+    session.imageAttachments.clear();
+    fs.promises.rm(path.join(this.root, session.id), { recursive: true, force: true }).catch(error => {
+      this.logger.debugInfo?.(`[structured-image] session cleanup failed: ${error.message}`);
+    });
+  }
+
+  clearUploads(session) {
+    if (!session?.imageUploads) return;
+    session.imageUploads.clear();
+    fs.promises.rm(path.join(this.uploadRoot, session.id), { recursive: true, force: true }).catch(error => {
+      this.logger.debugInfo?.(`[structured-image] upload cleanup failed: ${error.message}`);
+    });
+  }
+}
+
+module.exports = CodexImageStore;

package/lib/codex/structured-session.js

@@ -167,6 +167,7 @@ class CodexStructuredSession extends EventEmitter {
     this.currentTurnId = null;
     this.currentTurnStartedAt = null;
     this.threadTurns = new Map();
+    this.providerItemContexts = new Map();
     this.tokenUsage = null;
     this.permissionMode = normalizePermissionMode(options.permissionMode);
     this.sandboxMode = normalizeSandboxMode(options.sandboxMode);
@@ -481,17 +482,27 @@ class CodexStructuredSession extends EventEmitter {
     if (method === 'item/plan/delta') {
       const providerId = String(params.itemId || '');
       const target = this.messages.find(item => item.providerId === providerId && item.kind === 'reasoning');
-      if (target) this.patch(target.id, { text: String(target.text || '') + String(params.delta || '') });
-      else this.append({ kind: 'reasoning', providerId, text: String(params.delta || ''), streaming: true });
+      const known = this.providerItemContexts.get(providerId) || {};
+      const threadId = params.threadId || target?.threadId || known.threadId || null;
+      const turnId = params.turnId || target?.turnId || known.turnId
+        || (threadId ? this.threadTurns.get(threadId)?.turnId : null) || this.currentTurnId;
+      if (providerId && (threadId || turnId)) this.providerItemContexts.set(providerId, { threadId, turnId });
+      if (target) this.patch(target.id, { text: String(target.text || '') + String(params.delta || ''), threadId, turnId });
+      else this.append({ kind: 'reasoning', providerId, text: String(params.delta || ''), threadId, turnId, streaming: true });
       return;
     }
     if (method.includes('agentMessage/delta') || method.includes('reasoning/textDelta') || method.includes('reasoning/summaryTextDelta')) {
       const kind = method.includes('agentMessage') ? 'assistant' : 'reasoning';
       const itemId = String(params.itemId || params.id || '');
       const target = this.messages.find(item => item.providerId === itemId && item.kind === kind);
+      const known = this.providerItemContexts.get(itemId) || {};
+      const threadId = params.threadId || target?.threadId || known.threadId || null;
+      const turnId = params.turnId || target?.turnId || known.turnId
+        || (threadId ? this.threadTurns.get(threadId)?.turnId : null) || this.currentTurnId;
       const delta = String(params.delta || '');
-      if (target) this.patch(target.id, { text: (target.text || '') + delta });
-      else this.append({ kind, providerId: itemId, text: delta, streaming: true });
+      if (itemId && (threadId || turnId)) this.providerItemContexts.set(itemId, { threadId, turnId });
+      if (target) this.patch(target.id, { text: (target.text || '') + delta, threadId, turnId });
+      else this.append({ kind, providerId: itemId, text: delta, threadId, turnId, streaming: true });
       return;
     }
     if (method.startsWith('item/')) {
@@ -519,6 +530,7 @@ class CodexStructuredSession extends EventEmitter {
     const threadId = raw.threadId || context.threadId || null;
     const trackedTurnId = threadId ? this.threadTurns.get(threadId)?.turnId : null;
     const turnId = raw.turnId || context.turnId || trackedTurnId || this.currentTurnId;
+    if (providerId && (threadId || turnId)) this.providerItemContexts.set(providerId, { threadId, turnId });
     const existingStartedAtMs = existing?.startedAtMs || existing?.createdAt || null;
     const startedAtMs = Number(context.startedAtMs || raw.startedAtMs || 0)
       || toTimestampMs(raw.startedAt || raw.createdAt) || existingStartedAtMs;
@@ -836,6 +848,7 @@ class CodexStructuredSession extends EventEmitter {
     this.tokenUsage = thread?.tokenUsage || thread?.token_usage || this.tokenUsage;
     this.messages = [];
     this.completedPermissions = [];
+    this.providerItemContexts.clear();
     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);
@@ -846,6 +859,7 @@ class CodexStructuredSession extends EventEmitter {
       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
         });