farming-code 2.2.8 → 2.2.12

package/backend/codex-transcript.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const os = require('os');
 const path = require('path');
+const { fileURLToPath } = require('url');
 const { findCodexRolloutFile } = require('./codex-rollout-follower');
 const {
   heartbeatAssistantMessage,
@@ -18,8 +19,12 @@ const USER_MESSAGE_BEGIN = '## My request for Codex:';
 const MAX_USER_IMAGES_PER_TURN = 6;
 const MAX_USER_IMAGE_URL_LENGTH = 5 * 1024 * 1024;
 const MAX_LOCAL_IMAGE_BYTES = 5 * 1024 * 1024;
+const MAX_USER_AUDIOS_PER_TURN = 6;
+const MAX_USER_AUDIO_URL_LENGTH = 10 * 1024 * 1024;
+const MAX_LOCAL_AUDIO_BYTES = 10 * 1024 * 1024;
 const MAX_USER_FILES_PER_TURN = 6;
 const MAX_USER_FILE_CONTENT_CHARS = 50_000;
+const CODEX_HISTORY_IMAGE_LINK_PATTERN = /\[@(?:image|[^\]]+\.(?:gif|jpe?g|png|svg|webp))\]\(([^)\n]+)\)/gi;
 
 const LOCAL_IMAGE_MIME_BY_EXT = {
   '.gif': 'image/gif',
@@ -30,6 +35,18 @@ const LOCAL_IMAGE_MIME_BY_EXT = {
   '.webp': 'image/webp',
 };
 
+const LOCAL_AUDIO_MIME_BY_EXT = {
+  '.aac': 'audio/aac',
+  '.flac': 'audio/flac',
+  '.m4a': 'audio/mp4',
+  '.mp3': 'audio/mpeg',
+  '.oga': 'audio/ogg',
+  '.ogg': 'audio/ogg',
+  '.opus': 'audio/ogg',
+  '.wav': 'audio/wav',
+  '.webm': 'audio/webm',
+};
+
 function normalizeText(value) {
   return String(value || '')
     .replace(/\r\n/g, '\n')
@@ -290,6 +307,81 @@ function stripRenderedComposerAttachmentBlocks(value, renderedKinds) {
     .trim();
 }
 
+function codexHistoryImageTargets(value) {
+  const text = String(value || '');
+  const targets = [];
+  let match;
+  CODEX_HISTORY_IMAGE_LINK_PATTERN.lastIndex = 0;
+  while ((match = CODEX_HISTORY_IMAGE_LINK_PATTERN.exec(text))) {
+    const target = String(match[1] || '').trim();
+    if (!target || targets.includes(target)) continue;
+    targets.push(target);
+    if (targets.length >= MAX_USER_IMAGES_PER_TURN) break;
+  }
+  return targets;
+}
+
+function localImagePathFromTarget(value) {
+  const target = String(value || '').trim();
+  if (!target || target.includes('\0') || /^data:/i.test(target)) return '';
+  if (/^file:\/\//i.test(target)) {
+    try {
+      return fileURLToPath(target);
+    } catch {
+      return '';
+    }
+  }
+  return path.isAbsolute(target) ? target : '';
+}
+
+function localImagePathsFromUserContent(content) {
+  const paths = [];
+  const append = (value) => {
+    const filePath = localImagePathFromTarget(value);
+    if (!filePath || !LOCAL_IMAGE_MIME_BY_EXT[path.extname(filePath).toLowerCase()] || paths.includes(filePath)) return;
+    paths.push(filePath);
+  };
+  for (const part of Array.isArray(content) ? content : []) {
+    if (!part || typeof part !== 'object') continue;
+    if (['local_image', 'localImage'].includes(part.type)) append(part.path || part.file || part.url);
+    const text = typeof part.text === 'string' ? part.text : '';
+    for (const match of text.matchAll(/<image\b[^>]*\bpath=(['"])(.*?)\1/gi)) append(match[2]);
+    for (const match of text.matchAll(/^##\s+[^\n:]+:\s*(.+)$/gim)) append(match[1]);
+  }
+  return paths.slice(0, MAX_USER_IMAGES_PER_TURN);
+}
+
+function dataImageUrlsFromUserContent(content) {
+  const urls = [];
+  for (const part of Array.isArray(content) ? content : []) {
+    if (!part || typeof part !== 'object' || !['input_image', 'inputImage', 'image'].includes(part.type)) continue;
+    const value = String(part.image_url || part.imageUrl || part.url || part.data || '');
+    if (!/^data:image\/(?:gif|jpe?g|png|svg\+xml|webp);base64,/i.test(value)) continue;
+    if (value.length > MAX_USER_IMAGE_URL_LENGTH || urls.includes(value)) continue;
+    urls.push(value);
+    if (urls.length >= MAX_USER_IMAGES_PER_TURN) break;
+  }
+  return urls;
+}
+
+function appendHistoryImageDataFromContent(imageDataByPath, content) {
+  const paths = localImagePathsFromUserContent(content);
+  const urls = dataImageUrlsFromUserContent(content);
+  for (let index = 0; index < Math.min(paths.length, urls.length); index += 1) {
+    if (!imageDataByPath.has(paths[index])) imageDataByPath.set(paths[index], urls[index]);
+  }
+}
+
+function stripRenderedCodexHistoryAttachmentLinks(value, renderedKinds) {
+  const text = normalizeText(value);
+  if (!text || !renderedKinds.has('image')) return text;
+  CODEX_HISTORY_IMAGE_LINK_PATTERN.lastIndex = 0;
+  return text
+    .replace(CODEX_HISTORY_IMAGE_LINK_PATTERN, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
 function visibleUserMessageText(value, options = {}) {
   const rawText = stripUserMessagePrefix(value);
   const heartbeatMessage = heartbeatUserMessage(rawText);
@@ -297,19 +389,24 @@ function visibleUserMessageText(value, options = {}) {
   const text = stripCodexInternalContextBlocks(rawText);
   if (isInjectedContextMessage(text)) return '';
   const renderedKinds = renderedAttachmentKindSet(options);
-  return stripRenderedComposerAttachmentBlocks(stripRenderedAttachmentTagBlocks(text, renderedKinds), renderedKinds);
+  return stripRenderedCodexHistoryAttachmentLinks(
+    stripRenderedComposerAttachmentBlocks(stripRenderedAttachmentTagBlocks(text, renderedKinds), renderedKinds),
+    renderedKinds,
+  );
 }
 
 function renderedAttachmentKindsForTurn(turn) {
   const kinds = [];
   if (turn && Array.isArray(turn.userImages) && turn.userImages.length > 0) kinds.push('image');
+  if (turn && Array.isArray(turn.userAudios) && turn.userAudios.length > 0) kinds.push('audio');
   if (turn && Array.isArray(turn.userFiles) && turn.userFiles.length > 0) kinds.push('file');
   return kinds;
 }
 
-function renderedAttachmentKindsForAttachments({ images = [], files = [] } = {}) {
+function renderedAttachmentKindsForAttachments({ images = [], audios = [], files = [] } = {}) {
   const kinds = [];
   if (Array.isArray(images) && images.length > 0) kinds.push('image');
+  if (Array.isArray(audios) && audios.length > 0) kinds.push('audio');
   if (Array.isArray(files) && files.length > 0) kinds.push('file');
   return kinds;
 }
@@ -409,6 +506,79 @@ function imagesFromContent(content) {
   return images;
 }
 
+function audioMimeFromUrl(url) {
+  const dataMime = String(url || '').match(/^data:(audio\/[^;,]+)[;,]/i)?.[1];
+  if (dataMime) return dataMime.toLowerCase();
+  try {
+    return LOCAL_AUDIO_MIME_BY_EXT[path.extname(new URL(url).pathname).toLowerCase()] || '';
+  } catch {
+    return '';
+  }
+}
+
+function audioNameFromPart(part, index) {
+  const explicit = compactInline(part?.name || part?.filename || '');
+  if (explicit) return explicit;
+  const target = String(part?.path || part?.url || '');
+  if (target && !/^data:/i.test(target)) {
+    try {
+      const basename = path.basename(new URL(target, 'file:///').pathname);
+      if (basename) return basename;
+    } catch {
+      const basename = path.basename(target);
+      if (basename) return basename;
+    }
+  }
+  return `Audio ${index + 1}`;
+}
+
+function audioFromLocalPath(filePath, index) {
+  const normalized = String(filePath || '').trim();
+  if (!normalized || normalized.includes('\0')) return null;
+  const mimeType = LOCAL_AUDIO_MIME_BY_EXT[path.extname(normalized).toLowerCase()];
+  if (!mimeType) return null;
+  try {
+    const stat = fs.statSync(normalized);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_LOCAL_AUDIO_BYTES) return null;
+    return {
+      id: `local-audio-${index + 1}`,
+      url: `data:${mimeType};base64,${fs.readFileSync(normalized).toString('base64')}`,
+      mimeType,
+      name: path.basename(normalized) || `Audio ${index + 1}`,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function audiosFromContent(content) {
+  if (!Array.isArray(content)) return [];
+  const audios = [];
+  for (const part of content) {
+    if (!part || typeof part !== 'object') continue;
+    let audio = null;
+    if (part.type === 'localAudio') {
+      audio = audioFromLocalPath(part.path, audios.length);
+    } else if (part.type === 'audio') {
+      const url = String(part.url || '');
+      if (
+        url.length <= MAX_USER_AUDIO_URL_LENGTH
+        && (/^data:audio\//i.test(url) || /^https?:\/\//i.test(url))
+      ) {
+        audio = {
+          id: `audio-${audios.length + 1}`,
+          url,
+          mimeType: audioMimeFromUrl(url),
+          name: audioNameFromPart(part, audios.length),
+        };
+      }
+    }
+    if (audio && !audios.some(existing => existing.url === audio.url)) audios.push(audio);
+    if (audios.length >= MAX_USER_AUDIOS_PER_TURN) break;
+  }
+  return audios;
+}
+
 function inlineImageFromEntry(entry, index) {
   if (typeof entry === 'string') {
     return isDisplayableImageUrl(entry)
@@ -967,7 +1137,7 @@ function detailForPlanSteps(steps) {
     .join('\n');
 }
 
-function applyUserMessageToTurn(turn, { id = '', message = '', images = [] } = {}) {
+function applyUserMessageToTurn(turn, { id = '', message = '', images = [], audios = [] } = {}) {
   if (!turn) return;
   const subagentNotification = parseSubagentNotification(message);
   if (subagentNotification) {
@@ -981,6 +1151,7 @@ function applyUserMessageToTurn(turn, { id = '', message = '', images = [] } = {
     return;
   }
   const userImages = Array.isArray(images) ? images.filter(Boolean) : [];
+  const userAudios = Array.isArray(audios) ? audios.filter(Boolean) : [];
   const pastedTranscript = extractReferencedPastedTranscriptContext(message);
   const approvalTranscript = extractCodexApprovalTranscriptContext(pastedTranscript.text);
   const userFiles = [
@@ -989,13 +1160,18 @@ function applyUserMessageToTurn(turn, { id = '', message = '', images = [] } = {
     ...extractComposerFileAttachments(approvalTranscript.text).files,
   ].slice(0, MAX_USER_FILES_PER_TURN);
   const text = visibleUserMessageText(approvalTranscript.text, {
-    renderedAttachmentKinds: renderedAttachmentKindsForAttachments({ images: userImages, files: userFiles }),
+    renderedAttachmentKinds: renderedAttachmentKindsForAttachments({
+      images: userImages,
+      audios: userAudios,
+      files: userFiles,
+    }),
   });
-  if (!text && userImages.length <= 0 && userFiles.length <= 0) return;
+  if (!text && userImages.length <= 0 && userAudios.length <= 0 && userFiles.length <= 0) return;
 
   if (!turn.userMessage) {
     if (text) turn.userMessage = text;
     if (userImages.length) turn.userImages = userImages;
+    if (userAudios.length) turn.userAudios = userAudios;
     if (userFiles.length) turn.userFiles = userFiles;
     return;
   }
@@ -1004,6 +1180,7 @@ function applyUserMessageToTurn(turn, { id = '', message = '', images = [] } = {
     text &&
     turn.userMessage === text &&
     userImages.length === 0 &&
+    userAudios.length === 0 &&
     userFiles.length === 0
   ) {
     return;
@@ -1015,6 +1192,7 @@ function applyUserMessageToTurn(turn, { id = '', message = '', images = [] } = {
     title: text || 'User added context',
     detail: text,
     images: userImages,
+    audios: userAudios,
     files: userFiles,
     status: 'completed',
   });
@@ -1025,10 +1203,12 @@ function appendTurnItem(turn, item, status = '') {
   if (!type) return false;
   if (type === 'usermessage') {
     const images = imagesFromContent(item.content);
+    const audios = audiosFromContent(item.content);
     applyUserMessageToTurn(turn, {
       id: item.id,
       message: textFromUserInput(item.content),
       images,
+      audios,
     });
     return true;
   }
@@ -1383,6 +1563,7 @@ function newTurn(id = '') {
     id: id || `turn-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     userMessage: '',
     userImages: [],
+    userAudios: [],
     userFiles: [],
     finalMessage: '',
     startedAt: null,
@@ -1399,6 +1580,7 @@ function newTurn(id = '') {
 function isEmptyTurn(turn) {
   return !turn.userMessage &&
     (!Array.isArray(turn.userImages) || turn.userImages.length === 0) &&
+    (!Array.isArray(turn.userAudios) || turn.userAudios.length === 0) &&
     (!Array.isArray(turn.userFiles) || turn.userFiles.length === 0) &&
     !turn.finalMessage &&
     turn.processItems.length === 0;
@@ -1444,7 +1626,13 @@ function sanitizeProcessItemForOutput(item) {
   if (!item || typeof item !== 'object') return null;
   const title = stripCodexInternalContextBlocks(item.title);
   const detail = stripCodexInternalContextBlocks(item.detail);
-  if (!title && !detail && (!Array.isArray(item.images) || item.images.length <= 0) && (!Array.isArray(item.files) || item.files.length <= 0)) {
+  if (
+    !title
+    && !detail
+    && (!Array.isArray(item.images) || item.images.length <= 0)
+    && (!Array.isArray(item.audios) || item.audios.length <= 0)
+    && (!Array.isArray(item.files) || item.files.length <= 0)
+  ) {
     return null;
   }
   return {
@@ -2276,10 +2464,11 @@ function isUserMessageLine(line) {
       if (turnItemType(payload.item) !== 'usermessage') return false;
       const text = textFromUserInput(payload.item?.content);
       const images = imagesFromContent(payload.item?.content);
+      const audios = audiosFromContent(payload.item?.content);
       const files = extractComposerFileAttachments(text).files;
       return Boolean(visibleUserMessageText(text, {
-        renderedAttachmentKinds: renderedAttachmentKindsForAttachments({ images, files }),
-      }) || images.length > 0 || files.length > 0);
+        renderedAttachmentKinds: renderedAttachmentKindsForAttachments({ images, audios, files }),
+      }) || images.length > 0 || audios.length > 0 || files.length > 0);
     }
     return false;
   } catch {
@@ -2323,6 +2512,36 @@ async function readCodexTranscript(sessionId, options = {}) {
   };
 }
 
+async function readCodexHistoryImageData(sessionId, options = {}) {
+  const normalizedSessionId = String(sessionId || '').trim();
+  if (!normalizedSessionId) return new Map();
+  const filePath = findCodexRolloutFile(normalizedSessionId, {
+    codexHome: options.codexHome || path.join(os.homedir(), '.codex'),
+  });
+  if (!filePath) return new Map();
+  const tail = await readTailLines(filePath, options.maxReadBytes);
+  const imageDataByPath = new Map();
+  for (const line of tail.lines) {
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      const { type: eventType, payload } = normalizeEventEnvelope(event);
+      if (!payload) continue;
+      if (eventType === 'response_item' && payload.type === 'message' && payload.role === 'user') {
+        appendHistoryImageDataFromContent(imageDataByPath, payload.content);
+        continue;
+      }
+      if (['item/started', 'item/completed', 'item.started', 'item.completed'].includes(eventType)) {
+        const item = payload.item;
+        if (turnItemType(item) === 'usermessage') appendHistoryImageDataFromContent(imageDataByPath, item?.content);
+      }
+    } catch {
+      // Ignore malformed or partial tail records; history replay remains usable without image recovery.
+    }
+  }
+  return imageDataByPath;
+}
+
 function buildTranscriptFromEvents(events, options = {}) {
   const lines = Array.isArray(events)
     ? events.filter(event => event && typeof event === 'object').map(event => JSON.stringify(event))
@@ -2334,8 +2553,11 @@ module.exports = {
   DEFAULT_MAX_TURNS,
   buildTranscriptFromEvents,
   buildTranscriptFromLines,
+  codexHistoryImageTargets,
   dropLeadingPartialTurn,
+  readCodexHistoryImageData,
   readCodexTranscript,
   stripUserMessagePrefix,
   textFromContent,
+  visibleUserMessageText,
 };

package/backend/config-manager.js

@@ -72,6 +72,8 @@ const PERSISTED_SETTING_KEYS = new Set([
   'workspace',
   'lastMainWorkspace',
   'workspaceHistory',
+  'projectWorkspaces',
+  'pinnedProjectWorkspaces',
   'projectNames',
   'theme',
   'appearance',
@@ -196,6 +198,31 @@ class ConfigManager {
     return result.slice(0, 5);
   }
 
+  normalizeProjectWorkspaces(projects) {
+    const entries = Array.isArray(projects) ? projects : [];
+    const result = [];
+    const seen = new Set();
+
+    for (const entry of entries) {
+      const expanded = this.expandWorkspacePath(entry);
+      if (!expanded) continue;
+      const resolved = path.resolve(expanded);
+      if (resolved === path.parse(resolved).root || this.isInternalWorkspace(resolved)) continue;
+      let canonical;
+      try {
+        canonical = fs.realpathSync(resolved);
+        if (!fs.statSync(canonical).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (seen.has(canonical)) continue;
+      seen.add(canonical);
+      result.push(canonical);
+    }
+
+    return result.slice(0, 200);
+  }
+
   normalizeMainPageSessionKeys(keys) {
     const entries = Array.isArray(keys) ? keys : [];
     const result = [];
@@ -260,6 +287,8 @@ class ConfigManager {
         workspace: this.farmingDir,
         lastMainWorkspace: this.farmingDir,
         workspaceHistory: [],
+        projectWorkspaces: [],
+        pinnedProjectWorkspaces: [],
         projectNames: {},
         theme: 'terminal',
         appearance: 'light',
@@ -294,6 +323,8 @@ class ConfigManager {
       workspace: this.farmingDir,
       lastMainWorkspace: this.farmingDir,
       workspaceHistory: [],
+      projectWorkspaces: [],
+      pinnedProjectWorkspaces: [],
       projectNames: {},
       theme: 'terminal',
       appearance: 'light',
@@ -342,6 +373,8 @@ class ConfigManager {
     this.settings.workspace = this.farmingDir;
     this.settings.lastMainWorkspace = this.normalizeMainWorkspace(this.settings.lastMainWorkspace, this.farmingDir);
     this.settings.workspaceHistory = this.normalizeWorkspaceHistory(this.settings.workspaceHistory);
+    this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
+    this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
     this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
     this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
     if (this.settings.updateUrl === LEGACY_DEFAULT_UPDATE_URL || this.settings.updateUrl === API_DEFAULT_UPDATE_URL) {
@@ -783,6 +816,8 @@ class ConfigManager {
     };
     this.settings.lastMainWorkspace = this.normalizeMainWorkspace(this.settings.lastMainWorkspace, previousMainWorkspace);
     this.settings.workspaceHistory = this.normalizeWorkspaceHistory(this.settings.workspaceHistory);
+    this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
+    this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
     this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
     this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
     this.settings.updateUrl = this.normalizeUpdateUrl(this.settings.updateUrl);