om-memory-system 3.2.0-next.9 → 3.3.0-next.18

package/dist/services/settings-models.js

@@ -0,0 +1,39 @@
+export async function listOpencodeSettingsModels(client) {
+    try {
+        const active = client ?? (await import("./ai/opencode-provider.js")).getV2Client();
+        if (!active)
+            return { available: false, reason: "OpenCode model list unavailable" };
+        const result = await active.provider.list();
+        if (!result.data)
+            return { available: false, reason: "OpenCode model list unavailable" };
+        const connected = new Set(result.data.connected);
+        const models = result.data.all
+            .filter((provider) => connected.has(provider.id))
+            .flatMap((provider) => Object.entries(provider.models).map(([model, info]) => ({
+            provider: provider.id,
+            model,
+            name: info.name,
+        })));
+        return { available: true, models };
+    }
+    catch {
+        return { available: false, reason: "OpenCode model list unavailable" };
+    }
+}
+export async function listPiSettingsModels(loadSdk = () => import("@earendil-works/pi-coding-agent")) {
+    try {
+        const { ModelRuntime } = await loadSdk();
+        // Refresh local auth availability without fetching models or writing Pi credentials.
+        const runtime = await ModelRuntime.create({ refreshOnCreate: true, allowModelNetwork: false });
+        const models = runtime
+            .getModels()
+            .filter((model) => runtime.hasConfiguredAuth(model.provider))
+            .map((model) => ({ provider: model.provider, model: model.id, name: model.name }));
+        return models.length
+            ? { available: true, models }
+            : { available: false, models, reason: "No signed-in Pi models found" };
+    }
+    catch {
+        return { available: false, reason: "Pi model list unavailable; enter provider/model" };
+    }
+}

package/dist/services/settings-snapshot.d.ts

@@ -0,0 +1,24 @@
+export declare function getSettingsSnapshot(directory: string): {
+    revision: string;
+    settings: {
+        [k: string]: {
+            value: unknown;
+            source: string;
+            globalValue: {} | undefined;
+        };
+    };
+    secrets: {
+        [k: string]: {
+            set: boolean;
+            source: string | null;
+        };
+    };
+    fallback: {
+        model: string | null;
+        configured: boolean;
+    };
+    effective: {
+        opencode: import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
+        pi: import("./ai/live-model-choice.js").PiLiveModelChoice;
+    };
+};

package/dist/services/settings-snapshot.js

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "jsonc-parser";
+import { CONFIG, getGlobalConfigSourcePath } from "../config.js";
+import { readGlobalConfigRevision } from "./global-config-writer.js";
+import { getAutoCaptureProviderStatus, isExternalModelReady, resolvePiLiveModel, } from "./ai/live-model-choice.js";
+const editable = [
+    "opencodeProvider",
+    "opencodeModel",
+    "piProvider",
+    "piModel",
+    "captureTrace",
+    "captureTraceRetentionDays",
+    "captureAttemptRetentionDays",
+    "autoBackfill",
+    "opencodeBackfillModel",
+    "piBackfillModel",
+    "webServerAutoStart",
+];
+function readSettingsFile(path) {
+    if (!path)
+        return {};
+    const errors = [];
+    const result = parse(readFileSync(path, "utf8"), errors, { allowTrailingComma: true });
+    if (errors.length || !result || typeof result !== "object" || Array.isArray(result)) {
+        throw new Error("Config file cannot be parsed");
+    }
+    return result;
+}
+function projectFile(directory) {
+    return ["omms.jsonc", "omms.json", "opencode-mem.jsonc", "opencode-mem.json"]
+        .map((name) => join(directory, ".opencode", name))
+        .find((path) => existsSync(path));
+}
+export function getSettingsSnapshot(directory) {
+    const global = readSettingsFile(getGlobalConfigSourcePath());
+    const project = readSettingsFile(projectFile(directory));
+    const settings = Object.fromEntries(editable.map((key) => {
+        const projectOverrides = Object.hasOwn(project, key) &&
+            (key === "captureTrace"
+                ? project[key] === false
+                : !key.endsWith("RetentionDays") &&
+                    ![
+                        "autoBackfill",
+                        "opencodeBackfillModel",
+                        "piBackfillModel",
+                        "webServerAutoStart",
+                    ].includes(key));
+        const source = projectOverrides
+            ? "project"
+            : Object.hasOwn(global, key)
+                ? "global"
+                : "default";
+        const value = projectOverrides ? project[key] : (global[key] ?? CONFIG[key]);
+        return [key, { value, source, globalValue: global[key] ?? CONFIG[key] }];
+    }));
+    const secrets = Object.fromEntries(["memoryApiKey", "embeddingApiKey", "webServerApiToken", "webServerAuthPassword"].map((key) => {
+        const raw = global[key];
+        return [
+            key,
+            {
+                set: typeof raw === "string" && raw.length > 0,
+                source: typeof raw === "string"
+                    ? raw.startsWith("env://")
+                        ? "env"
+                        : raw.startsWith("file://")
+                            ? "file"
+                            : "literal"
+                    : null,
+            },
+        ];
+    }));
+    return {
+        revision: readGlobalConfigRevision(),
+        settings,
+        secrets,
+        fallback: { model: CONFIG.memoryModel ?? null, configured: isExternalModelReady(CONFIG) },
+        effective: {
+            opencode: getAutoCaptureProviderStatus(CONFIG),
+            pi: resolvePiLiveModel(CONFIG),
+        },
+    };
+}

package/dist/services/settings-traces.d.ts

@@ -0,0 +1,7 @@
+export declare function listSettingsTraces(): Promise<{
+    file: string;
+    date: string | undefined;
+    size: number;
+}[]>;
+export declare function readSettingsTrace(file: string): Promise<string>;
+export declare function deleteSettingsTrace(file: string): Promise<void>;

package/dist/services/settings-traces.js

@@ -0,0 +1,39 @@
+import { lstat, readdir, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { getTraceDirectory } from "./capture-diagnostics.js";
+const traceName = /^capture-(\d{4}-\d{2}-\d{2})\.jsonl$/;
+function tracePath(file) {
+    if (!traceName.test(file))
+        throw new Error("Invalid trace file name");
+    return join(getTraceDirectory(), file);
+}
+export async function listSettingsTraces() {
+    let files;
+    try {
+        files = await readdir(getTraceDirectory());
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const traces = await Promise.all(files
+        .filter((file) => traceName.test(file))
+        .map(async (file) => {
+        const stats = await lstat(tracePath(file));
+        return stats.isFile() ? { file, date: traceName.exec(file)[1], size: stats.size } : null;
+    }));
+    return traces.filter((trace) => trace !== null).sort((a, b) => b.file.localeCompare(a.file));
+}
+export async function readSettingsTrace(file) {
+    const path = tracePath(file);
+    if (!(await lstat(path)).isFile())
+        throw new Error("Invalid trace file");
+    return readFile(path, "utf8");
+}
+export async function deleteSettingsTrace(file) {
+    const path = tracePath(file);
+    if (!(await lstat(path)).isFile())
+        throw new Error("Invalid trace file");
+    await unlink(path);
+}

package/dist/services/user-memory-learning.js

@@ -1,6 +1,6 @@
 import { getTags } from "./tags.js";
 import { log } from "./logger.js";
-import { CONFIG } from "../config.js";
+import { CONFIG, refreshConfigIfChanged } from "../config.js";
 import { resolveOpencodeHostModel } from "./ai/live-model-choice.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
 import { userProfileManager } from "./user-profile/user-profile-manager.js";
@@ -42,6 +42,7 @@ async function runAutomaticProfileCleanup(userId) {
 export async function performUserProfileLearning(ctx, directory) {
     if (isLearningRunning)
         return;
+    refreshConfigIfChanged(directory);
     if (!CONFIG.autoCaptureProviderStatus || !CONFIG.autoCaptureProviderStatus.ready) {
         log("user-profile-learning: skipped (provider not ready)", {
             issues: CONFIG.autoCaptureProviderStatus?.issues ?? ["status undefined"],

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

@@ -0,0 +1,29 @@
+import { CONFIG } from "../config.js";
+type State = "installed" | "not-installed" | "unsupported" | "no-runtime" | "no-package";
+export type WebAutostartStatus = {
+    state: State;
+    path?: string;
+    runtime?: string;
+    packagePath?: string;
+    command?: string;
+};
+export interface WebAutostartOptions {
+    home?: string;
+    platform?: string;
+    runtime?: string | null;
+    packageRoot?: string | null;
+    systemctlAvailable?: boolean;
+    run?: (command: string, args: string[]) => void;
+    start?: boolean;
+}
+/** OpenCode's executable is not a JavaScript runtime. */
+export declare function resolveWebRuntime(execPath?: string, platform?: NodeJS.Platform): string | null;
+/** Read the login item's state without changing any system files. */
+export declare function webAutostartStatus(options?: WebAutostartOptions): WebAutostartStatus;
+/** Install or update only the fixed-name OMMS item. `start` launches it now. */
+export declare function installWebAutostart(options?: WebAutostartOptions): WebAutostartStatus;
+/** Remove only an item carrying the OMMS marker. */
+export declare function removeWebAutostart(options?: WebAutostartOptions): WebAutostartStatus;
+/** Host start checks the global settings. A failed item cannot block a session. */
+export declare function reconcileWebAutostart(config?: Pick<typeof CONFIG, "webServerAutoStart" | "webServerEnabled">, options?: WebAutostartOptions): void;
+export {};

package/dist/services/web-autostart.js

@@ -0,0 +1,208 @@
+import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { accessSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, constants, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, delimiter, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+const MARKER = "OMMS login item";
+const NAME = "io.github.cmdaltctr.omms.web";
+function executable(name) {
+    for (const part of (process.env.PATH ?? "").split(delimiter)) {
+        if (!part)
+            continue;
+        const path = resolve(part, name);
+        try {
+            accessSync(path, constants.X_OK);
+            return path;
+        }
+        catch {
+            /* Search the next directory. */
+        }
+    }
+    return null;
+}
+/** OpenCode's executable is not a JavaScript runtime. */
+export function resolveWebRuntime(execPath = process.execPath, platform = process.platform) {
+    const name = basename(execPath).toLowerCase();
+    if (["node", "bun", "node.exe", "bun.exe"].includes(name))
+        return execPath;
+    const suffix = platform === "win32" ? ".exe" : "";
+    return executable(`node${suffix}`) ?? executable(`bun${suffix}`);
+}
+function packageRoot() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const file = join(dir, "package.json");
+        try {
+            if (JSON.parse(readFileSync(file, "utf8")).name === "om-memory-system")
+                return dir;
+        }
+        catch {
+            /* Try the parent. */
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function itemPath(home, platform) {
+    if (platform === "darwin")
+        return join(home, "Library", "LaunchAgents", `${NAME}.plist`);
+    if (platform === "linux")
+        return join(home, ".config", "systemd", "user", "omms-web.service");
+    if (platform === "win32")
+        return join(home, "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "omms-web.cmd");
+    return null;
+}
+function details(options) {
+    const home = options.home ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const path = itemPath(home, platform);
+    const runtime = options.runtime === undefined ? resolveWebRuntime() : options.runtime;
+    const root = options.packageRoot === undefined ? packageRoot() : options.packageRoot;
+    const supported = platform !== "linux" || (options.systemctlAvailable ?? Boolean(executable("systemctl")));
+    return { home, platform, path, runtime, root, supported };
+}
+const xml = (value) => value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+const systemd = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '\\"')}"`;
+const windows = (value) => `"${value.replaceAll("%", "%%")}"`;
+function itemContent(platform, runtime, cli) {
+    if (platform === "darwin")
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<!-- ${MARKER} -->
+<key>Label</key><string>${NAME}</string>
+<key>ProgramArguments</key><array><string>${xml(runtime)}</string><string>${xml(cli)}</string><string>web</string><string>--login-item</string></array>
+<key>RunAtLoad</key><true/><key>KeepAlive</key><false/>
+<key>StandardOutPath</key><string>/dev/null</string><key>StandardErrorPath</key><string>/dev/null</string>
+</dict></plist>\n`;
+    if (platform === "linux")
+        return `# ${MARKER}
+[Unit]\nDescription=OMMS web app\n[Service]\nType=simple\nExecStart=${systemd(runtime)} ${systemd(cli)} web --login-item\n[Install]\nWantedBy=default.target\n`;
+    return `@echo off\r\nrem ${MARKER}\r\nstart "" /min ${windows(runtime)} ${windows(cli)} web --login-item\r\n`;
+}
+function owned(path) {
+    return readFileSync(path, "utf8").includes(MARKER);
+}
+function runCommand(options, home, command, args) {
+    if (options.run)
+        options.run(command, args);
+    else
+        execFileSync(command, args, { cwd: home, stdio: "ignore", timeout: 5_000 });
+}
+/** Read the login item's state without changing any system files. */
+export function webAutostartStatus(options = {}) {
+    const { path, runtime, root, supported } = details(options);
+    if (!path || !supported)
+        return { state: "unsupported" };
+    if (!runtime)
+        return { state: "no-runtime", path };
+    if (!root)
+        return { state: "no-package", path, runtime };
+    if (!existsSync(path))
+        return { state: "not-installed", path, runtime, packagePath: root };
+    if (!owned(path))
+        throw new Error("Login item at the OMMS path is not owned by OMMS");
+    return {
+        state: "installed",
+        path,
+        runtime,
+        packagePath: root,
+        command: readFileSync(path, "utf8"),
+    };
+}
+/** Install or update only the fixed-name OMMS item. `start` launches it now. */
+export function installWebAutostart(options = {}) {
+    const status = webAutostartStatus(options);
+    if (status.state === "unsupported" ||
+        status.state === "no-runtime" ||
+        status.state === "no-package")
+        return status;
+    const { home, platform, path, runtime, root } = details(options);
+    const file = path;
+    const content = itemContent(platform, runtime, join(root, "dist", "cli", "index.js"));
+    mkdirSync(dirname(file), { recursive: true });
+    const changed = !existsSync(file) || readFileSync(file, "utf8") !== content;
+    if (changed) {
+        const temp = `${file}.${randomUUID()}.tmp`;
+        try {
+            writeFileSync(temp, content, { mode: 0o600 });
+            renameSync(temp, file);
+        }
+        finally {
+            if (existsSync(temp))
+                unlinkSync(temp);
+        }
+    }
+    if (platform === "linux") {
+        if (changed)
+            runCommand(options, home, "systemctl", ["--user", "daemon-reload"]);
+        // Re-enable even if the unit file is unchanged; the user service may have been disabled.
+        runCommand(options, home, "systemctl", ["--user", "enable", "omms-web.service"]);
+        if (options.start)
+            runCommand(options, home, "systemctl", ["--user", "start", "omms-web.service"]);
+    }
+    if (platform === "darwin" && options.start) {
+        const domain = `gui/${process.getuid?.() ?? 0}`;
+        try {
+            runCommand(options, home, "launchctl", ["bootout", domain, file]);
+        }
+        catch {
+            /* Not loaded. */
+        }
+        runCommand(options, home, "launchctl", ["bootstrap", domain, file]);
+    }
+    return webAutostartStatus(options);
+}
+/** Remove only an item carrying the OMMS marker. */
+export function removeWebAutostart(options = {}) {
+    const { home, platform, path, supported } = details(options);
+    if (!path)
+        return { state: "unsupported" };
+    if (!existsSync(path))
+        return { state: "not-installed", path };
+    if (!owned(path))
+        throw new Error("Login item at the OMMS path is not owned by OMMS");
+    if (platform === "darwin" && options.start) {
+        try {
+            runCommand(options, home, "launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}`, path]);
+        }
+        catch {
+            /* A registered item may not be loaded. */
+        }
+    }
+    if (platform === "linux" && supported) {
+        runCommand(options, home, "systemctl", [
+            "--user",
+            "disable",
+            ...(options.start ? ["--now"] : []),
+            "omms-web.service",
+        ]);
+    }
+    unlinkSync(path);
+    return { state: "not-installed", path };
+}
+/** Host start checks the global settings. A failed item cannot block a session. */
+export function reconcileWebAutostart(config = CONFIG, options = {}) {
+    if (process.env.OMMS_DISABLE_WEB_AUTOSTART === "1")
+        return;
+    try {
+        if (config.webServerAutoStart && config.webServerEnabled)
+            installWebAutostart(options);
+        else
+            removeWebAutostart(options);
+    }
+    catch (error) {
+        log("OMMS login item reconciliation failed", {
+            code: error instanceof Error ? error.name : "unknown",
+        });
+    }
+}

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

@@ -19,6 +19,7 @@ export declare function nextFallbackPort(currentPort: number, failedTakeovers: n
 interface WebServerConfig {
     port: number;
     host: string;
+    directory?: string;
     enabled: boolean;
     auth?: WebAuth;
     apiToken?: string;
@@ -34,6 +35,10 @@ export declare class WebServer {
     private portsExhaustedNotified;
     private takeoverFailures;
     private readonly maxFallbackPort;
+    private settingsImportJobs?;
+    /** Run an import-page action; errors carry their own status and never file contents. */
+    private importResponse;
+    private importJobs;
     constructor(config: WebServerConfig);
     setOnTakeoverCallback(callback: () => Promise<void>): void;
     setOnPortsExhaustedCallback(callback: () => void): void;