replicas-engine 0.1.23 → 0.1.25

package/dist/src/index.js

@@ -56,9 +56,9 @@ async function readJSONL(filePath) {
 }
 
 // src/services/codex-manager.ts
-import { readdir, stat, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { readdir, stat, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/services/monolith-service.ts
 var MonolithService = class {
@@ -91,6 +91,15 @@ var MonolithService = class {
 var monolithService = new MonolithService();
 
 // src/services/linear-event-converter.ts
+function linearThoughtToResponse(thought) {
+  return {
+    linearSessionId: thought.linearSessionId,
+    content: {
+      type: "response",
+      body: thought.content.body
+    }
+  };
+}
 function summarizeInput(input) {
   if (!input) return "";
   if (typeof input === "string") return input;
@@ -397,7 +406,8 @@ var DEFAULT_STATE = {
   branch: null,
   prUrl: null,
   claudeSessionId: null,
-  codexThreadId: null
+  codexThreadId: null,
+  startHooksCompleted: false
 };
 async function loadEngineState() {
   try {
@@ -720,6 +730,206 @@ async function normalizeImages(images) {
   return normalized;
 }
 
+// src/services/replicas-config.ts
+import { readFile as readFile3, appendFile, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var START_HOOKS_LOG = join2(homedir2(), ".replicas", "startHooks.log");
+var START_HOOKS_RUNNING_PROMPT = `IMPORTANT - Start Hooks Running:
+Start hooks are shell commands/scripts set by the repository owners that run on workspace startup.
+These hooks are currently executing in the background. You can:
+- Check the status and output by reading ~/.replicas/startHooks.log
+- View the hook commands in replicas.json in the repository root (under the "startHook" field)
+
+The start hooks may install dependencies, build projects, or perform other setup tasks.
+If your task depends on setup being complete, check the log file before proceeding.`;
+var ReplicasConfigService = class {
+  config = null;
+  workingDirectory;
+  hooksRunning = false;
+  hooksCompleted = false;
+  startHooksPromise = null;
+  constructor() {
+    const repoName = process.env.REPLICAS_REPO_NAME;
+    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir2();
+    if (repoName) {
+      this.workingDirectory = join2(workspaceHome, "workspaces", repoName);
+    } else {
+      this.workingDirectory = workspaceHome;
+    }
+  }
+  /**
+   * Initialize the service by reading replicas.json and starting start hooks asynchronously
+   * Start hooks run in the background and don't block engine startup
+   */
+  async initialize() {
+    await this.loadConfig();
+    this.startHooksPromise = this.executeStartHooks();
+  }
+  /**
+   * Load and parse the replicas.json config file
+   */
+  async loadConfig() {
+    const configPath = join2(this.workingDirectory, "replicas.json");
+    if (!existsSync2(configPath)) {
+      console.log("No replicas.json found in workspace directory");
+      this.config = null;
+      return;
+    }
+    try {
+      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');
+      }
+      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.organizationId && typeof config.organizationId !== "string") {
+        throw new Error('Invalid replicas.json: "organizationId" must be a string');
+      }
+      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;
+    }
+  }
+  /**
+   * Write a message to the start hooks log file
+   */
+  async logToFile(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logLine = `[${timestamp}] ${message}
+`;
+    try {
+      await mkdir2(join2(homedir2(), ".replicas"), { recursive: true });
+      await appendFile(START_HOOKS_LOG, logLine, "utf-8");
+    } catch (error) {
+      console.error("Failed to write to start hooks log:", error);
+    }
+  }
+  /**
+   * Execute all start hooks defined in replicas.json
+   * Writes output to ~/.replicas/startHooks.log
+   * Only runs once per workspace lifecycle (persisted across sleep/wake cycles)
+   */
+  async executeStartHooks() {
+    const persistedState = await loadEngineState();
+    if (persistedState.startHooksCompleted) {
+      console.log("Start hooks already completed in previous session, skipping");
+      this.hooksCompleted = true;
+      await this.logToFile("Start hooks already completed in previous session, skipping");
+      return;
+    }
+    const startHookConfig = this.config?.startHook;
+    if (!startHookConfig || startHookConfig.commands.length === 0) {
+      this.hooksCompleted = true;
+      await saveEngineState({ startHooksCompleted: true });
+      return;
+    }
+    const timeout = startHookConfig.timeout ?? 3e5;
+    const hooks = startHookConfig.commands;
+    this.hooksRunning = true;
+    await mkdir2(join2(homedir2(), ".replicas"), { recursive: true });
+    await writeFile2(START_HOOKS_LOG, `=== Start Hooks Execution Log ===
+Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+Commands: ${hooks.length}
+
+`, "utf-8");
+    console.log(`Executing ${hooks.length} start hook(s) with timeout ${timeout}ms...`);
+    await this.logToFile(`Executing ${hooks.length} start hook(s) with timeout ${timeout}ms...`);
+    for (const hook of hooks) {
+      try {
+        console.log(`Running start hook: ${hook}`);
+        await this.logToFile(`
+--- Running: ${hook} ---`);
+        const { stdout, stderr } = await execAsync(hook, {
+          cwd: this.workingDirectory,
+          timeout,
+          env: process.env
+        });
+        if (stdout) {
+          console.log(`[${hook}] stdout:`, stdout);
+          await this.logToFile(`[stdout] ${stdout}`);
+        }
+        if (stderr) {
+          console.warn(`[${hook}] stderr:`, stderr);
+          await this.logToFile(`[stderr] ${stderr}`);
+        }
+        console.log(`Start hook completed: ${hook}`);
+        await this.logToFile(`--- Completed: ${hook} ---`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        console.error(`Start hook failed: ${hook}`, errorMessage);
+        await this.logToFile(`[ERROR] ${hook} failed: ${errorMessage}`);
+      }
+    }
+    this.hooksRunning = false;
+    this.hooksCompleted = true;
+    await saveEngineState({ startHooksCompleted: true });
+    console.log("All start hooks completed");
+    await this.logToFile(`
+=== All start hooks completed at ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
+  }
+  /**
+   * 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 are currently running
+   */
+  areHooksRunning() {
+    return this.hooksRunning;
+  }
+  /**
+   * Get start hook configuration (for system prompt)
+   */
+  getStartHookConfig() {
+    return this.config?.startHook;
+  }
+};
+var replicasConfigService = new ReplicasConfigService();
+
 // src/services/codex-manager.ts
 var DEFAULT_MODEL = "gpt-5.1-codex";
 var CodexManager = class {
@@ -737,14 +947,14 @@ var CodexManager = 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.tempImageDir = join2(homedir2(), ".replicas", "codex", "temp-images");
+    this.tempImageDir = join3(homedir3(), ".replicas", "codex", "temp-images");
     this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
     this.initialized = this.initialize();
   }
@@ -786,6 +996,20 @@ var CodexManager = class {
   getBaseSystemPrompt() {
     return this.baseSystemPrompt;
   }
+  /**
+   * Generate start hooks instruction for the system prompt
+   * Returns a message explaining start hooks status if they are running
+   */
+  getStartHooksInstruction() {
+    if (!replicasConfigService.areHooksRunning()) {
+      return void 0;
+    }
+    const startHookConfig = replicasConfigService.getStartHookConfig();
+    if (!startHookConfig || startHookConfig.commands.length === 0) {
+      return void 0;
+    }
+    return START_HOOKS_RUNNING_PROMPT;
+  }
   /**
    * Legacy sendMessage method - now uses the queue internally
    * @deprecated Use enqueueMessage for better control over queue status
@@ -798,14 +1022,14 @@ var CodexManager = class {
    * @returns Array of temp file paths
    */
   async saveImagesToTempFiles(images) {
-    await mkdir2(this.tempImageDir, { recursive: true });
+    await mkdir3(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 filepath = join3(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile2(filepath, buffer);
+      await writeFile3(filepath, buffer);
       tempPaths.push(filepath);
     }
     return tempPaths;
@@ -836,14 +1060,18 @@ var CodexManager = class {
             sandboxMode: "danger-full-access",
             model: model || DEFAULT_MODEL
           });
-          let combinedInstructions;
-          if (this.baseSystemPrompt && customInstructions) {
-            combinedInstructions = `${this.baseSystemPrompt}
-
-${customInstructions}`;
-          } else {
-            combinedInstructions = this.baseSystemPrompt || customInstructions;
+          const startHooksInstruction = this.getStartHooksInstruction();
+          const parts = [];
+          if (this.baseSystemPrompt) {
+            parts.push(this.baseSystemPrompt);
+          }
+          if (startHooksInstruction) {
+            parts.push(startHooksInstruction);
+          }
+          if (customInstructions) {
+            parts.push(customInstructions);
           }
+          const combinedInstructions = parts.length > 0 ? parts.join("\n\n") : void 0;
           if (combinedInstructions) {
             message = combinedInstructions + "\n" + message;
           }
@@ -873,15 +1101,30 @@ ${customInstructions}`;
         input = message;
       }
       const { events } = await this.currentThread.runStreamed(input);
+      let latestThoughtEvent = null;
       for await (const event of events) {
         if (linearSessionId) {
           const linearEvent = convertCodexEvent(event, linearSessionId);
           if (linearEvent) {
-            monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-            });
+            if (latestThoughtEvent) {
+              monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
+              });
+            }
+            if (linearEvent.content.type === "thought") {
+              latestThoughtEvent = linearEvent;
+            } else {
+              latestThoughtEvent = null;
+              monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+              });
+            }
           }
         }
       }
+      if (linearSessionId && latestThoughtEvent) {
+        const responseEvent = linearThoughtToResponse(latestThoughtEvent);
+        monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
+        });
+      }
     } finally {
       if (linearSessionId) {
         const status = await getGitStatus(this.workingDirectory);
@@ -955,13 +1198,13 @@ ${customInstructions}`;
   }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join2(homedir2(), ".codex", "sessions");
+    const sessionsDir = join3(homedir3(), ".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 = join2(sessionsDir, String(year), month, day);
+      const todayDir = join3(sessionsDir, String(year), month, day);
       const file = await this.findFileInDirectory(todayDir, threadId);
       if (file) return file;
       for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
@@ -970,7 +1213,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 = join2(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const searchDir = join3(sessionsDir, String(searchYear), searchMonth, searchDay);
         const file2 = await this.findFileInDirectory(searchDir, threadId);
         if (file2) return file2;
       }
@@ -984,7 +1227,7 @@ ${customInstructions}`;
       const files = await readdir(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join2(directory, file);
+          const fullPath = join3(directory, file);
           const stats = await stat(fullPath);
           if (stats.isFile()) {
             return fullPath;
@@ -1126,9 +1369,9 @@ import { Hono as Hono2 } from "hono";
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-import { join as join3 } from "path";
-import { mkdir as mkdir3, appendFile, rm } from "fs/promises";
-import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { mkdir as mkdir4, appendFile as appendFile2, rm } from "fs/promises";
+import { homedir as homedir4 } from "os";
 var ClaudeManager = class {
   workingDirectory;
   historyFile;
@@ -1141,14 +1384,14 @@ var ClaudeManager = class {
       this.workingDirectory = workingDirectory;
     } else {
       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;
       }
     }
-    this.historyFile = join3(homedir3(), ".replicas", "claude", "history.jsonl");
+    this.historyFile = join4(homedir4(), ".replicas", "claude", "history.jsonl");
     this.initialized = this.initialize();
     this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
   }
@@ -1183,6 +1426,20 @@ var ClaudeManager = class {
   getBaseSystemPrompt() {
     return this.baseSystemPrompt;
   }
+  /**
+   * Generate start hooks instruction for the system prompt
+   * Returns a message explaining start hooks status if they are running
+   */
+  getStartHooksInstruction() {
+    if (!replicasConfigService.areHooksRunning()) {
+      return void 0;
+    }
+    const startHookConfig = replicasConfigService.getStartHookConfig();
+    if (!startHookConfig || startHookConfig.commands.length === 0) {
+      return void 0;
+    }
+    return START_HOOKS_RUNNING_PROMPT;
+  }
   /**
    * Legacy sendMessage method - now uses the queue internally
    * @deprecated Use enqueueMessage for better control over queue status
@@ -1232,14 +1489,18 @@ 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 startHooksInstruction = this.getStartHooksInstruction();
+      const parts = [];
+      if (this.baseSystemPrompt) {
+        parts.push(this.baseSystemPrompt);
+      }
+      if (startHooksInstruction) {
+        parts.push(startHooksInstruction);
+      }
+      if (customInstructions) {
+        parts.push(customInstructions);
       }
+      const combinedInstructions = parts.length > 0 ? parts.join("\n\n") : void 0;
       const response = query({
         prompt: promptIterable,
         options: {
@@ -1257,16 +1518,31 @@ ${customInstructions}`;
           model: model || "opus"
         }
       });
+      let latestThoughtEvent = null;
       for await (const msg of response) {
         await this.handleMessage(msg);
         if (linearSessionId) {
           const linearEvent = convertClaudeEvent(msg, linearSessionId);
           if (linearEvent) {
-            monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-            });
+            if (latestThoughtEvent) {
+              monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
+              });
+            }
+            if (linearEvent.content.type === "thought") {
+              latestThoughtEvent = linearEvent;
+            } else {
+              latestThoughtEvent = null;
+              monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+              });
+            }
           }
         }
       }
+      if (linearSessionId && latestThoughtEvent) {
+        const responseEvent = linearThoughtToResponse(latestThoughtEvent);
+        monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
+        });
+      }
     } finally {
       if (linearSessionId) {
         const status = await getGitStatus(this.workingDirectory);
@@ -1310,8 +1586,8 @@ ${customInstructions}`;
     }
   }
   async initialize() {
-    const historyDir = join3(homedir3(), ".replicas", "claude");
-    await mkdir3(historyDir, { recursive: true });
+    const historyDir = join4(homedir4(), ".replicas", "claude");
+    await mkdir4(historyDir, { recursive: true });
     const persistedState = await loadEngineState();
     if (persistedState.claudeSessionId) {
       this.sessionId = persistedState.claudeSessionId;
@@ -1333,7 +1609,7 @@ ${customInstructions}`;
       type: `claude-${event.type}`,
       payload: event
     };
-    await appendFile(this.historyFile, JSON.stringify(jsonEvent) + "\n", "utf-8");
+    await appendFile2(this.historyFile, JSON.stringify(jsonEvent) + "\n", "utf-8");
   }
 };
 
@@ -1716,7 +1992,7 @@ var CodexTokenManager = class {
 var codexTokenManager = new CodexTokenManager();
 
 // src/services/git-init.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import path4 from "path";
 var initializedBranch = null;
 function findAvailableBranchName(baseName, cwd) {
@@ -1752,7 +2028,7 @@ async function initializeGitRepository() {
     };
   }
   const repoPath = path4.join(workspaceHome, "workspaces", repoName);
-  if (!existsSync2(repoPath)) {
+  if (!existsSync3(repoPath)) {
     console.log(`[GitInit] Repository directory does not exist: ${repoPath}`);
     console.log("[GitInit] Waiting for initializer to clone the repository...");
     return {
@@ -1760,7 +2036,7 @@ async function initializeGitRepository() {
       branch: null
     };
   }
-  if (!existsSync2(path4.join(repoPath, ".git"))) {
+  if (!existsSync3(path4.join(repoPath, ".git"))) {
     return {
       success: false,
       branch: null,
@@ -1828,148 +2104,6 @@ async function initializeGitRepository() {
   }
 }
 
-// src/services/replicas-config.ts
-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);
-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 || homedir4();
-    if (repoName) {
-      this.workingDirectory = join4(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 = 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 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');
-      }
-      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 ==========";
@@ -2017,9 +2151,7 @@ app.get("/status", async (c) => {
       isCodexUsed,
       isClaudeUsed,
       hasActiveSSHSessions,
-      ...gitStatus,
-      linearBetaEnabled: true
-      // TODO: delete
+      ...gitStatus
     });
   } catch (error) {
     console.error("Error getting workspace status:", error);

package/package.json

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