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

package/lib/src/runtime.js

@@ -0,0 +1,760 @@
+import { createHash } from "node:crypto";
+import { exec } from "@dbx-tools/core";
+import { SshKeyStore } from "@dbx-tools/lakebox/key-store";
+import { ensureLakeboxRunning, ensureLakeboxStopped, lakeboxIdleTimeoutSeconds, normalizeLakeboxStatus, } from "@dbx-tools/lakebox/lifecycle";
+import { isLakeboxUnavailable, LakeboxApiError, LakeboxClient, } from "@dbx-tools/lakebox/rest";
+import { SshCommand, SshSession } from "@dbx-tools/lakebox/session";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { LAKEBOX_BUILT_IN_SERVICES, lakeboxBuiltInServiceNameSchema, lakeboxCommandRequestSchema, lakeboxServiceLogsRequestSchema, } from "@dbx-tools/shared-lakebox";
+import { readPackageResource } from "./_package.js";
+import { stoppedSnapshotServices } from "./_service-snapshots.js";
+import { LakeboxMetrics } from "./metrics.js";
+import { LakeboxRouteRegistry } from "./routes.js";
+import { builtInDefinition, idleBuiltInService, imageDefinition, LakeboxControllerServiceSchema, serviceRoute, toLakeboxService, } from "./services.js";
+import { LAKEBOX_RUNTIME_ROOT, lakeboxUser } from "./user.js";
+const ADMIN_SCRIPT = readPackageResource("scripts", "lakebox-admin.sh");
+const HELPERS = {
+    "lakebox-service": readPackageResource("scripts", "lakebox-service.py"),
+    "desktop-session": readPackageResource("scripts", "desktop-session.sh"),
+    "desktop-prerequisites": readPackageResource("scripts", "desktop-prerequisites.sh"),
+};
+const CONTROLLER = `${LAKEBOX_RUNTIME_ROOT}/bin/lakebox-service`;
+const ENTRY_TTL_MS = 5_000;
+const SETUP_TIMEOUT_MS = 600_000;
+const METRICS_LEASE_MS = 60_000;
+const IDLE_CHECK_MS = 30_000;
+const SSH_KEY_OWNER = "app-service-principal";
+const LEGACY_NAME = /^dbx-(?!lakebox-)[a-z]+-[a-z]+-[0-9a-f]{8}(?:_uid_[A-Za-z0-9_-]+_exp_[0-9]+)?$/;
+const LEGACY_SCHEMA_PREFIX = "dbx_tools_databricks_sandbox";
+const logger = log.logger("appkit-lakebox:runtime");
+/**
+ * Owns the single lazily created Lakebox of one application.
+ *
+ * Every Databricks Lakebox REST call uses the app service principal supplied
+ * through {@link initialize}; request identity only selects the internal Linux
+ * account. Each authenticated identity maps through one FNV-1a hash to a locked
+ * account, persistent home, route segment, and service ports. Lifecycle and
+ * per-boot bootstrap are serialized in-process; the persistent resource
+ * registry serializes first creation across replicas.
+ */
+export class LakeboxRuntime {
+    config;
+    routes;
+    metrics;
+    keys;
+    stopParentTerminationSignal;
+    shutdownController = new AbortController();
+    api;
+    identity = () => undefined;
+    /** In-memory identities of routed users; never persisted. */
+    routedIdentities = new Map();
+    cached;
+    boot;
+    /** Last boot that completed runtime bootstrap and produced a metrics sample. */
+    readyBootKey;
+    converging;
+    waking;
+    metricsLease;
+    idleTimer;
+    lastActivity = Date.now();
+    activeCommands = 0;
+    /** Last service states per user hash, kept after an idle session release. */
+    lastServices = new Map();
+    lastServicesObservedAt = new Map();
+    resourceRegistry;
+    serviceSnapshots;
+    closing;
+    /** Creates a runtime from resolved plugin configuration. */
+    constructor(config) {
+        this.config = config;
+        this.keys = new SshKeyStore(config.keyDirectory);
+        this.routes = new LakeboxRouteRegistry(config.routePrefix, {
+            user: (headers) => {
+                const identity = this.identity(headers);
+                if (!identity)
+                    return undefined;
+                const user = this.user(identity);
+                this.routedIdentities.set(user.hash, identity);
+                return user;
+            },
+            resolve: (user, service) => this.resolveRoute(user, service),
+            unavailable: (user, service) => this.markUnavailable(user, service),
+        });
+        this.metrics = new LakeboxMetrics((signal) => this.readMetrics(signal), config.metricsIntervalSeconds * 1_000);
+        this.stopParentTerminationSignal = exec.onParentTerminationSignal(() => this.routes.beginShutdown());
+    }
+    /**
+     * Supplies app service-principal credentials and the request identity
+     * resolver used by routes.
+     */
+    initialize(auth, identity, serviceSnapshots, resourceRegistry) {
+        this.api = new LakeboxClient(auth);
+        if (identity)
+            this.identity = identity;
+        if (serviceSnapshots)
+            this.serviceSnapshots = serviceSnapshots;
+        if (resourceRegistry)
+            this.resourceRegistry = resourceRegistry;
+    }
+    /** Derives the Lakebox account for one authenticated identity. */
+    user(identity) {
+        return lakeboxUser(identity, this.config.routePrefix);
+    }
+    /** Summarizes the app Lakebox for one user without creating it. */
+    async summary(identity, signal) {
+        const user = this.user(identity);
+        const base = { auto: this.config.auto, name: "Lakebox", user };
+        let entry;
+        try {
+            entry = await this.entry(signal, true);
+        }
+        catch (error) {
+            if (isLakeboxUnavailable(error)) {
+                return {
+                    ...base,
+                    supported: false,
+                    status: "missing",
+                    services: [],
+                    servicesStale: false,
+                    canStart: false,
+                    canStop: false,
+                };
+            }
+            throw error;
+        }
+        const platformStatus = entry ? normalizeLakeboxStatus(entry.status) : "missing";
+        const status = this.productStatus(entry, platformStatus);
+        if (entry && platformStatus === "running" && status === "starting") {
+            this.wake(() => this.ready());
+        }
+        const listing = await this.serviceListing(identity, user, entry, status, signal);
+        return {
+            ...base,
+            supported: true,
+            status,
+            ...(entry ? { id: entry.sandboxId } : {}),
+            ...(lakeboxIdleTimeoutSeconds(entry?.idleTimeout) !== undefined
+                ? { idleTimeoutSeconds: lakeboxIdleTimeoutSeconds(entry?.idleTimeout) }
+                : {}),
+            services: listing.services,
+            servicesStale: listing.stale,
+            ...(listing.observedAt ? { servicesObservedAt: listing.observedAt } : {}),
+            canStart: status !== "running" && status !== "starting",
+            canStop: status === "running" || status === "starting",
+        };
+    }
+    /** Creates the Lakebox when needed, starts it, and restores saved services. */
+    async start(signal) {
+        await this.ready(signal, true);
+    }
+    /** Stops the shared Lakebox for every user. Files and saved services persist. */
+    async stop(signal) {
+        const entry = await this.entry(signal, true);
+        if (!entry)
+            return;
+        await this.discardBoot();
+        await ensureLakeboxStopped(this.client(), entry, signal);
+        this.cached = undefined;
+    }
+    /** Permanently deletes the managed Lakebox and every user's files. */
+    async delete(signal) {
+        const entry = await this.entry(signal, true);
+        if (!entry)
+            return false;
+        await this.discardBoot();
+        await this.client().delete(entry.sandboxId, signal);
+        await this.resources().clear(this.client());
+        this.readyBootKey = undefined;
+        this.cached = { at: Date.now() };
+        return true;
+    }
+    /**
+     * Runs one command as the user's account, creating or starting the Lakebox
+     * when `auto` is enabled.
+     */
+    execute(identity, input, signal) {
+        const request = lakeboxCommandRequestSchema.parse(input);
+        const timeoutMs = request.timeoutMs ?? this.config.commandTimeoutMs;
+        const user = this.user(identity);
+        return new SshCommand(request.command, request.args, { timeoutMs, signal }, async (execution) => {
+            const boot = await this.readyUser(user, identity, execution.signal);
+            this.activeCommands += 1;
+            try {
+                return await execution.follow(boot.session.execute(request.command, request.args, {
+                    user,
+                    ...(request.cwd ? { cwd: request.cwd } : {}),
+                    ...(request.env ? { env: request.env } : {}),
+                    timeoutMs,
+                    signal: execution.signal,
+                }));
+            }
+            finally {
+                this.activeCommands -= 1;
+                this.touch();
+            }
+        });
+    }
+    /** Lists the user's services, including idle built-ins. Never creates the Lakebox. */
+    async listServices(identity, signal) {
+        const user = this.user(identity);
+        const entry = await this.entry(signal);
+        const status = entry ? normalizeLakeboxStatus(entry.status) : "missing";
+        return (await this.serviceListing(identity, user, entry, status, signal)).services;
+    }
+    /** Creates or replaces one image service and waits until it is ready or failed. */
+    async createService(identity, input, signal) {
+        const user = this.user(identity);
+        const definition = imageDefinition(input, user);
+        const boot = await this.readyUser(user, identity, signal);
+        await this.controller(boot, user, "put", [encode(definition)], signal);
+        return this.runService(boot, user, definition, signal);
+    }
+    /** Starts a saved service or a built-in and waits until it is ready or failed. */
+    async startService(identity, name, signal) {
+        const user = this.user(identity);
+        const boot = await this.readyUser(user, identity, signal);
+        const builtIn = lakeboxBuiltInServiceNameSchema.safeParse(name);
+        if (builtIn.success) {
+            const definition = builtInDefinition(builtIn.data, user);
+            await this.controller(boot, user, "put", [encode(definition)], signal);
+            return this.runService(boot, user, definition, signal);
+        }
+        const saved = (await this.refreshServices(boot, user, identity, signal)).get(name);
+        if (!saved)
+            throw new Error(`Lakebox service ${name} does not exist`);
+        return this.runService(boot, user, saved.definition, signal);
+    }
+    /** Stops one running service without removing its definition. */
+    async stopService(identity, name, signal) {
+        const user = this.user(identity);
+        const boot = await this.readyUser(user, identity, signal);
+        const stopped = LakeboxControllerServiceSchema.parse(await this.controller(boot, user, "stop", [name], signal));
+        this.cacheService(boot, user, stopped);
+        return toLakeboxService(stopped, user, this.config.routePrefix);
+    }
+    /** Stops and deletes one saved service. Mounted home directories are preserved. */
+    async removeService(identity, name, signal) {
+        const user = this.user(identity);
+        const boot = await this.readyUser(user, identity, signal);
+        const result = (await this.controller(boot, user, "remove", [name], signal));
+        if (result.removed === true)
+            await this.refreshServices(boot, user, identity, signal);
+        return result.removed === true;
+    }
+    /** Reads a bounded tail of one service log. */
+    async serviceLogs(identity, input, signal) {
+        const request = lakeboxServiceLogsRequestSchema.parse(input);
+        const user = this.user(identity);
+        const entry = await this.entry(signal);
+        if (!entry || normalizeLakeboxStatus(entry.status) !== "running")
+            return { log: "" };
+        const boot = await this.readyUser(user, identity, signal);
+        const result = (await this.controller(boot, user, "logs", [request.name, String(request.maxLines), String(request.maxChars)], signal));
+        return { log: result.log ?? "" };
+    }
+    /**
+     * Returns recent metrics and keeps sampling for one lease interval. Sampling
+     * runs only while the Lakebox runs and a caller is watching, so metrics never
+     * keep an otherwise idle Lakebox awake.
+     */
+    async metricsResponse(signal) {
+        const entry = await this.entry(signal);
+        const platformStatus = entry ? normalizeLakeboxStatus(entry.status) : "missing";
+        if (platformStatus !== "running") {
+            this.metrics.stop();
+            return { status: platformStatus, series: [] };
+        }
+        if (!entry || !this.boot || this.boot.key !== this.bootKey(entry)) {
+            this.metrics.stop();
+            this.wake(() => this.ready());
+            return { status: "starting", series: [] };
+        }
+        this.leaseMetrics();
+        return {
+            status: this.productStatus(entry, platformStatus),
+            series: [...this.metrics.series()],
+        };
+    }
+    /** Subscribes to metrics snapshots while the Lakebox runs. */
+    subscribeMetrics(listener) {
+        this.metrics.on("snapshot", listener);
+        if (this.boot?.key === this.readyBootKey)
+            this.metrics.start();
+        return () => {
+            this.metrics.off("snapshot", listener);
+            this.leaseMetrics();
+        };
+    }
+    /**
+     * Deletes legacy per-user Lakeboxes and drops legacy ownership schemas.
+     *
+     * There is no migration: the earlier one-machine-per-user model is removed.
+     * The managed app Lakebox and Lakeboxes with other names are never touched.
+     */
+    async cleanupLegacy(pool, signal) {
+        try {
+            const entries = await this.client().list(signal);
+            await Promise.all(entries
+                .filter((entry) => entry.name && LEGACY_NAME.test(entry.name))
+                .map(async (entry) => {
+                await this.client().delete(entry.sandboxId, signal);
+                logger.info("deleted legacy per-user Lakebox", {
+                    id: entry.sandboxId,
+                    name: entry.name,
+                });
+            }));
+        }
+        catch (error) {
+            if (!isLakeboxUnavailable(error)) {
+                logger.warn("legacy Lakebox cleanup failed", { error: errorUtils.toError(error) });
+            }
+        }
+        if (!pool)
+            return;
+        try {
+            const schemas = await pool.query("SELECT nspname FROM pg_namespace WHERE nspname = $1 OR starts_with(nspname, $2)", [LEGACY_SCHEMA_PREFIX, `${LEGACY_SCHEMA_PREFIX}_`]);
+            for (const row of schemas.rows) {
+                const schema = String(row.nspname);
+                await pool.query(`DROP SCHEMA IF EXISTS "${schema.replaceAll('"', '""')}" CASCADE`);
+                logger.info("dropped legacy Lakebox ownership schema", { schema });
+            }
+        }
+        catch (error) {
+            logger.warn("legacy ownership schema cleanup failed", { error: errorUtils.toError(error) });
+        }
+    }
+    /** Cancels in-flight work before teardown. */
+    abortActiveOperations() {
+        if (!this.shutdownController.signal.aborted)
+            this.shutdownController.abort();
+    }
+    /** Closes routes, metrics, and the SSH session without changing the Lakebox. */
+    close() {
+        this.abortActiveOperations();
+        this.routes.beginShutdown();
+        this.closing ??= (async () => {
+            try {
+                if (this.metricsLease)
+                    clearTimeout(this.metricsLease);
+                this.metrics.stop();
+                await this.routes.close();
+                await this.boot?.session.close();
+                this.boot = undefined;
+            }
+            finally {
+                this.stopParentTerminationSignal();
+            }
+        })();
+        return this.closing;
+    }
+    client() {
+        if (!this.api)
+            throw new Error("The Lakebox runtime has no app service-principal credentials");
+        return this.api;
+    }
+    resources() {
+        if (!this.resourceRegistry)
+            throw new Error("The Lakebox runtime has no resource registry");
+        return this.resourceRegistry;
+    }
+    /** Returns the managed Lakebox entry, cached briefly to keep routes cheap. */
+    async entry(signal, fresh = false) {
+        if (!fresh && this.cached && Date.now() - this.cached.at < ENTRY_TTL_MS) {
+            return this.cached.entry;
+        }
+        const entry = await this.resources().read(this.client(), signal);
+        this.cached = { ...(entry ? { entry } : {}), at: Date.now() };
+        if (!entry || normalizeLakeboxStatus(entry.status) !== "running") {
+            this.readyBootKey = undefined;
+        }
+        if (this.boot && (!entry || this.bootKey(entry) !== this.boot.key))
+            await this.discardBoot();
+        return entry;
+    }
+    bootKey(entry) {
+        return `${entry.sandboxId}\0${entry.lastStartTime ?? ""}`;
+    }
+    productStatus(entry, status) {
+        return entry && status === "running" && this.readyBootKey !== this.bootKey(entry)
+            ? "starting"
+            : status;
+    }
+    /** Serializes create, start, connect, and bootstrap for the current boot. */
+    ready(signal, explicit = false) {
+        const current = this.boot;
+        if (current && this.cached?.entry && this.bootKey(this.cached.entry) === current.key) {
+            if (Date.now() - this.cached.at < ENTRY_TTL_MS)
+                return Promise.resolve(current);
+        }
+        this.converging ??= this.converge(signal, explicit).finally(() => {
+            this.converging = undefined;
+        });
+        return this.converging;
+    }
+    async converge(signal, explicit) {
+        const operationSignal = signal
+            ? AbortSignal.any([signal, this.shutdownController.signal])
+            : this.shutdownController.signal;
+        let entry = await this.entry(operationSignal, true);
+        if (!entry || normalizeLakeboxStatus(entry.status) !== "running") {
+            if (!this.config.auto && !explicit) {
+                throw new Error(`Lakebox is ${entry ? entry.status : "not created"}; start it explicitly because auto is false`);
+            }
+        }
+        entry ??= await this.resources().getOrCreate(this.client(), operationSignal);
+        if (lakeboxIdleTimeoutSeconds(entry.idleTimeout) !== this.config.idleTimeoutSeconds) {
+            entry = await this.client().setIdleTimeout(entry.sandboxId, this.config.idleTimeoutSeconds, operationSignal);
+        }
+        entry = await ensureLakeboxRunning(this.client(), entry, operationSignal);
+        this.cached = { entry, at: Date.now() };
+        const key = this.bootKey(entry);
+        if (this.boot?.key === key)
+            return this.boot;
+        await this.discardBoot();
+        const session = await this.connect(entry, operationSignal);
+        const boot = {
+            key,
+            entry,
+            session,
+            users: new Map(),
+            services: new Map(),
+            starting: new Map(),
+        };
+        try {
+            const restored = await this.bootstrap(session, operationSignal);
+            this.metrics.stop();
+            this.metrics.seed((await this.admin(session, ["metrics"], operationSignal)).stdout);
+            this.boot = boot;
+            this.readyBootKey = key;
+            this.watchIdle();
+            if (this.metrics.listenerCount("snapshot") > 0)
+                this.metrics.start();
+            for (const hash of restored)
+                void this.restoreUser(boot, hash);
+            return boot;
+        }
+        catch (error) {
+            await session.close();
+            throw error;
+        }
+    }
+    async connect(entry, signal) {
+        const api = this.client();
+        const scope = await api.workspaceScope();
+        const key = await this.keys.ensureRegistered(api, SSH_KEY_OWNER, signal);
+        const gatewayHost = entry.gatewayHost ?? key.gatewayHost;
+        if (!gatewayHost)
+            throw new Error("Databricks Lakebox did not return an SSH gateway host");
+        const port = this.config.gatewayPort;
+        const knownHost = await this.keys.knownHost(scope, SSH_KEY_OWNER, gatewayHost, port);
+        const session = new SshSession({
+            host: gatewayHost,
+            port,
+            username: entry.sandboxId,
+            privateKey: key.privateKey,
+            privateKeyPath: key.privateKeyPath,
+            knownHostsPath: this.keys.knownHostsPath(scope, SSH_KEY_OWNER, gatewayHost, port),
+            connectTimeoutMs: this.config.connectTimeoutMs,
+            sshTransport: this.config.sshTransport,
+            ssh2Patch: this.config.ssh2Patch,
+            ...(knownHost ? { knownHost } : {}),
+            rememberHost: (fingerprint, hostKey) => this.keys.rememberHost(scope, SSH_KEY_OWNER, gatewayHost, port, fingerprint, hostKey),
+        });
+        try {
+            await session.connect();
+            return session;
+        }
+        catch (error) {
+            await session.close();
+            throw error;
+        }
+    }
+    /** Runs the fixed privileged bootstrap and returns the restored user hashes. */
+    async bootstrap(session, signal) {
+        const helpers = Object.entries(HELPERS).map(([name, content]) => `${name}=${Buffer.from(content).toString("base64")}`);
+        const result = await this.admin(session, ["bootstrap", ...helpers], signal);
+        return result.stdout
+            .split("\n")
+            .filter((line) => line.startsWith("__LAKEBOX_USER__="))
+            .map((line) => line.slice("__LAKEBOX_USER__=".length).trim());
+    }
+    async admin(session, args, signal) {
+        const encoded = Buffer.from(ADMIN_SCRIPT).toString("base64");
+        const result = await session.executePrivileged("sh", ["-c", `printf %s '${encoded}' | base64 -d | sh -s -- ${args.map(shellQuote).join(" ")}`], { timeoutMs: SETUP_TIMEOUT_MS, ...(signal ? { signal } : {}) }).result;
+        if (!result.success) {
+            throw new Error(`Lakebox ${args[0]} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`}`);
+        }
+        return result;
+    }
+    /** Marks activity, readies the current boot, and converges the user's account. */
+    async readyUser(user, identity, signal) {
+        this.touch();
+        const boot = await this.ready(signal);
+        await this.convergeUser(boot, user, identity, signal);
+        return boot;
+    }
+    /** Creates or verifies the user's account once per boot. */
+    convergeUser(boot, user, identity, signal) {
+        let converged = boot.users.get(user.hash);
+        if (!converged) {
+            const digest = createHash("sha256").update(identity.trim().toLowerCase()).digest("hex");
+            converged = this.admin(boot.session, ["ensure-user", user.hash, String(user.uid), digest], signal).then(() => undefined);
+            boot.users.set(user.hash, converged);
+            converged.catch(() => boot.users.delete(user.hash));
+        }
+        return converged;
+    }
+    async restoreUser(boot, hash) {
+        const user = { name: `lakebox-${hash}`, home: `/home/lakebox-${hash}` };
+        boot.users.set(hash, Promise.resolve());
+        try {
+            const result = await boot.session.execute("python3", [CONTROLLER, "start-all"], {
+                user,
+                timeoutMs: SETUP_TIMEOUT_MS,
+                signal: this.shutdownController.signal,
+            }).result;
+            if (!result.success)
+                throw new Error(result.stderr.trim() || `exit ${result.exitCode}`);
+        }
+        catch (error) {
+            if (this.shutdownController.signal.aborted)
+                return;
+            logger.warn("Lakebox service restore failed", {
+                user: hash,
+                error: errorUtils.toError(error),
+            });
+        }
+    }
+    async controller(boot, user, command, args, signal) {
+        const result = await boot.session.execute("python3", [CONTROLLER, command, ...args], {
+            user,
+            timeoutMs: SETUP_TIMEOUT_MS,
+            ...(signal ? { signal } : {}),
+        }).result;
+        if (!result.success) {
+            throw new Error(`Lakebox service ${command} failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+        }
+        return JSON.parse(result.stdout);
+    }
+    async runService(boot, user, definition, signal) {
+        const key = `${user.hash}\0${definition.name}`;
+        const pending = boot.starting.get(key);
+        if (pending)
+            return pending;
+        const operation = (async () => {
+            if (definition.kind === "desktop") {
+                boot.desktop ??= this.admin(boot.session, ["desktop-prerequisites"], signal).then(() => undefined);
+                boot.desktop.catch(() => {
+                    boot.desktop = undefined;
+                });
+                await boot.desktop;
+            }
+            await this.admin(boot.session, ["allow-port", String(user.uid), String(definition.port)], signal);
+            const started = LakeboxControllerServiceSchema.parse(await this.controller(boot, user, "start", [definition.name], signal));
+            this.cacheService(boot, user, started);
+            return toLakeboxService(started, user, this.config.routePrefix);
+        })().finally(() => boot.starting.delete(key));
+        boot.starting.set(key, operation);
+        return operation;
+    }
+    async refreshServices(boot, user, identity, signal) {
+        await this.convergeUser(boot, user, identity, signal);
+        const response = (await this.controller(boot, user, "list", [], signal));
+        const services = new Map((response.services ?? []).map((service) => {
+            const parsed = LakeboxControllerServiceSchema.parse(service);
+            return [parsed.name, parsed];
+        }));
+        boot.services.set(user.hash, services);
+        this.lastServices.set(user.hash, services);
+        const observedAt = new Date().toISOString();
+        this.lastServicesObservedAt.set(user.hash, observedAt);
+        await this.persistServiceSnapshot(boot.entry, user, services, observedAt);
+        return services;
+    }
+    cacheService(boot, user, service) {
+        const services = boot.services.get(user.hash) ?? new Map();
+        services.set(service.name, service);
+        boot.services.set(user.hash, services);
+        this.lastServices.set(user.hash, services);
+        const observedAt = new Date().toISOString();
+        this.lastServicesObservedAt.set(user.hash, observedAt);
+        void this.persistServiceSnapshot(boot.entry, user, services, observedAt);
+    }
+    async serviceListing(identity, user, entry, status, signal) {
+        if (!entry || status === "missing") {
+            return { services: this.idleServices(user), stale: false };
+        }
+        if (status === "running" && this.boot?.key === this.bootKey(entry)) {
+            const services = await this.refreshServices(this.boot, user, identity, signal);
+            return { services: this.withBuiltIns(user, services), stale: false };
+        }
+        const memory = this.lastServices.get(user.hash);
+        if (memory) {
+            const observedAt = this.lastServicesObservedAt.get(user.hash);
+            const services = status === "running"
+                ? memory
+                : stoppedSnapshotServices({
+                    observedAt: observedAt ?? new Date().toISOString(),
+                    definitions: [...memory.values()].map((service) => service.definition),
+                });
+            return {
+                services: this.withBuiltIns(user, services),
+                stale: true,
+                ...(observedAt ? { observedAt } : {}),
+            };
+        }
+        const snapshot = await this.serviceSnapshots?.read(entry.sandboxId, user.hash);
+        return snapshot
+            ? {
+                services: this.withBuiltIns(user, stoppedSnapshotServices(snapshot)),
+                stale: true,
+                observedAt: snapshot.observedAt,
+            }
+            : { services: this.idleServices(user), stale: true };
+    }
+    async persistServiceSnapshot(entry, user, services, observedAt) {
+        await this.serviceSnapshots?.write(entry.sandboxId, user.hash, {
+            observedAt,
+            definitions: [...services.values()].map((service) => service.definition),
+        });
+    }
+    withBuiltIns(user, services) {
+        const builtIns = LAKEBOX_BUILT_IN_SERVICES.map(({ name }) => {
+            const saved = services.get(name);
+            return saved
+                ? toLakeboxService(saved, user, this.config.routePrefix)
+                : idleBuiltInService(name, user, this.config.routePrefix);
+        });
+        const custom = [...services.values()]
+            .filter((service) => !LAKEBOX_BUILT_IN_SERVICES.some(({ name }) => name === service.name))
+            .map((service) => toLakeboxService(service, user, this.config.routePrefix));
+        return [...builtIns, ...custom];
+    }
+    idleServices(user) {
+        return LAKEBOX_BUILT_IN_SERVICES.map(({ name }) => idleBuiltInService(name, user, this.config.routePrefix));
+    }
+    /** Resolves one routed request, waking the Lakebox or service in the background. */
+    async resolveRoute(user, name) {
+        this.touch();
+        const entry = await this.entry();
+        const running = entry && normalizeLakeboxStatus(entry.status) === "running";
+        const boot = this.boot;
+        if (!running || !boot || boot.key !== this.bootKey(entry)) {
+            if (!this.config.auto)
+                return { kind: "missing" };
+            this.wake(() => this.ready());
+            return { kind: "loading" };
+        }
+        const identity = this.routedIdentities.get(user.hash);
+        if (!identity)
+            return { kind: "missing" };
+        let service = boot.services.get(user.hash)?.get(name);
+        if (!service)
+            service = (await this.refreshServices(boot, user, identity)).get(name);
+        const builtIn = lakeboxBuiltInServiceNameSchema.safeParse(name);
+        if (!service && !builtIn.success)
+            return { kind: "missing" };
+        if (service?.state === "ready") {
+            return { kind: "ready", session: boot.session, route: serviceRoute(service.definition) };
+        }
+        if (service?.state === "error" && !boot.starting.has(`${user.hash}\0${name}`)) {
+            return { kind: "failed", message: service.error ?? "the service failed to start" };
+        }
+        const definition = service?.definition ?? builtInDefinition(builtIn.data, user);
+        this.wake(async () => {
+            if (!service)
+                await this.controller(boot, user, "put", [encode(definition)]);
+            await this.runService(boot, user, definition);
+        });
+        return { kind: "loading" };
+    }
+    markUnavailable(user, name) {
+        this.boot?.services.get(user.hash)?.delete(name);
+        this.cached = undefined;
+    }
+    wake(action) {
+        if (this.waking)
+            return;
+        this.waking = action()
+            .catch((error) => logger.warn("Lakebox wake failed", { error: errorUtils.toError(error) }))
+            .finally(() => {
+            this.waking = undefined;
+        });
+    }
+    async readMetrics(signal) {
+        const boot = this.boot;
+        if (!boot)
+            throw new Error("Lakebox is not running");
+        try {
+            return (await this.admin(boot.session, ["metrics"], signal)).stdout;
+        }
+        catch (error) {
+            this.cached = undefined;
+            throw error;
+        }
+    }
+    leaseMetrics() {
+        if (!this.boot)
+            return;
+        this.metrics.start();
+        if (this.metricsLease)
+            clearTimeout(this.metricsLease);
+        this.metricsLease = setTimeout(() => {
+            if (this.metrics.listenerCount("snapshot") === 0)
+                this.metrics.stop();
+        }, METRICS_LEASE_MS);
+        this.metricsLease.unref?.();
+    }
+    /**
+     * Releases the SSH session after the idle timeout without commands, service
+     * operations, routed traffic, open streams, or metrics watchers. An open
+     * session counts as activity for the platform watchdog, so releasing it lets
+     * the platform stop the Lakebox after its own idle timeout. The next request
+     * reconnects.
+     */
+    watchIdle() {
+        if (this.idleTimer)
+            clearInterval(this.idleTimer);
+        this.idleTimer = setInterval(() => {
+            const idleMs = Date.now() - this.lastActivity;
+            if (!this.boot ||
+                this.converging ||
+                idleMs < this.config.idleTimeoutSeconds * 1_000 ||
+                this.activeCommands > 0 ||
+                this.boot.starting.size > 0 ||
+                this.routes.activeConnections() > 0 ||
+                this.metrics.listenerCount("snapshot") > 0) {
+                if (this.routes.activeConnections() > 0 || this.activeCommands > 0)
+                    this.touch();
+                return;
+            }
+            logger.info("releasing idle Lakebox session", { idleSeconds: Math.round(idleMs / 1_000) });
+            void this.discardBoot();
+        }, IDLE_CHECK_MS);
+        this.idleTimer.unref?.();
+    }
+    touch() {
+        this.lastActivity = Date.now();
+    }
+    async discardBoot() {
+        if (this.idleTimer)
+            clearInterval(this.idleTimer);
+        this.idleTimer = undefined;
+        const boot = this.boot;
+        this.boot = undefined;
+        this.metrics.stop();
+        await this.routes.closeBridges();
+        await boot?.session.close().catch(() => undefined);
+    }
+}
+function encode(definition) {
+    return Buffer.from(JSON.stringify(definition)).toString("base64");
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+/** Returns whether an error means the managed Lakebox no longer exists. */
+export function isLakeboxMissing(error) {
+    return error instanceof LakeboxApiError && error.status === 404;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from \"node:crypto\";\nimport type { IncomingHttpHeaders } from \"node:http\";\nimport { exec } from \"@dbx-tools/core\";\nimport { SshKeyStore } from \"@dbx-tools/lakebox/key-store\";\nimport {\n  ensureLakeboxRunning,\n  ensureLakeboxStopped,\n  lakeboxIdleTimeoutSeconds,\n  normalizeLakeboxStatus,\n} from \"@dbx-tools/lakebox/lifecycle\";\nimport {\n  isLakeboxUnavailable,\n  LakeboxApiError,\n  LakeboxClient,\n  type LakeboxAuth,\n  type LakeboxEntry,\n} from \"@dbx-tools/lakebox/rest\";\nimport { SshCommand, SshSession } from \"@dbx-tools/lakebox/session\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport {\n  LAKEBOX_BUILT_IN_SERVICES,\n  lakeboxBuiltInServiceNameSchema,\n  lakeboxCommandRequestSchema,\n  lakeboxServiceLogsRequestSchema,\n  type CreateLakeboxServiceRequest,\n  type LakeboxBuiltInServiceName,\n  type LakeboxCommandRequest,\n  type LakeboxMetricsResponse,\n  type LakeboxMetricsSnapshot,\n  type LakeboxService,\n  type LakeboxServiceLogsRequest,\n  type LakeboxStatus,\n  type LakeboxSummary,\n  type LakeboxUser,\n} from \"@dbx-tools/shared-lakebox\";\nimport { readPackageResource } from \"./_package.ts\";\nimport { LakeboxResourceRegistry } from \"./_resource-registry.ts\";\nimport { LakeboxServiceSnapshots, stoppedSnapshotServices } from \"./_service-snapshots.ts\";\nimport type { ResolvedLakeboxPluginConfig } from \"./config.ts\";\nimport { LakeboxMetrics } from \"./metrics.ts\";\nimport { LakeboxRouteRegistry, type LakeboxRouteResolution } from \"./routes.ts\";\nimport {\n  builtInDefinition,\n  idleBuiltInService,\n  imageDefinition,\n  LakeboxControllerServiceSchema,\n  serviceRoute,\n  toLakeboxService,\n  type LakeboxControllerDefinition,\n  type LakeboxControllerService,\n} from \"./services.ts\";\nimport { LAKEBOX_RUNTIME_ROOT, lakeboxUser } from \"./user.ts\";\n\nconst ADMIN_SCRIPT = readPackageResource(\"scripts\", \"lakebox-admin.sh\");\nconst HELPERS = {\n  \"lakebox-service\": readPackageResource(\"scripts\", \"lakebox-service.py\"),\n  \"desktop-session\": readPackageResource(\"scripts\", \"desktop-session.sh\"),\n  \"desktop-prerequisites\": readPackageResource(\"scripts\", \"desktop-prerequisites.sh\"),\n} as const;\nconst CONTROLLER = `${LAKEBOX_RUNTIME_ROOT}/bin/lakebox-service`;\nconst ENTRY_TTL_MS = 5_000;\nconst SETUP_TIMEOUT_MS = 600_000;\nconst METRICS_LEASE_MS = 60_000;\nconst IDLE_CHECK_MS = 30_000;\nconst SSH_KEY_OWNER = \"app-service-principal\";\nconst LEGACY_NAME =\n  /^dbx-(?!lakebox-)[a-z]+-[a-z]+-[0-9a-f]{8}(?:_uid_[A-Za-z0-9_-]+_exp_[0-9]+)?$/;\nconst LEGACY_SCHEMA_PREFIX = \"dbx_tools_databricks_sandbox\";\nconst logger = log.logger(\"appkit-lakebox:runtime\");\n\n/** Resolves the authenticated identity for raw request headers. */\nexport type LakeboxIdentityResolver = (headers: IncomingHttpHeaders) => string | undefined;\n\n/** Minimal Lakebase pool used to drop legacy ownership schemas. */\nexport interface LakeboxLegacyPool {\n  query(sql: string, values?: unknown[]): Promise<{ rows: Array<Record<string, unknown>> }>;\n}\n\ninterface Boot {\n  key: string;\n  entry: LakeboxEntry;\n  session: SshSession;\n  users: Map<string, Promise<void>>;\n  services: Map<string, Map<string, LakeboxControllerService>>;\n  starting: Map<string, Promise<LakeboxService>>;\n  desktop?: Promise<void>;\n}\n\ninterface ServiceListing {\n  services: LakeboxService[];\n  stale: boolean;\n  observedAt?: string;\n}\n\n/**\n * Owns the single lazily created Lakebox of one application.\n *\n * Every Databricks Lakebox REST call uses the app service principal supplied\n * through {@link initialize}; request identity only selects the internal Linux\n * account. Each authenticated identity maps through one FNV-1a hash to a locked\n * account, persistent home, route segment, and service ports. Lifecycle and\n * per-boot bootstrap are serialized in-process; the persistent resource\n * registry serializes first creation across replicas.\n */\nexport class LakeboxRuntime {\n  readonly routes: LakeboxRouteRegistry;\n  readonly metrics: LakeboxMetrics;\n  private readonly keys: SshKeyStore;\n  private readonly stopParentTerminationSignal: () => void;\n  private readonly shutdownController = new AbortController();\n  private api?: LakeboxClient;\n  private identity: LakeboxIdentityResolver = () => undefined;\n  /** In-memory identities of routed users; never persisted. */\n  private readonly routedIdentities = new Map<string, string>();\n  private cached?: { entry?: LakeboxEntry; at: number };\n  private boot?: Boot;\n  /** Last boot that completed runtime bootstrap and produced a metrics sample. */\n  private readyBootKey?: string;\n  private converging?: Promise<Boot>;\n  private waking?: Promise<unknown>;\n  private metricsLease?: ReturnType<typeof setTimeout>;\n  private idleTimer?: ReturnType<typeof setInterval>;\n  private lastActivity = Date.now();\n  private activeCommands = 0;\n  /** Last service states per user hash, kept after an idle session release. */\n  private readonly lastServices = new Map<string, Map<string, LakeboxControllerService>>();\n  private readonly lastServicesObservedAt = new Map<string, string>();\n  private resourceRegistry?: LakeboxResourceRegistry;\n  private serviceSnapshots?: LakeboxServiceSnapshots;\n  private closing?: Promise<void>;\n\n  /** Creates a runtime from resolved plugin configuration. */\n  constructor(readonly config: ResolvedLakeboxPluginConfig) {\n    this.keys = new SshKeyStore(config.keyDirectory);\n    this.routes = new LakeboxRouteRegistry(config.routePrefix, {\n      user: (headers) => {\n        const identity = this.identity(headers);\n        if (!identity) return undefined;\n        const user = this.user(identity);\n        this.routedIdentities.set(user.hash, identity);\n        return user;\n      },\n      resolve: (user, service) => this.resolveRoute(user, service),\n      unavailable: (user, service) => this.markUnavailable(user, service),\n    });\n    this.metrics = new LakeboxMetrics(\n      (signal) => this.readMetrics(signal),\n      config.metricsIntervalSeconds * 1_000,\n    );\n    this.stopParentTerminationSignal = exec.onParentTerminationSignal(() =>\n      this.routes.beginShutdown(),\n    );\n  }\n\n  /**\n   * Supplies app service-principal credentials and the request identity\n   * resolver used by routes.\n   */\n  initialize(\n    auth: LakeboxAuth,\n    identity?: LakeboxIdentityResolver,\n    serviceSnapshots?: LakeboxServiceSnapshots,\n    resourceRegistry?: LakeboxResourceRegistry,\n  ): void {\n    this.api = new LakeboxClient(auth);\n    if (identity) this.identity = identity;\n    if (serviceSnapshots) this.serviceSnapshots = serviceSnapshots;\n    if (resourceRegistry) this.resourceRegistry = resourceRegistry;\n  }\n\n  /** Derives the Lakebox account for one authenticated identity. */\n  user(identity: string): LakeboxUser {\n    return lakeboxUser(identity, this.config.routePrefix);\n  }\n\n  /** Summarizes the app Lakebox for one user without creating it. */\n  async summary(identity: string, signal?: AbortSignal): Promise<LakeboxSummary> {\n    const user = this.user(identity);\n    const base = { auto: this.config.auto, name: \"Lakebox\", user };\n    let entry: LakeboxEntry | undefined;\n    try {\n      entry = await this.entry(signal, true);\n    } catch (error) {\n      if (isLakeboxUnavailable(error)) {\n        return {\n          ...base,\n          supported: false,\n          status: \"missing\",\n          services: [],\n          servicesStale: false,\n          canStart: false,\n          canStop: false,\n        };\n      }\n      throw error;\n    }\n    const platformStatus: LakeboxStatus = entry ? normalizeLakeboxStatus(entry.status) : \"missing\";\n    const status = this.productStatus(entry, platformStatus);\n    if (entry && platformStatus === \"running\" && status === \"starting\") {\n      this.wake(() => this.ready());\n    }\n    const listing = await this.serviceListing(identity, user, entry, status, signal);\n    return {\n      ...base,\n      supported: true,\n      status,\n      ...(entry ? { id: entry.sandboxId } : {}),\n      ...(lakeboxIdleTimeoutSeconds(entry?.idleTimeout) !== undefined\n        ? { idleTimeoutSeconds: lakeboxIdleTimeoutSeconds(entry?.idleTimeout) }\n        : {}),\n      services: listing.services,\n      servicesStale: listing.stale,\n      ...(listing.observedAt ? { servicesObservedAt: listing.observedAt } : {}),\n      canStart: status !== \"running\" && status !== \"starting\",\n      canStop: status === \"running\" || status === \"starting\",\n    };\n  }\n\n  /** Creates the Lakebox when needed, starts it, and restores saved services. */\n  async start(signal?: AbortSignal): Promise<void> {\n    await this.ready(signal, true);\n  }\n\n  /** Stops the shared Lakebox for every user. Files and saved services persist. */\n  async stop(signal?: AbortSignal): Promise<void> {\n    const entry = await this.entry(signal, true);\n    if (!entry) return;\n    await this.discardBoot();\n    await ensureLakeboxStopped(this.client(), entry, signal);\n    this.cached = undefined;\n  }\n\n  /** Permanently deletes the managed Lakebox and every user's files. */\n  async delete(signal?: AbortSignal): Promise<boolean> {\n    const entry = await this.entry(signal, true);\n    if (!entry) return false;\n    await this.discardBoot();\n    await this.client().delete(entry.sandboxId, signal);\n    await this.resources().clear(this.client());\n    this.readyBootKey = undefined;\n    this.cached = { at: Date.now() };\n    return true;\n  }\n\n  /**\n   * Runs one command as the user's account, creating or starting the Lakebox\n   * when `auto` is enabled.\n   */\n  execute(identity: string, input: LakeboxCommandRequest, signal?: AbortSignal): SshCommand {\n    const request = lakeboxCommandRequestSchema.parse(input);\n    const timeoutMs = request.timeoutMs ?? this.config.commandTimeoutMs;\n    const user = this.user(identity);\n    return new SshCommand(\n      request.command,\n      request.args,\n      { timeoutMs, signal },\n      async (execution) => {\n        const boot = await this.readyUser(user, identity, execution.signal);\n        this.activeCommands += 1;\n        try {\n          return await execution.follow(\n            boot.session.execute(request.command, request.args, {\n              user,\n              ...(request.cwd ? { cwd: request.cwd } : {}),\n              ...(request.env ? { env: request.env } : {}),\n              timeoutMs,\n              signal: execution.signal,\n            }),\n          );\n        } finally {\n          this.activeCommands -= 1;\n          this.touch();\n        }\n      },\n    );\n  }\n\n  /** Lists the user's services, including idle built-ins. Never creates the Lakebox. */\n  async listServices(identity: string, signal?: AbortSignal): Promise<LakeboxService[]> {\n    const user = this.user(identity);\n    const entry = await this.entry(signal);\n    const status: LakeboxStatus = entry ? normalizeLakeboxStatus(entry.status) : \"missing\";\n    return (await this.serviceListing(identity, user, entry, status, signal)).services;\n  }\n\n  /** Creates or replaces one image service and waits until it is ready or failed. */\n  async createService(\n    identity: string,\n    input: CreateLakeboxServiceRequest,\n    signal?: AbortSignal,\n  ): Promise<LakeboxService> {\n    const user = this.user(identity);\n    const definition = imageDefinition(input, user);\n    const boot = await this.readyUser(user, identity, signal);\n    await this.controller(boot, user, \"put\", [encode(definition)], signal);\n    return this.runService(boot, user, definition, signal);\n  }\n\n  /** Starts a saved service or a built-in and waits until it is ready or failed. */\n  async startService(\n    identity: string,\n    name: string,\n    signal?: AbortSignal,\n  ): Promise<LakeboxService> {\n    const user = this.user(identity);\n    const boot = await this.readyUser(user, identity, signal);\n    const builtIn = lakeboxBuiltInServiceNameSchema.safeParse(name);\n    if (builtIn.success) {\n      const definition = builtInDefinition(builtIn.data, user);\n      await this.controller(boot, user, \"put\", [encode(definition)], signal);\n      return this.runService(boot, user, definition, signal);\n    }\n    const saved = (await this.refreshServices(boot, user, identity, signal)).get(name);\n    if (!saved) throw new Error(`Lakebox service ${name} does not exist`);\n    return this.runService(boot, user, saved.definition, signal);\n  }\n\n  /** Stops one running service without removing its definition. */\n  async stopService(identity: string, name: string, signal?: AbortSignal): Promise<LakeboxService> {\n    const user = this.user(identity);\n    const boot = await this.readyUser(user, identity, signal);\n    const stopped = LakeboxControllerServiceSchema.parse(\n      await this.controller(boot, user, \"stop\", [name], signal),\n    );\n    this.cacheService(boot, user, stopped);\n    return toLakeboxService(stopped, user, this.config.routePrefix);\n  }\n\n  /** Stops and deletes one saved service. Mounted home directories are preserved. */\n  async removeService(identity: string, name: string, signal?: AbortSignal): Promise<boolean> {\n    const user = this.user(identity);\n    const boot = await this.readyUser(user, identity, signal);\n    const result = (await this.controller(boot, user, \"remove\", [name], signal)) as {\n      removed?: boolean;\n    };\n    if (result.removed === true) await this.refreshServices(boot, user, identity, signal);\n    return result.removed === true;\n  }\n\n  /** Reads a bounded tail of one service log. */\n  async serviceLogs(\n    identity: string,\n    input: LakeboxServiceLogsRequest,\n    signal?: AbortSignal,\n  ): Promise<{ log: string }> {\n    const request = lakeboxServiceLogsRequestSchema.parse(input);\n    const user = this.user(identity);\n    const entry = await this.entry(signal);\n    if (!entry || normalizeLakeboxStatus(entry.status) !== \"running\") return { log: \"\" };\n    const boot = await this.readyUser(user, identity, signal);\n    const result = (await this.controller(\n      boot,\n      user,\n      \"logs\",\n      [request.name, String(request.maxLines), String(request.maxChars)],\n      signal,\n    )) as { log?: string };\n    return { log: result.log ?? \"\" };\n  }\n\n  /**\n   * Returns recent metrics and keeps sampling for one lease interval. Sampling\n   * runs only while the Lakebox runs and a caller is watching, so metrics never\n   * keep an otherwise idle Lakebox awake.\n   */\n  async metricsResponse(signal?: AbortSignal): Promise<LakeboxMetricsResponse> {\n    const entry = await this.entry(signal);\n    const platformStatus: LakeboxStatus = entry ? normalizeLakeboxStatus(entry.status) : \"missing\";\n    if (platformStatus !== \"running\") {\n      this.metrics.stop();\n      return { status: platformStatus, series: [] };\n    }\n    if (!entry || !this.boot || this.boot.key !== this.bootKey(entry)) {\n      this.metrics.stop();\n      this.wake(() => this.ready());\n      return { status: \"starting\", series: [] };\n    }\n    this.leaseMetrics();\n    return {\n      status: this.productStatus(entry, platformStatus),\n      series: [...this.metrics.series()],\n    };\n  }\n\n  /** Subscribes to metrics snapshots while the Lakebox runs. */\n  subscribeMetrics(listener: (snapshot: LakeboxMetricsSnapshot) => void): () => void {\n    this.metrics.on(\"snapshot\", listener);\n    if (this.boot?.key === this.readyBootKey) this.metrics.start();\n    return () => {\n      this.metrics.off(\"snapshot\", listener);\n      this.leaseMetrics();\n    };\n  }\n\n  /**\n   * Deletes legacy per-user Lakeboxes and drops legacy ownership schemas.\n   *\n   * There is no migration: the earlier one-machine-per-user model is removed.\n   * The managed app Lakebox and Lakeboxes with other names are never touched.\n   */\n  async cleanupLegacy(pool?: LakeboxLegacyPool, signal?: AbortSignal): Promise<void> {\n    try {\n      const entries = await this.client().list(signal);\n      await Promise.all(\n        entries\n          .filter((entry) => entry.name && LEGACY_NAME.test(entry.name))\n          .map(async (entry) => {\n            await this.client().delete(entry.sandboxId, signal);\n            logger.info(\"deleted legacy per-user Lakebox\", {\n              id: entry.sandboxId,\n              name: entry.name,\n            });\n          }),\n      );\n    } catch (error) {\n      if (!isLakeboxUnavailable(error)) {\n        logger.warn(\"legacy Lakebox cleanup failed\", { error: errorUtils.toError(error) });\n      }\n    }\n    if (!pool) return;\n    try {\n      const schemas = await pool.query(\n        \"SELECT nspname FROM pg_namespace WHERE nspname = $1 OR starts_with(nspname, $2)\",\n        [LEGACY_SCHEMA_PREFIX, `${LEGACY_SCHEMA_PREFIX}_`],\n      );\n      for (const row of schemas.rows) {\n        const schema = String(row.nspname);\n        await pool.query(`DROP SCHEMA IF EXISTS \"${schema.replaceAll('\"', '\"\"')}\" CASCADE`);\n        logger.info(\"dropped legacy Lakebox ownership schema\", { schema });\n      }\n    } catch (error) {\n      logger.warn(\"legacy ownership schema cleanup failed\", { error: errorUtils.toError(error) });\n    }\n  }\n\n  /** Cancels in-flight work before teardown. */\n  abortActiveOperations(): void {\n    if (!this.shutdownController.signal.aborted) this.shutdownController.abort();\n  }\n\n  /** Closes routes, metrics, and the SSH session without changing the Lakebox. */\n  close(): Promise<void> {\n    this.abortActiveOperations();\n    this.routes.beginShutdown();\n    this.closing ??= (async () => {\n      try {\n        if (this.metricsLease) clearTimeout(this.metricsLease);\n        this.metrics.stop();\n        await this.routes.close();\n        await this.boot?.session.close();\n        this.boot = undefined;\n      } finally {\n        this.stopParentTerminationSignal();\n      }\n    })();\n    return this.closing;\n  }\n\n  private client(): LakeboxClient {\n    if (!this.api) throw new Error(\"The Lakebox runtime has no app service-principal credentials\");\n    return this.api;\n  }\n\n  private resources(): LakeboxResourceRegistry {\n    if (!this.resourceRegistry) throw new Error(\"The Lakebox runtime has no resource registry\");\n    return this.resourceRegistry;\n  }\n\n  /** Returns the managed Lakebox entry, cached briefly to keep routes cheap. */\n  private async entry(signal?: AbortSignal, fresh = false): Promise<LakeboxEntry | undefined> {\n    if (!fresh && this.cached && Date.now() - this.cached.at < ENTRY_TTL_MS) {\n      return this.cached.entry;\n    }\n    const entry = await this.resources().read(this.client(), signal);\n    this.cached = { ...(entry ? { entry } : {}), at: Date.now() };\n    if (!entry || normalizeLakeboxStatus(entry.status) !== \"running\") {\n      this.readyBootKey = undefined;\n    }\n    if (this.boot && (!entry || this.bootKey(entry) !== this.boot.key)) await this.discardBoot();\n    return entry;\n  }\n\n  private bootKey(entry: LakeboxEntry): string {\n    return `${entry.sandboxId}\\0${entry.lastStartTime ?? \"\"}`;\n  }\n\n  private productStatus(entry: LakeboxEntry | undefined, status: LakeboxStatus): LakeboxStatus {\n    return entry && status === \"running\" && this.readyBootKey !== this.bootKey(entry)\n      ? \"starting\"\n      : status;\n  }\n\n  /** Serializes create, start, connect, and bootstrap for the current boot. */\n  private ready(signal?: AbortSignal, explicit = false): Promise<Boot> {\n    const current = this.boot;\n    if (current && this.cached?.entry && this.bootKey(this.cached.entry) === current.key) {\n      if (Date.now() - this.cached.at < ENTRY_TTL_MS) return Promise.resolve(current);\n    }\n    this.converging ??= this.converge(signal, explicit).finally(() => {\n      this.converging = undefined;\n    });\n    return this.converging;\n  }\n\n  private async converge(signal: AbortSignal | undefined, explicit: boolean): Promise<Boot> {\n    const operationSignal = signal\n      ? AbortSignal.any([signal, this.shutdownController.signal])\n      : this.shutdownController.signal;\n    let entry = await this.entry(operationSignal, true);\n    if (!entry || normalizeLakeboxStatus(entry.status) !== \"running\") {\n      if (!this.config.auto && !explicit) {\n        throw new Error(\n          `Lakebox is ${entry ? entry.status : \"not created\"}; start it explicitly because auto is false`,\n        );\n      }\n    }\n    entry ??= await this.resources().getOrCreate(this.client(), operationSignal);\n    if (lakeboxIdleTimeoutSeconds(entry.idleTimeout) !== this.config.idleTimeoutSeconds) {\n      entry = await this.client().setIdleTimeout(\n        entry.sandboxId,\n        this.config.idleTimeoutSeconds,\n        operationSignal,\n      );\n    }\n    entry = await ensureLakeboxRunning(this.client(), entry, operationSignal);\n    this.cached = { entry, at: Date.now() };\n    const key = this.bootKey(entry);\n    if (this.boot?.key === key) return this.boot;\n    await this.discardBoot();\n    const session = await this.connect(entry, operationSignal);\n    const boot: Boot = {\n      key,\n      entry,\n      session,\n      users: new Map(),\n      services: new Map(),\n      starting: new Map(),\n    };\n    try {\n      const restored = await this.bootstrap(session, operationSignal);\n      this.metrics.stop();\n      this.metrics.seed((await this.admin(session, [\"metrics\"], operationSignal)).stdout);\n      this.boot = boot;\n      this.readyBootKey = key;\n      this.watchIdle();\n      if (this.metrics.listenerCount(\"snapshot\") > 0) this.metrics.start();\n      for (const hash of restored) void this.restoreUser(boot, hash);\n      return boot;\n    } catch (error) {\n      await session.close();\n      throw error;\n    }\n  }\n\n  private async connect(entry: LakeboxEntry, signal: AbortSignal): Promise<SshSession> {\n    const api = this.client();\n    const scope = await api.workspaceScope();\n    const key = await this.keys.ensureRegistered(api, SSH_KEY_OWNER, signal);\n    const gatewayHost = entry.gatewayHost ?? key.gatewayHost;\n    if (!gatewayHost) throw new Error(\"Databricks Lakebox did not return an SSH gateway host\");\n    const port = this.config.gatewayPort;\n    const knownHost = await this.keys.knownHost(scope, SSH_KEY_OWNER, gatewayHost, port);\n    const session = new SshSession({\n      host: gatewayHost,\n      port,\n      username: entry.sandboxId,\n      privateKey: key.privateKey,\n      privateKeyPath: key.privateKeyPath,\n      knownHostsPath: this.keys.knownHostsPath(scope, SSH_KEY_OWNER, gatewayHost, port),\n      connectTimeoutMs: this.config.connectTimeoutMs,\n      sshTransport: this.config.sshTransport,\n      ssh2Patch: this.config.ssh2Patch,\n      ...(knownHost ? { knownHost } : {}),\n      rememberHost: (fingerprint, hostKey) =>\n        this.keys.rememberHost(scope, SSH_KEY_OWNER, gatewayHost, port, fingerprint, hostKey),\n    });\n    try {\n      await session.connect();\n      return session;\n    } catch (error) {\n      await session.close();\n      throw error;\n    }\n  }\n\n  /** Runs the fixed privileged bootstrap and returns the restored user hashes. */\n  private async bootstrap(session: SshSession, signal: AbortSignal): Promise<string[]> {\n    const helpers = Object.entries(HELPERS).map(\n      ([name, content]) => `${name}=${Buffer.from(content).toString(\"base64\")}`,\n    );\n    const result = await this.admin(session, [\"bootstrap\", ...helpers], signal);\n    return result.stdout\n      .split(\"\\n\")\n      .filter((line) => line.startsWith(\"__LAKEBOX_USER__=\"))\n      .map((line) => line.slice(\"__LAKEBOX_USER__=\".length).trim());\n  }\n\n  private async admin(\n    session: SshSession,\n    args: readonly string[],\n    signal?: AbortSignal,\n  ): Promise<{ stdout: string }> {\n    const encoded = Buffer.from(ADMIN_SCRIPT).toString(\"base64\");\n    const result = await session.executePrivileged(\n      \"sh\",\n      [\"-c\", `printf %s '${encoded}' | base64 -d | sh -s -- ${args.map(shellQuote).join(\" \")}`],\n      { timeoutMs: SETUP_TIMEOUT_MS, ...(signal ? { signal } : {}) },\n    ).result;\n    if (!result.success) {\n      throw new Error(\n        `Lakebox ${args[0]} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`}`,\n      );\n    }\n    return result;\n  }\n\n  /** Marks activity, readies the current boot, and converges the user's account. */\n  private async readyUser(\n    user: LakeboxUser,\n    identity: string,\n    signal?: AbortSignal,\n  ): Promise<Boot> {\n    this.touch();\n    const boot = await this.ready(signal);\n    await this.convergeUser(boot, user, identity, signal);\n    return boot;\n  }\n\n  /** Creates or verifies the user's account once per boot. */\n  private convergeUser(\n    boot: Boot,\n    user: LakeboxUser,\n    identity: string,\n    signal?: AbortSignal,\n  ): Promise<void> {\n    let converged = boot.users.get(user.hash);\n    if (!converged) {\n      const digest = createHash(\"sha256\").update(identity.trim().toLowerCase()).digest(\"hex\");\n      converged = this.admin(\n        boot.session,\n        [\"ensure-user\", user.hash, String(user.uid), digest],\n        signal,\n      ).then(() => undefined);\n      boot.users.set(user.hash, converged);\n      converged.catch(() => boot.users.delete(user.hash));\n    }\n    return converged;\n  }\n\n  private async restoreUser(boot: Boot, hash: string): Promise<void> {\n    const user = { name: `lakebox-${hash}`, home: `/home/lakebox-${hash}` };\n    boot.users.set(hash, Promise.resolve());\n    try {\n      const result = await boot.session.execute(\"python3\", [CONTROLLER, \"start-all\"], {\n        user,\n        timeoutMs: SETUP_TIMEOUT_MS,\n        signal: this.shutdownController.signal,\n      }).result;\n      if (!result.success) throw new Error(result.stderr.trim() || `exit ${result.exitCode}`);\n    } catch (error) {\n      if (this.shutdownController.signal.aborted) return;\n      logger.warn(\"Lakebox service restore failed\", {\n        user: hash,\n        error: errorUtils.toError(error),\n      });\n    }\n  }\n\n  private async controller(\n    boot: Boot,\n    user: LakeboxUser,\n    command: string,\n    args: readonly string[],\n    signal?: AbortSignal,\n  ): Promise<unknown> {\n    const result = await boot.session.execute(\"python3\", [CONTROLLER, command, ...args], {\n      user,\n      timeoutMs: SETUP_TIMEOUT_MS,\n      ...(signal ? { signal } : {}),\n    }).result;\n    if (!result.success) {\n      throw new Error(\n        `Lakebox service ${command} failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`,\n      );\n    }\n    return JSON.parse(result.stdout) as unknown;\n  }\n\n  private async runService(\n    boot: Boot,\n    user: LakeboxUser,\n    definition: LakeboxControllerDefinition,\n    signal?: AbortSignal,\n  ): Promise<LakeboxService> {\n    const key = `${user.hash}\\0${definition.name}`;\n    const pending = boot.starting.get(key);\n    if (pending) return pending;\n    const operation = (async () => {\n      if (definition.kind === \"desktop\") {\n        boot.desktop ??= this.admin(boot.session, [\"desktop-prerequisites\"], signal).then(\n          () => undefined,\n        );\n        boot.desktop.catch(() => {\n          boot.desktop = undefined;\n        });\n        await boot.desktop;\n      }\n      await this.admin(\n        boot.session,\n        [\"allow-port\", String(user.uid), String(definition.port)],\n        signal,\n      );\n      const started = LakeboxControllerServiceSchema.parse(\n        await this.controller(boot, user, \"start\", [definition.name], signal),\n      );\n      this.cacheService(boot, user, started);\n      return toLakeboxService(started, user, this.config.routePrefix);\n    })().finally(() => boot.starting.delete(key));\n    boot.starting.set(key, operation);\n    return operation;\n  }\n\n  private async refreshServices(\n    boot: Boot,\n    user: LakeboxUser,\n    identity: string,\n    signal?: AbortSignal,\n  ): Promise<Map<string, LakeboxControllerService>> {\n    await this.convergeUser(boot, user, identity, signal);\n    const response = (await this.controller(boot, user, \"list\", [], signal)) as {\n      services?: unknown[];\n    };\n    const services = new Map(\n      (response.services ?? []).map((service) => {\n        const parsed = LakeboxControllerServiceSchema.parse(service);\n        return [parsed.name, parsed] as const;\n      }),\n    );\n    boot.services.set(user.hash, services);\n    this.lastServices.set(user.hash, services);\n    const observedAt = new Date().toISOString();\n    this.lastServicesObservedAt.set(user.hash, observedAt);\n    await this.persistServiceSnapshot(boot.entry, user, services, observedAt);\n    return services;\n  }\n\n  private cacheService(boot: Boot, user: LakeboxUser, service: LakeboxControllerService): void {\n    const services = boot.services.get(user.hash) ?? new Map<string, LakeboxControllerService>();\n    services.set(service.name, service);\n    boot.services.set(user.hash, services);\n    this.lastServices.set(user.hash, services);\n    const observedAt = new Date().toISOString();\n    this.lastServicesObservedAt.set(user.hash, observedAt);\n    void this.persistServiceSnapshot(boot.entry, user, services, observedAt);\n  }\n\n  private async serviceListing(\n    identity: string,\n    user: LakeboxUser,\n    entry: LakeboxEntry | undefined,\n    status: LakeboxStatus,\n    signal?: AbortSignal,\n  ): Promise<ServiceListing> {\n    if (!entry || status === \"missing\") {\n      return { services: this.idleServices(user), stale: false };\n    }\n    if (status === \"running\" && this.boot?.key === this.bootKey(entry)) {\n      const services = await this.refreshServices(this.boot, user, identity, signal);\n      return { services: this.withBuiltIns(user, services), stale: false };\n    }\n    const memory = this.lastServices.get(user.hash);\n    if (memory) {\n      const observedAt = this.lastServicesObservedAt.get(user.hash);\n      const services =\n        status === \"running\"\n          ? memory\n          : stoppedSnapshotServices({\n              observedAt: observedAt ?? new Date().toISOString(),\n              definitions: [...memory.values()].map((service) => service.definition),\n            });\n      return {\n        services: this.withBuiltIns(user, services),\n        stale: true,\n        ...(observedAt ? { observedAt } : {}),\n      };\n    }\n    const snapshot = await this.serviceSnapshots?.read(entry.sandboxId, user.hash);\n    return snapshot\n      ? {\n          services: this.withBuiltIns(user, stoppedSnapshotServices(snapshot)),\n          stale: true,\n          observedAt: snapshot.observedAt,\n        }\n      : { services: this.idleServices(user), stale: true };\n  }\n\n  private async persistServiceSnapshot(\n    entry: LakeboxEntry,\n    user: LakeboxUser,\n    services: ReadonlyMap<string, LakeboxControllerService>,\n    observedAt: string,\n  ): Promise<void> {\n    await this.serviceSnapshots?.write(entry.sandboxId, user.hash, {\n      observedAt,\n      definitions: [...services.values()].map((service) => service.definition),\n    });\n  }\n\n  private withBuiltIns(\n    user: LakeboxUser,\n    services: ReadonlyMap<string, LakeboxControllerService>,\n  ): LakeboxService[] {\n    const builtIns = LAKEBOX_BUILT_IN_SERVICES.map(({ name }) => {\n      const saved = services.get(name);\n      return saved\n        ? toLakeboxService(saved, user, this.config.routePrefix)\n        : idleBuiltInService(name, user, this.config.routePrefix);\n    });\n    const custom = [...services.values()]\n      .filter((service) => !LAKEBOX_BUILT_IN_SERVICES.some(({ name }) => name === service.name))\n      .map((service) => toLakeboxService(service, user, this.config.routePrefix));\n    return [...builtIns, ...custom];\n  }\n\n  private idleServices(user: LakeboxUser): LakeboxService[] {\n    return LAKEBOX_BUILT_IN_SERVICES.map(({ name }) =>\n      idleBuiltInService(name as LakeboxBuiltInServiceName, user, this.config.routePrefix),\n    );\n  }\n\n  /** Resolves one routed request, waking the Lakebox or service in the background. */\n  private async resolveRoute(user: LakeboxUser, name: string): Promise<LakeboxRouteResolution> {\n    this.touch();\n    const entry = await this.entry();\n    const running = entry && normalizeLakeboxStatus(entry.status) === \"running\";\n    const boot = this.boot;\n    if (!running || !boot || boot.key !== this.bootKey(entry)) {\n      if (!this.config.auto) return { kind: \"missing\" };\n      this.wake(() => this.ready());\n      return { kind: \"loading\" };\n    }\n    const identity = this.routedIdentities.get(user.hash);\n    if (!identity) return { kind: \"missing\" };\n    let service = boot.services.get(user.hash)?.get(name);\n    if (!service) service = (await this.refreshServices(boot, user, identity)).get(name);\n    const builtIn = lakeboxBuiltInServiceNameSchema.safeParse(name);\n    if (!service && !builtIn.success) return { kind: \"missing\" };\n    if (service?.state === \"ready\") {\n      return { kind: \"ready\", session: boot.session, route: serviceRoute(service.definition) };\n    }\n    if (service?.state === \"error\" && !boot.starting.has(`${user.hash}\\0${name}`)) {\n      return { kind: \"failed\", message: service.error ?? \"the service failed to start\" };\n    }\n    const definition = service?.definition ?? builtInDefinition(builtIn.data!, user);\n    this.wake(async () => {\n      if (!service) await this.controller(boot, user, \"put\", [encode(definition)]);\n      await this.runService(boot, user, definition);\n    });\n    return { kind: \"loading\" };\n  }\n\n  private markUnavailable(user: LakeboxUser, name: string): void {\n    this.boot?.services.get(user.hash)?.delete(name);\n    this.cached = undefined;\n  }\n\n  private wake(action: () => Promise<unknown>): void {\n    if (this.waking) return;\n    this.waking = action()\n      .catch((error) => logger.warn(\"Lakebox wake failed\", { error: errorUtils.toError(error) }))\n      .finally(() => {\n        this.waking = undefined;\n      });\n  }\n\n  private async readMetrics(signal: AbortSignal): Promise<string> {\n    const boot = this.boot;\n    if (!boot) throw new Error(\"Lakebox is not running\");\n    try {\n      return (await this.admin(boot.session, [\"metrics\"], signal)).stdout;\n    } catch (error) {\n      this.cached = undefined;\n      throw error;\n    }\n  }\n\n  private leaseMetrics(): void {\n    if (!this.boot) return;\n    this.metrics.start();\n    if (this.metricsLease) clearTimeout(this.metricsLease);\n    this.metricsLease = setTimeout(() => {\n      if (this.metrics.listenerCount(\"snapshot\") === 0) this.metrics.stop();\n    }, METRICS_LEASE_MS);\n    this.metricsLease.unref?.();\n  }\n\n  /**\n   * Releases the SSH session after the idle timeout without commands, service\n   * operations, routed traffic, open streams, or metrics watchers. An open\n   * session counts as activity for the platform watchdog, so releasing it lets\n   * the platform stop the Lakebox after its own idle timeout. The next request\n   * reconnects.\n   */\n  private watchIdle(): void {\n    if (this.idleTimer) clearInterval(this.idleTimer);\n    this.idleTimer = setInterval(() => {\n      const idleMs = Date.now() - this.lastActivity;\n      if (\n        !this.boot ||\n        this.converging ||\n        idleMs < this.config.idleTimeoutSeconds * 1_000 ||\n        this.activeCommands > 0 ||\n        this.boot.starting.size > 0 ||\n        this.routes.activeConnections() > 0 ||\n        this.metrics.listenerCount(\"snapshot\") > 0\n      ) {\n        if (this.routes.activeConnections() > 0 || this.activeCommands > 0) this.touch();\n        return;\n      }\n      logger.info(\"releasing idle Lakebox session\", { idleSeconds: Math.round(idleMs / 1_000) });\n      void this.discardBoot();\n    }, IDLE_CHECK_MS);\n    this.idleTimer.unref?.();\n  }\n\n  private touch(): void {\n    this.lastActivity = Date.now();\n  }\n\n  private async discardBoot(): Promise<void> {\n    if (this.idleTimer) clearInterval(this.idleTimer);\n    this.idleTimer = undefined;\n    const boot = this.boot;\n    this.boot = undefined;\n    this.metrics.stop();\n    await this.routes.closeBridges();\n    await boot?.session.close().catch(() => undefined);\n  }\n}\n\nfunction encode(definition: LakeboxControllerDefinition): string {\n  return Buffer.from(JSON.stringify(definition)).toString(\"base64\");\n}\n\nfunction shellQuote(value: string): string {\n  return `'${value.replaceAll(\"'\", \"'\\\\''\")}'`;\n}\n\n/** Returns whether an error means the managed Lakebox no longer exists. */\nexport function isLakeboxMissing(error: unknown): boolean {\n  return error instanceof LakeboxApiError && error.status === 404;\n}\n"]}