om-memory-system 3.1.0-next.4 → 3.2.0-next.10

package/dist/services/capture-diagnostics.js

@@ -0,0 +1,172 @@
+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.
+    }
+    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/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/v2/legacy-client.js

@@ -222,8 +222,17 @@ export function toLegacyEvent(raw) {
     const envelope = raw?.payload ?? raw;
     const source = envelope?.type === "sync" && envelope.syncEvent ? envelope.syncEvent : envelope;
     const rawType = typeof source?.type === "string" ? source.type.replace(/\.1$/, "") : source?.type;
-    const type = rawType === "session.compaction.ended" ? "session.compacted" : rawType;
     const data = source?.data ?? {};
+    // OpenCode 2.0.14 ends a turn with `session.execution.succeeded` and emits no
+    // `session.idle`; some builds report idleness through `session.status`. The
+    // V1 capture path listens for `session.idle`, so both map onto it.
+    // Subscribed events carry their payload in `data`; bus-style ones in `properties`.
+    const payload = source?.data ?? source?.properties ?? {};
+    if (rawType === "session.execution.succeeded" ||
+        (rawType === "session.status" && payload?.status?.type === "idle")) {
+        return { type: "session.idle", properties: { sessionID: payload.sessionID } };
+    }
+    const type = rawType === "session.compaction.ended" ? "session.compacted" : rawType;
     if (source && typeof source === "object" && "properties" in source) {
         return { type, properties: source.properties };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "om-memory-system",
-  "version": "3.1.0-next.4",
+  "version": "3.2.0-next.10",
   "description": "Opinionated modular memory system for coding agents (OpenCode + Pi)",
   "type": "module",
   "main": "dist/plugin.js",