opencode-mem 2.8.3 → 2.8.7

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA8ZA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;oBA2Bb,aAAa,GACb,kBAAkB,GAClB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwCT,OAAO,GACP,QAAQ;;CAEf,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAobA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;oBA2Bb,aAAa,GACb,kBAAkB,GAClB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwCT,OAAO,GACP,QAAQ;;CAEf,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}

package/dist/config.js

@@ -126,6 +126,7 @@ const CONFIG_TEMPLATE = `{
   // Optional: Use OpenAI-compatible API for embeddings
   // "embeddingApiUrl": "https://api.openai.com/v1",
   // "embeddingApiKey": "sk-...",
+  // "embeddingModel": "text-embedding-3-small",  // 1536 dims, auto-detected
   
   // ============================================
   // Web Server Settings
@@ -302,6 +303,7 @@ function ensureConfigExists() {
 ensureConfigExists();
 function getEmbeddingDimensions(model) {
     const dimensionMap = {
+        // Local Xenova models
         "Xenova/nomic-embed-text-v1": 768,
         "Xenova/nomic-embed-text-v1-unsupervised": 768,
         "Xenova/nomic-embed-text-v1-ablated": 768,
@@ -317,6 +319,22 @@ function getEmbeddingDimensions(model) {
         "Xenova/gte-small": 384,
         "Xenova/GIST-small-Embedding-v0": 384,
         "Xenova/text-embedding-ada-002": 1536,
+        // OpenAI API models
+        "text-embedding-3-small": 1536,
+        "text-embedding-3-large": 3072,
+        "text-embedding-ada-002": 1536,
+        // Cohere API models
+        "embed-english-v3.0": 1024,
+        "embed-multilingual-v3.0": 1024,
+        "embed-english-light-v3.0": 384,
+        "embed-multilingual-light-v3.0": 384,
+        // Google API models
+        "text-embedding-004": 768,
+        "text-multilingual-embedding-002": 768,
+        // Voyage AI models
+        "voyage-3": 1024,
+        "voyage-3-lite": 512,
+        "voyage-code-3": 1024,
     };
     return dimensionMap[model] || 768;
 }

package/dist/services/sqlite/shard-manager.d.ts

@@ -10,6 +10,17 @@ export declare class ShardManager {
     getAllShards(scope: "user" | "project", scopeHash: string): ShardInfo[];
     createShard(scope: "user" | "project", scopeHash: string, shardIndex: number): ShardInfo;
     private initShardDb;
+    /**
+     * Check if the shard DB file exists and contains the required 'memories' table.
+     * Returns false if the file is missing or the table doesn't exist.
+     */
+    private isShardValid;
+    /**
+     * Ensure the shard DB has all required tables. If tables are missing,
+     * re-initialize them. This handles cases where the DB file exists but
+     * was corrupted or partially created.
+     */
+    private ensureShardTables;
     getWriteShard(scope: "user" | "project", scopeHash: string): ShardInfo;
     private markShardReadOnly;
     incrementVectorCount(shardId: number): void;

package/dist/services/sqlite/shard-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shard-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/shard-manager.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAW;IAC7B,OAAO,CAAC,YAAY,CAAS;;IAQ7B,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,iBAAiB;IAKzB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAsB9E,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE;IAgCvE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IA2BxF,OAAO,CAAC,WAAW;IA2DnB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS;IAetE,OAAO,CAAC,iBAAiB;IAOzB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAkBhD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAqBnC;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC"}
+{"version":3,"file":"shard-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/shard-manager.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAW;IAC7B,OAAO,CAAC,YAAY,CAAS;;IAQ7B,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,iBAAiB;IAKzB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAsB9E,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE;IAgCvE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IA2BxF,OAAO,CAAC,WAAW;IA2DnB;;;OAGG;IACH,OAAO,CAAC,YAAY;IA8BpB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAYzB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS;IAqCtE,OAAO,CAAC,iBAAiB;IAOzB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAoBhD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CA0BnC;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/dist/services/sqlite/shard-manager.js

@@ -1,5 +1,6 @@
 import { Database } from "bun:sqlite";
 import { join, basename, isAbsolute } from "node:path";
+import { existsSync } from "node:fs";
 import { CONFIG } from "../../config.js";
 import { connectionManager } from "./connection-manager.js";
 import { log } from "../logger.js";
@@ -163,11 +164,75 @@ export class ShardManager {
         db.run(`CREATE INDEX IF NOT EXISTS idx_created_at ON memories(created_at DESC)`);
         db.run(`CREATE INDEX IF NOT EXISTS idx_is_pinned ON memories(is_pinned)`);
     }
+    /**
+     * Check if the shard DB file exists and contains the required 'memories' table.
+     * Returns false if the file is missing or the table doesn't exist.
+     */
+    isShardValid(shard) {
+        if (!existsSync(shard.dbPath)) {
+            log("Shard DB file missing", { dbPath: shard.dbPath, shardId: shard.id });
+            return false;
+        }
+        try {
+            const db = connectionManager.getConnection(shard.dbPath);
+            const result = db
+                .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='memories'`)
+                .get();
+            if (!result) {
+                log("Shard DB missing 'memories' table", {
+                    dbPath: shard.dbPath,
+                    shardId: shard.id,
+                });
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            log("Error validating shard DB", {
+                dbPath: shard.dbPath,
+                error: String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Ensure the shard DB has all required tables. If tables are missing,
+     * re-initialize them. This handles cases where the DB file exists but
+     * was corrupted or partially created.
+     */
+    ensureShardTables(shard) {
+        try {
+            const db = connectionManager.getConnection(shard.dbPath);
+            this.initShardDb(db);
+        }
+        catch (error) {
+            log("Error ensuring shard tables", {
+                dbPath: shard.dbPath,
+                error: String(error),
+            });
+        }
+    }
     getWriteShard(scope, scopeHash) {
         let shard = this.getActiveShard(scope, scopeHash);
         if (!shard) {
             return this.createShard(scope, scopeHash, 0);
         }
+        // Validate that the shard DB file exists and has required tables
+        if (!this.isShardValid(shard)) {
+            log("Active shard is invalid, recreating", {
+                scope,
+                scopeHash,
+                shardIndex: shard.shardIndex,
+                dbPath: shard.dbPath,
+            });
+            // Close any cached connection to the invalid shard
+            connectionManager.closeConnection(shard.dbPath);
+            // Remove the stale metadata record
+            const deleteStmt = this.metadataDb.prepare(`DELETE FROM shards WHERE id = ?`);
+            deleteStmt.run(shard.id);
+            // Create a fresh shard with the same index
+            return this.createShard(scope, scopeHash, shard.shardIndex);
+        }
         if (shard.vectorCount >= CONFIG.maxVectorsPerShard) {
             this.markShardReadOnly(shard.id);
             return this.createShard(scope, scopeHash, shard.shardIndex + 1);
@@ -222,7 +287,10 @@ export class ShardManager {
                 }
             }
             catch (error) {
-                log("Error deleting shard file", { dbPath: fullPath, error: String(error) });
+                log("Error deleting shard file", {
+                    dbPath: fullPath,
+                    error: String(error),
+                });
             }
             const deleteStmt = this.metadataDb.prepare(`DELETE FROM shards WHERE id = ?`);
             deleteStmt.run(shardId);

package/dist/services/web-server.d.ts

@@ -4,7 +4,7 @@ interface WebServerConfig {
     enabled: boolean;
 }
 export declare class WebServer {
-    private worker;
+    private server;
     private config;
     private isOwner;
     private startPromise;
@@ -22,6 +22,9 @@ export declare class WebServer {
     isServerOwner(): boolean;
     getUrl(): string;
     checkServerAvailable(): Promise<boolean>;
+    private handleRequest;
+    private serveStaticFile;
+    private jsonResponse;
 }
 export declare function startWebServer(config: WebServerConfig): Promise<WebServer>;
 export {};

package/dist/services/web-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-server.d.ts","sourceRoot":"","sources":["../../src/services/web-server.ts"],"names":[],"mappings":"AAOA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB;AAeD,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,mBAAmB,CAA+B;IAC1D,OAAO,CAAC,kBAAkB,CAAsC;gBAEpD,MAAM,EAAE,eAAe;IAInC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAIpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YASd,MAAM;IA6EpB,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,mBAAmB;YAOb,eAAe;IA2BvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmC3B,SAAS,IAAI,OAAO;IAIpB,aAAa,IAAI,OAAO;IAIxB,MAAM,IAAI,MAAM;IAIV,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC;CAW/C;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CAIhF"}
+{"version":3,"file":"web-server.d.ts","sourceRoot":"","sources":["../../src/services/web-server.ts"],"names":[],"mappings":"AAiCA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAA6C;IAC3D,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,mBAAmB,CAA+B;IAC1D,OAAO,CAAC,kBAAkB,CAAsC;gBAEpD,MAAM,EAAE,eAAe;IAInC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAIpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YASd,MAAM;IAgCpB,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,mBAAmB;YAOb,eAAe;IA+BvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,SAAS,IAAI,OAAO;IAIpB,aAAa,IAAI,OAAO;IAIxB,MAAM,IAAI,MAAM;IAIV,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC;YAchC,aAAa;IAmN3B,OAAO,CAAC,eAAe;IA4BvB,OAAO,CAAC,YAAY;CAWrB;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CAIhF"}

package/dist/services/web-server.js

@@ -1,10 +1,12 @@
+import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { log } from "./logger.js";
+import { handleListTags, handleListMemories, handleAddMemory, handleDeleteMemory, handleBulkDelete, handleUpdateMemory, handleSearch, handleStats, handlePinMemory, handleUnpinMemory, handleRunCleanup, handleRunDeduplication, handleDetectMigration, handleRunMigration, handleDetectTagMigration, handleRunTagMigrationBatch, handleGetTagMigrationProgress, handleDeletePrompt, handleBulkDeletePrompts, handleGetUserProfile, handleGetProfileChangelog, handleGetProfileSnapshot, handleRefreshProfile, } from "./api-handlers.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export class WebServer {
-    worker = null;
+    server = null;
     config;
     isOwner = false;
     startPromise = null;
@@ -28,68 +30,28 @@ export class WebServer {
             return;
         }
         try {
-            const workerPath = join(__dirname, "web-server-worker.js");
-            this.worker = new Worker(workerPath);
-            const startedPromise = new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    reject(new Error("Worker start timeout"));
-                }, 10000);
-                this.worker.onmessage = (event) => {
-                    clearTimeout(timeout);
-                    const response = event.data;
-                    if (response.type === "started") {
-                        this.isOwner = true;
-                        resolve();
-                    }
-                    else if (response.type === "error") {
-                        const errorMsg = response.error || "Unknown error";
-                        if (errorMsg.includes("EADDRINUSE") || errorMsg.includes("address already in use")) {
-                            this.isOwner = false;
-                            resolve();
-                        }
-                        else {
-                            log("Web server worker error", { error: errorMsg });
-                            reject(new Error(errorMsg));
-                        }
-                    }
-                };
-                this.worker.onerror = (error) => {
-                    clearTimeout(timeout);
-                    const errorDetails = {
-                        message: error.message || "Unknown error",
-                        filename: error.filename || "unknown",
-                        lineno: error.lineno || 0,
-                        colno: error.colno || 0,
-                        error: error.error ? String(error.error) : "no error object",
-                        type: error.type || "error",
-                    };
-                    log("Web server worker error (detailed)", errorDetails);
-                    const errorMsg = error.message
-                        ? `${error.message} (at ${error.filename}:${error.lineno}:${error.colno})`
-                        : error.error
-                            ? String(error.error)
-                            : `Worker failed: ${JSON.stringify(errorDetails)}`;
-                    reject(new Error(errorMsg));
-                };
-            });
-            this.worker.postMessage({
-                type: "start",
+            this.server = Bun.serve({
                 port: this.config.port,
-                host: this.config.host,
+                hostname: this.config.host,
+                fetch: this.handleRequest.bind(this),
             });
-            await startedPromise;
-            if (!this.isOwner) {
-                this.startHealthCheckLoop();
-            }
+            this.isOwner = true;
         }
         catch (error) {
-            this.isOwner = false;
-            if (this.worker) {
-                this.worker.terminate();
-                this.worker = null;
+            const errorMsg = String(error);
+            if (errorMsg.includes("EADDRINUSE") ||
+                errorMsg.includes("address already in use") ||
+                /Failed to start server.*Is port \d+ in use/.test(errorMsg)) {
+                this.isOwner = false;
+                this.server = null;
+                this.startHealthCheckLoop();
+            }
+            else {
+                this.isOwner = false;
+                this.server = null;
+                log("Web server failed to start", { error: errorMsg });
+                throw error;
             }
-            log("Web server failed to start", { error: String(error) });
-            throw error;
         }
     }
     startHealthCheckLoop() {
@@ -119,15 +81,18 @@ export class WebServer {
             return;
         }
         try {
+            // Reset startPromise so _start() can run again
+            this.startPromise = null;
             await this._start();
-            this.isOwner = true;
-            log("Web server takeover successful", { port: this.config.port });
-            if (this.onTakeoverCallback) {
-                try {
-                    await this.onTakeoverCallback();
-                }
-                catch (error) {
-                    log("Takeover callback error", { error: String(error) });
+            if (this.isOwner) {
+                log("Web server takeover successful", { port: this.config.port });
+                if (this.onTakeoverCallback) {
+                    try {
+                        await this.onTakeoverCallback();
+                    }
+                    catch (error) {
+                        log("Takeover callback error", { error: String(error) });
+                    }
                 }
             }
         }
@@ -137,35 +102,15 @@ export class WebServer {
     }
     async stop() {
         this.stopHealthCheckLoop();
-        if (!this.isOwner || !this.worker) {
+        if (!this.isOwner || !this.server) {
             return;
         }
-        return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                if (this.worker) {
-                    this.worker.terminate();
-                    this.worker = null;
-                }
-                resolve();
-            }, 5000);
-            this.worker.onmessage = (event) => {
-                clearTimeout(timeout);
-                const response = event.data;
-                if (response.type === "stopped") {
-                    if (this.worker) {
-                        this.worker.terminate();
-                        this.worker = null;
-                    }
-                    resolve();
-                }
-            };
-            this.worker.postMessage({
-                type: "stop",
-            });
-        });
+        this.server.stop();
+        this.server = null;
+        this.isOwner = false;
     }
     isRunning() {
-        return this.worker !== null;
+        return this.server !== null;
     }
     isServerOwner() {
         return this.isOwner;
@@ -185,6 +130,221 @@ export class WebServer {
             return false;
         }
     }
+    // --- HTTP request handling (inlined from web-server-worker.ts) ---
+    async handleRequest(req) {
+        const url = new URL(req.url);
+        const path = url.pathname;
+        const method = req.method;
+        try {
+            if (path === "/" || path === "/index.html") {
+                return this.serveStaticFile("index.html", "text/html");
+            }
+            if (path === "/styles.css") {
+                return this.serveStaticFile("styles.css", "text/css");
+            }
+            if (path === "/app.js") {
+                return this.serveStaticFile("app.js", "application/javascript");
+            }
+            if (path === "/favicon.ico") {
+                return this.serveStaticFile("favicon.ico", "image/x-icon");
+            }
+            if (path === "/api/tags" && method === "GET") {
+                const result = await handleListTags();
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/memories" && method === "GET") {
+                const tag = url.searchParams.get("tag") || undefined;
+                const page = parseInt(url.searchParams.get("page") || "1");
+                const pageSize = parseInt(url.searchParams.get("pageSize") || "20");
+                const includePrompts = url.searchParams.get("includePrompts") !== "false";
+                const result = await handleListMemories(tag, page, pageSize, includePrompts);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/memories" && method === "POST") {
+                const body = (await req.json());
+                const result = await handleAddMemory(body);
+                return this.jsonResponse(result);
+            }
+            if (path.startsWith("/api/memories/") && method === "DELETE") {
+                const parts = path.split("/");
+                const id = parts[3];
+                if (!id || id === "bulk-delete") {
+                    return this.jsonResponse({ success: false, error: "Invalid ID" });
+                }
+                const cascade = url.searchParams.get("cascade") === "true";
+                const result = await handleDeleteMemory(id, cascade);
+                return this.jsonResponse(result);
+            }
+            if (path.startsWith("/api/memories/") && method === "PUT") {
+                const id = path.split("/").pop();
+                if (!id) {
+                    return this.jsonResponse({ success: false, error: "Invalid ID" });
+                }
+                const body = (await req.json());
+                const result = await handleUpdateMemory(id, body);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/memories/bulk-delete" && method === "POST") {
+                const body = (await req.json());
+                const cascade = body.cascade !== false;
+                const result = await handleBulkDelete(body.ids || [], cascade);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/search" && method === "GET") {
+                const query = url.searchParams.get("q");
+                const tag = url.searchParams.get("tag") || undefined;
+                const page = parseInt(url.searchParams.get("page") || "1");
+                const pageSize = parseInt(url.searchParams.get("pageSize") || "20");
+                if (!query) {
+                    return this.jsonResponse({ success: false, error: "query parameter required" });
+                }
+                const result = await handleSearch(query, tag, page, pageSize);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/stats" && method === "GET") {
+                const result = await handleStats();
+                return this.jsonResponse(result);
+            }
+            if (path.match(/^\/api\/memories\/[^/]+\/pin$/) && method === "POST") {
+                const id = path.split("/")[3];
+                if (!id) {
+                    return this.jsonResponse({ success: false, error: "Invalid ID" });
+                }
+                const result = await handlePinMemory(id);
+                return this.jsonResponse(result);
+            }
+            if (path.match(/^\/api\/memories\/[^/]+\/unpin$/) && method === "POST") {
+                const id = path.split("/")[3];
+                if (!id) {
+                    return this.jsonResponse({ success: false, error: "Invalid ID" });
+                }
+                const result = await handleUnpinMemory(id);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/cleanup" && method === "POST") {
+                const result = await handleRunCleanup();
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/deduplicate" && method === "POST") {
+                const result = await handleRunDeduplication();
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/migration/detect" && method === "GET") {
+                const result = await handleDetectMigration();
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/migration/tags/detect" && method === "GET") {
+                const result = await handleDetectTagMigration();
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/migration/tags/run-batch" && method === "POST") {
+                const body = (await req.json());
+                const batchSize = body?.batchSize || 5;
+                const result = await handleRunTagMigrationBatch(batchSize);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/migration/tags/progress" && method === "GET") {
+                const result = await handleGetTagMigrationProgress();
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/migration/run" && method === "POST") {
+                const body = (await req.json());
+                const strategy = body.strategy || "fresh-start";
+                if (strategy !== "fresh-start" && strategy !== "re-embed") {
+                    return this.jsonResponse({ success: false, error: "Invalid strategy" });
+                }
+                const result = await handleRunMigration(strategy);
+                return this.jsonResponse(result);
+            }
+            if (path.startsWith("/api/prompts/") && method === "DELETE") {
+                const parts = path.split("/");
+                const id = parts[3];
+                if (!id || id === "bulk-delete") {
+                    return this.jsonResponse({ success: false, error: "Invalid ID" });
+                }
+                const cascade = url.searchParams.get("cascade") === "true";
+                const result = await handleDeletePrompt(id, cascade);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/prompts/bulk-delete" && method === "POST") {
+                const body = (await req.json());
+                const cascade = body.cascade !== false;
+                const result = await handleBulkDeletePrompts(body.ids || [], cascade);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/user-profile" && method === "GET") {
+                const userId = url.searchParams.get("userId") || undefined;
+                const result = await handleGetUserProfile(userId);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/user-profile/changelog" && method === "GET") {
+                const profileId = url.searchParams.get("profileId");
+                const limit = parseInt(url.searchParams.get("limit") || "5");
+                if (!profileId) {
+                    return this.jsonResponse({ success: false, error: "profileId parameter required" });
+                }
+                const result = await handleGetProfileChangelog(profileId, limit);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/user-profile/snapshot" && method === "GET") {
+                const changelogId = url.searchParams.get("chlogId");
+                if (!changelogId) {
+                    return this.jsonResponse({ success: false, error: "changelogId parameter required" });
+                }
+                const result = await handleGetProfileSnapshot(changelogId);
+                return this.jsonResponse(result);
+            }
+            if (path === "/api/user-profile/refresh" && method === "POST") {
+                const body = (await req.json().catch(() => ({})));
+                const userId = body.userId || undefined;
+                const result = await handleRefreshProfile(userId);
+                return this.jsonResponse(result);
+            }
+            return new Response("Not Found", { status: 404 });
+        }
+        catch (error) {
+            return this.jsonResponse({
+                success: false,
+                error: String(error),
+            }, 500);
+        }
+    }
+    serveStaticFile(filename, contentType) {
+        try {
+            const webDir = join(__dirname, "..", "web");
+            const filePath = join(webDir, filename);
+            if (contentType.startsWith("image/")) {
+                const content = readFileSync(filePath);
+                return new Response(content, {
+                    headers: {
+                        "Content-Type": contentType,
+                        "Cache-Control": "public, max-age=86400",
+                    },
+                });
+            }
+            const content = readFileSync(filePath, "utf-8");
+            return new Response(content, {
+                headers: {
+                    "Content-Type": contentType,
+                    "Cache-Control": "no-cache",
+                },
+            });
+        }
+        catch (error) {
+            return new Response("File not found", { status: 404 });
+        }
+    }
+    jsonResponse(data, status = 200) {
+        return new Response(JSON.stringify(data), {
+            status,
+            headers: {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            },
+        });
+    }
 }
 export async function startWebServer(config) {
     const server = new WebServer(config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mem",
-  "version": "2.8.3",
+  "version": "2.8.7",
   "description": "OpenCode plugin that gives coding agents persistent memory using local vector database",
   "type": "module",
   "main": "dist/plugin.js",