@clawchatsai/connector 0.0.86 → 0.0.87

package/server.js

@@ -3,73 +3,45 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// ../server/index.js
+// server/index.js
 import http from "node:http";
 import fs13 from "node:fs";
-import path15 from "node:path";
+import path14 from "node:path";
 import os5 from "node:os";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { WebSocket as WS2, WebSocketServer } from "ws";
 
-// ../server/bootstrap/native.js
-import { execSync } from "node:child_process";
-import { createRequire } from "node:module";
+// server/bootstrap/native.js
+import { DatabaseSync as Database } from "node:sqlite";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var _require = createRequire(import.meta.url);
 var requestDbStore = new AsyncLocalStorage();
-function loadDatabase() {
-  const isAbiMismatch = /* @__PURE__ */ __name((e) => e.message && (e.message.includes("did not self-register") || e.message.includes("NODE_MODULE_VERSION") || e.message.includes("was compiled against a different Node.js version")), "isAbiMismatch");
-  try {
-    return _require("better-sqlite3");
-  } catch (e) {
-    if (!isAbiMismatch(e)) throw e;
-    console.error("[ClawChats] better-sqlite3 binary is incompatible with your Node.js version. Attempting auto-rebuild...");
-    try {
-      execSync("npm rebuild better-sqlite3", { cwd: __dirname, stdio: "inherit" });
-      const db = _require("better-sqlite3");
-      console.log("[ClawChats] Auto-rebuild succeeded \u2014 continuing startup.");
-      return db;
-    } catch (rebuildErr) {
-      console.error("[ClawChats] Auto-rebuild failed. Build tools may be missing.");
-      console.error(`[ClawChats]   cd ${__dirname} && npm rebuild better-sqlite3`);
-      console.error("[ClawChats]   Linux:  sudo apt install build-essential python3");
-      console.error("[ClawChats]   macOS:  xcode-select --install");
-      process.exit(1);
-    }
-  }
-}
-__name(loadDatabase, "loadDatabase");
-var Database = loadDatabase();
 
-// ../server/config.js
+// server/config.js
 import fs from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 import os from "node:os";
-import { execSync as execSync2 } from "node:child_process";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath } from "node:url";
 var HOME = os.homedir();
 var MAX_PREAMBLE_CHARS = 5e4;
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
 function parseConfigField(field) {
-  try {
-    const configText = fs.readFileSync(path2.join(__dirname2, "config.js"), "utf8");
-    const match = configText.match(new RegExp(`${field}:\\s*['"]([^'"]+)['"]`));
-    return match ? match[1] : null;
-  } catch {
-    return null;
+  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 _authToken = process.env.CLAWCHATS_AUTH_TOKEN || process.env.SHELLCHAT_AUTH_TOKEN || parseConfigField("authToken") || "";
-if (!_authToken) console.error("WARNING: No auth token configured. Set CLAWCHATS_AUTH_TOKEN or create config.js");
-var AUTH_TOKEN = _authToken;
+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 [path2.join(HOME, ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
+  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;
@@ -82,58 +54,30 @@ function discoverGatewayWsUrl() {
 }
 __name(discoverGatewayWsUrl, "discoverGatewayWsUrl");
 var GATEWAY_WS_URL = discoverGatewayWsUrl();
-function discoverViaCliSync() {
-  try {
-    const out = execSync2("openclaw status --json", { encoding: "utf8", timeout: 5e3 });
-    const status = JSON.parse(out);
-    if (status.sessions?.paths?.[0]) return path2.dirname(status.sessions.paths[0]);
-  } catch {
-  }
-  return null;
-}
-__name(discoverViaCliSync, "discoverViaCliSync");
-var OPENCLAW_SESSIONS_DIR = (() => {
-  if (process.env.OPENCLAW_SESSIONS_DIR) {
-    console.log(`Sessions dir: ${process.env.OPENCLAW_SESSIONS_DIR} (env)`);
-    return process.env.OPENCLAW_SESSIONS_DIR;
-  }
-  const cfgDir = parseConfigField("sessionsDir");
-  if (cfgDir) {
-    console.log(`Sessions dir: ${cfgDir} (config)`);
-    return cfgDir;
-  }
-  const cliDir = discoverViaCliSync();
-  if (cliDir) {
-    console.log(`Sessions dir: ${cliDir} (cli)`);
-    return cliDir;
-  }
-  const fallback = path2.join(HOME, ".openclaw", "agents", "main", "sessions");
-  console.log(`Sessions dir: ${fallback} (fallback)`);
-  return fallback;
-})();
+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 path2.join(HOME, ".openclaw", "agents", agentId, "sessions");
+  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 = path2.join(HOME, ".openclaw", "agents", agentId);
+  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
+// server/debug.js
 import fs2 from "node:fs";
-import path3 from "node:path";
+import path2 from "node:path";
 var DebugLogger = class {
   static {
     __name(this, "DebugLogger");
   }
   constructor(baseDir) {
-    this.baseDir = path3.join(baseDir, "..", "debug");
+    this.baseDir = path2.join(baseDir, "..", "debug");
     this.active = false;
     this.sessionId = null;
     this.wsStream = null;
@@ -144,7 +88,7 @@ var DebugLogger = class {
     this.sessionId = ts.replace(/[:.]/g, "-");
     this.originatingClient = originatingClient;
     fs2.mkdirSync(this.baseDir, { recursive: true });
-    this.wsStream = fs2.createWriteStream(path3.join(this.baseDir, `session-${this.sessionId}-ws.log`), { flags: "a" });
+    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 };
@@ -171,15 +115,15 @@ var DebugLogger = class {
 ${err.stack || ""}
 `;
     if (logContent) {
-      fs2.writeFileSync(path3.join(this.baseDir, `session-${id}-client.log`), logContent);
+      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-client.log`), logContent);
       files.push(`session-${id}-client.log`);
     }
     if (payload.state) {
-      fs2.writeFileSync(path3.join(this.baseDir, `session-${id}-state.json`), JSON.stringify(payload.state, null, 2));
+      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(path3.join(this.baseDir, `session-${id}-screenshot.jpg`), Buffer.from(payload.screenshot, "base64"));
+      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-screenshot.jpg`), Buffer.from(payload.screenshot, "base64"));
       files.push(`session-${id}-screenshot.jpg`);
     }
     const savedId = id;
@@ -205,14 +149,14 @@ ${err.stack || ""}
   }
 };
 
-// ../server/gateway.js
-import path5 from "node:path";
+// server/gateway.js
+import path4 from "node:path";
 import { WebSocket as WS } from "ws";
 
-// ../server/bootstrap/identity.js
+// server/bootstrap/identity.js
 import crypto from "node:crypto";
 import fs3 from "node:fs";
-import path4 from "node:path";
+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" });
@@ -242,7 +186,7 @@ function loadOrCreateDeviceIdentity(identityPath) {
   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(path4.dirname(identityPath), { recursive: true });
+  fs3.mkdirSync(path3.dirname(identityPath), { recursive: true });
   fs3.writeFileSync(identityPath, JSON.stringify(identity, null, 2) + "\n", { mode: 384 });
   return identity;
 }
@@ -257,7 +201,7 @@ function buildDeviceAuth(identity, { clientId, clientMode, role, scopes, token,
 }
 __name(buildDeviceAuth, "buildDeviceAuth");
 
-// ../server/util/helpers.js
+// 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);
@@ -378,7 +322,7 @@ function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
 }
 __name(writeActivityToDb, "writeActivityToDb");
 
-// ../server/gateway.js
+// server/gateway.js
 var GatewayClient = class {
   static {
     __name(this, "GatewayClient");
@@ -440,7 +384,7 @@ var GatewayClient = class {
       return;
     }
     if (msg.type === "event" && msg.event === "connect.challenge") {
-      const identity = loadOrCreateDeviceIdentity(path5.join(this.dataDir, "device-identity.json"));
+      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;
@@ -773,14 +717,14 @@ Title:`, deliver: false, idempotencyKey: reqId } }));
   }
 };
 
-// ../server/providers/memory.js
+// server/providers/memory.js
 import fs4 from "node:fs";
-import path6 from "node:path";
+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 [path6.join(os2.homedir(), ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
+  for (const cfgPath of [path5.join(os2.homedir(), ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
     try {
       oc = JSON.parse(fs4.readFileSync(cfgPath, "utf8"));
       break;
@@ -815,7 +759,7 @@ function discoverMemoryConfig() {
     } catch {
     }
   }
-  if (!cfg.workspaceDir) cfg.workspaceDir = path6.join(os2.homedir(), ".openclaw", "workspace");
+  if (!cfg.workspaceDir) cfg.workspaceDir = path5.join(os2.homedir(), ".openclaw", "workspace");
   return cfg;
 }
 __name(discoverMemoryConfig, "discoverMemoryConfig");
@@ -951,11 +895,11 @@ function createMemoryProvider(config) {
 }
 __name(createMemoryProvider, "createMemoryProvider");
 
-// ../server/controllers/workspaces.js
+// server/controllers/workspaces.js
 import fs6 from "node:fs";
-import path8 from "node:path";
+import path7 from "node:path";
 
-// ../server/util/http.js
+// server/util/http.js
 import crypto2 from "node:crypto";
 function parseBody(req) {
   return new Promise((resolve, reject) => {
@@ -1017,20 +961,20 @@ function matchRoute(method, url, pattern) {
 }
 __name(matchRoute, "matchRoute");
 
-// ../server/gateway-cleanup.js
+// server/gateway-cleanup.js
 import fs5 from "node:fs";
-import path7 from "node:path";
+import path6 from "node:path";
 function cleanGatewaySession(sessionKey) {
   try {
     const agentMatch = (sessionKey || "").match(/^agent:([^:]+):/);
     const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const sessionsPath = path7.join(sessionsDir, "sessions.json");
+    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(path7.join(sessionsDir, `${entry.sessionId}.jsonl`));
+        fs5.unlinkSync(path6.join(sessionsDir, `${entry.sessionId}.jsonl`));
       } catch {
       }
     }
@@ -1048,14 +992,14 @@ function cleanGatewaySessionsByPrefix(prefix) {
   try {
     const agentMatch = (prefix || "").match(/^agent:([^:]+):/);
     const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const sessionsPath = path7.join(sessionsDir, "sessions.json");
+    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(path7.join(sessionsDir, `${store[key].sessionId}.jsonl`));
+          fs5.unlinkSync(path6.join(sessionsDir, `${store[key].sessionId}.jsonl`));
         } catch {
         }
       }
@@ -1071,7 +1015,7 @@ function cleanGatewaySessionsByPrefix(prefix) {
 }
 __name(cleanGatewaySessionsByPrefix, "cleanGatewaySessionsByPrefix");
 
-// ../server/controllers/workspaces.js
+// server/controllers/workspaces.js
 var WorkspaceController = class {
   static {
     __name(this, "WorkspaceController");
@@ -1148,7 +1092,7 @@ var WorkspaceController = class {
     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 = path8.join(this.dataDir, `${params.name}.db`);
+    const dbPath = path7.join(this.dataDir, `${params.name}.db`);
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
         fs6.unlinkSync(dbPath + suffix);
@@ -1183,9 +1127,9 @@ var WorkspaceController = class {
   }
 };
 
-// ../server/controllers/threads.js
+// server/controllers/threads.js
 import fs7 from "node:fs";
-import path9 from "node:path";
+import path8 from "node:path";
 var ThreadController = class {
   static {
     __name(this, "ThreadController");
@@ -1295,28 +1239,28 @@ var ThreadController = class {
     let sessionIdToDelete = thread.last_session_id;
     if (!sessionIdToDelete) {
       try {
-        sessionIdToDelete = JSON.parse(fs7.readFileSync(path9.join(sessionsDir, "sessions.json"), "utf8"))[thread.session_key]?.sessionId;
+        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(path9.join(sessionsDir, `${sessionIdToDelete}.jsonl`));
+        fs7.unlinkSync(path8.join(sessionsDir, `${sessionIdToDelete}.jsonl`));
       } catch {
       }
     }
     try {
-      fs7.rmSync(path9.join(this.uploadsDir, params.id), { recursive: true });
+      fs7.rmSync(path8.join(this.uploadsDir, params.id), { recursive: true });
     } catch {
     }
     send(res, 200, { ok: true });
   }
 };
 
-// ../server/util/context.js
+// server/util/context.js
 import fs8 from "node:fs";
-import path10 from "node:path";
+import path9 from "node:path";
 function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
   let summary = null;
   let method = "raw";
@@ -1324,7 +1268,7 @@ function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
     const agentMatch = (sessionKey || "").match(/^agent:([^:]+):/);
     const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
     try {
-      const lines = fs8.readFileSync(path10.join(sessionsDir, `${lastSessionId}.jsonl`), "utf8").split("\n").filter(Boolean);
+      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]);
@@ -1369,7 +1313,7 @@ function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
 }
 __name(buildContextPreamble, "buildContextPreamble");
 
-// ../server/controllers/messages.js
+// server/controllers/messages.js
 var MessageController = class {
   static {
     __name(this, "MessageController");
@@ -1498,7 +1442,8 @@ var MessageController = class {
     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.transaction(() => {
+    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}`;
@@ -1509,16 +1454,20 @@ var MessageController = class {
           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
+// server/controllers/files.js
 import fs9 from "node:fs";
-import path11 from "node:path";
+import path10 from "node:path";
 
-// ../server/util/multipart.js
+// server/util/multipart.js
 function parseMultipart(req) {
   return new Promise((resolve, reject) => {
     const contentType = req.headers["content-type"] || "";
@@ -1566,7 +1515,7 @@ function parseMultipart(req) {
 }
 __name(parseMultipart, "parseMultipart");
 
-// ../server/controllers/files.js
+// server/controllers/files.js
 var FileController = class {
   static {
     __name(this, "FileController");
@@ -1580,35 +1529,35 @@ var FileController = class {
   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 = path11.join(this.uploadsDir, params.id);
+    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 = path11.extname(file.filename) || "";
-      fs9.writeFileSync(path11.join(dir, fileId + ext), file.data);
+      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 = path11.join(this.uploadsDir, params.threadId, params.fileId);
+    const base = path10.join(this.uploadsDir, params.threadId, params.fileId);
     let resolved = base;
     if (!fs9.existsSync(resolved)) {
       try {
-        const match = fs9.readdirSync(path11.join(this.uploadsDir, params.threadId)).find((e) => e.startsWith(params.fileId.replace(/\.[^.]+$/, "")));
-        if (match) resolved = path11.join(this.uploadsDir, params.threadId, match);
+        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[path11.extname(resolved).toLowerCase()] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*" });
+    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 path11.join(this.intelligenceDir, this.getWorkspaces().active, `${threadId}.json`);
+    return path10.join(this.intelligenceDir, this.getWorkspaces().active, `${threadId}.json`);
   }
   getIntelligence(req, res, params) {
     const filePath = this._intelligencePath(params.id);
@@ -1622,16 +1571,16 @@ var FileController = class {
   async saveIntelligence(req, res, params) {
     const body = await parseBody(req);
     const filePath = this._intelligencePath(params.id);
-    fs9.mkdirSync(path11.dirname(filePath), { recursive: true });
+    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
+// server/controllers/memory.js
 import fs10 from "node:fs";
-import path12 from "node:path";
+import path11 from "node:path";
 var MemoryController = class {
   static {
     __name(this, "MemoryController");
@@ -1675,7 +1624,7 @@ var MemoryController = class {
         return;
       }
       for (const entry of entries) {
-        const fullPath = path12.join(dir, entry);
+        const fullPath = path11.join(dir, entry);
         const stat = (() => {
           try {
             return fs10.statSync(fullPath);
@@ -1736,16 +1685,16 @@ ${body}` : body, createdAt: dateMatch ? `${dateMatch[1]}T00:00:00Z` : stat.mtime
   }
 };
 
-// ../server/controllers/filesystem.js
+// server/controllers/filesystem.js
 import fs11 from "node:fs";
-import path13 from "node:path";
+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("../") ? path13.resolve(memoryConfig.workspaceDir, filePath) : path13.resolve(filePath);
+  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 = {
@@ -1781,7 +1730,7 @@ function handleServeFile(req, res, query, memoryConfig) {
     ".webm": "video/webm"
   };
   const stat = fs11.statSync(resolved);
-  res.writeHead(200, { "Content-Type": MIME[path13.extname(resolved).toLowerCase()] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*" });
+  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");
@@ -1789,17 +1738,17 @@ 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 = path13.resolve(reqPath.replace(/^~/, HOME2));
+  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: path13.basename(resolved), size: 0 }];
+  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 = path13.join(dir, entry.name);
+        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 {
@@ -1820,11 +1769,11 @@ __name(handleWorkspaceList, "handleWorkspaceList");
 function handleWorkspaceFileRead(req, res, query) {
   const filePath = query.path;
   if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = path13.resolve(filePath.replace(/^~/, HOME2));
+  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 = path13.extname(resolved).toLowerCase().slice(1);
+  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) {
@@ -1841,11 +1790,11 @@ __name(handleWorkspaceFileRead, "handleWorkspaceFileRead");
 async function handleWorkspaceFileWrite(req, res, query) {
   const filePath = query.path;
   if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = path13.resolve(filePath.replace(/^~/, HOME2));
+  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 = path13.dirname(resolved);
+  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 });
@@ -1854,7 +1803,7 @@ __name(handleWorkspaceFileWrite, "handleWorkspaceFileWrite");
 function handleWorkspaceFileDelete(req, res, query) {
   const filePath = query.path;
   if (!filePath) return sendError(res, 400, "Missing path parameter");
-  const resolved = path13.resolve(filePath.replace(/^~/, HOME2));
+  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 {
@@ -1874,52 +1823,36 @@ __name(handleWorkspaceFileDelete, "handleWorkspaceFileDelete");
 async function handleWorkspaceUpload(req, res, query) {
   const targetDir = query.path;
   if (!targetDir) return sendError(res, 400, "Missing path parameter");
-  const resolved = path13.resolve(targetDir.replace(/^~/, HOME2));
+  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");
-  const contentType = req.headers["content-type"] || "";
-  if (!contentType.includes("multipart/form-data")) return sendError(res, 400, "Expected multipart/form-data");
-  const boundary = contentType.split("boundary=")[1];
-  if (!boundary) return sendError(res, 400, "Missing boundary");
-  const chunks = [];
-  for await (const chunk of req) chunks.push(chunk);
-  const body = Buffer.concat(chunks);
-  const boundaryBuf = Buffer.from("--" + boundary);
+  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 = [];
-  let start = 0;
-  while (true) {
-    const idx = body.indexOf(boundaryBuf, start);
-    if (idx === -1) break;
-    if (start > 0) {
-      const partData = body.slice(start, idx - 2);
-      const headerEnd = partData.indexOf("\r\n\r\n");
-      if (headerEnd !== -1) {
-        const headerStr = partData.slice(0, headerEnd).toString("utf8");
-        const fileContent = partData.slice(headerEnd + 4);
-        const filenameMatch = headerStr.match(/filename="([^"]+)"/);
-        if (filenameMatch && fileContent.length > 0) {
-          const filename = path13.basename(filenameMatch[1]);
-          let finalPath = path13.join(resolved, filename);
-          let counter = 1;
-          while (fs11.existsSync(finalPath)) {
-            const ext = path13.extname(filename);
-            finalPath = path13.join(resolved, `${path13.basename(filename, ext)} (${counter})${ext}`);
-            counter++;
-          }
-          fs11.writeFileSync(finalPath, fileContent);
-          uploaded.push({ name: path13.basename(finalPath), size: fileContent.length });
-        }
-      }
-    }
-    start = idx + boundaryBuf.length + 2;
+  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
+// server/controllers/transcribe.js
 import fs12 from "node:fs";
-import path14 from "node:path";
+import path13 from "node:path";
 import os4 from "node:os";
 async function handleTranscribe(req, res) {
   try {
@@ -1930,7 +1863,7 @@ async function handleTranscribe(req, res) {
     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(path14.join(os4.homedir(), ".openclaw", "openclaw.json"), "utf8"));
+      const ocConfig = JSON.parse(fs12.readFileSync(path13.join(os4.homedir(), ".openclaw", "openclaw.json"), "utf8"));
       apiKey = ocConfig?.skills?.entries?.["openai-whisper-api"]?.apiKey;
     } catch {
     }
@@ -1978,17 +1911,17 @@ json\r
 }
 __name(handleTranscribe, "handleTranscribe");
 
-// ../server/index.js
+// server/index.js
 var HOME3 = os5.homedir();
 var PORT = parseInt(process.env.PORT || "3001", 10);
-var __dirname3 = path15.dirname(fileURLToPath3(import.meta.url));
-var PLUGIN_DIR = path15.resolve(__dirname3, "..");
+var __dirname2 = path14.dirname(fileURLToPath2(import.meta.url));
+var PLUGIN_DIR = path14.resolve(__dirname2, "..");
 function createApp(config = {}) {
-  const DATA_DIR = config.dataDir || path15.join(PLUGIN_DIR, "data");
-  const UPLOADS_DIR = config.uploadsDir || path15.join(PLUGIN_DIR, "uploads");
-  const WORKSPACES_FILE = path15.join(DATA_DIR, "workspaces.json");
-  const SETTINGS_FILE = path15.join(DATA_DIR, "settings.json");
-  const INTELLIGENCE_DIR = path15.join(DATA_DIR, "intelligence");
+  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;
@@ -1997,10 +1930,10 @@ function createApp(config = {}) {
   const dbCache = /* @__PURE__ */ new Map();
   function getDb(workspaceName) {
     if (dbCache.has(workspaceName)) return dbCache.get(workspaceName);
-    const db = new Database(path15.join(DATA_DIR, `${workspaceName}.db`));
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
-    _migrate(db);
+    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;
   }
@@ -2027,8 +1960,8 @@ function createApp(config = {}) {
   const globalDbCache = {
     get() {
       if (_globalDb) return _globalDb;
-      _globalDb = new Database(path15.join(DATA_DIR, "global.db"));
-      _globalDb.pragma("journal_mode = WAL");
+      _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;
     },
@@ -2062,7 +1995,7 @@ function createApp(config = {}) {
   const memoryConfig = discoverMemoryConfig();
   const memoryProvider = createMemoryProvider(memoryConfig);
   memoryProvider.init().catch((err) => console.error("[createApp] Memory provider init error:", err.message));
-  const MEMORY_FILES_DIR = path15.join(memoryConfig.workspaceDir, "memory");
+  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 });
@@ -2080,7 +2013,7 @@ function createApp(config = {}) {
   __name(handleGetSettings, "handleGetSettings");
   async function handleSaveSettings(req, res) {
     const body = await parseBody(req);
-    fs13.mkdirSync(path15.dirname(SETTINGS_FILE), { recursive: true });
+    fs13.mkdirSync(path14.dirname(SETTINGS_FILE), { recursive: true });
     fs13.writeFileSync(SETTINGS_FILE, JSON.stringify(body, null, 2));
     send(res, 200, { ok: true });
   }
@@ -2124,10 +2057,10 @@ function createApp(config = {}) {
       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 = path15.join(PLUGIN_DIR, fileName || urlPath.slice(1));
+        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 = path15.extname(staticPath).toLowerCase();
+          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);
@@ -2214,7 +2147,7 @@ function createApp(config = {}) {
       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(path15.join(HOME3, ".openclaw", "agents"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) });
+          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"] });
         }
@@ -2303,7 +2236,7 @@ function createApp(config = {}) {
           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 = path15.join(UPLOADS_DIR, threadId);
+            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 = [];
@@ -2311,7 +2244,7 @@ function createApp(config = {}) {
               if (!att.content || !att.mimeType) continue;
               try {
                 const rawExt = att.mimeType.split("/")[1]?.split(";")[0] || "bin";
-                const filePath = path15.join(uploadDir, `${Date.now()}_${Math.random().toString(36).slice(2, 6)}.${extMap[rawExt] || rawExt}`);
+                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) {
@@ -2353,7 +2286,7 @@ ${savedPaths.map((p) => `- ${p}`).join("\n")}]`;
   };
 }
 __name(createApp, "createApp");
-function _migrate(db) {
+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',
@@ -2378,25 +2311,25 @@ function _migrate(db) {
   }
   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);
+  ensureFts(db);
 }
-__name(_migrate, "_migrate");
-function _createFts(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) {
+__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) {
+__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);
+      createFts(db);
       db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
     } catch (e) {
       console.error("[DB] messages_fts creation failed:", e.message);
@@ -2407,13 +2340,13 @@ function _ensureFts(db) {
   if (schema && !schema.sql.includes("tokenchars")) {
     console.log("[DB] Upgrading messages_fts tokenizer...");
     try {
-      _dropFts(db);
-      _createFts(db);
+      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);
+      dropFts(db);
     }
   } else {
     try {
@@ -2423,12 +2356,12 @@ function _ensureFts(db) {
         db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
       } catch (e) {
         console.error("[DB] FTS rebuild failed:", e.message);
-        _dropFts(db);
+        dropFts(db);
       }
     }
   }
 }
-__name(_ensureFts, "_ensureFts");
+__name(ensureFts, "ensureFts");
 var isDirectRun = import.meta.url === `file://${process.argv[1]}`;
 if (isDirectRun) {
   const app = createApp();