om-memory-system 3.0.0

package/dist/services/user-prompt/user-prompt-manager.d.ts

@@ -0,0 +1,53 @@
+export interface UserPrompt {
+    id: string;
+    sessionId: string;
+    messageId: string;
+    projectPath: string | null;
+    content: string;
+    createdAt: number;
+    captured: boolean;
+    userLearningCaptured: boolean;
+    linkedMemoryId: string | null;
+    capture_attempts: number;
+    providerId: string | null;
+    modelId: string | null;
+}
+export declare class UserPromptManager {
+    private db;
+    private dbPath;
+    private initPromise;
+    constructor();
+    reset(): void;
+    private initialize;
+    private ready;
+    private initDatabase;
+    savePrompt(sessionId: string, messageId: string, projectPath: string, content: string): Promise<string>;
+    setPromptModel(messageId: string, providerId: string, modelId: string): Promise<void>;
+    getLastUncapturedPrompt(sessionId: string): Promise<UserPrompt | null>;
+    getUncapturedPromptsForSession(sessionId: string): Promise<UserPrompt[]>;
+    deletePrompt(promptId: string): Promise<void>;
+    markAsCaptured(promptId: string): Promise<void>;
+    claimPrompt(promptId: string): Promise<boolean>;
+    recordFailedAttempt(promptId: string): Promise<void>;
+    releaseClaim(promptId: string): Promise<boolean>;
+    countUncapturedPrompts(): Promise<number>;
+    getUncapturedPrompts(limit: number): Promise<UserPrompt[]>;
+    markMultipleAsCaptured(promptIds: string[]): Promise<void>;
+    countUnanalyzedForUserLearning(): Promise<number>;
+    getPromptsForUserLearning(limit: number): Promise<UserPrompt[]>;
+    markAsUserLearningCaptured(promptId: string): Promise<void>;
+    markMultipleAsUserLearningCaptured(promptIds: string[]): Promise<void>;
+    deleteOldPrompts(cutoffTime: number): Promise<{
+        deleted: number;
+        linkedMemoryIds: string[];
+    }>;
+    vacuum(): Promise<void>;
+    linkMemoryToPrompt(promptId: string, memoryId: string): Promise<void>;
+    getPromptById(promptId: string): Promise<UserPrompt | null>;
+    getCapturedPrompts(projectPath?: string): Promise<UserPrompt[]>;
+    searchPrompts(query: string, projectPath?: string, limit?: number): Promise<UserPrompt[]>;
+    getPromptsByIds(ids: string[]): Promise<UserPrompt[]>;
+    updateProjectPath(oldProjectPath: string, newProjectPath: string): Promise<number>;
+    private rowToPrompt;
+}
+export declare const userPromptManager: UserPromptManager;

package/dist/services/user-prompt/user-prompt-manager.js

@@ -0,0 +1,303 @@
+import { join } from "node:path";
+import { tursoConnectionManager } from "../turso/connection-manager.js";
+import { CONFIG } from "../../config.js";
+const USER_PROMPTS_DB_NAME = "user-prompts.db";
+export class UserPromptManager {
+    db = null;
+    dbPath;
+    initPromise = null;
+    constructor() {
+        this.dbPath = join(CONFIG.storagePath, USER_PROMPTS_DB_NAME);
+    }
+    reset() {
+        this.db = null;
+        this.initPromise = null;
+        this.dbPath = join(CONFIG.storagePath, USER_PROMPTS_DB_NAME);
+    }
+    async initialize() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            try {
+                this.dbPath = join(CONFIG.storagePath, USER_PROMPTS_DB_NAME);
+                this.db = await tursoConnectionManager.getConnection(this.dbPath);
+                await this.initDatabase();
+            }
+            catch (error) {
+                this.initPromise = null;
+                this.db = null;
+                throw error;
+            }
+        })();
+        return this.initPromise;
+    }
+    async ready() {
+        if (!this.db || !this.initPromise) {
+            await this.initialize();
+        }
+        else {
+            await this.initPromise;
+        }
+        if (!this.db) {
+            throw new Error("UserPromptManager: database not initialized");
+        }
+        return this.db;
+    }
+    async initDatabase() {
+        const db = this.db;
+        await db.batch([
+            {
+                sql: `
+          CREATE TABLE IF NOT EXISTS user_prompts (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            message_id TEXT NOT NULL,
+            project_path TEXT,
+            content TEXT NOT NULL,
+            created_at INTEGER NOT NULL,
+            captured INTEGER DEFAULT 0,
+            user_learning_captured BOOLEAN DEFAULT 0,
+            linked_memory_id TEXT,
+            capture_attempts INTEGER DEFAULT 0,
+            provider_id TEXT,
+            model_id TEXT
+          )
+        `,
+            },
+            { sql: "UPDATE user_prompts SET captured = 0 WHERE captured = 2" },
+            { sql: "CREATE INDEX IF NOT EXISTS idx_user_prompts_session ON user_prompts(session_id)" },
+            { sql: "CREATE INDEX IF NOT EXISTS idx_user_prompts_captured ON user_prompts(captured)" },
+            {
+                sql: "CREATE INDEX IF NOT EXISTS idx_user_prompts_created ON user_prompts(created_at DESC)",
+            },
+            { sql: "CREATE INDEX IF NOT EXISTS idx_user_prompts_project ON user_prompts(project_path)" },
+            {
+                sql: "CREATE INDEX IF NOT EXISTS idx_user_prompts_linked ON user_prompts(linked_memory_id)",
+            },
+            {
+                sql: "CREATE INDEX IF NOT EXISTS idx_user_prompts_user_learning ON user_prompts(user_learning_captured)",
+            },
+        ]);
+        for (const column of [
+            "capture_attempts INTEGER DEFAULT 0",
+            "provider_id TEXT",
+            "model_id TEXT",
+        ]) {
+            try {
+                await db.run(`ALTER TABLE user_prompts ADD COLUMN ${column}`);
+            }
+            catch (error) {
+                if (!String(error?.message ?? error).includes("duplicate column")) {
+                    console.warn(`Failed to add ${column.split(" ")[0]} column:`, error);
+                }
+            }
+        }
+    }
+    async savePrompt(sessionId, messageId, projectPath, content) {
+        const db = await this.ready();
+        const id = `prompt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const now = Date.now();
+        const changes = await db.run(`
+      INSERT INTO user_prompts (id, session_id, message_id, project_path, content, created_at, captured)
+      SELECT ?, ?, ?, ?, ?, ?, 0
+      WHERE NOT EXISTS (
+        SELECT 1 FROM user_prompts WHERE session_id = ? AND message_id = ?
+      )
+    `, [id, sessionId, messageId, projectPath, content, now, sessionId, messageId]);
+        if (changes > 0)
+            return id;
+        const existing = await db.get(`SELECT id FROM user_prompts
+       WHERE session_id = ? AND message_id = ?
+       ORDER BY created_at ASC
+       LIMIT 1`, [sessionId, messageId]);
+        if (existing?.id)
+            return String(existing.id);
+        throw new Error("Failed to save or locate user prompt");
+    }
+    async setPromptModel(messageId, providerId, modelId) {
+        const db = await this.ready();
+        await db.run(`UPDATE user_prompts SET provider_id = ?, model_id = ? WHERE message_id = ?`, [
+            providerId,
+            modelId,
+            messageId,
+        ]);
+    }
+    async getLastUncapturedPrompt(sessionId) {
+        const db = await this.ready();
+        const maxRetries = CONFIG.autoCaptureMaxRetries ?? 3;
+        const row = await db.get(`
+      SELECT * FROM user_prompts
+      WHERE session_id = ? AND captured = 0 AND capture_attempts < ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `, [sessionId, maxRetries]);
+        return row ? this.rowToPrompt(row) : null;
+    }
+    async getUncapturedPromptsForSession(sessionId) {
+        const db = await this.ready();
+        const maxRetries = CONFIG.autoCaptureMaxRetries ?? 3;
+        const rows = await db.all(`
+      SELECT * FROM user_prompts
+      WHERE session_id = ? AND captured = 0 AND capture_attempts < ?
+      ORDER BY created_at ASC
+    `, [sessionId, maxRetries]);
+        return rows.map((row) => this.rowToPrompt(row));
+    }
+    async deletePrompt(promptId) {
+        const db = await this.ready();
+        await db.run(`DELETE FROM user_prompts WHERE id = ?`, [promptId]);
+    }
+    async markAsCaptured(promptId) {
+        const db = await this.ready();
+        await db.run(`UPDATE user_prompts SET captured = 1 WHERE id = ?`, [promptId]);
+    }
+    async claimPrompt(promptId) {
+        const db = await this.ready();
+        const changes = await db.run(`UPDATE user_prompts SET captured = 2 WHERE id = ? AND captured = 0`, [promptId]);
+        return changes > 0;
+    }
+    async recordFailedAttempt(promptId) {
+        const db = await this.ready();
+        await db.run(`UPDATE user_prompts SET capture_attempts = capture_attempts + 1 WHERE id = ?`, [
+            promptId,
+        ]);
+    }
+    async releaseClaim(promptId) {
+        const db = await this.ready();
+        const changes = await db.run(`UPDATE user_prompts SET captured = 0 WHERE id = ? AND captured = 2`, [promptId]);
+        return changes > 0;
+    }
+    async countUncapturedPrompts() {
+        const db = await this.ready();
+        const maxRetries = CONFIG.autoCaptureMaxRetries ?? 3;
+        const row = await db.get(`SELECT COUNT(*) as count FROM user_prompts WHERE captured = 0 AND capture_attempts < ?`, [maxRetries]);
+        return Number(row?.count ?? 0);
+    }
+    async getUncapturedPrompts(limit) {
+        const db = await this.ready();
+        const maxRetries = CONFIG.autoCaptureMaxRetries ?? 3;
+        const rows = await db.all(`
+      SELECT * FROM user_prompts
+      WHERE captured = 0 AND capture_attempts < ?
+      ORDER BY capture_attempts ASC, created_at ASC
+      LIMIT ?
+    `, [maxRetries, limit]);
+        return rows.map((row) => this.rowToPrompt(row));
+    }
+    async markMultipleAsCaptured(promptIds) {
+        if (promptIds.length === 0)
+            return;
+        const db = await this.ready();
+        const placeholders = promptIds.map(() => "?").join(",");
+        await db.run(`UPDATE user_prompts SET captured = 1 WHERE id IN (${placeholders})`, promptIds);
+    }
+    async countUnanalyzedForUserLearning() {
+        const db = await this.ready();
+        const row = await db.get(`SELECT COUNT(*) as count FROM user_prompts WHERE user_learning_captured = 0`);
+        return Number(row?.count ?? 0);
+    }
+    async getPromptsForUserLearning(limit) {
+        const db = await this.ready();
+        const rows = await db.all(`
+      SELECT * FROM user_prompts
+      WHERE user_learning_captured = 0
+      ORDER BY created_at ASC
+      LIMIT ?
+    `, [limit]);
+        return rows.map((row) => this.rowToPrompt(row));
+    }
+    async markAsUserLearningCaptured(promptId) {
+        const db = await this.ready();
+        await db.run(`UPDATE user_prompts SET user_learning_captured = 1 WHERE id = ?`, [promptId]);
+    }
+    async markMultipleAsUserLearningCaptured(promptIds) {
+        if (promptIds.length === 0)
+            return;
+        const db = await this.ready();
+        const placeholders = promptIds.map(() => "?").join(",");
+        await db.run(`UPDATE user_prompts SET user_learning_captured = 1 WHERE id IN (${placeholders})`, promptIds);
+    }
+    async deleteOldPrompts(cutoffTime) {
+        const db = await this.ready();
+        const linkedRows = await db.all(`
+      SELECT linked_memory_id FROM user_prompts
+      WHERE created_at < ? AND linked_memory_id IS NOT NULL
+    `, [cutoffTime]);
+        const linkedMemoryIds = linkedRows
+            .map((row) => row.linked_memory_id)
+            .filter((id) => Boolean(id));
+        const deleted = await db.run(`DELETE FROM user_prompts WHERE created_at < ?`, [cutoffTime]);
+        return { deleted, linkedMemoryIds };
+    }
+    async vacuum() {
+        const db = await this.ready();
+        await db.run("VACUUM");
+    }
+    async linkMemoryToPrompt(promptId, memoryId) {
+        const db = await this.ready();
+        await db.run(`UPDATE user_prompts SET linked_memory_id = ? WHERE id = ?`, [memoryId, promptId]);
+    }
+    async getPromptById(promptId) {
+        const db = await this.ready();
+        const row = await db.get(`SELECT * FROM user_prompts WHERE id = ?`, [promptId]);
+        return row ? this.rowToPrompt(row) : null;
+    }
+    async getCapturedPrompts(projectPath) {
+        const db = await this.ready();
+        const rows = projectPath
+            ? await db.all(`SELECT * FROM user_prompts
+           WHERE captured = 1 AND REPLACE(project_path, '\\', '/') = ?
+           ORDER BY created_at DESC`, [projectPath.replace(/\\/g, "/")])
+            : await db.all(`SELECT * FROM user_prompts WHERE captured = 1 ORDER BY created_at DESC`);
+        return rows.map((row) => this.rowToPrompt(row));
+    }
+    async searchPrompts(query, projectPath, limit = 20) {
+        const db = await this.ready();
+        const params = [`%${query}%`];
+        let sql = `SELECT * FROM user_prompts WHERE content LIKE ? AND captured = 1`;
+        if (projectPath) {
+            sql += ` AND REPLACE(project_path, '\\', '/') = ?`;
+            params.push(projectPath.replace(/\\/g, "/"));
+        }
+        sql += ` ORDER BY created_at DESC LIMIT ?`;
+        params.push(limit);
+        const rows = await db.all(sql, params);
+        return rows.map((row) => this.rowToPrompt(row));
+    }
+    async getPromptsByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const db = await this.ready();
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = await db.all(`SELECT * FROM user_prompts WHERE id IN (${placeholders})`, ids);
+        return rows.map((row) => this.rowToPrompt(row));
+    }
+    async updateProjectPath(oldProjectPath, newProjectPath) {
+        if (!oldProjectPath || !newProjectPath || oldProjectPath === newProjectPath) {
+            return 0;
+        }
+        const db = await this.ready();
+        const normalizedOldPath = oldProjectPath.replace(/\\/g, "/");
+        return db.run(`UPDATE user_prompts
+       SET project_path = ?
+       WHERE REPLACE(project_path, '\\', '/') = ?`, [newProjectPath, normalizedOldPath]);
+    }
+    rowToPrompt(row) {
+        return {
+            id: String(row.id),
+            sessionId: String(row.session_id),
+            messageId: String(row.message_id),
+            projectPath: row.project_path ? String(row.project_path) : null,
+            content: String(row.content),
+            createdAt: Number(row.created_at),
+            captured: Number(row.captured) === 1,
+            userLearningCaptured: Number(row.user_learning_captured) === 1,
+            linkedMemoryId: row.linked_memory_id ? String(row.linked_memory_id) : null,
+            capture_attempts: Number(row.capture_attempts ?? 0),
+            providerId: row.provider_id ? String(row.provider_id) : null,
+            modelId: row.model_id ? String(row.model_id) : null,
+        };
+    }
+}
+export const userPromptManager = new UserPromptManager();

package/dist/services/web-api-auth.d.ts

@@ -0,0 +1,3 @@
+export declare function isLoopbackHost(host: string): boolean;
+export declare function assertWebServerNetworkAuth(host: string, apiToken?: string, basicAuthEnabled?: boolean): void;
+export declare function authorizeApiRequest(req: Request, apiToken?: string): Response | null;

package/dist/services/web-api-auth.js

@@ -0,0 +1,25 @@
+import { getRequestToken } from "./auth-token.js";
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]", "0:0:0:0:0:0:0:1"]);
+export function isLoopbackHost(host) {
+    return LOOPBACK_HOSTS.has(host.trim().toLowerCase());
+}
+export function assertWebServerNetworkAuth(host, apiToken, basicAuthEnabled = false) {
+    if (!isLoopbackHost(host) && !apiToken && !basicAuthEnabled) {
+        throw new Error(`webServerHost "${host}" exposes the API on the network. Set webServerApiToken in omms.jsonc, or bind to 127.0.0.1.`);
+    }
+}
+export function authorizeApiRequest(req, apiToken) {
+    if (!apiToken)
+        return null;
+    const header = req.headers.get("authorization");
+    const bearer = header?.match(/^Bearer\s+(.+)$/i)?.[1]?.trim();
+    const alt = getRequestToken(req);
+    const token = bearer || alt;
+    if (token && token === apiToken) {
+        return null;
+    }
+    return new Response(JSON.stringify({ success: false, error: "Unauthorized" }), {
+        status: 401,
+        headers: { "Content-Type": "application/json" },
+    });
+}

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

@@ -0,0 +1,46 @@
+export declare const WEB_AUTH_REALM = "OpenCode Memory Explorer";
+export interface WebAuthOptions {
+    /**
+     * Plain-text password used for HTTP Basic Auth. Empty / undefined disables
+     * auth entirely (the previous default). The caller is responsible for
+     * resolving `env://` / `file://` shortcuts via the shared
+     * `resolveSecretValue` helper before passing the value in.
+     */
+    password?: string;
+    /**
+     * Plain-text username. Defaults to `os.userInfo().username` so that, when
+     * the server is bound to a LAN-reachable interface, the obvious choice
+     * is the OS account that launched opencode.
+     */
+    username?: string;
+}
+export interface WebAuthConfig {
+    enabled: boolean;
+    username: string;
+}
+export interface AuthCheckResult {
+    ok: boolean;
+    response?: Response;
+}
+export declare class WebAuth {
+    private readonly enabled;
+    private readonly username;
+    private readonly expectedUsername;
+    private readonly expectedPassword;
+    constructor(options?: WebAuthOptions);
+    getConfig(): WebAuthConfig;
+    isEnabled(): boolean;
+    /**
+     * Validate the HTTP Basic Auth credentials on the incoming request.
+     *
+     * Returns `{ ok: true }` when auth is disabled, when the request is for a
+     * path the user-facing browser must reach without credentials (the health
+     * probe), or when the supplied `Authorization: Basic …` header matches the
+     * configured username/password.
+     *
+     * Otherwise returns a fully-formed 401 Response carrying the
+     * `WWW-Authenticate` challenge so browsers pop their native login dialog.
+     */
+    check(req: Request, path: string): AuthCheckResult;
+    challenge(): Response;
+}

package/dist/services/web-auth.js

@@ -0,0 +1,105 @@
+import { timingSafeEqual } from "node:crypto";
+import { userInfo } from "node:os";
+export const WEB_AUTH_REALM = "OpenCode Memory Explorer";
+export class WebAuth {
+    enabled;
+    username;
+    expectedUsername;
+    expectedPassword;
+    constructor(options = {}) {
+        const password = (options.password ?? "").trim();
+        this.enabled = password.length > 0;
+        const explicitUsername = (options.username ?? "").trim();
+        this.username = explicitUsername || safeOsUsername();
+        this.expectedUsername = Buffer.from(this.username, "utf8");
+        this.expectedPassword = Buffer.from(password, "utf8");
+    }
+    getConfig() {
+        return { enabled: this.enabled, username: this.username };
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Validate the HTTP Basic Auth credentials on the incoming request.
+     *
+     * Returns `{ ok: true }` when auth is disabled, when the request is for a
+     * path the user-facing browser must reach without credentials (the health
+     * probe), or when the supplied `Authorization: Basic …` header matches the
+     * configured username/password.
+     *
+     * Otherwise returns a fully-formed 401 Response carrying the
+     * `WWW-Authenticate` challenge so browsers pop their native login dialog.
+     */
+    check(req, path) {
+        if (!this.enabled)
+            return { ok: true };
+        if (path === "/api/health")
+            return { ok: true };
+        const header = req.headers.get("Authorization");
+        if (header) {
+            const decoded = decodeBasicAuth(header);
+            if (decoded &&
+                constantTimeEquals(decoded.username, this.expectedUsername) &&
+                constantTimeEquals(decoded.password, this.expectedPassword)) {
+                return { ok: true };
+            }
+        }
+        return { ok: false, response: this.challenge() };
+    }
+    challenge() {
+        return new Response("Authentication required", {
+            status: 401,
+            headers: {
+                "Content-Type": "text/plain; charset=utf-8",
+                "WWW-Authenticate": `Basic realm="${WEB_AUTH_REALM}", charset="UTF-8"`,
+                "Cache-Control": "no-store",
+            },
+        });
+    }
+}
+function safeOsUsername() {
+    try {
+        const info = userInfo();
+        if (info.username && info.username.length > 0)
+            return info.username;
+    }
+    catch {
+        // userInfo can throw on some sandboxes; fall through to env fallbacks.
+    }
+    if (process.env.USER && process.env.USER.length > 0)
+        return process.env.USER;
+    if (process.env.USERNAME && process.env.USERNAME.length > 0)
+        return process.env.USERNAME;
+    return "user";
+}
+function constantTimeEquals(provided, expected) {
+    const providedBuf = Buffer.from(provided ?? "", "utf8");
+    if (providedBuf.length !== expected.length) {
+        // Run a dummy compare so the call duration stays independent of length.
+        timingSafeEqual(expected, expected);
+        return false;
+    }
+    return timingSafeEqual(providedBuf, expected);
+}
+function decodeBasicAuth(header) {
+    if (!header.toLowerCase().startsWith("basic "))
+        return null;
+    const encoded = header.slice(6).trim();
+    if (!encoded)
+        return null;
+    let decoded;
+    try {
+        decoded = Buffer.from(encoded, "base64").toString("utf8");
+    }
+    catch {
+        return null;
+    }
+    const colon = decoded.indexOf(":");
+    if (colon === -1)
+        return null;
+    return {
+        username: decoded.slice(0, colon),
+        password: decoded.slice(colon + 1),
+    };
+}

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

@@ -0,0 +1,57 @@
+import { WebAuth } from "./web-auth.js";
+type NodeEventSource = {
+    on(event: string, listener: (...args: any[]) => void): unknown;
+};
+export declare function attachNodeDisconnectHandlers(req: NodeEventSource & {
+    aborted: boolean;
+    complete: boolean;
+    socket: NodeEventSource;
+}, res: NodeEventSource & {
+    writableEnded: boolean;
+}, onDisconnect: () => void): void;
+/**
+ * Port fallback policy for the takeover loop. A port that fails to bind AND
+ * answers no HTTP is treated as orphaned Windows kernel residue; after
+ * `minFailedTakeovers` consecutive failed takeovers the web server moves to
+ * `currentPort + 1`, bounded by `maxFallbackPort`.
+ */
+export declare function nextFallbackPort(currentPort: number, failedTakeovers: number, maxFallbackPort: number, minFailedTakeovers?: number): number;
+interface WebServerConfig {
+    port: number;
+    host: string;
+    enabled: boolean;
+    auth?: WebAuth;
+    apiToken?: string;
+}
+export declare class WebServer {
+    private server;
+    private config;
+    private isOwner;
+    private startPromise;
+    private healthCheckInterval;
+    private onTakeoverCallback;
+    private onPortsExhaustedCallback;
+    private portsExhaustedNotified;
+    private takeoverFailures;
+    private readonly maxFallbackPort;
+    constructor(config: WebServerConfig);
+    setOnTakeoverCallback(callback: () => Promise<void>): void;
+    setOnPortsExhaustedCallback(callback: () => void): void;
+    start(): Promise<void>;
+    private _start;
+    private startHealthCheckLoop;
+    private stopHealthCheckLoop;
+    private attemptTakeover;
+    private notifyPortsExhausted;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    isServerOwner(): boolean;
+    getUrl(): string;
+    checkServerAvailable(): Promise<boolean>;
+    private handleRequest;
+    private contentTypeFor;
+    private serveStaticFile;
+    private jsonResponse;
+}
+export declare function startWebServer(config: WebServerConfig): Promise<WebServer>;
+export {};