@nordbyte/nordrelay 0.2.1 → 0.3.0

package/dist/prompt-store.js

@@ -1,14 +1,17 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import path from "node:path";
-import { readJsonFileWithBackup, writeJsonFileAtomic } from "./persistence.js";
+import { createDocumentStore } from "./state-backend.js";
 export class PromptStore {
-    persistPath;
+    store;
     lastPrompts = new Map();
     queues = new Map();
     pausedContexts = new Set();
-    constructor(workspace) {
-        this.persistPath = path.join(workspace, ".nordrelay", "prompts.json");
+    constructor(workspace, backend = "json") {
+        this.store = createDocumentStore({
+            workspace,
+            fileName: "prompts.json",
+            sqliteKey: "prompts",
+            backend,
+        });
         this.load();
     }
     setLastPrompt(contextKey, prompt) {
@@ -18,12 +21,13 @@ export class PromptStore {
     getLastPrompt(contextKey) {
         return this.lastPrompts.get(contextKey);
     }
-    enqueue(contextKey, prompt) {
+    enqueue(contextKey, prompt, options = {}) {
         const item = {
             ...prompt,
             id: createQueueId(),
             contextKey,
             createdAt: Date.now(),
+            notBefore: options.notBefore,
         };
         const queue = this.queues.get(contextKey) ?? [];
         queue.push(item);
@@ -39,7 +43,15 @@ export class PromptStore {
     }
     dequeue(contextKey) {
         const queue = this.queues.get(contextKey);
-        const item = queue?.shift();
+        if (!queue || queue.length === 0) {
+            return undefined;
+        }
+        const now = Date.now();
+        const index = queue.findIndex((queued) => !queued.notBefore || queued.notBefore <= now);
+        if (index === -1) {
+            return undefined;
+        }
+        const [item] = queue.splice(index, 1);
         if (!queue || queue.length === 0) {
             this.queues.delete(contextKey);
         }
@@ -53,6 +65,16 @@ export class PromptStore {
     list(contextKey) {
         return [...(this.queues.get(contextKey) ?? [])];
     }
+    get(contextKey, id) {
+        return this.queues.get(contextKey)?.find((item) => item.id === id);
+    }
+    nextRunnableAt(contextKey) {
+        const timestamps = (this.queues.get(contextKey) ?? [])
+            .map((item) => item.notBefore)
+            .filter((value) => typeof value === "number")
+            .sort((left, right) => left - right);
+        return timestamps[0] ?? null;
+    }
     listContextKeys() {
         return [...new Set([...this.queues.keys(), ...this.pausedContexts])];
     }
@@ -143,13 +165,12 @@ export class PromptStore {
     }
     persist() {
         try {
-            mkdirSync(path.dirname(this.persistPath), { recursive: true });
             const payload = {
                 lastPrompts: Object.fromEntries(this.lastPrompts.entries()),
                 queues: Object.fromEntries(this.queues.entries()),
                 pausedContexts: [...this.pausedContexts],
             };
-            writeJsonFileAtomic(this.persistPath, payload);
+            this.store.write(payload);
         }
         catch (error) {
             console.warn("Failed to persist prompt store:", error instanceof Error ? error.message : String(error));
@@ -157,7 +178,7 @@ export class PromptStore {
     }
     load() {
         try {
-            const payload = readJsonFileWithBackup(this.persistPath).value;
+            const payload = this.store.read();
             if (!payload) {
                 return;
             }
@@ -218,6 +239,7 @@ function isQueuedPrompt(value) {
         typeof value.id === "string" &&
         typeof value.contextKey === "string" &&
         typeof value.createdAt === "number" &&
+        (value.notBefore === undefined || typeof value.notBefore === "number") &&
         (value.updatedAt === undefined || typeof value.updatedAt === "number") &&
         (value.attempts === undefined || typeof value.attempts === "number") &&
         (value.lastError === undefined || typeof value.lastError === "string");

package/dist/relay-runtime.js

@@ -0,0 +1,479 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { createArtifactZipBundle, getArtifactTurnReport, ensureOutDir, listRecentArtifactReports, removeArtifactTurn, totalArtifactSize, } from "./artifacts.js";
+import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
+import { CODEX_AGENT_CAPABILITIES, CODEX_REASONING_EFFORTS, PI_THINKING_LEVELS, agentLabel, agentReasoningLabel, } from "./agent.js";
+import { enabledAgents } from "./agent-factory.js";
+import { checkAuthStatus } from "./codex-auth.js";
+import { friendlyErrorText } from "./error-messages.js";
+import { getConnectorHealth, getVersionChecks, readFormattedLogTail } from "./operations.js";
+import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
+import { renderSessionInfoPlain } from "./session-format.js";
+import { SessionRegistry } from "./session-registry.js";
+import { transcribeAudio } from "./voice.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "./workspace-policy.js";
+const WEB_CONTEXT_KEY = "0";
+const MAX_WEB_SESSION_PAGE_SIZE = 50;
+export class RelayRuntime {
+    config;
+    registry;
+    promptStore;
+    subscribers = new Set();
+    draining = false;
+    currentTurnId = null;
+    accumulatedText = "";
+    constructor(config) {
+        this.config = config;
+        this.registry = new SessionRegistry(config);
+        this.promptStore = new PromptStore(config.workspace, config.stateBackend);
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        void this.snapshot().then((data) => callback({ type: "snapshot", data })).catch(() => { });
+        return () => this.subscribers.delete(callback);
+    }
+    async snapshot() {
+        const session = await this.getSession(true);
+        const info = this.publicInfo(session);
+        return {
+            session: info,
+            sessionText: renderSessionInfoPlain(info),
+            queue: this.queue(),
+            processing: session.isProcessing(),
+            enabledAgents: enabledAgents(this.config),
+            workspaces: filterAllowedWorkspaces(session.listWorkspaces(), this.config),
+        };
+    }
+    async status() {
+        return {
+            health: await getConnectorHealth(),
+            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath }),
+            snapshot: await this.snapshot(),
+        };
+    }
+    async listSessions(limit = 80, query = "") {
+        return this.filteredSessions(await this.getSession(true), query, Math.max(1, limit * 3)).slice(0, limit);
+    }
+    async listSessionsPage(page = 1, pageSize = MAX_WEB_SESSION_PAGE_SIZE, query = "") {
+        const session = await this.getSession(true);
+        const effectivePage = Math.max(1, Math.floor(page));
+        const effectivePageSize = Math.min(MAX_WEB_SESSION_PAGE_SIZE, Math.max(1, Math.floor(pageSize)));
+        const offset = (effectivePage - 1) * effectivePageSize;
+        const requested = Math.min(5_000, Math.max(100, (offset + effectivePageSize + 1) * 3));
+        const records = this.filteredSessions(session, query, requested);
+        return {
+            sessions: records.slice(offset, offset + effectivePageSize),
+            pagination: {
+                page: effectivePage,
+                pageSize: effectivePageSize,
+                hasPrevious: effectivePage > 1,
+                hasNext: records.length > offset + effectivePageSize,
+            },
+        };
+    }
+    filteredSessions(session, query, limit) {
+        const normalized = query.trim().toLowerCase();
+        return session.listAllSessions(limit)
+            .filter((record) => evaluateWorkspacePolicy(record.cwd, this.config).allowed)
+            .filter((record) => {
+            if (!normalized) {
+                return true;
+            }
+            return [
+                record.id,
+                record.title,
+                record.cwd,
+                record.model,
+                record.reasoningEffort,
+                record.firstUserMessage,
+            ].some((value) => value?.toLowerCase().includes(normalized));
+        });
+    }
+    async listModels() {
+        return (await this.getSession(true)).listModels();
+    }
+    async setAgent(agentId) {
+        if (!enabledAgents(this.config).includes(agentId)) {
+            throw new Error(`Agent is not enabled: ${agentId}`);
+        }
+        const session = await this.registry.switchAgent(WEB_CONTEXT_KEY, agentId);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async newSession(options = {}) {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        const info = await session.newThread(options.workspace, options.model);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async switchSession(threadId) {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        const info = await session.switchSession(threadId);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async attachSession(threadId) {
+        return this.switchSession(threadId);
+    }
+    async setModel(model) {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        await session.setModelForCurrentSession(model);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async setReasoningEffort(effort) {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        const options = session.getInfo().agentId === "pi" ? PI_THINKING_LEVELS : CODEX_REASONING_EFFORTS;
+        if (!options.includes(effort)) {
+            throw new Error(`Invalid ${agentReasoningLabel(session.getInfo().agentId)} value: ${effort}`);
+        }
+        await session.setReasoningEffortForCurrentSession(effort);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async setFastMode(enabled) {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        if (!(session.getInfo().capabilities ?? CODEX_AGENT_CAPABILITIES).fastMode) {
+            throw new Error(`Fast mode is not supported for ${agentLabel(session.getInfo().agentId)}.`);
+        }
+        session.setFastMode(enabled);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async setLaunchProfile(profileId) {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        session.setLaunchProfile(profileId);
+        this.updateSession(session);
+        return this.publicInfo(session);
+    }
+    async handback() {
+        const session = await this.getSession(true);
+        this.ensureIdle(session);
+        const result = session.handback();
+        this.updateSession(session);
+        return result;
+    }
+    async abort() {
+        const session = await this.getSession(true);
+        await session.abort();
+        this.broadcast({ type: "status", level: "warn", message: "Current operation aborted.", at: new Date().toISOString() });
+    }
+    async sendPrompt(text) {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            throw new Error("Prompt is empty.");
+        }
+        return this.sendEnvelope(toPromptEnvelope(trimmed));
+    }
+    async sendUploadPrompt(options) {
+        const text = options.text?.trim() ?? "";
+        const files = options.files.filter((file) => file.data.byteLength > 0);
+        if (!text && files.length === 0) {
+            throw new Error("Prompt is empty.");
+        }
+        const session = await this.getSession(false);
+        const workspace = session.getInfo().workspace;
+        const turnId = randomUUID().slice(0, 12);
+        const outDir = outboxPath(workspace, turnId);
+        await ensureOutDir(outDir);
+        const stagedFiles = [];
+        const imagePaths = [];
+        const transcriptParts = [];
+        for (const [index, file] of files.entries()) {
+            const mimeType = normalizeMimeType(file.mimeType, file.name);
+            const staged = await stageFile(file.data, file.name || `upload-${index + 1}`, mimeType, {
+                workspace,
+                turnId,
+                maxFileSize: this.config.maxFileSize,
+            });
+            stagedFiles.push(staged);
+            if (mimeType.startsWith("image/")) {
+                imagePaths.push(staged.localPath);
+            }
+            if (mimeType.startsWith("audio/")) {
+                const result = await transcribeAudio(staged.localPath, {
+                    preferredBackend: this.config.voicePreferredBackend === "auto"
+                        ? undefined
+                        : this.config.voicePreferredBackend,
+                    language: this.config.voiceDefaultLanguage,
+                });
+                const transcript = result.text.trim();
+                if (transcript) {
+                    transcriptParts.push(`Audio transcript (${staged.safeName}, via ${result.backend}):\n${transcript}`);
+                }
+            }
+        }
+        const audioOnly = stagedFiles.length > 0 && stagedFiles.every((file) => file.mimeType.startsWith("audio/"));
+        if (this.config.voiceTranscribeOnly && audioOnly && !text) {
+            return {
+                queued: false,
+                transcript: transcriptParts.join("\n\n"),
+                transcribeOnly: true,
+                files: uploadFileDtos(stagedFiles),
+            };
+        }
+        const promptInput = {};
+        const textParts = [text, ...transcriptParts].filter(Boolean);
+        if (textParts.length > 0) {
+            promptInput.text = textParts.join("\n\n");
+        }
+        if (imagePaths.length > 0) {
+            promptInput.imagePaths = imagePaths;
+        }
+        if (stagedFiles.length > 0) {
+            promptInput.stagedFileInstructions = buildFileInstructions(stagedFiles, outDir);
+        }
+        const result = await this.sendEnvelope(toPromptEnvelope(promptInput, outDir));
+        return {
+            ...result,
+            transcript: transcriptParts.join("\n\n") || undefined,
+            files: uploadFileDtos(stagedFiles),
+        };
+    }
+    async sendEnvelope(envelope) {
+        const session = await this.getSession(false);
+        if (session.isProcessing()) {
+            const queued = this.promptStore.enqueue(WEB_CONTEXT_KEY, envelope);
+            this.broadcastQueue();
+            return { queued: true, queueId: queued.id };
+        }
+        void this.runPrompt(session, envelope).catch((error) => {
+            this.broadcast({ type: "turn_error", id: this.currentTurnId ?? "turn", error: friendlyErrorText(error), at: new Date().toISOString() });
+        });
+        return { queued: false };
+    }
+    queue() {
+        return this.promptStore.list(WEB_CONTEXT_KEY).map(queueItemDto);
+    }
+    queueAction(action, id) {
+        if (action === "pause")
+            this.promptStore.pause(WEB_CONTEXT_KEY);
+        if (action === "resume")
+            this.promptStore.resume(WEB_CONTEXT_KEY);
+        if (action === "clear")
+            this.promptStore.clear(WEB_CONTEXT_KEY);
+        if (id && action === "cancel")
+            this.promptStore.remove(WEB_CONTEXT_KEY, id);
+        if (id && action === "top")
+            this.promptStore.moveToTop(WEB_CONTEXT_KEY, id);
+        if (id && action === "up")
+            this.promptStore.moveUp(WEB_CONTEXT_KEY, id);
+        if (id && action === "down")
+            this.promptStore.moveDown(WEB_CONTEXT_KEY, id);
+        if (id && action === "run") {
+            const item = this.promptStore.remove(WEB_CONTEXT_KEY, id);
+            if (item)
+                this.promptStore.enqueueFront(WEB_CONTEXT_KEY, item);
+            void this.drainQueue().catch((error) => this.broadcastStatus(friendlyErrorText(error), "error"));
+        }
+        this.broadcastQueue();
+        return this.queue();
+    }
+    async artifacts() {
+        const session = await this.getSession(true);
+        return (await listRecentArtifactReports(session.getInfo().workspace, 20, this.config.maxFileSize)).map(artifactDto);
+    }
+    async artifact(turnId) {
+        const session = await this.getSession(true);
+        return getArtifactTurnReport(session.getInfo().workspace, turnId, this.config.maxFileSize);
+    }
+    async deleteArtifact(turnId) {
+        const session = await this.getSession(true);
+        return removeArtifactTurn(session.getInfo().workspace, turnId);
+    }
+    async createArtifactZip(turnId) {
+        const report = await this.artifact(turnId);
+        if (!report) {
+            return null;
+        }
+        const bundle = await createArtifactZipBundle(report.artifacts, report.outDir, {
+            maxFileSize: this.config.maxFileSize,
+            bundleName: `nordrelay-artifacts-${turnId}.zip`,
+        });
+        return bundle ? { path: bundle.localPath, name: bundle.name } : null;
+    }
+    async logs(target = "connector", lines = 100) {
+        if (target === "update") {
+            const { getUpdateLogPath } = await import("./operations.js");
+            return readFormattedLogTail(lines, getUpdateLogPath());
+        }
+        return readFormattedLogTail(lines);
+    }
+    dispose() {
+        this.registry.disposeAll();
+        this.subscribers.clear();
+    }
+    async getSession(deferThreadStart) {
+        return this.registry.getOrCreate(WEB_CONTEXT_KEY, { deferThreadStart });
+    }
+    async ensureActiveThread(session) {
+        if (!session.hasActiveThread()) {
+            await session.newThread();
+            this.updateSession(session);
+        }
+    }
+    ensureIdle(session) {
+        if (session.isProcessing()) {
+            throw new Error("The active session is still processing a turn.");
+        }
+    }
+    async runPrompt(session, envelope) {
+        await this.ensureActiveThread(session);
+        const info = session.getInfo();
+        if ((info.capabilities ?? CODEX_AGENT_CAPABILITIES).auth) {
+            const auth = await checkAuthStatus(this.config.codexApiKey);
+            if (!auth.authenticated) {
+                throw new Error(`Codex is not authenticated: ${auth.detail}`);
+            }
+        }
+        const workspacePolicy = evaluateWorkspacePolicy(session.getInfo().workspace, this.config);
+        if (!workspacePolicy.allowed) {
+            throw new Error(workspacePolicy.warning ?? "Current workspace is blocked by policy.");
+        }
+        const turnId = randomUUID().slice(0, 12);
+        this.currentTurnId = turnId;
+        this.accumulatedText = "";
+        this.promptStore.setLastPrompt(WEB_CONTEXT_KEY, envelope);
+        this.broadcast({ type: "turn_start", id: turnId, prompt: envelope.description, at: new Date().toISOString() });
+        const callbacks = {
+            onTextDelta: (delta) => {
+                this.accumulatedText += delta;
+                this.broadcast({ type: "text_delta", id: turnId, delta });
+            },
+            onToolStart: (toolName, toolCallId) => this.broadcast({ type: "tool_start", id: turnId, toolCallId, toolName }),
+            onToolUpdate: (toolCallId, partialResult) => this.broadcast({ type: "tool_update", id: turnId, toolCallId, partialResult }),
+            onToolEnd: (toolCallId, isError) => this.broadcast({ type: "tool_end", id: turnId, toolCallId, isError }),
+            onTodoUpdate: (items) => this.broadcast({ type: "todo_update", id: turnId, items }),
+            onTurnComplete: () => { },
+            onAgentEnd: () => this.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() }),
+        };
+        try {
+            await session.prompt(envelope.input, callbacks);
+            this.updateSession(session);
+            this.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() });
+        }
+        catch (error) {
+            this.broadcast({ type: "turn_error", id: turnId, error: friendlyErrorText(error), at: new Date().toISOString() });
+            throw error;
+        }
+        finally {
+            this.currentTurnId = null;
+            await this.drainQueue();
+        }
+    }
+    async drainQueue() {
+        if (this.draining || this.promptStore.isPaused(WEB_CONTEXT_KEY)) {
+            return;
+        }
+        this.draining = true;
+        try {
+            const session = await this.getSession(false);
+            while (!session.isProcessing()) {
+                const next = this.promptStore.dequeue(WEB_CONTEXT_KEY);
+                this.broadcastQueue();
+                if (!next) {
+                    return;
+                }
+                await this.runPrompt(session, next);
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    updateSession(session) {
+        this.registry.updateMetadata(WEB_CONTEXT_KEY, session);
+        this.broadcast({ type: "session_update", session: this.publicInfo(session) });
+    }
+    broadcastQueue() {
+        this.broadcast({ type: "queue_update", queue: this.queue() });
+    }
+    broadcastStatus(message, level = "info") {
+        this.broadcast({ type: "status", message, level, at: new Date().toISOString() });
+    }
+    broadcast(event) {
+        for (const subscriber of this.subscribers) {
+            try {
+                subscriber(event);
+            }
+            catch {
+                this.subscribers.delete(subscriber);
+            }
+        }
+    }
+    publicInfo(session) {
+        const info = session.getInfo();
+        const agentId = info.agentId ?? "codex";
+        return {
+            ...info,
+            agentId,
+            agentLabel: info.agentLabel ?? agentLabel(agentId),
+            capabilities: info.capabilities ?? CODEX_AGENT_CAPABILITIES,
+        };
+    }
+}
+function queueItemDto(item) {
+    return {
+        id: item.id,
+        description: item.description,
+        createdAt: new Date(item.createdAt).toISOString(),
+        attempts: item.attempts ?? 0,
+        notBefore: item.notBefore ? new Date(item.notBefore).toISOString() : undefined,
+        lastError: item.lastError,
+    };
+}
+function artifactDto(report) {
+    return {
+        turnId: report.turnId,
+        updatedAt: report.updatedAt.toISOString(),
+        source: report.source,
+        fileCount: report.artifacts.length,
+        totalSizeBytes: totalArtifactSize(report.artifacts),
+        skippedCount: report.skippedCount,
+        omittedCount: report.omittedCount,
+        artifacts: report.artifacts.map((artifact) => ({
+            name: artifact.name,
+            relativePath: artifact.relativePath.split(path.sep).join("/"),
+            sizeBytes: artifact.sizeBytes,
+        })),
+    };
+}
+function normalizeMimeType(value, name) {
+    const configured = value?.trim();
+    if (configured) {
+        return configured;
+    }
+    const extension = path.extname(name).toLowerCase();
+    if ([".jpg", ".jpeg"].includes(extension))
+        return "image/jpeg";
+    if (extension === ".png")
+        return "image/png";
+    if (extension === ".gif")
+        return "image/gif";
+    if (extension === ".webp")
+        return "image/webp";
+    if (extension === ".mp3")
+        return "audio/mpeg";
+    if (extension === ".wav")
+        return "audio/wav";
+    if (extension === ".ogg" || extension === ".oga")
+        return "audio/ogg";
+    if (extension === ".m4a")
+        return "audio/mp4";
+    if (extension === ".webm")
+        return "audio/webm";
+    return "application/octet-stream";
+}
+function uploadFileDtos(files) {
+    return files.map((file) => ({
+        name: file.safeName,
+        mimeType: file.mimeType,
+        sizeBytes: file.sizeBytes,
+    }));
+}

package/dist/session-locks.js

@@ -0,0 +1,81 @@
+import { createDocumentStore } from "./state-backend.js";
+export class SessionLockStore {
+    store;
+    constructor(workspace, backend = "json") {
+        this.store = createDocumentStore({
+            workspace,
+            fileName: "locks.json",
+            sqliteKey: "locks",
+            backend,
+        });
+    }
+    get(contextKey, now = Date.now()) {
+        const payload = this.readPayload();
+        const lock = payload.locks[contextKey];
+        if (!lock) {
+            return null;
+        }
+        if (lock.expiresAt && lock.expiresAt <= now) {
+            delete payload.locks[contextKey];
+            this.store.write(payload);
+            return null;
+        }
+        return lock;
+    }
+    set(contextKey, ownerId, ownerName, ttlMs) {
+        const payload = this.readPayload();
+        const lock = {
+            contextKey,
+            ownerId,
+            ownerName,
+            createdAt: Date.now(),
+            expiresAt: ttlMs > 0 ? Date.now() + ttlMs : undefined,
+        };
+        payload.locks[contextKey] = lock;
+        this.store.write(payload);
+        return lock;
+    }
+    clear(contextKey) {
+        const payload = this.readPayload();
+        const existed = Boolean(payload.locks[contextKey]);
+        delete payload.locks[contextKey];
+        this.store.write(payload);
+        return existed;
+    }
+    list() {
+        const payload = this.readPayload();
+        const now = Date.now();
+        const locks = Object.values(payload.locks).filter((lock) => !lock.expiresAt || lock.expiresAt > now);
+        if (locks.length !== Object.keys(payload.locks).length) {
+            payload.locks = Object.fromEntries(locks.map((lock) => [lock.contextKey, lock]));
+            this.store.write(payload);
+        }
+        return locks.sort((left, right) => right.createdAt - left.createdAt);
+    }
+    readPayload() {
+        const payload = this.store.read();
+        if (!payload || payload.version !== 1 || !payload.locks || typeof payload.locks !== "object") {
+            return { version: 1, locks: {} };
+        }
+        return {
+            version: 1,
+            locks: Object.fromEntries(Object.entries(payload.locks).filter(([, lock]) => isSessionLock(lock))),
+        };
+    }
+}
+export function canWriteWithLock(lock, userId, isAdmin) {
+    if (!lock) {
+        return true;
+    }
+    return isAdmin || userId === lock.ownerId;
+}
+function isSessionLock(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.contextKey === "string" &&
+        Number.isInteger(candidate.ownerId) &&
+        typeof candidate.createdAt === "number" &&
+        (candidate.expiresAt === undefined || typeof candidate.expiresAt === "number");
+}