@serendb/serendesktop 0.1.0

package/dist/server.js

@@ -0,0 +1,2598 @@
+// src/server.ts
+import { randomBytes as randomBytes3, createHash as createHash3 } from "crypto";
+import { exec as exec2 } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { createServer as createServer2 } from "http";
+import { request as httpsRequest } from "https";
+import { homedir as homedir5, platform as platform3 } from "os";
+import { join as join7, extname as extname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { WebSocketServer } from "ws";
+
+// src/events.ts
+var subscribers = /* @__PURE__ */ new Map();
+var authenticatedClients = /* @__PURE__ */ new Set();
+function addClient(ws) {
+  authenticatedClients.add(ws);
+  ws.on("close", () => authenticatedClients.delete(ws));
+}
+function emit(event, params) {
+  const localSubs = subscribers.get(event);
+  if (localSubs) {
+    for (const cb of localSubs) {
+      try {
+        cb(params);
+      } catch (err) {
+        console.error(`[Events] Local subscriber error for ${event}:`, err);
+      }
+    }
+  }
+  const notification = JSON.stringify({
+    jsonrpc: "2.0",
+    method: event,
+    params: params ?? null
+  });
+  for (const client of authenticatedClients) {
+    if (client.readyState === client.OPEN) {
+      try {
+        client.send(notification);
+      } catch (err) {
+        console.error("[Events] Failed to send to client:", err);
+      }
+    }
+  }
+}
+
+// src/handlers/chat.ts
+import Database from "better-sqlite3";
+var db;
+function initChatDb(dbPath) {
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      selected_model TEXT,
+      selected_provider TEXT,
+      is_archived INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      model TEXT,
+      timestamp INTEGER NOT NULL,
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation
+      ON messages(conversation_id, timestamp);
+  `);
+}
+async function createConversation(params) {
+  const conv = {
+    id: params.id,
+    title: params.title,
+    created_at: Date.now(),
+    selected_model: params.selectedModel ?? null,
+    selected_provider: params.selectedProvider ?? null,
+    is_archived: false
+  };
+  db.prepare(
+    `INSERT OR REPLACE INTO conversations (id, title, created_at, selected_model, selected_provider, is_archived)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    conv.id,
+    conv.title,
+    conv.created_at,
+    conv.selected_model,
+    conv.selected_provider,
+    conv.is_archived ? 1 : 0
+  );
+  return conv;
+}
+async function getConversations() {
+  const rows = db.prepare(
+    `SELECT * FROM conversations WHERE is_archived = 0 ORDER BY created_at DESC`
+  ).all();
+  return rows.map((r) => ({ ...r, is_archived: r.is_archived === 1 }));
+}
+async function getConversation(params) {
+  const row = db.prepare(`SELECT * FROM conversations WHERE id = ?`).get(params.id);
+  if (!row) return null;
+  return { ...row, is_archived: row.is_archived === 1 };
+}
+async function updateConversation(params) {
+  const existing = await getConversation({ id: params.id });
+  if (!existing) return;
+  const updated = {
+    title: params.title ?? existing.title,
+    selected_model: params.selectedModel !== void 0 ? params.selectedModel : existing.selected_model,
+    selected_provider: params.selectedProvider !== void 0 ? params.selectedProvider : existing.selected_provider
+  };
+  db.prepare(
+    `UPDATE conversations SET title = ?, selected_model = ?, selected_provider = ? WHERE id = ?`
+  ).run(
+    updated.title,
+    updated.selected_model,
+    updated.selected_provider,
+    params.id
+  );
+}
+async function archiveConversation(params) {
+  db.prepare(`UPDATE conversations SET is_archived = 1 WHERE id = ?`).run(
+    params.id
+  );
+}
+async function deleteConversation(params) {
+  db.prepare(`DELETE FROM messages WHERE conversation_id = ?`).run(params.id);
+  db.prepare(`DELETE FROM conversations WHERE id = ?`).run(params.id);
+}
+async function saveMessage(params) {
+  db.prepare(
+    `INSERT OR REPLACE INTO messages (id, conversation_id, role, content, model, timestamp)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    params.id,
+    params.conversationId,
+    params.role,
+    params.content,
+    params.model,
+    params.timestamp
+  );
+}
+async function getMessages(params) {
+  const rows = db.prepare(
+    `SELECT * FROM messages WHERE conversation_id = ?
+       ORDER BY timestamp DESC LIMIT ?`
+  ).all(params.conversationId, params.limit);
+  return rows.reverse();
+}
+
+// src/rpc.ts
+var handlers = /* @__PURE__ */ new Map();
+function errorResponse(code, message, id) {
+  const response = {
+    jsonrpc: "2.0",
+    error: { code, message },
+    id
+  };
+  return JSON.stringify(response);
+}
+function successResponse(result, id) {
+  const response = {
+    jsonrpc: "2.0",
+    result,
+    id
+  };
+  return JSON.stringify(response);
+}
+function registerHandler(method, handler) {
+  handlers.set(method, handler);
+}
+async function handleMessage(raw) {
+  let request;
+  try {
+    request = JSON.parse(raw);
+  } catch {
+    return errorResponse(-32700, "Parse error", null);
+  }
+  const id = request.id ?? null;
+  const isNotification = request.id === void 0;
+  if (!request.method || typeof request.method !== "string") {
+    return errorResponse(-32600, "Invalid request: missing method", id);
+  }
+  const handler = handlers.get(request.method);
+  if (!handler) {
+    if (isNotification) return null;
+    return errorResponse(-32601, `Method not found: ${request.method}`, id);
+  }
+  try {
+    const result = await handler(request.params);
+    if (isNotification) return null;
+    return successResponse(result, id);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Internal error";
+    if (isNotification) return null;
+    return errorResponse(-32e3, message, id);
+  }
+}
+
+// src/handlers/acp.ts
+import * as acp from "@agentclientprotocol/sdk";
+import { spawn, execFile } from "child_process";
+import { Readable, Writable } from "stream";
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { resolve } from "path";
+import { platform } from "os";
+var sessions = /* @__PURE__ */ new Map();
+function createClient(sessionId) {
+  return {
+    async requestPermission(params) {
+      const requestId = randomUUID();
+      const session = sessions.get(sessionId);
+      if (!session) throw new Error("Session not found");
+      emit("acp://permission-request", {
+        sessionId,
+        requestId,
+        toolCall: params.toolCall,
+        options: params.options
+      });
+      const optionId = await new Promise((resolve3, reject) => {
+        session.pendingPermissions.set(requestId, resolve3);
+        setTimeout(() => {
+          session.pendingPermissions.delete(requestId);
+          reject(new Error("Permission request timed out"));
+        }, 3e5);
+      });
+      return {
+        outcome: { outcome: "selected", optionId }
+      };
+    },
+    async sessionUpdate(params) {
+      handleSessionUpdate(sessionId, params);
+    },
+    async readTextFile(params) {
+      const content = await readFile(params.path, "utf-8");
+      return { content };
+    },
+    async writeTextFile(params) {
+      const session = sessions.get(sessionId);
+      if (!session) throw new Error("Session not found");
+      let oldText = "";
+      try {
+        oldText = await readFile(params.path, "utf-8");
+      } catch {
+      }
+      const proposalId = randomUUID();
+      emit("acp://diff-proposal", {
+        sessionId,
+        proposalId,
+        path: params.path,
+        oldText,
+        newText: params.content
+      });
+      const accepted = await new Promise((resolve3, reject) => {
+        session.pendingDiffProposals.set(proposalId, resolve3);
+        setTimeout(() => {
+          session.pendingDiffProposals.delete(proposalId);
+          reject(new Error("Diff proposal timed out"));
+        }, 3e5);
+      });
+      if (!accepted) {
+        throw new Error("File write rejected by user");
+      }
+      await writeFile(params.path, params.content, "utf-8");
+      return {};
+    }
+  };
+}
+function handleSessionUpdate(sessionId, notification) {
+  const update = notification.update;
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      if (update.content.type === "text") {
+        emit("acp://message-chunk", {
+          sessionId,
+          text: update.content.text
+        });
+      }
+      break;
+    case "agent_thought_chunk":
+      if (update.content.type === "text") {
+        emit("acp://message-chunk", {
+          sessionId,
+          text: update.content.text,
+          isThought: true
+        });
+      }
+      break;
+    case "tool_call":
+      emit("acp://tool-call", {
+        sessionId,
+        toolCallId: update.toolCallId,
+        title: update.title,
+        kind: update.kind,
+        status: update.status
+      });
+      break;
+    case "tool_call_update": {
+      if (update.content) {
+        for (const block of update.content) {
+          if ("diff" in block || block.path) {
+            const diff = block;
+            emit("acp://diff", {
+              sessionId,
+              toolCallId: update.toolCallId,
+              path: diff.path,
+              oldText: diff.oldText ?? diff.old_text ?? "",
+              newText: diff.newText ?? diff.new_text ?? ""
+            });
+          }
+        }
+      }
+      emit("acp://tool-result", {
+        sessionId,
+        toolCallId: update.toolCallId,
+        status: update.status
+      });
+      break;
+    }
+    case "plan":
+      emit("acp://plan-update", {
+        sessionId,
+        entries: update.entries ?? []
+      });
+      break;
+    default:
+      break;
+  }
+}
+var AGENT_BINARIES = {
+  "claude-code": "seren-acp-claude",
+  codex: "seren-acp-codex"
+};
+function findAgentCommand(agentType) {
+  const binBase = AGENT_BINARIES[agentType];
+  if (!binBase) {
+    throw new Error(`Unknown agent type: ${agentType}`);
+  }
+  return findAgentBinary(binBase);
+}
+function findAgentBinary(binBase) {
+  const ext = platform() === "win32" ? ".exe" : "";
+  const binName = `${binBase}${ext}`;
+  const home2 = process.env.HOME ?? "~";
+  const candidates = [
+    // 1. runtime/bin/ (bundled with seren-local)
+    resolve(import.meta.dirname, "../../bin", binName),
+    // 2. ~/.seren-local/bin/ (user install location)
+    resolve(home2, ".seren-local/bin", binName),
+    // 3. Seren Desktop embedded-runtime (development)
+    resolve(home2, "Projects/Seren_Projects/seren-desktop/src-tauri/embedded-runtime/bin", binName)
+  ];
+  if (binBase === "seren-acp-claude") {
+    const legacyName = `acp_agent${ext}`;
+    candidates.push(
+      resolve(import.meta.dirname, "../../bin", legacyName),
+      resolve(home2, ".seren-local/bin", legacyName),
+      resolve(home2, "Projects/Seren_Projects/seren-desktop/src-tauri/embedded-runtime/bin", legacyName)
+    );
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      console.log(`[ACP] Found ${binBase} binary at: ${candidate}`);
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Agent binary '${binBase}' not found. Checked locations:
+${candidates.map((p) => `  - ${p}`).join("\n")}`
+  );
+}
+async function isCommandAvailable(command) {
+  const which = platform() === "win32" ? "where" : "which";
+  return new Promise((resolve3) => {
+    execFile(which, [command], (err) => resolve3(!err));
+  });
+}
+async function acpSpawn(params) {
+  const { agentType, cwd, sandboxMode, thinking } = params;
+  const sessionId = randomUUID();
+  const command = findAgentCommand(agentType);
+  const resolvedCwd = resolve(cwd);
+  const args = [];
+  if (sandboxMode) {
+    args.push("--sandbox", sandboxMode);
+  }
+  const agentProcess = spawn(command, args, {
+    cwd: resolvedCwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env }
+  });
+  if (!agentProcess.stdin || !agentProcess.stdout) {
+    throw new Error("Failed to create agent process stdio");
+  }
+  if (agentProcess.stderr) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: agentProcess.stderr });
+    rl.on("line", (line) => {
+      console.log(`[ACP Agent stderr] ${line}`);
+    });
+  }
+  const input = Writable.toWeb(agentProcess.stdin);
+  const output = Readable.toWeb(
+    agentProcess.stdout
+  );
+  const stream = acp.ndJsonStream(input, output);
+  const client = createClient(sessionId);
+  const connection = new acp.ClientSideConnection(
+    (_agent) => client,
+    stream
+  );
+  const session = {
+    id: sessionId,
+    agentType,
+    cwd: resolvedCwd,
+    status: "initializing",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    connection,
+    process: agentProcess,
+    pendingPermissions: /* @__PURE__ */ new Map(),
+    pendingDiffProposals: /* @__PURE__ */ new Map(),
+    cancelling: false
+  };
+  sessions.set(sessionId, session);
+  agentProcess.on("exit", (code, signal) => {
+    session.status = "terminated";
+    emit("acp://session-status", {
+      sessionId,
+      status: "terminated"
+    });
+    console.log(
+      `[ACP] Agent ${sessionId} exited: code=${code}, signal=${signal}`
+    );
+  });
+  try {
+    const initResult = await connection.initialize({
+      protocolVersion: acp.PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: {
+          readTextFile: true,
+          writeTextFile: true
+        },
+        terminal: true
+      }
+    });
+    session.status = "ready";
+    emit("acp://session-status", {
+      sessionId,
+      status: "ready",
+      agentInfo: initResult.agentInfo
+    });
+    const meta = thinking ? { claudeCode: { options: { maxThinkingTokens: thinking.maxTokens ?? 16e3 } } } : void 0;
+    const sessionResult = await connection.newSession({
+      cwd: resolvedCwd,
+      mcpServers: [],
+      ...meta ? { _meta: meta } : {}
+    });
+    session.acpSessionId = sessionResult.sessionId ?? sessionId;
+  } catch (err) {
+    session.status = "error";
+    emit("acp://error", {
+      sessionId,
+      error: `Failed to initialize agent: ${err instanceof Error ? err.message : JSON.stringify(err)}`
+    });
+    throw err;
+  }
+  return {
+    id: sessionId,
+    agentType,
+    cwd: resolvedCwd,
+    status: session.status,
+    createdAt: session.createdAt
+  };
+}
+async function acpPrompt(params) {
+  const { sessionId, prompt, context } = params;
+  const session = sessions.get(sessionId);
+  if (!session) throw new Error(`Session not found: ${sessionId}`);
+  session.status = "prompting";
+  emit("acp://session-status", { sessionId, status: "prompting" });
+  const acpSessionId = session.acpSessionId ?? sessionId;
+  const promptContent = [
+    { type: "text", text: prompt }
+  ];
+  if (context) {
+    for (const item of context) {
+      if (item.text) {
+        promptContent.push({ type: "text", text: item.text });
+      }
+    }
+  }
+  try {
+    const result = await session.connection.prompt({
+      sessionId: acpSessionId,
+      prompt: promptContent
+    });
+    emit("acp://prompt-complete", {
+      sessionId,
+      stopReason: result.stopReason ?? "end_turn"
+    });
+  } catch (err) {
+    emit("acp://error", {
+      sessionId,
+      error: `Prompt failed: ${err instanceof Error ? err.message : JSON.stringify(err)}`
+    });
+    throw err;
+  } finally {
+    session.cancelling = false;
+    if (session.status === "prompting") {
+      session.status = "ready";
+    }
+  }
+}
+async function acpCancel(params) {
+  const { sessionId } = params;
+  const session = sessions.get(sessionId);
+  if (!session) throw new Error(`Session not found: ${sessionId}`);
+  if (session.cancelling) {
+    console.log(`[ACP] Cancel already in progress for ${sessionId}, ignoring duplicate`);
+    return;
+  }
+  session.cancelling = true;
+  try {
+    const acpSessionId = session.acpSessionId ?? sessionId;
+    await session.connection.cancel({ sessionId: acpSessionId });
+  } finally {
+    session.cancelling = false;
+  }
+}
+async function acpTerminate(params) {
+  const { sessionId } = params;
+  const session = sessions.get(sessionId);
+  if (!session) throw new Error(`Session not found: ${sessionId}`);
+  session.process.kill();
+  sessions.delete(sessionId);
+  session.status = "terminated";
+  emit("acp://session-status", { sessionId, status: "terminated" });
+}
+async function acpListSessions() {
+  return Array.from(sessions.values()).map((s) => ({
+    id: s.id,
+    agentType: s.agentType,
+    cwd: s.cwd,
+    status: s.status,
+    createdAt: s.createdAt
+  }));
+}
+async function acpSetPermissionMode(params) {
+  const { sessionId, mode } = params;
+  const session = sessions.get(sessionId);
+  if (!session) throw new Error(`Session not found: ${sessionId}`);
+  const acpSessionId = session.acpSessionId ?? sessionId;
+  await session.connection.setSessionMode({
+    sessionId: acpSessionId,
+    modeId: mode
+  });
+}
+async function acpRespondToPermission(params) {
+  const { sessionId, requestId, optionId } = params;
+  const session = sessions.get(sessionId);
+  if (!session) throw new Error(`Session not found: ${sessionId}`);
+  const resolver = session.pendingPermissions.get(requestId);
+  if (!resolver) throw new Error(`No pending permission: ${requestId}`);
+  session.pendingPermissions.delete(requestId);
+  resolver(optionId);
+}
+async function acpRespondToDiffProposal(params) {
+  const { sessionId, proposalId, accepted } = params;
+  const session = sessions.get(sessionId);
+  if (!session) throw new Error(`Session not found: ${sessionId}`);
+  const resolver = session.pendingDiffProposals.get(proposalId);
+  if (!resolver) throw new Error(`No pending diff proposal: ${proposalId}`);
+  session.pendingDiffProposals.delete(proposalId);
+  resolver(accepted);
+}
+async function acpGetAvailableAgents() {
+  const agents = [
+    { type: "claude-code", name: "Claude Code", description: "AI coding assistant by Anthropic", command: "seren-acp-claude" },
+    { type: "codex", name: "Codex", description: "AI coding assistant powered by OpenAI Codex", command: "seren-acp-codex" }
+  ];
+  return agents.map((agent) => {
+    let available = false;
+    let unavailableReason;
+    try {
+      findAgentCommand(agent.type);
+      available = true;
+    } catch (err) {
+      unavailableReason = err.message;
+    }
+    return { ...agent, available, unavailableReason };
+  });
+}
+async function acpCheckAgentAvailable(params) {
+  try {
+    findAgentCommand(params.agentType);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acpEnsureClaudeCli() {
+  if (await isCommandAvailable("claude")) {
+    return "claude";
+  }
+  const npmCmd = platform() === "win32" ? "npm.cmd" : "npm";
+  return new Promise((resolve3, reject) => {
+    const proc = execFile(
+      npmCmd,
+      ["install", "-g", "@anthropic-ai/claude-code"],
+      (err, stdout, stderr) => {
+        if (err) {
+          reject(
+            new Error(
+              `Failed to install Claude Code CLI: ${stderr || err.message}`
+            )
+          );
+          return;
+        }
+        console.log(`[ACP] Claude Code CLI installed: ${stdout}`);
+        resolve3("claude");
+      }
+    );
+  });
+}
+
+// src/handlers/dialogs.ts
+import { execFile as execFile2 } from "child_process";
+import { platform as platform2 } from "os";
+import { dirname } from "path";
+var os = platform2();
+function exec(cmd, args) {
+  return new Promise((resolve3, reject) => {
+    execFile2(cmd, args, { timeout: 6e4 }, (err, stdout) => {
+      if (err) {
+        if (err.code === 1 || err.killed) {
+          resolve3("");
+          return;
+        }
+        reject(err);
+        return;
+      }
+      resolve3(stdout.trim());
+    });
+  });
+}
+async function openFolderDialog() {
+  let result;
+  if (os === "darwin") {
+    result = await exec("osascript", [
+      "-e",
+      'POSIX path of (choose folder with prompt "Select a folder")'
+    ]);
+  } else if (os === "linux") {
+    result = await exec("zenity", ["--file-selection", "--directory", "--title=Select a folder"]);
+  } else if (os === "win32") {
+    result = await exec("powershell", [
+      "-NoProfile",
+      "-Command",
+      "[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms') | Out-Null; $f = New-Object System.Windows.Forms.FolderBrowserDialog; if ($f.ShowDialog() -eq 'OK') { $f.SelectedPath }"
+    ]);
+  } else {
+    throw new Error(`Unsupported platform: ${os}`);
+  }
+  return result || null;
+}
+async function openFileDialog() {
+  let result;
+  if (os === "darwin") {
+    result = await exec("osascript", [
+      "-e",
+      'POSIX path of (choose file with prompt "Select a file")'
+    ]);
+  } else if (os === "linux") {
+    result = await exec("zenity", ["--file-selection", "--title=Select a file"]);
+  } else if (os === "win32") {
+    result = await exec("powershell", [
+      "-NoProfile",
+      "-Command",
+      "[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms') | Out-Null; $f = New-Object System.Windows.Forms.OpenFileDialog; if ($f.ShowDialog() -eq 'OK') { $f.FileName }"
+    ]);
+  } else {
+    throw new Error(`Unsupported platform: ${os}`);
+  }
+  return result || null;
+}
+async function saveFileDialog(params) {
+  let result;
+  if (os === "darwin") {
+    const prompt = params.defaultPath ? `POSIX path of (choose file name with prompt "Save as" default name "${params.defaultPath}")` : 'POSIX path of (choose file name with prompt "Save as")';
+    result = await exec("osascript", ["-e", prompt]);
+  } else if (os === "linux") {
+    const args = ["--file-selection", "--save", "--title=Save as"];
+    if (params.defaultPath) args.push(`--filename=${params.defaultPath}`);
+    result = await exec("zenity", args);
+  } else if (os === "win32") {
+    result = await exec("powershell", [
+      "-NoProfile",
+      "-Command",
+      "[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms') | Out-Null; $f = New-Object System.Windows.Forms.SaveFileDialog; if ($f.ShowDialog() -eq 'OK') { $f.FileName }"
+    ]);
+  } else {
+    throw new Error(`Unsupported platform: ${os}`);
+  }
+  return result || null;
+}
+async function revealInFileManager(params) {
+  if (os === "darwin") {
+    await exec("open", ["-R", params.path]);
+  } else if (os === "linux") {
+    await exec("xdg-open", [dirname(params.path)]);
+  } else if (os === "win32") {
+    await exec("explorer", [`/select,${params.path}`]);
+  } else {
+    throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+
+// src/handlers/fs.ts
+import {
+  access,
+  readFile as fsReadFile,
+  realpath,
+  writeFile as fsWriteFile,
+  mkdir,
+  readdir,
+  rename,
+  rm,
+  stat
+} from "fs/promises";
+import { realpathSync as realpathSyncNative } from "fs";
+import { homedir, tmpdir } from "os";
+import { join, resolve as resolve2 } from "path";
+var home = homedir();
+var tmp = tmpdir();
+var homeReal;
+var tmpReal;
+try {
+  homeReal = realpathSyncNative(home);
+} catch {
+  homeReal = home;
+}
+try {
+  tmpReal = realpathSyncNative(tmp);
+} catch {
+  tmpReal = tmp;
+}
+function isAllowedPath(p) {
+  return p.startsWith(home) || p.startsWith(tmp) || p.startsWith(homeReal) || p.startsWith(tmpReal);
+}
+async function validatePathReal(requestedPath) {
+  const resolved = resolve2(requestedPath);
+  if (!isAllowedPath(resolved)) {
+    throw new Error("Access denied: path must be within home directory");
+  }
+  try {
+    const real = await realpath(resolved);
+    if (!isAllowedPath(real)) {
+      throw new Error("Access denied: symlink target is outside home directory");
+    }
+    return real;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return resolved;
+    }
+    throw err;
+  }
+}
+async function listDirectory(params) {
+  const dir = await validatePathReal(params.path);
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    path: join(dir, entry.name),
+    is_directory: entry.isDirectory()
+  }));
+}
+async function readFile2(params) {
+  const filePath = await validatePathReal(params.path);
+  return fsReadFile(filePath, "utf-8");
+}
+async function readFileBase64(params) {
+  const filePath = await validatePathReal(params.path);
+  const buffer = await fsReadFile(filePath);
+  return Buffer.from(buffer).toString("base64");
+}
+async function writeFile2(params) {
+  const filePath = await validatePathReal(params.path);
+  await fsWriteFile(filePath, params.content, "utf-8");
+}
+async function pathExists(params) {
+  const p = await validatePathReal(params.path);
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(params) {
+  const p = await validatePathReal(params.path);
+  try {
+    const s = await stat(p);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function createFile(params) {
+  const filePath = await validatePathReal(params.path);
+  await fsWriteFile(filePath, params.content ?? "", "utf-8");
+}
+async function createDirectory(params) {
+  const dir = await validatePathReal(params.path);
+  await mkdir(dir, { recursive: true });
+}
+async function deletePath(params) {
+  const p = await validatePathReal(params.path);
+  await rm(p, { recursive: true, force: true });
+}
+async function renamePath(params) {
+  const oldP = await validatePathReal(params.oldPath);
+  const newP = await validatePathReal(params.newPath);
+  await rename(oldP, newP);
+}
+
+// src/services/vector-store.ts
+import Database2 from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { createHash } from "crypto";
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var EMBEDDING_DIM = 1536;
+function getDataDir() {
+  return join2(homedir2(), ".seren-local", "data");
+}
+function getVectorDbPath(projectPath) {
+  const hash = createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
+  return join2(getDataDir(), "indexes", `${hash}.db`);
+}
+function hasIndex(projectPath) {
+  return existsSync2(getVectorDbPath(projectPath));
+}
+function openDb(projectPath) {
+  const dbPath = getVectorDbPath(projectPath);
+  const dir = join2(getDataDir(), "indexes");
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db2 = new Database2(dbPath);
+  sqliteVec.load(db2);
+  return db2;
+}
+function initVectorDb(projectPath) {
+  const db2 = openDb(projectPath);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS code_chunks (
+      id INTEGER PRIMARY KEY,
+      file_path TEXT NOT NULL,
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      chunk_type TEXT NOT NULL,
+      symbol_name TEXT,
+      language TEXT NOT NULL,
+      file_hash TEXT NOT NULL,
+      indexed_at INTEGER NOT NULL
+    )
+  `);
+  db2.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_file ON code_chunks(file_path)`);
+  db2.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_hash ON code_chunks(file_hash)`);
+  db2.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS code_embeddings USING vec0(
+      chunk_id INTEGER PRIMARY KEY,
+      embedding float[${EMBEDDING_DIM}]
+    )
+  `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS index_metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  db2.prepare(
+    "INSERT OR REPLACE INTO index_metadata (key, value) VALUES ('project_path', ?)"
+  ).run(projectPath);
+  const stats = getIndexStats(db2);
+  db2.close();
+  return stats;
+}
+function getIndexStats(db2) {
+  const totalChunks = db2.prepare("SELECT COUNT(*) as c FROM code_chunks").get().c;
+  const totalFiles = db2.prepare("SELECT COUNT(DISTINCT file_path) as c FROM code_chunks").get().c;
+  const lastIndexed = db2.prepare("SELECT MAX(indexed_at) as m FROM code_chunks").get().m;
+  return {
+    total_chunks: totalChunks,
+    total_files: totalFiles,
+    last_indexed: lastIndexed ?? null
+  };
+}
+function getStats(projectPath) {
+  if (!hasIndex(projectPath)) {
+    return { total_chunks: 0, total_files: 0, last_indexed: null };
+  }
+  const db2 = openDb(projectPath);
+  const stats = getIndexStats(db2);
+  db2.close();
+  return stats;
+}
+function float32ArrayToBuffer(arr) {
+  const f32 = new Float32Array(arr);
+  return Buffer.from(f32.buffer);
+}
+function insertChunks(projectPath, chunks) {
+  const db2 = openDb(projectPath);
+  const now = Date.now();
+  const insertChunk = db2.prepare(`
+    INSERT INTO code_chunks (file_path, start_line, end_line, content, chunk_type, symbol_name, language, file_hash, indexed_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertEmbedding = db2.prepare(`
+    INSERT INTO code_embeddings (chunk_id, embedding) VALUES (?, ?)
+  `);
+  const ids = [];
+  const transaction = db2.transaction(() => {
+    for (const chunk of chunks) {
+      if (chunk.embedding.length !== EMBEDDING_DIM) {
+        throw new Error(
+          `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${chunk.embedding.length}`
+        );
+      }
+      const result = insertChunk.run(
+        chunk.file_path,
+        chunk.start_line,
+        chunk.end_line,
+        chunk.content,
+        chunk.chunk_type,
+        chunk.symbol_name,
+        chunk.language,
+        chunk.file_hash,
+        now
+      );
+      const chunkId = Number(result.lastInsertRowid);
+      insertEmbedding.run(chunkId, float32ArrayToBuffer(chunk.embedding));
+      ids.push(chunkId);
+    }
+  });
+  transaction();
+  db2.close();
+  return ids;
+}
+function deleteFileChunks(projectPath, filePath) {
+  const db2 = openDb(projectPath);
+  const chunkIds = db2.prepare("SELECT id FROM code_chunks WHERE file_path = ?").all(filePath).map((row) => row.id);
+  const deleteEmbedding = db2.prepare(
+    "DELETE FROM code_embeddings WHERE chunk_id = ?"
+  );
+  for (const id of chunkIds) {
+    deleteEmbedding.run(id);
+  }
+  const result = db2.prepare("DELETE FROM code_chunks WHERE file_path = ?").run(filePath);
+  db2.close();
+  return result.changes;
+}
+function searchSimilar(projectPath, queryEmbedding, limit) {
+  const db2 = openDb(projectPath);
+  const embeddingBlob = float32ArrayToBuffer(queryEmbedding);
+  const rows = db2.prepare(
+    `SELECT
+        c.id, c.file_path, c.start_line, c.end_line, c.content,
+        c.chunk_type, c.symbol_name, c.language, c.file_hash, c.indexed_at,
+        e.distance
+       FROM code_embeddings e
+       JOIN code_chunks c ON c.id = e.chunk_id
+       WHERE e.embedding MATCH ?
+       ORDER BY e.distance
+       LIMIT ?`
+  ).all(embeddingBlob, limit);
+  db2.close();
+  return rows.map((row) => ({
+    chunk: {
+      id: row.id,
+      file_path: row.file_path,
+      start_line: row.start_line,
+      end_line: row.end_line,
+      content: row.content,
+      chunk_type: row.chunk_type,
+      symbol_name: row.symbol_name,
+      language: row.language,
+      file_hash: row.file_hash,
+      indexed_at: row.indexed_at
+    },
+    distance: row.distance
+  }));
+}
+function fileNeedsReindex(projectPath, filePath, currentHash) {
+  if (!hasIndex(projectPath)) return true;
+  const db2 = openDb(projectPath);
+  const row = db2.prepare("SELECT file_hash FROM code_chunks WHERE file_path = ? LIMIT 1").get(filePath);
+  db2.close();
+  if (!row) return true;
+  return row.file_hash !== currentHash;
+}
+
+// src/services/chunker.ts
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join as join3, extname, relative } from "path";
+import { createHash as createHash2 } from "crypto";
+var MAX_CHUNK_LINES = 100;
+var MIN_CHUNK_LINES = 5;
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "target",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  ".idea",
+  ".vscode",
+  ".DS_Store",
+  "Thumbs.db",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Cargo.lock"
+];
+var WILDCARD_SUFFIXES = [".min.js", ".min.css", ".map"];
+var LANG_MAP = {
+  rs: "rust",
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  py: "python",
+  go: "go",
+  java: "java",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  cc: "cpp",
+  cxx: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  rb: "ruby",
+  php: "php",
+  swift: "swift",
+  kt: "kotlin",
+  kts: "kotlin",
+  scala: "scala",
+  r: "r",
+  sql: "sql",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  ps1: "powershell",
+  yml: "yaml",
+  yaml: "yaml",
+  json: "json",
+  toml: "toml",
+  xml: "xml",
+  html: "html",
+  htm: "html",
+  css: "css",
+  scss: "css",
+  sass: "css",
+  less: "css",
+  md: "markdown",
+  markdown: "markdown",
+  vue: "vue",
+  svelte: "svelte"
+};
+function detectLanguage(filePath) {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  return LANG_MAP[ext] ?? null;
+}
+function shouldIgnore(name) {
+  if (IGNORE_PATTERNS.includes(name)) return true;
+  for (const suffix of WILDCARD_SUFFIXES) {
+    if (name.endsWith(suffix)) return true;
+  }
+  return false;
+}
+function computeHash(content) {
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+}
+function discoverFiles(projectPath) {
+  const files = [];
+  discoverRecursive(projectPath, projectPath, files);
+  return files;
+}
+function discoverRecursive(root, current, files) {
+  let entries;
+  try {
+    entries = readdirSync(current);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (shouldIgnore(name)) continue;
+    const fullPath = join3(current, name);
+    let stat2;
+    try {
+      stat2 = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat2.isDirectory()) {
+      discoverRecursive(root, fullPath, files);
+    } else if (stat2.isFile()) {
+      const language = detectLanguage(fullPath);
+      if (!language) continue;
+      if (stat2.size > MAX_FILE_SIZE) continue;
+      let content;
+      try {
+        content = readFileSync(fullPath, "utf-8");
+      } catch {
+        continue;
+      }
+      files.push({
+        path: fullPath,
+        relative_path: relative(root, fullPath),
+        language,
+        size: stat2.size,
+        hash: computeHash(content)
+      });
+    }
+  }
+}
+function chunkFile(file) {
+  const content = readFileSync(file.path, "utf-8");
+  const lines = content.split("\n");
+  let chunks;
+  switch (file.language) {
+    case "rust":
+      chunks = chunkBraceLanguage(lines, detectRustBlock);
+      break;
+    case "typescript":
+    case "javascript":
+      chunks = chunkBraceLanguage(lines, detectJsBlock);
+      break;
+    case "python":
+      chunks = chunkPython(lines);
+      break;
+    default:
+      chunks = chunkGeneric(lines);
+  }
+  if (chunks.length === 0) {
+    chunks = chunkGeneric(lines);
+  }
+  return { file, chunks };
+}
+function chunkBraceLanguage(lines, detect) {
+  const chunks = [];
+  let currentStart = null;
+  let braceDepth = 0;
+  let currentType = "block";
+  let currentName = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (currentStart === null) {
+      const block = detect(trimmed);
+      if (block) {
+        currentStart = i;
+        currentType = block.type;
+        currentName = block.name;
+        braceDepth = 0;
+      }
+    }
+    if (currentStart !== null) {
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        else if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0 && (line.includes("}") || line.includes(";"))) {
+        const content = lines.slice(currentStart, i + 1).join("\n");
+        if (i - currentStart + 1 >= MIN_CHUNK_LINES) {
+          chunks.push({
+            start_line: currentStart + 1,
+            end_line: i + 1,
+            content,
+            chunk_type: currentType,
+            symbol_name: currentName
+          });
+        }
+        currentStart = null;
+        currentName = null;
+      }
+    }
+  }
+  return chunks;
+}
+function extractIdAfter(line, keyword) {
+  const idx = line.indexOf(keyword);
+  if (idx === -1) return null;
+  const after = line.slice(idx + keyword.length);
+  const match = after.match(/^[a-zA-Z_]\w*/);
+  return match ? match[0] : null;
+}
+function detectRustBlock(line) {
+  if (line.startsWith("//") || line.startsWith("#[")) return null;
+  if (/^(pub\s+)?(async\s+)?fn\s/.test(line))
+    return { type: "function", name: extractIdAfter(line, "fn ") };
+  if (/^impl[\s<]/.test(line))
+    return { type: "class", name: extractIdAfter(line, "impl ") };
+  if (/^(pub\s+)?struct\s/.test(line))
+    return { type: "class", name: extractIdAfter(line, "struct ") };
+  if (/^(pub\s+)?enum\s/.test(line))
+    return { type: "class", name: extractIdAfter(line, "enum ") };
+  if (/^(pub\s+)?mod\s/.test(line))
+    return { type: "module", name: extractIdAfter(line, "mod ") };
+  return null;
+}
+function detectJsBlock(line) {
+  if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) return null;
+  if (/^(export\s+)?(async\s+)?function\s/.test(line))
+    return { type: "function", name: extractIdAfter(line, "function ") };
+  if (/^(export\s+)?const\s.*=\s*(async\s+)?\(/.test(line))
+    return { type: "function", name: extractIdAfter(line, "const ") };
+  if (/^(export\s+)?(default\s+)?class\s/.test(line))
+    return { type: "class", name: extractIdAfter(line, "class ") };
+  if (/^(export\s+)?interface\s/.test(line))
+    return { type: "class", name: extractIdAfter(line, "interface ") };
+  if (/^(export\s+)?type\s/.test(line))
+    return { type: "class", name: extractIdAfter(line, "type ") };
+  return null;
+}
+function chunkPython(lines) {
+  const chunks = [];
+  let currentStart = null;
+  let currentIndent = 0;
+  let currentType = "block";
+  let currentName = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const indent = line.length - line.trimStart().length;
+    if (currentStart === null) {
+      const block = detectPythonBlock(trimmed);
+      if (block) {
+        currentStart = i;
+        currentIndent = indent;
+        currentType = block.type;
+        currentName = block.name;
+      }
+    } else if (trimmed.length > 0 && indent <= currentIndent && i > currentStart) {
+      const content = lines.slice(currentStart, i).join("\n");
+      if (i - currentStart >= MIN_CHUNK_LINES) {
+        chunks.push({
+          start_line: currentStart + 1,
+          end_line: i,
+          content,
+          chunk_type: currentType,
+          symbol_name: currentName
+        });
+      }
+      currentStart = null;
+      currentName = null;
+      const block = detectPythonBlock(trimmed);
+      if (block) {
+        currentStart = i;
+        currentIndent = indent;
+        currentType = block.type;
+        currentName = block.name;
+      }
+    }
+  }
+  if (currentStart !== null) {
+    const content = lines.slice(currentStart).join("\n");
+    if (lines.length - currentStart >= MIN_CHUNK_LINES) {
+      chunks.push({
+        start_line: currentStart + 1,
+        end_line: lines.length,
+        content,
+        chunk_type: currentType,
+        symbol_name: currentName
+      });
+    }
+  }
+  return chunks;
+}
+function detectPythonBlock(line) {
+  if (line.startsWith("#") || line.startsWith('"""') || line.startsWith("'''")) return null;
+  if (/^(async\s+)?def\s/.test(line))
+    return { type: "function", name: extractIdAfter(line, "def ") };
+  if (/^class\s/.test(line))
+    return { type: "class", name: extractIdAfter(line, "class ") };
+  return null;
+}
+function chunkGeneric(lines) {
+  const chunks = [];
+  if (lines.length <= MAX_CHUNK_LINES) {
+    if (lines.length >= MIN_CHUNK_LINES) {
+      chunks.push({
+        start_line: 1,
+        end_line: lines.length,
+        content: lines.join("\n"),
+        chunk_type: "file",
+        symbol_name: null
+      });
+    }
+    return chunks;
+  }
+  let start = 0;
+  while (start < lines.length) {
+    const end = Math.min(start + MAX_CHUNK_LINES, lines.length);
+    chunks.push({
+      start_line: start + 1,
+      end_line: end,
+      content: lines.slice(start, end).join("\n"),
+      chunk_type: "block",
+      symbol_name: null
+    });
+    start = end;
+  }
+  return chunks;
+}
+function estimateIndexing(files) {
+  let totalChunks = 0;
+  let totalTokens = 0;
+  for (const file of files) {
+    try {
+      const chunked = chunkFile(file);
+      totalChunks += chunked.chunks.length;
+      for (const chunk of chunked.chunks) {
+        totalTokens += Math.floor(chunk.content.length / 4);
+      }
+    } catch {
+    }
+  }
+  return { chunks: totalChunks, tokens: totalTokens };
+}
+
+// src/handlers/indexing.ts
+async function initProjectIndex(params) {
+  return initVectorDb(params.projectPath);
+}
+async function getIndexStatus(params) {
+  return getStats(params.projectPath);
+}
+async function hasProjectIndex(params) {
+  return hasIndex(params.projectPath);
+}
+async function searchCodebase(params) {
+  if (params.queryEmbedding.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Query embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${params.queryEmbedding.length}`
+    );
+  }
+  return searchSimilar(
+    params.projectPath,
+    params.queryEmbedding,
+    params.limit
+  );
+}
+async function fileNeedsReindex2(params) {
+  return fileNeedsReindex(
+    params.projectPath,
+    params.filePath,
+    params.fileHash
+  );
+}
+async function deleteFileIndex(params) {
+  return deleteFileChunks(params.projectPath, params.filePath);
+}
+async function indexChunks(params) {
+  return insertChunks(params.projectPath, params.chunks);
+}
+async function discoverProjectFiles(params) {
+  return discoverFiles(params.projectPath);
+}
+async function chunkFile2(params) {
+  return chunkFile(params.file);
+}
+async function estimateIndexing2(params) {
+  return estimateIndexing(params.files);
+}
+async function computeFileHash(params) {
+  return computeHash(params.content);
+}
+async function getEmbeddingDimension() {
+  return EMBEDDING_DIM;
+}
+
+// src/handlers/mcp.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var processes = /* @__PURE__ */ new Map();
+function sendRequest(proc, method, params) {
+  const id = randomUUID2();
+  return new Promise((resolve3, reject) => {
+    const timeout = setTimeout(() => {
+      proc.pendingRequests.delete(id);
+      reject(new Error(`MCP request timeout: ${method}`));
+    }, 3e4);
+    proc.pendingRequests.set(id, {
+      resolve: (v) => {
+        clearTimeout(timeout);
+        resolve3(v);
+      },
+      reject: (e) => {
+        clearTimeout(timeout);
+        reject(e);
+      }
+    });
+    const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} });
+    proc.child.stdin?.write(msg + "\n");
+  });
+}
+async function mcpDisconnect(params) {
+  const proc = processes.get(params.serverName);
+  if (proc) {
+    proc.child.kill();
+    processes.delete(params.serverName);
+  }
+}
+async function mcpReadResource(params) {
+  const proc = processes.get(params.serverName);
+  if (!proc) {
+    throw new Error(`Server '${params.serverName}' not connected`);
+  }
+  return sendRequest(proc, "resources/read", { uri: params.uri });
+}
+
+// src/handlers/openclaw.ts
+import { execFile as execFile3, spawn as spawn2 } from "child_process";
+import { createServer } from "net";
+import {
+  readFile as readFile3,
+  writeFile as writeFile3,
+  mkdir as mkdir2,
+  access as access2,
+  constants
+} from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { randomBytes } from "crypto";
+import WebSocket from "ws";
+var childProcess = null;
+var processStatus = "stopped";
+var hookToken = null;
+var port = 0;
+var restartCount = 0;
+var startedAt = null;
+var wsClient = null;
+var reconnectTimer = null;
+var monitorTimer = null;
+var channels = [];
+var trustSettings = /* @__PURE__ */ new Map();
+var approvedIds = /* @__PURE__ */ new Set();
+var MAX_RESTART_ATTEMPTS = 3;
+var OPENCLAW_DIR = join4(homedir3(), ".openclaw");
+var CONFIG_PATH = join4(OPENCLAW_DIR, "openclaw.json");
+var SETTINGS_PATH = join4(homedir3(), ".seren-local", "settings.json");
+async function loadSettings() {
+  try {
+    const data = await readFile3(SETTINGS_PATH, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+async function saveSettings(settings) {
+  await mkdir2(join4(homedir3(), ".seren-local"), { recursive: true });
+  await writeFile3(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+}
+async function getSetting(params) {
+  const settings = await loadSettings();
+  return settings[params.key] ?? null;
+}
+async function setSetting(params) {
+  const settings = await loadSettings();
+  settings[params.key] = params.value;
+  await saveSettings(settings);
+}
+function findAvailablePort() {
+  return new Promise((resolve3, reject) => {
+    const server = createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr && typeof addr === "object") {
+        const p = addr.port;
+        server.close(() => resolve3(p));
+      } else {
+        server.close(() => reject(new Error("Failed to get port")));
+      }
+    });
+    server.on("error", reject);
+  });
+}
+async function getOrCreateToken() {
+  if (hookToken) return hookToken;
+  try {
+    const config2 = JSON.parse(await readFile3(CONFIG_PATH, "utf-8"));
+    if (config2.hookToken) {
+      hookToken = config2.hookToken;
+      return hookToken;
+    }
+  } catch {
+  }
+  hookToken = randomBytes(32).toString("hex");
+  await mkdir2(OPENCLAW_DIR, { recursive: true });
+  let config = {};
+  try {
+    config = JSON.parse(await readFile3(CONFIG_PATH, "utf-8"));
+  } catch {
+  }
+  config.hookToken = hookToken;
+  await writeFile3(CONFIG_PATH, JSON.stringify(config, null, 2), {
+    mode: 384
+  });
+  return hookToken;
+}
+async function findOpenClawEntrypoint() {
+  const candidates = [
+    // Global npm install
+    join4(homedir3(), ".seren-local", "lib", "node_modules", "openclaw", "openclaw.mjs"),
+    // Development
+    join4(homedir3(), ".openclaw", "openclaw.mjs")
+  ];
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const path = await new Promise((resolve3, reject) => {
+      execFile3(cmd, ["openclaw"], (err, stdout) => {
+        if (err) reject(err);
+        else resolve3(stdout.trim());
+      });
+    });
+    if (path) candidates.unshift(path);
+  } catch {
+  }
+  for (const candidate of candidates) {
+    try {
+      await access2(candidate, constants.R_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  throw new Error(
+    "OpenClaw not found. Install it or ensure openclaw.mjs is in ~/.openclaw/"
+  );
+}
+function connectWebSocket() {
+  if (!port || !hookToken) return;
+  const url = `ws://127.0.0.1:${port}/ws?token=${hookToken}`;
+  wsClient = new WebSocket(url);
+  wsClient.on("open", () => {
+    console.log("[OpenClaw] WebSocket connected");
+  });
+  wsClient.on("message", (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+      handleOpenClawEvent(msg);
+    } catch (err) {
+      console.error("[OpenClaw] Failed to parse WS message:", err);
+    }
+  });
+  wsClient.on("close", () => {
+    wsClient = null;
+    if (processStatus === "running") {
+      scheduleWsReconnect();
+    }
+  });
+  wsClient.on("error", (err) => {
+    console.error("[OpenClaw] WebSocket error:", err.message);
+  });
+}
+function scheduleWsReconnect() {
+  if (reconnectTimer) return;
+  const delay = Math.min(1e3 * 2 ** restartCount, 3e4);
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    if (processStatus === "running") {
+      connectWebSocket();
+    }
+  }, delay);
+}
+function handleOpenClawEvent(msg) {
+  const { type, ...payload } = msg;
+  switch (type) {
+    case "channel:connected":
+    case "channel:disconnected":
+    case "channel:error":
+      emit("openclaw://channel-event", { type, ...payload });
+      break;
+    case "message:received":
+      emit("openclaw://message-received", payload);
+      break;
+    default:
+      console.log("[OpenClaw] Unknown event:", type);
+  }
+}
+function startProcessMonitor() {
+  if (monitorTimer) return;
+  monitorTimer = setInterval(() => {
+    if (!childProcess || processStatus !== "running") return;
+    try {
+      childProcess.kill(0);
+    } catch {
+      processStatus = "crashed";
+      emit("openclaw://status-changed", { status: "crashed" });
+      if (restartCount < MAX_RESTART_ATTEMPTS) {
+        restartCount++;
+        processStatus = "restarting";
+        emit("openclaw://status-changed", { status: "restarting" });
+        openclawStart({}).catch(
+          (err) => console.error("[OpenClaw] Auto-restart failed:", err)
+        );
+      }
+    }
+  }, 2e3);
+}
+function stopProcessMonitor() {
+  if (monitorTimer) {
+    clearInterval(monitorTimer);
+    monitorTimer = null;
+  }
+}
+async function openclawStart(_params) {
+  if (processStatus === "running") return;
+  processStatus = "starting";
+  emit("openclaw://status-changed", { status: "starting" });
+  const entrypoint = await findOpenClawEntrypoint();
+  const token = await getOrCreateToken();
+  port = await findAvailablePort();
+  childProcess = spawn2("node", [entrypoint, "gateway", "--allow-unconfigured"], {
+    cwd: OPENCLAW_DIR,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      OPENCLAW_GATEWAY_PORT: String(port),
+      OPENCLAW_GATEWAY_TOKEN: token,
+      OPENCLAW_GATEWAY_HOST: "127.0.0.1",
+      OPENCLAW_SKIP_CHANNELS: "1"
+    }
+  });
+  if (childProcess.stdout) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: childProcess.stdout });
+    rl.on("line", (line) => console.log(`[OpenClaw stdout] ${line}`));
+  }
+  if (childProcess.stderr) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: childProcess.stderr });
+    rl.on("line", (line) => console.log(`[OpenClaw stderr] ${line}`));
+  }
+  childProcess.on("exit", (code, signal) => {
+    console.log(`[OpenClaw] Process exited: code=${code}, signal=${signal}`);
+    childProcess = null;
+    if (processStatus !== "stopped" && processStatus !== "restarting") {
+      processStatus = "crashed";
+      emit("openclaw://status-changed", { status: "crashed" });
+    }
+  });
+  await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+  if (childProcess && !childProcess.killed) {
+    processStatus = "running";
+    startedAt = Date.now();
+    restartCount = 0;
+    emit("openclaw://status-changed", { status: "running" });
+    connectWebSocket();
+    startProcessMonitor();
+  } else {
+    processStatus = "crashed";
+    emit("openclaw://status-changed", { status: "crashed" });
+    throw new Error("OpenClaw process failed to start");
+  }
+}
+async function openclawStop(_params) {
+  processStatus = "stopped";
+  emit("openclaw://status-changed", { status: "stopped" });
+  stopProcessMonitor();
+  if (wsClient) {
+    wsClient.close();
+    wsClient = null;
+  }
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+  if (childProcess) {
+    childProcess.kill("SIGTERM");
+    const proc = childProcess;
+    setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+    }, 5e3);
+    childProcess = null;
+  }
+  startedAt = null;
+}
+async function openclawRestart(_params) {
+  await openclawStop({});
+  await new Promise((resolve3) => setTimeout(resolve3, 500));
+  await openclawStart({});
+}
+async function openclawStatus(_params) {
+  return {
+    status: processStatus,
+    port: processStatus === "running" ? port : null,
+    uptimeSecs: startedAt ? Math.floor((Date.now() - startedAt) / 1e3) : null,
+    channels,
+    restartCount
+  };
+}
+async function openclawListChannels(_params) {
+  if (processStatus !== "running") return [];
+  const entrypoint = await findOpenClawEntrypoint();
+  return new Promise((resolve3) => {
+    execFile3(
+      "node",
+      [entrypoint, "channels", "status", "--json"],
+      { cwd: OPENCLAW_DIR, timeout: 1e4 },
+      (err, stdout) => {
+        if (err) {
+          console.error("[OpenClaw] Failed to list channels:", err);
+          resolve3([]);
+          return;
+        }
+        try {
+          const data = JSON.parse(stdout);
+          const result = [];
+          const accounts = data.channelAccounts || {};
+          for (const [id, info] of Object.entries(accounts)) {
+            const ch = info;
+            result.push({
+              id,
+              platform: id.split(":")[0] || id,
+              displayName: ch.label || id,
+              status: ch.running ? "connected" : "disconnected",
+              errorMessage: ch.error
+            });
+          }
+          channels.length = 0;
+          channels.push(...result);
+          resolve3(result);
+        } catch {
+          resolve3([]);
+        }
+      }
+    );
+  });
+}
+async function openclawConnectChannel(params) {
+  const { platform: plat, credentials } = params;
+  switch (plat) {
+    case "signal":
+      if (!credentials?.phone) throw new Error("Signal requires a phone number");
+      break;
+    case "telegram":
+      if (!credentials?.botToken) throw new Error("Telegram requires a bot token");
+      break;
+    case "discord":
+      if (!credentials?.botToken) throw new Error("Discord requires a bot token");
+      break;
+    case "slack":
+      if (!credentials?.botToken || !credentials?.appToken)
+        throw new Error("Slack requires both botToken and appToken");
+      break;
+  }
+  let config = {};
+  try {
+    config = JSON.parse(await readFile3(CONFIG_PATH, "utf-8"));
+  } catch {
+  }
+  if (!config.channels) config.channels = {};
+  switch (plat) {
+    case "signal":
+      config.channels.signal = {
+        enabled: true,
+        account: credentials.phone
+      };
+      break;
+    case "telegram":
+      config.channels.telegram = {
+        enabled: true,
+        botToken: credentials.botToken
+      };
+      break;
+    case "discord":
+      config.channels.discord = {
+        enabled: true,
+        botToken: credentials.botToken
+      };
+      break;
+    case "slack":
+      config.channels.slack = {
+        enabled: true,
+        botToken: credentials.botToken,
+        appToken: credentials.appToken
+      };
+      break;
+    case "whatsapp":
+      config.channels.whatsapp = { enabled: true };
+      break;
+    default:
+      config.channels[plat] = { enabled: true, ...credentials };
+  }
+  if (hookToken) config.hookToken = hookToken;
+  await mkdir2(OPENCLAW_DIR, { recursive: true });
+  await writeFile3(CONFIG_PATH, JSON.stringify(config, null, 2), {
+    mode: 384
+  });
+  return { success: true, platform: plat };
+}
+async function openclawDisconnectChannel(params) {
+  const { channelId } = params;
+  const entrypoint = await findOpenClawEntrypoint();
+  return new Promise((resolve3, reject) => {
+    execFile3(
+      "node",
+      [entrypoint, "channels", "remove", "--channel", channelId, "--delete"],
+      { cwd: OPENCLAW_DIR, timeout: 1e4 },
+      (err) => {
+        if (err) reject(new Error(`Failed to disconnect: ${err.message}`));
+        else resolve3();
+      }
+    );
+  });
+}
+async function openclawSetTrust(params) {
+  const { channelId, trustLevel, agentMode } = params;
+  trustSettings.set(channelId, { trustLevel, agentMode });
+  const settings = await loadSettings();
+  const trust = settings.openclawTrust || {};
+  trust[channelId] = { trustLevel, agentMode };
+  settings.openclawTrust = trust;
+  await saveSettings(settings);
+}
+async function openclawSend(params) {
+  const { channel, to, message } = params;
+  if (processStatus !== "running" || !port || !hookToken) {
+    throw new Error("OpenClaw is not running");
+  }
+  const key = `${channel}:${to}`;
+  const trust = trustSettings.get(channel);
+  if (trust?.trustLevel === "approval-required" && !approvedIds.has(key)) {
+    emit("openclaw://approval-needed", {
+      id: `${key}:${Date.now()}`,
+      channel,
+      to,
+      message,
+      platform: channel.split(":")[0] || channel
+    });
+    throw new Error("Message requires approval");
+  }
+  approvedIds.delete(key);
+  const url = `http://127.0.0.1:${port}/hooks/agent`;
+  const body = JSON.stringify({ message, channel, to });
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${hookToken}`
+    },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`OpenClaw send failed: ${response.status}`);
+  }
+  const result = await response.text();
+  return result;
+}
+async function openclawGrantApproval(params) {
+  const { channel, to } = params;
+  approvedIds.add(`${channel}:${to}`);
+}
+async function openclawGetQr(params) {
+  const { platform: plat } = params;
+  const entrypoint = await findOpenClawEntrypoint();
+  return new Promise((resolve3, reject) => {
+    execFile3(
+      "node",
+      [entrypoint, "channels", "qr", "--platform", plat, "--json"],
+      { cwd: OPENCLAW_DIR, timeout: 3e4 },
+      (err, stdout) => {
+        if (err) reject(new Error(`Failed to get QR: ${err.message}`));
+        else {
+          try {
+            const data = JSON.parse(stdout);
+            resolve3(data.qr || data.qrCode || stdout.trim());
+          } catch {
+            resolve3(stdout.trim());
+          }
+        }
+      }
+    );
+  });
+}
+
+// src/handlers/sync.ts
+import { watch } from "fs";
+var watcher = null;
+var watchingPath = null;
+async function startWatching(params) {
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+    watchingPath = null;
+  }
+  watchingPath = params.path;
+  watcher = watch(
+    params.path,
+    { recursive: true },
+    (eventType, filename) => {
+      if (!filename) return;
+      if (filename.includes("node_modules") || filename.includes(".git") || filename.endsWith(".DS_Store")) {
+        return;
+      }
+      const filePath = filename.startsWith("/") ? filename : `${params.path}/${filename}`;
+      emit("file-changed", {
+        paths: [filePath],
+        kind: eventType
+      });
+      emit("sync-status", {
+        status: "syncing",
+        message: `File changed: ${filePath}`,
+        watchingPath
+      });
+      setTimeout(() => {
+        emit("sync-status", {
+          status: "synced",
+          message: null,
+          watchingPath
+        });
+      }, 500);
+    }
+  );
+  watcher.on("error", (error) => {
+    emit("sync-status", {
+      status: "error",
+      message: `Watch error: ${error}`,
+      watchingPath: null
+    });
+  });
+  emit("sync-status", {
+    status: "synced",
+    message: `Watching: ${params.path}`,
+    watchingPath: params.path
+  });
+}
+async function stopWatching() {
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+    watchingPath = null;
+  }
+  emit("sync-status", {
+    status: "idle",
+    message: null,
+    watchingPath: null
+  });
+}
+
+// src/handlers/wallet.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import {
+  privateKeyToAccount
+} from "viem/accounts";
+import {
+  createPublicClient,
+  http,
+  formatUnits,
+  toHex,
+  isHex,
+  getAddress
+} from "viem";
+import { base } from "viem/chains";
+var SEREN_DIR = join5(homedir4(), ".seren-local");
+var WALLET_FILE = join5(SEREN_DIR, "data", "crypto-wallet.json");
+var USDC_CONTRACT_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var BASE_RPC_URL = "https://mainnet.base.org";
+async function loadStore() {
+  try {
+    const data = await readFile4(WALLET_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function saveStore(store) {
+  await mkdir3(join5(SEREN_DIR, "data"), { recursive: true });
+  await writeFile4(WALLET_FILE, JSON.stringify(store), "utf-8");
+}
+async function clearStore() {
+  try {
+    await writeFile4(WALLET_FILE, "{}", "utf-8");
+  } catch {
+  }
+}
+function loadAccount(store) {
+  let key = store.privateKey;
+  if (!key.startsWith("0x")) {
+    key = `0x${key}`;
+  }
+  return privateKeyToAccount(key);
+}
+function chainIdFromNetwork(network) {
+  const eip155Match = network.match(/^eip155:(\d+)$/);
+  if (eip155Match) return BigInt(eip155Match[1]);
+  const map = {
+    base: 8453n,
+    "base-sepolia": 84532n,
+    ethereum: 1n,
+    "ethereum-sepolia": 11155111n,
+    avalanche: 43114n,
+    "avalanche-fuji": 43113n
+  };
+  return map[network] ?? null;
+}
+function parseRequirements(json) {
+  const body = JSON.parse(json);
+  if (body.minimumRequired !== void 0 && body.currentBalance !== void 0) {
+    throw new Error("Prepaid payment not supported for wallet signing");
+  }
+  const version = body.x402Version;
+  if (!version) throw new Error("Missing x402Version");
+  if (version === 1) {
+    const accepts = body.accepts ?? [];
+    const first = accepts[0];
+    return {
+      x402Version: 1,
+      resource: first ? {
+        url: first.resource,
+        description: first.description,
+        mimeType: first.mimeType ?? "application/json"
+      } : null,
+      options: accepts.map(
+        (opt) => ({
+          scheme: opt.scheme,
+          network: opt.network,
+          asset: opt.asset,
+          amount: opt.maxAmountRequired ?? opt.amount,
+          payTo: opt.payTo,
+          maxTimeoutSeconds: opt.maxTimeoutSeconds,
+          extra: opt.extra ?? {}
+        })
+      )
+    };
+  }
+  if (version === 2) {
+    return {
+      x402Version: 2,
+      resource: body.resource ?? null,
+      options: (body.accepts ?? []).map(
+        (opt) => ({
+          scheme: opt.scheme,
+          network: opt.network,
+          asset: opt.asset,
+          amount: opt.amount,
+          payTo: opt.payTo,
+          maxTimeoutSeconds: opt.maxTimeoutSeconds,
+          extra: opt.extra ?? {}
+        })
+      )
+    };
+  }
+  throw new Error(`Unsupported x402Version: ${version}`);
+}
+var transferWithAuthorizationTypes = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function getExtra(option, ...path) {
+  let current = option.extra;
+  for (const key of path) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+async function signPayload(account, requirements, option) {
+  const chainId = chainIdFromNetwork(option.network);
+  if (!chainId) throw new Error(`Unsupported network: ${option.network}`);
+  const typedVC = getExtra(
+    option,
+    "eip712TypedData",
+    "domain",
+    "verifyingContract"
+  );
+  if (typedVC && typedVC.toLowerCase() !== option.asset.toLowerCase()) {
+    throw new Error(
+      `Mismatched verifyingContract (${typedVC}) for asset ${option.asset}`
+    );
+  }
+  const verifyingContract = getAddress(
+    typedVC ?? option.asset
+  );
+  const domainName = getExtra(option, "name") ?? getExtra(option, "eip712TypedData", "domain", "name") ?? "USD Coin";
+  const domainVersion = getExtra(option, "version") ?? getExtra(option, "eip712TypedData", "domain", "version") ?? "2";
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  const validAfterStr = getExtra(
+    option,
+    "eip712TypedData",
+    "message",
+    "validAfter"
+  );
+  const validBeforeStr = getExtra(
+    option,
+    "eip712TypedData",
+    "message",
+    "validBefore"
+  );
+  const validAfter = validAfterStr ? BigInt(validAfterStr) : now - 60n;
+  const validBefore = validBeforeStr ? BigInt(validBeforeStr) : now + BigInt(option.maxTimeoutSeconds);
+  const nonceStr = getExtra(option, "eip712TypedData", "message", "nonce");
+  let nonce;
+  if (nonceStr && isHex(nonceStr) && nonceStr.length === 66) {
+    nonce = nonceStr;
+  } else {
+    nonce = toHex(randomBytes2(32), { size: 32 });
+  }
+  const domain = {
+    name: domainName,
+    version: domainVersion,
+    chainId,
+    verifyingContract
+  };
+  const message = {
+    from: account.address,
+    to: getAddress(option.payTo),
+    value: BigInt(option.amount),
+    validAfter,
+    validBefore,
+    nonce
+  };
+  const signature = await account.signTypedData({
+    domain,
+    types: transferWithAuthorizationTypes,
+    primaryType: "TransferWithAuthorization",
+    message
+  });
+  const authorization = {
+    from: account.address,
+    to: getAddress(option.payTo),
+    value: option.amount,
+    validAfter: validAfter.toString(),
+    validBefore: validBefore.toString(),
+    nonce
+  };
+  const payload = requirements.x402Version === 1 ? {
+    x402Version: 1,
+    scheme: option.scheme,
+    network: option.network,
+    payload: { signature, authorization }
+  } : {
+    x402Version: 2,
+    resource: requirements.resource,
+    accepted: option,
+    payload: { signature, authorization }
+  };
+  const headerValue = Buffer.from(JSON.stringify(payload)).toString("base64");
+  const headerName = requirements.x402Version === 1 ? "X-PAYMENT" : "PAYMENT-SIGNATURE";
+  return {
+    headerName,
+    headerValue,
+    x402Version: requirements.x402Version ?? 2
+  };
+}
+async function storeCryptoPrivateKey(params) {
+  const { privateKey } = params;
+  if (!privateKey) throw new Error("Empty private key");
+  let key = privateKey;
+  if (!key.startsWith("0x")) {
+    key = `0x${key}`;
+  }
+  const account = privateKeyToAccount(key);
+  const address = account.address;
+  await saveStore({ privateKey: key, walletAddress: address });
+  return address;
+}
+async function getCryptoWalletAddress() {
+  const store = await loadStore();
+  return store?.walletAddress ?? null;
+}
+async function clearCryptoWallet() {
+  await clearStore();
+}
+async function signX402Payment(params) {
+  const store = await loadStore();
+  if (!store?.privateKey) throw new Error("Wallet not configured");
+  const account = loadAccount(store);
+  const requirements = parseRequirements(params.requirementsJson);
+  const option = requirements.options[0];
+  if (!option) throw new Error("No x402 payment option in requirements");
+  return signPayload(account, requirements, option);
+}
+async function getCryptoUsdcBalance() {
+  const store = await loadStore();
+  if (!store?.walletAddress) throw new Error("Wallet not configured");
+  const client = createPublicClient({
+    chain: base,
+    transport: http(BASE_RPC_URL)
+  });
+  const balanceRaw = await client.readContract({
+    address: USDC_CONTRACT_BASE,
+    abi: [
+      {
+        name: "balanceOf",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }]
+      }
+    ],
+    functionName: "balanceOf",
+    args: [store.walletAddress]
+  });
+  const formatted = formatUnits(balanceRaw, 6);
+  const balance = Number.parseFloat(formatted).toFixed(2);
+  return {
+    balance,
+    balanceRaw: balanceRaw.toString(),
+    network: "Base"
+  };
+}
+
+// src/handlers/index.ts
+function registerAllHandlers() {
+  registerHandler("list_directory", listDirectory);
+  registerHandler("read_file", readFile2);
+  registerHandler("read_file_base64", readFileBase64);
+  registerHandler("write_file", writeFile2);
+  registerHandler("path_exists", pathExists);
+  registerHandler("is_directory", isDirectory);
+  registerHandler("create_file", createFile);
+  registerHandler("create_directory", createDirectory);
+  registerHandler("delete_path", deletePath);
+  registerHandler("rename_path", renamePath);
+  registerHandler("open_folder_dialog", openFolderDialog);
+  registerHandler("open_file_dialog", openFileDialog);
+  registerHandler("save_file_dialog", saveFileDialog);
+  registerHandler("reveal_in_file_manager", revealInFileManager);
+  registerHandler("acp_spawn", acpSpawn);
+  registerHandler("acp_prompt", acpPrompt);
+  registerHandler("acp_cancel", acpCancel);
+  registerHandler("acp_terminate", acpTerminate);
+  registerHandler("acp_list_sessions", acpListSessions);
+  registerHandler("acp_set_permission_mode", acpSetPermissionMode);
+  registerHandler("acp_respond_to_permission", acpRespondToPermission);
+  registerHandler("acp_respond_to_diff_proposal", acpRespondToDiffProposal);
+  registerHandler("acp_get_available_agents", acpGetAvailableAgents);
+  registerHandler("acp_check_agent_available", acpCheckAgentAvailable);
+  registerHandler("acp_ensure_claude_cli", acpEnsureClaudeCli);
+  registerHandler("openclaw_start", openclawStart);
+  registerHandler("openclaw_stop", openclawStop);
+  registerHandler("openclaw_restart", openclawRestart);
+  registerHandler("openclaw_status", openclawStatus);
+  registerHandler("openclaw_list_channels", openclawListChannels);
+  registerHandler("openclaw_connect_channel", openclawConnectChannel);
+  registerHandler("openclaw_disconnect_channel", openclawDisconnectChannel);
+  registerHandler("openclaw_set_trust", openclawSetTrust);
+  registerHandler("openclaw_send", openclawSend);
+  registerHandler("openclaw_grant_approval", openclawGrantApproval);
+  registerHandler("openclaw_get_qr", openclawGetQr);
+  registerHandler("get_setting", getSetting);
+  registerHandler("set_setting", setSetting);
+  registerHandler("store_crypto_private_key", storeCryptoPrivateKey);
+  registerHandler("get_crypto_wallet_address", getCryptoWalletAddress);
+  registerHandler("clear_crypto_wallet", clearCryptoWallet);
+  registerHandler("sign_x402_payment", signX402Payment);
+  registerHandler("get_crypto_usdc_balance", getCryptoUsdcBalance);
+  registerHandler("start_watching", startWatching);
+  registerHandler("stop_watching", stopWatching);
+  registerHandler("init_project_index", initProjectIndex);
+  registerHandler("get_index_status", getIndexStatus);
+  registerHandler("has_project_index", hasProjectIndex);
+  registerHandler("search_codebase", searchCodebase);
+  registerHandler("file_needs_reindex", fileNeedsReindex2);
+  registerHandler("delete_file_index", deleteFileIndex);
+  registerHandler("index_chunks", indexChunks);
+  registerHandler("discover_project_files", discoverProjectFiles);
+  registerHandler("chunk_file", chunkFile2);
+  registerHandler("estimate_indexing", estimateIndexing2);
+  registerHandler("compute_file_hash", computeFileHash);
+  registerHandler("get_embedding_dimension", getEmbeddingDimension);
+  registerHandler("mcp_disconnect", mcpDisconnect);
+  registerHandler("mcp_read_resource", mcpReadResource);
+  registerHandler("create_conversation", createConversation);
+  registerHandler("get_conversations", getConversations);
+  registerHandler("get_conversation", getConversation);
+  registerHandler("update_conversation", updateConversation);
+  registerHandler("archive_conversation", archiveConversation);
+  registerHandler("delete_conversation", deleteConversation);
+  registerHandler("save_message", saveMessage);
+  registerHandler("get_messages", getMessages);
+}
+
+// src/update-check.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function getInstalledVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync2(join6(__dirname, "..", "package.json"), "utf-8")
+    );
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function getLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch("https://registry.npmjs.org/@serendb/runtime/latest", {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+function checkForUpdates() {
+  const current = getInstalledVersion();
+  getLatestVersion().then((latest) => {
+    if (latest && isNewer(latest, current)) {
+      console.log("");
+      console.log(`  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`);
+      console.log(`  \u2551  Update available: v${current} \u2192 v${latest.padEnd(10)}            \u2551`);
+      console.log(`  \u2551  Run: npm update -g @serendb/runtime                \u2551`);
+      console.log(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`);
+      console.log("");
+    }
+  }).catch(() => {
+  });
+}
+
+// src/server.ts
+var PORT = Number(process.env.SEREN_PORT) || 19420;
+var NO_OPEN = process.argv.includes("--no-open");
+var AUTH_TOKEN = process.env.SEREN_RUNTIME_TOKEN || randomBytes3(32).toString("hex");
+var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
+var PUBLIC_DIR = join7(__dirname2, "..", "public");
+function computeBuildHash() {
+  try {
+    const indexPath = join7(PUBLIC_DIR, "index.html");
+    const content = readFileSync3(indexPath, "utf-8");
+    return createHash3("sha256").update(content).digest("hex").slice(0, 12);
+  } catch {
+    return "unknown";
+  }
+}
+var BUILD_HASH = computeBuildHash();
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm"
+};
+function serveHtml(res) {
+  const indexPath = join7(PUBLIC_DIR, "index.html");
+  try {
+    let html = readFileSync3(indexPath, "utf-8");
+    html = html.replace(
+      "<head>",
+      `<head><meta name="seren-build-hash" content="${BUILD_HASH}">`
+    );
+    res.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      "Pragma": "no-cache",
+      "Expires": "0"
+    });
+    res.end(html);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function serveStatic(urlPath, res) {
+  const safePath = urlPath.split("?")[0].replace(/\.\./g, "");
+  if (safePath === "/" || safePath === "/index.html") {
+    return serveHtml(res);
+  }
+  const filePath = join7(PUBLIC_DIR, safePath);
+  if (!filePath.startsWith(PUBLIC_DIR)) {
+    return false;
+  }
+  try {
+    const stat2 = statSync2(filePath);
+    if (stat2.isFile()) {
+      const ext = extname2(filePath).toLowerCase();
+      const mime = MIME_TYPES[ext] || "application/octet-stream";
+      const content = readFileSync3(filePath);
+      res.writeHead(200, { "Content-Type": mime, "Cache-Control": "public, max-age=3600" });
+      res.end(content);
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function serveSpaFallback(res) {
+  return serveHtml(res);
+}
+function openBrowser(url) {
+  const cmd = platform3() === "darwin" ? `open "${url}"` : platform3() === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec2(cmd, (err) => {
+    if (err) console.log(`[Seren Local] Could not open browser: ${err.message}`);
+  });
+}
+function isLocalhost(addr) {
+  return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+}
+var GATEWAY_HOST = "api.serendb.com";
+var MCP_GATEWAY_HOST = "mcp.serendb.com";
+function proxyToGateway(req, res, host) {
+  const targetPath = (req.url || "").replace(/^\/(api|mcp)/, "");
+  const chunks = [];
+  req.on("data", (chunk) => chunks.push(chunk));
+  req.on("end", () => {
+    const body = chunks.length > 0 ? Buffer.concat(chunks) : void 0;
+    const forwardHeaders = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (key === "host" || key === "origin" || key === "referer") continue;
+      if (value) forwardHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    forwardHeaders["host"] = host;
+    const proxyReq = httpsRequest(
+      {
+        hostname: host,
+        port: 443,
+        path: targetPath,
+        method: req.method,
+        headers: forwardHeaders
+      },
+      (proxyRes) => {
+        const responseHeaders = {};
+        for (const [key, value] of Object.entries(proxyRes.headers)) {
+          if (value) responseHeaders[key] = value;
+        }
+        responseHeaders["access-control-allow-origin"] = "*";
+        responseHeaders["access-control-allow-methods"] = "GET, POST, PUT, DELETE, OPTIONS";
+        responseHeaders["access-control-allow-headers"] = "Content-Type, Authorization";
+        res.writeHead(proxyRes.statusCode ?? 502, responseHeaders);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      console.error("[Seren Local] Gateway proxy error:", err.message);
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Gateway proxy error", message: err.message }));
+    });
+    if (body) proxyReq.write(body);
+    proxyReq.end();
+  });
+}
+var httpServer = createServer2((req, res) => {
+  if (!isLocalhost(req.socket.remoteAddress)) {
+    res.writeHead(403);
+    res.end("Forbidden: only localhost connections allowed");
+    return;
+  }
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  if (req.url?.startsWith("/api/") || req.url === "/api") {
+    proxyToGateway(req, res, GATEWAY_HOST);
+    return;
+  }
+  if (req.url?.startsWith("/mcp/") || req.url === "/mcp") {
+    proxyToGateway(req, res, MCP_GATEWAY_HOST);
+    return;
+  }
+  if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", version: "0.1.0", token: AUTH_TOKEN, buildHash: BUILD_HASH }));
+    return;
+  }
+  const urlPath = req.url || "/";
+  if (serveStatic(urlPath, res)) return;
+  if (serveSpaFallback(res)) return;
+  res.writeHead(404);
+  res.end();
+});
+var wss = new WebSocketServer({ server: httpServer });
+var authenticatedSockets = /* @__PURE__ */ new WeakSet();
+wss.on("connection", (ws, req) => {
+  if (!isLocalhost(req.socket.remoteAddress)) {
+    ws.close(4003, "Forbidden");
+    return;
+  }
+  console.log("[Seren Local] Browser connecting (awaiting auth)...");
+  const authTimeout = setTimeout(() => {
+    if (!authenticatedSockets.has(ws)) {
+      console.warn("[Seren Local] Auth timeout, closing connection");
+      ws.close(4001, "Authentication timeout");
+    }
+  }, 5e3);
+  ws.on("message", async (data) => {
+    const raw = typeof data === "string" ? data : data.toString();
+    if (!authenticatedSockets.has(ws)) {
+      clearTimeout(authTimeout);
+      try {
+        const authMsg = JSON.parse(raw);
+        if (authMsg.method === "auth" && authMsg.params?.token === AUTH_TOKEN) {
+          authenticatedSockets.add(ws);
+          addClient(ws);
+          console.log("[Seren Local] Browser authenticated");
+          if (authMsg.id != null) {
+            ws.send(JSON.stringify({ jsonrpc: "2.0", result: { authenticated: true }, id: authMsg.id }));
+          }
+          return;
+        }
+      } catch {
+      }
+      console.warn("[Seren Local] Invalid auth token, closing connection");
+      ws.close(4002, "Invalid auth token");
+      return;
+    }
+    const response = await handleMessage(raw);
+    if (response !== null) {
+      ws.send(response);
+    }
+  });
+  ws.on("close", () => {
+    clearTimeout(authTimeout);
+    console.log("[Seren Local] Browser disconnected");
+  });
+});
+var dataDir = join7(homedir5(), ".seren-local");
+mkdirSync2(dataDir, { recursive: true });
+initChatDb(join7(dataDir, "conversations.db"));
+registerAllHandlers();
+httpServer.listen(PORT, "127.0.0.1", () => {
+  const url = `http://127.0.0.1:${PORT}`;
+  const hasSpa = existsSync3(join7(PUBLIC_DIR, "index.html"));
+  console.log(`[Seren Local] Listening on ${url}`);
+  if (hasSpa) {
+    console.log(`[Seren Local] Serving app at ${url}`);
+    if (!NO_OPEN) openBrowser(url);
+  } else {
+    console.log("[Seren Local] No embedded SPA found (runtime/public/). Run build:embed to bundle the app.");
+  }
+  checkForUpdates();
+});
+export {
+  AUTH_TOKEN,
+  PORT,
+  httpServer,
+  wss
+};