replicas-engine 0.1.154 → 0.1.156

package/dist/src/index.js

@@ -277,7 +277,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "10-05-2026-royal-york-v5";
+var DAYTONA_SNAPSHOT_ID = "11-05-2026-royal-york-v2";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -1993,12 +1993,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 +4451,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 +4564,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);
@@ -4635,15 +4606,79 @@ async function collectRepoWarmHooks() {
   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 +4691,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 +4718,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");
@@ -4707,11 +4747,12 @@ async function runWarmHooks(params) {
     let repoTimedOut = false;
     let repoExitCode = 0;
     for (const command of repoHook.commands) {
-      const repoResult = await executeHookScript({
+      const repoResult = await executeHookScriptStreaming({
         label: `repo-warm-hook:${repoHook.repoName}`,
         cwd: repoHook.repoPath,
         content: command,
-        timeoutMs: repoHook.timeoutMs
+        timeoutMs: repoHook.timeoutMs,
+        onChunk: (chunk) => params.onEvent({ type: "output", data: chunk, label: `repo:${repoHook.repoName}` })
       });
       outputBlocks.push(repoResult.output);
       repoOutputBlocks.push(repoResult.output);
@@ -4734,25 +4775,23 @@ async function runWarmHooks(params) {
       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 +5085,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.154",
+  "version": "0.1.156",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",