codex-multi-auth 2.17.0 → 2.17.3

package/dist/lib/env-parsing.d.ts

@@ -18,4 +18,16 @@
  * @returns `true`/`false` for recognised literals, otherwise `undefined`.
  */
 export declare function parseBooleanEnv(value: string | undefined): boolean | undefined;
-//# sourceMappingURL=env-parsing.d.ts.map
+/**
+ * Parses an integer environment-variable string.
+ *
+ * Returns `undefined` for `undefined` input, an empty/whitespace-only string,
+ * or any value that does not start with a parseable integer — letting callers
+ * fall back through nullish coalescing to their default. Matches the semantics
+ * of the local `parseEnvInt` copies in lib/refresh-lease.ts and
+ * lib/request/failover-config.ts.
+ *
+ * @param value - Raw env-variable value (or `undefined` when unset).
+ * @returns The parsed integer, otherwise `undefined`.
+ */
+export declare function parseIntegerEnv(value: string | undefined): number | undefined;

package/dist/lib/env-parsing.js

@@ -31,3 +31,24 @@ export function parseBooleanEnv(value) {
         return false;
     return undefined;
 }
+/**
+ * Parses an integer environment-variable string.
+ *
+ * Returns `undefined` for `undefined` input, an empty/whitespace-only string,
+ * or any value that does not start with a parseable integer — letting callers
+ * fall back through nullish coalescing to their default. Matches the semantics
+ * of the local `parseEnvInt` copies in lib/refresh-lease.ts and
+ * lib/request/failover-config.ts.
+ *
+ * @param value - Raw env-variable value (or `undefined` when unset).
+ * @returns The parsed integer, otherwise `undefined`.
+ */
+export function parseIntegerEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/lib/errors.d.ts

@@ -134,4 +134,3 @@ export declare class CodexUnavailableError extends CodexError {
  * boundaries by also matching on the structural `code` marker.
  */
 export declare function isCodexUnavailableError(error: unknown): error is CodexUnavailableError;
-//# sourceMappingURL=errors.d.ts.map

package/dist/lib/forecast.d.ts

@@ -80,4 +80,3 @@ export declare function recommendForecastAccount(results: ForecastAccountResult[
 export declare function summarizeForecast(results: ForecastAccountResult[]): ForecastSummary;
 export declare function buildForecastExplanation(results: ForecastAccountResult[], recommendation: ForecastRecommendation): ForecastExplanation;
 export {};
-//# sourceMappingURL=forecast.d.ts.map

package/dist/lib/fs-retry.d.ts

@@ -47,4 +47,3 @@ export declare function withRetry<T>(operation: () => Promise<T> | T, options: R
  */
 export declare function withRetrySync<T>(operation: () => T, options: RetryOptions): T;
 export declare function withFileOperationRetry<T>(operation: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=fs-retry.d.ts.map

package/dist/lib/health.d.ts

@@ -31,4 +31,3 @@ export declare function getAccountHealth(accounts: Array<{
     lastUsedAt?: number;
 }>, now?: number): PluginHealth;
 export declare function formatHealthReport(health: PluginHealth): string;
-//# sourceMappingURL=health.d.ts.map

package/dist/lib/index.d.ts

@@ -41,4 +41,3 @@ export * from "./local-bridge.js";
 export * from "./local-client-tokens.js";
 export * from "./integration-generators.js";
 export * from "./temp-path.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/integration-generators.d.ts

@@ -11,4 +11,3 @@ export interface IntegrationSnippet {
 }
 export declare function generateIntegrationSnippet(kind: IntegrationSnippetKind, input?: IntegrationSnippetInput): IntegrationSnippet;
 export declare function generateIntegrationSnippets(kinds?: IntegrationSnippetKind[], input?: IntegrationSnippetInput): IntegrationSnippet[];
-//# sourceMappingURL=integration-generators.d.ts.map

package/dist/lib/live-account-sync.d.ts

@@ -36,4 +36,3 @@ export declare class LiveAccountSync {
     private pollOnce;
     private runReload;
 }
-//# sourceMappingURL=live-account-sync.d.ts.map

package/dist/lib/local-bridge.d.ts

@@ -22,4 +22,3 @@ export interface LocalBridgeOptions {
     runtimeClientApiKey?: string;
 }
 export declare function startLocalBridge(options: LocalBridgeOptions): Promise<LocalBridgeServer>;
-//# sourceMappingURL=local-bridge.d.ts.map

package/dist/lib/local-bridge.js

@@ -195,10 +195,13 @@ export async function startLocalBridge(options) {
         throw new Error("Local bridge requires requireAuth=true when runtimeClientApiKey is configured.");
     }
     const app = new Hono();
+    // Deliberately minimal payload: /health is reachable without a bearer (it is
+    // the liveness probe), so it must not echo runtimeBaseUrl back — that value
+    // describes where the bridge forwards local client tokens and is internal
+    // routing detail, not something to hand unauthenticated callers.
     app.get("/health", (context) => context.json({
         ok: true,
         service: "codex-multi-auth-local-bridge",
-        runtimeBaseUrl,
     }));
     const forward = async (request, targetPath) => {
         const startedAt = Date.now();

package/dist/lib/local-client-tokens.d.ts

@@ -34,4 +34,3 @@ export declare function rotateLocalClientToken(input: {
 export declare function revokeLocalClientToken(id: string, now?: number): Promise<boolean>;
 export declare function verifyLocalClientBearerToken(authorizationHeader: string | null, now?: number): Promise<LocalClientTokenRecord | null>;
 export declare function resetLocalClientTokenWriteQueueForTests(): void;
-//# sourceMappingURL=local-client-tokens.d.ts.map

package/dist/lib/local-client-tokens.js

@@ -1,10 +1,11 @@
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { existsSync, promises as fs } from "node:fs";
 import { basename, join } from "node:path";
 import { logWarn } from "./logger.js";
 import { getCodexMultiAuthDir } from "./runtime-paths.js";
 import { isRecord, sleep } from "./utils.js";
 import { tempPathFor } from "./temp-path.js";
+import { assertJsonStoreFileMtimeUnchanged, getJsonStoreFileMtimeMs, withJsonStoreCasRetry, withJsonStoreFileLock, } from "./storage/json-store-lock.js";
 const TOKEN_FILE_NAME = "local-client-tokens.json";
 const TOKEN_PREFIX = "cma_local";
 // Debounce window for persisting a record's lastUsedAt. Bearer verification is
@@ -43,6 +44,27 @@ function normalizeLabel(value) {
 function hashToken(token) {
     return `sha256:${createHash("sha256").update(token).digest("hex")}`;
 }
+/**
+ * Constant-time equality for two `sha256:<hex>` token hashes.
+ *
+ * A `===` on the hex strings returns early at the first differing byte, so a
+ * local process that can spam verify calls could measure the comparison cost
+ * and recover a stored hash prefix byte-by-byte. Comparing the decoded digest
+ * bytes with timingSafeEqual removes the oracle; both inputs are validated to
+ * the fixed 32-byte shape first, so timingSafeEqual never throws.
+ */
+function sha256DigestBytes(hash) {
+    if (!/^sha256:[0-9a-f]{64}$/i.test(hash))
+        return null;
+    return Buffer.from(hash.slice("sha256:".length), "hex");
+}
+function tokenHashEqual(left, right) {
+    const leftDigest = sha256DigestBytes(left);
+    const rightDigest = sha256DigestBytes(right);
+    return (leftDigest !== null &&
+        rightDigest !== null &&
+        timingSafeEqual(leftDigest, rightDigest));
+}
 function createPlainToken() {
     return `${TOKEN_PREFIX}_${randomBytes(32).toString("base64url")}`;
 }
@@ -120,7 +142,46 @@ export async function loadLocalClientTokenStore() {
         return emptyStore();
     }
 }
-async function writeStoreToDisk(store) {
+/**
+ * Merge a caller-supplied store over the freshest on-disk store by token id.
+ * Records the caller does not carry are preserved (this store is append-only:
+ * rotation and revocation mark records in place, nothing deletes them), and
+ * the monotone fields a concurrent process may have advanced — `lastUsedAt`
+ * from verifies, `revokedAt` from revocations/rotations — are kept at their
+ * furthest value so a stale snapshot cannot un-revoke or rewind usage.
+ */
+function mergeTokenStoreRecords(current, incoming) {
+    const indexById = new Map();
+    const tokens = current.tokens.map((record, index) => {
+        indexById.set(record.id, index);
+        return record;
+    });
+    for (const record of incoming.tokens) {
+        const index = indexById.get(record.id);
+        if (index === undefined) {
+            indexById.set(record.id, tokens.length);
+            tokens.push(record);
+            continue;
+        }
+        const existing = tokens[index];
+        if (existing === undefined) {
+            // Unreachable: indexes recorded in indexById always point at a
+            // slot that exists in `tokens`.
+            continue;
+        }
+        tokens[index] = {
+            ...record,
+            lastUsedAt: record.lastUsedAt === null
+                ? existing.lastUsedAt
+                : existing.lastUsedAt === null
+                    ? record.lastUsedAt
+                    : Math.max(record.lastUsedAt, existing.lastUsedAt),
+            revokedAt: record.revokedAt ?? existing.revokedAt,
+        };
+    }
+    return { version: 1, tokens };
+}
+async function writeStoreToDisk(store, expectedMtimeMs) {
     const path = getLocalClientTokenPath();
     const payload = normalizeStore(store);
     const dir = getCodexMultiAuthDir();
@@ -153,6 +214,12 @@ async function writeStoreToDisk(store) {
         finally {
             await handle.close();
         }
+        // Compare-and-swap guard: a writer that did not take the lockfile (or an
+        // expired-lock takeover racing this write) moved the target's mtime; abort
+        // with ESTALE so the caller reloads and re-merges instead of clobbering.
+        if (expectedMtimeMs !== undefined) {
+            await assertJsonStoreFileMtimeUnchanged(path, expectedMtimeMs);
+        }
         for (let attempt = 0; attempt < 5; attempt += 1) {
             try {
                 await fs.rename(tempPath, path);
@@ -177,8 +244,36 @@ async function writeStoreToDisk(store) {
         }
     }
 }
+/**
+ * Run a token-store read→mutate→write inside the write queue (in-process
+ * serialization) AND the cross-process lock directory, with mtime CAS retry:
+ * every attempt re-stats the file, re-reads the freshest on-disk store, and
+ * re-applies `mutate` before writing — so an op whose snapshot raced a
+ * concurrent process's write reloads-and-retries rather than clobbering it.
+ * `mutate` must be re-appliable across retries (apply precomputed work onto
+ * the store it is handed, don't capture mutated state).
+ */
+async function updateLocalClientTokenStore(mutate) {
+    const path = getLocalClientTokenPath();
+    return enqueue(() => withJsonStoreFileLock(path, () => withJsonStoreCasRetry(async () => {
+        const expectedMtimeMs = await getJsonStoreFileMtimeMs(path);
+        const store = await loadLocalClientTokenStore();
+        const { result, dirty } = mutate(store);
+        if (dirty) {
+            await writeStoreToDisk(store, expectedMtimeMs);
+        }
+        return result;
+    })));
+}
 export async function saveLocalClientTokenStore(store) {
-    await enqueue(() => writeStoreToDisk(store));
+    const path = getLocalClientTokenPath();
+    const incoming = normalizeStore(store);
+    await enqueue(() => withJsonStoreFileLock(path, () => withJsonStoreCasRetry(async () => {
+        const expectedMtimeMs = await getJsonStoreFileMtimeMs(path);
+        const current = await loadLocalClientTokenStore();
+        const merged = mergeTokenStoreRecords(current, incoming);
+        await writeStoreToDisk(merged, expectedMtimeMs);
+    })));
 }
 export function createLocalClientTokenRecord(input = {}) {
     const plainToken = createPlainToken();
@@ -194,40 +289,40 @@ export function createLocalClientTokenRecord(input = {}) {
     return { plainToken, record };
 }
 export async function addLocalClientToken(input = {}) {
-    return enqueue(async () => {
-        const store = await loadLocalClientTokenStore();
-        const created = createLocalClientTokenRecord(input);
+    // The token record is created once, outside the CAS retry: re-applying the
+    // same record onto a freshly-reloaded store is what makes each retry safe.
+    const created = createLocalClientTokenRecord(input);
+    return updateLocalClientTokenStore((store) => {
         store.tokens.push(created.record);
-        await writeStoreToDisk(store);
-        return created;
+        return { result: created, dirty: true };
     });
 }
 export async function rotateLocalClientToken(input) {
-    return enqueue(async () => {
-        const store = await loadLocalClientTokenStore();
+    const now = input.now ?? Date.now();
+    let created = null;
+    return updateLocalClientTokenStore((store) => {
         const existing = store.tokens.find((record) => record.id === input.id);
-        if (!existing || existing.revokedAt !== null)
-            return null;
-        const now = input.now ?? Date.now();
+        if (!existing || existing.revokedAt !== null) {
+            return { result: null, dirty: false };
+        }
         existing.revokedAt = now;
-        const created = createLocalClientTokenRecord({
+        // Same record across CAS retries so a retry cannot mint a second token.
+        created ??= createLocalClientTokenRecord({
             label: input.label ?? existing.label,
             now,
         });
         store.tokens.push(created.record);
-        await writeStoreToDisk(store);
-        return created;
+        return { result: created, dirty: true };
     });
 }
 export async function revokeLocalClientToken(id, now = Date.now()) {
-    return enqueue(async () => {
-        const store = await loadLocalClientTokenStore();
+    return updateLocalClientTokenStore((store) => {
         const existing = store.tokens.find((record) => record.id === id);
-        if (!existing || existing.revokedAt !== null)
-            return false;
+        if (!existing || existing.revokedAt !== null) {
+            return { result: false, dirty: false };
+        }
         existing.revokedAt = now;
-        await writeStoreToDisk(store);
-        return true;
+        return { result: true, dirty: true };
     });
 }
 export async function verifyLocalClientBearerToken(authorizationHeader, now = Date.now()) {
@@ -236,11 +331,10 @@ export async function verifyLocalClientBearerToken(authorizationHeader, now = Da
     if (!token)
         return null;
     const tokenHash = hashToken(token);
-    return enqueue(async () => {
-        const store = await loadLocalClientTokenStore();
-        const record = store.tokens.find((entry) => entry.revokedAt === null && entry.tokenHash === tokenHash);
+    return updateLocalClientTokenStore((store) => {
+        const record = store.tokens.find((entry) => entry.revokedAt === null && tokenHashEqual(entry.tokenHash, tokenHash));
         if (!record)
-            return null;
+            return { result: null, dirty: false };
         // Token match (verification correctness) is decided above and never
         // depends on lastUsedAt. Always advance lastUsedAt in-memory so callers
         // see a fresh value, but only flush to disk when it has not been
@@ -249,10 +343,11 @@ export async function verifyLocalClientBearerToken(authorizationHeader, now = Da
         // recent usage on a coarse (>=60s) cadence.
         const persisted = record.lastUsedAt;
         record.lastUsedAt = now;
-        if (persisted === null || now - persisted >= LAST_USED_PERSIST_THRESHOLD_MS) {
-            await writeStoreToDisk(store);
-        }
-        return record;
+        return {
+            result: record,
+            dirty: persisted === null ||
+                now - persisted >= LAST_USED_PERSIST_THRESHOLD_MS,
+        };
     });
 }
 export function resetLocalClientTokenWriteQueueForTests() {

package/dist/lib/logger.d.ts

@@ -45,4 +45,3 @@ export interface ScopedLogger {
 export declare function createLogger(scope: string): ScopedLogger;
 export declare function getRequestId(): number;
 export { formatDuration, maskEmail, maskString, maskToken, sanitizeValue };
-//# sourceMappingURL=logger.d.ts.map

package/dist/lib/logger.js

@@ -21,7 +21,17 @@ const TOKEN_PATTERNS = [
     // line of defense and must recognize the project's own token shape too.
     /cma_local_[A-Za-z0-9_-]{16,}/g,
 ];
-const EMAIL_PATTERN = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+// Label-shaped domain instead of `[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`: letting `.`
+// live inside the quantified class makes every dot a candidate split point,
+// which backtracked quadratically (~3.5s) on dotted near-miss input. Labels
+// are dot-free, so each dot has exactly one structural role.
+// The `(?<!...)` lookbehind confines match starts to a run boundary: the
+// unanchored pattern could otherwise begin inside an overlong local part or
+// domain label and leave its leading/trailing edge visible in logs. Interior
+// positions fail the lookbehind in O(1), which is also what keeps the
+// unbounded quantifiers linear — each character run is scanned once from its
+// edge instead of being rescanned from every offset.
+const EMAIL_PATTERN = /(?<![a-zA-Z0-9._%+-])[a-zA-Z0-9._%+-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*\.[a-zA-Z]{2,}/g;
 const SENSITIVE_KEYS = new Set([
     "access",
     "accesstoken",

package/dist/lib/model-capability-matrix.d.ts

@@ -35,4 +35,3 @@ export declare function buildModelCapabilityMatrix(input: {
     quotaCache?: QuotaCacheData | null;
     now?: number;
 }): ModelCapabilityMatrix;
-//# sourceMappingURL=model-capability-matrix.d.ts.map

package/dist/lib/model-route-policy.d.ts

@@ -44,9 +44,8 @@ export declare function modelEntitlements(model: RouteModel): {
     reasoningLevels: string[];
     accessPrograms: string[];
     probes?: {
-        [k: string]: "unsupported" | "verified" | "unverified" | "downgraded";
+        [k: string]: "verified" | "unsupported" | "unverified" | "downgraded";
     } | undefined;
     checkedAt?: number | undefined;
     model: string;
 };
-//# sourceMappingURL=model-route-policy.d.ts.map

package/dist/lib/named-backup-export.d.ts

@@ -66,4 +66,3 @@ export declare function resolveNamedBackupPath(name: string, storagePath: string
 export declare function exportNamedBackupFile(name: string, dependencies: NamedBackupExportDependencies, options?: {
     force?: boolean;
 }): Promise<string>;
-//# sourceMappingURL=named-backup-export.d.ts.map

package/dist/lib/oauth-success.html

@@ -1,126 +1,126 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>Codex Sign-In Complete</title>
-  <style>
-    :root {
-      color-scheme: dark;
-      --bg: #0b0b0b;
-      --panel: #111111;
-      --text: #f2f2f2;
-      --muted: #a3a3a3;
-      --line: #232323;
-      --ok: #7cf0a6;
-    }
-
-    * {
-      box-sizing: border-box;
-    }
-
-    body {
-      margin: 0;
-      min-height: 100vh;
-      display: grid;
-      place-items: center;
-      background: var(--bg);
-      color: var(--text);
-      font-family: "Geist Mono", "GeistMono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
-      padding: 24px;
-    }
-
-    main {
-      width: min(520px, 100%);
-      background: var(--panel);
-      border: 1px solid var(--line);
-      border-radius: 12px;
-      padding: 20px;
-      display: grid;
-      gap: 14px;
-    }
-
-    h1 {
-      margin: 0;
-      font-size: 20px;
-      font-weight: 600;
-      letter-spacing: -0.02em;
-    }
-
-    p {
-      margin: 0;
-      color: var(--muted);
-      font-size: 14px;
-      line-height: 1.5;
-    }
-
-    .status {
-      display: inline-flex;
-      align-items: center;
-      gap: 8px;
-      color: var(--ok);
-      font-size: 13px;
-    }
-
-    .dot {
-      width: 8px;
-      height: 8px;
-      border-radius: 50%;
-      background: currentColor;
-    }
-
-    dl {
-      margin: 0;
-      display: grid;
-      grid-template-columns: 120px 1fr;
-      gap: 8px 12px;
-      font-size: 13px;
-    }
-
-    dt {
-      color: var(--muted);
-    }
-
-    dd {
-      margin: 0;
-      color: var(--text);
-      word-break: break-word;
-    }
-
-    code {
-      background: #171717;
-      border: 1px solid var(--line);
-      border-radius: 6px;
-      padding: 2px 6px;
-      font-family: inherit;
-      font-size: 12px;
-    }
-
-    @media (max-width: 520px) {
-      dl {
-        grid-template-columns: 1fr;
-      }
-    }
-  </style>
-</head>
-<body>
-  <main role="main" aria-label="OAuth callback received">
-    <h1>Sign-in complete</h1>
-    <p>Return to your terminal to finish Codex login.</p>
-
-    <div class="status" aria-live="polite">
-      <span class="dot" aria-hidden="true"></span>
-      Callback received
-    </div>
-
-    <dl>
-      <dt>Endpoint</dt>
-      <dd><code>localhost:1455</code></dd>
-      <dt>Flow</dt>
-      <dd>OAuth callback captured</dd>
-      <dt>Next</dt>
-      <dd>Close this tab and continue in terminal</dd>
-    </dl>
-  </main>
-</body>
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Codex Sign-In Complete</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --bg: #0b0b0b;
+      --panel: #111111;
+      --text: #f2f2f2;
+      --muted: #a3a3a3;
+      --line: #232323;
+      --ok: #7cf0a6;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: grid;
+      place-items: center;
+      background: var(--bg);
+      color: var(--text);
+      font-family: "Geist Mono", "GeistMono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+      padding: 24px;
+    }
+
+    main {
+      width: min(520px, 100%);
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: 12px;
+      padding: 20px;
+      display: grid;
+      gap: 14px;
+    }
+
+    h1 {
+      margin: 0;
+      font-size: 20px;
+      font-weight: 600;
+      letter-spacing: -0.02em;
+    }
+
+    p {
+      margin: 0;
+      color: var(--muted);
+      font-size: 14px;
+      line-height: 1.5;
+    }
+
+    .status {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      color: var(--ok);
+      font-size: 13px;
+    }
+
+    .dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: currentColor;
+    }
+
+    dl {
+      margin: 0;
+      display: grid;
+      grid-template-columns: 120px 1fr;
+      gap: 8px 12px;
+      font-size: 13px;
+    }
+
+    dt {
+      color: var(--muted);
+    }
+
+    dd {
+      margin: 0;
+      color: var(--text);
+      word-break: break-word;
+    }
+
+    code {
+      background: #171717;
+      border: 1px solid var(--line);
+      border-radius: 6px;
+      padding: 2px 6px;
+      font-family: inherit;
+      font-size: 12px;
+    }
+
+    @media (max-width: 520px) {
+      dl {
+        grid-template-columns: 1fr;
+      }
+    }
+  </style>
+</head>
+<body>
+  <main role="main" aria-label="OAuth callback received">
+    <h1>Sign-in complete</h1>
+    <p>Return to your terminal to finish Codex login.</p>
+
+    <div class="status" aria-live="polite">
+      <span class="dot" aria-hidden="true"></span>
+      Callback received
+    </div>
+
+    <dl>
+      <dt>Endpoint</dt>
+      <dd><code>localhost:1455</code></dd>
+      <dt>Flow</dt>
+      <dd>OAuth callback captured</dd>
+      <dt>Next</dt>
+      <dd>Close this tab and continue in terminal</dd>
+    </dl>
+  </main>
+</body>
 </html>

package/dist/lib/oc-chatgpt-import-adapter.d.ts

@@ -61,4 +61,3 @@ export declare function previewOcChatgptImportMerge(options: {
     destination: AccountStorageV3 | null;
 }): OcChatgptMergePreview;
 export {};
-//# sourceMappingURL=oc-chatgpt-import-adapter.d.ts.map

package/dist/lib/oc-chatgpt-orchestrator.d.ts

@@ -83,4 +83,3 @@ export type RunNamedBackupExportResult = {
 };
 export declare function runNamedBackupExport(options: RunNamedBackupExportOptions): Promise<RunNamedBackupExportResult>;
 export {};
-//# sourceMappingURL=oc-chatgpt-orchestrator.d.ts.map