@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/chunk-3JDNWX7W.js

@@ -0,0 +1,1264 @@
+import {
+  loadKodeAgentSessionMessages
+} from "./chunk-TNGVRTO5.js";
+import {
+  listKodeAgentSessions
+} from "./chunk-HJYOH4HC.js";
+import {
+  isUuid
+} from "./chunk-UNOY3VJ2.js";
+import {
+  buildSystemPromptForSession,
+  getSessionContext,
+  runTurn
+} from "./chunk-4A46ZXMJ.js";
+import {
+  getTotalCost
+} from "./chunk-6BAS4WY6.js";
+import {
+  getTools
+} from "./chunk-77XDJMBP.js";
+import {
+  grantReadPermissionForOriginalDir,
+  hasPermissionsToUseTool,
+  savePermission
+} from "./chunk-PPHLQVL7.js";
+import {
+  loadToolPermissionContextFromDisk
+} from "./chunk-2JN5MY67.js";
+import {
+  kodeMessageToSdkMessage,
+  makeSdkInitMessage,
+  makeSdkResultMessage
+} from "./chunk-CDGRYGPZ.js";
+import {
+  setKodeAgentSessionId
+} from "./chunk-SWQV4KSY.js";
+import {
+  REJECT_MESSAGE,
+  REJECT_MESSAGE_WITH_FEEDBACK_PREFIX,
+  createAssistantMessage,
+  createUserMessage
+} from "./chunk-HRJ3ICQK.js";
+import {
+  setCwd,
+  setOriginalCwd
+} from "./chunk-BBJFHTBC.js";
+
+// apps/server/src/server.ts
+import { dirname, resolve as resolve4 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// apps/server/src/server/serveNode.ts
+import {
+  createServer
+} from "node:http";
+import { WebSocketServer } from "ws";
+async function readRequestBody(req) {
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") return void 0;
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) return void 0;
+  const buf = Buffer.concat(chunks);
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+async function toFetchRequest(req, hostname) {
+  const base = `http://${req.headers.host ?? hostname}`;
+  const url = new URL(req.url ?? "/", base);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (typeof value === "string") headers.set(key, value);
+    else if (Array.isArray(value)) headers.set(key, value.join(", "));
+  }
+  const body = await readRequestBody(req);
+  return new Request(url.toString(), {
+    method: req.method ?? "GET",
+    headers,
+    ...body ? { body } : {}
+  });
+}
+async function sendFetchResponse(res, response) {
+  res.statusCode = response.status;
+  for (const [key, value] of response.headers.entries()) {
+    try {
+      res.setHeader(key, value);
+    } catch {
+    }
+  }
+  if (!response.body || res.req?.method === "HEAD") {
+    res.end();
+    return;
+  }
+  const buf = Buffer.from(await response.arrayBuffer());
+  res.setHeader("content-length", String(buf.length));
+  res.end(buf);
+}
+async function sendFetchResponseToSocket(socket, response) {
+  const headers = [];
+  for (const [key, value] of response.headers.entries()) {
+    headers.push(`${key}: ${value}`);
+  }
+  if (!response.headers.has("connection")) headers.push("connection: close");
+  const body = response.body ? Buffer.from(await response.arrayBuffer()) : Buffer.alloc(0);
+  headers.push(`content-length: ${body.length}`);
+  const statusText = response.statusText || "OK";
+  socket.write(`HTTP/1.1 ${response.status} ${statusText}\r
+`);
+  socket.write(headers.join("\r\n"));
+  socket.write("\r\n\r\n");
+  if (body.length) socket.write(body);
+  socket.destroy();
+}
+async function serveNode(options) {
+  const wss = new WebSocketServer({ noServer: true });
+  const httpServer = createServer(async (req, res) => {
+    const request = await toFetchRequest(req, options.hostname);
+    const response = await options.fetch(request, { upgrade: () => false });
+    if (!response) {
+      res.statusCode = 500;
+      res.end("No response");
+      return;
+    }
+    await sendFetchResponse(res, response);
+  });
+  httpServer.on("upgrade", async (req, socket, head) => {
+    const request = await toFetchRequest(req, options.hostname);
+    let upgraded = false;
+    const response = await options.fetch(request, {
+      upgrade: (_request, upgradeOptions) => {
+        if (upgraded) return true;
+        upgraded = true;
+        try {
+          wss.handleUpgrade(req, socket, head, (ws) => {
+            const wsWithData = Object.assign(ws, { data: upgradeOptions.data });
+            try {
+              options.websocket.open(wsWithData);
+            } catch {
+            }
+            ws.on("message", (message) => {
+              Promise.resolve(
+                options.websocket.message(wsWithData, message)
+              ).catch(() => {
+              });
+            });
+            ws.on("close", () => {
+              try {
+                options.websocket.close(wsWithData);
+              } catch {
+              }
+            });
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+    if (upgraded) return;
+    if (response) {
+      await sendFetchResponseToSocket(socket, response);
+      return;
+    }
+    socket.destroy();
+  });
+  await new Promise((resolve5, reject) => {
+    const onError = (err) => {
+      reject(err);
+    };
+    httpServer.once("error", onError);
+    httpServer.listen(options.port, options.hostname, () => {
+      httpServer.removeListener("error", onError);
+      resolve5();
+    });
+  });
+  const address = httpServer.address();
+  const actualPort = typeof address === "object" && address && typeof address.port === "number" ? address.port : options.port;
+  const stop = () => {
+    try {
+      wss.clients.forEach((ws) => {
+        try {
+          ws.close();
+        } catch {
+        }
+      });
+    } catch {
+    }
+    try {
+      wss.close();
+    } catch {
+    }
+    try {
+      httpServer.close();
+    } catch {
+    }
+  };
+  return { port: actualPort, stop };
+}
+
+// apps/server/src/server/auth.ts
+import { timingSafeEqual } from "node:crypto";
+function timingSafeEquals(a, b) {
+  try {
+    const aBuf = Buffer.from(a, "utf8");
+    const bBuf = Buffer.from(b, "utf8");
+    if (aBuf.length !== bBuf.length) return false;
+    return timingSafeEqual(aBuf, bBuf);
+  } catch {
+    return false;
+  }
+}
+function getCookieValue(cookieHeader, name) {
+  if (!cookieHeader) return null;
+  const parts = cookieHeader.split(";");
+  for (const part of parts) {
+    const [k, ...rest] = part.trim().split("=");
+    if (!k) continue;
+    if (k === name) {
+      const value = rest.join("=");
+      if (!value) return "";
+      try {
+        return decodeURIComponent(value);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function createTokenChecker(args) {
+  const token = args.token;
+  return (req) => {
+    const url = new URL(req.url);
+    const qp = url.searchParams.get("token");
+    if (qp && timingSafeEquals(qp, token)) return true;
+    const header = req.headers.get("authorization");
+    if (header && header.startsWith("Bearer ")) {
+      const h = header.slice("Bearer ".length).trim();
+      if (h && timingSafeEquals(h, token)) return true;
+    }
+    const cookieToken = getCookieValue(req.headers.get("cookie"), "kode_token");
+    if (cookieToken && timingSafeEquals(cookieToken, token)) return true;
+    return false;
+  };
+}
+
+// apps/server/src/server/webui.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, sep } from "node:path";
+function detectWebuiDir(moduleDir) {
+  const candidates = [
+    // Packaged: dist/* → dist/webui (compiled chunks may live in dist/, dist/entrypoints/, dist/chunks/, etc.)
+    resolve(moduleDir, "webui"),
+    resolve(moduleDir, "..", "webui"),
+    resolve(moduleDir, "..", "..", "webui")
+  ];
+  for (let up = 0; up <= 6; up++) {
+    const parents = Array(up).fill("..");
+    candidates.push(resolve(moduleDir, ...parents, "apps", "server", "static"));
+    candidates.push(resolve(moduleDir, ...parents, "ui", "web", "dist"));
+    candidates.push(resolve(moduleDir, ...parents, "ui", "web"));
+    candidates.push(resolve(moduleDir, ...parents, "dist", "webui"));
+  }
+  for (const candidate of candidates) {
+    try {
+      if (existsSync(resolve(candidate, "index.html"))) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function contentTypeForPath(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return ext === "html" ? "text/html; charset=utf-8" : ext === "js" ? "text/javascript; charset=utf-8" : ext === "css" ? "text/css; charset=utf-8" : ext === "svg" ? "image/svg+xml" : ext === "json" ? "application/json; charset=utf-8" : ext === "png" ? "image/png" : ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "application/octet-stream";
+}
+function maybeServeWebui(args) {
+  const webuiRoot = resolve(args.webuiRoot);
+  const pathname = args.url.pathname;
+  const requested = pathname === "/" ? "/index.html" : pathname;
+  const rel = requested.startsWith("/") ? requested.slice(1) : requested;
+  const filePath = resolve(webuiRoot, rel);
+  if (!(filePath === webuiRoot || filePath.startsWith(webuiRoot + sep))) {
+    return null;
+  }
+  if (!existsSync(filePath)) return null;
+  const file = readFileSync(filePath);
+  return new Response(file, {
+    headers: {
+      "content-type": contentTypeForPath(filePath),
+      "cache-control": "no-cache"
+    }
+  });
+}
+
+// apps/server/src/handlers/workspaces.handler.ts
+import { spawn } from "node:child_process";
+import { basename, resolve as resolve2 } from "node:path";
+function parseWorktreePorcelain(stdout) {
+  const entries = [];
+  let current = null;
+  const lines = stdout.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) {
+      if (current?.path) entries.push(current);
+      current = null;
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      if (current?.path) entries.push(current);
+      current = { path: line.slice("worktree ".length).trim(), branch: null };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("branch ")) {
+      const ref = line.slice("branch ".length).trim();
+      const branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+      current.branch = branch || null;
+    }
+  }
+  if (current?.path) entries.push(current);
+  return entries;
+}
+async function execArgs(cmd, options) {
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  const abortController = new AbortController();
+  let wasAborted = false;
+  let proc = null;
+  const onAbort = () => {
+    wasAborted = true;
+    try {
+      abortController.abort();
+    } catch {
+    }
+    try {
+      proc?.kill();
+    } catch {
+    }
+  };
+  if (options.abortSignal) {
+    options.abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    proc = spawn(cmd[0] ?? "", cmd.slice(1), {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env ?? {} },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    proc.stderr?.setEncoding("utf8");
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const exitPromise = new Promise((resolve5) => {
+      proc?.once("exit", (code2) => resolve5({ kind: "exit", code: code2 }));
+      proc?.once("error", (error) => resolve5({ kind: "error", error }));
+    });
+    let timeoutHandle = null;
+    const timeoutPromise = new Promise((resolveTimeout) => {
+      timeoutHandle = setTimeout(() => resolveTimeout("timeout"), timeoutMs);
+    });
+    const outcome = await Promise.race([
+      exitPromise.then(() => "completed"),
+      timeoutPromise
+    ]);
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+    if (outcome === "timeout") {
+      onAbort();
+      try {
+        await exitPromise;
+      } catch {
+      }
+      return {
+        stdout: "",
+        stderr: "Command timed out",
+        code: 143,
+        interrupted: true
+      };
+    }
+    const exitOutcome = await exitPromise;
+    if (exitOutcome.kind === "error") {
+      stderr = [stderr, exitOutcome.error.message].filter(Boolean).join("\n");
+    }
+    const interrupted = wasAborted || options.abortSignal?.aborted === true || abortController.signal.aborted === true;
+    const code = exitOutcome.kind === "exit" && typeof exitOutcome.code === "number" ? exitOutcome.code : exitOutcome.kind === "error" ? 2 : interrupted ? 143 : 0;
+    return { stdout, stderr, code, interrupted };
+  } finally {
+    if (options.abortSignal) {
+      options.abortSignal.removeEventListener("abort", onAbort);
+    }
+  }
+}
+function createWorkspaceLister(args) {
+  const workspaceCacheTtlMs = args.cacheTtlMs ?? 2e3;
+  let workspaceCache = null;
+  const listWorkspaces = async () => {
+    const now = Date.now();
+    if (workspaceCache && now - workspaceCache.at < workspaceCacheTtlMs) {
+      return {
+        workspaces: workspaceCache.workspaces,
+        currentId: workspaceCache.currentId
+      };
+    }
+    const absCwd = resolve2(args.cwd);
+    const repoRootRes = await execArgs(
+      ["git", "rev-parse", "--show-toplevel"],
+      {
+        cwd: absCwd,
+        timeoutMs: 2e3
+      }
+    );
+    const repoRoot = repoRootRes.code === 0 ? repoRootRes.stdout.trim() : "";
+    if (!repoRoot) {
+      const only = {
+        id: absCwd,
+        path: absCwd,
+        title: basename(absCwd) || absCwd,
+        branch: null,
+        isCurrent: true
+      };
+      workspaceCache = { at: now, workspaces: [only], currentId: only.id };
+      return { workspaces: [only], currentId: only.id };
+    }
+    const porcelainRes = await execArgs(
+      ["git", "worktree", "list", "--porcelain"],
+      { cwd: repoRoot, timeoutMs: 3e3 }
+    );
+    const worktreeEntries = porcelainRes.code === 0 ? parseWorktreePorcelain(porcelainRes.stdout) : [];
+    const normalized = worktreeEntries.map((e) => ({
+      path: resolve2(e.path),
+      branch: e.branch
+    })).filter((e) => e.path);
+    const currentRoot = resolve2(repoRoot);
+    const unique = /* @__PURE__ */ new Map();
+    for (const e of normalized) {
+      unique.set(e.path, {
+        id: e.path,
+        path: e.path,
+        title: e.branch || basename(e.path) || e.path,
+        branch: e.branch,
+        isCurrent: e.path === currentRoot
+      });
+    }
+    if (!unique.has(currentRoot)) {
+      unique.set(currentRoot, {
+        id: currentRoot,
+        path: currentRoot,
+        title: basename(currentRoot) || currentRoot,
+        branch: null,
+        isCurrent: true
+      });
+    }
+    const workspaces = Array.from(unique.values()).sort((a, b) => {
+      if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
+      return a.title.localeCompare(b.title);
+    });
+    const currentId = workspaces.find((w) => w.isCurrent)?.id ?? workspaces[0]?.id ?? currentRoot;
+    workspaceCache = { at: now, workspaces, currentId };
+    return { workspaces, currentId };
+  };
+  return { listWorkspaces };
+}
+
+// apps/server/src/routes/index.ts
+import { basename as basename2, resolve as resolve3 } from "node:path";
+
+// apps/server/src/handlers/chat.handler.ts
+function extractFirstAssistantText(message) {
+  const blocks = Array.isArray(message.content) ? message.content : [];
+  for (const block of blocks) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const maybeText = block.text;
+      if (typeof maybeText === "string") return maybeText;
+    }
+  }
+  return null;
+}
+async function getToolDescription(tool, input) {
+  if (typeof tool.description === "function") {
+    return await tool.description(input);
+  }
+  if (typeof tool.description === "string") return tool.description;
+  return `Tool: ${tool.name}`;
+}
+async function handleChatPrompt(args) {
+  const {
+    wsSend,
+    session,
+    prompt,
+    echo,
+    commands,
+    tools,
+    toolNames,
+    slashCommands
+  } = args;
+  setOriginalCwd(session.cwd);
+  await setCwd(session.cwd);
+  grantReadPermissionForOriginalDir();
+  setKodeAgentSessionId(session.sessionId);
+  const abortController = new AbortController();
+  session.activeAbortController = abortController;
+  const startedAt = Date.now();
+  const costBefore = getTotalCost();
+  const userMsg = createUserMessage(prompt);
+  session.messages.push(userMsg);
+  const sdkUser = kodeMessageToSdkMessage(userMsg, session.sessionId);
+  if (sdkUser) wsSend(sdkUser);
+  if (echo) {
+    const assistant = createAssistantMessage(prompt);
+    session.messages.push(assistant);
+    const sdkAssistant = kodeMessageToSdkMessage(assistant, session.sessionId);
+    if (sdkAssistant) wsSend(sdkAssistant);
+    wsSend(
+      makeSdkResultMessage({
+        sessionId: session.sessionId,
+        result: prompt,
+        numTurns: 1,
+        usage: void 0,
+        totalCostUsd: 0,
+        durationMs: Date.now() - startedAt,
+        durationApiMs: 0,
+        isError: false
+      })
+    );
+    session.activeAbortController = null;
+    return;
+  }
+  const requestToolPermission = async (params) => {
+    const base = await hasPermissionsToUseTool(
+      params.tool,
+      params.input,
+      params.toolUseContext,
+      params.assistantMessage
+    );
+    if (base.result === true) return { result: true };
+    if (base.shouldPromptUser === false) {
+      return {
+        result: false,
+        message: base.message,
+        shouldPromptUser: false
+      };
+    }
+    if (params.toolUseContext.abortController.signal.aborted) {
+      return {
+        result: false,
+        message: REJECT_MESSAGE,
+        shouldPromptUser: false
+      };
+    }
+    const requestId = typeof params.toolUseContext.toolUseId === "string" && params.toolUseContext.toolUseId ? params.toolUseContext.toolUseId : crypto.randomUUID();
+    const toolDescription = await getToolDescription(params.tool, params.input);
+    const request = {
+      type: "permission_request",
+      request_id: requestId,
+      tool_name: params.tool.name,
+      tool_description: toolDescription,
+      input: params.input
+    };
+    wsSend(request);
+    const decision = await new Promise((resolve5) => {
+      session.inflightPermissionRequests.set(requestId, resolve5);
+    });
+    if (params.toolUseContext.abortController.signal.aborted) {
+      return {
+        result: false,
+        message: REJECT_MESSAGE,
+        shouldPromptUser: false
+      };
+    }
+    if (decision.updatedInput && typeof decision.updatedInput === "object") {
+      Object.assign(params.input, decision.updatedInput);
+    }
+    if (decision.decision === "deny") {
+      try {
+        params.toolUseContext.abortController.abort();
+      } catch {
+      }
+      const message = decision.rejectionMessage && decision.rejectionMessage.trim() ? `${REJECT_MESSAGE_WITH_FEEDBACK_PREFIX}${decision.rejectionMessage.trim()}` : REJECT_MESSAGE;
+      return { result: false, message, shouldPromptUser: false };
+    }
+    if (decision.decision === "allow_always") {
+      try {
+        await savePermission(
+          params.tool,
+          params.input,
+          null,
+          params.toolUseContext
+        );
+      } catch {
+      }
+    }
+    return { result: true };
+  };
+  const canUseTool = async (tool, input, toolUseContext, assistantMessage) => {
+    return await requestToolPermission({
+      tool,
+      input,
+      toolUseContext,
+      assistantMessage
+    });
+  };
+  const [context, systemPrompt] = await Promise.all([
+    getSessionContext(),
+    buildSystemPromptForSession({ disableSlashCommands: false })
+  ]);
+  const options = {
+    commands,
+    tools,
+    verbose: true,
+    safeMode: false,
+    forkNumber: 0,
+    messageLogName: session.sessionId,
+    maxThinkingTokens: 0,
+    persistSession: true,
+    toolPermissionContext: session.toolPermissionContext,
+    mcpClients: [],
+    shouldAvoidPermissionPrompts: false
+  };
+  let lastAssistant = null;
+  let queryError = null;
+  try {
+    const baseMessages = [...session.messages];
+    for await (const m of runTurn({
+      messages: baseMessages,
+      systemPrompt,
+      context,
+      canUseTool,
+      toolUseContext: {
+        options,
+        abortController,
+        messageId: void 0,
+        readFileTimestamps: session.readFileTimestamps,
+        setToolJSX: () => {
+        },
+        agentId: "main",
+        responseState: session.responseState
+      }
+    })) {
+      if (abortController.signal.aborted) break;
+      if (m.type === "assistant") lastAssistant = m;
+      if (m.type !== "progress") {
+        session.messages.push(m);
+      }
+      const sdk = kodeMessageToSdkMessage(m, session.sessionId);
+      if (sdk) wsSend(sdk);
+    }
+  } catch (err) {
+    queryError = err;
+    try {
+      abortController.abort();
+    } catch {
+    }
+  } finally {
+    session.activeAbortController = null;
+  }
+  const resultFromAssistant = lastAssistant ? extractFirstAssistantText(lastAssistant.message) : null;
+  const resultText = typeof resultFromAssistant === "string" ? resultFromAssistant : queryError instanceof Error ? queryError.message : queryError ? String(queryError) : "";
+  const usage = lastAssistant?.message?.usage;
+  const durationMs = Date.now() - startedAt;
+  const totalCostUsd = Math.max(0, getTotalCost() - costBefore);
+  const isError = Boolean(queryError) || abortController.signal.aborted;
+  wsSend(
+    makeSdkResultMessage({
+      sessionId: session.sessionId,
+      result: String(resultText),
+      numTurns: 1,
+      usage,
+      totalCostUsd,
+      durationMs,
+      durationApiMs: 0,
+      isError
+    })
+  );
+}
+
+// apps/server/src/handlers/session.handler.ts
+function loadSessionMessages(args) {
+  return loadKodeAgentSessionMessages(args);
+}
+function buildSessionList(args) {
+  return listKodeAgentSessions({ cwd: args.cwd }).map((s) => ({
+    sessionId: s.sessionId,
+    slug: s.slug,
+    customTitle: s.customTitle,
+    tag: s.tag,
+    summary: s.summary,
+    cwd: s.cwd,
+    createdAt: s.createdAt ? s.createdAt.toISOString() : null,
+    modifiedAt: s.modifiedAt ? s.modifiedAt.toISOString() : null
+  }));
+}
+function sendSessionList(ws, args) {
+  try {
+    const sessions = buildSessionList({ cwd: args.cwd });
+    ws.send(JSON.stringify({ type: "session_list", sessions }));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    args.onError?.(message);
+  }
+}
+
+// apps/server/src/ws/events.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toText(message) {
+  if (typeof message === "string") return message;
+  if (Array.isArray(message)) {
+    return message.map((part) => typeof part === "string" ? part : part.toString()).join("");
+  }
+  return message.toString();
+}
+function parseClientWsMessage(message) {
+  const text = toText(message);
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "Invalid JSON message" };
+  }
+  if (!isRecord(payload)) return { ok: false, error: "Invalid payload" };
+  const type = payload.type;
+  if (type === "cancel") return { ok: true, value: { type: "cancel" } };
+  if (type === "list_sessions")
+    return { ok: true, value: { type: "list_sessions" } };
+  if (type === "new_session")
+    return { ok: true, value: { type: "new_session" } };
+  if (type === "resume") {
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id.trim() : "";
+    if (!sessionId) return { ok: false, error: "Invalid session_id" };
+    return { ok: true, value: { type: "resume", sessionId } };
+  }
+  if (type === "prompt") {
+    const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
+    if (!prompt.trim()) return { ok: false, error: "Missing prompt" };
+    return { ok: true, value: { type: "prompt", prompt } };
+  }
+  if (type === "permission_response") {
+    const requestId = typeof payload.request_id === "string" ? payload.request_id : "";
+    const decision = payload.decision === "allow_once" || payload.decision === "allow_always" || payload.decision === "deny" ? payload.decision : null;
+    if (!requestId || !decision)
+      return { ok: false, error: "Invalid permission response" };
+    const updatedInput = isRecord(payload.updated_input) ? payload.updated_input : null;
+    const rejectionMessage = typeof payload.rejection_message === "string" ? payload.rejection_message : null;
+    return {
+      ok: true,
+      value: {
+        type: "permission_response",
+        requestId,
+        decision,
+        updatedInput,
+        rejectionMessage
+      }
+    };
+  }
+  return { ok: false, error: `Unsupported message type: ${String(type)}` };
+}
+function sendJson(ws, payload) {
+  ws.send(JSON.stringify(payload));
+}
+function log(level, message) {
+  return { type: "log", log: { level, message } };
+}
+
+// apps/server/src/routes/chat.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function sendJson2(ws, payload) {
+  ws.send(JSON.stringify(payload));
+}
+async function routeChat(req, ctx) {
+  const url = new URL(req.url);
+  if (url.pathname !== "/api/chat") return void 0;
+  if (req.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    body = null;
+  }
+  if (!isRecord2(body)) {
+    return Response.json(
+      { ok: false, error: "Invalid JSON body" },
+      { status: 400 }
+    );
+  }
+  const sessionId = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+  const prompt = typeof body.prompt === "string" ? body.prompt : "";
+  if (!sessionId) {
+    return Response.json(
+      { ok: false, error: "Missing sessionId" },
+      { status: 400 }
+    );
+  }
+  if (!prompt.trim()) {
+    return Response.json(
+      { ok: false, error: "Missing prompt" },
+      { status: 400 }
+    );
+  }
+  const session = ctx.sessions.get(sessionId);
+  if (!session) {
+    return Response.json(
+      { ok: false, error: "Unknown session" },
+      { status: 404 }
+    );
+  }
+  const ws = session.ws;
+  if (!ws) {
+    return Response.json(
+      { ok: false, error: "No active websocket connection for this session" },
+      { status: 409 }
+    );
+  }
+  if (session.activeAbortController) {
+    return Response.json(
+      { ok: false, error: "Session already has an active prompt" },
+      { status: 409 }
+    );
+  }
+  const wsSend = (payload) => {
+    try {
+      sendJson2(ws, payload);
+    } catch {
+    }
+  };
+  void (async () => {
+    try {
+      await handleChatPrompt({
+        wsSend,
+        session,
+        prompt,
+        echo: ctx.echo,
+        commands: ctx.commands,
+        tools: ctx.tools,
+        toolNames: ctx.toolNames,
+        slashCommands: ctx.slashCommands
+      });
+    } catch (err) {
+      wsSend(log("error", err instanceof Error ? err.message : String(err)));
+    } finally {
+      try {
+        sendSessionList(ws, {
+          cwd: session.cwd,
+          onError: (message) => wsSend(log("error", message))
+        });
+      } catch {
+      }
+    }
+  })();
+  return Response.json({ ok: true });
+}
+
+// apps/server/src/routes/session.ts
+async function routeSession(req, ctx) {
+  const url = new URL(req.url);
+  if (!url.pathname.startsWith("/api/sessions")) return void 0;
+  if (req.method !== "GET") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+  const pathParts = url.pathname.split("/").filter(Boolean);
+  const hasId = pathParts.length >= 3;
+  const requestedId = hasId ? pathParts[2] ?? "" : "";
+  if (!hasId) {
+    const sessions2 = buildSessionList({ cwd: ctx.cwd });
+    return Response.json({ sessions: sessions2 });
+  }
+  const sessionId = requestedId.trim();
+  if (!sessionId || !isUuid(sessionId)) {
+    return Response.json(
+      { ok: false, error: "Invalid session id" },
+      { status: 400 }
+    );
+  }
+  const sessions = buildSessionList({ cwd: ctx.cwd });
+  const base = sessions.find((s) => s.sessionId === sessionId) ?? {
+    sessionId,
+    slug: null,
+    customTitle: null,
+    tag: null,
+    summary: null,
+    cwd: ctx.cwd,
+    createdAt: null,
+    modifiedAt: null
+  };
+  const messages = loadSessionMessages({ cwd: ctx.cwd, sessionId });
+  const events = messages.map((m) => kodeMessageToSdkMessage(m, sessionId)).filter((e) => Boolean(e));
+  return Response.json({ ...base, events });
+}
+
+// apps/server/src/routes/index.ts
+function createRoutes(args) {
+  return {
+    async fetch(req, server) {
+      const url = new URL(req.url);
+      if (args.webuiRoot) {
+        const response = maybeServeWebui({ webuiRoot: args.webuiRoot, url });
+        if (response) return response;
+      }
+      if (url.pathname === "/health") {
+        return Response.json({
+          ok: true,
+          version: process.env.npm_package_version ?? null,
+          pid: process.pid
+        });
+      }
+      if (url.pathname === "/api/health") {
+        if (!args.checkToken(req))
+          return new Response("Unauthorized", { status: 401 });
+        return Response.json({ ok: true });
+      }
+      if (url.pathname.startsWith("/api/")) {
+        if (!args.checkToken(req))
+          return new Response("Unauthorized", { status: 401 });
+      }
+      if (url.pathname === "/api/workspaces") {
+        try {
+          const { workspaces, currentId } = await args.listWorkspaces();
+          return Response.json({ workspaces, currentId });
+        } catch (err) {
+          const only = resolve3(args.cwd);
+          return Response.json(
+            {
+              workspaces: [
+                {
+                  id: only,
+                  path: only,
+                  title: basename2(only) || only,
+                  branch: null,
+                  isCurrent: true
+                }
+              ],
+              currentId: only,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 200 }
+          );
+        }
+      }
+      const chatResponse = await routeChat(req, {
+        sessions: args.sessions,
+        echo: args.echo,
+        commands: args.commands,
+        tools: args.tools,
+        toolNames: args.toolNames,
+        slashCommands: args.slashCommands
+      });
+      if (chatResponse) return chatResponse;
+      const sessionResponse = await routeSession(req, { cwd: args.cwd });
+      if (sessionResponse) return sessionResponse;
+      if (url.pathname === "/ws") {
+        if (!args.checkToken(req))
+          return new Response("Unauthorized", { status: 401 });
+        const { workspaces, currentId } = await args.listWorkspaces();
+        const requested = url.searchParams.get("workspace");
+        const selected = requested && workspaces.some((w) => w.id === requested) ? requested : currentId;
+        const selectedCwd = workspaces.find((w) => w.id === selected)?.path ?? resolve3(args.cwd);
+        const sessionId = crypto.randomUUID();
+        const session = {
+          sessionId,
+          cwd: selectedCwd,
+          ws: null,
+          messages: [],
+          readFileTimestamps: {},
+          responseState: {},
+          toolPermissionContext: loadToolPermissionContextFromDisk({
+            projectDir: selectedCwd,
+            includeKodeProjectConfig: true,
+            isBypassPermissionsModeAvailable: true
+          }),
+          activeAbortController: null,
+          inflightPermissionRequests: /* @__PURE__ */ new Map()
+        };
+        args.sessions.set(sessionId, session);
+        const ok = server.upgrade(req, { data: { session } });
+        return ok ? void 0 : new Response("Upgrade failed", { status: 400 });
+      }
+      return new Response("Not found", { status: 404 });
+    }
+  };
+}
+
+// apps/server/src/ws/connection.ts
+function createWebSocketHandlers(args) {
+  return {
+    open(ws) {
+      const session = ws.data.session;
+      session.ws = ws;
+      sendJson(
+        ws,
+        makeSdkInitMessage({
+          sessionId: session.sessionId,
+          cwd: session.cwd,
+          tools: args.toolNames,
+          slashCommands: args.slashCommands
+        })
+      );
+      sendSessionList(ws, {
+        cwd: session.cwd,
+        onError: (message) => sendJson(ws, log("error", message))
+      });
+    },
+    async message(ws, message) {
+      const session = ws.data.session;
+      const parsed = parseClientWsMessage(message);
+      if (parsed.ok === false) {
+        sendJson(ws, log("error", parsed.error));
+        return;
+      }
+      const payload = parsed.value;
+      if (payload.type === "cancel") {
+        try {
+          session.activeAbortController?.abort();
+        } catch {
+        }
+        for (const resolve5 of session.inflightPermissionRequests.values()) {
+          try {
+            resolve5({
+              decision: "deny",
+              rejectionMessage: "Cancelled",
+              updatedInput: null
+            });
+          } catch {
+          }
+        }
+        session.inflightPermissionRequests.clear();
+        return;
+      }
+      if (payload.type === "permission_response") {
+        const resolve5 = session.inflightPermissionRequests.get(
+          payload.requestId
+        );
+        if (!resolve5) return;
+        session.inflightPermissionRequests.delete(payload.requestId);
+        try {
+          resolve5({
+            decision: payload.decision,
+            updatedInput: payload.updatedInput,
+            rejectionMessage: payload.rejectionMessage
+          });
+        } catch {
+        }
+        return;
+      }
+      if (payload.type === "list_sessions") {
+        sendSessionList(ws, {
+          cwd: session.cwd,
+          onError: (message2) => sendJson(ws, log("error", message2))
+        });
+        return;
+      }
+      if (payload.type === "new_session") {
+        try {
+          session.activeAbortController?.abort();
+        } catch {
+        }
+        for (const resolve5 of session.inflightPermissionRequests.values()) {
+          try {
+            resolve5({
+              decision: "deny",
+              rejectionMessage: "Cancelled",
+              updatedInput: null
+            });
+          } catch {
+          }
+        }
+        session.inflightPermissionRequests.clear();
+        session.messages = [];
+        session.readFileTimestamps = {};
+        session.responseState = {};
+        session.activeAbortController = null;
+        session.toolPermissionContext = loadToolPermissionContextFromDisk({
+          projectDir: session.cwd,
+          includeKodeProjectConfig: true,
+          isBypassPermissionsModeAvailable: true
+        });
+        const nextId = crypto.randomUUID();
+        args.sessions.delete(session.sessionId);
+        session.sessionId = nextId;
+        args.sessions.set(session.sessionId, session);
+        sendJson(
+          ws,
+          makeSdkInitMessage({
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            tools: args.toolNames,
+            slashCommands: args.slashCommands
+          })
+        );
+        sendSessionList(ws, {
+          cwd: session.cwd,
+          onError: (message2) => sendJson(ws, log("error", message2))
+        });
+        return;
+      }
+      if (payload.type === "resume") {
+        if (!isUuid(payload.sessionId)) {
+          sendJson(ws, log("error", "Invalid session_id"));
+          return;
+        }
+        try {
+          const loaded = loadSessionMessages({
+            cwd: session.cwd,
+            sessionId: payload.sessionId
+          });
+          session.messages = loaded;
+          session.readFileTimestamps = {};
+          session.responseState = {};
+          try {
+            session.activeAbortController?.abort();
+          } catch {
+          }
+          session.activeAbortController = null;
+          args.sessions.delete(session.sessionId);
+          session.sessionId = payload.sessionId;
+          args.sessions.set(session.sessionId, session);
+          sendJson(
+            ws,
+            makeSdkInitMessage({
+              sessionId: session.sessionId,
+              cwd: session.cwd,
+              tools: args.toolNames,
+              slashCommands: args.slashCommands
+            })
+          );
+          sendJson(ws, { type: "history_begin", sessionId: session.sessionId });
+          for (const m of loaded) {
+            const sdk = kodeMessageToSdkMessage(m, session.sessionId);
+            if (sdk) sendJson(ws, sdk);
+          }
+          sendJson(ws, { type: "history_end", sessionId: session.sessionId });
+          sendSessionList(ws, {
+            cwd: session.cwd,
+            onError: (message2) => sendJson(ws, log("error", message2))
+          });
+        } catch (err) {
+          sendJson(
+            ws,
+            log("error", err instanceof Error ? err.message : String(err))
+          );
+        }
+        return;
+      }
+      if (payload.type === "prompt") {
+        if (session.activeAbortController) {
+          sendJson(ws, log("error", "Session already has an active prompt"));
+          return;
+        }
+        const wsSend = (outgoing) => sendJson(ws, outgoing);
+        try {
+          await handleChatPrompt({
+            wsSend,
+            session,
+            prompt: payload.prompt,
+            echo: args.echo,
+            commands: args.commands,
+            tools: args.tools,
+            toolNames: args.toolNames,
+            slashCommands: args.slashCommands
+          });
+        } finally {
+          sendSessionList(ws, {
+            cwd: session.cwd,
+            onError: (message2) => sendJson(ws, log("error", message2))
+          });
+        }
+      }
+    },
+    close(ws) {
+      const session = ws.data.session;
+      session.ws = null;
+      try {
+        session.activeAbortController?.abort();
+      } catch {
+      }
+      for (const resolve5 of session.inflightPermissionRequests.values()) {
+        try {
+          resolve5({
+            decision: "deny",
+            rejectionMessage: "Disconnected",
+            updatedInput: null
+          });
+        } catch {
+        }
+      }
+      session.inflightPermissionRequests.clear();
+      args.sessions.delete(session.sessionId);
+    }
+  };
+}
+
+// apps/server/src/server.ts
+async function startKodeDaemon(args) {
+  const host = args.host ?? "127.0.0.1";
+  const port = args.port ?? 0;
+  const token = args.token ?? crypto.randomUUID().replace(/-/g, "").slice(0, 9);
+  const cwd = resolve4(args.cwd);
+  const echo = args.echo === true || process.env.KODE_DAEMON_ECHO === "1";
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const webuiDir = typeof args.webuiDir === "string" ? args.webuiDir : detectWebuiDir(moduleDir);
+  const webuiRoot = webuiDir ? resolve4(webuiDir) : null;
+  setOriginalCwd(cwd);
+  await setCwd(cwd);
+  grantReadPermissionForOriginalDir();
+  const tools = await getTools();
+  const toolNames = tools.map((t) => t.name);
+  const commands = [];
+  const slashCommands = [];
+  const sessions = /* @__PURE__ */ new Map();
+  const checkToken = createTokenChecker({ token });
+  const workspaces = createWorkspaceLister({ cwd });
+  const routes = createRoutes({
+    webuiRoot,
+    checkToken,
+    listWorkspaces: workspaces.listWorkspaces,
+    sessions,
+    cwd,
+    echo,
+    commands,
+    tools,
+    toolNames,
+    slashCommands
+  });
+  const websocket = createWebSocketHandlers({
+    sessions,
+    toolNames,
+    slashCommands,
+    commands,
+    tools,
+    echo
+  });
+  const server = await serveNode({
+    hostname: host,
+    port,
+    fetch: routes.fetch,
+    websocket
+  });
+  const displayHost = host === "127.0.0.1" ? "localhost" : host;
+  return {
+    url: `http://${displayHost}:${server.port}?token=${encodeURIComponent(token)}`,
+    host,
+    port: server.port,
+    token,
+    stop: () => {
+      try {
+        server.stop(true);
+      } catch {
+      }
+    }
+  };
+}
+
+export {
+  startKodeDaemon
+};