@dbx-tools/appkit 0.6.59 → 0.6.60

package/README.md

@@ -20,6 +20,12 @@ Lakebase auto-configuration without taking on a heavier feature package.
   `Context` values.
 - Lakebase cache-schema provisioning for deployments where the app identity must
   be granted access before persistent cache initialization.
+- An interceptor context on `createApp` (`interceptor?: Interceptor | Interceptor[]`)
+  that hands add-ons the computed env, AppKit lifecycle hooks (`onLifecycle`, using
+  AppKit's own `setup:complete` / `server:ready` / `shutdown` vocabulary), signal
+  broadcast, and `bindProcess` for concurrently-style child supervision - any
+  bound process's death tears the app down, signals pass through. `@dbx-tools/tunnel`
+  is the primary consumer.
 
 ## Why Use This Over Native AppKit
 
@@ -99,7 +105,7 @@ pool. AppKit's PERSISTENT cache is the common case: it builds its own pool from
 env, and `createLakebasePool()` throws unless `LAKEBASE_ENDPOINT`, `PGHOST`,
 `PGDATABASE`, and a username are all present — while a Databricks App `postgres`
 resource binding supplies only the first. Miss one and the cache degrades silently
-to in-memory. `@dbx-tools/cli-tunnel`'s OTP gate calls this for exactly that
+to in-memory. `@dbx-tools/tunnel`'s OTP gate calls this for exactly that
 reason.
 
 ## Configuration
@@ -109,6 +115,7 @@ reason.
 | Option          | Type                            | Default       | Description                                                                                                                                                                                                                                                                                                                 |
 | --------------- | ------------------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `autoConfigure` | `"provision" \| "env" \| false` | `"provision"` | What to run before AppKit boots. `"provision"` resolves the Lakebase connection into `process.env` and grants the AppKit cache schema; `"env"` resolves the connection only; `false` skips auto-configuration. Omit it to gate the default on a `lakebase` plugin being registered, or set it explicitly to run regardless. |
+| `interceptor`   | `Interceptor \| Interceptor[]`  | none          | One or many callbacks handed an `InterceptorContext` after auto-config computes the env and before AppKit boots. The context carries the resolved env, `onLifecycle` (AppKit's `setup:complete` / `server:ready` / `shutdown`), `broadcastSignal`, and `bindProcess` for concurrently-style child supervision.              |
 
 Set `autoConfigure` explicitly on an app that registers no `lakebase()` plugin but
 still wants AppKit's PERSISTENT cache. AppKit only chooses Lakebase for
@@ -277,7 +284,7 @@ behaviour depends entirely on `NODE_ENV`:
 That throw is right for an app behind the front door, where a missing token means
 something is broken. It is fatal for an app whose traffic legitimately arrives
 without one - a public tunnel where callers authenticate by email code
-([`@dbx-tools/cli-tunnel`](../../cli/tunnel)), or a bot channel that validates its
+([`@dbx-tools/tunnel`](../../node/tunnel)), or a bot channel that validates its
 own inbound JWT (`POST /api/teams/messages`). Those apps must not run with
 `NODE_ENV=development` just to get the fallback, since that flag also relaxes
 secure cookies and unlocks other dev-only escape hatches.

package/index.ts

@@ -7,6 +7,7 @@ export * as config from "./src/config.ts";
 export * as createApp from "./src/create-app.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
+export * as interceptor from "./src/interceptor.ts";
 export * as lakebaseResolver from "./src/lakebase-resolver.ts";
 export * as pgaddress from "./src/pgaddress.ts";
 export * as plugin from "./src/plugin.ts";
@@ -18,6 +19,8 @@ export { MAX_TCP_PORT } from "./src/databricks.ts";
 export type { ContextLike } from "./src/databricks.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";
 export type { IdentityMode, HeaderBearing } from "./src/identity.ts";
+export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.ts";
+export type { LifecycleEvent, LifecycleHandler, ResolvedAppEnv, BindableProcess, InterceptorContext, Interceptor, InterceptorRuntime } from "./src/interceptor.ts";
 export type { LakebaseResolverInputs, LakebaseConnection } from "./src/lakebase-resolver.ts";
 export { SSL_MODES } from "./src/pgaddress.ts";
 export type { SslMode, LakebaseConnectionInputs, ParsedAddress } from "./src/pgaddress.ts";

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export * as config from "./src/config.ts";
 export * as createApp from "./src/create-app.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
+export * as interceptor from "./src/interceptor.ts";
 export * as lakebaseResolver from "./src/lakebase-resolver.ts";
 export * as pgaddress from "./src/pgaddress.ts";
 export * as plugin from "./src/plugin.ts";
@@ -14,6 +15,8 @@ export { MAX_TCP_PORT } from "./src/databricks.ts";
 export type { ContextLike } from "./src/databricks.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";
 export type { IdentityMode, HeaderBearing } from "./src/identity.ts";
+export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.ts";
+export type { LifecycleEvent, LifecycleHandler, ResolvedAppEnv, BindableProcess, InterceptorContext, Interceptor, InterceptorRuntime } from "./src/interceptor.ts";
 export type { LakebaseResolverInputs, LakebaseConnection } from "./src/lakebase-resolver.ts";
 export { SSL_MODES } from "./src/pgaddress.ts";
 export type { SslMode, LakebaseConnectionInputs, ParsedAddress } from "./src/pgaddress.ts";

package/lib/index.js

@@ -6,11 +6,13 @@ export * as config from "./src/config.js";
 export * as createApp from "./src/create-app.js";
 export * as databricks from "./src/databricks.js";
 export * as identity from "./src/identity.js";
+export * as interceptor from "./src/interceptor.js";
 export * as lakebaseResolver from "./src/lakebase-resolver.js";
 export * as pgaddress from "./src/pgaddress.js";
 export * as plugin from "./src/plugin.js";
 export * as provision from "./src/provision.js";
 export { MAX_TCP_PORT } from "./src/databricks.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.js";
+export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.js";
 export { SSL_MODES } from "./src/pgaddress.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/create-app.d.ts

@@ -22,6 +22,8 @@
  */
 import { createApp as appkitCreateApp } from "@databricks/appkit";
 import type { PluginMap } from "@databricks/appkit/dist/shared/src/plugin";
+import { type Interceptor } from "./interceptor.ts";
+import { type LakebaseConnection } from "./lakebase-resolver.ts";
 type AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;
 type AppKitPlugins = NonNullable<AppKitCreateAppConfig["plugins"]>;
 /**
@@ -50,6 +52,13 @@ export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<AppK
     onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;
     /** Auto-configuration to run before AppKit boots. Defaults to `"provision"`. */
     autoConfigure?: AutoConfigureMode | false;
+    /**
+     * One or many {@link Interceptor}s handed an {@link InterceptorContext} once
+     * auto-configuration has computed the env. Each receives the resolved env, an
+     * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -
+     * see `./interceptor`. The tunnel is the primary consumer.
+     */
+    interceptor?: Interceptor | Interceptor[];
 };
 /**
  * Run enabled auto-configuration steps without calling AppKit's `createApp`.
@@ -65,11 +74,18 @@ export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<AppK
  * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.
  * await createApp.autoConfigure({ autoConfigure: "env" });
  */
-export declare function autoConfigure<T extends AppKitPlugins>(config?: CreateAppConfig<T>, signal?: AbortSignal): Promise<void>;
+export declare function autoConfigure<T extends AppKitPlugins>(config?: CreateAppConfig<T>, signal?: AbortSignal): Promise<LakebaseConnection | undefined>;
 /**
  * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
  * plugin-export map, with {@link autoConfigure} run first.
  *
+ * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an
+ * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE
+ * AppKit boots - so an interceptor can read the resolved connection, register
+ * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}
+ * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit
+ * events; it has no exports, so the returned {@link PluginMap} is unchanged.
+ *
  * @example
  * import { createApp } from "@dbx-tools/appkit";
  * import { lakebase, server } from "@databricks/appkit";

package/lib/src/create-app.js

@@ -22,6 +22,7 @@
  */
 import { createApp as appkitCreateApp } from "@databricks/appkit";
 import { async, log } from "@dbx-tools/shared-core";
+import { createInterceptorContext, lifecycleBridge, } from "./interceptor.js";
 import { applyLakebaseEnv } from "./lakebase-resolver.js";
 import { provisionCacheSchema } from "./provision.js";
 const logger = log.logger("create-app");
@@ -63,14 +64,15 @@ export async function autoConfigure(config, signal) {
             provisioned: false,
             skippedReason: mode === false ? "disabled" : "no lakebase plugin",
         });
-        return;
+        return undefined;
     }
     const controller = new AbortController();
     async.tieAbortSignal(controller, signal);
     async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));
     const provision = mode === "provision";
-    await autoConfigureLakebase(provision, controller.signal);
+    const resolved = await autoConfigureLakebase(provision, controller.signal);
     logger.info("ready", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });
+    return resolved;
 }
 /**
  * Resolve Lakebase Postgres connection info, write the resolved values to
@@ -97,10 +99,30 @@ function redactLakebaseConnection(resolved) {
         sslMode: resolved.sslMode,
     };
 }
+/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */
+function resolvedAppEnv(lakebase) {
+    return {
+        ...(lakebase ? { lakebase } : {}),
+        ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),
+    };
+}
+/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */
+function interceptorList(interceptor) {
+    if (!interceptor)
+        return [];
+    return Array.isArray(interceptor) ? interceptor : [interceptor];
+}
 /**
  * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
  * plugin-export map, with {@link autoConfigure} run first.
  *
+ * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an
+ * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE
+ * AppKit boots - so an interceptor can read the resolved connection, register
+ * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}
+ * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit
+ * events; it has no exports, so the returned {@link PluginMap} is unchanged.
+ *
  * @example
  * import { createApp } from "@dbx-tools/appkit";
  * import { lakebase, server } from "@databricks/appkit";
@@ -108,9 +130,25 @@ function redactLakebaseConnection(resolved) {
  * const app = await createApp.createApp({ plugins: [server(), lakebase()] });
  */
 export async function createApp(config) {
-    await autoConfigure(config);
+    const lakebase = await autoConfigure(config);
     const appConfig = { ...config };
     delete appConfig.autoConfigure;
+    delete appConfig.interceptor;
+    const interceptors = interceptorList(config?.interceptor);
+    if (interceptors.length === 0) {
+        return appkitCreateApp(appConfig);
+    }
+    // Build the context from the computed env, run each interceptor (they register
+    // lifecycle handlers + bind processes), then inject the bridge that relays the
+    // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.
+    const runtime = createInterceptorContext(resolvedAppEnv(lakebase));
+    for (const interceptor of interceptors) {
+        await interceptor(runtime.context);
+    }
+    // Append the bridge to the plugins tuple. It is hidden and exports nothing, so
+    // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is
+    // only because appending widens the tuple type beyond `T`.
+    appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })];
     return appkitCreateApp(appConfig);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-app.js","sourceRoot":"","sources":["../../src/create-app.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `createApp` wrapper: runs dbx-tools auto-configuration, then delegates to\n * AppKit's own `createApp` with the exact same arguments.\n *\n * Drop it in as a one-for-one replacement for `@databricks/appkit`'s\n * `createApp` - same parameters, same return type, full plugin-export inference\n * preserved:\n *\n * ```ts\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { lakebase, server } from \"@databricks/appkit\";\n *\n * await createApp.createApp({ plugins: [server(), lakebase()] });\n * ```\n *\n * Auto-configuration runs BEFORE delegating so plugins see a fully populated\n * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when\n * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set\n * explicitly on the config object.\n *\n * @module\n */\n\nimport { createApp as appkitCreateApp } from \"@databricks/appkit\";\n// AppKit's root barrel re-exports `PluginData` but not `PluginMap`; the package\n// publishes this subpath for exactly that type.\nimport type { PluginMap } from \"@databricks/appkit/dist/shared/src/plugin\";\nimport { async, log } from \"@dbx-tools/shared-core\";\n\nimport { applyLakebaseEnv, type LakebaseConnection } from \"./lakebase-resolver.ts\";\nimport { provisionCacheSchema } from \"./provision.ts\";\n\ntype AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;\ntype AppKitPlugins = NonNullable<AppKitCreateAppConfig[\"plugins\"]>;\n\n/**\n * What auto-configuration does before AppKit boots.\n *\n * - `\"provision\"`: resolve the Lakebase connection into `process.env`, then\n *   grant the AppKit cache schema to the connecting role.\n * - `\"env\"`: resolve the Lakebase connection into `process.env` only.\n *\n * Omit it to get `\"provision\"` gated on a `lakebase` plugin being registered;\n * set it explicitly to run regardless of the plugin list, or pass `false` to\n * skip auto-configuration entirely.\n *\n * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants\n * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when\n * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /\n * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the\n * cache silently falls back to in-memory, and anything it holds (a session\n * signing key, a one-time code) is lost on restart. `\"env\"` is the right mode\n * there: the app SP cannot grant on the cache schema anyway.\n */\nexport type AutoConfigureMode = \"env\" | \"provision\";\n\n/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */\nexport type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<\n  AppKitCreateAppConfig,\n  \"plugins\" | \"onPluginsReady\"\n> & {\n  plugins?: T;\n  onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;\n  /** Auto-configuration to run before AppKit boots. Defaults to `\"provision\"`. */\n  autoConfigure?: AutoConfigureMode | false;\n};\n\nconst logger = log.logger(\"create-app\");\n\nconst LAKEBASE_PLUGIN = \"lakebase\";\nconst DEFAULT_AUTO_CONFIGURE: AutoConfigureMode = \"provision\";\n\n/**\n * Upper bound on boot-time auto-configuration. It runs as the service principal\n * before any plugin is constructed, so it sits outside AppKit's interceptor\n * chain and inherits no timeout, retry, or telemetry from it. The budget covers\n * the resolver's own worst case (create a project, then wait for its endpoint)\n * plus the cache-schema grants.\n */\nconst AUTO_CONFIGURE_TIMEOUT_MS = 11 * 60_000;\n\nfunction usesPlugin<T extends AppKitPlugins>(\n  config: CreateAppConfig<T> | undefined,\n  name: string,\n): boolean {\n  return Boolean(config?.plugins?.some((entry) => entry.name === name));\n}\n\n/**\n * Run enabled auto-configuration steps without calling AppKit's `createApp`.\n *\n * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set\n * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`\n * cancels the resolution; it is combined with an internal boot timeout either\n * way.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n *\n * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.\n * await createApp.autoConfigure({ autoConfigure: \"env\" });\n */\nexport async function autoConfigure<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n  signal?: AbortSignal,\n): Promise<void> {\n  const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;\n  const explicit = config?.autoConfigure !== undefined;\n  const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);\n  if (mode === false || !(explicit || lakebasePluginPresent)) {\n    logger.info(\"ready\", {\n      autoConfigure: mode,\n      lakebasePluginPresent,\n      provisioned: false,\n      skippedReason: mode === false ? \"disabled\" : \"no lakebase plugin\",\n    });\n    return;\n  }\n\n  const controller = new AbortController();\n  async.tieAbortSignal(controller, signal);\n  async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));\n\n  const provision = mode === \"provision\";\n  await autoConfigureLakebase(provision, controller.signal);\n  logger.info(\"ready\", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });\n}\n\n/**\n * Resolve Lakebase Postgres connection info, write the resolved values to\n * `process.env`, and return the record. Used by {@link autoConfigure}; call\n * {@link applyLakebaseEnv} directly when finer control is needed (a different\n * `autoCreate` policy, or a caller that wants the env without booting AppKit).\n */\nasync function autoConfigureLakebase(\n  provision: boolean,\n  signal: AbortSignal,\n): Promise<LakebaseConnection> {\n  const { resolved, user } = await applyLakebaseEnv(undefined, signal);\n  logger.info(\"env updated\", { ...redactLakebaseConnection(resolved), user });\n  if (provision) {\n    await provisionCacheSchema(user, logger);\n  }\n  return resolved;\n}\n\nfunction redactLakebaseConnection(resolved: LakebaseConnection): Record<string, unknown> {\n  return {\n    project: resolved.project,\n    branch: resolved.branch,\n    endpoint: resolved.endpoint,\n    database: resolved.database,\n    host: resolved.host,\n    port: resolved.port,\n    sslMode: resolved.sslMode,\n  };\n}\n\n/**\n * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed\n * plugin-export map, with {@link autoConfigure} run first.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { lakebase, server } from \"@databricks/appkit\";\n *\n * const app = await createApp.createApp({ plugins: [server(), lakebase()] });\n */\nexport async function createApp<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n): Promise<PluginMap<T>> {\n  await autoConfigure(config);\n  const appConfig = { ...config };\n  delete appConfig.autoConfigure;\n  return appkitCreateApp<T>(appConfig);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-app.js","sourceRoot":"","sources":["../../src/create-app.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `createApp` wrapper: runs dbx-tools auto-configuration, then delegates to\n * AppKit's own `createApp` with the exact same arguments.\n *\n * Drop it in as a one-for-one replacement for `@databricks/appkit`'s\n * `createApp` - same parameters, same return type, full plugin-export inference\n * preserved:\n *\n * ```ts\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { lakebase, server } from \"@databricks/appkit\";\n *\n * await createApp.createApp({ plugins: [server(), lakebase()] });\n * ```\n *\n * Auto-configuration runs BEFORE delegating so plugins see a fully populated\n * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when\n * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set\n * explicitly on the config object.\n *\n * @module\n */\n\nimport { createApp as appkitCreateApp } from \"@databricks/appkit\";\n// AppKit's root barrel re-exports `PluginData` but not `PluginMap`; the package\n// publishes this subpath for exactly that type.\nimport type { PluginMap } from \"@databricks/appkit/dist/shared/src/plugin\";\nimport { async, log } from \"@dbx-tools/shared-core\";\n\nimport {\n  createInterceptorContext,\n  type Interceptor,\n  type InterceptorRuntime,\n  lifecycleBridge,\n  type ResolvedAppEnv,\n} from \"./interceptor.ts\";\nimport { applyLakebaseEnv, type LakebaseConnection } from \"./lakebase-resolver.ts\";\nimport { provisionCacheSchema } from \"./provision.ts\";\n\ntype AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;\ntype AppKitPlugins = NonNullable<AppKitCreateAppConfig[\"plugins\"]>;\n\n/**\n * What auto-configuration does before AppKit boots.\n *\n * - `\"provision\"`: resolve the Lakebase connection into `process.env`, then\n *   grant the AppKit cache schema to the connecting role.\n * - `\"env\"`: resolve the Lakebase connection into `process.env` only.\n *\n * Omit it to get `\"provision\"` gated on a `lakebase` plugin being registered;\n * set it explicitly to run regardless of the plugin list, or pass `false` to\n * skip auto-configuration entirely.\n *\n * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants\n * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when\n * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /\n * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the\n * cache silently falls back to in-memory, and anything it holds (a session\n * signing key, a one-time code) is lost on restart. `\"env\"` is the right mode\n * there: the app SP cannot grant on the cache schema anyway.\n */\nexport type AutoConfigureMode = \"env\" | \"provision\";\n\n/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */\nexport type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<\n  AppKitCreateAppConfig,\n  \"plugins\" | \"onPluginsReady\"\n> & {\n  plugins?: T;\n  onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;\n  /** Auto-configuration to run before AppKit boots. Defaults to `\"provision\"`. */\n  autoConfigure?: AutoConfigureMode | false;\n  /**\n   * One or many {@link Interceptor}s handed an {@link InterceptorContext} once\n   * auto-configuration has computed the env. Each receives the resolved env, an\n   * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -\n   * see `./interceptor`. The tunnel is the primary consumer.\n   */\n  interceptor?: Interceptor | Interceptor[];\n};\n\nconst logger = log.logger(\"create-app\");\n\nconst LAKEBASE_PLUGIN = \"lakebase\";\nconst DEFAULT_AUTO_CONFIGURE: AutoConfigureMode = \"provision\";\n\n/**\n * Upper bound on boot-time auto-configuration. It runs as the service principal\n * before any plugin is constructed, so it sits outside AppKit's interceptor\n * chain and inherits no timeout, retry, or telemetry from it. The budget covers\n * the resolver's own worst case (create a project, then wait for its endpoint)\n * plus the cache-schema grants.\n */\nconst AUTO_CONFIGURE_TIMEOUT_MS = 11 * 60_000;\n\nfunction usesPlugin<T extends AppKitPlugins>(\n  config: CreateAppConfig<T> | undefined,\n  name: string,\n): boolean {\n  return Boolean(config?.plugins?.some((entry) => entry.name === name));\n}\n\n/**\n * Run enabled auto-configuration steps without calling AppKit's `createApp`.\n *\n * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set\n * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`\n * cancels the resolution; it is combined with an internal boot timeout either\n * way.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n *\n * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.\n * await createApp.autoConfigure({ autoConfigure: \"env\" });\n */\nexport async function autoConfigure<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n  signal?: AbortSignal,\n): Promise<LakebaseConnection | undefined> {\n  const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;\n  const explicit = config?.autoConfigure !== undefined;\n  const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);\n  if (mode === false || !(explicit || lakebasePluginPresent)) {\n    logger.info(\"ready\", {\n      autoConfigure: mode,\n      lakebasePluginPresent,\n      provisioned: false,\n      skippedReason: mode === false ? \"disabled\" : \"no lakebase plugin\",\n    });\n    return undefined;\n  }\n\n  const controller = new AbortController();\n  async.tieAbortSignal(controller, signal);\n  async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));\n\n  const provision = mode === \"provision\";\n  const resolved = await autoConfigureLakebase(provision, controller.signal);\n  logger.info(\"ready\", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });\n  return resolved;\n}\n\n/**\n * Resolve Lakebase Postgres connection info, write the resolved values to\n * `process.env`, and return the record. Used by {@link autoConfigure}; call\n * {@link applyLakebaseEnv} directly when finer control is needed (a different\n * `autoCreate` policy, or a caller that wants the env without booting AppKit).\n */\nasync function autoConfigureLakebase(\n  provision: boolean,\n  signal: AbortSignal,\n): Promise<LakebaseConnection> {\n  const { resolved, user } = await applyLakebaseEnv(undefined, signal);\n  logger.info(\"env updated\", { ...redactLakebaseConnection(resolved), user });\n  if (provision) {\n    await provisionCacheSchema(user, logger);\n  }\n  return resolved;\n}\n\nfunction redactLakebaseConnection(resolved: LakebaseConnection): Record<string, unknown> {\n  return {\n    project: resolved.project,\n    branch: resolved.branch,\n    endpoint: resolved.endpoint,\n    database: resolved.database,\n    host: resolved.host,\n    port: resolved.port,\n    sslMode: resolved.sslMode,\n  };\n}\n\n/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */\nfunction resolvedAppEnv(lakebase: LakebaseConnection | undefined): ResolvedAppEnv {\n  return {\n    ...(lakebase ? { lakebase } : {}),\n    ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),\n  };\n}\n\n/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */\nfunction interceptorList(interceptor: CreateAppConfig[\"interceptor\"]): Interceptor[] {\n  if (!interceptor) return [];\n  return Array.isArray(interceptor) ? interceptor : [interceptor];\n}\n\n/**\n * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed\n * plugin-export map, with {@link autoConfigure} run first.\n *\n * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an\n * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE\n * AppKit boots - so an interceptor can read the resolved connection, register\n * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}\n * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit\n * events; it has no exports, so the returned {@link PluginMap} is unchanged.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { lakebase, server } from \"@databricks/appkit\";\n *\n * const app = await createApp.createApp({ plugins: [server(), lakebase()] });\n */\nexport async function createApp<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n): Promise<PluginMap<T>> {\n  const lakebase = await autoConfigure(config);\n  const appConfig = { ...config };\n  delete appConfig.autoConfigure;\n  delete appConfig.interceptor;\n\n  const interceptors = interceptorList(config?.interceptor);\n  if (interceptors.length === 0) {\n    return appkitCreateApp<T>(appConfig);\n  }\n\n  // Build the context from the computed env, run each interceptor (they register\n  // lifecycle handlers + bind processes), then inject the bridge that relays the\n  // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.\n  const runtime: InterceptorRuntime = createInterceptorContext(resolvedAppEnv(lakebase));\n  for (const interceptor of interceptors) {\n    await interceptor(runtime.context);\n  }\n  // Append the bridge to the plugins tuple. It is hidden and exports nothing, so\n  // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is\n  // only because appending widens the tuple type beyond `T`.\n  appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })] as unknown as T;\n  return appkitCreateApp<T>(appConfig);\n}\n"]}

package/lib/src/identity.d.ts

@@ -20,7 +20,7 @@
  * where a missing token means something is wrong. It is fatal for an app whose
  * traffic legitimately arrives WITHOUT one:
  *
- *   - a public tunnel (`@dbx-tools/cli-tunnel`), where callers authenticate by
+ *   - a public tunnel (`@dbx-tools/tunnel`), where callers authenticate by
  *     email OTP and no OBO token exists to forward - the gate can prove WHO the
  *     caller is, but it cannot mint a Databricks credential for them;
  *   - any reverse proxy, webhook, or bot channel (`POST /api/teams/messages`)
@@ -41,7 +41,7 @@
  *
  * `"auto"` decides per REQUEST, not per boot, because a single container serves
  * both doors at once - the tunnel gate and the platform front door share a port
- * (see `@dbx-tools/cli-tunnel`). A boot-time flag would have to be wrong for one
+ * (see `@dbx-tools/tunnel`). A boot-time flag would have to be wrong for one
  * of them.
  *
  * What the service principal does NOT change is WHO the request belongs to. The

package/lib/src/identity.js

@@ -20,7 +20,7 @@
  * where a missing token means something is wrong. It is fatal for an app whose
  * traffic legitimately arrives WITHOUT one:
  *
- *   - a public tunnel (`@dbx-tools/cli-tunnel`), where callers authenticate by
+ *   - a public tunnel (`@dbx-tools/tunnel`), where callers authenticate by
  *     email OTP and no OBO token exists to forward - the gate can prove WHO the
  *     caller is, but it cannot mint a Databricks credential for them;
  *   - any reverse proxy, webhook, or bot channel (`POST /api/teams/messages`)
@@ -41,7 +41,7 @@
  *
  * `"auto"` decides per REQUEST, not per boot, because a single container serves
  * both doors at once - the tunnel gate and the platform front door share a port
- * (see `@dbx-tools/cli-tunnel`). A boot-time flag would have to be wrong for one
+ * (see `@dbx-tools/tunnel`). A boot-time flag would have to be wrong for one
  * of them.
  *
  * What the service principal does NOT change is WHO the request belongs to. The
@@ -134,4 +134,4 @@ export function useServicePrincipal(mode, req) {
         return false;
     return requestAccessToken(req) === undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAC,mBAAmB,CAAC;AAE7D,8EAA8E;AAC9E,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;AAEnD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAC;AAKzD,oFAAoF;AACpF,MAAM,CAAC,MAAM,cAAc,GAA4B,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,CAAC;AAE7F;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAiB,MAAM,CAAC;AAO1D;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CACjC,UAA8B,EAC9B,OAAe,EACf,KAAK,GAAG,UAAU;IAElB,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC5C,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,qBAAqB,CAAC;IAC/C,MAAM,IAAI,GAAG,GAAG,CAAC,WAAW,EAAkB,CAAC;IAC/C,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1E,MAAM,IAAI,kBAAkB,CAC1B,GAAG,KAAK,mBAAmB,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,GAAG,EACvE,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CACrD,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAA8B;IAC/D,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,mBAAmB,CAAC,CAAC,IAAI,SAAS,CAAC;AAC1E,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,aAAa,CAAC,GAA8B;IAC1D,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,SAAS,CAAC;AACrE,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,gBAAgB,CAAC,GAA8B;IAC7D,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,iBAAiB,CAAC,CAAC,IAAI,SAAS,CAAC;AACxE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAkB,EAAE,GAAmB;IACzE,IAAI,IAAI,KAAK,mBAAmB;QAAE,OAAO,IAAI,CAAC;IAC9C,IAAI,IAAI,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IAClC,OAAO,kBAAkB,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;AAC/C,CAAC","sourcesContent":["/**\n * Which Databricks identity a request's workspace calls run as.\n *\n * AppKit gives a plugin two identities: the ambient SERVICE context (the app's\n * own service principal) and a per-request USER context entered with\n * `asUser(req)`, which authenticates as the caller on-behalf-of (OBO). The\n * choice is one call, so the whole decision is \"do we enter `asUser` for this\n * request\".\n *\n * `asUser(req)` needs the OBO token the platform front door forwards on\n * {@link ACCESS_TOKEN_HEADER}. Measured against the installed AppKit, its\n * behavior when that header is absent depends ENTIRELY on `NODE_ENV`:\n *\n * | `NODE_ENV`    | no `x-forwarded-access-token`                        |\n * | ------------- | ---------------------------------------------------- |\n * | `development` | logs a warning, silently runs as the service principal |\n * | anything else | throws `AuthenticationError: Missing user token`      |\n *\n * That production throw is correct for an app behind the Databricks front door,\n * where a missing token means something is wrong. It is fatal for an app whose\n * traffic legitimately arrives WITHOUT one:\n *\n *   - a public tunnel (`@dbx-tools/cli-tunnel`), where callers authenticate by\n *     email OTP and no OBO token exists to forward - the gate can prove WHO the\n *     caller is, but it cannot mint a Databricks credential for them;\n *   - any reverse proxy, webhook, or bot channel (`POST /api/teams/messages`)\n *     that authenticates its own way.\n *\n * Such an app must not run with `NODE_ENV=development` just to get the fallback:\n * that flag also relaxes secure cookies, AppKit's own dev affordances, and\n * `allowUnauthenticated` escape hatches. Hence {@link IdentityMode}:\n *\n *   - `\"user\"` - always OBO. Per-user attribution and per-user Genie / Unity\n *     Catalog row filters. Correct when every caller is a workspace member.\n *   - `\"service-principal\"` - always the app's own identity. Needs no OBO\n *     scopes and works for any caller, at the cost of per-user data scoping.\n *   - `\"auto\"` - OBO when the request actually carries a usable OBO token,\n *     the service principal otherwise. One deployment then serves BOTH doors\n *     correctly: front-door requests keep full per-user scoping, while tunnel /\n *     webhook requests degrade to the service principal instead of 500ing.\n *\n * `\"auto\"` decides per REQUEST, not per boot, because a single container serves\n * both doors at once - the tunnel gate and the platform front door share a port\n * (see `@dbx-tools/cli-tunnel`). A boot-time flag would have to be wrong for one\n * of them.\n *\n * What the service principal does NOT change is WHO the request belongs to. The\n * caller's identity still arrives on {@link USER_ID_HEADER} /\n * {@link USER_EMAIL_HEADER}, so memory threads, cache namespaces, and trace\n * attribution stay per-user. Only the Databricks credential is shared.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { env, string, token, type EnvKey } from \"@dbx-tools/shared-core\";\n\n/**\n * Header the Databricks Apps front door forwards the caller's OBO token on.\n * Its presence is what makes `asUser(req)` viable, so it is the signal\n * {@link useServicePrincipal} reads in `\"auto\"` mode.\n *\n * Re-exported from `@dbx-tools/shared-core`'s `token` module (which reads the\n * same header to decode OAuth scopes) rather than re-spelled, so the name for\n * this wire contract exists once.\n */\nexport const ACCESS_TOKEN_HEADER = token.ACCESS_TOKEN_HEADER;\n\n/** Header the Databricks Apps front door forwards the caller's user id on. */\nexport const USER_ID_HEADER = token.USER_ID_HEADER;\n\n/** Header the Databricks Apps front door forwards the caller's email on. */\nexport const USER_EMAIL_HEADER = token.USER_EMAIL_HEADER;\n\n/** Identity a request's Databricks calls run as. See the module docs. */\nexport type IdentityMode = \"user\" | \"service-principal\" | \"auto\";\n\n/** Every accepted {@link IdentityMode}, in the order docs and schemas list them. */\nexport const IDENTITY_MODES: readonly IdentityMode[] = [\"user\", \"service-principal\", \"auto\"];\n\n/**\n * Default mode. `\"user\"` keeps OBO the only identity unless an app opts in, so\n * adopting this option can never silently widen an existing app's data access.\n */\nexport const DEFAULT_IDENTITY_MODE: IdentityMode = \"user\";\n\n/** The subset of `express.Request` this module reads - one header lookup. */\nexport interface HeaderBearing {\n  header(name: string): string | undefined;\n}\n\n/**\n * Resolve a configured mode: explicit config value, then the first non-empty\n * variable among `envKeys`, then {@link DEFAULT_IDENTITY_MODE}.\n *\n * An unrecognized value throws rather than falling back. Falling back would\n * silently keep serving OBO - and the production `AuthenticationError` it\n * produces - to exactly the callers the option was set to accommodate, and a\n * typo (`\"obo\"`, `\"sp\"`) is the likeliest way to get one.\n */\nexport function resolveIdentityMode(\n  configured: string | undefined,\n  envKeys: EnvKey,\n  field = \"identity\",\n): IdentityMode {\n  const raw = env.string(configured, envKeys);\n  if (raw === null) return DEFAULT_IDENTITY_MODE;\n  const mode = raw.toLowerCase() as IdentityMode;\n  if (!IDENTITY_MODES.includes(mode)) {\n    const names = typeof envKeys === \"string\" ? envKeys : envKeys.join(\" / \");\n    throw new ConfigurationError(\n      `${field} must be one of ${IDENTITY_MODES.join(\" | \")} (env: ${names})`,\n      { context: { field, envVar: names, received: raw } },\n    );\n  }\n  return mode;\n}\n\n/**\n * The OBO token on `req`, or `undefined`. Read through the same trim as every\n * other header, so a header present-but-blank (which some proxies emit for an\n * unset upstream value) counts as absent rather than as a token that fails at\n * the first Databricks call.\n */\nexport function requestAccessToken(req: HeaderBearing | undefined): string | undefined {\n  return string.trimToNull(req?.header(ACCESS_TOKEN_HEADER)) ?? undefined;\n}\n\n/** The forwarded user id on `req`, or `undefined`. */\nexport function requestUserId(req: HeaderBearing | undefined): string | undefined {\n  return string.trimToNull(req?.header(USER_ID_HEADER)) ?? undefined;\n}\n\n/** The forwarded user email on `req`, or `undefined`. */\nexport function requestUserEmail(req: HeaderBearing | undefined): string | undefined {\n  return string.trimToNull(req?.header(USER_EMAIL_HEADER)) ?? undefined;\n}\n\n/**\n * Whether `req` should run its Databricks calls as the app service principal\n * rather than OBO.\n *\n * - `\"service-principal\"` -> always `true`.\n * - `\"user\"` -> always `false`, even with no token. The mode is an explicit\n *   assertion that every caller is OBO-capable, so a missing token is a real\n *   error and must surface as AppKit's `AuthenticationError` rather than being\n *   quietly downgraded to shared data access.\n * - `\"auto\"` -> `true` only when the request carries no usable OBO token.\n *\n * A request AppKit will not accept for OBO anyway (no token) can never be\n * served by entering `asUser`, so in `\"auto\"` mode the token check is the whole\n * decision: it is the same condition AppKit itself branches on, just resolved\n * before it can throw.\n */\nexport function useServicePrincipal(mode: IdentityMode, req?: HeaderBearing): boolean {\n  if (mode === \"service-principal\") return true;\n  if (mode === \"user\") return false;\n  return requestAccessToken(req) === undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAC,mBAAmB,CAAC;AAE7D,8EAA8E;AAC9E,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;AAEnD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAC;AAKzD,oFAAoF;AACpF,MAAM,CAAC,MAAM,cAAc,GAA4B,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,CAAC;AAE7F;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAiB,MAAM,CAAC;AAO1D;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CACjC,UAA8B,EAC9B,OAAe,EACf,KAAK,GAAG,UAAU;IAElB,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC5C,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,qBAAqB,CAAC;IAC/C,MAAM,IAAI,GAAG,GAAG,CAAC,WAAW,EAAkB,CAAC;IAC/C,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1E,MAAM,IAAI,kBAAkB,CAC1B,GAAG,KAAK,mBAAmB,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,GAAG,EACvE,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CACrD,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAA8B;IAC/D,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,mBAAmB,CAAC,CAAC,IAAI,SAAS,CAAC;AAC1E,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,aAAa,CAAC,GAA8B;IAC1D,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,SAAS,CAAC;AACrE,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,gBAAgB,CAAC,GAA8B;IAC7D,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,iBAAiB,CAAC,CAAC,IAAI,SAAS,CAAC;AACxE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAkB,EAAE,GAAmB;IACzE,IAAI,IAAI,KAAK,mBAAmB;QAAE,OAAO,IAAI,CAAC;IAC9C,IAAI,IAAI,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IAClC,OAAO,kBAAkB,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;AAC/C,CAAC","sourcesContent":["/**\n * Which Databricks identity a request's workspace calls run as.\n *\n * AppKit gives a plugin two identities: the ambient SERVICE context (the app's\n * own service principal) and a per-request USER context entered with\n * `asUser(req)`, which authenticates as the caller on-behalf-of (OBO). The\n * choice is one call, so the whole decision is \"do we enter `asUser` for this\n * request\".\n *\n * `asUser(req)` needs the OBO token the platform front door forwards on\n * {@link ACCESS_TOKEN_HEADER}. Measured against the installed AppKit, its\n * behavior when that header is absent depends ENTIRELY on `NODE_ENV`:\n *\n * | `NODE_ENV`    | no `x-forwarded-access-token`                        |\n * | ------------- | ---------------------------------------------------- |\n * | `development` | logs a warning, silently runs as the service principal |\n * | anything else | throws `AuthenticationError: Missing user token`      |\n *\n * That production throw is correct for an app behind the Databricks front door,\n * where a missing token means something is wrong. It is fatal for an app whose\n * traffic legitimately arrives WITHOUT one:\n *\n *   - a public tunnel (`@dbx-tools/tunnel`), where callers authenticate by\n *     email OTP and no OBO token exists to forward - the gate can prove WHO the\n *     caller is, but it cannot mint a Databricks credential for them;\n *   - any reverse proxy, webhook, or bot channel (`POST /api/teams/messages`)\n *     that authenticates its own way.\n *\n * Such an app must not run with `NODE_ENV=development` just to get the fallback:\n * that flag also relaxes secure cookies, AppKit's own dev affordances, and\n * `allowUnauthenticated` escape hatches. Hence {@link IdentityMode}:\n *\n *   - `\"user\"` - always OBO. Per-user attribution and per-user Genie / Unity\n *     Catalog row filters. Correct when every caller is a workspace member.\n *   - `\"service-principal\"` - always the app's own identity. Needs no OBO\n *     scopes and works for any caller, at the cost of per-user data scoping.\n *   - `\"auto\"` - OBO when the request actually carries a usable OBO token,\n *     the service principal otherwise. One deployment then serves BOTH doors\n *     correctly: front-door requests keep full per-user scoping, while tunnel /\n *     webhook requests degrade to the service principal instead of 500ing.\n *\n * `\"auto\"` decides per REQUEST, not per boot, because a single container serves\n * both doors at once - the tunnel gate and the platform front door share a port\n * (see `@dbx-tools/tunnel`). A boot-time flag would have to be wrong for one\n * of them.\n *\n * What the service principal does NOT change is WHO the request belongs to. The\n * caller's identity still arrives on {@link USER_ID_HEADER} /\n * {@link USER_EMAIL_HEADER}, so memory threads, cache namespaces, and trace\n * attribution stay per-user. Only the Databricks credential is shared.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { env, string, token, type EnvKey } from \"@dbx-tools/shared-core\";\n\n/**\n * Header the Databricks Apps front door forwards the caller's OBO token on.\n * Its presence is what makes `asUser(req)` viable, so it is the signal\n * {@link useServicePrincipal} reads in `\"auto\"` mode.\n *\n * Re-exported from `@dbx-tools/shared-core`'s `token` module (which reads the\n * same header to decode OAuth scopes) rather than re-spelled, so the name for\n * this wire contract exists once.\n */\nexport const ACCESS_TOKEN_HEADER = token.ACCESS_TOKEN_HEADER;\n\n/** Header the Databricks Apps front door forwards the caller's user id on. */\nexport const USER_ID_HEADER = token.USER_ID_HEADER;\n\n/** Header the Databricks Apps front door forwards the caller's email on. */\nexport const USER_EMAIL_HEADER = token.USER_EMAIL_HEADER;\n\n/** Identity a request's Databricks calls run as. See the module docs. */\nexport type IdentityMode = \"user\" | \"service-principal\" | \"auto\";\n\n/** Every accepted {@link IdentityMode}, in the order docs and schemas list them. */\nexport const IDENTITY_MODES: readonly IdentityMode[] = [\"user\", \"service-principal\", \"auto\"];\n\n/**\n * Default mode. `\"user\"` keeps OBO the only identity unless an app opts in, so\n * adopting this option can never silently widen an existing app's data access.\n */\nexport const DEFAULT_IDENTITY_MODE: IdentityMode = \"user\";\n\n/** The subset of `express.Request` this module reads - one header lookup. */\nexport interface HeaderBearing {\n  header(name: string): string | undefined;\n}\n\n/**\n * Resolve a configured mode: explicit config value, then the first non-empty\n * variable among `envKeys`, then {@link DEFAULT_IDENTITY_MODE}.\n *\n * An unrecognized value throws rather than falling back. Falling back would\n * silently keep serving OBO - and the production `AuthenticationError` it\n * produces - to exactly the callers the option was set to accommodate, and a\n * typo (`\"obo\"`, `\"sp\"`) is the likeliest way to get one.\n */\nexport function resolveIdentityMode(\n  configured: string | undefined,\n  envKeys: EnvKey,\n  field = \"identity\",\n): IdentityMode {\n  const raw = env.string(configured, envKeys);\n  if (raw === null) return DEFAULT_IDENTITY_MODE;\n  const mode = raw.toLowerCase() as IdentityMode;\n  if (!IDENTITY_MODES.includes(mode)) {\n    const names = typeof envKeys === \"string\" ? envKeys : envKeys.join(\" / \");\n    throw new ConfigurationError(\n      `${field} must be one of ${IDENTITY_MODES.join(\" | \")} (env: ${names})`,\n      { context: { field, envVar: names, received: raw } },\n    );\n  }\n  return mode;\n}\n\n/**\n * The OBO token on `req`, or `undefined`. Read through the same trim as every\n * other header, so a header present-but-blank (which some proxies emit for an\n * unset upstream value) counts as absent rather than as a token that fails at\n * the first Databricks call.\n */\nexport function requestAccessToken(req: HeaderBearing | undefined): string | undefined {\n  return string.trimToNull(req?.header(ACCESS_TOKEN_HEADER)) ?? undefined;\n}\n\n/** The forwarded user id on `req`, or `undefined`. */\nexport function requestUserId(req: HeaderBearing | undefined): string | undefined {\n  return string.trimToNull(req?.header(USER_ID_HEADER)) ?? undefined;\n}\n\n/** The forwarded user email on `req`, or `undefined`. */\nexport function requestUserEmail(req: HeaderBearing | undefined): string | undefined {\n  return string.trimToNull(req?.header(USER_EMAIL_HEADER)) ?? undefined;\n}\n\n/**\n * Whether `req` should run its Databricks calls as the app service principal\n * rather than OBO.\n *\n * - `\"service-principal\"` -> always `true`.\n * - `\"user\"` -> always `false`, even with no token. The mode is an explicit\n *   assertion that every caller is OBO-capable, so a missing token is a real\n *   error and must surface as AppKit's `AuthenticationError` rather than being\n *   quietly downgraded to shared data access.\n * - `\"auto\"` -> `true` only when the request carries no usable OBO token.\n *\n * A request AppKit will not accept for OBO anyway (no token) can never be\n * served by entering `asUser`, so in `\"auto\"` mode the token check is the whole\n * decision: it is the same condition AppKit itself branches on, just resolved\n * before it can throw.\n */\nexport function useServicePrincipal(mode: IdentityMode, req?: HeaderBearing): boolean {\n  if (mode === \"service-principal\") return true;\n  if (mode === \"user\") return false;\n  return requestAccessToken(req) === undefined;\n}\n"]}

package/lib/src/interceptor.d.ts

@@ -0,0 +1,152 @@
+/**
+ * The `createApp` INTERCEPTOR context: an in-process handle an app hands to
+ * add-ons (the tunnel, chiefly) so they can read the env auto-configuration
+ * computed, hook AppKit's lifecycle, and supervise sibling child processes as one
+ * unit - concurrently-style, where any death takes the whole set down.
+ *
+ * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to
+ * {@link CreateAppConfig.interceptor} ("one or many"). {@link createApp} runs each
+ * one AFTER auto-configuration has populated `process.env` but as part of booting
+ * the app, so an interceptor sees the resolved connection and can bind processes
+ * before or during setup.
+ *
+ * The names here mirror AppKit's own vocabulary rather than inventing parallel
+ * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the
+ * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /
+ * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -
+ * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin
+ * {@link createApp} injects to capture `this.context` and relay its events.
+ *
+ * @module
+ */
+import type { ChildProcess } from "node:child_process";
+import { Plugin, type BasePluginConfig } from "@databricks/appkit";
+import type { LakebaseConnection } from "./lakebase-resolver.ts";
+/**
+ * AppKit's plugin-lifecycle events, verbatim from `PluginContext`
+ * (`node_modules/@databricks/appkit/.../core/plugin-context.d.ts`). Re-declared
+ * structurally rather than imported because `PluginContext` is not in the
+ * package's `exports` map (the same reason {@link PluginContextLike} exists in
+ * `./plugin`).
+ *
+ * - `setup:complete` - every plugin's `setup()` has resolved.
+ * - `server:ready` - the `server()` plugin is listening (never fires for a
+ *   serverless app, e.g. the tunnel gate).
+ * - `shutdown` - the app is tearing down.
+ */
+export type LifecycleEvent = "setup:complete" | "server:ready" | "shutdown";
+/** A lifecycle subscriber. Errors are logged, not propagated (matches AppKit). */
+export type LifecycleHandler = () => void | Promise<void>;
+/**
+ * The env auto-configuration resolved before boot, exposed to interceptors so
+ * they read COMPUTED values instead of re-reading `process.env` themselves.
+ *
+ * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran
+ * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the
+ * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the
+ * tunnel interceptor both reads and, when it must, sets.
+ */
+export interface ResolvedAppEnv {
+    /** Resolved Lakebase connection, when auto-config resolved one. */
+    readonly lakebase?: LakebaseConnection;
+    /** Resolved Databricks workspace host (`DATABRICKS_HOST`), when known. */
+    readonly databricksHost?: string;
+}
+/**
+ * A process {@link InterceptorContext.bindProcess} can supervise. A bare
+ * `node:child_process` `ChildProcess` (e.g. portr) satisfies this, and so does
+ * `@dbx-tools/core`'s `spawn()` result (a `ChildProcessResult` IS a
+ * `ChildProcess`) - one code path handles both.
+ */
+export type BindableProcess = Pick<ChildProcess, "pid" | "kill" | "killed" | "once">;
+/**
+ * The handle passed to each interceptor.
+ *
+ * @example
+ * import { createApp } from "@dbx-tools/appkit";
+ *
+ * await createApp({
+ *   plugins: [server()],
+ *   interceptor: (ctx) => {
+ *     const portr = spawnPortr(ctx.env.databricksHost);
+ *     ctx.bindProcess(portr);            // app <-> portr live/die together
+ *     ctx.onLifecycle("shutdown", () => portr.kill("SIGTERM"));
+ *   },
+ * });
+ */
+export interface InterceptorContext {
+    /** The env auto-configuration computed before boot. */
+    readonly env: ResolvedAppEnv;
+    /**
+     * Subscribe to an AppKit lifecycle event. Mirrors `PluginContext.onLifecycle`;
+     * the injected {@link lifecycleBridge} relays the real events here once the app
+     * boots. A handler registered for an event that already fired is NOT called
+     * retroactively (same semantics as AppKit).
+     */
+    onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;
+    /**
+     * Broadcast a termination signal from the main app to every bound process.
+     * Called automatically when this process receives `SIGINT`/`SIGTERM`/`SIGHUP`;
+     * exposed so an interceptor can trigger teardown itself.
+     */
+    broadcastSignal(signal: NodeJS.Signals): void;
+    /**
+     * Supervise a child process alongside the app, concurrently-style: signals pass
+     * through, and if EITHER the child or the app dies the whole set comes down.
+     * Generalizes the tunnel's old hand-rolled `superviseExit`. Safe to call for
+     * several children; teardown is idempotent.
+     */
+    bindProcess(child: BindableProcess): void;
+}
+/** A single interceptor, or several. The `createApp` `interceptor?:` option. */
+export type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;
+/**
+ * The mutable machinery behind an {@link InterceptorContext}. Split out so
+ * {@link createInterceptorContext} can hand the public context to interceptors
+ * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.
+ */
+export interface InterceptorRuntime {
+    /** The context handed to each interceptor. */
+    readonly context: InterceptorContext;
+    /** Fire a lifecycle event to every subscriber (called by {@link lifecycleBridge}). */
+    emitLifecycle(event: LifecycleEvent): Promise<void>;
+}
+/**
+ * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.
+ *
+ * Teardown is the generalized `superviseExit`: the first child exit or main-process
+ * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,
+ * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it
+ * never itself holds the loop open). The process-signal listeners are installed
+ * lazily on the first `bindProcess` so an app that binds nothing is untouched.
+ */
+export declare function createInterceptorContext(env: ResolvedAppEnv): InterceptorRuntime;
+/** Config for {@link LifecycleBridgePlugin}: the sink its captured events flow to. */
+interface LifecycleBridgeConfig extends BasePluginConfig {
+    /** The runtime whose `emitLifecycle` receives the real AppKit events. */
+    runtime?: InterceptorRuntime;
+}
+/**
+ * The internal plugin {@link createApp} injects to make AppKit's lifecycle
+ * reachable from interceptor code. On `setup()` it reads its own `this.context`
+ * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the
+ * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine
+ * events. It owns no routes, config surface, or exports.
+ */
+export declare class LifecycleBridgePlugin extends Plugin<LifecycleBridgeConfig> {
+    static manifest: {
+        name: "dbxToolsLifecycleBridge";
+        displayName: string;
+        description: string;
+        stability: "beta";
+        hidden: true;
+        resources: {
+            required: never[];
+            optional: never[];
+        };
+    };
+    setup(): Promise<void>;
+}
+/** Factory for the injected {@link LifecycleBridgePlugin}. */
+export declare const lifecycleBridge: import("@databricks/appkit").ToPlugin<typeof LifecycleBridgePlugin, LifecycleBridgeConfig, "dbxToolsLifecycleBridge">;
+export {};

package/lib/src/interceptor.js

@@ -0,0 +1,141 @@
+/**
+ * The `createApp` INTERCEPTOR context: an in-process handle an app hands to
+ * add-ons (the tunnel, chiefly) so they can read the env auto-configuration
+ * computed, hook AppKit's lifecycle, and supervise sibling child processes as one
+ * unit - concurrently-style, where any death takes the whole set down.
+ *
+ * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to
+ * {@link CreateAppConfig.interceptor} ("one or many"). {@link createApp} runs each
+ * one AFTER auto-configuration has populated `process.env` but as part of booting
+ * the app, so an interceptor sees the resolved connection and can bind processes
+ * before or during setup.
+ *
+ * The names here mirror AppKit's own vocabulary rather than inventing parallel
+ * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the
+ * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /
+ * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -
+ * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin
+ * {@link createApp} injects to capture `this.context` and relay its events.
+ *
+ * @module
+ */
+import { Plugin, toPlugin } from "@databricks/appkit";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("interceptor");
+/** How long bound children get to exit on `SIGTERM` before the app force-exits. */
+const TEARDOWN_GRACE_MS = 3000;
+/** The signals that trigger teardown when the MAIN process receives them. */
+const TEARDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+/**
+ * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.
+ *
+ * Teardown is the generalized `superviseExit`: the first child exit or main-process
+ * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,
+ * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it
+ * never itself holds the loop open). The process-signal listeners are installed
+ * lazily on the first `bindProcess` so an app that binds nothing is untouched.
+ */
+export function createInterceptorContext(env) {
+    const handlers = new Map();
+    const children = new Set();
+    let shuttingDown = false;
+    let signalsBound = false;
+    const teardown = (code) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        for (const child of children) {
+            if (!child.killed)
+                child.kill("SIGTERM");
+        }
+        setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();
+    };
+    const broadcastSignal = (signal) => {
+        for (const child of children) {
+            if (!child.killed)
+                child.kill(signal);
+        }
+        teardown(0);
+    };
+    const bindProcessSignals = () => {
+        if (signalsBound)
+            return;
+        signalsBound = true;
+        for (const signal of TEARDOWN_SIGNALS) {
+            process.on(signal, () => broadcastSignal(signal));
+        }
+    };
+    const bindProcess = (child) => {
+        bindProcessSignals();
+        children.add(child);
+        child.once("exit", (code) => {
+            logger.warn("bound process exited; tearing down the app", { code });
+            teardown(typeof code === "number" ? code : 1);
+        });
+    };
+    const onLifecycle = (event, fn) => {
+        const list = handlers.get(event);
+        if (list)
+            list.push(fn);
+        else
+            handlers.set(event, [fn]);
+    };
+    const emitLifecycle = async (event) => {
+        const list = handlers.get(event);
+        if (!list)
+            return;
+        for (const fn of list) {
+            try {
+                await fn();
+            }
+            catch (error) {
+                // Match AppKit: a failing lifecycle handler is logged, never fatal, and
+                // never blocks its siblings.
+                logger.warn("lifecycle handler failed", { event, error });
+            }
+        }
+    };
+    const context = {
+        env,
+        onLifecycle,
+        broadcastSignal,
+        bindProcess,
+    };
+    return { context, emitLifecycle };
+}
+function hasOnLifecycle(context) {
+    return typeof context?.onLifecycle === "function";
+}
+/**
+ * The internal plugin {@link createApp} injects to make AppKit's lifecycle
+ * reachable from interceptor code. On `setup()` it reads its own `this.context`
+ * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the
+ * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine
+ * events. It owns no routes, config surface, or exports.
+ */
+export class LifecycleBridgePlugin extends Plugin {
+    static manifest = {
+        name: "dbxToolsLifecycleBridge",
+        displayName: "Lifecycle Bridge",
+        description: "Relays AppKit lifecycle events to the createApp interceptor context.",
+        stability: "beta",
+        hidden: true,
+        resources: { required: [], optional: [] },
+    };
+    async setup() {
+        const runtime = this.config.runtime;
+        if (!runtime)
+            return;
+        if (!hasOnLifecycle(this.context)) {
+            logger.debug("no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert");
+            return;
+        }
+        const events = ["setup:complete", "server:ready", "shutdown"];
+        for (const event of events) {
+            this.context.onLifecycle(event, () => runtime.emitLifecycle(event));
+        }
+    }
+}
+/** Factory for the injected {@link LifecycleBridgePlugin}. */
+export const lifecycleBridge = toPlugin(LifecycleBridgePlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,MAAM,EAAE,QAAQ,EAA8C,MAAM,oBAAoB,CAAC;AAClG,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAG7C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AAsFzC,mFAAmF;AACnF,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAE/B,6EAA6E;AAC7E,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAU,CAAC;AAclE;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAAmB;IAC1D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAsC,CAAC;IAC/D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC5C,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,IAAI,YAAY,GAAG,KAAK,CAAC;IAEzB,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAQ,EAAE;QACtC,IAAI,YAAY;YAAE,OAAO;QACzB,YAAY,GAAG,IAAI,CAAC;QACpB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC;QACD,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,CAAC,KAAK,EAAE,CAAC;IAClE,CAAC,CAAC;IAEF,MAAM,eAAe,GAAG,CAAC,MAAsB,EAAQ,EAAE;QACvD,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC;QACD,QAAQ,CAAC,CAAC,CAAC,CAAC;IACd,CAAC,CAAC;IAEF,MAAM,kBAAkB,GAAG,GAAS,EAAE;QACpC,IAAI,YAAY;YAAE,OAAO;QACzB,YAAY,GAAG,IAAI,CAAC;QACpB,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;YACtC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,KAAsB,EAAQ,EAAE;QACnD,kBAAkB,EAAE,CAAC;QACrB,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YAC1B,MAAM,CAAC,IAAI,CAAC,4CAA4C,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;YACpE,QAAQ,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,KAAqB,EAAE,EAAoB,EAAQ,EAAE;QACxE,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;;YACnB,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACjC,CAAC,CAAC;IAEF,MAAM,aAAa,GAAG,KAAK,EAAE,KAAqB,EAAiB,EAAE;QACnE,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,KAAK,MAAM,EAAE,IAAI,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC;gBACH,MAAM,EAAE,EAAE,CAAC;YACb,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,wEAAwE;gBACxE,6BAA6B;gBAC7B,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YAC5D,CAAC;QACH,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,OAAO,GAAuB;QAClC,GAAG;QACH,WAAW;QACX,eAAe;QACf,WAAW;KACZ,CAAC;IAEF,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;AACpC,CAAC;AAiBD,SAAS,cAAc,CAAC,OAAgB;IACtC,OAAO,OAAQ,OAA4C,EAAE,WAAW,KAAK,UAAU,CAAC;AAC1F,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,qBAAsB,SAAQ,MAA6B;IACtE,MAAM,CAAC,QAAQ,GAAG;QAChB,IAAI,EAAE,yBAAyB;QAC/B,WAAW,EAAE,kBAAkB;QAC/B,WAAW,EAAE,sEAAsE;QACnF,SAAS,EAAE,MAAM;QACjB,MAAM,EAAE,IAAI;QACZ,SAAS,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;KACU,CAAC;IAE7C,KAAK,CAAC,KAAK;QAClB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;QACpC,IAAI,CAAC,OAAO;YAAE,OAAO;QACrB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAClC,MAAM,CAAC,KAAK,CAAC,4EAA4E,CAAC,CAAC;YAC3F,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GAAqB,CAAC,gBAAgB,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;QAChF,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;;AAGH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC,qBAAqB,CAAC,CAAC","sourcesContent":["/**\n * The `createApp` INTERCEPTOR context: an in-process handle an app hands to\n * add-ons (the tunnel, chiefly) so they can read the env auto-configuration\n * computed, hook AppKit's lifecycle, and supervise sibling child processes as one\n * unit - concurrently-style, where any death takes the whole set down.\n *\n * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to\n * {@link CreateAppConfig.interceptor} (\"one or many\"). {@link createApp} runs each\n * one AFTER auto-configuration has populated `process.env` but as part of booting\n * the app, so an interceptor sees the resolved connection and can bind processes\n * before or during setup.\n *\n * The names here mirror AppKit's own vocabulary rather than inventing parallel\n * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the\n * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /\n * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -\n * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin\n * {@link createApp} injects to capture `this.context` and relay its events.\n *\n * @module\n */\n\nimport type { ChildProcess } from \"node:child_process\";\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { LakebaseConnection } from \"./lakebase-resolver.ts\";\n\nconst logger = log.logger(\"interceptor\");\n\n/**\n * AppKit's plugin-lifecycle events, verbatim from `PluginContext`\n * (`node_modules/@databricks/appkit/.../core/plugin-context.d.ts`). Re-declared\n * structurally rather than imported because `PluginContext` is not in the\n * package's `exports` map (the same reason {@link PluginContextLike} exists in\n * `./plugin`).\n *\n * - `setup:complete` - every plugin's `setup()` has resolved.\n * - `server:ready` - the `server()` plugin is listening (never fires for a\n *   serverless app, e.g. the tunnel gate).\n * - `shutdown` - the app is tearing down.\n */\nexport type LifecycleEvent = \"setup:complete\" | \"server:ready\" | \"shutdown\";\n\n/** A lifecycle subscriber. Errors are logged, not propagated (matches AppKit). */\nexport type LifecycleHandler = () => void | Promise<void>;\n\n/**\n * The env auto-configuration resolved before boot, exposed to interceptors so\n * they read COMPUTED values instead of re-reading `process.env` themselves.\n *\n * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran\n * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the\n * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the\n * tunnel interceptor both reads and, when it must, sets.\n */\nexport interface ResolvedAppEnv {\n  /** Resolved Lakebase connection, when auto-config resolved one. */\n  readonly lakebase?: LakebaseConnection;\n  /** Resolved Databricks workspace host (`DATABRICKS_HOST`), when known. */\n  readonly databricksHost?: string;\n}\n\n/**\n * A process {@link InterceptorContext.bindProcess} can supervise. A bare\n * `node:child_process` `ChildProcess` (e.g. portr) satisfies this, and so does\n * `@dbx-tools/core`'s `spawn()` result (a `ChildProcessResult` IS a\n * `ChildProcess`) - one code path handles both.\n */\nexport type BindableProcess = Pick<ChildProcess, \"pid\" | \"kill\" | \"killed\" | \"once\">;\n\n/**\n * The handle passed to each interceptor.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n *\n * await createApp({\n *   plugins: [server()],\n *   interceptor: (ctx) => {\n *     const portr = spawnPortr(ctx.env.databricksHost);\n *     ctx.bindProcess(portr);            // app <-> portr live/die together\n *     ctx.onLifecycle(\"shutdown\", () => portr.kill(\"SIGTERM\"));\n *   },\n * });\n */\nexport interface InterceptorContext {\n  /** The env auto-configuration computed before boot. */\n  readonly env: ResolvedAppEnv;\n  /**\n   * Subscribe to an AppKit lifecycle event. Mirrors `PluginContext.onLifecycle`;\n   * the injected {@link lifecycleBridge} relays the real events here once the app\n   * boots. A handler registered for an event that already fired is NOT called\n   * retroactively (same semantics as AppKit).\n   */\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n  /**\n   * Broadcast a termination signal from the main app to every bound process.\n   * Called automatically when this process receives `SIGINT`/`SIGTERM`/`SIGHUP`;\n   * exposed so an interceptor can trigger teardown itself.\n   */\n  broadcastSignal(signal: NodeJS.Signals): void;\n  /**\n   * Supervise a child process alongside the app, concurrently-style: signals pass\n   * through, and if EITHER the child or the app dies the whole set comes down.\n   * Generalizes the tunnel's old hand-rolled `superviseExit`. Safe to call for\n   * several children; teardown is idempotent.\n   */\n  bindProcess(child: BindableProcess): void;\n}\n\n/** A single interceptor, or several. The `createApp` `interceptor?:` option. */\nexport type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;\n\n/** How long bound children get to exit on `SIGTERM` before the app force-exits. */\nconst TEARDOWN_GRACE_MS = 3000;\n\n/** The signals that trigger teardown when the MAIN process receives them. */\nconst TEARDOWN_SIGNALS = [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"] as const;\n\n/**\n * The mutable machinery behind an {@link InterceptorContext}. Split out so\n * {@link createInterceptorContext} can hand the public context to interceptors\n * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.\n */\nexport interface InterceptorRuntime {\n  /** The context handed to each interceptor. */\n  readonly context: InterceptorContext;\n  /** Fire a lifecycle event to every subscriber (called by {@link lifecycleBridge}). */\n  emitLifecycle(event: LifecycleEvent): Promise<void>;\n}\n\n/**\n * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.\n *\n * Teardown is the generalized `superviseExit`: the first child exit or main-process\n * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,\n * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it\n * never itself holds the loop open). The process-signal listeners are installed\n * lazily on the first `bindProcess` so an app that binds nothing is untouched.\n */\nexport function createInterceptorContext(env: ResolvedAppEnv): InterceptorRuntime {\n  const handlers = new Map<LifecycleEvent, LifecycleHandler[]>();\n  const children = new Set<BindableProcess>();\n  let shuttingDown = false;\n  let signalsBound = false;\n\n  const teardown = (code: number): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    for (const child of children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();\n  };\n\n  const broadcastSignal = (signal: NodeJS.Signals): void => {\n    for (const child of children) {\n      if (!child.killed) child.kill(signal);\n    }\n    teardown(0);\n  };\n\n  const bindProcessSignals = (): void => {\n    if (signalsBound) return;\n    signalsBound = true;\n    for (const signal of TEARDOWN_SIGNALS) {\n      process.on(signal, () => broadcastSignal(signal));\n    }\n  };\n\n  const bindProcess = (child: BindableProcess): void => {\n    bindProcessSignals();\n    children.add(child);\n    child.once(\"exit\", (code) => {\n      logger.warn(\"bound process exited; tearing down the app\", { code });\n      teardown(typeof code === \"number\" ? code : 1);\n    });\n  };\n\n  const onLifecycle = (event: LifecycleEvent, fn: LifecycleHandler): void => {\n    const list = handlers.get(event);\n    if (list) list.push(fn);\n    else handlers.set(event, [fn]);\n  };\n\n  const emitLifecycle = async (event: LifecycleEvent): Promise<void> => {\n    const list = handlers.get(event);\n    if (!list) return;\n    for (const fn of list) {\n      try {\n        await fn();\n      } catch (error) {\n        // Match AppKit: a failing lifecycle handler is logged, never fatal, and\n        // never blocks its siblings.\n        logger.warn(\"lifecycle handler failed\", { event, error });\n      }\n    }\n  };\n\n  const context: InterceptorContext = {\n    env,\n    onLifecycle,\n    broadcastSignal,\n    bindProcess,\n  };\n\n  return { context, emitLifecycle };\n}\n\n/** Config for {@link LifecycleBridgePlugin}: the sink its captured events flow to. */\ninterface LifecycleBridgeConfig extends BasePluginConfig {\n  /** The runtime whose `emitLifecycle` receives the real AppKit events. */\n  runtime?: InterceptorRuntime;\n}\n\n/**\n * Structural shape of the `PluginContext.onLifecycle` we bridge. Mirrors only the\n * one method we touch (like {@link PluginContextLike} in `./plugin`), since\n * AppKit's `PluginContext` is not importable from the package's `exports`.\n */\ninterface LifecycleContextLike {\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n}\n\nfunction hasOnLifecycle(context: unknown): context is LifecycleContextLike {\n  return typeof (context as LifecycleContextLike | undefined)?.onLifecycle === \"function\";\n}\n\n/**\n * The internal plugin {@link createApp} injects to make AppKit's lifecycle\n * reachable from interceptor code. On `setup()` it reads its own `this.context`\n * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the\n * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine\n * events. It owns no routes, config surface, or exports.\n */\nexport class LifecycleBridgePlugin extends Plugin<LifecycleBridgeConfig> {\n  static manifest = {\n    name: \"dbxToolsLifecycleBridge\",\n    displayName: \"Lifecycle Bridge\",\n    description: \"Relays AppKit lifecycle events to the createApp interceptor context.\",\n    stability: \"beta\",\n    hidden: true,\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"dbxToolsLifecycleBridge\">;\n\n  override async setup(): Promise<void> {\n    const runtime = this.config.runtime;\n    if (!runtime) return;\n    if (!hasOnLifecycle(this.context)) {\n      logger.debug(\"no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert\");\n      return;\n    }\n    const events: LifecycleEvent[] = [\"setup:complete\", \"server:ready\", \"shutdown\"];\n    for (const event of events) {\n      this.context.onLifecycle(event, () => runtime.emitLifecycle(event));\n    }\n  }\n}\n\n/** Factory for the injected {@link LifecycleBridgePlugin}. */\nexport const lifecycleBridge = toPlugin(LifecycleBridgePlugin);\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/appkit.ts","../src/config.ts","../src/create-app.ts","../src/databricks.ts","../src/identity.ts","../src/lakebase-resolver.ts","../src/pgaddress.ts","../src/plugin.ts","../src/provision.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/appkit.ts","../src/config.ts","../src/create-app.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/pgaddress.ts","../src/plugin.ts","../src/provision.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -28,8 +28,8 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/core": "0.6.59",
-    "@dbx-tools/shared-core": "0.6.59",
+    "@dbx-tools/core": "0.6.60",
+    "@dbx-tools/shared-core": "0.6.60",
     "yaml": "^2.9.0",
     "zod": "4.3.6"
   },
@@ -47,7 +47,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.59",
+  "version": "0.6.60",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/create-app.ts

@@ -27,6 +27,13 @@ import { createApp as appkitCreateApp } from "@databricks/appkit";
 import type { PluginMap } from "@databricks/appkit/dist/shared/src/plugin";
 import { async, log } from "@dbx-tools/shared-core";
 
+import {
+  createInterceptorContext,
+  type Interceptor,
+  type InterceptorRuntime,
+  lifecycleBridge,
+  type ResolvedAppEnv,
+} from "./interceptor.ts";
 import { applyLakebaseEnv, type LakebaseConnection } from "./lakebase-resolver.ts";
 import { provisionCacheSchema } from "./provision.ts";
 
@@ -63,6 +70,13 @@ export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<
   onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;
   /** Auto-configuration to run before AppKit boots. Defaults to `"provision"`. */
   autoConfigure?: AutoConfigureMode | false;
+  /**
+   * One or many {@link Interceptor}s handed an {@link InterceptorContext} once
+   * auto-configuration has computed the env. Each receives the resolved env, an
+   * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -
+   * see `./interceptor`. The tunnel is the primary consumer.
+   */
+  interceptor?: Interceptor | Interceptor[];
 };
 
 const logger = log.logger("create-app");
@@ -103,7 +117,7 @@ function usesPlugin<T extends AppKitPlugins>(
 export async function autoConfigure<T extends AppKitPlugins>(
   config?: CreateAppConfig<T>,
   signal?: AbortSignal,
-): Promise<void> {
+): Promise<LakebaseConnection | undefined> {
   const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;
   const explicit = config?.autoConfigure !== undefined;
   const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);
@@ -114,7 +128,7 @@ export async function autoConfigure<T extends AppKitPlugins>(
       provisioned: false,
       skippedReason: mode === false ? "disabled" : "no lakebase plugin",
     });
-    return;
+    return undefined;
   }
 
   const controller = new AbortController();
@@ -122,8 +136,9 @@ export async function autoConfigure<T extends AppKitPlugins>(
   async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));
 
   const provision = mode === "provision";
-  await autoConfigureLakebase(provision, controller.signal);
+  const resolved = await autoConfigureLakebase(provision, controller.signal);
   logger.info("ready", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });
+  return resolved;
 }
 
 /**
@@ -156,10 +171,31 @@ function redactLakebaseConnection(resolved: LakebaseConnection): Record<string,
   };
 }
 
+/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */
+function resolvedAppEnv(lakebase: LakebaseConnection | undefined): ResolvedAppEnv {
+  return {
+    ...(lakebase ? { lakebase } : {}),
+    ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),
+  };
+}
+
+/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */
+function interceptorList(interceptor: CreateAppConfig["interceptor"]): Interceptor[] {
+  if (!interceptor) return [];
+  return Array.isArray(interceptor) ? interceptor : [interceptor];
+}
+
 /**
  * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
  * plugin-export map, with {@link autoConfigure} run first.
  *
+ * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an
+ * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE
+ * AppKit boots - so an interceptor can read the resolved connection, register
+ * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}
+ * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit
+ * events; it has no exports, so the returned {@link PluginMap} is unchanged.
+ *
  * @example
  * import { createApp } from "@dbx-tools/appkit";
  * import { lakebase, server } from "@databricks/appkit";
@@ -169,8 +205,26 @@ function redactLakebaseConnection(resolved: LakebaseConnection): Record<string,
 export async function createApp<T extends AppKitPlugins>(
   config?: CreateAppConfig<T>,
 ): Promise<PluginMap<T>> {
-  await autoConfigure(config);
+  const lakebase = await autoConfigure(config);
   const appConfig = { ...config };
   delete appConfig.autoConfigure;
+  delete appConfig.interceptor;
+
+  const interceptors = interceptorList(config?.interceptor);
+  if (interceptors.length === 0) {
+    return appkitCreateApp<T>(appConfig);
+  }
+
+  // Build the context from the computed env, run each interceptor (they register
+  // lifecycle handlers + bind processes), then inject the bridge that relays the
+  // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.
+  const runtime: InterceptorRuntime = createInterceptorContext(resolvedAppEnv(lakebase));
+  for (const interceptor of interceptors) {
+    await interceptor(runtime.context);
+  }
+  // Append the bridge to the plugins tuple. It is hidden and exports nothing, so
+  // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is
+  // only because appending widens the tuple type beyond `T`.
+  appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })] as unknown as T;
   return appkitCreateApp<T>(appConfig);
 }

package/src/identity.ts

@@ -20,7 +20,7 @@
  * where a missing token means something is wrong. It is fatal for an app whose
  * traffic legitimately arrives WITHOUT one:
  *
- *   - a public tunnel (`@dbx-tools/cli-tunnel`), where callers authenticate by
+ *   - a public tunnel (`@dbx-tools/tunnel`), where callers authenticate by
  *     email OTP and no OBO token exists to forward - the gate can prove WHO the
  *     caller is, but it cannot mint a Databricks credential for them;
  *   - any reverse proxy, webhook, or bot channel (`POST /api/teams/messages`)
@@ -41,7 +41,7 @@
  *
  * `"auto"` decides per REQUEST, not per boot, because a single container serves
  * both doors at once - the tunnel gate and the platform front door share a port
- * (see `@dbx-tools/cli-tunnel`). A boot-time flag would have to be wrong for one
+ * (see `@dbx-tools/tunnel`). A boot-time flag would have to be wrong for one
  * of them.
  *
  * What the service principal does NOT change is WHO the request belongs to. The

package/src/interceptor.ts

@@ -0,0 +1,261 @@
+/**
+ * The `createApp` INTERCEPTOR context: an in-process handle an app hands to
+ * add-ons (the tunnel, chiefly) so they can read the env auto-configuration
+ * computed, hook AppKit's lifecycle, and supervise sibling child processes as one
+ * unit - concurrently-style, where any death takes the whole set down.
+ *
+ * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to
+ * {@link CreateAppConfig.interceptor} ("one or many"). {@link createApp} runs each
+ * one AFTER auto-configuration has populated `process.env` but as part of booting
+ * the app, so an interceptor sees the resolved connection and can bind processes
+ * before or during setup.
+ *
+ * The names here mirror AppKit's own vocabulary rather than inventing parallel
+ * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the
+ * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /
+ * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -
+ * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin
+ * {@link createApp} injects to capture `this.context` and relay its events.
+ *
+ * @module
+ */
+
+import type { ChildProcess } from "node:child_process";
+import { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from "@databricks/appkit";
+import { log } from "@dbx-tools/shared-core";
+import type { LakebaseConnection } from "./lakebase-resolver.ts";
+
+const logger = log.logger("interceptor");
+
+/**
+ * AppKit's plugin-lifecycle events, verbatim from `PluginContext`
+ * (`node_modules/@databricks/appkit/.../core/plugin-context.d.ts`). Re-declared
+ * structurally rather than imported because `PluginContext` is not in the
+ * package's `exports` map (the same reason {@link PluginContextLike} exists in
+ * `./plugin`).
+ *
+ * - `setup:complete` - every plugin's `setup()` has resolved.
+ * - `server:ready` - the `server()` plugin is listening (never fires for a
+ *   serverless app, e.g. the tunnel gate).
+ * - `shutdown` - the app is tearing down.
+ */
+export type LifecycleEvent = "setup:complete" | "server:ready" | "shutdown";
+
+/** A lifecycle subscriber. Errors are logged, not propagated (matches AppKit). */
+export type LifecycleHandler = () => void | Promise<void>;
+
+/**
+ * The env auto-configuration resolved before boot, exposed to interceptors so
+ * they read COMPUTED values instead of re-reading `process.env` themselves.
+ *
+ * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran
+ * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the
+ * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the
+ * tunnel interceptor both reads and, when it must, sets.
+ */
+export interface ResolvedAppEnv {
+  /** Resolved Lakebase connection, when auto-config resolved one. */
+  readonly lakebase?: LakebaseConnection;
+  /** Resolved Databricks workspace host (`DATABRICKS_HOST`), when known. */
+  readonly databricksHost?: string;
+}
+
+/**
+ * A process {@link InterceptorContext.bindProcess} can supervise. A bare
+ * `node:child_process` `ChildProcess` (e.g. portr) satisfies this, and so does
+ * `@dbx-tools/core`'s `spawn()` result (a `ChildProcessResult` IS a
+ * `ChildProcess`) - one code path handles both.
+ */
+export type BindableProcess = Pick<ChildProcess, "pid" | "kill" | "killed" | "once">;
+
+/**
+ * The handle passed to each interceptor.
+ *
+ * @example
+ * import { createApp } from "@dbx-tools/appkit";
+ *
+ * await createApp({
+ *   plugins: [server()],
+ *   interceptor: (ctx) => {
+ *     const portr = spawnPortr(ctx.env.databricksHost);
+ *     ctx.bindProcess(portr);            // app <-> portr live/die together
+ *     ctx.onLifecycle("shutdown", () => portr.kill("SIGTERM"));
+ *   },
+ * });
+ */
+export interface InterceptorContext {
+  /** The env auto-configuration computed before boot. */
+  readonly env: ResolvedAppEnv;
+  /**
+   * Subscribe to an AppKit lifecycle event. Mirrors `PluginContext.onLifecycle`;
+   * the injected {@link lifecycleBridge} relays the real events here once the app
+   * boots. A handler registered for an event that already fired is NOT called
+   * retroactively (same semantics as AppKit).
+   */
+  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;
+  /**
+   * Broadcast a termination signal from the main app to every bound process.
+   * Called automatically when this process receives `SIGINT`/`SIGTERM`/`SIGHUP`;
+   * exposed so an interceptor can trigger teardown itself.
+   */
+  broadcastSignal(signal: NodeJS.Signals): void;
+  /**
+   * Supervise a child process alongside the app, concurrently-style: signals pass
+   * through, and if EITHER the child or the app dies the whole set comes down.
+   * Generalizes the tunnel's old hand-rolled `superviseExit`. Safe to call for
+   * several children; teardown is idempotent.
+   */
+  bindProcess(child: BindableProcess): void;
+}
+
+/** A single interceptor, or several. The `createApp` `interceptor?:` option. */
+export type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;
+
+/** How long bound children get to exit on `SIGTERM` before the app force-exits. */
+const TEARDOWN_GRACE_MS = 3000;
+
+/** The signals that trigger teardown when the MAIN process receives them. */
+const TEARDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
+
+/**
+ * The mutable machinery behind an {@link InterceptorContext}. Split out so
+ * {@link createInterceptorContext} can hand the public context to interceptors
+ * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.
+ */
+export interface InterceptorRuntime {
+  /** The context handed to each interceptor. */
+  readonly context: InterceptorContext;
+  /** Fire a lifecycle event to every subscriber (called by {@link lifecycleBridge}). */
+  emitLifecycle(event: LifecycleEvent): Promise<void>;
+}
+
+/**
+ * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.
+ *
+ * Teardown is the generalized `superviseExit`: the first child exit or main-process
+ * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,
+ * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it
+ * never itself holds the loop open). The process-signal listeners are installed
+ * lazily on the first `bindProcess` so an app that binds nothing is untouched.
+ */
+export function createInterceptorContext(env: ResolvedAppEnv): InterceptorRuntime {
+  const handlers = new Map<LifecycleEvent, LifecycleHandler[]>();
+  const children = new Set<BindableProcess>();
+  let shuttingDown = false;
+  let signalsBound = false;
+
+  const teardown = (code: number): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    for (const child of children) {
+      if (!child.killed) child.kill("SIGTERM");
+    }
+    setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();
+  };
+
+  const broadcastSignal = (signal: NodeJS.Signals): void => {
+    for (const child of children) {
+      if (!child.killed) child.kill(signal);
+    }
+    teardown(0);
+  };
+
+  const bindProcessSignals = (): void => {
+    if (signalsBound) return;
+    signalsBound = true;
+    for (const signal of TEARDOWN_SIGNALS) {
+      process.on(signal, () => broadcastSignal(signal));
+    }
+  };
+
+  const bindProcess = (child: BindableProcess): void => {
+    bindProcessSignals();
+    children.add(child);
+    child.once("exit", (code) => {
+      logger.warn("bound process exited; tearing down the app", { code });
+      teardown(typeof code === "number" ? code : 1);
+    });
+  };
+
+  const onLifecycle = (event: LifecycleEvent, fn: LifecycleHandler): void => {
+    const list = handlers.get(event);
+    if (list) list.push(fn);
+    else handlers.set(event, [fn]);
+  };
+
+  const emitLifecycle = async (event: LifecycleEvent): Promise<void> => {
+    const list = handlers.get(event);
+    if (!list) return;
+    for (const fn of list) {
+      try {
+        await fn();
+      } catch (error) {
+        // Match AppKit: a failing lifecycle handler is logged, never fatal, and
+        // never blocks its siblings.
+        logger.warn("lifecycle handler failed", { event, error });
+      }
+    }
+  };
+
+  const context: InterceptorContext = {
+    env,
+    onLifecycle,
+    broadcastSignal,
+    bindProcess,
+  };
+
+  return { context, emitLifecycle };
+}
+
+/** Config for {@link LifecycleBridgePlugin}: the sink its captured events flow to. */
+interface LifecycleBridgeConfig extends BasePluginConfig {
+  /** The runtime whose `emitLifecycle` receives the real AppKit events. */
+  runtime?: InterceptorRuntime;
+}
+
+/**
+ * Structural shape of the `PluginContext.onLifecycle` we bridge. Mirrors only the
+ * one method we touch (like {@link PluginContextLike} in `./plugin`), since
+ * AppKit's `PluginContext` is not importable from the package's `exports`.
+ */
+interface LifecycleContextLike {
+  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;
+}
+
+function hasOnLifecycle(context: unknown): context is LifecycleContextLike {
+  return typeof (context as LifecycleContextLike | undefined)?.onLifecycle === "function";
+}
+
+/**
+ * The internal plugin {@link createApp} injects to make AppKit's lifecycle
+ * reachable from interceptor code. On `setup()` it reads its own `this.context`
+ * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the
+ * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine
+ * events. It owns no routes, config surface, or exports.
+ */
+export class LifecycleBridgePlugin extends Plugin<LifecycleBridgeConfig> {
+  static manifest = {
+    name: "dbxToolsLifecycleBridge",
+    displayName: "Lifecycle Bridge",
+    description: "Relays AppKit lifecycle events to the createApp interceptor context.",
+    stability: "beta",
+    hidden: true,
+    resources: { required: [], optional: [] },
+  } satisfies PluginManifest<"dbxToolsLifecycleBridge">;
+
+  override async setup(): Promise<void> {
+    const runtime = this.config.runtime;
+    if (!runtime) return;
+    if (!hasOnLifecycle(this.context)) {
+      logger.debug("no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert");
+      return;
+    }
+    const events: LifecycleEvent[] = ["setup:complete", "server:ready", "shutdown"];
+    for (const event of events) {
+      this.context.onLifecycle(event, () => runtime.emitLifecycle(event));
+    }
+  }
+}
+
+/** Factory for the injected {@link LifecycleBridgePlugin}. */
+export const lifecycleBridge = toPlugin(LifecycleBridgePlugin);