@ycodium-ai/agent-kimi 0.2.3210 → 0.2.3212

package/dist/index.js

@@ -91,8 +91,8 @@ var KIMI_CARD = {
 };
 
 // src/kimiInstance.ts
-import * as NodeOS4 from "node:os";
-import * as NodePath6 from "node:path";
+import * as NodeOS5 from "node:os";
+import * as NodePath7 from "node:path";
 import { mergeLaunchEnv, modelSelectionStringOption } from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
 
@@ -26943,6 +26943,92 @@ function readOpenToolCalls(toolCalls, turnId) {
   return running;
 }
 
+// ../../packages/ycodium-acp-executor/src/protocol-log.ts
+import * as NodeFS from "node:fs";
+import * as NodeOS from "node:os";
+import * as NodePath2 from "node:path";
+var DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
+var UNSAFE_FILE_CHARS = /[^A-Za-z0-9._-]+/gu;
+function safeFileName(value) {
+  return value.replaceAll(UNSAFE_FILE_CHARS, "_");
+}
+function createAcpProtocolLogFile(input2) {
+  const maxBytes = input2.maxBytes ?? DEFAULT_MAX_BYTES;
+  NodeFS.mkdirSync(input2.directory, { recursive: true });
+  const filePath = NodePath2.join(
+    input2.directory,
+    `${safeFileName(input2.provider)}-${safeFileName(input2.threadId)}-${Date.now().toString(36)}.ndjson`
+  );
+  const stream = (input2.openStream ?? ((path) => NodeFS.createWriteStream(path, { flags: "a" })))(
+    filePath
+  );
+  let bytes = 0;
+  let stopped = false;
+  const closed = Promise.withResolvers();
+  let closing = false;
+  stream.once("close", () => closed.resolve());
+  stream.on("error", () => {
+    stopped = true;
+    stream.destroy();
+  });
+  const writeTruncated = () => {
+    stopped = true;
+    const marker = `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), stage: "truncated" })}
+`;
+    if (bytes + Buffer.byteLength(marker) <= maxBytes) stream.write(marker);
+    stream.end();
+  };
+  const writeLine = (value) => {
+    if (stopped) return;
+    const line = `${JSON.stringify(value)}
+`;
+    const lineBytes = Buffer.byteLength(line);
+    if (bytes + lineBytes > maxBytes) {
+      writeTruncated();
+      return;
+    }
+    bytes += lineBytes;
+    stream.write(line);
+  };
+  return {
+    path: filePath,
+    write: (event) => writeLine({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      direction: event.direction,
+      stage: event.stage,
+      payload: event.payload
+    }),
+    close: async () => {
+      if (closing) return closed.promise;
+      closing = true;
+      stopped = true;
+      stream.end();
+      await closed.promise;
+    }
+  };
+}
+function createAcpProtocolLogFromEnv(input2) {
+  const flag = process.env.YCODIUM_ACP_PROTOCOL_LOG;
+  if (flag !== "1" && flag?.toLowerCase() !== "true") return void 0;
+  const configured = process.env.YCODIUM_ACP_PROTOCOL_LOG_DIR?.trim();
+  const directory = configured && configured.length > 0 ? configured : NodePath2.join(NodeOS.tmpdir(), "ycodium-acp-protocol");
+  try {
+    const sink = createAcpProtocolLogFile({
+      directory,
+      provider: input2.provider,
+      threadId: input2.threadId
+    });
+    input2.log?.info("acp protocol frames are being recorded", { path: sink.path });
+    return sink;
+  } catch (error62) {
+    input2.log?.warn?.("acp protocol frame log could not be opened", {
+      directory,
+      error: error62 instanceof Error ? error62.message : String(error62)
+    });
+    return void 0;
+  }
+}
+
 // ../../packages/ycodium-acp-executor/src/executor.ts
 var DEFAULT_CANCEL_GRACE_MS = 5e3;
 function defaultNowIso() {
@@ -27051,9 +27137,16 @@ function createAcpExecutor(options) {
   });
   const { rememberSettledPromptKey, abortPendingSettlement, settleFromNotification } = createExecutorSettlement({ hooks, shared });
   const promptResults = createPromptResults({ options, shared });
+  const protocolLogSink = options.protocolLog === void 0 ? createAcpProtocolLogFromEnv({
+    provider: options.provider,
+    threadId: options.threadId,
+    ...options.log === void 0 ? {} : { log: options.log }
+  }) : void 0;
+  const protocolLog = options.protocolLog ?? protocolLogSink?.write;
   const connection = createAcpConnection({
     readable: options.readable,
     writable: options.writable,
+    ...protocolLog === void 0 ? {} : { logger: protocolLog },
     onInboundFailure: (error62) => {
       options.log?.warn?.("acp connection closed: an inbound request could not be answered", {
         threadId: options.threadId,
@@ -27150,7 +27243,11 @@ function createAcpExecutor(options) {
     notifyPromptSettled,
     shared
   });
-  const { cancel, compact, dispose } = createExecutorLifecycle({
+  const {
+    cancel,
+    compact,
+    dispose: disposeLifecycle
+  } = createExecutorLifecycle({
     promptResults,
     failIfDisposed,
     requireStarted,
@@ -27177,6 +27274,7 @@ function createAcpExecutor(options) {
     onInputDead,
     shared
   });
+  let disposeOnce;
   return {
     get generation() {
       return shared.generation;
@@ -27199,7 +27297,16 @@ function createAcpExecutor(options) {
     setNativeMode,
     compact,
     openToolCalls: () => readOpenToolCalls(toolCalls, shared.activeTurnId),
-    dispose
+    dispose: () => {
+      disposeOnce ??= (async () => {
+        try {
+          await disposeLifecycle();
+        } finally {
+          await protocolLogSink?.close();
+        }
+      })();
+      return disposeOnce;
+    }
   };
 }
 
@@ -27523,8 +27630,8 @@ function tokenizeLaunchArgs(value) {
 }
 
 // src/kimi.ts
-import * as NodeFS from "node:fs";
-import * as NodePath2 from "node:path";
+import * as NodeFS2 from "node:fs";
+import * as NodePath3 from "node:path";
 var KIMI_USER_INPUT_TITLES = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
 var KIMI_PLAN_ACTIONS = {
   plan_approve: "approve",
@@ -27606,40 +27713,40 @@ function parseKimiContextWindow(contents) {
 function readTail(filePath) {
   let handle;
   try {
-    const size = NodeFS.statSync(filePath).size;
+    const size = NodeFS2.statSync(filePath).size;
     if (!Number.isFinite(size) || size <= 0) return void 0;
     const length = size > TAIL_SCAN_BYTES ? TAIL_SCAN_BYTES : size;
     const buffer = Buffer.alloc(length);
-    handle = NodeFS.openSync(filePath, "r");
-    NodeFS.readSync(handle, buffer, 0, length, size - length);
+    handle = NodeFS2.openSync(filePath, "r");
+    NodeFS2.readSync(handle, buffer, 0, length, size - length);
     return buffer.toString("utf8");
   } catch {
     return void 0;
   } finally {
     if (handle !== void 0) {
       try {
-        NodeFS.closeSync(handle);
+        NodeFS2.closeSync(handle);
       } catch {
       }
     }
   }
 }
 function findKimiSessionWireLog(input2) {
-  const sessionsRoot = NodePath2.join(input2.homePath, SESSIONS_DIR);
+  const sessionsRoot = NodePath3.join(input2.homePath, SESSIONS_DIR);
   let workspaces;
   try {
-    workspaces = NodeFS.readdirSync(sessionsRoot);
+    workspaces = NodeFS2.readdirSync(sessionsRoot);
   } catch {
     return void 0;
   }
   for (const workspace of workspaces) {
-    const candidate = NodePath2.join(
+    const candidate = NodePath3.join(
       sessionsRoot,
       workspace,
       input2.acpSessionId,
       ...WIRE_LOG_SEGMENTS
     );
-    if (NodeFS.existsSync(candidate)) return candidate;
+    if (NodeFS2.existsSync(candidate)) return candidate;
   }
   return void 0;
 }
@@ -27652,26 +27759,26 @@ function readKimiContextWindow(input2) {
 }
 
 // src/kimiQuota.ts
-import * as NodeFS3 from "node:fs";
-import * as NodeOS2 from "node:os";
-import * as NodePath4 from "node:path";
+import * as NodeFS4 from "node:fs";
+import * as NodeOS3 from "node:os";
+import * as NodePath5 from "node:path";
 import {
   parseRetryAfterMs
 } from "@ycodium-ai/plugin-api/usage";
 
 // src/kimiAccount.ts
-import * as NodeFS2 from "node:fs";
-import * as NodeOS from "node:os";
-import * as NodePath3 from "node:path";
+import * as NodeFS3 from "node:fs";
+import * as NodeOS2 from "node:os";
+import * as NodePath4 from "node:path";
 function kimiCredentialsPath(resolvedHomePath) {
-  const home = resolvedHomePath.trim().length > 0 ? resolvedHomePath : NodePath3.join(NodeOS.homedir(), ".kimi-code");
-  return NodePath3.join(home, "credentials", "kimi-code.json");
+  const home = resolvedHomePath.trim().length > 0 ? resolvedHomePath : NodePath4.join(NodeOS2.homedir(), ".kimi-code");
+  return NodePath4.join(home, "credentials", "kimi-code.json");
 }
 var nonEmptyString = (value) => typeof value === "string" && value.length > 0;
 function readKimiAuthState(resolvedHomePath) {
   let raw;
   try {
-    raw = NodeFS2.readFileSync(kimiCredentialsPath(resolvedHomePath), "utf8");
+    raw = NodeFS3.readFileSync(kimiCredentialsPath(resolvedHomePath), "utf8");
   } catch (error62) {
     return error62.code === "ENOENT" ? "signed-out" : "unreadable";
   }
@@ -27836,12 +27943,12 @@ var kimiEffectiveHome = (resolvedHomePath, processEnvHome) => {
 var createKimiUsage = (input2) => {
   const now = input2.now ?? Date.now;
   const processEnv = input2.processEnv ?? process.env;
-  const home = input2.homePath.trim().length > 0 ? input2.homePath : NodePath4.join(NodeOS2.homedir(), ".kimi-code");
+  const home = input2.homePath.trim().length > 0 ? input2.homePath : NodePath5.join(NodeOS3.homedir(), ".kimi-code");
   const credentialsPath = kimiCredentialsPath(input2.homePath);
   const readQuota = async (request) => {
     let configToml = null;
     try {
-      configToml = NodeFS3.readFileSync(NodePath4.join(home, "config.toml"), "utf8");
+      configToml = NodeFS4.readFileSync(NodePath5.join(home, "config.toml"), "utf8");
     } catch (error62) {
       if (error62.code !== "ENOENT") {
         return { status: "unavailable", reason: "unreachable" };
@@ -27854,7 +27961,7 @@ var createKimiUsage = (input2) => {
     if ("custom" in endpoint) return { status: "unavailable", reason: "customEndpoint" };
     let token = null;
     try {
-      token = extractKimiToken(parseJson(NodeFS3.readFileSync(credentialsPath, "utf8")), now());
+      token = extractKimiToken(parseJson(NodeFS4.readFileSync(credentialsPath, "utf8")), now());
     } catch {
       token = null;
     }
@@ -27903,9 +28010,9 @@ var createKimiUsage = (input2) => {
 };
 
 // src/kimiTokens.ts
-import * as NodeFS4 from "node:fs";
-import * as NodeOS3 from "node:os";
-import * as NodePath5 from "node:path";
+import * as NodeFS5 from "node:fs";
+import * as NodeOS4 from "node:os";
+import * as NodePath6 from "node:path";
 var MTIME_SLACK_MS = 36 * 60 * 60 * 1e3;
 var GUARD_LENGTH = 64;
 var isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -27942,7 +28049,7 @@ var parseKimiUsageLine = (line) => {
 var hasTokens = (totals) => totals.uncachedInputTokens > 0 || totals.cachedInputTokens > 0 || totals.cacheCreationTokens > 0 || totals.outputTokens > 0;
 var readDirs = (dir) => {
   try {
-    return NodeFS4.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return NodeFS5.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -27950,10 +28057,10 @@ var readDirs = (dir) => {
 var listWireLogs = (sessionsRoot) => {
   const found = [];
   for (const workspace of readDirs(sessionsRoot)) {
-    for (const session of readDirs(NodePath5.join(sessionsRoot, workspace))) {
-      const agentsDir = NodePath5.join(sessionsRoot, workspace, session, "agents");
+    for (const session of readDirs(NodePath6.join(sessionsRoot, workspace))) {
+      const agentsDir = NodePath6.join(sessionsRoot, workspace, session, "agents");
       for (const agent of readDirs(agentsDir)) {
-        found.push({ file: NodePath5.join(agentsDir, agent, "wire.jsonl"), sessionId: session });
+        found.push({ file: NodePath6.join(agentsDir, agent, "wire.jsonl"), sessionId: session });
       }
     }
   }
@@ -27962,23 +28069,23 @@ var listWireLogs = (sessionsRoot) => {
 var readRange = (file2, from, to) => {
   const length = Math.max(0, to - from);
   const buffer = Buffer.alloc(length);
-  const fd = NodeFS4.openSync(file2, "r");
+  const fd = NodeFS5.openSync(file2, "r");
   try {
     let read = 0;
     while (read < length) {
-      const n = NodeFS4.readSync(fd, buffer, read, length - read, from + read);
+      const n = NodeFS5.readSync(fd, buffer, read, length - read, from + read);
       if (n === 0) break;
       read += n;
     }
     return read === length ? buffer : buffer.subarray(0, read);
   } finally {
-    NodeFS4.closeSync(fd);
+    NodeFS5.closeSync(fd);
   }
 };
 var guardOf = (file2, size) => readRange(file2, 0, Math.min(size, GUARD_LENGTH)).toString("base64");
 var createKimiTokenReader = (input2) => {
-  const home = input2.homePath.trim().length > 0 ? NodePath5.resolve(input2.homePath) : NodePath5.join(NodeOS3.homedir(), ".kimi-code");
-  const sessionsRoot = NodePath5.join(home, "sessions");
+  const home = input2.homePath.trim().length > 0 ? NodePath6.resolve(input2.homePath) : NodePath6.join(NodeOS4.homedir(), ".kimi-code");
+  const sessionsRoot = NodePath6.join(home, "sessions");
   const memos = /* @__PURE__ */ new Map();
   const refresh = (file2, size) => {
     const guard = guardOf(file2, size);
@@ -28003,7 +28110,7 @@ var createKimiTokenReader = (input2) => {
   const readTokenUsage = async (request) => {
     const sinceMs = Date.parse(request.since);
     const untilMs = Date.parse(request.until);
-    if (!NodeFS4.existsSync(sessionsRoot)) {
+    if (!NodeFS5.existsSync(sessionsRoot)) {
       return {
         records: [],
         source: {
@@ -28024,7 +28131,7 @@ var createKimiTokenReader = (input2) => {
     for (const { file: file2, sessionId } of listWireLogs(sessionsRoot)) {
       let size;
       try {
-        const stat = NodeFS4.statSync(file2);
+        const stat = NodeFS5.statSync(file2);
         if (stat.mtimeMs < sinceMs - MTIME_SLACK_MS) {
           skippedFiles += 1;
           continue;
@@ -28304,9 +28411,9 @@ var EventBus = class {
   }
 };
 function expandHomePath(value) {
-  if (value === "~") return NodeOS4.homedir();
+  if (value === "~") return NodeOS5.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return NodePath6.join(NodeOS4.homedir(), value.slice(2));
+    return NodePath7.join(NodeOS5.homedir(), value.slice(2));
   }
   return value;
 }
@@ -28331,7 +28438,7 @@ function nowIso() {
 }
 function kimiContinuationKey(recipe) {
   const homePath = recipe.homePath.trim();
-  const resolvedHomePath = homePath.length > 0 ? NodePath6.resolve(expandHomePath(homePath)) : "";
+  const resolvedHomePath = homePath.length > 0 ? NodePath7.resolve(expandHomePath(homePath)) : "";
   return `kimiCode:home:${recipe.binaryPath.trim()}\0${resolvedHomePath}`;
 }
 function resolveHomePath(recipe) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-kimi",
-  "version": "0.2.3210",
+  "version": "0.2.3212",
   "description": "Kimi Code executor: runs `kimi acp` over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "ycodium-acp-executor": "0.2.3210",
-    "@ycodium-ai/plugin-api": "0.2.3210",
+    "ycodium-acp-executor": "0.2.3212",
+    "@ycodium-ai/plugin-api": "0.2.0",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {