replicas-engine 0.1.19 → 0.1.21

package/dist/src/index.js

@@ -4,7 +4,7 @@
 import "dotenv/config";
 import { serve } from "@hono/node-server";
 import { Hono as Hono3 } from "hono";
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { execSync as execSync2 } from "child_process";
 
 // src/middleware/auth.ts
@@ -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;
@@ -608,6 +671,8 @@ var CodexManager = class {
   currentThread = null;
   workingDirectory;
   messageQueue;
+  baseSystemPrompt;
+  tempImageDir;
   constructor(workingDirectory) {
     this.codex = new Codex();
     if (workingDirectory) {
@@ -621,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() {
@@ -631,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
@@ -640,19 +706,54 @@ var CodexManager = class {
   getQueueStatus() {
     return this.messageQueue.getStatus();
   }
+  /**
+   * Set the base system prompt from replicas.json
+   * This will be combined with any custom instructions passed to individual messages
+   */
+  setBaseSystemPrompt(prompt) {
+    this.baseSystemPrompt = prompt;
+  }
+  /**
+   * Get the current base system prompt
+   */
+  getBaseSystemPrompt() {
+    return this.baseSystemPrompt;
+  }
   /**
    * 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, {
@@ -668,8 +769,16 @@ var CodexManager = class {
             sandboxMode: "danger-full-access",
             model: model || "gpt-5.1-codex"
           });
-          if (customInstructions) {
-            message = customInstructions + "\n" + message;
+          let combinedInstructions;
+          if (this.baseSystemPrompt && customInstructions) {
+            combinedInstructions = `${this.baseSystemPrompt}
+
+${customInstructions}`;
+          } else {
+            combinedInstructions = this.baseSystemPrompt || customInstructions;
+          }
+          if (combinedInstructions) {
+            message = combinedInstructions + "\n" + message;
           }
           const { events: events2 } = await this.currentThread.runStreamed("Hello");
           for await (const event of events2) {
@@ -683,7 +792,17 @@ var CodexManager = class {
           }
         }
       }
-      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);
@@ -814,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",
@@ -937,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;
@@ -945,6 +1064,7 @@ var ClaudeManager = class {
   sessionId = null;
   initialized;
   messageQueue;
+  baseSystemPrompt;
   constructor(workingDirectory) {
     if (workingDirectory) {
       this.workingDirectory = workingDirectory;
@@ -969,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
@@ -979,33 +1099,60 @@ var ClaudeManager = class {
   getQueueStatus() {
     return this.messageQueue.getStatus();
   }
+  /**
+   * Set the base system prompt from replicas.json
+   * This will be combined with any custom instructions passed to individual messages
+   */
+  setBaseSystemPrompt(prompt) {
+    this.baseSystemPrompt = prompt;
+  }
+  /**
+   * Get the current base system prompt
+   */
+  getBaseSystemPrompt() {
+    return this.baseSystemPrompt;
+  }
   /**
    * 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 ?? ""
@@ -1014,6 +1161,14 @@ var ClaudeManager = class {
       const promptIterable = (async function* () {
         yield userMessage;
       })();
+      let combinedInstructions;
+      if (this.baseSystemPrompt && customInstructions) {
+        combinedInstructions = `${this.baseSystemPrompt}
+
+${customInstructions}`;
+      } else {
+        combinedInstructions = this.baseSystemPrompt || customInstructions;
+      }
       const response = query({
         prompt: promptIterable,
         options: {
@@ -1025,7 +1180,7 @@ var ClaudeManager = class {
           systemPrompt: {
             type: "preset",
             preset: "claude_code",
-            append: customInstructions
+            append: combinedInstructions
           },
           env: process.env,
           model: model || "opus"
@@ -1084,7 +1239,7 @@ var ClaudeManager = class {
   }
   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) {
@@ -1109,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",
@@ -1568,6 +1723,148 @@ async function initializeGitRepository() {
   }
 }
 
+// src/services/replicas-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var ReplicasConfigService = class {
+  config = null;
+  workingDirectory;
+  hooksExecuted = false;
+  constructor() {
+    const repoName = process.env.REPLICAS_REPO_NAME;
+    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir3();
+    if (repoName) {
+      this.workingDirectory = join3(workspaceHome, "workspaces", repoName);
+    } else {
+      this.workingDirectory = workspaceHome;
+    }
+  }
+  /**
+   * Initialize the service by reading replicas.json and executing start hooks
+   */
+  async initialize() {
+    await this.loadConfig();
+    await this.executeStartHooks();
+  }
+  /**
+   * Load and parse the replicas.json config file
+   */
+  async loadConfig() {
+    const configPath = join3(this.workingDirectory, "replicas.json");
+    if (!existsSync2(configPath)) {
+      console.log("No replicas.json found in workspace directory");
+      this.config = null;
+      return;
+    }
+    try {
+      const data = await readFile2(configPath, "utf-8");
+      const config = JSON.parse(data);
+      if (config.copy && !Array.isArray(config.copy)) {
+        throw new Error('Invalid replicas.json: "copy" must be an array of file paths');
+      }
+      if (config.ports && !Array.isArray(config.ports)) {
+        throw new Error('Invalid replicas.json: "ports" must be an array of port numbers');
+      }
+      if (config.ports && !config.ports.every((p) => typeof p === "number")) {
+        throw new Error("Invalid replicas.json: all ports must be numbers");
+      }
+      if (config.systemPrompt && typeof config.systemPrompt !== "string") {
+        throw new Error('Invalid replicas.json: "systemPrompt" must be a string');
+      }
+      if (config.startHook) {
+        if (typeof config.startHook !== "object" || Array.isArray(config.startHook)) {
+          throw new Error('Invalid replicas.json: "startHook" must be an object with "commands" array');
+        }
+        if (!Array.isArray(config.startHook.commands)) {
+          throw new Error('Invalid replicas.json: "startHook.commands" must be an array of shell commands');
+        }
+        if (!config.startHook.commands.every((cmd) => typeof cmd === "string")) {
+          throw new Error("Invalid replicas.json: all startHook.commands entries must be strings");
+        }
+        if (config.startHook.timeout !== void 0 && (typeof config.startHook.timeout !== "number" || config.startHook.timeout <= 0)) {
+          throw new Error('Invalid replicas.json: "startHook.timeout" must be a positive number');
+        }
+      }
+      this.config = config;
+      console.log("Loaded replicas.json config:", {
+        hasSystemPrompt: !!config.systemPrompt,
+        startHookCount: config.startHook?.commands.length ?? 0
+      });
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        console.error("Failed to parse replicas.json:", error.message);
+      } else if (error instanceof Error) {
+        console.error("Error loading replicas.json:", error.message);
+      }
+      this.config = null;
+    }
+  }
+  /**
+   * Execute all start hooks defined in replicas.json
+   */
+  async executeStartHooks() {
+    if (this.hooksExecuted) {
+      console.log("Start hooks already executed, skipping");
+      return;
+    }
+    const startHookConfig = this.config?.startHook;
+    if (!startHookConfig || startHookConfig.commands.length === 0) {
+      this.hooksExecuted = true;
+      return;
+    }
+    const timeout = startHookConfig.timeout ?? 3e5;
+    const hooks = startHookConfig.commands;
+    console.log(`Executing ${hooks.length} start hook(s) with timeout ${timeout}ms...`);
+    for (const hook of hooks) {
+      try {
+        console.log(`Running start hook: ${hook}`);
+        const { stdout, stderr } = await execAsync(hook, {
+          cwd: this.workingDirectory,
+          timeout,
+          env: process.env
+        });
+        if (stdout) {
+          console.log(`[${hook}] stdout:`, stdout);
+        }
+        if (stderr) {
+          console.warn(`[${hook}] stderr:`, stderr);
+        }
+        console.log(`Start hook completed: ${hook}`);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(`Start hook failed: ${hook}`, error.message);
+        }
+      }
+    }
+    this.hooksExecuted = true;
+    console.log("All start hooks completed");
+  }
+  /**
+   * Get the system prompt from replicas.json
+   */
+  getSystemPrompt() {
+    return this.config?.systemPrompt;
+  }
+  /**
+   * Get the full config object
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Check if start hooks have been executed
+   */
+  hasExecutedHooks() {
+    return this.hooksExecuted;
+  }
+};
+var replicasConfigService = new ReplicasConfigService();
+
 // src/index.ts
 var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
 var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
@@ -1583,7 +1880,7 @@ function checkActiveSSHSessions() {
 var app = new Hono3();
 app.get("/health", async (c) => {
   try {
-    const logContent = await readFile2("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile3("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";
@@ -1648,6 +1945,13 @@ serve(
     } else {
       console.warn(`Git initialization warning: ${gitResult.error}`);
     }
+    await replicasConfigService.initialize();
+    const systemPrompt = replicasConfigService.getSystemPrompt();
+    if (systemPrompt) {
+      claudeManager.setBaseSystemPrompt(systemPrompt);
+      codexManager.setBaseSystemPrompt(systemPrompt);
+      console.log("Applied system prompt from replicas.json to Claude and Codex managers");
+    }
     await githubTokenManager.start();
     await claudeTokenManager.start();
     await codexTokenManager.start();

package/package.json

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