@slock-ai/daemon 0.52.1 → 0.52.2

package/dist/{chunk-WGO5H7XX.js → chunk-HSBOURQE.js}

@@ -823,6 +823,7 @@ function buildPrompt(config, variant, opts) {
     "- Always communicate through `slock` CLI commands. This is your only output channel.",
     ...opts.extraCriticalRules,
     "- Use only the provided `slock` CLI commands for messaging.",
+    "- Do not combine multiple `slock` CLI commands in one shell command. Run one `slock` command per tool call, read its output, then decide the next command.",
     "- Always claim a task via `slock task claim` before starting work on it. If the claim fails, move on to a different task."
   ] : [
     `- Always communicate through ${sendCmd}. This is your only output channel.`,
@@ -1810,6 +1811,18 @@ function consumeVisibleResponse(registration, targetUrl, sendTarget, responseTex
     });
     return;
   }
+  if (targetUrl.pathname === "/internal/agent-api/send" && parsed.state === "sent") {
+    const messageSeq2 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
+    if (sendTarget && messageSeq2 && messageSeq2 > 0) {
+      coordinator.consumeVisibleMessages({
+        target: sendTarget,
+        messages: normalizeVisibleMessages([{ seq: messageSeq2, id: parsed.messageId }], sendTarget),
+        boundarySeq: messageSeq2,
+        source: "agent_api_send_commit"
+      });
+    }
+    return;
+  }
   if (targetUrl.pathname === "/internal/agent-api/events" && Array.isArray(parsed.events)) {
     const messages = normalizeVisibleMessages(parsed.events);
     coordinator.consumeVisibleMessages({ messages, source: "agent_api_events" });
@@ -3786,7 +3799,7 @@ function detectKimiModels(home = os4.homedir()) {
 
 // src/drivers/opencode.ts
 import { spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
 import os5 from "os";
 import path10 from "path";
 var CHAT_MCP_SERVER_NAME = "chat";
@@ -4039,6 +4052,102 @@ function runOpenCodeModelsCommand(home, deps = {}) {
     error: result.error
   };
 }
+function isWindowsCommandShim(commandPath) {
+  const ext = path10.win32.extname(commandPath).toLowerCase();
+  return ext === ".cmd" || ext === ".bat";
+}
+function opencodePackageEntryCandidates(packageRoot) {
+  const winPath = path10.win32;
+  return [
+    winPath.join(packageRoot, "bin", "opencode.exe"),
+    winPath.join(packageRoot, "bin", "opencode.js"),
+    winPath.join(packageRoot, "bin", "opencode.mjs"),
+    winPath.join(packageRoot, "dist", "index.js")
+  ];
+}
+function openCodeSpecForEntry(entry, commandArgs) {
+  if (path10.win32.extname(entry).toLowerCase() === ".exe") {
+    return { command: entry, args: commandArgs, shell: false };
+  }
+  return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
+}
+function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
+  const existsSyncFn = deps.existsSyncFn ?? existsSync8;
+  const execFileSyncFn = deps.execFileSyncFn;
+  const env = deps.env ?? process.env;
+  const winPath = path10.win32;
+  const candidates = [];
+  if (execFileSyncFn) {
+    try {
+      const globalRoot = String(execFileSyncFn("npm", ["root", "-g"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env
+      })).trim();
+      if (globalRoot) {
+        candidates.push(...opencodePackageEntryCandidates(winPath.join(globalRoot, "opencode-ai")));
+      }
+    } catch {
+    }
+  }
+  if (commandPath) {
+    const commandDir = winPath.dirname(commandPath);
+    candidates.push(...opencodePackageEntryCandidates(winPath.join(commandDir, "node_modules", "opencode-ai")));
+    candidates.push(...extractWindowsShimTargets(commandPath, deps));
+  }
+  for (const candidate of candidates) {
+    if (existsSyncFn(candidate)) return candidate;
+  }
+  return null;
+}
+function extractWindowsShimTargets(commandPath, deps = {}) {
+  if (!isWindowsCommandShim(commandPath)) return [];
+  const readFileSyncFn = deps.readFileSyncFn ?? readFileSync4;
+  const commandDir = path10.win32.dirname(commandPath);
+  let raw;
+  try {
+    raw = String(readFileSyncFn(commandPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  const dp0Pattern = /%~dp0\\?([^"\r\n]*?opencode\.(?:exe|js|mjs|cjs))/gi;
+  for (const match of raw.matchAll(dp0Pattern)) {
+    const relative = match[1]?.replace(/^\\+/, "");
+    if (relative) candidates.push(path10.win32.normalize(path10.win32.join(commandDir, relative)));
+  }
+  return candidates;
+}
+function resolveOpenCodeSpawn(commandArgs, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
+    return {
+      command: resolveCommandOnPath("opencode", deps) ?? "opencode",
+      args: commandArgs,
+      shell: false
+    };
+  }
+  const command = resolveCommandOnPath("opencode", deps);
+  if (command && path10.win32.extname(command).toLowerCase() === ".exe") {
+    return { command, args: commandArgs, shell: false };
+  }
+  const packageEntry = resolveWindowsOpenCodePackageEntry(command, deps);
+  if (packageEntry) return openCodeSpecForEntry(packageEntry, commandArgs);
+  if (command && !isWindowsCommandShim(command)) {
+    return { command, args: commandArgs, shell: false };
+  }
+  throw new Error(
+    "Cannot resolve OpenCode CLI entry point on Windows without cmd.exe. Install the native OpenCode executable or install opencode-ai globally so Slock can launch node_modules/opencode-ai/bin/opencode.exe directly."
+  );
+}
+function readOpenCodeVersion(deps = {}) {
+  try {
+    const launch = resolveOpenCodeSpawn([], deps);
+    return readCommandVersion(launch.command, launch.args, deps);
+  } catch {
+    return null;
+  }
+}
 function isSystemFirstMessageTask(message) {
   return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX);
 }
@@ -4081,7 +4190,7 @@ var OpenCodeDriver = class {
           model: modelId
         }
       };
-      const version = readCommandVersion("opencode");
+      const version = readOpenCodeVersion();
       const launch = buildOpenCodeLaunchOptions(launchCtx, opts?.home, version);
       return {
         args: launch.args,
@@ -4102,8 +4211,13 @@ var OpenCodeDriver = class {
   sessionId = null;
   sessionAnnounced = false;
   probe() {
-    if (!resolveCommandOnPath("opencode")) return { available: false };
-    const version = readCommandVersion("opencode") || void 0;
+    let version;
+    try {
+      const launch = resolveOpenCodeSpawn([]);
+      version = readCommandVersion(launch.command, launch.args);
+    } catch {
+      return { available: false };
+    }
     const unsupportedMessage = unsupportedOpenCodeVersionMessage(version);
     if (unsupportedMessage) {
       return {
@@ -4111,7 +4225,7 @@ var OpenCodeDriver = class {
         version: `${version} (requires >= ${MIN_SUPPORTED_OPENCODE_VERSION})`
       };
     }
-    return { available: true, version };
+    return { available: true, version: version ?? void 0 };
   }
   async detectModels() {
     return detectOpenCodeModels();
@@ -4119,17 +4233,18 @@ var OpenCodeDriver = class {
   spawn(ctx) {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
-    const version = readCommandVersion("opencode");
+    const version = readOpenCodeVersion();
     const unsupportedMessage = unsupportedOpenCodeVersionMessage(version);
     if (unsupportedMessage) {
       throw new Error(unsupportedMessage);
     }
     const launch = buildOpenCodeLaunchOptions(ctx, os5.homedir(), version);
-    const proc = spawn7("opencode", launch.args, {
+    const spawnSpec = resolveOpenCodeSpawn(launch.args);
+    const proc = spawn7(spawnSpec.command, spawnSpec.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: launch.env,
-      shell: process.platform === "win32"
+      shell: spawnSpec.shell
     });
     proc.stdin?.end();
     return { process: proc };
@@ -4367,6 +4482,7 @@ function classifyRuntimeError(message, httpStatus) {
     return "ProviderApiError";
   }
   if (/\btimeout|timed out\b/i.test(message)) return "TimeoutError";
+  if (/stream closed before response\.completed|error decoding response body/i.test(message)) return "ProviderStreamError";
   if (/\brate.?limit|too many requests\b/i.test(message)) return "RateLimitError";
   if (/\bnot found\b/i.test(message)) return "NotFoundError";
   return "RuntimeError";
@@ -5241,12 +5357,21 @@ function classifyTerminalFailure(ap) {
   ].filter((value) => !!value);
   for (const text of candidates) {
     const lower = text.toLowerCase();
-    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found")) {
+    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found") || isProviderStreamFailureText(text)) {
       return text;
     }
   }
   return null;
 }
+function isProviderStreamFailureText(text) {
+  return /stream closed before response\.completed|error decoding response body/i.test(text);
+}
+function isCodexProviderReconnectLog(text) {
+  return /Reconnecting\.\.\.\s*\d+\s*\/\s*\d+/i.test(text);
+}
+function isCodexBenignTransportLog(text) {
+  return /Falling back from WebSockets/i.test(text);
+}
 function hasDirectStdinRecoveryEvidence(ap) {
   const candidates = [
     ap.lastRuntimeError,
@@ -6098,8 +6223,24 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       proc.stderr?.on("data", (chunk) => {
         const text = chunk.toString().trim();
         if (!text) return;
-        if (/Reconnecting\.\.\.|Falling back from WebSockets/i.test(text)) return;
         const current = this.agents.get(agentId);
+        if (driver.id === "codex" && isCodexProviderReconnectLog(text)) {
+          if (current) {
+            current.recentStderr = pushRecentStderr(current.recentStderr, text);
+          }
+          this.recordDaemonTrace("daemon.agent.provider_reconnect", {
+            agentId,
+            launchId: current?.launchId || void 0,
+            runtime: config.runtime,
+            model: config.model
+          });
+          this.broadcastActivity(agentId, "working", "Codex reconnecting to provider\u2026", [
+            { kind: "text", text }
+          ]);
+          logger.info(`[Agent ${agentId} stderr]: ${text}`);
+          return;
+        }
+        if (driver.id === "codex" && isCodexBenignTransportLog(text)) return;
         if (current) {
           current.recentStderr = pushRecentStderr(current.recentStderr, text);
         }
@@ -6243,10 +6384,20 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             }
             this.broadcastActivity(agentId, "online", "Process idle");
           } else {
-            this.idleAgentConfigs.delete(agentId);
             const reason = formatCrashReason(finalCode, finalSignal, ap);
-            logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
-            this.sendAgentStatus(agentId, "inactive", ap.launchId);
+            if (terminalFailureDetail && isProviderStreamFailureText(terminalFailureDetail)) {
+              this.idleAgentConfigs.set(agentId, {
+                config: { ...ap.config, sessionId: ap.sessionId },
+                sessionId: ap.sessionId,
+                launchId: ap.launchId
+              });
+              logger.warn(`[Agent ${agentId}] Recoverable provider stream failure (${reason}) \u2014 keeping agent wakeable`);
+              this.sendAgentStatus(agentId, "active", ap.launchId);
+            } else {
+              this.idleAgentConfigs.delete(agentId);
+              logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
+              this.sendAgentStatus(agentId, "inactive", ap.launchId);
+            }
             if (terminalFailureDetail) {
               this.broadcastActivity(
                 agentId,

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-WGO5H7XX.js";
+} from "./chunk-HSBOURQE.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-KNMCE6WB.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-WGO5H7XX.js";
+} from "./chunk-HSBOURQE.js";
 import "./chunk-KNMCE6WB.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.52.1",
+  "version": "0.52.2",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"