@ycodium-ai/agent-dsh 0.2.2126 → 0.2.2143

package/dist/index.js

@@ -23721,6 +23721,7 @@ function createAcpConnection(options) {
       options.readable.off("data", onData);
       options.readable.off("end", onEnd);
       options.readable.off("error", onError);
+      options.writable.off("error", onWritableError);
       try {
         await byteWriter.close();
       } catch {
@@ -23859,8 +23860,17 @@ function createAcpConnection(options) {
       endInboundBatch();
     }
   };
+  const failInbound = (error62) => {
+    if (closedError !== void 0) return;
+    options.onInboundFailure?.(error62);
+    void shutdown(
+      new AcpConnectionClosedError(
+        `ACP inbound handling failed: ${error62 instanceof Error ? error62.message : String(error62)}`
+      )
+    );
+  };
   const enqueueInbound = (work) => {
-    inboundTail = inboundTail.then(work, work);
+    inboundTail = inboundTail.then(work).catch(failInbound);
   };
   const onData = (chunk) => {
     if (closedError !== void 0) {
@@ -23910,9 +23920,15 @@ function createAcpConnection(options) {
       );
     });
   };
+  const onWritableError = (error62) => {
+    void shutdown(
+      error62 instanceof Error ? error62 : new AcpConnectionClosedError("ACP output stream error")
+    );
+  };
   options.readable.on("data", onData);
   options.readable.on("end", onEnd);
   options.readable.on("error", onError);
+  options.writable.once("error", onWritableError);
   const request = (async (method, params) => {
     failIfClosed();
     const id = nextRequestId;
@@ -23921,7 +23937,7 @@ function createAcpConnection(options) {
     pending.set(String(id), { method, resolve: resolve2, reject });
     const message = params === void 0 ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
     try {
-      await writeMessage(message);
+      await Promise.race([writeMessage(message), promise2]);
     } catch (error62) {
       if (pending.delete(String(id))) {
         reject(error62);
@@ -25704,6 +25720,12 @@ function createAcpExecutor(options) {
   const connection = createAcpConnection({
     readable: options.readable,
     writable: options.writable,
+    onInboundFailure: (error62) => {
+      options.log?.warn?.("acp connection closed: an inbound request could not be answered", {
+        threadId: options.threadId,
+        error: error62 instanceof Error ? error62.message : String(error62)
+      });
+    },
     onNotification: (notification) => {
       if (notification.method === "session/update") {
         handleSessionUpdate(notification.params);
@@ -26341,10 +26363,10 @@ function createAcpExecutor(options) {
 }
 
 // ../../packages/ycodium-acp-executor/src/probe.ts
-function withProbeTimeout(promise2, timeoutMs, method) {
+function withProbeTimeout(promise2, timeoutMs, what) {
   return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
-      reject(new Error(`ACP probe request '${method}' timed out after ${timeoutMs}ms`));
+      reject(new Error(`${what} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timer.unref?.();
     promise2.then(
@@ -26369,11 +26391,15 @@ async function openAcpProbeHandshake(input2) {
     const initializeResult = await withProbeTimeout(
       connection.request("initialize", acpInitializePayload(input2.clientInfo)),
       input2.requestTimeoutMs,
-      "initialize"
+      "ACP probe request 'initialize'"
     );
     return {
       initializeResult,
-      request: (method, params) => withProbeTimeout(connection.request(method, params), input2.requestTimeoutMs, method),
+      request: (method, params) => withProbeTimeout(
+        connection.request(method, params),
+        input2.requestTimeoutMs,
+        `ACP probe request '${method}'`
+      ),
       close: () => connection.close()
     };
   } catch (error62) {
@@ -26381,6 +26407,57 @@ async function openAcpProbeHandshake(input2) {
     throw error62;
   }
 }
+var CLI_VERSION_PATTERN = /(?<![\d.])(\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)/;
+function parseCliVersion(output2) {
+  return CLI_VERSION_PATTERN.exec(output2)?.[1] ?? null;
+}
+async function collectCappedText(stream, maxBytes) {
+  const decoder = new TextDecoder();
+  let text = "";
+  let total = 0;
+  for await (const chunk of stream) {
+    total += chunk.byteLength;
+    if (total <= maxBytes) text += decoder.decode(chunk, { stream: true });
+  }
+  return { text: text + decoder.decode(), overflowed: total > maxBytes };
+}
+async function collectProbeProcess(child, input2) {
+  try {
+    await child.closeStdin().catch(() => void 0);
+    const [stdout, stderr, exitCode] = await withProbeTimeout(
+      Promise.all([
+        collectCappedText(child.stdout, input2.maxOutputBytes),
+        collectCappedText(child.stderr, input2.maxOutputBytes),
+        child.exited
+      ]),
+      input2.timeoutMs,
+      input2.what
+    );
+    return { stdout: stdout.overflowed ? void 0 : stdout.text, stderr: stderr.text, exitCode };
+  } finally {
+    await child.kill("SIGTERM").catch(() => void 0);
+  }
+}
+var MAX_VERSION_OUTPUT_BYTES = 64 * 1024;
+async function probeCliVersion(input2) {
+  let child;
+  try {
+    child = await input2.spawn();
+  } catch {
+    return null;
+  }
+  try {
+    const run = await collectProbeProcess(child, {
+      timeoutMs: input2.timeoutMs,
+      maxOutputBytes: MAX_VERSION_OUTPUT_BYTES,
+      what: "--version"
+    });
+    if (run.exitCode !== 0) return null;
+    return parseCliVersion(run.stdout ?? "") ?? parseCliVersion(run.stderr);
+  } catch {
+    return null;
+  }
+}
 
 // src/config.ts
 var DSH_DEFAULT_LAUNCH_ARGS = "--profile acp";
@@ -26482,6 +26559,9 @@ function tokenizeLaunchArgs(value) {
 import * as NodeFS from "node:fs";
 import * as NodeOS2 from "node:os";
 import * as NodePath2 from "node:path";
+import {
+  ExecutorSpawnRefusedError
+} from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
 
 // src/spawnEnv.ts
@@ -26540,6 +26620,10 @@ function resolveHomePath(value) {
   if (trimmed.length === 0) return "";
   return NodePath.resolve(expandHomePath(trimmed));
 }
+function dshContinuationKey(homePath) {
+  const resolved = resolveHomePath(homePath);
+  return `dsh:home:${resolved.length > 0 ? resolved : NodePath.join(NodeOS.homedir(), ".dsh")}`;
+}
 function buildSpawnEnv(recipe, resolvedHomePath, launchEnv = {}, nativeModeId) {
   const homeEnvVar = recipe.homeEnvVar.trim() || DSH_CARD.homeEnvVar;
   const homeInjection = resolvedHomePath.length > 0 && homeEnvVar.length > 0 ? { [homeEnvVar]: resolvedHomePath } : {};
@@ -26635,6 +26719,7 @@ async function probeDshModels(input2) {
       ...Object.keys(env).length > 0 ? { env } : {}
     });
   } catch (error62) {
+    if (error62 instanceof ExecutorSpawnRefusedError) throw error62;
     return { kind: "not-started", detail: failureDetail(error62) };
   }
   let handshake;
@@ -26657,6 +26742,19 @@ async function probeDshModels(input2) {
     await handle.kill("SIGTERM").catch(() => void 0);
   }
 }
+async function probeDshVersion(input2) {
+  const { recipe, host } = input2;
+  const env = buildSpawnEnv(recipe, resolveHomePath(recipe.homePath));
+  return probeCliVersion({
+    spawn: () => host.process.spawn({
+      program: recipe.binaryPath,
+      args: ["--version"],
+      owner: { bindingId: host.bindingId },
+      ...Object.keys(env).length > 0 ? { env } : {}
+    }),
+    timeoutMs: PROBE_REQUEST_TIMEOUT_MS
+  });
+}
 
 // src/dshInstance.ts
 var RESUME_SCHEMA_VERSION = 1;
@@ -26731,11 +26829,14 @@ var createDshInstance = (config2, host) => {
           detail: "DeepSeek Harness program path is not configured"
         };
       }
-      const outcome = await probeDshModels({ recipe, host });
+      const [outcome, version2] = await Promise.all([
+        probeDshModels({ recipe, host }),
+        probeDshVersion({ recipe, host })
+      ]);
       if (outcome.kind !== "answered") {
         return {
           installed: outcome.kind === "failed",
-          version: null,
+          version: version2,
           readiness: "error",
           auth: { status: "unknown" },
           ...outcome.detail === void 0 ? {} : { detail: outcome.detail },
@@ -26745,7 +26846,7 @@ var createDshInstance = (config2, host) => {
       }
       return {
         installed: true,
-        version: null,
+        version: version2,
         readiness: "ready",
         auth: { status: "unknown" },
         ...outcome.models === void 0 ? {} : { models: outcome.models },
@@ -26919,6 +27020,7 @@ var createDshInstance = (config2, host) => {
       return { threadId, turns: booked.turns };
     },
     events,
+    continuationKey: dshContinuationKey(recipe.homePath),
     dispose: async () => {
       if (disposed) return;
       disposed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-dsh",
-  "version": "0.2.2126",
+  "version": "0.2.2143",
   "description": "DeepSeek Harness executor: dsh CLI over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -20,8 +20,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
+    "@ycodium-ai/plugin-api": "0.2.2143",
     "ycodium-acp-executor": "0.0.0",
-    "@ycodium-ai/plugin-api": "0.2.2126",
     "ycodium-acp-protocol": "0.0.0"
   },
   "ycodium": {