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

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.d.ts

@@ -0,0 +1,66 @@
+import type { CaptureAttemptDiagnostics, CaptureAttemptOutcome, CaptureExtractionPath, CaptureFailureReason } from "../core/host.js";
+import type { MemoryHost, MemorySourceType } from "../types/index.js";
+/**
+ * The config fields this module reads. Callers pass `CONFIG`; tests pass a
+ * plain object, so no import of `../config.js` is needed here.
+ */
+export interface CaptureDiagnosticsConfig {
+    captureTrace?: boolean;
+    captureTraceRetentionDays?: number;
+    memoryApiKey?: string;
+    embeddingApiKey?: string;
+    webServerApiToken?: string;
+    webServerAuthPassword?: string;
+}
+export interface CaptureAttemptContext {
+    host: MemoryHost;
+    sourceType: MemorySourceType;
+    sessionId: string;
+}
+/**
+ * The metadata-only record written to the OMMS log for every attempt. Every
+ * key is always present so records from both hosts have one shape; a value a
+ * path could not observe is null.
+ */
+export interface CaptureAttemptRecord {
+    host: MemoryHost;
+    sourceType: MemorySourceType;
+    sessionId: string;
+    path: CaptureExtractionPath | null;
+    provider: string | null;
+    model: string | null;
+    stopReason: string | null;
+    blockTypes: string[] | null;
+    promptChars: number | null;
+    replyChars: number | null;
+    durationMs: number;
+    outcome: CaptureAttemptOutcome;
+    reason: CaptureFailureReason | null;
+}
+export declare const DEFAULT_CAPTURE_TRACE_RETENTION_DAYS = 7;
+export declare function buildCaptureAttemptRecord(context: CaptureAttemptContext, diagnostics: CaptureAttemptDiagnostics, outcome: CaptureAttemptOutcome, durationMs: number): CaptureAttemptRecord;
+/**
+ * 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 declare function redactTraceText(text: string, config: CaptureDiagnosticsConfig): string;
+export declare function getTraceDirectory(): string;
+/**
+ * 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 declare function pruneTraces(config: CaptureDiagnosticsConfig, now?: Date): number;
+/**
+ * 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 declare function writeTraceEntry(record: CaptureAttemptRecord, diagnostics: CaptureAttemptDiagnostics, config: CaptureDiagnosticsConfig, now?: Date): void;
+/**
+ * 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 declare function emitCaptureAttempt(record: CaptureAttemptRecord, diagnostics: CaptureAttemptDiagnostics, config: CaptureDiagnosticsConfig, now?: Date): void;
+/** Test hook: forget which day the last trace was written. */
+export declare function resetTraceStateForTests(): void;

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,110 @@
+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",
+    "autoBackfill",
+    "opencodeBackfillModel",
+    "piBackfillModel",
+    "webServerAutoStart",
+]);
+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" || key === "autoBackfill" || key === "webServerAutoStart"
+            ? 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/live-captured-entries.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryHost } from "../types/index.js";
+/** Read user and assistant IDs saved by live capture in one project session. */
+export declare function findLiveCapturedEntryIds(projectHash: string, host: MemoryHost, sessionId: string): Promise<Set<string>>;

package/dist/services/live-captured-entries.js

@@ -0,0 +1,34 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG } from "../config.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+import { tursoShardManager } from "./turso/shard-manager.js";
+/** Read user and assistant IDs saved by live capture in one project session. */
+export async function findLiveCapturedEntryIds(projectHash, host, sessionId) {
+    const entries = new Set();
+    if (!existsSync(join(CONFIG.storagePath, "metadata.db")))
+        return entries;
+    const shards = await tursoShardManager.getAllShards("project", projectHash);
+    for (const shard of shards) {
+        const db = await tursoConnectionManager.getConnection(shard.dbPath);
+        const rows = await db.all(`SELECT metadata FROM memories WHERE json_valid(metadata)
+       AND json_extract(metadata, '$.host') = ?
+       AND json_extract(metadata, '$.hostSessionId') = ?
+       AND json_extract(metadata, '$.sourceType') != 'history-import'`, [host, sessionId]);
+        for (const row of rows) {
+            const metadata = JSON.parse(row.metadata);
+            if (!metadata || typeof metadata !== "object")
+                continue;
+            const provenance = metadata;
+            if (typeof provenance.promptId === "string")
+                entries.add(provenance.promptId);
+            const ids = provenance.sourceEntryIds;
+            if (Array.isArray(ids)) {
+                for (const id of ids)
+                    if (typeof id === "string")
+                        entries.add(id);
+            }
+        }
+    }
+    return entries;
+}

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/safe-health-error.d.ts

@@ -0,0 +1,2 @@
+/** Remove configured credentials before returning a model error to the browser. */
+export declare function safeHealthError(error: unknown, secrets: Array<string | undefined>): string;

package/dist/services/safe-health-error.js

@@ -0,0 +1,11 @@
+/** Remove configured credentials before returning a model error to the browser. */
+export function safeHealthError(error, secrets) {
+    let message = error instanceof Error ? error.message : String(error);
+    for (const secret of secrets) {
+        if (secret && secret.length > 2)
+            message = message.replaceAll(secret, "[redacted]");
+    }
+    return message
+        .replace(/(Bearer\s+)[^\s]+/gi, "$1[redacted]")
+        .replace(/(api[_-]?key[=:]\s*)[^\s&]+/gi, "$1[redacted]");
+}

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;
+}>;