@dudousxd/nestjs-agent-dashboard 0.19.1 → 0.20.0

package/dist/server/index.js

@@ -82,6 +82,7 @@ var AGENT_ACTOR_RESOLVER = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:ac
 var DASHBOARD_BASE_PATH = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-dashboard:base-path");
 var DASHBOARD_API_PATH = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-dashboard:api-path");
 var DASHBOARD_APPROVAL_ACTOR_REF = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-dashboard:approval-actor-ref");
+var DASHBOARD_CONSOLE_OPTIONS = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-dashboard:console-options");
 
 // src/server/dashboard.service.ts
 function _ts_decorate(decorators, target, key, desc) {
@@ -1043,7 +1044,7 @@ __name(agentDashboardMountPaths, "agentDashboardMountPaths");
 // src/server/agent-dashboard.module.ts
 import { withControllerDecorators } from "@dudousxd/nestjs-agent-core";
 import "reflect-metadata";
-import { Module } from "@nestjs/common";
+import { Module, UseFilters as UseFilters2, UseGuards as UseGuards2 } from "@nestjs/common";
 import { RouterModule } from "@nestjs/core";
 
 // src/server/agent-ui.controller.ts
@@ -1051,7 +1052,187 @@ import { existsSync, readFileSync } from "fs";
 import { basename, extname, join, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { CanAnyone as CanAnyone2 } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller2, Get as Get2, Header, Inject as Inject3, NotFoundException as NotFoundException2, Param as Param2, Req as Req2, Res, StreamableFile } from "@nestjs/common";
+import { Controller as Controller2, Get as Get2, Header, Inject as Inject4, NotFoundException as NotFoundException2, Param as Param2, Req as Req2, Res, StreamableFile } from "@nestjs/common";
+
+// src/server/console-authorize.guard.ts
+import { Catch, HttpException, Inject as Inject3, Injectable as Injectable2, SetMetadata, UseFilters, UseGuards, applyDecorators } from "@nestjs/common";
+import { HttpAdapterHost, ModuleRef } from "@nestjs/core";
+
+// src/server/console-authorize.ts
+import { createHash, timingSafeEqual } from "crypto";
+import { Logger } from "@nestjs/common";
+var CONSOLE_GATE = /* @__PURE__ */ Symbol.for("@dudousxd/aviary:console-gate");
+var PACKAGE = "@dudousxd/nestjs-agent-dashboard";
+var MODULE = "AgentDashboardModule";
+var logger = new Logger(MODULE);
+var CONSOLE_AUTHORIZE_MISSING_WARNING = `[${PACKAGE}] console has no \`authorize\` configured: it is open outside production and denies every request in production. Set \`authorize\` in ${MODULE}.forRoot().`;
+var allow = /* @__PURE__ */ __name(() => ({
+  allowed: true
+}), "allow");
+var forbidden = /* @__PURE__ */ __name(() => ({
+  allowed: false,
+  reason: "forbidden"
+}), "forbidden");
+var unauthenticated = /* @__PURE__ */ __name(() => ({
+  allowed: false,
+  reason: "unauthenticated"
+}), "unauthenticated");
+function isProduction() {
+  return (process.env.NODE_ENV ?? "").trim().toLowerCase() === "production";
+}
+__name(isProduction, "isProduction");
+function normalizeConsoleResult(result) {
+  if (result === true) return allow();
+  if (result === null || typeof result !== "object") return forbidden();
+  const value = result;
+  if (typeof value.redirectTo === "string" && value.redirectTo !== "" && value.allowed !== true) {
+    return {
+      allowed: false,
+      reason: "unauthenticated",
+      redirectTo: value.redirectTo
+    };
+  }
+  if (value.allowed === true) return allow();
+  return value.reason === "unauthenticated" ? unauthenticated() : forbidden();
+}
+__name(normalizeConsoleResult, "normalizeConsoleResult");
+function isAuthorizerClass(value) {
+  if (typeof value !== "function") return false;
+  if (typeof value.prototype?.authorize === "function") {
+    return true;
+  }
+  return /^class[\s{]/.test(Function.prototype.toString.call(value));
+}
+__name(isAuthorizerClass, "isAuthorizerClass");
+function isPolicyCheck(value) {
+  return typeof value === "object" && value !== null && typeof value.policy === "function" && typeof value.ability === "string";
+}
+__name(isPolicyCheck, "isPolicyCheck");
+function lazyModuleClass(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const candidate = value.default;
+  return isAuthorizerClass(candidate) ? candidate : void 0;
+}
+__name(lazyModuleClass, "lazyModuleClass");
+function tryGet(moduleRef, token) {
+  try {
+    return moduleRef.get(token, {
+      strict: false
+    }) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(tryGet, "tryGet");
+function classInstances(moduleRef) {
+  const instances = /* @__PURE__ */ new Map();
+  return (Class) => {
+    let instance = instances.get(Class);
+    if (instance === void 0) {
+      const registered = tryGet(moduleRef, Class);
+      instance = registered !== void 0 ? Promise.resolve(registered) : moduleRef.create(Class);
+      instance.catch(() => instances.delete(Class));
+      instances.set(Class, instance);
+    }
+    return instance;
+  };
+}
+__name(classInstances, "classInstances");
+function hasUser(user) {
+  return user !== null && user !== void 0 && user !== false;
+}
+__name(hasUser, "hasUser");
+async function policyDecider(check, moduleRef) {
+  let mod;
+  try {
+    mod = await import("@nestjs/authorization");
+  } catch {
+    throw new Error(`${MODULE}: \`authorize: { policy, ability }\` needs @nestjs/authorization installed and AuthorizationModule imported; or pass a function, a class, or a gate name.`);
+  }
+  const service = tryGet(moduleRef, mod.AuthorizationService);
+  if (service === void 0) {
+    throw new Error(`${MODULE}: \`authorize: { policy, ability }\` needs AuthorizationModule.forRoot() from @nestjs/authorization imported in the app.`);
+  }
+  const options = tryGet(moduleRef, mod.AUTHORIZATION_MODULE_OPTIONS);
+  const getUser = options?.getUser ?? mod.defaultGetUser;
+  return async (context) => {
+    const user = await getUser(context);
+    const signedIn = hasUser(user);
+    if (await service.can(check.policy, check.ability, signedIn ? user : null)) return allow();
+    return signedIn ? forbidden() : unauthenticated();
+  };
+}
+__name(policyDecider, "policyDecider");
+async function resolveConsoleAuthorize(authorize, moduleRef, options = {}) {
+  const log = options.logger ?? logger;
+  if (authorize === void 0) {
+    if (options.warnIfMissing !== false) log.warn(CONSOLE_AUTHORIZE_MISSING_WARNING);
+    const production = isProduction();
+    return async () => production ? forbidden() : allow();
+  }
+  const instanceOf = classInstances(moduleRef);
+  let decide;
+  if (typeof authorize === "string") {
+    const name = authorize;
+    const gate = tryGet(moduleRef, CONSOLE_GATE);
+    if (gate === void 0) {
+      throw new Error(`${MODULE}: \`authorize: '${name}'\` needs @dudousxd/nestjs-authz's AuthzModule (it resolves gate names); or pass a function, a class, or { policy, ability }.`);
+    }
+    decide = /* @__PURE__ */ __name((context) => gate.allows(name, context), "decide");
+  } else if (isPolicyCheck(authorize)) {
+    decide = await policyDecider(authorize, moduleRef);
+  } else if (isAuthorizerClass(authorize)) {
+    const Class = authorize;
+    decide = /* @__PURE__ */ __name(async (context) => (await instanceOf(Class)).authorize(context), "decide");
+  } else if (typeof authorize === "function") {
+    const fn = authorize;
+    let lazyClass;
+    decide = /* @__PURE__ */ __name(async (context) => {
+      if (lazyClass !== void 0) return (await instanceOf(lazyClass)).authorize(context);
+      const result = await fn(context);
+      const Class = lazyModuleClass(result);
+      if (Class === void 0) return result;
+      lazyClass = Class;
+      return (await instanceOf(Class)).authorize(context);
+    }, "decide");
+  } else {
+    throw new Error(`${MODULE}: \`authorize\` must be a function, a class with authorize(), a lazy import, { policy, ability } or a gate name.`);
+  }
+  return async (context) => {
+    try {
+      return normalizeConsoleResult(await decide(context));
+    } catch (error) {
+      log.warn(`console \`authorize\` threw, denying the request: ${error instanceof Error ? error.message : String(error)}`);
+      return forbidden();
+    }
+  };
+}
+__name(resolveConsoleAuthorize, "resolveConsoleAuthorize");
+function sha256(value) {
+  return createHash("sha256").update(value).digest();
+}
+__name(sha256, "sha256");
+function authorizeByToken(options) {
+  const token = options.token;
+  if (typeof token !== "string" || token === "") {
+    throw new Error("authorizeByToken: `token` is empty; set it (e.g. from an env var).");
+  }
+  const expected = sha256(token);
+  return (context) => {
+    const req = context.switchToHttp().getRequest();
+    const header = req?.headers?.authorization;
+    const value = Array.isArray(header) ? header[0] : header;
+    const match = typeof value === "string" ? /^Bearer\s+(.+)$/i.exec(value.trim()) : null;
+    if (match?.[1] !== void 0 && timingSafeEqual(sha256(match[1]), expected)) return true;
+    return {
+      allowed: false,
+      reason: "unauthenticated"
+    };
+  };
+}
+__name(authorizeByToken, "authorizeByToken");
+
+// src/server/console-authorize.guard.ts
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -1078,6 +1259,161 @@ function _ts_param3(paramIndex, decorator) {
   };
 }
 __name(_ts_param3, "_ts_param");
+var DashboardConsoleAccess = class {
+  static {
+    __name(this, "DashboardConsoleAccess");
+  }
+  options;
+  moduleRef;
+  #decide;
+  constructor(options, moduleRef) {
+    this.options = options;
+    this.moduleRef = moduleRef;
+  }
+  #resolving;
+  /** Resolves `authorize` at boot: a configuration mistake fails the boot, and the warning logs once. */
+  async onModuleInit() {
+    this.#resolving ??= resolveConsoleAuthorize(this.options.authorize, this.moduleRef);
+    this.#decide = await this.#resolving;
+  }
+  /** The decision for one request. */
+  async check(context) {
+    if (this.#decide === void 0) await this.onModuleInit();
+    return this.#decide(context);
+  }
+};
+DashboardConsoleAccess = _ts_decorate3([
+  Injectable2(),
+  _ts_param3(0, Inject3(DASHBOARD_CONSOLE_OPTIONS)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DashboardConsoleOptions === "undefined" ? Object : DashboardConsoleOptions,
+    typeof ModuleRef === "undefined" ? Object : ModuleRef
+  ])
+], DashboardConsoleAccess);
+var CONSOLE_PAGE_METADATA = "@dudousxd/nestjs-agent-dashboard:console-page";
+var ConsolePage = /* @__PURE__ */ __name(() => SetMetadata(CONSOLE_PAGE_METADATA, true), "ConsolePage");
+var ConsoleAccessDenied = class extends HttpException {
+  static {
+    __name(this, "ConsoleAccessDenied");
+  }
+  decision;
+  page;
+  constructor(decision, page) {
+    super(decision.reason === "forbidden" ? {
+      error: "forbidden"
+    } : {
+      error: "unauthenticated",
+      ...decision.redirectTo !== void 0 ? {
+        redirectTo: decision.redirectTo
+      } : {}
+    }, decision.reason === "forbidden" ? 403 : 401), this.decision = decision, this.page = page;
+  }
+};
+function isPageNavigation(context) {
+  if (context.getType() !== "http") return false;
+  const page = Reflect.getMetadata(CONSOLE_PAGE_METADATA, context.getHandler()) === true || Reflect.getMetadata(CONSOLE_PAGE_METADATA, context.getClass()) === true;
+  if (!page) return false;
+  const req = context.switchToHttp().getRequest();
+  if ((req.method ?? "GET").toUpperCase() !== "GET") return false;
+  const accept = req.headers?.accept;
+  const value = Array.isArray(accept) ? accept.join(",") : accept ?? "";
+  return value.includes("text/html");
+}
+__name(isPageNavigation, "isPageNavigation");
+var ConsoleAuthorizeGuard = class {
+  static {
+    __name(this, "ConsoleAuthorizeGuard");
+  }
+  access;
+  constructor(access) {
+    this.access = access;
+  }
+  async canActivate(context) {
+    const decision = await this.access.check(context);
+    if (decision.allowed) return true;
+    throw new ConsoleAccessDenied(decision, isPageNavigation(context));
+  }
+};
+ConsoleAuthorizeGuard = _ts_decorate3([
+  Injectable2(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DashboardConsoleAccess === "undefined" ? Object : DashboardConsoleAccess
+  ])
+], ConsoleAuthorizeGuard);
+function deniedPage(title, message) {
+  const body = "font-family:system-ui,sans-serif;display:grid;place-items:center;min-height:100vh;margin:0";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${title}</title></head><body style="${body}"><main style="text-align:center"><h1>${title}</h1><p>${message}</p></main></body></html>`;
+}
+__name(deniedPage, "deniedPage");
+var FORBIDDEN_PAGE = deniedPage("Access denied", "You do not have access to this console.");
+var UNAUTHENTICATED_PAGE = deniedPage("Sign in required", "Sign in to open this console.");
+var ConsoleAuthorizeFilter = class {
+  static {
+    __name(this, "ConsoleAuthorizeFilter");
+  }
+  adapterHost;
+  constructor(adapterHost) {
+    this.adapterHost = adapterHost;
+  }
+  catch(exception, host) {
+    const adapter = this.adapterHost.httpAdapter;
+    const res = host.switchToHttp().getResponse();
+    const { decision, page } = exception;
+    if (page && decision.reason === "unauthenticated" && decision.redirectTo !== void 0) {
+      adapter.redirect(res, 302, decision.redirectTo);
+      return;
+    }
+    if (page) {
+      const forbidden2 = decision.reason === "forbidden";
+      adapter.setHeader(res, "Content-Type", "text/html; charset=utf-8");
+      adapter.reply(res, forbidden2 ? FORBIDDEN_PAGE : UNAUTHENTICATED_PAGE, forbidden2 ? 403 : 401);
+      return;
+    }
+    adapter.reply(res, exception.getResponse(), exception.getStatus());
+  }
+};
+ConsoleAuthorizeFilter = _ts_decorate3([
+  Catch(ConsoleAccessDenied),
+  Injectable2(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost
+  ])
+], ConsoleAuthorizeFilter);
+function UseConsoleAuthorize() {
+  return applyDecorators(UseGuards(ConsoleAuthorizeGuard), UseFilters(ConsoleAuthorizeFilter));
+}
+__name(UseConsoleAuthorize, "UseConsoleAuthorize");
+
+// src/server/agent-ui.controller.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
 var BUILD_BASE = "/ai-gateway";
 function spaDir() {
   return fileURLToPath(new URL("../spa", import.meta.url));
@@ -1133,45 +1469,46 @@ var AgentUiController = class {
     });
   }
 };
-_ts_decorate3([
+_ts_decorate4([
   Get2(),
+  ConsolePage(),
   Header("Content-Type", "text/html; charset=utf-8"),
   Header("Cache-Control", "no-store, must-revalidate"),
-  _ts_param3(0, Req2()),
-  _ts_param3(1, Res({
+  _ts_param4(0, Req2()),
+  _ts_param4(1, Res({
     passthrough: true
   })),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     typeof UiPageRequest === "undefined" ? Object : UiPageRequest,
     typeof UiPageResponse === "undefined" ? Object : UiPageResponse
   ]),
-  _ts_metadata3("design:returntype", String)
+  _ts_metadata4("design:returntype", String)
 ], AgentUiController.prototype, "index", null);
-_ts_decorate3([
+_ts_decorate4([
   Get2("assets/:file"),
   Header("Cache-Control", "public, max-age=31536000, immutable"),
-  _ts_param3(0, Param2("file")),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param4(0, Param2("file")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String
   ]),
-  _ts_metadata3("design:returntype", typeof StreamableFile === "undefined" ? Object : StreamableFile)
+  _ts_metadata4("design:returntype", typeof StreamableFile === "undefined" ? Object : StreamableFile)
 ], AgentUiController.prototype, "asset", null);
-AgentUiController = _ts_decorate3([
+AgentUiController = _ts_decorate4([
   CanAnyone2(),
   Controller2(),
-  _ts_param3(0, Inject3(DASHBOARD_BASE_PATH)),
-  _ts_param3(1, Inject3(DASHBOARD_API_PATH)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param4(0, Inject4(DASHBOARD_BASE_PATH)),
+  _ts_param4(1, Inject4(DASHBOARD_API_PATH)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
     String
   ])
 ], AgentUiController);
 
 // src/server/agent-dashboard.module.ts
-function _ts_decorate4(decorators, target, key, desc) {
+function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -1184,23 +1521,29 @@ function _ts_decorate4(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate4, "_ts_decorate");
+__name(_ts_decorate5, "_ts_decorate");
 function normalize(path) {
   return normalizeDashboardPath(path);
 }
 __name(normalize, "normalize");
-function assertProtected(options) {
-  if (process.env.NODE_ENV !== "production") return;
-  if (options.routes === false) return;
-  if ((options.decorators ?? []).length > 0) return;
-  throw new Error("AgentDashboardModule: the AI-gateway console would be served open in production. Say who reaches it, with `decorators: [UseGuards(AuthenticationGuard), Can(ConsolePolicy, 'view')]`, or mount its routes yourself with `routes: false` and extend `AgentApiController` / `AgentUiController` under your own guards.");
+function consoleDecorators(decorators) {
+  return [
+    ...decorators ?? [],
+    UseGuards2(ConsoleAuthorizeGuard),
+    UseFilters2(ConsoleAuthorizeFilter)
+  ];
 }
-__name(assertProtected, "assertProtected");
+__name(consoleDecorators, "consoleDecorators");
 var AgentApiModule = class _AgentApiModule {
   static {
     __name(this, "AgentApiModule");
   }
   static register(options) {
+    const consoleOptions = {
+      ...options.authorize !== void 0 ? {
+        authorize: options.authorize
+      } : {}
+    };
     return {
       module: _AgentApiModule,
       imports: [
@@ -1208,7 +1551,7 @@ var AgentApiModule = class _AgentApiModule {
       ],
       controllers: options.routes === false ? [] : withControllerDecorators([
         AgentApiController
-      ], options.decorators),
+      ], consoleDecorators(options.decorators)),
       providers: [
         DashboardService,
         // `useValue` even when `options.approvalActorRef` is `undefined` — AgentApiController
@@ -1216,17 +1559,24 @@ var AgentApiModule = class _AgentApiModule {
         {
           provide: DASHBOARD_APPROVAL_ACTOR_REF,
           useValue: options.approvalActorRef
-        }
+        },
+        {
+          provide: DASHBOARD_CONSOLE_OPTIONS,
+          useValue: consoleOptions
+        },
+        DashboardConsoleAccess
       ],
-      // What a self-mounted `AgentApiController` subclass injects, too (`routes: false`).
+      // What a self-mounted `AgentApiController` subclass injects, too (`routes: false`), and the
+      // access check `UseConsoleAuthorize()` runs.
       exports: [
         DashboardService,
-        DASHBOARD_APPROVAL_ACTOR_REF
+        DASHBOARD_APPROVAL_ACTOR_REF,
+        DashboardConsoleAccess
       ]
     };
   }
 };
-AgentApiModule = _ts_decorate4([
+AgentApiModule = _ts_decorate5([
   Module({})
 ], AgentApiModule);
 var AgentDashboardModule = class _AgentDashboardModule {
@@ -1234,7 +1584,6 @@ var AgentDashboardModule = class _AgentDashboardModule {
     __name(this, "AgentDashboardModule");
   }
   static forRoot(options = {}) {
-    assertProtected(options);
     const basePath = normalize(options.basePath ?? "/ai-gateway");
     const apiBasePath = normalize(options.apiBasePath ?? `${basePath}/api`);
     return {
@@ -1254,6 +1603,9 @@ var AgentDashboardModule = class _AgentDashboardModule {
           } : {},
           ...options.approvalActorRef ? {
             approvalActorRef: options.approvalActorRef
+          } : {},
+          ...options.authorize !== void 0 ? {
+            authorize: options.authorize
           } : {}
         }),
         ...options.routes === false ? [] : [
@@ -1271,7 +1623,7 @@ var AgentDashboardModule = class _AgentDashboardModule {
       ],
       controllers: options.routes === false ? [] : withControllerDecorators([
         AgentUiController
-      ], options.decorators),
+      ], consoleDecorators(options.decorators)),
       providers: [
         {
           provide: DASHBOARD_BASE_PATH,
@@ -1292,7 +1644,7 @@ var AgentDashboardModule = class _AgentDashboardModule {
     };
   }
 };
-AgentDashboardModule = _ts_decorate4([
+AgentDashboardModule = _ts_decorate5([
   Module({})
 ], AgentDashboardModule);
 export {
@@ -1305,11 +1657,24 @@ export {
   AgentApiModule,
   AgentDashboardModule,
   AgentUiController,
+  CONSOLE_AUTHORIZE_MISSING_WARNING,
+  CONSOLE_GATE,
+  CONSOLE_PAGE_METADATA,
+  ConsoleAccessDenied,
+  ConsoleAuthorizeFilter,
+  ConsoleAuthorizeGuard,
+  ConsolePage,
   DASHBOARD_API_PATH,
   DASHBOARD_APPROVAL_ACTOR_REF,
   DASHBOARD_BASE_PATH,
+  DASHBOARD_CONSOLE_OPTIONS,
+  DashboardConsoleAccess,
   DashboardService,
+  UseConsoleAuthorize,
   agentDashboardMountPaths,
-  parsePriceInput
+  authorizeByToken,
+  normalizeConsoleResult,
+  parsePriceInput,
+  resolveConsoleAuthorize
 };
 //# sourceMappingURL=index.js.map