replicas-engine 0.1.235 → 0.1.237

package/dist/src/index.js

@@ -1779,11 +1779,11 @@ function parseReplicasConfigString(content, filename) {
 // ../shared/src/claude-auth.ts
 function isClaudeAuthErrorText(text) {
   const lower = text.toLowerCase();
-  return lower.includes("failed to authenticate") || lower.includes("authentication_error") || lower.includes("authentication_failed") || lower.includes("authentication failed") || lower.includes("invalid authentication credentials") || lower.includes("not logged in") || lower.includes("please run /login") || lower.includes("401") && lower.includes("authentic");
+  return lower.includes("failed to authenticate") || lower.includes("authentication_error") || lower.includes("authentication_failed") || lower.includes("authentication failed") || lower.includes("invalid authentication credentials") || lower.includes("not logged in") || lower.includes("please run /login") || lower.includes("credit balance is too low") || lower.includes("401") && lower.includes("authentic");
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v6";
+var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v8";
 var DESKTOP_NOVNC_PORT = 6080;
 
 // ../shared/src/engine/types.ts
@@ -1905,6 +1905,53 @@ var AUDIT_LOG_ACTION = {
 };
 var AUDIT_LOG_ACTIONS = Object.values(AUDIT_LOG_ACTION);
 
+// ../shared/src/display-message/types.ts
+var BACKGROUND_TASK_SUBTYPES = /* @__PURE__ */ new Set([
+  "task_started",
+  "task_progress",
+  "task_updated",
+  "task_notification"
+]);
+function isBackgroundTaskSubtype(subtype) {
+  return typeof subtype === "string" && BACKGROUND_TASK_SUBTYPES.has(subtype);
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function coerceBackgroundTaskPayload(payload) {
+  if (!isRecord(payload)) return null;
+  const subtype = payload.subtype;
+  if (!isBackgroundTaskSubtype(subtype)) return null;
+  const taskId = payload.task_id;
+  if (typeof taskId !== "string" || !taskId) return null;
+  const patch = isRecord(payload.patch) ? {
+    status: optionalString(payload.patch.status),
+    description: optionalString(payload.patch.description),
+    error: optionalString(payload.patch.error)
+  } : void 0;
+  return {
+    subtype,
+    taskId,
+    description: optionalString(payload.description),
+    summary: optionalString(payload.summary),
+    outputFile: optionalString(payload.output_file),
+    status: optionalString(payload.status),
+    patch
+  };
+}
+function normalizeBackgroundTaskStatus(status) {
+  if (status === "completed" || status === "failed" || status === "stopped") {
+    return status;
+  }
+  if (status === "killed") {
+    return "stopped";
+  }
+  return "in_progress";
+}
+function isTerminalBackgroundTaskStatus(status) {
+  return normalizeBackgroundTaskStatus(status) !== "in_progress";
+}
+
 // ../shared/src/agent-event-utils.ts
 function getUserMessage(event) {
   return event.type === "event_msg" && event.payload.type === "user_message" && typeof event.payload.message === "string" ? event.payload.message : null;
@@ -3260,33 +3307,67 @@ 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 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");
-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}`;
-}
-function repoFilename(repoName) {
-  return `repo-${sanitizeFilename(repoName)}.json`;
+
+// src/services/hook-log-files.ts
+import { createHash } from "crypto";
+var ENVIRONMENT_HOOK_LOG_FILENAME = "environment.json";
+function repoHookLogFilename(repoName) {
+  const safe = repoName.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = createHash("sha256").update(repoName).digest("hex").slice(0, 8);
+  return `repo-${safe}-${hash}.json`;
 }
+
+// src/services/start-hook-logs-service.ts
+var LOGS_DIR = join8(homedir6(), ".replicas", "start-hook-logs");
 function withPreview(stored) {
   const preview = buildHookOutputPreview(stored.output);
   return { ...stored, ...preview };
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function optionalString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeStored(raw) {
+  if (!isObject(raw)) return null;
+  if (typeof raw.output !== "string" || typeof raw.exitCode !== "number") return null;
+  const hookType = raw.hookType === "environment" ? "environment" : "repository";
+  const repoNameField = optionalString2(raw.repoName);
+  const hookName = optionalString2(raw.hookName) ?? repoNameField ?? "";
+  const repoName = repoNameField ?? hookName;
+  const hookCommands = Array.isArray(raw.hookCommands) ? raw.hookCommands.filter((c) => typeof c === "string") : [];
+  return {
+    hookType,
+    hookName,
+    repoName,
+    hookCommands,
+    output: raw.output,
+    exitCode: raw.exitCode,
+    timedOut: typeof raw.timedOut === "boolean" ? raw.timedOut : false,
+    executedAt: optionalString2(raw.executedAt) ?? ""
+  };
+}
 var StartHookLogsService = class {
   async ensureDir() {
     await mkdir4(LOGS_DIR, { recursive: true });
   }
-  async saveRepoLog(repoName, entry) {
+  async saveLog(hookType, hookName, entry) {
     await this.ensureDir();
-    const log = { repoName, ...entry };
-    await writeFile3(join8(LOGS_DIR, repoFilename(repoName)), `${JSON.stringify(log, null, 2)}
+    const log = { hookType, hookName, repoName: hookName, ...entry };
+    const filename = hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
+    await writeFile3(join8(LOGS_DIR, filename), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
+  async saveEnvironmentLog(entry) {
+    await this.saveLog("environment", "environment", entry);
+  }
+  async saveRepoLog(repoName, entry) {
+    await this.saveLog("repository", repoName, entry);
+  }
   async getAllLogs() {
     let files;
     try {
@@ -3304,19 +3385,27 @@ var StartHookLogsService = class {
       }
       try {
         const raw = await readFile3(join8(LOGS_DIR, file), "utf-8");
-        const stored = JSON.parse(raw);
-        logs.push(withPreview(stored));
+        const stored = normalizeStored(JSON.parse(raw));
+        if (stored) {
+          logs.push(withPreview(stored));
+        }
       } catch {
       }
     }
-    logs.sort((a, b) => a.repoName.localeCompare(b.repoName));
+    logs.sort((a, b) => {
+      if (a.hookType !== b.hookType) {
+        return a.hookType === "environment" ? -1 : 1;
+      }
+      return a.hookName.localeCompare(b.hookName);
+    });
     return logs;
   }
-  async getFullOutput(repoName) {
+  async getFullOutput(hookType, hookName) {
+    const filename = hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile3(join8(LOGS_DIR, repoFilename(repoName)), "utf-8");
-      const stored = JSON.parse(raw);
-      if (stored.repoName !== repoName) {
+      const raw = await readFile3(join8(LOGS_DIR, filename), "utf-8");
+      const stored = normalizeStored(JSON.parse(raw));
+      if (!stored || stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
       }
       return stored.output;
@@ -3565,6 +3654,13 @@ Repositories: ${hookEntries.length}
           onOutputChunk: (chunk) => onEvent({ type: "output", data: chunk, label: "environment" })
         });
         recordResult(envResult);
+        await startHookLogsService.saveEnvironmentLog({
+          hookCommands: [envHookContent],
+          output: envResult.output.join(""),
+          exitCode: envResult.exitCode,
+          timedOut: envResult.timedOut,
+          executedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
       } else {
         await environmentDetailsService.setEnvironmentStartHook("n/a");
       }
@@ -5095,7 +5191,14 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   sessionId = null;
   activeQuery = null;
   activePromptStream = null;
+  activeSessionSignature = null;
+  activeSessionModel = null;
+  activeSessionPermissionMode = null;
+  sessionLoop = null;
+  sessionLinearForwarder = null;
+  pendingTurn = null;
   pendingInterrupt = false;
+  activeBackgroundTasks = /* @__PURE__ */ new Set();
   systemPromptOverride;
   toolsOverride;
   mcpServersConfig;
@@ -5116,7 +5219,6 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   }
   async interruptActiveTurn() {
     this.pendingInterrupt = true;
-    this.activePromptStream?.close();
     if (this.activeQuery) {
       await this.activeQuery.interrupt();
     }
@@ -5298,117 +5400,271 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       thinkingLevel,
       enableInteractiveTools
     } = request;
-    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
       throw new Error("Message cannot be empty");
     }
     await this.initialized;
-    try {
-      const content = [
-        {
-          type: "text",
-          text: message
+    this.pendingInterrupt = false;
+    const content = [
+      {
+        type: "text",
+        text: message
+      }
+    ];
+    if (images && images.length > 0) {
+      const normalizedImages = await normalizeImages(images);
+      for (const image of normalizedImages) {
+        content.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: image.source.media_type,
+            data: image.source.data
+          }
+        });
+      }
+    }
+    const userMessage = {
+      type: "user",
+      message: {
+        role: "user",
+        content
+      },
+      parent_tool_use_id: null,
+      session_id: this.sessionId ?? ""
+    };
+    if (!options.skipUserMessageRecord) {
+      await this.recordEvent(userMessage);
+    }
+    const combinedInstructions = this.buildCombinedInstructions(customInstructions);
+    const resolvedModel = normalizeClaudeModel(model) || CLAUDE_OPUS_1M_MODEL;
+    const resolvedPermissionMode = permissionMode === "read" ? "plan" : "bypassPermissions";
+    const signature = {
+      combinedInstructions,
+      thinkingLevel,
+      // enableInteractiveTools only matters when permissionMode is 'read'; the
+      // session signature tracks the effective flag so a permissionMode change
+      // can hot-swap via setPermissionMode without restarting.
+      enableInteractiveTools: Boolean(enableInteractiveTools)
+    };
+    await this.ensureSession({
+      signature,
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools: signature.enableInteractiveTools,
+      thinkingLevel
+    });
+    const promptStream = this.activePromptStream;
+    const activeQuery = this.activeQuery;
+    if (!promptStream || !activeQuery) {
+      throw new Error("Claude session unavailable after ensureSession");
+    }
+    if (this.pendingInterrupt) {
+      this.pendingInterrupt = false;
+      return;
+    }
+    await new Promise((resolve3, reject) => {
+      this.pendingTurn = { resolve: resolve3, reject };
+      promptStream.push(userMessage);
+    });
+  }
+  async ensureSession(args) {
+    const {
+      signature,
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools,
+      thinkingLevel
+    } = args;
+    if (this.activeQuery && this.activeSessionSignature && this.sessionSignaturesMatch(this.activeSessionSignature, signature)) {
+      if (this.activeSessionModel !== resolvedModel) {
+        try {
+          await this.activeQuery.setModel(resolvedModel);
+          this.activeSessionModel = resolvedModel;
+        } catch (err) {
+          console.warn("[ClaudeManager] setModel failed; recreating session:", err);
+          await this.tearDownSession();
         }
-      ];
-      if (images && images.length > 0) {
-        const normalizedImages = await normalizeImages(images);
-        for (const image of normalizedImages) {
-          content.push({
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: image.source.media_type,
-              data: image.source.data
-            }
-          });
+      }
+      if (this.activeQuery && this.activeSessionPermissionMode !== resolvedPermissionMode) {
+        try {
+          await this.activeQuery.setPermissionMode(resolvedPermissionMode);
+          this.activeSessionPermissionMode = resolvedPermissionMode;
+        } catch (err) {
+          console.warn("[ClaudeManager] setPermissionMode failed; recreating session:", err);
+          await this.tearDownSession();
         }
       }
-      const userMessage = {
-        type: "user",
-        message: {
-          role: "user",
-          content
-        },
-        parent_tool_use_id: null,
-        session_id: this.sessionId ?? ""
-      };
-      if (!options.skipUserMessageRecord) {
-        await this.recordEvent(userMessage);
+      if (this.activeQuery) return;
+    } else if (this.activeQuery) {
+      await this.tearDownSession();
+    }
+    await this.startSession({
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools,
+      thinkingLevel,
+      signature
+    });
+  }
+  sessionSignaturesMatch(a, b) {
+    return a.combinedInstructions === b.combinedInstructions && a.thinkingLevel === b.thinkingLevel && a.enableInteractiveTools === b.enableInteractiveTools;
+  }
+  async startSession(args) {
+    const {
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools,
+      thinkingLevel,
+      signature
+    } = args;
+    const systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(combinedInstructions) : {
+      type: "preset",
+      preset: "claude_code",
+      append: combinedInstructions
+    };
+    const queryEnv = buildClaudeAgentEnv(this.envOverrides);
+    const additionalDirectories = await getAgentAdditionalDirectories();
+    const interactiveAllowed = enableInteractiveTools && resolvedPermissionMode === "plan";
+    const useDefaultToolPolicy = !this.toolsOverride;
+    const allowedTools = useDefaultToolPolicy ? [
+      ...ALWAYS_ALLOWED_TOOLS,
+      ...interactiveAllowed ? INTERACTIVE_TOOL_NAMES : []
+    ] : void 0;
+    const disallowedTools = [
+      ...this.disallowedToolsOverride ?? [],
+      ...useDefaultToolPolicy ? ALWAYS_DISALLOWED_TOOLS : [],
+      ...interactiveAllowed ? [] : INTERACTIVE_TOOL_NAMES
+    ];
+    const promptStream = new PromptStream();
+    const response = query({
+      prompt: promptStream,
+      options: {
+        resume: this.sessionId || void 0,
+        cwd: this.workingDirectory,
+        additionalDirectories,
+        permissionMode: resolvedPermissionMode,
+        allowDangerouslySkipPermissions: resolvedPermissionMode === "bypassPermissions",
+        ...this.toolsOverride ? { tools: this.toolsOverride } : {},
+        ...allowedTools ? { allowedTools } : {},
+        ...disallowedTools.length > 0 ? { disallowedTools } : {},
+        settingSources: ["user", "project", "local"],
+        systemPrompt,
+        ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
+        env: queryEnv,
+        model: resolvedModel,
+        ...thinkingLevel ? { effort: thinkingLevel } : {},
+        canUseTool: this.buildCanUseTool()
       }
-      const promptStream = new PromptStream();
-      promptStream.push(userMessage);
-      this.activePromptStream = promptStream;
-      const combinedInstructions = this.buildCombinedInstructions(customInstructions);
-      const systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(combinedInstructions) : {
-        type: "preset",
-        preset: "claude_code",
-        append: combinedInstructions
-      };
-      const queryEnv = buildClaudeAgentEnv(this.envOverrides);
-      const additionalDirectories = await getAgentAdditionalDirectories();
-      const resolvedModel = normalizeClaudeModel(model) || CLAUDE_OPUS_1M_MODEL;
-      const interactiveAllowed = enableInteractiveTools && permissionMode === "read";
-      const useDefaultToolPolicy = !this.toolsOverride;
-      const allowedTools = useDefaultToolPolicy ? [
-        ...ALWAYS_ALLOWED_TOOLS,
-        ...interactiveAllowed ? INTERACTIVE_TOOL_NAMES : []
-      ] : void 0;
-      const disallowedTools = [
-        ...this.disallowedToolsOverride ?? [],
-        ...useDefaultToolPolicy ? ALWAYS_DISALLOWED_TOOLS : [],
-        ...interactiveAllowed ? [] : INTERACTIVE_TOOL_NAMES
-      ];
-      const response = query({
-        prompt: promptStream,
-        options: {
-          resume: this.sessionId || void 0,
-          cwd: this.workingDirectory,
-          additionalDirectories,
-          permissionMode: permissionMode === "read" ? "plan" : "bypassPermissions",
-          allowDangerouslySkipPermissions: permissionMode !== "read",
-          ...this.toolsOverride ? { tools: this.toolsOverride } : {},
-          ...allowedTools ? { allowedTools } : {},
-          ...disallowedTools.length > 0 ? { disallowedTools } : {},
-          settingSources: ["user", "project", "local"],
-          systemPrompt,
-          ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
-          env: queryEnv,
-          model: resolvedModel,
-          ...thinkingLevel ? { effort: thinkingLevel } : {},
-          canUseTool: this.buildCanUseTool()
-        }
-      });
-      this.activeQuery = response;
-      if (this.pendingInterrupt) {
-        this.pendingInterrupt = false;
-        this.activePromptStream?.close();
-        await this.activeQuery.interrupt();
-      }
-      const linearForwarder = new LinearEventForwarder(linearSessionId);
-      for await (const msg of response) {
+    });
+    this.activeQuery = response;
+    this.activePromptStream = promptStream;
+    this.activeSessionSignature = signature;
+    this.activeSessionModel = resolvedModel;
+    this.activeSessionPermissionMode = resolvedPermissionMode;
+    this.sessionLinearForwarder = new LinearEventForwarder(ENGINE_ENV.LINEAR_SESSION_ID);
+    this.activeBackgroundTasks.clear();
+    this.sessionLoop = this.runSessionLoop(response).catch((err) => {
+      console.error("[ClaudeManager] Session loop crashed:", err);
+    });
+  }
+  async runSessionLoop(response) {
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    const iterator = response[Symbol.asyncIterator]();
+    try {
+      while (true) {
+        const next = await iterator.next();
+        if (next.done) break;
+        const msg = next.value;
         const authErrorMessage = _ClaudeManager.detectAuthErrorInMessage(msg);
         if (authErrorMessage) {
-          this.activePromptStream?.close();
-          throw new ClaudeAuthError(authErrorMessage);
+          this.failPendingTurn(new ClaudeAuthError(authErrorMessage));
+          try {
+            response.close();
+          } catch (err) {
+            console.warn("[ClaudeManager] query.close() during auth error failed:", err);
+          }
+          return;
         }
         this.setAuthRetrying(false);
         await this.handleMessage(msg);
-        if (linearSessionId) {
-          linearForwarder.sendPlan(extractPlanFromClaudeEvent(msg));
-          linearForwarder.sendEvent(convertClaudeEvent(msg, linearSessionId));
+        _ClaudeManager.updateBackgroundTaskState(msg, this.activeBackgroundTasks);
+        if (linearSessionId && this.sessionLinearForwarder) {
+          this.sessionLinearForwarder.sendPlan(extractPlanFromClaudeEvent(msg));
+          this.sessionLinearForwarder.sendEvent(convertClaudeEvent(msg, linearSessionId));
         }
         if (msg.type === "result") {
           await this.recordContextUsage(response);
-          this.activePromptStream?.close();
-          break;
+          this.sessionLinearForwarder?.flushThoughtAsResponse();
+          this.resolvePendingTurn();
         }
       }
-      linearForwarder.flushThoughtAsResponse();
     } finally {
-      this.activeQuery = null;
-      this.activePromptStream?.close();
-      this.activePromptStream = null;
-      this.pendingInterrupt = false;
+      this.sessionLinearForwarder?.flushThoughtAsResponse();
+      this.failPendingTurn(new Error("Claude session ended unexpectedly"));
+      if (this.activeQuery === response) {
+        this.clearSessionState();
+      }
+    }
+  }
+  clearSessionState() {
+    this.activeQuery = null;
+    this.activePromptStream = null;
+    this.activeSessionSignature = null;
+    this.activeSessionModel = null;
+    this.activeSessionPermissionMode = null;
+    this.sessionLinearForwarder = null;
+    this.sessionLoop = null;
+    this.activeBackgroundTasks.clear();
+  }
+  resolvePendingTurn() {
+    const pending = this.pendingTurn;
+    if (!pending) return;
+    this.pendingTurn = null;
+    this.pendingInterrupt = false;
+    pending.resolve();
+  }
+  failPendingTurn(err) {
+    const pending = this.pendingTurn;
+    if (!pending) return;
+    this.pendingTurn = null;
+    this.pendingInterrupt = false;
+    pending.reject(err);
+  }
+  async tearDownSession() {
+    const query2 = this.activeQuery;
+    const stream = this.activePromptStream;
+    const loop = this.sessionLoop;
+    this.failPendingTurn(new Error("Claude session torn down"));
+    this.clearSessionState();
+    if (query2) {
+      try {
+        query2.close();
+      } catch (err) {
+        console.warn("[ClaudeManager] query.close() failed:", err);
+      }
+    }
+    stream?.close();
+    if (loop) {
+      try {
+        await loop;
+      } catch {
+      }
+    }
+  }
+  static updateBackgroundTaskState(message, activeTasks) {
+    if (message.type !== "system") return;
+    const payload = coerceBackgroundTaskPayload(message);
+    if (!payload) return;
+    const status = payload.subtype === "task_updated" ? payload.patch?.status : payload.status;
+    if (isTerminalBackgroundTaskStatus(status)) {
+      activeTasks.delete(payload.taskId);
+    } else {
+      activeTasks.add(payload.taskId);
     }
   }
   getContextUsageProvider() {
@@ -5726,7 +5982,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.213";
+var ENGINE_PACKAGE_VERSION = "0.1.237";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -9224,26 +9480,12 @@ 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 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");
 var CURRENT_RUN_LOG = join18(LOGS_DIR2, "current-run.log");
-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}`;
-}
-function globalFilename() {
-  return "global.json";
-}
-function environmentFilename() {
-  return "environment.json";
-}
-function repoFilename2(repoName) {
-  return `repo-${sanitizeFilename2(repoName)}.json`;
-}
+var GLOBAL_FILENAME = "global.json";
 function withPreview2(stored) {
   const preview = buildHookOutputPreview(stored.output);
   return { ...stored, ...preview };
@@ -9259,7 +9501,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile7(join18(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join18(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -9269,7 +9511,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile7(join18(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join18(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -9279,7 +9521,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile7(join18(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join18(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -9334,7 +9576,7 @@ var WarmHookLogsService = class {
     }
   }
   async getFullOutput(hookType, hookName) {
-    const filename = hookType === "global" ? globalFilename() : hookType === "environment" ? environmentFilename() : repoFilename2(hookName);
+    const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
       const raw = await readFile11(join18(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
@@ -10172,10 +10414,14 @@ function createV1Routes(deps) {
       );
     }
   });
-  app2.get("/start-hooks/logs/:repoName/full", async (c) => {
+  app2.get("/start-hooks/logs/:hookType/:hookName/full", async (c) => {
     try {
-      const repoName = c.req.param("repoName");
-      const output = await startHookLogsService.getFullOutput(repoName);
+      const hookType = c.req.param("hookType");
+      const hookName = c.req.param("hookName");
+      if (hookType !== "environment" && hookType !== "repository") {
+        return c.json(jsonError("Invalid hookType", 'Must be "environment" or "repository"'), 400);
+      }
+      const output = await startHookLogsService.getFullOutput(hookType, hookName);
       if (output === null) {
         return c.json(jsonError("Start hook log not found"), 404);
       }

package/package.json

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