@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/vector-backends/exact-scan-backend.js

@@ -0,0 +1,63 @@
+export class ExactScanBackend {
+    getBackendName() {
+        return "exact-scan";
+    }
+    rankVectors(rows, queryVector, limit) {
+        return rows
+            .map((row) => ({
+            id: row.id,
+            distance: 1 - this.cosineSimilarity(row.vector, queryVector),
+        }))
+            .sort((a, b) => a.distance - b.distance)
+            .slice(0, limit);
+    }
+    async insert(_args) { }
+    async insertBatch(_args) { }
+    async delete(_args) { }
+    async search(args) {
+        const column = args.kind === "tags" ? "tags_vector" : "vector";
+        const rows = args.db
+            .prepare(`SELECT id, ${column} FROM memories WHERE ${column} IS NOT NULL`)
+            .all();
+        if (rows.length === 0) {
+            return [];
+        }
+        const rankedRows = rows
+            .map((row) => ({
+            id: row.id,
+            vector: this.decodeVector(args.kind === "tags" ? row.tags_vector : row.vector),
+        }))
+            .filter((row) => row.vector.length > 0);
+        return this.rankVectors(rankedRows, args.queryVector, args.limit);
+    }
+    async rebuildFromShard(_args) { }
+    async deleteShardIndexes(_args) { }
+    decodeVector(value) {
+        if (!value) {
+            return new Float32Array();
+        }
+        if (value instanceof Uint8Array) {
+            return new Float32Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+        }
+        return new Float32Array(value);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+            return 0;
+        }
+        let dot = 0;
+        let magA = 0;
+        let magB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const av = a[i] ?? 0;
+            const bv = b[i] ?? 0;
+            dot += av * bv;
+            magA += av * av;
+            magB += bv * bv;
+        }
+        if (magA === 0 || magB === 0) {
+            return 0;
+        }
+        return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+    }
+}

package/dist/services/vector-backends/types.d.ts

@@ -0,0 +1,51 @@
+import type { ShardInfo } from "../sqlite/types.js";
+export type VectorKind = "content" | "tags";
+export interface BackendSearchResult {
+    id: string;
+    distance: number;
+}
+export interface BackendInsertItem {
+    id: string;
+    vector: Float32Array;
+}
+export interface VectorBackendSearchParams {
+    db: unknown;
+    shard: ShardInfo;
+    kind: VectorKind;
+    queryVector: Float32Array;
+    limit: number;
+}
+export interface VectorBackend {
+    getBackendName(): string;
+    insert(args: {
+        id: string;
+        vector: Float32Array;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    insertBatch(args: {
+        items: BackendInsertItem[];
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    delete(args: {
+        id: string;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    search(args: VectorBackendSearchParams): Promise<BackendSearchResult[]>;
+    rebuildFromShard(args: {
+        db: unknown;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    deleteShardIndexes(args: {
+        shard: ShardInfo;
+    }): Promise<void>;
+}
+export interface VectorBackendFactoryOptions {
+    vectorBackend: "usearch-first" | "usearch" | "exact-scan";
+    probeUSearch?: () => Promise<boolean>;
+    createUSearchBackend?: () => VectorBackend;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/vector-backends/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/vector-backends/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,YAAY,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,cAAc,IAAI,MAAM,CAAC;IACzB,MAAM,CAAC,IAAI,EAAE;QACX,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,WAAW,CAAC,IAAI,EAAE;QAChB,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAC3B,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,MAAM,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,MAAM,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACxE,gBAAgB,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3F,kBAAkB,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,SAAS,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,eAAe,GAAG,SAAS,GAAG,YAAY,CAAC;IAC1D,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,oBAAoB,CAAC,EAAE,MAAM,aAAa,CAAC;CAC5C"}

package/dist/services/vector-backends/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/vector-backends/usearch-backend.d.ts

@@ -0,0 +1,47 @@
+import type { BackendInsertItem, BackendSearchResult, VectorBackend, VectorBackendSearchParams, VectorKind } from "./types.js";
+import type { ShardInfo } from "../sqlite/types.js";
+export declare class USearchBackend implements VectorBackend {
+    private readonly options;
+    private readonly indexes;
+    constructor(options: {
+        baseDir: string;
+        dimensions: number;
+    });
+    getBackendName(): string;
+    insert(args: {
+        id: string;
+        vector: Float32Array;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    insertBatch(args: {
+        items: BackendInsertItem[];
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    delete(args: {
+        id: string;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    search(args: VectorBackendSearchParams): Promise<BackendSearchResult[]>;
+    rebuildFromShard(args: {
+        db: unknown;
+        shard: ShardInfo;
+        kind: VectorKind;
+    }): Promise<void>;
+    deleteShardIndexes(args: {
+        shard: ShardInfo;
+    }): Promise<void>;
+    insertManyForTest(indexKey: string, items: BackendInsertItem[]): Promise<void>;
+    searchForTest(indexKey: string, queryVector: Float32Array, limit: number): Promise<BackendSearchResult[]>;
+    private getOrCreateIndex;
+    private createEmptyIndex;
+    private ensureKey;
+    private addItems;
+    private upsertItem;
+    private decodeVector;
+    private getIndexKey;
+    private loadUSearch;
+}
+//# sourceMappingURL=usearch-backend.d.ts.map

package/dist/services/vector-backends/usearch-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usearch-backend.d.ts","sourceRoot":"","sources":["../../../src/services/vector-backends/usearch-backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,yBAAyB,EACzB,UAAU,EACX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAcpD,qBAAa,cAAe,YAAW,aAAa;IAIhD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;gBAGvC,OAAO,EAAE;QACxB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB;IAKH,cAAc,IAAI,MAAM;IAIlB,MAAM,CAAC,IAAI,EAAE;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IAWX,WAAW,CAAC,IAAI,EAAE;QACtB,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAC3B,KAAK,EAAE,SAAS,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IAWX,MAAM,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E,MAAM,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAsBvE,gBAAgB,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC1F,kBAAkB,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,SAAS,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9E,aAAa,CACjB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,YAAY,EACzB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,mBAAmB,EAAE,CAAC;YAqBnB,gBAAgB;YAShB,gBAAgB;IAY9B,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,WAAW;YAIL,WAAW;CAO1B"}

package/dist/services/vector-backends/usearch-backend.js

@@ -0,0 +1,174 @@
+export class USearchBackend {
+    options;
+    indexes = new Map();
+    constructor(options) {
+        this.options = options;
+        void this.options.baseDir;
+    }
+    getBackendName() {
+        return "usearch";
+    }
+    async insert(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            this.upsertItem(cache, { id: args.id, vector: args.vector });
+            cache.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`USearch insert failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async insertBatch(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            this.addItems(cache, args.items);
+            cache.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`USearch batch insert failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async delete(args) {
+        const cache = await this.getOrCreateIndex(this.getIndexKey(args.shard, args.kind));
+        const key = cache.idToKey.get(args.id);
+        if (key === undefined)
+            return;
+        cache.index.remove(key);
+        cache.idToKey.delete(args.id);
+        cache.keyToId.delete(key);
+    }
+    async search(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            const matches = cache.index.search(args.queryVector, args.limit);
+            return Array.from(matches.keys, (key, index) => {
+                const id = cache.keyToId.get(key);
+                if (!id) {
+                    throw new Error(`USearch index metadata missing for key ${String(key)} in ${cache.indexKey}`);
+                }
+                return {
+                    id,
+                    distance: matches.distances[index] ?? 0,
+                };
+            });
+        }
+        catch (error) {
+            throw new Error(`USearch search failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async rebuildFromShard(args) {
+        const indexKey = this.getIndexKey(args.shard, args.kind);
+        const existing = this.indexes.get(indexKey);
+        if (existing?.initialized) {
+            return;
+        }
+        const column = args.kind === "tags" ? "tags_vector" : "vector";
+        const rows = args.db
+            .prepare(`SELECT id, ${column} FROM memories WHERE ${column} IS NOT NULL`)
+            .all();
+        const cache = await this.createEmptyIndex(indexKey);
+        this.indexes.set(indexKey, cache);
+        for (const row of rows) {
+            const raw = args.kind === "tags" ? row.tags_vector : row.vector;
+            const vector = this.decodeVector(raw);
+            if (vector.length === 0)
+                continue;
+            this.upsertItem(cache, { id: row.id, vector });
+        }
+        cache.initialized = true;
+    }
+    async deleteShardIndexes(args) {
+        for (const kind of ["content", "tags"]) {
+            const indexKey = this.getIndexKey(args.shard, kind);
+            this.indexes.delete(indexKey);
+        }
+    }
+    async insertManyForTest(indexKey, items) {
+        const cache = await this.getOrCreateIndex(indexKey);
+        this.addItems(cache, items);
+        cache.initialized = true;
+    }
+    async searchForTest(indexKey, queryVector, limit) {
+        const cache = await this.getOrCreateIndex(indexKey);
+        try {
+            const matches = cache.index.search(queryVector, limit);
+            return Array.from(matches.keys, (key, index) => {
+                const id = cache.keyToId.get(key);
+                if (!id) {
+                    throw new Error(`USearch index metadata missing for key ${String(key)} in ${cache.indexKey}`);
+                }
+                return {
+                    id,
+                    distance: matches.distances[index] ?? 0,
+                };
+            });
+        }
+        catch (error) {
+            throw new Error(`USearch test search failed for ${indexKey}: ${String(error)}`);
+        }
+    }
+    async getOrCreateIndex(indexKey) {
+        const existing = this.indexes.get(indexKey);
+        if (existing)
+            return existing;
+        const cache = await this.createEmptyIndex(indexKey);
+        this.indexes.set(indexKey, cache);
+        return cache;
+    }
+    async createEmptyIndex(indexKey) {
+        const usearch = await this.loadUSearch();
+        return {
+            index: new usearch.Index({ dimensions: this.options.dimensions, metric: "cos" }),
+            idToKey: new Map(),
+            keyToId: new Map(),
+            nextKey: 1n,
+            indexKey,
+            initialized: false,
+        };
+    }
+    ensureKey(cache, id) {
+        const existing = cache.idToKey.get(id);
+        if (existing !== undefined)
+            return existing;
+        const key = cache.nextKey;
+        cache.nextKey += 1n;
+        cache.idToKey.set(id, key);
+        cache.keyToId.set(key, id);
+        return key;
+    }
+    addItems(cache, items) {
+        for (const item of items) {
+            this.upsertItem(cache, item);
+        }
+    }
+    upsertItem(cache, item) {
+        const existing = cache.idToKey.get(item.id);
+        if (existing !== undefined) {
+            cache.index.remove(existing);
+        }
+        const key = this.ensureKey(cache, item.id);
+        cache.index.add(key, item.vector);
+    }
+    decodeVector(value) {
+        if (!value)
+            return new Float32Array();
+        if (value instanceof Uint8Array) {
+            return new Float32Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+        }
+        return new Float32Array(value);
+    }
+    getIndexKey(shard, kind) {
+        return `${shard.scope}_${shard.scopeHash}_${shard.shardIndex}_${kind}`;
+    }
+    async loadUSearch() {
+        try {
+            return await import("usearch");
+        }
+        catch (error) {
+            throw new Error(`Failed to load usearch backend: ${String(error)}`);
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=web-server-worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"web-server-worker.d.ts","sourceRoot":"","sources":["../../src/services/web-server-worker.ts"],"names":[],"mappings":""}

package/dist/services/web-server-worker.js

@@ -0,0 +1,283 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+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);
+let server = null;
+async function handleRequest(req) {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+    try {
+        if (path === "/" || path === "/index.html") {
+            return serveStaticFile("index.html", "text/html");
+        }
+        if (path === "/styles.css") {
+            return serveStaticFile("styles.css", "text/css");
+        }
+        if (path === "/app.js") {
+            return serveStaticFile("app.js", "application/javascript");
+        }
+        if (path === "/favicon.ico") {
+            return serveStaticFile("favicon.ico", "image/x-icon");
+        }
+        if (path === "/api/tags" && method === "GET") {
+            const result = await handleListTags();
+            return 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 jsonResponse(result);
+        }
+        if (path === "/api/memories" && method === "POST") {
+            const body = (await req.json());
+            const result = await handleAddMemory(body);
+            return jsonResponse(result);
+        }
+        if (path.startsWith("/api/memories/") && method === "DELETE") {
+            const parts = path.split("/");
+            const id = parts[3];
+            if (!id || id === "bulk-delete") {
+                return jsonResponse({ success: false, error: "Invalid ID" });
+            }
+            const cascade = url.searchParams.get("cascade") === "true";
+            const result = await handleDeleteMemory(id, cascade);
+            return jsonResponse(result);
+        }
+        if (path.startsWith("/api/memories/") && method === "PUT") {
+            const id = path.split("/").pop();
+            if (!id) {
+                return jsonResponse({ success: false, error: "Invalid ID" });
+            }
+            const body = (await req.json());
+            const result = await handleUpdateMemory(id, body);
+            return 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 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 jsonResponse({ success: false, error: "query parameter required" });
+            }
+            const result = await handleSearch(query, tag, page, pageSize);
+            return jsonResponse(result);
+        }
+        if (path === "/api/stats" && method === "GET") {
+            const result = await handleStats();
+            return jsonResponse(result);
+        }
+        if (path.match(/^\/api\/memories\/[^/]+\/pin$/) && method === "POST") {
+            const id = path.split("/")[3];
+            if (!id) {
+                return jsonResponse({ success: false, error: "Invalid ID" });
+            }
+            const result = await handlePinMemory(id);
+            return jsonResponse(result);
+        }
+        if (path.match(/^\/api\/memories\/[^/]+\/unpin$/) && method === "POST") {
+            const id = path.split("/")[3];
+            if (!id) {
+                return jsonResponse({ success: false, error: "Invalid ID" });
+            }
+            const result = await handleUnpinMemory(id);
+            return jsonResponse(result);
+        }
+        if (path === "/api/cleanup" && method === "POST") {
+            const result = await handleRunCleanup();
+            return jsonResponse(result);
+        }
+        if (path === "/api/deduplicate" && method === "POST") {
+            const result = await handleRunDeduplication();
+            return jsonResponse(result);
+        }
+        if (path === "/api/migration/detect" && method === "GET") {
+            const result = await handleDetectMigration();
+            return jsonResponse(result);
+        }
+        if (path === "/api/migration/tags/detect" && method === "GET") {
+            const result = await handleDetectTagMigration();
+            return 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 jsonResponse(result);
+        }
+        if (path === "/api/migration/tags/progress" && method === "GET") {
+            const result = await handleGetTagMigrationProgress();
+            return 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 jsonResponse({ success: false, error: "Invalid strategy" });
+            }
+            const result = await handleRunMigration(strategy);
+            return jsonResponse(result);
+        }
+        if (path.startsWith("/api/prompts/") && method === "DELETE") {
+            const parts = path.split("/");
+            const id = parts[3];
+            if (!id || id === "bulk-delete") {
+                return jsonResponse({ success: false, error: "Invalid ID" });
+            }
+            const cascade = url.searchParams.get("cascade") === "true";
+            const result = await handleDeletePrompt(id, cascade);
+            return 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 jsonResponse(result);
+        }
+        if (path === "/api/user-profile" && method === "GET") {
+            const userId = url.searchParams.get("userId") || undefined;
+            const result = await handleGetUserProfile(userId);
+            return 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 jsonResponse({ success: false, error: "profileId parameter required" });
+            }
+            const result = await handleGetProfileChangelog(profileId, limit);
+            return jsonResponse(result);
+        }
+        if (path === "/api/user-profile/snapshot" && method === "GET") {
+            const changelogId = url.searchParams.get("chlogId");
+            if (!changelogId) {
+                return jsonResponse({ success: false, error: "changelogId parameter required" });
+            }
+            const result = await handleGetProfileSnapshot(changelogId);
+            return 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 jsonResponse(result);
+        }
+        return new Response("Not Found", { status: 404 });
+    }
+    catch (error) {
+        return jsonResponse({
+            success: false,
+            error: String(error),
+        }, 500);
+    }
+}
+function 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 });
+    }
+}
+function 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",
+        },
+    });
+}
+self.onmessage = async (event) => {
+    const message = event.data;
+    try {
+        switch (message.type) {
+            case "start": {
+                if (server) {
+                    self.postMessage({
+                        type: "error",
+                        error: "Server already running",
+                    });
+                    return;
+                }
+                server = Bun.serve({
+                    port: message.port,
+                    hostname: message.host,
+                    fetch: handleRequest,
+                });
+                self.postMessage({
+                    type: "started",
+                    url: `http://${message.host}:${message.port}`,
+                });
+                break;
+            }
+            case "stop": {
+                if (server) {
+                    server.stop();
+                    server = null;
+                    self.postMessage({
+                        type: "stopped",
+                    });
+                }
+                else {
+                    self.postMessage({
+                        type: "error",
+                        error: "Server not running",
+                    });
+                }
+                break;
+            }
+            case "status": {
+                self.postMessage({
+                    type: "status",
+                    running: server !== null,
+                });
+                break;
+            }
+            default: {
+                self.postMessage({
+                    type: "error",
+                    error: `Unknown message type: ${message.type}`,
+                });
+                break;
+            }
+        }
+    }
+    catch (error) {
+        self.postMessage({
+            type: "error",
+            error: String(error),
+        });
+    }
+};

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

@@ -0,0 +1,31 @@
+interface WebServerConfig {
+    port: number;
+    host: string;
+    enabled: boolean;
+}
+export declare class WebServer {
+    private server;
+    private config;
+    private isOwner;
+    private startPromise;
+    private healthCheckInterval;
+    private onTakeoverCallback;
+    constructor(config: WebServerConfig);
+    setOnTakeoverCallback(callback: () => Promise<void>): void;
+    start(): Promise<void>;
+    private _start;
+    private startHealthCheckLoop;
+    private stopHealthCheckLoop;
+    private attemptTakeover;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    isServerOwner(): boolean;
+    getUrl(): string;
+    checkServerAvailable(): Promise<boolean>;
+    private handleRequest;
+    private serveStaticFile;
+    private jsonResponse;
+}
+export declare function startWebServer(config: WebServerConfig): Promise<WebServer>;
+export {};
+//# sourceMappingURL=web-server.d.ts.map

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

@@ -0,0 +1 @@
+{"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;IAuN3B,OAAO,CAAC,eAAe;IA4BvB,OAAO,CAAC,YAAY;CAWrB;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CAIhF"}