om-memory-system 3.2.0-next.10 → 3.2.0-next.12

package/dist/services/ai/opencode-import-models.js

@@ -0,0 +1,55 @@
+import { CONFIG } from "../../config.js";
+import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
+import { loadOpencodeProvider } from "./opencode-provider-loader.js";
+/** Capture and profile calls routed through OpenCode's structured-output sessions. */
+export async function createOpencodeImportModels(ref, directory) {
+    const { getV2Client, generateStructuredOutput } = await loadOpencodeProvider();
+    const client = getV2Client();
+    if (!client)
+        throw new Error("the OpenCode client is not ready; retry in a moment");
+    const { z } = await import("zod");
+    const { buildCaptureSystemPrompt, createUserProfileAnalysisSchema, parseCaptureSummary } = await import("../../core/extraction.js");
+    const { detectLanguage, getLanguageName } = await import("../language-detector.js");
+    const captureSchema = z.object({
+        summary: z.string().optional(),
+        type: z.string(),
+        tags: z.array(z.string()).optional(),
+    });
+    const capture = {
+        async summarize(request) {
+            const target = CONFIG.autoCaptureLanguage && CONFIG.autoCaptureLanguage !== "auto"
+                ? CONFIG.autoCaptureLanguage
+                : detectLanguage(request.userPrompt);
+            const systemPrompt = buildCaptureSystemPrompt(getLanguageName(target));
+            const result = await generateStructuredOutput({
+                client,
+                ...ref,
+                systemPrompt,
+                userPrompt: buildBoundedSummaryPrompt(request.context, systemPrompt, z.toJSONSchema(captureSchema)),
+                schema: captureSchema,
+                directory,
+            });
+            const parsed = parseCaptureSummary(JSON.stringify(result));
+            if (!parsed)
+                throw new Error("History capture returned an invalid summary");
+            return parsed;
+        },
+    };
+    const profileSchema = createUserProfileAnalysisSchema(z);
+    const profile = {
+        provider: ref.providerID,
+        modelId: ref.modelID,
+        async complete(systemPrompt, userPrompt) {
+            const result = await generateStructuredOutput({
+                client,
+                ...ref,
+                systemPrompt,
+                userPrompt,
+                schema: profileSchema,
+                directory,
+            });
+            return JSON.stringify(result);
+        },
+    };
+    return { capture, profile };
+}

package/dist/services/capture-attempt-store.d.ts

@@ -0,0 +1,21 @@
+import type { CaptureAttemptRecord } from "./capture-diagnostics.js";
+export declare function saveCaptureAttempt(record: CaptureAttemptRecord, now?: number): Promise<void>;
+export declare function pruneCaptureAttempts(days: number, now?: number): Promise<number>;
+export declare function queryCaptureAttempts(from: number, to: number, limit?: number): Promise<{
+    byModel: {
+        total: number;
+        saved: number;
+        skipped: number;
+        failed: number;
+    }[];
+    byReason: {
+        host: string;
+        provider: unknown;
+        model: unknown;
+        reason: string;
+        count: number;
+    }[];
+    recent: {
+        blockTypes: any;
+    }[];
+}>;

package/dist/services/capture-attempt-store.js

@@ -0,0 +1,108 @@
+import { join } from "node:path";
+import { CONFIG } from "../config.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+const prepared = new Set();
+// Keyed by path: a store change mid-preparation must prepare the new store too.
+const preparing = new Map();
+async function database() {
+    const path = join(CONFIG.storagePath, "user-prompts.db");
+    const db = await tursoConnectionManager.getConnection(path);
+    if (!prepared.has(path)) {
+        let pending = preparing.get(path);
+        if (!pending) {
+            pending = db
+                .batch([
+                {
+                    sql: `CREATE TABLE IF NOT EXISTS capture_attempts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          created_at INTEGER NOT NULL,
+          host TEXT NOT NULL, source_type TEXT NOT NULL, session_id TEXT NOT NULL,
+          path TEXT, provider TEXT, model TEXT, stop_reason TEXT, block_types TEXT,
+          prompt_chars INTEGER, reply_chars INTEGER, duration_ms INTEGER NOT NULL,
+          outcome TEXT NOT NULL, reason TEXT
+        )`,
+                },
+                {
+                    sql: "CREATE INDEX IF NOT EXISTS idx_capture_attempts_time ON capture_attempts(created_at)",
+                },
+                {
+                    sql: "CREATE INDEX IF NOT EXISTS idx_capture_attempts_host_model ON capture_attempts(host, provider, model, created_at)",
+                },
+            ])
+                .then(() => {
+                prepared.add(path);
+            })
+                .finally(() => {
+                preparing.delete(path);
+            });
+            preparing.set(path, pending);
+        }
+        await pending;
+    }
+    return db;
+}
+export async function saveCaptureAttempt(record, now = Date.now()) {
+    const db = await database();
+    await db.run(`INSERT INTO capture_attempts
+    (created_at, host, source_type, session_id, path, provider, model, stop_reason,
+     block_types, prompt_chars, reply_chars, duration_ms, outcome, reason)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        now,
+        record.host,
+        record.sourceType,
+        record.sessionId,
+        record.path ?? null,
+        record.provider ?? null,
+        record.model ?? null,
+        record.stopReason ?? null,
+        record.blockTypes ? JSON.stringify(record.blockTypes) : null,
+        record.promptChars ?? null,
+        record.replyChars ?? null,
+        record.durationMs,
+        record.outcome,
+        record.reason ?? null,
+    ]);
+}
+export async function pruneCaptureAttempts(days, now = Date.now()) {
+    const db = await database();
+    return db.run("DELETE FROM capture_attempts WHERE created_at < ?", [now - days * 86400000]);
+}
+export async function queryCaptureAttempts(from, to, limit = 100) {
+    const db = await database();
+    const range = [from, to];
+    const byModel = await db.all(`SELECT host, provider, model, COUNT(*) AS total,
+    SUM(CASE WHEN outcome = 'saved' THEN 1 ELSE 0 END) AS saved,
+    SUM(CASE WHEN outcome = 'skipped' THEN 1 ELSE 0 END) AS skipped,
+    SUM(CASE WHEN outcome = 'failed' THEN 1 ELSE 0 END) AS failed
+    FROM capture_attempts WHERE created_at BETWEEN ? AND ?
+    GROUP BY host, provider, model ORDER BY total DESC`, range);
+    const byReason = await db.all(`SELECT host, provider, model, reason, COUNT(*) AS count
+    FROM capture_attempts WHERE created_at BETWEEN ? AND ? AND outcome = 'failed'
+    GROUP BY host, provider, model, reason ORDER BY count DESC`, range);
+    const recent = await db.all(`SELECT created_at AS timestamp, host,
+    source_type AS sourceType, session_id AS sessionId, path, provider, model,
+    stop_reason AS stopReason, block_types AS blockTypes, prompt_chars AS promptChars,
+    reply_chars AS replyChars, duration_ms AS durationMs, outcome, reason
+    FROM capture_attempts WHERE created_at BETWEEN ? AND ?
+    ORDER BY created_at DESC, id DESC LIMIT ?`, [...range, Math.max(1, Math.min(500, limit))]);
+    return {
+        byModel: byModel.map((row) => ({
+            ...row,
+            total: Number(row.total),
+            saved: Number(row.saved),
+            skipped: Number(row.skipped),
+            failed: Number(row.failed),
+        })),
+        byReason: byReason.map((row) => ({
+            host: String(row.host),
+            provider: row.provider,
+            model: row.model,
+            reason: String(row.reason),
+            count: Number(row.count),
+        })),
+        recent: recent.map((row) => ({
+            ...row,
+            blockTypes: row.blockTypes ? JSON.parse(String(row.blockTypes)) : null,
+        })),
+    };
+}

package/dist/services/capture-diagnostics.js

@@ -156,6 +156,9 @@ export function emitCaptureAttempt(record, diagnostics, config, now = new Date()
     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);
     }

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/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;