opencode-mem 1.0.0

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

@@ -0,0 +1,221 @@
+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, } 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 result = await handleListMemories(tag, page, pageSize);
+            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 id = path.split("/").pop();
+            if (!id) {
+                return jsonResponse({ success: false, error: "Invalid ID" });
+            }
+            const result = await handleDeleteMemory(id);
+            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 result = await handleBulkDelete(body.ids || []);
+            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/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);
+        }
+        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,22 @@
+interface WebServerConfig {
+    port: number;
+    host: string;
+    enabled: boolean;
+}
+export declare class WebServer {
+    private worker;
+    private config;
+    private isOwner;
+    private startPromise;
+    constructor(config: WebServerConfig);
+    start(): Promise<void>;
+    private _start;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    isServerOwner(): boolean;
+    getUrl(): string;
+    checkServerAvailable(): Promise<boolean>;
+}
+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":"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;gBAEtC,MAAM,EAAE,eAAe;IAI7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YASd,MAAM;IA8Dd,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC3B,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"}

package/dist/services/web-server.js

@@ -0,0 +1,134 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { log } from "./logger.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export class WebServer {
+    worker = null;
+    config;
+    isOwner = false;
+    startPromise = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        this.startPromise = this._start();
+        return this.startPromise;
+    }
+    async _start() {
+        if (!this.config.enabled) {
+            log("Web server disabled in config");
+            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;
+                        log("Web server started (owner)", { url: response.url });
+                        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;
+                            log("Web server already running (port in use)");
+                            resolve();
+                        }
+                        else {
+                            log("Web server worker error", { error: errorMsg });
+                            reject(new Error(errorMsg));
+                        }
+                    }
+                };
+                this.worker.onerror = (error) => {
+                    clearTimeout(timeout);
+                    log("Web server worker error", { error: String(error) });
+                    reject(error);
+                };
+            });
+            this.worker.postMessage({
+                type: "start",
+                port: this.config.port,
+                host: this.config.host,
+            });
+            await startedPromise;
+        }
+        catch (error) {
+            this.isOwner = false;
+            if (this.worker) {
+                this.worker.terminate();
+                this.worker = null;
+            }
+            log("Web server failed to start", { error: String(error) });
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isOwner || !this.worker) {
+            log("Web server stop skipped (not owner or no worker)");
+            return;
+        }
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                if (this.worker) {
+                    this.worker.terminate();
+                    this.worker = null;
+                }
+                log("Web server stopped (timeout, forced termination)");
+                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;
+                    }
+                    log("Web server stopped (owner exiting)");
+                    resolve();
+                }
+            };
+            this.worker.postMessage({
+                type: "stop",
+            });
+        });
+    }
+    isRunning() {
+        return this.worker !== 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;
+        }
+    }
+}
+export async function startWebServer(config) {
+    const server = new WebServer(config);
+    await server.start();
+    return server;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,48 @@
+export type MemoryScope = "user" | "project";
+export type MemoryType = string;
+export type ConversationRole = "user" | "assistant" | "system" | "tool";
+export type ConversationContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    imageUrl: {
+        url: string;
+    };
+};
+export interface ConversationToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ConversationMessage {
+    role: ConversationRole;
+    content: string | ConversationContentPart[];
+    name?: string;
+    tool_calls?: ConversationToolCall[];
+    tool_call_id?: string;
+}
+export interface ConversationIngestResponse {
+    id: string;
+    conversationId: string;
+    status: string;
+}
+export interface MemoryMetadata {
+    type?: MemoryType;
+    source?: "manual" | "auto-capture" | "import" | "api";
+    tool?: string;
+    sessionID?: string;
+    reasoning?: string;
+    captureTimestamp?: number;
+    displayName?: string;
+    userName?: string;
+    userEmail?: string;
+    projectPath?: string;
+    projectName?: string;
+    gitRepoUrl?: string;
+    [key: string]: unknown;
+}
+//# 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,WAAW,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExE,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAErD,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,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,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"}

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":""}