@intent-systems/nexus 2026.1.5-3

package/dist/config/sessions.js

@@ -0,0 +1,611 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSON5 from "json5";
+import { buildAgentMainSessionKey, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
+import { normalizeE164 } from "../utils.js";
+import { resolveStateDir } from "./paths.js";
+const GROUP_SURFACES = new Set([
+    "whatsapp",
+    "telegram",
+    "discord",
+    "signal",
+    "imessage",
+    "webchat",
+    "slack",
+]);
+function resolveAgentSessionsDir(agentId, env = process.env, homedir = os.homedir) {
+    const root = resolveStateDir(env, homedir);
+    const id = normalizeAgentId(agentId ?? DEFAULT_AGENT_ID);
+    return path.join(root, "agents", id, "sessions");
+}
+export function resolveSessionTranscriptsDir(env = process.env, homedir = os.homedir) {
+    return resolveAgentSessionsDir(DEFAULT_AGENT_ID, env, homedir);
+}
+export function resolveDefaultSessionStorePath(agentId) {
+    return path.join(resolveAgentSessionsDir(agentId), "sessions.json");
+}
+export const DEFAULT_RESET_TRIGGER = "/new";
+export const DEFAULT_RESET_TRIGGERS = ["/new", "/reset"];
+export const DEFAULT_IDLE_MINUTES = 60;
+export function resolveSessionTranscriptPath(sessionId, agentId) {
+    return path.join(resolveAgentSessionsDir(agentId), `${sessionId}.jsonl`);
+}
+// ============================================================================
+// New Session Storage Format (agent-grouped, per-session directories)
+// ============================================================================
+/**
+ * Resolve the directory path for a specific session.
+ * New format: ~/nexus/state/agents/{agentId}/sessions/{sessionId}/
+ */
+export function resolveSessionDir(agentId, sessionId, env = process.env, homedir = os.homedir) {
+    const sessionsDir = resolveAgentSessionsDir(agentId, env, homedir);
+    return path.join(sessionsDir, sessionId);
+}
+/**
+ * Create session directory structure.
+ * Creates: ~/nexus/state/agents/{agentId}/sessions/{sessionId}/
+ */
+export async function createSessionDir(agentId, sessionId) {
+    const sessionDir = resolveSessionDir(agentId, sessionId);
+    await fs.promises.mkdir(sessionDir, { recursive: true });
+    return sessionDir;
+}
+/**
+ * Write session metadata to session.json.
+ * Includes: sessionId, agentId, created, updated, surface, parentSession, chatType, model, etc.
+ */
+export async function writeSessionMetadata(agentId, sessionId, metadata) {
+    const sessionDir = await createSessionDir(agentId, sessionId);
+    const metadataPath = path.join(sessionDir, "session.json");
+    const existing = await loadSessionMetadata(agentId, sessionId).catch(() => null);
+    const sessionData = {
+        sessionId,
+        agentId,
+        created: existing?.created ?? metadata.created ?? new Date().toISOString(),
+        updated: new Date().toISOString(),
+        surface: metadata.surface ?? existing?.surface,
+        chatType: metadata.chatType ?? existing?.chatType,
+        parentSession: metadata.parentSession ?? existing?.parentSession ?? null,
+        agentType: metadata.agentType ?? existing?.agentType,
+        model: metadata.modelOverride ?? existing?.model,
+        compactionCount: metadata.compactionCount ?? existing?.compactionCount ?? 0,
+        displayName: metadata.displayName ?? existing?.displayName,
+        // Copy all other metadata fields
+        ...metadata,
+    };
+    const json = JSON.stringify(sessionData, null, 2);
+    await fs.promises.writeFile(metadataPath, json, "utf-8");
+}
+/**
+ * Load session metadata from session.json.
+ * Returns null if session doesn't exist.
+ */
+export async function loadSessionMetadata(agentId, sessionId) {
+    const sessionDir = resolveSessionDir(agentId, sessionId);
+    const metadataPath = path.join(sessionDir, "session.json");
+    try {
+        const raw = await fs.promises.readFile(metadataPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+/**
+ * Append a turn to history.jsonl.
+ */
+export async function appendToHistory(agentId, sessionId, turn) {
+    const sessionDir = await createSessionDir(agentId, sessionId);
+    const historyPath = path.join(sessionDir, "history.jsonl");
+    const line = JSON.stringify(turn) + "\n";
+    await fs.promises.appendFile(historyPath, line, "utf-8");
+}
+/**
+ * Load history from history.jsonl.
+ * Returns empty array if no history exists.
+ */
+export async function loadHistory(agentId, sessionId) {
+    const sessionDir = resolveSessionDir(agentId, sessionId);
+    const historyPath = path.join(sessionDir, "history.jsonl");
+    try {
+        const raw = await fs.promises.readFile(historyPath, "utf-8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        return lines.map((line) => JSON.parse(line));
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT")
+            return [];
+        throw err;
+    }
+}
+/**
+ * Archive old history to archives/{n}.jsonl and optionally keep recent messages in history.jsonl.
+ * Increments compaction count in session metadata.
+ *
+ * @param agentId - Agent ID
+ * @param sessionId - Session ID
+ * @param keepMessages - Optional array of recent messages to keep in history.jsonl
+ */
+export async function archiveHistory(agentId, sessionId, keepMessages) {
+    const sessionDir = resolveSessionDir(agentId, sessionId);
+    const historyPath = path.join(sessionDir, "history.jsonl");
+    const archivesDir = path.join(sessionDir, "archives");
+    // Get current compaction count
+    const metadata = await loadSessionMetadata(agentId, sessionId);
+    const nextNum = (metadata?.compactionCount ?? 0) + 1;
+    // Create archives directory
+    await fs.promises.mkdir(archivesDir, { recursive: true });
+    // Load current history to archive
+    const currentHistory = await loadHistory(agentId, sessionId);
+    // Calculate which messages to archive (exclude keepMessages from the end)
+    const numToKeep = keepMessages?.length ?? 0;
+    const toArchive = numToKeep > 0
+        ? currentHistory.slice(0, currentHistory.length - numToKeep)
+        : currentHistory;
+    // Write archived messages to archive file
+    const archivePath = path.join(archivesDir, `${String(nextNum).padStart(3, "0")}.jsonl`);
+    if (toArchive.length > 0) {
+        const archiveContent = toArchive
+            .map((turn) => JSON.stringify(turn))
+            .join("\n");
+        await fs.promises.writeFile(archivePath, archiveContent + "\n", "utf-8");
+    }
+    // Rewrite history.jsonl with only the kept messages
+    if (keepMessages && keepMessages.length > 0) {
+        const newHistoryContent = keepMessages
+            .map((turn) => JSON.stringify(turn))
+            .join("\n");
+        await fs.promises.writeFile(historyPath, newHistoryContent + "\n", "utf-8");
+    }
+    else {
+        // No messages to keep, delete or truncate history.jsonl
+        try {
+            await fs.promises.unlink(historyPath);
+        }
+        catch (err) {
+            const code = err && typeof err === "object" && "code" in err
+                ? String(err.code)
+                : null;
+            if (code !== "ENOENT") {
+                throw err;
+            }
+        }
+    }
+    // Update compaction count in metadata
+    await writeSessionMetadata(agentId, sessionId, {
+        compactionCount: nextNum,
+    });
+    return nextNum;
+}
+/**
+ * Write or update summary.md.
+ */
+export async function writeSummary(agentId, sessionId, summary) {
+    const sessionDir = await createSessionDir(agentId, sessionId);
+    const summaryPath = path.join(sessionDir, "summary.md");
+    await fs.promises.writeFile(summaryPath, summary, "utf-8");
+}
+/**
+ * Load summary.md.
+ * Returns null if no summary exists.
+ */
+export async function loadSummary(agentId, sessionId) {
+    const sessionDir = resolveSessionDir(agentId, sessionId);
+    const summaryPath = path.join(sessionDir, "summary.md");
+    try {
+        return await fs.promises.readFile(summaryPath, "utf-8");
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+/**
+ * Load complete session (metadata + history).
+ * Returns null if session doesn't exist.
+ */
+export async function loadSession(agentId, sessionId) {
+    const metadata = await loadSessionMetadata(agentId, sessionId);
+    if (!metadata)
+        return null;
+    const history = await loadHistory(agentId, sessionId);
+    const summary = await loadSummary(agentId, sessionId);
+    return { metadata, history, summary };
+}
+/**
+ * List all session IDs for an agent.
+ * Returns empty array if no sessions exist.
+ */
+export async function listAgentSessions(agentId) {
+    const sessionsDir = resolveAgentSessionsDir(agentId);
+    try {
+        const entries = await fs.promises.readdir(sessionsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT")
+            return [];
+        throw err;
+    }
+}
+/**
+ * Check if old format exists (sessions.json + {sessionId}.jsonl).
+ * Used for migration detection.
+ */
+export async function hasOldFormatSessions(agentId) {
+    const storePath = resolveDefaultSessionStorePath(agentId);
+    try {
+        await fs.promises.access(storePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Migrate a single session from old format to new format.
+ * Old: sessions.json entry + {sessionId}.jsonl
+ * New: {sessionId}/session.json + {sessionId}/history.jsonl
+ */
+export async function migrateSessionToNewFormat(agentId, sessionKey, sessionEntry) {
+    const { sessionId } = sessionEntry;
+    // Create session directory and write metadata
+    await writeSessionMetadata(agentId, sessionId, {
+        ...sessionEntry,
+        created: new Date(sessionEntry.updatedAt).toISOString(),
+    });
+    // Migrate transcript if it exists
+    const oldTranscriptPath = resolveSessionTranscriptPath(sessionId, agentId);
+    try {
+        const transcriptContent = await fs.promises.readFile(oldTranscriptPath, "utf-8");
+        const lines = transcriptContent.trim().split("\n").filter(Boolean);
+        // Parse old transcript format and convert to new history format
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                // Old format might vary, so we do a best-effort conversion
+                const turn = {
+                    turn_id: parsed.turn_id ?? crypto.randomUUID(),
+                    role: parsed.role ?? "user",
+                    content: parsed.content ?? JSON.stringify(parsed),
+                    tool_calls: parsed.tool_calls,
+                    tool_call_id: parsed.tool_call_id,
+                    timestamp: parsed.timestamp ?? new Date().toISOString(),
+                };
+                await appendToHistory(agentId, sessionId, turn);
+            }
+            catch (parseErr) {
+                // Skip malformed lines
+                console.warn(`Failed to parse transcript line for session ${sessionId}:`, parseErr);
+            }
+        }
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code !== "ENOENT") {
+            throw err;
+        }
+        // No transcript to migrate, that's ok
+    }
+}
+/**
+ * Migrate all sessions from old format to new format.
+ * Should be called once on first access if old format detected.
+ */
+export async function migrateAllSessionsToNewFormat(agentId) {
+    const hasOld = await hasOldFormatSessions(agentId);
+    if (!hasOld)
+        return;
+    const storePath = resolveDefaultSessionStorePath(agentId);
+    const store = loadSessionStore(storePath);
+    // Migrate each session
+    for (const [sessionKey, sessionEntry] of Object.entries(store)) {
+        await migrateSessionToNewFormat(agentId, sessionKey, sessionEntry);
+    }
+    // Optionally: rename old sessions.json to sessions.json.migrated
+    // to preserve it but mark as migrated
+    try {
+        await fs.promises.rename(storePath, `${storePath}.migrated`);
+    }
+    catch {
+        // Best effort, ignore errors
+    }
+}
+export function resolveStorePath(store, opts) {
+    const agentId = normalizeAgentId(opts?.agentId ?? DEFAULT_AGENT_ID);
+    if (!store)
+        return resolveDefaultSessionStorePath(agentId);
+    if (store.includes("{agentId}")) {
+        return path.resolve(store.replaceAll("{agentId}", agentId).replace("~", os.homedir()));
+    }
+    if (store.startsWith("~"))
+        return path.resolve(store.replace("~", os.homedir()));
+    return path.resolve(store);
+}
+export function resolveMainSessionKey(cfg) {
+    if (cfg?.session?.scope === "global")
+        return "global";
+    const agentId = normalizeAgentId(cfg?.routing?.defaultAgentId ?? DEFAULT_AGENT_ID);
+    const mainKey = (cfg?.session?.mainKey ?? DEFAULT_MAIN_KEY).trim() || DEFAULT_MAIN_KEY;
+    return buildAgentMainSessionKey({ agentId, mainKey });
+}
+export function resolveAgentIdFromSessionKey(sessionKey) {
+    const parsed = parseAgentSessionKey(sessionKey);
+    return normalizeAgentId(parsed?.agentId ?? DEFAULT_AGENT_ID);
+}
+export function resolveAgentMainSessionKey(params) {
+    const mainKey = (params.cfg?.session?.mainKey ?? DEFAULT_MAIN_KEY).trim() ||
+        DEFAULT_MAIN_KEY;
+    return buildAgentMainSessionKey({ agentId: params.agentId, mainKey });
+}
+function normalizeGroupLabel(raw) {
+    const trimmed = raw?.trim().toLowerCase() ?? "";
+    if (!trimmed)
+        return "";
+    const dashed = trimmed.replace(/\s+/g, "-");
+    const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
+    return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+}
+function shortenGroupId(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return "";
+    if (trimmed.length <= 14)
+        return trimmed;
+    return `${trimmed.slice(0, 6)}...${trimmed.slice(-4)}`;
+}
+export function buildGroupDisplayName(params) {
+    const providerKey = (params.provider?.trim().toLowerCase() || "group").trim();
+    const room = params.room?.trim();
+    const space = params.space?.trim();
+    const subject = params.subject?.trim();
+    const detail = (room && space
+        ? `${space}${room.startsWith("#") ? "" : "#"}${room}`
+        : room || subject || space || "") || "";
+    const fallbackId = params.id?.trim() || params.key.replace(/^group:/, "");
+    const rawLabel = detail || fallbackId;
+    let token = normalizeGroupLabel(rawLabel);
+    if (!token) {
+        token = normalizeGroupLabel(shortenGroupId(rawLabel));
+    }
+    if (!params.room && token.startsWith("#")) {
+        token = token.replace(/^#+/, "");
+    }
+    if (token &&
+        !/^[@#]/.test(token) &&
+        !token.startsWith("g-") &&
+        !token.includes("#")) {
+        token = `g-${token}`;
+    }
+    return token ? `${providerKey}:${token}` : providerKey;
+}
+export function resolveGroupSessionKey(ctx) {
+    const from = typeof ctx.From === "string" ? ctx.From.trim() : "";
+    if (!from)
+        return null;
+    const chatType = ctx.ChatType?.trim().toLowerCase();
+    const isGroup = chatType === "group" ||
+        from.startsWith("group:") ||
+        from.includes("@g.us") ||
+        from.includes(":group:") ||
+        from.includes(":channel:");
+    if (!isGroup)
+        return null;
+    const providerHint = ctx.Provider?.trim().toLowerCase();
+    const hasLegacyGroupPrefix = from.startsWith("group:");
+    const raw = (hasLegacyGroupPrefix ? from.slice("group:".length) : from).trim();
+    let provider;
+    let kind;
+    let id = "";
+    const parseKind = (value) => {
+        if (value === "channel")
+            return "channel";
+        return "group";
+    };
+    const parseParts = (parts) => {
+        if (parts.length >= 2 && GROUP_SURFACES.has(parts[0])) {
+            provider = parts[0];
+            if (parts.length >= 3) {
+                const kindCandidate = parts[1];
+                if (["group", "channel"].includes(kindCandidate)) {
+                    kind = parseKind(kindCandidate);
+                    id = parts.slice(2).join(":");
+                }
+                else {
+                    id = parts.slice(1).join(":");
+                }
+            }
+            else {
+                id = parts[1];
+            }
+            return;
+        }
+        if (parts.length >= 2 && ["group", "channel"].includes(parts[0])) {
+            kind = parseKind(parts[0]);
+            id = parts.slice(1).join(":");
+        }
+    };
+    if (hasLegacyGroupPrefix) {
+        const legacyParts = raw.split(":").filter(Boolean);
+        if (legacyParts.length > 1) {
+            parseParts(legacyParts);
+        }
+        else {
+            id = raw;
+        }
+    }
+    else if (from.includes("@g.us") && !from.includes(":")) {
+        id = from;
+    }
+    else {
+        parseParts(from.split(":").filter(Boolean));
+        if (!id) {
+            id = raw || from;
+        }
+    }
+    const resolvedProvider = provider ?? providerHint;
+    if (!resolvedProvider) {
+        const legacy = hasLegacyGroupPrefix ? `group:${raw}` : `group:${from}`;
+        return {
+            key: legacy,
+            id: raw || from,
+            legacyKey: legacy,
+            chatType: "group",
+        };
+    }
+    const resolvedKind = kind === "channel" ? "channel" : "group";
+    const key = `${resolvedProvider}:${resolvedKind}:${id || raw || from}`;
+    let legacyKey;
+    if (hasLegacyGroupPrefix || from.includes("@g.us")) {
+        legacyKey = `group:${id || raw || from}`;
+    }
+    return {
+        key,
+        legacyKey,
+        provider: resolvedProvider,
+        id: id || raw || from,
+        chatType: resolvedKind === "channel" ? "room" : "group",
+    };
+}
+export function loadSessionStore(storePath) {
+    try {
+        const raw = fs.readFileSync(storePath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore missing/invalid store; we'll recreate it
+    }
+    return {};
+}
+export async function saveSessionStore(storePath, store) {
+    await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
+    const json = JSON.stringify(store, null, 2);
+    const tmp = `${storePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await fs.promises.writeFile(tmp, json, "utf-8");
+        await fs.promises.rename(tmp, storePath);
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT") {
+            // In tests the temp session-store directory may be deleted while writes are in-flight.
+            // Best-effort: try a direct write (recreating the parent dir), otherwise ignore.
+            try {
+                await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
+                await fs.promises.writeFile(storePath, json, "utf-8");
+            }
+            catch (err2) {
+                const code2 = err2 && typeof err2 === "object" && "code" in err2
+                    ? String(err2.code)
+                    : null;
+                if (code2 === "ENOENT")
+                    return;
+                throw err2;
+            }
+            return;
+        }
+        throw err;
+    }
+    finally {
+        await fs.promises.rm(tmp, { force: true });
+    }
+}
+export async function updateLastRoute(params) {
+    const { storePath, sessionKey, provider, to, accountId } = params;
+    const store = loadSessionStore(storePath);
+    const existing = store[sessionKey];
+    const now = Date.now();
+    const next = {
+        sessionId: existing?.sessionId ?? crypto.randomUUID(),
+        updatedAt: Math.max(existing?.updatedAt ?? 0, now),
+        systemSent: existing?.systemSent,
+        abortedLastRun: existing?.abortedLastRun,
+        thinkingLevel: existing?.thinkingLevel,
+        verboseLevel: existing?.verboseLevel,
+        providerOverride: existing?.providerOverride,
+        modelOverride: existing?.modelOverride,
+        sendPolicy: existing?.sendPolicy,
+        queueMode: existing?.queueMode,
+        inputTokens: existing?.inputTokens,
+        outputTokens: existing?.outputTokens,
+        totalTokens: existing?.totalTokens,
+        modelProvider: existing?.modelProvider,
+        model: existing?.model,
+        contextTokens: existing?.contextTokens,
+        displayName: existing?.displayName,
+        chatType: existing?.chatType,
+        provider: existing?.provider,
+        subject: existing?.subject,
+        room: existing?.room,
+        space: existing?.space,
+        skillsSnapshot: existing?.skillsSnapshot,
+        lastProvider: provider,
+        lastTo: to?.trim() ? to.trim() : undefined,
+        lastAccountId: accountId?.trim()
+            ? accountId.trim()
+            : existing?.lastAccountId,
+    };
+    store[sessionKey] = next;
+    await saveSessionStore(storePath, store);
+    return next;
+}
+// Decide which session bucket to use (per-sender vs global).
+export function deriveSessionKey(scope, ctx) {
+    if (scope === "global")
+        return "global";
+    const resolvedGroup = resolveGroupSessionKey(ctx);
+    if (resolvedGroup)
+        return resolvedGroup.key;
+    const from = ctx.From ? normalizeE164(ctx.From) : "";
+    return from || "unknown";
+}
+/**
+ * Resolve the session key with a canonical direct-chat bucket (default: "main").
+ * All non-group direct chats collapse to this bucket; groups stay isolated.
+ */
+export function resolveSessionKey(scope, ctx, mainKey) {
+    const explicit = ctx.SessionKey?.trim();
+    if (explicit)
+        return explicit;
+    const raw = deriveSessionKey(scope, ctx);
+    if (scope === "global")
+        return raw;
+    const canonicalMainKey = (mainKey ?? DEFAULT_MAIN_KEY).trim() || DEFAULT_MAIN_KEY;
+    const canonical = buildAgentMainSessionKey({
+        agentId: DEFAULT_AGENT_ID,
+        mainKey: canonicalMainKey,
+    });
+    const isGroup = raw.startsWith("group:") ||
+        raw.includes(":group:") ||
+        raw.includes(":channel:");
+    if (!isGroup)
+        return canonical;
+    return `agent:${DEFAULT_AGENT_ID}:${raw}`;
+}

package/dist/config/talk.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function readTalkApiKeyFromProfile(deps = {}) {
+    const fsImpl = deps.fs ?? fs;
+    const osImpl = deps.os ?? os;
+    const pathImpl = deps.path ?? path;
+    const home = osImpl.homedir();
+    const candidates = [".profile", ".zprofile", ".zshrc", ".bashrc"].map((name) => pathImpl.join(home, name));
+    for (const candidate of candidates) {
+        if (!fsImpl.existsSync(candidate))
+            continue;
+        try {
+            const text = fsImpl.readFileSync(candidate, "utf-8");
+            const match = text.match(/(?:^|\n)\s*(?:export\s+)?ELEVENLABS_API_KEY\s*=\s*["']?([^\n"']+)["']?/);
+            const value = match?.[1]?.trim();
+            if (value)
+                return value;
+        }
+        catch {
+            // Ignore profile read errors.
+        }
+    }
+    return null;
+}
+export function resolveTalkApiKey(env = process.env, deps = {}) {
+    const envValue = (env.ELEVENLABS_API_KEY ?? "").trim();
+    if (envValue)
+        return envValue;
+    return readTalkApiKeyFromProfile(deps);
+}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/validation.js

@@ -0,0 +1,29 @@
+import { applyIdentityDefaults, applyModelDefaults, applySessionDefaults, } from "./defaults.js";
+import { findLegacyConfigIssues } from "./legacy.js";
+import { NexusSchema } from "./zod-schema.js";
+export function validateConfigObject(raw) {
+    const legacyIssues = findLegacyConfigIssues(raw);
+    if (legacyIssues.length > 0) {
+        return {
+            ok: false,
+            issues: legacyIssues.map((iss) => ({
+                path: iss.path,
+                message: iss.message,
+            })),
+        };
+    }
+    const validated = NexusSchema.safeParse(raw);
+    if (!validated.success) {
+        return {
+            ok: false,
+            issues: validated.error.issues.map((iss) => ({
+                path: iss.path.join("."),
+                message: iss.message,
+            })),
+        };
+    }
+    return {
+        ok: true,
+        config: applyModelDefaults(applySessionDefaults(applyIdentityDefaults(validated.data))),
+    };
+}