replicas-engine 0.1.53 → 0.1.55

package/dist/src/index.js

@@ -4,9 +4,9 @@ import "./chunk-ZXMDA7VB.js";
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { execSync } from "child_process";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/managers/github-token-manager.ts
 import { promises as fs } from "fs";
@@ -846,9 +846,13 @@ var SANDBOX_PATHS = {
   REPLICAS_DIR: "/home/ubuntu/.replicas",
   REPLICAS_FILES_DIR: "/home/ubuntu/.replicas/files",
   REPLICAS_FILES_DISPLAY_DIR: "~/.replicas/files",
-  REPLICAS_RUNTIME_ENV_FILE: "/home/ubuntu/.replicas/runtime-env.sh"
+  REPLICAS_RUNTIME_ENV_FILE: "/home/ubuntu/.replicas/runtime-env.sh",
+  REPLICAS_PREVIEW_PORTS_FILE: "/home/ubuntu/.replicas/preview-ports.json"
 };
 
+// ../shared/src/replicas-config.ts
+import { parse as parseYaml } from "yaml";
+
 // ../shared/src/warm-hooks.ts
 var DEFAULT_WARM_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
 var MAX_WARM_HOOK_TIMEOUT_MS = 15 * 60 * 1e3;
@@ -869,18 +873,18 @@ function truncateWarmHookOutput(text, maxChars = DEFAULT_WARM_HOOK_OUTPUT_MAX_CH
   return `${text.slice(0, maxChars)}
 ...[truncated]`;
 }
-function parseWarmHookConfig(value) {
+function parseWarmHookConfig(value, filename = "replicas.json") {
   if (typeof value === "string") {
     return value;
   }
   if (!isRecord2(value)) {
-    throw new Error('Invalid replicas.json: "warmHook" must be a string or object');
+    throw new Error(`Invalid ${filename}: "warmHook" must be a string or object`);
   }
   if (!Array.isArray(value.commands) || !value.commands.every((entry) => typeof entry === "string")) {
-    throw new Error('Invalid replicas.json: "warmHook.commands" must be an array of shell commands');
+    throw new Error(`Invalid ${filename}: "warmHook.commands" must be an array of shell commands`);
   }
   if (value.timeout !== void 0 && (typeof value.timeout !== "number" || value.timeout <= 0)) {
-    throw new Error('Invalid replicas.json: "warmHook.timeout" must be a positive number');
+    throw new Error(`Invalid ${filename}: "warmHook.timeout" must be a positive number`);
   }
   return {
     commands: value.commands,
@@ -902,6 +906,57 @@ function resolveWarmHookConfig(value) {
   };
 }
 
+// ../shared/src/replicas-config.ts
+var REPLICAS_CONFIG_FILENAMES = ["replicas.json", "replicas.yaml", "replicas.yml"];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseReplicasConfig(value, filename = "replicas.json") {
+  if (!isRecord3(value)) {
+    throw new Error(`Invalid ${filename}: expected an object`);
+  }
+  const config = {};
+  if ("organizationId" in value) {
+    if (typeof value.organizationId !== "string") {
+      throw new Error(`Invalid ${filename}: "organizationId" must be a string`);
+    }
+    config.organizationId = value.organizationId;
+  }
+  if ("systemPrompt" in value) {
+    if (typeof value.systemPrompt !== "string") {
+      throw new Error(`Invalid ${filename}: "systemPrompt" must be a string`);
+    }
+    config.systemPrompt = value.systemPrompt;
+  }
+  if ("startHook" in value) {
+    if (!isRecord3(value.startHook)) {
+      throw new Error(`Invalid ${filename}: "startHook" must be an object with "commands" array`);
+    }
+    const { commands, timeout } = value.startHook;
+    if (!Array.isArray(commands) || !commands.every((entry) => typeof entry === "string")) {
+      throw new Error(`Invalid ${filename}: "startHook.commands" must be an array of shell commands`);
+    }
+    if (timeout !== void 0 && (typeof timeout !== "number" || timeout <= 0)) {
+      throw new Error(`Invalid ${filename}: "startHook.timeout" must be a positive number`);
+    }
+    config.startHook = { commands, timeout };
+  }
+  if ("warmHook" in value) {
+    config.warmHook = parseWarmHookConfig(value.warmHook, filename);
+  }
+  return config;
+}
+function parseReplicasConfigString(content, filename) {
+  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
+  let parsed;
+  if (isYaml) {
+    parsed = parseYaml(content);
+  } else {
+    parsed = JSON.parse(content);
+  }
+  return parseReplicasConfig(parsed, filename);
+}
+
 // ../shared/src/engine/environment.ts
 var REPLICAS_ENGINE_VERSION = "09-03-2026-kipling";
 
@@ -1081,52 +1136,17 @@ These hooks are currently executing in the background. You can:
 
 The start hooks may install dependencies, build projects, or perform other setup tasks.
 If your task depends on setup being complete, check the log file before proceeding.`;
-function parseReplicasConfig(value) {
-  if (!isRecord(value)) {
-    throw new Error("Invalid replicas.json: expected an object");
-  }
-  const config = {};
-  if ("copy" in value) {
-    if (!Array.isArray(value.copy) || !value.copy.every((entry) => typeof entry === "string")) {
-      throw new Error('Invalid replicas.json: "copy" must be an array of file paths');
-    }
-    config.copy = value.copy;
-  }
-  if ("ports" in value) {
-    if (!Array.isArray(value.ports) || !value.ports.every((entry) => typeof entry === "number")) {
-      throw new Error('Invalid replicas.json: "ports" must be an array of port numbers');
-    }
-    config.ports = value.ports;
-  }
-  if ("organizationId" in value) {
-    if (typeof value.organizationId !== "string") {
-      throw new Error('Invalid replicas.json: "organizationId" must be a string');
-    }
-    config.organizationId = value.organizationId;
-  }
-  if ("systemPrompt" in value) {
-    if (typeof value.systemPrompt !== "string") {
-      throw new Error('Invalid replicas.json: "systemPrompt" must be a string');
-    }
-    config.systemPrompt = value.systemPrompt;
-  }
-  if ("startHook" in value) {
-    if (!isRecord(value.startHook)) {
-      throw new Error('Invalid replicas.json: "startHook" must be an object with "commands" array');
-    }
-    const { commands, timeout } = value.startHook;
-    if (!Array.isArray(commands) || !commands.every((entry) => typeof entry === "string")) {
-      throw new Error('Invalid replicas.json: "startHook.commands" must be an array of shell commands');
-    }
-    if (timeout !== void 0 && (typeof timeout !== "number" || timeout <= 0)) {
-      throw new Error('Invalid replicas.json: "startHook.timeout" must be a positive number');
+async function readReplicasConfigFromDir(dirPath) {
+  for (const filename of REPLICAS_CONFIG_FILENAMES) {
+    const configPath = join6(dirPath, filename);
+    if (!existsSync4(configPath)) {
+      continue;
     }
-    config.startHook = { commands, timeout };
+    const data = await readFile3(configPath, "utf-8");
+    const config = parseReplicasConfigString(data, filename);
+    return { config, filename };
   }
-  if ("warmHook" in value) {
-    config.warmHook = parseWarmHookConfig(value.warmHook);
-  }
-  return config;
+  return null;
 }
 var ReplicasConfigService = class {
   configs = [];
@@ -1134,7 +1154,7 @@ var ReplicasConfigService = class {
   hooksCompleted = false;
   hooksFailed = false;
   /**
-   * Initialize by reading all replicas.json files and running start hooks.
+   * Initialize by reading all replicas config files and running start hooks.
    */
   async initialize() {
     await this.loadConfigs();
@@ -1146,30 +1166,29 @@ var ReplicasConfigService = class {
     });
   }
   /**
-   * Load and parse replicas.json from each discovered repository root.
+   * Load and parse replicas config from each discovered repository root.
+   * Checks replicas.json first, then falls back to replicas.yaml/replicas.yml.
    */
   async loadConfigs() {
     const repos = await gitService.listRepositories();
     const configs = [];
     for (const repo of repos) {
-      const configPath = join6(repo.path, "replicas.json");
-      if (!existsSync4(configPath)) {
-        continue;
-      }
       try {
-        const data = await readFile3(configPath, "utf-8");
-        const config = parseReplicasConfig(JSON.parse(data));
+        const result = await readReplicasConfigFromDir(repo.path);
+        if (!result) {
+          continue;
+        }
         configs.push({
           repoName: repo.name,
           workingDirectory: repo.path,
           defaultBranch: repo.defaultBranch,
-          config
+          config: result.config
         });
       } catch (error) {
         if (error instanceof SyntaxError) {
-          console.error(`[ReplicasConfig] Failed to parse ${repo.name}/replicas.json:`, error.message);
+          console.error(`[ReplicasConfig] Failed to parse ${repo.name} config:`, error.message);
         } else if (error instanceof Error) {
-          console.error(`[ReplicasConfig] Error loading ${repo.name}/replicas.json:`, error.message);
+          console.error(`[ReplicasConfig] Error loading ${repo.name} config:`, error.message);
         }
       }
     }
@@ -1368,22 +1387,77 @@ 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 { existsSync as existsSync5 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname } from "path";
+var PREVIEW_PORTS_FILE = SANDBOX_PATHS.REPLICAS_PREVIEW_PORTS_FILE;
+async function readPreviewsFile() {
+  try {
+    if (!existsSync5(PREVIEW_PORTS_FILE)) {
+      return { previews: [] };
+    }
+    const raw = await readFile4(PREVIEW_PORTS_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { previews: [] };
+  }
+}
+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)}
+`, "utf-8");
+}
+var PreviewService = class {
+  async initialize() {
+    await writePreviewsFile({ previews: [] });
+  }
+  async addPreview(port2, publicUrl) {
+    const data = await readPreviewsFile();
+    const existing = data.previews.find((p) => p.port === port2);
+    if (existing) {
+      throw new Error(`Preview already exists for port ${port2}`);
+    }
+    const preview = {
+      port: port2,
+      publicUrl,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    data.previews.push(preview);
+    await writePreviewsFile(data);
+    eventService.publish({
+      id: randomUUID2(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "preview.changed",
+      payload: { previews: data.previews }
+    });
+    return preview;
+  }
+  async listPreviews() {
+    const data = await readPreviewsFile();
+    return data.previews;
+  }
+};
+var previewService = new PreviewService();
+
 // src/services/chat/chat-service.ts
-import { mkdir as mkdir8, readFile as readFile6, rm, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile7, rm, writeFile as writeFile7 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { join as join10 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+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 mkdir6, appendFile as appendFile4 } from "fs/promises";
+import { mkdir as mkdir7, appendFile as appendFile4 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 
 // src/utils/jsonl-reader.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 function isJsonlEvent(value) {
   if (!isRecord(value)) {
     return false;
@@ -1405,7 +1479,7 @@ function parseJsonlEvents(lines) {
 }
 async function readJSONL(filePath) {
   try {
-    const content = await readFile4(filePath, "utf-8");
+    const content = await readFile5(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return parseJsonlEvents(lines);
   } catch (error) {
@@ -2281,7 +2355,7 @@ var ClaudeManager = class extends CodingAgentManager {
   }
   async initialize() {
     const historyDir = join8(homedir7(), ".replicas", "claude");
-    await mkdir6(historyDir, { recursive: true });
+    await mkdir7(historyDir, { recursive: true });
     if (this.initialSessionId) {
       this.sessionId = this.initialSessionId;
       console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
@@ -2309,9 +2383,9 @@ var ClaudeManager = class extends CodingAgentManager {
 
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
-import { randomUUID as randomUUID2 } from "crypto";
-import { readdir as readdir2, stat as stat2, writeFile as writeFile5, mkdir as mkdir7, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+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 { existsSync as existsSync6 } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir8 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
@@ -2359,11 +2433,11 @@ var CodexManager = class extends CodingAgentManager {
   async updateCodexConfig(developerInstructions) {
     try {
       const codexDir = join9(homedir8(), ".codex");
-      await mkdir7(codexDir, { recursive: true });
+      await mkdir8(codexDir, { recursive: true });
       let config = {};
-      if (existsSync5(CODEX_CONFIG_PATH)) {
+      if (existsSync6(CODEX_CONFIG_PATH)) {
         try {
-          const existingContent = await readFile5(CODEX_CONFIG_PATH, "utf-8");
+          const existingContent = await readFile6(CODEX_CONFIG_PATH, "utf-8");
           const parsed = parseToml(existingContent);
           if (isRecord(parsed)) {
             config = parsed;
@@ -2378,7 +2452,7 @@ var CodexManager = class extends CodingAgentManager {
         delete config.developer_instructions;
       }
       const tomlContent = stringifyToml(config);
-      await writeFile5(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);
@@ -2389,14 +2463,14 @@ var CodexManager = class extends CodingAgentManager {
    * @returns Array of temp file paths
    */
   async saveImagesToTempFiles(images) {
-    await mkdir7(this.tempImageDir, { recursive: true });
+    await mkdir8(this.tempImageDir, { recursive: true });
     const tempPaths = [];
     for (const image of images) {
       const ext = image.source.media_type.split("/")[1] || "png";
-      const filename = `img_${randomUUID2()}.${ext}`;
+      const filename = `img_${randomUUID3()}.${ext}`;
       const filepath = join9(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile5(filepath, buffer);
+      await writeFile6(filepath, buffer);
       tempPaths.push(filepath);
     }
     return tempPaths;
@@ -2588,7 +2662,7 @@ var CodexManager = class extends CodingAgentManager {
     const seenLines = /* @__PURE__ */ new Set();
     const seedSeenLines = async () => {
       try {
-        const content = await readFile5(sessionFile, "utf-8");
+        const content = await readFile6(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
         for (const line of lines) {
           seenLines.add(line);
@@ -2600,7 +2674,7 @@ var CodexManager = class extends CodingAgentManager {
     const pump = async () => {
       let emitted = 0;
       try {
-        const content = await readFile5(sessionFile, "utf-8");
+        const content = await readFile6(sessionFile, "utf-8");
         const lines = content.split("\n");
         const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
         for (const line of completeLines) {
@@ -2688,8 +2762,8 @@ var ChatService = class {
   chats = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir8(ENGINE_DIR2, { recursive: true });
-    await mkdir8(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir9(ENGINE_DIR2, { recursive: true });
+    await mkdir9(CLAUDE_HISTORY_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -2710,7 +2784,7 @@ var ChatService = class {
       throw new DuplicateDefaultChatError(request.provider);
     }
     const persisted = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       provider: request.provider,
       title,
       createdAt: now,
@@ -2912,7 +2986,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile6(CHATS_FILE, "utf-8");
+      const content = await readFile7(CHATS_FILE, "utf-8");
       const parsed = JSON.parse(content);
       if (!Array.isArray(parsed)) {
         return [];
@@ -2929,13 +3003,13 @@ var ChatService = class {
     this.writeChain = this.writeChain.catch(() => {
     }).then(async () => {
       const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      await writeFile6(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile7(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
     });
     await this.writeChain;
   }
   async publish(input) {
     const event = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       ...input
     };
@@ -2954,7 +3028,7 @@ import { Hono } from "hono";
 import { z } from "zod";
 
 // src/services/plan-service.ts
-import { readdir as readdir3, readFile as readFile7 } from "fs/promises";
+import { readdir as readdir3, readFile as readFile8 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { basename, join as join11 } from "path";
 var PLAN_DIRECTORIES = [
@@ -2995,7 +3069,7 @@ var PlanService = class {
     for (const directory of PLAN_DIRECTORIES) {
       const filePath = join11(directory, safeFilename);
       try {
-        const content = await readFile7(filePath, "utf-8");
+        const content = await readFile8(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -3008,7 +3082,8 @@ 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 readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
 import { join as join12 } from "path";
 var execFileAsync2 = promisify3(execFile2);
 async function executeHookScript(params) {
@@ -3039,21 +3114,27 @@ async function executeHookScript(params) {
   }
 }
 async function readRepoWarmHook(repoPath) {
-  const configPath = join12(repoPath, "replicas.json");
-  try {
-    const raw = await readFile8(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!isRecord(parsed) || !("warmHook" in parsed)) {
-      return null;
+  for (const filename of REPLICAS_CONFIG_FILENAMES) {
+    const configPath = join12(repoPath, filename);
+    if (!existsSync7(configPath)) {
+      continue;
     }
-    return resolveWarmHookConfig(parsed.warmHook);
-  } catch (error) {
-    const nodeError = error;
-    if (nodeError?.code === "ENOENT") {
-      return null;
+    try {
+      const raw = await readFile9(configPath, "utf-8");
+      const config = parseReplicasConfigString(raw, filename);
+      if (!config.warmHook) {
+        return null;
+      }
+      return resolveWarmHookConfig(config.warmHook);
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError?.code === "ENOENT") {
+        continue;
+      }
+      throw error;
     }
-    throw error;
   }
+  return null;
 }
 async function collectRepoWarmHooks() {
   const repos = await gitService.listRepositories();
@@ -3152,6 +3233,10 @@ var createChatSchema = z.object({
   title: z.string().min(1).optional()
 });
 var imageMediaTypeSchema = z.enum(IMAGE_MEDIA_TYPES);
+var createPreviewSchema = z.object({
+  port: z.number().int().min(1).max(65535),
+  publicUrl: z.string().min(1)
+});
 var sendMessageSchema = z.object({
   message: z.string().min(1),
   model: z.string().optional(),
@@ -3399,7 +3484,6 @@ function createV1Routes(deps) {
     try {
       const body = await c.req.json();
       const result = await runWarmHooks({
-        skills: Array.isArray(body.skills) ? body.skills : [],
         organizationWarmHook: body.organizationWarmHook,
         includeRepoHooks: body.includeRepoHooks,
         timeoutMs: body.timeoutMs
@@ -3416,6 +3500,30 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.get("/previews", async (c) => {
+    try {
+      const previews = await previewService.listPreviews();
+      return c.json({ previews });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to list previews", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
+  app2.post("/previews", async (c) => {
+    try {
+      const body = createPreviewSchema.parse(await c.req.json());
+      const preview = await previewService.addPreview(body.port, body.publicUrl);
+      return c.json({ preview }, 201);
+    } catch (error) {
+      const details = error instanceof Error ? error.message : "Unknown error";
+      if (details.includes("already exists")) {
+        return c.json(jsonError("Preview already exists", details), 409);
+      }
+      return c.json(jsonError("Failed to create preview", details), 400);
+    }
+  });
   return app2;
 }
 
@@ -3456,7 +3564,7 @@ app.get("/health", async (c) => {
     return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() }, 503);
   }
   try {
-    const logContent = await readFile9("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile10("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";
@@ -3511,7 +3619,7 @@ function startStatusBroadcaster() {
       if (serialized !== previousRepoStatus) {
         previousRepoStatus = serialized;
         eventService.publish({
-          id: randomUUID4(),
+          id: randomUUID5(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "repo.status.changed",
           payload: { repos }
@@ -3531,7 +3639,7 @@ function startStatusBroadcaster() {
       if (engineStatusJson !== previousEngineStatus) {
         previousEngineStatus = engineStatusJson;
         eventService.publish({
-          id: randomUUID4(),
+          id: randomUUID5(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "engine.status.changed",
           payload: { status: engineStatus }
@@ -3552,7 +3660,7 @@ function startStatusBroadcaster() {
       previousHookStatus = hookSnapshot;
       if (!lastHooksRunning && hooksRunning) {
         eventService.publish({
-          id: randomUUID4(),
+          id: randomUUID5(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.started",
           payload: { running: true, completed: false }
@@ -3561,7 +3669,7 @@ function startStatusBroadcaster() {
       }
       if (hooksRunning) {
         eventService.publish({
-          id: randomUUID4(),
+          id: randomUUID5(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.progress",
           payload: { running: true, completed: false }
@@ -3570,7 +3678,7 @@ function startStatusBroadcaster() {
       }
       if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
         eventService.publish({
-          id: randomUUID4(),
+          id: randomUUID5(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.completed",
           payload: { running: false, completed: true }
@@ -3579,7 +3687,7 @@ function startStatusBroadcaster() {
       }
       if (lastHooksRunning && !hooksRunning && hooksFailed) {
         eventService.publish({
-          id: randomUUID4(),
+          id: randomUUID5(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.failed",
           payload: { running: false, completed: hooksCompleted }
@@ -3587,7 +3695,7 @@ function startStatusBroadcaster() {
         });
       }
       eventService.publish({
-        id: randomUUID4(),
+        id: randomUUID5(),
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         type: "hooks.status",
         payload: {
@@ -3617,6 +3725,7 @@ serve(
     }
     await replicasConfigService.initialize();
     await chatService.initialize();
+    await previewService.initialize();
     engineReady = true;
     if (!IS_WARMING_MODE) {
       await githubTokenManager.start();
@@ -3625,20 +3734,20 @@ serve(
     }
     const repos = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID4(),
+      id: randomUUID5(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.discovered",
       payload: { repos }
     });
     const repoStatuses = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID4(),
+      id: randomUUID5(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.status.changed",
       payload: { repos: repoStatuses }
     });
     await eventService.publish({
-      id: randomUUID4(),
+      id: randomUUID5(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "engine.ready",
       payload: { version: "v1" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",
@@ -32,6 +32,7 @@
     "@openai/codex-sdk": "^0.111.0",
     "hono": "^4.10.3",
     "smol-toml": "^1.6.0",
+    "yaml": "^2.8.2",
     "zod": "^4.0.0"
   },
   "devDependencies": {