@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/src-QXLGGMUW.js

@@ -0,0 +1,1647 @@
+import "./chunk-U2IHWPCU.js";
+import {
+  startKodeDaemon
+} from "./chunk-3JDNWX7W.js";
+import "./chunk-TNGVRTO5.js";
+import "./chunk-HJYOH4HC.js";
+import "./chunk-UNOY3VJ2.js";
+import {
+  buildSystemPromptForSession,
+  getSessionContext,
+  runTurn
+} from "./chunk-4A46ZXMJ.js";
+import "./chunk-6BAS4WY6.js";
+import {
+  getTools
+} from "./chunk-77XDJMBP.js";
+import "./chunk-GCQCAXJZ.js";
+import "./chunk-7RRW4NTB.js";
+import {
+  getClients
+} from "./chunk-ZBVLKZ5V.js";
+import "./chunk-BTA7SZ26.js";
+import {
+  grantReadPermissionForOriginalDir,
+  hasPermissionsToUseTool
+} from "./chunk-PPHLQVL7.js";
+import {
+  loadToolPermissionContextFromDisk,
+  persistToolPermissionUpdateToDisk
+} from "./chunk-2JN5MY67.js";
+import {
+  applyToolPermissionContextUpdates
+} from "./chunk-CP6E5UG6.js";
+import "./chunk-TNWB3U5Y.js";
+import "./chunk-UVDJL6ZZ.js";
+import "./chunk-CDGRYGPZ.js";
+import "./chunk-T7RB5V5J.js";
+import "./chunk-53M46S5I.js";
+import "./chunk-HPYNW6TT.js";
+import "./chunk-LOD5ZHCI.js";
+import "./chunk-GELCZWMB.js";
+import "./chunk-3BYE3ME6.js";
+import "./chunk-M7P3QNRU.js";
+import "./chunk-SWQV4KSY.js";
+import "./chunk-LOCXPQNJ.js";
+import "./chunk-ZCLTZIVP.js";
+import "./chunk-4CRUCZR4.js";
+import "./chunk-BHDHXOXB.js";
+import {
+  createAssistantMessage,
+  createUserMessage
+} from "./chunk-HRJ3ICQK.js";
+import "./chunk-6ZWEOSEI.js";
+import {
+  initDebugLogger
+} from "./chunk-YIO5EBMQ.js";
+import {
+  PRODUCT_COMMAND,
+  getKodeBaseDir,
+  logError,
+  logMCPError
+} from "./chunk-3OEJVB5A.js";
+import {
+  setCwd,
+  setOriginalCwd
+} from "./chunk-BBJFHTBC.js";
+import "./chunk-QHQOBUF6.js";
+import {
+  MACRO
+} from "./chunk-W5EGGA44.js";
+import "./chunk-DXD76CMV.js";
+import "./chunk-LB6TCPDI.js";
+import {
+  enableConfigs
+} from "./chunk-XR2W3MAM.js";
+import "./chunk-B3MW3YGY.js";
+import "./chunk-54KOYG5C.js";
+
+// apps/server/src/bootstrapEnv.ts
+import { basename, dirname, join } from "node:path";
+function ensurePackagedRuntimeEnv() {
+  if (process.env.KODE_PACKAGED !== void 0) return;
+  try {
+    const exec = basename(process.execPath || "").toLowerCase();
+    if (exec && exec !== "bun" && exec !== "bun.exe" && exec !== "node" && exec !== "node.exe") {
+      process.env.KODE_PACKAGED = "1";
+    }
+  } catch {
+  }
+}
+
+// apps/server/src/index.ts
+import { cwd as processCwd } from "process";
+
+// apps/server/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);
+    const errorValue = msg && typeof msg === "object" ? msg.error : void 0;
+    if (isObject(errorValue)) {
+      const code = typeof errorValue.code === "number" ? errorValue.code : -32603;
+      const message = typeof errorValue.message === "string" ? errorValue.message : "Unknown error";
+      pending.reject(new JsonRpcError(code, message, errorValue.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);
+  }
+};
+
+// apps/server/src/acp/protocol.ts
+var ACP_PROTOCOL_VERSION = 1;
+
+// apps/server/src/acp/stdioTransport.ts
+import readline from "node:readline";
+var StdioTransport = class {
+  constructor(peer, opts) {
+    this.peer = peer;
+    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;
+  }
+};
+
+// apps/server/src/acp/stdoutGuard.ts
+import { format as format2 } from "node:util";
+function writeTo(write, chunk, encoding, cb) {
+  if (typeof encoding === "function") {
+    return write(chunk, 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 writeAcpLine = (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, restore, originalStdoutWrite };
+}
+
+// apps/server/src/acp/agent/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// apps/server/src/acp/agent/handlers/initialize.ts
+function handleInitialize(args) {
+  const p = isRecord(args.params) ? args.params : {};
+  const clientCapabilities = isRecord(p.clientCapabilities) ? p.clientCapabilities : {};
+  args.setClientCapabilities(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: []
+  };
+}
+function handleAuthenticate() {
+  return {};
+}
+
+// apps/server/src/acp/agent/handlers/sessions.ts
+import { nanoid } from "nanoid";
+import { isAbsolute as isAbsolute2 } from "node:path";
+
+// apps/server/src/acp/agent/mcp.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+function getConnectionTimeoutMs() {
+  const rawTimeout = process.env.MCP_CONNECTION_TIMEOUT_MS;
+  const parsedTimeout = rawTimeout ? Number.parseInt(rawTimeout, 10) : NaN;
+  return Number.isFinite(parsedTimeout) ? parsedTimeout : 3e4;
+}
+function buildEnv(extra) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  if (extra) Object.assign(env, extra);
+  return env;
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const h of headers ?? []) {
+    if (!h || typeof h !== "object") continue;
+    if (typeof h.name === "string" && typeof h.value === "string") {
+      out[h.name] = h.value;
+    }
+  }
+  return out;
+}
+function normalizeEnvVars(vars) {
+  const out = {};
+  for (const v of vars ?? []) {
+    if (!v || typeof v !== "object") continue;
+    if (typeof v.name === "string" && typeof v.value === "string") {
+      out[v.name] = v.value;
+    }
+  }
+  return out;
+}
+async function connectWithTimeout(client, transport, name, timeoutMs) {
+  const connectPromise = client.connect(transport);
+  if (timeoutMs <= 0) {
+    await connectPromise;
+    return;
+  }
+  const timeoutPromise = new Promise((_, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(
+        new Error(
+          `Connection to MCP server "${name}" timed out after ${timeoutMs}ms`
+        )
+      );
+    }, timeoutMs);
+    connectPromise.finally(() => clearTimeout(timeoutId));
+  });
+  await Promise.race([connectPromise, timeoutPromise]);
+}
+function createCandidates(server) {
+  const name = server.name;
+  if (!name) return null;
+  if (server.type === "http" || server.type === "sse") {
+    const url = server.url;
+    if (!url) return null;
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(url);
+    } catch (e) {
+      logError(e);
+      return null;
+    }
+    const headers = normalizeHeaders(server.headers);
+    const options = Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0;
+    if (server.type === "http") {
+      return {
+        name,
+        candidates: [
+          {
+            kind: "http",
+            transport: new StreamableHTTPClientTransport(parsedUrl, options)
+          },
+          {
+            kind: "sse",
+            transport: new SSEClientTransport(parsedUrl, options)
+          }
+        ]
+      };
+    }
+    return {
+      name,
+      candidates: [
+        { kind: "sse", transport: new SSEClientTransport(parsedUrl, options) },
+        {
+          kind: "http",
+          transport: new StreamableHTTPClientTransport(parsedUrl, options)
+        }
+      ]
+    };
+  }
+  const envFromParams = normalizeEnvVars(server.env);
+  return {
+    name,
+    candidates: [
+      {
+        kind: "stdio",
+        transport: new StdioClientTransport({
+          command: server.command,
+          args: server.args,
+          env: buildEnv(envFromParams),
+          stderr: "pipe"
+        })
+      }
+    ]
+  };
+}
+async function connectAcpMcpServers(mcpServers) {
+  if (!Array.isArray(mcpServers) || mcpServers.length === 0) return [];
+  const timeoutMs = getConnectionTimeoutMs();
+  const results = [];
+  for (const server of mcpServers) {
+    const normalized = createCandidates(server);
+    if (!normalized) {
+      results.push({ name: "<invalid>", type: "failed" });
+      continue;
+    }
+    const { name, candidates } = normalized;
+    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, timeoutMs);
+        if (candidate.kind === "stdio") {
+          candidate.transport.stderr?.on("data", (data) => {
+            const errorText = data.toString().trim();
+            if (errorText) logMCPError(name, `Server stderr: ${errorText}`);
+          });
+        }
+        let capabilities = null;
+        try {
+          capabilities = client.getServerCapabilities() ?? null;
+        } 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());
+}
+
+// apps/server/src/acp/agent/modes.ts
+var MODE_SET = /* @__PURE__ */ new Set([
+  "default",
+  "acceptEdits",
+  "plan",
+  "dontAsk",
+  "bypassPermissions"
+]);
+function isPermissionMode(value) {
+  return typeof value === "string" && MODE_SET.has(value);
+}
+function coercePermissionMode(value) {
+  return isPermissionMode(value) ? value : "default";
+}
+function getModeState(currentModeId) {
+  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 current = coercePermissionMode(currentModeId);
+  return { currentModeId: current, availableModes };
+}
+
+// apps/server/src/acp/agent/sessionStore.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var ACP_SESSION_STORE_VERSION = 1;
+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 join2(getKodeBaseDir(), getProjectDirSlug(cwd), "acp-sessions");
+}
+function getAcpSessionFilePath(cwd, sessionId) {
+  return join2(getAcpSessionDir(cwd), `${sanitizeSessionId(sessionId)}.json`);
+}
+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;
+  }
+}
+
+// apps/server/src/acp/agent/notifications.ts
+function sendAvailableCommands(peer, session) {
+  const availableCommands = session.commands.filter((c) => !c.isHidden).map((c) => ({
+    name: c.userFacingName(),
+    description: c.description,
+    ...c.argumentHint ? { input: { hint: c.argumentHint } } : {}
+  }));
+  peer.sendNotification("session/update", {
+    sessionId: session.sessionId,
+    update: {
+      sessionUpdate: "available_commands_update",
+      availableCommands
+    }
+  });
+}
+function sendCurrentMode(peer, session) {
+  peer.sendNotification("session/update", {
+    sessionId: session.sessionId,
+    update: {
+      sessionUpdate: "current_mode_update",
+      currentModeId: session.currentModeId
+    }
+  });
+}
+function sendUserMessageChunk(peer, sessionId, text) {
+  if (!text) return;
+  peer.sendNotification("session/update", {
+    sessionId,
+    update: {
+      sessionUpdate: "user_message_chunk",
+      content: { type: "text", text }
+    }
+  });
+}
+function sendAgentMessageChunk(peer, sessionId, text) {
+  if (!text) return;
+  peer.sendNotification("session/update", {
+    sessionId,
+    update: {
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text }
+    }
+  });
+}
+function sendAgentThoughtChunk(peer, sessionId, text) {
+  if (!text) return;
+  peer.sendNotification("session/update", {
+    sessionId,
+    update: {
+      sessionUpdate: "agent_thought_chunk",
+      content: { type: "text", text }
+    }
+  });
+}
+function sendToolCall(peer, sessionId, toolCall) {
+  peer.sendNotification("session/update", {
+    sessionId,
+    update: toolCall
+  });
+}
+function sendToolCallUpdate(peer, sessionId, update) {
+  peer.sendNotification("session/update", {
+    sessionId,
+    update: {
+      sessionUpdate: "tool_call_update",
+      ...update
+    }
+  });
+}
+
+// apps/server/src/acp/agent/content.ts
+function asJsonObject(value) {
+  if (!isRecord(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) {
+    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 = resource.uri;
+        const mimeType = resource.mimeType?.trim() || "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 = block.uri;
+        const name = block.name;
+        const title = block.title ?? "";
+        const description = 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 texts = [];
+  for (const block of msg.message.content) {
+    if (block.type === "text") texts.push(block.text);
+    if (block.type === "thinking") texts.push(block.thinking);
+  }
+  return texts.join("").trim();
+}
+function isTextBlockParam(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string";
+}
+function extractToolResults(msg) {
+  const content = msg.message.content;
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const block of content) {
+    if (block.type !== "tool_result") continue;
+    const toolUseId = block.tool_use_id;
+    const isError = Boolean(block.is_error);
+    const raw = block.content;
+    const text = typeof raw === "string" ? raw : Array.isArray(raw) ? raw.filter(isTextBlockParam).map((x) => x.text).join("") : "";
+    if (toolUseId) out.push({ toolUseId, isError, content: text });
+  }
+  return out;
+}
+
+// apps/server/src/acp/agent/toolCalls.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+var MAX_DIFF_FILE_BYTES = 512e3;
+var MAX_DIFF_TEXT_CHARS = 4e5;
+function readTextFileForDiff(filePath) {
+  try {
+    const stats = statSync(filePath);
+    if (!stats.isFile()) return null;
+    if (stats.size > MAX_DIFF_FILE_BYTES) return null;
+    return readFileSync2(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 captureFileSnapshotForTool(params) {
+  const { session, toolUseId, toolName, input } = params;
+  if (toolName !== "Write" && toolName !== "MultiEdit") return;
+  const filePath = isRecord(input) && typeof input.file_path === "string" ? input.file_path : "";
+  if (!filePath) return;
+  const absPath = isAbsolute(filePath) ? filePath : resolve(session.cwd, filePath);
+  const oldContent = existsSync2(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 }
+  });
+}
+function getJsonStringMaybe(obj, key) {
+  const value = obj?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function buildDiffContentForToolResult(params) {
+  const { session, toolUseId, rawOutput } = params;
+  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 : getJsonStringMaybe(rawOutput, "filePath") ?? "";
+  if (!inputFilePath) return null;
+  const absPath = isAbsolute(inputFilePath) ? inputFilePath : resolve(session.cwd, inputFilePath);
+  const oldText = getJsonStringMaybe(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 = getJsonStringMaybe(rawOutput, "content");
+  const newText = newTextFromDisk ?? newTextFromOutput;
+  if (newText === null || newText === void 0) return null;
+  return {
+    type: "diff",
+    path: absPath,
+    oldText: truncateDiffText(oldText),
+    newText: truncateDiffText(newText)
+  };
+}
+
+// apps/server/src/acp/agent/kodeMessages.ts
+function toInputRecord(value) {
+  return isRecord(value) ? value : {};
+}
+function emitAssistantContentBlocks(peer, session, blocks) {
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        sendAgentMessageChunk(peer, session.sessionId, block.text);
+        break;
+      case "thinking":
+        sendAgentThoughtChunk(peer, session.sessionId, block.thinking);
+        break;
+      case "tool_use": {
+        const toolUseId = typeof block.id === "string" ? block.id : "";
+        const toolName = typeof block.name === "string" ? block.name : "";
+        if (!toolUseId || !toolName) break;
+        if (!session.toolCalls.has(toolUseId)) {
+          const input = toInputRecord(block.input);
+          const kind = toolKindForName(toolName);
+          const title = titleForToolCall(toolName, input);
+          session.toolCalls.set(toolUseId, {
+            title,
+            kind,
+            status: "pending",
+            rawInput: asJsonObject(input)
+          });
+          sendToolCall(peer, session.sessionId, {
+            sessionUpdate: "tool_call",
+            toolCallId: toolUseId,
+            title,
+            kind,
+            status: "pending",
+            rawInput: asJsonObject(input)
+          });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+async function handleKodeMessage(args) {
+  const { peer, session, message: m } = args;
+  if (!m || typeof m !== "object") return;
+  if (m.type === "assistant") {
+    session.messages.push(m);
+    emitAssistantContentBlocks(peer, session, m.message.content);
+    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
+      });
+      sendToolCallUpdate(peer, session.sessionId, {
+        toolCallId,
+        status: "in_progress"
+      });
+    }
+    const text = extractAssistantText(m.content);
+    if (text) {
+      sendToolCallUpdate(peer, 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
+        });
+        sendToolCallUpdate(peer, 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" ? buildDiffContentForToolResult({
+        session,
+        toolUseId: tr.toolUseId,
+        rawOutput
+      }) : null;
+      if (diffContent) content.push(diffContent);
+      if (tr.content) {
+        content.push({
+          type: "content",
+          content: { type: "text", text: tr.content }
+        });
+      }
+      sendToolCallUpdate(peer, session.sessionId, {
+        toolCallId: tr.toolUseId,
+        status,
+        ...content.length > 0 ? { content } : {},
+        ...rawOutput ? { rawOutput } : {}
+      });
+    }
+    session.messages.push(m);
+  }
+}
+function replayConversation(peer, session) {
+  session.toolCalls.clear();
+  for (const m of session.messages) {
+    if (!m || typeof m !== "object") continue;
+    if (m.type === "assistant") {
+      emitAssistantContentBlocks(peer, session, m.message.content);
+      continue;
+    }
+    if (m.type === "user") {
+      if (typeof m.message.content === "string" && m.message.content.trim()) {
+        sendUserMessageChunk(peer, session.sessionId, m.message.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"
+          });
+          sendToolCall(peer, session.sessionId, {
+            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);
+        sendToolCallUpdate(peer, session.sessionId, {
+          toolCallId: tr.toolUseId,
+          status,
+          ...contentBlocks.length > 0 ? { content: contentBlocks } : {},
+          ...rawOutput ? { rawOutput } : {}
+        });
+        session.toolCalls.set(tr.toolUseId, {
+          title,
+          kind,
+          status,
+          rawInput: existing?.rawInput
+        });
+      }
+    }
+  }
+}
+
+// apps/server/src/acp/agent/handlers/sessions.ts
+async function loadSessionDeps() {
+  const [tools, ctx, systemPrompt, configuredMcpClients] = await Promise.all([
+    getTools(),
+    getSessionContext(),
+    buildSystemPromptForSession({ disableSlashCommands: false }),
+    getClients().catch(() => [])
+  ]);
+  return {
+    commands: [],
+    tools,
+    context: ctx,
+    systemPrompt,
+    configuredMcpClients
+  };
+}
+async function handleSessionNew(args) {
+  const p = isRecord(args.params) ? args.params : {};
+  const cwd = typeof p.cwd === "string" ? p.cwd : "";
+  if (!cwd) {
+    throw new JsonRpcError(-32602, "Missing required param: cwd");
+  }
+  if (!isAbsolute2(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, context, systemPrompt, configuredMcpClients } = await loadSessionDeps();
+  const acpMcpClients = await connectAcpMcpServers(mcpServers);
+  const mcpClients = mergeMcpClients(configuredMcpClients, acpMcpClients);
+  const toolPermissionContext = loadToolPermissionContextFromDisk({
+    projectDir: cwd,
+    includeKodeProjectConfig: true,
+    isBypassPermissionsModeAvailable: true
+  });
+  const sessionId = `sess_${nanoid()}`;
+  const currentModeId = toolPermissionContext.mode;
+  const session = {
+    sessionId,
+    cwd,
+    mcpServers,
+    mcpClients,
+    commands,
+    tools,
+    systemPrompt,
+    context,
+    messages: [],
+    toolPermissionContext,
+    readFileTimestamps: {},
+    responseState: {},
+    currentModeId,
+    activeAbortController: null,
+    toolCalls: /* @__PURE__ */ new Map()
+  };
+  args.sessions.set(sessionId, session);
+  sendAvailableCommands(args.peer, session);
+  sendCurrentMode(args.peer, session);
+  persistAcpSessionToDisk(session);
+  return {
+    sessionId,
+    modes: getModeState(session.currentModeId)
+  };
+}
+async function handleSessionLoad(args) {
+  const p = isRecord(args.params) ? args.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 (!isAbsolute2(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, context, systemPrompt, configuredMcpClients } = await loadSessionDeps();
+  const acpMcpClients = await connectAcpMcpServers(mcpServers);
+  const mcpClients = mergeMcpClients(configuredMcpClients, acpMcpClients);
+  const toolPermissionContext = loadToolPermissionContextFromDisk({
+    projectDir: cwd,
+    includeKodeProjectConfig: true,
+    isBypassPermissionsModeAvailable: true
+  });
+  const currentModeId = coercePermissionMode(
+    typeof persisted.currentModeId === "string" && persisted.currentModeId ? persisted.currentModeId : toolPermissionContext.mode
+  );
+  toolPermissionContext.mode = currentModeId;
+  const session = {
+    sessionId,
+    cwd,
+    mcpServers,
+    mcpClients,
+    commands,
+    tools,
+    systemPrompt,
+    context,
+    messages: Array.isArray(persisted.messages) ? persisted.messages : [],
+    toolPermissionContext,
+    readFileTimestamps: isRecord(persisted.readFileTimestamps) ? persisted.readFileTimestamps : {},
+    responseState: isRecord(persisted.responseState) ? persisted.responseState : {},
+    currentModeId,
+    activeAbortController: null,
+    toolCalls: /* @__PURE__ */ new Map()
+  };
+  args.sessions.set(sessionId, session);
+  sendAvailableCommands(args.peer, session);
+  sendCurrentMode(args.peer, session);
+  replayConversation(args.peer, session);
+  return { modes: getModeState(session.currentModeId) };
+}
+async function handleSessionSetMode(args) {
+  const p = isRecord(args.params) ? args.params : {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : "";
+  const modeId = typeof p.modeId === "string" ? p.modeId : "";
+  const session = args.sessions.get(sessionId);
+  if (!session)
+    throw new JsonRpcError(-32602, `Session not found: ${sessionId}`);
+  const allowed = new Set(
+    getModeState(session.currentModeId).availableModes.map((m) => m.id)
+  );
+  if (!allowed.has(modeId)) {
+    throw new JsonRpcError(-32602, `Unknown modeId: ${modeId}`);
+  }
+  const nextMode = coercePermissionMode(modeId);
+  session.currentModeId = nextMode;
+  session.toolPermissionContext.mode = nextMode;
+  sendCurrentMode(args.peer, session);
+  persistAcpSessionToDisk(session);
+  return {};
+}
+async function handleSessionCancel(args) {
+  const p = isRecord(args.params) ? args.params : {};
+  const sessionId = typeof p.sessionId === "string" ? p.sessionId : "";
+  const session = args.sessions.get(sessionId);
+  if (!session) return;
+  session.activeAbortController?.abort();
+}
+
+// apps/server/src/acp/agent/handlers/prompt.ts
+import { isAbsolute as isAbsolute3 } from "node:path";
+
+// apps/server/src/acp/agent/permissions.ts
+import { nanoid as nanoid2 } from "nanoid";
+function getPermissionTimeoutMs() {
+  const raw = process.env.KODE_ACP_PERMISSION_TIMEOUT_MS;
+  const parsed = raw ? Number(raw) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
+}
+function toPermissionOptions(denied) {
+  const options = [
+    { optionId: "allow_once", name: "Allow once", kind: "allow_once" },
+    { optionId: "reject_once", name: "Reject", kind: "reject_once" }
+  ];
+  if ((denied.suggestions ?? []).length > 0) {
+    options.splice(1, 0, {
+      optionId: "allow_always",
+      name: "Allow always (remember)",
+      kind: "allow_always"
+    });
+  }
+  return options;
+}
+function createAcpCanUseTool(args) {
+  const timeoutMs = getPermissionTimeoutMs();
+  const { peer, session } = args;
+  return async (tool, input, toolUseContext, assistantMessage) => {
+    const toolUseId = typeof toolUseContext.toolUseId === "string" && toolUseContext.toolUseId ? toolUseContext.toolUseId : `call_${nanoid2()}`;
+    const base = await hasPermissionsToUseTool(
+      tool,
+      input,
+      toolUseContext,
+      assistantMessage
+    );
+    if (base.result === true) {
+      captureFileSnapshotForTool({
+        session,
+        toolUseId,
+        toolName: 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)
+      });
+      sendToolCall(peer, session.sessionId, {
+        sessionUpdate: "tool_call",
+        toolCallId: toolUseId,
+        title,
+        kind,
+        status: "pending",
+        rawInput: asJsonObject(input)
+      });
+    }
+    const options = toPermissionOptions(denied);
+    try {
+      const response = await 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") {
+        captureFileSnapshotForTool({
+          session,
+          toolUseId,
+          toolName: tool.name,
+          input
+        });
+        return { result: true };
+      }
+      if (outcome.outcome === "selected" && outcome.optionId === "allow_always") {
+        const 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);
+            }
+          }
+        }
+        captureFileSnapshotForTool({
+          session,
+          toolUseId,
+          toolName: tool.name,
+          input
+        });
+        return { result: true };
+      }
+      sendToolCallUpdate(peer, session.sessionId, {
+        toolCallId: toolUseId,
+        status: "failed"
+      });
+      return { result: false, message: denied.message };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      sendToolCallUpdate(peer, session.sessionId, {
+        toolCallId: toolUseId,
+        status: "failed"
+      });
+      return {
+        result: false,
+        message: `Permission prompt failed: ${msg}`,
+        shouldPromptUser: false
+      };
+    }
+  };
+}
+
+// apps/server/src/acp/agent/handlers/prompt.ts
+async function handleSessionPrompt(args) {
+  const p = isRecord(args.params) ? args.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 = args.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}`
+    );
+  }
+  if (!session.cwd || !isAbsolute3(session.cwd)) {
+    throw new JsonRpcError(-32602, `Invalid session cwd: ${session.cwd}`);
+  }
+  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 handleKodeMessage({
+      peer: args.peer,
+      session,
+      message: createAssistantMessage(promptText)
+    });
+    persistAcpSessionToDisk(session);
+    return { stopReason: "end_turn" };
+  }
+  const abortController = new AbortController();
+  session.activeAbortController = abortController;
+  const canUseTool = createAcpCanUseTool({ peer: args.peer, 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 runTurn({
+      messages: baseMessages,
+      systemPrompt: session.systemPrompt,
+      context: session.context,
+      canUseTool,
+      toolUseContext: {
+        options,
+        abortController,
+        messageId: void 0,
+        readFileTimestamps: session.readFileTimestamps,
+        setToolJSX: () => {
+        },
+        agentId: "main",
+        responseState: session.responseState
+      }
+    })) {
+      if (abortController.signal.aborted) stopReason = "cancelled";
+      await handleKodeMessage({ peer: args.peer, session, message: 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);
+      sendAgentMessageChunk(args.peer, session.sessionId, msg);
+      stopReason = "end_turn";
+    }
+  } finally {
+    session.activeAbortController = null;
+    persistAcpSessionToDisk(session);
+  }
+  return { stopReason };
+}
+
+// apps/server/src/acp/kodeAcpAgent.ts
+var KodeAcpAgent = class {
+  constructor(peer) {
+    this.peer = peer;
+    this.registerMethods();
+  }
+  clientCapabilities = {};
+  sessions = /* @__PURE__ */ new Map();
+  registerMethods() {
+    this.peer.registerMethod("initialize", this.onInitialize.bind(this));
+    this.peer.registerMethod("authenticate", this.onAuthenticate.bind(this));
+    this.peer.registerMethod("session/new", this.onSessionNew.bind(this));
+    this.peer.registerMethod("session/load", this.onSessionLoad.bind(this));
+    this.peer.registerMethod("session/prompt", this.onSessionPrompt.bind(this));
+    this.peer.registerMethod(
+      "session/set_mode",
+      this.onSessionSetMode.bind(this)
+    );
+    this.peer.registerMethod("session/cancel", this.onSessionCancel.bind(this));
+  }
+  onInitialize(params) {
+    return handleInitialize({
+      params,
+      setClientCapabilities: (caps) => {
+        this.clientCapabilities = caps;
+      }
+    });
+  }
+  onAuthenticate() {
+    return handleAuthenticate();
+  }
+  onSessionNew(params) {
+    return handleSessionNew({
+      peer: this.peer,
+      sessions: this.sessions,
+      params
+    });
+  }
+  onSessionLoad(params) {
+    return handleSessionLoad({
+      peer: this.peer,
+      sessions: this.sessions,
+      params
+    });
+  }
+  onSessionSetMode(params) {
+    return handleSessionSetMode({
+      peer: this.peer,
+      sessions: this.sessions,
+      params
+    });
+  }
+  onSessionCancel(params) {
+    return handleSessionCancel({ sessions: this.sessions, params });
+  }
+  onSessionPrompt(params) {
+    return handleSessionPrompt({
+      peer: this.peer,
+      sessions: this.sessions,
+      params
+    });
+  }
+};
+
+// apps/server/src/acp/runAcpStdio.ts
+function runAcpStdio() {
+  const { writeAcpLine } = installStdoutGuard();
+  initDebugLogger();
+  try {
+    enableConfigs();
+  } catch (error) {
+    logError(error);
+  }
+  const peer = new JsonRpcPeer();
+  new KodeAcpAgent(peer);
+  const transport = new StdioTransport(peer, { writeLine: writeAcpLine });
+  transport.start();
+}
+
+// apps/server/src/index.ts
+ensurePackagedRuntimeEnv();
+if (process.argv.includes("--acp")) {
+  runAcpStdio();
+} else {
+  let getArgValue = function(flag) {
+    const idx = process.argv.indexOf(flag);
+    if (idx >= 0) {
+      const v = process.argv[idx + 1];
+      if (typeof v === "string") return v;
+    }
+    const withEq = process.argv.find((a) => a.startsWith(flag + "="));
+    if (withEq) return withEq.slice(flag.length + 1);
+    return null;
+  };
+  initDebugLogger();
+  try {
+    enableConfigs();
+  } catch (e) {
+    logError(e);
+  }
+  const host = getArgValue("--host") ?? process.env.KODE_DAEMON_HOST ?? "127.0.0.1";
+  const portRaw = getArgValue("--port") ?? process.env.KODE_DAEMON_PORT ?? "";
+  const port = portRaw ? Number(portRaw) : 0;
+  const cwd = getArgValue("--cwd") ?? process.env.KODE_DAEMON_CWD ?? processCwd();
+  const token = getArgValue("--token") ?? process.env.KODE_DAEMON_TOKEN ?? void 0;
+  const echo = process.argv.includes("--echo") || process.env.KODE_DAEMON_ECHO === "1";
+  const daemon = await startKodeDaemon({
+    host,
+    port: Number.isFinite(port) ? port : 0,
+    cwd,
+    token,
+    echo
+  });
+  console.log(daemon.url);
+  process.on("SIGINT", () => {
+    daemon.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    daemon.stop();
+    process.exit(0);
+  });
+}