@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/server/connector-runtime.js

@@ -5,6 +5,7 @@ import { ActionPolicyService } from "../core/action-policy.js";
 import { setEgressTrustedHosts, setPrivateNetworkAccessAllowed } from "../core/request.js";
 import { ProviderLoader } from "../providers/provider-loader.js";
 import { executorModules } from "../providers/registry.generated.js";
+import { DEFAULT_OAUTH_CLOSE_DELAY_SECONDS } from "./api/oauth-completion-page.js";
 import { createRuntimeJwtVerifier } from "./api/runtime-jwt.js";
 import { createConnectApp } from "./connect-app.js";
 import { getConnectorAssetDirectory } from "./connector-assets.js";
@@ -48,6 +49,9 @@ async function openRuntime(options) {
         throw new Error("transitFiles.ttlSeconds must be a positive number of seconds.");
     if (!Number.isFinite(maxBytes) || maxBytes <= 0)
         throw new Error("transitFiles.maxBytes must be a positive number.");
+    const oauthCloseDelaySeconds = options.oauthCloseDelaySeconds ?? DEFAULT_OAUTH_CLOSE_DELAY_SECONDS;
+    if (!Number.isInteger(oauthCloseDelaySeconds) || oauthCloseDelaySeconds < 0)
+        throw new Error("oauthCloseDelaySeconds must be a non-negative integer of seconds.");
     const assetDirectory = getConnectorAssetDirectory();
     const assets = options.assets ?? {
         catalogDir: join(assetDirectory, "catalog/apps"),
@@ -104,13 +108,15 @@ async function openRuntime(options) {
         const tempDir = join(dataDir, "tmp/transit-files");
         await transitFiles.cleanupExpired();
         await cleanupStagedTransitFiles(tempDir, ttlSeconds * 1000);
-        const { app, runtimeAuthConfigured } = await createConnectApp({
+        const { app, runtimeAuthConfigured, saasCleanup, triggerMaintenance } = await createConnectApp({
             catalog,
             providerLoader: new ProviderLoader(executorModules),
+            providerHttpDispatch: options.providerHttpDispatch,
             runtimeDatabase: database,
             transitFiles,
             uploadTransitFile: createNodeTransitFileUpload({ transitFiles, tempDir }),
             publicOrigin,
+            configuredOrigin: options.publicOriginConfigured === false ? undefined : publicOrigin,
             secretCodec,
             adminToken: options.adminToken,
             runtimeToken: options.runtimeToken,
@@ -119,7 +125,10 @@ async function openRuntime(options) {
             allowedCustomOAuth: options.allowedCustomOAuth,
             logger: options.logger,
             serveDocumentation: options.apiReference ?? false,
+            oauthCloseDelaySeconds,
         });
+        saasCleanup.start();
+        triggerMaintenance.start();
         const shutdown = new AbortController();
         const pending = new Set();
         let closing;
@@ -142,7 +151,7 @@ async function openRuntime(options) {
                 if (!closing) {
                     closing = Promise.resolve().then(async () => {
                         shutdown.abort(new Error("Open Connector runtime is closing."));
-                        await Promise.allSettled([...pending]);
+                        await Promise.allSettled([...pending, saasCleanup.close(), triggerMaintenance.close()]);
                         try {
                             await database.close();
                         }

package/src/server/files/node-transit-file-upload.js

@@ -41,7 +41,11 @@ async function stageMultipartFile(request, path, maxBytes) {
         parser = Busboy({
             headers: { "content-type": contentType },
             defParamCharset: "utf8",
-            limits: { fields: 0, files: 1, parts: 2, fileSize: maxBytes },
+            // Busboy flags truncation when its counter *reaches* its limit, so give it
+            // one byte of headroom and judge the bytes actually written below. This
+            // also rejects an over-limit file under a fractional limit, where the
+            // counter never equals the limit and `truncated` would stay false.
+            limits: { fields: 0, files: 1, parts: 2, fileSize: maxBytes + 1 },
         });
     }
     catch {
@@ -62,13 +66,13 @@ async function stageMultipartFile(request, path, maxBytes) {
         }
         const writer = createWriteStream(path, { flags: "wx" });
         staged = pipeline(stream, writer).then(() => {
-            if (stream.truncated) {
+            if (writer.bytesWritten > maxBytes) {
                 throw new TransitFileError(413, "file_too_large", `Transit file must be ${maxBytes} bytes or smaller.`);
             }
             return {
                 path,
                 sizeBytes: writer.bytesWritten,
-                name: info.filename,
+                name: info.filename ?? "",
                 mimeType: info.mimeType,
             };
         });

package/src/server/files/transit-file-store.js

@@ -52,11 +52,15 @@ export function uploadResult(publicOrigin, fileId, info) {
  * ASCII-only form for clients that do not read `filename*`.
  */
 export function contentDispositionForFileName(name) {
-    const asciiName = name.replace(/[^\u0020-\u007e]/gu, "_").replace(/["\\]/g, "_");
-    if (!/[\u0080-\u{10ffff}]/u.test(name)) {
+    // Metadata written before the write-time repair (or supplied by a caller)
+    // can still hold an unpaired surrogate. `encodeURIComponent` throws on it,
+    // which would fail every download for the whole lifetime of the file.
+    const repaired = name.toWellFormed();
+    const asciiName = repaired.replace(/[^\u0020-\u007e]/gu, "_").replace(/["\\]/g, "_");
+    if (!/[\u0080-\u{10ffff}]/u.test(repaired)) {
         return `attachment; filename="${asciiName}"`;
     }
-    return `attachment; filename="${asciiName}"; filename*=UTF-8''${encodeExtendedValue(name)}`;
+    return `attachment; filename="${asciiName}"; filename*=UTF-8''${encodeExtendedValue(repaired)}`;
 }
 /** Percent-encode a file name as an RFC 8187 `ext-value`, which allows fewer literals than a URI component. */
 function encodeExtendedValue(name) {
@@ -144,7 +148,9 @@ export function metadataKey(fileId) {
 /** Trim a stored name and MIME type, substituting the matching fallback for a missing or blank value. */
 export function normalizeDescriptor(input, fallback = { name: "file", mimeType: "application/octet-stream" }) {
     return {
-        name: typeof input.name === "string" && input.name.trim() ? input.name.trim() : fallback.name,
+        // Repair unpaired UTF-16 surrogates at the storage boundary so every
+        // backend and every later reader sees a well-formed name.
+        name: typeof input.name === "string" && input.name.trim() ? input.name.trim().toWellFormed() : fallback.name,
         mimeType: typeof input.mimeType === "string" && input.mimeType.trim() ? input.mimeType.trim() : fallback.mimeType,
     };
 }

package/src/server/files/transit-files.d.ts

@@ -11,6 +11,9 @@ export declare class TransitFileService implements IStagedTransitFileService {
     private readonly publicOrigin;
     private readonly ttlMs;
     readonly maxBytes: number;
+    private sweeping;
+    private followUp;
+    private lastSweepAt;
     constructor(options: TransitFileOptions);
     create(file: File): Promise<TransitFileUpload>;
     createFromStream(file: TransitFileStream): Promise<TransitFileUpload>;
@@ -18,7 +21,22 @@ export declare class TransitFileService implements IStagedTransitFileService {
     read(fileId: string): Promise<TransitFileRead>;
     response(fileId: string): Promise<Response>;
     delete(fileId: string): Promise<boolean>;
+    /**
+     * Remove expired files and their side-cars. One sweep runs at a time (a
+     * caller arriving mid-sweep shares it), and the directory is walked in
+     * bounded batches, so its size never turns into that many concurrent
+     * filesystem requests on the heap.
+     */
     cleanupExpired(): Promise<void>;
+    private startSweep;
+    /**
+     * The write path's sweep: at most one every {@link sweepIntervalMs}, never
+     * awaited. Sweeping on every write made each upload walk the whole
+     * directory, so concurrent downloads into a store holding a day of files
+     * queued hundreds of thousands of `stat` calls and exhausted the heap.
+     */
+    private sweepIfDue;
+    private sweep;
     /** Resolve a live, unexpired file on disk together with its side-car metadata, or report it as missing. */
     private locate;
     private readMetadata;

package/src/server/files/transit-files.js

@@ -1,14 +1,21 @@
 import { createReadStream, createWriteStream } from "node:fs";
-import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir, opendir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { assertFileSize, assertSafeFileId, contentTypeFromFileId, isSafeFileId, normalizeDescriptor, randomHex, safeExtension, TransitFileError, transitFileRead, transitFileResponse, uploadResult, } from "./transit-file-store.js";
+/** How often the write path may start a sweep of expired transit files. */
+const sweepIntervalMs = 60_000;
+/** How many directory entries a sweep stats at once. */
+const sweepConcurrency = 64;
 export class TransitFileService {
     rootDir;
     publicOrigin;
     ttlMs;
     maxBytes;
+    sweeping;
+    followUp;
+    lastSweepAt = Number.NEGATIVE_INFINITY;
     constructor(options) {
         this.rootDir = options.rootDir;
         this.publicOrigin = options.publicOrigin;
@@ -29,7 +36,8 @@ export class TransitFileService {
         });
         try {
             file.signal?.throwIfAborted();
-            await this.cleanupExpired();
+            this.sweepIfDue();
+            await mkdir(this.rootDir, { recursive: true });
             const sizeBytes = await this.writeStream(file, tempPath);
             file.signal?.throwIfAborted();
             await writeFile(metadataPath(path), JSON.stringify(metadata), { flag: "wx", signal: file.signal });
@@ -47,7 +55,7 @@ export class TransitFileService {
     }
     async createFromPath(file) {
         assertFileSize(file.sizeBytes, this.maxBytes);
-        await this.cleanupExpired();
+        this.sweepIfDue();
         await mkdir(this.rootDir, { recursive: true });
         const fileId = `${randomHex(16)}${safeExtension(file.name)}`;
         const path = join(this.rootDir, fileId);
@@ -82,21 +90,74 @@ export class TransitFileService {
             return false;
         }
     }
-    async cleanupExpired() {
+    /**
+     * Remove expired files and their side-cars. One sweep runs at a time (a
+     * caller arriving mid-sweep shares it), and the directory is walked in
+     * bounded batches, so its size never turns into that many concurrent
+     * filesystem requests on the heap.
+     */
+    cleanupExpired() {
+        if (this.sweeping) {
+            // The running sweep may have read the directory before this call:
+            // run one more after it, shared by every caller that arrives meanwhile.
+            if (!this.followUp) {
+                const next = () => {
+                    this.followUp = undefined;
+                    return this.startSweep();
+                };
+                this.followUp = this.sweeping.then(next, next);
+            }
+            return this.followUp;
+        }
+        return this.startSweep();
+    }
+    startSweep() {
+        if (this.sweeping) {
+            return this.sweeping;
+        }
+        this.lastSweepAt = Date.now();
+        this.sweeping = this.sweep().finally(() => {
+            this.sweeping = undefined;
+        });
+        return this.sweeping;
+    }
+    /**
+     * The write path's sweep: at most one every {@link sweepIntervalMs}, never
+     * awaited. Sweeping on every write made each upload walk the whole
+     * directory, so concurrent downloads into a store holding a day of files
+     * queued hundreds of thousands of `stat` calls and exhausted the heap.
+     */
+    sweepIfDue() {
+        if (this.sweeping || Date.now() - this.lastSweepAt < sweepIntervalMs) {
+            return;
+        }
+        void this.cleanupExpired().catch(() => undefined);
+    }
+    async sweep() {
         await mkdir(this.rootDir, { recursive: true });
         const cutoff = Date.now() - this.ttlMs;
-        const entries = await readdir(this.rootDir, { withFileTypes: true });
-        await Promise.all(entries.map(async (entry) => {
+        let batch = [];
+        const flush = async () => {
+            await Promise.all(batch.map(async (name) => {
+                const path = join(this.rootDir, name);
+                const stats = await stat(path).catch(() => undefined);
+                if (stats && stats.mtimeMs < cutoff) {
+                    await unlink(path).catch(() => undefined);
+                    await unlink(metadataPath(path)).catch(() => undefined);
+                }
+            }));
+            batch = [];
+        };
+        for await (const entry of await opendir(this.rootDir)) {
             if (!entry.isFile() || !isManagedFileName(entry.name)) {
-                return;
+                continue;
             }
-            const path = join(this.rootDir, entry.name);
-            const stats = await stat(path).catch(() => undefined);
-            if (stats && stats.mtimeMs < cutoff) {
-                await unlink(path).catch(() => undefined);
-                await unlink(metadataPath(path)).catch(() => undefined);
+            batch.push(entry.name);
+            if (batch.length >= sweepConcurrency) {
+                await flush();
             }
-        }));
+        }
+        await flush();
     }
     /** Resolve a live, unexpired file on disk together with its side-car metadata, or report it as missing. */
     async locate(fileId) {
@@ -130,13 +191,22 @@ export class TransitFileService {
     async writeStream(file, tempPath) {
         let sizeBytes = 0;
         const maxBytes = this.maxBytes;
-        await pipeline(Readable.fromWeb(file.body), async function* (source) {
-            for await (const chunk of source) {
-                sizeBytes += chunk.byteLength;
-                assertFileSize(sizeBytes, maxBytes);
-                yield chunk;
-            }
-        }, createWriteStream(tempPath, { flags: "wx" }), { signal: file.signal });
+        const source = Readable.fromWeb(file.body);
+        const destination = createWriteStream(tempPath, { flags: "wx" });
+        // Pipeline can reject while the file is still opening. Wait for close before unlinking it.
+        const closed = new Promise((resolve) => destination.once("close", resolve));
+        try {
+            await pipeline(source, async function* (source) {
+                for await (const chunk of source) {
+                    sizeBytes += chunk.byteLength;
+                    assertFileSize(sizeBytes, maxBytes);
+                    yield chunk;
+                }
+            }, destination, { signal: file.signal });
+        }
+        finally {
+            await closed;
+        }
         return sizeBytes;
     }
 }

package/src/server/proxy/proxy-runner.d.ts

@@ -1,19 +1,24 @@
 import type { CatalogStore } from "../../catalog-store.ts";
 import type { ConnectionService } from "../../connection-service.ts";
 import type { ActionPolicySnapshot } from "../../core/action-policy.ts";
+import type { ProviderHttpDispatchOptions } from "../../core/provider-http-dispatch.ts";
 import type { RuntimeLogger, ProxyResponse } from "../../core/types.ts";
 import type { IProviderLoader } from "../../providers/provider-loader.ts";
-export type ProxyFailureStatus = 400 | 402 | 403 | 404 | 409 | 413 | 429 | 500 | 501;
+import type { SaasExecutionService } from "../../saas/saas-execution-service.ts";
+export type ProxyFailureStatus = 400 | 402 | 403 | 404 | 409 | 413 | 429 | 500 | 501 | 502 | 503 | 504;
 export interface ProxyRunnerOptions {
+    providerHttpDispatch?: ProviderHttpDispatchOptions;
     catalog: CatalogStore;
     providerLoader: IProviderLoader;
     connections: ConnectionService;
     logger?: RuntimeLogger;
+    saas?: SaasExecutionService;
 }
 export interface RunProxyInput {
     service: string;
     input: unknown;
     connectionName?: string;
+    connectionId?: string;
     policy: ActionPolicySnapshot;
     /** Cancellation signal from the HTTP request, handed to the provider proxy executor. */
     signal?: AbortSignal;
@@ -21,6 +26,7 @@ export interface RunProxyInput {
 export type ProxyRunResult = {
     ok: true;
     response: ProxyResponse;
+    meta?: Record<string, unknown>;
 } | ProxyRunFailure;
 export interface ProxyRunFailure {
     ok: false;
@@ -34,6 +40,7 @@ export declare class ProxyRunner {
     private readonly options;
     constructor(options: ProxyRunnerOptions);
     run(input: RunProxyInput): Promise<ProxyRunResult>;
+    private runProxy;
     private readProxyRequestInput;
     private assertRelativeEndpoint;
     private hasPathTraversalSegment;

package/src/server/proxy/proxy-runner.js

@@ -1,5 +1,8 @@
 import { ConnectionError } from "../../connection-service.js";
 import { optionalInteger, optionalRecord, requiredRecord, requiredString } from "../../core/cast.js";
+import { withProviderHttpDispatch } from "../../core/provider-http-dispatch.js";
+import { ProviderDispatchRequestError, toProviderExecutionError, withProviderHttpDispatchResult, } from "../../providers/provider-runtime.js";
+import { SaasError } from "../../saas/saas-client.js";
 import { mapConnectionErrorStatus } from "../api/runtime-api.js";
 class ProxyInputError extends Error {
 }
@@ -10,6 +13,10 @@ export class ProxyRunner {
         this.options = options;
     }
     async run(input) {
+        const provider = this.options.catalog.providers.find((candidate) => candidate.service === input.service);
+        return withProviderHttpDispatch({ operation: "proxy", service: provider?.service }, () => this.runProxy(input), this.options.providerHttpDispatch);
+    }
+    async runProxy(input) {
         const provider = this.options.catalog.providers.find((candidate) => candidate.service === input.service);
         if (!provider) {
             return {
@@ -30,29 +37,6 @@ export class ProxyRunner {
                 meta: { service: provider.service },
             };
         }
-        let executor;
-        try {
-            executor = await this.options.providerLoader.loadProxyExecutor(provider.service, provider.displayName);
-        }
-        catch {
-            this.options.logger?.warn({ service: provider.service, errorCode: "internal_error" }, "proxy request failed");
-            return {
-                ok: false,
-                status: 500,
-                errorCode: "internal_error",
-                message: "Proxy request failed unexpectedly.",
-                meta: { service: provider.service },
-            };
-        }
-        if (!executor) {
-            return {
-                ok: false,
-                status: 501,
-                errorCode: "proxy_not_supported",
-                message: `Proxy execution is not supported for ${provider.service}.`,
-                meta: { service: provider.service },
-            };
-        }
         const request = this.readProxyRequestInput(input.input);
         if (!request.ok) {
             return request;
@@ -64,8 +48,9 @@ export class ProxyRunner {
             connectionName: input.connectionName,
         };
         const startedAtMs = Date.now();
+        let executionId;
         try {
-            const connection = await this.options.connections.getConnectionSummary(provider.service, input.connectionName);
+            const connection = await this.options.connections.getConnectionSummary(provider.service, input.connectionName, input.connectionId);
             const connectionDecision = connection?.authType === "no_auth" ? undefined : input.policy.evaluateConnection(connection?.id);
             if (connectionDecision && !connectionDecision.allowed) {
                 return {
@@ -76,12 +61,65 @@ export class ProxyRunner {
                     meta: { service: provider.service },
                 };
             }
+            const target = await this.options.connections.resolveForExecution(provider.service, input.connectionName, input.connectionId);
+            const targetDecision = target.summary?.authType === "no_auth" ? undefined : input.policy.evaluateConnection(target.summary?.id);
+            if (targetDecision && !targetDecision.allowed)
+                return {
+                    ok: false,
+                    status: 403,
+                    errorCode: targetDecision.code,
+                    message: targetDecision.message,
+                    meta: { service: provider.service },
+                };
             this.options.logger?.info(logContext, "proxy request started");
-            const credentials = this.options.connections.forConnection(input.connectionName);
-            const result = await executor(request.input, {
-                getCredential: credentials.getCredential,
+            if (target.kind === "saas") {
+                executionId = crypto.randomUUID();
+                input.signal?.throwIfAborted();
+                if (!this.options.saas)
+                    throw new SaasError("oauth_source_unavailable", "SaaS execution is unavailable.", 503);
+                const { alias: _alias, connectionName: _connectionName, ...remoteRequest } = optionalRecord(input.input);
+                remoteRequest.method = request.input.method;
+                const remote = await this.options.saas.executeProxy(target.reference, provider.service, remoteRequest, input.signal);
+                input.signal?.throwIfAborted();
+                this.options.logger?.info({
+                    ...logContext,
+                    executionId,
+                    remoteExecutionId: remote.executionId,
+                    durationMs: Date.now() - startedAtMs,
+                    status: remote.response.status,
+                }, "proxy request completed");
+                return {
+                    ok: true,
+                    response: remote.response,
+                    meta: { service: provider.service, executionId, remoteExecutionId: remote.executionId },
+                };
+            }
+            if (target.kind === "marketplace")
+                return {
+                    ok: false,
+                    status: 501,
+                    errorCode: "proxy_not_supported",
+                    message: "Marketplace connections do not support proxy execution.",
+                    meta: { service: provider.service },
+                };
+            const executor = await this.options.providerLoader.loadProxyExecutor(provider.service, provider.displayName);
+            if (!executor)
+                return {
+                    ok: false,
+                    status: 501,
+                    errorCode: "proxy_not_supported",
+                    message: `Proxy execution is not supported for ${provider.service}.`,
+                    meta: { service: provider.service },
+                };
+            const result = await withProviderHttpDispatchResult({
+                operation: "proxy",
+                service: provider.service,
+                connectionId: target.summary?.id,
+                connectionName: target.summary?.connectionName,
+            }, () => executor(request.input, {
+                getCredential: target.getCredential,
                 signal: input.signal,
-            });
+            }), this.options.providerHttpDispatch);
             const durationMs = Date.now() - startedAtMs;
             if (result.ok) {
                 this.options.logger?.info({ ...logContext, durationMs, status: result.response.status }, "proxy request completed");
@@ -103,6 +141,35 @@ export class ProxyRunner {
         }
         catch (error) {
             const durationMs = Date.now() - startedAtMs;
+            if (executionId && input.signal?.aborted)
+                return {
+                    ok: false,
+                    status: 400,
+                    errorCode: "execution_cancelled",
+                    message: "Proxy execution was cancelled.",
+                    meta: { service: provider.service, executionId },
+                };
+            if (error instanceof SaasError) {
+                this.options.logger?.warn({ ...logContext, durationMs, executionId, errorCode: error.code, remoteExecutionId: error.remoteExecutionId }, "proxy request failed");
+                return {
+                    ok: false,
+                    status: error.status,
+                    errorCode: error.code,
+                    message: error.message,
+                    data: error.retryAfter ? { details: { retryAfter: error.retryAfter } } : undefined,
+                    meta: { service: provider.service, executionId, remoteExecutionId: error.remoteExecutionId },
+                };
+            }
+            if (error instanceof ProviderDispatchRequestError) {
+                return {
+                    ok: false,
+                    status: 429,
+                    errorCode: "rate_limited",
+                    message: error.message,
+                    data: toProviderExecutionError(error, error.message).error?.details,
+                    meta: { service: provider.service },
+                };
+            }
             if (error instanceof ConnectionError) {
                 const missingConnectionDecision = error.code === "connection_not_found" ? input.policy.evaluateConnection() : undefined;
                 if (missingConnectionDecision && !missingConnectionDecision.allowed) {

package/src/server/storage/connection-request-store.d.ts

@@ -1,4 +1,4 @@
-import type { StoredConnection } from "../../connection-service.ts";
+import type { StoredConnection, StoredSaasConnection } from "../../connection-service.ts";
 import type { ResolvedCredential } from "../../core/types.ts";
 import type { OAuthAuthorizationState } from "../../oauth/oauth-flow-service.ts";
 import type { ISecretCodec } from "../secrets/secret-codec-core.ts";
@@ -26,6 +26,35 @@ export interface RequestStatement {
     sql: string;
     values: (string | number | null)[];
 }
+export interface PendingSaasRequest {
+    connectionRequestId: string;
+    connectionId: string;
+    owner: string;
+    service: string;
+    connectionName: string;
+    managedProjectId: string;
+    providerConfigId: string;
+    externalUserId: string;
+    createdAt: string;
+    expiresAt: string;
+    returnUri?: string;
+    target?: Pick<StoredConnection, "id" | "revision">;
+    comment?: string | null;
+}
+export interface SaasRequestLease {
+    pending: PendingSaasRequest;
+    leaseId: string;
+    phase: "creating" | "pending" | "candidate";
+    remoteRequestId: string | null;
+    candidate?: SaasCandidate;
+    pollAttempts: number;
+}
+export interface SaasCandidate {
+    connectedAccountId: string;
+    profile: StoredSaasConnection["profile"];
+    status: StoredSaasConnection["status"];
+    comment: string | null;
+}
 /** Executes all statements atomically; each result contains its RETURNING/SELECT rows. */
 export type RequestTransaction = (statements: RequestStatement[]) => Promise<RuntimeRow[][]>;
 /** Shared SQL lifecycle for SQLite, PostgreSQL and D1. Secrets use the runtime's codec. */
@@ -38,4 +67,15 @@ export declare class ConnectionRequestStore {
     claim(state: string): Promise<PendingConnectionRequest | undefined>;
     fail(id: string, errorCode: string, errorMessage: string): Promise<void>;
     complete(pending: PendingConnectionRequest, credential: ResolvedCredential, signal?: AbortSignal): Promise<string | undefined>;
+    private retireRequests;
+    createSaas(pending: PendingSaasRequest): Promise<SaasRequestLease>;
+    claimSaas(id: string, owner: string, now?: number): Promise<SaasRequestLease | undefined>;
+    saveSaasRequest(lease: SaasRequestLease, remoteRequestId: string, expiresAt?: string): Promise<boolean>;
+    saveSaasCandidate(lease: SaasRequestLease, candidate: SaasCandidate): Promise<boolean>;
+    releaseSaas(lease: SaasRequestLease, nextPollAt: number, failed?: boolean): Promise<boolean>;
+    failSaas(lease: SaasRequestLease, code: string, message: string): Promise<boolean>;
+    getSaasReturnUri(id: string, owner: string): Promise<string | undefined>;
+    cancelSaas(id: string, owner: string): Promise<void>;
+    expireSaas(now?: number): Promise<void>;
+    completeSaas(lease: SaasRequestLease): Promise<"connected" | "conflict" | "lease_lost">;
 }