replicas-engine 0.1.229 → 0.1.231

package/dist/src/index.js

@@ -1652,9 +1652,26 @@ function parseGoalCommand(message) {
 // ../shared/src/replicas-config.ts
 import { parse as parseYaml } from "yaml";
 
+// ../shared/src/hook-config.ts
+function resolveHookConfig(value) {
+  if (value === void 0) {
+    return null;
+  }
+  const commands = typeof value === "string" ? [value.trim()].filter(Boolean) : value.commands.map((command) => command.trim()).filter(Boolean);
+  if (commands.length === 0) {
+    return null;
+  }
+  return {
+    commands,
+    timeoutMs: typeof value === "string" ? void 0 : value.timeout,
+    separate: typeof value === "string" ? void 0 : value.separate
+  };
+}
+
 // ../shared/src/warm-hooks.ts
-var DEFAULT_WARM_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
-var MAX_WARM_HOOK_TIMEOUT_MS = 15 * 60 * 1e3;
+var DEFAULT_WARM_HOOK_TIMEOUT_MS = 60 * 60 * 1e3;
+var MAX_WARM_HOOK_TIMEOUT_MS = 120 * 60 * 1e3;
+var DEFAULT_START_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
 var DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS = 1e5;
 var HOOK_EXEC_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
 function isRecord2(value) {
@@ -1703,16 +1720,7 @@ function resolveWarmHookConfig(value) {
   if (value === void 0) {
     return null;
   }
-  const parsed = parseWarmHookConfig(value);
-  const commands = typeof parsed === "string" ? [parsed.trim()].filter(Boolean) : parsed.commands.map((command) => command.trim()).filter(Boolean);
-  if (commands.length === 0) {
-    return null;
-  }
-  return {
-    commands,
-    timeoutMs: typeof parsed === "string" ? void 0 : parsed.timeout,
-    separate: typeof parsed === "string" ? void 0 : parsed.separate
-  };
+  return resolveHookConfig(parseWarmHookConfig(value));
 }
 
 // ../shared/src/replicas-config.ts
@@ -1776,7 +1784,7 @@ function isClaudeAuthErrorText(text) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "28-05-2026-royal-york-v6";
+var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v2";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -2022,7 +2030,9 @@ function loadEngineEnv() {
     AWS_REGION: readEnv("AWS_REGION"),
     REPLICAS_CLAUDE_AUTH_METHOD: parseClaudeAuthMethod(readEnv("REPLICAS_CLAUDE_AUTH_METHOD")),
     REPLICAS_CODEX_AUTH_METHOD: parseCodexAuthMethod(readEnv("REPLICAS_CODEX_AUTH_METHOD")),
-    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT")
+    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT"),
+    REPLICAS_ENV_START_HOOK: readEnv("REPLICAS_ENV_START_HOOK"),
+    REPLICAS_DISABLE_AUTO_START_HOOKS: readEnv("REPLICAS_DISABLE_AUTO_START_HOOKS")?.toLowerCase() === "true"
   };
   if (!IS_WARMING_MODE && !env.WORKSPACE_ID) {
     console.error("WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
@@ -3053,8 +3063,7 @@ import { readFile as readFile4, appendFile as appendFile2, writeFile as writeFil
 import { existsSync as existsSync4 } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir7 } from "os";
-import { exec } from "child_process";
-import { promisify as promisify2 } from "util";
+import { spawn } from "child_process";
 
 // src/services/environment-details-service.ts
 import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
@@ -3114,6 +3123,7 @@ function createDefaultDetails() {
     engineVersion: DAYTONA_SNAPSHOT_ID,
     globalWarmHookCompleted: { status: "n/a", details: null },
     environmentWarmHookCompleted: { status: "n/a", details: null },
+    environmentStartHookCompleted: { status: "n/a", details: null },
     repositories: [],
     filesUploaded: [],
     envVarsSet: [],
@@ -3199,6 +3209,12 @@ var EnvironmentDetailsService = class {
     current.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await writeDetails(current);
   }
+  async setEnvironmentStartHook(status, details) {
+    const current = await readDetails();
+    current.environmentStartHookCompleted = { status, details: details ?? null };
+    current.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeDetails(current);
+  }
   async setRepositoryWarmHook(repositoryName, status) {
     const current = await readDetails();
     current.repositories = upsertRepositoryStatus(current.repositories, [{
@@ -3294,7 +3310,6 @@ var StartHookLogsService = class {
 var startHookLogsService = new StartHookLogsService();
 
 // src/services/replicas-config-service.ts
-var execAsync = promisify2(exec);
 var START_HOOKS_LOG = join9(homedir7(), ".replicas", "startHooks.log");
 var START_HOOKS_RUNNING_PROMPT = `IMPORTANT - Start Hooks Running:
 Start hooks are shell commands/scripts set by repository owners that run on workspace startup.
@@ -3326,6 +3341,12 @@ var ReplicasConfigService = class {
    */
   async initialize() {
     await this.loadConfigs();
+    if (IS_WARMING_MODE || ENGINE_ENV.REPLICAS_DISABLE_AUTO_START_HOOKS) {
+      this.hooksRunning = false;
+      this.hooksCompleted = false;
+      this.hooksFailed = false;
+      return;
+    }
     void this.executeStartHooks().catch((error) => {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.hooksFailed = true;
@@ -3376,71 +3397,156 @@ var ReplicasConfigService = class {
       console.error("Failed to write to start hooks log:", error);
     }
   }
+  async executeEnvironmentStartHook(params) {
+    await this.logToFile(`[environment] --- Running env-level start hook ---`);
+    const result = await this.execStartHookCommand({
+      command: params.content,
+      label: "env start hook",
+      repoName: "environment",
+      cwd: homedir7(),
+      timeout: params.timeoutMs ?? DEFAULT_START_HOOK_TIMEOUT_MS,
+      onOutputChunk: params.onOutputChunk
+    });
+    if (result.exitCode !== 0) {
+      this.hooksFailed = true;
+      await environmentDetailsService.setEnvironmentStartHook("no");
+    } else {
+      await environmentDetailsService.setEnvironmentStartHook("yes");
+    }
+    return result;
+  }
   async execStartHookCommand(params) {
     const output = [];
-    try {
-      await this.logToFile(`[${params.repoName}] --- Running: ${params.label} ---`);
-      const { stdout, stderr } = await execAsync(params.command, {
+    let outputBytes = 0;
+    let bufferExceeded = false;
+    const emit = (chunk) => {
+      output.push(chunk);
+      params.onOutputChunk?.(chunk);
+    };
+    await this.logToFile(`[${params.repoName}] --- Running: ${params.label} ---`);
+    emit(`$ ${params.label}
+`);
+    return new Promise((resolve3) => {
+      const proc = spawn("bash", ["-lc", params.command], {
         cwd: params.cwd,
-        timeout: params.timeout,
-        maxBuffer: HOOK_EXEC_MAX_BUFFER_BYTES,
-        env: process.env
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"]
       });
-      if (stdout) {
-        output.push(stdout);
-        await this.logToFile(`[${params.repoName}] [stdout] ${stdout}`);
-      }
-      if (stderr) {
-        output.push(stderr);
-        await this.logToFile(`[${params.repoName}] [stderr] ${stderr}`);
+      let timedOut = false;
+      let settled = false;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve3(result);
+      };
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, params.timeout);
+      const handleData = (data, streamName) => {
+        outputBytes += data.length;
+        if (bufferExceeded) return;
+        if (outputBytes > HOOK_EXEC_MAX_BUFFER_BYTES) {
+          bufferExceeded = true;
+          const message = `
+[output truncated \u2014 exceeded ${HOOK_EXEC_MAX_BUFFER_BYTES} bytes]
+`;
+          emit(message);
+          void this.logToFile(`[${params.repoName}] [ERROR] ${message.trim()}`);
+          proc.kill("SIGTERM");
+          return;
+        }
+        const text = data.toString();
+        emit(text);
+        void this.logToFile(`[${params.repoName}] [${streamName}] ${text}`);
+      };
+      proc.stdout.on("data", (data) => handleData(data, "stdout"));
+      proc.stderr.on("data", (data) => handleData(data, "stderr"));
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const exitCode = bufferExceeded ? 1 : code ?? 1;
+        if (exitCode !== 0) {
+          const reason = timedOut ? "timed out" : `exited with code ${exitCode}`;
+          const message = `[ERROR] ${params.label} failed: ${reason}
+`;
+          emit(message);
+          void this.logToFile(`[${params.repoName}] ${message.trim()}`);
+        } else {
+          void this.logToFile(`[${params.repoName}] --- Completed: ${params.label} ---`);
+        }
+        finish({ exitCode, timedOut: timedOut && !bufferExceeded, output });
+      });
+      proc.on("error", (error) => {
+        clearTimeout(timer);
+        const message = `[ERROR] ${params.label} failed: ${error.message}
+`;
+        emit(message);
+        void this.logToFile(`[${params.repoName}] ${message.trim()}`);
+        finish({ exitCode: 1, timedOut: false, output });
+      });
+      proc.stdin.end();
+    });
+  }
+  async executeStartHooks(params = {}) {
+    const onEvent = params.onEvent ?? (() => {
+    });
+    const envHookContent = (params.environmentStartHook ?? ENGINE_ENV.REPLICAS_ENV_START_HOOK)?.trim() ?? "";
+    const hookEntries = this.configs.filter((entry) => entry.config.startHook && entry.config.startHook.commands.length > 0);
+    const outputBlocks = [];
+    let overallExitCode = 0;
+    let overallTimedOut = false;
+    const recordResult = (result) => {
+      const output = result.output.join("");
+      if (output) {
+        outputBlocks.push(output);
       }
-      await this.logToFile(`[${params.repoName}] --- Completed: ${params.label} ---`);
-      return { exitCode: 0, timedOut: false, output };
-    } catch (error) {
-      const execError = error;
-      if (execError.stdout) {
-        output.push(execError.stdout);
-        await this.logToFile(`[${params.repoName}] [stdout] ${execError.stdout}`);
+      if (result.exitCode !== 0 && overallExitCode === 0) {
+        overallExitCode = result.exitCode;
       }
-      if (execError.stderr) {
-        output.push(execError.stderr);
-        await this.logToFile(`[${params.repoName}] [stderr] ${execError.stderr}`);
+      if (result.timedOut) {
+        overallTimedOut = true;
       }
-      const rawMessage = execError.message ?? "Unknown error";
-      const errorMessage = rawMessage.split("\n", 1)[0];
-      output.push(`[ERROR] ${params.label} failed: ${errorMessage}`);
-      await this.logToFile(`[${params.repoName}] [ERROR] ${params.label} failed: ${errorMessage}`);
-      return { exitCode: execError.code ?? 1, timedOut: execError.killed === true, output };
-    }
-  }
-  /**
-   * Execute start hooks from all repositories sequentially.
-   */
-  async executeStartHooks() {
-    const hookEntries = this.configs.filter((entry) => entry.config.startHook && entry.config.startHook.commands.length > 0);
-    if (hookEntries.length === 0) {
+    };
+    if (!envHookContent && hookEntries.length === 0) {
       this.hooksRunning = false;
       this.hooksCompleted = true;
       this.hooksFailed = false;
+      await environmentDetailsService.setEnvironmentStartHook("n/a");
       const repos = await gitService.listRepositories();
       for (const repo of repos) {
         await environmentDetailsService.setRepositoryStartHook(repo.name, "n/a");
       }
-      return;
+      const result = { exitCode: 0, output: "No start hooks configured.", timedOut: false };
+      onEvent({ type: "output", data: `${result.output}
+`, label: "start-hooks" });
+      onEvent({ type: "complete", exitCode: result.exitCode, timedOut: result.timedOut });
+      return result;
     }
     this.hooksRunning = true;
     this.hooksCompleted = false;
+    this.hooksFailed = false;
     try {
       await mkdir5(join9(homedir7(), ".replicas"), { recursive: true });
       await writeFile5(
         START_HOOKS_LOG,
         `=== Start Hooks Execution Log ===
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+Environment hook: ${envHookContent ? "yes" : "no"}
 Repositories: ${hookEntries.length}
 
 `,
         "utf-8"
       );
+      if (envHookContent) {
+        const envResult = await this.executeEnvironmentStartHook({
+          content: envHookContent,
+          timeoutMs: params.timeoutMs,
+          onOutputChunk: (chunk) => onEvent({ type: "output", data: chunk, label: "environment" })
+        });
+        recordResult(envResult);
+      } else {
+        await environmentDetailsService.setEnvironmentStartHook("n/a");
+      }
       const repos = await gitService.listRepositories();
       const reposWithHooks = new Set(hookEntries.map((entry) => entry.repoName));
       for (const repo of repos) {
@@ -3454,48 +3560,53 @@ Repositories: ${hookEntries.length}
           continue;
         }
         const persistedRepoState = await loadRepoState(entry.repoName);
-        if (persistedRepoState?.startHooksCompleted) {
+        if (!params.ignorePersistedState && persistedRepoState?.startHooksCompleted) {
           await this.logToFile(`[${entry.repoName}] Start hooks already completed in this workspace lifecycle, skipping`);
           await environmentDetailsService.setRepositoryStartHook(entry.repoName, "yes");
           continue;
         }
-        const timeout = startHookConfig.timeout ?? 3e5;
+        const timeout = params.timeoutMs ?? startHookConfig.timeout ?? DEFAULT_START_HOOK_TIMEOUT_MS;
         let repoFailed = false;
         let lastExitCode = 0;
         let repoTimedOut = false;
         const repoOutput = [];
+        const onRepoOutput = (chunk) => onEvent({ type: "output", data: chunk, label: `repo:${entry.repoName}` });
         await this.logToFile(`[${entry.repoName}] Executing ${startHookConfig.commands.length} hook(s) with timeout ${timeout}ms`);
         if (startHookConfig.separate === false) {
           const combinedScript = `set -e
 ${startHookConfig.commands.join("\n")}`;
-          const result = await this.execStartHookCommand({
+          const result2 = await this.execStartHookCommand({
             command: combinedScript,
             label: "combined script",
             repoName: entry.repoName,
             cwd: entry.workingDirectory,
-            timeout
+            timeout,
+            onOutputChunk: onRepoOutput
           });
-          repoOutput.push(...result.output);
-          if (result.exitCode !== 0) {
-            lastExitCode = result.exitCode;
-            repoTimedOut = result.timedOut;
+          repoOutput.push(...result2.output);
+          recordResult(result2);
+          if (result2.exitCode !== 0) {
+            lastExitCode = result2.exitCode;
+            repoTimedOut = result2.timedOut;
             this.hooksFailed = true;
             repoFailed = true;
             await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
           }
         } else {
           for (const hook of startHookConfig.commands) {
-            const result = await this.execStartHookCommand({
+            const result2 = await this.execStartHookCommand({
               command: hook,
               label: hook,
               repoName: entry.repoName,
               cwd: entry.workingDirectory,
-              timeout
+              timeout,
+              onOutputChunk: onRepoOutput
             });
-            repoOutput.push(...result.output);
-            if (result.exitCode !== 0) {
-              lastExitCode = result.exitCode;
-              repoTimedOut = result.timedOut;
+            repoOutput.push(...result2.output);
+            recordResult(result2);
+            if (result2.exitCode !== 0) {
+              lastExitCode = result2.exitCode;
+              repoTimedOut = result2.timedOut;
               this.hooksFailed = true;
               repoFailed = true;
               await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
@@ -3510,20 +3621,30 @@ ${startHookConfig.commands.join("\n")}`;
           timedOut: repoTimedOut,
           executedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        const fallbackRepoState = persistedRepoState ?? {
-          name: entry.repoName,
-          path: entry.workingDirectory,
-          defaultBranch: entry.defaultBranch,
-          currentBranch: entry.defaultBranch,
-          prUrls: [],
-          gitDiff: null,
-          startHooksCompleted: false
-        };
-        await saveRepoState(entry.repoName, { startHooksCompleted: true }, fallbackRepoState);
+        if ((params.markRepoCompleted ?? true) && !repoFailed) {
+          const fallbackRepoState = persistedRepoState ?? {
+            name: entry.repoName,
+            path: entry.workingDirectory,
+            defaultBranch: entry.defaultBranch,
+            currentBranch: entry.defaultBranch,
+            prUrls: [],
+            gitDiff: null,
+            startHooksCompleted: false
+          };
+          await saveRepoState(entry.repoName, { startHooksCompleted: true }, fallbackRepoState);
+        }
         await environmentDetailsService.setRepositoryStartHook(entry.repoName, repoFailed ? "no" : "yes");
       }
       this.hooksCompleted = true;
+      this.hooksFailed = overallExitCode !== 0;
       await this.logToFile(`=== All start hooks completed at ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
+      const result = {
+        exitCode: overallExitCode,
+        output: outputBlocks.join("\n\n"),
+        timedOut: overallTimedOut
+      };
+      onEvent({ type: "complete", exitCode: result.exitCode, timedOut: result.timedOut });
+      return result;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.hooksFailed = true;
@@ -3535,6 +3656,16 @@ ${startHookConfig.commands.join("\n")}`;
       this.hooksRunning = false;
     }
   }
+  async runStartHooksStreaming(params) {
+    await this.loadConfigs();
+    return this.executeStartHooks({
+      environmentStartHook: params.environmentStartHook,
+      timeoutMs: params.timeoutMs,
+      ignorePersistedState: true,
+      markRepoCompleted: false,
+      onEvent: params.onEvent
+    });
+  }
   /**
    * Check if start hooks are currently running.
    */
@@ -3547,14 +3678,18 @@ ${startHookConfig.commands.join("\n")}`;
   didHooksFail() {
     return this.hooksFailed;
   }
-  /**
-   * Get aggregated start hook metadata.
-   */
   getStartHookConfig() {
-    const commands = this.configs.flatMap((entry) => {
+    const commands = [];
+    const envHookContent = ENGINE_ENV.REPLICAS_ENV_START_HOOK?.trim();
+    if (envHookContent) {
+      commands.push(`[environment] ${envHookContent}`);
+    }
+    for (const entry of this.configs) {
       const repoCommands = entry.config.startHook?.commands ?? [];
-      return repoCommands.map((command) => `[${entry.repoName}] ${command}`);
-    });
+      for (const command of repoCommands) {
+        commands.push(`[${entry.repoName}] ${command}`);
+      }
+    }
     if (commands.length === 0) {
       return void 0;
     }
@@ -5358,7 +5493,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
 };
 
 // src/managers/codex-asp/app-server-process.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 
 // src/managers/codex-asp/asp-client.ts
@@ -5580,7 +5715,7 @@ var AppServerProcess = class {
       return { client: this.client };
     }
     this.shuttingDown = false;
-    const child = spawn(this.binary, this.args, {
+    const child = spawn2(this.binary, this.args, {
       cwd: this.cwd,
       env: this.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -9010,7 +9145,7 @@ var PlanService = class {
 var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import { join as join19 } from "path";
@@ -9199,7 +9334,7 @@ async function executeHookScriptStreaming(params) {
   params.onChunk(`$ ${params.label}
 `);
   return new Promise((resolve3) => {
-    const proc = spawn2("bash", ["-lc", params.content], {
+    const proc = spawn3("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -9854,6 +9989,64 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.post("/start-hooks/run/stream", async (c) => {
+    try {
+      const body = await c.req.json();
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start: (controller) => {
+          let closed = false;
+          const safeEnqueue = (chunk) => {
+            if (closed) return false;
+            try {
+              controller.enqueue(encoder.encode(chunk));
+              return true;
+            } catch {
+              closed = true;
+              return false;
+            }
+          };
+          const heartbeat = setInterval(() => {
+            if (!safeEnqueue(": ping\n\n")) clearInterval(heartbeat);
+          }, 15e3);
+          safeEnqueue(": connected\n\n");
+          replicasConfigService.runStartHooksStreaming({
+            environmentStartHook: body.environmentStartHook,
+            timeoutMs: body.timeoutMs,
+            onEvent: (event) => {
+              safeEnqueue(`data: ${JSON.stringify(event)}
+
+`);
+            }
+          }).then(() => {
+            clearInterval(heartbeat);
+            if (!closed) {
+              closed = true;
+              controller.close();
+            }
+          }).catch((err) => {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            safeEnqueue(`data: ${JSON.stringify({ type: "error", data: message })}
+
+`);
+            clearInterval(heartbeat);
+            if (!closed) {
+              closed = true;
+              controller.close();
+            }
+          });
+        }
+      });
+      return new Response(stream, {
+        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" }
+      });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to run start hooks", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
   app2.get("/warm-hooks/logs", async (c) => {
     try {
       const logs = await warmHookLogsService.getAllLogs();

package/package.json

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