replicas-engine 0.1.236 → 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-v7";
+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;
@@ -3282,15 +3329,15 @@ function withPreview(stored) {
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
-function optionalString(value) {
+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 = optionalString(raw.repoName);
-  const hookName = optionalString(raw.hookName) ?? repoNameField ?? "";
+  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 {
@@ -3301,7 +3348,7 @@ function normalizeStored(raw) {
     output: raw.output,
     exitCode: raw.exitCode,
     timedOut: typeof raw.timedOut === "boolean" ? raw.timedOut : false,
-    executedAt: optionalString(raw.executedAt) ?? ""
+    executedAt: optionalString2(raw.executedAt) ?? ""
   };
 }
 var StartHookLogsService = class {
@@ -5144,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;
@@ -5165,7 +5219,6 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   }
   async interruptActiveTurn() {
     this.pendingInterrupt = true;
-    this.activePromptStream?.close();
     if (this.activeQuery) {
       await this.activeQuery.interrupt();
     }
@@ -5347,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() {
@@ -5775,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";

package/package.json

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