@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/web-server.js

@@ -0,0 +1,356 @@
+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 {
+    server = null;
+    config;
+    isOwner = false;
+    startPromise = null;
+    healthCheckInterval = null;
+    onTakeoverCallback = null;
+    constructor(config) {
+        this.config = config;
+    }
+    setOnTakeoverCallback(callback) {
+        this.onTakeoverCallback = callback;
+    }
+    async start() {
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        this.startPromise = this._start();
+        return this.startPromise;
+    }
+    async _start() {
+        if (!this.config.enabled) {
+            return;
+        }
+        try {
+            this.server = Bun.serve({
+                port: this.config.port,
+                hostname: this.config.host,
+                fetch: this.handleRequest.bind(this),
+            });
+            this.isOwner = true;
+        }
+        catch (error) {
+            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;
+            }
+        }
+    }
+    startHealthCheckLoop() {
+        if (this.healthCheckInterval) {
+            return;
+        }
+        this.healthCheckInterval = setInterval(async () => {
+            const isAvailable = await this.checkServerAvailable();
+            if (!isAvailable) {
+                this.stopHealthCheckLoop();
+                await this.attemptTakeover();
+            }
+        }, 5000);
+    }
+    stopHealthCheckLoop() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    async attemptTakeover() {
+        // prevent thundering herd: multiple non-owners racing to bind port
+        const jitterMs = 500 + Math.random() * 1000;
+        await new Promise((resolve) => setTimeout(resolve, jitterMs));
+        if (await this.checkServerAvailable()) {
+            this.startHealthCheckLoop();
+            return;
+        }
+        try {
+            // Reset startPromise so _start() can run again
+            this.startPromise = null;
+            await this._start();
+            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) });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.startHealthCheckLoop();
+        }
+    }
+    async stop() {
+        this.stopHealthCheckLoop();
+        if (!this.isOwner || !this.server) {
+            return;
+        }
+        this.server.stop();
+        this.server = null;
+        this.isOwner = false;
+    }
+    isRunning() {
+        return this.server !== null;
+    }
+    isServerOwner() {
+        return this.isOwner;
+    }
+    getUrl() {
+        return `http://${this.config.host}:${this.config.port}`;
+    }
+    async checkServerAvailable() {
+        try {
+            const response = await fetch(`${this.getUrl()}/api/stats`, {
+                method: "GET",
+                signal: AbortSignal.timeout(2000),
+            });
+            return response.ok;
+        }
+        catch {
+            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 === "/i18n.js") {
+                return this.serveStaticFile("i18n.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);
+    await server.start();
+    return server;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,19 @@
+export type MemoryType = string;
+export interface MemoryMetadata {
+    type?: MemoryType;
+    source?: "manual" | "auto-capture" | "import" | "api";
+    tool?: string;
+    sessionID?: string;
+    reasoning?: string;
+    captureTimestamp?: number;
+    promptId?: string;
+    displayName?: string;
+    userName?: string;
+    userEmail?: string;
+    projectPath?: string;
+    projectName?: string;
+    gitRepoUrl?: string;
+    [key: string]: unknown;
+}
+export type AIProviderType = "openai-chat" | "openai-responses" | "anthropic";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,kBAAkB,GAAG,WAAW,CAAC"}

package/dist/types/index.js

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

package/dist/web/app.d.ts

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

package/dist/web/app.d.ts.map

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