replicas-engine 0.1.173 → 0.1.174

package/dist/src/index.js

@@ -5,7 +5,7 @@ import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
 import { readFile as readFile14 } from "fs/promises";
 import { execSync as execSync2 } from "child_process";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/managers/github-token-manager.ts
 import { promises as fs } from "fs";
@@ -375,7 +375,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "14-05-2026-royal-york-v18";
+var DAYTONA_SNAPSHOT_ID = "15-05-2026-royal-york-v19";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -2077,12 +2077,13 @@ import { existsSync as existsSync7 } from "fs";
 import { appendFile as appendFile5, mkdir as mkdir10, readFile as readFile8, rm, writeFile as writeFile8 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { join as join12 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/managers/claude-manager.ts
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
+import { randomUUID as randomUUID3 } from "crypto";
 import { join as join10 } from "path";
 import { mkdir as mkdir8, appendFile as appendFile4 } from "fs/promises";
 import { homedir as homedir7 } from "os";
@@ -2940,6 +2941,82 @@ var PromptStream = class {
 function isLinearThoughtEvent(event) {
   return event.content.type === "thought";
 }
+var INTERACTIVE_TOOL_NAMES = ["AskUserQuestion", "ExitPlanMode"];
+var TOOL_INPUT_HANDLERS = {
+  ExitPlanMode: {
+    getRequest: () => ({
+      options: [
+        { id: "approve", label: "Start implementing", variant: "primary" },
+        { id: "deny", label: "Keep planning", variant: "secondary" }
+      ]
+    }),
+    resolve: (selectionId, input) => {
+      if (selectionId === "approve") {
+        return { result: { behavior: "allow", updatedInput: input }, summary: "Start implementing" };
+      }
+      return { result: { behavior: "deny", message: "User declined to exit plan mode." }, summary: "Keep planning" };
+    }
+  },
+  AskUserQuestion: {
+    getRequest: (input) => {
+      const questions = Array.isArray(input.questions) ? input.questions : [];
+      return {
+        questions: questions.map((q, qi) => ({
+          id: String(qi),
+          prompt: q.question,
+          multiSelect: Boolean(q.multiSelect),
+          options: (q.options ?? []).map((opt, oi) => ({
+            id: String(oi),
+            label: opt.label,
+            description: opt.description,
+            preview: opt.preview
+          }))
+        }))
+      };
+    },
+    resolve: (selectionId, input) => {
+      if (selectionId === "declined") {
+        return {
+          result: { behavior: "deny", message: "User declined to answer questions." },
+          summary: "Declined to answer"
+        };
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(selectionId);
+      } catch {
+        return {
+          result: { behavior: "deny", message: "Invalid selection payload." }
+        };
+      }
+      const questions = Array.isArray(input.questions) ? input.questions : [];
+      const answers = {};
+      const summaryParts = [];
+      for (let qi = 0; qi < questions.length; qi++) {
+        const q = questions[qi];
+        const entry = parsed[String(qi)];
+        if (!entry) continue;
+        let answer = null;
+        if (typeof entry.custom === "string" && entry.custom.trim()) {
+          answer = entry.custom.trim();
+        } else if (Array.isArray(entry.options) && entry.options.length > 0) {
+          const labels = entry.options.map((idx) => q.options[Number(idx)]?.label).filter((l) => Boolean(l));
+          if (labels.length > 0) {
+            answer = labels.join(", ");
+          }
+        }
+        if (answer) {
+          answers[q.question] = answer;
+          summaryParts.push(`${q.question}: ${answer}`);
+        }
+      }
+      return {
+        result: { behavior: "allow", updatedInput: { ...input, answers } },
+        summary: summaryParts.join(" \u2022 ")
+      };
+    }
+  }
+};
 var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   historyFile;
   sessionId = null;
@@ -2951,6 +3028,8 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   mcpServersConfig;
   envOverrides;
   disallowedToolsOverride;
+  /** Active tool-input requests keyed by requestId; resolved when the user selects an option. */
+  pendingToolInputs = /* @__PURE__ */ new Map();
   constructor(options) {
     super(options);
     this.historyFile = options.historyFilePath ?? join10(homedir7(), ".replicas", "claude", "history.jsonl");
@@ -2967,6 +3046,96 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     if (this.activeQuery) {
       await this.activeQuery.interrupt();
     }
+    await this.abortAllPendingToolInputs();
+  }
+  async abortAllPendingToolInputs() {
+    const pending = Array.from(this.pendingToolInputs.values());
+    this.pendingToolInputs.clear();
+    for (const entry of pending) {
+      entry.resolve({ behavior: "deny", message: "Turn interrupted" });
+      await this.emitToolInputEvent("replicas-tool-input-resolved", {
+        requestId: entry.requestId,
+        toolUseId: entry.toolUseId,
+        toolName: entry.toolName,
+        selectionId: "aborted"
+      });
+    }
+  }
+  async respondToToolInput(requestId, selectionId) {
+    const pending = this.pendingToolInputs.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    this.pendingToolInputs.delete(requestId);
+    const resolution = pending.handler.resolve(selectionId, pending.input);
+    pending.resolve(resolution.result);
+    await this.emitToolInputEvent("replicas-tool-input-resolved", {
+      requestId,
+      toolUseId: pending.toolUseId,
+      toolName: pending.toolName,
+      selectionId,
+      ...resolution.summary ? { selectionSummary: resolution.summary } : {}
+    });
+    return true;
+  }
+  async emitToolInputEvent(type, payload) {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      payload: { ...payload, parent_tool_use_id: null }
+    };
+    await appendFile4(this.historyFile, JSON.stringify(event) + "\n", "utf-8");
+    this.onEvent(event);
+  }
+  buildCanUseTool() {
+    return async (toolName, input, options) => {
+      const handler = TOOL_INPUT_HANDLERS[toolName];
+      if (!handler) {
+        return { behavior: "allow" };
+      }
+      const requestId = randomUUID3();
+      const toolUseId = options.toolUseID;
+      const { options: requestOptions, questions: requestQuestions } = handler.getRequest(input);
+      const result = await new Promise((resolve3) => {
+        this.pendingToolInputs.set(requestId, {
+          requestId,
+          toolUseId,
+          toolName,
+          input,
+          handler,
+          resolve: resolve3
+        });
+        const onAbort = () => {
+          const pending = this.pendingToolInputs.get(requestId);
+          if (!pending) return;
+          this.pendingToolInputs.delete(requestId);
+          pending.resolve({ behavior: "deny", message: "Aborted." });
+          this.emitToolInputEvent("replicas-tool-input-resolved", {
+            requestId: pending.requestId,
+            toolUseId: pending.toolUseId,
+            toolName: pending.toolName,
+            selectionId: "aborted"
+          }).catch((err) => {
+            console.error("[ClaudeManager] Failed to emit resolved event on abort:", err);
+          });
+        };
+        if (options.signal.aborted) {
+          onAbort();
+          return;
+        }
+        options.signal.addEventListener("abort", onAbort, { once: true });
+        this.emitToolInputEvent("replicas-tool-input-request", {
+          requestId,
+          toolUseId,
+          toolName,
+          ...requestOptions ? { options: requestOptions } : {},
+          ...requestQuestions ? { questions: requestQuestions } : {}
+        }).catch((err) => {
+          console.error("[ClaudeManager] Failed to emit tool-input request event:", err);
+        });
+      });
+      return result;
+    };
   }
   /**
    * Internal method that actually processes the message.
@@ -2997,7 +3166,8 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       customInstructions,
       images,
       permissionMode,
-      thinkingLevel
+      thinkingLevel,
+      enableInteractiveTools
     } = request;
     const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
@@ -3045,6 +3215,10 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       };
       const queryEnv = buildClaudeAgentEnv(this.envOverrides);
       const resolvedModel = normalizeClaudeModel(model) || CLAUDE_OPUS_1M_MODEL;
+      const disallowedTools = [
+        ...this.disallowedToolsOverride ?? [],
+        ...enableInteractiveTools ? [] : INTERACTIVE_TOOL_NAMES
+      ];
       const response = query({
         prompt: promptStream,
         options: {
@@ -3053,13 +3227,14 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           permissionMode: permissionMode === "read" ? "plan" : "bypassPermissions",
           allowDangerouslySkipPermissions: permissionMode !== "read",
           ...this.toolsOverride ? { tools: this.toolsOverride } : {},
-          disallowedTools: this.disallowedToolsOverride ?? ["ExitPlanMode", "AskUserQuestion"],
+          ...disallowedTools.length > 0 ? { disallowedTools } : {},
           settingSources: ["user", "project", "local"],
           systemPrompt,
           ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
           env: queryEnv,
           model: resolvedModel,
-          ...thinkingLevel ? { effort: thinkingLevel } : {}
+          ...thinkingLevel ? { effort: thinkingLevel } : {},
+          canUseTool: this.buildCanUseTool()
         }
       });
       this.activeQuery = response;
@@ -3229,7 +3404,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
 
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 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 join11 } from "path";
@@ -3412,7 +3587,7 @@ var CodexManager = class extends CodingAgentManager {
     const tempPaths = [];
     for (const image of images) {
       const ext = image.source.media_type.split("/")[1] || "png";
-      const filename = `img_${randomUUID3()}.${ext}`;
+      const filename = `img_${randomUUID4()}.${ext}`;
       const filepath = join11(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
       await writeFile7(filepath, buffer);
@@ -4387,7 +4562,7 @@ var ChatService = class {
       throw new ChatNotFoundError(parentChatId);
     }
     const persisted = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       provider: request.provider,
       title,
       createdAt: now,
@@ -4509,6 +4684,13 @@ var ChatService = class {
       queue: chat.provider.getQueue()
     };
   }
+  async respondToToolInput(chatId, requestId, selectionId) {
+    const chat = this.requireChat(chatId);
+    if (!chat.provider.respondToToolInput) {
+      return false;
+    }
+    return chat.provider.respondToToolInput(requestId, selectionId);
+  }
   async deleteChat(chatId) {
     const chat = this.requireChat(chatId);
     if (chat.persisted.title === DEFAULT_CHAT_TITLES[chat.persisted.provider]) {
@@ -4733,7 +4915,7 @@ var ChatService = class {
   }
   async publish(input) {
     const event = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       ...input
     };
@@ -5506,10 +5688,15 @@ var sendMessageSchema = z2.object({
     ])
   })).optional(),
   thinkingLevel: z2.enum(["low", "medium", "high", "max"]).optional(),
+  enableInteractiveTools: z2.boolean().optional(),
   senderUserId: z2.string().optional(),
   senderEmail: z2.string().optional(),
   senderDisplayName: z2.string().optional()
 });
+var respondToolInputSchema = z2.object({
+  requestId: z2.string().min(1),
+  selectionId: z2.string().min(1)
+});
 function jsonError(message, details) {
   return { error: message, details };
 }
@@ -5708,6 +5895,22 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to reorder queue", error instanceof Error ? error.message : "Unknown error"), 500);
     }
   });
+  app2.post("/chats/:chatId/tool-input", async (c) => {
+    try {
+      const body = respondToolInputSchema.parse(await c.req.json());
+      const resolved = await deps.chatService.respondToToolInput(
+        c.req.param("chatId"),
+        body.requestId,
+        body.selectionId
+      );
+      return c.json({ resolved });
+    } catch (error) {
+      if (error instanceof ChatNotFoundError) {
+        return c.json(jsonError("Failed to resolve tool input", error.message), 404);
+      }
+      return c.json(jsonError("Failed to resolve tool input", error instanceof Error ? error.message : "Unknown error"), 400);
+    }
+  });
   app2.get("/repos", async (c) => {
     const includeDiffs = c.req.query("includeDiffs") === "true";
     const repos = await gitService.listRepos({ includeDiffs });
@@ -6170,7 +6373,7 @@ function startStatusBroadcaster() {
       if (serialized !== previousRepoStatus) {
         previousRepoStatus = serialized;
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "repo.status.changed",
           payload: { repos }
@@ -6190,7 +6393,7 @@ function startStatusBroadcaster() {
       if (engineStatusJson !== previousEngineStatus) {
         previousEngineStatus = engineStatusJson;
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "engine.status.changed",
           payload: { status: engineStatus }
@@ -6211,7 +6414,7 @@ function startStatusBroadcaster() {
       previousHookStatus = hookSnapshot;
       if (!lastHooksRunning && hooksRunning) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.started",
           payload: { running: true, completed: false }
@@ -6220,7 +6423,7 @@ function startStatusBroadcaster() {
       }
       if (hooksRunning) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.progress",
           payload: { running: true, completed: false }
@@ -6229,7 +6432,7 @@ function startStatusBroadcaster() {
       }
       if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.completed",
           payload: { running: false, completed: true }
@@ -6238,7 +6441,7 @@ function startStatusBroadcaster() {
       }
       if (lastHooksRunning && !hooksRunning && hooksFailed) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.failed",
           payload: { running: false, completed: hooksCompleted }
@@ -6246,7 +6449,7 @@ function startStatusBroadcaster() {
         });
       }
       eventService.publish({
-        id: randomUUID5(),
+        id: randomUUID6(),
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         type: "hooks.status",
         payload: {
@@ -6287,20 +6490,20 @@ serve(
     }
     const repos = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID5(),
+      id: randomUUID6(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.discovered",
       payload: { repos }
     });
     const repoStatuses = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID5(),
+      id: randomUUID6(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.status.changed",
       payload: { repos: repoStatuses }
     });
     await eventService.publish({
-      id: randomUUID5(),
+      id: randomUUID6(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "engine.ready",
       payload: { version: "v1" }

package/package.json

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