@dbx-tools/appkit 0.6.58 → 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
 
@@ -86,6 +92,22 @@ const resolved = await lakebaseResolver.resolveLakebaseConnection({
 lakebaseResolver.applyLakebaseToEnv(resolved);
 ```
 
+`applyLakebaseEnv()` does both steps and applies the COMPLETE set a Postgres pool
+needs, `PGUSER` included — it is what auto-configuration itself calls, so a caller
+outside `createApp` gets the same env rather than a hand-rolled subset:
+
+```ts
+const { resolved, user } = await lakebaseResolver.applyLakebaseEnv({ autoCreate: false });
+```
+
+Reach for it when something other than the `lakebase()` plugin needs a working
+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/tunnel`'s OTP gate calls this for exactly that
+reason.
+
 ## Configuration
 
 `createApp.createApp()` accepts everything AppKit's `createApp` does, plus:
@@ -93,6 +115,7 @@ lakebaseResolver.applyLakebaseToEnv(resolved);
 | 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
@@ -130,7 +153,8 @@ Environment variables read during resolution:
 
 Resolved values are written back to `process.env` by
 `lakebaseResolver.applyLakebaseToEnv()`, which never overwrites a variable that
-is already set.
+is already set. That function covers everything except `PGUSER`, which needs an
+await; `lakebaseResolver.applyLakebaseEnv()` resolves and applies the full set.
 
 ## Resolve Local And Bundle Config
 
@@ -260,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.
@@ -298,17 +322,17 @@ is shared. `@dbx-tools/appkit-mastra` exposes this as its `genieIdentity` option
 
 ## Modules
 
-| Module             | Responsibility                                                                             |
-| ------------------ | ------------------------------------------------------------------------------------------ |
-| `createApp`        | `createApp()` wrapper and `autoConfigure()`.                                               |
-| `lakebaseResolver` | Lakebase connection discovery, default picking, optional auto-create, and env application. |
-| `pgaddress`        | Permissive Lakebase/Postgres address parser.                                               |
-| `config`           | Local/env/bundle/app-yaml config lookup.                                                   |
-| `appkit`           | Execution context lookup and initialization.                                               |
-| `databricks`       | App env detection and SDK context cancellation adapters.                                   |
-| `plugin`           | Typed AppKit plugin data, instance, and required-instance lookup.                          |
-| `provision`        | Cache schema provisioning helpers.                                                         |
-| `identity`         | OBO-vs-service-principal request identity: modes, resolution, and the forwarded headers.   |
+| Module             | Responsibility                                                                                                                                  |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createApp`        | `createApp()` wrapper and `autoConfigure()`.                                                                                                    |
+| `lakebaseResolver` | Lakebase connection discovery, default picking, optional auto-create, and env application (`applyLakebaseEnv()` for the full set a pool needs). |
+| `pgaddress`        | Permissive Lakebase/Postgres address parser.                                                                                                    |
+| `config`           | Local/env/bundle/app-yaml config lookup.                                                                                                        |
+| `appkit`           | Execution context lookup and initialization.                                                                                                    |
+| `databricks`       | App env detection and SDK context cancellation adapters.                                                                                        |
+| `plugin`           | Typed AppKit plugin data, instance, and required-instance lookup.                                                                               |
+| `provision`        | Cache schema provisioning helpers.                                                                                                              |
+| `identity`         | OBO-vs-service-principal request identity: modes, resolution, and the forwarded headers.                                                        |
 
 The shell-facing wrapper for auto-config is
 [`@dbx-tools/cli-appkit-env`](../../cli/appkit-env). Higher-level agent composition

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssTUFBTSxNQUFNLGlCQUFpQixDQUFDO0FBQzFDLE9BQU8sS0FBSyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxLQUFLLFNBQVMsTUFBTSxxQkFBcUIsQ0FBQztBQUNqRCxPQUFPLEtBQUssVUFBVSxNQUFNLHFCQUFxQixDQUFDO0FBQ2xELE9BQU8sS0FBSyxRQUFRLE1BQU0sbUJBQW1CLENBQUM7QUFDOUMsT0FBTyxLQUFLLGdCQUFnQixNQUFNLDRCQUE0QixDQUFDO0FBQy9ELE9BQU8sS0FBSyxTQUFTLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxLQUFLLE1BQU0sTUFBTSxpQkFBaUIsQ0FBQztBQUMxQyxPQUFPLEtBQUssU0FBUyxNQUFNLG9CQUFvQixDQUFDO0FBSWhELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsY0FBYyxFQUFFLGlCQUFpQixFQUFFLGNBQWMsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBR2xJLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCAqIGFzIGFwcGtpdCBmcm9tIFwiLi9zcmMvYXBwa2l0LnRzXCI7XG5leHBvcnQgKiBhcyBjb25maWcgZnJvbSBcIi4vc3JjL2NvbmZpZy50c1wiO1xuZXhwb3J0ICogYXMgY3JlYXRlQXBwIGZyb20gXCIuL3NyYy9jcmVhdGUtYXBwLnRzXCI7XG5leHBvcnQgKiBhcyBkYXRhYnJpY2tzIGZyb20gXCIuL3NyYy9kYXRhYnJpY2tzLnRzXCI7XG5leHBvcnQgKiBhcyBpZGVudGl0eSBmcm9tIFwiLi9zcmMvaWRlbnRpdHkudHNcIjtcbmV4cG9ydCAqIGFzIGxha2ViYXNlUmVzb2x2ZXIgZnJvbSBcIi4vc3JjL2xha2ViYXNlLXJlc29sdmVyLnRzXCI7XG5leHBvcnQgKiBhcyBwZ2FkZHJlc3MgZnJvbSBcIi4vc3JjL3BnYWRkcmVzcy50c1wiO1xuZXhwb3J0ICogYXMgcGx1Z2luIGZyb20gXCIuL3NyYy9wbHVnaW4udHNcIjtcbmV4cG9ydCAqIGFzIHByb3Zpc2lvbiBmcm9tIFwiLi9zcmMvcHJvdmlzaW9uLnRzXCI7XG5leHBvcnQgdHlwZSB7IEV4ZWN1dGlvbkNvbnRleHRMaWtlLCBXb3Jrc3BhY2VDbGllbnRMaWtlIH0gZnJvbSBcIi4vc3JjL2FwcGtpdC50c1wiO1xuZXhwb3J0IHR5cGUgeyBCdW5kbGVWYWxpZGF0ZUpzb24sIENvbmZpZ0ZpbGUsIENvbmZpZ1NvdXJjZSwgQ29uZmlnTWFwVmFsdWUsIFJlc29sdmVDb25maWdWYWx1ZU9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvY29uZmlnLnRzXCI7XG5leHBvcnQgdHlwZSB7IEF1dG9Db25maWd1cmVNb2RlLCBDcmVhdGVBcHBDb25maWcgfSBmcm9tIFwiLi9zcmMvY3JlYXRlLWFwcC50c1wiO1xuZXhwb3J0IHsgTUFYX1RDUF9QT1JUIH0gZnJvbSBcIi4vc3JjL2RhdGFicmlja3MudHNcIjtcbmV4cG9ydCB0eXBlIHsgQ29udGV4dExpa2UgfSBmcm9tIFwiLi9zcmMvZGF0YWJyaWNrcy50c1wiO1xuZXhwb3J0IHsgQUNDRVNTX1RPS0VOX0hFQURFUiwgVVNFUl9JRF9IRUFERVIsIFVTRVJfRU1BSUxfSEVBREVSLCBJREVOVElUWV9NT0RFUywgREVGQVVMVF9JREVOVElUWV9NT0RFIH0gZnJvbSBcIi4vc3JjL2lkZW50aXR5LnRzXCI7XG5leHBvcnQgdHlwZSB7IElkZW50aXR5TW9kZSwgSGVhZGVyQmVhcmluZyB9IGZyb20gXCIuL3NyYy9pZGVudGl0eS50c1wiO1xuZXhwb3J0IHR5cGUgeyBMYWtlYmFzZVJlc29sdmVySW5wdXRzLCBMYWtlYmFzZUNvbm5lY3Rpb24gfSBmcm9tIFwiLi9zcmMvbGFrZWJhc2UtcmVzb2x2ZXIudHNcIjtcbmV4cG9ydCB7IFNTTF9NT0RFUyB9IGZyb20gXCIuL3NyYy9wZ2FkZHJlc3MudHNcIjtcbmV4cG9ydCB0eXBlIHsgU3NsTW9kZSwgTGFrZWJhc2VDb25uZWN0aW9uSW5wdXRzLCBQYXJzZWRBZGRyZXNzIH0gZnJvbSBcIi4vc3JjL3BnYWRkcmVzcy50c1wiO1xuZXhwb3J0IHR5cGUgeyBQbHVnaW5Db250ZXh0TGlrZSB9IGZyb20gXCIuL3NyYy9wbHVnaW4udHNcIjtcbiJdfQ==
+//# 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

@@ -20,9 +20,10 @@
  *
  * @module
  */
-import { createApp as appkitCreateApp, getUsernameWithApiLookup } from "@databricks/appkit";
+import { createApp as appkitCreateApp } from "@databricks/appkit";
 import { async, log } from "@dbx-tools/shared-core";
-import { applyLakebaseToEnv, resolveLakebaseConnection, } from "./lakebase-resolver.js";
+import { createInterceptorContext, lifecycleBridge, } from "./interceptor.js";
+import { applyLakebaseEnv } from "./lakebase-resolver.js";
 import { provisionCacheSchema } from "./provision.js";
 const logger = log.logger("create-app");
 const LAKEBASE_PLUGIN = "lakebase";
@@ -63,27 +64,24 @@ 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
  * `process.env`, and return the record. Used by {@link autoConfigure}; call
- * {@link resolveLakebaseConnection} and {@link applyLakebaseToEnv} directly when
- * finer control is needed.
+ * {@link applyLakebaseEnv} directly when finer control is needed (a different
+ * `autoCreate` policy, or a caller that wants the env without booting AppKit).
  */
 async function autoConfigureLakebase(provision, signal) {
-    const resolved = await resolveLakebaseConnection(undefined, signal);
-    applyLakebaseToEnv(resolved);
-    const user = await getUsernameWithApiLookup({});
-    if (user)
-        process.env.PGUSER ??= user;
+    const { resolved, user } = await applyLakebaseEnv(undefined, signal);
     logger.info("env updated", { ...redactLakebaseConnection(resolved), user });
     if (provision) {
         await provisionCacheSchema(user, logger);
@@ -101,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";
@@ -112,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, getUsernameWithApiLookup } 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  applyLakebaseToEnv,\n  resolveLakebaseConnection,\n  type LakebaseConnection,\n} 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 resolveLakebaseConnection} and {@link applyLakebaseToEnv} directly when\n * finer control is needed.\n */\nasync function autoConfigureLakebase(\n  provision: boolean,\n  signal: AbortSignal,\n): Promise<LakebaseConnection> {\n  const resolved = await resolveLakebaseConnection(undefined, signal);\n  applyLakebaseToEnv(resolved);\n  const user = await getUsernameWithApiLookup({});\n  if (user) process.env.PGUSER ??= user;\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 {};