replicas-engine 0.1.21 → 0.1.23

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
@@ -56,9 +56,9 @@ async function readJSONL(filePath) {
 }
 
 // src/services/codex-manager.ts
-import { readdir, stat, writeFile, mkdir } 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 {
@@ -385,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, {
@@ -443,7 +490,7 @@ function getGitDiff(cwd) {
     return null;
   }
 }
-function getPullRequestUrl(cwd) {
+async function getPullRequestUrl(cwd) {
   try {
     const currentBranch = getCurrentBranch(cwd);
     if (!currentBranch) {
@@ -452,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}`, {
@@ -476,6 +531,7 @@ function getPullRequestUrl(cwd) {
           prUrl: prInfo,
           branch: currentBranch
         };
+        await saveEngineState({ prUrl: prInfo });
         return cachedPr.prUrl;
       }
     } catch {
@@ -487,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)
   };
 }
 
@@ -665,6 +721,7 @@ async function normalizeImages(images) {
 }
 
 // src/services/codex-manager.ts
+var DEFAULT_MODEL = "gpt-5.1-codex";
 var CodexManager = class {
   codex;
   currentThreadId = null;
@@ -673,21 +730,30 @@ var CodexManager = class {
   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 = join(homedir(), ".replicas", "codex", "temp-images");
+    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();
@@ -698,6 +764,7 @@ var CodexManager = class {
    * @returns Object with queued status, messageId, and position in queue
    */
   async enqueueMessage(message, model, customInstructions, images) {
+    await this.initialized;
     return this.messageQueue.enqueue(message, model, customInstructions, images);
   }
   /**
@@ -731,14 +798,14 @@ var CodexManager = class {
    * @returns Array of temp file paths
    */
   async saveImagesToTempFiles(images) {
-    await mkdir(this.tempImageDir, { recursive: true });
+    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 = join(this.tempImageDir, filename);
+      const filepath = join2(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile(filepath, buffer);
+      await writeFile2(filepath, buffer);
       tempPaths.push(filepath);
     }
     return tempPaths;
@@ -760,14 +827,14 @@ var CodexManager = class {
             workingDirectory: this.workingDirectory,
             skipGitRepoCheck: true,
             sandboxMode: "danger-full-access",
-            model: model || "gpt-5.1-codex"
+            model: model || DEFAULT_MODEL
           });
         } else {
           this.currentThread = this.codex.startThread({
             workingDirectory: this.workingDirectory,
             skipGitRepoCheck: true,
             sandboxMode: "danger-full-access",
-            model: model || "gpt-5.1-codex"
+            model: model || DEFAULT_MODEL
           });
           let combinedInstructions;
           if (this.baseSystemPrompt && customInstructions) {
@@ -784,11 +851,14 @@ ${customInstructions}`;
           for await (const event of events2) {
             if (event.type === "thread.started") {
               this.currentThreadId = event.thread_id;
-              break;
+              await saveEngineState({ codexThreadId: this.currentThreadId });
+              console.log(`[CodexManager] Captured and persisted thread ID: ${this.currentThreadId}`);
             }
           }
           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}`);
           }
         }
       }
@@ -814,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(() => {
         });
       }
@@ -856,6 +926,7 @@ ${customInstructions}`;
     this.currentThread = null;
     this.currentThreadId = null;
     this.messageQueue.reset();
+    await saveEngineState({ codexThreadId: null });
   }
   getThreadId() {
     return this.currentThreadId;
@@ -884,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++) {
@@ -899,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;
       }
@@ -913,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;
@@ -1055,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 as mkdir2, 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;
@@ -1070,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));
   }
@@ -1198,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(() => {
         });
       }
@@ -1232,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 mkdir2(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);
   }
@@ -1637,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) {
@@ -1673,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 {
@@ -1681,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,
@@ -1690,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...");
@@ -1707,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);
@@ -1724,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);
@@ -1737,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;
     }
@@ -1755,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');
@@ -1880,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";
@@ -1905,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.21",
+  "version": "0.1.23",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",