replicas-engine 0.1.20 → 0.1.21

package/dist/src/index.js

@@ -34,6 +34,7 @@ import { Hono } from "hono";
 
 // src/services/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
+import { randomUUID } from "crypto";
 
 // src/utils/jsonl-reader.ts
 import { readFile } from "fs/promises";
@@ -55,7 +56,7 @@ async function readJSONL(filePath) {
 }
 
 // src/services/codex-manager.ts
-import { readdir, stat } from "fs/promises";
+import { readdir, stat, writeFile, mkdir } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
 
@@ -511,13 +512,14 @@ var MessageQueue = class {
    * Add a message to the queue or start processing immediately if not busy
    * @returns Object indicating whether the message was queued or started processing
    */
-  async enqueue(message, model, customInstructions) {
+  async enqueue(message, model, customInstructions, images) {
     const messageId = this.generateMessageId();
     const queuedMessage = {
       id: messageId,
       message,
       model,
       customInstructions,
+      images,
       queuedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (this.processing) {
@@ -542,7 +544,8 @@ var MessageQueue = class {
       await this.processMessage(
         queuedMessage.message,
         queuedMessage.model,
-        queuedMessage.customInstructions
+        queuedMessage.customInstructions,
+        queuedMessage.images
       );
     } catch (error) {
       console.error("[MessageQueue] Error processing message:", error);
@@ -601,6 +604,66 @@ var MessageQueue = class {
   }
 };
 
+// src/utils/image-utils.ts
+function inferMediaType(url, contentType) {
+  if (contentType) {
+    const normalized = contentType.toLowerCase().split(";")[0].trim();
+    if (normalized === "image/png" || normalized === "image/jpeg" || normalized === "image/gif" || normalized === "image/webp") {
+      return normalized;
+    }
+    if (normalized === "image/jpg") {
+      return "image/jpeg";
+    }
+  }
+  const urlLower = url.toLowerCase();
+  if (urlLower.includes(".png")) return "image/png";
+  if (urlLower.includes(".jpg") || urlLower.includes(".jpeg")) return "image/jpeg";
+  if (urlLower.includes(".gif")) return "image/gif";
+  if (urlLower.includes(".webp")) return "image/webp";
+  return "image/jpeg";
+}
+async function fetchImageAsBase64(url) {
+  const headers = {};
+  if (new URL(url).hostname === "uploads.linear.app") {
+    const token = process.env.LINEAR_TOKEN;
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type");
+  const mediaType = inferMediaType(url, contentType);
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  const data = buffer.toString("base64");
+  return {
+    type: "base64",
+    media_type: mediaType,
+    data
+  };
+}
+async function normalizeImages(images) {
+  const normalized = [];
+  for (const image of images) {
+    if (image.source.type === "base64") {
+      normalized.push({
+        type: "image",
+        source: image.source
+      });
+    } else if (image.source.type === "url") {
+      const base64Source = await fetchImageAsBase64(image.source.url);
+      normalized.push({
+        type: "image",
+        source: base64Source
+      });
+    }
+  }
+  return normalized;
+}
+
 // src/services/codex-manager.ts
 var CodexManager = class {
   codex;
@@ -609,6 +672,7 @@ var CodexManager = class {
   workingDirectory;
   messageQueue;
   baseSystemPrompt;
+  tempImageDir;
   constructor(workingDirectory) {
     this.codex = new Codex();
     if (workingDirectory) {
@@ -622,6 +686,7 @@ var CodexManager = class {
         this.workingDirectory = workspaceHome;
       }
     }
+    this.tempImageDir = join(homedir(), ".replicas", "codex", "temp-images");
     this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
   }
   isProcessing() {
@@ -632,8 +697,8 @@ var CodexManager = class {
    * If already processing, adds to queue.
    * @returns Object with queued status, messageId, and position in queue
    */
-  async enqueueMessage(message, model, customInstructions) {
-    return this.messageQueue.enqueue(message, model, customInstructions);
+  async enqueueMessage(message, model, customInstructions, images) {
+    return this.messageQueue.enqueue(message, model, customInstructions, images);
   }
   /**
    * Get the current queue status
@@ -658,15 +723,37 @@ var CodexManager = class {
    * Legacy sendMessage method - now uses the queue internally
    * @deprecated Use enqueueMessage for better control over queue status
    */
-  async sendMessage(message, model, customInstructions) {
-    await this.enqueueMessage(message, model, customInstructions);
+  async sendMessage(message, model, customInstructions, images) {
+    await this.enqueueMessage(message, model, customInstructions, images);
+  }
+  /**
+   * Helper method to save normalized images to temp files for Codex SDK
+   * @returns Array of temp file paths
+   */
+  async saveImagesToTempFiles(images) {
+    await mkdir(this.tempImageDir, { recursive: true });
+    const tempPaths = [];
+    for (const image of images) {
+      const ext = image.source.media_type.split("/")[1] || "png";
+      const filename = `img_${randomUUID()}.${ext}`;
+      const filepath = join(this.tempImageDir, filename);
+      const buffer = Buffer.from(image.source.data, "base64");
+      await writeFile(filepath, buffer);
+      tempPaths.push(filepath);
+    }
+    return tempPaths;
   }
   /**
    * Internal method that actually processes the message
    */
-  async processMessageInternal(message, model, customInstructions) {
+  async processMessageInternal(message, model, customInstructions, images) {
     const linearSessionId = process.env.LINEAR_SESSION_ID;
+    let tempImagePaths = [];
     try {
+      if (images && images.length > 0) {
+        const normalizedImages = await normalizeImages(images);
+        tempImagePaths = await this.saveImagesToTempFiles(normalizedImages);
+      }
       if (!this.currentThread) {
         if (this.currentThreadId) {
           this.currentThread = this.codex.resumeThread(this.currentThreadId, {
@@ -705,7 +792,17 @@ ${customInstructions}`;
           }
         }
       }
-      const { events } = await this.currentThread.runStreamed(message);
+      let input;
+      if (tempImagePaths.length > 0) {
+        const inputItems = [
+          { type: "text", text: message },
+          ...tempImagePaths.map((path5) => ({ type: "local_image", path: path5 }))
+        ];
+        input = inputItems;
+      } else {
+        input = message;
+      }
+      const { events } = await this.currentThread.runStreamed(input);
       for await (const event of events) {
         if (linearSessionId) {
           const linearEvent = convertCodexEvent(event, linearSessionId);
@@ -836,11 +933,11 @@ var codexManager = new CodexManager();
 codex.post("/send", async (c) => {
   try {
     const body = await c.req.json();
-    const { message, model, customInstructions } = body;
+    const { message, model, customInstructions, images } = body;
     if (!message || typeof message !== "string") {
       return c.json({ error: "Message is required and must be a string" }, 400);
     }
-    const result = await codexManager.enqueueMessage(message, model, customInstructions);
+    const result = await codexManager.enqueueMessage(message, model, customInstructions, images);
     const response = {
       success: true,
       message: result.queued ? `Message queued at position ${result.position}` : "Message sent successfully",
@@ -959,7 +1056,7 @@ import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
 import { join as join2 } from "path";
-import { mkdir, appendFile, rm } from "fs/promises";
+import { mkdir as mkdir2, appendFile, rm } from "fs/promises";
 import { homedir as homedir2 } from "os";
 var ClaudeManager = class {
   workingDirectory;
@@ -992,9 +1089,9 @@ var ClaudeManager = class {
    * If already processing, adds to queue.
    * @returns Object with queued status, messageId, and position in queue
    */
-  async enqueueMessage(message, model, customInstructions) {
+  async enqueueMessage(message, model, customInstructions, images) {
     await this.initialized;
-    return this.messageQueue.enqueue(message, model, customInstructions);
+    return this.messageQueue.enqueue(message, model, customInstructions, images);
   }
   /**
    * Get the current queue status
@@ -1019,29 +1116,43 @@ var ClaudeManager = class {
    * Legacy sendMessage method - now uses the queue internally
    * @deprecated Use enqueueMessage for better control over queue status
    */
-  async sendMessage(message, model, customInstructions) {
-    await this.enqueueMessage(message, model, customInstructions);
+  async sendMessage(message, model, customInstructions, images) {
+    await this.enqueueMessage(message, model, customInstructions, images);
   }
   /**
    * Internal method that actually processes the message
    */
-  async processMessageInternal(message, model, customInstructions) {
+  async processMessageInternal(message, model, customInstructions, images) {
     const linearSessionId = process.env.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
       throw new Error("Message cannot be empty");
     }
     await this.initialized;
     try {
+      const content = [
+        {
+          type: "text",
+          text: message
+        }
+      ];
+      if (images && images.length > 0) {
+        const normalizedImages = await normalizeImages(images);
+        for (const image of normalizedImages) {
+          content.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: image.source.media_type,
+              data: image.source.data
+            }
+          });
+        }
+      }
       const userMessage = {
         type: "user",
         message: {
           role: "user",
-          content: [
-            {
-              type: "text",
-              text: message
-            }
-          ]
+          content
         },
         parent_tool_use_id: null,
         session_id: this.sessionId ?? ""
@@ -1128,7 +1239,7 @@ ${customInstructions}`;
   }
   async initialize() {
     const historyDir = join2(homedir2(), ".replicas", "claude");
-    await mkdir(historyDir, { recursive: true });
+    await mkdir2(historyDir, { recursive: true });
   }
   async handleMessage(message) {
     if ("session_id" in message && message.session_id && !this.sessionId) {
@@ -1153,11 +1264,11 @@ var claudeManager = new ClaudeManager();
 claude.post("/send", async (c) => {
   try {
     const body = await c.req.json();
-    const { message, model, customInstructions } = body;
+    const { message, model, customInstructions, images } = body;
     if (!message || typeof message !== "string") {
       return c.json({ error: "Message is required and must be a string" }, 400);
     }
-    const result = await claudeManager.enqueueMessage(message, model, customInstructions);
+    const result = await claudeManager.enqueueMessage(message, model, customInstructions, images);
     const response = {
       success: true,
       message: result.queued ? `Message queued at position ${result.position}` : "Message sent successfully",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",