@dbx-tools/appkit-lakebox 0.0.0-stage → 0.9.131

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,105 @@
-# Temporary Holding Version
+# @dbx-tools/appkit-lakebox
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Give every user of a Databricks App a terminal, a desktop, and long-running
+services in one shared, lazily created Databricks Lakebox.
+
+- One Lakebox per app, created on first use by the app service principal and
+  stopped by the platform after its idle timeout. Databricks assigns the
+  machine name; users see only the Lakebox product label.
+- Each signed-in user gets a locked, non-sudo Linux account with a persistent
+  home. Other users cannot read the home or reach the user's service ports.
+- Services run OCI images detached with direct crun. Terminal and desktop are
+  built-in services. Saved services restart when the Lakebox starts.
+- Every service is reachable at `/lakebox/<user hash>/<service>` behind the
+  app's authentication.
+- Agent tools, a Mastra workspace sandbox, and live machine metrics.
+
+## Register the plugin
+
+```ts
+import { createApp, lakebase, server } from "@databricks/appkit";
+import { lakebox } from "@dbx-tools/appkit-lakebox";
+
+await createApp({ plugins: [server(), lakebase(), lakebox({ idleTimeoutSeconds: 1_800 })] });
+```
+
+Lakebase persists the Databricks-assigned Lakebox ID, serializes first creation
+across app replicas, and retains last-known service definitions while the
+machine is stopped. The registry adopts an existing
+`dbx-lakebox-<application>` machine once, but new machines use the name
+Databricks assigns. Startup also deletes legacy per-user
+`dbx-<adjective>-<animal>-<nonce>` Lakeboxes and drops legacy Sandbox ownership
+schemas; no user data is migrated between machines.
+
+To share the runtime with Mastra, create it once:
+
+```ts
+import { lakebox, LakeboxRuntime } from "@dbx-tools/appkit-lakebox";
+import { resolveLakeboxPluginConfig } from "@dbx-tools/appkit-lakebox/config";
+import { lakeboxSkillMounts } from "@dbx-tools/appkit-lakebox/skills";
+import { lakeboxWorkspaceSandbox } from "@dbx-tools/appkit-lakebox/workspace";
+
+const runtime = new LakeboxRuntime(resolveLakeboxPluginConfig());
+
+lakebox({ runtime });
+mastra({ sandbox: lakeboxWorkspaceSandbox(runtime), localSkillMounts: lakeboxSkillMounts() });
+```
+
+## Create a service
+
+Agents call `create_lakebox_service`; REST clients `POST /api/lakebox/services`:
+
+```json
+{
+  "name": "hello",
+  "image": "docker.io/library/python:3.12-alpine",
+  "command": ["python", "-m", "http.server", "--bind", "127.0.0.1"],
+  "mounts": [{ "source": "data", "target": "/data" }]
+}
+```
+
+The call returns after the service listens. The runtime injects
+`SERVICE_NAME`, `SERVICE_PATH`, `SERVICE_PORT`, and `PORT`; routed services must
+listen on `127.0.0.1:$SERVICE_PORT`. Mount sources are relative to the user's
+home.
+
+This is a constrained container API, not the Docker CLI. There is no daemon,
+port publishing, privileged mode, device access, or bridge network. A Lakebox
+stop and start restarts services from their saved definitions; process memory
+does not resume.
+
+## Agent tools
+
+| Tool | Effect |
+| --- | --- |
+| `get_lakebox` | Status, the current user's account, and services. Never creates the Lakebox. |
+| `execute_lakebox_command` | Run a command as the user's account. |
+| `list_lakebox_services` | List the user's services. |
+| `create_lakebox_service` | Create or replace an image service and wait until ready. |
+| `start_lakebox_service`, `stop_lakebox_service` | Start a saved service, `terminal`, or `desktop`; stop one. |
+| `remove_lakebox_service` | Delete a saved service. Requires approval. |
+| `get_lakebox_service_logs` | Read a bounded service log. |
+
+## Configuration
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `application` | `DBX_TOOLS_LAKEBOX_APPLICATION`, `DATABRICKS_APP_NAME`, or the project directory | Stable key for the persisted Lakebox resource ID. |
+| `idleTimeoutSeconds` | `3600` | Platform idle timeout, 60 to 86400 seconds. |
+| `auto` | `true` | Create or start the Lakebox on demand. |
+| `routePrefix` | `/lakebox` | AppKit root for service routes. |
+| `metricsIntervalSeconds` | `5` | Sample interval while a client watches metrics. |
+| `sshTransport` | `auto` | `auto`, `openssh`, or `ssh2`. |
+
+## Interactive testing
+
+`test/cli.ts` runs the real runtime against a workspace profile as any user:
+
+```sh
+bun packages/js/node/appkit-lakebox/test/cli.ts --profile <profile> --user a@example.com status
+bun packages/js/node/appkit-lakebox/test/cli.ts --profile <profile> --user b@example.com exec id
+bun packages/js/node/appkit-lakebox/test/cli.ts --profile <profile> --user a@example.com serve
+```
+
+`serve` starts that user's terminal and desktop and proxies their routes on
+`http://127.0.0.1:8787`.

package/index.ts

@@ -0,0 +1,32 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// 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-lakebox";
+export const PACKAGE_VERSION = "0.9.131";
+export * as config from "./src/config.ts";
+export * as desktop from "./src/desktop.ts";
+export * as metrics from "./src/metrics.ts";
+export * as plugin from "./src/plugin.ts";
+export * as routes from "./src/routes.ts";
+export * as runtime from "./src/runtime.ts";
+export * as services from "./src/services.ts";
+export * as skills from "./src/skills.ts";
+export * as user from "./src/user.ts";
+export * as workspace from "./src/workspace.ts";
+export { LakeboxPluginConfigSchema } from "./src/config.ts";
+export type { SerializableLakeboxPluginConfig, ResolvedLakeboxPluginConfig, LakeboxPluginConfig } from "./src/config.ts";
+export { desktopHtmlHead } from "./src/desktop.ts";
+export { LakeboxMetrics } from "./src/metrics.ts";
+export type { LakeboxCounters, LakeboxMetricsEvents } from "./src/metrics.ts";
+export { AppKitLakeboxPlugin, lakebox } from "./src/plugin.ts";
+export { LakeboxRouteRegistry } from "./src/routes.ts";
+export type { LakeboxRouteResolution, LakeboxRouteResolver } from "./src/routes.ts";
+export { LakeboxRuntime } from "./src/runtime.ts";
+export type { LakeboxIdentityResolver, LakeboxLegacyPool } from "./src/runtime.ts";
+export { LakeboxControllerDefinitionSchema, LakeboxControllerServiceSchema } from "./src/services.ts";
+export type { LakeboxControllerDefinition, LakeboxControllerService, LakeboxServiceRoute } from "./src/services.ts";
+export { LAKEBOX_SKILLS_MOUNT } from "./src/skills.ts";
+export { LAKEBOX_AGENT_USER, LAKEBOX_AGENT_HOME, LAKEBOX_STATE_ROOT, LAKEBOX_USERS_ROOT, LAKEBOX_RUNTIME_ROOT, LAKEBOX_RUN_ROOT, LAKEBOX_UID_MIN, LAKEBOX_UID_COUNT, LAKEBOX_PORT_MIN, LAKEBOX_PORT_COUNT } from "./src/user.ts";
+export { LakeboxWorkspaceSandbox } from "./src/workspace.ts";
+export type { LakeboxWorkspaceSandboxOptions } from "./src/workspace.ts";

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-lakebox";
+export declare const PACKAGE_VERSION = "0.9.131";
+export * as config from "./src/config.ts";
+export * as desktop from "./src/desktop.ts";
+export * as metrics from "./src/metrics.ts";
+export * as plugin from "./src/plugin.ts";
+export * as routes from "./src/routes.ts";
+export * as runtime from "./src/runtime.ts";
+export * as services from "./src/services.ts";
+export * as skills from "./src/skills.ts";
+export * as user from "./src/user.ts";
+export * as workspace from "./src/workspace.ts";
+export { LakeboxPluginConfigSchema } from "./src/config.ts";
+export type { SerializableLakeboxPluginConfig, ResolvedLakeboxPluginConfig, LakeboxPluginConfig } from "./src/config.ts";
+export { desktopHtmlHead } from "./src/desktop.ts";
+export { LakeboxMetrics } from "./src/metrics.ts";
+export type { LakeboxCounters, LakeboxMetricsEvents } from "./src/metrics.ts";
+export { AppKitLakeboxPlugin, lakebox } from "./src/plugin.ts";
+export { LakeboxRouteRegistry } from "./src/routes.ts";
+export type { LakeboxRouteResolution, LakeboxRouteResolver } from "./src/routes.ts";
+export { LakeboxRuntime } from "./src/runtime.ts";
+export type { LakeboxIdentityResolver, LakeboxLegacyPool } from "./src/runtime.ts";
+export { LakeboxControllerDefinitionSchema, LakeboxControllerServiceSchema } from "./src/services.ts";
+export type { LakeboxControllerDefinition, LakeboxControllerService, LakeboxServiceRoute } from "./src/services.ts";
+export { LAKEBOX_SKILLS_MOUNT } from "./src/skills.ts";
+export { LAKEBOX_AGENT_USER, LAKEBOX_AGENT_HOME, LAKEBOX_STATE_ROOT, LAKEBOX_USERS_ROOT, LAKEBOX_RUNTIME_ROOT, LAKEBOX_RUN_ROOT, LAKEBOX_UID_MIN, LAKEBOX_UID_COUNT, LAKEBOX_PORT_MIN, LAKEBOX_PORT_COUNT } from "./src/user.ts";
+export { LakeboxWorkspaceSandbox } from "./src/workspace.ts";
+export type { LakeboxWorkspaceSandboxOptions } from "./src/workspace.ts";

package/lib/index.js

@@ -0,0 +1,26 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// 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-lakebox";
+export const PACKAGE_VERSION = "0.9.131";
+export * as config from "./src/config.js";
+export * as desktop from "./src/desktop.js";
+export * as metrics from "./src/metrics.js";
+export * as plugin from "./src/plugin.js";
+export * as routes from "./src/routes.js";
+export * as runtime from "./src/runtime.js";
+export * as services from "./src/services.js";
+export * as skills from "./src/skills.js";
+export * as user from "./src/user.js";
+export * as workspace from "./src/workspace.js";
+export { LakeboxPluginConfigSchema } from "./src/config.js";
+export { desktopHtmlHead } from "./src/desktop.js";
+export { LakeboxMetrics } from "./src/metrics.js";
+export { AppKitLakeboxPlugin, lakebox } from "./src/plugin.js";
+export { LakeboxRouteRegistry } from "./src/routes.js";
+export { LakeboxRuntime } from "./src/runtime.js";
+export { LakeboxControllerDefinitionSchema, LakeboxControllerServiceSchema } from "./src/services.js";
+export { LAKEBOX_SKILLS_MOUNT } from "./src/skills.js";
+export { LAKEBOX_AGENT_USER, LAKEBOX_AGENT_HOME, LAKEBOX_STATE_ROOT, LAKEBOX_USERS_ROOT, LAKEBOX_RUNTIME_ROOT, LAKEBOX_RUN_ROOT, LAKEBOX_UID_MIN, LAKEBOX_UID_COUNT, LAKEBOX_PORT_MIN, LAKEBOX_PORT_COUNT } from "./src/user.js";
+export { LakeboxWorkspaceSandbox } from "./src/workspace.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_package.d.ts

@@ -0,0 +1,2 @@
+/** Read one source or packaged resource from the appkit-lakebox package root. */
+export declare function readPackageResource(...segments: string[]): string;

package/lib/src/_package.js

@@ -0,0 +1,11 @@
+import { readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Read one source or packaged resource from the appkit-lakebox package root. */
+export function readPackageResource(...segments) {
+    const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+    const parent = dirname(moduleDirectory);
+    const packageRoot = basename(parent) === "lib" ? dirname(parent) : parent;
+    return readFileSync(join(packageRoot, ...segments), "utf8");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX3BhY2thZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvX3BhY2thZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUN2QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDcEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUV6QyxpRkFBaUY7QUFDakYsTUFBTSxVQUFVLG1CQUFtQixDQUFDLEdBQUcsUUFBa0I7SUFDdkQsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDaEUsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQ3hDLE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxNQUFNLENBQUMsS0FBSyxLQUFLLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzFFLE9BQU8sWUFBWSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsR0FBRyxRQUFRLENBQUMsRUFBRSxNQUFNLENBQUMsQ0FBQztBQUM5RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcmVhZEZpbGVTeW5jIH0gZnJvbSBcIm5vZGU6ZnNcIjtcbmltcG9ydCB7IGJhc2VuYW1lLCBkaXJuYW1lLCBqb2luIH0gZnJvbSBcIm5vZGU6cGF0aFwiO1xuaW1wb3J0IHsgZmlsZVVSTFRvUGF0aCB9IGZyb20gXCJub2RlOnVybFwiO1xuXG4vKiogUmVhZCBvbmUgc291cmNlIG9yIHBhY2thZ2VkIHJlc291cmNlIGZyb20gdGhlIGFwcGtpdC1sYWtlYm94IHBhY2thZ2Ugcm9vdC4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWFkUGFja2FnZVJlc291cmNlKC4uLnNlZ21lbnRzOiBzdHJpbmdbXSk6IHN0cmluZyB7XG4gIGNvbnN0IG1vZHVsZURpcmVjdG9yeSA9IGRpcm5hbWUoZmlsZVVSTFRvUGF0aChpbXBvcnQubWV0YS51cmwpKTtcbiAgY29uc3QgcGFyZW50ID0gZGlybmFtZShtb2R1bGVEaXJlY3RvcnkpO1xuICBjb25zdCBwYWNrYWdlUm9vdCA9IGJhc2VuYW1lKHBhcmVudCkgPT09IFwibGliXCIgPyBkaXJuYW1lKHBhcmVudCkgOiBwYXJlbnQ7XG4gIHJldHVybiByZWFkRmlsZVN5bmMoam9pbihwYWNrYWdlUm9vdCwgLi4uc2VnbWVudHMpLCBcInV0ZjhcIik7XG59XG4iXX0=

package/lib/src/_resource-registry.d.ts

@@ -0,0 +1,41 @@
+import { type LakeboxEntry } from "@dbx-tools/lakebox/rest";
+import { type PgPoolLike } from "@dbx-tools/postgres";
+interface ResourceCache {
+    generateKey(parts: (string | number | object)[], userKey: string): string;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, options?: {
+        ttl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** Lakebox client capabilities required by the persistent resource registry. */
+export interface LakeboxResourceClient {
+    workspaceScope(): Promise<string>;
+    list(signal?: AbortSignal): Promise<LakeboxEntry[]>;
+    get(id: string, signal?: AbortSignal): Promise<LakeboxEntry>;
+    create(signal?: AbortSignal): Promise<LakeboxEntry>;
+    delete(id: string, signal?: AbortSignal): Promise<void>;
+}
+/**
+ * Persists the Databricks-assigned Lakebox ID and serializes first creation
+ * across app replicas with the Lakebase service-principal pool.
+ */
+export declare class LakeboxResourceRegistry {
+    private readonly application;
+    private readonly pool?;
+    private readonly cache;
+    private readonly pending;
+    private readonly legacyChecked;
+    constructor(application: string, pool?: PgPoolLike | undefined, cache?: () => ResourceCache);
+    /** Resolves the current app Lakebox without creating one. */
+    read(client: LakeboxResourceClient, signal?: AbortSignal): Promise<LakeboxEntry | undefined>;
+    /** Returns the current app Lakebox or creates one with a Databricks-assigned name. */
+    getOrCreate(client: LakeboxResourceClient, signal?: AbortSignal): Promise<LakeboxEntry>;
+    /** Clears the persisted pointer after the managed Lakebox is deleted. */
+    clear(client: LakeboxResourceClient): Promise<void>;
+    private resolve;
+    private write;
+    private key;
+    private withLock;
+}
+export {};

package/lib/src/_resource-registry.js

@@ -0,0 +1,128 @@
+import { CacheManager } from "@databricks/appkit";
+import { LakeboxApiError } from "@dbx-tools/lakebox/rest";
+import { withAdvisoryLock } from "@dbx-tools/postgres";
+import { log } from "@dbx-tools/shared-core";
+import { z } from "zod";
+const CACHE_NAMESPACE = "appkit-lakebox:resource";
+const RESOURCE_TTL_SECONDS = 365 * 24 * 60 * 60;
+const LEGACY_PREFIX = "dbx-lakebox-";
+const logger = log.logger("appkit-lakebox:resource");
+const LakeboxResourceReferenceSchema = z
+    .object({ sandboxId: z.string().min(1).describe("Databricks Lakebox identifier.") })
+    .strict()
+    .describe("Persistent pointer to the Databricks-assigned app Lakebox.");
+/**
+ * Persists the Databricks-assigned Lakebox ID and serializes first creation
+ * across app replicas with the Lakebase service-principal pool.
+ */
+export class LakeboxResourceRegistry {
+    application;
+    pool;
+    cache;
+    pending = new Map();
+    legacyChecked = new Set();
+    constructor(application, pool, cache = () => CacheManager.getInstanceSync()) {
+        this.application = application;
+        this.pool = pool;
+        this.cache = cache;
+    }
+    /** Resolves the current app Lakebox without creating one. */
+    async read(client, signal) {
+        const scope = await client.workspaceScope();
+        return this.resolve(client, scope, signal);
+    }
+    /** Returns the current app Lakebox or creates one with a Databricks-assigned name. */
+    async getOrCreate(client, signal) {
+        const scope = await client.workspaceScope();
+        const current = this.pending.get(scope);
+        if (current)
+            return current;
+        const pending = this.withLock(scope, async () => {
+            const existing = await this.resolve(client, scope, signal);
+            if (existing)
+                return existing;
+            const created = await client.create(signal);
+            try {
+                await this.write(scope, created.sandboxId);
+            }
+            catch (error) {
+                await client.delete(created.sandboxId, signal).catch(() => undefined);
+                throw error;
+            }
+            logger.info("created app Lakebox", { id: created.sandboxId });
+            return created;
+        }).finally(() => this.pending.delete(scope));
+        this.pending.set(scope, pending);
+        return pending;
+    }
+    /** Clears the persisted pointer after the managed Lakebox is deleted. */
+    async clear(client) {
+        const scope = await client.workspaceScope();
+        await this.cache().delete(this.key(scope));
+        this.legacyChecked.add(scope);
+    }
+    async resolve(client, scope, signal) {
+        const key = this.key(scope);
+        const value = await this.cache().get(key);
+        const parsed = LakeboxResourceReferenceSchema.safeParse(value);
+        if (value !== null && !parsed.success) {
+            logger.warn("discarded invalid cached Lakebox resource reference", {
+                application: this.application,
+            });
+            await this.cache().delete(key);
+        }
+        if (parsed.success) {
+            try {
+                return await client.get(parsed.data.sandboxId, signal);
+            }
+            catch (error) {
+                if (!(error instanceof LakeboxApiError) || error.status !== 404)
+                    throw error;
+                await this.cache().delete(key);
+                this.legacyChecked.add(scope);
+                return undefined;
+            }
+        }
+        if (this.legacyChecked.has(scope))
+            return undefined;
+        this.legacyChecked.add(scope);
+        const legacy = selectLegacyLakebox(await client.list(signal), legacyLakeboxName(this.application));
+        if (!legacy)
+            return undefined;
+        await this.write(scope, legacy.sandboxId);
+        logger.info("adopted legacy named app Lakebox", { id: legacy.sandboxId });
+        return legacy;
+    }
+    async write(scope, sandboxId) {
+        await this.cache().set(this.key(scope), LakeboxResourceReferenceSchema.parse({ sandboxId }), {
+            ttl: RESOURCE_TTL_SECONDS,
+        });
+    }
+    key(scope) {
+        return this.cache().generateKey([CACHE_NAMESPACE, this.application], scope);
+    }
+    withLock(scope, fn) {
+        if (!this.pool)
+            return fn();
+        return withAdvisoryLock(this.pool, [CACHE_NAMESPACE, this.application, scope], fn);
+    }
+}
+function legacyLakeboxName(application) {
+    const slug = application
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 200);
+    if (!slug)
+        throw new Error("A managed Lakebox requires a non-empty application key");
+    return `${LEGACY_PREFIX}${slug}`;
+}
+function selectLegacyLakebox(entries, name) {
+    return entries
+        .filter((entry) => entry.name === name)
+        .sort((left, right) => (Date.parse(left.createTime ?? "") || Number.MAX_SAFE_INTEGER) -
+        (Date.parse(right.createTime ?? "") || Number.MAX_SAFE_INTEGER) ||
+        left.sandboxId.localeCompare(right.sandboxId))[0];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_resource-registry.js","sourceRoot":"","sources":["../../src/_resource-registry.ts"],"names":[],"mappings":"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","sourcesContent":["import { CacheManager } from \"@databricks/appkit\";\nimport { LakeboxApiError, type LakeboxEntry } from \"@dbx-tools/lakebox/rest\";\nimport { withAdvisoryLock, type PgPoolLike } from \"@dbx-tools/postgres\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\n\nconst CACHE_NAMESPACE = \"appkit-lakebox:resource\";\nconst RESOURCE_TTL_SECONDS = 365 * 24 * 60 * 60;\nconst LEGACY_PREFIX = \"dbx-lakebox-\";\nconst logger = log.logger(\"appkit-lakebox:resource\");\n\nconst LakeboxResourceReferenceSchema = z\n  .object({ sandboxId: z.string().min(1).describe(\"Databricks Lakebox identifier.\") })\n  .strict()\n  .describe(\"Persistent pointer to the Databricks-assigned app Lakebox.\");\n\ninterface ResourceCache {\n  generateKey(parts: (string | number | object)[], userKey: string): string;\n  get<T>(key: string): Promise<T | null>;\n  set<T>(key: string, value: T, options?: { ttl?: number }): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Lakebox client capabilities required by the persistent resource registry. */\nexport interface LakeboxResourceClient {\n  workspaceScope(): Promise<string>;\n  list(signal?: AbortSignal): Promise<LakeboxEntry[]>;\n  get(id: string, signal?: AbortSignal): Promise<LakeboxEntry>;\n  create(signal?: AbortSignal): Promise<LakeboxEntry>;\n  delete(id: string, signal?: AbortSignal): Promise<void>;\n}\n\n/**\n * Persists the Databricks-assigned Lakebox ID and serializes first creation\n * across app replicas with the Lakebase service-principal pool.\n */\nexport class LakeboxResourceRegistry {\n  private readonly pending = new Map<string, Promise<LakeboxEntry>>();\n  private readonly legacyChecked = new Set<string>();\n\n  constructor(\n    private readonly application: string,\n    private readonly pool?: PgPoolLike,\n    private readonly cache = (): ResourceCache => CacheManager.getInstanceSync(),\n  ) {}\n\n  /** Resolves the current app Lakebox without creating one. */\n  async read(\n    client: LakeboxResourceClient,\n    signal?: AbortSignal,\n  ): Promise<LakeboxEntry | undefined> {\n    const scope = await client.workspaceScope();\n    return this.resolve(client, scope, signal);\n  }\n\n  /** Returns the current app Lakebox or creates one with a Databricks-assigned name. */\n  async getOrCreate(client: LakeboxResourceClient, signal?: AbortSignal): Promise<LakeboxEntry> {\n    const scope = await client.workspaceScope();\n    const current = this.pending.get(scope);\n    if (current) return current;\n    const pending = this.withLock(scope, async () => {\n      const existing = await this.resolve(client, scope, signal);\n      if (existing) return existing;\n      const created = await client.create(signal);\n      try {\n        await this.write(scope, created.sandboxId);\n      } catch (error) {\n        await client.delete(created.sandboxId, signal).catch(() => undefined);\n        throw error;\n      }\n      logger.info(\"created app Lakebox\", { id: created.sandboxId });\n      return created;\n    }).finally(() => this.pending.delete(scope));\n    this.pending.set(scope, pending);\n    return pending;\n  }\n\n  /** Clears the persisted pointer after the managed Lakebox is deleted. */\n  async clear(client: LakeboxResourceClient): Promise<void> {\n    const scope = await client.workspaceScope();\n    await this.cache().delete(this.key(scope));\n    this.legacyChecked.add(scope);\n  }\n\n  private async resolve(\n    client: LakeboxResourceClient,\n    scope: string,\n    signal?: AbortSignal,\n  ): Promise<LakeboxEntry | undefined> {\n    const key = this.key(scope);\n    const value = await this.cache().get<unknown>(key);\n    const parsed = LakeboxResourceReferenceSchema.safeParse(value);\n    if (value !== null && !parsed.success) {\n      logger.warn(\"discarded invalid cached Lakebox resource reference\", {\n        application: this.application,\n      });\n      await this.cache().delete(key);\n    }\n    if (parsed.success) {\n      try {\n        return await client.get(parsed.data.sandboxId, signal);\n      } catch (error) {\n        if (!(error instanceof LakeboxApiError) || error.status !== 404) throw error;\n        await this.cache().delete(key);\n        this.legacyChecked.add(scope);\n        return undefined;\n      }\n    }\n    if (this.legacyChecked.has(scope)) return undefined;\n    this.legacyChecked.add(scope);\n    const legacy = selectLegacyLakebox(\n      await client.list(signal),\n      legacyLakeboxName(this.application),\n    );\n    if (!legacy) return undefined;\n    await this.write(scope, legacy.sandboxId);\n    logger.info(\"adopted legacy named app Lakebox\", { id: legacy.sandboxId });\n    return legacy;\n  }\n\n  private async write(scope: string, sandboxId: string): Promise<void> {\n    await this.cache().set(this.key(scope), LakeboxResourceReferenceSchema.parse({ sandboxId }), {\n      ttl: RESOURCE_TTL_SECONDS,\n    });\n  }\n\n  private key(scope: string): string {\n    return this.cache().generateKey([CACHE_NAMESPACE, this.application], scope);\n  }\n\n  private withLock<T>(scope: string, fn: () => Promise<T>): Promise<T> {\n    if (!this.pool) return fn();\n    return withAdvisoryLock(this.pool, [CACHE_NAMESPACE, this.application, scope], fn);\n  }\n}\n\nfunction legacyLakeboxName(application: string): string {\n  const slug = application\n    .trim()\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-|-$/g, \"\")\n    .slice(0, 200);\n  if (!slug) throw new Error(\"A managed Lakebox requires a non-empty application key\");\n  return `${LEGACY_PREFIX}${slug}`;\n}\n\nfunction selectLegacyLakebox(\n  entries: readonly LakeboxEntry[],\n  name: string,\n): LakeboxEntry | undefined {\n  return entries\n    .filter((entry) => entry.name === name)\n    .sort(\n      (left, right) =>\n        (Date.parse(left.createTime ?? \"\") || Number.MAX_SAFE_INTEGER) -\n          (Date.parse(right.createTime ?? \"\") || Number.MAX_SAFE_INTEGER) ||\n        left.sandboxId.localeCompare(right.sandboxId),\n    )[0];\n}\n"]}