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

package/lib/src/_resource-registry.js

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

package/lib/src/_service-snapshots.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { type LakeboxControllerService } from "./services.ts";
+export declare const LakeboxServiceSnapshotSchema: z.ZodObject<{
+    observedAt: z.ZodString;
+    definitions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            desktop: "desktop";
+            image: "image";
+        }>;
+        image: z.ZodOptional<z.ZodString>;
+        pull: z.ZodDefault<z.ZodEnum<{
+            missing: "missing";
+            always: "always";
+        }>>;
+        command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+        workingDirectory: z.ZodOptional<z.ZodString>;
+        mounts: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            target: z.ZodString;
+            readOnly: z.ZodBoolean;
+        }, z.core.$strict>>;
+        port: z.ZodNumber;
+        readiness: z.ZodEnum<{
+            tcp: "tcp";
+            none: "none";
+        }>;
+        readySeconds: z.ZodNumber;
+        autostart: z.ZodBoolean;
+        route: z.ZodBoolean;
+        stripPrefix: z.ZodBoolean;
+        openPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LakeboxServiceSnapshot = z.infer<typeof LakeboxServiceSnapshotSchema>;
+/** Projects saved definitions into explicitly non-live stopped service records. */
+export declare function stoppedSnapshotServices(snapshot: LakeboxServiceSnapshot): Map<string, LakeboxControllerService>;
+interface SnapshotCache {
+    generateKey(parts: (string | number | object)[], userKey: string): string;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, options?: {
+        ttl?: number;
+    }): Promise<void>;
+}
+/** Best-effort persistent snapshots backed by AppKit's configured cache. */
+export declare class LakeboxServiceSnapshots {
+    private readonly cache;
+    constructor(cache?: () => SnapshotCache);
+    read(lakeboxId: string, userHash: string): Promise<LakeboxServiceSnapshot | undefined>;
+    write(lakeboxId: string, userHash: string, snapshot: LakeboxServiceSnapshot): Promise<void>;
+    private key;
+}
+export {};

package/lib/src/_service-snapshots.js

@@ -0,0 +1,65 @@
+import { CacheManager } from "@databricks/appkit";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { z } from "zod";
+import { LakeboxControllerDefinitionSchema } from "./services.js";
+const CACHE_NAMESPACE = "appkit-lakebox:service-snapshot";
+const SNAPSHOT_TTL_SECONDS = 365 * 24 * 60 * 60;
+const logger = log.logger("appkit-lakebox:service-snapshot");
+export const LakeboxServiceSnapshotSchema = z
+    .object({
+    observedAt: z.string().datetime().describe("Time the controller last returned this list."),
+    definitions: z
+        .array(LakeboxControllerDefinitionSchema)
+        .describe("Last observed saved service definitions; never authoritative live state."),
+})
+    .strict()
+    .describe("Best-effort last-known Lakebox service definitions for an unavailable machine.");
+/** Projects saved definitions into explicitly non-live stopped service records. */
+export function stoppedSnapshotServices(snapshot) {
+    return new Map(snapshot.definitions.map((definition) => [
+        definition.name,
+        { name: definition.name, state: "stopped", definition },
+    ]));
+}
+/** Best-effort persistent snapshots backed by AppKit's configured cache. */
+export class LakeboxServiceSnapshots {
+    cache;
+    constructor(cache = () => CacheManager.getInstanceSync()) {
+        this.cache = cache;
+    }
+    async read(lakeboxId, userHash) {
+        try {
+            const value = await this.cache().get(this.key(lakeboxId, userHash));
+            if (value === null)
+                return undefined;
+            const parsed = LakeboxServiceSnapshotSchema.safeParse(value);
+            if (parsed.success)
+                return parsed.data;
+            logger.warn("ignored invalid cached service snapshot", { lakeboxId, userHash });
+        }
+        catch (error) {
+            logger.warn("unable to read cached service snapshot", {
+                lakeboxId,
+                userHash,
+                error: errorUtils.toError(error),
+            });
+        }
+        return undefined;
+    }
+    async write(lakeboxId, userHash, snapshot) {
+        try {
+            await this.cache().set(this.key(lakeboxId, userHash), LakeboxServiceSnapshotSchema.parse(snapshot), { ttl: SNAPSHOT_TTL_SECONDS });
+        }
+        catch (error) {
+            logger.warn("unable to cache service snapshot", {
+                lakeboxId,
+                userHash,
+                error: errorUtils.toError(error),
+            });
+        }
+    }
+    key(lakeboxId, userHash) {
+        return this.cache().generateKey([CACHE_NAMESPACE, lakeboxId], userHash);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/config.d.ts

@@ -0,0 +1,40 @@
+import type { BasePluginConfig } from "@databricks/appkit";
+import { z } from "zod";
+export declare const LakeboxPluginConfigSchema: z.ZodObject<{
+    auto: z.ZodDefault<z.ZodBoolean>;
+    application: z.ZodString;
+    idleTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    routePrefix: z.ZodDefault<z.ZodString>;
+    gatewayPort: z.ZodDefault<z.ZodNumber>;
+    connectTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    commandTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    metricsIntervalSeconds: z.ZodDefault<z.ZodNumber>;
+    sshTransport: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        openssh: "openssh";
+        ssh2: "ssh2";
+    }>>>;
+    ssh2Patch: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
+        true: "true";
+        false: "false";
+        auto: "auto";
+    }>>>;
+    keyDirectory: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SerializableLakeboxPluginConfig = z.input<typeof LakeboxPluginConfigSchema>;
+export type ResolvedLakeboxPluginConfig = z.output<typeof LakeboxPluginConfigSchema>;
+/**
+ * Configuration accepted by the Lakebox AppKit plugin.
+ *
+ * Pass a shared runtime when the plugin and the Mastra workspace resolver must
+ * use the same sessions, routes, and metrics.
+ */
+export type LakeboxPluginConfig = BasePluginConfig & Partial<SerializableLakeboxPluginConfig> & {
+    runtime?: import("./runtime.ts").LakeboxRuntime;
+};
+/**
+ * Resolves defaults through configUtils and removes AppKit-only fields.
+ *
+ * @throws A Zod validation error when a field has an invalid type or range.
+ */
+export declare function resolveLakeboxPluginConfig(config?: LakeboxPluginConfig): ResolvedLakeboxPluginConfig;

package/lib/src/config.js

@@ -0,0 +1,86 @@
+import { basename } from "node:path";
+import { configUtils, projectUtils } from "@dbx-tools/core";
+import { Ssh2PatchModeSchema, SshTransportModeSchema } from "@dbx-tools/lakebox/transport";
+import { LAKEBOX_DEFAULT_ROUTE_PREFIX } from "@dbx-tools/shared-lakebox";
+import { z } from "zod";
+const APPLICATION_CONFIG_KEY = "LAKEBOX_APPLICATION";
+const IDLE_TIMEOUT_CONFIG_KEY = "LAKEBOX_IDLE_TIMEOUT_SECONDS";
+const SSH_TRANSPORT_CONFIG_KEY = "LAKEBOX_SSH_TRANSPORT";
+const SSH2_PATCH_CONFIG_KEY = "LAKEBOX_SSH_SSH2_PATCH";
+export const LakeboxPluginConfigSchema = z
+    .object({
+    auto: z
+        .boolean()
+        .default(true)
+        .describe("Whether commands, services, and routes create or start the app Lakebox on demand. Defaults to true."),
+    application: z
+        .string()
+        .trim()
+        .min(1)
+        .describe(`Stable application key for the persisted Lakebox resource ID. Defaults to ${configUtils.name(APPLICATION_CONFIG_KEY)}, then DATABRICKS_APP_NAME, then the project directory name.`),
+    idleTimeoutSeconds: z
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .default(3_600)
+        .describe(`Platform idle timeout that stops the Lakebox after inactivity, from 60 to 86400 seconds. Defaults to 3600; configure with ${configUtils.name(IDLE_TIMEOUT_CONFIG_KEY)}.`),
+    routePrefix: z
+        .string()
+        .startsWith("/")
+        .default(LAKEBOX_DEFAULT_ROUTE_PREFIX)
+        .describe("AppKit root path for user service routes. Defaults to /lakebox."),
+    gatewayPort: z
+        .number()
+        .int()
+        .min(1)
+        .max(65535)
+        .default(2222)
+        .describe("Lakebox SSH gateway port. Defaults to 2222."),
+    connectTimeoutMs: z
+        .number()
+        .int()
+        .positive()
+        .default(30_000)
+        .describe("SSH connection timeout in milliseconds. Defaults to 30000."),
+    commandTimeoutMs: z
+        .number()
+        .int()
+        .positive()
+        .default(120_000)
+        .describe("Default command timeout in milliseconds. Defaults to 120000."),
+    metricsIntervalSeconds: z
+        .number()
+        .int()
+        .min(1)
+        .max(300)
+        .default(5)
+        .describe("Interval between metrics samples while the Lakebox runs. Defaults to 5."),
+    sshTransport: SshTransportModeSchema.describe(`SSH transport: auto, openssh, or ssh2. Configure with ${configUtils.name(SSH_TRANSPORT_CONFIG_KEY)}.`),
+    ssh2Patch: Ssh2PatchModeSchema.describe(`ssh2 missing-exec-reply workaround: auto, true, or false. Configure with ${configUtils.name(SSH2_PATCH_CONFIG_KEY)}.`),
+    keyDirectory: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Server-side directory for the app SSH key and gateway host keys."),
+})
+    .strict()
+    .describe("Serializable Lakebox AppKit plugin configuration.");
+/**
+ * Resolves defaults through configUtils and removes AppKit-only fields.
+ *
+ * @throws A Zod validation error when a field has an invalid type or range.
+ */
+export function resolveLakeboxPluginConfig(config = {}) {
+    const { runtime: _runtime, name: _name, host: _host, context: _context, telemetry: _telemetry, streamConfig: _stream, application, idleTimeoutSeconds, sshTransport, ssh2Patch, ...serializable } = config;
+    return LakeboxPluginConfigSchema.parse({
+        ...serializable,
+        application: configUtils.string(application, APPLICATION_CONFIG_KEY) ??
+            configUtils.string(undefined, "DATABRICKS_APP_NAME", configUtils.ENV_ONLY) ??
+            basename(projectUtils.root() ?? process.cwd()),
+        idleTimeoutSeconds: configUtils.positiveInt(idleTimeoutSeconds, IDLE_TIMEOUT_CONFIG_KEY, 3_600),
+        sshTransport: configUtils.string(sshTransport, SSH_TRANSPORT_CONFIG_KEY),
+        ssh2Patch: configUtils.string(ssh2Patch, SSH2_PATCH_CONFIG_KEY),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["import { basename } from \"node:path\";\nimport type { BasePluginConfig } from \"@databricks/appkit\";\nimport { configUtils, projectUtils } from \"@dbx-tools/core\";\nimport { Ssh2PatchModeSchema, SshTransportModeSchema } from \"@dbx-tools/lakebox/transport\";\nimport { LAKEBOX_DEFAULT_ROUTE_PREFIX } from \"@dbx-tools/shared-lakebox\";\nimport { z } from \"zod\";\n\nconst APPLICATION_CONFIG_KEY = \"LAKEBOX_APPLICATION\";\nconst IDLE_TIMEOUT_CONFIG_KEY = \"LAKEBOX_IDLE_TIMEOUT_SECONDS\";\nconst SSH_TRANSPORT_CONFIG_KEY = \"LAKEBOX_SSH_TRANSPORT\";\nconst SSH2_PATCH_CONFIG_KEY = \"LAKEBOX_SSH_SSH2_PATCH\";\n\nexport const LakeboxPluginConfigSchema = z\n  .object({\n    auto: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"Whether commands, services, and routes create or start the app Lakebox on demand. Defaults to true.\",\n      ),\n    application: z\n      .string()\n      .trim()\n      .min(1)\n      .describe(\n        `Stable application key for the persisted Lakebox resource ID. Defaults to ${configUtils.name(APPLICATION_CONFIG_KEY)}, then DATABRICKS_APP_NAME, then the project directory name.`,\n      ),\n    idleTimeoutSeconds: z\n      .number()\n      .int()\n      .min(60)\n      .max(86_400)\n      .default(3_600)\n      .describe(\n        `Platform idle timeout that stops the Lakebox after inactivity, from 60 to 86400 seconds. Defaults to 3600; configure with ${configUtils.name(IDLE_TIMEOUT_CONFIG_KEY)}.`,\n      ),\n    routePrefix: z\n      .string()\n      .startsWith(\"/\")\n      .default(LAKEBOX_DEFAULT_ROUTE_PREFIX)\n      .describe(\"AppKit root path for user service routes. Defaults to /lakebox.\"),\n    gatewayPort: z\n      .number()\n      .int()\n      .min(1)\n      .max(65535)\n      .default(2222)\n      .describe(\"Lakebox SSH gateway port. Defaults to 2222.\"),\n    connectTimeoutMs: z\n      .number()\n      .int()\n      .positive()\n      .default(30_000)\n      .describe(\"SSH connection timeout in milliseconds. Defaults to 30000.\"),\n    commandTimeoutMs: z\n      .number()\n      .int()\n      .positive()\n      .default(120_000)\n      .describe(\"Default command timeout in milliseconds. Defaults to 120000.\"),\n    metricsIntervalSeconds: z\n      .number()\n      .int()\n      .min(1)\n      .max(300)\n      .default(5)\n      .describe(\"Interval between metrics samples while the Lakebox runs. Defaults to 5.\"),\n    sshTransport: SshTransportModeSchema.describe(\n      `SSH transport: auto, openssh, or ssh2. Configure with ${configUtils.name(SSH_TRANSPORT_CONFIG_KEY)}.`,\n    ),\n    ssh2Patch: Ssh2PatchModeSchema.describe(\n      `ssh2 missing-exec-reply workaround: auto, true, or false. Configure with ${configUtils.name(SSH2_PATCH_CONFIG_KEY)}.`,\n    ),\n    keyDirectory: z\n      .string()\n      .min(1)\n      .optional()\n      .describe(\"Server-side directory for the app SSH key and gateway host keys.\"),\n  })\n  .strict()\n  .describe(\"Serializable Lakebox AppKit plugin configuration.\");\n\nexport type SerializableLakeboxPluginConfig = z.input<typeof LakeboxPluginConfigSchema>;\nexport type ResolvedLakeboxPluginConfig = z.output<typeof LakeboxPluginConfigSchema>;\n\n/**\n * Configuration accepted by the Lakebox AppKit plugin.\n *\n * Pass a shared runtime when the plugin and the Mastra workspace resolver must\n * use the same sessions, routes, and metrics.\n */\nexport type LakeboxPluginConfig = BasePluginConfig &\n  Partial<SerializableLakeboxPluginConfig> & {\n    runtime?: import(\"./runtime.ts\").LakeboxRuntime;\n  };\n\n/**\n * Resolves defaults through configUtils and removes AppKit-only fields.\n *\n * @throws A Zod validation error when a field has an invalid type or range.\n */\nexport function resolveLakeboxPluginConfig(\n  config: LakeboxPluginConfig = {},\n): ResolvedLakeboxPluginConfig {\n  const {\n    runtime: _runtime,\n    name: _name,\n    host: _host,\n    context: _context,\n    telemetry: _telemetry,\n    streamConfig: _stream,\n    application,\n    idleTimeoutSeconds,\n    sshTransport,\n    ssh2Patch,\n    ...serializable\n  } = config;\n  return LakeboxPluginConfigSchema.parse({\n    ...serializable,\n    application:\n      configUtils.string(application, APPLICATION_CONFIG_KEY) ??\n      configUtils.string(undefined, \"DATABRICKS_APP_NAME\", configUtils.ENV_ONLY) ??\n      basename(projectUtils.root() ?? process.cwd()),\n    idleTimeoutSeconds: configUtils.positiveInt(idleTimeoutSeconds, IDLE_TIMEOUT_CONFIG_KEY, 3_600),\n    sshTransport: configUtils.string(sshTransport, SSH_TRANSPORT_CONFIG_KEY),\n    ssh2Patch: configUtils.string(ssh2Patch, SSH2_PATCH_CONFIG_KEY),\n  });\n}\n"]}

package/lib/src/desktop.d.ts

@@ -0,0 +1,6 @@
+/** Markup injected into the KasmVNC client page to apply dbx-tools branding. */
+export declare const desktopHtmlHead: string;
+/** Browser entry URL for the built-in KasmVNC desktop. */
+export declare function desktopOpenUrl(path: string): string;
+/** Branding environment consumed by the packaged desktop session entrypoint. */
+export declare function desktopEnvironment(): Readonly<Record<string, string>>;

package/lib/src/desktop.js

@@ -0,0 +1,88 @@
+import { brandUtils } from "@dbx-tools/shared-core";
+import { dbxToolsAssetDataUrls, dbxToolsAssetSvg } from "@dbx-tools/ui/branding/assets";
+const BRAND = brandUtils.defaultBrandContext;
+const BRAND_COLORS = BRAND.colors;
+const WALLPAPER_LOGO = dbxToolsAssetSvg.logoDark.replace("<svg ", '<svg x="500" y="378" width="600" height="135" ');
+const DBX_TOOLS_WALLPAPER = 
+// ============================================================================
+/*xml*/ `
+<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="1000" viewBox="0 0 1600 1000">
+  <defs>
+    <linearGradient id="background" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#0B161B"/>
+      <stop offset="0.55" stop-color="${BRAND_COLORS.primary}"/>
+      <stop offset="1" stop-color="${BRAND_COLORS.primaryHover}"/>
+    </linearGradient>
+    <pattern id="grid" width="64" height="64" patternUnits="userSpaceOnUse">
+      <path d="M64 0H0V64" fill="none" stroke="${BRAND_COLORS.surface}" stroke-opacity="0.045"/>
+    </pattern>
+  </defs>
+  <rect width="1600" height="1000" fill="url(#background)"/>
+  <rect width="1600" height="1000" fill="url(#grid)"/>
+  <path d="M0 780C310 650 475 920 780 775s500-220 820-55v280H0Z" fill="${BRAND_COLORS.accent}" fill-opacity="0.13"/>
+  <path d="M0 835c300-125 510 105 790-10s500-170 810-65" fill="none" stroke="${BRAND_COLORS.accent}" stroke-width="4" stroke-opacity="0.7"/>
+  ${WALLPAPER_LOGO}
+  <text x="800" y="558" text-anchor="middle" fill="${BRAND_COLORS.muted}" font-family="${BRAND.typography.sans}" font-size="24" letter-spacing="5">LAKEBOX DESKTOP</text>
+</svg>
+`
+    // ============================================================================
+    .trim();
+const DBX_TOOLS_TERMINAL_ICON = 
+// ============================================================================
+/*xml*/ `
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
+  <rect x="4" y="6" width="56" height="52" rx="12" fill="${BRAND_COLORS.primary}"/>
+  <rect x="8" y="10" width="48" height="44" rx="8" fill="${BRAND_COLORS.primaryHover}"/>
+  <path d="m18 23 9 9-9 9" fill="none" stroke="${BRAND_COLORS.surface}" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M34 41h12" fill="none" stroke="${BRAND_COLORS.accent}" stroke-width="4" stroke-linecap="round"/>
+</svg>
+`
+    // ============================================================================
+    .trim();
+const DESKTOP_BRAND_HEAD = 
+// ============================================================================
+/*html*/ `
+<style id="dbx-tools-desktop-brand">
+html,body{width:100%;max-width:100%;height:100%;max-height:100%;min-width:0;min-height:0;overflow:hidden}
+body{position:fixed;inset:0;width:var(--dbx-tools-viewport-width,100vw);height:var(--dbx-tools-viewport-height,100dvh)}
+#noVNC_container{width:100%!important;max-width:100%;height:100%!important;max-height:100%;overflow:hidden}
+.noVNC_logo,h1.noVNC_logo,a[title="KasmVNC Learn More"]{display:none!important}
+#noVNC_fallback_errormsg{overflow-wrap:anywhere}
+</style>
+<link data-dbx-tools-desktop-icon rel="icon" href="${dbxToolsAssetDataUrls.iconDark}">
+<script id="dbx-tools-kasm-mobile-guard">(()=>{const ignored=(error)=>error instanceof ReferenceError&&/^Can't find variable: W[0-9A-F]{32}$/.test(error.message);window.addEventListener("error",(event)=>{if(ignored(event.error)){event.preventDefault();event.stopImmediatePropagation()}},true);window.addEventListener("unhandledrejection",(event)=>{if(ignored(event.reason)){event.preventDefault();event.stopImmediatePropagation()}},true);let timer;const sync=()=>{const viewport=window.visualViewport;document.documentElement.style.setProperty("--dbx-tools-viewport-width",String(Math.round(viewport?.width??window.innerWidth))+"px");document.documentElement.style.setProperty("--dbx-tools-viewport-height",String(Math.round(viewport?.height??window.innerHeight))+"px");window.dispatchEvent(new Event("resize"))};const schedule=()=>{clearTimeout(timer);sync();setTimeout(sync,250);timer=setTimeout(sync,750)};window.visualViewport?.addEventListener("resize",schedule);window.visualViewport?.addEventListener("scroll",schedule);window.addEventListener("orientationchange",schedule);window.addEventListener("pageshow",schedule);document.readyState==="loading"?document.addEventListener("DOMContentLoaded",schedule,{once:true}):schedule()})();</script>
+<script id="dbx-tools-desktop-brand-script">(()=>{const icon=${JSON.stringify(dbxToolsAssetDataUrls.iconDark)};const rewrite=(root)=>{if(root.nodeType===Node.TEXT_NODE){if(root.nodeValue?.includes("KasmVNC"))root.nodeValue=root.nodeValue.replaceAll("KasmVNC","dbx tools Desktop");return}const walker=document.createTreeWalker(root,NodeFilter.SHOW_TEXT);let node;while(node=walker.nextNode())if(node.nodeValue?.includes("KasmVNC"))node.nodeValue=node.nodeValue.replaceAll("KasmVNC","dbx tools Desktop")};const apply=()=>{document.title="dbx tools Desktop";for(const link of document.querySelectorAll('link[rel~="icon"],link[rel="apple-touch-icon"]'))link.setAttribute("href",icon);if(document.body)rewrite(document.body)};if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",apply,{once:true});else apply();new MutationObserver((entries)=>{for(const entry of entries){if(entry.type==="characterData")rewrite(entry.target);else for(const node of entry.addedNodes)rewrite(node)}}).observe(document.documentElement,{childList:true,subtree:true,characterData:true})})();</script>
+`
+    // ============================================================================
+    .trim();
+/** Markup injected into the KasmVNC client page to apply dbx-tools branding. */
+export const desktopHtmlHead = DESKTOP_BRAND_HEAD;
+/** Browser entry URL for the built-in KasmVNC desktop. */
+export function desktopOpenUrl(path) {
+    const normalized = path.replace(/\/+$/, "");
+    const websocketPath = `${normalized.replace(/^\/+/, "")}/websockify`;
+    const parameters = new URLSearchParams({
+        autoconnect: "1",
+        resize: "remote",
+        show_dot: "1",
+        clipboard_seamless: "0",
+        enable_webp: "0",
+        kasmvnc_mode_preference: "-1027",
+        path: websocketPath,
+    });
+    return `${normalized}/?${parameters.toString()}`;
+}
+/** Branding environment consumed by the packaged desktop session entrypoint. */
+export function desktopEnvironment() {
+    return {
+        DBX_TOOLS_DESKTOP_WALLPAPER_BASE64: Buffer.from(DBX_TOOLS_WALLPAPER).toString("base64"),
+        DBX_TOOLS_DESKTOP_BRAND_ICON_BASE64: Buffer.from(dbxToolsAssetSvg.iconDark).toString("base64"),
+        DBX_TOOLS_DESKTOP_TERMINAL_ICON_BASE64: Buffer.from(DBX_TOOLS_TERMINAL_ICON).toString("base64"),
+        DBX_TOOLS_DESKTOP_HOMEPAGE_BASE64: Buffer.from(BRAND.links.website).toString("base64"),
+        DBX_TOOLS_DESKTOP_PRIMARY: BRAND_COLORS.primary,
+        DBX_TOOLS_DESKTOP_PRIMARY_HOVER: BRAND_COLORS.primaryHover,
+        DBX_TOOLS_DESKTOP_SURFACE: BRAND_COLORS.surface,
+        DBX_TOOLS_DESKTOP_FONT: "DejaVu Sans",
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"desktop.js","sourceRoot":"","sources":["../../src/desktop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAExF,MAAM,KAAK,GAAG,UAAU,CAAC,mBAAmB,CAAC;AAC7C,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,CAAC;AAClC,MAAM,cAAc,GAAG,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CACtD,OAAO,EACP,gDAAgD,CACjD,CAAC;AAEF,MAAM,mBAAmB;AACvB,+EAA+E;AAC/E,OAAO,CAAC;;;;;wCAK8B,YAAY,CAAC,OAAO;qCACvB,YAAY,CAAC,YAAY;;;iDAGb,YAAY,CAAC,OAAO;;;;;yEAKI,YAAY,CAAC,MAAM;+EACb,YAAY,CAAC,MAAM;IAC9F,cAAc;qDACmC,YAAY,CAAC,KAAK,kBAAkB,KAAK,CAAC,UAAU,CAAC,IAAI;;CAE7G;IACG,+EAA+E;KAC9E,IAAI,EAAE,CAAC;AAEZ,MAAM,uBAAuB;AAC3B,+EAA+E;AAC/E,OAAO,CAAC;;2DAEiD,YAAY,CAAC,OAAO;2DACpB,YAAY,CAAC,YAAY;iDACnC,YAAY,CAAC,OAAO;4CACzB,YAAY,CAAC,MAAM;;CAE9D;IACG,+EAA+E;KAC9E,IAAI,EAAE,CAAC;AAEZ,MAAM,kBAAkB;AACtB,+EAA+E;AAC/E,QAAQ,CAAC;;;;;;;;qDAQ0C,qBAAqB,CAAC,QAAQ;;+DAEpB,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC,QAAQ,CAAC;CAC5G;IACG,+EAA+E;KAC9E,IAAI,EAAE,CAAC;AAEZ,gFAAgF;AAChF,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAElD,0DAA0D;AAC1D,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC5C,MAAM,aAAa,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC;IACrE,MAAM,UAAU,GAAG,IAAI,eAAe,CAAC;QACrC,WAAW,EAAE,GAAG;QAChB,MAAM,EAAE,QAAQ;QAChB,QAAQ,EAAE,GAAG;QACb,kBAAkB,EAAE,GAAG;QACvB,WAAW,EAAE,GAAG;QAChB,uBAAuB,EAAE,OAAO;QAChC,IAAI,EAAE,aAAa;KACpB,CAAC,CAAC;IACH,OAAO,GAAG,UAAU,KAAK,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC;AACnD,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,kCAAkC,EAAE,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACvF,mCAAmC,EAAE,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC9F,sCAAsC,EAAE,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC/F,iCAAiC,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACtF,yBAAyB,EAAE,YAAY,CAAC,OAAO;QAC/C,+BAA+B,EAAE,YAAY,CAAC,YAAY;QAC1D,yBAAyB,EAAE,YAAY,CAAC,OAAO;QAC/C,sBAAsB,EAAE,aAAa;KACtC,CAAC;AACJ,CAAC","sourcesContent":["import { brandUtils } from \"@dbx-tools/shared-core\";\nimport { dbxToolsAssetDataUrls, dbxToolsAssetSvg } from \"@dbx-tools/ui/branding/assets\";\n\nconst BRAND = brandUtils.defaultBrandContext;\nconst BRAND_COLORS = BRAND.colors;\nconst WALLPAPER_LOGO = dbxToolsAssetSvg.logoDark.replace(\n  \"<svg \",\n  '<svg x=\"500\" y=\"378\" width=\"600\" height=\"135\" ',\n);\n\nconst DBX_TOOLS_WALLPAPER =\n  // ============================================================================\n  /*xml*/ `\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1600\" height=\"1000\" viewBox=\"0 0 1600 1000\">\n  <defs>\n    <linearGradient id=\"background\" x1=\"0\" y1=\"0\" x2=\"1\" y2=\"1\">\n      <stop offset=\"0\" stop-color=\"#0B161B\"/>\n      <stop offset=\"0.55\" stop-color=\"${BRAND_COLORS.primary}\"/>\n      <stop offset=\"1\" stop-color=\"${BRAND_COLORS.primaryHover}\"/>\n    </linearGradient>\n    <pattern id=\"grid\" width=\"64\" height=\"64\" patternUnits=\"userSpaceOnUse\">\n      <path d=\"M64 0H0V64\" fill=\"none\" stroke=\"${BRAND_COLORS.surface}\" stroke-opacity=\"0.045\"/>\n    </pattern>\n  </defs>\n  <rect width=\"1600\" height=\"1000\" fill=\"url(#background)\"/>\n  <rect width=\"1600\" height=\"1000\" fill=\"url(#grid)\"/>\n  <path d=\"M0 780C310 650 475 920 780 775s500-220 820-55v280H0Z\" fill=\"${BRAND_COLORS.accent}\" fill-opacity=\"0.13\"/>\n  <path d=\"M0 835c300-125 510 105 790-10s500-170 810-65\" fill=\"none\" stroke=\"${BRAND_COLORS.accent}\" stroke-width=\"4\" stroke-opacity=\"0.7\"/>\n  ${WALLPAPER_LOGO}\n  <text x=\"800\" y=\"558\" text-anchor=\"middle\" fill=\"${BRAND_COLORS.muted}\" font-family=\"${BRAND.typography.sans}\" font-size=\"24\" letter-spacing=\"5\">LAKEBOX DESKTOP</text>\n</svg>\n`\n    // ============================================================================\n    .trim();\n\nconst DBX_TOOLS_TERMINAL_ICON =\n  // ============================================================================\n  /*xml*/ `\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"64\" height=\"64\" viewBox=\"0 0 64 64\">\n  <rect x=\"4\" y=\"6\" width=\"56\" height=\"52\" rx=\"12\" fill=\"${BRAND_COLORS.primary}\"/>\n  <rect x=\"8\" y=\"10\" width=\"48\" height=\"44\" rx=\"8\" fill=\"${BRAND_COLORS.primaryHover}\"/>\n  <path d=\"m18 23 9 9-9 9\" fill=\"none\" stroke=\"${BRAND_COLORS.surface}\" stroke-width=\"4\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n  <path d=\"M34 41h12\" fill=\"none\" stroke=\"${BRAND_COLORS.accent}\" stroke-width=\"4\" stroke-linecap=\"round\"/>\n</svg>\n`\n    // ============================================================================\n    .trim();\n\nconst DESKTOP_BRAND_HEAD =\n  // ============================================================================\n  /*html*/ `\n<style id=\"dbx-tools-desktop-brand\">\nhtml,body{width:100%;max-width:100%;height:100%;max-height:100%;min-width:0;min-height:0;overflow:hidden}\nbody{position:fixed;inset:0;width:var(--dbx-tools-viewport-width,100vw);height:var(--dbx-tools-viewport-height,100dvh)}\n#noVNC_container{width:100%!important;max-width:100%;height:100%!important;max-height:100%;overflow:hidden}\n.noVNC_logo,h1.noVNC_logo,a[title=\"KasmVNC Learn More\"]{display:none!important}\n#noVNC_fallback_errormsg{overflow-wrap:anywhere}\n</style>\n<link data-dbx-tools-desktop-icon rel=\"icon\" href=\"${dbxToolsAssetDataUrls.iconDark}\">\n<script id=\"dbx-tools-kasm-mobile-guard\">(()=>{const ignored=(error)=>error instanceof ReferenceError&&/^Can't find variable: W[0-9A-F]{32}$/.test(error.message);window.addEventListener(\"error\",(event)=>{if(ignored(event.error)){event.preventDefault();event.stopImmediatePropagation()}},true);window.addEventListener(\"unhandledrejection\",(event)=>{if(ignored(event.reason)){event.preventDefault();event.stopImmediatePropagation()}},true);let timer;const sync=()=>{const viewport=window.visualViewport;document.documentElement.style.setProperty(\"--dbx-tools-viewport-width\",String(Math.round(viewport?.width??window.innerWidth))+\"px\");document.documentElement.style.setProperty(\"--dbx-tools-viewport-height\",String(Math.round(viewport?.height??window.innerHeight))+\"px\");window.dispatchEvent(new Event(\"resize\"))};const schedule=()=>{clearTimeout(timer);sync();setTimeout(sync,250);timer=setTimeout(sync,750)};window.visualViewport?.addEventListener(\"resize\",schedule);window.visualViewport?.addEventListener(\"scroll\",schedule);window.addEventListener(\"orientationchange\",schedule);window.addEventListener(\"pageshow\",schedule);document.readyState===\"loading\"?document.addEventListener(\"DOMContentLoaded\",schedule,{once:true}):schedule()})();</script>\n<script id=\"dbx-tools-desktop-brand-script\">(()=>{const icon=${JSON.stringify(dbxToolsAssetDataUrls.iconDark)};const rewrite=(root)=>{if(root.nodeType===Node.TEXT_NODE){if(root.nodeValue?.includes(\"KasmVNC\"))root.nodeValue=root.nodeValue.replaceAll(\"KasmVNC\",\"dbx tools Desktop\");return}const walker=document.createTreeWalker(root,NodeFilter.SHOW_TEXT);let node;while(node=walker.nextNode())if(node.nodeValue?.includes(\"KasmVNC\"))node.nodeValue=node.nodeValue.replaceAll(\"KasmVNC\",\"dbx tools Desktop\")};const apply=()=>{document.title=\"dbx tools Desktop\";for(const link of document.querySelectorAll('link[rel~=\"icon\"],link[rel=\"apple-touch-icon\"]'))link.setAttribute(\"href\",icon);if(document.body)rewrite(document.body)};if(document.readyState===\"loading\")document.addEventListener(\"DOMContentLoaded\",apply,{once:true});else apply();new MutationObserver((entries)=>{for(const entry of entries){if(entry.type===\"characterData\")rewrite(entry.target);else for(const node of entry.addedNodes)rewrite(node)}}).observe(document.documentElement,{childList:true,subtree:true,characterData:true})})();</script>\n`\n    // ============================================================================\n    .trim();\n\n/** Markup injected into the KasmVNC client page to apply dbx-tools branding. */\nexport const desktopHtmlHead = DESKTOP_BRAND_HEAD;\n\n/** Browser entry URL for the built-in KasmVNC desktop. */\nexport function desktopOpenUrl(path: string): string {\n  const normalized = path.replace(/\\/+$/, \"\");\n  const websocketPath = `${normalized.replace(/^\\/+/, \"\")}/websockify`;\n  const parameters = new URLSearchParams({\n    autoconnect: \"1\",\n    resize: \"remote\",\n    show_dot: \"1\",\n    clipboard_seamless: \"0\",\n    enable_webp: \"0\",\n    kasmvnc_mode_preference: \"-1027\",\n    path: websocketPath,\n  });\n  return `${normalized}/?${parameters.toString()}`;\n}\n\n/** Branding environment consumed by the packaged desktop session entrypoint. */\nexport function desktopEnvironment(): Readonly<Record<string, string>> {\n  return {\n    DBX_TOOLS_DESKTOP_WALLPAPER_BASE64: Buffer.from(DBX_TOOLS_WALLPAPER).toString(\"base64\"),\n    DBX_TOOLS_DESKTOP_BRAND_ICON_BASE64: Buffer.from(dbxToolsAssetSvg.iconDark).toString(\"base64\"),\n    DBX_TOOLS_DESKTOP_TERMINAL_ICON_BASE64: Buffer.from(DBX_TOOLS_TERMINAL_ICON).toString(\"base64\"),\n    DBX_TOOLS_DESKTOP_HOMEPAGE_BASE64: Buffer.from(BRAND.links.website).toString(\"base64\"),\n    DBX_TOOLS_DESKTOP_PRIMARY: BRAND_COLORS.primary,\n    DBX_TOOLS_DESKTOP_PRIMARY_HOVER: BRAND_COLORS.primaryHover,\n    DBX_TOOLS_DESKTOP_SURFACE: BRAND_COLORS.surface,\n    DBX_TOOLS_DESKTOP_FONT: \"DejaVu Sans\",\n  };\n}\n"]}

package/lib/src/metrics.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from "node:events";
+import type { LakeboxMetricsSnapshot } from "@dbx-tools/shared-lakebox";
+/** Raw cumulative counters read from one sample. */
+export interface LakeboxCounters {
+    at: number;
+    cores: number;
+    cpuBusy: number;
+    cpuTotal: number;
+    load1: number;
+    memoryTotalBytes: number;
+    memoryAvailableBytes: number;
+    storageTotalBytes: number;
+    storageUsedBytes: number;
+    rxBytes: number;
+    txBytes: number;
+}
+/** Events emitted by {@link LakeboxMetrics}. */
+export interface LakeboxMetricsEvents {
+    snapshot: [LakeboxMetricsSnapshot];
+}
+/**
+ * In-process metrics emitter for the app Lakebox.
+ *
+ * Sampling runs only between {@link start} and {@link stop}, which the runtime
+ * ties to the Lakebox running state. Samples contain machine-level CPU,
+ * memory, persistent storage, and network counters; they never contain
+ * process names, arguments, environment, or per-process usage.
+ */
+export declare class LakeboxMetrics extends EventEmitter<LakeboxMetricsEvents> {
+    private readonly read;
+    private readonly intervalMs;
+    private readonly capacity;
+    private readonly samples;
+    private previous?;
+    private timer?;
+    private controller?;
+    /** Creates a stopped emitter that reads raw counters with `read`. */
+    constructor(read: (signal: AbortSignal) => Promise<string>, intervalMs: number, capacity?: number);
+    /** Whether sampling is active. */
+    get running(): boolean;
+    /** Recent samples, oldest first. */
+    series(): readonly LakeboxMetricsSnapshot[];
+    /** Seeds one validated sample without starting the recurring sampler or emitting an event. */
+    seed(output: string, at?: number): LakeboxMetricsSnapshot;
+    /** Starts sampling. Repeated calls are ignored. */
+    start(): void;
+    /** Stops sampling and clears the series. */
+    stop(): void;
+    private tick;
+    private record;
+}
+/**
+ * Parses the package-owned metrics command output.
+ *
+ * @throws When a required counter is missing.
+ */
+export declare function parseLakeboxCounters(output: string, at?: number): LakeboxCounters;
+/** Converts cumulative counters to one snapshot using the previous sample for rates. */
+export declare function toSnapshot(current: LakeboxCounters, previous?: LakeboxCounters): LakeboxMetricsSnapshot;