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

package/lib/src/plugin.js

@@ -0,0 +1,329 @@
+import { createWorkspaceClient, lakebase, toPlugin, } from "@databricks/appkit";
+import { executeFromRegistry, } from "@databricks/appkit/beta";
+import { USER_EMAIL_HEADER, USER_ID_HEADER, appkit, lakebaseResolver, pluginRegistry, toolkitEntries, toolOperations, ToolRegistryPlugin, } from "@dbx-tools/appkit";
+import { createLakeboxServiceOperationSchema, executeLakeboxCommandOperationSchema, getLakeboxOperationSchema, getLakeboxServiceLogsOperationSchema, LAKEBOX_PLUGIN_NAME, LAKEBOX_ROUTES, lakeboxCommandRequestSchema, lakeboxServiceActionSchema, lakeboxServiceLogsRequestSchema, listLakeboxServicesOperationSchema, removeLakeboxServiceOperationSchema, startLakeboxServiceOperationSchema, stopLakeboxServiceOperationSchema, } from "@dbx-tools/shared-lakebox";
+import { z } from "zod";
+import { LakeboxResourceRegistry } from "./_resource-registry.js";
+import { LakeboxServiceSnapshots } from "./_service-snapshots.js";
+import { LakeboxPluginConfigSchema, resolveLakeboxPluginConfig, } from "./config.js";
+import { LakeboxRuntime } from "./runtime.js";
+import { withServiceOrigin } from "./services.js";
+const CONFIG_SCHEMA = z.toJSONSchema(LakeboxPluginConfigSchema);
+/**
+ * AppKit plugin for the single app Lakebox.
+ *
+ * Registers user-scoped REST routes, agent tools, the deterministic service
+ * proxy, and WebSocket upgrade handling. Every Lakebox lifecycle call uses the
+ * app service principal; the authenticated request identity only selects the
+ * user's Lakebox account and authorizes that user's routes.
+ */
+export class AppKitLakeboxPlugin extends ToolRegistryPlugin {
+    static manifest = {
+        name: LAKEBOX_PLUGIN_NAME,
+        displayName: "Lakebox",
+        description: "Runs per-user services, terminals, desktops, and commands in one lazily created Databricks Lakebox.",
+        stability: "beta",
+        resources: { required: [], optional: [] },
+        config: { schema: CONFIG_SCHEMA },
+    };
+    runtime;
+    mounted = false;
+    httpServer;
+    upgradeAttachTimer;
+    upgradeIdentityGate;
+    upgradeHandler = (request, socket, head) => {
+        void this.handleUpgrade(request, socket, head);
+    };
+    /** Creates a plugin with a supplied shared runtime or one from resolved config. */
+    constructor(config = {}) {
+        super(config);
+        this.runtime = config.runtime ?? new LakeboxRuntime(resolveLakeboxPluginConfig(config));
+    }
+    get toolRegistry() {
+        return this.createToolRegistry();
+    }
+    async setup() {
+        this.context?.onLifecycle("setup:complete", async () => {
+            const pool = lakebaseResolver.captureServicePrincipalPool(pluginRegistry.require(this.context, lakebase, "appkit-lakebox").exports().pool);
+            this.runtime.initialize(createWorkspaceClient().config, (headers) => this.requestIdentity(headers), new LakeboxServiceSnapshots(), new LakeboxResourceRegistry(this.runtime.config.application, pool));
+            void this.runtime.cleanupLegacy(pool);
+            const server = this.context?.getPlugins().get("server");
+            if (!server || this.mounted)
+                return;
+            this.upgradeIdentityGate = resolveUpgradeIdentityGate(this.context?.getPlugins().get("authGate"));
+            server.addExtension((application) => application.use(this.runtime.routes.middleware()));
+            this.mounted = true;
+            this.attachUpgradeHandler(server);
+        });
+    }
+    injectRoutes(router) {
+        const json = (name, method, path, handler) => this.route(router, {
+            name,
+            method,
+            path,
+            handler: async (req, res) => {
+                res.json(await handler(this.resolveUserId(req), req));
+            },
+        });
+        json("status", "get", LAKEBOX_ROUTES.status, (identity) => this.runtime.summary(identity));
+        json("start", "post", LAKEBOX_ROUTES.start, async (identity) => {
+            await this.runtime.start();
+            return this.runtime.summary(identity);
+        });
+        json("stop", "post", LAKEBOX_ROUTES.stop, async (identity) => {
+            await this.runtime.stop();
+            return this.runtime.summary(identity);
+        });
+        json("executeCommand", "post", LAKEBOX_ROUTES.commands, (identity, req) => this.runtime.execute(identity, lakeboxCommandRequestSchema.parse(req.body ?? {})).result);
+        json("services", "get", LAKEBOX_ROUTES.services, async (identity) => ({
+            services: await this.runtime.listServices(identity),
+        }));
+        json("createService", "post", LAKEBOX_ROUTES.services, async (identity, req) => ({
+            service: await this.runtime.createService(identity, req.body ?? {}),
+        }));
+        json("startService", "post", LAKEBOX_ROUTES.serviceStart, async (identity, req) => ({
+            service: await this.runtime.startService(identity, serviceName(req)),
+        }));
+        json("stopService", "post", LAKEBOX_ROUTES.serviceStop, async (identity, req) => ({
+            service: await this.runtime.stopService(identity, serviceName(req)),
+        }));
+        json("removeService", "delete", LAKEBOX_ROUTES.service, async (identity, req) => ({
+            removed: await this.runtime.removeService(identity, serviceName(req)),
+        }));
+        json("serviceLogs", "get", LAKEBOX_ROUTES.serviceLogs, (identity, req) => this.runtime.serviceLogs(identity, lakeboxServiceLogsRequestSchema.parse({
+            name: req.params.name,
+            maxLines: req.query.maxLines,
+            maxChars: req.query.maxChars,
+        })));
+        json("metrics", "get", LAKEBOX_ROUTES.metrics, () => this.runtime.metricsResponse());
+        this.route(router, {
+            name: "metricsStream",
+            method: "get",
+            path: LAKEBOX_ROUTES.metricsStream,
+            handler: async (req, res) => this.streamMetrics(req, res),
+        });
+    }
+    /** Returns browser-safe route defaults published through AppKit client config. */
+    clientConfig() {
+        return { routePrefix: this.runtime.config.routePrefix };
+    }
+    /** Returns selected AppKit toolkit entries backed by this plugin's agent tools. */
+    toolkit(options) {
+        return toolkitEntries.entries(LAKEBOX_PLUGIN_NAME, this.getAgentTools(), {
+            ...options,
+            prefix: options?.prefix ?? "",
+        });
+    }
+    /** Executes one registered agent tool for the current execution identity. */
+    executeAgentTool(name, args, signal, context) {
+        return executeFromRegistry(this.createToolRegistry(context?.resourceId, context?.origin), name, args, signal);
+    }
+    /** Returns the typed sibling-plugin API. */
+    exports() {
+        return {
+            summary: (identity) => this.runtime.summary(identity),
+            start: () => this.runtime.start(),
+            stop: () => this.runtime.stop(),
+            delete: () => this.runtime.delete(),
+            executeCommand: (identity, input) => this.runtime.execute(identity, input).result,
+            listServices: (identity) => this.runtime.listServices(identity),
+            createService: (identity, input) => this.runtime.createService(identity, input),
+            startService: (identity, name) => this.runtime.startService(identity, name),
+            stopService: (identity, name) => this.runtime.stopService(identity, name),
+            removeService: (identity, name) => this.runtime.removeService(identity, name),
+            serviceLogs: (identity, input) => this.runtime.serviceLogs(identity, input),
+            operations: (identity) => this.operations(identity),
+            toolkit: (options) => this.toolkit(options),
+        };
+    }
+    /** Cancels in-flight work before shutdown tears down resources. */
+    abortActiveOperations() {
+        this.runtime.abortActiveOperations();
+    }
+    /** Detaches WebSocket handling and closes the shared runtime. */
+    async shutdown() {
+        if (this.upgradeAttachTimer)
+            clearTimeout(this.upgradeAttachTimer);
+        this.upgradeAttachTimer = undefined;
+        this.httpServer?.off("upgrade", this.upgradeHandler);
+        this.httpServer = undefined;
+        await this.runtime.close();
+    }
+    /** Returns the Zod-owned operation contracts used by agent tools. */
+    operations(identity, origin) {
+        const user = () => identity ?? this.executionIdentity();
+        const presentService = (value) => omitLog(withServiceOrigin(value, origin));
+        return toolOperations.defineOperations({
+            get_lakebox: {
+                schema: getLakeboxOperationSchema,
+                execute: async (_input, signal) => {
+                    const summary = await this.runtime.summary(user(), signal);
+                    return { ...summary, services: summary.services.map(presentService) };
+                },
+            },
+            execute_lakebox_command: {
+                schema: executeLakeboxCommandOperationSchema,
+                execute: (input, signal) => this.runtime.execute(user(), input, signal).result,
+            },
+            list_lakebox_services: {
+                schema: listLakeboxServicesOperationSchema,
+                execute: async (_input, signal) => ({
+                    services: (await this.runtime.listServices(user(), signal)).map(presentService),
+                }),
+            },
+            create_lakebox_service: {
+                schema: createLakeboxServiceOperationSchema,
+                execute: async (input, signal) => ({
+                    service: presentService(await this.runtime.createService(user(), input, signal)),
+                }),
+            },
+            start_lakebox_service: {
+                schema: startLakeboxServiceOperationSchema,
+                execute: async (input, signal) => ({
+                    service: presentService(await this.runtime.startService(user(), input.name, signal)),
+                }),
+            },
+            stop_lakebox_service: {
+                schema: stopLakeboxServiceOperationSchema,
+                execute: async (input, signal) => ({
+                    service: presentService(await this.runtime.stopService(user(), input.name, signal)),
+                }),
+            },
+            remove_lakebox_service: {
+                schema: removeLakeboxServiceOperationSchema,
+                execute: async (input, signal) => ({
+                    removed: await this.runtime.removeService(user(), input.name, signal),
+                }),
+            },
+            get_lakebox_service_logs: {
+                schema: getLakeboxServiceLogsOperationSchema,
+                execute: (input, signal) => this.runtime.serviceLogs(user(), input, signal),
+            },
+        });
+    }
+    createToolRegistry(identity, origin) {
+        return toolOperations.toolRegistryFromOperations(this.operations(identity, origin));
+    }
+    executionIdentity() {
+        const context = appkit.tryGetExecutionContext();
+        if (!context)
+            throw new Error("Lakebox tools require an AppKit execution context");
+        return "userId" in context ? context.userId : context.serviceUserId;
+    }
+    /**
+     * Resolves route identity with the same rules as REST: the forwarded user,
+     * or AppKit's development user for direct loopback navigation outside
+     * production. Everything else is anonymous and fails closed.
+     */
+    requestIdentity(headers) {
+        const forwarded = headerValue(headers[USER_ID_HEADER])?.trim();
+        if (forwarded)
+            return forwarded;
+        if (process.env.NODE_ENV !== "development" || !isLoopbackHost(headerValue(headers.host))) {
+            return undefined;
+        }
+        try {
+            return this.resolveUserId({
+                header: (name) => headerValue(headers[name.toLowerCase()]),
+            });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async streamMetrics(req, res) {
+        const initial = await this.runtime.metricsResponse();
+        res.statusCode = 200;
+        res.setHeader("content-type", "text/event-stream; charset=utf-8");
+        res.setHeader("cache-control", "no-cache, no-transform");
+        res.setHeader("connection", "keep-alive");
+        res.setHeader("x-accel-buffering", "no");
+        res.flushHeaders?.();
+        res.write(`data: ${JSON.stringify(initial)}\n\n`);
+        const unsubscribe = this.runtime.subscribeMetrics((snapshot) => {
+            res.write(`data: ${JSON.stringify({ status: "running", series: [snapshot] })}\n\n`);
+        });
+        req.once("close", unsubscribe);
+    }
+    attachUpgradeHandler(server) {
+        if (this.httpServer || this.upgradeAttachTimer)
+            return;
+        try {
+            this.httpServer = server.getServer();
+            this.httpServer.on("upgrade", this.upgradeHandler);
+        }
+        catch {
+            this.upgradeAttachTimer = setTimeout(() => {
+                this.upgradeAttachTimer = undefined;
+                this.attachUpgradeHandler(server);
+            }, 10);
+            this.upgradeAttachTimer.unref?.();
+        }
+    }
+    async handleUpgrade(request, socket, head) {
+        const path = new URL(request.url ?? "/", "http://localhost").pathname;
+        if (!this.runtime.routes.canHandleUpgrade(path))
+            return;
+        const gate = this.upgradeIdentityGate;
+        if (gate) {
+            const headers = requestHeaders(request);
+            if (gate.isProtectedHost(headers)) {
+                delete request.headers[USER_ID_HEADER];
+                delete request.headers[USER_EMAIL_HEADER];
+                const userId = await gate.session(headers);
+                if (!userId) {
+                    socket.destroy();
+                    return;
+                }
+                request.headers[USER_ID_HEADER] = userId;
+                request.headers[USER_EMAIL_HEADER] = userId;
+            }
+        }
+        if (!(await this.runtime.routes.handleUpgrade(request, socket, head)))
+            socket.destroy();
+    }
+}
+function serviceName(req) {
+    return lakeboxServiceActionSchema.parse({ name: req.params.name }).name;
+}
+function omitLog({ log: _log, ...value }) {
+    return value;
+}
+function headerValue(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function isLoopbackHost(host) {
+    if (!host)
+        return false;
+    try {
+        const hostname = new URL(`http://${host}`).hostname.toLowerCase();
+        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+    }
+    catch {
+        return false;
+    }
+}
+function resolveUpgradeIdentityGate(plugin) {
+    const exports = plugin?.exports?.();
+    if (typeof exports?.isProtectedHost !== "function" ||
+        typeof exports?.session !== "function") {
+        return undefined;
+    }
+    return exports;
+}
+function requestHeaders(request) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(request.headers)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                headers.append(name, item);
+        }
+        else if (value !== undefined) {
+            headers.set(name, value);
+        }
+    }
+    return headers;
+}
+/** AppKit plugin factory for {@link AppKitLakeboxPlugin}. */
+export const lakebox = toPlugin(AppKitLakeboxPlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IncomingHttpHeaders, IncomingMessage, Server as HttpServer } from \"node:http\";\nimport type { Socket } from \"node:net\";\nimport {\n  createWorkspaceClient,\n  lakebase,\n  toPlugin,\n  type IAppRouter,\n  type PluginManifest,\n} from \"@databricks/appkit\";\nimport {\n  executeFromRegistry,\n  type ToolkitEntry,\n  type ToolkitOptions,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport {\n  USER_EMAIL_HEADER,\n  USER_ID_HEADER,\n  appkit,\n  lakebaseResolver,\n  pluginRegistry,\n  toolkitEntries,\n  toolOperations,\n  ToolRegistryPlugin,\n  type AgentToolExecutionContext,\n} from \"@dbx-tools/appkit\";\nimport {\n  createLakeboxServiceOperationSchema,\n  executeLakeboxCommandOperationSchema,\n  getLakeboxOperationSchema,\n  getLakeboxServiceLogsOperationSchema,\n  LAKEBOX_PLUGIN_NAME,\n  LAKEBOX_ROUTES,\n  lakeboxCommandRequestSchema,\n  lakeboxServiceActionSchema,\n  lakeboxServiceLogsRequestSchema,\n  listLakeboxServicesOperationSchema,\n  removeLakeboxServiceOperationSchema,\n  startLakeboxServiceOperationSchema,\n  stopLakeboxServiceOperationSchema,\n  type CreateLakeboxServiceRequest,\n  type LakeboxClientConfigInput,\n  type LakeboxCommandRequest,\n  type LakeboxService,\n  type LakeboxServiceLogsRequest,\n} from \"@dbx-tools/shared-lakebox\";\nimport type { Application, Request, Response } from \"express\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport { z } from \"zod\";\nimport { LakeboxResourceRegistry } from \"./_resource-registry.ts\";\nimport { LakeboxServiceSnapshots } from \"./_service-snapshots.ts\";\nimport {\n  LakeboxPluginConfigSchema,\n  resolveLakeboxPluginConfig,\n  type LakeboxPluginConfig,\n} from \"./config.ts\";\nimport { LakeboxRuntime, type LakeboxLegacyPool } from \"./runtime.ts\";\nimport { withServiceOrigin } from \"./services.ts\";\n\ninterface ServerExtension {\n  addExtension(fn: (application: Application) => void): void;\n  getServer(): HttpServer;\n}\n\ninterface UpgradeIdentityGate {\n  isProtectedHost(headers: Headers): boolean;\n  session(headers: Headers): Promise<string | undefined>;\n}\n\nconst CONFIG_SCHEMA = z.toJSONSchema(LakeboxPluginConfigSchema) as JSONSchema7;\n\n/**\n * AppKit plugin for the single app Lakebox.\n *\n * Registers user-scoped REST routes, agent tools, the deterministic service\n * proxy, and WebSocket upgrade handling. Every Lakebox lifecycle call uses the\n * app service principal; the authenticated request identity only selects the\n * user's Lakebox account and authorizes that user's routes.\n */\nexport class AppKitLakeboxPlugin extends ToolRegistryPlugin<LakeboxPluginConfig> {\n  static manifest = {\n    name: LAKEBOX_PLUGIN_NAME,\n    displayName: \"Lakebox\",\n    description:\n      \"Runs per-user services, terminals, desktops, and commands in one lazily created Databricks Lakebox.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n    config: { schema: CONFIG_SCHEMA },\n  } satisfies PluginManifest<typeof LAKEBOX_PLUGIN_NAME>;\n\n  readonly runtime: LakeboxRuntime;\n  private mounted = false;\n  private httpServer?: HttpServer;\n  private upgradeAttachTimer?: ReturnType<typeof setTimeout>;\n  private upgradeIdentityGate?: UpgradeIdentityGate;\n  private readonly upgradeHandler = (request: IncomingMessage, socket: Socket, head: Buffer) => {\n    void this.handleUpgrade(request, socket, head);\n  };\n\n  /** Creates a plugin with a supplied shared runtime or one from resolved config. */\n  constructor(config: LakeboxPluginConfig = {}) {\n    super(config);\n    this.runtime = config.runtime ?? new LakeboxRuntime(resolveLakeboxPluginConfig(config));\n  }\n\n  protected get toolRegistry(): ToolRegistry {\n    return this.createToolRegistry();\n  }\n\n  override async setup(): Promise<void> {\n    this.context?.onLifecycle(\"setup:complete\", async () => {\n      const pool = lakebaseResolver.captureServicePrincipalPool(\n        pluginRegistry.require(this.context, lakebase, \"appkit-lakebox\").exports().pool,\n      );\n      this.runtime.initialize(\n        createWorkspaceClient().config,\n        (headers) => this.requestIdentity(headers),\n        new LakeboxServiceSnapshots(),\n        new LakeboxResourceRegistry(this.runtime.config.application, pool),\n      );\n      void this.runtime.cleanupLegacy(pool as LakeboxLegacyPool);\n      const server = this.context?.getPlugins().get(\"server\") as ServerExtension | undefined;\n      if (!server || this.mounted) return;\n      this.upgradeIdentityGate = resolveUpgradeIdentityGate(\n        this.context?.getPlugins().get(\"authGate\"),\n      );\n      server.addExtension((application) => application.use(this.runtime.routes.middleware()));\n      this.mounted = true;\n      this.attachUpgradeHandler(server);\n    });\n  }\n\n  override injectRoutes(router: IAppRouter): void {\n    const json = (\n      name: string,\n      method: \"get\" | \"post\" | \"delete\",\n      path: string,\n      handler: (identity: string, req: Request) => Promise<unknown>,\n    ) =>\n      this.route(router, {\n        name,\n        method,\n        path,\n        handler: async (req, res) => {\n          res.json(await handler(this.resolveUserId(req), req));\n        },\n      });\n    json(\"status\", \"get\", LAKEBOX_ROUTES.status, (identity) => this.runtime.summary(identity));\n    json(\"start\", \"post\", LAKEBOX_ROUTES.start, async (identity) => {\n      await this.runtime.start();\n      return this.runtime.summary(identity);\n    });\n    json(\"stop\", \"post\", LAKEBOX_ROUTES.stop, async (identity) => {\n      await this.runtime.stop();\n      return this.runtime.summary(identity);\n    });\n    json(\n      \"executeCommand\",\n      \"post\",\n      LAKEBOX_ROUTES.commands,\n      (identity, req) =>\n        this.runtime.execute(identity, lakeboxCommandRequestSchema.parse(req.body ?? {})).result,\n    );\n    json(\"services\", \"get\", LAKEBOX_ROUTES.services, async (identity) => ({\n      services: await this.runtime.listServices(identity),\n    }));\n    json(\"createService\", \"post\", LAKEBOX_ROUTES.services, async (identity, req) => ({\n      service: await this.runtime.createService(identity, req.body ?? {}),\n    }));\n    json(\"startService\", \"post\", LAKEBOX_ROUTES.serviceStart, async (identity, req) => ({\n      service: await this.runtime.startService(identity, serviceName(req)),\n    }));\n    json(\"stopService\", \"post\", LAKEBOX_ROUTES.serviceStop, async (identity, req) => ({\n      service: await this.runtime.stopService(identity, serviceName(req)),\n    }));\n    json(\"removeService\", \"delete\", LAKEBOX_ROUTES.service, async (identity, req) => ({\n      removed: await this.runtime.removeService(identity, serviceName(req)),\n    }));\n    json(\"serviceLogs\", \"get\", LAKEBOX_ROUTES.serviceLogs, (identity, req) =>\n      this.runtime.serviceLogs(\n        identity,\n        lakeboxServiceLogsRequestSchema.parse({\n          name: req.params.name,\n          maxLines: req.query.maxLines,\n          maxChars: req.query.maxChars,\n        }),\n      ),\n    );\n    json(\"metrics\", \"get\", LAKEBOX_ROUTES.metrics, () => this.runtime.metricsResponse());\n    this.route(router, {\n      name: \"metricsStream\",\n      method: \"get\",\n      path: LAKEBOX_ROUTES.metricsStream,\n      handler: async (req, res) => this.streamMetrics(req, res),\n    });\n  }\n\n  /** Returns browser-safe route defaults published through AppKit client config. */\n  clientConfig(): LakeboxClientConfigInput {\n    return { routePrefix: this.runtime.config.routePrefix };\n  }\n\n  /** Returns selected AppKit toolkit entries backed by this plugin's agent tools. */\n  toolkit(options?: ToolkitOptions): Record<string, ToolkitEntry> {\n    return toolkitEntries.entries(LAKEBOX_PLUGIN_NAME, this.getAgentTools(), {\n      ...options,\n      prefix: options?.prefix ?? \"\",\n    });\n  }\n\n  /** Executes one registered agent tool for the current execution identity. */\n  override executeAgentTool(\n    name: string,\n    args: unknown,\n    signal?: AbortSignal,\n    context?: AgentToolExecutionContext,\n  ): Promise<unknown> {\n    return executeFromRegistry(\n      this.createToolRegistry(context?.resourceId, context?.origin),\n      name,\n      args,\n      signal,\n    );\n  }\n\n  /** Returns the typed sibling-plugin API. */\n  exports() {\n    return {\n      summary: (identity: string) => this.runtime.summary(identity),\n      start: () => this.runtime.start(),\n      stop: () => this.runtime.stop(),\n      delete: () => this.runtime.delete(),\n      executeCommand: (identity: string, input: LakeboxCommandRequest) =>\n        this.runtime.execute(identity, input).result,\n      listServices: (identity: string) => this.runtime.listServices(identity),\n      createService: (identity: string, input: CreateLakeboxServiceRequest) =>\n        this.runtime.createService(identity, input),\n      startService: (identity: string, name: string) => this.runtime.startService(identity, name),\n      stopService: (identity: string, name: string) => this.runtime.stopService(identity, name),\n      removeService: (identity: string, name: string) => this.runtime.removeService(identity, name),\n      serviceLogs: (identity: string, input: LakeboxServiceLogsRequest) =>\n        this.runtime.serviceLogs(identity, input),\n      operations: (identity?: string) => this.operations(identity),\n      toolkit: (options?: ToolkitOptions) => this.toolkit(options),\n    };\n  }\n\n  /** Cancels in-flight work before shutdown tears down resources. */\n  override abortActiveOperations(): void {\n    this.runtime.abortActiveOperations();\n  }\n\n  /** Detaches WebSocket handling and closes the shared runtime. */\n  async shutdown(): Promise<void> {\n    if (this.upgradeAttachTimer) clearTimeout(this.upgradeAttachTimer);\n    this.upgradeAttachTimer = undefined;\n    this.httpServer?.off(\"upgrade\", this.upgradeHandler);\n    this.httpServer = undefined;\n    await this.runtime.close();\n  }\n\n  /** Returns the Zod-owned operation contracts used by agent tools. */\n  operations(identity?: string, origin?: string) {\n    const user = () => identity ?? this.executionIdentity();\n    const presentService = (value: LakeboxService) => omitLog(withServiceOrigin(value, origin));\n    return toolOperations.defineOperations({\n      get_lakebox: {\n        schema: getLakeboxOperationSchema,\n        execute: async (_input, signal) => {\n          const summary = await this.runtime.summary(user(), signal);\n          return { ...summary, services: summary.services.map(presentService) };\n        },\n      },\n      execute_lakebox_command: {\n        schema: executeLakeboxCommandOperationSchema,\n        execute: (input, signal) => this.runtime.execute(user(), input, signal).result,\n      },\n      list_lakebox_services: {\n        schema: listLakeboxServicesOperationSchema,\n        execute: async (_input, signal) => ({\n          services: (await this.runtime.listServices(user(), signal)).map(presentService),\n        }),\n      },\n      create_lakebox_service: {\n        schema: createLakeboxServiceOperationSchema,\n        execute: async (input, signal) => ({\n          service: presentService(await this.runtime.createService(user(), input, signal)),\n        }),\n      },\n      start_lakebox_service: {\n        schema: startLakeboxServiceOperationSchema,\n        execute: async (input, signal) => ({\n          service: presentService(await this.runtime.startService(user(), input.name, signal)),\n        }),\n      },\n      stop_lakebox_service: {\n        schema: stopLakeboxServiceOperationSchema,\n        execute: async (input, signal) => ({\n          service: presentService(await this.runtime.stopService(user(), input.name, signal)),\n        }),\n      },\n      remove_lakebox_service: {\n        schema: removeLakeboxServiceOperationSchema,\n        execute: async (input, signal) => ({\n          removed: await this.runtime.removeService(user(), input.name, signal),\n        }),\n      },\n      get_lakebox_service_logs: {\n        schema: getLakeboxServiceLogsOperationSchema,\n        execute: (input, signal) => this.runtime.serviceLogs(user(), input, signal),\n      },\n    });\n  }\n\n  private createToolRegistry(identity?: string, origin?: string): ToolRegistry {\n    return toolOperations.toolRegistryFromOperations(this.operations(identity, origin));\n  }\n\n  private executionIdentity(): string {\n    const context = appkit.tryGetExecutionContext();\n    if (!context) throw new Error(\"Lakebox tools require an AppKit execution context\");\n    return \"userId\" in context ? context.userId : context.serviceUserId;\n  }\n\n  /**\n   * Resolves route identity with the same rules as REST: the forwarded user,\n   * or AppKit's development user for direct loopback navigation outside\n   * production. Everything else is anonymous and fails closed.\n   */\n  private requestIdentity(headers: IncomingHttpHeaders): string | undefined {\n    const forwarded = headerValue(headers[USER_ID_HEADER])?.trim();\n    if (forwarded) return forwarded;\n    if (process.env.NODE_ENV !== \"development\" || !isLoopbackHost(headerValue(headers.host))) {\n      return undefined;\n    }\n    try {\n      return this.resolveUserId({\n        header: (name: string) => headerValue(headers[name.toLowerCase()]),\n      } as unknown as Request);\n    } catch {\n      return undefined;\n    }\n  }\n\n  private async streamMetrics(req: Request, res: Response): Promise<void> {\n    const initial = await this.runtime.metricsResponse();\n    res.statusCode = 200;\n    res.setHeader(\"content-type\", \"text/event-stream; charset=utf-8\");\n    res.setHeader(\"cache-control\", \"no-cache, no-transform\");\n    res.setHeader(\"connection\", \"keep-alive\");\n    res.setHeader(\"x-accel-buffering\", \"no\");\n    res.flushHeaders?.();\n    res.write(`data: ${JSON.stringify(initial)}\\n\\n`);\n    const unsubscribe = this.runtime.subscribeMetrics((snapshot) => {\n      res.write(`data: ${JSON.stringify({ status: \"running\", series: [snapshot] })}\\n\\n`);\n    });\n    req.once(\"close\", unsubscribe);\n  }\n\n  private attachUpgradeHandler(server: ServerExtension): void {\n    if (this.httpServer || this.upgradeAttachTimer) return;\n    try {\n      this.httpServer = server.getServer();\n      this.httpServer.on(\"upgrade\", this.upgradeHandler);\n    } catch {\n      this.upgradeAttachTimer = setTimeout(() => {\n        this.upgradeAttachTimer = undefined;\n        this.attachUpgradeHandler(server);\n      }, 10);\n      this.upgradeAttachTimer.unref?.();\n    }\n  }\n\n  private async handleUpgrade(\n    request: IncomingMessage,\n    socket: Socket,\n    head: Buffer,\n  ): Promise<void> {\n    const path = new URL(request.url ?? \"/\", \"http://localhost\").pathname;\n    if (!this.runtime.routes.canHandleUpgrade(path)) return;\n    const gate = this.upgradeIdentityGate;\n    if (gate) {\n      const headers = requestHeaders(request);\n      if (gate.isProtectedHost(headers)) {\n        delete request.headers[USER_ID_HEADER];\n        delete request.headers[USER_EMAIL_HEADER];\n        const userId = await gate.session(headers);\n        if (!userId) {\n          socket.destroy();\n          return;\n        }\n        request.headers[USER_ID_HEADER] = userId;\n        request.headers[USER_EMAIL_HEADER] = userId;\n      }\n    }\n    if (!(await this.runtime.routes.handleUpgrade(request, socket, head))) socket.destroy();\n  }\n}\n\nfunction serviceName(req: Request): string {\n  return lakeboxServiceActionSchema.parse({ name: req.params.name }).name;\n}\n\nfunction omitLog<T extends { log?: string }>({ log: _log, ...value }: T): Omit<T, \"log\"> {\n  return value;\n}\n\nfunction headerValue(value: string | string[] | undefined): string | undefined {\n  return Array.isArray(value) ? value[0] : value;\n}\n\nfunction isLoopbackHost(host: string | undefined): boolean {\n  if (!host) return false;\n  try {\n    const hostname = new URL(`http://${host}`).hostname.toLowerCase();\n    return hostname === \"localhost\" || hostname === \"127.0.0.1\" || hostname === \"[::1]\";\n  } catch {\n    return false;\n  }\n}\n\nfunction resolveUpgradeIdentityGate(plugin: unknown): UpgradeIdentityGate | undefined {\n  const exports = (plugin as { exports?: () => unknown } | undefined)?.exports?.();\n  if (\n    typeof (exports as UpgradeIdentityGate | undefined)?.isProtectedHost !== \"function\" ||\n    typeof (exports as UpgradeIdentityGate | undefined)?.session !== \"function\"\n  ) {\n    return undefined;\n  }\n  return exports as UpgradeIdentityGate;\n}\n\nfunction requestHeaders(request: IncomingMessage): Headers {\n  const headers = new Headers();\n  for (const [name, value] of Object.entries(request.headers)) {\n    if (Array.isArray(value)) {\n      for (const item of value) headers.append(name, item);\n    } else if (value !== undefined) {\n      headers.set(name, value);\n    }\n  }\n  return headers;\n}\n\n/** AppKit plugin factory for {@link AppKitLakeboxPlugin}. */\nexport const lakebox = toPlugin(AppKitLakeboxPlugin);\n"]}

package/lib/src/routes.d.ts

@@ -0,0 +1,75 @@
+import type { IncomingHttpHeaders, IncomingMessage } from "node:http";
+import { type Socket } from "node:net";
+import type { SshSession } from "@dbx-tools/lakebox/session";
+import type { LakeboxUser } from "@dbx-tools/shared-lakebox";
+import type { NextFunction, Request, Response } from "express";
+import type { LakeboxServiceRoute } from "./services.ts";
+/** Result of resolving one user's service for a routed request. */
+export type LakeboxRouteResolution = {
+    kind: "ready";
+    session: SshSession;
+    route: LakeboxServiceRoute;
+} | {
+    kind: "loading";
+} | {
+    kind: "failed";
+    message: string;
+} | {
+    kind: "missing";
+};
+/** Runtime callbacks that authorize and resolve deterministic routes. */
+export interface LakeboxRouteResolver {
+    /** Returns the authenticated Lakebox user for request headers, or `undefined`. */
+    user(headers: IncomingHttpHeaders): LakeboxUser | undefined;
+    /**
+     * Resolves a running service. Returns `loading` after starting the Lakebox
+     * or service in the background, and `missing` for an unknown service.
+     */
+    resolve(user: LakeboxUser, service: string): Promise<LakeboxRouteResolution>;
+    /** Reports that a ready service refused a forwarded connection. */
+    unavailable(user: LakeboxUser, service: string): void;
+}
+interface RouteMatch {
+    userHash: string;
+    service: string;
+    mount: string;
+}
+/**
+ * Proxies `<prefix>/<user-hash>/<service>` to that user's service port.
+ *
+ * The user hash is the only routing key. A request is forwarded only when its
+ * authenticated identity hashes to the same value, and the port is derived from
+ * the hash and service name, so there is no stored route table. Requests
+ * without an identity are rejected with 404, including WebSocket upgrades.
+ */
+export declare class LakeboxRouteRegistry {
+    private readonly prefix;
+    private readonly resolver;
+    private readonly forwardingReadyTimeoutMs;
+    private readonly bridges;
+    private readonly upgrades;
+    private readonly pending;
+    private readonly proxy;
+    private shuttingDown;
+    /** Creates a registry beneath one AppKit route prefix. */
+    constructor(prefix: string, resolver: LakeboxRouteResolver, forwardingReadyTimeoutMs?: number);
+    /** Returns the route path segment match for a request path. */
+    match(path: string): RouteMatch | undefined;
+    /** Express middleware that authorizes, rewrites, and proxies matching requests. */
+    middleware(): (request: Request, response: Response, next: NextFunction) => Promise<void>;
+    /** Number of open forwarded HTTP and WebSocket connections. */
+    activeConnections(): number;
+    /** Returns whether an upgrade path belongs to the Lakebox route prefix. */
+    canHandleUpgrade(path: string): boolean;
+    /** Proxies an authorized WebSocket upgrade. Returns false when it was not handled. */
+    handleUpgrade(request: IncomingMessage, socket: Socket, head: Buffer): Promise<boolean>;
+    /** Closes every forwarding bridge, for example after the Lakebox stops. */
+    closeBridges(): Promise<void>;
+    /** Suppresses expected proxy errors once shutdown begins. */
+    beginShutdown(): void;
+    /** Closes bridges and the shared proxy. */
+    close(): Promise<void>;
+    private authorize;
+    private bridge;
+}
+export {};