glad-web 1.0.45 → 2.0.1

package/lib/claude/transcript-repository.js

@@ -1,216 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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 = ['claude-structured', 'codex-structured'].includes(session.kind);
-    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;