@clawchatsai/connector 0.0.87 → 0.0.89

package/server.js

@@ -1,2392 +0,0 @@
-// ClawChats backend — built by esbuild, source: github.com/clawchatsai/connector
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// server/index.js
-import http from "node:http";
-import fs13 from "node:fs";
-import path14 from "node:path";
-import os5 from "node:os";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { WebSocket as WS2, WebSocketServer } from "ws";
-
-// server/bootstrap/native.js
-import { DatabaseSync as Database } from "node:sqlite";
-import { AsyncLocalStorage } from "node:async_hooks";
-var requestDbStore = new AsyncLocalStorage();
-
-// server/config.js
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { fileURLToPath } from "node:url";
-var HOME = os.homedir();
-var MAX_PREAMBLE_CHARS = 5e4;
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-function parseConfigField(field) {
-  const candidates = [path.join(__dirname, "config.js"), path.join(__dirname, "..", "config.js")];
-  for (const configPath of candidates) {
-    try {
-      const configText = fs.readFileSync(configPath, "utf8");
-      const match = configText.match(new RegExp(`${field}:\\s*['"]([^'"]+)['"]`));
-      if (match) return match[1];
-    } catch {
-    }
-  }
-  return null;
-}
-__name(parseConfigField, "parseConfigField");
-var AUTH_TOKEN = process.env.CLAWCHATS_AUTH_TOKEN || parseConfigField("authToken") || "";
-function discoverGatewayWsUrl() {
-  if (process.env.GATEWAY_WS_URL) return process.env.GATEWAY_WS_URL;
-  for (const cfgPath of [path.join(HOME, ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
-    try {
-      const raw = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
-      const port = raw.gateway?.port || raw.port;
-      const host = raw.gateway?.host || raw.host || "localhost";
-      if (port) return `ws://${host}:${port}`;
-    } catch {
-    }
-  }
-  return "ws://localhost:18789";
-}
-__name(discoverGatewayWsUrl, "discoverGatewayWsUrl");
-var GATEWAY_WS_URL = discoverGatewayWsUrl();
-var OPENCLAW_SESSIONS_DIR = process.env.OPENCLAW_SESSIONS_DIR || parseConfigField("sessionsDir") || path.join(HOME, ".openclaw", "agents", "main", "sessions");
-function getSessionsDirForAgent(agentId) {
-  if (!agentId || agentId === "main") return OPENCLAW_SESSIONS_DIR;
-  return path.join(HOME, ".openclaw", "agents", agentId, "sessions");
-}
-__name(getSessionsDirForAgent, "getSessionsDirForAgent");
-function validateAgent(agentId) {
-  if (!agentId) return "main";
-  if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) throw new Error("Invalid agent ID");
-  const agentDir = path.join(HOME, ".openclaw", "agents", agentId);
-  if (!fs.existsSync(agentDir)) throw new Error(`Agent not found: ${agentId}`);
-  return agentId;
-}
-__name(validateAgent, "validateAgent");
-
-// server/debug.js
-import fs2 from "node:fs";
-import path2 from "node:path";
-var DebugLogger = class {
-  static {
-    __name(this, "DebugLogger");
-  }
-  constructor(baseDir) {
-    this.baseDir = path2.join(baseDir, "..", "debug");
-    this.active = false;
-    this.sessionId = null;
-    this.wsStream = null;
-    this.originatingClient = null;
-  }
-  start(ts, originatingClient) {
-    if (this.active) return { error: "already-active", sessionId: this.sessionId };
-    this.sessionId = ts.replace(/[:.]/g, "-");
-    this.originatingClient = originatingClient;
-    fs2.mkdirSync(this.baseDir, { recursive: true });
-    this.wsStream = fs2.createWriteStream(path2.join(this.baseDir, `session-${this.sessionId}-ws.log`), { flags: "a" });
-    this.active = true;
-    console.log(`Debug recording started: ${this.sessionId}`);
-    return { sessionId: this.sessionId };
-  }
-  logFrame(direction, data) {
-    if (this.active && this.wsStream) this.wsStream.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${direction} ${data}
-`);
-  }
-  saveDump(payload) {
-    if (!this.sessionId) return { sessionId: null, files: [] };
-    const files = [];
-    const id = this.sessionId;
-    if (this.wsStream) {
-      this.wsStream.end();
-      this.wsStream = null;
-      files.push(`session-${id}-ws.log`);
-    }
-    let logContent = "";
-    for (const entry of payload.console || []) {
-      logContent += `${entry.ts} [${entry.level.toUpperCase()}] ${entry.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
-`;
-    }
-    for (const err of payload.errors || []) logContent += `${err.ts} [UNHANDLED] ${err.message}
-${err.stack || ""}
-`;
-    if (logContent) {
-      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-client.log`), logContent);
-      files.push(`session-${id}-client.log`);
-    }
-    if (payload.state) {
-      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-state.json`), JSON.stringify(payload.state, null, 2));
-      files.push(`session-${id}-state.json`);
-    }
-    if (payload.screenshot) {
-      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-screenshot.jpg`), Buffer.from(payload.screenshot, "base64"));
-      files.push(`session-${id}-screenshot.jpg`);
-    }
-    const savedId = id;
-    this.active = false;
-    this.sessionId = null;
-    this.originatingClient = null;
-    console.log(`Debug session saved: ${files.join(", ")}`);
-    return { sessionId: savedId, files };
-  }
-  handleClientDisconnect(ws) {
-    if (this.active && this.originatingClient === ws) {
-      console.log(`Debug session ${this.sessionId} auto-closed: client disconnected`);
-      if (this.wsStream) {
-        this.wsStream.write(`${(/* @__PURE__ */ new Date()).toISOString()} SYSTEM Client disconnected \u2014 session auto-closed
-`);
-        this.wsStream.end();
-        this.wsStream = null;
-      }
-      this.active = false;
-      this.sessionId = null;
-      this.originatingClient = null;
-    }
-  }
-};
-
-// server/gateway.js
-import path4 from "node:path";
-import { WebSocket as WS } from "ws";
-
-// server/bootstrap/identity.js
-import crypto from "node:crypto";
-import fs3 from "node:fs";
-import path3 from "node:path";
-var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
-function derivePublicKeyRaw(publicKeyPem) {
-  const spki = crypto.createPublicKey(publicKeyPem).export({ type: "spki", format: "der" });
-  if (spki.length === ED25519_SPKI_PREFIX.length + 32 && spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
-    return spki.subarray(ED25519_SPKI_PREFIX.length);
-  }
-  return spki;
-}
-__name(derivePublicKeyRaw, "derivePublicKeyRaw");
-function fingerprintPublicKey(publicKeyPem) {
-  return crypto.createHash("sha256").update(derivePublicKeyRaw(publicKeyPem)).digest("hex");
-}
-__name(fingerprintPublicKey, "fingerprintPublicKey");
-function base64UrlEncode(buf) {
-  return buf.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
-}
-__name(base64UrlEncode, "base64UrlEncode");
-function loadOrCreateDeviceIdentity(identityPath) {
-  try {
-    if (fs3.existsSync(identityPath)) {
-      const parsed = JSON.parse(fs3.readFileSync(identityPath, "utf8"));
-      if (parsed?.version === 1 && parsed.deviceId && parsed.publicKeyPem && parsed.privateKeyPem) return parsed;
-    }
-  } catch {
-  }
-  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
-  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
-  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
-  const identity = { version: 1, deviceId: fingerprintPublicKey(publicKeyPem), publicKeyPem, privateKeyPem, createdAtMs: Date.now() };
-  fs3.mkdirSync(path3.dirname(identityPath), { recursive: true });
-  fs3.writeFileSync(identityPath, JSON.stringify(identity, null, 2) + "\n", { mode: 384 });
-  return identity;
-}
-__name(loadOrCreateDeviceIdentity, "loadOrCreateDeviceIdentity");
-function buildDeviceAuth(identity, { clientId, clientMode, role, scopes, token, nonce }) {
-  const signedAt = Date.now();
-  const payload = ["v2", identity.deviceId, clientId, clientMode, role, scopes.join(","), String(signedAt), token || "", nonce].join("|");
-  const privateKey = crypto.createPrivateKey(identity.privateKeyPem);
-  const signature = base64UrlEncode(crypto.sign(null, Buffer.from(payload, "utf8"), privateKey));
-  const publicKeyB64Url = base64UrlEncode(derivePublicKeyRaw(identity.publicKeyPem));
-  return { id: identity.deviceId, publicKey: publicKeyB64Url, signature, signedAt, nonce };
-}
-__name(buildDeviceAuth, "buildDeviceAuth");
-
-// server/util/helpers.js
-function syncThreadUnreadCount(db, threadId) {
-  const count = db.prepare("SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?").get(threadId).c;
-  db.prepare("UPDATE threads SET unread_count = ? WHERE id = ?").run(count, threadId);
-  return count;
-}
-__name(syncThreadUnreadCount, "syncThreadUnreadCount");
-function parseSessionKey(sessionKey) {
-  if (!sessionKey) return null;
-  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
-  if (!match) return null;
-  return { agent: match[1], workspace: match[2], threadId: match[3] };
-}
-__name(parseSessionKey, "parseSessionKey");
-function extractContent(message) {
-  if (!message) return "";
-  if (typeof message.content === "string") return message.content;
-  if (Array.isArray(message.content)) {
-    return message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
-  }
-  return "";
-}
-__name(extractContent, "extractContent");
-function isSilentReplyExact(text, token = "NO_REPLY") {
-  if (!text) return false;
-  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
-}
-__name(isSilentReplyExact, "isSilentReplyExact");
-function isSilentReplyPrefix(text, token = "NO_REPLY") {
-  if (!text) return false;
-  const trimmed = text.trimStart();
-  if (!trimmed) return false;
-  if (trimmed !== trimmed.toUpperCase()) return false;
-  const normalized = trimmed.toUpperCase();
-  if (normalized.length < 2 || /[^A-Z_]/.test(normalized)) return false;
-  const tokenUpper = token.toUpperCase();
-  if (!tokenUpper.startsWith(normalized)) return false;
-  if (normalized.includes("_")) return true;
-  return tokenUpper === "NO_REPLY" && normalized === "NO";
-}
-__name(isSilentReplyPrefix, "isSilentReplyPrefix");
-function stripTrailingSentinel(text, token = "NO_REPLY") {
-  if (!text) return text;
-  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), "").trim();
-}
-__name(stripTrailingSentinel, "stripTrailingSentinel");
-function stripFinalTags(text) {
-  return text ? text.replace(/<\s*\/?\s*final\s*>/gi, "") : text;
-}
-__name(stripFinalTags, "stripFinalTags");
-function sanitizeAssistantContent(text) {
-  if (!text) return text;
-  let out = stripFinalTags(text);
-  out = out.replace(/^(?:[ \t]*\r?\n)+/, "");
-  if (out.includes("NO_REPLY")) out = stripTrailingSentinel(out, "NO_REPLY");
-  if (out.includes("HEARTBEAT_OK")) out = stripTrailingSentinel(out, "HEARTBEAT_OK");
-  return out;
-}
-__name(sanitizeAssistantContent, "sanitizeAssistantContent");
-function generateActivitySummary(steps) {
-  const toolSteps = steps.filter((s) => s.type === "tool" && s.phase !== "result" && s.phase !== "update");
-  const hasThinking = steps.some((s) => s.type === "thinking" && s.text);
-  const hasNarration = steps.some((s) => s.type === "assistant" && s.text?.trim());
-  if (toolSteps.length === 0 && !hasThinking && !hasNarration) return null;
-  if (toolSteps.length === 0 && hasThinking) return "Reasoned through the problem";
-  if (toolSteps.length === 0 && hasNarration) return "Processed in multiple steps";
-  const counts = {};
-  for (const s of toolSteps) {
-    const name = s.name || "unknown";
-    counts[name] = (counts[name] || 0) + 1;
-  }
-  const toolNames = { web_search: "searched the web", web_fetch: "fetched web pages", Read: "read files", read: "read files", Write: "wrote files", write: "wrote files", Edit: "edited files", edit: "edited files", exec: "ran commands", Bash: "ran commands", browser: "browsed the web", memory_search: "searched memory", memory_store: "saved to memory", image: "analyzed images", message: "sent messages", sessions_spawn: "spawned sub-agents", cron: "managed cron jobs", Grep: "searched code", grep: "searched code", Glob: "found files", glob: "found files" };
-  const parts = [];
-  for (const [name, count] of Object.entries(counts)) {
-    const friendly = toolNames[name];
-    parts.push(friendly ? count > 1 ? `${friendly} (${count}\xD7)` : friendly : count > 1 ? `used ${name} (${count}\xD7)` : `used ${name}`);
-  }
-  if (parts.length === 0) return null;
-  if (parts.length === 1) return parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
-  const last = parts.pop();
-  return (parts.join(", ") + " and " + last).replace(/^./, (c) => c.toUpperCase());
-}
-__name(generateActivitySummary, "generateActivitySummary");
-function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
-  if (!log._parsed) log._parsed = parseSessionKey(log.sessionKey);
-  const parsed = log._parsed;
-  if (!parsed) return;
-  const db = getDbFn(parsed.workspace);
-  if (!db) return;
-  const cleanSteps = log.steps.map((s) => {
-    const c = { ...s };
-    delete c._sealed;
-    return c;
-  });
-  const summary = generateActivitySummary(log.steps);
-  const now = Date.now();
-  if (!log._messageId) {
-    const thread = db.prepare("SELECT id FROM threads WHERE id = ?").get(parsed.threadId);
-    if (!thread) return;
-    const messageId = `gw-activity-${runId}`;
-    const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
-    try {
-      db.prepare(`INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)`).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
-      log._messageId = messageId;
-      broadcastFn(JSON.stringify({ type: "clawchats", event: "message-saved", threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now }));
-    } catch (err) {
-      console.error(`[activity] Failed to write activity ${messageId}:`, err.message);
-    }
-  } else {
-    const existing = db.prepare("SELECT metadata FROM messages WHERE id = ?").get(log._messageId);
-    const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
-    metadata.activityLog = cleanSteps;
-    metadata.activitySummary = summary;
-    metadata.pending = true;
-    db.prepare("UPDATE messages SET metadata = ? WHERE id = ?").run(JSON.stringify(metadata), log._messageId);
-  }
-}
-__name(writeActivityToDb, "writeActivityToDb");
-
-// server/gateway.js
-var GatewayClient = class {
-  static {
-    __name(this, "GatewayClient");
-  }
-  constructor({ getDb, getWorkspaces, dataDir, debugLogger, gatewayWsUrl, authToken, mediaStash }) {
-    this.getDb = getDb;
-    this.getWorkspaces = getWorkspaces;
-    this.dataDir = dataDir;
-    this.debugLogger = debugLogger;
-    this.gatewayWsUrl = gatewayWsUrl;
-    this.authToken = authToken;
-    this.mediaStash = mediaStash;
-    this.ws = null;
-    this.connected = false;
-    this.reconnectAttempts = 0;
-    this.maxReconnectDelay = 3e4;
-    this.browserClients = /* @__PURE__ */ new Map();
-    this._externalBroadcastTargets = [];
-    this.streamState = /* @__PURE__ */ new Map();
-    this.activityLogs = /* @__PURE__ */ new Map();
-    this._pendingTitleGens = /* @__PURE__ */ new Map();
-    setInterval(() => {
-      const cutoff = Date.now() - 10 * 60 * 1e3;
-      for (const [runId, log] of this.activityLogs) {
-        if (log.startTime < cutoff) {
-          if (log._messageId) {
-            const db = this.getDb(log._parsed?.workspace);
-            if (db) db.prepare(`UPDATE messages SET content = '[Response interrupted]', metadata = json_remove(metadata, '$.pending') WHERE id = ? AND content = ''`).run(log._messageId);
-          }
-          this.activityLogs.delete(runId);
-        }
-      }
-    }, 5 * 60 * 1e3);
-  }
-  connect() {
-    if (this.ws && (this.ws.readyState === WS.CONNECTING || this.ws.readyState === WS.OPEN)) return;
-    console.log(`Connecting to gateway at ${this.gatewayWsUrl}...`);
-    this.ws = new WS(this.gatewayWsUrl);
-    this.ws.on("open", () => {
-      console.log("Gateway WebSocket connected");
-      this.reconnectAttempts = 0;
-    });
-    this.ws.on("message", (data) => this.handleGatewayMessage(data.toString()));
-    this.ws.on("close", () => {
-      console.log("Gateway WebSocket closed");
-      this.connected = false;
-      this.broadcastGatewayStatus(false);
-      this.scheduleReconnect();
-    });
-    this.ws.on("error", (err) => console.error("Gateway WebSocket error:", err.message));
-  }
-  handleGatewayMessage(data) {
-    this.debugLogger.logFrame("GW\u2192SRV", data);
-    let msg;
-    try {
-      msg = JSON.parse(data);
-    } catch {
-      console.error("Invalid JSON from gateway:", data);
-      return;
-    }
-    if (msg.type === "event" && msg.event === "connect.challenge") {
-      const identity = loadOrCreateDeviceIdentity(path4.join(this.dataDir, "device-identity.json"));
-      const device = buildDeviceAuth(identity, { clientId: "gateway-client", clientMode: "backend", role: "operator", scopes: ["operator.read", "operator.write", "operator.admin"], token: this.authToken, nonce: msg.payload?.nonce || "" });
-      this.ws.send(JSON.stringify({ type: "req", id: "gw-connect-1", method: "connect", params: { minProtocol: 3, maxProtocol: 3, client: { id: "gateway-client", version: "0.1.0", platform: "node", mode: "backend" }, role: "operator", scopes: ["operator.read", "operator.write", "operator.admin"], device, auth: { token: this.authToken }, caps: ["tool-events"] } }));
-      return;
-    }
-    if (msg.type === "res" && msg.payload?.type === "hello-ok") {
-      console.log("Gateway handshake complete");
-      this.connected = true;
-      this.broadcastGatewayStatus(true);
-    }
-    if (msg.type === "event" && msg.event === "chat" && msg.payload) {
-      this.handleChatEvent(msg.payload, data);
-    } else {
-      this.broadcastToBrowsers(data);
-    }
-    if (msg.type === "event" && msg.event === "agent" && msg.payload) this.handleAgentEvent(msg.payload);
-  }
-  handleChatEvent(params, rawData) {
-    const { sessionKey, state, message, seq } = params;
-    if (state === "delta") {
-      const parsed = parseSessionKey(sessionKey);
-      if (parsed) {
-        const existing = this.streamState.get(sessionKey) || { buffer: "", threadId: parsed.threadId, state: "streaming", held: [] };
-        existing.buffer += extractContent(message);
-        if (isSilentReplyPrefix(existing.buffer, "NO_REPLY") || isSilentReplyPrefix(existing.buffer, "HEARTBEAT_OK")) {
-          existing.held = existing.held || [];
-          existing.held.push(rawData);
-          this.streamState.set(sessionKey, existing);
-          return;
-        }
-        if (existing.held?.length > 0) {
-          for (const h of existing.held) this.broadcastToBrowsers(h);
-          existing.held = [];
-        }
-        this.streamState.set(sessionKey, existing);
-      }
-      this.broadcastToBrowsers(rawData);
-      return;
-    }
-    const streamEntry = this.streamState.get(sessionKey);
-    if (state === "final" || state === "aborted" || state === "error") this.streamState.delete(sessionKey);
-    if (sessionKey?.includes("__clawchats_title_")) {
-      if (state === "final") {
-        const content = extractContent(message);
-        if (content && this.handleTitleResponse(sessionKey, content)) return;
-      } else if (state === "error" || state === "aborted") {
-        for (const key of this._pendingTitleGens.keys()) {
-          if (sessionKey === key || sessionKey.includes(key)) {
-            this._pendingTitleGens.delete(key);
-            break;
-          }
-        }
-        return;
-      }
-    }
-    if (state === "final") {
-      const rawContent = extractContent(message);
-      if (isSilentReplyExact(rawContent, "NO_REPLY") || isSilentReplyExact(rawContent, "HEARTBEAT_OK")) return;
-      if (streamEntry?.held?.length > 0) for (const h of streamEntry.held) this.broadcastToBrowsers(h);
-      this.broadcastToBrowsers(rawData);
-      this.saveAssistantMessage(sessionKey, message, seq);
-      return;
-    }
-    if (state === "aborted" || state === "error") this.broadcastToBrowsers(rawData);
-    if (state === "error") this.saveErrorMarker(sessionKey, message);
-  }
-  saveAssistantMessage(sessionKey, message, seq) {
-    const parsed = parseSessionKey(sessionKey);
-    if (!parsed) return;
-    const ws = this.getWorkspaces();
-    if (!ws.workspaces[parsed.workspace]) {
-      console.log(`Ignoring response for deleted workspace: ${parsed.workspace}`);
-      return;
-    }
-    const db = this.getDb(parsed.workspace);
-    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(parsed.threadId)) {
-      console.log(`Ignoring response for deleted thread: ${parsed.threadId}`);
-      return;
-    }
-    let content = sanitizeAssistantContent(extractContent(message));
-    if (!content?.trim()) {
-      console.log(`Skipping empty assistant response for thread ${parsed.threadId}`);
-      return;
-    }
-    const pendingPaths = this.mediaStash?.get(sessionKey) ?? [];
-    this.mediaStash?.delete(sessionKey);
-    const IMAGE_EXTS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg", "ico", "avif", "tiff"]);
-    const AUDIO_EXTS = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "m4a", "flac", "aac", "opus", "wma"]);
-    const imagePaths = [], pendingAttachments = [];
-    for (const p of pendingPaths) {
-      const ext = (p.split(".").pop() || "").toLowerCase();
-      if (IMAGE_EXTS.has(ext)) imagePaths.push(p);
-      else pendingAttachments.push({ path: p, name: p.split("/").pop(), type: AUDIO_EXTS.has(ext) ? "audio" : "file" });
-    }
-    if (imagePaths.length > 0) content = content.trimEnd() + "\n\n" + imagePaths.map((p) => `![image](${p})`).join("\n");
-    if (pendingPaths.length > 0) console.log(`[clawchats] media-attach: ${imagePaths.length} image(s), ${pendingAttachments.length} attachment(s) for ${sessionKey}`);
-    const now = Date.now();
-    const pendingMsg = db.prepare(`SELECT id, metadata FROM messages WHERE thread_id = ? AND role = 'assistant' AND json_extract(metadata, '$.pending') = 1 ORDER BY timestamp DESC LIMIT 1`).get(parsed.threadId);
-    let messageId;
-    if (pendingMsg) {
-      const metadata = pendingMsg.metadata ? JSON.parse(pendingMsg.metadata) : {};
-      delete metadata.pending;
-      if (metadata.activityLog) {
-        const idx = metadata.activityLog.findLastIndex((s) => s.type === "assistant");
-        if (idx >= 0) metadata.activityLog.splice(idx, 1);
-        metadata.activitySummary = generateActivitySummary(metadata.activityLog);
-      }
-      if (pendingAttachments.length > 0) metadata.attachments = [...metadata.attachments || [], ...pendingAttachments];
-      db.prepare("UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?").run(content, JSON.stringify(metadata), now, pendingMsg.id);
-      messageId = pendingMsg.id;
-    } else {
-      messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
-      const newMeta = pendingAttachments.length > 0 ? JSON.stringify({ attachments: pendingAttachments }) : null;
-      db.prepare(`INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', ?, 'sent', ?, ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, metadata = COALESCE(excluded.metadata, metadata), timestamp = excluded.timestamp`).run(messageId, parsed.threadId, content, newMeta, now, now);
-    }
-    try {
-      db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(now, parsed.threadId);
-      db.prepare("INSERT OR IGNORE INTO unread_messages (thread_id, message_id, created_at) VALUES (?, ?, ?)").run(parsed.threadId, messageId, now);
-      syncThreadUnreadCount(db, parsed.threadId);
-      const threadInfo = db.prepare("SELECT title FROM threads WHERE id = ?").get(parsed.threadId);
-      const unreadCount = db.prepare("SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?").get(parsed.threadId).c;
-      const preview = content.length > 120 ? content.substring(0, 120) + "..." : content;
-      this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "message-saved", threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now, title: threadInfo?.title, preview, unreadCount, updatedContent: imagePaths.length > 0 ? content : void 0, updatedAttachments: pendingAttachments.length > 0 ? pendingAttachments : void 0 }));
-      this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "unread-update", workspace: parsed.workspace, threadId: parsed.threadId, messageId, action: "new", unreadCount, workspaceUnreadTotal: db.prepare("SELECT COALESCE(SUM(unread_count), 0) as total FROM threads").get().total, title: threadInfo?.title, preview, timestamp: now }));
-      console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (${pendingMsg ? "merged into pending" : "seq: " + seq})`);
-      const msgCount = db.prepare("SELECT COUNT(*) as c FROM messages WHERE thread_id = ?").get(parsed.threadId).c;
-      if (msgCount === 2 || threadInfo?.title === "New chat") this.generateThreadTitle(db, parsed.threadId, parsed.workspace, true);
-    } catch (e) {
-      console.error("Failed to save assistant message:", e.message);
-    }
-  }
-  saveErrorMarker(sessionKey, message) {
-    const parsed = parseSessionKey(sessionKey);
-    if (!parsed) return;
-    const ws = this.getWorkspaces();
-    if (!ws.workspaces[parsed.workspace]) return;
-    const db = this.getDb(parsed.workspace);
-    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(parsed.threadId)) return;
-    const now = Date.now();
-    try {
-      db.prepare("INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(`gw-error-${parsed.threadId}-${now}`, parsed.threadId, "system", `[error] ${message?.error || message?.content || "Unknown error"}`, "sent", '{"transient":true}', now, now);
-    } catch (e) {
-      console.error("Failed to save error marker:", e.message);
-    }
-  }
-  generateThreadTitle(db, threadId, workspace, skipHeuristic = false) {
-    if (!db.prepare("SELECT title FROM threads WHERE id = ?").get(threadId)) return;
-    const titleKey = `__clawchats_title_${threadId}`;
-    if (this._pendingTitleGens.has(titleKey)) return;
-    const firstUserMsg = db.prepare("SELECT content FROM messages WHERE thread_id = ? AND role = 'user' ORDER BY created_at ASC LIMIT 1").get(threadId);
-    if (!firstUserMsg?.content) return;
-    if (!skipHeuristic) {
-      const heuristic = firstUserMsg.content.replace(/\n.*/s, "").slice(0, 40).trim() + (firstUserMsg.content.length > 40 ? "..." : "");
-      db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(heuristic, threadId);
-      this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "thread-title-updated", threadId, workspace, title: heuristic }));
-    }
-    const messages = db.prepare("SELECT role, content FROM messages WHERE thread_id = ? ORDER BY created_at ASC LIMIT 6").all(threadId);
-    if (messages.length < 2) return;
-    const conversation = messages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content.length > 300 ? m.content.slice(0, 300) + "..." : m.content}`).join("\n\n");
-    const reqId = `title-${threadId}-${Date.now()}`;
-    this._pendingTitleGens.set(titleKey, { threadId, workspace, reqId });
-    setTimeout(() => {
-      if (this._pendingTitleGens.has(titleKey)) {
-        this._pendingTitleGens.delete(titleKey);
-        console.log(`Title gen timeout for ${threadId}`);
-      }
-    }, 3e4);
-    this.sendToGateway(JSON.stringify({ type: "req", id: reqId, method: "chat.send", params: { sessionKey: titleKey, message: `Based on this conversation, generate a concise 3-5 word title. Return ONLY the title text, no quotes, no explanation:
-
-${conversation}
-
-Title:`, deliver: false, idempotencyKey: reqId } }));
-  }
-  handleTitleResponse(sessionKey, content) {
-    let matchKey = null, pending = null;
-    for (const [key, val] of this._pendingTitleGens) {
-      if (sessionKey === key || sessionKey.includes(key)) {
-        matchKey = key;
-        pending = val;
-        break;
-      }
-    }
-    if (!pending) return false;
-    this._pendingTitleGens.delete(matchKey);
-    let title = content.trim().replace(/^["']|["']$/g, "").replace(/^Title:\s*/i, "").replace(/\n.*/s, "").trim();
-    if (title.length > 50) title = title.substring(0, 47) + "...";
-    if (!title || title.length >= 100) return true;
-    const db = this.getDb(pending.workspace);
-    db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(title, pending.threadId);
-    this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "thread-title-updated", threadId: pending.threadId, workspace: pending.workspace, title }));
-    console.log(`AI title generated for ${pending.threadId}: "${title}"`);
-    return true;
-  }
-  handleAgentEvent(payload) {
-    const { runId, stream, data, sessionKey } = payload;
-    if (!runId) return;
-    if (!this.activityLogs.has(runId)) this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
-    const log = this.activityLogs.get(runId);
-    if (stream === "assistant") {
-      const text = data?.text || "";
-      if (text) {
-        let seg = log._currentAssistantSegment;
-        if (!seg || seg._sealed) {
-          seg = { type: "assistant", timestamp: Date.now(), text, _sealed: false };
-          log._currentAssistantSegment = seg;
-          log.steps.push(seg);
-        } else seg.text = text;
-      }
-      return;
-    }
-    if (stream === "thinking") {
-      let step = log.steps.find((s) => s.type === "thinking");
-      if (step) step.text = data?.text || "";
-      else log.steps.push({ type: "thinking", timestamp: Date.now(), text: data?.text || "" });
-      writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
-      const now = Date.now();
-      if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
-        log._lastThinkingBroadcast = now;
-        this._broadcastActivityUpdate(runId, log);
-      }
-    }
-    if (stream === "tool") {
-      if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
-      const argsMeta = data?.args ? data.args.command || data.args.path || data.args.query || data.args.url || Object.values(data.args).find((v) => typeof v === "string") || "" : "";
-      const step = { type: "tool", timestamp: Date.now(), name: data?.name || "unknown", phase: data?.phase || "start", toolCallId: data?.toolCallId, meta: data?.meta || (argsMeta ? String(argsMeta) : void 0), isError: data?.isError || false };
-      if (data?.phase === "result") {
-        const existing = log.steps.findLast((s) => s.toolCallId === data.toolCallId && (s.phase === "start" || s.phase === "running"));
-        if (existing) {
-          existing.phase = "done";
-          existing.resultMeta = data?.meta;
-          existing.isError = data?.isError || false;
-          existing.durationMs = Date.now() - existing.timestamp;
-        } else {
-          step.phase = "done";
-          log.steps.push(step);
-        }
-      } else if (data?.phase === "update") {
-        const existing = log.steps.findLast((s) => s.toolCallId === data.toolCallId);
-        if (existing) {
-          if (data?.meta) existing.resultMeta = data.meta;
-          if (data?.isError) existing.isError = true;
-          existing.phase = "running";
-        }
-      } else log.steps.push(step);
-      writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
-      this._broadcastActivityUpdate(runId, log);
-    }
-    if (stream === "lifecycle" && (data?.phase === "end" || data?.phase === "error")) {
-      if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
-      const idx = log.steps.findLastIndex((s) => s.type === "assistant");
-      if (idx >= 0) log.steps.splice(idx, 1);
-      writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
-      this.activityLogs.delete(runId);
-    }
-  }
-  _broadcastActivityUpdate(runId, log) {
-    if (!log._parsed || !log._messageId) return;
-    const cleanSteps = log.steps.map((s) => {
-      const c = { ...s };
-      delete c._sealed;
-      return c;
-    });
-    this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "activity-updated", workspace: log._parsed.workspace, threadId: log._parsed.threadId, messageId: log._messageId, activityLog: cleanSteps, activitySummary: generateActivitySummary(log.steps) }));
-  }
-  broadcastToBrowsers(data) {
-    this.debugLogger.logFrame("SRV\u2192BR", data);
-    for (const client of this.browserClients.keys()) {
-      if (client.readyState === WS.OPEN) client.send(data);
-    }
-    for (const fn of this._externalBroadcastTargets) {
-      try {
-        fn(data);
-      } catch {
-      }
-    }
-  }
-  broadcastGatewayStatus(connected) {
-    this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "gateway-status", connected }));
-  }
-  sendToGateway(data) {
-    this.debugLogger.logFrame("SRV\u2192GW", data);
-    if (this.ws?.readyState === WS.OPEN) this.ws.send(data);
-    else console.error("Cannot send to gateway: not connected");
-  }
-  scheduleReconnect() {
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
-    this.reconnectAttempts++;
-    console.log(`Reconnecting to gateway in ${delay}ms (attempt ${this.reconnectAttempts})...`);
-    setTimeout(() => this.connect(), delay);
-  }
-  addBrowserClient(ws) {
-    this.browserClients.set(ws, { activeWorkspace: null, activeThreadId: null });
-    if (ws.readyState === WS.OPEN) {
-      ws.send(JSON.stringify({ type: "clawchats", event: "gateway-status", connected: this.connected }));
-      const streams = [];
-      for (const [sessionKey, state] of this.streamState.entries()) {
-        if (state.state === "streaming" && !(state.held?.length > 0)) streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
-      }
-      if (streams.length > 0) ws.send(JSON.stringify({ type: "clawchats", event: "stream-sync", streams }));
-    }
-  }
-  removeBrowserClient(ws) {
-    this.browserClients.delete(ws);
-  }
-  setActiveThread(ws, workspace, threadId) {
-    const client = ws ? this.browserClients.get(ws) : null;
-    if (client) {
-      client.activeWorkspace = workspace;
-      client.activeThreadId = threadId;
-    }
-    if (!workspace || !threadId) return;
-    try {
-      const wsData = this.getWorkspaces();
-      if (!wsData.workspaces[workspace]) return;
-      const db = this.getDb(workspace);
-      if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(threadId)) return;
-      const deleted = db.prepare("DELETE FROM unread_messages WHERE thread_id = ?").run(threadId);
-      if (deleted.changes > 0) {
-        syncThreadUnreadCount(db, threadId);
-        this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "unread-update", workspace, threadId, action: "clear", unreadCount: 0, workspaceUnreadTotal: db.prepare("SELECT COALESCE(SUM(unread_count), 0) as total FROM threads").get().total, timestamp: Date.now() }));
-      }
-    } catch (e) {
-      console.error("Failed to auto-clear unreads on active-thread:", e.message);
-    }
-  }
-  addBroadcastTarget(fn) {
-    this._externalBroadcastTargets.push(fn);
-  }
-  removeBroadcastTarget(fn) {
-    this._externalBroadcastTargets = this._externalBroadcastTargets.filter((f) => f !== fn);
-  }
-};
-
-// server/providers/memory.js
-import fs4 from "node:fs";
-import path5 from "node:path";
-import os2 from "node:os";
-function discoverMemoryConfig() {
-  const defaults = { provider: "qdrant", host: "localhost", port: 6333, collection: null };
-  let oc = null;
-  for (const cfgPath of [path5.join(os2.homedir(), ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
-    try {
-      oc = JSON.parse(fs4.readFileSync(cfgPath, "utf8"));
-      break;
-    } catch {
-    }
-  }
-  let cfg = { ...defaults };
-  if (oc) {
-    const vs = oc.plugins?.slots?.memory ? oc.plugins?.entries?.[oc.plugins.slots.memory]?.config?.oss?.vectorStore : null;
-    if (vs) {
-      if (vs.provider) cfg.provider = vs.provider;
-      if (vs.config?.host) cfg.host = vs.config.host;
-      if (vs.config?.port) cfg.port = vs.config.port;
-      if (vs.config?.collectionName) cfg.collection = vs.config.collectionName;
-      if (vs.config?.user) cfg.pgUser = vs.config.user;
-      if (vs.config?.password) cfg.pgPassword = vs.config.password;
-      if (vs.config?.dbname) cfg.pgDbName = vs.config.dbname;
-    }
-    const wsDir = oc.agents?.defaults?.workspace;
-    if (wsDir) cfg.workspaceDir = wsDir;
-  }
-  if (process.env.MEMORY_PROVIDER) cfg.provider = process.env.MEMORY_PROVIDER;
-  if (process.env.MEMORY_HOST || process.env.QDRANT_HOST) cfg.host = process.env.MEMORY_HOST || process.env.QDRANT_HOST;
-  if (process.env.MEMORY_PORT || process.env.QDRANT_PORT) cfg.port = parseInt(process.env.MEMORY_PORT || process.env.QDRANT_PORT, 10);
-  if (process.env.MEMORY_COLLECTION || process.env.QDRANT_COLLECTION) cfg.collection = process.env.MEMORY_COLLECTION || process.env.QDRANT_COLLECTION;
-  if (process.env.MEMORY_PG_URL) cfg.pgUrl = process.env.MEMORY_PG_URL;
-  if (process.env.QDRANT_URL && !process.env.MEMORY_HOST) {
-    try {
-      const u = new URL(process.env.QDRANT_URL);
-      cfg.host = u.hostname;
-      if (u.port) cfg.port = parseInt(u.port, 10);
-    } catch {
-    }
-  }
-  if (!cfg.workspaceDir) cfg.workspaceDir = path5.join(os2.homedir(), ".openclaw", "workspace");
-  return cfg;
-}
-__name(discoverMemoryConfig, "discoverMemoryConfig");
-async function autoDetectQdrantCollection(config) {
-  if (config.collection) return config.collection;
-  try {
-    const r = await fetch(`http://${config.host}:${config.port}/collections`, { signal: AbortSignal.timeout(3e3) });
-    const data = await r.json();
-    const found = (data.result?.collections || []).map((c) => c.name).find((n) => !n.includes("migration"));
-    if (found) {
-      console.log(`Memory: auto-detected Qdrant collection "${found}"`);
-      return found;
-    }
-  } catch {
-  }
-  console.log('Memory: Qdrant unreachable or no collections, falling back to "memories"');
-  return "memories";
-}
-__name(autoDetectQdrantCollection, "autoDetectQdrantCollection");
-function createQdrantProvider(config) {
-  const baseUrl = `http://${config.host}:${config.port}`;
-  let collection = config.collection;
-  return {
-    name: "qdrant",
-    config,
-    async init() {
-      collection = await autoDetectQdrantCollection(config);
-      config.collection = collection;
-    },
-    async list(limit, offset) {
-      const body = { limit, with_payload: true, with_vector: false };
-      if (offset) body.offset = offset;
-      const r = await fetch(`${baseUrl}/collections/${collection}/points/scroll`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
-      const data = await r.json();
-      return { memories: (data.result?.points || []).map((p) => ({ id: p.id, ...p.payload })), next_offset: data.result?.next_page_offset || null };
-    },
-    async search(query) {
-      const q = query.toLowerCase();
-      const matches = [];
-      let offset = null;
-      do {
-        const body = { limit: 100, with_payload: true, with_vector: false };
-        if (offset) body.offset = offset;
-        const r = await fetch(`${baseUrl}/collections/${collection}/points/scroll`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
-        const data = await r.json();
-        for (const p of data.result?.points || []) {
-          if ((p.payload?.data || "").toLowerCase().includes(q)) matches.push({ id: p.id, ...p.payload });
-        }
-        offset = data.result?.next_page_offset || null;
-      } while (offset);
-      return { memories: matches, next_offset: null };
-    },
-    async update(id, newData) {
-      const r = await fetch(`${baseUrl}/collections/${collection}/points/payload`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ points: [id], payload: { data: newData } }) });
-      const data = await r.json();
-      if (data.status?.error) throw new Error(data.status.error);
-      return data.result;
-    },
-    async delete(id) {
-      const r = await fetch(`${baseUrl}/collections/${collection}/points/delete`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ points: [id] }) });
-      return (await r.json()).result;
-    },
-    async status() {
-      try {
-        const r = await fetch(`${baseUrl}/collections/${collection}`, { signal: AbortSignal.timeout(3e3) });
-        const data = await r.json();
-        return { reachable: true, pointsCount: data.result?.points_count ?? null };
-      } catch {
-        return { reachable: false };
-      }
-    }
-  };
-}
-__name(createQdrantProvider, "createQdrantProvider");
-function createPgProvider(config) {
-  let _pool = null;
-  const table = config.collection || "memories";
-  async function getPool() {
-    if (_pool) return _pool;
-    let pg;
-    try {
-      pg = await import("pg");
-    } catch {
-      throw new Error("pg package not installed. Run: npm install pg");
-    }
-    const Pool = pg.default?.Pool || pg.Pool;
-    _pool = config.pgUrl ? new Pool({ connectionString: config.pgUrl }) : new Pool({ host: config.host, port: config.port || 5432, user: config.pgUser || "mem0", password: config.pgPassword || "", database: config.pgDbName || "mem0" });
-    return _pool;
-  }
-  __name(getPool, "getPool");
-  return {
-    name: "postgres",
-    config,
-    async init() {
-    },
-    async list(limit, offset) {
-      const pool = await getPool();
-      const off = offset ? parseInt(offset, 10) : 0;
-      const { rows } = await pool.query(`SELECT id, payload FROM ${table} ORDER BY created_at DESC LIMIT $1 OFFSET $2`, [limit, off]);
-      return { memories: rows.map((r) => ({ id: r.id, ...typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload })), next_offset: rows.length === limit ? off + limit : null };
-    },
-    async search(query) {
-      const pool = await getPool();
-      const { rows } = await pool.query(`SELECT id, payload FROM ${table} WHERE payload->>'data' ILIKE $1 LIMIT 100`, [`%${query}%`]);
-      return { memories: rows.map((r) => ({ id: r.id, ...typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload })), next_offset: null };
-    },
-    async update(id, newData) {
-      const pool = await getPool();
-      const { rowCount } = await pool.query(`UPDATE ${table} SET payload = jsonb_set(payload, '{data}', $1::jsonb) WHERE id = $2`, [JSON.stringify(newData), id]);
-      if (rowCount === 0) throw new Error("Memory not found");
-      return { updated: true };
-    },
-    async delete(id) {
-      const pool = await getPool();
-      await pool.query(`DELETE FROM ${table} WHERE id = $1`, [id]);
-      return { deleted: true };
-    },
-    async status() {
-      try {
-        const pool = await getPool();
-        const { rows } = await pool.query(`SELECT COUNT(*) as count FROM ${table}`);
-        return { reachable: true, pointsCount: parseInt(rows[0].count, 10) };
-      } catch (err) {
-        return { reachable: false, error: err.message };
-      }
-    }
-  };
-}
-__name(createPgProvider, "createPgProvider");
-function createMemoryProvider(config) {
-  if (config.provider === "postgres" || config.provider === "pgvector") return createPgProvider(config);
-  return createQdrantProvider(config);
-}
-__name(createMemoryProvider, "createMemoryProvider");
-
-// server/controllers/workspaces.js
-import fs6 from "node:fs";
-import path7 from "node:path";
-
-// server/util/http.js
-import crypto2 from "node:crypto";
-function parseBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (c) => chunks.push(c));
-    req.on("end", () => {
-      const raw = Buffer.concat(chunks).toString();
-      if (!raw) return resolve({});
-      try {
-        resolve(JSON.parse(raw));
-      } catch {
-        reject(new Error("Invalid JSON"));
-      }
-    });
-    req.on("error", reject);
-  });
-}
-__name(parseBody, "parseBody");
-function send(res, status, data) {
-  const body = JSON.stringify(data);
-  res.writeHead(status, {
-    "Content-Type": "application/json",
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, Authorization"
-  });
-  res.end(body);
-}
-__name(send, "send");
-function sendError(res, status, message) {
-  send(res, status, { error: message });
-}
-__name(sendError, "sendError");
-function setCors(res) {
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS");
-  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-}
-__name(setCors, "setCors");
-function uuid() {
-  return crypto2.randomUUID();
-}
-__name(uuid, "uuid");
-function matchRoute(method, url, pattern) {
-  const [pMethod, pPath] = pattern.split(" ");
-  if (method !== pMethod) return null;
-  const pParts = pPath.split("/").filter(Boolean);
-  const uParts = url.split("/").filter(Boolean);
-  if (pParts.length !== uParts.length) return null;
-  const params = {};
-  for (let i = 0; i < pParts.length; i++) {
-    if (pParts[i].startsWith(":")) {
-      params[pParts[i].slice(1)] = decodeURIComponent(uParts[i]);
-    } else if (pParts[i] !== uParts[i]) {
-      return null;
-    }
-  }
-  return params;
-}
-__name(matchRoute, "matchRoute");
-
-// server/gateway-cleanup.js
-import fs5 from "node:fs";
-import path6 from "node:path";
-function cleanGatewaySession(sessionKey) {
-  try {
-    const agentMatch = (sessionKey || "").match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const sessionsPath = path6.join(sessionsDir, "sessions.json");
-    const store = JSON.parse(fs5.readFileSync(sessionsPath, "utf8"));
-    const entry = store[sessionKey];
-    if (!entry) return null;
-    if (entry.sessionId) {
-      try {
-        fs5.unlinkSync(path6.join(sessionsDir, `${entry.sessionId}.jsonl`));
-      } catch {
-      }
-    }
-    const sessionId = entry.sessionId || null;
-    delete store[sessionKey];
-    fs5.writeFileSync(sessionsPath, JSON.stringify(store, null, 2));
-    return sessionId;
-  } catch (err) {
-    console.warn(`cleanGatewaySession(${sessionKey}):`, err.message);
-    return null;
-  }
-}
-__name(cleanGatewaySession, "cleanGatewaySession");
-function cleanGatewaySessionsByPrefix(prefix) {
-  try {
-    const agentMatch = (prefix || "").match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const sessionsPath = path6.join(sessionsDir, "sessions.json");
-    const store = JSON.parse(fs5.readFileSync(sessionsPath, "utf8"));
-    let cleaned = 0;
-    for (const key of Object.keys(store)) {
-      if (!key.startsWith(prefix)) continue;
-      if (store[key]?.sessionId) {
-        try {
-          fs5.unlinkSync(path6.join(sessionsDir, `${store[key].sessionId}.jsonl`));
-        } catch {
-        }
-      }
-      delete store[key];
-      cleaned++;
-    }
-    if (cleaned > 0) fs5.writeFileSync(sessionsPath, JSON.stringify(store, null, 2));
-    return cleaned;
-  } catch (err) {
-    console.warn(`cleanGatewaySessionsByPrefix(${prefix}):`, err.message);
-    return 0;
-  }
-}
-__name(cleanGatewaySessionsByPrefix, "cleanGatewaySessionsByPrefix");
-
-// server/controllers/workspaces.js
-var WorkspaceController = class {
-  static {
-    __name(this, "WorkspaceController");
-  }
-  constructor({ getDb, closeDb, getWorkspaces, setWorkspaces, dataDir, broadcast }) {
-    this.getDb = getDb;
-    this.closeDb = closeDb;
-    this.getWorkspaces = getWorkspaces;
-    this.setWorkspaces = setWorkspaces;
-    this.dataDir = dataDir;
-    this.broadcast = broadcast;
-  }
-  getAll(req, res) {
-    const ws = this.getWorkspaces();
-    const sorted = Object.values(ws.workspaces).sort((a, b) => (a.order ?? 999) - (b.order ?? 999));
-    for (const workspace of sorted) {
-      try {
-        workspace.unread_count = this.getDb(workspace.name).prepare("SELECT COALESCE(SUM(unread_count), 0) as total FROM threads").get().total;
-      } catch {
-        workspace.unread_count = 0;
-      }
-    }
-    send(res, 200, { active: ws.active, workspaces: sorted });
-  }
-  async create(req, res) {
-    const body = await parseBody(req);
-    const { name, label } = body;
-    if (!name || !/^[a-z0-9-]{1,32}$/.test(name)) return sendError(res, 400, "Name must be [a-z0-9-], 1-32 chars");
-    const ws = this.getWorkspaces();
-    if (ws.workspaces[name]) return sendError(res, 409, "Workspace already exists");
-    let agent = "main";
-    try {
-      agent = validateAgent(body.agent || "main");
-    } catch {
-      agent = "main";
-    }
-    ws.workspaces[name] = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
-    this.setWorkspaces(ws);
-    this.getDb(name);
-    send(res, 201, { workspace: ws.workspaces[name] });
-  }
-  async update(req, res, params) {
-    const body = await parseBody(req);
-    const ws = this.getWorkspaces();
-    if (!ws.workspaces[params.name]) return sendError(res, 404, "Workspace not found");
-    if (body.label !== void 0) ws.workspaces[params.name].label = body.label;
-    if (body.color !== void 0) ws.workspaces[params.name].color = body.color;
-    if (body.icon !== void 0) ws.workspaces[params.name].icon = body.icon;
-    if (body.lastThread !== void 0) ws.workspaces[params.name].lastThread = body.lastThread;
-    let migratedThreads = 0;
-    if (body.agent !== void 0) {
-      let newAgent;
-      try {
-        newAgent = validateAgent(body.agent);
-      } catch (e) {
-        return sendError(res, 400, e.message);
-      }
-      const oldAgent = ws.workspaces[params.name].agent || "main";
-      if (newAgent !== oldAgent) {
-        const db = this.getDb(params.name);
-        const threads = db.prepare(`SELECT id, session_key FROM threads WHERE session_key LIKE ?`).all(`agent:${oldAgent}:${params.name}:chat:%`);
-        db.prepare(`UPDATE threads SET session_key = replace(session_key, 'agent:' || ? || ':' || ? || ':chat:', 'agent:' || ? || ':' || ? || ':chat:') WHERE session_key LIKE 'agent:' || ? || ':' || ? || ':chat:%'`).run(oldAgent, params.name, newAgent, params.name, oldAgent, params.name);
-        for (const t of threads) cleanGatewaySession(t.session_key);
-        ws.workspaces[params.name].agent = newAgent;
-        migratedThreads = threads.length;
-        this.broadcast(JSON.stringify({ type: "clawchats", event: "workspace-agent-changed", workspace: params.name, agent: newAgent }));
-      }
-    }
-    this.setWorkspaces(ws);
-    send(res, 200, { workspace: ws.workspaces[params.name], migratedThreads });
-  }
-  delete(req, res, params) {
-    const ws = this.getWorkspaces();
-    if (!ws.workspaces[params.name]) return sendError(res, 404, "Workspace not found");
-    if (Object.keys(ws.workspaces).length <= 1) return sendError(res, 400, "Cannot delete the only workspace");
-    this.closeDb(params.name);
-    const dbPath = path7.join(this.dataDir, `${params.name}.db`);
-    for (const suffix of ["", "-wal", "-shm"]) {
-      try {
-        fs6.unlinkSync(dbPath + suffix);
-      } catch {
-      }
-    }
-    const wsAgent = ws.workspaces[params.name]?.agent || "main";
-    const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgent}:${params.name}:chat:`);
-    if (cleaned > 0) console.log(`Cleaned ${cleaned} gateway sessions for workspace: ${params.name}`);
-    delete ws.workspaces[params.name];
-    if (ws.active === params.name) ws.active = Object.keys(ws.workspaces)[0] || null;
-    this.setWorkspaces(ws);
-    send(res, 200, { ok: true });
-  }
-  async reorder(req, res) {
-    const body = await parseBody(req);
-    if (!Array.isArray(body.order)) return sendError(res, 400, "order must be an array of workspace names");
-    const ws = this.getWorkspaces();
-    body.order.forEach((name, i) => {
-      if (ws.workspaces[name]) ws.workspaces[name].order = i;
-    });
-    this.setWorkspaces(ws);
-    send(res, 200, { ok: true, workspaces: Object.values(ws.workspaces) });
-  }
-  activate(req, res, params) {
-    const ws = this.getWorkspaces();
-    if (!ws.workspaces[params.name]) return sendError(res, 404, "Workspace not found");
-    ws.active = params.name;
-    this.setWorkspaces(ws);
-    this.getDb(params.name);
-    send(res, 200, { ok: true, workspace: ws.workspaces[params.name] });
-  }
-};
-
-// server/controllers/threads.js
-import fs7 from "node:fs";
-import path8 from "node:path";
-var ThreadController = class {
-  static {
-    __name(this, "ThreadController");
-  }
-  constructor({ getActiveDb, getWorkspaces, uploadsDir, broadcast }) {
-    this.getActiveDb = getActiveDb;
-    this.getWorkspaces = getWorkspaces;
-    this.uploadsDir = uploadsDir;
-    this.broadcast = broadcast;
-  }
-  getAll(req, res, params, query) {
-    const db = this.getActiveDb();
-    const page = parseInt(query.page || "1", 10);
-    const limit = Math.min(parseInt(query.limit || "50", 10), 200);
-    const offset = (page - 1) * limit;
-    const search = query.search || "";
-    let threads, total;
-    if (search) {
-      try {
-        const matchingIds = db.prepare(`SELECT DISTINCT m.thread_id FROM messages m JOIN messages_fts ON messages_fts.rowid = m.rowid WHERE messages_fts MATCH ?`).all(search).map((r) => r.thread_id);
-        if (!matchingIds.length) return send(res, 200, { threads: [], total: 0, page });
-        const ph = matchingIds.map(() => "?").join(",");
-        total = db.prepare(`SELECT COUNT(*) as c FROM threads WHERE id IN (${ph})`).get(...matchingIds).c;
-        threads = db.prepare(`SELECT * FROM threads WHERE id IN (${ph}) ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?`).all(...matchingIds, limit, offset);
-      } catch {
-        return send(res, 200, { threads: [], total: 0, page });
-      }
-    } else {
-      total = db.prepare("SELECT COUNT(*) as c FROM threads").get().c;
-      threads = db.prepare("SELECT * FROM threads ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?").all(limit, offset);
-    }
-    send(res, 200, { threads, total, page });
-  }
-  getUnread(req, res) {
-    const db = this.getActiveDb();
-    const threads = db.prepare(`SELECT t.id, t.title, t.unread_count, m.content as lastMessage FROM threads t LEFT JOIN messages m ON m.thread_id = t.id WHERE t.unread_count > 0 AND m.timestamp = (SELECT MAX(timestamp) FROM messages WHERE thread_id = t.id) ORDER BY t.updated_at DESC`).all();
-    for (const t of threads) t.unreadMessageIds = db.prepare("SELECT message_id FROM unread_messages WHERE thread_id = ?").all(t.id).map((r) => r.message_id);
-    send(res, 200, { threads });
-  }
-  async markRead(req, res, params) {
-    const { messageIds } = await parseBody(req);
-    if (!Array.isArray(messageIds) || !messageIds.length) return send(res, 400, { error: "messageIds array required" });
-    const db = this.getActiveDb();
-    const ph = messageIds.map(() => "?").join(",");
-    db.prepare(`DELETE FROM unread_messages WHERE thread_id = ? AND message_id IN (${ph})`).run(params.id, ...messageIds);
-    const remaining = syncThreadUnreadCount(db, params.id);
-    this.broadcast(JSON.stringify({ type: "clawchats", event: "unread-update", workspace: this.getWorkspaces().active, threadId: params.id, action: "read", messageIds, unreadCount: remaining, timestamp: Date.now() }));
-    send(res, 200, { unread_count: remaining });
-  }
-  async create(req, res) {
-    const body = await parseBody(req);
-    const db = this.getActiveDb();
-    const ws = this.getWorkspaces();
-    const id = body.id || uuid();
-    const now = Date.now();
-    const agent = ws.workspaces[ws.active]?.agent || "main";
-    try {
-      db.prepare("INSERT INTO threads (id, session_key, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(id, `agent:${agent}:${ws.active}:chat:${id}`, "New chat", now, now);
-    } catch (e) {
-      if (e.message.includes("UNIQUE constraint")) return sendError(res, 409, "Thread already exists");
-      throw e;
-    }
-    send(res, 201, { thread: db.prepare("SELECT * FROM threads WHERE id = ?").get(id) });
-  }
-  get(req, res, params) {
-    const thread = this.getActiveDb().prepare("SELECT * FROM threads WHERE id = ?").get(params.id);
-    if (!thread) return sendError(res, 404, "Thread not found");
-    send(res, 200, { thread });
-  }
-  async update(req, res, params) {
-    const body = await parseBody(req);
-    const db = this.getActiveDb();
-    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
-    const fields = [], values = [];
-    for (const [col, val] of [["title", body.title], ["model", body.model], ["last_session_id", body.last_session_id], ["unread_count", body.unread_count]]) {
-      if (val !== void 0) {
-        fields.push(`${col} = ?`);
-        values.push(val);
-      }
-    }
-    if (body.pinned !== void 0) {
-      fields.push("pinned = ?");
-      values.push(body.pinned ? 1 : 0);
-    }
-    if (body.pin_order !== void 0) {
-      fields.push("pin_order = ?");
-      values.push(body.pin_order);
-    }
-    if (body.sort_order !== void 0) {
-      fields.push("sort_order = ?");
-      values.push(body.sort_order);
-    }
-    if (fields.length) {
-      fields.push("updated_at = ?");
-      values.push(Date.now(), params.id);
-      db.prepare(`UPDATE threads SET ${fields.join(", ")} WHERE id = ?`).run(...values);
-    }
-    send(res, 200, { thread: db.prepare("SELECT * FROM threads WHERE id = ?").get(params.id) });
-  }
-  delete(req, res, params) {
-    const db = this.getActiveDb();
-    const thread = db.prepare("SELECT * FROM threads WHERE id = ?").get(params.id);
-    if (!thread) return sendError(res, 404, "Thread not found");
-    db.prepare("DELETE FROM threads WHERE id = ?").run(params.id);
-    const agentMatch = (thread.session_key || "").match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    let sessionIdToDelete = thread.last_session_id;
-    if (!sessionIdToDelete) {
-      try {
-        sessionIdToDelete = JSON.parse(fs7.readFileSync(path8.join(sessionsDir, "sessions.json"), "utf8"))[thread.session_key]?.sessionId;
-      } catch {
-      }
-    }
-    cleanGatewaySession(thread.session_key);
-    if (sessionIdToDelete) {
-      try {
-        fs7.unlinkSync(path8.join(sessionsDir, `${sessionIdToDelete}.jsonl`));
-      } catch {
-      }
-    }
-    try {
-      fs7.rmSync(path8.join(this.uploadsDir, params.id), { recursive: true });
-    } catch {
-    }
-    send(res, 200, { ok: true });
-  }
-};
-
-// server/util/context.js
-import fs8 from "node:fs";
-import path9 from "node:path";
-function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
-  let summary = null;
-  let method = "raw";
-  if (lastSessionId) {
-    const agentMatch = (sessionKey || "").match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    try {
-      const lines = fs8.readFileSync(path9.join(sessionsDir, `${lastSessionId}.jsonl`), "utf8").split("\n").filter(Boolean);
-      for (let i = lines.length - 1; i >= 0; i--) {
-        try {
-          const entry = JSON.parse(lines[i]);
-          if (entry.type === "compaction" && entry.summary) {
-            summary = entry.summary;
-            method = "compaction";
-            break;
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  let preamble = "";
-  if (method === "compaction" && summary) {
-    preamble += "[CONTEXT RECOVERY \u2014 This thread's agent session was reset. Below is a summary of the previous conversation followed by recent messages to restore context.]\n\n";
-    preamble += "[CONVERSATION SUMMARY]\n" + summary + "\n\n";
-    const msgs = db.prepare("SELECT role, content, timestamp FROM messages WHERE thread_id = ? ORDER BY timestamp DESC LIMIT 10").all(threadId).reverse();
-    if (msgs.length) {
-      preamble += "[RECENT MESSAGES]\n";
-      for (const m of msgs) {
-        const ts = new Date(m.timestamp).toISOString().replace("T", " ").slice(0, 16);
-        preamble += `${m.role.charAt(0).toUpperCase() + m.role.slice(1)} (${ts}): ${m.content}
-`;
-      }
-    }
-  } else {
-    preamble += "[CONTEXT RECOVERY \u2014 This thread's agent session was reset. Below are recent messages from the previous conversation to restore context.]\n\n";
-    const msgs = db.prepare("SELECT role, content, timestamp FROM messages WHERE thread_id = ? ORDER BY timestamp DESC LIMIT 25").all(threadId).reverse();
-    if (msgs.length) {
-      preamble += "[PREVIOUS MESSAGES]\n";
-      for (const m of msgs) {
-        const ts = new Date(m.timestamp).toISOString().replace("T", " ").slice(0, 16);
-        preamble += `${m.role.charAt(0).toUpperCase() + m.role.slice(1)} (${ts}): ${m.content}
-`;
-      }
-    }
-  }
-  if (preamble.length > MAX_PREAMBLE_CHARS) preamble = preamble.slice(preamble.length - MAX_PREAMBLE_CHARS);
-  return { preamble, method };
-}
-__name(buildContextPreamble, "buildContextPreamble");
-
-// server/controllers/messages.js
-var MessageController = class {
-  static {
-    __name(this, "MessageController");
-  }
-  constructor({ getActiveDb, getWorkspaces, broadcast }) {
-    this.getActiveDb = getActiveDb;
-    this.getWorkspaces = getWorkspaces;
-    this.broadcast = broadcast;
-  }
-  getAll(req, res, params, query) {
-    const db = this.getActiveDb();
-    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
-    const limit = Math.min(parseInt(query.limit || "100", 10), 500);
-    const before = query.before ? parseInt(query.before, 10) : null;
-    const after = query.after ? parseInt(query.after, 10) : null;
-    let sql = "SELECT * FROM messages WHERE thread_id = ?";
-    const sqlParams = [params.id];
-    if (before) {
-      sql += " AND timestamp < ?";
-      sqlParams.push(before);
-    }
-    if (after) {
-      sql += " AND timestamp > ?";
-      sqlParams.push(after);
-    }
-    const total = db.prepare(sql.replace("SELECT *", "SELECT COUNT(*) as c")).get(...sqlParams).c;
-    const rows = db.prepare(sql + " ORDER BY timestamp DESC LIMIT ?").all(...sqlParams, limit + 1);
-    const messages = rows.slice(0, limit).reverse();
-    for (const m of messages) {
-      if (m.metadata) {
-        try {
-          m.metadata = JSON.parse(m.metadata);
-        } catch {
-        }
-      }
-    }
-    send(res, 200, { messages, hasMore: rows.length > limit });
-  }
-  async create(req, res, params) {
-    const body = await parseBody(req);
-    const db = this.getActiveDb();
-    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
-    if (!body.id || !body.role || body.content === void 0 || !body.timestamp) return sendError(res, 400, "Required: id, role, content, timestamp");
-    const metadata = body.metadata ? JSON.stringify(body.metadata) : null;
-    const existing = db.prepare("SELECT id, status, metadata FROM messages WHERE id = ?").get(body.id);
-    if (existing) {
-      if (body.status && body.status !== existing.status) {
-        db.prepare("UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?").run(body.status, body.content, metadata || existing.metadata, body.id);
-      }
-    } else {
-      db.prepare("INSERT INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(body.id, params.id, body.role, body.content, body.status || "sent", metadata, body.seq || null, body.timestamp, Date.now());
-      db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(Date.now(), params.id);
-      if (body.role === "user" && body.content) {
-        const thread = db.prepare("SELECT title FROM threads WHERE id = ?").get(params.id);
-        if (thread?.title === "New chat") {
-          const title = body.content.replace(/\n.*/s, "").slice(0, 40).trim() + (body.content.length > 40 ? "..." : "");
-          if (title) {
-            db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(title, params.id);
-            this.broadcast(JSON.stringify({ type: "clawchats", event: "thread-title-updated", threadId: params.id, workspace: this.getWorkspaces().active, title }));
-          }
-        }
-      }
-    }
-    const message = db.prepare("SELECT * FROM messages WHERE id = ?").get(body.id);
-    if (message?.metadata) {
-      try {
-        message.metadata = JSON.parse(message.metadata);
-      } catch {
-      }
-    }
-    send(res, existing ? 200 : 201, { message });
-  }
-  delete(req, res, params) {
-    const db = this.getActiveDb();
-    if (!db.prepare("SELECT id FROM messages WHERE id = ? AND thread_id = ?").get(params.messageId, params.id)) return sendError(res, 404, "Message not found");
-    db.prepare("DELETE FROM messages WHERE id = ?").run(params.messageId);
-    send(res, 200, { ok: true });
-  }
-  contextFill(req, res, params) {
-    const db = this.getActiveDb();
-    const thread = db.prepare("SELECT * FROM threads WHERE id = ?").get(params.id);
-    if (!thread) return sendError(res, 404, "Thread not found");
-    send(res, 200, buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key));
-  }
-  search(req, res, params, query) {
-    const q = query.q || "";
-    if (!q) return send(res, 200, { results: [], total: 0 });
-    const db = this.getActiveDb();
-    const page = parseInt(query.page || "1", 10);
-    const limit = Math.min(parseInt(query.limit || "20", 10), 100);
-    const offset = (page - 1) * limit;
-    try {
-      const results = db.prepare(`SELECT m.id as messageId, m.thread_id as threadId, t.title as threadTitle, m.role, snippet(messages_fts, 0, '<mark>', '</mark>', '...', 40) as content, m.timestamp FROM messages_fts JOIN messages m ON messages_fts.rowid = m.rowid JOIN threads t ON m.thread_id = t.id WHERE messages_fts MATCH ? ORDER BY rank LIMIT ? OFFSET ?`).all(q, limit, offset);
-      const total = db.prepare(`SELECT COUNT(*) as c FROM messages_fts WHERE messages_fts MATCH ?`).get(q).c;
-      send(res, 200, { results, total });
-    } catch {
-      send(res, 200, { results: [], total: 0 });
-    }
-  }
-  export(req, res) {
-    const db = this.getActiveDb();
-    const ws = this.getWorkspaces();
-    const threads = db.prepare("SELECT * FROM threads ORDER BY updated_at DESC").all();
-    send(res, 200, {
-      workspace: ws.active,
-      exportedAt: Date.now(),
-      threads: threads.map((t) => {
-        const messages = db.prepare("SELECT * FROM messages WHERE thread_id = ? ORDER BY timestamp ASC").all(t.id);
-        for (const m of messages) {
-          if (m.metadata) {
-            try {
-              m.metadata = JSON.parse(m.metadata);
-            } catch {
-            }
-          }
-        }
-        return { ...t, messages };
-      })
-    });
-  }
-  async import(req, res) {
-    const body = await parseBody(req);
-    const db = this.getActiveDb();
-    const ws = this.getWorkspaces();
-    if (!body.threads || !Array.isArray(body.threads)) return sendError(res, 400, "Expected { threads: [...] }");
-    let threadsImported = 0, messagesImported = 0;
-    const insertThread = db.prepare("INSERT OR IGNORE INTO threads (id, session_key, title, pinned, pin_order, model, last_session_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    const insertMsg = db.prepare("INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    db.exec("BEGIN");
-    try {
-      for (const t of body.threads) {
-        if (!t.id) continue;
-        const sessionKey = t.session_key || `agent:main:${ws.active}:chat:${t.id}`;
-        if (insertThread.run(t.id, sessionKey, t.title || "Imported chat", t.pinned || 0, t.pin_order || 0, t.model || null, t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now()).changes > 0) threadsImported++;
-        for (const m of t.messages || []) {
-          if (!m.id || !m.role) continue;
-          const meta = m.metadata ? typeof m.metadata === "string" ? m.metadata : JSON.stringify(m.metadata) : null;
-          if (insertMsg.run(m.id, t.id, m.role, m.content || "", m.status || "sent", meta, m.seq || null, m.timestamp || Date.now(), m.created_at || Date.now()).changes > 0) messagesImported++;
-        }
-      }
-      db.exec("COMMIT");
-    } catch (e) {
-      db.exec("ROLLBACK");
-      throw e;
-    }
-    send(res, 200, { ok: true, threadsImported, messagesImported });
-  }
-};
-
-// server/controllers/files.js
-import fs9 from "node:fs";
-import path10 from "node:path";
-
-// server/util/multipart.js
-function parseMultipart(req) {
-  return new Promise((resolve, reject) => {
-    const contentType = req.headers["content-type"] || "";
-    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
-    if (!boundaryMatch) return reject(new Error("No boundary in content-type"));
-    const boundary = boundaryMatch[1] || boundaryMatch[2];
-    const chunks = [];
-    req.on("data", (c) => chunks.push(c));
-    req.on("end", () => {
-      const buf = Buffer.concat(chunks);
-      const files = [];
-      const delimiter = Buffer.from(`--${boundary}`);
-      let pos = 0;
-      while (pos < buf.length) {
-        const start = buf.indexOf(delimiter, pos);
-        if (start === -1) break;
-        const nextStart = buf.indexOf(delimiter, start + delimiter.length);
-        if (nextStart === -1) break;
-        const part = buf.subarray(start + delimiter.length, nextStart);
-        const headerEnd = part.indexOf("\r\n\r\n");
-        if (headerEnd === -1) {
-          pos = nextStart;
-          continue;
-        }
-        const headerStr = part.subarray(0, headerEnd).toString();
-        let body = part.subarray(headerEnd + 4);
-        if (body.length >= 2 && body[body.length - 2] === 13 && body[body.length - 1] === 10) {
-          body = body.subarray(0, body.length - 2);
-        }
-        const filenameMatch = headerStr.match(/filename="([^"]+)"/);
-        const ctMatch = headerStr.match(/Content-Type:\s*(\S+)/i);
-        if (filenameMatch) {
-          files.push({
-            filename: filenameMatch[1],
-            mimeType: ctMatch ? ctMatch[1] : "application/octet-stream",
-            data: body
-          });
-        }
-        pos = nextStart;
-      }
-      resolve(files);
-    });
-    req.on("error", reject);
-  });
-}
-__name(parseMultipart, "parseMultipart");
-
-// server/controllers/files.js
-var FileController = class {
-  static {
-    __name(this, "FileController");
-  }
-  constructor({ getActiveDb, getWorkspaces, uploadsDir, intelligenceDir }) {
-    this.getActiveDb = getActiveDb;
-    this.getWorkspaces = getWorkspaces;
-    this.uploadsDir = uploadsDir;
-    this.intelligenceDir = intelligenceDir;
-  }
-  async upload(req, res, params) {
-    if (!this.getActiveDb().prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
-    const files = await parseMultipart(req);
-    const dir = path10.join(this.uploadsDir, params.id);
-    fs9.mkdirSync(dir, { recursive: true });
-    const savedFiles = [];
-    for (const file of files) {
-      const fileId = uuid();
-      const ext = path10.extname(file.filename) || "";
-      fs9.writeFileSync(path10.join(dir, fileId + ext), file.data);
-      savedFiles.push({ id: fileId, filename: file.filename, path: `/api/uploads/${params.id}/${fileId}${ext}`, mimeType: file.mimeType, size: file.data.length });
-    }
-    send(res, 200, { files: savedFiles });
-  }
-  serveUpload(req, res, params) {
-    const base = path10.join(this.uploadsDir, params.threadId, params.fileId);
-    let resolved = base;
-    if (!fs9.existsSync(resolved)) {
-      try {
-        const match = fs9.readdirSync(path10.join(this.uploadsDir, params.threadId)).find((e) => e.startsWith(params.fileId.replace(/\.[^.]+$/, "")));
-        if (match) resolved = path10.join(this.uploadsDir, params.threadId, match);
-      } catch {
-      }
-    }
-    if (!fs9.existsSync(resolved)) return sendError(res, 404, "File not found");
-    const MIME = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".pdf": "application/pdf", ".txt": "text/plain", ".json": "application/json" };
-    const stat = fs9.statSync(resolved);
-    res.writeHead(200, { "Content-Type": MIME[path10.extname(resolved).toLowerCase()] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*" });
-    fs9.createReadStream(resolved).pipe(res);
-  }
-  _intelligencePath(threadId) {
-    return path10.join(this.intelligenceDir, this.getWorkspaces().active, `${threadId}.json`);
-  }
-  getIntelligence(req, res, params) {
-    const filePath = this._intelligencePath(params.id);
-    if (!fs9.existsSync(filePath)) return send(res, 200, { versions: [], currentVersion: -1 });
-    try {
-      return send(res, 200, JSON.parse(fs9.readFileSync(filePath, "utf8")));
-    } catch {
-      return send(res, 200, { versions: [], currentVersion: -1 });
-    }
-  }
-  async saveIntelligence(req, res, params) {
-    const body = await parseBody(req);
-    const filePath = this._intelligencePath(params.id);
-    fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
-    const data = { versions: body.versions || [], currentVersion: body.currentVersion ?? -1, updatedAt: Date.now() };
-    fs9.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    send(res, 200, data);
-  }
-};
-
-// server/controllers/memory.js
-import fs10 from "node:fs";
-import path11 from "node:path";
-var MemoryController = class {
-  static {
-    __name(this, "MemoryController");
-  }
-  constructor({ memoryProvider, memoryFilesDir, memoryConfig }) {
-    this.provider = memoryProvider;
-    this.filesDir = memoryFilesDir;
-    this.config = memoryConfig;
-  }
-  async list(req, res, query) {
-    const limit = Math.min(parseInt(query.limit) || 20, 100);
-    try {
-      send(res, 200, await this.provider.list(limit, query.offset || null));
-    } catch (err) {
-      send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message });
-    }
-  }
-  async search(req, res, query) {
-    const q = (query.query || "").toLowerCase().trim();
-    if (!q) return send(res, 400, { error: "Missing query parameter" });
-    try {
-      send(res, 200, await this.provider.search(q));
-    } catch (err) {
-      send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message });
-    }
-  }
-  files(req, res, query) {
-    const q = (query.query || "").toLowerCase().trim();
-    const memories = this._parseFiles();
-    const filtered = q ? memories.filter((m) => m.data.toLowerCase().includes(q) || m.title.toLowerCase().includes(q)) : memories;
-    filtered.sort((a, b) => (b.createdAt || "").localeCompare(a.createdAt || ""));
-    send(res, 200, { memories: filtered });
-  }
-  _parseFiles() {
-    const memories = [];
-    const scanDir = /* @__PURE__ */ __name((dir, prefix = "") => {
-      let entries;
-      try {
-        entries = fs10.readdirSync(dir);
-      } catch {
-        return;
-      }
-      for (const entry of entries) {
-        const fullPath = path11.join(dir, entry);
-        const stat = (() => {
-          try {
-            return fs10.statSync(fullPath);
-          } catch {
-            return null;
-          }
-        })();
-        if (!stat) continue;
-        if (stat.isDirectory() && !prefix) {
-          scanDir(fullPath, entry + "/");
-          continue;
-        }
-        if (!entry.endsWith(".md") || !stat.isFile()) continue;
-        const content = fs10.readFileSync(fullPath, "utf8");
-        const basename = entry.replace(/\.md$/, "");
-        const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})/);
-        if (prefix) {
-          memories.push({ id: `file:${prefix + basename}`, source: "file", file: prefix + basename, title: basename, data: content.trim(), createdAt: stat.mtime.toISOString() });
-        } else {
-          for (const section of content.split(/^(?=## )/m)) {
-            const trimmed = section.trim();
-            if (!trimmed) continue;
-            const headingMatch = trimmed.match(/^##\s+(.+)/);
-            const heading = headingMatch ? headingMatch[1].trim() : null;
-            const body = headingMatch ? trimmed.slice(trimmed.indexOf("\n") + 1).trim() : trimmed;
-            if (!heading && body.match(/^#\s+/) && body.split("\n").length <= 2) continue;
-            const title = heading || basename;
-            memories.push({ id: `file:${basename}:${title}`, source: "file", file: basename, title, data: heading ? `**${title}**
-${body}` : body, createdAt: dateMatch ? `${dateMatch[1]}T00:00:00Z` : stat.mtime.toISOString() });
-          }
-        }
-      }
-    }, "scanDir");
-    scanDir(this.filesDir);
-    return memories;
-  }
-  async update(req, res, params) {
-    try {
-      const chunks = [];
-      for await (const chunk of req) chunks.push(chunk);
-      const { data } = JSON.parse(Buffer.concat(chunks).toString());
-      if (!(data || "").trim()) return send(res, 400, { error: "Missing data field" });
-      send(res, 200, { ok: true, result: await this.provider.update(params.id, data.trim()) });
-    } catch (err) {
-      send(res, 502, { error: "Failed to update memory", detail: err.message });
-    }
-  }
-  async delete(req, res, params) {
-    try {
-      send(res, 200, { ok: true, result: await this.provider.delete(params.id) });
-    } catch (err) {
-      send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message });
-    }
-  }
-  async status(req, res) {
-    const status = await this.provider.status();
-    send(res, 200, { provider: this.provider.name, host: this.config.host, port: this.config.port, collection: this.config.collection, backend: status, memoryFilesDir: this.filesDir, memoryFilesDirExists: fs10.existsSync(this.filesDir) });
-  }
-};
-
-// server/controllers/filesystem.js
-import fs11 from "node:fs";
-import path12 from "node:path";
-import os3 from "node:os";
-var HOME2 = os3.homedir();
-var ALLOWED_FILE_DIRS = [HOME2, "/tmp"];
-function handleServeFile(req, res, query, memoryConfig) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = filePath.startsWith("./") || filePath.startsWith("../") ? path12.resolve(memoryConfig.workspaceDir, filePath) : path12.resolve(filePath);
-  if (!ALLOWED_FILE_DIRS.some((dir) => resolved.startsWith(dir + "/") || resolved === dir)) return sendError(res, 403, "Access denied: path not in allowed directories");
-  if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isFile()) return sendError(res, 404, "File not found");
-  const MIME = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".svg": "image/svg+xml",
-    ".pdf": "application/pdf",
-    ".txt": "text/plain",
-    ".json": "application/json",
-    ".md": "text/markdown",
-    ".csv": "text/csv",
-    ".xml": "text/xml",
-    ".html": "text/html",
-    ".css": "text/css",
-    ".js": "text/javascript",
-    ".py": "text/x-python",
-    ".sh": "text/x-shellscript",
-    ".yaml": "text/yaml",
-    ".yml": "text/yaml",
-    ".toml": "text/toml",
-    ".zip": "application/zip",
-    ".gz": "application/gzip",
-    ".tar": "application/x-tar",
-    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    ".mp3": "audio/mpeg",
-    ".wav": "audio/wav",
-    ".ogg": "audio/ogg",
-    ".mp4": "video/mp4",
-    ".webm": "video/webm"
-  };
-  const stat = fs11.statSync(resolved);
-  res.writeHead(200, { "Content-Type": MIME[path12.extname(resolved).toLowerCase()] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*" });
-  fs11.createReadStream(resolved).pipe(res);
-}
-__name(handleServeFile, "handleServeFile");
-function handleWorkspaceList(req, res, query) {
-  const reqPath = query.path || "~/.openclaw/workspace";
-  const depth = parseInt(query.depth || "2", 10);
-  const showHidden = query.hidden === "1" || query.hidden === "true";
-  const resolved = path12.resolve(reqPath.replace(/^~/, HOME2));
-  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
-  if (!fs11.existsSync(resolved)) return sendError(res, 404, "Path not found");
-  const files = [{ path: resolved + "/", type: "dir", name: path12.basename(resolved), size: 0 }];
-  const walk = /* @__PURE__ */ __name((dir, d) => {
-    if (d > depth) return;
-    try {
-      for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.name.startsWith(".") && entry.name !== ".openclaw" && !showHidden) continue;
-        if (entry.name === "node_modules") continue;
-        const fullPath = path12.join(dir, entry.name);
-        const isDir = entry.isDirectory();
-        files.push({ path: fullPath + (isDir ? "/" : ""), type: isDir ? "dir" : "file", name: entry.name, size: isDir ? 0 : (() => {
-          try {
-            return fs11.statSync(fullPath).size;
-          } catch {
-            return 0;
-          }
-        })() });
-        if (isDir) walk(fullPath, d + 1);
-      }
-    } catch {
-    }
-  }, "walk");
-  walk(resolved, 1);
-  send(res, 200, { files, cwd: resolved });
-}
-__name(handleWorkspaceList, "handleWorkspaceList");
-function handleWorkspaceFileRead(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = path12.resolve(filePath.replace(/^~/, HOME2));
-  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
-  if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isFile()) return sendError(res, 404, "File not found");
-  const stat = fs11.statSync(resolved);
-  const ext = path12.extname(resolved).toLowerCase().slice(1);
-  const binaryMime = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", svg: "image/svg+xml", bmp: "image/bmp", ico: "image/x-icon", pdf: "application/pdf", mp3: "audio/mpeg", mp4: "video/mp4", wav: "audio/wav", ogg: "audio/ogg", webm: "video/webm" };
-  const mime = binaryMime[ext];
-  if (mime) {
-    if (stat.size > 20 * 1024 * 1024) return sendError(res, 413, "File too large (max 20MB)");
-    res.writeHead(200, { "Content-Type": mime, "Cache-Control": "private, max-age=60" });
-    res.end(fs11.readFileSync(resolved));
-  } else {
-    if (stat.size > 1024 * 1024) return sendError(res, 413, "File too large (max 1MB)");
-    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
-    res.end(fs11.readFileSync(resolved, "utf8"));
-  }
-}
-__name(handleWorkspaceFileRead, "handleWorkspaceFileRead");
-async function handleWorkspaceFileWrite(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = path12.resolve(filePath.replace(/^~/, HOME2));
-  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Can only write to workspace directory");
-  const chunks = [];
-  for await (const chunk of req) chunks.push(chunk);
-  const dir = path12.dirname(resolved);
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
-  fs11.writeFileSync(resolved, Buffer.concat(chunks).toString("utf8"), "utf8");
-  send(res, 200, { ok: true });
-}
-__name(handleWorkspaceFileWrite, "handleWorkspaceFileWrite");
-function handleWorkspaceFileDelete(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = path12.resolve(filePath.replace(/^~/, HOME2));
-  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
-  if (!fs11.existsSync(resolved)) return sendError(res, 404, "Path not found");
-  try {
-    const stat = fs11.statSync(resolved);
-    if (stat.isDirectory()) {
-      fs11.rmSync(resolved, { recursive: true, force: true });
-      send(res, 200, { ok: true, type: "dir" });
-    } else {
-      fs11.unlinkSync(resolved);
-      send(res, 200, { ok: true, type: "file" });
-    }
-  } catch (err) {
-    sendError(res, 500, "Delete failed: " + err.message);
-  }
-}
-__name(handleWorkspaceFileDelete, "handleWorkspaceFileDelete");
-async function handleWorkspaceUpload(req, res, query) {
-  const targetDir = query.path;
-  if (!targetDir) return sendError(res, 400, "Missing path parameter");
-  const resolved = path12.resolve(targetDir.replace(/^~/, HOME2));
-  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
-  if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isDirectory()) return sendError(res, 404, "Target directory not found");
-  if (!(req.headers["content-type"] || "").includes("multipart/form-data")) return sendError(res, 400, "Expected multipart/form-data");
-  let files;
-  try {
-    files = await parseMultipart(req);
-  } catch (err) {
-    return sendError(res, 400, "Invalid multipart data: " + err.message);
-  }
-  const uploaded = [];
-  for (const { filename, data } of files) {
-    if (!filename || !data.length) continue;
-    const safeName = path12.basename(filename);
-    let finalPath = path12.join(resolved, safeName);
-    let counter = 1;
-    while (fs11.existsSync(finalPath)) {
-      const ext = path12.extname(safeName);
-      finalPath = path12.join(resolved, `${path12.basename(safeName, ext)} (${counter++})${ext}`);
-    }
-    fs11.writeFileSync(finalPath, data);
-    uploaded.push({ name: path12.basename(finalPath), size: data.length });
-  }
-  send(res, 200, { ok: true, uploaded });
-}
-__name(handleWorkspaceUpload, "handleWorkspaceUpload");
-
-// server/controllers/transcribe.js
-import fs12 from "node:fs";
-import path13 from "node:path";
-import os4 from "node:os";
-async function handleTranscribe(req, res) {
-  try {
-    const chunks = [];
-    for await (const chunk of req) chunks.push(chunk);
-    const audioBuffer = Buffer.concat(chunks);
-    if (audioBuffer.length === 0) return send(res, 400, { error: "No audio data" });
-    if (audioBuffer.length > 25 * 1024 * 1024) return send(res, 400, { error: "Audio too large (max 25MB)" });
-    let apiKey;
-    try {
-      const ocConfig = JSON.parse(fs12.readFileSync(path13.join(os4.homedir(), ".openclaw", "openclaw.json"), "utf8"));
-      apiKey = ocConfig?.skills?.entries?.["openai-whisper-api"]?.apiKey;
-    } catch {
-    }
-    if (!apiKey) apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) return send(res, 500, { error: "No OpenAI API key configured" });
-    const contentType = req.headers["content-type"] || "audio/webm";
-    const ext = contentType.includes("wav") ? "wav" : contentType.includes("mp4") || contentType.includes("m4a") ? "m4a" : contentType.includes("ogg") ? "ogg" : "webm";
-    const boundary = "----WhisperBoundary" + Date.now();
-    const body = Buffer.concat([
-      `--${boundary}\r
-Content-Disposition: form-data; name="file"; filename="audio.${ext}"\r
-Content-Type: ${contentType}\r
-\r
-`,
-      audioBuffer,
-      `\r
---${boundary}\r
-Content-Disposition: form-data; name="model"\r
-\r
-whisper-1\r
-`,
-      `--${boundary}\r
-Content-Disposition: form-data; name="response_format"\r
-\r
-json\r
-`,
-      `--${boundary}--\r
-`
-    ].map((p) => typeof p === "string" ? Buffer.from(p) : p));
-    const resp = await fetch("https://api.openai.com/v1/audio/transcriptions", {
-      method: "POST",
-      headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": `multipart/form-data; boundary=${boundary}` },
-      body
-    });
-    if (!resp.ok) {
-      console.error("Whisper API error:", resp.status, await resp.text());
-      return send(res, 502, { error: `Whisper API error: ${resp.status}` });
-    }
-    const result = await resp.json();
-    return send(res, 200, { text: result.text || "" });
-  } catch (err) {
-    console.error("Transcribe error:", err);
-    return send(res, 500, { error: err.message });
-  }
-}
-__name(handleTranscribe, "handleTranscribe");
-
-// server/index.js
-var HOME3 = os5.homedir();
-var PORT = parseInt(process.env.PORT || "3001", 10);
-var __dirname2 = path14.dirname(fileURLToPath2(import.meta.url));
-var PLUGIN_DIR = path14.resolve(__dirname2, "..");
-function createApp(config = {}) {
-  const DATA_DIR = config.dataDir || path14.join(PLUGIN_DIR, "data");
-  const UPLOADS_DIR = config.uploadsDir || path14.join(PLUGIN_DIR, "uploads");
-  const WORKSPACES_FILE = path14.join(DATA_DIR, "workspaces.json");
-  const SETTINGS_FILE = path14.join(DATA_DIR, "settings.json");
-  const INTELLIGENCE_DIR = path14.join(DATA_DIR, "intelligence");
-  const authToken = config.authToken !== void 0 ? config.authToken : AUTH_TOKEN;
-  const gatewayToken = config.gatewayToken !== void 0 ? config.gatewayToken : authToken;
-  const gatewayUrl = config.gatewayUrl || GATEWAY_WS_URL;
-  fs13.mkdirSync(DATA_DIR, { recursive: true });
-  fs13.mkdirSync(UPLOADS_DIR, { recursive: true });
-  const dbCache = /* @__PURE__ */ new Map();
-  function getDb(workspaceName) {
-    if (dbCache.has(workspaceName)) return dbCache.get(workspaceName);
-    const db = new Database(path14.join(DATA_DIR, `${workspaceName}.db`));
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("PRAGMA foreign_keys = ON");
-    migrate(db);
-    dbCache.set(workspaceName, db);
-    return db;
-  }
-  __name(getDb, "getDb");
-  function getActiveDb() {
-    return requestDbStore.getStore() || getDb(getWorkspaces().active);
-  }
-  __name(getActiveDb, "getActiveDb");
-  function closeDb(name) {
-    const db = dbCache.get(name);
-    if (db) {
-      db.close();
-      dbCache.delete(name);
-    }
-  }
-  __name(closeDb, "closeDb");
-  function closeAll() {
-    for (const db of dbCache.values()) db.close();
-    dbCache.clear();
-    globalDbCache.close?.();
-  }
-  __name(closeAll, "closeAll");
-  let _globalDb = null;
-  const globalDbCache = {
-    get() {
-      if (_globalDb) return _globalDb;
-      _globalDb = new Database(path14.join(DATA_DIR, "global.db"));
-      _globalDb.exec("PRAGMA journal_mode = WAL");
-      _globalDb.exec(`CREATE TABLE IF NOT EXISTS custom_emojis (name TEXT NOT NULL, pack TEXT NOT NULL DEFAULT 'slackmojis', url TEXT NOT NULL, mime_type TEXT, created_at INTEGER DEFAULT (strftime('%s','now')), PRIMARY KEY (name, pack))`);
-      return _globalDb;
-    },
-    close() {
-      if (_globalDb) {
-        _globalDb.close();
-        _globalDb = null;
-      }
-    }
-  };
-  let workspacesConfig = null;
-  function getWorkspaces() {
-    if (!workspacesConfig) {
-      try {
-        workspacesConfig = JSON.parse(fs13.readFileSync(WORKSPACES_FILE, "utf8"));
-      } catch {
-        workspacesConfig = { active: "default", workspaces: { default: { name: "default", label: "Default", createdAt: Date.now() } } };
-        fs13.writeFileSync(WORKSPACES_FILE, JSON.stringify(workspacesConfig, null, 2));
-      }
-    }
-    return workspacesConfig;
-  }
-  __name(getWorkspaces, "getWorkspaces");
-  function setWorkspaces(data) {
-    workspacesConfig = data;
-    fs13.writeFileSync(WORKSPACES_FILE, JSON.stringify(data, null, 2));
-  }
-  __name(setWorkspaces, "setWorkspaces");
-  const debugLogger = new DebugLogger(DATA_DIR);
-  const mediaStash = /* @__PURE__ */ new Map();
-  const memoryConfig = discoverMemoryConfig();
-  const memoryProvider = createMemoryProvider(memoryConfig);
-  memoryProvider.init().catch((err) => console.error("[createApp] Memory provider init error:", err.message));
-  const MEMORY_FILES_DIR = path14.join(memoryConfig.workspaceDir, "memory");
-  const gatewayClient = new GatewayClient({ getDb, getWorkspaces, dataDir: DATA_DIR, debugLogger, gatewayWsUrl: gatewayUrl, authToken: gatewayToken, mediaStash });
-  const broadcast = /* @__PURE__ */ __name((msg) => gatewayClient.broadcastToBrowsers(msg), "broadcast");
-  const workspaces = new WorkspaceController({ getDb, closeDb, getWorkspaces, setWorkspaces, dataDir: DATA_DIR, broadcast });
-  const threads = new ThreadController({ getActiveDb, getWorkspaces, uploadsDir: UPLOADS_DIR, broadcast });
-  const messages = new MessageController({ getActiveDb, getWorkspaces, broadcast });
-  const files = new FileController({ getActiveDb, getWorkspaces, uploadsDir: UPLOADS_DIR, intelligenceDir: INTELLIGENCE_DIR });
-  const memory = new MemoryController({ memoryProvider, memoryFilesDir: MEMORY_FILES_DIR, memoryConfig });
-  function handleGetSettings(req, res) {
-    try {
-      send(res, 200, fs13.existsSync(SETTINGS_FILE) ? JSON.parse(fs13.readFileSync(SETTINGS_FILE, "utf8")) : {});
-    } catch {
-      send(res, 200, {});
-    }
-  }
-  __name(handleGetSettings, "handleGetSettings");
-  async function handleSaveSettings(req, res) {
-    const body = await parseBody(req);
-    fs13.mkdirSync(path14.dirname(SETTINGS_FILE), { recursive: true });
-    fs13.writeFileSync(SETTINGS_FILE, JSON.stringify(body, null, 2));
-    send(res, 200, { ok: true });
-  }
-  __name(handleSaveSettings, "handleSaveSettings");
-  function checkAuth(req, res) {
-    if (!authToken) return true;
-    const auth = req.headers.authorization;
-    if (!auth?.startsWith("Bearer ")) {
-      sendError(res, 401, "Missing or invalid Authorization header");
-      return false;
-    }
-    if (auth.slice(7) !== authToken) {
-      sendError(res, 401, "Invalid auth token");
-      return false;
-    }
-    return true;
-  }
-  __name(checkAuth, "checkAuth");
-  async function handleRequest(req, res) {
-    const wsName = req.headers?.["x-workspace"];
-    const db = wsName ? getDb(wsName) : getActiveDb();
-    return requestDbStore.run(db, () => route(req, res));
-  }
-  __name(handleRequest, "handleRequest");
-  async function route(req, res) {
-    const [urlPath, queryString] = (req.url || "/").split("?");
-    const query = {};
-    if (queryString) for (const pair of queryString.split("&")) {
-      const [k, v] = pair.split("=");
-      if (k) query[decodeURIComponent(k)] = decodeURIComponent(v || "");
-    }
-    const method = req.method;
-    let p;
-    if (method === "OPTIONS") {
-      setCors(res);
-      res.writeHead(204);
-      return res.end();
-    }
-    if (method === "GET" && !urlPath.startsWith("/api/")) {
-      const STATIC = { "/": "index.html", "/index.html": "index.html", "/app.js": "app.js", "/style.css": "style.css", "/error-handler.js": "error-handler.js", "/manifest.json": "manifest.json", "/favicon.ico": "favicon.ico" };
-      const fileName = STATIC[urlPath];
-      const isAllowed = fileName || urlPath.startsWith("/icons/") || urlPath.startsWith("/lib/") || urlPath.startsWith("/frontend/") || urlPath.startsWith("/emoji/") || urlPath === "/config.js";
-      if (isAllowed) {
-        const staticPath = path14.join(PLUGIN_DIR, fileName || urlPath.slice(1));
-        if (fs13.existsSync(staticPath) && fs13.statSync(staticPath).isFile()) {
-          const MIME = { ".html": "text/html", ".js": "text/javascript", ".css": "text/css", ".json": "application/json", ".ico": "image/x-icon", ".png": "image/png", ".svg": "image/svg+xml", ".gif": "image/gif", ".webp": "image/webp" };
-          const ext = path14.extname(staticPath).toLowerCase();
-          const stat = fs13.statSync(staticPath);
-          res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": ext === ".html" ? "no-cache" : "public, max-age=3600" });
-          return fs13.createReadStream(staticPath).pipe(res);
-        }
-      }
-    }
-    if (p = matchRoute(method, urlPath, "GET /api/uploads/:threadId/:fileId")) return files.serveUpload(req, res, p);
-    if (method === "GET" && urlPath === "/api/emoji") {
-      try {
-        const rows = globalDbCache.get().prepare("SELECT name, pack, url, mime_type FROM custom_emojis ORDER BY created_at DESC").all();
-        res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "public, max-age=300" });
-        return res.end(JSON.stringify(rows));
-      } catch (e) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        return res.end(JSON.stringify({ error: e.message }));
-      }
-    }
-    if (method === "GET" && urlPath === "/api/emoji/search") {
-      const q = query.q || "";
-      if (!q) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        return res.end(JSON.stringify({ error: "Missing ?q=" }));
-      }
-      try {
-        const https = await import("https");
-        const html = await new Promise((resolve, reject) => {
-          https.default.get(`https://slackmojis.com/emojis/search?query=${encodeURIComponent(q)}`, (resp) => {
-            let body = "";
-            resp.on("data", (c) => body += c);
-            resp.on("end", () => resolve(body));
-          }).on("error", reject);
-        });
-        const results = [];
-        const regex = /data-emoji-id-name="([^"]+)"[^>]*href="([^"]+)"[\s\S]*?<img[^>]*src="([^"]+)"/g;
-        let match;
-        while ((match = regex.exec(html)) !== null && results.length < 50) results.push({ name: match[1].replace(/^\d+-/, ""), image_url: match[3], download_url: `https://slackmojis.com${match[2]}` });
-        res.writeHead(200, { "Content-Type": "application/json" });
-        return res.end(JSON.stringify(results));
-      } catch (e) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        return res.end(JSON.stringify({ error: e.message }));
-      }
-    }
-    if (!checkAuth(req, res)) return;
-    try {
-      if (method === "POST" && urlPath === "/api/emoji/add") {
-        const { url, name, pack } = await parseBody(req);
-        if (!url || !name) {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          return res.end(JSON.stringify({ error: "Missing url or name" }));
-        }
-        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const targetPack = pack || "slackmojis";
-        const mimeType = url.toLowerCase().endsWith(".gif") ? "image/gif" : url.toLowerCase().endsWith(".webp") ? "image/webp" : url.toLowerCase().match(/\.jpe?g/) ? "image/jpeg" : "image/png";
-        globalDbCache.get().prepare("INSERT OR REPLACE INTO custom_emojis (name, pack, url, mime_type) VALUES (?, ?, ?, ?)").run(safeName, targetPack, url, mimeType);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        return res.end(JSON.stringify({ name: safeName, pack: targetPack, url, mime_type: mimeType }));
-      }
-      if (method === "DELETE" && urlPath === "/api/emoji") {
-        const { name, pack } = await parseBody(req);
-        if (!name || !pack) {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          return res.end(JSON.stringify({ error: "Missing name or pack" }));
-        }
-        globalDbCache.get().prepare("DELETE FROM custom_emojis WHERE name = ? AND pack = ?").run(name, pack);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        return res.end(JSON.stringify({ ok: true }));
-      }
-      if (method === "GET" && urlPath === "/api/file") return handleServeFile(req, res, query, memoryConfig);
-      if (method === "GET" && urlPath === "/api/workspace") return handleWorkspaceList(req, res, query);
-      if (method === "GET" && urlPath === "/api/workspace/file") return handleWorkspaceFileRead(req, res, query);
-      if (method === "PUT" && urlPath === "/api/workspace/file") return await handleWorkspaceFileWrite(req, res, query);
-      if (method === "DELETE" && urlPath === "/api/workspace/file") return handleWorkspaceFileDelete(req, res, query);
-      if (method === "POST" && urlPath === "/api/workspace/upload") return await handleWorkspaceUpload(req, res, query);
-      if (method === "GET" && urlPath === "/api/memory/status") return await memory.status(req, res);
-      if (method === "GET" && urlPath === "/api/memory/list") return await memory.list(req, res, query);
-      if (method === "GET" && urlPath === "/api/memory/search") return await memory.search(req, res, query);
-      if (method === "GET" && urlPath === "/api/memory/files") return memory.files(req, res, query);
-      if (p = matchRoute(method, urlPath, "PUT /api/memory/:id")) return await memory.update(req, res, p);
-      if (p = matchRoute(method, urlPath, "DELETE /api/memory/:id")) return await memory.delete(req, res, p);
-      if (method === "GET" && urlPath === "/api/settings") return handleGetSettings(req, res);
-      if (method === "PUT" && urlPath === "/api/settings") return await handleSaveSettings(req, res);
-      if (method === "POST" && urlPath === "/api/transcribe") return await handleTranscribe(req, res);
-      if (method === "GET" && urlPath === "/api/health") return send(res, 200, { ok: true, workspace: getWorkspaces().active, uptime: process.uptime() });
-      if (method === "GET" && urlPath === "/api/agents") {
-        try {
-          send(res, 200, { agents: fs13.readdirSync(path14.join(HOME3, ".openclaw", "agents"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) });
-        } catch {
-          send(res, 200, { agents: ["main"] });
-        }
-        return;
-      }
-      if (method === "GET" && urlPath === "/api/workspaces") return workspaces.getAll(req, res);
-      if (method === "POST" && urlPath === "/api/workspaces") return await workspaces.create(req, res);
-      if (p = matchRoute(method, urlPath, "PATCH /api/workspaces/:name")) return await workspaces.update(req, res, p);
-      if (p = matchRoute(method, urlPath, "DELETE /api/workspaces/:name")) return workspaces.delete(req, res, p);
-      if (method === "POST" && urlPath === "/api/workspaces/reorder") return await workspaces.reorder(req, res);
-      if (p = matchRoute(method, urlPath, "POST /api/workspaces/:name/activate")) return workspaces.activate(req, res, p);
-      if (method === "GET" && urlPath === "/api/threads") return threads.getAll(req, res, {}, query);
-      if (method === "GET" && urlPath === "/api/threads/unread") return threads.getUnread(req, res);
-      if (method === "POST" && urlPath === "/api/threads") return await threads.create(req, res);
-      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/mark-read")) return await threads.markRead(req, res, p);
-      if (p = matchRoute(method, urlPath, "GET /api/threads/:id/messages")) return messages.getAll(req, res, p, query);
-      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/messages")) return await messages.create(req, res, p);
-      if (p = matchRoute(method, urlPath, "DELETE /api/threads/:id/messages/:messageId")) return messages.delete(req, res, p);
-      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/context-fill")) return messages.contextFill(req, res, p);
-      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/generate-title")) {
-        const db = getActiveDb();
-        const thread = db.prepare("SELECT * FROM threads WHERE id = ?").get(p.id);
-        if (!thread) return sendError(res, 404, "Thread not found");
-        gatewayClient.generateThreadTitle(db, p.id, getWorkspaces().active);
-        return send(res, 200, { ok: true });
-      }
-      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/upload")) return await files.upload(req, res, p);
-      if (p = matchRoute(method, urlPath, "GET /api/threads/:id/intelligence")) return files.getIntelligence(req, res, p);
-      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/intelligence")) return await files.saveIntelligence(req, res, p);
-      if (p = matchRoute(method, urlPath, "GET /api/threads/:id")) return threads.get(req, res, p);
-      if (p = matchRoute(method, urlPath, "PATCH /api/threads/:id")) return await threads.update(req, res, p);
-      if (p = matchRoute(method, urlPath, "DELETE /api/threads/:id")) return threads.delete(req, res, p);
-      if (method === "GET" && urlPath === "/api/search") return messages.search(req, res, {}, query);
-      if (method === "GET" && urlPath === "/api/export") return messages.export(req, res);
-      if (method === "POST" && urlPath === "/api/import") return await messages.import(req, res);
-      if (method === "POST" && urlPath === "/api/active-thread") {
-        const body = await parseBody(req);
-        if (body.threadId && body.workspace) gatewayClient.setActiveThread(null, body.workspace, body.threadId);
-        return send(res, 200, { ok: true });
-      }
-      sendError(res, 404, `Not found: ${method} ${urlPath}`);
-    } catch (err) {
-      console.error(`Error handling ${method} ${urlPath}:`, err);
-      if (err.message?.includes("UNIQUE constraint")) sendError(res, 409, "Conflict: " + err.message);
-      else sendError(res, 500, err.message || "Internal server error");
-    }
-  }
-  __name(route, "route");
-  function setupBrowserWs(wss) {
-    wss.on("connection", (ws) => {
-      console.log("Browser client connected");
-      gatewayClient.addBrowserClient(ws);
-      ws.send(JSON.stringify({ type: "event", event: "connect.challenge", payload: { nonce: uuid(), ts: Date.now() } }));
-      ws.on("message", async (data) => {
-        const msgStr = data.toString();
-        debugLogger.logFrame("BR\u2192SRV", msgStr);
-        let msgToForward = msgStr;
-        try {
-          const msg = JSON.parse(msgStr);
-          if (msg.type === "req" && msg.method === "connect") {
-            const token = msg.params?.auth?.token;
-            if (token === authToken || !authToken) {
-              ws.send(JSON.stringify({ type: "res", id: msg.id, ok: true, payload: { type: "hello-ok", protocol: 3, server: { version: "0.1.0", host: "clawchats-backend" } } }));
-            } else {
-              ws.send(JSON.stringify({ type: "res", id: msg.id, ok: false, error: { code: "AUTH_FAILED", message: "Invalid auth token" } }));
-              ws.close();
-            }
-            return;
-          }
-          if (msg.type === "clawchats" || msg.type === "shellchat") {
-            if (msg.action === "active-thread") {
-              gatewayClient.setActiveThread(ws, msg.workspace, msg.threadId);
-              return;
-            }
-            if (msg.action === "debug-start") {
-              const r = debugLogger.start(msg.ts, ws);
-              ws.send(JSON.stringify(r.error === "already-active" ? { type: "clawchats", event: "debug-error", error: "Recording already active in another tab", sessionId: r.sessionId } : { type: "clawchats", event: "debug-started", sessionId: r.sessionId }));
-              return;
-            }
-            if (msg.action === "debug-dump") {
-              const r = debugLogger.saveDump(msg);
-              ws.send(JSON.stringify({ type: "clawchats", event: "debug-saved", sessionId: r.sessionId, files: r.files }));
-              return;
-            }
-          }
-          if (msg.type === "req" && msg.method === "chat.send" && msg.params?.attachments?.length > 0) {
-            const parsed = parseSessionKey(msg.params.sessionKey || "");
-            const threadId = parsed?.threadId || "misc";
-            const uploadDir = path14.join(UPLOADS_DIR, threadId);
-            fs13.mkdirSync(uploadDir, { recursive: true });
-            const extMap = { jpeg: "jpg", jpg: "jpg", png: "png", gif: "gif", webp: "webp", pdf: "pdf", "svg+xml": "svg", mp3: "mp3", mp4: "mp4", wav: "wav", webm: "webm" };
-            const savedPaths = [];
-            for (const att of msg.params.attachments) {
-              if (!att.content || !att.mimeType) continue;
-              try {
-                const rawExt = att.mimeType.split("/")[1]?.split(";")[0] || "bin";
-                const filePath = path14.join(uploadDir, `${Date.now()}_${Math.random().toString(36).slice(2, 6)}.${extMap[rawExt] || rawExt}`);
-                fs13.writeFileSync(filePath, Buffer.from(att.content, "base64"));
-                savedPaths.push(filePath);
-              } catch (err) {
-                console.error("[upload] Failed to save attachment:", err.message);
-              }
-            }
-            if (savedPaths.length > 0) {
-              const note = `
-
-[${savedPaths.length === 1 ? "Attached file saved on disk" : "Attached files saved on disk"}:
-${savedPaths.map((p) => `- ${p}`).join("\n")}]`;
-              msgToForward = JSON.stringify({ ...msg, params: { ...msg.params, message: (msg.params.message || "") + note } });
-            }
-          }
-        } catch {
-        }
-        gatewayClient.sendToGateway(msgToForward);
-      });
-      ws.on("close", () => {
-        console.log("Browser client disconnected");
-        debugLogger.handleClientDisconnect(ws);
-        gatewayClient.removeBrowserClient(ws);
-      });
-      ws.on("error", (err) => console.error("Browser WebSocket error:", err.message));
-    });
-  }
-  __name(setupBrowserWs, "setupBrowserWs");
-  return {
-    handleRequest,
-    getDb,
-    getActiveDb,
-    getWorkspaces,
-    setWorkspaces,
-    shutdown: closeAll,
-    closeAllDbs: closeAll,
-    gatewayClient,
-    setupBrowserWs,
-    dataDir: DATA_DIR
-  };
-}
-__name(createApp, "createApp");
-function migrate(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS threads (
-      id TEXT PRIMARY KEY, session_key TEXT UNIQUE NOT NULL, title TEXT DEFAULT 'New chat',
-      pinned INTEGER DEFAULT 0, pin_order INTEGER DEFAULT 0, model TEXT,
-      last_session_id TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS messages (
-      id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL,
-      status TEXT DEFAULT 'sent', metadata TEXT, seq INTEGER, timestamp INTEGER NOT NULL, created_at INTEGER NOT NULL,
-      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
-    );
-    CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages(thread_id, timestamp);
-    CREATE INDEX IF NOT EXISTS idx_messages_dedup ON messages(thread_id, role, timestamp);
-  `);
-  try {
-    db.exec("ALTER TABLE threads ADD COLUMN sort_order INTEGER DEFAULT 0");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE threads ADD COLUMN unread_count INTEGER DEFAULT 0");
-  } catch {
-  }
-  db.exec(`CREATE TABLE IF NOT EXISTS unread_messages (thread_id TEXT NOT NULL, message_id TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY (thread_id, message_id), FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE)`);
-  db.exec("CREATE INDEX IF NOT EXISTS idx_unread_thread ON unread_messages(thread_id)");
-  ensureFts(db);
-}
-__name(migrate, "migrate");
-function createFts(db) {
-  db.exec(`CREATE VIRTUAL TABLE messages_fts USING fts5(content, content=messages, content_rowid=rowid, tokenize='porter unicode61 tokenchars x27')`);
-  db.exec(`CREATE TRIGGER messages_ai AFTER INSERT ON messages BEGIN INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content); END`);
-  db.exec(`CREATE TRIGGER messages_ad AFTER DELETE ON messages BEGIN INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content); END`);
-  db.exec(`CREATE TRIGGER messages_au AFTER UPDATE ON messages BEGIN INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content); INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content); END`);
-}
-__name(createFts, "createFts");
-function dropFts(db) {
-  db.exec("DROP TABLE IF EXISTS messages_fts; DROP TRIGGER IF EXISTS messages_ai; DROP TRIGGER IF EXISTS messages_ad; DROP TRIGGER IF EXISTS messages_au;");
-}
-__name(dropFts, "dropFts");
-function ensureFts(db) {
-  const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
-  if (!hasFts) {
-    try {
-      createFts(db);
-      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
-    } catch (e) {
-      console.error("[DB] messages_fts creation failed:", e.message);
-    }
-    return;
-  }
-  const schema = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
-  if (schema && !schema.sql.includes("tokenchars")) {
-    console.log("[DB] Upgrading messages_fts tokenizer...");
-    try {
-      dropFts(db);
-      createFts(db);
-      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
-      console.log("[DB] Upgrade complete");
-    } catch (e) {
-      console.error("[DB] Upgrade failed:", e.message);
-      dropFts(db);
-    }
-  } else {
-    try {
-      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('integrity-check')").run();
-    } catch {
-      try {
-        db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
-      } catch (e) {
-        console.error("[DB] FTS rebuild failed:", e.message);
-        dropFts(db);
-      }
-    }
-  }
-}
-__name(ensureFts, "ensureFts");
-var isDirectRun = import.meta.url === `file://${process.argv[1]}`;
-if (isDirectRun) {
-  const app = createApp();
-  app.getActiveDb();
-  const server = http.createServer(app.handleRequest);
-  const wss = new WebSocketServer({ noServer: true });
-  app.setupBrowserWs(wss);
-  server.on("upgrade", (req, socket, head) => {
-    wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
-  });
-  server.listen(PORT, () => {
-    console.log(`ClawChats backend listening on port ${PORT}`);
-    console.log(`Active workspace: ${app.getWorkspaces().active}`);
-    console.log(`Data dir: ${app.dataDir}`);
-    app.gatewayClient.connect();
-  });
-  const shutdown = /* @__PURE__ */ __name(() => {
-    console.log("Shutting down...");
-    app.shutdown();
-    server.close(() => process.exit(0));
-    setTimeout(() => process.exit(1), 5e3);
-  }, "shutdown");
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-}
-export {
-  createApp
-};