@jeffjassky/oauth-host 0.1.0 → 0.3.0

package/dist/index.js

@@ -22,9 +22,11 @@ function clientSchema() {
     {
       clientId: { type: String, required: true, unique: true },
       name: { type: String, required: true },
-      // `public` exists for CIMD clients, which hold no secret and are bound by
-      // PKCE instead. The enum was written with this widening in mind, so it
-      // was one member rather than a migration.
+      // `public` is a client that holds no secret and is bound by PKCE instead.
+      // Two ways in and they are independent: a CIMD row is written public, and
+      // `clients.create({ type: 'public' })` registers one by hand. The enum was
+      // written with this widening in mind, so it was one member rather than a
+      // migration.
       type: { type: String, enum: ["confidential", "public"], default: "confidential" },
       // How the row got here. A `cimd` row is re-derived from the client's own
       // metadata document, so this is what tells the re-fetch path which fields
@@ -493,6 +495,7 @@ function resolveConfig(config) {
   }
   const store = rateLimits.store ?? memoryStore();
   const normalizedMount = `/${String(mountPath).replace(/^\/+|\/+$/g, "")}`;
+  const indexes = { ready: false };
   const ctx = {
     models,
     issuer,
@@ -524,6 +527,11 @@ function resolveConfig(config) {
     cors: { tokenEndpoint: cors.tokenEndpoint ?? false, origins: cors.origins ?? [] },
     clockSkewMs,
     cimd: resolveCimd(clientIdMetadata, scopeIndex),
+    indexes,
+    async syncIndexes() {
+      await syncModelIndexes(models);
+      indexes.ready = true;
+    },
     logger,
     track,
     async audit(entry) {
@@ -1351,6 +1359,15 @@ function assertResources(ctx, input) {
   }
   return [...input];
 }
+function assertClientType(value) {
+  if (value === void 0) return "confidential";
+  if (value !== "confidential" && value !== "public") {
+    throw new TypeError(
+      `oauth-host: client type must be 'confidential' or 'public' (got ${JSON.stringify(value)})`
+    );
+  }
+  return value;
+}
 function assertName(value) {
   if (typeof value !== "string" || !value.trim()) {
     throw new TypeError("oauth-host: a client needs a non-empty `name` \u2014 it is what the consent screen shows");
@@ -1372,35 +1389,38 @@ async function revokeTokensMatching(ctx, filter) {
   return res.modifiedCount ?? 0;
 }
 function createClientsApi(ctx) {
+  async function create(spec) {
+    if (!spec || typeof spec !== "object") {
+      throw new TypeError("oauth-host: clients.create(spec) requires a spec object");
+    }
+    const name = assertName(spec.name);
+    const type = assertClientType(spec.type);
+    const redirectUris = assertRedirectUris(spec.redirectUris);
+    const allowedScopes = assertScopes(ctx, spec.allowedScopes);
+    const allowedResources = assertResources(ctx, spec.allowedResources);
+    const clientId = spec.clientId ?? generateClientId();
+    const clientSecret = type === "confidential" ? generateClientSecret() : void 0;
+    const doc = await ctx.models.Client.create({
+      clientId,
+      name,
+      type,
+      registration: "manual",
+      trusted: Boolean(spec.trusted),
+      // Only the digest is stored. `clientSecret` below is the only time the
+      // raw value exists outside the caller's variable. Empty for a public
+      // client, which is the same shape a CIMD row is written with.
+      secrets: clientSecret ? [{ hash: sha256(clientSecret), label: "initial", createdAt: /* @__PURE__ */ new Date() }] : [],
+      redirectUris,
+      allowedScopes,
+      allowedResources,
+      branding: spec.branding ?? {},
+      status: "active"
+    });
+    await ctx.audit({ type: "oauth.client_created", actor: "admin", clientId, meta: { type } });
+    return clientSecret ? { client: toPublicClient(doc), clientId, type: "confidential", clientSecret } : { client: toPublicClient(doc), clientId, type: "public" };
+  }
   return {
-    async create(spec) {
-      if (!spec || typeof spec !== "object") {
-        throw new TypeError("oauth-host: clients.create(spec) requires a spec object");
-      }
-      const name = assertName(spec.name);
-      const redirectUris = assertRedirectUris(spec.redirectUris);
-      const allowedScopes = assertScopes(ctx, spec.allowedScopes);
-      const allowedResources = assertResources(ctx, spec.allowedResources);
-      const clientId = spec.clientId ?? generateClientId();
-      const clientSecret = generateClientSecret();
-      const doc = await ctx.models.Client.create({
-        clientId,
-        name,
-        type: "confidential",
-        registration: "manual",
-        trusted: Boolean(spec.trusted),
-        // Only the digest is stored. `clientSecret` below is the only time the
-        // raw value exists outside the caller's variable.
-        secrets: [{ hash: sha256(clientSecret), label: "initial", createdAt: /* @__PURE__ */ new Date() }],
-        redirectUris,
-        allowedScopes,
-        allowedResources,
-        branding: spec.branding ?? {},
-        status: "active"
-      });
-      await ctx.audit({ type: "oauth.client_created", actor: "admin", clientId });
-      return { client: toPublicClient(doc), clientId, clientSecret };
-    },
+    create,
     async rotateSecret(clientId, opts = {}) {
       const doc = await ctx.models.Client.findOne({ clientId });
       if (!doc) throw notFound(clientId);
@@ -1429,7 +1449,7 @@ function createClientsApi(ctx) {
         clientId,
         meta: { retireAfter, retiresAt }
       });
-      return { client: toPublicClient(doc), clientId, clientSecret };
+      return { client: toPublicClient(doc), clientId, type: "confidential", clientSecret };
     },
     async update(clientId, patch) {
       const doc = await ctx.models.Client.findOne({ clientId });
@@ -2473,8 +2493,17 @@ function createOAuthRouter(ctx) {
   const ipKey = (req) => req.ip ?? "unknown";
   const clientKey = (req) => clientIdFromRequest(req) ?? ipKey(req);
   const cors = corsMiddleware(ctx);
+  const requireIndexes = w((_req, _res, next) => {
+    if (ctx.indexes.ready) return next();
+    throw new OAuthError(
+      503,
+      "server_error",
+      "This authorization server is not ready: `syncIndexes()` has not resolved yet. Await `oauth.syncIndexes()` at boot, before mounting the routers."
+    );
+  });
   router.get(
     "/authorize",
+    requireIndexes,
     rateLimit(ctx, "authorize", ipKey),
     w(async (req, res) => {
       let validated;
@@ -2533,6 +2562,7 @@ function createOAuthRouter(ctx) {
   router.post(
     "/token",
     cors,
+    requireIndexes,
     form,
     rateLimit(ctx, "token", clientKey),
     w(async (req, res) => {
@@ -2637,6 +2667,7 @@ function createOAuthRouter(ctx) {
   );
   router.post(
     "/consent/:requestId",
+    requireIndexes,
     rateLimit(ctx, "consent", ipKey),
     w(async (req, res) => {
       const user = await requireUser(ctx, req);
@@ -2738,6 +2769,16 @@ function corsMiddleware(ctx) {
   };
 }
 
+// src/server/vendors.ts
+var CLAUDE_CONNECTOR_REDIRECT_URI = "https://claude.ai/api/mcp/auth_callback";
+var CLAUDE_CODE_REDIRECT_URIS = [
+  "http://localhost/callback",
+  "http://127.0.0.1/callback"
+];
+var CHATGPT_LEGACY_REDIRECT_URI = "https://chatgpt.com/connector_platform_oauth_redirect";
+var CHATGPT_CONNECTOR_REDIRECT_URI_PATTERN = "https://chatgpt.com/connector/oauth/{callback_id}";
+var CIMD_ALLOWED_HOSTS = ["claude.ai", "chatgpt.com"];
+
 // src/server/index.ts
 function createOAuthHost(config) {
   const ctx = resolveConfig(config);
@@ -2761,13 +2802,30 @@ function createOAuthHost(config) {
      * stops one user holding two live grants for the same client, and mongoose
      * builds indexes in the background — a cold database will happily serve
      * the write that violates it first. See standards/traps.md #3.
+     *
+     * Resolving this is also what flips `ready` and un-gates `/authorize`,
+     * `POST /consent/:requestId` and `POST /token`.
+     */
+    syncIndexes: () => ctx.syncIndexes(),
+    /**
+     * Has `syncIndexes()` resolved?
+     *
+     * A boolean, not a promise, and the difference is the failure mode. A
+     * promise would have to exist from construction, so a host that never calls
+     * `syncIndexes()` would await it forever — a boot-order mistake turning into
+     * an unexplained hang with no message. A boolean is plainly `false`, cannot
+     * be awaited by accident, and is backed by three routes that say what is
+     * wrong by name. Gate a mount on it, or simply
+     * `await oauth.syncIndexes()` first, which is the same thing said directly.
      */
-    syncIndexes: () => syncModelIndexes(ctx.models),
+    get ready() {
+      return ctx.indexes.ready;
+    },
     /** Escape hatch. Prefer the APIs above; these carry no invariants. */
     models: ctx.models
   };
 }
 
-export { OAuthError, RedirectableAuthError, UnredirectableError, createModels, createOAuthHost, createUserAdapter, defaultResolveUser, syncModelIndexes };
+export { CHATGPT_CONNECTOR_REDIRECT_URI_PATTERN, CHATGPT_LEGACY_REDIRECT_URI, CIMD_ALLOWED_HOSTS, CLAUDE_CODE_REDIRECT_URIS, CLAUDE_CONNECTOR_REDIRECT_URI, OAuthError, RedirectableAuthError, UnredirectableError, createModels, createOAuthHost, createUserAdapter, defaultResolveUser, syncModelIndexes };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map