busa-sdk 0.10.2 → 0.10.3

package/dist/index.js

@@ -1,9 +1,34 @@
+import { normalizeBaseUrl } from './chunk-5NYQX65A.js';
+export { normalizeBaseUrl } from './chunk-5NYQX65A.js';
 import { createORPCClient, ORPCError } from '@orpc/client';
 import { OpenAPILink } from '@orpc/openapi-client/fetch';
 import { oc, eventIterator } from '@orpc/contract';
 import { z } from 'zod';
 
-// src/client.ts
+// src/asset-grep.ts
+var toUnifiedFilesGrepInput = (input) => ({
+  pattern: input.pattern,
+  flags: input.flags,
+  sources: ["files"],
+  scope: input.scope ? { files: input.scope } : void 0,
+  maxMatches: input.maxMatches,
+  contextLines: input.contextLines
+});
+var toFilesOnlyGrepResult = (result) => ({
+  matches: result.matches.flatMap((match) => {
+    if (match.source !== "files") return [];
+    const { source: _source, ...fileMatch } = match;
+    return [fileMatch];
+  }),
+  filesScanned: result.coverage.files.scanned,
+  missing: result.coverage.files.missing,
+  stale: result.coverage.files.stale,
+  unsearchable: result.coverage.files.unsearchable,
+  errored: result.coverage.files.errored,
+  notReached: result.coverage.files.notReached,
+  truncated: result.truncated
+});
+var grepAssets = async (client, input) => toFilesOnlyGrepResult(await client.grep(toUnifiedFilesGrepInput(input)));
 var i18n = {
   locales: ["en", "zh-CN", "zh-TW", "ja", "ko", "de", "fr", "es", "pt"]};
 var LocaleSchema = z.enum(i18n.locales);
@@ -1277,7 +1302,7 @@ var GREP_DEFAULT_MAX_MATCHES = 100;
 var GREP_HARD_MAX_MATCHES = 1e3;
 var GREP_DEFAULT_CONTEXT_LINES = 0;
 var GREP_MAX_CONTEXT_LINES = 10;
-var GrepInputSchema = z.object({
+z.object({
   pattern: z.string().min(1),
   /** JS RegExp flags, e.g. `"i"` for case-insensitive. `g`/`y` are ignored (grep always scans every match per line). */
   flags: z.string().optional().default(""),
@@ -1298,7 +1323,7 @@ var GrepMatchVOSchema = z.object({
   before: z.array(z.string()),
   after: z.array(z.string())
 });
-var GrepResultVOSchema = z.object({
+z.object({
   matches: z.array(GrepMatchVOSchema),
   filesScanned: z.number().int().nonnegative(),
   /** Asset ids in scope with no text yet (contentKind text-or-writable-binary, no row). */
@@ -1432,13 +1457,6 @@ var assetsContract = {
     summary: "Request a presigned upload URL for large text",
     successDescription: "Presigned (or dev) upload URL for a temporary text object; PUT the bytes there, then call putText with the returned storageKey to bind, verify, and content-address it."
   }).input(CreateTextUploadUrlInputSchema).output(CreateTextUploadUrlVOSchema),
-  grep: oc.route({
-    method: "POST",
-    path: "/assets/grep",
-    tags: ["Assets"],
-    summary: "Search every text-bearing asset in scope",
-    successDescription: "Streaming regex/literal matches with real file + line + column numbers and context, across every asset with text \u2014 any size, no 256KB cap. Honest coverage: missing/stale/unsearchable/errored name assets that were not (fully or successfully) searched, notReached counts present assets the scan never got to, and truncated flags a capped response."
-  }).input(GrepInputSchema).output(GrepResultVOSchema),
   readTextLines: oc.route({
     method: "GET",
     path: "/assets/{assetId}/text/lines",
@@ -1616,6 +1634,19 @@ var listRecordsResponseSchema = z.object({
   records: z.array(recordSchema),
   nextCursor: z.string().nullable()
 });
+var listRecordsPageInputSchema = z.object({
+  baseId: z.string().min(1),
+  viewId: z.string().min(1).optional(),
+  page: z.coerce.number().int().min(1).optional().default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).optional().default(50)
+});
+var listRecordsPageResponseSchema = z.object({
+  records: z.array(recordSchema),
+  total: z.number().int().nonnegative(),
+  totalPages: z.number().int().nonnegative(),
+  page: z.number().int().min(1),
+  pageSize: z.number().int().min(1).max(100)
+});
 var countRecordsInputSchema = z.object({
   baseId: z.string().optional()
 }).optional().default({});
@@ -1662,10 +1693,16 @@ var recordFieldFilterInputSchema = z.object({
   limit: z.coerce.number().int().min(1).max(100).optional().default(50)
 });
 var recordFieldGetInputSchema = z.object({
-  baseId: z.string(),
-  fieldSlug: z.string().min(1),
-  valueText: z.string().min(1)
+  baseId: z.string().describe("Field selector: Base id. Requires fieldSlug and valueText."),
+  fieldSlug: z.string().min(1).describe("Field selector: exact field slug. Requires baseId and valueText."),
+  valueText: z.string().min(1).describe("Field selector: exact text value. Requires baseId and fieldSlug.")
 });
+var recordGetInputSchema = z.union([
+  z.object({
+    recordId: z.string().min(1).describe("Record id selector. Use alone; do not combine with field selector fields.")
+  }).strict(),
+  recordFieldGetInputSchema.strict()
+]);
 var restoreRecordInputSchema = z.object({
   message: z.string().optional(),
   submittedBy: z.string().optional().default("local-editor")
@@ -1801,6 +1838,13 @@ var recordContract = {
     summary: "List records",
     successDescription: "A page of canonical records plus an opaque nextCursor (null at the end). `status=archived` lists the Base's trash instead of its live rows."
   }).input(listRecordsInputSchema).output(listRecordsResponseSchema),
+  listPage: oc.route({
+    method: "GET",
+    path: "/records/page",
+    tags: ["Records"],
+    summary: "List a numbered record page",
+    successDescription: "A random-access page of active records. When viewId is supplied, the saved view is authoritatively filtered and sorted before total and page slicing are calculated."
+  }).input(listRecordsPageInputSchema).output(listRecordsPageResponseSchema),
   count: oc.route({
     method: "GET",
     path: "/records/count",
@@ -1810,11 +1854,15 @@ var recordContract = {
   }).input(countRecordsInputSchema).output(countRecordsResponseSchema),
   get: oc.route({
     method: "GET",
-    path: "/records/{recordId}",
+    path: "/records/get",
     tags: ["Records"],
     summary: "Get record",
-    successDescription: "Canonical record detail."
-  }).input(z.object({ recordId: z.string() })).output(recordSchema),
+    description: "Provide exactly one selector: recordId alone, or the complete baseId + fieldSlug + valueText tuple. Other combinations return 400.",
+    successDescription: "One canonical record selected by id or exact field value."
+  }).errors({
+    BAD_REQUEST: { status: 400, message: "Exactly one record selector is required" },
+    NOT_FOUND: { status: 404, message: "Record not found" }
+  }).input(recordGetInputSchema).output(recordSchema),
   search: oc.route({
     method: "GET",
     path: "/records/search",
@@ -1822,13 +1870,6 @@ var recordContract = {
     summary: "Filter records by field text",
     successDescription: "Canonical records matching a field text filter."
   }).input(recordFieldFilterInputSchema).output(z.array(recordSchema)),
-  getByField: oc.route({
-    method: "GET",
-    path: "/records/by-field",
-    tags: ["Records"],
-    summary: "Get record by field value",
-    successDescription: "Single canonical record whose field value exactly matches, or null when none does \u2014 a scoped point lookup (e.g. by a unique slug or path field), not a list."
-  }).input(recordFieldGetInputSchema).output(recordSchema.nullable()),
   changeRequest: oc.route({
     method: "POST",
     path: "/records/{recordId}/change-requests",
@@ -2697,7 +2738,7 @@ var UnifiedGrepScopeSchema = z.object({
 });
 var UnifiedGrepInputSchema = z.object({
   pattern: z.string().min(1),
-  /** JS RegExp flags, e.g. `"i"` for case-insensitive — same language as `assets.grep`. */
+  /** JS RegExp flags, e.g. `"i"` for case-insensitive. */
   flags: z.string().optional().default(""),
   /** Which sources to scan. Omitted = all three (`files`, `docs`, `records`). */
   sources: z.array(GrepSourceSchema).optional(),
@@ -2806,11 +2847,9 @@ var busabaseContractRoutes = {
     summary: "Search Busabase",
     successDescription: "Paginated search results across records, change requests, Bases, File nodes, and Assets."
   }).input(searchInputSchema).output(searchResponseSchema),
-  // Unified Grep (P2a files+docs, P2b records) — top-level, cross-source
-  // superset of `assets.grep`. See apps/busabase/content/spec/unified-grep.md.
-  // Composes `logic/grep.ts`; `assets.grep` (files-only specialist) is
-  // unchanged and stays the dedicated endpoint for its fuller
-  // missing/stale/unsearchable reporting.
+  // Unified Grep (P2a files+docs, P2b records) — the single public pattern
+  // search endpoint. Files-only callers use `sources: ["files"]` and retain
+  // the full missing/stale/unsearchable coverage block.
   grep: oc.route({
     method: "POST",
     path: "/grep",
@@ -3384,9 +3423,6 @@ var env = (key) => {
   const value = process.env[key];
   return value && value.length > 0 ? value : void 0;
 };
-function normalizeBaseUrl(raw) {
-  return raw.replace(/\/+$/, "").replace(/\/api\/v1$/, "");
-}
 function resolveConfig(config = {}) {
   return {
     baseUrl: normalizeBaseUrl(config.baseUrl ?? env("BUSABASE_BASE_URL") ?? DEFAULT_BASE_URL),
@@ -3434,6 +3470,17 @@ function createBusabaseClient(config = {}) {
   return createORPCClient(link);
 }
 
+// src/record-get.ts
+var isNotFound = (error) => typeof error === "object" && error !== null && ("status" in error && error.status === 404 || "code" in error && error.code === "NOT_FOUND");
+var getRecordByField = async (client, input) => {
+  try {
+    return await client.records.get(input);
+  } catch (error) {
+    if (isNotFound(error)) return null;
+    throw error;
+  }
+};
+
 // src/index.ts
 var Busabase = class {
   /** The underlying fully-typed oRPC client. Use it for anything not surfaced here. */
@@ -3450,7 +3497,13 @@ var Busabase = class {
     return this.client.bases;
   }
   get records() {
-    return this.client.records;
+    const getByField = (input) => getRecordByField(this.client, input);
+    return new Proxy(this.client.records, {
+      get(target, property, receiver) {
+        if (property === "getByField") return getByField;
+        return Reflect.get(target, property, receiver);
+      }
+    });
   }
   get views() {
     return this.client.views;
@@ -3474,7 +3527,13 @@ var Busabase = class {
     return this.client.agent;
   }
   get assets() {
-    return this.client.assets;
+    const filesOnlyGrep = (input) => grepAssets(this.client, input);
+    return new Proxy(this.client.assets, {
+      get(target, property, receiver) {
+        if (property === "grep") return filesOnlyGrep;
+        return Reflect.get(target, property, receiver);
+      }
+    });
   }
   /** Skills, Drives, and AirApps — one surface, discriminated by `type`. */
   get fileTrees() {
@@ -3507,10 +3566,8 @@ var Busabase = class {
    * source (Drive/Skill files, Doc bodies, and Base records — records read
    * the canonical `headCommit.fields`, never the truncated search
    * projection), with a shared `maxMatches`/deadline budget and per-source
-   * honest coverage. Use this when the answer could live anywhere; use
-   * `client.assets.grep` directly instead when you specifically only care
-   * about files and want its fuller `missing`/`stale`/`unsearchable`
-   * file-only reporting.
+   * honest coverage. `bb.assets.grep` remains available as a files-only SDK
+   * convenience and delegates here with `sources: ["files"]`.
    */
   grep(input) {
     return this.client.grep(input);
@@ -3560,4 +3617,4 @@ var Busabase = class {
   }
 };
 
-export { Busabase, CREATABLE_NODE_TYPES, DEFAULT_BASE_URL, cloudContract, createBusabaseClient, normalizeBaseUrl, resolveConfig };
+export { Busabase, CREATABLE_NODE_TYPES, DEFAULT_BASE_URL, cloudContract, createBusabaseClient, getRecordByField, grepAssets, resolveConfig, toFilesOnlyGrepResult, toUnifiedFilesGrepInput };

package/dist/oauth-node.d.ts

@@ -0,0 +1,33 @@
+import { BusabaseOAuthTokenSet } from './oauth.js';
+
+interface BusabaseAirAppOAuthCredential {
+    version: 1;
+    appId: string;
+    baseUrl: string;
+    clientId: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: string;
+    scope: string[];
+    tokenType: string;
+}
+interface BusabaseAirAppCredentialStoreOptions {
+    /** Override only for tests or an explicitly isolated installation. */
+    rootDir?: string;
+}
+/** Directory containing one owner-only OAuth registration per local AirApp. */
+declare const busabaseAirAppCredentialsDir: (options?: BusabaseAirAppCredentialStoreOptions) => string;
+declare const busabaseAirAppCredentialPath: (appId: string, options?: BusabaseAirAppCredentialStoreOptions) => string;
+declare function loadBusabaseAirAppOAuthCredential(appId: string, options?: BusabaseAirAppCredentialStoreOptions): BusabaseAirAppOAuthCredential | null;
+declare function storeBusabaseAirAppOAuthCredential(input: {
+    appId: string;
+    baseUrl: string;
+    tokenSet: BusabaseOAuthTokenSet;
+    clientId?: string;
+}, options?: BusabaseAirAppCredentialStoreOptions): BusabaseAirAppOAuthCredential;
+/** Load a valid access token, rotating and persisting the token set when needed. */
+declare function getBusabaseAirAppAccessToken(appId: string, options?: BusabaseAirAppCredentialStoreOptions, fetchImpl?: typeof fetch): Promise<BusabaseAirAppOAuthCredential | null>;
+declare function clearBusabaseAirAppOAuthCredential(appId: string, options?: BusabaseAirAppCredentialStoreOptions): void;
+declare function revokeBusabaseAirAppOAuthCredential(appId: string, options?: BusabaseAirAppCredentialStoreOptions, fetchImpl?: typeof fetch): Promise<void>;
+
+export { type BusabaseAirAppCredentialStoreOptions, type BusabaseAirAppOAuthCredential, busabaseAirAppCredentialPath, busabaseAirAppCredentialsDir, clearBusabaseAirAppOAuthCredential, getBusabaseAirAppAccessToken, loadBusabaseAirAppOAuthCredential, revokeBusabaseAirAppOAuthCredential, storeBusabaseAirAppOAuthCredential };

package/dist/oauth-node.js

@@ -0,0 +1,147 @@
+import { BusabaseOAuthError, BUSABASE_AIRAPP_CLIENT_ID, refreshBusabaseOAuthToken, revokeBusabaseOAuthToken } from './chunk-J2DZKX7A.js';
+import { normalizeBaseUrl } from './chunk-5NYQX65A.js';
+import { randomUUID } from 'crypto';
+import { readFileSync, mkdirSync, chmodSync, writeFileSync, renameSync, rmSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+
+var STORE_VERSION = 1;
+var APP_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var REFRESH_WINDOW_MS = 6e4;
+var refreshesByCredentialPath = /* @__PURE__ */ new Map();
+var assertAppId = (appId) => {
+  if (!APP_ID_RE.test(appId)) {
+    throw new BusabaseOAuthError(
+      "invalid_airapp_id",
+      "AirApp id must use letters, digits, dot, dash, or underscore"
+    );
+  }
+  return appId;
+};
+var storeRoot = (options = {}) => options.rootDir ?? join(homedir(), ".busabase");
+var busabaseAirAppCredentialsDir = (options = {}) => join(storeRoot(options), "airapps");
+var busabaseAirAppCredentialPath = (appId, options = {}) => join(busabaseAirAppCredentialsDir(options), `${assertAppId(appId)}.json`);
+var normalizeOrigin = (raw) => {
+  const url = new URL(normalizeBaseUrl(raw));
+  if (url.username || url.password || url.search || url.hash) {
+    throw new BusabaseOAuthError("invalid_base_url", "Busabase base URL must be an origin");
+  }
+  return url.origin;
+};
+var parseCredential = (raw, expectedAppId) => {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new BusabaseOAuthError("invalid_local_credential", "AirApp OAuth credential is invalid");
+  }
+  const item = value;
+  if (item.version !== STORE_VERSION || item.appId !== expectedAppId || typeof item.baseUrl !== "string" || typeof item.clientId !== "string" || typeof item.accessToken !== "string" || typeof item.refreshToken !== "string" || typeof item.expiresAt !== "string" || !Array.isArray(item.scope) || item.scope.some((scope) => typeof scope !== "string") || typeof item.tokenType !== "string") {
+    throw new BusabaseOAuthError("invalid_local_credential", "AirApp OAuth credential is invalid");
+  }
+  return item;
+};
+function loadBusabaseAirAppOAuthCredential(appId, options = {}) {
+  const path = busabaseAirAppCredentialPath(appId, options);
+  try {
+    return parseCredential(readFileSync(path, "utf8"), appId);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function storeBusabaseAirAppOAuthCredential(input, options = {}) {
+  if (!input.tokenSet.refreshToken) {
+    throw new BusabaseOAuthError(
+      "missing_refresh_token",
+      "A refresh token is required for a persistent local AirApp login"
+    );
+  }
+  const credential = {
+    version: STORE_VERSION,
+    appId: assertAppId(input.appId),
+    baseUrl: normalizeOrigin(input.baseUrl),
+    clientId: input.clientId ?? BUSABASE_AIRAPP_CLIENT_ID,
+    accessToken: input.tokenSet.accessToken,
+    refreshToken: input.tokenSet.refreshToken,
+    expiresAt: input.tokenSet.expiresAt,
+    scope: input.tokenSet.scope,
+    tokenType: input.tokenSet.tokenType
+  };
+  const path = busabaseAirAppCredentialPath(input.appId, options);
+  const directory = dirname(path);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  try {
+    chmodSync(directory, 448);
+  } catch {
+  }
+  const temporaryPath = `${path}.${randomUUID()}.tmp`;
+  writeFileSync(temporaryPath, `${JSON.stringify(credential, null, 2)}
+`, { mode: 384 });
+  try {
+    chmodSync(temporaryPath, 384);
+  } catch {
+  }
+  renameSync(temporaryPath, path);
+  return credential;
+}
+async function getBusabaseAirAppAccessToken(appId, options = {}, fetchImpl = fetch) {
+  const credential = loadBusabaseAirAppOAuthCredential(appId, options);
+  if (!credential) return null;
+  const expiresAt = Date.parse(credential.expiresAt);
+  if (Number.isFinite(expiresAt) && expiresAt > Date.now() + REFRESH_WINDOW_MS) return credential;
+  const credentialPath = busabaseAirAppCredentialPath(appId, options);
+  const activeRefresh = refreshesByCredentialPath.get(credentialPath);
+  if (activeRefresh) return activeRefresh;
+  const refresh = (async () => {
+    const tokenSet = await refreshBusabaseOAuthToken(
+      {
+        baseUrl: credential.baseUrl,
+        refreshToken: credential.refreshToken,
+        clientId: credential.clientId
+      },
+      fetchImpl
+    );
+    return storeBusabaseAirAppOAuthCredential(
+      {
+        appId,
+        baseUrl: credential.baseUrl,
+        clientId: credential.clientId,
+        tokenSet: {
+          ...tokenSet,
+          refreshToken: tokenSet.refreshToken ?? credential.refreshToken
+        }
+      },
+      options
+    );
+  })();
+  refreshesByCredentialPath.set(credentialPath, refresh);
+  try {
+    return await refresh;
+  } finally {
+    if (refreshesByCredentialPath.get(credentialPath) === refresh) {
+      refreshesByCredentialPath.delete(credentialPath);
+    }
+  }
+}
+function clearBusabaseAirAppOAuthCredential(appId, options = {}) {
+  rmSync(busabaseAirAppCredentialPath(appId, options), { force: true });
+}
+async function revokeBusabaseAirAppOAuthCredential(appId, options = {}, fetchImpl = fetch) {
+  const credential = loadBusabaseAirAppOAuthCredential(appId, options);
+  if (!credential) return;
+  try {
+    await revokeBusabaseOAuthToken(
+      {
+        baseUrl: credential.baseUrl,
+        token: credential.refreshToken,
+        clientId: credential.clientId
+      },
+      fetchImpl
+    );
+  } finally {
+    clearBusabaseAirAppOAuthCredential(appId, options);
+  }
+}
+
+export { busabaseAirAppCredentialPath, busabaseAirAppCredentialsDir, clearBusabaseAirAppOAuthCredential, getBusabaseAirAppAccessToken, loadBusabaseAirAppOAuthCredential, revokeBusabaseAirAppOAuthCredential, storeBusabaseAirAppOAuthCredential };

package/dist/oauth.d.ts

@@ -0,0 +1,55 @@
+/** Public client identifier used by local Hono/AirApp development servers. */
+declare const BUSABASE_AIRAPP_CLIENT_ID = "busabase-airapp";
+
+interface BusabaseOAuthRequest {
+    authorizeUrl: string;
+    baseUrl: string;
+    clientId: string;
+    codeVerifier: string;
+    redirectUri: string;
+    resource: string;
+    state: string;
+}
+interface CreateBusabaseOAuthRequestInput {
+    baseUrl: string;
+    redirectUri: string;
+    clientId?: string;
+    state?: string;
+    prompt?: "login";
+}
+interface BusabaseOAuthTokenSet {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn: number;
+    expiresAt: string;
+    scope: string[];
+    tokenType: string;
+    user?: {
+        id: string;
+        name: string;
+        email: string;
+        image: string | null;
+    };
+}
+declare class BusabaseOAuthError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    constructor(code: string, message: string, status?: number);
+}
+/** Build a public-client OAuth 2.1 authorization request with PKCE S256. */
+declare function createBusabaseOAuthRequest(input: CreateBusabaseOAuthRequestInput): Promise<BusabaseOAuthRequest>;
+/** Validate state and issuer before accepting the authorization code. */
+declare function parseBusabaseOAuthCallback(callbackUrl: string, request: BusabaseOAuthRequest): string;
+declare function exchangeBusabaseOAuthCode(request: BusabaseOAuthRequest, code: string, fetchImpl?: typeof fetch): Promise<BusabaseOAuthTokenSet>;
+declare function refreshBusabaseOAuthToken(input: {
+    baseUrl: string;
+    refreshToken: string;
+    clientId?: string;
+}, fetchImpl?: typeof fetch): Promise<BusabaseOAuthTokenSet>;
+declare function revokeBusabaseOAuthToken(input: {
+    baseUrl: string;
+    token: string;
+    clientId?: string;
+}, fetchImpl?: typeof fetch): Promise<void>;
+
+export { BUSABASE_AIRAPP_CLIENT_ID, BusabaseOAuthError, type BusabaseOAuthRequest, type BusabaseOAuthTokenSet, type CreateBusabaseOAuthRequestInput, createBusabaseOAuthRequest, exchangeBusabaseOAuthCode, parseBusabaseOAuthCallback, refreshBusabaseOAuthToken, revokeBusabaseOAuthToken };

package/dist/oauth.js

@@ -0,0 +1,2 @@
+export { BUSABASE_AIRAPP_CLIENT_ID, BusabaseOAuthError, createBusabaseOAuthRequest, exchangeBusabaseOAuthCode, parseBusabaseOAuthCallback, refreshBusabaseOAuthToken, revokeBusabaseOAuthToken } from './chunk-J2DZKX7A.js';
+import './chunk-5NYQX65A.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "busa-sdk",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Typed TypeScript/JavaScript SDK for the Busabase OpenAPI REST API. Talks to a local or remote `busabase server` (or Busabase Cloud). Short-name alias for busabase-sdk.",
   "license": "MIT",
   "homepage": "https://github.com/busabase/busabase/tree/main/apps/busabase-sdk",
@@ -22,6 +22,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./oauth": {
+      "types": "./dist/oauth.d.ts",
+      "default": "./dist/oauth.js"
+    },
+    "./oauth-node": {
+      "types": "./dist/oauth-node.d.ts",
+      "default": "./dist/oauth-node.js"
     }
   },
   "files": [