@cueai/omni-reader-mcp 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+interface WritableLike {
+    write(chunk: string): unknown;
+}
+export interface RunCliOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly homeDirectory?: string;
+    readonly cwd?: string;
+    readonly artifactRoot?: string;
+    readonly platform?: NodeJS.Platform;
+    readonly now?: () => Date;
+    readonly npmVersion?: string;
+    readonly packageVersion?: string;
+    readonly fetchImpl?: typeof fetch;
+    readonly stdout?: WritableLike;
+    readonly stderr?: WritableLike;
+    readonly ask?: (question: string) => Promise<string>;
+    readonly startServer?: () => Promise<void>;
+}
+export declare function startStdioServer(options?: RunCliOptions): Promise<void>;
+export declare function runCli(args: readonly string[], options?: RunCliOptions): Promise<number>;
+export {};

package/dist/index.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import { execFile as execFileCallback } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout as processStdout } from "node:process";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ArtifactStore, defaultArtifactRoot } from "./artifact-store.js";
+import { runClean } from "./cli/clean.js";
+import { runDoctor } from "./cli/doctor.js";
+import { runSetup } from "./cli/setup.js";
+import { CubeGrantClient } from "./cube-client.js";
+import { IiisClient } from "./iiis-client.js";
+import { OperationJournal } from "./operation-journal.js";
+import { splitAllowedRoots } from "./path-security.js";
+import { createOmniMcpServer } from "./server.js";
+function helpText() {
+    return [
+        "Usage: omni-reader-mcp [setup|doctor|clean|--help|--version]",
+        "",
+        "No arguments start the stdio MCP server.",
+        "setup   Configure a supported user-scope Agent",
+        "doctor  Check local configuration and protocol health",
+        "clean   Delete Bridge-created local artifacts and expired records",
+        "",
+    ].join("\n");
+}
+async function defaultAsk(question) {
+    const prompt = createInterface({ input: stdin, output: processStdout });
+    try {
+        return await prompt.question(question);
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function installedPackageVersion() {
+    try {
+        const value = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            const version = value.version;
+            if (typeof version === "string" && version.length > 0)
+                return version;
+        }
+    }
+    catch {
+        // Report an explicit unknown version rather than a stale compiled constant.
+    }
+    return "unknown";
+}
+async function installedNpmVersion(env) {
+    const userAgent = env.npm_config_user_agent;
+    const embedded = userAgent === undefined ? null : /(?:^|\s)npm\/([^\s]+)/u.exec(userAgent);
+    if (embedded !== null)
+        return embedded[1];
+    return new Promise((resolve) => {
+        execFileCallback("npm", ["--version"], { encoding: "utf8", env, timeout: 5_000, windowsHide: true }, (error, output) => {
+            const version = output.trim();
+            resolve(error === null && version.length > 0 ? version : "unavailable");
+        });
+    });
+}
+export async function startStdioServer(options = {}) {
+    const env = options.env ?? process.env;
+    const cwd = options.cwd ?? process.cwd();
+    const artifactRoot = options.artifactRoot ?? defaultArtifactRoot({
+        platform: options.platform,
+        homeDirectory: options.homeDirectory,
+        env,
+    });
+    const artifactStore = await ArtifactStore.open({
+        rootDirectory: artifactRoot,
+        projectDirectory: cwd,
+        now: options.now,
+    });
+    const journal = new OperationJournal({ rootDirectory: artifactStore.rootDirectory, now: options.now });
+    const cubeClient = new CubeGrantClient({
+        journal,
+        environment: { CUE_API_KEY: env.CUE_API_KEY },
+        fetchImpl: options.fetchImpl,
+    });
+    const server = createOmniMcpServer({
+        workspace: cwd,
+        extraRoots: splitAllowedRoots(env.OMNI_ALLOWED_ROOTS),
+        cubeClient,
+        iiisClient: new IiisClient({ fetchImpl: options.fetchImpl }),
+        artifactStore,
+    });
+    const close = async () => {
+        await server.close().catch(() => undefined);
+        await artifactStore.close().catch(() => undefined);
+    };
+    process.once("SIGINT", () => { void close(); });
+    process.once("SIGTERM", () => { void close(); });
+    await server.connect(new StdioServerTransport());
+}
+export async function runCli(args, options = {}) {
+    const env = options.env ?? process.env;
+    const homeDirectory = options.homeDirectory ?? (await import("node:os")).homedir();
+    const cwd = options.cwd ?? process.cwd();
+    const platform = options.platform ?? process.platform;
+    const artifactRoot = options.artifactRoot ?? defaultArtifactRoot({ platform, homeDirectory, env });
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const output = options.stdout ?? process.stdout;
+    const errorOutput = options.stderr ?? process.stderr;
+    const ask = options.ask ?? defaultAsk;
+    const write = (text) => { output.write(text); };
+    const packageVersion = options.packageVersion ?? await installedPackageVersion();
+    try {
+        if (args.length === 0) {
+            await (options.startServer ?? (() => startStdioServer({
+                ...options,
+                env,
+                homeDirectory,
+                cwd,
+                platform,
+                artifactRoot,
+                fetchImpl,
+            })))();
+            return 0;
+        }
+        const command = args[0];
+        if (command === "--help" || command === "-h" || command === "help") {
+            write(helpText());
+            return 0;
+        }
+        if (command === "--version" || command === "-v") {
+            write(`${packageVersion}\n`);
+            return 0;
+        }
+        if (command === "setup") {
+            await runSetup({ env, homeDirectory, platform, fetchImpl, ask, write });
+            return 0;
+        }
+        if (command === "doctor") {
+            const lines = await runDoctor({
+                env,
+                homeDirectory,
+                platform,
+                artifactRoot,
+                fetchImpl,
+                npmVersion: options.npmVersion ?? await installedNpmVersion(env),
+                packageVersion,
+            });
+            write(`${lines.join("\n")}\n`);
+            return 0;
+        }
+        if (command === "clean") {
+            const result = await runClean({ artifactRoot, projectDirectory: cwd, now: options.now });
+            write(`Removed ${result.removed} Bridge cache item(s).\n`);
+            return 0;
+        }
+        errorOutput.write(`Unknown command: ${command}\n`);
+        errorOutput.write(helpText());
+        return 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "The Bridge command failed.";
+        errorOutput.write(`Error: ${message}\n`);
+        return 1;
+    }
+}
+async function main() {
+    const code = await runCli(process.argv.slice(2));
+    if (code !== 0)
+        process.exitCode = code;
+}
+const invokedPath = process.argv[1];
+if (invokedPath !== undefined && import.meta.url === pathToFileURL(invokedPath).href) {
+    void main().catch(() => {
+        process.stderr.write("Bridge startup failed.\n");
+        process.exitCode = 1;
+    });
+}

package/dist/multipart-body.d.ts

@@ -0,0 +1,12 @@
+import type { OpenedAllowedFile } from "./path-security.js";
+export interface MultipartBodyOptions {
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (uploadedBytes: number) => void;
+    readonly boundary?: string;
+}
+export interface MultipartBody {
+    readonly contentType: string;
+    readonly contentLength: number;
+    readonly stream: AsyncIterable<Uint8Array>;
+}
+export declare function createMultipartBody(openedFile: OpenedAllowedFile, options?: MultipartBodyOptions): MultipartBody;

package/dist/multipart-body.js

@@ -0,0 +1,90 @@
+import { randomBytes } from "node:crypto";
+import { OmniBridgeError } from "./errors.js";
+function bridgeError(code, message, retryable) {
+    return new OmniBridgeError({
+        code,
+        message,
+        fileUploaded: false,
+        billed: false,
+        contentReleased: false,
+        retryable,
+    });
+}
+function cancellationError() {
+    return bridgeError("CANCELED_BEFORE_UPLOAD_COMPLETE", "The local upload was canceled before it completed.", false);
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw cancellationError();
+    }
+}
+function validatedBoundary(boundary) {
+    const value = boundary ?? `omni-${randomBytes(18).toString("hex")}`;
+    if (!/^[A-Za-z0-9-]{1,70}$/u.test(value)) {
+        throw bridgeError("INVALID_MULTIPART_BOUNDARY", "The multipart upload boundary is invalid.", false);
+    }
+    return value;
+}
+export function createMultipartBody(openedFile, options = {}) {
+    const boundary = validatedBoundary(options.boundary);
+    const preamble = Buffer.from([
+        `--${boundary}`,
+        `Content-Disposition: form-data; name="file"; filename="document${openedFile.safeExtension}"`,
+        `Content-Type: ${openedFile.contentType}`,
+        "",
+        "",
+    ].join("\r\n"), "utf8");
+    const trailer = Buffer.from(`\r\n--${boundary}--\r\n`, "utf8");
+    const contentLength = preamble.length + openedFile.size + trailer.length;
+    const stream = (async function* () {
+        throwIfAborted(options.signal);
+        await options.onProgress?.(0);
+        throwIfAborted(options.signal);
+        yield preamble;
+        throwIfAborted(options.signal);
+        const fileStream = openedFile.createReadStream();
+        const abortStream = () => {
+            fileStream.destroy();
+        };
+        options.signal?.addEventListener("abort", abortStream, { once: true });
+        let uploadedBytes = 0;
+        try {
+            for await (const rawChunk of fileStream) {
+                throwIfAborted(options.signal);
+                const chunk = Buffer.isBuffer(rawChunk)
+                    ? rawChunk
+                    : Buffer.from(rawChunk);
+                if (uploadedBytes + chunk.length > openedFile.size) {
+                    throw bridgeError("FILE_CHANGED_DURING_UPLOAD", "The local file changed during upload. Retry after file changes stop.", true);
+                }
+                yield chunk;
+                uploadedBytes += chunk.length;
+                await options.onProgress?.(uploadedBytes);
+                throwIfAborted(options.signal);
+            }
+            if (uploadedBytes !== openedFile.size) {
+                throw bridgeError("FILE_CHANGED_DURING_UPLOAD", "The local file changed during upload. Retry after file changes stop.", true);
+            }
+            throwIfAborted(options.signal);
+            yield trailer;
+        }
+        catch (error) {
+            if (options.signal?.aborted) {
+                throw cancellationError();
+            }
+            if (error instanceof OmniBridgeError) {
+                throw error;
+            }
+            throw bridgeError("LOCAL_FILE_READ_FAILED", "The local file could not be read during upload.", true);
+        }
+        finally {
+            options.signal?.removeEventListener("abort", abortStream);
+            fileStream.destroy();
+        }
+    })();
+    return {
+        contentType: `multipart/form-data; boundary=${boundary}`,
+        contentLength,
+        stream,
+    };
+}

package/dist/operation-journal.d.ts

@@ -0,0 +1,28 @@
+export type JournalState = "GRANT_PENDING" | "GRANT_ISSUED";
+export interface JournalRecord {
+    readonly clientRequestId: string;
+    readonly requestHash: string;
+    readonly operationId: string | null;
+    readonly operationToken: string | null;
+    readonly uploadUrl: string | null;
+    readonly state: JournalState;
+    readonly createdAt: string;
+    readonly expiresAt: string | null;
+}
+export interface IssuedGrantJournalFields {
+    readonly operationId: string;
+    readonly operationToken: string;
+    readonly uploadUrl: string;
+    readonly expiresAt: string;
+}
+export interface OperationJournalOptions {
+    readonly rootDirectory?: string;
+    readonly now?: () => Date;
+}
+export declare class OperationJournal {
+    #private;
+    constructor(options?: OperationJournalOptions);
+    begin(clientRequestId: string, requestHash: string): Promise<JournalRecord>;
+    markGrantIssued(clientRequestId: string, fields: IssuedGrantJournalFields): Promise<JournalRecord>;
+    load(clientRequestId: string): Promise<JournalRecord | null>;
+}

package/dist/operation-journal.js

@@ -0,0 +1,351 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, randomUUID, } from "node:crypto";
+import { chmod, link, mkdir, open, readFile, unlink, } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { OmniBridgeError } from "./errors.js";
+function bridgeError(code, message, retryable) {
+    return new OmniBridgeError({
+        code,
+        message,
+        fileUploaded: false,
+        billed: false,
+        contentReleased: false,
+        retryable,
+    });
+}
+function defaultRootDirectory() {
+    if (process.platform === "darwin") {
+        return path.join(homedir(), "Library", "Caches", "cue", "omni-reader-mcp");
+    }
+    if (process.platform === "win32") {
+        return path.join(homedir(), "AppData", "Local", "cue", "omni-reader-mcp");
+    }
+    return path.join(homedir(), ".cache", "cue", "omni-reader-mcp");
+}
+function recordFileName(clientRequestId) {
+    validateClientRequestId(clientRequestId);
+    return `${createHash("sha256").update(clientRequestId, "utf8").digest("hex")}.json`;
+}
+function validateClientRequestId(clientRequestId) {
+    if (!/^[A-Za-z0-9._:-]{1,128}$/u.test(clientRequestId)) {
+        throw bridgeError("INVALID_CLIENT_REQUEST_ID", "The local grant request identifier is invalid.", false);
+    }
+}
+function isEncryptedToken(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const token = value;
+    return (token.algorithm === "aes-256-gcm" &&
+        typeof token.nonce === "string" &&
+        typeof token.ciphertext === "string" &&
+        typeof token.tag === "string");
+}
+function parsePersistedRecord(value) {
+    if (value === null || typeof value !== "object") {
+        throw new Error("record is not an object");
+    }
+    const record = value;
+    if (record.version !== 1 ||
+        typeof record.clientRequestId !== "string" ||
+        typeof record.requestHash !== "string" ||
+        (record.operationId !== null && typeof record.operationId !== "string") ||
+        (record.operationToken !== null && !isEncryptedToken(record.operationToken)) ||
+        (record.uploadUrl !== null && typeof record.uploadUrl !== "string") ||
+        (record.state !== "GRANT_PENDING" && record.state !== "GRANT_ISSUED") ||
+        typeof record.createdAt !== "string" ||
+        (record.expiresAt !== null && typeof record.expiresAt !== "string")) {
+        throw new Error("record fields are invalid");
+    }
+    return record;
+}
+async function closeQuietly(handle) {
+    await handle?.close().catch(() => undefined);
+}
+export class OperationJournal {
+    #rootDirectory;
+    #now;
+    #keyPromise;
+    constructor(options = {}) {
+        this.#rootDirectory = options.rootDirectory ?? defaultRootDirectory();
+        this.#now = options.now ?? (() => new Date());
+    }
+    async begin(clientRequestId, requestHash) {
+        validateClientRequestId(clientRequestId);
+        const existing = await this.#readRecord(clientRequestId);
+        if (existing !== null) {
+            return this.#requireMatchingRequest(clientRequestId, requestHash, existing);
+        }
+        const pending = {
+            version: 1,
+            clientRequestId,
+            requestHash,
+            operationId: null,
+            operationToken: null,
+            uploadUrl: null,
+            state: "GRANT_PENDING",
+            createdAt: this.#now().toISOString(),
+            expiresAt: null,
+        };
+        if (await this.#createRecord(pending, this.#pendingRecordPath(clientRequestId))) {
+            return this.#publicRecord(pending, null);
+        }
+        const raced = await this.#readRecord(clientRequestId);
+        if (raced === null) {
+            throw bridgeError("JOURNAL_WRITE_FAILED", "The local grant journal could not be saved.", true);
+        }
+        return this.#requireMatchingRequest(clientRequestId, requestHash, raced);
+    }
+    async markGrantIssued(clientRequestId, fields) {
+        const persisted = await this.#readRecord(clientRequestId);
+        if (persisted === null) {
+            throw bridgeError("JOURNAL_RECORD_NOT_FOUND", "The local grant journal record is missing.", true);
+        }
+        if (persisted.state === "GRANT_ISSUED") {
+            return this.#requireMatchingGrant(clientRequestId, persisted, fields);
+        }
+        const operationToken = await this.#encryptToken(clientRequestId, fields.operationToken);
+        const issued = {
+            ...persisted,
+            operationId: fields.operationId,
+            operationToken,
+            uploadUrl: fields.uploadUrl,
+            state: "GRANT_ISSUED",
+            expiresAt: fields.expiresAt,
+        };
+        if (await this.#createRecord(issued, this.#issuedRecordPath(clientRequestId))) {
+            return this.#publicRecord(issued, fields.operationToken);
+        }
+        const raced = await this.#readRecord(clientRequestId);
+        if (raced === null || raced.state !== "GRANT_ISSUED") {
+            throw bridgeError("JOURNAL_WRITE_FAILED", "The local grant journal could not be saved.", true);
+        }
+        return this.#requireMatchingGrant(clientRequestId, raced, fields);
+    }
+    async load(clientRequestId) {
+        const persisted = await this.#readRecord(clientRequestId);
+        if (persisted === null) {
+            return null;
+        }
+        return this.#recordToPublic(clientRequestId, persisted);
+    }
+    async #recordToPublic(clientRequestId, persisted) {
+        const operationToken = persisted.operationToken === null
+            ? null
+            : await this.#decryptToken(clientRequestId, persisted.operationToken);
+        return this.#publicRecord(persisted, operationToken);
+    }
+    async #requireMatchingRequest(clientRequestId, requestHash, persisted) {
+        if (persisted.requestHash !== requestHash) {
+            throw bridgeError("IDEMPOTENCY_COLLISION", "This local grant request identifier is already bound to different metadata.", false);
+        }
+        return this.#recordToPublic(clientRequestId, persisted);
+    }
+    async #requireMatchingGrant(clientRequestId, persisted, fields) {
+        const existing = await this.#recordToPublic(clientRequestId, persisted);
+        if (existing.operationId !== fields.operationId ||
+            existing.operationToken !== fields.operationToken ||
+            existing.uploadUrl !== fields.uploadUrl ||
+            existing.expiresAt !== fields.expiresAt) {
+            throw bridgeError("JOURNAL_GRANT_CONFLICT", "Cube returned conflicting data for the same grant request.", false);
+        }
+        return existing;
+    }
+    async #ensureRoot() {
+        await mkdir(this.#rootDirectory, { recursive: true, mode: 0o700 });
+        if (process.platform !== "win32") {
+            await chmod(this.#rootDirectory, 0o700);
+        }
+    }
+    #pendingRecordPath(clientRequestId) {
+        return path.join(this.#rootDirectory, recordFileName(clientRequestId));
+    }
+    #issuedRecordPath(clientRequestId) {
+        return this.#pendingRecordPath(clientRequestId).replace(/\.json$/u, ".issued.json");
+    }
+    async #readRecord(clientRequestId) {
+        const issued = await this.#readRecordFile(clientRequestId, this.#issuedRecordPath(clientRequestId));
+        if (issued !== null) {
+            return issued;
+        }
+        return this.#readRecordFile(clientRequestId, this.#pendingRecordPath(clientRequestId));
+    }
+    async #readRecordFile(clientRequestId, recordPath) {
+        let serialized;
+        try {
+            serialized = await readFile(recordPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw bridgeError("JOURNAL_READ_FAILED", "The local grant journal could not be read.", true);
+        }
+        try {
+            const persisted = parsePersistedRecord(JSON.parse(serialized));
+            if (persisted.clientRequestId !== clientRequestId) {
+                throw new Error("record identity mismatch");
+            }
+            return persisted;
+        }
+        catch {
+            throw bridgeError("JOURNAL_CORRUPT", "The local grant journal is invalid.", false);
+        }
+    }
+    async #createRecord(record, recordPath) {
+        await this.#ensureRoot();
+        const temporaryPath = path.join(this.#rootDirectory, `.${path.basename(recordPath)}.${randomUUID()}.tmp`);
+        let handle;
+        try {
+            handle = await open(temporaryPath, "wx", 0o600);
+            await handle.writeFile(`${JSON.stringify(record)}\n`, "utf8");
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await link(temporaryPath, recordPath);
+            if (process.platform !== "win32") {
+                await chmod(recordPath, 0o600);
+            }
+            await this.#syncDirectory();
+            return true;
+        }
+        catch (error) {
+            await closeQuietly(handle);
+            if (error.code === "EEXIST") {
+                return false;
+            }
+            throw bridgeError("JOURNAL_WRITE_FAILED", "The local grant journal could not be saved.", true);
+        }
+        finally {
+            await unlink(temporaryPath).catch(() => undefined);
+        }
+    }
+    async #journalKey() {
+        this.#keyPromise ??= this.#loadOrCreateKey();
+        return this.#keyPromise;
+    }
+    async #existingJournalKey() {
+        if (this.#keyPromise !== undefined) {
+            return this.#keyPromise;
+        }
+        const keyPath = path.join(this.#rootDirectory, "journal.key");
+        try {
+            const existing = await readFile(keyPath);
+            if (existing.length !== 32) {
+                throw new Error("invalid key length");
+            }
+            this.#keyPromise = Promise.resolve(existing);
+            return existing;
+        }
+        catch {
+            throw bridgeError("JOURNAL_KEY_INVALID", "The local grant journal key is missing or invalid.", false);
+        }
+    }
+    async #loadOrCreateKey() {
+        await this.#ensureRoot();
+        const keyPath = path.join(this.#rootDirectory, "journal.key");
+        try {
+            const existing = await readFile(keyPath);
+            if (existing.length !== 32) {
+                throw new Error("invalid key length");
+            }
+            return existing;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw bridgeError("JOURNAL_KEY_INVALID", "The local grant journal key is invalid.", false);
+            }
+        }
+        const key = randomBytes(32);
+        const temporaryPath = path.join(this.#rootDirectory, `.journal.key.${randomUUID()}.tmp`);
+        let handle;
+        try {
+            handle = await open(temporaryPath, "wx", 0o600);
+            await handle.writeFile(key);
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await link(temporaryPath, keyPath);
+            if (process.platform !== "win32") {
+                await chmod(keyPath, 0o600);
+            }
+            await this.#syncDirectory();
+            return key;
+        }
+        catch (error) {
+            await closeQuietly(handle);
+            if (error.code === "EEXIST") {
+                const existing = await readFile(keyPath);
+                if (existing.length === 32) {
+                    return existing;
+                }
+            }
+            throw bridgeError("JOURNAL_KEY_WRITE_FAILED", "The local grant journal key could not be saved.", true);
+        }
+        finally {
+            await unlink(temporaryPath).catch(() => undefined);
+        }
+    }
+    async #encryptToken(clientRequestId, operationToken) {
+        const key = await this.#journalKey();
+        const nonce = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", key, nonce);
+        cipher.setAAD(Buffer.from(clientRequestId, "utf8"));
+        const ciphertext = Buffer.concat([
+            cipher.update(operationToken, "utf8"),
+            cipher.final(),
+        ]);
+        return {
+            algorithm: "aes-256-gcm",
+            nonce: nonce.toString("base64url"),
+            ciphertext: ciphertext.toString("base64url"),
+            tag: cipher.getAuthTag().toString("base64url"),
+        };
+    }
+    async #decryptToken(clientRequestId, encrypted) {
+        try {
+            const key = await this.#existingJournalKey();
+            const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(encrypted.nonce, "base64url"));
+            decipher.setAAD(Buffer.from(clientRequestId, "utf8"));
+            decipher.setAuthTag(Buffer.from(encrypted.tag, "base64url"));
+            return Buffer.concat([
+                decipher.update(Buffer.from(encrypted.ciphertext, "base64url")),
+                decipher.final(),
+            ]).toString("utf8");
+        }
+        catch (error) {
+            if (error instanceof OmniBridgeError) {
+                throw error;
+            }
+            throw bridgeError("JOURNAL_TOKEN_DECRYPT_FAILED", "The local operation token could not be recovered.", false);
+        }
+    }
+    #publicRecord(persisted, operationToken) {
+        return {
+            clientRequestId: persisted.clientRequestId,
+            requestHash: persisted.requestHash,
+            operationId: persisted.operationId,
+            operationToken,
+            uploadUrl: persisted.uploadUrl,
+            state: persisted.state,
+            createdAt: persisted.createdAt,
+            expiresAt: persisted.expiresAt,
+        };
+    }
+    async #syncDirectory() {
+        if (process.platform === "win32") {
+            return;
+        }
+        let directory;
+        try {
+            directory = await open(this.#rootDirectory, "r");
+            await directory.sync();
+        }
+        catch {
+            // File and key fsync still provide the primary durability guarantee.
+        }
+        finally {
+            await closeQuietly(directory);
+        }
+    }
+}