replicas-engine 0.1.155 → 0.1.157

package/dist/src/index.js

@@ -205,9 +205,13 @@ function parseWarmHookConfig(value, filename = "replicas.json") {
   if (value.timeout !== void 0 && (typeof value.timeout !== "number" || value.timeout <= 0)) {
     throw new Error(`Invalid ${filename}: "warmHook.timeout" must be a positive number`);
   }
+  if (value.separate !== void 0 && typeof value.separate !== "boolean") {
+    throw new Error(`Invalid ${filename}: "warmHook.separate" must be a boolean`);
+  }
   return {
     commands: value.commands,
-    timeout: value.timeout
+    timeout: value.timeout,
+    separate: value.separate
   };
 }
 function resolveWarmHookConfig(value) {
@@ -221,7 +225,8 @@ function resolveWarmHookConfig(value) {
   }
   return {
     commands,
-    timeoutMs: typeof parsed === "string" ? void 0 : parsed.timeout
+    timeoutMs: typeof parsed === "string" ? void 0 : parsed.timeout,
+    separate: typeof parsed === "string" ? void 0 : parsed.separate
   };
 }
 
@@ -251,14 +256,17 @@ function parseReplicasConfig(value, filename = "replicas.json") {
     if (!isRecord2(value.startHook)) {
       throw new Error(`Invalid ${filename}: "startHook" must be an object with "commands" array`);
     }
-    const { commands, timeout } = value.startHook;
+    const { commands, timeout, separate } = value.startHook;
     if (!Array.isArray(commands) || !commands.every((entry) => typeof entry === "string")) {
       throw new Error(`Invalid ${filename}: "startHook.commands" must be an array of shell commands`);
     }
     if (timeout !== void 0 && (typeof timeout !== "number" || timeout <= 0)) {
       throw new Error(`Invalid ${filename}: "startHook.timeout" must be a positive number`);
     }
-    config.startHook = { commands, timeout };
+    if (separate !== void 0 && typeof separate !== "boolean") {
+      throw new Error(`Invalid ${filename}: "startHook.separate" must be a boolean`);
+    }
+    config.startHook = { commands, timeout, separate };
   }
   if ("warmHook" in value) {
     config.warmHook = parseWarmHookConfig(value.warmHook, filename);
@@ -277,7 +285,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "11-05-2026-royal-york-v1";
+var DAYTONA_SNAPSHOT_ID = "11-05-2026-royal-york-v3";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -1592,6 +1600,43 @@ var ReplicasConfigService = class {
       console.error("Failed to write to start hooks log:", error);
     }
   }
+  async execStartHookCommand(params) {
+    const output = [];
+    try {
+      await this.logToFile(`[${params.repoName}] --- Running: ${params.label} ---`);
+      const { stdout, stderr } = await execAsync(params.command, {
+        cwd: params.cwd,
+        timeout: params.timeout,
+        maxBuffer: HOOK_EXEC_MAX_BUFFER_BYTES,
+        env: process.env
+      });
+      if (stdout) {
+        output.push(stdout);
+        await this.logToFile(`[${params.repoName}] [stdout] ${stdout}`);
+      }
+      if (stderr) {
+        output.push(stderr);
+        await this.logToFile(`[${params.repoName}] [stderr] ${stderr}`);
+      }
+      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 (execError.stderr) {
+        output.push(execError.stderr);
+        await this.logToFile(`[${params.repoName}] [stderr] ${execError.stderr}`);
+      }
+      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.
    */
@@ -1644,46 +1689,43 @@ Repositories: ${hookEntries.length}
         let repoTimedOut = false;
         const repoOutput = [];
         await this.logToFile(`[${entry.repoName}] Executing ${startHookConfig.commands.length} hook(s) with timeout ${timeout}ms`);
-        for (const hook of startHookConfig.commands) {
-          try {
-            await this.logToFile(`[${entry.repoName}] --- Running: ${hook} ---`);
-            const { stdout, stderr } = await execAsync(hook, {
-              cwd: entry.workingDirectory,
-              timeout,
-              maxBuffer: HOOK_EXEC_MAX_BUFFER_BYTES,
-              env: process.env
-            });
-            if (stdout) {
-              repoOutput.push(stdout);
-              await this.logToFile(`[${entry.repoName}] [stdout] ${stdout}`);
-            }
-            if (stderr) {
-              repoOutput.push(stderr);
-              await this.logToFile(`[${entry.repoName}] [stderr] ${stderr}`);
-            }
-            await this.logToFile(`[${entry.repoName}] --- Completed: ${hook} ---`);
-          } catch (error) {
-            const execError = error;
-            lastExitCode = execError.code ?? 1;
-            if (execError.killed) {
-              repoTimedOut = true;
-            }
+        if (startHookConfig.separate === false) {
+          const combinedScript = `set -e
+${startHookConfig.commands.join("\n")}`;
+          const result = await this.execStartHookCommand({
+            command: combinedScript,
+            label: "combined script",
+            repoName: entry.repoName,
+            cwd: entry.workingDirectory,
+            timeout
+          });
+          repoOutput.push(...result.output);
+          if (result.exitCode !== 0) {
+            lastExitCode = result.exitCode;
+            repoTimedOut = result.timedOut;
             this.hooksFailed = true;
             repoFailed = true;
-            if (execError.stdout) {
-              repoOutput.push(execError.stdout);
-              await this.logToFile(`[${entry.repoName}] [stdout] ${execError.stdout}`);
-            }
-            if (execError.stderr) {
-              repoOutput.push(execError.stderr);
-              await this.logToFile(`[${entry.repoName}] [stderr] ${execError.stderr}`);
-            }
-            const rawMessage = execError.message ?? "Unknown error";
-            const errorMessage = rawMessage.split("\n", 1)[0];
-            repoOutput.push(`[ERROR] ${hook} failed: ${errorMessage}`);
-            await this.logToFile(`[${entry.repoName}] [ERROR] ${hook} failed: ${errorMessage}`);
             await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
           }
+        } else {
+          for (const hook of startHookConfig.commands) {
+            const result = await this.execStartHookCommand({
+              command: hook,
+              label: hook,
+              repoName: entry.repoName,
+              cwd: entry.workingDirectory,
+              timeout
+            });
+            repoOutput.push(...result.output);
+            if (result.exitCode !== 0) {
+              lastExitCode = result.exitCode;
+              repoTimedOut = result.timedOut;
+              this.hooksFailed = true;
+              repoFailed = true;
+              await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
+              break;
+            }
+          }
         }
         await startHookLogsService.saveRepoLog(entry.repoName, {
           hookCommands: startHookConfig.commands,
@@ -1993,12 +2035,12 @@ function convertClaudeEvent(event, linearSessionId) {
           }
         };
       }
-      if (block.type === "thinking" && block.text) {
+      if (block.type === "thinking" && block.thinking) {
         return {
           linearSessionId,
           content: {
             type: "thought",
-            body: block.text
+            body: block.thinking
           }
         };
       }
@@ -4451,8 +4493,7 @@ var PlanService = class {
 var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify3 } from "util";
+import { spawn } from "child_process";
 import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import { join as join15 } from "path";
@@ -4565,34 +4606,6 @@ var WarmHookLogsService = class {
 var warmHookLogsService = new WarmHookLogsService();
 
 // src/services/warm-hooks-service.ts
-var execFileAsync2 = promisify3(execFile2);
-async function executeHookScript(params) {
-  const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
-  try {
-    const { stdout, stderr } = await execFileAsync2("bash", ["-lc", params.content], {
-      cwd: params.cwd,
-      timeout,
-      maxBuffer: HOOK_EXEC_MAX_BUFFER_BYTES,
-      env: process.env
-    });
-    const combined = [`$ ${params.label}`, stdout ?? "", stderr ?? ""].filter(Boolean).join("\n");
-    return {
-      exitCode: 0,
-      output: combined,
-      timedOut: false
-    };
-  } catch (error) {
-    const execError = error;
-    const timedOut = execError.signal === "SIGTERM" || execError.killed === true;
-    const exitCode = typeof execError.code === "number" ? execError.code : 1;
-    const combined = [`$ ${params.label}`, execError.stdout ?? "", execError.stderr ?? "", execError.message].filter(Boolean).join("\n");
-    return {
-      exitCode,
-      output: combined,
-      timedOut
-    };
-  }
-}
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
     const configPath = join15(repoPath, filename);
@@ -4628,22 +4641,87 @@ async function collectRepoWarmHooks() {
       repoName: repo.name,
       repoPath: repo.path,
       commands: warmHook.commands,
-      timeoutMs: warmHook.timeoutMs
+      timeoutMs: warmHook.timeoutMs,
+      separate: warmHook.separate
     });
   }
   collected.sort((a, b) => a.repoName.localeCompare(b.repoName));
   return collected;
 }
 async function runWarmHooks(params) {
+  return runWarmHooksStreaming({ ...params, onEvent: () => {
+  } });
+}
+async function executeHookScriptStreaming(params) {
+  const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
+  const outputParts = [];
+  let outputBytes = 0;
+  let bufferExceeded = false;
+  params.onChunk(`$ ${params.label}
+`);
+  return new Promise((resolve2) => {
+    const proc = spawn("bash", ["-lc", params.content], {
+      cwd: params.cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      proc.kill("SIGTERM");
+    }, timeout);
+    const handleData = (data) => {
+      outputBytes += data.length;
+      if (bufferExceeded) return;
+      if (outputBytes > HOOK_EXEC_MAX_BUFFER_BYTES) {
+        bufferExceeded = true;
+        const msg = `
+[output truncated \u2014 exceeded ${HOOK_EXEC_MAX_BUFFER_BYTES} bytes]
+`;
+        outputParts.push(msg);
+        params.onChunk(msg);
+        proc.kill("SIGTERM");
+        return;
+      }
+      const text = data.toString();
+      outputParts.push(text);
+      params.onChunk(text);
+    };
+    proc.stdout.on("data", handleData);
+    proc.stderr.on("data", handleData);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      const output = [`$ ${params.label}`, ...outputParts].join("");
+      resolve2({
+        exitCode: bufferExceeded ? 1 : code ?? 1,
+        output,
+        timedOut: killed && !bufferExceeded
+      });
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      const output = [`$ ${params.label}
+`, ...outputParts, err.message].join("");
+      resolve2({
+        exitCode: 1,
+        output,
+        timedOut: false
+      });
+    });
+    proc.stdin.end();
+  });
+}
+async function runWarmHooksStreaming(params) {
   const outputBlocks = [];
   const globalHook = (params.globalWarmHook ?? params.organizationWarmHook)?.trim();
   const environmentHook = params.environmentWarmHook?.trim();
   if (globalHook) {
-    const globalResult = await executeHookScript({
+    const globalResult = await executeHookScriptStreaming({
       label: "global-warm-hook",
       cwd: gitService.getWorkspaceRoot(),
       content: globalHook,
-      timeoutMs: params.timeoutMs
+      timeoutMs: params.timeoutMs,
+      onChunk: (chunk) => params.onEvent({ type: "output", data: chunk, label: "global-warm-hook" })
     });
     outputBlocks.push(globalResult.output);
     await environmentDetailsService.setGlobalWarmHook(globalResult.exitCode === 0 ? "yes" : "no", globalResult.output);
@@ -4656,19 +4734,22 @@ async function runWarmHooks(params) {
     });
     if (globalResult.exitCode !== 0) {
       await environmentDetailsService.setEnvironmentWarmHook("n/a");
-      return {
+      const result2 = {
         exitCode: globalResult.exitCode,
         output: outputBlocks.join("\n\n"),
         timedOut: globalResult.timedOut
       };
+      params.onEvent({ type: "complete", exitCode: result2.exitCode, timedOut: result2.timedOut });
+      return result2;
     }
   }
   if (environmentHook) {
-    const envResult = await executeHookScript({
+    const envResult = await executeHookScriptStreaming({
       label: "environment-warm-hook",
       cwd: gitService.getWorkspaceRoot(),
       content: environmentHook,
-      timeoutMs: params.timeoutMs
+      timeoutMs: params.timeoutMs,
+      onChunk: (chunk) => params.onEvent({ type: "output", data: chunk, label: "environment-warm-hook" })
     });
     outputBlocks.push(envResult.output);
     await environmentDetailsService.setEnvironmentWarmHook(envResult.exitCode === 0 ? "yes" : "no", envResult.output);
@@ -4680,11 +4761,13 @@ async function runWarmHooks(params) {
       executedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (envResult.exitCode !== 0) {
-      return {
+      const result2 = {
         exitCode: envResult.exitCode,
         output: outputBlocks.join("\n\n"),
         timedOut: envResult.timedOut
       };
+      params.onEvent({ type: "complete", exitCode: result2.exitCode, timedOut: result2.timedOut });
+      return result2;
     }
   } else {
     await environmentDetailsService.setEnvironmentWarmHook("n/a");
@@ -4706,53 +4789,73 @@ async function runWarmHooks(params) {
     let repoFailed = false;
     let repoTimedOut = false;
     let repoExitCode = 0;
-    for (const command of repoHook.commands) {
-      const repoResult = await executeHookScript({
+    if (repoHook.separate === false) {
+      const scriptWithErrExit = `set -e
+${combinedScript}`;
+      const repoResult = await executeHookScriptStreaming({
         label: `repo-warm-hook:${repoHook.repoName}`,
         cwd: repoHook.repoPath,
-        content: command,
-        timeoutMs: repoHook.timeoutMs
+        content: scriptWithErrExit,
+        timeoutMs: repoHook.timeoutMs,
+        onChunk: (chunk) => params.onEvent({ type: "output", data: chunk, label: `repo:${repoHook.repoName}` })
       });
       outputBlocks.push(repoResult.output);
       repoOutputBlocks.push(repoResult.output);
-      await environmentDetailsService.setRepositoryWarmHook(
-        repoHook.repoName,
-        repoResult.exitCode === 0 ? "yes" : "no"
-      );
       if (repoResult.exitCode !== 0) {
         repoFailed = true;
         repoTimedOut = repoResult.timedOut;
         repoExitCode = repoResult.exitCode;
-        break;
+      }
+    } else {
+      for (const command of repoHook.commands) {
+        const repoResult = await executeHookScriptStreaming({
+          label: `repo-warm-hook:${repoHook.repoName}`,
+          cwd: repoHook.repoPath,
+          content: command,
+          timeoutMs: repoHook.timeoutMs,
+          onChunk: (chunk) => params.onEvent({ type: "output", data: chunk, label: `repo:${repoHook.repoName}` })
+        });
+        outputBlocks.push(repoResult.output);
+        repoOutputBlocks.push(repoResult.output);
+        if (repoResult.exitCode !== 0) {
+          repoFailed = true;
+          repoTimedOut = repoResult.timedOut;
+          repoExitCode = repoResult.exitCode;
+          break;
+        }
       }
     }
+    await environmentDetailsService.setRepositoryWarmHook(
+      repoHook.repoName,
+      repoFailed ? "no" : "yes"
+    );
+    const loggedScript = repoHook.separate === false ? `set -e
+${combinedScript}` : combinedScript;
     await warmHookLogsService.saveRepoHookLog(repoHook.repoName, {
-      hookScript: combinedScript,
+      hookScript: loggedScript,
       output: repoOutputBlocks.join("\n\n"),
       exitCode: repoFailed ? repoExitCode : 0,
       timedOut: repoTimedOut,
       executedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (repoFailed) {
-      return {
+      const result2 = {
         exitCode: repoExitCode,
         output: outputBlocks.join("\n\n"),
         timedOut: repoTimedOut
       };
+      params.onEvent({ type: "complete", exitCode: result2.exitCode, timedOut: result2.timedOut });
+      return result2;
     }
   }
   if (outputBlocks.length === 0) {
-    return {
-      exitCode: 0,
-      output: "No warm hooks configured.",
-      timedOut: false
-    };
+    const result2 = { exitCode: 0, output: "No warm hooks configured.", timedOut: false };
+    params.onEvent({ type: "complete", exitCode: 0, timedOut: false });
+    return result2;
   }
-  return {
-    exitCode: 0,
-    output: outputBlocks.join("\n\n"),
-    timedOut: false
-  };
+  const result = { exitCode: 0, output: outputBlocks.join("\n\n"), timedOut: false };
+  params.onEvent({ type: "complete", exitCode: 0, timedOut: false });
+  return result;
 }
 
 // src/v1-routes.ts
@@ -5046,6 +5149,66 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.post("/warm-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");
+          runWarmHooksStreaming({
+            globalWarmHook: body.globalWarmHook,
+            environmentWarmHook: body.environmentWarmHook,
+            organizationWarmHook: body.organizationWarmHook,
+            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 warm 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.155",
+  "version": "0.1.157",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",