om-memory-system 3.2.0-next.8 → 3.3.0-next.17

package/dist/services/capture-diagnostics.js

@@ -0,0 +1,175 @@
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { getLogDirPath } from "./log-path.js";
+import { log } from "./logger.js";
+import { stripPrivateContent } from "./privacy.js";
+export const DEFAULT_CAPTURE_TRACE_RETENTION_DAYS = 7;
+const TRACE_SCHEMA_VERSION = 1;
+const TRACE_FILE = /^capture-(\d{4})-(\d{2})-(\d{2})\.jsonl$/;
+const REDACTED = "[REDACTED]";
+export function buildCaptureAttemptRecord(context, diagnostics, outcome, durationMs) {
+    const promptChars = diagnostics.systemPrompt === undefined && diagnostics.userPrompt === undefined
+        ? null
+        : (diagnostics.systemPrompt?.length ?? 0) + (diagnostics.userPrompt?.length ?? 0);
+    return {
+        host: context.host,
+        sourceType: context.sourceType,
+        sessionId: context.sessionId,
+        path: diagnostics.path ?? null,
+        provider: diagnostics.provider ?? null,
+        model: diagnostics.model ?? null,
+        stopReason: diagnostics.stopReason ?? null,
+        blockTypes: diagnostics.blockTypes ?? null,
+        promptChars,
+        replyChars: diagnostics.rawReply?.length ?? null,
+        durationMs,
+        outcome,
+        reason: outcome === "failed" ? (diagnostics.failureReason ?? "call-error") : null,
+    };
+}
+// Common key and token formats. Each match is replaced whole, except the
+// Bearer rule, which keeps the scheme so the trace still reads naturally.
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g, REDACTED],
+    [/\bsk-ant-[A-Za-z0-9_-]{10,}/g, REDACTED],
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, REDACTED],
+    [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, REDACTED],
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, REDACTED],
+    [/\bAKIA[0-9A-Z]{16}\b/g, REDACTED],
+    [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, REDACTED],
+    [/\bAIza[0-9A-Za-z_-]{35}/g, REDACTED],
+    [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, REDACTED],
+    [/(\bBearer\s+)[A-Za-z0-9._~+/=-]{16,}/gi, `$1${REDACTED}`],
+];
+function configuredSecrets(config) {
+    return [
+        config.memoryApiKey,
+        config.embeddingApiKey,
+        config.webServerApiToken,
+        config.webServerAuthPassword,
+    ].filter((value) => typeof value === "string" &&
+        // Short values would redact ordinary words; unresolved references are not secrets.
+        value.length >= 8 &&
+        !value.startsWith("env://") &&
+        !value.startsWith("file://"));
+}
+/**
+ * Prepare prompt or reply text for the trace file: drop `<private>` regions the
+ * same way memory storage does, then configured secrets, then common key and
+ * token formats.
+ */
+export function redactTraceText(text, config) {
+    let result = stripPrivateContent(text);
+    for (const secret of configuredSecrets(config)) {
+        result = result.replaceAll(secret, REDACTED);
+    }
+    for (const [pattern, replacement] of SECRET_PATTERNS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}
+function formatDate(d) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+export function getTraceDirectory() {
+    return join(getLogDirPath(), "traces");
+}
+function retentionDays(config) {
+    const days = config.captureTraceRetentionDays;
+    if (typeof days !== "number" || !Number.isFinite(days)) {
+        return DEFAULT_CAPTURE_TRACE_RETENTION_DAYS;
+    }
+    return Math.max(1, Math.floor(days));
+}
+/**
+ * Delete trace files dated more than `captureTraceRetentionDays` before `now`.
+ * The date comes from the file name, not the modification time, and files
+ * that do not match the trace name pattern are never touched.
+ */
+export function pruneTraces(config, now = new Date()) {
+    const dir = getTraceDirectory();
+    let removed = 0;
+    try {
+        if (!existsSync(dir))
+            return 0;
+        const cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        cutoff.setDate(cutoff.getDate() - retentionDays(config));
+        for (const file of readdirSync(dir)) {
+            const match = TRACE_FILE.exec(file);
+            if (!match)
+                continue;
+            const fileDate = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+            if (fileDate < cutoff) {
+                unlinkSync(join(dir, file));
+                removed++;
+            }
+        }
+    }
+    catch (error) {
+        log("Capture trace cleanup failed", { code: errorCode(error) });
+    }
+    return removed;
+}
+let lastTraceDate = null;
+/**
+ * Append one trace entry to the day's JSON Lines file. A single append per
+ * entry keeps lines whole when Pi and OpenCode write at the same time.
+ */
+export function writeTraceEntry(record, diagnostics, config, now = new Date()) {
+    try {
+        const today = formatDate(now);
+        if (lastTraceDate !== today) {
+            lastTraceDate = today;
+            pruneTraces(config, now);
+        }
+        const dir = getTraceDirectory();
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        chmodSync(dir, 0o700);
+        const redact = (value) => value === undefined ? null : redactTraceText(value, config);
+        const entry = {
+            schemaVersion: TRACE_SCHEMA_VERSION,
+            timestamp: now.toISOString(),
+            ...record,
+            systemPrompt: redact(diagnostics.systemPrompt),
+            userPrompt: redact(diagnostics.userPrompt),
+            reply: redact(diagnostics.rawReply),
+        };
+        const file = join(dir, `capture-${today}.jsonl`);
+        appendFileSync(file, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+        // The mode above applies only when the append creates the file; a file
+        // that already existed with wider permissions is narrowed here.
+        chmodSync(file, 0o600);
+    }
+    catch (error) {
+        log("Capture trace write failed", { code: errorCode(error) });
+    }
+}
+/**
+ * Write the attempt's metadata record to the log and, when tracing is on, its
+ * trace entry. Never throws: diagnostics must not change a capture outcome.
+ */
+export function emitCaptureAttempt(record, diagnostics, config, now = new Date()) {
+    try {
+        log("Capture attempt", record);
+    }
+    catch {
+        // The log is best effort here, as everywhere else.
+    }
+    void import("./capture-attempt-store.js")
+        .then(({ saveCaptureAttempt }) => saveCaptureAttempt(record, now.getTime()))
+        .catch((error) => log("Capture attempt store failed", { code: errorCode(error) }));
+    if (config.captureTrace === true) {
+        writeTraceEntry(record, diagnostics, config, now);
+    }
+}
+function errorCode(error) {
+    if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+        return error.code;
+    }
+    return error instanceof Error ? error.name : "unknown";
+}
+/** Test hook: forget which day the last trace was written. */
+export function resetTraceStateForTests() {
+    lastTraceDate = null;
+}

package/dist/services/cleanup-service.js

@@ -77,6 +77,15 @@ export class CleanupService {
                 }
             }
             const promptsDeleted = promptCleanupResult.deleted - linkedMemoryIds.size;
+            try {
+                const { pruneCaptureAttempts } = await import("./capture-attempt-store.js");
+                await pruneCaptureAttempts(CONFIG.captureAttemptRetentionDays);
+            }
+            catch (error) {
+                log("Capture attempt cleanup failed", {
+                    code: error instanceof Error ? error.name : "unknown",
+                });
+            }
             try {
                 await userPromptManager.vacuum();
                 log("Cleanup: VACUUM done", { db: "user-prompts.db" });

package/dist/services/global-config-writer.d.ts

@@ -0,0 +1,10 @@
+export declare class ConfigConflictError extends Error {
+    readonly status = 409;
+    constructor();
+}
+export declare function readGlobalConfigRevision(): string;
+/** Write only page-editable keys; reject edits based on a stale config revision. */
+export declare function writeGlobalConfigKeys(edits: Record<string, unknown>, expectedRevision: string): Promise<{
+    revision: string;
+    migratedLegacy: boolean;
+}>;

package/dist/services/global-config-writer.js

@@ -0,0 +1,106 @@
+import { createHash, randomUUID } from "node:crypto";
+import { promises as fs, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { CONFIG_TEMPLATE, getGlobalConfigSourcePath, getGlobalConfigWritePath, validateGlobalConfig, } from "../config.js";
+const keys = new Set([
+    "opencodeProvider",
+    "opencodeModel",
+    "piProvider",
+    "piModel",
+    "captureTrace",
+    "captureTraceRetentionDays",
+    "captureAttemptRetentionDays",
+]);
+export class ConfigConflictError extends Error {
+    status = 409;
+    constructor() {
+        super("Config changed. Reload settings and save again.");
+    }
+}
+function digest(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+async function snapshot(path) {
+    const content = await fs.readFile(path, "utf8");
+    const stat = await fs.stat(path);
+    return { content, revision: `${stat.mtimeMs}:${stat.size}:${digest(content)}` };
+}
+export function readGlobalConfigRevision() {
+    const source = getGlobalConfigSourcePath();
+    if (!source)
+        return digest(CONFIG_TEMPLATE);
+    // Synchronous read keeps the revision tied to the file shown by GET /settings.
+    const content = readFileSync(source, "utf8");
+    const stat = statSync(source);
+    return `${stat.mtimeMs}:${stat.size}:${digest(content)}`;
+}
+let queue = Promise.resolve();
+let pending = 0;
+let lastBaseRevision;
+let lastWrittenRevision;
+/** Write only page-editable keys; reject edits based on a stale config revision. */
+export async function writeGlobalConfigKeys(edits, expectedRevision) {
+    if (!edits || !Object.keys(edits).length)
+        throw new Error("No settings to save");
+    for (const [key, value] of Object.entries(edits)) {
+        if (!keys.has(key))
+            throw new Error(`Setting ${key} cannot be edited here`);
+        if (key === "captureTrace"
+            ? typeof value !== "boolean"
+            : key.endsWith("RetentionDays")
+                ? !Number.isSafeInteger(value) || value < 1
+                : typeof value !== "string" || !value.trim()) {
+            throw new Error(`Invalid ${key} setting`);
+        }
+    }
+    const wasQueued = pending > 0;
+    pending++;
+    const save = queue.then(async () => {
+        const source = getGlobalConfigSourcePath();
+        const target = getGlobalConfigWritePath();
+        const original = source
+            ? await snapshot(source)
+            : { content: CONFIG_TEMPLATE, revision: digest(CONFIG_TEMPLATE) };
+        if (original.revision !== expectedRevision &&
+            !(wasQueued &&
+                lastBaseRevision === expectedRevision &&
+                lastWrittenRevision === original.revision)) {
+            throw new ConfigConflictError();
+        }
+        let content = original.content;
+        for (const [key, value] of Object.entries(edits)) {
+            content = applyEdits(content, modify(content, [key], value, {
+                formattingOptions: { insertSpaces: true, tabSize: 2, eol: "\n" },
+            }));
+        }
+        const errors = [];
+        const parsed = parse(content, errors, { allowTrailingComma: true });
+        if (errors.length)
+            throw new Error("Config contains invalid JSONC");
+        validateGlobalConfig(parsed);
+        if (source && (await snapshot(source)).revision !== original.revision) {
+            throw new ConfigConflictError();
+        }
+        await fs.mkdir(dirname(target), { recursive: true });
+        const temp = join(dirname(target), `.omms-${randomUUID()}.tmp`);
+        try {
+            await fs.writeFile(temp, content, { mode: source ? (await fs.stat(source)).mode : 0o600 });
+            await fs.rename(temp, target);
+        }
+        finally {
+            await fs.rm(temp, { force: true });
+        }
+        const revision = (await snapshot(target)).revision;
+        lastBaseRevision = expectedRevision;
+        lastWrittenRevision = revision;
+        return { revision, migratedLegacy: Boolean(source && source !== target) };
+    });
+    queue = save.then(() => { }, () => { });
+    try {
+        return await save;
+    }
+    finally {
+        pending--;
+    }
+}

package/dist/services/log-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getLogFilePath(): string;
+export declare function getLogDirPath(): string;

package/dist/services/log-path.js

@@ -0,0 +1,15 @@
+import { homedir } from "os";
+import { join } from "path";
+// Kept apart from logger.ts: many tests replace logger.js with a stub that
+// only has `log`, so modules that need the paths import them from here.
+export function getLogFilePath() {
+    return (process.env.OMMS_LOG_FILE ||
+        // Legacy override, still honoured from the opencode-mem days.
+        process.env.OPENCODE_MEM_LOG_FILE ||
+        join(homedir(), ".omms", "omms.log"));
+}
+export function getLogDirPath() {
+    const logFile = getLogFilePath();
+    const lastSlash = Math.max(logFile.lastIndexOf("/"), logFile.lastIndexOf("\\"));
+    return lastSlash === -1 ? "." : logFile.slice(0, lastSlash);
+}

package/dist/services/logger.js

@@ -1,17 +1,6 @@
 import { appendFileSync, writeFileSync, existsSync, mkdirSync, statSync, renameSync, unlinkSync, readdirSync, } from "fs";
-import { homedir } from "os";
 import { join } from "path";
-function getLogFilePath() {
-    return (process.env.OMMS_LOG_FILE ||
-        // Legacy override, still honoured from the opencode-mem days.
-        process.env.OPENCODE_MEM_LOG_FILE ||
-        join(homedir(), ".omms", "omms.log"));
-}
-function getLogDirPath() {
-    const logFile = getLogFilePath();
-    const lastSlash = Math.max(logFile.lastIndexOf("/"), logFile.lastIndexOf("\\"));
-    return lastSlash === -1 ? "." : logFile.slice(0, lastSlash);
-}
+import { getLogDirPath, getLogFilePath } from "./log-path.js";
 const MAX_LOG_SIZE = 5 * 1024 * 1024;
 const MAX_LOG_DAYS = 30;
 const GLOBAL_LOGGER_KEY = Symbol.for("omms.logger.initialized");

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

@@ -0,0 +1,5 @@
+/** Read the bounded tail of OMMS's own log. The request cannot choose a path. */
+export declare function readSettingsLog(lines?: number, captureOnly?: boolean): Promise<{
+    path: string;
+    lines: string[];
+}>;

package/dist/services/settings-log.js

@@ -0,0 +1,36 @@
+import { open, stat } from "node:fs/promises";
+import { getLogFilePath } from "./log-path.js";
+/** Read the bounded tail of OMMS's own log. The request cannot choose a path. */
+export async function readSettingsLog(lines = 200, captureOnly = false) {
+    const path = getLogFilePath();
+    const count = Number.isFinite(lines) ? Math.max(1, Math.min(2000, Math.floor(lines))) : 200;
+    let size;
+    try {
+        size = (await stat(path)).size;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { path, lines: [] };
+        throw error;
+    }
+    const start = Math.max(0, size - 256 * 1024);
+    const file = await open(path, "r");
+    try {
+        const buffer = Buffer.alloc(size - start);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, start);
+        const text = buffer.subarray(0, bytesRead).toString("utf8");
+        const whole = start === 0 ? text : text.slice(text.indexOf("\n") + 1);
+        if (start > 0 && !text.includes("\n"))
+            return { path, lines: [] };
+        const rows = whole.split(/\r?\n/);
+        if (rows.at(-1) === "")
+            rows.pop();
+        return {
+            path,
+            lines: rows.filter((line) => !captureOnly || line.includes("Capture attempt")).slice(-count),
+        };
+    }
+    finally {
+        await file.close();
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
+export declare function listOpencodeSettingsModels(client?: Pick<OpencodeClient, "provider">): Promise<{
+    available: false;
+    reason: string;
+    models?: undefined;
+} | {
+    available: true;
+    models: {
+        provider: string;
+        model: string;
+        name: string;
+    }[];
+    reason?: undefined;
+}>;
+export declare function listPiSettingsModels(loadSdk?: () => Promise<typeof import("@earendil-works/pi-coding-agent")>): Promise<{
+    available: true;
+    models: {
+        provider: string;
+        model: string;
+        name: string;
+    }[];
+    reason?: undefined;
+} | {
+    available: false;
+    models: {
+        provider: string;
+        model: string;
+        name: string;
+    }[];
+    reason: string;
+} | {
+    available: false;
+    reason: string;
+    models?: undefined;
+}>;

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,71 @@
+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",
+];
+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"));
+        const source = projectOverrides
+            ? "project"
+            : Object.hasOwn(global, key)
+                ? "global"
+                : "default";
+        const value = projectOverrides ? project[key] : (CONFIG[key] ?? global[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-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;