open-managed-agents 0.1.0

package/dist/src/control-plane/files/store-memory.js

@@ -0,0 +1,270 @@
+import { randomUUID } from "node:crypto";
+import { invalidRequest } from "../errors.js";
+import { newFileId } from "../ids.js";
+import { MAX_SESSION_OUTPUT_BYTES, MAX_SESSION_OUTPUT_FILENAME_BYTES, MAX_SESSION_OUTPUT_FILE_BYTES, MAX_SESSION_OUTPUT_FILES, MAX_UPLOADED_FILE_BYTES, MAX_WORKSPACE_FILE_BYTES, } from "./types.js";
+import { compareId, compareRecords, consumeUploadBody, limitLabel, normalizeLimit, reusableOutput, toRecord, validateOutputFilename, } from "./store-common.js";
+export class InMemoryFileStorage {
+    files = new Map();
+    workspaceBytes = new Map();
+    maxUploadedFileBytes;
+    maxWorkspaceFileBytes;
+    maxSessionOutputFiles;
+    maxSessionOutputFileBytes;
+    maxSessionOutputBytes;
+    maxSessionOutputFilenameBytes;
+    constructor(opts = {}) {
+        this.maxUploadedFileBytes =
+            opts.maxUploadedFileBytes ?? MAX_UPLOADED_FILE_BYTES;
+        this.maxWorkspaceFileBytes =
+            opts.maxWorkspaceFileBytes ?? MAX_WORKSPACE_FILE_BYTES;
+        this.maxSessionOutputFiles =
+            opts.maxSessionOutputFiles ?? MAX_SESSION_OUTPUT_FILES;
+        this.maxSessionOutputFileBytes =
+            opts.maxSessionOutputFileBytes ?? MAX_SESSION_OUTPUT_FILE_BYTES;
+        this.maxSessionOutputBytes =
+            opts.maxSessionOutputBytes ?? MAX_SESSION_OUTPUT_BYTES;
+        this.maxSessionOutputFilenameBytes =
+            opts.maxSessionOutputFilenameBytes ?? MAX_SESSION_OUTPUT_FILENAME_BYTES;
+    }
+    async create(workspaceId, input) {
+        return this.createStored(workspaceId, input, {
+            visibility: "public",
+            kind: "upload",
+            scope: null,
+            scopeId: null,
+            storageKeySegment: "",
+            fileId: undefined,
+            downloadable: false,
+            relativePath: undefined,
+            maxBytes: this.maxUploadedFileBytes,
+        });
+    }
+    async createInternalSnapshot(workspaceId, input) {
+        return this.createStored(workspaceId, input, {
+            visibility: "internal",
+            kind: "internal_snapshot",
+            scope: { type: "session", id: input.scopeId },
+            scopeId: input.scopeId,
+            storageKeySegment: "internal/",
+            fileId: input.fileId,
+            downloadable: false,
+            relativePath: undefined,
+            maxBytes: this.maxUploadedFileBytes,
+        });
+    }
+    async createStored(workspaceId, input, opts) {
+        const { bytes, sizeBytes, sha256 } = await consumeUploadBody(input.body, opts.maxBytes, "Uploaded file");
+        const currentWorkspaceBytes = this.workspaceBytes.get(workspaceId) ?? 0;
+        if (currentWorkspaceBytes + sizeBytes > this.maxWorkspaceFileBytes) {
+            throw invalidRequest(`Workspace file storage exceeds the ${limitLabel(this.maxWorkspaceFileBytes)} in-memory limit`);
+        }
+        const id = opts.fileId ?? newFileId();
+        if (this.files.has(id)) {
+            throw invalidRequest(`File ${id} already exists`);
+        }
+        const now = new Date().toISOString();
+        const stored = {
+            visibility: opts.visibility,
+            kind: opts.kind,
+            workspace_id: workspaceId,
+            storage_key: `memory://${workspaceId}/${opts.storageKeySegment}${id}/${randomUUID()}`,
+            sha256,
+            bytes,
+            scope_id: opts.scopeId,
+            relative_path: opts.relativePath,
+            metadata: {
+                id,
+                type: "file",
+                filename: input.filename,
+                mime_type: input.mimeType,
+                size_bytes: sizeBytes,
+                created_at: now,
+                downloadable: opts.downloadable,
+                scope: opts.scope,
+            },
+        };
+        this.files.set(id, stored);
+        this.workspaceBytes.set(workspaceId, currentWorkspaceBytes + sizeBytes);
+        return toRecord(stored);
+    }
+    async retrieveMetadata(workspaceId, fileId) {
+        const stored = this.files.get(fileId);
+        if (!stored ||
+            stored.workspace_id !== workspaceId ||
+            stored.visibility !== "public") {
+            return undefined;
+        }
+        return toRecord(stored);
+    }
+    async openBytes(workspaceId, fileId) {
+        const stored = this.files.get(fileId);
+        if (!stored ||
+            stored.workspace_id !== workspaceId ||
+            stored.visibility !== "public") {
+            return undefined;
+        }
+        return singleChunk(stored.bytes);
+    }
+    async openInternalSnapshotBytes(workspaceId, fileId) {
+        const stored = this.files.get(fileId);
+        if (!stored ||
+            stored.workspace_id !== workspaceId ||
+            stored.visibility !== "internal") {
+            return undefined;
+        }
+        return singleChunk(stored.bytes);
+    }
+    async delete(workspaceId, fileId) {
+        const stored = this.files.get(fileId);
+        if (!stored ||
+            stored.workspace_id !== workspaceId ||
+            stored.visibility !== "public") {
+            return false;
+        }
+        this.deleteStored(workspaceId, fileId, stored);
+        return true;
+    }
+    async deleteInternalSnapshot(workspaceId, fileId) {
+        const stored = this.files.get(fileId);
+        if (!stored ||
+            stored.workspace_id !== workspaceId ||
+            stored.visibility !== "internal") {
+            return false;
+        }
+        this.deleteStored(workspaceId, fileId, stored);
+        return true;
+    }
+    async replaceSessionOutputs(workspaceId, sessionId, files) {
+        if (files.length > this.maxSessionOutputFiles) {
+            throw invalidRequest(`Session output collection exceeds the ${this.maxSessionOutputFiles} file limit`);
+        }
+        const oldOutputs = this.sessionOutputFiles(workspaceId, sessionId);
+        const reusableOutputByRelativePath = new Map(oldOutputs
+            .filter((stored) => stored.relative_path !== undefined)
+            .map((stored) => [stored.relative_path, stored]));
+        const basenameOwners = new Map();
+        const prepared = [];
+        let totalOutputBytes = 0;
+        for (const file of files) {
+            validateOutputFilename(file.filename, this.maxSessionOutputFilenameBytes);
+            const existingRelativePath = basenameOwners.get(file.filename);
+            if (existingRelativePath !== undefined &&
+                existingRelativePath !== file.relativePath) {
+                throw invalidRequest(`Session output filename collision for '${file.filename}' from '${existingRelativePath}' and '${file.relativePath}'`);
+            }
+            basenameOwners.set(file.filename, file.relativePath);
+            if (file.sizeBytes !== undefined &&
+                file.sizeBytes > this.maxSessionOutputFileBytes) {
+                throw invalidRequest(`Session output file exceeds the ${limitLabel(this.maxSessionOutputFileBytes)} per-file limit`);
+            }
+            if (file.sizeBytes !== undefined &&
+                totalOutputBytes + file.sizeBytes > this.maxSessionOutputBytes) {
+                throw invalidRequest(`Session outputs exceed the ${limitLabel(this.maxSessionOutputBytes)} aggregate limit`);
+            }
+            const { bytes, sizeBytes, sha256 } = await consumeUploadBody(file.body, this.maxSessionOutputFileBytes, "Session output file");
+            if (file.sizeBytes !== undefined && file.sizeBytes !== sizeBytes) {
+                throw invalidRequest(`Session output '${file.relativePath}' size changed during collection`);
+            }
+            if (file.sha256 !== undefined && file.sha256 !== sha256) {
+                throw invalidRequest(`Session output '${file.relativePath}' checksum changed during collection`);
+            }
+            totalOutputBytes += sizeBytes;
+            if (totalOutputBytes > this.maxSessionOutputBytes) {
+                throw invalidRequest(`Session outputs exceed the ${limitLabel(this.maxSessionOutputBytes)} aggregate limit`);
+            }
+            const reusable = reusableOutput(reusableOutputByRelativePath.get(file.relativePath), file, sizeBytes, sha256);
+            const id = reusable?.metadata.id ?? newFileId();
+            const createdAt = reusable?.metadata.created_at ?? new Date().toISOString();
+            prepared.push({
+                visibility: "public",
+                kind: "session_output",
+                workspace_id: workspaceId,
+                storage_key: reusable?.storage_key ??
+                    `memory://${workspaceId}/outputs/${sessionId}/${id}/${randomUUID()}`,
+                sha256,
+                bytes,
+                scope_id: sessionId,
+                relative_path: file.relativePath,
+                metadata: {
+                    id,
+                    type: "file",
+                    filename: file.filename,
+                    mime_type: file.mimeType,
+                    size_bytes: sizeBytes,
+                    created_at: createdAt,
+                    downloadable: true,
+                    scope: { type: "session", id: sessionId },
+                },
+            });
+        }
+        const oldBytes = oldOutputs.reduce((sum, stored) => sum + stored.metadata.size_bytes, 0);
+        const currentWorkspaceBytes = this.workspaceBytes.get(workspaceId) ?? 0;
+        if (currentWorkspaceBytes - oldBytes + totalOutputBytes > this.maxWorkspaceFileBytes) {
+            throw invalidRequest(`Workspace file storage exceeds the ${limitLabel(this.maxWorkspaceFileBytes)} in-memory limit`);
+        }
+        for (const stored of oldOutputs) {
+            this.files.delete(stored.metadata.id);
+        }
+        for (const stored of prepared) {
+            this.files.set(stored.metadata.id, stored);
+        }
+        this.workspaceBytes.set(workspaceId, currentWorkspaceBytes - oldBytes + totalOutputBytes);
+        return prepared.map(toRecord).sort(compareRecords);
+    }
+    async deleteSessionOutputs(workspaceId, sessionId) {
+        for (const stored of this.sessionOutputFiles(workspaceId, sessionId)) {
+            this.deleteStored(workspaceId, stored.metadata.id, stored);
+        }
+    }
+    deleteStored(workspaceId, fileId, stored) {
+        this.files.delete(fileId);
+        this.workspaceBytes.set(workspaceId, Math.max(0, (this.workspaceBytes.get(workspaceId) ?? 0) -
+            stored.metadata.size_bytes));
+    }
+    async list(workspaceId, opts = {}) {
+        const limit = normalizeLimit(opts.limit);
+        const rows = [...this.files.values()]
+            .filter((file) => file.workspace_id === workspaceId)
+            .filter((file) => file.visibility === "public")
+            .filter((file) => opts.scopeId === undefined
+            ? file.scope_id === null
+            : file.kind === "session_output" && file.scope_id === opts.scopeId)
+            .map(toRecord)
+            .sort(compareRecords);
+        const cursorRows = opts.beforeId !== undefined
+            ? rows.filter((row) => compareId(row.metadata.id, opts.beforeId) < 0)
+            : opts.afterId !== undefined
+                ? rows.filter((row) => compareId(row.metadata.id, opts.afterId) > 0)
+                : rows;
+        const pageRows = opts.beforeId === undefined
+            ? cursorRows.slice(0, limit)
+            : cursorRows.slice(-limit);
+        return {
+            data: pageRows,
+            has_more: cursorRows.length > limit,
+            first_id: pageRows[0]?.metadata.id ?? null,
+            last_id: pageRows[pageRows.length - 1]?.metadata.id ?? null,
+        };
+    }
+    getInternalRecordForTest(fileId) {
+        const stored = this.files.get(fileId);
+        return stored ? toRecord(stored) : undefined;
+    }
+    getWorkspaceBytesForTest(workspaceId) {
+        return this.workspaceBytes.get(workspaceId) ?? 0;
+    }
+    getSessionOutputRecordsForTest(workspaceId, sessionId) {
+        return this.sessionOutputFiles(workspaceId, sessionId)
+            .map(toRecord)
+            .sort(compareRecords);
+    }
+    sessionOutputFiles(workspaceId, sessionId) {
+        return [...this.files.values()].filter((file) => file.workspace_id === workspaceId &&
+            file.visibility === "public" &&
+            file.kind === "session_output" &&
+            file.scope_id === sessionId);
+    }
+}
+async function* singleChunk(bytes) {
+    yield bytes;
+}

package/dist/src/control-plane/files/store.js

@@ -0,0 +1,2 @@
+export { InMemoryFileStorage } from "./store-memory.js";
+export { LocalObjectFileStorage } from "./store-local.js";

package/dist/src/control-plane/files/types.js

@@ -0,0 +1,7 @@
+export { DEFAULT_WORKSPACE_ID } from "../workspace.js";
+export const MAX_UPLOADED_FILE_BYTES = 20 * 1024 * 1024;
+export const MAX_WORKSPACE_FILE_BYTES = 100 * 1024 * 1024;
+export const MAX_SESSION_OUTPUT_FILES = 100;
+export const MAX_SESSION_OUTPUT_FILE_BYTES = 25 * 1024 * 1024;
+export const MAX_SESSION_OUTPUT_BYTES = 100 * 1024 * 1024;
+export const MAX_SESSION_OUTPUT_FILENAME_BYTES = 255;

package/dist/src/control-plane/http.js

@@ -0,0 +1,25 @@
+import { invalidRequest } from "./errors.js";
+export async function parseJsonBody(req) {
+    try {
+        return await req.json();
+    }
+    catch (error) {
+        throw invalidRequest("Request body must be valid JSON", String(error));
+    }
+}
+export function parseLimit(value) {
+    if (value === undefined)
+        return undefined;
+    const limit = Number(value);
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw invalidRequest("`limit` must be a positive integer");
+    }
+    return limit;
+}
+export function parseOrder(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "asc" || value === "desc")
+        return value;
+    throw invalidRequest("`order` must be `asc` or `desc`");
+}

package/dist/src/control-plane/ids.js

@@ -0,0 +1,43 @@
+import { uuidv7 } from "../types/events.js";
+export function newAgentId() {
+    return `agent_${uuidv7()}`;
+}
+export function newEnvironmentId() {
+    return `env_${uuidv7()}`;
+}
+export function newFileId() {
+    return `file_${uuidv7()}`;
+}
+export function newRequestId() {
+    return `req_${uuidv7()}`;
+}
+export function newRuntimeTurnId() {
+    return `rtun_${uuidv7()}`;
+}
+export function newSessionResourceId() {
+    return `sesrsc_${uuidv7()}`;
+}
+export function newSessionSkillSnapshotId() {
+    return `sesskill_${uuidv7()}`;
+}
+export function newSessionId() {
+    return `sesn_${uuidv7()}`;
+}
+export function newSecretId() {
+    return `sec_${uuidv7()}`;
+}
+export function newSkillId() {
+    return `skill_${uuidv7()}`;
+}
+export function newSkillVersionId() {
+    return `skill_version_${uuidv7()}`;
+}
+export function newSkillContentObjectId() {
+    return `skobj_${uuidv7()}`;
+}
+export function newVaultId() {
+    return `vlt_${uuidv7()}`;
+}
+export function newVaultCredentialId() {
+    return `vcrd_${uuidv7()}`;
+}

package/dist/src/control-plane/logging.js

@@ -0,0 +1,263 @@
+// Structured logging with enforced redaction (plan 0121 C1, threat-model §5).
+//
+// Every control-plane log line goes through this module. Redaction is
+// programmatic, not a review convention: a field denylist replaces
+// content-bearing keys, and a secret scrubber runs over every string value
+// (not just error messages — a pasted key in a label must not survive).
+// The logger must never throw, and must import cleanly in the egress
+// sidecar: no dependencies beyond the runtime.
+//
+// Wire contract: one JSON line per event via console.debug/info/warn/error
+// (looked up at emit time so test spies and stream semantics both work):
+//   {"ts":"…","level":"…","event":"snake_case_name", ...fields}
+// audit outranks every configurable threshold — always emitted.
+const LEVEL_RANK = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    audit: 50,
+};
+// Keys that carry content or credentials by construction (threat-model §5
+// R1). Content names match per segment (snake/kebab/camel), so compound
+// keys like tool_output or errorMessage are caught, while `context` (which
+// merely contains "text") is not. Identifiers pass; anything named like key
+// material does not — except digest suffixes (key_sha256 is a reference,
+// not a secret; the exception is suffix-anchored so password_hash-style
+// names stay denied).
+const DENY_CONTENT_SEGMENTS = new Set([
+    "message",
+    "text",
+    "prompt",
+    "content",
+    "input",
+    "output",
+    "body",
+    "authorization",
+]);
+const DENY_HEURISTIC = /(key|secret|token|password)/i;
+const DENY_DIGEST_EXCEPTION = /(sha256|sha512|digest|fingerprint)$/i;
+function keySegments(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[\s_-]+/)
+        .map((segment) => segment.toLowerCase());
+}
+function isDeniedKey(key) {
+    if (keySegments(key).some((segment) => DENY_CONTENT_SEGMENTS.has(segment))) {
+        return true;
+    }
+    return DENY_HEURISTIC.test(key) && !DENY_DIGEST_EXCEPTION.test(key);
+}
+// Credential header/kv assignments: keep the name, mask the whole value —
+// including the scheme+credential form (`Authorization: Bearer <token>`),
+// where a bare \S+ would stop at the scheme word and leak the token
+// (C1 review, Codex P2 / Opus M1).
+const HEADER_ASSIGNMENT = /(x-api-key|x-admin-key|proxy-authorization|authorization)(\s*[:=]\s*)(?:(?:Bearer|Basic|Digest)\s+)?\S+/gi;
+const JSON_HEADER_ASSIGNMENT = /(["'])(x-api-key|x-admin-key|proxy-authorization|authorization)\1(\s*:\s*)(["'])(?:(?:Bearer|Basic|Digest)\s+)?[^"']+\4/gi;
+// Workspace API keys: oma_ + base64url(32 bytes) (workspaces/store.ts).
+const OMA_KEY = /oma_[A-Za-z0-9_-]+/g;
+// Admin/master keys: base64(32 bytes) = 43 chars + optional pad, standalone.
+// STANDARD base64 alphabet only (+/) — base64url (-_) would false-positive on
+// prefixed UUIDs (`sesrsc_<uuid>` is exactly 43 base64url chars; found when
+// the scrubber ate a resource id), and the only base64url secrets OMA mints
+// are oma_-prefixed, caught above. `=` is deliberately absent from the
+// lookbehind so `SOME_VAR=<key>` assignments still match; the boundary
+// assertions keep hex digests and long identifier runs intact.
+const BASE64_32_BYTES = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{43}=?(?![A-Za-z0-9+/=])/g;
+// Foreign credential shapes that can transit OMA via provider/tool errors
+// and egress-vendor debug strings (C1 review, Opus M3 / Codex-adv). This is
+// a floor, not an enumeration of the world: Anthropic/OpenAI-style sk-,
+// GitHub gh?_ tokens, JWTs, AWS access key ids.
+const FOREIGN_KEY_SHAPES = [
+    /\bsk-[A-Za-z0-9_-]{8,}/g,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+    /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+];
+// Credential-bearing query params in logged URLs (egress debug under
+// SRT_DEBUG passes raw request URLs): mask the value, keep the param name.
+const QUERY_CREDENTIAL = /([?&](?:key|apikey|api_key|token|access_token|secret|password|sig|signature|credential)=)[^&\s"']+/gi;
+// Exact-value scrubbing for KNOWN live secrets in server-controlled text
+// (plan 0122 §7B.9 slice 0). The pattern scrubber below catches credential
+// *shapes*; this catches the specific values a chokepoint already holds
+// (e.g. the bearer token injected into an MCP dial, echoed back by a
+// hostile server in a tool result). Common whole-value encodings are covered
+// because event/log serialization can transform an otherwise verbatim echo;
+// arbitrarily split or encrypted reflections remain outside this boundary.
+// Values under 8 chars are ignored so a pathological 1-char "secret" cannot
+// shred output.
+const MIN_KNOWN_SECRET_LENGTH = 8;
+export function scrubKnownSecrets(text, values) {
+    let out = text;
+    // Longest first: if one value contains another (full header vs bare
+    // token), the containing value must not be broken by an inner
+    // replacement leaving its prefix behind.
+    const eligible = [...new Set(values)]
+        .filter((value) => value.length >= MIN_KNOWN_SECRET_LENGTH)
+        .flatMap(knownSecretRepresentations)
+        .filter((value) => value.length >= MIN_KNOWN_SECRET_LENGTH)
+        .filter((value, index, all) => all.indexOf(value) === index)
+        .sort((a, b) => b.length - a.length);
+    for (const value of eligible) {
+        out = out.split(value).join("[redacted]");
+    }
+    return out;
+}
+export function knownSecretRepresentations(value) {
+    return [
+        value,
+        encodeURIComponent(value),
+        JSON.stringify(value).slice(1, -1),
+        Buffer.from(value).toString("base64"),
+    ];
+}
+export function scrubSecrets(text) {
+    let out = text
+        .replace(JSON_HEADER_ASSIGNMENT, (_m, keyQuote, name, sep, valueQuote) => `${keyQuote}${name}${keyQuote}${sep}${valueQuote}[redacted]${valueQuote}`)
+        .replace(HEADER_ASSIGNMENT, (_m, name, sep) => `${name}${sep}[redacted]`)
+        .replace(OMA_KEY, "[redacted]")
+        .replace(BASE64_32_BYTES, "[redacted]");
+    for (const shape of FOREIGN_KEY_SHAPES) {
+        out = out.replace(shape, "[redacted]");
+    }
+    return out.replace(QUERY_CREDENTIAL, "$1[redacted]");
+}
+const STRING_CAP = 1024;
+const STACK_CAP = 4096;
+const MAX_DEPTH = 6;
+function cap(text, limit) {
+    return text.length <= limit ? text : `${text.slice(0, limit)}…[truncated]`;
+}
+function scrubAndCap(text, limit = STRING_CAP) {
+    return cap(scrubSecrets(text), limit);
+}
+function serializeError(error, stacks) {
+    const out = {
+        name: error.name,
+        message: scrubAndCap(error.message),
+    };
+    if (stacks && typeof error.stack === "string") {
+        out.stack = scrubAndCap(error.stack, STACK_CAP);
+    }
+    // One level of cause — enough to diagnose wrapped errors without
+    // reintroducing an unbounded structure (deeper causes are dropped).
+    if (error.cause instanceof Error) {
+        out.cause = { name: error.cause.name, message: scrubAndCap(error.cause.message) };
+    }
+    else if (typeof error.cause === "string") {
+        out.cause = scrubAndCap(error.cause);
+    }
+    return out;
+}
+function redactValue(value, stacks, depth, seen) {
+    if (value === null || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string")
+        return scrubAndCap(value);
+    if (typeof value === "bigint")
+        return String(value);
+    if (value === undefined)
+        return undefined;
+    if (value instanceof Error)
+        return serializeError(value, stacks);
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value !== "object")
+        return "[unserializable]";
+    if (depth >= MAX_DEPTH)
+        return "[truncated]";
+    if (seen.has(value))
+        return "[circular]";
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.map((item) => redactValue(item, stacks, depth + 1, seen));
+    }
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        out[key] = isDeniedKey(key)
+            ? "[redacted]"
+            : redactValue(entry, stacks, depth + 1, seen);
+    }
+    return out;
+}
+export function redactFields(fields, stacks) {
+    return redactValue(fields, stacks, 0, new WeakSet());
+}
+// House rule: unknown config values refuse to start, never silently coerce.
+// (Moved from app.ts so the one parser serves both; app.ts imports it.)
+export function parseBooleanFlag(raw, name) {
+    if (raw === undefined || raw === "0")
+        return false;
+    if (raw === "1")
+        return true;
+    throw new Error(`Unsupported ${name}: ${JSON.stringify(raw)} (expected "1" or "0")`);
+}
+export function parseLogConfig(env) {
+    const raw = env.OMA_LOG_LEVEL ?? "info";
+    if (raw !== "debug" && raw !== "info" && raw !== "warn" && raw !== "error") {
+        throw new Error(`Unsupported OMA_LOG_LEVEL: ${JSON.stringify(raw)} (expected "debug", "info", "warn", or "error")`);
+    }
+    return {
+        level: raw,
+        stacks: parseBooleanFlag(env.OMA_LOG_STACKS, "OMA_LOG_STACKS"),
+    };
+}
+// 0121 C2: oma_log_events_total feed. Module-level because `log` is a
+// module singleton; exactly one deployment assembly sets it per process
+// (matching the in-process admission-counter scope). Must not throw —
+// defensively wrapped at the call site anyway.
+let logEventHook;
+export function setLogEventHook(hook) {
+    logEventHook = hook;
+}
+// Looked up per call, not captured: test spies on console.* must intercept,
+// and console keeps the debug/info→stdout, warn/error→stderr split. Audit
+// lines ride console.info (stdout) — existing admin_audit consumers grep
+// stdout, and the audit distinction lives in the JSON `level` field.
+const defaultWriter = (level, line) => {
+    console[level === "audit" ? "info" : level](line);
+};
+export function createLogger(config, write = defaultWriter) {
+    const threshold = LEVEL_RANK[config.level];
+    const emit = (level, event, fields) => {
+        if (LEVEL_RANK[level] < threshold)
+            return;
+        try {
+            logEventHook?.(level);
+        }
+        catch {
+            // Telemetry must never fail a log emission.
+        }
+        try {
+            const record = {
+                ts: new Date().toISOString(),
+                level,
+                event,
+            };
+            for (const [key, value] of Object.entries(redactFields(fields ?? {}, config.stacks))) {
+                if (!(key in record))
+                    record[key] = value;
+            }
+            write(level, JSON.stringify(record));
+        }
+        catch {
+            // A logger that throws is worse than the event it was reporting.
+            try {
+                write(level, JSON.stringify({ ts: new Date().toISOString(), level, event, logger_error: "emit_failed" }));
+            }
+            catch {
+                // Writer itself failed; nothing sane left to do.
+            }
+        }
+    };
+    return {
+        debug: (event, fields) => emit("debug", event, fields),
+        info: (event, fields) => emit("info", event, fields),
+        warn: (event, fields) => emit("warn", event, fields),
+        error: (event, fields) => emit("error", event, fields),
+        audit: (event, fields) => emit("audit", event, fields),
+    };
+}
+export const log = createLogger(parseLogConfig(process.env));