open-managed-agents 0.1.1 → 0.2.0

package/dist/src/control-plane/sessions/service.js

@@ -30,6 +30,7 @@ export class DefaultSessionService {
     startedAt = new Date().toISOString();
     deleteSessionRows;
     assertDeletable;
+    awaitDeletable;
     idempotencyLedger;
     createSessionRowsWithIdempotency;
     pendingSnapshotCleanupRetryDelayMs;
@@ -48,6 +49,7 @@ export class DefaultSessionService {
             throw new Error("DefaultSessionService requires assertDeletable for safe session deletion");
         }
         this.assertDeletable = opts.assertDeletable;
+        this.awaitDeletable = opts.awaitDeletable;
         this.maxActiveSessionsPerWorkspace = opts.maxActiveSessionsPerWorkspace;
         this.onAdmissionRejected = opts.onAdmissionRejected;
         this.modelAvailability = opts.modelAvailability;
@@ -348,6 +350,9 @@ export class DefaultSessionService {
         // Domain-owned liveness invariant: reject deleting a running session before
         // any row/file mutation, so no caller (route or internal) can tear down a
         // live runtime. Synchronous, so it runs in the same tick as the row removal.
+        // A session that already reported idle may still be collecting outputs;
+        // let that settle first so a client deleting after idle is not rejected.
+        await this.awaitDeletable?.(workspaceId, sessionId);
         this.assertDeletable(workspaceId, sessionId);
         const result = this.deleteSessionRows?.(workspaceId, sessionId) ??
             this.deleteSessionRowsWithDefaultStore(workspaceId, sessionId);

package/dist/src/control-plane/vaults/console-mcp-oauth.js

@@ -0,0 +1,545 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { auth, selectClientAuthMethod, } from "@modelcontextprotocol/sdk/client/auth.js";
+import { invalidRequest, notFound } from "../errors.js";
+export const CONSOLE_MCP_OAUTH_FLOW_TTL_MS = 10 * 60 * 1000;
+export const CONSOLE_MCP_OAUTH_MAX_BODY_BYTES = 64 * 1024;
+export class ConsoleMcpOauthService {
+    vaults;
+    fetch;
+    opts;
+    flows = new Map();
+    flowIdsByState = new Map();
+    constructor(vaults, fetch, opts = {}) {
+        this.vaults = vaults;
+        this.fetch = fetch;
+        this.opts = opts;
+    }
+    async startConnect(workspaceId, input, callbackUrl) {
+        const body = objectInput(input);
+        const vaultId = stringField(body, "vault_id");
+        const serverUrl = mcpServerUrl(stringField(body, "mcp_server_url"));
+        const displayName = optionalStringField(body, "display_name");
+        this.vaults.retrieveVault(workspaceId, vaultId);
+        return this.start({
+            workspaceId,
+            vaultId,
+            ...(displayName === undefined ? {} : { displayName }),
+            serverUrl,
+            callbackUrl,
+            operation: "connect",
+        });
+    }
+    async startReauthorize(workspaceId, input, callbackUrl) {
+        const body = objectInput(input);
+        const vaultId = stringField(body, "vault_id");
+        const credentialId = stringField(body, "credential_id");
+        const credential = this.vaults.retrieveCredential(workspaceId, vaultId, credentialId);
+        if (credential.archived_at !== null)
+            throw invalidRequest("Credential is archived.");
+        if (credential.auth.type !== "mcp_oauth") {
+            throw invalidRequest("Only MCP OAuth credentials can be reauthorized");
+        }
+        const oauth = this.vaults.readOauthValidationSnapshot(workspaceId, vaultId, credentialId);
+        if (oauth?.refresh === undefined) {
+            throw invalidRequest("This OAuth credential has no reusable client registration");
+        }
+        // Without the connect-time authorization server, a hostile MCP server
+        // could echo the stored token endpoint and take the redirect (#257).
+        if (oauth.refresh.authorizationServer === undefined) {
+            throw invalidRequest("This OAuth credential was connected before OMA recorded its authorization server. Delete it and connect again to reauthorize.");
+        }
+        return this.start({
+            workspaceId,
+            vaultId,
+            credentialId,
+            serverUrl: credential.auth.mcp_server_url,
+            callbackUrl,
+            operation: "reauthorize",
+            boundTokenEndpoint: oauth.refresh.tokenEndpoint,
+            boundAuthorizationServer: oauth.refresh.authorizationServer,
+            clientInformation: {
+                client_id: oauth.refresh.clientId,
+                ...(oauth.secrets.clientSecret === undefined
+                    ? {}
+                    : { client_secret: oauth.secrets.clientSecret }),
+            },
+        });
+    }
+    status(workspaceId, flowId) {
+        const flow = this.flowForWorkspace(workspaceId, flowId);
+        this.expire(flow);
+        return publicStatus(flow);
+    }
+    deny(state) {
+        const flow = this.consumeCallbackState(state);
+        flow.status = "failed";
+        flow.error = {
+            code: "authorization_denied",
+            message: "Authorization was denied or cancelled at the provider.",
+        };
+        flow.provider.clearSecrets();
+        return { flowId: flow.id, ok: false };
+    }
+    async complete(state, code) {
+        const flow = this.consumeCallbackState(state);
+        if (!code) {
+            flow.status = "failed";
+            flow.error = {
+                code: "callback_invalid",
+                message: "The provider callback did not include an authorization code.",
+            };
+            return { flowId: flow.id, ok: false };
+        }
+        flow.status = "completing";
+        let safetyFailure;
+        try {
+            const result = await auth(flow.provider, {
+                serverUrl: flow.serverUrl,
+                authorizationCode: code,
+                fetchFn: this.oauthFetch((error) => { safetyFailure = error; }),
+            });
+            if (result !== "AUTHORIZED" || flow.provider.savedTokens === undefined) {
+                throw new Error("OAuth token exchange did not produce tokens");
+            }
+            flow.credential = this.persist(flow, flow.provider.savedTokens);
+            flow.status = "connected";
+        }
+        catch (error) {
+            flow.status = "failed";
+            flow.error = safetyFailure ?? classifyOauthError(error, "token_exchange_failed");
+        }
+        finally {
+            flow.provider.clearSecrets();
+        }
+        return { flowId: flow.id, ok: flow.status === "connected" };
+    }
+    async start(input) {
+        this.cleanup();
+        const now = this.now();
+        const flowId = opaqueId("oauth_flow");
+        const state = opaqueId("oauth_state");
+        const provider = new FlowProvider({
+            redirectUrl: input.callbackUrl,
+            state,
+            clientInformation: input.clientInformation,
+            boundTokenEndpoint: input.boundTokenEndpoint,
+            boundAuthorizationServer: input.boundAuthorizationServer,
+        });
+        const flow = {
+            id: flowId,
+            state,
+            workspaceId: input.workspaceId,
+            vaultId: input.vaultId,
+            ...(input.credentialId === undefined ? {} : { credentialId: input.credentialId }),
+            ...(input.displayName === undefined ? {} : { displayName: input.displayName }),
+            serverUrl: input.serverUrl,
+            redirectUrl: input.callbackUrl,
+            operation: input.operation,
+            createdAtMs: now.getTime(),
+            expiresAtMs: now.getTime() + (this.opts.flowTtlMs ?? CONSOLE_MCP_OAUTH_FLOW_TTL_MS),
+            status: "pending",
+            provider,
+        };
+        this.flows.set(flowId, flow);
+        this.flowIdsByState.set(state, flowId);
+        let safetyFailure;
+        try {
+            const result = await auth(provider, {
+                serverUrl: input.serverUrl,
+                fetchFn: this.oauthFetch((error) => { safetyFailure = error; }),
+            });
+            if (result !== "REDIRECT" || provider.authorizationUrl === undefined) {
+                throw new Error("OAuth provider did not return an authorization redirect");
+            }
+            return {
+                flow_id: flow.id,
+                authorization_url: provider.authorizationUrl.toString(),
+                expires_at: new Date(flow.expiresAtMs).toISOString(),
+            };
+        }
+        catch (error) {
+            this.flowIdsByState.delete(state);
+            provider.clearSecrets();
+            flow.status = "failed";
+            flow.error = safetyFailure ?? classifyOauthError(error, "provider_unsupported");
+            throw invalidRequest(flow.error.message);
+        }
+    }
+    oauthFetch(onSafetyFailure) {
+        return boundedOauthFetch(this.fetch, {
+            timeoutMs: this.opts.operationTimeoutMs ?? 30_000,
+            maxBodyBytes: this.opts.maxBodyBytes ?? CONSOLE_MCP_OAUTH_MAX_BODY_BYTES,
+        }, onSafetyFailure);
+    }
+    persist(flow, tokens) {
+        const client = flow.provider.savedClientInformation;
+        const discovery = flow.provider.savedDiscoveryState;
+        const tokenEndpoint = discovery?.authorizationServerMetadata?.token_endpoint;
+        const refreshToken = tokens.refresh_token;
+        const clientId = client?.client_id;
+        const expiresAt = tokens.expires_in === undefined
+            ? undefined
+            : new Date(this.now().getTime() + tokens.expires_in * 1000).toISOString();
+        try {
+            if (flow.operation === "reauthorize") {
+                return this.vaults.updateCredential(flow.workspaceId, flow.vaultId, flow.credentialId, {
+                    auth: {
+                        type: "mcp_oauth",
+                        access_token: tokens.access_token,
+                        expires_at: expiresAt ?? null,
+                        ...(refreshToken === undefined
+                            ? {}
+                            : { refresh: { refresh_token: refreshToken } }),
+                    },
+                });
+            }
+            const canRefresh = refreshToken !== undefined && clientId !== undefined && tokenEndpoint !== undefined;
+            const authType = client === undefined
+                ? "none"
+                : selectClientAuthMethod(client, discovery?.authorizationServerMetadata?.token_endpoint_auth_methods_supported ?? []);
+            return this.vaults.createCredential(flow.workspaceId, flow.vaultId, {
+                ...(flow.displayName === undefined ? {} : { display_name: flow.displayName }),
+                auth: {
+                    type: "mcp_oauth",
+                    mcp_server_url: flow.serverUrl,
+                    access_token: tokens.access_token,
+                    ...(expiresAt === undefined ? {} : { expires_at: expiresAt }),
+                    ...(canRefresh
+                        ? {
+                            refresh: {
+                                token_endpoint: tokenEndpoint,
+                                client_id: clientId,
+                                ...(tokens.scope === undefined ? {} : { scope: tokens.scope }),
+                                refresh_token: refreshToken,
+                                token_endpoint_auth: {
+                                    type: authType,
+                                    ...(client?.client_secret === undefined
+                                        ? {}
+                                        : { client_secret: client.client_secret }),
+                                },
+                            },
+                        }
+                        : {}),
+                },
+            }, discovery?.authorizationServerUrl === undefined
+                ? {}
+                : { oauthAuthorizationServer: discovery.authorizationServerUrl });
+        }
+        catch (error) {
+            throw Object.assign(new Error("OAuth completed, but OMA could not save the credential"), {
+                cause: error,
+                oauthPersistenceFailure: true,
+            });
+        }
+    }
+    consumeCallbackState(state) {
+        if (!state)
+            throw invalidRequest("The OAuth callback state is missing");
+        const flowId = this.flowIdsByState.get(state);
+        if (flowId === undefined)
+            throw invalidRequest("The OAuth callback is unknown or was already used");
+        const flow = this.flows.get(flowId);
+        if (flow === undefined || !safeEqual(state, flow.state)) {
+            throw invalidRequest("The OAuth callback is unknown or was already used");
+        }
+        this.flowIdsByState.delete(state);
+        if (this.expire(flow)) {
+            flow.error = {
+                code: "callback_expired",
+                message: "The OAuth connection expired. Start Connect again.",
+            };
+            throw invalidRequest(flow.error.message);
+        }
+        if (flow.status !== "pending") {
+            throw invalidRequest("The OAuth callback is unknown or was already used");
+        }
+        return flow;
+    }
+    flowForWorkspace(workspaceId, flowId) {
+        const flow = this.flows.get(flowId);
+        if (flow === undefined || flow.workspaceId !== workspaceId) {
+            throw notFound(`OAuth flow ${flowId} not found`);
+        }
+        return flow;
+    }
+    expire(flow) {
+        if (flow.status === "pending" && this.now().getTime() >= flow.expiresAtMs) {
+            this.flowIdsByState.delete(flow.state);
+            flow.provider.clearSecrets();
+            flow.status = "expired";
+            flow.error = {
+                code: "callback_expired",
+                message: "The OAuth connection expired. Start Connect again.",
+            };
+            return true;
+        }
+        return flow.status === "expired";
+    }
+    cleanup() {
+        const cutoff = this.now().getTime() - (this.opts.flowTtlMs ?? CONSOLE_MCP_OAUTH_FLOW_TTL_MS);
+        for (const [id, flow] of this.flows) {
+            this.expire(flow);
+            if (flow.expiresAtMs < cutoff)
+                this.flows.delete(id);
+        }
+    }
+    now() {
+        return this.opts.now?.() ?? new Date();
+    }
+}
+class FlowProvider {
+    input;
+    authorizationUrl;
+    savedClientInformation;
+    savedTokens;
+    savedCodeVerifier;
+    savedDiscoveryState;
+    clientMetadata;
+    constructor(input) {
+        this.input = input;
+        this.savedClientInformation = input.clientInformation;
+        this.clientMetadata = {
+            redirect_uris: [input.redirectUrl],
+            client_name: "Open Managed Agents",
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        };
+    }
+    get redirectUrl() {
+        return this.input.redirectUrl;
+    }
+    state() {
+        return this.input.state;
+    }
+    clientInformation() {
+        return this.savedClientInformation;
+    }
+    saveClientInformation(value) {
+        this.savedClientInformation = value;
+    }
+    tokens() {
+        return undefined;
+    }
+    saveTokens(value) {
+        this.savedTokens = value;
+    }
+    redirectToAuthorization(url) {
+        this.authorizationUrl = url;
+    }
+    saveCodeVerifier(value) {
+        this.savedCodeVerifier = value;
+    }
+    codeVerifier() {
+        if (this.savedCodeVerifier === undefined)
+            throw new Error("PKCE verifier is missing");
+        return this.savedCodeVerifier;
+    }
+    // The MCP server picks the authorization server, so on reauthorize a
+    // hostile or compromised server could point the stored client secret at
+    // its own token endpoint (GHSA-6qxp-vccf-f47h). Stored credentials carry no
+    // SDK issuer stamp, so bind to the token endpoint saved at connect time:
+    // the only place the SDK sends the secret, and to the authorization server
+    // recorded at connect, so a server echoing the token endpoint cannot take
+    // the browser redirect (code injection, #257). The SDK saves discovery
+    // state before the redirect and before any token request.
+    saveDiscoveryState(value) {
+        const bound = this.input.boundTokenEndpoint;
+        const tokenEndpoint = value.authorizationServerMetadata?.token_endpoint;
+        const boundServer = this.input.boundAuthorizationServer;
+        if ((bound !== undefined && (tokenEndpoint === undefined || !sameUrl(tokenEndpoint, bound))) ||
+            (boundServer !== undefined && !sameUrl(value.authorizationServerUrl, boundServer))) {
+            throw Object.assign(new Error("OAuth authorization server changed since this credential was connected"), {
+                oauthAuthorizationServerChanged: true,
+            });
+        }
+        this.savedDiscoveryState = value;
+    }
+    discoveryState() {
+        return this.savedDiscoveryState;
+    }
+    clearSecrets() {
+        this.savedTokens = undefined;
+        this.savedCodeVerifier = undefined;
+        if (this.savedClientInformation?.client_secret !== undefined) {
+            const { client_secret: _discarded, ...clientInformation } = this.savedClientInformation;
+            this.savedClientInformation = clientInformation;
+        }
+    }
+}
+function publicStatus(flow) {
+    const oauth = flow.credential?.auth.type === "mcp_oauth" ? flow.credential.auth : undefined;
+    return {
+        flow_id: flow.id,
+        status: flow.status,
+        expires_at: new Date(flow.expiresAtMs).toISOString(),
+        ...(flow.credential === undefined ? {} : { credential_id: flow.credential.id }),
+        ...(oauth === undefined ? {} : { refreshable: oauth.refresh !== undefined }),
+        ...(flow.error === undefined ? {} : { error: flow.error }),
+    };
+}
+function classifyOauthError(error, fallback) {
+    if (isObject(error) && error.oauthAuthorizationServerChanged === true) {
+        return {
+            code: "authorization_server_changed",
+            message: "The MCP server now names a different authorization server than when this credential was connected. Delete the credential and connect again if the change is expected.",
+        };
+    }
+    if (isObject(error) && error.oauthPersistenceFailure === true) {
+        return {
+            code: "credential_persist_failed",
+            message: "Authorization succeeded, but OMA could not save the credential.",
+        };
+    }
+    const message = error instanceof Error ? error.message.toLowerCase() : "";
+    if (message.includes("registration endpoint") ||
+        message.includes("client information") ||
+        message.includes("dynamic client registration")) {
+        return {
+            code: "provider_unsupported",
+            message: "This MCP provider does not support automatic client registration. A pre-registered client is not supported in this console flow yet.",
+        };
+    }
+    if (message.includes("fetch failed") ||
+        message.includes("timeout") ||
+        message.includes("aborted") ||
+        message.includes("egress denied") ||
+        message.includes("response too large")) {
+        return {
+            code: "provider_unreachable",
+            message: "OMA could not safely reach the MCP authorization service.",
+        };
+    }
+    return fallback === "provider_unsupported"
+        ? {
+            code: fallback,
+            message: "This MCP server did not expose a supported OAuth authorization flow.",
+        }
+        : {
+            code: fallback,
+            message: "The provider could not complete the OAuth token exchange. Start Connect again.",
+        };
+}
+function boundedOauthFetch(inner, opts, onSafetyFailure) {
+    return async (url, init = {}) => {
+        const timeout = new AbortController();
+        const timer = setTimeout(() => {
+            onSafetyFailure(oauthFetchSafetyFailure());
+            timeout.abort();
+        }, opts.timeoutMs);
+        const signal = init.signal == null
+            ? timeout.signal
+            : AbortSignal.any([init.signal, timeout.signal]);
+        try {
+            const response = await inner(url, { ...init, signal });
+            const declared = Number(response.headers.get("content-length"));
+            if (Number.isFinite(declared) && declared > opts.maxBodyBytes) {
+                await response.body?.cancel();
+                onSafetyFailure(oauthFetchSafetyFailure());
+                throw new Error("OAuth response too large");
+            }
+            let bytes;
+            try {
+                bytes = await readBoundedBody(response, opts.maxBodyBytes);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === "OAuth response too large") {
+                    onSafetyFailure(oauthFetchSafetyFailure());
+                }
+                throw error;
+            }
+            return new Response(bytes, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+}
+function oauthFetchSafetyFailure() {
+    return {
+        code: "provider_unreachable",
+        message: "OMA could not safely reach the MCP authorization service.",
+    };
+}
+async function readBoundedBody(response, maxBodyBytes) {
+    if (response.body === null)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBodyBytes)
+                throw new Error("OAuth response too large");
+            chunks.push(value);
+        }
+    }
+    catch (error) {
+        await reader.cancel().catch(() => undefined);
+        throw error;
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function opaqueId(prefix) {
+    return `${prefix}_${randomBytes(24).toString("base64url")}`;
+}
+function safeEqual(left, right) {
+    const a = Buffer.from(left);
+    const b = Buffer.from(right);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+function mcpServerUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            throw new Error();
+        if (url.username || url.password || url.hash)
+            throw new Error();
+        return url.toString();
+    }
+    catch {
+        throw invalidRequest("`mcp_server_url` must be an http(s) URL without userinfo or a fragment");
+    }
+}
+function objectInput(input) {
+    if (!isObject(input))
+        throw invalidRequest("Request body must be a JSON object");
+    return input;
+}
+function stringField(input, field) {
+    const value = input[field];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw invalidRequest(`\`${field}\` must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalStringField(input, field) {
+    if (input[field] === undefined)
+        return undefined;
+    return stringField(input, field);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameUrl(a, b) {
+    try {
+        return new URL(a).href === new URL(b).href;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/control-plane/vaults/service.js

@@ -70,7 +70,7 @@ export class DefaultVaultService {
         }
         return { id: vaultId, type: "vault_deleted" };
     }
-    createCredential(workspaceId, vaultId, input) {
+    createCredential(workspaceId, vaultId, input, internal = {}) {
         const vault = this.store.retrieveVault(workspaceId, vaultId);
         if (!vault)
             throw notFound(`Vault ${vaultId} not found`);
@@ -96,6 +96,9 @@ export class DefaultVaultService {
                     archived_at: null,
                 },
                 token: req.secretValue,
+                ...(req.auth.type === "mcp_oauth" && internal.oauthAuthorizationServer !== undefined
+                    ? { oauthAuthorizationServer: internal.oauthAuthorizationServer }
+                    : {}),
                 nextRefreshAt: oauthSchedule(new Date(now), req.auth, req.auth.type === "mcp_oauth" && req.auth.refresh !== undefined),
             }));
             if (req.auth.type === "mcp_oauth" && req.auth.refresh !== undefined) {

package/dist/src/control-plane/vaults/store.js

@@ -28,6 +28,7 @@ CREATE TABLE IF NOT EXISTS vault_credentials (
   client_id       TEXT,
   scope           TEXT,
   token_endpoint_auth_type TEXT,
+  oauth_authorization_server TEXT,
   expires_at      TEXT,
   auth_version    INTEGER NOT NULL DEFAULT 1,
   refresh_status  TEXT,
@@ -95,8 +96,9 @@ export class SqliteVaultStore {
         this.insertCredentialStmt = this.db.prepare(`INSERT INTO vault_credentials (
         id, workspace_id, vault_id, type, display_name, metadata, auth_type,
         mcp_server_url, token_endpoint, client_id, scope, token_endpoint_auth_type,
+        oauth_authorization_server,
         expires_at, auth_version, next_refresh_at, created_at, updated_at, archived_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
         this.retrieveCredentialActiveStmt = this.db.prepare(`SELECT * FROM vault_credentials
        WHERE workspace_id = ? AND vault_id = ? AND id = ? AND archived_at IS NULL`);
         this.retrieveCredentialAnyStmt = this.db.prepare(`SELECT * FROM vault_credentials
@@ -249,7 +251,7 @@ export class SqliteVaultStore {
             this.requireSecrets().put(c.workspace_id, secretName(c.vault_id, c.id), record.token);
             this.insertCredentialStmt.run(c.id, c.workspace_id, c.vault_id, c.type, c.display_name, JSON.stringify(c.metadata), c.auth.type, c.auth.mcp_server_url, c.auth.type === "mcp_oauth" ? c.auth.refresh?.token_endpoint ?? null : null, c.auth.type === "mcp_oauth" ? c.auth.refresh?.client_id ?? null : null, c.auth.type === "mcp_oauth" ? c.auth.refresh?.scope ?? null : null, c.auth.type === "mcp_oauth"
                 ? c.auth.refresh?.token_endpoint_auth.type ?? null
-                : null, c.auth.type === "mcp_oauth" ? c.auth.expires_at ?? null : null, c.auth_version, record.nextRefreshAt ?? null, c.created_at, c.updated_at, c.archived_at);
+                : null, record.oauthAuthorizationServer ?? null, c.auth.type === "mcp_oauth" ? c.auth.expires_at ?? null : null, c.auth_version, record.nextRefreshAt ?? null, c.created_at, c.updated_at, c.archived_at);
             return c;
         });
     }
@@ -470,6 +472,9 @@ export class SqliteVaultStore {
                 : {
                     refresh: {
                         tokenEndpoint: auth.refresh.token_endpoint,
+                        ...(row.oauth_authorization_server === null
+                            ? {}
+                            : { authorizationServer: row.oauth_authorization_server }),
                         clientId: auth.refresh.client_id,
                         ...(auth.refresh.scope === undefined
                             ? {}
@@ -660,6 +665,7 @@ function ensureVaultCredentialColumns(db) {
         ["client_id", "TEXT"],
         ["scope", "TEXT"],
         ["token_endpoint_auth_type", "TEXT"],
+        ["oauth_authorization_server", "TEXT"],
         ["expires_at", "TEXT"],
         ["auth_version", "INTEGER NOT NULL DEFAULT 1"],
         ["refresh_status", "TEXT"],

package/dist/src/main.js

@@ -50,7 +50,7 @@ export async function startAppliance(env = process.env, opts = {}) {
     const resolved = resolveApplianceEnv(env);
     const port = parseAppliancePort(resolved.OMA_PORT);
     const host = resolved.OMA_HOST ?? "127.0.0.1";
-    const plane = createDeploymentControlPlane(resolved, {
+    const plane = await createDeploymentControlPlane(resolved, {
         ...(opts.onboarding === undefined ? {} : { consoleBootstrap: opts.onboarding.bootstrap }),
     });
     const { app, stores, authMode } = plane;