replicas-engine 0.1.20 → 0.1.22

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 readFile3 } from "fs/promises";
+import { readFile as readFile4 } 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,9 +56,9 @@ async function readJSONL(filePath) {
 }
 
 // src/services/codex-manager.ts
-import { readdir, stat } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
+import { readdir, stat, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/services/monolith-service.ts
 var MonolithService = class {
@@ -384,6 +385,53 @@ function convertCodexEvent(event, linearSessionId) {
 
 // src/utils/git.ts
 import { execSync } from "child_process";
+
+// src/services/engine-state.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var STATE_DIR = join(homedir(), ".replicas");
+var STATE_FILE = join(STATE_DIR, "engine-state.json");
+var DEFAULT_STATE = {
+  branch: null,
+  prUrl: null,
+  claudeSessionId: null,
+  codexThreadId: null
+};
+async function loadEngineState() {
+  try {
+    if (!existsSync(STATE_FILE)) {
+      return { ...DEFAULT_STATE };
+    }
+    const content = await readFile2(STATE_FILE, "utf-8");
+    const state = JSON.parse(content);
+    return {
+      ...DEFAULT_STATE,
+      ...state
+    };
+  } catch (error) {
+    console.error("[EngineState] Failed to load state, using defaults:", error);
+    return { ...DEFAULT_STATE };
+  }
+}
+async function saveEngineState(state) {
+  try {
+    await mkdir(STATE_DIR, { recursive: true });
+    const currentState = await loadEngineState();
+    const newState = {
+      ...currentState,
+      ...state
+    };
+    await writeFile(STATE_FILE, JSON.stringify(newState, null, 2), "utf-8");
+    console.log("[EngineState] State saved:", newState);
+  } catch (error) {
+    console.error("[EngineState] Failed to save state:", error);
+    throw error;
+  }
+}
+
+// src/utils/git.ts
 var cachedPr = null;
 function runGitCommand(command, cwd) {
   return execSync(command, {
@@ -442,7 +490,7 @@ function getGitDiff(cwd) {
     return null;
   }
 }
-function getPullRequestUrl(cwd) {
+async function getPullRequestUrl(cwd) {
   try {
     const currentBranch = getCurrentBranch(cwd);
     if (!currentBranch) {
@@ -451,6 +499,14 @@ function getPullRequestUrl(cwd) {
     if (cachedPr && cachedPr.branch === currentBranch) {
       return cachedPr.prUrl;
     }
+    const persistedState = await loadEngineState();
+    if (persistedState.prUrl && persistedState.branch === currentBranch) {
+      cachedPr = {
+        prUrl: persistedState.prUrl,
+        branch: currentBranch
+      };
+      return cachedPr.prUrl;
+    }
     cachedPr = null;
     try {
       const remoteRef = execSync(`git ls-remote --heads origin ${currentBranch}`, {
@@ -475,6 +531,7 @@ function getPullRequestUrl(cwd) {
           prUrl: prInfo,
           branch: currentBranch
         };
+        await saveEngineState({ prUrl: prInfo });
         return cachedPr.prUrl;
       }
     } catch {
@@ -486,11 +543,11 @@ function getPullRequestUrl(cwd) {
     return null;
   }
 }
-function getGitStatus(workingDirectory) {
+async function getGitStatus(workingDirectory) {
   return {
     branch: getCurrentBranch(workingDirectory),
     gitDiff: getGitDiff(workingDirectory),
-    prUrl: getPullRequestUrl(workingDirectory)
+    prUrl: await getPullRequestUrl(workingDirectory)
   };
 }
 
@@ -511,13 +568,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 +600,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 +660,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,20 +728,31 @@ var CodexManager = class {
   workingDirectory;
   messageQueue;
   baseSystemPrompt;
+  tempImageDir;
+  initialized;
   constructor(workingDirectory) {
     this.codex = new Codex();
     if (workingDirectory) {
       this.workingDirectory = workingDirectory;
     } else {
       const repoName = process.env.REPLICAS_REPO_NAME;
-      const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir();
+      const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir2();
       if (repoName) {
-        this.workingDirectory = join(workspaceHome, "workspaces", repoName);
+        this.workingDirectory = join2(workspaceHome, "workspaces", repoName);
       } else {
         this.workingDirectory = workspaceHome;
       }
     }
+    this.tempImageDir = join2(homedir2(), ".replicas", "codex", "temp-images");
     this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
+    this.initialized = this.initialize();
+  }
+  async initialize() {
+    const persistedState = await loadEngineState();
+    if (persistedState.codexThreadId) {
+      this.currentThreadId = persistedState.codexThreadId;
+      console.log(`[CodexManager] Restored thread ID from persisted state: ${this.currentThreadId}`);
+    }
   }
   isProcessing() {
     return this.messageQueue.isProcessing();
@@ -632,8 +762,9 @@ 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) {
+    await this.initialized;
+    return this.messageQueue.enqueue(message, model, customInstructions, images);
   }
   /**
    * Get the current queue status
@@ -658,15 +789,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 mkdir2(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 = join2(this.tempImageDir, filename);
+      const buffer = Buffer.from(image.source.data, "base64");
+      await writeFile2(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, {
@@ -697,15 +850,29 @@ ${customInstructions}`;
           for await (const event of events2) {
             if (event.type === "thread.started") {
               this.currentThreadId = event.thread_id;
+              await saveEngineState({ codexThreadId: this.currentThreadId });
+              console.log(`[CodexManager] Captured and persisted thread ID: ${this.currentThreadId}`);
               break;
             }
           }
           if (!this.currentThreadId && this.currentThread.id) {
             this.currentThreadId = this.currentThread.id;
+            await saveEngineState({ codexThreadId: this.currentThreadId });
+            console.log(`[CodexManager] Captured and persisted thread ID from thread.id: ${this.currentThreadId}`);
           }
         }
       }
-      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);
@@ -717,7 +884,7 @@ ${customInstructions}`;
       }
     } finally {
       if (linearSessionId) {
-        const status = getGitStatus(this.workingDirectory);
+        const status = await getGitStatus(this.workingDirectory);
         monolithService.sendEvent({ type: "agent_turn_complete", payload: { linearSessionId, status } }).catch(() => {
         });
       }
@@ -759,6 +926,7 @@ ${customInstructions}`;
     this.currentThread = null;
     this.currentThreadId = null;
     this.messageQueue.reset();
+    await saveEngineState({ codexThreadId: null });
   }
   getThreadId() {
     return this.currentThreadId;
@@ -787,13 +955,13 @@ ${customInstructions}`;
   }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join(homedir(), ".codex", "sessions");
+    const sessionsDir = join2(homedir2(), ".codex", "sessions");
     try {
       const now = /* @__PURE__ */ new Date();
       const year = now.getFullYear();
       const month = String(now.getMonth() + 1).padStart(2, "0");
       const day = String(now.getDate()).padStart(2, "0");
-      const todayDir = join(sessionsDir, String(year), month, day);
+      const todayDir = join2(sessionsDir, String(year), month, day);
       const file = await this.findFileInDirectory(todayDir, threadId);
       if (file) return file;
       for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
@@ -802,7 +970,7 @@ ${customInstructions}`;
         const searchYear = date.getFullYear();
         const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
         const searchDay = String(date.getDate()).padStart(2, "0");
-        const searchDir = join(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const searchDir = join2(sessionsDir, String(searchYear), searchMonth, searchDay);
         const file2 = await this.findFileInDirectory(searchDir, threadId);
         if (file2) return file2;
       }
@@ -816,7 +984,7 @@ ${customInstructions}`;
       const files = await readdir(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join(directory, file);
+          const fullPath = join2(directory, file);
           const stats = await stat(fullPath);
           if (stats.isFile()) {
             return fullPath;
@@ -836,11 +1004,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",
@@ -958,9 +1126,9 @@ import { Hono as Hono2 } from "hono";
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-import { join as join2 } from "path";
-import { mkdir, appendFile, rm } from "fs/promises";
-import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { mkdir as mkdir3, appendFile, rm } from "fs/promises";
+import { homedir as homedir3 } from "os";
 var ClaudeManager = class {
   workingDirectory;
   historyFile;
@@ -973,14 +1141,14 @@ var ClaudeManager = class {
       this.workingDirectory = workingDirectory;
     } else {
       const repoName = process.env.REPLICAS_REPO_NAME;
-      const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir2();
+      const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir3();
       if (repoName) {
-        this.workingDirectory = join2(workspaceHome, "workspaces", repoName);
+        this.workingDirectory = join3(workspaceHome, "workspaces", repoName);
       } else {
         this.workingDirectory = workspaceHome;
       }
     }
-    this.historyFile = join2(homedir2(), ".replicas", "claude", "history.jsonl");
+    this.historyFile = join3(homedir3(), ".replicas", "claude", "history.jsonl");
     this.initialized = this.initialize();
     this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
   }
@@ -992,9 +1160,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 +1187,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 ?? ""
@@ -1087,7 +1269,7 @@ ${customInstructions}`;
       }
     } finally {
       if (linearSessionId) {
-        const status = getGitStatus(this.workingDirectory);
+        const status = await getGitStatus(this.workingDirectory);
         monolithService.sendEvent({ type: "agent_turn_complete", payload: { linearSessionId, status } }).catch(() => {
         });
       }
@@ -1121,18 +1303,26 @@ ${customInstructions}`;
     await this.initialized;
     this.sessionId = null;
     this.messageQueue.reset();
+    await saveEngineState({ claudeSessionId: null });
     try {
       await rm(this.historyFile, { force: true });
     } catch {
     }
   }
   async initialize() {
-    const historyDir = join2(homedir2(), ".replicas", "claude");
-    await mkdir(historyDir, { recursive: true });
+    const historyDir = join3(homedir3(), ".replicas", "claude");
+    await mkdir3(historyDir, { recursive: true });
+    const persistedState = await loadEngineState();
+    if (persistedState.claudeSessionId) {
+      this.sessionId = persistedState.claudeSessionId;
+      console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
+    }
   }
   async handleMessage(message) {
     if ("session_id" in message && message.session_id && !this.sessionId) {
       this.sessionId = message.session_id;
+      await saveEngineState({ claudeSessionId: this.sessionId });
+      console.log(`[ClaudeManager] Captured and persisted session ID: ${this.sessionId}`);
     }
     await this.recordEvent(message);
   }
@@ -1153,11 +1343,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",
@@ -1526,7 +1716,7 @@ var CodexTokenManager = class {
 var codexTokenManager = new CodexTokenManager();
 
 // src/services/git-init.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import path4 from "path";
 var initializedBranch = null;
 function findAvailableBranchName(baseName, cwd) {
@@ -1562,7 +1752,7 @@ async function initializeGitRepository() {
     };
   }
   const repoPath = path4.join(workspaceHome, "workspaces", repoName);
-  if (!existsSync(repoPath)) {
+  if (!existsSync2(repoPath)) {
     console.log(`[GitInit] Repository directory does not exist: ${repoPath}`);
     console.log("[GitInit] Waiting for initializer to clone the repository...");
     return {
@@ -1570,7 +1760,7 @@ async function initializeGitRepository() {
       branch: null
     };
   }
-  if (!existsSync(path4.join(repoPath, ".git"))) {
+  if (!existsSync2(path4.join(repoPath, ".git"))) {
     return {
       success: false,
       branch: null,
@@ -1579,8 +1769,32 @@ async function initializeGitRepository() {
   }
   console.log(`[GitInit] Initializing repository at ${repoPath}`);
   try {
+    const persistedState = await loadEngineState();
+    const persistedBranch = persistedState.branch;
     console.log("[GitInit] Fetching all remotes...");
     runGitCommand("git fetch --all --prune", repoPath);
+    if (persistedBranch && branchExists(persistedBranch, repoPath)) {
+      console.log(`[GitInit] Found persisted branch: ${persistedBranch}`);
+      const currentBranch = getCurrentBranch(repoPath);
+      if (currentBranch === persistedBranch) {
+        console.log(`[GitInit] Already on persisted branch: ${persistedBranch}`);
+        initializedBranch = persistedBranch;
+        return {
+          success: true,
+          branch: persistedBranch,
+          resumed: true
+        };
+      }
+      console.log(`[GitInit] Resuming on persisted branch: ${persistedBranch}`);
+      runGitCommand(`git checkout ${persistedBranch}`, repoPath);
+      initializedBranch = persistedBranch;
+      console.log(`[GitInit] Successfully resumed on branch: ${persistedBranch}`);
+      return {
+        success: true,
+        branch: persistedBranch,
+        resumed: true
+      };
+    }
     console.log(`[GitInit] Checking out default branch: ${defaultBranch}`);
     runGitCommand(`git checkout ${defaultBranch}`, repoPath);
     console.log("[GitInit] Pulling latest changes...");
@@ -1596,10 +1810,12 @@ async function initializeGitRepository() {
     console.log(`[GitInit] Creating workspace branch: ${branchName}`);
     runGitCommand(`git checkout -b ${branchName}`, repoPath);
     initializedBranch = branchName;
+    await saveEngineState({ branch: branchName });
     console.log(`[GitInit] Successfully initialized on branch: ${branchName}`);
     return {
       success: true,
-      branch: branchName
+      branch: branchName,
+      resumed: false
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1613,10 +1829,10 @@ 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 { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
@@ -1626,9 +1842,9 @@ var ReplicasConfigService = class {
   hooksExecuted = false;
   constructor() {
     const repoName = process.env.REPLICAS_REPO_NAME;
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir3();
+    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir4();
     if (repoName) {
-      this.workingDirectory = join3(workspaceHome, "workspaces", repoName);
+      this.workingDirectory = join4(workspaceHome, "workspaces", repoName);
     } else {
       this.workingDirectory = workspaceHome;
     }
@@ -1644,14 +1860,14 @@ var ReplicasConfigService = class {
    * Load and parse the replicas.json config file
    */
   async loadConfig() {
-    const configPath = join3(this.workingDirectory, "replicas.json");
-    if (!existsSync2(configPath)) {
+    const configPath = join4(this.workingDirectory, "replicas.json");
+    if (!existsSync3(configPath)) {
       console.log("No replicas.json found in workspace directory");
       this.config = null;
       return;
     }
     try {
-      const data = await readFile2(configPath, "utf-8");
+      const data = await readFile3(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');
@@ -1769,7 +1985,7 @@ function checkActiveSSHSessions() {
 var app = new Hono3();
 app.get("/health", async (c) => {
   try {
-    const logContent = await readFile3("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile4("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";
@@ -1794,13 +2010,14 @@ app.get("/status", async (c) => {
     const claudeStatus = await claudeManager.getStatus();
     const workingDirectory = claudeStatus.working_directory;
     const hasActiveSSHSessions = checkActiveSSHSessions();
+    const gitStatus = await getGitStatus(workingDirectory);
     return c.json({
       isCodexProcessing,
       isClaudeProcessing,
       isCodexUsed,
       isClaudeUsed,
       hasActiveSSHSessions,
-      ...getGitStatus(workingDirectory),
+      ...gitStatus,
       linearBetaEnabled: true
       // TODO: delete
     });

package/package.json

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