open-managed-agents 0.1.0

package/dist/src/control-plane/vaults/oauth-refresh-ticker.js

@@ -0,0 +1,43 @@
+import { createWakeLoop } from "../wake-loop.js";
+export const OAUTH_TICKER_BATCH_SIZE = 50;
+export const OAUTH_TICKER_CONCURRENCY = 5;
+export const OAUTH_TICKER_MAX_SLEEP_MS = 15 * 60_000;
+export const OAUTH_TICKER_MIN_SLEEP_MS = 30_000;
+export function createOauthRefreshTicker(opts) {
+    const now = opts.now ?? (() => new Date());
+    return createWakeLoop({
+        nextWakeAt: () => {
+            const next = opts.store.nextDueRefreshAt(now().toISOString());
+            return next === null ? null : new Date(next);
+        },
+        run: async () => {
+            const due = opts.store.listDueRefreshes(now().toISOString(), OAUTH_TICKER_BATCH_SIZE);
+            await mapConcurrent(due, OAUTH_TICKER_CONCURRENCY, async (credential) => {
+                await refreshDue(opts.refresh, credential);
+            });
+        },
+        maxSleepMs: OAUTH_TICKER_MAX_SLEEP_MS,
+        minSleepMs: OAUTH_TICKER_MIN_SLEEP_MS,
+        onError: opts.onError,
+        now: () => now().getTime(),
+    });
+}
+function refreshDue(refresh, credential) {
+    return refresh.refreshCredential({
+        workspaceId: credential.workspaceId,
+        vaultId: credential.vaultId,
+        credentialId: credential.credentialId,
+        expectedAuthVersion: credential.authVersion,
+    });
+}
+async function mapConcurrent(values, concurrency, visit) {
+    let index = 0;
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+        while (index < values.length) {
+            const value = values[index];
+            index += 1;
+            if (value !== undefined)
+                await visit(value);
+        }
+    }));
+}

package/dist/src/control-plane/vaults/oauth-refresh.js

@@ -0,0 +1,448 @@
+import { Buffer } from "node:buffer";
+export const OAUTH_REFRESH_TIMEOUT_MS = 30_000;
+export const OAUTH_REFRESH_MAX_BODY_BYTES = 64 * 1024;
+export const OAUTH_REFRESH_LEAD_MS = 5 * 60_000;
+export const OAUTH_REFRESH_FLOOR_MS = 30_000;
+export const OAUTH_REFRESH_MAX_BACKOFF_MS = 15 * 60_000;
+export const OAUTH_REFRESH_LONG_LIVED_RECHECK_MS = 15 * 60_000;
+export const OAUTH_FORCED_REFRESH_FLOOR_MS = 60_000;
+export const OAUTH_VALIDATE_REFRESH_FLOOR_MS = 10_000;
+const PERMANENT_OAUTH_ERRORS = new Set([
+    "invalid_grant",
+    "invalid_refresh_token",
+    "invalid_client",
+    "unauthorized_client",
+    "invalid_scope",
+    "unsupported_grant_type",
+]);
+export class RefreshCoordinator {
+    opts;
+    inflight = new Map();
+    forcedAdmissions = new Map();
+    validateAdmissions = new Map();
+    fetchImpl;
+    now;
+    timeoutMs;
+    maxBodyBytes;
+    random;
+    constructor(opts) {
+        this.opts = opts;
+        this.fetchImpl = opts.fetch;
+        this.now = opts.now ?? (() => new Date());
+        this.timeoutMs = opts.timeoutMs ?? OAUTH_REFRESH_TIMEOUT_MS;
+        this.maxBodyBytes = opts.maxBodyBytes ?? OAUTH_REFRESH_MAX_BODY_BYTES;
+        this.random = opts.random ?? Math.random;
+    }
+    refreshCredential(input) {
+        const key = `${input.workspaceId}\0${input.vaultId}\0${input.credentialId}`;
+        const existing = this.inflight.get(key);
+        if (existing)
+            return existing;
+        const admittedAt = this.now().getTime();
+        const forcedKey = `${key}\0${input.expectedAuthVersion ?? "unversioned"}`;
+        pruneAdmissions(this.forcedAdmissions, admittedAt, OAUTH_FORCED_REFRESH_FLOOR_MS);
+        pruneAdmissions(this.validateAdmissions, admittedAt, OAUTH_VALIDATE_REFRESH_FLOOR_MS);
+        if (input.trigger === "validate") {
+            const previousAdmission = this.validateAdmissions.get(key);
+            if (previousAdmission !== undefined &&
+                admittedAt - previousAdmission < OAUTH_VALIDATE_REFRESH_FLOOR_MS) {
+                return Promise.resolve({
+                    outcome: "skipped",
+                    reason: "validate_floor",
+                    state: undefined,
+                });
+            }
+            this.validateAdmissions.set(key, admittedAt);
+            this.forcedAdmissions.set(forcedKey, admittedAt);
+        }
+        else if (input.force === true) {
+            const previousAdmission = this.forcedAdmissions.get(forcedKey);
+            if (previousAdmission !== undefined &&
+                admittedAt - previousAdmission < OAUTH_FORCED_REFRESH_FLOOR_MS) {
+                return Promise.resolve({
+                    outcome: "skipped",
+                    reason: "forced_refresh_floor",
+                    state: undefined,
+                });
+            }
+            this.forcedAdmissions.set(forcedKey, admittedAt);
+        }
+        const promise = this.refreshCredentialOnce(input).finally(() => {
+            this.inflight.delete(key);
+        });
+        this.inflight.set(key, promise);
+        return promise;
+    }
+    recordAuthHint(input) {
+        return this.opts.store.persistAuthHint(input);
+    }
+    async refreshCredentialOnce(input) {
+        const state = this.opts.store.readOauthRefreshState(input.workspaceId, input.vaultId, input.credentialId);
+        if (state === undefined) {
+            const row = this.opts.store.retrieveCredential(input.workspaceId, input.vaultId, input.credentialId);
+            if (row?.auth.type === "static_bearer") {
+                return {
+                    outcome: "skipped",
+                    reason: "unsupported_credential_type",
+                    state: undefined,
+                };
+            }
+            return { outcome: "skipped", reason: "missing", state };
+        }
+        if (input.expectedAuthVersion !== undefined &&
+            state.authVersion !== input.expectedAuthVersion) {
+            return {
+                outcome: "skipped",
+                reason: "stale_version",
+                state: publicState(state),
+            };
+        }
+        if (state.refreshStatus === "invalid" &&
+            input.force !== true &&
+            input.trigger !== "validate") {
+            return {
+                outcome: "skipped",
+                reason: "invalid_status",
+                state: publicState(state),
+            };
+        }
+        if (state.refresh === undefined) {
+            return {
+                outcome: "skipped",
+                reason: "no_refresh_metadata",
+                state: publicState(state),
+            };
+        }
+        if (state.secrets.refreshToken === undefined) {
+            return {
+                outcome: "skipped",
+                reason: "no_refresh_token",
+                state: publicState(state),
+            };
+        }
+        if (state.refresh.tokenEndpointAuth.type !== "none" &&
+            state.secrets.clientSecret === undefined) {
+            return {
+                outcome: "skipped",
+                reason: "missing_client_secret",
+                state: publicState(state),
+            };
+        }
+        const refreshed = await this.performTokenRefresh(state);
+        if ("accessToken" in refreshed) {
+            const now = this.now();
+            const persisted = this.opts.store.persistOauthRefreshSuccess({
+                workspaceId: input.workspaceId,
+                vaultId: input.vaultId,
+                credentialId: input.credentialId,
+                expectedAuthVersion: state.authVersion,
+                accessToken: refreshed.accessToken,
+                ...(refreshed.refreshToken === undefined
+                    ? {}
+                    : { refreshToken: refreshed.refreshToken }),
+                expiresAt: refreshed.expiresAt,
+                ...(refreshed.scope === undefined ? {} : { scope: refreshed.scope }),
+                nextRefreshAt: refreshed.expiresAt === null
+                    ? new Date(now.getTime() + OAUTH_REFRESH_LONG_LIVED_RECHECK_MS).toISOString()
+                    : nextRefreshAt(now, new Date(refreshed.expiresAt)).toISOString(),
+                updatedAt: now.toISOString(),
+            });
+            if (persisted.status === "updated")
+                this.opts.onScheduled?.();
+            return {
+                outcome: "ok",
+                state: publicState(persisted.state ?? state),
+                persisted: persisted.status,
+                tokenEndpointResponse: refreshed.tokenEndpointResponse,
+            };
+        }
+        const attempts = state.refreshAttempts + 1;
+        const now = this.now();
+        const status = refreshed.outcome === "invalid" ? "invalid" : "transient";
+        const persisted = this.opts.store.persistOauthRefreshFailure({
+            workspaceId: input.workspaceId,
+            vaultId: input.vaultId,
+            credentialId: input.credentialId,
+            expectedAuthVersion: state.authVersion,
+            status,
+            refreshAttempts: attempts,
+            nextRefreshAt: status === "invalid"
+                ? null
+                : new Date(now.getTime() +
+                    (refreshed.retryAfterMs ?? transientBackoffMs(attempts, this.random()))).toISOString(),
+        });
+        if (status === "transient" && persisted.status === "updated") {
+            this.opts.onScheduled?.();
+        }
+        return {
+            outcome: refreshed.outcome,
+            reason: refreshed.reason,
+            state: persisted.state === undefined ? undefined : publicState(persisted.state),
+            persisted: persisted.status,
+            ...(refreshed.tokenEndpointResponse === undefined
+                ? {}
+                : { tokenEndpointResponse: refreshed.tokenEndpointResponse }),
+        };
+    }
+    async performTokenRefresh(state) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        let tokenEndpointResponse;
+        try {
+            const init = buildRefreshRequest(state, controller.signal);
+            const response = await this.fetchImpl(state.refresh.tokenEndpoint, init);
+            tokenEndpointResponse = {
+                statusCode: response.status,
+                // This crosses the control-plane response boundary. Keep only a validated
+                // media type: token endpoint headers are server controlled and may echo a
+                // freshly issued grant which is not in the pre-refresh scrub set yet.
+                contentType: safeMediaType(response.headers.get("content-type")),
+            };
+            const body = await readLimitedText(response, this.maxBodyBytes);
+            const parsed = parseJsonObject(body);
+            if (!parsed.ok) {
+                return {
+                    outcome: "transient_error",
+                    reason: parsed.reason,
+                    retryAfterMs: retryAfterMs(response),
+                    tokenEndpointResponse,
+                };
+            }
+            return {
+                ...classifyTokenResponse(response, parsed.value, this.now()),
+                tokenEndpointResponse,
+            };
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                return {
+                    outcome: "transient_error",
+                    reason: "timeout",
+                    ...(tokenEndpointResponse === undefined ? {} : { tokenEndpointResponse }),
+                };
+            }
+            if (error instanceof ResponseBodyTooLargeError) {
+                return {
+                    outcome: "transient_error",
+                    reason: "response_body_too_large",
+                    ...(tokenEndpointResponse === undefined ? {} : { tokenEndpointResponse }),
+                };
+            }
+            return {
+                outcome: "transient_error",
+                reason: isRedirectError(error) ? "redirect_blocked" : "request_failed",
+                ...(tokenEndpointResponse === undefined ? {} : { tokenEndpointResponse }),
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+export function nextRefreshAt(now, expiresAt) {
+    const ttlMs = expiresAt.getTime() - now.getTime();
+    if (ttlMs <= 0)
+        return new Date(now.getTime() + OAUTH_REFRESH_FLOOR_MS);
+    if (ttlMs < OAUTH_REFRESH_LEAD_MS) {
+        return new Date(now.getTime() + Math.max(OAUTH_REFRESH_FLOOR_MS, Math.floor(ttlMs / 2)));
+    }
+    return new Date(expiresAt.getTime() - OAUTH_REFRESH_LEAD_MS);
+}
+function transientBackoffMs(attempts, random) {
+    const base = Math.min(OAUTH_REFRESH_MAX_BACKOFF_MS, 60_000 * 2 ** Math.max(0, attempts - 1));
+    const jitter = 0.9 + Math.min(1, Math.max(0, random)) * 0.2;
+    return Math.min(OAUTH_REFRESH_MAX_BACKOFF_MS, Math.round(base * jitter));
+}
+function buildRefreshRequest(state, signal) {
+    const refresh = state.refresh;
+    const body = new URLSearchParams();
+    body.set("grant_type", "refresh_token");
+    body.set("refresh_token", state.secrets.refreshToken);
+    if (refresh.scope !== undefined)
+        body.set("scope", refresh.scope);
+    const headers = new Headers();
+    headers.set("content-type", "application/x-www-form-urlencoded");
+    const mode = refresh.tokenEndpointAuth.type;
+    if (mode === "none") {
+        body.set("client_id", refresh.clientId);
+    }
+    else if (mode === "client_secret_post") {
+        body.set("client_id", refresh.clientId);
+        body.set("client_secret", state.secrets.clientSecret);
+    }
+    else {
+        headers.set("authorization", `Basic ${Buffer.from(`${formEncodeComponent(refresh.clientId)}:${formEncodeComponent(state.secrets.clientSecret)}`).toString("base64")}`);
+    }
+    return {
+        method: "POST",
+        redirect: "error",
+        headers,
+        body,
+        signal,
+    };
+}
+function formEncodeComponent(value) {
+    const params = new URLSearchParams();
+    params.set("x", value);
+    return params.toString().slice(2);
+}
+function classifyTokenResponse(response, value, now) {
+    const oauthError = oauthErrorCode(value);
+    if (!response.ok || oauthError !== undefined) {
+        return {
+            outcome: oauthError !== undefined && PERMANENT_OAUTH_ERRORS.has(oauthError)
+                ? "invalid"
+                : "transient_error",
+            reason: oauthError ?? `http_${response.status}`,
+            retryAfterMs: retryAfterMs(response, now.getTime()),
+        };
+    }
+    if (value.ok === false &&
+        typeof value.error === "string" &&
+        value.error.length > 0) {
+        const error = value.error;
+        return {
+            outcome: PERMANENT_OAUTH_ERRORS.has(error) ? "invalid" : "transient_error",
+            reason: error,
+            retryAfterMs: retryAfterMs(response, now.getTime()),
+        };
+    }
+    if (typeof value.access_token !== "string" || value.access_token.length === 0) {
+        return { outcome: "transient_error", reason: "missing_access_token" };
+    }
+    if (typeof value.token_type === "string" &&
+        value.token_type.toLowerCase() !== "bearer") {
+        return { outcome: "invalid", reason: "unsupported_token_type" };
+    }
+    const expiresAt = expiresAtFromResponse(value, now);
+    return {
+        accessToken: value.access_token,
+        ...(typeof value.refresh_token === "string" && value.refresh_token.length > 0
+            ? { refreshToken: value.refresh_token }
+            : {}),
+        expiresAt,
+        ...(typeof value.scope === "string" ? { scope: value.scope } : {}),
+    };
+}
+function oauthErrorCode(value) {
+    return typeof value.error === "string" && value.error.length > 0
+        ? value.error
+        : undefined;
+}
+function expiresAtFromResponse(value, now) {
+    if (typeof value.expires_in !== "number" || !Number.isFinite(value.expires_in)) {
+        return null;
+    }
+    return new Date(now.getTime() + Math.max(0, value.expires_in) * 1000).toISOString();
+}
+function retryAfterMs(response, now = Date.now()) {
+    const value = response.headers.get("retry-after");
+    if (value === null)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.min(OAUTH_REFRESH_MAX_BACKOFF_MS, seconds * 1000);
+    }
+    const date = Date.parse(value);
+    if (Number.isNaN(date))
+        return undefined;
+    return Math.min(OAUTH_REFRESH_MAX_BACKOFF_MS, Math.max(0, date - now));
+}
+async function readLimitedText(response, maxBytes) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("json")) {
+        await response.body?.cancel().catch(() => undefined);
+        return "";
+    }
+    if (response.body === null)
+        return "";
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            if (value === undefined)
+                continue;
+            total += value.byteLength;
+            if (total > maxBytes)
+                throw new ResponseBodyTooLargeError();
+            chunks.push(value);
+        }
+        const bytes = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return new TextDecoder().decode(bytes);
+    }
+    catch (error) {
+        await reader.cancel().catch(() => undefined);
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+const MEDIA_TYPE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+function safeMediaType(value) {
+    const mediaType = (value ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
+    return MEDIA_TYPE.test(mediaType) ? mediaType : "application/octet-stream";
+}
+function parseJsonObject(text) {
+    if (text.length === 0)
+        return { ok: false, reason: "non_json_response" };
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? { ok: true, value: parsed }
+            : { ok: false, reason: "invalid_json_response" };
+    }
+    catch {
+        return { ok: false, reason: "invalid_json_response" };
+    }
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError";
+}
+function isRedirectError(error) {
+    let current = error;
+    for (let i = 0; i < 4 && current !== undefined; i++) {
+        if (current instanceof Error &&
+            /redirect/i.test(`${current.name} ${current.message}`)) {
+            return true;
+        }
+        current = typeof current === "object" && current !== null && "cause" in current
+            ? current.cause
+            : undefined;
+    }
+    return false;
+}
+function publicState(state) {
+    return {
+        workspaceId: state.workspaceId,
+        vaultId: state.vaultId,
+        credentialId: state.credentialId,
+        authVersion: state.authVersion,
+        mcpServerUrl: state.mcpServerUrl,
+        ...(state.expiresAt === undefined ? {} : { expiresAt: state.expiresAt }),
+        refreshStatus: state.refreshStatus,
+        refreshAttempts: state.refreshAttempts,
+        nextRefreshAt: state.nextRefreshAt,
+        authHintAt: state.authHintAt,
+        hasAccessToken: state.secrets.accessToken !== undefined,
+        hasRefreshToken: state.secrets.refreshToken !== undefined,
+        hasClientSecret: state.secrets.clientSecret !== undefined,
+    };
+}
+class ResponseBodyTooLargeError extends Error {
+}
+function pruneAdmissions(admissions, now, floorMs) {
+    for (const [key, timestamp] of admissions) {
+        if (now - timestamp >= floorMs)
+            admissions.delete(key);
+    }
+}

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

@@ -0,0 +1,66 @@
+import { Hono } from "hono";
+import { parseJsonBody, parseLimit } from "../http.js";
+import { workspaceIdFrom } from "../workspace.js";
+import { invalidRequest } from "../errors.js";
+import { validateMcpOauthCredential, } from "./mcp-oauth-validate.js";
+export function vaultsRoutes(service, mcp) {
+    const app = new Hono();
+    app.post("/", async (c) => {
+        const body = await parseJsonBody(c.req);
+        return c.json(service.createVault(workspaceIdFrom(c), body), 200);
+    });
+    app.get("/", (c) => {
+        return c.json(service.listVaults(workspaceIdFrom(c), listOpts((key) => c.req.query(key))), 200);
+    });
+    app.get("/:vaultId", (c) => {
+        return c.json(service.retrieveVault(workspaceIdFrom(c), c.req.param("vaultId")), 200);
+    });
+    app.post("/:vaultId/archive", (c) => {
+        return c.json(service.archiveVault(workspaceIdFrom(c), c.req.param("vaultId")), 200);
+    });
+    app.post("/:vaultId", async (c) => {
+        const body = await parseJsonBody(c.req);
+        return c.json(service.updateVault(workspaceIdFrom(c), c.req.param("vaultId"), body), 200);
+    });
+    app.delete("/:vaultId", (c) => {
+        return c.json(service.deleteVault(workspaceIdFrom(c), c.req.param("vaultId")), 200);
+    });
+    app.post("/:vaultId/credentials", async (c) => {
+        const body = await parseJsonBody(c.req);
+        return c.json(service.createCredential(workspaceIdFrom(c), c.req.param("vaultId"), body), 200);
+    });
+    app.get("/:vaultId/credentials", (c) => {
+        return c.json(service.listCredentials(workspaceIdFrom(c), c.req.param("vaultId"), listOpts((key) => c.req.query(key))), 200);
+    });
+    app.post("/:vaultId/credentials/:credentialId/archive", (c) => {
+        return c.json(service.archiveCredential(workspaceIdFrom(c), c.req.param("vaultId"), c.req.param("credentialId")), 200);
+    });
+    app.post("/:vaultId/credentials/:credentialId/mcp_oauth_validate", async (c) => {
+        if (mcp === undefined) {
+            throw invalidRequest("MCP is disabled on this deployment");
+        }
+        return c.json(await validateMcpOauthCredential(service, mcp, workspaceIdFrom(c), c.req.param("vaultId"), c.req.param("credentialId")), 200);
+    });
+    app.get("/:vaultId/credentials/:credentialId", (c) => {
+        return c.json(service.retrieveCredential(workspaceIdFrom(c), c.req.param("vaultId"), c.req.param("credentialId")), 200);
+    });
+    app.post("/:vaultId/credentials/:credentialId", async (c) => {
+        const body = await parseJsonBody(c.req);
+        return c.json(service.updateCredential(workspaceIdFrom(c), c.req.param("vaultId"), c.req.param("credentialId"), body), 200);
+    });
+    app.delete("/:vaultId/credentials/:credentialId", (c) => {
+        service.deleteCredential(workspaceIdFrom(c), c.req.param("vaultId"), c.req.param("credentialId"));
+        return c.body(null, 204);
+    });
+    return app;
+}
+function listOpts(query) {
+    const limit = parseLimit(query("limit"));
+    const page = query("page") || undefined;
+    const includeArchived = query("include_archived") === "true";
+    return {
+        ...(limit === undefined ? {} : { limit }),
+        ...(page === undefined ? {} : { page }),
+        ...(includeArchived ? { includeArchived } : {}),
+    };
+}