@shareai-lab/kode 2.0.2 → 2.0.3

package/dist/acp-H3VJ77YG.js

@@ -1,1357 +0,0 @@
-#!/usr/bin/env bun
-import { createRequire as __kodeCreateRequire } from "node:module";
-const require = __kodeCreateRequire(import.meta.url);
-import {
-  ensurePackagedRuntimeEnv
-} from "./chunk-WWUWDNWW.js";
-import {
-  getTools
-} from "./chunk-6DRDLOLP.js";
-import {
-  getCommands,
-  getSystemPrompt,
-  grantReadPermissionForOriginalDir,
-  hasPermissionsToUseTool,
-  query
-} from "./chunk-HSPVVDIW.js";
-import "./chunk-NQLEUHMS.js";
-import {
-  getClients
-} from "./chunk-7CQVZNQV.js";
-import "./chunk-4GAIJGRH.js";
-import "./chunk-2PMO2FS2.js";
-import "./chunk-G6I7XROM.js";
-import "./chunk-3TXNP6HH.js";
-import "./chunk-KAA5BGMQ.js";
-import "./chunk-3RUXVV4S.js";
-import "./chunk-K2MI4TPB.js";
-import "./chunk-NPFOMITO.js";
-import "./chunk-54DNHKOD.js";
-import "./chunk-ZQU3TXLC.js";
-import "./chunk-67PY5IX6.js";
-import "./chunk-OWTG2W3A.js";
-import "./chunk-SRZZFAS7.js";
-import {
-  loadToolPermissionContextFromDisk,
-  persistToolPermissionUpdateToDisk
-} from "./chunk-EH34V7CY.js";
-import "./chunk-VBXVYQYY.js";
-import {
-  applyToolPermissionContextUpdates
-} from "./chunk-S6HRABTA.js";
-import "./chunk-IE2CG2TV.js";
-import "./chunk-E6YNABER.js";
-import "./chunk-OZNRLY3E.js";
-import "./chunk-UKHTVRJM.js";
-import "./chunk-S3J2TLV6.js";
-import {
-  createAssistantMessage,
-  createUserMessage
-} from "./chunk-2KWKUXLT.js";
-import "./chunk-Z33T5YN5.js";
-import {
-  getContext
-} from "./chunk-OIFQB3S4.js";
-import "./chunk-SDGKPKDK.js";
-import {
-  enableConfigs
-} from "./chunk-AIMIPK4B.js";
-import "./chunk-UYXEDKOZ.js";
-import {
-  initDebugLogger
-} from "./chunk-QYFKRZQC.js";
-import {
-  PRODUCT_COMMAND,
-  getKodeBaseDir,
-  initSentry,
-  logError,
-  setCwd,
-  setOriginalCwd
-} from "./chunk-MN77D2F7.js";
-import {
-  MACRO
-} from "./chunk-FH5CHM6L.js";
-import "./chunk-EZXMVTDU.js";
-import "./chunk-JC6NCUG5.js";
-
-// src/acp/jsonrpc.ts
-import { format } from "node:util";
-var JsonRpcError = class extends Error {
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-  }
-};
-var JSONRPC_VERSION = "2.0";
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function safeStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return format(value);
-  }
-}
-function makeErrorResponse(id, code, message, data) {
-  return {
-    jsonrpc: JSONRPC_VERSION,
-    id,
-    error: data === void 0 ? { code, message } : { code, message, data }
-  };
-}
-function normalizeId(id) {
-  return typeof id === "string" || typeof id === "number" ? id : null;
-}
-var JsonRpcPeer = class {
-  handlers = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  nextId = 1;
-  sendLine = null;
-  setSend(send) {
-    this.sendLine = send;
-  }
-  registerMethod(method, handler) {
-    this.handlers.set(method, handler);
-  }
-  async handleIncoming(payload) {
-    if (Array.isArray(payload)) {
-      const responses = [];
-      for (const item of payload) {
-        const r = await this.handleIncomingOne(item);
-        if (r) responses.push(r);
-      }
-      if (responses.length > 0) {
-        this.sendRaw(responses);
-      }
-      return;
-    }
-    const response = await this.handleIncomingOne(payload);
-    if (response) this.sendRaw(response);
-  }
-  async handleIncomingOne(payload) {
-    if (!isObject(payload)) {
-      return makeErrorResponse(null, -32600, "Invalid Request");
-    }
-    const jsonrpc = payload.jsonrpc;
-    if (jsonrpc !== JSONRPC_VERSION) {
-      return makeErrorResponse(normalizeId(payload.id), -32600, "Invalid Request");
-    }
-    const hasMethod = typeof payload.method === "string" && payload.method.length > 0;
-    const hasId = typeof payload.id === "string" || typeof payload.id === "number";
-    if (!hasMethod && hasId && ("result" in payload || "error" in payload)) {
-      this.handleResponse(payload);
-      return null;
-    }
-    if (!hasMethod) {
-      return makeErrorResponse(normalizeId(payload.id), -32600, "Invalid Request");
-    }
-    const method = String(payload.method);
-    const params = "params" in payload ? payload.params : void 0;
-    const id = hasId ? payload.id : null;
-    const handler = this.handlers.get(method);
-    if (!handler) {
-      if (id === null) return null;
-      return makeErrorResponse(id, -32601, `Method not found: ${method}`);
-    }
-    if (id === null) {
-      try {
-        await handler(params);
-      } catch {
-      }
-      return null;
-    }
-    try {
-      const result = await handler(params);
-      return { jsonrpc: JSONRPC_VERSION, id, result: result ?? null };
-    } catch (err) {
-      if (err instanceof JsonRpcError) {
-        return makeErrorResponse(id, err.code, err.message, err.data);
-      }
-      const message = err instanceof Error ? err.message : safeStringify(err);
-      return makeErrorResponse(id, -32603, message);
-    }
-  }
-  handleResponse(msg) {
-    const id = normalizeId(msg.id);
-    if (id === null) return;
-    const pending = this.pending.get(id);
-    if (!pending) return;
-    this.pending.delete(id);
-    if (pending.timeoutId) clearTimeout(pending.timeoutId);
-    if (msg && typeof msg === "object" && "error" in msg && msg.error) {
-      const e = msg.error;
-      const code = typeof e.code === "number" ? e.code : -32603;
-      const message = typeof e.message === "string" ? e.message : "Unknown error";
-      pending.reject(new JsonRpcError(code, message, e.data));
-      return;
-    }
-    pending.resolve(msg.result);
-  }
-  sendNotification(method, params) {
-    this.sendRaw({ jsonrpc: JSONRPC_VERSION, method, ...params !== void 0 ? { params } : {} });
-  }
-  sendRequest(args) {
-    const id = this.nextId++;
-    const timeoutMs = args.timeoutMs;
-    const p = new Promise((resolve2, reject) => {
-      const entry = { resolve: resolve2, reject, abort: args.signal };
-      if (timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-        entry.timeoutId = setTimeout(() => {
-          this.pending.delete(id);
-          reject(new JsonRpcError(-32e3, `Request timed out: ${args.method}`));
-        }, timeoutMs);
-      }
-      if (args.signal) {
-        const onAbort = () => {
-          this.pending.delete(id);
-          if (entry.timeoutId) clearTimeout(entry.timeoutId);
-          reject(new JsonRpcError(-32e3, `Request aborted: ${args.method}`));
-        };
-        if (args.signal.aborted) {
-          onAbort();
-          return;
-        }
-        args.signal.addEventListener("abort", onAbort, { once: true });
-      }
-      this.pending.set(id, entry);
-    });
-    this.sendRaw({
-      jsonrpc: JSONRPC_VERSION,
-      id,
-      method: args.method,
-      ...args.params !== void 0 ? { params: args.params } : {}
-    });
-    return p;
-  }
-  sendRaw(obj) {
-    const send = this.sendLine;
-    if (!send) {
-      throw new Error("JsonRpcPeer send() not configured");
-    }
-    const line = JSON.stringify(obj);
-    send(line);
-  }
-};
-
-// src/acp/stdioTransport.ts
-import readline from "node:readline";
-var StdioTransport = class {
-  constructor(peer2, opts) {
-    this.peer = peer2;
-    this.opts = opts;
-  }
-  rl = null;
-  pending = /* @__PURE__ */ new Set();
-  start() {
-    if (this.rl) return;
-    this.peer.setSend(this.opts.writeLine);
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      crlfDelay: Infinity
-    });
-    this.rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      try {
-        const payload = JSON.parse(trimmed);
-        const p = this.peer.handleIncoming(payload).catch(() => {
-        });
-        this.pending.add(p);
-        void p.finally(() => this.pending.delete(p));
-      } catch (err) {
-        this.opts.writeLine(
-          JSON.stringify({
-            jsonrpc: "2.0",
-            id: null,
-            error: { code: -32700, message: "Parse error" }
-          })
-        );
-      }
-    });
-    this.rl.on("close", () => {
-      void (async () => {
-        const pending = Array.from(this.pending);
-        if (pending.length > 0) {
-          await Promise.allSettled(pending);
-        }
-        process.exit(0);
-      })();
-    });
-  }
-  stop() {
-    this.rl?.close();
-    this.rl = null;
-  }
-};
-
-// src/acp/stdoutGuard.ts
-import { format as format2 } from "node:util";
-function writeTo(write, chunk, encoding, cb) {
-  if (typeof encoding === "function") {
-    return write(chunk, void 0, encoding);
-  }
-  return write(chunk, encoding, cb);
-}
-function installStdoutGuard() {
-  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-  const originalStderrWrite = process.stderr.write.bind(process.stderr);
-  const originalConsoleLog = console.log.bind(console);
-  const originalConsoleInfo = console.info.bind(console);
-  const originalConsoleDebug = console.debug.bind(console);
-  const originalConsoleWarn = console.warn.bind(console);
-  const originalConsoleError = console.error.bind(console);
-  const writeAcpLine2 = (line) => {
-    writeTo(originalStdoutWrite, `${line}
-`);
-  };
-  const writeLogToStderr = (...args) => {
-    writeTo(originalStderrWrite, `${format2(...args)}
-`);
-  };
-  console.log = writeLogToStderr;
-  console.info = writeLogToStderr;
-  console.debug = writeLogToStderr;
-  console.warn = writeLogToStderr;
-  console.error = writeLogToStderr;
-  process.stdout.write = ((chunk, encoding, cb) => {
-    return writeTo(originalStderrWrite, chunk, encoding, cb);
-  });
-  const restore = () => {
-    process.stdout.write = originalStdoutWrite;
-    console.log = originalConsoleLog;
-    console.info = originalConsoleInfo;
-    console.debug = originalConsoleDebug;
-    console.warn = originalConsoleWarn;
-    console.error = originalConsoleError;
-  };
-  return { writeAcpLine: writeAcpLine2, restore, originalStdoutWrite };
-}
-
-// src/acp/kodeAcpAgent.ts
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
-import { nanoid } from "nanoid";
-
-// src/acp/protocol.ts
-var ACP_PROTOCOL_VERSION = 1;
-
-// src/acp/kodeAcpAgent.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-function asJsonObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  try {
-    JSON.stringify(value);
-    return value;
-  } catch {
-    return void 0;
-  }
-}
-function toolKindForName(toolName) {
-  switch (toolName) {
-    case "Read":
-      return "read";
-    case "Write":
-    case "Edit":
-    case "MultiEdit":
-    case "NotebookEdit":
-      return "edit";
-    case "Grep":
-    case "Glob":
-      return "search";
-    case "Bash":
-    case "TaskOutput":
-    case "KillShell":
-      return "execute";
-    case "SwitchModel":
-      return "switch_mode";
-    default:
-      return "other";
-  }
-}
-function titleForToolCall(toolName, input) {
-  if (toolName === "Read" && typeof input.file_path === "string") {
-    return `Read ${input.file_path}`;
-  }
-  if ((toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") && typeof input.file_path === "string") {
-    return `${toolName} ${input.file_path}`;
-  }
-  if (toolName === "Bash" && typeof input.command === "string") {
-    const cmd = input.command.trim().replace(/\s+/g, " ");
-    const clipped = cmd.length > 120 ? `${cmd.slice(0, 117)}...` : cmd;
-    return `Run ${clipped}`;
-  }
-  return toolName;
-}
-function blocksToText(blocks) {
-  const parts = [];
-  for (const block of blocks) {
-    if (!block || typeof block !== "object") continue;
-    switch (block.type) {
-      case "text": {
-        const text = typeof block.text === "string" ? block.text : "";
-        if (text) parts.push(text);
-        break;
-      }
-      case "resource": {
-        const resource = block.resource || {};
-        const uri = typeof resource.uri === "string" ? resource.uri : "";
-        const mimeType = typeof resource.mimeType === "string" && resource.mimeType ? resource.mimeType : "text/plain";
-        if (typeof resource.text === "string") {
-          parts.push(
-            [
-              "",
-              `@resource ${uri} (${mimeType})`,
-              "```",
-              resource.text,
-              "```"
-            ].join("\n")
-          );
-        } else if (typeof resource.blob === "string") {
-          parts.push(
-            [
-              "",
-              `@resource ${uri} (${mimeType}) [base64]`,
-              resource.blob
-            ].join("\n")
-          );
-        } else if (uri) {
-          parts.push(`@resource ${uri} (${mimeType})`);
-        }
-        break;
-      }
-      case "resource_link": {
-        const uri = typeof block.uri === "string" ? block.uri : "";
-        const name = typeof block.name === "string" ? block.name : "";
-        const title = typeof block.title === "string" ? block.title : "";
-        const description = typeof block.description === "string" ? block.description : "";
-        parts.push(
-          [
-            "",
-            `@resource_link ${name || uri}`,
-            ...title ? [title] : [],
-            ...description ? [description] : [],
-            ...uri ? [uri] : []
-          ].join("\n")
-        );
-        break;
-      }
-      case "image":
-      case "audio": {
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  return parts.join("\n").trim();
-}
-function extractAssistantText(msg) {
-  const blocks = Array.isArray(msg?.message?.content) ? msg.message.content : [];
-  const texts = [];
-  for (const b of blocks) {
-    if (!b || typeof b !== "object") continue;
-    if (b.type === "text" && typeof b.text === "string") texts.push(b.text);
-    if (b.type === "thinking" && typeof b.thinking === "string") texts.push(b.thinking);
-  }
-  return texts.join("").trim();
-}
-function extractToolResults(msg) {
-  const content = msg?.message?.content;
-  const blocks = Array.isArray(content) ? content : [];
-  const out = [];
-  for (const b of blocks) {
-    if (!b || typeof b !== "object") continue;
-    if (b.type !== "tool_result") continue;
-    const toolUseId = typeof b.tool_use_id === "string" ? b.tool_use_id : "";
-    const isError = Boolean(b.is_error);
-    const raw = b.content;
-    const text = typeof raw === "string" ? raw : Array.isArray(raw) ? raw.filter((x) => x && typeof x === "object" && x.type === "text").map((x) => String(x.text ?? "")).join("") : "";
-    if (toolUseId) out.push({ toolUseId, isError, content: text });
-  }
-  return out;
-}
-var ACP_SESSION_STORE_VERSION = 1;
-var MAX_DIFF_FILE_BYTES = 512e3;
-var MAX_DIFF_TEXT_CHARS = 4e5;
-function getProjectDirSlug(cwd) {
-  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
-}
-function sanitizeSessionId(sessionId) {
-  return sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function getAcpSessionDir(cwd) {
-  return join(getKodeBaseDir(), getProjectDirSlug(cwd), "acp-sessions");
-}
-function getAcpSessionFilePath(cwd, sessionId) {
-  return join(getAcpSessionDir(cwd), `${sanitizeSessionId(sessionId)}.json`);
-}
-function readTextFileForDiff(filePath) {
-  try {
-    const stats = statSync(filePath);
-    if (!stats.isFile()) return null;
-    if (stats.size > MAX_DIFF_FILE_BYTES) return null;
-    return readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-function truncateDiffText(text) {
-  if (text.length <= MAX_DIFF_TEXT_CHARS) return text;
-  return `${text.slice(0, MAX_DIFF_TEXT_CHARS)}
-
-[truncated ${text.length - MAX_DIFF_TEXT_CHARS} chars]`;
-}
-function persistAcpSessionToDisk(session) {
-  try {
-    const dir = getAcpSessionDir(session.cwd);
-    mkdirSync(dir, { recursive: true });
-    const payload = {
-      version: ACP_SESSION_STORE_VERSION,
-      sessionId: session.sessionId,
-      cwd: session.cwd,
-      mcpServers: session.mcpServers,
-      messages: session.messages,
-      toolPermissionContext: session.toolPermissionContext,
-      readFileTimestamps: session.readFileTimestamps,
-      responseState: session.responseState,
-      currentModeId: session.currentModeId
-    };
-    const path = getAcpSessionFilePath(session.cwd, session.sessionId);
-    writeFileSync(path, JSON.stringify(payload, null, 2), "utf8");
-  } catch (e) {
-    logError(e);
-  }
-}
-function loadAcpSessionFromDisk(cwd, sessionId) {
-  try {
-    const path = getAcpSessionFilePath(cwd, sessionId);
-    if (!existsSync(path)) return null;
-    const raw = readFileSync(path, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    if (parsed.sessionId !== sessionId) return null;
-    if (typeof parsed.cwd !== "string" || parsed.cwd !== cwd) return null;
-    if (!Array.isArray(parsed.messages)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function connectAcpMcpServers(mcpServers) {
-  if (!Array.isArray(mcpServers) || mcpServers.length === 0) return [];
-  const rawTimeout = process.env.MCP_CONNECTION_TIMEOUT_MS;
-  const parsedTimeout = rawTimeout ? Number.parseInt(rawTimeout, 10) : NaN;
-  const timeoutMs = Number.isFinite(parsedTimeout) ? parsedTimeout : 3e4;
-  const results = [];
-  const connectWithTimeout = async (client, transport2, name) => {
-    const connectPromise = client.connect(transport2);
-    if (timeoutMs > 0) {
-      const timeoutPromise = new Promise((_, reject) => {
-        const timeoutId = setTimeout(() => {
-          reject(new Error(`Connection to MCP server "${name}" timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        connectPromise.then(
-          () => clearTimeout(timeoutId),
-          () => clearTimeout(timeoutId)
-        );
-      });
-      await Promise.race([connectPromise, timeoutPromise]);
-    } else {
-      await connectPromise;
-    }
-  };
-  for (const server of mcpServers) {
-    const serverType = typeof server?.type === "string" ? String(server.type) : "stdio";
-    const name = typeof server?.name === "string" ? String(server.name) : "";
-    if (!name) {
-      results.push({ name: "<invalid>", type: "failed" });
-      continue;
-    }
-    const candidates = [];
-    if (serverType === "http" || serverType === "sse") {
-      const url = typeof server?.url === "string" ? String(server.url) : "";
-      if (!url) {
-        results.push({ name, type: "failed" });
-        continue;
-      }
-      let parsedUrl;
-      try {
-        parsedUrl = new URL(url);
-      } catch (e) {
-        logError(e);
-        results.push({ name, type: "failed" });
-        continue;
-      }
-      const headerList = Array.isArray(server?.headers) ? server.headers : [];
-      const headers = {};
-      for (const h of headerList) {
-        if (!h || typeof h !== "object") continue;
-        const k = typeof h.name === "string" ? String(h.name) : "";
-        const val = typeof h.value === "string" ? String(h.value) : "";
-        if (k) headers[k] = val;
-      }
-      const requestInit = Object.keys(headers).length > 0 ? { requestInit: { headers } } : {};
-      if (serverType === "http") {
-        candidates.push(
-          { kind: "http", transport: new StreamableHTTPClientTransport(parsedUrl, requestInit) },
-          { kind: "sse", transport: new SSEClientTransport(parsedUrl, requestInit) }
-        );
-      } else {
-        candidates.push(
-          { kind: "sse", transport: new SSEClientTransport(parsedUrl, requestInit) },
-          { kind: "http", transport: new StreamableHTTPClientTransport(parsedUrl, requestInit) }
-        );
-      }
-    } else {
-      const command = typeof server?.command === "string" ? String(server.command) : "";
-      const args = Array.isArray(server?.args) ? server.args.map((a) => String(a)) : [];
-      const envList = Array.isArray(server?.env) ? server.env : [];
-      if (!command) {
-        results.push({ name, type: "failed" });
-        continue;
-      }
-      const envFromParams = {};
-      for (const v of envList) {
-        if (!v || typeof v !== "object") continue;
-        const k = typeof v.name === "string" ? String(v.name) : "";
-        const val = typeof v.value === "string" ? String(v.value) : "";
-        if (k) envFromParams[k] = val;
-      }
-      candidates.push({
-        kind: "stdio",
-        transport: new StdioClientTransport({
-          command,
-          args,
-          env: { ...process.env, ...envFromParams },
-          stderr: "pipe"
-        })
-      });
-    }
-    let lastError;
-    for (const candidate of candidates) {
-      const client = new Client(
-        { name: PRODUCT_COMMAND, version: MACRO.VERSION || "0.0.0" },
-        { capabilities: {} }
-      );
-      try {
-        await connectWithTimeout(client, candidate.transport, name);
-        let capabilities = null;
-        try {
-          capabilities = client.getServerCapabilities();
-        } catch {
-          capabilities = null;
-        }
-        results.push({ name, client, capabilities, type: "connected" });
-        lastError = null;
-        break;
-      } catch (e) {
-        lastError = e;
-        try {
-          await client.close();
-        } catch {
-        }
-      }
-    }
-    if (lastError) {
-      logError(lastError);
-      results.push({ name, type: "failed" });
-    }
-  }
-  return results;
-}
-function mergeMcpClients(base, extra) {
-  const map = /* @__PURE__ */ new Map();
-  for (const c of base) map.set(c.name, c);
-  for (const c of extra) map.set(c.name, c);
-  return Array.from(map.values());
-}
-var KodeAcpAgent = class {
-  constructor(peer2) {
-    this.peer = peer2;
-    this.registerMethods();
-  }
-  clientCapabilities = {};
-  sessions = /* @__PURE__ */ new Map();
-  registerMethods() {
-    this.peer.registerMethod("initialize", this.handleInitialize.bind(this));
-    this.peer.registerMethod("authenticate", this.handleAuthenticate.bind(this));
-    this.peer.registerMethod("session/new", this.handleSessionNew.bind(this));
-    this.peer.registerMethod("session/load", this.handleSessionLoad.bind(this));
-    this.peer.registerMethod("session/prompt", this.handleSessionPrompt.bind(this));
-    this.peer.registerMethod("session/set_mode", this.handleSessionSetMode.bind(this));
-    this.peer.registerMethod("session/cancel", this.handleSessionCancel.bind(this));
-  }
-  async handleInitialize(params) {
-    const p = params ?? {};
-    const protocolVersion = typeof p.protocolVersion === "number" ? p.protocolVersion : ACP_PROTOCOL_VERSION;
-    this.clientCapabilities = p.clientCapabilities && typeof p.clientCapabilities === "object" ? p.clientCapabilities : {};
-    return {
-      protocolVersion: ACP_PROTOCOL_VERSION,
-      agentCapabilities: {
-        loadSession: true,
-        promptCapabilities: {
-          image: false,
-          audio: false,
-          embeddedContext: true,
-          embeddedContent: true
-        },
-        mcpCapabilities: {
-          http: true,
-          sse: true
-        }
-      },
-      agentInfo: {
-        name: "kode",
-        title: "Kode",
-        version: MACRO.VERSION || "0.0.0"
-      },
-      authMethods: []
-    };
-  }
-  async handleAuthenticate(_params) {
-    return {};
-  }
-  async handleSessionNew(params) {
-    const p = params ?? {};
-    const cwd = typeof p.cwd === "string" ? p.cwd : "";
-    if (!cwd) {
-      throw new JsonRpcError(-32602, "Missing required param: cwd");
-    }
-    if (!isAbsolute(cwd)) {
-      throw new JsonRpcError(-32602, `cwd must be an absolute path: ${cwd}`);
-    }
-    setOriginalCwd(cwd);
-    await setCwd(cwd);
-    grantReadPermissionForOriginalDir();
-    const mcpServers = Array.isArray(p.mcpServers) ? p.mcpServers : [];
-    const [commands, tools, ctx, systemPrompt, configuredMcpClients] = await Promise.all([
-      getCommands(),
-      getTools(),
-      getContext(),
-      getSystemPrompt({ disableSlashCommands: false }),
-      getClients().catch(() => [])
-    ]);
-    const acpMcpClients = await connectAcpMcpServers(mcpServers);
-    const mcpClients = mergeMcpClients(configuredMcpClients, acpMcpClients);
-    const toolPermissionContext = loadToolPermissionContextFromDisk({
-      projectDir: cwd,
-      includeKodeProjectConfig: true,
-      isBypassPermissionsModeAvailable: true
-    });
-    const sessionId = `sess_${nanoid()}`;
-    const session = {
-      sessionId,
-      cwd,
-      mcpServers,
-      mcpClients,
-      commands,
-      tools,
-      systemPrompt,
-      context: ctx,
-      messages: [],
-      toolPermissionContext,
-      readFileTimestamps: {},
-      responseState: {},
-      currentModeId: toolPermissionContext.mode ?? "default",
-      activeAbortController: null,
-      toolCalls: /* @__PURE__ */ new Map()
-    };
-    this.sessions.set(sessionId, session);
-    this.sendAvailableCommands(session);
-    this.sendCurrentMode(session);
-    persistAcpSessionToDisk(session);
-    return {
-      sessionId,
-      modes: this.getModeState(session)
-    };
-  }
-  async handleSessionLoad(params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : "";
-    const cwd = typeof p.cwd === "string" ? p.cwd : "";
-    if (!sessionId) throw new JsonRpcError(-32602, "Missing required param: sessionId");
-    if (!cwd) throw new JsonRpcError(-32602, "Missing required param: cwd");
-    if (!isAbsolute(cwd)) {
-      throw new JsonRpcError(-32602, `cwd must be an absolute path: ${cwd}`);
-    }
-    setOriginalCwd(cwd);
-    await setCwd(cwd);
-    grantReadPermissionForOriginalDir();
-    const persisted = loadAcpSessionFromDisk(cwd, sessionId);
-    if (!persisted) {
-      throw new JsonRpcError(-32602, `Session not found: ${sessionId}`);
-    }
-    const mcpServers = Array.isArray(p.mcpServers) ? p.mcpServers : [];
-    const [commands, tools, ctx, systemPrompt, configuredMcpClients] = await Promise.all([
-      getCommands(),
-      getTools(),
-      getContext(),
-      getSystemPrompt({ disableSlashCommands: false }),
-      getClients().catch(() => [])
-    ]);
-    const acpMcpClients = await connectAcpMcpServers(mcpServers);
-    const mcpClients = mergeMcpClients(configuredMcpClients, acpMcpClients);
-    const toolPermissionContext = loadToolPermissionContextFromDisk({
-      projectDir: cwd,
-      includeKodeProjectConfig: true,
-      isBypassPermissionsModeAvailable: true
-    });
-    const currentModeId = typeof persisted.currentModeId === "string" && persisted.currentModeId ? persisted.currentModeId : toolPermissionContext.mode ?? "default";
-    toolPermissionContext.mode = currentModeId;
-    const session = {
-      sessionId,
-      cwd,
-      mcpServers,
-      mcpClients,
-      commands,
-      tools,
-      systemPrompt,
-      context: ctx,
-      messages: Array.isArray(persisted.messages) ? persisted.messages : [],
-      toolPermissionContext,
-      readFileTimestamps: persisted.readFileTimestamps && typeof persisted.readFileTimestamps === "object" ? persisted.readFileTimestamps : {},
-      responseState: persisted.responseState && typeof persisted.responseState === "object" ? persisted.responseState : {},
-      currentModeId,
-      activeAbortController: null,
-      toolCalls: /* @__PURE__ */ new Map()
-    };
-    this.sessions.set(sessionId, session);
-    this.sendAvailableCommands(session);
-    this.sendCurrentMode(session);
-    this.replayConversation(session);
-    return { modes: this.getModeState(session) };
-  }
-  async handleSessionSetMode(params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : "";
-    const modeId = typeof p.modeId === "string" ? p.modeId : "";
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new JsonRpcError(-32602, `Session not found: ${sessionId}`);
-    const allowed = new Set(this.getModeState(session).availableModes.map((m) => m.id));
-    if (!allowed.has(modeId)) {
-      throw new JsonRpcError(-32602, `Unknown modeId: ${modeId}`);
-    }
-    session.currentModeId = modeId;
-    session.toolPermissionContext.mode = modeId;
-    this.sendCurrentMode(session);
-    persistAcpSessionToDisk(session);
-    return {};
-  }
-  async handleSessionCancel(params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : "";
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    session.activeAbortController?.abort();
-  }
-  async handleSessionPrompt(params) {
-    const p = params ?? {};
-    const sessionId = typeof p.sessionId === "string" ? p.sessionId : "";
-    const blocks = Array.isArray(p.prompt) ? p.prompt : Array.isArray(p.content) ? p.content : [];
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new JsonRpcError(-32602, `Session not found: ${sessionId}`);
-    if (session.activeAbortController) {
-      throw new JsonRpcError(-32e3, `Session already has an active prompt: ${sessionId}`);
-    }
-    setOriginalCwd(session.cwd);
-    await setCwd(session.cwd);
-    grantReadPermissionForOriginalDir();
-    const promptText = blocksToText(blocks);
-    const userMsg = createUserMessage(promptText);
-    const baseMessages = [...session.messages, userMsg];
-    session.messages.push(userMsg);
-    if (process.env.KODE_ACP_ECHO === "1") {
-      await this.handleKodeMessage(session, createAssistantMessage(promptText));
-      persistAcpSessionToDisk(session);
-      return { stopReason: "end_turn" };
-    }
-    const abortController = new AbortController();
-    session.activeAbortController = abortController;
-    const canUseTool = this.createAcpCanUseTool(session);
-    const options = {
-      commands: session.commands,
-      tools: session.tools,
-      verbose: false,
-      safeMode: false,
-      forkNumber: 0,
-      messageLogName: session.sessionId,
-      maxThinkingTokens: 0,
-      persistSession: false,
-      toolPermissionContext: session.toolPermissionContext,
-      mcpClients: session.mcpClients,
-      shouldAvoidPermissionPrompts: false
-    };
-    let stopReason = "end_turn";
-    try {
-      for await (const m of query(baseMessages, session.systemPrompt, session.context, canUseTool, {
-        options,
-        abortController,
-        messageId: void 0,
-        readFileTimestamps: session.readFileTimestamps,
-        setToolJSX: () => {
-        },
-        agentId: "main",
-        responseState: session.responseState
-      })) {
-        if (abortController.signal.aborted) {
-          stopReason = "cancelled";
-        }
-        await this.handleKodeMessage(session, m);
-      }
-      if (abortController.signal.aborted) stopReason = "cancelled";
-    } catch (err) {
-      if (abortController.signal.aborted) {
-        stopReason = "cancelled";
-      } else {
-        logError(err);
-        const msg = err instanceof Error ? err.message : String(err);
-        this.sendAgentMessage(session.sessionId, msg);
-        stopReason = "end_turn";
-      }
-    } finally {
-      session.activeAbortController = null;
-      persistAcpSessionToDisk(session);
-    }
-    return { stopReason };
-  }
-  async handleKodeMessage(session, m) {
-    if (!m || typeof m !== "object") return;
-    if (m.type === "assistant") {
-      session.messages.push(m);
-      const blocks = Array.isArray(m.message?.content) ? m.message.content : [];
-      for (const b of blocks) {
-        if (!b || typeof b !== "object") continue;
-        if (b.type === "text" && typeof b.text === "string") {
-          this.sendAgentMessage(session.sessionId, b.text);
-        } else if (b.type === "thinking" && typeof b.thinking === "string") {
-          this.sendAgentThought(session.sessionId, b.thinking);
-        } else if (b.type === "tool_use") {
-          const toolUseId = typeof b.id === "string" ? b.id : "";
-          const toolName = typeof b.name === "string" ? b.name : "";
-          const input = b.input && typeof b.input === "object" && !Array.isArray(b.input) ? b.input : {};
-          if (!toolUseId || !toolName) continue;
-          const kind = toolKindForName(toolName);
-          const title = titleForToolCall(toolName, input);
-          session.toolCalls.set(toolUseId, {
-            title,
-            kind,
-            status: "pending",
-            rawInput: asJsonObject(input)
-          });
-          this.peer.sendNotification("session/update", {
-            sessionId: session.sessionId,
-            update: {
-              sessionUpdate: "tool_call",
-              toolCallId: toolUseId,
-              title,
-              kind,
-              status: "pending",
-              rawInput: asJsonObject(input)
-            }
-          });
-        }
-      }
-      return;
-    }
-    if (m.type === "progress") {
-      const toolCallId = m.toolUseID;
-      const existing = session.toolCalls.get(toolCallId);
-      const title = existing?.title ?? "Tool";
-      const kind = existing?.kind ?? "other";
-      if (!existing || existing.status === "pending") {
-        session.toolCalls.set(toolCallId, {
-          title,
-          kind,
-          status: "in_progress",
-          rawInput: existing?.rawInput
-        });
-        this.sendToolCallUpdate(session.sessionId, {
-          toolCallId,
-          status: "in_progress"
-        });
-      }
-      const text = extractAssistantText(m.content);
-      if (text) {
-        this.sendToolCallUpdate(session.sessionId, {
-          toolCallId,
-          content: [
-            {
-              type: "content",
-              content: { type: "text", text }
-            }
-          ]
-        });
-      }
-      return;
-    }
-    if (m.type === "user") {
-      const toolResults = extractToolResults(m);
-      if (toolResults.length === 0) {
-        session.messages.push(m);
-        return;
-      }
-      for (const tr of toolResults) {
-        const existing = session.toolCalls.get(tr.toolUseId);
-        const title = existing?.title ?? "Tool";
-        const kind = existing?.kind ?? "other";
-        if (!existing || existing.status === "pending") {
-          session.toolCalls.set(tr.toolUseId, {
-            title,
-            kind,
-            status: "in_progress",
-            rawInput: existing?.rawInput
-          });
-          this.sendToolCallUpdate(session.sessionId, {
-            toolCallId: tr.toolUseId,
-            status: "in_progress"
-          });
-        }
-        const status = tr.isError ? "failed" : "completed";
-        session.toolCalls.set(tr.toolUseId, {
-          title,
-          kind,
-          status,
-          rawInput: existing?.rawInput
-        });
-        const rawOutput = asJsonObject(m.toolUseResult?.data);
-        const content = [];
-        const diffContent = status === "completed" ? this.buildDiffContentForToolResult(session, tr.toolUseId, rawOutput) : null;
-        if (diffContent) content.push(diffContent);
-        if (tr.content) {
-          content.push({ type: "content", content: { type: "text", text: tr.content } });
-        }
-        this.sendToolCallUpdate(session.sessionId, {
-          toolCallId: tr.toolUseId,
-          status,
-          ...content.length > 0 ? { content } : {},
-          ...rawOutput ? { rawOutput } : {}
-        });
-      }
-      session.messages.push(m);
-      return;
-    }
-  }
-  createAcpCanUseTool(session) {
-    const timeoutMs = (() => {
-      const raw = process.env.KODE_ACP_PERMISSION_TIMEOUT_MS;
-      const parsed = raw ? Number(raw) : NaN;
-      return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
-    })();
-    return async (tool, input, toolUseContext, assistantMessage) => {
-      const toolUseId = typeof toolUseContext?.toolUseId === "string" && toolUseContext.toolUseId ? toolUseContext.toolUseId : `call_${nanoid()}`;
-      const base = await hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage);
-      if (base.result === true) {
-        this.captureFileSnapshotForTool(session, toolUseId, tool.name, input);
-        return base;
-      }
-      const denied = base;
-      if (denied.shouldPromptUser === false) {
-        return { result: false, message: denied.message };
-      }
-      const title = titleForToolCall(tool.name, input);
-      const kind = toolKindForName(tool.name);
-      if (!session.toolCalls.has(toolUseId)) {
-        session.toolCalls.set(toolUseId, { title, kind, status: "pending", rawInput: asJsonObject(input) });
-        this.peer.sendNotification("session/update", {
-          sessionId: session.sessionId,
-          update: {
-            sessionUpdate: "tool_call",
-            toolCallId: toolUseId,
-            title,
-            kind,
-            status: "pending",
-            rawInput: asJsonObject(input)
-          }
-        });
-      }
-      const options = [
-        { optionId: "allow_once", name: "Allow once", kind: "allow_once" },
-        { optionId: "reject_once", name: "Reject", kind: "reject_once" }
-      ];
-      if (Array.isArray(denied.suggestions) && denied.suggestions.length > 0) {
-        options.splice(1, 0, {
-          optionId: "allow_always",
-          name: "Allow always (remember)",
-          kind: "allow_always"
-        });
-      }
-      try {
-        const response = await this.peer.sendRequest({
-          method: "session/request_permission",
-          params: {
-            sessionId: session.sessionId,
-            toolCall: {
-              toolCallId: toolUseId,
-              title,
-              kind,
-              status: "pending",
-              content: [
-                {
-                  type: "content",
-                  content: { type: "text", text: denied.message }
-                }
-              ],
-              rawInput: asJsonObject(input)
-            },
-            options
-          },
-          signal: toolUseContext.abortController.signal,
-          timeoutMs
-        });
-        const outcome = response?.outcome;
-        if (!outcome || outcome.outcome === "cancelled") {
-          toolUseContext.abortController.abort();
-          return { result: false, message: denied.message, shouldPromptUser: false };
-        }
-        if (outcome.outcome === "selected" && outcome.optionId === "allow_once") {
-          this.captureFileSnapshotForTool(session, toolUseId, tool.name, input);
-          return { result: true };
-        }
-        if (outcome.outcome === "selected" && outcome.optionId === "allow_always") {
-          const suggestions = Array.isArray(denied.suggestions) ? denied.suggestions : [];
-          if (suggestions.length > 0) {
-            const next = applyToolPermissionContextUpdates(session.toolPermissionContext, suggestions);
-            session.toolPermissionContext = next;
-            if (toolUseContext?.options) toolUseContext.options.toolPermissionContext = next;
-            for (const update of suggestions) {
-              try {
-                persistToolPermissionUpdateToDisk({ update, projectDir: session.cwd });
-              } catch (e) {
-                logError(e);
-              }
-            }
-          }
-          this.captureFileSnapshotForTool(session, toolUseId, tool.name, input);
-          return { result: true };
-        }
-        return { result: false, message: denied.message };
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return { result: false, message: `Permission prompt failed: ${msg}`, shouldPromptUser: false };
-      }
-    };
-  }
-  captureFileSnapshotForTool(session, toolUseId, toolName, input) {
-    if (toolName !== "Write" && toolName !== "MultiEdit") return;
-    const filePath = input && typeof input === "object" ? String(input.file_path ?? "") : "";
-    if (!filePath) return;
-    const absPath = isAbsolute(filePath) ? filePath : resolve(session.cwd, filePath);
-    const oldContent = existsSync(absPath) ? readTextFileForDiff(absPath) : "";
-    if (oldContent === null) return;
-    const existing = session.toolCalls.get(toolUseId);
-    if (existing) {
-      existing.fileSnapshot = { path: absPath, content: oldContent };
-      session.toolCalls.set(toolUseId, existing);
-      return;
-    }
-    session.toolCalls.set(toolUseId, {
-      title: toolName,
-      kind: toolKindForName(toolName),
-      status: "pending",
-      rawInput: asJsonObject(input),
-      fileSnapshot: { path: absPath, content: oldContent }
-    });
-  }
-  buildDiffContentForToolResult(session, toolUseId, rawOutput) {
-    const existing = session.toolCalls.get(toolUseId);
-    if (!existing || existing.kind !== "edit") return null;
-    const inputFilePath = typeof existing.rawInput?.file_path === "string" ? existing.rawInput.file_path : rawOutput && typeof rawOutput.filePath === "string" ? String(rawOutput.filePath) : "";
-    if (!inputFilePath) return null;
-    const absPath = isAbsolute(inputFilePath) ? inputFilePath : resolve(session.cwd, inputFilePath);
-    const oldText = rawOutput && typeof rawOutput.originalFile === "string" ? String(rawOutput.originalFile) : existing.fileSnapshot && existing.fileSnapshot.path === absPath ? existing.fileSnapshot.content : void 0;
-    if (oldText === void 0) return null;
-    const newTextFromDisk = readTextFileForDiff(absPath);
-    const newTextFromOutput = rawOutput && typeof rawOutput.content === "string" ? String(rawOutput.content) : null;
-    const newText = newTextFromDisk ?? newTextFromOutput;
-    if (newText === null) return null;
-    return {
-      type: "diff",
-      path: absPath,
-      oldText: truncateDiffText(oldText),
-      newText: truncateDiffText(newText)
-    };
-  }
-  replayConversation(session) {
-    session.toolCalls.clear();
-    for (const m of session.messages) {
-      if (!m || typeof m !== "object") continue;
-      if (m.type === "assistant") {
-        const blocks = Array.isArray(m.message?.content) ? m.message.content : [];
-        for (const b of blocks) {
-          if (!b || typeof b !== "object") continue;
-          if (b.type === "text" && typeof b.text === "string") {
-            this.sendAgentMessage(session.sessionId, b.text);
-          } else if (b.type === "thinking" && typeof b.thinking === "string") {
-            this.sendAgentThought(session.sessionId, b.thinking);
-          } else if (b.type === "tool_use") {
-            const toolUseId = typeof b.id === "string" ? b.id : "";
-            const toolName = typeof b.name === "string" ? b.name : "";
-            const input = b.input && typeof b.input === "object" && !Array.isArray(b.input) ? b.input : {};
-            if (!toolUseId || !toolName) continue;
-            if (!session.toolCalls.has(toolUseId)) {
-              const kind = toolKindForName(toolName);
-              const title = titleForToolCall(toolName, input);
-              session.toolCalls.set(toolUseId, {
-                title,
-                kind,
-                status: "pending",
-                rawInput: asJsonObject(input)
-              });
-              this.peer.sendNotification("session/update", {
-                sessionId: session.sessionId,
-                update: {
-                  sessionUpdate: "tool_call",
-                  toolCallId: toolUseId,
-                  title,
-                  kind,
-                  status: "pending",
-                  rawInput: asJsonObject(input)
-                }
-              });
-            }
-          }
-        }
-        continue;
-      }
-      if (m.type === "user") {
-        const content = m?.message?.content;
-        if (typeof content === "string" && content.trim()) {
-          this.sendUserMessage(session.sessionId, content);
-        }
-        const toolResults = extractToolResults(m);
-        if (toolResults.length === 0) continue;
-        for (const tr of toolResults) {
-          const existing = session.toolCalls.get(tr.toolUseId);
-          const title = existing?.title ?? "Tool";
-          const kind = existing?.kind ?? "other";
-          if (!existing) {
-            session.toolCalls.set(tr.toolUseId, { title, kind, status: "pending" });
-            this.peer.sendNotification("session/update", {
-              sessionId: session.sessionId,
-              update: {
-                sessionUpdate: "tool_call",
-                toolCallId: tr.toolUseId,
-                title,
-                kind,
-                status: "pending"
-              }
-            });
-          }
-          const status = tr.isError ? "failed" : "completed";
-          const contentBlocks = [];
-          if (tr.content) {
-            contentBlocks.push({ type: "content", content: { type: "text", text: tr.content } });
-          }
-          const rawOutput = asJsonObject(m.toolUseResult?.data);
-          this.sendToolCallUpdate(session.sessionId, {
-            toolCallId: tr.toolUseId,
-            status,
-            ...contentBlocks.length > 0 ? { content: contentBlocks } : {},
-            ...rawOutput ? { rawOutput } : {}
-          });
-          session.toolCalls.set(tr.toolUseId, {
-            title,
-            kind,
-            status,
-            rawInput: existing?.rawInput
-          });
-        }
-      }
-    }
-  }
-  getModeState(session) {
-    const availableModes = [
-      { id: "default", name: "Default", description: "Normal permissions (prompt when needed)" },
-      { id: "acceptEdits", name: "Accept Edits", description: "Auto-approve safe file edits" },
-      { id: "plan", name: "Plan", description: "Read-only planning mode" },
-      { id: "dontAsk", name: "Don't Ask", description: "Auto-deny permission prompts" },
-      { id: "bypassPermissions", name: "Bypass", description: "Bypass permission prompts (dangerous)" }
-    ];
-    const currentModeId = availableModes.some((m) => m.id === session.currentModeId) ? session.currentModeId : "default";
-    return { currentModeId, availableModes };
-  }
-  sendAvailableCommands(session) {
-    const availableCommands = session.commands.filter((c) => !c.isHidden).map((c) => ({
-      name: c.userFacingName(),
-      description: c.description,
-      ...c.argumentHint ? { input: { hint: c.argumentHint } } : {}
-    }));
-    this.peer.sendNotification("session/update", {
-      sessionId: session.sessionId,
-      update: {
-        sessionUpdate: "available_commands_update",
-        availableCommands
-      }
-    });
-  }
-  sendCurrentMode(session) {
-    this.peer.sendNotification("session/update", {
-      sessionId: session.sessionId,
-      update: {
-        sessionUpdate: "current_mode_update",
-        currentModeId: session.currentModeId
-      }
-    });
-  }
-  sendUserMessage(sessionId, text) {
-    if (!text) return;
-    this.peer.sendNotification("session/update", {
-      sessionId,
-      update: {
-        sessionUpdate: "user_message_chunk",
-        content: { type: "text", text }
-      }
-    });
-  }
-  sendAgentMessage(sessionId, text) {
-    if (!text) return;
-    this.peer.sendNotification("session/update", {
-      sessionId,
-      update: {
-        sessionUpdate: "agent_message_chunk",
-        content: { type: "text", text }
-      }
-    });
-  }
-  sendAgentThought(sessionId, text) {
-    if (!text) return;
-    this.peer.sendNotification("session/update", {
-      sessionId,
-      update: {
-        sessionUpdate: "agent_thought_chunk",
-        content: { type: "text", text }
-      }
-    });
-  }
-  sendToolCallUpdate(sessionId, update) {
-    this.peer.sendNotification("session/update", {
-      sessionId,
-      update: {
-        sessionUpdate: "tool_call_update",
-        ...update
-      }
-    });
-  }
-};
-
-// src/entrypoints/acp.ts
-initSentry();
-ensurePackagedRuntimeEnv();
-var { writeAcpLine } = installStdoutGuard();
-initDebugLogger();
-try {
-  enableConfigs();
-} catch (e) {
-  logError(e);
-}
-var peer = new JsonRpcPeer();
-new KodeAcpAgent(peer);
-var transport = new StdioTransport(peer, { writeLine: writeAcpLine });
-transport.start();