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

package/lib/src/metrics.js

@@ -0,0 +1,151 @@
+import { EventEmitter } from "node:events";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+const logger = log.logger("appkit-lakebox:metrics");
+const DEFAULT_CAPACITY = 120;
+/**
+ * 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 class LakeboxMetrics extends EventEmitter {
+    read;
+    intervalMs;
+    capacity;
+    samples = [];
+    previous;
+    timer;
+    controller;
+    /** Creates a stopped emitter that reads raw counters with `read`. */
+    constructor(read, intervalMs, capacity = DEFAULT_CAPACITY) {
+        super();
+        this.read = read;
+        this.intervalMs = intervalMs;
+        this.capacity = capacity;
+    }
+    /** Whether sampling is active. */
+    get running() {
+        return this.controller !== undefined;
+    }
+    /** Recent samples, oldest first. */
+    series() {
+        return [...this.samples];
+    }
+    /** Seeds one validated sample without starting the recurring sampler or emitting an event. */
+    seed(output, at = Date.now()) {
+        const snapshot = this.record(parseLakeboxCounters(output, at), false);
+        return snapshot;
+    }
+    /** Starts sampling. Repeated calls are ignored. */
+    start() {
+        if (this.controller)
+            return;
+        this.controller = new AbortController();
+        void this.tick(this.controller.signal);
+    }
+    /** Stops sampling and clears the series. */
+    stop() {
+        this.controller?.abort();
+        this.controller = undefined;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        this.previous = undefined;
+        this.samples.length = 0;
+    }
+    async tick(signal) {
+        try {
+            const counters = parseLakeboxCounters(await this.read(signal));
+            if (signal.aborted)
+                return;
+            this.record(counters, true);
+        }
+        catch (error) {
+            if (!signal.aborted) {
+                logger.debug("Lakebox metrics sample failed", { error: errorUtils.toError(error) });
+            }
+        }
+        if (signal.aborted)
+            return;
+        this.timer = setTimeout(() => void this.tick(signal), this.intervalMs);
+        this.timer.unref?.();
+    }
+    record(counters, emit) {
+        const snapshot = toSnapshot(counters, this.previous);
+        this.previous = counters;
+        this.samples.push(snapshot);
+        if (this.samples.length > this.capacity)
+            this.samples.shift();
+        if (emit)
+            this.emit("snapshot", snapshot);
+        return snapshot;
+    }
+}
+/**
+ * Parses the package-owned metrics command output.
+ *
+ * @throws When a required counter is missing.
+ */
+export function parseLakeboxCounters(output, at = Date.now()) {
+    const lines = new Map();
+    for (const line of output.split("\n")) {
+        const [key, ...values] = line.trim().split(/\s+/);
+        if (key)
+            lines.set(key.replace(/:$/, ""), values.map(Number));
+    }
+    const value = (key, index = 0) => {
+        const entry = lines.get(key)?.[index];
+        if (entry === undefined || !Number.isFinite(entry)) {
+            throw new Error(`Lakebox metrics output is missing ${key}`);
+        }
+        return entry;
+    };
+    const cpu = lines.get("cpu") ?? [];
+    const idle = (cpu[3] ?? 0) + (cpu[4] ?? 0);
+    const total = cpu
+        .slice(0, 8)
+        .reduce((sum, entry) => sum + (Number.isFinite(entry) ? entry : 0), 0);
+    return {
+        at,
+        cores: value("cores"),
+        cpuBusy: total - idle,
+        cpuTotal: total,
+        load1: value("load"),
+        memoryTotalBytes: value("MemTotal") * 1024,
+        memoryAvailableBytes: value("MemAvailable") * 1024,
+        storageTotalBytes: value("storage", 0),
+        storageUsedBytes: value("storage", 1),
+        rxBytes: value("network", 0),
+        txBytes: value("network", 1),
+    };
+}
+/** Converts cumulative counters to one snapshot using the previous sample for rates. */
+export function toSnapshot(current, previous) {
+    const seconds = previous ? Math.max((current.at - previous.at) / 1_000, 0.001) : 0;
+    const cpuTotal = previous ? current.cpuTotal - previous.cpuTotal : 0;
+    const cpuBusy = previous ? current.cpuBusy - previous.cpuBusy : 0;
+    const rate = (now, before) => previous && before !== undefined ? Math.max(0, (now - before) / seconds) : 0;
+    return {
+        at: new Date(current.at).toISOString(),
+        cpu: {
+            cores: current.cores,
+            usedPercent: cpuTotal > 0 ? clamp((cpuBusy / cpuTotal) * 100) : 0,
+            load1: current.load1,
+        },
+        memory: {
+            totalBytes: current.memoryTotalBytes,
+            usedBytes: Math.max(0, current.memoryTotalBytes - current.memoryAvailableBytes),
+        },
+        storage: { totalBytes: current.storageTotalBytes, usedBytes: current.storageUsedBytes },
+        network: {
+            rxBytesPerSecond: rate(current.rxBytes, previous?.rxBytes),
+            txBytesPerSecond: rate(current.txBytes, previous?.txBytes),
+        },
+    };
+}
+function clamp(value) {
+    return Math.min(100, Math.max(0, Math.round(value * 10) / 10));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics.js","sourceRoot":"","sources":["../../src/metrics.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from \"node:events\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport type { LakeboxMetricsSnapshot } from \"@dbx-tools/shared-lakebox\";\n\nconst logger = log.logger(\"appkit-lakebox:metrics\");\nconst DEFAULT_CAPACITY = 120;\n\n/** Raw cumulative counters read from one sample. */\nexport interface LakeboxCounters {\n  at: number;\n  cores: number;\n  cpuBusy: number;\n  cpuTotal: number;\n  load1: number;\n  memoryTotalBytes: number;\n  memoryAvailableBytes: number;\n  storageTotalBytes: number;\n  storageUsedBytes: number;\n  rxBytes: number;\n  txBytes: number;\n}\n\n/** Events emitted by {@link LakeboxMetrics}. */\nexport interface LakeboxMetricsEvents {\n  snapshot: [LakeboxMetricsSnapshot];\n}\n\n/**\n * In-process metrics emitter for the app Lakebox.\n *\n * Sampling runs only between {@link start} and {@link stop}, which the runtime\n * ties to the Lakebox running state. Samples contain machine-level CPU,\n * memory, persistent storage, and network counters; they never contain\n * process names, arguments, environment, or per-process usage.\n */\nexport class LakeboxMetrics extends EventEmitter<LakeboxMetricsEvents> {\n  private readonly samples: LakeboxMetricsSnapshot[] = [];\n  private previous?: LakeboxCounters;\n  private timer?: ReturnType<typeof setTimeout>;\n  private controller?: AbortController;\n\n  /** Creates a stopped emitter that reads raw counters with `read`. */\n  constructor(\n    private readonly read: (signal: AbortSignal) => Promise<string>,\n    private readonly intervalMs: number,\n    private readonly capacity = DEFAULT_CAPACITY,\n  ) {\n    super();\n  }\n\n  /** Whether sampling is active. */\n  get running(): boolean {\n    return this.controller !== undefined;\n  }\n\n  /** Recent samples, oldest first. */\n  series(): readonly LakeboxMetricsSnapshot[] {\n    return [...this.samples];\n  }\n\n  /** Seeds one validated sample without starting the recurring sampler or emitting an event. */\n  seed(output: string, at = Date.now()): LakeboxMetricsSnapshot {\n    const snapshot = this.record(parseLakeboxCounters(output, at), false);\n    return snapshot;\n  }\n\n  /** Starts sampling. Repeated calls are ignored. */\n  start(): void {\n    if (this.controller) return;\n    this.controller = new AbortController();\n    void this.tick(this.controller.signal);\n  }\n\n  /** Stops sampling and clears the series. */\n  stop(): void {\n    this.controller?.abort();\n    this.controller = undefined;\n    if (this.timer) clearTimeout(this.timer);\n    this.timer = undefined;\n    this.previous = undefined;\n    this.samples.length = 0;\n  }\n\n  private async tick(signal: AbortSignal): Promise<void> {\n    try {\n      const counters = parseLakeboxCounters(await this.read(signal));\n      if (signal.aborted) return;\n      this.record(counters, true);\n    } catch (error) {\n      if (!signal.aborted) {\n        logger.debug(\"Lakebox metrics sample failed\", { error: errorUtils.toError(error) });\n      }\n    }\n    if (signal.aborted) return;\n    this.timer = setTimeout(() => void this.tick(signal), this.intervalMs);\n    this.timer.unref?.();\n  }\n\n  private record(counters: LakeboxCounters, emit: boolean): LakeboxMetricsSnapshot {\n    const snapshot = toSnapshot(counters, this.previous);\n    this.previous = counters;\n    this.samples.push(snapshot);\n    if (this.samples.length > this.capacity) this.samples.shift();\n    if (emit) this.emit(\"snapshot\", snapshot);\n    return snapshot;\n  }\n}\n\n/**\n * Parses the package-owned metrics command output.\n *\n * @throws When a required counter is missing.\n */\nexport function parseLakeboxCounters(output: string, at = Date.now()): LakeboxCounters {\n  const lines = new Map<string, number[]>();\n  for (const line of output.split(\"\\n\")) {\n    const [key, ...values] = line.trim().split(/\\s+/);\n    if (key) lines.set(key.replace(/:$/, \"\"), values.map(Number));\n  }\n  const value = (key: string, index = 0): number => {\n    const entry = lines.get(key)?.[index];\n    if (entry === undefined || !Number.isFinite(entry)) {\n      throw new Error(`Lakebox metrics output is missing ${key}`);\n    }\n    return entry;\n  };\n  const cpu = lines.get(\"cpu\") ?? [];\n  const idle = (cpu[3] ?? 0) + (cpu[4] ?? 0);\n  const total = cpu\n    .slice(0, 8)\n    .reduce((sum, entry) => sum + (Number.isFinite(entry) ? entry : 0), 0);\n  return {\n    at,\n    cores: value(\"cores\"),\n    cpuBusy: total - idle,\n    cpuTotal: total,\n    load1: value(\"load\"),\n    memoryTotalBytes: value(\"MemTotal\") * 1024,\n    memoryAvailableBytes: value(\"MemAvailable\") * 1024,\n    storageTotalBytes: value(\"storage\", 0),\n    storageUsedBytes: value(\"storage\", 1),\n    rxBytes: value(\"network\", 0),\n    txBytes: value(\"network\", 1),\n  };\n}\n\n/** Converts cumulative counters to one snapshot using the previous sample for rates. */\nexport function toSnapshot(\n  current: LakeboxCounters,\n  previous?: LakeboxCounters,\n): LakeboxMetricsSnapshot {\n  const seconds = previous ? Math.max((current.at - previous.at) / 1_000, 0.001) : 0;\n  const cpuTotal = previous ? current.cpuTotal - previous.cpuTotal : 0;\n  const cpuBusy = previous ? current.cpuBusy - previous.cpuBusy : 0;\n  const rate = (now: number, before: number | undefined) =>\n    previous && before !== undefined ? Math.max(0, (now - before) / seconds) : 0;\n  return {\n    at: new Date(current.at).toISOString(),\n    cpu: {\n      cores: current.cores,\n      usedPercent: cpuTotal > 0 ? clamp((cpuBusy / cpuTotal) * 100) : 0,\n      load1: current.load1,\n    },\n    memory: {\n      totalBytes: current.memoryTotalBytes,\n      usedBytes: Math.max(0, current.memoryTotalBytes - current.memoryAvailableBytes),\n    },\n    storage: { totalBytes: current.storageTotalBytes, usedBytes: current.storageUsedBytes },\n    network: {\n      rxBytesPerSecond: rate(current.rxBytes, previous?.rxBytes),\n      txBytesPerSecond: rate(current.txBytes, previous?.txBytes),\n    },\n  };\n}\n\nfunction clamp(value: number): number {\n  return Math.min(100, Math.max(0, Math.round(value * 10) / 10));\n}\n"]}

package/lib/src/plugin.d.ts

@@ -0,0 +1,259 @@
+import { type IAppRouter } from "@databricks/appkit";
+import { type ToolkitEntry, type ToolkitOptions, type ToolRegistry } from "@databricks/appkit/beta";
+import { toolOperations, ToolRegistryPlugin, type AgentToolExecutionContext } from "@dbx-tools/appkit";
+import { type CreateLakeboxServiceRequest, type LakeboxClientConfigInput, type LakeboxCommandRequest, type LakeboxServiceLogsRequest } from "@dbx-tools/shared-lakebox";
+import type { JSONSchema7 } from "json-schema";
+import { z } from "zod";
+import { type LakeboxPluginConfig } from "./config.ts";
+import { LakeboxRuntime } from "./runtime.ts";
+/**
+ * AppKit plugin for the single app Lakebox.
+ *
+ * Registers user-scoped REST routes, agent tools, the deterministic service
+ * proxy, and WebSocket upgrade handling. Every Lakebox lifecycle call uses the
+ * app service principal; the authenticated request identity only selects the
+ * user's Lakebox account and authorizes that user's routes.
+ */
+export declare class AppKitLakeboxPlugin extends ToolRegistryPlugin<LakeboxPluginConfig> {
+    static manifest: {
+        name: "lakebox";
+        displayName: string;
+        description: string;
+        stability: "beta";
+        resources: {
+            required: never[];
+            optional: never[];
+        };
+        config: {
+            schema: JSONSchema7;
+        };
+    };
+    readonly runtime: LakeboxRuntime;
+    private mounted;
+    private httpServer?;
+    private upgradeAttachTimer?;
+    private upgradeIdentityGate?;
+    private readonly upgradeHandler;
+    /** Creates a plugin with a supplied shared runtime or one from resolved config. */
+    constructor(config?: LakeboxPluginConfig);
+    protected get toolRegistry(): ToolRegistry;
+    setup(): Promise<void>;
+    injectRoutes(router: IAppRouter): void;
+    /** Returns browser-safe route defaults published through AppKit client config. */
+    clientConfig(): LakeboxClientConfigInput;
+    /** Returns selected AppKit toolkit entries backed by this plugin's agent tools. */
+    toolkit(options?: ToolkitOptions): Record<string, ToolkitEntry>;
+    /** Executes one registered agent tool for the current execution identity. */
+    executeAgentTool(name: string, args: unknown, signal?: AbortSignal, context?: AgentToolExecutionContext): Promise<unknown>;
+    /** Returns the typed sibling-plugin API. */
+    exports(): {
+        summary: (identity: string) => Promise<{
+            supported: boolean;
+            auto: boolean;
+            status: "error" | "unknown" | "missing" | "starting" | "running" | "stopping" | "stopped";
+            name: string;
+            user: {
+                hash: string;
+                name: string;
+                uid: number;
+                home: string;
+                routePrefix: string;
+            };
+            services: {
+                name: string;
+                kind: "terminal" | "desktop" | "image";
+                state: "error" | "starting" | "stopped" | "ready";
+                port: number;
+                route: boolean;
+                path: string;
+                image?: string | undefined;
+                openPath?: string | undefined;
+                openUrl?: string | undefined;
+                error?: string | undefined;
+                log?: string | undefined;
+            }[];
+            servicesStale: boolean;
+            canStart: boolean;
+            canStop: boolean;
+            id?: string | undefined;
+            idleTimeoutSeconds?: number | undefined;
+            servicesObservedAt?: string | undefined;
+        }>;
+        start: () => Promise<void>;
+        stop: () => Promise<void>;
+        delete: () => Promise<boolean>;
+        executeCommand: (identity: string, input: LakeboxCommandRequest) => Promise<{
+            success: boolean;
+            exitCode: number;
+            stdout: string;
+            stderr: string;
+            executionTimeMs: number;
+            command: string;
+            args: string[];
+            timedOut?: boolean | undefined;
+        }>;
+        listServices: (identity: string) => Promise<{
+            name: string;
+            kind: "terminal" | "desktop" | "image";
+            state: "error" | "starting" | "stopped" | "ready";
+            port: number;
+            route: boolean;
+            path: string;
+            image?: string | undefined;
+            openPath?: string | undefined;
+            openUrl?: string | undefined;
+            error?: string | undefined;
+            log?: string | undefined;
+        }[]>;
+        createService: (identity: string, input: CreateLakeboxServiceRequest) => Promise<{
+            name: string;
+            kind: "terminal" | "desktop" | "image";
+            state: "error" | "starting" | "stopped" | "ready";
+            port: number;
+            route: boolean;
+            path: string;
+            image?: string | undefined;
+            openPath?: string | undefined;
+            openUrl?: string | undefined;
+            error?: string | undefined;
+            log?: string | undefined;
+        }>;
+        startService: (identity: string, name: string) => Promise<{
+            name: string;
+            kind: "terminal" | "desktop" | "image";
+            state: "error" | "starting" | "stopped" | "ready";
+            port: number;
+            route: boolean;
+            path: string;
+            image?: string | undefined;
+            openPath?: string | undefined;
+            openUrl?: string | undefined;
+            error?: string | undefined;
+            log?: string | undefined;
+        }>;
+        stopService: (identity: string, name: string) => Promise<{
+            name: string;
+            kind: "terminal" | "desktop" | "image";
+            state: "error" | "starting" | "stopped" | "ready";
+            port: number;
+            route: boolean;
+            path: string;
+            image?: string | undefined;
+            openPath?: string | undefined;
+            openUrl?: string | undefined;
+            error?: string | undefined;
+            log?: string | undefined;
+        }>;
+        removeService: (identity: string, name: string) => Promise<boolean>;
+        serviceLogs: (identity: string, input: LakeboxServiceLogsRequest) => Promise<{
+            log: string;
+        }>;
+        operations: (identity?: string) => {
+            readonly get_lakebox: toolOperations.AppKitOperation<z.ZodObject<{}, z.core.$strict>, unknown>;
+            readonly execute_lakebox_command: toolOperations.AppKitOperation<z.ZodObject<{
+                command: z.ZodString;
+                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                cwd: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, unknown>;
+            readonly list_lakebox_services: toolOperations.AppKitOperation<z.ZodObject<{}, z.core.$strict>, unknown>;
+            readonly create_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+                name: z.ZodString;
+                image: z.ZodString;
+                command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                workingDirectory: z.ZodOptional<z.ZodString>;
+                mounts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    source: z.ZodString;
+                    target: z.ZodString;
+                    readOnly: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                route: z.ZodDefault<z.ZodBoolean>;
+                openPath: z.ZodOptional<z.ZodString>;
+                stripPrefix: z.ZodDefault<z.ZodBoolean>;
+                pull: z.ZodDefault<z.ZodEnum<{
+                    missing: "missing";
+                    always: "always";
+                }>>;
+            }, z.core.$strict>, unknown>;
+            readonly start_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strict>, unknown>;
+            readonly stop_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strict>, unknown>;
+            readonly remove_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strict>, unknown>;
+            readonly get_lakebox_service_logs: toolOperations.AppKitOperation<z.ZodObject<{
+                name: z.ZodString;
+                maxLines: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                maxChars: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            }, z.core.$strict>, unknown>;
+        };
+        toolkit: (options?: ToolkitOptions) => Record<string, ToolkitEntry>;
+    };
+    /** Cancels in-flight work before shutdown tears down resources. */
+    abortActiveOperations(): void;
+    /** Detaches WebSocket handling and closes the shared runtime. */
+    shutdown(): Promise<void>;
+    /** Returns the Zod-owned operation contracts used by agent tools. */
+    operations(identity?: string, origin?: string): {
+        readonly get_lakebox: toolOperations.AppKitOperation<z.ZodObject<{}, z.core.$strict>, unknown>;
+        readonly execute_lakebox_command: toolOperations.AppKitOperation<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, unknown>;
+        readonly list_lakebox_services: toolOperations.AppKitOperation<z.ZodObject<{}, z.core.$strict>, unknown>;
+        readonly create_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+            name: z.ZodString;
+            image: z.ZodString;
+            command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+            workingDirectory: z.ZodOptional<z.ZodString>;
+            mounts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                readOnly: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            route: z.ZodDefault<z.ZodBoolean>;
+            openPath: z.ZodOptional<z.ZodString>;
+            stripPrefix: z.ZodDefault<z.ZodBoolean>;
+            pull: z.ZodDefault<z.ZodEnum<{
+                missing: "missing";
+                always: "always";
+            }>>;
+        }, z.core.$strict>, unknown>;
+        readonly start_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>, unknown>;
+        readonly stop_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>, unknown>;
+        readonly remove_lakebox_service: toolOperations.AppKitOperation<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>, unknown>;
+        readonly get_lakebox_service_logs: toolOperations.AppKitOperation<z.ZodObject<{
+            name: z.ZodString;
+            maxLines: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            maxChars: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strict>, unknown>;
+    };
+    private createToolRegistry;
+    private executionIdentity;
+    /**
+     * Resolves route identity with the same rules as REST: the forwarded user,
+     * or AppKit's development user for direct loopback navigation outside
+     * production. Everything else is anonymous and fails closed.
+     */
+    private requestIdentity;
+    private streamMetrics;
+    private attachUpgradeHandler;
+    private handleUpgrade;
+}
+/** AppKit plugin factory for {@link AppKitLakeboxPlugin}. */
+export declare const lakebox: import("@databricks/appkit").ToPlugin<typeof AppKitLakeboxPlugin, LakeboxPluginConfig | undefined, "lakebox">;