replicas-engine 0.1.230 → 0.1.232

package/dist/src/index.js

@@ -1652,6 +1652,22 @@ 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 = 60 * 60 * 1e3;
 var MAX_WARM_HOOK_TIMEOUT_MS = 120 * 60 * 1e3;
@@ -1667,17 +1683,25 @@ function clampWarmHookTimeoutMs(timeoutMs) {
   }
   return Math.min(timeoutMs, MAX_WARM_HOOK_TIMEOUT_MS);
 }
-function buildHookOutputPreview(text, maxChars = DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS) {
+function buildOutputPreview(text, {
+  maxChars = DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS,
+  truncateFrom = "head",
+  marker = "\n...[truncated \u2014 download the full log to see the rest]"
+} = {}) {
   if (text.length <= maxChars) {
     return { output: text, outputTruncated: false, outputTotalChars: text.length };
   }
+  const previewChars = Math.max(0, maxChars - marker.length);
+  const output = previewChars === 0 ? marker.slice(0, maxChars) : truncateFrom === "tail" ? `${marker}${text.slice(-previewChars)}` : `${text.slice(0, previewChars)}${marker}`;
   return {
-    output: `${text.slice(0, maxChars)}
-...[truncated \u2014 download the full log to see the rest]`,
+    output,
     outputTruncated: true,
     outputTotalChars: text.length
   };
 }
+function buildHookOutputPreview(text, maxChars = DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS) {
+  return buildOutputPreview(text, { maxChars });
+}
 function parseWarmHookConfig(value, filename = "replicas.json") {
   if (typeof value === "string") {
     return value;
@@ -1704,16 +1728,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
@@ -1777,7 +1792,7 @@ function isClaudeAuthErrorText(text) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v1";
+var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v3";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -2023,7 +2038,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");
@@ -2426,11 +2443,24 @@ import { execFileSync as execFileSync2, spawnSync } from "child_process";
 import { join as join5 } from "path";
 
 // src/utils/state.ts
-import { readFile, writeFile, mkdir, rename, unlink } from "fs/promises";
+import { readFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 
+// src/utils/file.ts
+import { rename, unlink, writeFile } from "fs/promises";
+async function atomicWriteFile(path4, data) {
+  const tmpFile = `${path4}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(tmpFile, data, "utf-8");
+    await rename(tmpFile, path4);
+  } catch (error) {
+    await unlink(tmpFile).catch(() => void 0);
+    throw error;
+  }
+}
+
 // src/utils/type-guards.ts
 function isRecord4(value) {
   return typeof value === "object" && value !== null;
@@ -2453,14 +2483,7 @@ async function updateEngineState(updater) {
     await mkdir(STATE_DIR, { recursive: true });
     const currentState = await loadEngineState();
     const nextState = updater(currentState);
-    const tmpFile = `${STATE_FILE}.${process.pid}.tmp`;
-    try {
-      await writeFile(tmpFile, JSON.stringify(nextState, null, 2), "utf-8");
-      await rename(tmpFile, STATE_FILE);
-    } catch (err) {
-      await unlink(tmpFile).catch(() => void 0);
-      throw err;
-    }
+    await atomicWriteFile(STATE_FILE, JSON.stringify(nextState, null, 2));
   });
 }
 function isEngineRepoDiff(value) {
@@ -3050,15 +3073,14 @@ var EngineLogger = class {
 var engineLogger = new EngineLogger();
 
 // src/services/replicas-config-service.ts
-import { readFile as readFile4, appendFile as appendFile2, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { readFile as readFile4, appendFile as appendFile2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
 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";
+import { mkdir as mkdir3, readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
@@ -3115,6 +3137,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: [],
@@ -3145,8 +3168,8 @@ async function readDetails() {
 }
 async function writeDetails(details) {
   await mkdir3(REPLICAS_DIR, { recursive: true });
-  await writeFile3(DETAILS_FILE, `${JSON.stringify(details, null, 2)}
-`, "utf-8");
+  await atomicWriteFile(DETAILS_FILE, `${JSON.stringify(details, null, 2)}
+`);
 }
 var EnvironmentDetailsService = class {
   async getDetails() {
@@ -3200,6 +3223,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, [{
@@ -3225,7 +3254,7 @@ var environmentDetailsService = new EnvironmentDetailsService();
 
 // src/services/start-hook-logs-service.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4, readdir as readdir2 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3, readdir as readdir2 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join8 } from "path";
 var LOGS_DIR = join8(homedir6(), ".replicas", "start-hook-logs");
@@ -3248,7 +3277,7 @@ var StartHookLogsService = class {
   async saveRepoLog(repoName, entry) {
     await this.ensureDir();
     const log = { repoName, ...entry };
-    await writeFile4(join8(LOGS_DIR, repoFilename(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile3(join8(LOGS_DIR, repoFilename(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -3295,7 +3324,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.
@@ -3327,6 +3355,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;
@@ -3377,71 +3411,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(
+      await writeFile4(
         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) {
@@ -3455,48 +3574,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 ?? DEFAULT_START_HOOK_TIMEOUT_MS;
+        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");
@@ -3511,20 +3635,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;
@@ -3536,6 +3670,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.
    */
@@ -3548,14 +3692,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;
     }
@@ -3619,7 +3767,7 @@ var EventService = class {
 var eventService = new EventService();
 
 // src/services/preview-service.ts
-import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile5 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { homedir as homedir9 } from "os";
@@ -3639,8 +3787,8 @@ async function readPreviewsFile() {
 async function writePreviewsFile(data) {
   const dir = dirname(PREVIEW_PORTS_FILE);
   await mkdir7(dir, { recursive: true });
-  await writeFile6(PREVIEW_PORTS_FILE, `${JSON.stringify(data, null, 2)}
-`, "utf-8");
+  await atomicWriteFile(PREVIEW_PORTS_FILE, `${JSON.stringify(data, null, 2)}
+`);
 }
 var PreviewService = class {
   async initialize() {
@@ -3692,7 +3840,7 @@ var previewService = new PreviewService();
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile5, mkdir as mkdir11, readFile as readFile8, rm, writeFile as writeFile9 } from "fs/promises";
+import { appendFile as appendFile5, copyFile, mkdir as mkdir11, readFile as readFile8, rename as rename2, rm } from "fs/promises";
 import { homedir as homedir13 } from "os";
 import { join as join15 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -4245,7 +4393,7 @@ function extractPlanFromCodexAspNotification(notification) {
 
 // src/utils/image-utils.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir8, unlink as unlink2, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir8, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { join as join12 } from "path";
 function isImageMediaType(value) {
@@ -4333,7 +4481,7 @@ async function saveNormalizedImagesToTempFiles(images, tempImageDir = join12(hom
       const ext = image.source.media_type.split("/")[1] || "png";
       const filename = `img_${randomUUID3()}.${ext}`;
       const filepath = join12(tempImageDir, filename);
-      await writeFile7(filepath, Buffer.from(image.source.data, "base64"));
+      await writeFile5(filepath, Buffer.from(image.source.data, "base64"));
       tempPaths.push(filepath);
     }
   } catch (error) {
@@ -5359,7 +5507,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
@@ -5581,7 +5729,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"]
@@ -5831,6 +5979,7 @@ var THREAD_GOAL_CLEAR_METHOD = "thread/goal/clear";
 var TURN_START_METHOD = "turn/start";
 var TURN_INTERRUPT_METHOD = "turn/interrupt";
 var ACCOUNT_RATE_LIMITS_READ_METHOD = "account/rateLimits/read";
+var MAX_CODEX_ASP_TRANSCRIPT_OUTPUT_CHARS = DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS;
 function toReasoningEffort(thinkingLevel) {
   return codexReasoningEffortForThinkingLevel(thinkingLevel);
 }
@@ -5852,7 +6001,7 @@ function timestampFromMilliseconds(value) {
 }
 function stringifyToolOutput(value) {
   if (value === null || value === void 0) return void 0;
-  if (typeof value === "string") return value;
+  if (typeof value === "string") return truncateCodexAspTranscriptOutput(value);
   if (typeof value === "object" && "content" in value && Array.isArray(value.content)) {
     const text = value.content.map((item) => {
       if (typeof item === "string") return item;
@@ -5861,14 +6010,24 @@ function stringifyToolOutput(value) {
       }
       return "";
     }).filter(Boolean).join("\n");
-    if (text) return text;
+    if (text) return truncateCodexAspTranscriptOutput(text);
   }
   try {
-    return JSON.stringify(value);
+    return truncateCodexAspTranscriptOutput(JSON.stringify(value));
   } catch {
-    return String(value);
+    return truncateCodexAspTranscriptOutput(String(value));
   }
 }
+function truncateCodexAspTranscriptOutput(output, maxChars = MAX_CODEX_ASP_TRANSCRIPT_OUTPUT_CHARS) {
+  return buildOutputPreview(output, {
+    maxChars,
+    truncateFrom: "tail",
+    marker: "\n[output truncated: showing tail of output]\n"
+  }).output;
+}
+function appendCodexAspTranscriptOutput(current, delta, maxChars = MAX_CODEX_ASP_TRANSCRIPT_OUTPUT_CHARS) {
+  return truncateCodexAspTranscriptOutput(`${current ?? ""}${delta}`, maxChars);
+}
 function transcriptPatchOperation(change) {
   return {
     action: change.kind.type,
@@ -5915,7 +6074,7 @@ function itemToTranscriptItem(item, timestamp, status) {
       type: "commandExecution",
       id: item.id,
       command: item.command,
-      ...item.aggregatedOutput ? { output: item.aggregatedOutput } : {},
+      ...item.aggregatedOutput ? { output: truncateCodexAspTranscriptOutput(item.aggregatedOutput) } : {},
       exitCode,
       timestamp,
       status: normalizeCodexAspTranscriptStatus(item.status, typeof exitCode === "number" && exitCode !== 0)
@@ -5939,7 +6098,7 @@ function itemToTranscriptItem(item, timestamp, status) {
       server: item.server,
       tool: item.tool,
       input: item.arguments,
-      output: item.error?.message ?? stringifyToolOutput(item.result),
+      output: item.error?.message ? truncateCodexAspTranscriptOutput(item.error.message) : stringifyToolOutput(item.result),
       timestamp,
       status: normalizeCodexAspTranscriptStatus(item.status, item.status === "failed")
     };
@@ -6953,7 +7112,7 @@ var CodexAspManager = class extends CodingAgentManager {
     if (item.type !== "commandExecution" && item.type !== "fileChange") return;
     turn.items[itemIndex] = {
       ...item,
-      output: `${item.output ?? ""}${delta}`,
+      output: appendCodexAspTranscriptOutput(item.output, delta),
       status: "in_progress"
     };
     this.codexAspTranscript.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -7055,7 +7214,7 @@ var CodexAspManager = class extends CodingAgentManager {
 
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
-import { readdir as readdir3, stat as stat2, writeFile as writeFile8, mkdir as mkdir10, readFile as readFile7 } from "fs/promises";
+import { readdir as readdir3, stat as stat2, writeFile as writeFile6, mkdir as mkdir10, readFile as readFile7 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import { join as join14 } from "path";
 import { homedir as homedir12 } from "os";
@@ -7159,7 +7318,7 @@ var CodexManager = class extends CodingAgentManager {
         delete config.developer_instructions;
       }
       const tomlContent = stringifyToml(config);
-      await writeFile8(CODEX_CONFIG_PATH, tomlContent, "utf-8");
+      await writeFile6(CODEX_CONFIG_PATH, tomlContent, "utf-8");
       console.log("[CodexManager] Updated config.toml with developer_instructions");
     } catch (error) {
       console.error("[CodexManager] Failed to update config.toml:", error);
@@ -8070,6 +8229,7 @@ var CLAUDE_HISTORY_DIR = join15(ENGINE_DIR2, "claude-histories");
 var RELAY_HISTORY_DIR = join15(ENGINE_DIR2, "relay-histories");
 var CHAT_SENDERS_DIR = join15(ENGINE_DIR2, "chat-senders");
 var CODEX_AUTH_PATH2 = join15(homedir13(), ".codex", "auth.json");
+var CHATS_BACKUP_FILE = `${CHATS_FILE}.bak`;
 function isChatMessageSender(value) {
   if (!isRecord4(value)) return false;
   return typeof value.senderUserId === "string" && typeof value.senderEmail === "string" && typeof value.recordedAt === "string";
@@ -8124,6 +8284,16 @@ function normalizePersistedChat(chat) {
     ...chat.provider === "codex" ? { codexBackend: codexBackendForChat(chat) } : {}
   };
 }
+function parsePersistedChatsContent(content) {
+  const parsed = JSON.parse(content);
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  return parsed.filter((entry) => isPersistedChat(entry)).map((entry) => normalizePersistedChat(entry));
+}
+function corruptChatsFilePath() {
+  return `${CHATS_FILE}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+}
 function createUserMessageEvent(message, messageId) {
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8615,23 +8785,44 @@ var ChatService = class {
   async loadChats() {
     try {
       const content = await readFile8(CHATS_FILE, "utf-8");
-      const parsed = JSON.parse(content);
-      if (!Array.isArray(parsed)) {
-        return [];
-      }
-      return parsed.filter((entry) => isPersistedChat(entry)).map((entry) => normalizePersistedChat(entry));
+      return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
         return [];
       }
-      throw error;
+      const quarantinePath = corruptChatsFilePath();
+      console.error(`[ChatService] Failed to load ${CHATS_FILE}; quarantining and trying backup:`, error);
+      try {
+        await rename2(CHATS_FILE, quarantinePath);
+        console.error(`[ChatService] Quarantined corrupt chats file at ${quarantinePath}`);
+      } catch (renameError) {
+        console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
+      }
+      try {
+        const backupContent = await readFile8(CHATS_BACKUP_FILE, "utf-8");
+        return parsePersistedChatsContent(backupContent);
+      } catch (backupError) {
+        if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
+          return [];
+        }
+        console.error(`[ChatService] Failed to load backup ${CHATS_BACKUP_FILE}; starting with defaults:`, backupError);
+        return [];
+      }
     }
   }
   async persistAllChats() {
     this.writeChain = this.writeChain.catch(() => {
     }).then(async () => {
       const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      await writeFile9(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
+      try {
+        await copyFile(CHATS_FILE, CHATS_BACKUP_FILE);
+      } catch (error) {
+        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+          console.error("[ChatService] Failed to update chats backup:", error);
+        }
+      }
+      await atomicWriteFile(CHATS_FILE, `${JSON.stringify(payload, null, 2)}
+`);
     });
     await this.writeChain;
   }
@@ -9011,14 +9202,14 @@ 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";
 
 // src/services/warm-hook-logs-service.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile10, readdir as readdir5, appendFile as appendFile6, unlink as unlink3 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile7, readdir as readdir5, appendFile as appendFile6, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir15 } from "os";
 import { join as join18 } from "path";
 var LOGS_DIR2 = join18(homedir15(), ".replicas", "warm-hook-logs");
@@ -9052,7 +9243,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile10(join18(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join18(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -9062,7 +9253,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile10(join18(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join18(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -9072,7 +9263,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile10(join18(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join18(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -9200,7 +9391,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"]
@@ -9855,6 +10046,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.230",
+  "version": "0.1.232",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",