om-memory-system 3.0.0

package/dist/services/auth-token.d.ts

@@ -0,0 +1,14 @@
+export declare const AUTH_HEADER = "x-omms-token";
+/** Header sent by opencode-mem-era clients; still accepted. */
+export declare const LEGACY_AUTH_HEADER = "x-opencode-mem-token";
+/**
+ * A shared secret generated on first run and persisted to a local,
+ * user-only-readable file. Required on every /api/* request so that a
+ * malicious web page (which cannot read cross-origin/opaque responses,
+ * including the token injected into index.html) cannot drive the API via
+ * CSRF even though the CORS check alone lets no-Origin requests through.
+ */
+export declare function getOrCreateAuthToken(): string;
+/** The auth token from either the omms header or the legacy opencode-mem header. */
+export declare function getRequestToken(req: Request): string | undefined;
+export declare function isAuthorizedApiRequest(req: Request): boolean;

package/dist/services/auth-token.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync, writeFileSync, chmodSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { randomBytes } from "node:crypto";
+const DATA_DIR = join(homedir(), ".omms");
+const TOKEN_FILE = join(DATA_DIR, ".auth-token");
+// Token written by opencode-mem builds; adopted once so open web UI tabs keep working.
+const LEGACY_TOKEN_FILE = join(homedir(), ".opencode-mem", ".auth-token");
+export const AUTH_HEADER = "x-omms-token";
+/** Header sent by opencode-mem-era clients; still accepted. */
+export const LEGACY_AUTH_HEADER = "x-opencode-mem-token";
+let cachedToken = null;
+function readToken(path) {
+    if (!existsSync(path))
+        return null;
+    const token = readFileSync(path, "utf-8").trim();
+    return token || null;
+}
+function writeToken(token) {
+    mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(TOKEN_FILE, token, { mode: 0o600 });
+    if (platform() !== "win32") {
+        try {
+            chmodSync(TOKEN_FILE, 0o600);
+        }
+        catch {
+            // best-effort; file was already created with mode 0o600 above
+        }
+    }
+}
+/**
+ * A shared secret generated on first run and persisted to a local,
+ * user-only-readable file. Required on every /api/* request so that a
+ * malicious web page (which cannot read cross-origin/opaque responses,
+ * including the token injected into index.html) cannot drive the API via
+ * CSRF even though the CORS check alone lets no-Origin requests through.
+ */
+export function getOrCreateAuthToken() {
+    if (cachedToken) {
+        return cachedToken;
+    }
+    const existing = readToken(TOKEN_FILE);
+    if (existing) {
+        cachedToken = existing;
+        return cachedToken;
+    }
+    const token = readToken(LEGACY_TOKEN_FILE) ?? randomBytes(32).toString("hex");
+    writeToken(token);
+    cachedToken = token;
+    return cachedToken;
+}
+/** The auth token from either the omms header or the legacy opencode-mem header. */
+export function getRequestToken(req) {
+    return (req.headers.get(AUTH_HEADER)?.trim() || req.headers.get(LEGACY_AUTH_HEADER)?.trim() || undefined);
+}
+export function isAuthorizedApiRequest(req) {
+    const token = getOrCreateAuthToken();
+    return getRequestToken(req) === token;
+}

package/dist/services/auto-capture.d.ts

@@ -0,0 +1,3 @@
+import type { AutoCaptureHost } from "../core/host.js";
+export { buildBoundedSummaryPrompt, buildMarkdownContext, getAutoCaptureMarkdownBudget, } from "../core/capture-context.js";
+export declare function performAutoCapture(host: AutoCaptureHost, sessionID: string, directory: string): Promise<void>;

package/dist/services/auto-capture.js

@@ -0,0 +1,127 @@
+import { CONFIG } from "../config.js";
+import { captureConversation } from "../core/capture.js";
+import { log } from "./logger.js";
+import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+export { buildBoundedSummaryPrompt, buildMarkdownContext, getAutoCaptureMarkdownBudget, } from "../core/capture-context.js";
+const RETRY_BASE_DELAY_MS = 2000;
+let isCaptureRunning = false;
+async function notifySafely(host, notification) {
+    try {
+        await host.notify?.(notification);
+    }
+    catch {
+        // Host UI failures must never affect memory capture.
+    }
+}
+export async function performAutoCapture(host, sessionID, directory) {
+    if (isCaptureRunning)
+        return;
+    isCaptureRunning = true;
+    try {
+        const prompts = await userPromptManager.getUncapturedPromptsForSession(sessionID);
+        if (prompts.length === 0 || !host.isCaptureReady())
+            return;
+        const maxRetries = CONFIG.autoCaptureMaxRetries ?? 3;
+        for (const prompt of prompts) {
+            await capturePrompt(host, sessionID, directory, prompt, maxRetries);
+        }
+    }
+    finally {
+        isCaptureRunning = false;
+    }
+}
+async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
+    let claimedPromptId = null;
+    let attempt = prompt.capture_attempts || 0;
+    try {
+        if (!(await userPromptManager.claimPrompt(prompt.id)))
+            return;
+        claimedPromptId = prompt.id;
+        while (attempt < maxRetries) {
+            attempt++;
+            try {
+                const conversation = await host.getConversation(sessionID, prompt.messageId);
+                if (!conversation)
+                    return;
+                if (conversation.textResponses.length === 0 && conversation.toolCalls.length === 0)
+                    return;
+                const captureResult = await captureConversation({
+                    host: host.host,
+                    hostSessionId: sessionID,
+                    sourceType: "live-capture",
+                    projectDirectory: directory,
+                    userPrompt: prompt.content,
+                    promptId: prompt.id,
+                    prompt: {
+                        id: prompt.id,
+                        providerId: prompt.providerId,
+                        modelId: prompt.modelId,
+                    },
+                    ...conversation,
+                }, host);
+                if (captureResult.status === "skipped") {
+                    log("Auto-capture skipped", {
+                        promptId: prompt.id,
+                        sessionID,
+                        type: captureResult.type,
+                    });
+                    await userPromptManager.deletePrompt(prompt.id);
+                    claimedPromptId = null;
+                    return;
+                }
+                await userPromptManager.linkMemoryToPrompt(prompt.id, captureResult.memoryId);
+                await userPromptManager.markAsCaptured(prompt.id);
+                claimedPromptId = null;
+                log("Auto-capture memory persisted", {
+                    promptId: prompt.id,
+                    sessionID,
+                    memoryId: captureResult.memoryId,
+                    host: host.host,
+                });
+                if (CONFIG.showAutoCaptureToasts) {
+                    await notifySafely(host, {
+                        title: "Memory Captured",
+                        message: "Project memory saved from conversation",
+                        variant: "success",
+                        duration: 3000,
+                    });
+                }
+                return;
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                await userPromptManager.recordFailedAttempt(prompt.id);
+                if (attempt < maxRetries) {
+                    log(`Auto-capture warning (attempt ${attempt}/${maxRetries})`, { error: errMsg });
+                    await new Promise((resolve) => setTimeout(resolve, RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1)));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        log(`Auto-capture final error after ${attempt} attempts`, { error: errMsg });
+        if (CONFIG.showErrorToasts) {
+            const shortReason = errMsg.length > 100 ? errMsg.substring(0, 100) + "..." : errMsg;
+            await notifySafely(host, {
+                title: "Auto Capture Failed",
+                message: shortReason,
+                variant: "error",
+                duration: 5000,
+            });
+        }
+    }
+    finally {
+        if (claimedPromptId !== null) {
+            try {
+                await userPromptManager.releaseClaim(claimedPromptId);
+            }
+            catch (releaseErr) {
+                log(`Failed to release captured=2 claim for prompt ${claimedPromptId}: ${releaseErr instanceof Error ? releaseErr.message : String(releaseErr)}`);
+            }
+        }
+    }
+}

package/dist/services/cleanup-service.d.ts

@@ -0,0 +1,22 @@
+interface CleanupResult {
+    deletedCount: number;
+    userCount: number;
+    projectCount: number;
+    promptsDeleted: number;
+    linkedMemoriesDeleted: number;
+    pinnedMemoriesSkipped: number;
+}
+export declare class CleanupService {
+    private lastCleanupTime;
+    private isRunning;
+    shouldRunCleanup(): Promise<boolean>;
+    runCleanup(): Promise<CleanupResult>;
+    getStatus(): {
+        enabled: boolean;
+        retentionDays: number;
+        lastCleanupTime: number;
+        isRunning: boolean;
+    };
+}
+export declare const cleanupService: CleanupService;
+export {};

package/dist/services/cleanup-service.js

@@ -0,0 +1,109 @@
+import { tursoShardManager } from "./turso/shard-manager.js";
+import { tursoVectorSearch } from "./turso/vector-search.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+import { ensureTursoReady } from "./turso/ready.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+export class CleanupService {
+    lastCleanupTime = 0;
+    isRunning = false;
+    async shouldRunCleanup() {
+        if (!CONFIG.autoCleanupEnabled)
+            return false;
+        if (this.isRunning)
+            return false;
+        const now = Date.now();
+        const oneDayMs = 24 * 60 * 60 * 1000;
+        if (now - this.lastCleanupTime < oneDayMs) {
+            return false;
+        }
+        return true;
+    }
+    async runCleanup() {
+        if (this.isRunning) {
+            throw new Error("Cleanup already running");
+        }
+        this.isRunning = true;
+        this.lastCleanupTime = Date.now();
+        try {
+            await ensureTursoReady();
+            const cutoffTime = Date.now() - CONFIG.autoCleanupRetentionDays * 24 * 60 * 60 * 1000;
+            const userShards = await tursoShardManager.getAllShards("user", "");
+            const projectShards = await tursoShardManager.getAllShards("project", "");
+            const allShards = [...userShards, ...projectShards];
+            const pinnedMemoryIds = new Set();
+            for (const shard of allShards) {
+                const db = await tursoConnectionManager.getConnection(shard.dbPath);
+                const pinned = await db.all(`SELECT id FROM memories WHERE is_pinned = 1`);
+                pinned.forEach((row) => pinnedMemoryIds.add(String(row.id)));
+            }
+            const promptCleanupResult = await userPromptManager.deleteOldPrompts(cutoffTime);
+            const linkedMemoryIds = new Set(promptCleanupResult.linkedMemoryIds);
+            const protectedMemoryIds = new Set([...pinnedMemoryIds, ...linkedMemoryIds]);
+            let totalDeleted = 0;
+            let userDeleted = 0;
+            let projectDeleted = 0;
+            const linkedMemoriesDeleted = 0;
+            let pinnedSkipped = 0;
+            for (const shard of allShards) {
+                const db = await tursoConnectionManager.getConnection(shard.dbPath);
+                const oldMemories = await db.all(`
+          SELECT id, container_tag, is_pinned FROM memories
+          WHERE updated_at < ?
+        `, [cutoffTime]);
+                for (const memory of oldMemories) {
+                    try {
+                        if (Number(memory.is_pinned) === 1) {
+                            pinnedSkipped++;
+                            continue;
+                        }
+                        if (protectedMemoryIds.has(String(memory.id))) {
+                            continue;
+                        }
+                        await tursoVectorSearch.deleteVector(db, String(memory.id));
+                        await tursoShardManager.decrementVectorCount(shard.id);
+                        totalDeleted++;
+                        if (String(memory.container_tag).includes("_user_")) {
+                            userDeleted++;
+                        }
+                        else if (String(memory.container_tag).includes("_project_")) {
+                            projectDeleted++;
+                        }
+                    }
+                    catch (error) {
+                        log("Cleanup: delete error", { memoryId: memory.id, error: String(error) });
+                    }
+                }
+            }
+            const promptsDeleted = promptCleanupResult.deleted - linkedMemoryIds.size;
+            try {
+                await userPromptManager.vacuum();
+                log("Cleanup: VACUUM done", { db: "user-prompts.db" });
+            }
+            catch (err) {
+                log("Cleanup: VACUUM skipped (DB busy)", { error: String(err) });
+            }
+            return {
+                deletedCount: totalDeleted,
+                userCount: userDeleted,
+                projectCount: projectDeleted,
+                promptsDeleted,
+                linkedMemoriesDeleted,
+                pinnedMemoriesSkipped: pinnedSkipped,
+            };
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    getStatus() {
+        return {
+            enabled: CONFIG.autoCleanupEnabled,
+            retentionDays: CONFIG.autoCleanupRetentionDays,
+            lastCleanupTime: this.lastCleanupTime,
+            isRunning: this.isRunning,
+        };
+    }
+}
+export const cleanupService = new CleanupService();

package/dist/services/client.d.ts

@@ -0,0 +1,134 @@
+import type { MemoryType } from "../types/index.js";
+export type MemoryScope = "project" | "all-projects";
+export declare class LocalMemoryClient {
+    private initPromise;
+    private isInitialized;
+    constructor();
+    private initialize;
+    warmup(progressCallback?: (progress: any) => void): Promise<void>;
+    isReady(): Promise<boolean>;
+    getEmbeddingInitError(): string | null;
+    getStatus(): {
+        dbConnected: boolean;
+        modelLoaded: boolean;
+        ready: boolean;
+        embeddingError: string | null;
+    };
+    reset(): void;
+    close(): Promise<void>;
+    searchMemories(query: string, containerTag: string, scope?: MemoryScope): Promise<{
+        warnings?: string[] | undefined;
+        success: true;
+        results: import("./turso/types.js").SearchResult[];
+        total: number;
+        timing: number;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        results: never[];
+        total: number;
+        timing: number;
+    }>;
+    addMemory(content: string, containerTag: string, metadata?: {
+        type?: MemoryType;
+        source?: "manual" | "auto-capture" | "import" | "api";
+        tags?: string[];
+        tool?: string;
+        sessionID?: string;
+        reasoning?: string;
+        captureTimestamp?: number;
+        displayName?: string;
+        userName?: string;
+        userEmail?: string;
+        projectPath?: string;
+        projectName?: string;
+        gitRepoUrl?: string;
+        [key: string]: unknown;
+    }): Promise<{
+        success: true;
+        id: string;
+    } | {
+        success: false;
+        error: string;
+    }>;
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    listMemories(containerTag: string, limit?: number, scope?: MemoryScope): Promise<{
+        success: true;
+        memories: {
+            id: any;
+            summary: any;
+            createdAt: string;
+            metadata: any;
+            displayName: any;
+            userName: any;
+            userEmail: any;
+            projectPath: any;
+            projectName: any;
+            gitRepoUrl: any;
+        }[];
+        pagination: {
+            currentPage: number;
+            totalItems: number;
+            totalPages: number;
+        };
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        memories: never[];
+        pagination: {
+            currentPage: number;
+            totalItems: number;
+            totalPages: number;
+        };
+    }>;
+    ensureStorageReady(): Promise<void>;
+    listShards(currentDirectory: string): Promise<import("./shard-inventory-service.js").ListShardsResult | {
+        success: false;
+        error: string;
+    }>;
+    migrateProjectPath(options: {
+        currentDirectory: string;
+        fromPath?: string;
+        fromHash?: string;
+        dryRun?: boolean;
+        allowLinkedSource?: boolean;
+    }): Promise<import("./shard-path-migration-service.js").PathMigrationResult>;
+    exportMemories(currentDirectory: string, outputPath: string): Promise<import("./memory-portability-service.js").ExportMemoriesResult>;
+    importMemories(currentDirectory: string, inputPath: string, dryRun?: boolean): Promise<import("./memory-portability-service.js").ImportMemoriesResult>;
+    searchMemoriesBySessionID(sessionID: string, containerTag: string, limit?: number): Promise<{
+        success: true;
+        results: {
+            id: any;
+            memory: any;
+            similarity: number;
+            tags: any;
+            metadata: any;
+            containerTag: any;
+            displayName: any;
+            userName: any;
+            userEmail: any;
+            projectPath: any;
+            projectName: any;
+            gitRepoUrl: any;
+            createdAt: any;
+        }[];
+        total: number;
+        timing: number;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        results: never[];
+        total: number;
+        timing: number;
+    }>;
+}
+export declare const memoryClient: LocalMemoryClient;