replicas-engine 0.1.14 → 0.1.16

package/dist/src/index.js

@@ -5,6 +5,7 @@ import "dotenv/config";
 import { serve } from "@hono/node-server";
 import { Hono as Hono3 } from "hono";
 import { readFile as readFile2 } from "fs/promises";
+import { execSync as execSync2 } from "child_process";
 
 // src/middleware/auth.ts
 var authMiddleware = async (c, next) => {
@@ -57,6 +58,439 @@ async function readJSONL(filePath) {
 import { readdir, stat } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
+
+// src/services/monolith-service.ts
+var MonolithService = class {
+  async sendEvent(event) {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      return;
+    }
+    try {
+      const response = await fetch(`${monolithUrl}/v1/engine/webhook`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${engineSecret}`,
+          "X-Workspace-Id": workspaceId,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`[MonolithService] Failed to send event: ${response.status} ${errorText}`);
+      }
+    } catch (error) {
+      console.error("[MonolithService] Failed to send event:", error);
+    }
+  }
+};
+var monolithService = new MonolithService();
+
+// src/services/linear-event-converter.ts
+function summarizeInput(input) {
+  if (!input) return "";
+  if (typeof input === "string") return input;
+  if (typeof input === "object") {
+    const obj = input;
+    if (obj.file_path) return String(obj.file_path);
+    if (obj.command) return String(obj.command);
+    if (obj.pattern) return `pattern: ${String(obj.pattern)}`;
+    if (obj.query) return String(obj.query);
+    if (obj.url) return String(obj.url);
+    const keys = Object.keys(obj);
+    if (keys.length > 0) {
+      const firstKey = keys[0];
+      return `${firstKey}: ${String(obj[firstKey])}`;
+    }
+  }
+  return "";
+}
+function convertClaudeEvent(event, linearSessionId) {
+  if (event.type === "assistant") {
+    const message = event;
+    const contentBlocks = message.message?.content || [];
+    for (const block of contentBlocks) {
+      if (block.type === "text" && block.text) {
+        return {
+          linearSessionId,
+          content: {
+            type: "thought",
+            body: block.text
+          }
+        };
+      }
+      if (block.type === "thinking" && block.text) {
+        return {
+          linearSessionId,
+          content: {
+            type: "thought",
+            body: block.text
+          }
+        };
+      }
+      if (block.type === "tool_use" && block.name) {
+        const toolName = block.name;
+        const parameter = summarizeInput(block.input);
+        let action = toolName;
+        switch (toolName) {
+          case "Bash":
+            action = "Running command";
+            break;
+          case "Edit":
+            action = "Editing file";
+            break;
+          case "Write":
+            action = "Writing file";
+            break;
+          case "Read":
+            action = "Reading file";
+            break;
+          case "Glob":
+            action = "Searching files";
+            break;
+          case "Grep":
+            action = "Searching code";
+            break;
+          case "WebSearch":
+            action = "Web search";
+            break;
+          case "WebFetch":
+            action = "Fetching URL";
+            break;
+          case "Task":
+            action = "Spawning subagent";
+            break;
+          case "TodoWrite":
+            action = "Updating plan";
+            break;
+        }
+        return {
+          linearSessionId,
+          content: {
+            type: "action",
+            action,
+            parameter
+          }
+        };
+      }
+    }
+  }
+  if (event.type === "user") {
+    const message = event;
+    const contentBlocks = message.message?.content || [];
+    for (const block of contentBlocks) {
+      if (block.type === "tool_result") {
+        let resultText = "";
+        if (typeof block.content === "string") {
+          resultText = block.content;
+        } else if (Array.isArray(block.content)) {
+          resultText = block.content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+        }
+        const isError = block.is_error || false;
+        const result = isError ? `Error: ${resultText}` : resultText || "Done";
+        return {
+          linearSessionId,
+          content: {
+            type: "action",
+            action: "Tool completed",
+            parameter: "",
+            result
+          }
+        };
+      }
+    }
+  }
+  return null;
+}
+function convertCodexEvent(event, linearSessionId) {
+  if (event.type === "turn.started") {
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body: "Processing..."
+      }
+    };
+  }
+  if (event.type === "item.started") {
+    const item = event.item;
+    if (!item) return null;
+    if (item.type === "agent_message") {
+      const text = "text" in item ? String(item.text || "") : "";
+      if (text) {
+        return {
+          linearSessionId,
+          content: {
+            type: "thought",
+            body: text
+          }
+        };
+      }
+    }
+    if (item.type === "reasoning") {
+      const text = "text" in item ? String(item.text || "") : "";
+      if (text) {
+        return {
+          linearSessionId,
+          content: {
+            type: "thought",
+            body: text
+          }
+        };
+      }
+    }
+    if (item.type === "command_execution") {
+      const command = "command" in item ? String(item.command || "") : "";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "Running command",
+          parameter: command
+        }
+      };
+    }
+    if (item.type === "file_change") {
+      const changes = "changes" in item && Array.isArray(item.changes) ? item.changes : [];
+      const paths = changes.map((c) => c.path || "").filter(Boolean);
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "File change",
+          parameter: paths.join(", ") || ""
+        }
+      };
+    }
+    if (item.type === "mcp_tool_call") {
+      const tool = "tool" in item ? String(item.tool || "") : "";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: tool || "MCP tool call",
+          parameter: ""
+        }
+      };
+    }
+    if (item.type === "web_search") {
+      const query2 = "query" in item ? String(item.query || "") : "";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "Web search",
+          parameter: query2
+        }
+      };
+    }
+    if (item.type === "todo_list") {
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "Updating plan",
+          parameter: ""
+        }
+      };
+    }
+  }
+  if (event.type === "item.completed") {
+    const item = event.item;
+    if (!item) return null;
+    if (item.type === "command_execution") {
+      const command = "command" in item ? String(item.command || "") : "";
+      const output = "aggregated_output" in item ? String(item.aggregated_output || "") : "";
+      const exitCode = "exit_code" in item ? item.exit_code : void 0;
+      const result = exitCode !== void 0 ? `Exit code: ${exitCode}` : output || "Done";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "Running command",
+          parameter: command,
+          result
+        }
+      };
+    }
+    if (item.type === "file_change") {
+      const changes = "changes" in item && Array.isArray(item.changes) ? item.changes : [];
+      const paths = changes.map((c) => c.path || "").filter(Boolean);
+      const status = "status" in item ? String(item.status || "") : "";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "File change",
+          parameter: paths.join(", ") || "",
+          result: status === "completed" ? "Done" : status || "Done"
+        }
+      };
+    }
+    if (item.type === "mcp_tool_call") {
+      const tool = "tool" in item ? String(item.tool || "") : "";
+      const status = "status" in item ? String(item.status || "") : "";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: tool || "MCP tool call",
+          parameter: "",
+          result: status === "completed" ? "Done" : status || "Done"
+        }
+      };
+    }
+    if (item.type === "web_search") {
+      const query2 = "query" in item ? String(item.query || "") : "";
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "Web search",
+          parameter: query2,
+          result: "Done"
+        }
+      };
+    }
+    if (item.type === "todo_list") {
+      return {
+        linearSessionId,
+        content: {
+          type: "action",
+          action: "Updating plan",
+          parameter: "",
+          result: "Done"
+        }
+      };
+    }
+    if (item.type === "agent_message") {
+      const text = "text" in item ? String(item.text || "") : "";
+      if (text) {
+        return {
+          linearSessionId,
+          content: {
+            type: "thought",
+            body: text
+          }
+        };
+      }
+    }
+  }
+  return null;
+}
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+var cachedPrUrl = null;
+function runGitCommand(command, cwd) {
+  return execSync(command, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function branchExists(branchName, cwd) {
+  try {
+    runGitCommand(`git rev-parse --verify ${branchName}`, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCurrentBranch(cwd) {
+  try {
+    return runGitCommand("git rev-parse --abbrev-ref HEAD", cwd);
+  } catch (error) {
+    console.error("Error getting current branch:", error);
+    return null;
+  }
+}
+function getGitDiff(cwd) {
+  try {
+    const defaultBranch = process.env.REPLICAS_DEFAULT_BRANCH || "main";
+    const baseBranch = `origin/${defaultBranch}`;
+    const shortstat = execSync(`git diff ${baseBranch}...HEAD --shortstat -M`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    let added = 0;
+    let removed = 0;
+    const addedMatch = shortstat.match(/(\d+) insertion/);
+    const removedMatch = shortstat.match(/(\d+) deletion/);
+    if (addedMatch) {
+      added = parseInt(addedMatch[1], 10);
+    }
+    if (removedMatch) {
+      removed = parseInt(removedMatch[1], 10);
+    }
+    const fullDiff = execSync(`git diff ${baseBranch}...HEAD -M -C`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return {
+      added,
+      removed,
+      fullDiff
+    };
+  } catch (error) {
+    console.error("Error getting git diff:", error);
+    return null;
+  }
+}
+function getPullRequestUrl(cwd) {
+  if (cachedPrUrl) {
+    return cachedPrUrl;
+  }
+  try {
+    const branch = getCurrentBranch(cwd);
+    if (!branch) {
+      return null;
+    }
+    try {
+      const remoteRef = execSync(`git ls-remote --heads origin ${branch}`, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (!remoteRef) {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    try {
+      const prInfo = execSync("gh pr view --json url --jq .url", {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (prInfo) {
+        cachedPrUrl = prInfo;
+        return cachedPrUrl;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  } catch (error) {
+    console.error("Error checking for pull request:", error);
+    return null;
+  }
+}
+function getGitStatus(workingDirectory) {
+  return {
+    branch: getCurrentBranch(workingDirectory),
+    gitDiff: getGitDiff(workingDirectory),
+    prUrl: getPullRequestUrl(workingDirectory)
+  };
+}
+
+// src/services/codex-manager.ts
 var CodexManager = class {
   codex;
   currentThreadId = null;
@@ -81,6 +515,7 @@ var CodexManager = class {
     return this.processing;
   }
   async sendMessage(message, model, customInstructions) {
+    const linearSessionId = process.env.LINEAR_SESSION_ID;
     try {
       this.processing = true;
       if (!this.currentThread) {
@@ -89,20 +524,20 @@ var CodexManager = class {
             workingDirectory: this.workingDirectory,
             skipGitRepoCheck: true,
             sandboxMode: "danger-full-access",
-            model: model || "gpt-5-codex"
+            model: model || "gpt-5.1-codex"
           });
         } else {
           this.currentThread = this.codex.startThread({
             workingDirectory: this.workingDirectory,
             skipGitRepoCheck: true,
             sandboxMode: "danger-full-access",
-            model: model || "gpt-5-codex"
+            model: model || "gpt-5.1-codex"
           });
           if (customInstructions) {
             message = customInstructions + "\n" + message;
           }
-          const { events } = await this.currentThread.runStreamed("Hello");
-          for await (const event of events) {
+          const { events: events2 } = await this.currentThread.runStreamed("Hello");
+          for await (const event of events2) {
             if (event.type === "thread.started") {
               this.currentThreadId = event.thread_id;
               break;
@@ -113,9 +548,23 @@ var CodexManager = class {
           }
         }
       }
-      await this.currentThread.run(message);
+      const { events } = await this.currentThread.runStreamed(message);
+      for await (const event of events) {
+        if (linearSessionId) {
+          const linearEvent = convertCodexEvent(event, linearSessionId);
+          if (linearEvent) {
+            monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+            });
+          }
+        }
+      }
     } finally {
       this.processing = false;
+      if (linearSessionId) {
+        const status = getGitStatus(this.workingDirectory);
+        monolithService.sendEvent({ type: "agent_turn_complete", payload: { linearSessionId, status } }).catch(() => {
+        });
+      }
     }
   }
   async getHistory() {
@@ -372,6 +821,7 @@ var ClaudeManager = class {
     return this.processing;
   }
   async sendMessage(message, model, customInstructions) {
+    const linearSessionId = process.env.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
       throw new Error("Message cannot be empty");
     }
@@ -410,14 +860,26 @@ var ClaudeManager = class {
             append: customInstructions
           },
           env: process.env,
-          model: model || "sonnet"
+          model: model || "opus"
         }
       });
       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(() => {
+            });
+          }
+        }
       }
     } finally {
       this.processing = false;
+      if (linearSessionId) {
+        const status = getGitStatus(this.workingDirectory);
+        monolithService.sendEvent({ type: "agent_turn_complete", payload: { linearSessionId, status } }).catch(() => {
+        });
+      }
     }
   }
   async getHistory() {
@@ -586,59 +1048,185 @@ claude.post("/reset", async (c) => {
 });
 var claude_default = claude;
 
-// src/utils/git.ts
-import { execSync } from "child_process";
-function getCurrentBranch(cwd) {
-  try {
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return branch;
-  } catch (error) {
-    console.error("Error getting current branch:", error);
-    return null;
+// src/services/github-token-manager.ts
+import { promises as fs } from "fs";
+import path from "path";
+var GitHubTokenManager = class {
+  refreshInterval = null;
+  REFRESH_INTERVAL_MS = 45 * 60 * 1e3;
+  // 45 minutes
+  async start() {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      console.log("[GitHubTokenManager] Skipping: missing MONOLITH_URL, WORKSPACE_ID, or REPLICAS_ENGINE_SECRET");
+      return;
+    }
+    console.log("[GitHubTokenManager] Starting token refresh service");
+    await this.refreshToken();
+    this.refreshInterval = setInterval(() => {
+      this.refreshToken().catch((error) => {
+        console.error("[GitHubTokenManager] Scheduled refresh failed:", error);
+      });
+    }, this.REFRESH_INTERVAL_MS);
+    console.log("[GitHubTokenManager] Token refresh scheduled every 45 minutes");
+  }
+  stop() {
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+      this.refreshInterval = null;
+      console.log("[GitHubTokenManager] Stopped");
+    }
+  }
+  async refreshToken() {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      console.log("[GitHubTokenManager] Refresh skipped: missing configuration");
+      return;
+    }
+    console.log("[GitHubTokenManager] Refreshing GitHub token...");
+    try {
+      const response = await fetch(`${monolithUrl}/v1/engine/github/refresh-token`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${engineSecret}`,
+          "X-Workspace-Id": workspaceId,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Token refresh failed: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      await this.updateGitCredentials(data.token);
+      process.env.GH_TOKEN = data.token;
+      console.log(`[GitHubTokenManager] Token refreshed successfully, expires at ${data.expiresAt}`);
+    } catch (error) {
+      console.error("[GitHubTokenManager] Failed to refresh token:", error);
+    }
   }
+  async updateGitCredentials(token) {
+    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
+    if (!workspaceHome) {
+      console.warn("[GitHubTokenManager] No WORKSPACE_HOME or HOME set, skipping git credentials update");
+      return;
+    }
+    const credentialsPath = path.join(workspaceHome, ".git-credentials");
+    const credentialsContent = `https://x-access-token:${token}@github.com
+`;
+    try {
+      await fs.writeFile(credentialsPath, credentialsContent, { mode: 384 });
+      console.log(`[GitHubTokenManager] Updated ${credentialsPath}`);
+    } catch (error) {
+      console.error("[GitHubTokenManager] Failed to update git credentials:", error);
+    }
+  }
+};
+var githubTokenManager = new GitHubTokenManager();
+
+// src/services/git-init.ts
+import { existsSync } from "fs";
+import path2 from "path";
+var initializedBranch = null;
+function findAvailableBranchName(baseName, cwd) {
+  if (!branchExists(baseName, cwd)) {
+    return baseName;
+  }
+  return `${baseName}-${Date.now()}`;
 }
-function getGitDiff(cwd) {
+async function initializeGitRepository() {
+  const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
+  const repoName = process.env.REPLICAS_REPO_NAME;
+  const workspaceName = process.env.WORKSPACE_NAME;
+  const defaultBranch = process.env.REPLICAS_DEFAULT_BRANCH || "main";
+  if (!workspaceHome) {
+    return {
+      success: false,
+      branch: null,
+      error: "No WORKSPACE_HOME or HOME environment variable set"
+    };
+  }
+  if (!repoName) {
+    console.log("[GitInit] No REPLICAS_REPO_NAME set, skipping git initialization");
+    return {
+      success: true,
+      branch: null
+    };
+  }
+  if (!workspaceName) {
+    return {
+      success: false,
+      branch: null,
+      error: "No WORKSPACE_NAME environment variable set"
+    };
+  }
+  const repoPath = path2.join(workspaceHome, "workspaces", repoName);
+  if (!existsSync(repoPath)) {
+    console.log(`[GitInit] Repository directory does not exist: ${repoPath}`);
+    console.log("[GitInit] Waiting for initializer to clone the repository...");
+    return {
+      success: true,
+      branch: null
+    };
+  }
+  if (!existsSync(path2.join(repoPath, ".git"))) {
+    return {
+      success: false,
+      branch: null,
+      error: `Directory exists but is not a git repository: ${repoPath}`
+    };
+  }
+  console.log(`[GitInit] Initializing repository at ${repoPath}`);
   try {
-    const defaultBranch = process.env.REPLICAS_DEFAULT_BRANCH || "main";
-    const baseBranch = `origin/${defaultBranch}`;
-    const shortstat = execSync(`git diff ${baseBranch}...HEAD --shortstat -M`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    let added = 0;
-    let removed = 0;
-    const addedMatch = shortstat.match(/(\d+) insertion/);
-    const removedMatch = shortstat.match(/(\d+) deletion/);
-    if (addedMatch) {
-      added = parseInt(addedMatch[1], 10);
+    console.log("[GitInit] Fetching all remotes...");
+    runGitCommand("git fetch --all --prune", repoPath);
+    console.log(`[GitInit] Checking out default branch: ${defaultBranch}`);
+    runGitCommand(`git checkout ${defaultBranch}`, repoPath);
+    console.log("[GitInit] Pulling latest changes...");
+    try {
+      runGitCommand("git pull --rebase --autostash", repoPath);
+    } catch (pullError) {
+      console.warn("[GitInit] Pull had issues, continuing anyway:", pullError);
     }
-    if (removedMatch) {
-      removed = parseInt(removedMatch[1], 10);
+    const branchName = findAvailableBranchName(workspaceName, repoPath);
+    if (branchName !== workspaceName) {
+      console.log(`[GitInit] Branch "${workspaceName}" already exists, using "${branchName}" instead`);
     }
-    const fullDiff = execSync(`git diff ${baseBranch}...HEAD -M -C`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
+    console.log(`[GitInit] Creating workspace branch: ${branchName}`);
+    runGitCommand(`git checkout -b ${branchName}`, repoPath);
+    initializedBranch = branchName;
+    console.log(`[GitInit] Successfully initialized on branch: ${branchName}`);
     return {
-      added,
-      removed,
-      fullDiff
+      success: true,
+      branch: branchName
     };
   } catch (error) {
-    console.error("Error getting git diff:", error);
-    return null;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("[GitInit] Failed to initialize repository:", errorMessage);
+    return {
+      success: false,
+      branch: null,
+      error: errorMessage
+    };
   }
 }
 
 // src/index.ts
 var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
 var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
+function checkActiveSSHSessions() {
+  try {
+    const output = execSync2('who | grep -v "^$" | wc -l', { encoding: "utf-8" });
+    const sessionCount = parseInt(output.trim(), 10);
+    return sessionCount > 0;
+  } catch {
+    return false;
+  }
+}
 var app = new Hono3();
 app.get("/health", async (c) => {
   try {
@@ -666,15 +1254,16 @@ app.get("/status", async (c) => {
     const isClaudeUsed = claudeHistory.thread_id !== null;
     const claudeStatus = await claudeManager.getStatus();
     const workingDirectory = claudeStatus.working_directory;
-    const branch = getCurrentBranch(workingDirectory);
-    const gitDiff = getGitDiff(workingDirectory);
+    const hasActiveSSHSessions = checkActiveSSHSessions();
     return c.json({
       isCodexProcessing,
       isClaudeProcessing,
       isCodexUsed,
       isClaudeUsed,
-      branch,
-      gitDiff
+      hasActiveSSHSessions,
+      ...getGitStatus(workingDirectory),
+      linearBetaEnabled: true
+      // TODO: delete
     });
   } catch (error) {
     console.error("Error getting workspace status:", error);
@@ -696,7 +1285,18 @@ serve(
     fetch: app.fetch,
     port
   },
-  (info) => {
+  async (info) => {
     console.log(`Replicas Engine running on port ${info.port}`);
+    const gitResult = await initializeGitRepository();
+    if (gitResult.success) {
+      if (gitResult.branch) {
+        console.log(`Git initialized on branch: ${gitResult.branch}`);
+      }
+    } else {
+      console.warn(`Git initialization warning: ${gitResult.error}`);
+    }
+    await githubTokenManager.start();
+    const monolithService2 = new MonolithService();
+    await monolithService2.sendEvent({ type: "workspace_ready", payload: {} });
   }
 );

package/package.json

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