@dbx-tools/appkit 0.9.58 → 0.9.61

package/README.md

@@ -256,6 +256,33 @@ hard-code registered names or casts at every call site. A missing required
 plugin throws AppKit's `ConfigurationError`, naming both the caller and the
 plugin to register.
 
+## Supervise AppKit Subprocesses
+
+`AppKitChildProcess` starts a long-running sibling process through
+`@dbx-tools/core/exec` and owns its shutdown escalation. Its spawn tuple accepts
+core exec options, including line handlers and optional output capture.
+
+```ts
+import { AppKitChildProcess } from "@dbx-tools/appkit/child-process";
+
+const worker = new AppKitChildProcess([
+  "bun",
+  ["run", "worker.ts"],
+  {
+    stdout: { onLine: (line) => logger.info(line), capture: false },
+    stderr: { onLine: (line) => logger.error(line), capture: false },
+  },
+]);
+
+worker.start();
+this.context.onLifecycle("shutdown", () => worker.shutdown());
+```
+
+`shutdown()` is idempotent. It sends `SIGTERM`, waits seven seconds, then sends
+`SIGKILL` and waits one more second. Override those signals or timeouts in the
+constructor's second argument. A detached POSIX child is signaled as a process
+group so descendants do not survive their AppKit owner.
+
 ## Provision Lakebase Cache Schema
 
 `provision.provisionCacheSchema()` grants the AppKit cache schema in Lakebase to
@@ -340,5 +367,5 @@ is shared. `@dbx-tools/appkit-mastra` exposes this as its `genieIdentity` option
 | `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
+[`@dbx-tools/cli/appkit`](../../cli/dbx-tools). Higher-level agent composition
 is in [`@dbx-tools/appkit-mastra`](../appkit-mastra).

package/index.ts

@@ -3,10 +3,11 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export const PACKAGE_VERSION = "0.9.58";
+export const PACKAGE_VERSION = "0.9.61";
 export * as appkit from "./src/appkit.ts";
 export * as brandContext from "./src/brand-context.ts";
 export * as bundle from "./src/bundle.ts";
+export * as childProcess from "./src/child-process.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -21,6 +22,8 @@ export * as toolkitEntries from "./src/toolkit-entries.ts";
 export type { AutoConfigureMode, CreateAppConfig, ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
 export { bundleAppResourceSchema, flattenAppYamlEnv, flattenAppEnv, getBundlePath } from "./src/bundle.ts";
 export type { BundleValidateJson, ConfigFile, ConfigMapValue, ConfigSource, ResolveConfigValueOptions } from "./src/bundle.ts";
+export { AppKitChildProcess } from "./src/child-process.ts";
+export type { AppKitSpawnArgs, AppKitChildProcessOptions } from "./src/child-process.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";

package/lib/index.d.ts

@@ -1,8 +1,9 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export declare const PACKAGE_VERSION = "0.9.58";
+export declare const PACKAGE_VERSION = "0.9.61";
 export * as appkit from "./src/appkit.ts";
 export * as brandContext from "./src/brand-context.ts";
 export * as bundle from "./src/bundle.ts";
+export * as childProcess from "./src/child-process.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -17,6 +18,8 @@ export * as toolkitEntries from "./src/toolkit-entries.ts";
 export type { AutoConfigureMode, CreateAppConfig, ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
 export { bundleAppResourceSchema, flattenAppYamlEnv, flattenAppEnv, getBundlePath } from "./src/bundle.ts";
 export type { BundleValidateJson, ConfigFile, ConfigMapValue, ConfigSource, ResolveConfigValueOptions } from "./src/bundle.ts";
+export { AppKitChildProcess } from "./src/child-process.ts";
+export type { AppKitSpawnArgs, AppKitChildProcessOptions } from "./src/child-process.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";

package/lib/index.js

@@ -2,10 +2,11 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export const PACKAGE_VERSION = "0.9.58";
+export const PACKAGE_VERSION = "0.9.61";
 export * as appkit from "./src/appkit.js";
 export * as brandContext from "./src/brand-context.js";
 export * as bundle from "./src/bundle.js";
+export * as childProcess from "./src/child-process.js";
 export * as databricks from "./src/databricks.js";
 export * as identity from "./src/identity.js";
 export * as interceptor from "./src/interceptor.js";
@@ -18,8 +19,9 @@ export * as provision from "./src/provision.js";
 export * as toolProvider from "./src/tool-provider.js";
 export * as toolkitEntries from "./src/toolkit-entries.js";
 export { bundleAppResourceSchema, flattenAppYamlEnv, flattenAppEnv, getBundlePath } from "./src/bundle.js";
+export { AppKitChildProcess } from "./src/child-process.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";
 export { ToolRegistryPlugin } from "./src/tool-provider.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_cache-storage.js

@@ -16,6 +16,7 @@
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { createLakebasePool, getWorkspaceClient } from "@databricks/appkit";
+import { postgresConnectionOptions } from "@dbx-tools/postgres";
 import { errorUtils, hash, log } from "@dbx-tools/shared-core";
 import { handleOwnershipMigrationError } from "./migration.js";
 const logger = log.logger("cache-storage");
@@ -128,7 +129,7 @@ export async function createSoftPersistentStorage(cache) {
     }
     let pool;
     try {
-        const createdPool = createLakebasePool({ workspaceClient: getWorkspaceClient({}) });
+        const createdPool = createLakebasePool(postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }));
         pool = createdPool;
         const storage = new PersistentStorage(cache ?? {}, createdPool);
         softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));
@@ -150,4 +151,4 @@ export async function createSoftPersistentStorage(cache) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAoB,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AAkB3C,IAAI,qBAAqB,GAAoD,IAAI,CAAC;AAElF;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;QACnC,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,IAAI,CACrB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,EAC9C,6BAA6B,CAC9B,CAAC;QACF,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,iBACO,CAAC;QAC3C,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,CAAC,KAAK,CAAC,2DAA2D,CAAC,CAAC;YAC1E,qBAAqB,GAAG,SAAS,CAAC;YAClC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,qBAAqB,GAAG,MAAM,CAAC;QAC/B,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,+DAA+D,EAAE;YAC5E,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC;SACpC,CAAC,CAAC;QACH,qBAAqB,GAAG,SAAS,CAAC;QAClC,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,uBAAuB,CACpC,OAA8B,EAC9B,IAAkB;IAElB,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,OAAO,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAC5D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAC7B;;;yEAGqE,EACrE,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,CACxC,CAAC;IACF,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IAClD,MAAM,CAAC,IAAI,CAAC,mEAAmE,EAAE;QAC/E,MAAM,EAAE,OAAO,CAAC,UAAU;QAC1B,KAAK,EAAE,OAAO,CAAC,SAAS;KACzB,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AACd,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,gBAAgB,CAC9B,OAA8B,EAC9B,cAAuC;IAEvC,MAAM,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5D,IAAI,eAA0C,CAAC;IAE/C,OAAO,CAAC,UAAU,GAAG,KAAK,IAAI,EAAE;QAC9B,IAAI,OAAO,CAAC,WAAW;YAAE,OAAO;QAChC,eAAe,KAAK,CAAC,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC;gBACH,IAAI,CAAC,CAAC,MAAM,cAAc,EAAE,EAAE,CAAC;oBAAE,MAAM,kBAAkB,EAAE,CAAC;YAC9D,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IACE,CAAC,6BAA6B,CAAC,GAAG,EAAE;oBAClC,KAAK,EAAE,eAAe;oBACtB,MAAM;oBACN,KAAK,EAAE,mCAAmC;iBAC3C,CAAC,EACF,CAAC;oBACD,MAAM,GAAG,CAAC;gBACZ,CAAC;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QACL,IAAI,CAAC;YACH,MAAM,eAAe,CAAC;YACtB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;QAC7B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,eAAe,GAAG,SAAS,CAAC;YAC5B,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,OAA8B;IAC/D,MAAM,GAAG,GAAG,yBAAyB,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IACjD,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;QACpE,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,MAAM,EAAE,KAAK,KAAK,GAAG,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;YAAS,CAAC;QACT,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,KAA8B;IAE9B,MAAM,iBAAiB,GAAG,qBAAqB,EAAE,CAAC;IAClD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,IAA8B,CAAC;IACnC,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,kBAAkB,CAAC,EAAE,eAAe,EAAE,kBAAkB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACpF,IAAI,GAAG,WAAW,CAAC;QACnB,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC,KAAK,IAAI,EAAE,EAAE,WAAW,CAAC,CAAC;QAChE,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,uBAAuB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACnC,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YACtC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC;QAC3B,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;QAC5B,OAAO,OAAO,CAAC;IACjB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,mCAAmC,EAAE;YAChD,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC;SACpC,CAAC,CAAC;QACH,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Soft-fail Lakebase cache storage for AppKit's persistent cache.\n *\n * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on\n * any step failure. With `cache.strictPersistence: true` that throw makes\n * `CacheManager` silently disable the cache. This wraps the same storage,\n * still runs its migrations, but logs a failed step instead of throwing so a\n * usable table keeps serving.\n *\n * `PersistentStorage` is not on AppKit's public export map. The deep load is\n * lazy and best-effort: if the installed AppKit layout changes, this returns\n * `undefined` and `createApp` leaves AppKit on its default cache path.\n *\n * @module\n */\n\nimport { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\nimport { createLakebasePool, getWorkspaceClient, type CacheConfig } from \"@databricks/appkit\";\nimport { errorUtils, hash, log } from \"@dbx-tools/shared-core\";\nimport { handleOwnershipMigrationError } from \"./migration.ts\";\n\nconst logger = log.logger(\"cache-storage\");\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\n/** AppKit's internal persistent storage surface. */\nexport type PersistentStorageBase = CacheStorage & {\n  initialize(): Promise<void>;\n  initialized: boolean;\n  schemaName?: string;\n  tableName?: string;\n};\n\ntype PersistentStorageConstructor = new (\n  config: CacheConfig,\n  pool: LakebasePool,\n) => PersistentStorageBase;\n\nlet persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;\n\n/**\n * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`\n * means not attempted yet; `undefined` means the lookup already failed.\n */\nexport function loadPersistentStorage(): PersistentStorageConstructor | undefined {\n  if (persistentStorageCtor !== null) {\n    return persistentStorageCtor;\n  }\n  try {\n    const require = createRequire(import.meta.url);\n    const modulePath = join(\n      dirname(require.resolve(\"@databricks/appkit\")),\n      \"cache/storage/persistent.js\",\n    );\n    const loaded = require(modulePath).PersistentStorage as\n      PersistentStorageConstructor | undefined;\n    if (typeof loaded !== \"function\") {\n      logger.debug(\"soft persistent cache skipped (PersistentStorage missing)\");\n      persistentStorageCtor = undefined;\n      return undefined;\n    }\n    persistentStorageCtor = loaded;\n    return loaded;\n  } catch (err) {\n    logger.debug(\"soft persistent cache skipped (PersistentStorage unavailable)\", {\n      error: errorUtils.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/**\n * Whether an existing cache table belongs to another role.\n *\n * PostgreSQL allows granted reads/writes but reserves index DDL for the table\n * owner. Skip AppKit migrations in that case; {@link probeStorage} still proves\n * the existing table can serve the cache before it is accepted.\n */\nasync function tableOwnedByAnotherRole(\n  storage: PersistentStorageBase,\n  pool: LakebasePool,\n): Promise<boolean> {\n  if (!storage.schemaName || !storage.tableName) return false;\n  const result = await pool.query(\n    `SELECT pg_get_userbyid(c.relowner) = current_user AS owned\n     FROM pg_class c\n     JOIN pg_namespace n ON n.oid = c.relnamespace\n     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r', 'p')`,\n    [storage.schemaName, storage.tableName],\n  );\n  if (result.rows[0]?.owned !== false) return false;\n  logger.warn(\"persistent cache migrations skipped (table owned by another role)\", {\n    schema: storage.schemaName,\n    table: storage.tableName,\n  });\n  return true;\n}\n\n/** Soften `initialize()` so an ownership-only migration failure is not fatal. */\nexport function softenInitialize(\n  storage: PersistentStorageBase,\n  skipMigrations?: () => Promise<boolean>,\n): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  let softInitPromise: Promise<void> | undefined;\n\n  storage.initialize = async () => {\n    if (storage.initialized) return;\n    softInitPromise ??= (async () => {\n      try {\n        if (!(await skipMigrations?.())) await originalInitialize();\n      } catch (err) {\n        if (\n          !handleOwnershipMigrationError(err, {\n            scope: \"cache-storage\",\n            logger,\n            event: \"persistent cache migration failed\",\n          })\n        ) {\n          throw err;\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n      storage.initialized = true;\n    } catch (err) {\n      softInitPromise = undefined;\n      throw err;\n    }\n  };\n}\n\n/** Verify the migrated cache table can serve the reads and writes AppKit needs. */\nexport async function probeStorage(storage: PersistentStorageBase): Promise<void> {\n  const key = `dbx-tools:cache-probe:${hash.id()}`;\n  try {\n    await storage.set(key, { value: key, expiry: Date.now() + 60_000 });\n    const result = await storage.get(key);\n    if (result?.value !== key) {\n      throw new Error(\"persistent cache probe returned an unexpected value\");\n    }\n  } finally {\n    await storage.delete(key).catch(() => undefined);\n  }\n}\n\n/**\n * Build a soft-fail Lakebase cache storage when a pool can be created and\n * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so\n * AppKit can fall through to its normal cache path.\n */\nexport async function createSoftPersistentStorage(\n  cache: CacheConfig | undefined,\n): Promise<CacheStorage | undefined> {\n  const PersistentStorage = loadPersistentStorage();\n  if (!PersistentStorage) {\n    return undefined;\n  }\n\n  let pool: LakebasePool | undefined;\n  try {\n    const createdPool = createLakebasePool({ workspaceClient: getWorkspaceClient({}) });\n    pool = createdPool;\n    const storage = new PersistentStorage(cache ?? {}, createdPool);\n    softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    await probeStorage(storage);\n    return storage;\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: errorUtils.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Soft-fail Lakebase cache storage for AppKit's persistent cache.\n *\n * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on\n * any step failure. With `cache.strictPersistence: true` that throw makes\n * `CacheManager` silently disable the cache. This wraps the same storage,\n * still runs its migrations, but logs a failed step instead of throwing so a\n * usable table keeps serving.\n *\n * `PersistentStorage` is not on AppKit's public export map. The deep load is\n * lazy and best-effort: if the installed AppKit layout changes, this returns\n * `undefined` and `createApp` leaves AppKit on its default cache path.\n *\n * @module\n */\n\nimport { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\nimport { createLakebasePool, getWorkspaceClient, type CacheConfig } from \"@databricks/appkit\";\nimport { postgresConnectionOptions } from \"@dbx-tools/postgres\";\nimport { errorUtils, hash, log } from \"@dbx-tools/shared-core\";\nimport { handleOwnershipMigrationError } from \"./migration.ts\";\n\nconst logger = log.logger(\"cache-storage\");\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\n/** AppKit's internal persistent storage surface. */\nexport type PersistentStorageBase = CacheStorage & {\n  initialize(): Promise<void>;\n  initialized: boolean;\n  schemaName?: string;\n  tableName?: string;\n};\n\ntype PersistentStorageConstructor = new (\n  config: CacheConfig,\n  pool: LakebasePool,\n) => PersistentStorageBase;\n\nlet persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;\n\n/**\n * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`\n * means not attempted yet; `undefined` means the lookup already failed.\n */\nexport function loadPersistentStorage(): PersistentStorageConstructor | undefined {\n  if (persistentStorageCtor !== null) {\n    return persistentStorageCtor;\n  }\n  try {\n    const require = createRequire(import.meta.url);\n    const modulePath = join(\n      dirname(require.resolve(\"@databricks/appkit\")),\n      \"cache/storage/persistent.js\",\n    );\n    const loaded = require(modulePath).PersistentStorage as\n      PersistentStorageConstructor | undefined;\n    if (typeof loaded !== \"function\") {\n      logger.debug(\"soft persistent cache skipped (PersistentStorage missing)\");\n      persistentStorageCtor = undefined;\n      return undefined;\n    }\n    persistentStorageCtor = loaded;\n    return loaded;\n  } catch (err) {\n    logger.debug(\"soft persistent cache skipped (PersistentStorage unavailable)\", {\n      error: errorUtils.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/**\n * Whether an existing cache table belongs to another role.\n *\n * PostgreSQL allows granted reads/writes but reserves index DDL for the table\n * owner. Skip AppKit migrations in that case; {@link probeStorage} still proves\n * the existing table can serve the cache before it is accepted.\n */\nasync function tableOwnedByAnotherRole(\n  storage: PersistentStorageBase,\n  pool: LakebasePool,\n): Promise<boolean> {\n  if (!storage.schemaName || !storage.tableName) return false;\n  const result = await pool.query(\n    `SELECT pg_get_userbyid(c.relowner) = current_user AS owned\n     FROM pg_class c\n     JOIN pg_namespace n ON n.oid = c.relnamespace\n     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r', 'p')`,\n    [storage.schemaName, storage.tableName],\n  );\n  if (result.rows[0]?.owned !== false) return false;\n  logger.warn(\"persistent cache migrations skipped (table owned by another role)\", {\n    schema: storage.schemaName,\n    table: storage.tableName,\n  });\n  return true;\n}\n\n/** Soften `initialize()` so an ownership-only migration failure is not fatal. */\nexport function softenInitialize(\n  storage: PersistentStorageBase,\n  skipMigrations?: () => Promise<boolean>,\n): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  let softInitPromise: Promise<void> | undefined;\n\n  storage.initialize = async () => {\n    if (storage.initialized) return;\n    softInitPromise ??= (async () => {\n      try {\n        if (!(await skipMigrations?.())) await originalInitialize();\n      } catch (err) {\n        if (\n          !handleOwnershipMigrationError(err, {\n            scope: \"cache-storage\",\n            logger,\n            event: \"persistent cache migration failed\",\n          })\n        ) {\n          throw err;\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n      storage.initialized = true;\n    } catch (err) {\n      softInitPromise = undefined;\n      throw err;\n    }\n  };\n}\n\n/** Verify the migrated cache table can serve the reads and writes AppKit needs. */\nexport async function probeStorage(storage: PersistentStorageBase): Promise<void> {\n  const key = `dbx-tools:cache-probe:${hash.id()}`;\n  try {\n    await storage.set(key, { value: key, expiry: Date.now() + 60_000 });\n    const result = await storage.get(key);\n    if (result?.value !== key) {\n      throw new Error(\"persistent cache probe returned an unexpected value\");\n    }\n  } finally {\n    await storage.delete(key).catch(() => undefined);\n  }\n}\n\n/**\n * Build a soft-fail Lakebase cache storage when a pool can be created and\n * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so\n * AppKit can fall through to its normal cache path.\n */\nexport async function createSoftPersistentStorage(\n  cache: CacheConfig | undefined,\n): Promise<CacheStorage | undefined> {\n  const PersistentStorage = loadPersistentStorage();\n  if (!PersistentStorage) {\n    return undefined;\n  }\n\n  let pool: LakebasePool | undefined;\n  try {\n    const createdPool = createLakebasePool(\n      postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }),\n    );\n    pool = createdPool;\n    const storage = new PersistentStorage(cache ?? {}, createdPool);\n    softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    await probeStorage(storage);\n    return storage;\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: errorUtils.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}

package/lib/src/child-process.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AppKit child-process lifecycle built on `@dbx-tools/core/exec`.
+ *
+ * @module
+ */
+import * as exec from "@dbx-tools/core/exec";
+/** Spawn arguments accepted by {@link AppKitChildProcess}. */
+export type AppKitSpawnArgs = exec.SpawnArgs<exec.ExecOptions>;
+/** Graceful and forced shutdown policy for an AppKit child process. */
+export interface AppKitChildProcessOptions {
+    /** Signal sent when shutdown starts. Defaults to `SIGTERM`. */
+    gracefulSignal?: NodeJS.Signals;
+    /** Time to wait after the graceful signal. Defaults to 7 seconds. */
+    gracefulTimeoutMs?: number;
+    /** Signal sent when graceful shutdown times out. Defaults to `SIGKILL`. */
+    forceSignal?: NodeJS.Signals;
+    /** Time to wait after the force signal. Defaults to 1 second. */
+    forceTimeoutMs?: number;
+}
+/**
+ * Start and stop one AppKit-owned subprocess.
+ *
+ * The spawn arguments use {@link exec.ExecOptions}, including core exec's
+ * stdin, output capture, line handlers, exit checking, and trim policy.
+ * Shutdown is idempotent and escalates from the graceful signal to the force
+ * signal when the child does not exit within the configured timeouts.
+ */
+export declare class AppKitChildProcess {
+    #private;
+    constructor(spawnArgs: AppKitSpawnArgs, options?: AppKitChildProcessOptions);
+    /** Current child handle, or `undefined` when no child is running. */
+    get process(): exec.ChildProcessResult | undefined;
+    /** Whether the current child has not reported an exit code or signal. */
+    get running(): boolean;
+    /** Start the configured child process. */
+    start(): exec.ChildProcessResult;
+    /** Stop the child once, escalating when graceful shutdown times out. */
+    shutdown(): Promise<void>;
+}

package/lib/src/child-process.js

@@ -0,0 +1,128 @@
+/**
+ * AppKit child-process lifecycle built on `@dbx-tools/core/exec`.
+ *
+ * @module
+ */
+import * as exec from "@dbx-tools/core/exec";
+/**
+ * Start and stop one AppKit-owned subprocess.
+ *
+ * The spawn arguments use {@link exec.ExecOptions}, including core exec's
+ * stdin, output capture, line handlers, exit checking, and trim policy.
+ * Shutdown is idempotent and escalates from the graceful signal to the force
+ * signal when the child does not exit within the configured timeouts.
+ */
+export class AppKitChildProcess {
+    #spawnArgs;
+    #options;
+    #detached;
+    #child;
+    #shutdownPromise;
+    constructor(spawnArgs, options = {}) {
+        this.#spawnArgs = spawnArgs;
+        this.#options = {
+            gracefulSignal: options.gracefulSignal ?? "SIGTERM",
+            gracefulTimeoutMs: options.gracefulTimeoutMs ?? 7_000,
+            forceSignal: options.forceSignal ?? "SIGKILL",
+            forceTimeoutMs: options.forceTimeoutMs ?? 1_000,
+        };
+        this.#detached = spawnOptions(spawnArgs)?.detached === true;
+    }
+    /** Current child handle, or `undefined` when no child is running. */
+    get process() {
+        return this.#child;
+    }
+    /** Whether the current child has not reported an exit code or signal. */
+    get running() {
+        return this.#child !== undefined && !hasExited(this.#child);
+    }
+    /** Start the configured child process. */
+    start() {
+        if (this.running)
+            throw new Error("Child process is already running");
+        if (this.#shutdownPromise) {
+            throw new Error("Child process is shutting down or has been shut down");
+        }
+        const child = exec.spawn(...this.#spawnArgs);
+        this.#child = child;
+        void child.once("close", () => {
+            if (this.#child === child)
+                this.#child = undefined;
+        });
+        return child;
+    }
+    /** Stop the child once, escalating when graceful shutdown times out. */
+    shutdown() {
+        this.#shutdownPromise ??= this.#performShutdown();
+        return this.#shutdownPromise;
+    }
+    async #performShutdown() {
+        const child = this.#child;
+        if (!child || hasExited(child)) {
+            this.#child = undefined;
+            return;
+        }
+        signalChild(child, this.#options.gracefulSignal, this.#detached);
+        if (await waitForExit(child, this.#options.gracefulTimeoutMs)) {
+            if (this.#child === child)
+                this.#child = undefined;
+            return;
+        }
+        signalChild(child, this.#options.forceSignal, this.#detached);
+        if (!(await waitForExit(child, this.#options.forceTimeoutMs))) {
+            throw new Error(`Child process ${child.pid ?? "<unknown>"} did not terminate`);
+        }
+        if (this.#child === child)
+            this.#child = undefined;
+    }
+}
+function spawnOptions(args) {
+    const value = args.at(-1);
+    return isExecOptions(value) ? value : undefined;
+}
+function isExecOptions(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasExited(child) {
+    return child.exitCode !== null || child.signalCode !== null;
+}
+function signalChild(child, signal, detached) {
+    if (detached && process.platform !== "win32" && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch {
+            // Fall back to the direct child when the process group already exited.
+        }
+    }
+    child.kill(signal);
+}
+function waitForExit(child, timeoutMs) {
+    if (hasExited(child))
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let timer;
+        let settled = false;
+        const finish = (exited) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            void child.off("exit", onExit);
+            void child.off("error", onError);
+            resolve(exited);
+        };
+        const onExit = () => finish(true);
+        const onError = () => finish(true);
+        void child.once("exit", onExit);
+        void child.once("error", onError);
+        if (hasExited(child)) {
+            finish(true);
+            return;
+        }
+        timer = setTimeout(() => finish(false), timeoutMs);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"child-process.js","sourceRoot":"","sources":["../../src/child-process.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit child-process lifecycle built on `@dbx-tools/core/exec`.\n *\n * @module\n */\nimport * as exec from \"@dbx-tools/core/exec\";\n\n/** Spawn arguments accepted by {@link AppKitChildProcess}. */\nexport type AppKitSpawnArgs = exec.SpawnArgs<exec.ExecOptions>;\n\n/** Graceful and forced shutdown policy for an AppKit child process. */\nexport interface AppKitChildProcessOptions {\n  /** Signal sent when shutdown starts. Defaults to `SIGTERM`. */\n  gracefulSignal?: NodeJS.Signals;\n  /** Time to wait after the graceful signal. Defaults to 7 seconds. */\n  gracefulTimeoutMs?: number;\n  /** Signal sent when graceful shutdown times out. Defaults to `SIGKILL`. */\n  forceSignal?: NodeJS.Signals;\n  /** Time to wait after the force signal. Defaults to 1 second. */\n  forceTimeoutMs?: number;\n}\n\n/**\n * Start and stop one AppKit-owned subprocess.\n *\n * The spawn arguments use {@link exec.ExecOptions}, including core exec's\n * stdin, output capture, line handlers, exit checking, and trim policy.\n * Shutdown is idempotent and escalates from the graceful signal to the force\n * signal when the child does not exit within the configured timeouts.\n */\nexport class AppKitChildProcess {\n  readonly #spawnArgs: AppKitSpawnArgs;\n  readonly #options: Required<AppKitChildProcessOptions>;\n  readonly #detached: boolean;\n\n  #child?: exec.ChildProcessResult;\n  #shutdownPromise?: Promise<void>;\n\n  constructor(spawnArgs: AppKitSpawnArgs, options: AppKitChildProcessOptions = {}) {\n    this.#spawnArgs = spawnArgs;\n    this.#options = {\n      gracefulSignal: options.gracefulSignal ?? \"SIGTERM\",\n      gracefulTimeoutMs: options.gracefulTimeoutMs ?? 7_000,\n      forceSignal: options.forceSignal ?? \"SIGKILL\",\n      forceTimeoutMs: options.forceTimeoutMs ?? 1_000,\n    };\n    this.#detached = spawnOptions(spawnArgs)?.detached === true;\n  }\n\n  /** Current child handle, or `undefined` when no child is running. */\n  get process(): exec.ChildProcessResult | undefined {\n    return this.#child;\n  }\n\n  /** Whether the current child has not reported an exit code or signal. */\n  get running(): boolean {\n    return this.#child !== undefined && !hasExited(this.#child);\n  }\n\n  /** Start the configured child process. */\n  start(): exec.ChildProcessResult {\n    if (this.running) throw new Error(\"Child process is already running\");\n    if (this.#shutdownPromise) {\n      throw new Error(\"Child process is shutting down or has been shut down\");\n    }\n\n    const child = exec.spawn(...this.#spawnArgs);\n    this.#child = child;\n    void child.once(\"close\", () => {\n      if (this.#child === child) this.#child = undefined;\n    });\n    return child;\n  }\n\n  /** Stop the child once, escalating when graceful shutdown times out. */\n  shutdown(): Promise<void> {\n    this.#shutdownPromise ??= this.#performShutdown();\n    return this.#shutdownPromise;\n  }\n\n  async #performShutdown(): Promise<void> {\n    const child = this.#child;\n    if (!child || hasExited(child)) {\n      this.#child = undefined;\n      return;\n    }\n\n    signalChild(child, this.#options.gracefulSignal, this.#detached);\n    if (await waitForExit(child, this.#options.gracefulTimeoutMs)) {\n      if (this.#child === child) this.#child = undefined;\n      return;\n    }\n\n    signalChild(child, this.#options.forceSignal, this.#detached);\n    if (!(await waitForExit(child, this.#options.forceTimeoutMs))) {\n      throw new Error(`Child process ${child.pid ?? \"<unknown>\"} did not terminate`);\n    }\n    if (this.#child === child) this.#child = undefined;\n  }\n}\n\nfunction spawnOptions(args: AppKitSpawnArgs): exec.ExecOptions | undefined {\n  const value = args.at(-1);\n  return isExecOptions(value) ? value : undefined;\n}\n\nfunction isExecOptions(value: unknown): value is exec.ExecOptions {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\nfunction hasExited(child: exec.ChildProcessResult): boolean {\n  return child.exitCode !== null || child.signalCode !== null;\n}\n\nfunction signalChild(\n  child: exec.ChildProcessResult,\n  signal: NodeJS.Signals,\n  detached: boolean,\n): void {\n  if (detached && process.platform !== \"win32\" && child.pid) {\n    try {\n      process.kill(-child.pid, signal);\n      return;\n    } catch {\n      // Fall back to the direct child when the process group already exited.\n    }\n  }\n  child.kill(signal);\n}\n\nfunction waitForExit(child: exec.ChildProcessResult, timeoutMs: number): Promise<boolean> {\n  if (hasExited(child)) return Promise.resolve(true);\n\n  return new Promise((resolve) => {\n    let timer: NodeJS.Timeout | undefined;\n    let settled = false;\n\n    const finish = (exited: boolean) => {\n      if (settled) return;\n      settled = true;\n      if (timer) clearTimeout(timer);\n      void child.off(\"exit\", onExit);\n      void child.off(\"error\", onError);\n      resolve(exited);\n    };\n    const onExit = () => finish(true);\n    const onError = () => finish(true);\n\n    void child.once(\"exit\", onExit);\n    void child.once(\"error\", onError);\n    if (hasExited(child)) {\n      finish(true);\n      return;\n    }\n    timer = setTimeout(() => finish(false), timeoutMs);\n  });\n}\n"]}

package/lib/src/provision.js

@@ -22,6 +22,7 @@
  */
 import { createLakebasePool, getWorkspaceClient, ValidationError } from "@databricks/appkit";
 import { configUtils } from "@dbx-tools/core";
+import { postgresConnectionOptions, quotePostgresIdentifier } from "@dbx-tools/postgres";
 import { errorUtils, log } from "@dbx-tools/shared-core";
 const defaultLogger = log.logger("provision");
 /** AppKit persistent-cache schema (see AppKit's `PersistentStorage`). */
@@ -38,16 +39,6 @@ const ROLE_PATTERN = /^[A-Za-z0-9._@+-]{1,255}$/;
  */
 const CONNECT_TIMEOUT_MS = 10_000;
 const STATEMENT_TIMEOUT_MS = 15_000;
-/**
- * Quote a Postgres identifier: wrap in double quotes and double any embedded
- * quote. Schema and role names are identifiers, and Postgres does not accept a
- * bind parameter in an identifier position, so quoting is the only defense
- * available for these statements. Lakebase role names are usually emails
- * (`user@host`), which must be quoted to be a valid identifier at all.
- */
-function quoteIdent(ident) {
-    return `"${ident.replace(/"/g, '""')}"`;
-}
 /**
  * Idempotent grants that make the (already-existing) AppKit cache schema fully
  * usable by `role`. The `ALTER DEFAULT PRIVILEGES` lines cover the cache table
@@ -60,8 +51,8 @@ export function cacheGrantStatements(role) {
     if (!ROLE_PATTERN.test(role)) {
         throw ValidationError.invalidValue("role", role, "a Postgres role name");
     }
-    const schema = quoteIdent(CACHE_SCHEMA);
-    const target = quoteIdent(role);
+    const schema = quotePostgresIdentifier(CACHE_SCHEMA);
+    const target = quotePostgresIdentifier(role);
     return [
         `GRANT USAGE, CREATE ON SCHEMA ${schema} TO ${target}`,
         `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ${schema} TO ${target}`,
@@ -103,12 +94,12 @@ export async function provisionCacheSchema(role, logger = defaultLogger) {
     // returns a fresh default-auth client - literally `new WorkspaceClient({})`,
     // but built against the SDK version AppKit's `createLakebasePool` expects
     // (importing the SDK class directly here pulls a newer, type-incompatible copy).
-    const pool = createLakebasePool({
+    const pool = createLakebasePool(postgresConnectionOptions({
         user: role,
         workspaceClient: getWorkspaceClient({}),
         connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
         statement_timeout: STATEMENT_TIMEOUT_MS,
-    });
+    }));
     try {
         const found = await pool.query("SELECT 1 FROM information_schema.schemata WHERE schema_name = $1", [CACHE_SCHEMA]);
         if (found.rowCount === 0) {
@@ -130,4 +121,4 @@ export async function provisionCacheSchema(role, logger = defaultLogger) {
         await pool.end().catch(() => { });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../src/provision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAE9C,yEAAyE;AACzE,MAAM,YAAY,GAAG,QAAQ,CAAC;AAE9B;;;GAGG;AACH,MAAM,YAAY,GAAG,2BAA2B,CAAC;AAEjD;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAClC,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAEpC;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;AAC1C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,MAAM,eAAe,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,sBAAsB,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,MAAM,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAChC,OAAO;QACL,iCAAiC,MAAM,OAAO,MAAM,EAAE;QACtD,gDAAgD,MAAM,OAAO,MAAM,EAAE;QACrE,mDAAmD,MAAM,OAAO,MAAM,EAAE;QACxE,sCAAsC,MAAM,2BAA2B,MAAM,EAAE;QAC/E,sCAAsC,MAAM,8BAA8B,MAAM,EAAE;KACnF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,IAAwB,EACxB,SAAqB,aAAa;IAElC,IAAI,WAAW,CAAC,kBAAkB,EAAE,EAAE,CAAC;QACrC,MAAM,CAAC,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC1E,OAAO;IACT,CAAC;IACD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,CAAC,IAAI,CAAC,qEAAqE,CAAC,CAAC;QACnF,OAAO;IACT,CAAC;IACD,gEAAgE;IAChE,2EAA2E;IAC3E,8EAA8E;IAC9E,6EAA6E;IAC7E,0EAA0E;IAC1E,iFAAiF;IACjF,MAAM,IAAI,GAAG,kBAAkB,CAAC;QAC9B,IAAI,EAAE,IAAI;QACV,eAAe,EAAE,kBAAkB,CAAC,EAAE,CAAC;QACvC,uBAAuB,EAAE,kBAAkB;QAC3C,iBAAiB,EAAE,oBAAoB;KACxC,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAC5B,kEAAkE,EAClE,CAAC,YAAY,CAAC,CACf,CAAC;QACF,IAAI,KAAK,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,KAAK,CAAC,iDAAiD,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;YAC1F,OAAO;QACT,CAAC;QACD,KAAK,MAAM,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,8BAA8B,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,gDAAgD,EAAE;YAC5D,MAAM,EAAE,YAAY;YACpB,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC;SACpC,CAAC,CAAC;IACL,CAAC;YAAS,CAAC;QACT,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IACnC,CAAC;AACH,CAAC","sourcesContent":["/**\n * Lakebase cache-schema grant fix-up.\n *\n * AppKit's persistent cache (`CacheManager` -> `PersistentStorage`) uses a\n * schema `appkit` and a table `appkit.appkit_cache_entries`. When the connecting\n * Databricks identity lacks privileges on that schema, the cache migration\n * throws, and because AppKit is typically run with `cache.strictPersistence:\n * true`, the cache is silently switched to a disabled in-memory stub - so every\n * persistent read (chart long-poll, history, etc.) misses and 404s.\n *\n * This grants the connecting role full rights on the cache schema, but only when\n * the schema ALREADY EXISTS - it never creates the schema itself. Run from a\n * LOCAL identity that owns the schema (or holds grant option on it); it is\n * skipped inside a Databricks App, where the app SP cannot grant and its\n * Postgres role does not exist until its first connection.\n *\n * Must run AFTER {@link applyLakebaseToEnv} has written the resolved connection\n * to `process.env` (so `createLakebasePool` picks up host / database / endpoint)\n * and BEFORE `createApp` initializes the cache.\n *\n * @module\n */\n\nimport { createLakebasePool, getWorkspaceClient, ValidationError } from \"@databricks/appkit\";\nimport { configUtils } from \"@dbx-tools/core\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\n\nconst defaultLogger = log.logger(\"provision\");\n\n/** AppKit persistent-cache schema (see AppKit's `PersistentStorage`). */\nconst CACHE_SCHEMA = \"appkit\";\n\n/**\n * Characters a Lakebase Postgres role can legitimately contain: workspace\n * identities are emails, service principals are UUIDs.\n */\nconst ROLE_PATTERN = /^[A-Za-z0-9._@+-]{1,255}$/;\n\n/**\n * Provisioning runs at boot as the local developer identity, before any plugin\n * exists, so it is outside AppKit's interceptor chain and inherits no timeout\n * from it. Both bounds are explicit for that reason.\n */\nconst CONNECT_TIMEOUT_MS = 10_000;\nconst STATEMENT_TIMEOUT_MS = 15_000;\n\n/**\n * Quote a Postgres identifier: wrap in double quotes and double any embedded\n * quote. Schema and role names are identifiers, and Postgres does not accept a\n * bind parameter in an identifier position, so quoting is the only defense\n * available for these statements. Lakebase role names are usually emails\n * (`user@host`), which must be quoted to be a valid identifier at all.\n */\nfunction quoteIdent(ident: string): string {\n  return `\"${ident.replace(/\"/g, '\"\"')}\"`;\n}\n\n/**\n * Idempotent grants that make the (already-existing) AppKit cache schema fully\n * usable by `role`. The `ALTER DEFAULT PRIVILEGES` lines cover the cache table\n * whenever the schema owner creates it later.\n *\n * Throws a {@link ValidationError} when `role` is not a plausible Postgres role\n * name, since the value lands in an identifier position.\n */\nexport function cacheGrantStatements(role: string): readonly string[] {\n  if (!ROLE_PATTERN.test(role)) {\n    throw ValidationError.invalidValue(\"role\", role, \"a Postgres role name\");\n  }\n  const schema = quoteIdent(CACHE_SCHEMA);\n  const target = quoteIdent(role);\n  return [\n    `GRANT USAGE, CREATE ON SCHEMA ${schema} TO ${target}`,\n    `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ${schema} TO ${target}`,\n    `GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA ${schema} TO ${target}`,\n    `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON TABLES TO ${target}`,\n    `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON SEQUENCES TO ${target}`,\n  ];\n}\n\n/**\n * Grant `role` rights on the AppKit cache schema, but only when that schema\n * already exists.\n *\n * No-ops inside a Databricks App env, when `role` is undefined, or when the\n * schema is absent. Best-effort otherwise: any failure (e.g. the local identity\n * doesn't own the schema) is logged and swallowed so it never blocks startup -\n * a disabled cache is degraded, not fatal.\n *\n * @param role - Postgres role to grant to and connect as (the resolved\n *   workspace-client identity); skips when undefined.\n * @param logger - Logger to report progress on. Defaults to this module's.\n *\n * @example\n * import { provision } from \"@dbx-tools/appkit\";\n *\n * await provision.provisionCacheSchema(\"app-service-principal@databricks.com\");\n */\nexport async function provisionCacheSchema(\n  role: string | undefined,\n  logger: log.Logger = defaultLogger,\n): Promise<void> {\n  if (configUtils.isDatabricksAppEnv()) {\n    logger.debug(\"autopg: skip cache provisioning (inside a Databricks App)\");\n    return;\n  }\n  if (!role) {\n    logger.warn(\"autopg: skip cache provisioning (could not resolve connecting role)\");\n    return;\n  }\n  // Pass `user` explicitly: autopg resolves the connection target\n  // (host/database/endpoint) but not the identity, so `createLakebasePool`'s\n  // synchronous username lookup would otherwise throw. `getWorkspaceClient({})`\n  // returns a fresh default-auth client - literally `new WorkspaceClient({})`,\n  // but built against the SDK version AppKit's `createLakebasePool` expects\n  // (importing the SDK class directly here pulls a newer, type-incompatible copy).\n  const pool = createLakebasePool({\n    user: role,\n    workspaceClient: getWorkspaceClient({}),\n    connectionTimeoutMillis: CONNECT_TIMEOUT_MS,\n    statement_timeout: STATEMENT_TIMEOUT_MS,\n  });\n  try {\n    const found = await pool.query(\n      \"SELECT 1 FROM information_schema.schemata WHERE schema_name = $1\",\n      [CACHE_SCHEMA],\n    );\n    if (found.rowCount === 0) {\n      logger.debug(\"autopg: skip cache provisioning (schema absent)\", { schema: CACHE_SCHEMA });\n      return;\n    }\n    for (const sql of cacheGrantStatements(role)) {\n      await pool.query(sql);\n    }\n    logger.info(\"autopg: granted cache schema\", { schema: CACHE_SCHEMA, role });\n  } catch (err) {\n    logger.warn(\"autopg: cache provisioning failed (continuing)\", {\n      schema: CACHE_SCHEMA,\n      error: errorUtils.errorMessage(err),\n    });\n  } finally {\n    await pool.end().catch(() => {});\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../src/provision.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lakebase cache-schema grant fix-up.\n *\n * AppKit's persistent cache (`CacheManager` -> `PersistentStorage`) uses a\n * schema `appkit` and a table `appkit.appkit_cache_entries`. When the connecting\n * Databricks identity lacks privileges on that schema, the cache migration\n * throws, and because AppKit is typically run with `cache.strictPersistence:\n * true`, the cache is silently switched to a disabled in-memory stub - so every\n * persistent read (chart long-poll, history, etc.) misses and 404s.\n *\n * This grants the connecting role full rights on the cache schema, but only when\n * the schema ALREADY EXISTS - it never creates the schema itself. Run from a\n * LOCAL identity that owns the schema (or holds grant option on it); it is\n * skipped inside a Databricks App, where the app SP cannot grant and its\n * Postgres role does not exist until its first connection.\n *\n * Must run AFTER {@link applyLakebaseToEnv} has written the resolved connection\n * to `process.env` (so `createLakebasePool` picks up host / database / endpoint)\n * and BEFORE `createApp` initializes the cache.\n *\n * @module\n */\n\nimport { createLakebasePool, getWorkspaceClient, ValidationError } from \"@databricks/appkit\";\nimport { configUtils } from \"@dbx-tools/core\";\nimport { postgresConnectionOptions, quotePostgresIdentifier } from \"@dbx-tools/postgres\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\n\nconst defaultLogger = log.logger(\"provision\");\n\n/** AppKit persistent-cache schema (see AppKit's `PersistentStorage`). */\nconst CACHE_SCHEMA = \"appkit\";\n\n/**\n * Characters a Lakebase Postgres role can legitimately contain: workspace\n * identities are emails, service principals are UUIDs.\n */\nconst ROLE_PATTERN = /^[A-Za-z0-9._@+-]{1,255}$/;\n\n/**\n * Provisioning runs at boot as the local developer identity, before any plugin\n * exists, so it is outside AppKit's interceptor chain and inherits no timeout\n * from it. Both bounds are explicit for that reason.\n */\nconst CONNECT_TIMEOUT_MS = 10_000;\nconst STATEMENT_TIMEOUT_MS = 15_000;\n\n/**\n * Idempotent grants that make the (already-existing) AppKit cache schema fully\n * usable by `role`. The `ALTER DEFAULT PRIVILEGES` lines cover the cache table\n * whenever the schema owner creates it later.\n *\n * Throws a {@link ValidationError} when `role` is not a plausible Postgres role\n * name, since the value lands in an identifier position.\n */\nexport function cacheGrantStatements(role: string): readonly string[] {\n  if (!ROLE_PATTERN.test(role)) {\n    throw ValidationError.invalidValue(\"role\", role, \"a Postgres role name\");\n  }\n  const schema = quotePostgresIdentifier(CACHE_SCHEMA);\n  const target = quotePostgresIdentifier(role);\n  return [\n    `GRANT USAGE, CREATE ON SCHEMA ${schema} TO ${target}`,\n    `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ${schema} TO ${target}`,\n    `GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA ${schema} TO ${target}`,\n    `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON TABLES TO ${target}`,\n    `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON SEQUENCES TO ${target}`,\n  ];\n}\n\n/**\n * Grant `role` rights on the AppKit cache schema, but only when that schema\n * already exists.\n *\n * No-ops inside a Databricks App env, when `role` is undefined, or when the\n * schema is absent. Best-effort otherwise: any failure (e.g. the local identity\n * doesn't own the schema) is logged and swallowed so it never blocks startup -\n * a disabled cache is degraded, not fatal.\n *\n * @param role - Postgres role to grant to and connect as (the resolved\n *   workspace-client identity); skips when undefined.\n * @param logger - Logger to report progress on. Defaults to this module's.\n *\n * @example\n * import { provision } from \"@dbx-tools/appkit\";\n *\n * await provision.provisionCacheSchema(\"app-service-principal@databricks.com\");\n */\nexport async function provisionCacheSchema(\n  role: string | undefined,\n  logger: log.Logger = defaultLogger,\n): Promise<void> {\n  if (configUtils.isDatabricksAppEnv()) {\n    logger.debug(\"autopg: skip cache provisioning (inside a Databricks App)\");\n    return;\n  }\n  if (!role) {\n    logger.warn(\"autopg: skip cache provisioning (could not resolve connecting role)\");\n    return;\n  }\n  // Pass `user` explicitly: autopg resolves the connection target\n  // (host/database/endpoint) but not the identity, so `createLakebasePool`'s\n  // synchronous username lookup would otherwise throw. `getWorkspaceClient({})`\n  // returns a fresh default-auth client - literally `new WorkspaceClient({})`,\n  // but built against the SDK version AppKit's `createLakebasePool` expects\n  // (importing the SDK class directly here pulls a newer, type-incompatible copy).\n  const pool = createLakebasePool(\n    postgresConnectionOptions({\n      user: role,\n      workspaceClient: getWorkspaceClient({}),\n      connectionTimeoutMillis: CONNECT_TIMEOUT_MS,\n      statement_timeout: STATEMENT_TIMEOUT_MS,\n    }),\n  );\n  try {\n    const found = await pool.query(\n      \"SELECT 1 FROM information_schema.schemata WHERE schema_name = $1\",\n      [CACHE_SCHEMA],\n    );\n    if (found.rowCount === 0) {\n      logger.debug(\"autopg: skip cache provisioning (schema absent)\", { schema: CACHE_SCHEMA });\n      return;\n    }\n    for (const sql of cacheGrantStatements(role)) {\n      await pool.query(sql);\n    }\n    logger.info(\"autopg: granted cache schema\", { schema: CACHE_SCHEMA, role });\n  } catch (err) {\n    logger.warn(\"autopg: cache provisioning failed (continuing)\", {\n      schema: CACHE_SCHEMA,\n      error: errorUtils.errorMessage(err),\n    });\n  } finally {\n    await pool.end().catch(() => {});\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_auto-configure.ts","../src/_cache-storage.ts","../src/appkit.ts","../src/brand-context.ts","../src/bundle.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/migration.ts","../src/pgaddress.ts","../src/plugin-execution.ts","../src/plugin-registry.ts","../src/provision.ts","../src/tool-provider.ts","../src/toolkit-entries.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_auto-configure.ts","../src/_cache-storage.ts","../src/appkit.ts","../src/brand-context.ts","../src/bundle.ts","../src/child-process.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/migration.ts","../src/pgaddress.ts","../src/plugin-execution.ts","../src/plugin-registry.ts","../src/provision.ts","../src/tool-provider.ts","../src/toolkit-entries.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -20,7 +20,7 @@
   },
   "devDependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/projen": "^0.9.58",
+    "@dbx-tools/projen": "^0.9.61",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3",
     "vitest": "3.2.4"
@@ -30,10 +30,11 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/auth": "^0.9.58",
-    "@dbx-tools/core": "^0.9.58",
-    "@dbx-tools/lakebase": "^0.9.58",
-    "@dbx-tools/shared-core": "^0.9.58",
+    "@dbx-tools/auth": "^0.9.61",
+    "@dbx-tools/core": "^0.9.61",
+    "@dbx-tools/lakebase": "^0.9.61",
+    "@dbx-tools/postgres": "^0.9.61",
+    "@dbx-tools/shared-core": "^0.9.61",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -59,6 +60,10 @@
         "types": "./lib/src/bundle.d.ts",
         "default": "./lib/src/bundle.js"
       },
+      "./child-process": {
+        "types": "./lib/src/child-process.d.ts",
+        "default": "./lib/src/child-process.js"
+      },
       "./databricks": {
         "types": "./lib/src/databricks.d.ts",
         "default": "./lib/src/databricks.js"
@@ -106,7 +111,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.58",
+  "version": "0.9.61",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -131,6 +136,10 @@
       "types": "./lib/src/bundle.d.ts",
       "default": "./lib/src/bundle.js"
     },
+    "./child-process": {
+      "types": "./lib/src/child-process.d.ts",
+      "default": "./lib/src/child-process.js"
+    },
     "./databricks": {
       "types": "./lib/src/databricks.d.ts",
       "default": "./lib/src/databricks.js"

package/src/_cache-storage.ts

@@ -17,6 +17,7 @@
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { createLakebasePool, getWorkspaceClient, type CacheConfig } from "@databricks/appkit";
+import { postgresConnectionOptions } from "@dbx-tools/postgres";
 import { errorUtils, hash, log } from "@dbx-tools/shared-core";
 import { handleOwnershipMigrationError } from "./migration.ts";
 
@@ -163,7 +164,9 @@ export async function createSoftPersistentStorage(
 
   let pool: LakebasePool | undefined;
   try {
-    const createdPool = createLakebasePool({ workspaceClient: getWorkspaceClient({}) });
+    const createdPool = createLakebasePool(
+      postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }),
+    );
     pool = createdPool;
     const storage = new PersistentStorage(cache ?? {}, createdPool);
     softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));

package/src/child-process.ts

@@ -0,0 +1,157 @@
+/**
+ * AppKit child-process lifecycle built on `@dbx-tools/core/exec`.
+ *
+ * @module
+ */
+import * as exec from "@dbx-tools/core/exec";
+
+/** Spawn arguments accepted by {@link AppKitChildProcess}. */
+export type AppKitSpawnArgs = exec.SpawnArgs<exec.ExecOptions>;
+
+/** Graceful and forced shutdown policy for an AppKit child process. */
+export interface AppKitChildProcessOptions {
+  /** Signal sent when shutdown starts. Defaults to `SIGTERM`. */
+  gracefulSignal?: NodeJS.Signals;
+  /** Time to wait after the graceful signal. Defaults to 7 seconds. */
+  gracefulTimeoutMs?: number;
+  /** Signal sent when graceful shutdown times out. Defaults to `SIGKILL`. */
+  forceSignal?: NodeJS.Signals;
+  /** Time to wait after the force signal. Defaults to 1 second. */
+  forceTimeoutMs?: number;
+}
+
+/**
+ * Start and stop one AppKit-owned subprocess.
+ *
+ * The spawn arguments use {@link exec.ExecOptions}, including core exec's
+ * stdin, output capture, line handlers, exit checking, and trim policy.
+ * Shutdown is idempotent and escalates from the graceful signal to the force
+ * signal when the child does not exit within the configured timeouts.
+ */
+export class AppKitChildProcess {
+  readonly #spawnArgs: AppKitSpawnArgs;
+  readonly #options: Required<AppKitChildProcessOptions>;
+  readonly #detached: boolean;
+
+  #child?: exec.ChildProcessResult;
+  #shutdownPromise?: Promise<void>;
+
+  constructor(spawnArgs: AppKitSpawnArgs, options: AppKitChildProcessOptions = {}) {
+    this.#spawnArgs = spawnArgs;
+    this.#options = {
+      gracefulSignal: options.gracefulSignal ?? "SIGTERM",
+      gracefulTimeoutMs: options.gracefulTimeoutMs ?? 7_000,
+      forceSignal: options.forceSignal ?? "SIGKILL",
+      forceTimeoutMs: options.forceTimeoutMs ?? 1_000,
+    };
+    this.#detached = spawnOptions(spawnArgs)?.detached === true;
+  }
+
+  /** Current child handle, or `undefined` when no child is running. */
+  get process(): exec.ChildProcessResult | undefined {
+    return this.#child;
+  }
+
+  /** Whether the current child has not reported an exit code or signal. */
+  get running(): boolean {
+    return this.#child !== undefined && !hasExited(this.#child);
+  }
+
+  /** Start the configured child process. */
+  start(): exec.ChildProcessResult {
+    if (this.running) throw new Error("Child process is already running");
+    if (this.#shutdownPromise) {
+      throw new Error("Child process is shutting down or has been shut down");
+    }
+
+    const child = exec.spawn(...this.#spawnArgs);
+    this.#child = child;
+    void child.once("close", () => {
+      if (this.#child === child) this.#child = undefined;
+    });
+    return child;
+  }
+
+  /** Stop the child once, escalating when graceful shutdown times out. */
+  shutdown(): Promise<void> {
+    this.#shutdownPromise ??= this.#performShutdown();
+    return this.#shutdownPromise;
+  }
+
+  async #performShutdown(): Promise<void> {
+    const child = this.#child;
+    if (!child || hasExited(child)) {
+      this.#child = undefined;
+      return;
+    }
+
+    signalChild(child, this.#options.gracefulSignal, this.#detached);
+    if (await waitForExit(child, this.#options.gracefulTimeoutMs)) {
+      if (this.#child === child) this.#child = undefined;
+      return;
+    }
+
+    signalChild(child, this.#options.forceSignal, this.#detached);
+    if (!(await waitForExit(child, this.#options.forceTimeoutMs))) {
+      throw new Error(`Child process ${child.pid ?? "<unknown>"} did not terminate`);
+    }
+    if (this.#child === child) this.#child = undefined;
+  }
+}
+
+function spawnOptions(args: AppKitSpawnArgs): exec.ExecOptions | undefined {
+  const value = args.at(-1);
+  return isExecOptions(value) ? value : undefined;
+}
+
+function isExecOptions(value: unknown): value is exec.ExecOptions {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasExited(child: exec.ChildProcessResult): boolean {
+  return child.exitCode !== null || child.signalCode !== null;
+}
+
+function signalChild(
+  child: exec.ChildProcessResult,
+  signal: NodeJS.Signals,
+  detached: boolean,
+): void {
+  if (detached && process.platform !== "win32" && child.pid) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+      // Fall back to the direct child when the process group already exited.
+    }
+  }
+  child.kill(signal);
+}
+
+function waitForExit(child: exec.ChildProcessResult, timeoutMs: number): Promise<boolean> {
+  if (hasExited(child)) return Promise.resolve(true);
+
+  return new Promise((resolve) => {
+    let timer: NodeJS.Timeout | undefined;
+    let settled = false;
+
+    const finish = (exited: boolean) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      void child.off("exit", onExit);
+      void child.off("error", onError);
+      resolve(exited);
+    };
+    const onExit = () => finish(true);
+    const onError = () => finish(true);
+
+    void child.once("exit", onExit);
+    void child.once("error", onError);
+    if (hasExited(child)) {
+      finish(true);
+      return;
+    }
+    timer = setTimeout(() => finish(false), timeoutMs);
+  });
+}

package/src/provision.ts

@@ -23,6 +23,7 @@
 
 import { createLakebasePool, getWorkspaceClient, ValidationError } from "@databricks/appkit";
 import { configUtils } from "@dbx-tools/core";
+import { postgresConnectionOptions, quotePostgresIdentifier } from "@dbx-tools/postgres";
 import { errorUtils, log } from "@dbx-tools/shared-core";
 
 const defaultLogger = log.logger("provision");
@@ -44,17 +45,6 @@ const ROLE_PATTERN = /^[A-Za-z0-9._@+-]{1,255}$/;
 const CONNECT_TIMEOUT_MS = 10_000;
 const STATEMENT_TIMEOUT_MS = 15_000;
 
-/**
- * Quote a Postgres identifier: wrap in double quotes and double any embedded
- * quote. Schema and role names are identifiers, and Postgres does not accept a
- * bind parameter in an identifier position, so quoting is the only defense
- * available for these statements. Lakebase role names are usually emails
- * (`user@host`), which must be quoted to be a valid identifier at all.
- */
-function quoteIdent(ident: string): string {
-  return `"${ident.replace(/"/g, '""')}"`;
-}
-
 /**
  * Idempotent grants that make the (already-existing) AppKit cache schema fully
  * usable by `role`. The `ALTER DEFAULT PRIVILEGES` lines cover the cache table
@@ -67,8 +57,8 @@ export function cacheGrantStatements(role: string): readonly string[] {
   if (!ROLE_PATTERN.test(role)) {
     throw ValidationError.invalidValue("role", role, "a Postgres role name");
   }
-  const schema = quoteIdent(CACHE_SCHEMA);
-  const target = quoteIdent(role);
+  const schema = quotePostgresIdentifier(CACHE_SCHEMA);
+  const target = quotePostgresIdentifier(role);
   return [
     `GRANT USAGE, CREATE ON SCHEMA ${schema} TO ${target}`,
     `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ${schema} TO ${target}`,
@@ -114,12 +104,14 @@ export async function provisionCacheSchema(
   // returns a fresh default-auth client - literally `new WorkspaceClient({})`,
   // but built against the SDK version AppKit's `createLakebasePool` expects
   // (importing the SDK class directly here pulls a newer, type-incompatible copy).
-  const pool = createLakebasePool({
-    user: role,
-    workspaceClient: getWorkspaceClient({}),
-    connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
-    statement_timeout: STATEMENT_TIMEOUT_MS,
-  });
+  const pool = createLakebasePool(
+    postgresConnectionOptions({
+      user: role,
+      workspaceClient: getWorkspaceClient({}),
+      connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
+      statement_timeout: STATEMENT_TIMEOUT_MS,
+    }),
+  );
   try {
     const found = await pool.query(
       "SELECT 1 FROM information_schema.schemata WHERE schema_name = $1",