replicas-engine 0.1.61 → 0.1.62

package/dist/src/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { execSync } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 
@@ -854,9 +853,9 @@ var EngineLogger = class {
 var engineLogger = new EngineLogger();
 
 // src/services/replicas-config-service.ts
-import { readFile as readFile3, appendFile as appendFile2, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { readFile as readFile4, appendFile as appendFile2, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir5 } from "os";
 import { exec } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -1203,9 +1202,57 @@ var EnvironmentDetailsService = class {
 };
 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 { join as join6 } from "path";
+var LOGS_DIR = join6(SANDBOX_PATHS.REPLICAS_DIR, "start-hook-logs");
+function sanitizeFilename(name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+  return `${safe}-${hash}`;
+}
+var StartHookLogsService = class {
+  async ensureDir() {
+    await mkdir4(LOGS_DIR, { recursive: true });
+  }
+  async saveRepoLog(repoName, entry) {
+    await this.ensureDir();
+    const log = { repoName, ...entry };
+    const filename = `repo-${sanitizeFilename(repoName)}.json`;
+    await writeFile4(join6(LOGS_DIR, filename), `${JSON.stringify(log, null, 2)}
+`, "utf-8");
+  }
+  async getAllLogs() {
+    let files;
+    try {
+      files = await readdir2(LOGS_DIR);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const logs = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      try {
+        const raw = await readFile3(join6(LOGS_DIR, file), "utf-8");
+        logs.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    logs.sort((a, b) => a.repoName.localeCompare(b.repoName));
+    return logs;
+  }
+};
+var startHookLogsService = new StartHookLogsService();
+
 // src/services/replicas-config-service.ts
 var execAsync = promisify2(exec);
-var START_HOOKS_LOG = join6(homedir5(), ".replicas", "startHooks.log");
+var START_HOOKS_LOG = join7(homedir5(), ".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.
 These hooks are currently executing in the background. You can:
@@ -1216,11 +1263,11 @@ The start hooks may install dependencies, build projects, or perform other setup
 If your task depends on setup being complete, check the log file before proceeding.`;
 async function readReplicasConfigFromDir(dirPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join6(dirPath, filename);
+    const configPath = join7(dirPath, filename);
     if (!existsSync4(configPath)) {
       continue;
     }
-    const data = await readFile3(configPath, "utf-8");
+    const data = await readFile4(configPath, "utf-8");
     const config = parseReplicasConfigString(data, filename);
     return { config, filename };
   }
@@ -1280,7 +1327,7 @@ var ReplicasConfigService = class {
     const logLine = `[${timestamp}] ${message}
 `;
     try {
-      await mkdir4(join6(homedir5(), ".replicas"), { recursive: true });
+      await mkdir5(join7(homedir5(), ".replicas"), { recursive: true });
       await appendFile2(START_HOOKS_LOG, logLine, "utf-8");
     } catch (error) {
       console.error("Failed to write to start hooks log:", error);
@@ -1304,8 +1351,8 @@ var ReplicasConfigService = class {
     this.hooksRunning = true;
     this.hooksCompleted = false;
     try {
-      await mkdir4(join6(homedir5(), ".replicas"), { recursive: true });
-      await writeFile4(
+      await mkdir5(join7(homedir5(), ".replicas"), { recursive: true });
+      await writeFile5(
         START_HOOKS_LOG,
         `=== Start Hooks Execution Log ===
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
@@ -1334,6 +1381,9 @@ Repositories: ${hookEntries.length}
         }
         const timeout = startHookConfig.timeout ?? 3e5;
         let repoFailed = false;
+        let lastExitCode = 0;
+        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 {
@@ -1344,20 +1394,35 @@ Repositories: ${hookEntries.length}
               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 errorMessage = error instanceof Error ? error.message : "Unknown error";
+            const execError = error;
+            lastExitCode = execError.code ?? 1;
+            if (execError.killed) {
+              repoTimedOut = true;
+            }
             this.hooksFailed = true;
             repoFailed = true;
+            repoOutput.push(`[ERROR] ${hook} failed: ${errorMessage}`);
             await this.logToFile(`[${entry.repoName}] [ERROR] ${hook} failed: ${errorMessage}`);
             await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
           }
         }
+        await startHookLogsService.saveRepoLog(entry.repoName, {
+          hookCommands: startHookConfig.commands,
+          output: repoOutput.join("\n"),
+          exitCode: lastExitCode,
+          timedOut: repoTimedOut,
+          executedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
         const fallbackRepoState = persistedRepoState ?? {
           name: entry.repoName,
           path: entry.workingDirectory,
@@ -1426,17 +1491,17 @@ Repositories: ${hookEntries.length}
 var replicasConfigService = new ReplicasConfigService();
 
 // src/services/event-service.ts
-import { appendFile as appendFile3, mkdir as mkdir5 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { randomUUID } from "crypto";
-var ENGINE_DIR = join7(homedir6(), ".replicas", "engine");
-var EVENTS_FILE = join7(ENGINE_DIR, "events.jsonl");
+var ENGINE_DIR = join8(homedir6(), ".replicas", "engine");
+var EVENTS_FILE = join8(ENGINE_DIR, "events.jsonl");
 var EventService = class {
   subscribers = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir5(ENGINE_DIR, { recursive: true });
+    await mkdir6(ENGINE_DIR, { recursive: true });
   }
   subscribe(subscriber) {
     const id = randomUUID();
@@ -1466,7 +1531,7 @@ var EventService = class {
 var eventService = new EventService();
 
 // src/services/preview-service.ts
-import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { dirname } from "path";
@@ -1476,7 +1541,7 @@ async function readPreviewsFile() {
     if (!existsSync5(PREVIEW_PORTS_FILE)) {
       return { previews: [] };
     }
-    const raw = await readFile4(PREVIEW_PORTS_FILE, "utf-8");
+    const raw = await readFile5(PREVIEW_PORTS_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { previews: [] };
@@ -1484,8 +1549,8 @@ async function readPreviewsFile() {
 }
 async function writePreviewsFile(data) {
   const dir = dirname(PREVIEW_PORTS_FILE);
-  await mkdir6(dir, { recursive: true });
-  await writeFile5(PREVIEW_PORTS_FILE, `${JSON.stringify(data, null, 2)}
+  await mkdir7(dir, { recursive: true });
+  await writeFile6(PREVIEW_PORTS_FILE, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 var PreviewService = class {
@@ -1521,21 +1586,21 @@ var PreviewService = class {
 var previewService = new PreviewService();
 
 // src/services/chat/chat-service.ts
-import { mkdir as mkdir9, readFile as readFile7, rm, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile8, rm, writeFile as writeFile8 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/managers/claude-manager.ts
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-import { join as join8 } from "path";
-import { mkdir as mkdir7, appendFile as appendFile4 } from "fs/promises";
+import { join as join9 } from "path";
+import { mkdir as mkdir8, appendFile as appendFile4 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 
 // src/utils/jsonl-reader.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 function isJsonlEvent(value) {
   if (!isRecord(value)) {
     return false;
@@ -1557,7 +1622,7 @@ function parseJsonlEvents(lines) {
 }
 async function readJSONL(filePath) {
   try {
-    const content = await readFile5(filePath, "utf-8");
+    const content = await readFile6(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return parseJsonlEvents(lines);
   } catch (error) {
@@ -2294,7 +2359,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   pendingInterrupt = false;
   constructor(options) {
     super(options);
-    this.historyFile = options.historyFilePath ?? join8(homedir7(), ".replicas", "claude", "history.jsonl");
+    this.historyFile = options.historyFilePath ?? join9(homedir7(), ".replicas", "claude", "history.jsonl");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async interruptActiveTurn() {
@@ -2463,8 +2528,8 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     };
   }
   async initialize() {
-    const historyDir = join8(homedir7(), ".replicas", "claude");
-    await mkdir7(historyDir, { recursive: true });
+    const historyDir = join9(homedir7(), ".replicas", "claude");
+    await mkdir8(historyDir, { recursive: true });
     if (this.initialSessionId) {
       this.sessionId = this.initialSessionId;
       console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
@@ -2515,13 +2580,13 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
 import { randomUUID as randomUUID3 } from "crypto";
-import { readdir as readdir2, stat as stat2, writeFile as writeFile6, mkdir as mkdir8, readFile as readFile6 } from "fs/promises";
+import { readdir as readdir3, stat as stat2, writeFile as writeFile7, mkdir as mkdir9, readFile as readFile7 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { homedir as homedir8 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 var DEFAULT_MODEL = "gpt-5.4";
-var CODEX_CONFIG_PATH = join9(homedir8(), ".codex", "config.toml");
+var CODEX_CONFIG_PATH = join10(homedir8(), ".codex", "config.toml");
 function isLinearThoughtEvent2(event) {
   return event.content.type === "thought";
 }
@@ -2543,7 +2608,7 @@ var CodexManager = class extends CodingAgentManager {
   constructor(options) {
     super(options);
     this.codex = new Codex();
-    this.tempImageDir = join9(homedir8(), ".replicas", "codex", "temp-images");
+    this.tempImageDir = join10(homedir8(), ".replicas", "codex", "temp-images");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
@@ -2563,12 +2628,12 @@ var CodexManager = class extends CodingAgentManager {
    */
   async updateCodexConfig(developerInstructions) {
     try {
-      const codexDir = join9(homedir8(), ".codex");
-      await mkdir8(codexDir, { recursive: true });
+      const codexDir = join10(homedir8(), ".codex");
+      await mkdir9(codexDir, { recursive: true });
       let config = {};
       if (existsSync6(CODEX_CONFIG_PATH)) {
         try {
-          const existingContent = await readFile6(CODEX_CONFIG_PATH, "utf-8");
+          const existingContent = await readFile7(CODEX_CONFIG_PATH, "utf-8");
           const parsed = parseToml(existingContent);
           if (isRecord(parsed)) {
             config = parsed;
@@ -2583,7 +2648,7 @@ var CodexManager = class extends CodingAgentManager {
         delete config.developer_instructions;
       }
       const tomlContent = stringifyToml(config);
-      await writeFile6(CODEX_CONFIG_PATH, tomlContent, "utf-8");
+      await writeFile7(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);
@@ -2594,14 +2659,14 @@ var CodexManager = class extends CodingAgentManager {
    * @returns Array of temp file paths
    */
   async saveImagesToTempFiles(images) {
-    await mkdir8(this.tempImageDir, { recursive: true });
+    await mkdir9(this.tempImageDir, { recursive: true });
     const tempPaths = [];
     for (const image of images) {
       const ext = image.source.media_type.split("/")[1] || "png";
       const filename = `img_${randomUUID3()}.${ext}`;
-      const filepath = join9(this.tempImageDir, filename);
+      const filepath = join10(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile6(filepath, buffer);
+      await writeFile7(filepath, buffer);
       tempPaths.push(filepath);
     }
     return tempPaths;
@@ -2731,13 +2796,13 @@ var CodexManager = class extends CodingAgentManager {
   }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join9(homedir8(), ".codex", "sessions");
+    const sessionsDir = join10(homedir8(), ".codex", "sessions");
     try {
       const now = /* @__PURE__ */ new Date();
       const year = now.getFullYear();
       const month = String(now.getMonth() + 1).padStart(2, "0");
       const day = String(now.getDate()).padStart(2, "0");
-      const todayDir = join9(sessionsDir, String(year), month, day);
+      const todayDir = join10(sessionsDir, String(year), month, day);
       const file = await this.findFileInDirectory(todayDir, threadId);
       if (file) return file;
       for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
@@ -2746,7 +2811,7 @@ var CodexManager = class extends CodingAgentManager {
         const searchYear = date.getFullYear();
         const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
         const searchDay = String(date.getDate()).padStart(2, "0");
-        const searchDir = join9(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const searchDir = join10(sessionsDir, String(searchYear), searchMonth, searchDay);
         const file2 = await this.findFileInDirectory(searchDir, threadId);
         if (file2) return file2;
       }
@@ -2757,10 +2822,10 @@ var CodexManager = class extends CodingAgentManager {
   }
   async findFileInDirectory(directory, threadId) {
     try {
-      const files = await readdir2(directory);
+      const files = await readdir3(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join9(directory, file);
+          const fullPath = join10(directory, file);
           const stats = await stat2(fullPath);
           if (stats.isFile()) {
             return fullPath;
@@ -2793,7 +2858,7 @@ var CodexManager = class extends CodingAgentManager {
     const seenLines = /* @__PURE__ */ new Set();
     const seedSeenLines = async () => {
       try {
-        const content = await readFile6(sessionFile, "utf-8");
+        const content = await readFile7(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
         for (const line of lines) {
           seenLines.add(line);
@@ -2805,7 +2870,7 @@ var CodexManager = class extends CodingAgentManager {
     const pump = async () => {
       let emitted = 0;
       try {
-        const content = await readFile6(sessionFile, "utf-8");
+        const content = await readFile7(sessionFile, "utf-8");
         const lines = content.split("\n");
         const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
         for (const line of completeLines) {
@@ -2876,9 +2941,9 @@ var DuplicateDefaultChatError = class extends Error {
 };
 
 // src/services/chat/chat-service.ts
-var ENGINE_DIR2 = join10(homedir9(), ".replicas", "engine");
-var CHATS_FILE = join10(ENGINE_DIR2, "chats.json");
-var CLAUDE_HISTORY_DIR = join10(ENGINE_DIR2, "claude-histories");
+var ENGINE_DIR2 = join11(homedir9(), ".replicas", "engine");
+var CHATS_FILE = join11(ENGINE_DIR2, "chats.json");
+var CLAUDE_HISTORY_DIR = join11(ENGINE_DIR2, "claude-histories");
 function isPersistedChat(value) {
   if (!isRecord(value)) {
     return false;
@@ -2893,8 +2958,8 @@ var ChatService = class {
   chats = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir9(ENGINE_DIR2, { recursive: true });
-    await mkdir9(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir10(ENGINE_DIR2, { recursive: true });
+    await mkdir10(CLAUDE_HISTORY_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -2990,7 +3055,7 @@ var ChatService = class {
     this.chats.delete(chatId);
     await this.persistAllChats();
     if (chat.persisted.provider === "claude") {
-      const historyFilePath = join10(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
+      const historyFilePath = join11(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
       await rm(historyFilePath, { force: true });
     }
     await this.publish({
@@ -3033,7 +3098,7 @@ var ChatService = class {
     };
     const provider = persisted.provider === "claude" ? new ClaudeManager({
       workingDirectory: this.workingDirectory,
-      historyFilePath: join10(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+      historyFilePath: join11(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
       initialSessionId: persisted.providerSessionId,
       onSaveSessionId: saveSession,
       onTurnComplete: onProviderTurnComplete,
@@ -3129,7 +3194,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile7(CHATS_FILE, "utf-8");
+      const content = await readFile8(CHATS_FILE, "utf-8");
       const parsed = JSON.parse(content);
       if (!Array.isArray(parsed)) {
         return [];
@@ -3146,7 +3211,7 @@ var ChatService = class {
     this.writeChain = this.writeChain.catch(() => {
     }).then(async () => {
       const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      await writeFile7(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile8(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
     });
     await this.writeChain;
   }
@@ -3176,12 +3241,12 @@ import { Hono } from "hono";
 import { z } from "zod";
 
 // src/services/plan-service.ts
-import { readdir as readdir3, readFile as readFile8 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile9 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename, join as join11 } from "path";
+import { basename, join as join12 } from "path";
 var PLAN_DIRECTORIES = [
-  join11(homedir10(), ".claude", "plans"),
-  join11(homedir10(), ".replicas", "plans")
+  join12(homedir10(), ".claude", "plans"),
+  join12(homedir10(), ".replicas", "plans")
 ];
 function isMarkdownFile(filename) {
   return filename.toLowerCase().endsWith(".md");
@@ -3194,7 +3259,7 @@ var PlanService = class {
     const planNames = /* @__PURE__ */ new Set();
     for (const directory of PLAN_DIRECTORIES) {
       try {
-        const entries = await readdir3(directory, { withFileTypes: true });
+        const entries = await readdir4(directory, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isFile()) {
             continue;
@@ -3215,9 +3280,9 @@ var PlanService = class {
       return null;
     }
     for (const directory of PLAN_DIRECTORIES) {
-      const filePath = join11(directory, safeFilename);
+      const filePath = join12(directory, safeFilename);
       try {
-        const content = await readFile8(filePath, "utf-8");
+        const content = await readFile9(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -3230,9 +3295,78 @@ var planService = new PlanService();
 // src/services/warm-hooks-service.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
+
+// src/services/warm-hook-logs-service.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9, readdir as readdir5 } from "fs/promises";
+import { join as join13 } from "path";
+var LOGS_DIR2 = join13(SANDBOX_PATHS.REPLICAS_DIR, "warm-hook-logs");
+function sanitizeFilename2(name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = createHash2("sha256").update(name).digest("hex").slice(0, 8);
+  return `${safe}-${hash}`;
+}
+var WarmHookLogsService = class {
+  async ensureDir() {
+    await mkdir11(LOGS_DIR2, { recursive: true });
+  }
+  async saveGlobalHookLog(entry) {
+    await this.ensureDir();
+    const log = {
+      hookType: "global",
+      hookName: "organization",
+      ...entry
+    };
+    await writeFile9(join13(LOGS_DIR2, "global.json"), `${JSON.stringify(log, null, 2)}
+`, "utf-8");
+  }
+  async saveRepoHookLog(repoName, entry) {
+    await this.ensureDir();
+    const log = {
+      hookType: "repository",
+      hookName: repoName,
+      ...entry
+    };
+    const filename = `repo-${sanitizeFilename2(repoName)}.json`;
+    await writeFile9(join13(LOGS_DIR2, filename), `${JSON.stringify(log, null, 2)}
+`, "utf-8");
+  }
+  async getAllLogs() {
+    let files;
+    try {
+      files = await readdir5(LOGS_DIR2);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const logs = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      try {
+        const raw = await readFile10(join13(LOGS_DIR2, file), "utf-8");
+        logs.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    logs.sort((a, b) => {
+      if (a.hookType !== b.hookType) {
+        return a.hookType === "global" ? -1 : 1;
+      }
+      return a.hookName.localeCompare(b.hookName);
+    });
+    return logs;
+  }
+};
+var warmHookLogsService = new WarmHookLogsService();
+
+// src/services/warm-hooks-service.ts
 var execFileAsync2 = promisify3(execFile2);
 async function executeHookScript(params) {
   const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
@@ -3263,12 +3397,12 @@ async function executeHookScript(params) {
 }
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join12(repoPath, filename);
+    const configPath = join14(repoPath, filename);
     if (!existsSync7(configPath)) {
       continue;
     }
     try {
-      const raw = await readFile9(configPath, "utf-8");
+      const raw = await readFile11(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -3314,6 +3448,13 @@ async function runWarmHooks(params) {
     });
     outputBlocks.push(orgResult.output);
     await environmentDetailsService.setGlobalWarmHook(orgResult.exitCode === 0 ? "yes" : "no", orgResult.output);
+    await warmHookLogsService.saveGlobalHookLog({
+      hookScript: orgHook,
+      output: orgResult.output,
+      exitCode: orgResult.exitCode,
+      timedOut: orgResult.timedOut,
+      executedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     if (orgResult.exitCode !== 0) {
       return {
         exitCode: orgResult.exitCode,
@@ -3334,6 +3475,11 @@ async function runWarmHooks(params) {
       }
     }
     for (const repoHook of repoHooks) {
+      const combinedScript = repoHook.commands.join("\n");
+      const repoOutputBlocks = [];
+      let repoFailed = false;
+      let repoTimedOut = false;
+      let repoExitCode = 0;
       for (const command of repoHook.commands) {
         const repoResult = await executeHookScript({
           label: `repo-warm-hook:${repoHook.repoName}`,
@@ -3342,18 +3488,32 @@ async function runWarmHooks(params) {
           timeoutMs: repoHook.timeoutMs
         });
         outputBlocks.push(repoResult.output);
+        repoOutputBlocks.push(repoResult.output);
         await environmentDetailsService.setRepositoryWarmHook(
           repoHook.repoName,
           repoResult.exitCode === 0 ? "yes" : "no"
         );
         if (repoResult.exitCode !== 0) {
-          return {
-            exitCode: repoResult.exitCode,
-            output: outputBlocks.join("\n\n"),
-            timedOut: repoResult.timedOut
-          };
+          repoFailed = true;
+          repoTimedOut = repoResult.timedOut;
+          repoExitCode = repoResult.exitCode;
+          break;
         }
       }
+      await warmHookLogsService.saveRepoHookLog(repoHook.repoName, {
+        hookScript: combinedScript,
+        output: repoOutputBlocks.join("\n\n"),
+        exitCode: repoFailed ? repoExitCode : 0,
+        timedOut: repoTimedOut,
+        executedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (repoFailed) {
+        return {
+          exitCode: repoExitCode,
+          output: outputBlocks.join("\n\n"),
+          timedOut: repoTimedOut
+        };
+      }
     }
   } else {
     const repos = await gitService.listRepositories();
@@ -3651,6 +3811,28 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.get("/warm-hooks/logs", async (c) => {
+    try {
+      const logs = await warmHookLogsService.getAllLogs();
+      return c.json({ logs });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to read warm hook logs", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
+  app2.get("/start-hooks/logs", async (c) => {
+    try {
+      const logs = await startHookLogsService.getAllLogs();
+      return c.json({ logs });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to read start hook logs", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
   app2.post("/workspace-name", async (c) => {
     try {
       const body = setWorkspaceNameSchema.parse(await c.req.json());
@@ -3728,7 +3910,7 @@ app.get("/health", async (c) => {
     return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() }, 503);
   }
   try {
-    const logContent = await readFile10("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile12("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";