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

package/lib/src/schemas.js

@@ -0,0 +1,367 @@
+import { z } from "zod";
+export const lakeboxStatusSchema = z
+    .enum(["missing", "unknown", "starting", "running", "stopping", "stopped", "error"])
+    .describe("Normalized Lakebox lifecycle state. missing means the app Lakebox has not been created yet; it is created on first use.");
+export const lakeboxUserSchema = z
+    .object({
+    hash: z
+        .string()
+        .regex(/^[0-9a-z]+$/)
+        .describe("FNV-1a hash of the authenticated identity; the only user routing key."),
+    name: z.string().min(1).describe("Locked, non-sudo Linux account that runs the user's work."),
+    uid: z.number().int().min(1).max(65535).describe("Deterministic Linux UID of the account."),
+    home: z.string().startsWith("/").describe("Stable home path, a symlink to persistent storage."),
+    routePrefix: z
+        .string()
+        .startsWith("/")
+        .describe("AppKit route prefix beneath which this user's services are exposed."),
+})
+    .strict()
+    .describe("The Lakebox account derived from the current authenticated user.");
+/** Built-in services every user can start without a definition. */
+export const LAKEBOX_BUILT_IN_SERVICES = [
+    { name: "terminal", label: "Terminal" },
+    { name: "desktop", label: "Desktop" },
+];
+export const lakeboxBuiltInServiceNameSchema = z
+    .enum(["terminal", "desktop"])
+    .describe("Built-in user service backed by a package-owned definition.");
+/** Environment variables the runtime injects into every service. */
+export const LAKEBOX_RESERVED_SERVICE_ENV = [
+    "SERVICE_NAME",
+    "SERVICE_PATH",
+    "SERVICE_PORT",
+    "PORT",
+];
+export const lakeboxServiceNameSchema = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]{0,30}$/, "Use 1-31 lowercase letters, digits, or hyphens, starting with a letter.")
+    .describe("Service name, unique per user. It is the route segment and, with the user hash, derives the service port.");
+export const lakeboxServiceStateSchema = z
+    .enum(["stopped", "starting", "ready", "error"])
+    .describe("Current service state.");
+export const lakeboxServiceKindSchema = z
+    .enum(["image", "terminal", "desktop"])
+    .describe("image runs an OCI image; terminal and desktop are built-in services that run the Lakebox host environment.");
+export const lakeboxServiceSchema = z
+    .object({
+    name: lakeboxServiceNameSchema,
+    kind: lakeboxServiceKindSchema,
+    image: z.string().optional().describe("OCI image reference for image services."),
+    openPath: z
+        .string()
+        .optional()
+        .describe("Configured entry path appended to the service route."),
+    state: lakeboxServiceStateSchema,
+    port: z
+        .number()
+        .int()
+        .min(1024)
+        .max(65535)
+        .describe("Loopback port derived from the user hash and service name."),
+    route: z
+        .boolean()
+        .describe("Whether AppKit exposes the service through an authenticated route."),
+    path: z.string().startsWith("/").describe("AppKit route path for the service."),
+    openUrl: z
+        .union([z.string().startsWith("/"), z.httpUrl()])
+        .optional()
+        .describe("AppKit URL that opens the service; REST responses use a path and agent tools resolve it against the browser app origin."),
+    error: z.string().optional().describe("Latest start or readiness failure."),
+    log: z
+        .string()
+        .optional()
+        .describe("Bounded tail of the service log; omitted in agent listings."),
+})
+    .strict()
+    .describe("One user-scoped Lakebox service.");
+export const lakeboxSummarySchema = z
+    .object({
+    supported: z.boolean().describe("Whether the workspace exposes the Databricks Lakebox API."),
+    auto: z
+        .boolean()
+        .describe("Whether commands, services, and routes start or create the Lakebox on demand."),
+    status: lakeboxStatusSchema,
+    id: z.string().optional().describe("Databricks Lakebox identifier, once created."),
+    name: z.string().min(1).describe("Product display label; never the upstream machine name."),
+    idleTimeoutSeconds: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Platform idle timeout after which the Lakebox stops."),
+    user: lakeboxUserSchema,
+    services: z.array(lakeboxServiceSchema).describe("The current user's services."),
+    servicesStale: z
+        .boolean()
+        .describe("True when services come from the last successful controller observation rather than live Lakebox state."),
+    servicesObservedAt: z
+        .string()
+        .datetime()
+        .optional()
+        .describe("Time of the last successful live service observation."),
+    canStart: z.boolean().describe("Whether the Lakebox can be started or created now."),
+    canStop: z.boolean().describe("Whether the Lakebox can be stopped now."),
+})
+    .strict()
+    .describe("Secret-free summary of the app Lakebox for the current user.");
+const environmentSchema = z
+    .record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), z.string())
+    .describe("Environment variables.");
+export const lakeboxCommandRequestSchema = z
+    .object({
+    command: z
+        .string()
+        .min(1)
+        .regex(/^\S+$/, 'Command must be one executable name; use command "sh" for shell syntax.')
+        .describe('Executable name only. Put arguments in args. For shell syntax, use command "sh" with args ["-lc", "<script>"].'),
+    args: z
+        .array(z.string())
+        .default([])
+        .describe("Individual arguments. Never concatenate the executable and its arguments."),
+    cwd: z
+        .string()
+        .optional()
+        .describe("Working directory on the Lakebox host. Defaults to the user's home."),
+    env: environmentSchema
+        .optional()
+        .describe("Non-authentication environment overlay. Databricks credentials and SSH agent variables are rejected."),
+    timeoutMs: z.number().int().positive().max(3_600_000).optional().describe("Command timeout."),
+})
+    .strict()
+    .superRefine((request, context) => rejectCredentialEnvKeys(request.env, context))
+    .describe("Command executed as the current user's Lakebox account.");
+export const lakeboxCommandResultSchema = z
+    .object({
+    success: z.boolean().describe("Whether the command exited successfully."),
+    exitCode: z.number().int().describe("Remote exit code."),
+    stdout: z.string().describe("Captured standard output."),
+    stderr: z.string().describe("Captured standard error."),
+    executionTimeMs: z.number().nonnegative().describe("Elapsed execution time."),
+    timedOut: z.boolean().optional().describe("Whether timeout terminated the command."),
+    command: z.string().describe("Executed command."),
+    args: z.array(z.string()).describe("Executed arguments."),
+})
+    .strict()
+    .describe("Lakebox command execution result.");
+export const lakeboxServiceMountSchema = z
+    .object({
+    source: z
+        .string()
+        .min(1)
+        .describe("Host directory relative to the user's home, such as data. It is created when missing. Absolute paths and parent traversal are rejected."),
+    target: z
+        .string()
+        .startsWith("/")
+        .describe("Absolute path inside the container, such as /example."),
+    readOnly: z.boolean().default(false).describe("Mount read-only inside the container."),
+})
+    .strict()
+    .refine((mount) => !mount.source.startsWith("/") && !mount.source.split("/").includes(".."), {
+    message: "Mount sources must stay inside the user's home.",
+    path: ["source"],
+})
+    .describe("Bind mount from the user's persistent home into the container.");
+export const createLakeboxServiceRequestSchema = z
+    .object({
+    name: lakeboxServiceNameSchema,
+    image: z
+        .string()
+        .min(1)
+        .regex(/^\S+$/)
+        .describe("OCI image reference pulled anonymously, such as docker.io/library/python:3.12-alpine."),
+    command: z
+        .array(z.string())
+        .min(1)
+        .optional()
+        .describe('Complete argv that replaces the image entrypoint and command. Tokens are passed literally; there is no shell parsing unless the first tokens are a shell such as ["sh", "-c", "..."]. Omit to run the image\'s own entrypoint and command.'),
+    env: environmentSchema
+        .default({})
+        .describe("Container environment. SERVICE_NAME, SERVICE_PATH, SERVICE_PORT, and PORT are injected and reserved; Databricks credentials are rejected."),
+    workingDirectory: z
+        .string()
+        .startsWith("/")
+        .optional()
+        .describe("Working directory inside the container. Defaults to the image working directory."),
+    mounts: z
+        .array(lakeboxServiceMountSchema)
+        .default([])
+        .describe("Bind mounts from the user's home. Host file permissions still apply."),
+    route: z
+        .boolean()
+        .default(true)
+        .describe("Expose the service through the user's authenticated AppKit route. Routed services must listen on 127.0.0.1:$SERVICE_PORT; there is no Docker-style port publishing."),
+    openPath: z
+        .string()
+        .optional()
+        .describe("Entry path appended to the route, such as index.html?mode=1."),
+    stripPrefix: z
+        .boolean()
+        .default(true)
+        .describe("Remove the route prefix before forwarding. Set false only when the server is configured for the full SERVICE_PATH base path."),
+    pull: z
+        .enum(["missing", "always"])
+        .default("missing")
+        .describe("Pull the image only when absent, or always before starting."),
+})
+    .strict()
+    .superRefine((request, context) => {
+    rejectCredentialEnvKeys(request.env, context);
+    for (const name of LAKEBOX_RESERVED_SERVICE_ENV) {
+        if (name in request.env) {
+            context.addIssue({
+                code: "custom",
+                path: ["env", name],
+                message: `${name} is injected by the Lakebox runtime and cannot be set.`,
+            });
+        }
+    }
+    if (LAKEBOX_BUILT_IN_SERVICES.some((service) => service.name === request.name)) {
+        context.addIssue({
+            code: "custom",
+            path: ["name"],
+            message: `${request.name} is a built-in service name.`,
+        });
+    }
+})
+    .describe("Create or replace a user service that runs an OCI image detached under the Lakebox runtime.");
+export const lakeboxServiceActionSchema = z
+    .object({ name: lakeboxServiceNameSchema })
+    .strict()
+    .describe("Request that targets one of the current user's services.");
+/** Default number of service log lines returned by bounded log reads. */
+export const LAKEBOX_LOG_DEFAULT_MAX_LINES = 200;
+/** Default service log character cap returned by bounded log reads. */
+export const LAKEBOX_LOG_DEFAULT_MAX_CHARS = 16_000;
+export const lakeboxServiceLogsRequestSchema = lakeboxServiceActionSchema
+    .extend({
+    maxLines: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(1_000)
+        .default(LAKEBOX_LOG_DEFAULT_MAX_LINES)
+        .describe("Maximum number of trailing log lines."),
+    maxChars: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(64_000)
+        .default(LAKEBOX_LOG_DEFAULT_MAX_CHARS)
+        .describe("Maximum number of trailing log characters."),
+})
+    .strict()
+    .describe("Bounded log request for one service.");
+export const lakeboxServiceLogsResponseSchema = z
+    .object({ log: z.string().describe("Bounded trailing service log, including image pulls.") })
+    .strict()
+    .describe("Bounded service log response.");
+export const lakeboxServicesResponseSchema = z
+    .object({ services: z.array(lakeboxServiceSchema).describe("The current user's services.") })
+    .strict()
+    .describe("Service listing response.");
+export const lakeboxServiceResponseSchema = z
+    .object({ service: lakeboxServiceSchema })
+    .strict()
+    .describe("Single service response.");
+export const removeLakeboxServiceResponseSchema = z
+    .object({ removed: z.boolean().describe("Whether a saved service was removed.") })
+    .strict()
+    .describe("Service removal response.");
+export const lakeboxMetricsSnapshotSchema = z
+    .object({
+    at: z.string().datetime().describe("Sample time."),
+    cpu: z
+        .object({
+        cores: z.number().int().positive().describe("Online CPU count."),
+        usedPercent: z
+            .number()
+            .min(0)
+            .max(100)
+            .describe("CPU busy percentage since the last sample."),
+        load1: z.number().nonnegative().describe("One-minute load average."),
+    })
+        .strict()
+        .describe("CPU usage."),
+    memory: z
+        .object({
+        totalBytes: z.number().nonnegative().describe("Total memory."),
+        usedBytes: z.number().nonnegative().describe("Memory in use, excluding reclaimable cache."),
+    })
+        .strict()
+        .describe("Memory usage."),
+    storage: z
+        .object({
+        totalBytes: z.number().nonnegative().describe("Persistent home volume size."),
+        usedBytes: z.number().nonnegative().describe("Persistent home volume usage."),
+    })
+        .strict()
+        .describe("Persistent storage usage."),
+    network: z
+        .object({
+        rxBytesPerSecond: z.number().nonnegative().describe("Inbound network throughput."),
+        txBytesPerSecond: z.number().nonnegative().describe("Outbound network throughput."),
+    })
+        .strict()
+        .describe("Network throughput on the primary interface."),
+})
+    .strict()
+    .describe("Machine-level Lakebox resource sample. Never includes process information.");
+export const lakeboxMetricsResponseSchema = z
+    .object({
+    status: lakeboxStatusSchema,
+    series: z
+        .array(lakeboxMetricsSnapshotSchema)
+        .describe("Recent samples, oldest first. Empty while the Lakebox is not running."),
+})
+    .strict()
+    .describe("Lakebox metrics response.");
+const readTool = { appkitTool: { agentTool: true, effect: "read", requiresUserContext: true } };
+const writeTool = { appkitTool: { agentTool: true, effect: "write", requiresUserContext: true } };
+export const getLakeboxOperationSchema = z
+    .object({})
+    .strict()
+    .describe("Return the app Lakebox status, the current user's Lakebox account, and that user's services. This never creates the Lakebox.")
+    .meta(readTool);
+export const executeLakeboxCommandOperationSchema = lakeboxCommandRequestSchema
+    .describe("Run a command on the Lakebox host as the current user's locked, non-sudo account, starting the Lakebox when needed. Use services, not background commands, for long-running servers.")
+    .meta(writeTool);
+export const listLakeboxServicesOperationSchema = z
+    .object({})
+    .strict()
+    .describe("List the current user's services with state, port, and route. Logs are omitted.")
+    .meta(readTool);
+export const createLakeboxServiceOperationSchema = createLakeboxServiceRequestSchema
+    .describe("Create or replace a user service from an OCI image, start it detached, and wait until it is ready or failed. This is a constrained container API, not the Docker CLI: there is no daemon, port publishing, privileged mode, or device access. Routed services listen on 127.0.0.1:$SERVICE_PORT and are reached at the returned openUrl. Services restart from their saved definition when the Lakebox starts; process memory is not resumed.")
+    .meta(writeTool);
+export const startLakeboxServiceOperationSchema = lakeboxServiceActionSchema
+    .describe("Start a saved service or a built-in terminal or desktop and wait until it is ready or failed.")
+    .meta({ appkitTool: { ...writeTool.appkitTool, idempotent: true } });
+export const stopLakeboxServiceOperationSchema = lakeboxServiceActionSchema
+    .describe("Stop one running service without removing its definition.")
+    .meta({ appkitTool: { ...writeTool.appkitTool, idempotent: true } });
+export const removeLakeboxServiceOperationSchema = lakeboxServiceActionSchema
+    .describe("Stop and delete one saved service definition and its image root filesystem. Mounted home directories are preserved.")
+    .meta({
+    appkitTool: {
+        agentTool: true,
+        effect: "destructive",
+        approval: true,
+        requiresUserContext: true,
+    },
+});
+export const getLakeboxServiceLogsOperationSchema = lakeboxServiceLogsRequestSchema
+    .describe("Read a bounded tail of one service log, including image pull and readiness output.")
+    .meta(readTool);
+function rejectCredentialEnvKeys(env, context) {
+    for (const name of Object.keys(env ?? {})) {
+        if (name.startsWith("DATABRICKS_") || name === "SSH_AUTH_SOCK") {
+            context.addIssue({
+                code: "custom",
+                path: ["env", name],
+                message: "Environment overlays cannot restore Databricks or SSH agent credentials; use a dedicated app-mediated capability.",
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KACjC,IAAI,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;KACnF,QAAQ,CACP,yHAAyH,CAC1H,CAAC;AAGJ,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACN,IAAI,EAAE,CAAC;SACJ,MAAM,EAAE;SACR,KAAK,CAAC,aAAa,CAAC;SACpB,QAAQ,CAAC,uEAAuE,CAAC;IACpF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,2DAA2D,CAAC;IAC7F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IAC3F,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,oDAAoD,CAAC;IAC/F,WAAW,EAAE,CAAC;SACX,MAAM,EAAE;SACR,UAAU,CAAC,GAAG,CAAC;SACf,QAAQ,CAAC,qEAAqE,CAAC;CACnF,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,kEAAkE,CAAC,CAAC;AAGhF,mEAAmE;AACnE,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE;IACvC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE;CAC7B,CAAC;AAEX,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC;KAC7C,IAAI,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;KAC7B,QAAQ,CAAC,6DAA6D,CAAC,CAAC;AAG3E,oEAAoE;AACpE,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,cAAc;IACd,cAAc;IACd,cAAc;IACd,MAAM;CACE,CAAC;AAEX,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC;KACtC,MAAM,EAAE;KACR,KAAK,CACJ,wBAAwB,EACxB,yEAAyE,CAC1E;KACA,QAAQ,CACP,2GAA2G,CAC5G,CAAC;AAEJ,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC;KACvC,IAAI,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;KAC/C,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAGtC,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC;KACtC,IAAI,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;KACtC,QAAQ,CACP,4GAA4G,CAC7G,CAAC;AAGJ,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,IAAI,EAAE,wBAAwB;IAC9B,IAAI,EAAE,wBAAwB;IAC9B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IAChF,QAAQ,EAAE,CAAC;SACR,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,sDAAsD,CAAC;IACnE,KAAK,EAAE,yBAAyB;IAChC,IAAI,EAAE,CAAC;SACJ,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,IAAI,CAAC;SACT,GAAG,CAAC,KAAK,CAAC;SACV,QAAQ,CAAC,4DAA4D,CAAC;IACzE,KAAK,EAAE,CAAC;SACL,OAAO,EAAE;SACT,QAAQ,CAAC,oEAAoE,CAAC;IACjF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,oCAAoC,CAAC;IAC/E,OAAO,EAAE,CAAC;SACP,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;SAChD,QAAQ,EAAE;SACV,QAAQ,CACP,yHAAyH,CAC1H;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oCAAoC,CAAC;IAC3E,GAAG,EAAE,CAAC;SACH,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,6DAA6D,CAAC;CAC3E,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,kCAAkC,CAAC,CAAC;AAGhD,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,2DAA2D,CAAC;IAC5F,IAAI,EAAE,CAAC;SACJ,OAAO,EAAE;SACT,QAAQ,CAAC,+EAA+E,CAAC;IAC5F,MAAM,EAAE,mBAAmB;IAC3B,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8CAA8C,CAAC;IAClF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,yDAAyD,CAAC;IAC3F,kBAAkB,EAAE,CAAC;SAClB,MAAM,EAAE;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,QAAQ,EAAE;SACV,QAAQ,CAAC,sDAAsD,CAAC;IACnE,IAAI,EAAE,iBAAiB;IACvB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IAChF,aAAa,EAAE,CAAC;SACb,OAAO,EAAE;SACT,QAAQ,CACP,yGAAyG,CAC1G;IACH,kBAAkB,EAAE,CAAC;SAClB,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,EAAE;SACV,QAAQ,CAAC,uDAAuD,CAAC;IACpE,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,oDAAoD,CAAC;IACpF,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;CACzE,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,8DAA8D,CAAC,CAAC;AAG5E,MAAM,iBAAiB,GAAG,CAAC;KACxB,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;KAChE,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAEtC,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC;KACzC,MAAM,CAAC;IACN,OAAO,EAAE,CAAC;SACP,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,KAAK,CAAC,OAAO,EAAE,yEAAyE,CAAC;SACzF,QAAQ,CACP,gHAAgH,CACjH;IACH,IAAI,EAAE,CAAC;SACJ,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,2EAA2E,CAAC;IACxF,GAAG,EAAE,CAAC;SACH,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,qEAAqE,CAAC;IAClF,GAAG,EAAE,iBAAiB;SACnB,QAAQ,EAAE;SACV,QAAQ,CACP,sGAAsG,CACvG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC;CAC9F,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,uBAAuB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;KAChF,QAAQ,CAAC,yDAAyD,CAAC,CAAC;AAGvE,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,0CAA0C,CAAC;IACzE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IACxD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;IACxD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;IACvD,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;IAC7E,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IACpF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IACjD,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,qBAAqB,CAAC;CAC1D,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,mCAAmC,CAAC,CAAC;AAGjD,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC;KACvC,MAAM,CAAC;IACN,MAAM,EAAE,CAAC;SACN,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CACP,yIAAyI,CAC1I;IACH,MAAM,EAAE,CAAC;SACN,MAAM,EAAE;SACR,UAAU,CAAC,GAAG,CAAC;SACf,QAAQ,CAAC,uDAAuD,CAAC;IACpE,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,uCAAuC,CAAC;CACvF,CAAC;KACD,MAAM,EAAE;KACR,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;IAC3F,OAAO,EAAE,iDAAiD;IAC1D,IAAI,EAAE,CAAC,QAAQ,CAAC;CACjB,CAAC;KACD,QAAQ,CAAC,gEAAgE,CAAC,CAAC;AAG9E,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC;KAC/C,MAAM,CAAC;IACN,IAAI,EAAE,wBAAwB;IAC9B,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,KAAK,CAAC,OAAO,CAAC;SACd,QAAQ,CACP,uFAAuF,CACxF;IACH,OAAO,EAAE,CAAC;SACP,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CACP,4OAA4O,CAC7O;IACH,GAAG,EAAE,iBAAiB;SACnB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CACP,2IAA2I,CAC5I;IACH,gBAAgB,EAAE,CAAC;SAChB,MAAM,EAAE;SACR,UAAU,CAAC,GAAG,CAAC;SACf,QAAQ,EAAE;SACV,QAAQ,CAAC,kFAAkF,CAAC;IAC/F,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,yBAAyB,CAAC;SAChC,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,sEAAsE,CAAC;IACnF,KAAK,EAAE,CAAC;SACL,OAAO,EAAE;SACT,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CACP,qKAAqK,CACtK;IACH,QAAQ,EAAE,CAAC;SACR,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,8DAA8D,CAAC;IAC3E,WAAW,EAAE,CAAC;SACX,OAAO,EAAE;SACT,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CACP,8HAA8H,CAC/H;IACH,IAAI,EAAE,CAAC;SACJ,IAAI,CAAC,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SAC3B,OAAO,CAAC,SAAS,CAAC;SAClB,QAAQ,CAAC,6DAA6D,CAAC;CAC3E,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;IAChC,uBAAuB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC9C,KAAK,MAAM,IAAI,IAAI,4BAA4B,EAAE,CAAC;QAChD,IAAI,IAAI,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;YACxB,OAAO,CAAC,QAAQ,CAAC;gBACf,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;gBACnB,OAAO,EAAE,GAAG,IAAI,wDAAwD;aACzE,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/E,OAAO,CAAC,QAAQ,CAAC;YACf,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,MAAM,CAAC;YACd,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,8BAA8B;SACvD,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC;KACD,QAAQ,CACP,6FAA6F,CAC9F,CAAC;AAIJ,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC;KAC1C,MAAM,EAAE;KACR,QAAQ,CAAC,0DAA0D,CAAC,CAAC;AAGxE,yEAAyE;AACzE,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,CAAC;AACjD,uEAAuE;AACvE,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC;AAEpD,MAAM,CAAC,MAAM,+BAA+B,GAAG,0BAA0B;KACtE,MAAM,CAAC;IACN,QAAQ,EAAE,CAAC,CAAC,MAAM;SACf,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,KAAK,CAAC;SACV,OAAO,CAAC,6BAA6B,CAAC;SACtC,QAAQ,CAAC,uCAAuC,CAAC;IACpD,QAAQ,EAAE,CAAC,CAAC,MAAM;SACf,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,MAAM,CAAC;SACX,OAAO,CAAC,6BAA6B,CAAC;SACtC,QAAQ,CAAC,4CAA4C,CAAC;CAC1D,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,sCAAsC,CAAC,CAAC;AAGpD,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC;KAC9C,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sDAAsD,CAAC,EAAE,CAAC;KAC5F,MAAM,EAAE;KACR,QAAQ,CAAC,+BAA+B,CAAC,CAAC;AAG7C,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC;KAC3C,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,8BAA8B,CAAC,EAAE,CAAC;KAC5F,MAAM,EAAE;KACR,QAAQ,CAAC,2BAA2B,CAAC,CAAC;AAGzC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC;KAC1C,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;KACzC,MAAM,EAAE;KACR,QAAQ,CAAC,0BAA0B,CAAC,CAAC;AAGxC,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC;KAChD,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,sCAAsC,CAAC,EAAE,CAAC;KACjF,MAAM,EAAE;KACR,QAAQ,CAAC,2BAA2B,CAAC,CAAC;AAGzC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC;KAC1C,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC;IAClD,GAAG,EAAE,CAAC;SACH,MAAM,CAAC;QACN,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QAChE,WAAW,EAAE,CAAC;aACX,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,GAAG,CAAC,GAAG,CAAC;aACR,QAAQ,CAAC,4CAA4C,CAAC;QACzD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;KACrE,CAAC;SACD,MAAM,EAAE;SACR,QAAQ,CAAC,YAAY,CAAC;IACzB,MAAM,EAAE,CAAC;SACN,MAAM,CAAC;QACN,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC;QAC9D,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,6CAA6C,CAAC;KAC5F,CAAC;SACD,MAAM,EAAE;SACR,QAAQ,CAAC,eAAe,CAAC;IAC5B,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,8BAA8B,CAAC;QAC7E,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,+BAA+B,CAAC;KAC9E,CAAC;SACD,MAAM,EAAE;SACR,QAAQ,CAAC,2BAA2B,CAAC;IACxC,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC;QAClF,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,8BAA8B,CAAC;KACpF,CAAC;SACD,MAAM,EAAE;SACR,QAAQ,CAAC,8CAA8C,CAAC;CAC5D,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,4EAA4E,CAAC,CAAC;AAG1F,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC;KAC1C,MAAM,CAAC;IACN,MAAM,EAAE,mBAAmB;IAC3B,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,4BAA4B,CAAC;SACnC,QAAQ,CAAC,uEAAuE,CAAC;CACrF,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,2BAA2B,CAAC,CAAC;AAGzC,MAAM,QAAQ,GAAG,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,EAAE,CAAC;AAChG,MAAM,SAAS,GAAG,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE,EAAE,CAAC;AAElG,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC;KACvC,MAAM,CAAC,EAAE,CAAC;KACV,MAAM,EAAE;KACR,QAAQ,CACP,8HAA8H,CAC/H;KACA,IAAI,CAAC,QAAQ,CAAC,CAAC;AAElB,MAAM,CAAC,MAAM,oCAAoC,GAAG,2BAA2B;KAC5E,QAAQ,CACP,sLAAsL,CACvL;KACA,IAAI,CAAC,SAAS,CAAC,CAAC;AAEnB,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC;KAChD,MAAM,CAAC,EAAE,CAAC;KACV,MAAM,EAAE;KACR,QAAQ,CAAC,iFAAiF,CAAC;KAC3F,IAAI,CAAC,QAAQ,CAAC,CAAC;AAElB,MAAM,CAAC,MAAM,mCAAmC,GAAG,iCAAiC;KACjF,QAAQ,CACP,+aAA+a,CAChb;KACA,IAAI,CAAC,SAAS,CAAC,CAAC;AAEnB,MAAM,CAAC,MAAM,kCAAkC,GAAG,0BAA0B;KACzE,QAAQ,CACP,+FAA+F,CAChG;KACA,IAAI,CAAC,EAAE,UAAU,EAAE,EAAE,GAAG,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;AAEvE,MAAM,CAAC,MAAM,iCAAiC,GAAG,0BAA0B;KACxE,QAAQ,CAAC,2DAA2D,CAAC;KACrE,IAAI,CAAC,EAAE,UAAU,EAAE,EAAE,GAAG,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;AAEvE,MAAM,CAAC,MAAM,mCAAmC,GAAG,0BAA0B;KAC1E,QAAQ,CACP,qHAAqH,CACtH;KACA,IAAI,CAAC;IACJ,UAAU,EAAE;QACV,SAAS,EAAE,IAAI;QACf,MAAM,EAAE,aAAa;QACrB,QAAQ,EAAE,IAAI;QACd,mBAAmB,EAAE,IAAI;KAC1B;CACF,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,oCAAoC,GAAG,+BAA+B;KAChF,QAAQ,CAAC,oFAAoF,CAAC;KAC9F,IAAI,CAAC,QAAQ,CAAC,CAAC;AAElB,SAAS,uBAAuB,CAC9B,GAAiD,EACjD,OAAwB;IAExB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC;QAC1C,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,IAAI,IAAI,KAAK,eAAe,EAAE,CAAC;YAC/D,OAAO,CAAC,QAAQ,CAAC;gBACf,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;gBACnB,OAAO,EACL,mHAAmH;aACtH,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import { z } from \"zod\";\n\nexport const lakeboxStatusSchema = z\n  .enum([\"missing\", \"unknown\", \"starting\", \"running\", \"stopping\", \"stopped\", \"error\"])\n  .describe(\n    \"Normalized Lakebox lifecycle state. missing means the app Lakebox has not been created yet; it is created on first use.\",\n  );\nexport type LakeboxStatus = z.infer<typeof lakeboxStatusSchema>;\n\nexport const lakeboxUserSchema = z\n  .object({\n    hash: z\n      .string()\n      .regex(/^[0-9a-z]+$/)\n      .describe(\"FNV-1a hash of the authenticated identity; the only user routing key.\"),\n    name: z.string().min(1).describe(\"Locked, non-sudo Linux account that runs the user's work.\"),\n    uid: z.number().int().min(1).max(65535).describe(\"Deterministic Linux UID of the account.\"),\n    home: z.string().startsWith(\"/\").describe(\"Stable home path, a symlink to persistent storage.\"),\n    routePrefix: z\n      .string()\n      .startsWith(\"/\")\n      .describe(\"AppKit route prefix beneath which this user's services are exposed.\"),\n  })\n  .strict()\n  .describe(\"The Lakebox account derived from the current authenticated user.\");\nexport type LakeboxUser = z.infer<typeof lakeboxUserSchema>;\n\n/** Built-in services every user can start without a definition. */\nexport const LAKEBOX_BUILT_IN_SERVICES = [\n  { name: \"terminal\", label: \"Terminal\" },\n  { name: \"desktop\", label: \"Desktop\" },\n] as const;\n\nexport const lakeboxBuiltInServiceNameSchema = z\n  .enum([\"terminal\", \"desktop\"])\n  .describe(\"Built-in user service backed by a package-owned definition.\");\nexport type LakeboxBuiltInServiceName = z.infer<typeof lakeboxBuiltInServiceNameSchema>;\n\n/** Environment variables the runtime injects into every service. */\nexport const LAKEBOX_RESERVED_SERVICE_ENV = [\n  \"SERVICE_NAME\",\n  \"SERVICE_PATH\",\n  \"SERVICE_PORT\",\n  \"PORT\",\n] as const;\n\nexport const lakeboxServiceNameSchema = z\n  .string()\n  .regex(\n    /^[a-z][a-z0-9-]{0,30}$/,\n    \"Use 1-31 lowercase letters, digits, or hyphens, starting with a letter.\",\n  )\n  .describe(\n    \"Service name, unique per user. It is the route segment and, with the user hash, derives the service port.\",\n  );\n\nexport const lakeboxServiceStateSchema = z\n  .enum([\"stopped\", \"starting\", \"ready\", \"error\"])\n  .describe(\"Current service state.\");\nexport type LakeboxServiceState = z.infer<typeof lakeboxServiceStateSchema>;\n\nexport const lakeboxServiceKindSchema = z\n  .enum([\"image\", \"terminal\", \"desktop\"])\n  .describe(\n    \"image runs an OCI image; terminal and desktop are built-in services that run the Lakebox host environment.\",\n  );\nexport type LakeboxServiceKind = z.infer<typeof lakeboxServiceKindSchema>;\n\nexport const lakeboxServiceSchema = z\n  .object({\n    name: lakeboxServiceNameSchema,\n    kind: lakeboxServiceKindSchema,\n    image: z.string().optional().describe(\"OCI image reference for image services.\"),\n    openPath: z\n      .string()\n      .optional()\n      .describe(\"Configured entry path appended to the service route.\"),\n    state: lakeboxServiceStateSchema,\n    port: z\n      .number()\n      .int()\n      .min(1024)\n      .max(65535)\n      .describe(\"Loopback port derived from the user hash and service name.\"),\n    route: z\n      .boolean()\n      .describe(\"Whether AppKit exposes the service through an authenticated route.\"),\n    path: z.string().startsWith(\"/\").describe(\"AppKit route path for the service.\"),\n    openUrl: z\n      .union([z.string().startsWith(\"/\"), z.httpUrl()])\n      .optional()\n      .describe(\n        \"AppKit URL that opens the service; REST responses use a path and agent tools resolve it against the browser app origin.\",\n      ),\n    error: z.string().optional().describe(\"Latest start or readiness failure.\"),\n    log: z\n      .string()\n      .optional()\n      .describe(\"Bounded tail of the service log; omitted in agent listings.\"),\n  })\n  .strict()\n  .describe(\"One user-scoped Lakebox service.\");\nexport type LakeboxService = z.infer<typeof lakeboxServiceSchema>;\n\nexport const lakeboxSummarySchema = z\n  .object({\n    supported: z.boolean().describe(\"Whether the workspace exposes the Databricks Lakebox API.\"),\n    auto: z\n      .boolean()\n      .describe(\"Whether commands, services, and routes start or create the Lakebox on demand.\"),\n    status: lakeboxStatusSchema,\n    id: z.string().optional().describe(\"Databricks Lakebox identifier, once created.\"),\n    name: z.string().min(1).describe(\"Product display label; never the upstream machine name.\"),\n    idleTimeoutSeconds: z\n      .number()\n      .int()\n      .positive()\n      .optional()\n      .describe(\"Platform idle timeout after which the Lakebox stops.\"),\n    user: lakeboxUserSchema,\n    services: z.array(lakeboxServiceSchema).describe(\"The current user's services.\"),\n    servicesStale: z\n      .boolean()\n      .describe(\n        \"True when services come from the last successful controller observation rather than live Lakebox state.\",\n      ),\n    servicesObservedAt: z\n      .string()\n      .datetime()\n      .optional()\n      .describe(\"Time of the last successful live service observation.\"),\n    canStart: z.boolean().describe(\"Whether the Lakebox can be started or created now.\"),\n    canStop: z.boolean().describe(\"Whether the Lakebox can be stopped now.\"),\n  })\n  .strict()\n  .describe(\"Secret-free summary of the app Lakebox for the current user.\");\nexport type LakeboxSummary = z.infer<typeof lakeboxSummarySchema>;\n\nconst environmentSchema = z\n  .record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), z.string())\n  .describe(\"Environment variables.\");\n\nexport const lakeboxCommandRequestSchema = z\n  .object({\n    command: z\n      .string()\n      .min(1)\n      .regex(/^\\S+$/, 'Command must be one executable name; use command \"sh\" for shell syntax.')\n      .describe(\n        'Executable name only. Put arguments in args. For shell syntax, use command \"sh\" with args [\"-lc\", \"<script>\"].',\n      ),\n    args: z\n      .array(z.string())\n      .default([])\n      .describe(\"Individual arguments. Never concatenate the executable and its arguments.\"),\n    cwd: z\n      .string()\n      .optional()\n      .describe(\"Working directory on the Lakebox host. Defaults to the user's home.\"),\n    env: environmentSchema\n      .optional()\n      .describe(\n        \"Non-authentication environment overlay. Databricks credentials and SSH agent variables are rejected.\",\n      ),\n    timeoutMs: z.number().int().positive().max(3_600_000).optional().describe(\"Command timeout.\"),\n  })\n  .strict()\n  .superRefine((request, context) => rejectCredentialEnvKeys(request.env, context))\n  .describe(\"Command executed as the current user's Lakebox account.\");\nexport type LakeboxCommandRequest = z.input<typeof lakeboxCommandRequestSchema>;\n\nexport const lakeboxCommandResultSchema = z\n  .object({\n    success: z.boolean().describe(\"Whether the command exited successfully.\"),\n    exitCode: z.number().int().describe(\"Remote exit code.\"),\n    stdout: z.string().describe(\"Captured standard output.\"),\n    stderr: z.string().describe(\"Captured standard error.\"),\n    executionTimeMs: z.number().nonnegative().describe(\"Elapsed execution time.\"),\n    timedOut: z.boolean().optional().describe(\"Whether timeout terminated the command.\"),\n    command: z.string().describe(\"Executed command.\"),\n    args: z.array(z.string()).describe(\"Executed arguments.\"),\n  })\n  .strict()\n  .describe(\"Lakebox command execution result.\");\nexport type LakeboxCommandResult = z.infer<typeof lakeboxCommandResultSchema>;\n\nexport const lakeboxServiceMountSchema = z\n  .object({\n    source: z\n      .string()\n      .min(1)\n      .describe(\n        \"Host directory relative to the user's home, such as data. It is created when missing. Absolute paths and parent traversal are rejected.\",\n      ),\n    target: z\n      .string()\n      .startsWith(\"/\")\n      .describe(\"Absolute path inside the container, such as /example.\"),\n    readOnly: z.boolean().default(false).describe(\"Mount read-only inside the container.\"),\n  })\n  .strict()\n  .refine((mount) => !mount.source.startsWith(\"/\") && !mount.source.split(\"/\").includes(\"..\"), {\n    message: \"Mount sources must stay inside the user's home.\",\n    path: [\"source\"],\n  })\n  .describe(\"Bind mount from the user's persistent home into the container.\");\nexport type LakeboxServiceMount = z.input<typeof lakeboxServiceMountSchema>;\n\nexport const createLakeboxServiceRequestSchema = z\n  .object({\n    name: lakeboxServiceNameSchema,\n    image: z\n      .string()\n      .min(1)\n      .regex(/^\\S+$/)\n      .describe(\n        \"OCI image reference pulled anonymously, such as docker.io/library/python:3.12-alpine.\",\n      ),\n    command: z\n      .array(z.string())\n      .min(1)\n      .optional()\n      .describe(\n        'Complete argv that replaces the image entrypoint and command. Tokens are passed literally; there is no shell parsing unless the first tokens are a shell such as [\"sh\", \"-c\", \"...\"]. Omit to run the image\\'s own entrypoint and command.',\n      ),\n    env: environmentSchema\n      .default({})\n      .describe(\n        \"Container environment. SERVICE_NAME, SERVICE_PATH, SERVICE_PORT, and PORT are injected and reserved; Databricks credentials are rejected.\",\n      ),\n    workingDirectory: z\n      .string()\n      .startsWith(\"/\")\n      .optional()\n      .describe(\"Working directory inside the container. Defaults to the image working directory.\"),\n    mounts: z\n      .array(lakeboxServiceMountSchema)\n      .default([])\n      .describe(\"Bind mounts from the user's home. Host file permissions still apply.\"),\n    route: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"Expose the service through the user's authenticated AppKit route. Routed services must listen on 127.0.0.1:$SERVICE_PORT; there is no Docker-style port publishing.\",\n      ),\n    openPath: z\n      .string()\n      .optional()\n      .describe(\"Entry path appended to the route, such as index.html?mode=1.\"),\n    stripPrefix: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"Remove the route prefix before forwarding. Set false only when the server is configured for the full SERVICE_PATH base path.\",\n      ),\n    pull: z\n      .enum([\"missing\", \"always\"])\n      .default(\"missing\")\n      .describe(\"Pull the image only when absent, or always before starting.\"),\n  })\n  .strict()\n  .superRefine((request, context) => {\n    rejectCredentialEnvKeys(request.env, context);\n    for (const name of LAKEBOX_RESERVED_SERVICE_ENV) {\n      if (name in request.env) {\n        context.addIssue({\n          code: \"custom\",\n          path: [\"env\", name],\n          message: `${name} is injected by the Lakebox runtime and cannot be set.`,\n        });\n      }\n    }\n    if (LAKEBOX_BUILT_IN_SERVICES.some((service) => service.name === request.name)) {\n      context.addIssue({\n        code: \"custom\",\n        path: [\"name\"],\n        message: `${request.name} is a built-in service name.`,\n      });\n    }\n  })\n  .describe(\n    \"Create or replace a user service that runs an OCI image detached under the Lakebox runtime.\",\n  );\nexport type CreateLakeboxServiceRequest = z.input<typeof createLakeboxServiceRequestSchema>;\nexport type LakeboxServiceDefinition = z.output<typeof createLakeboxServiceRequestSchema>;\n\nexport const lakeboxServiceActionSchema = z\n  .object({ name: lakeboxServiceNameSchema })\n  .strict()\n  .describe(\"Request that targets one of the current user's services.\");\nexport type LakeboxServiceAction = z.infer<typeof lakeboxServiceActionSchema>;\n\n/** Default number of service log lines returned by bounded log reads. */\nexport const LAKEBOX_LOG_DEFAULT_MAX_LINES = 200;\n/** Default service log character cap returned by bounded log reads. */\nexport const LAKEBOX_LOG_DEFAULT_MAX_CHARS = 16_000;\n\nexport const lakeboxServiceLogsRequestSchema = lakeboxServiceActionSchema\n  .extend({\n    maxLines: z.coerce\n      .number()\n      .int()\n      .min(1)\n      .max(1_000)\n      .default(LAKEBOX_LOG_DEFAULT_MAX_LINES)\n      .describe(\"Maximum number of trailing log lines.\"),\n    maxChars: z.coerce\n      .number()\n      .int()\n      .min(1)\n      .max(64_000)\n      .default(LAKEBOX_LOG_DEFAULT_MAX_CHARS)\n      .describe(\"Maximum number of trailing log characters.\"),\n  })\n  .strict()\n  .describe(\"Bounded log request for one service.\");\nexport type LakeboxServiceLogsRequest = z.input<typeof lakeboxServiceLogsRequestSchema>;\n\nexport const lakeboxServiceLogsResponseSchema = z\n  .object({ log: z.string().describe(\"Bounded trailing service log, including image pulls.\") })\n  .strict()\n  .describe(\"Bounded service log response.\");\nexport type LakeboxServiceLogsResponse = z.infer<typeof lakeboxServiceLogsResponseSchema>;\n\nexport const lakeboxServicesResponseSchema = z\n  .object({ services: z.array(lakeboxServiceSchema).describe(\"The current user's services.\") })\n  .strict()\n  .describe(\"Service listing response.\");\nexport type LakeboxServicesResponse = z.infer<typeof lakeboxServicesResponseSchema>;\n\nexport const lakeboxServiceResponseSchema = z\n  .object({ service: lakeboxServiceSchema })\n  .strict()\n  .describe(\"Single service response.\");\nexport type LakeboxServiceResponse = z.infer<typeof lakeboxServiceResponseSchema>;\n\nexport const removeLakeboxServiceResponseSchema = z\n  .object({ removed: z.boolean().describe(\"Whether a saved service was removed.\") })\n  .strict()\n  .describe(\"Service removal response.\");\nexport type RemoveLakeboxServiceResponse = z.infer<typeof removeLakeboxServiceResponseSchema>;\n\nexport const lakeboxMetricsSnapshotSchema = z\n  .object({\n    at: z.string().datetime().describe(\"Sample time.\"),\n    cpu: z\n      .object({\n        cores: z.number().int().positive().describe(\"Online CPU count.\"),\n        usedPercent: z\n          .number()\n          .min(0)\n          .max(100)\n          .describe(\"CPU busy percentage since the last sample.\"),\n        load1: z.number().nonnegative().describe(\"One-minute load average.\"),\n      })\n      .strict()\n      .describe(\"CPU usage.\"),\n    memory: z\n      .object({\n        totalBytes: z.number().nonnegative().describe(\"Total memory.\"),\n        usedBytes: z.number().nonnegative().describe(\"Memory in use, excluding reclaimable cache.\"),\n      })\n      .strict()\n      .describe(\"Memory usage.\"),\n    storage: z\n      .object({\n        totalBytes: z.number().nonnegative().describe(\"Persistent home volume size.\"),\n        usedBytes: z.number().nonnegative().describe(\"Persistent home volume usage.\"),\n      })\n      .strict()\n      .describe(\"Persistent storage usage.\"),\n    network: z\n      .object({\n        rxBytesPerSecond: z.number().nonnegative().describe(\"Inbound network throughput.\"),\n        txBytesPerSecond: z.number().nonnegative().describe(\"Outbound network throughput.\"),\n      })\n      .strict()\n      .describe(\"Network throughput on the primary interface.\"),\n  })\n  .strict()\n  .describe(\"Machine-level Lakebox resource sample. Never includes process information.\");\nexport type LakeboxMetricsSnapshot = z.infer<typeof lakeboxMetricsSnapshotSchema>;\n\nexport const lakeboxMetricsResponseSchema = z\n  .object({\n    status: lakeboxStatusSchema,\n    series: z\n      .array(lakeboxMetricsSnapshotSchema)\n      .describe(\"Recent samples, oldest first. Empty while the Lakebox is not running.\"),\n  })\n  .strict()\n  .describe(\"Lakebox metrics response.\");\nexport type LakeboxMetricsResponse = z.infer<typeof lakeboxMetricsResponseSchema>;\n\nconst readTool = { appkitTool: { agentTool: true, effect: \"read\", requiresUserContext: true } };\nconst writeTool = { appkitTool: { agentTool: true, effect: \"write\", requiresUserContext: true } };\n\nexport const getLakeboxOperationSchema = z\n  .object({})\n  .strict()\n  .describe(\n    \"Return the app Lakebox status, the current user's Lakebox account, and that user's services. This never creates the Lakebox.\",\n  )\n  .meta(readTool);\n\nexport const executeLakeboxCommandOperationSchema = lakeboxCommandRequestSchema\n  .describe(\n    \"Run a command on the Lakebox host as the current user's locked, non-sudo account, starting the Lakebox when needed. Use services, not background commands, for long-running servers.\",\n  )\n  .meta(writeTool);\n\nexport const listLakeboxServicesOperationSchema = z\n  .object({})\n  .strict()\n  .describe(\"List the current user's services with state, port, and route. Logs are omitted.\")\n  .meta(readTool);\n\nexport const createLakeboxServiceOperationSchema = createLakeboxServiceRequestSchema\n  .describe(\n    \"Create or replace a user service from an OCI image, start it detached, and wait until it is ready or failed. This is a constrained container API, not the Docker CLI: there is no daemon, port publishing, privileged mode, or device access. Routed services listen on 127.0.0.1:$SERVICE_PORT and are reached at the returned openUrl. Services restart from their saved definition when the Lakebox starts; process memory is not resumed.\",\n  )\n  .meta(writeTool);\n\nexport const startLakeboxServiceOperationSchema = lakeboxServiceActionSchema\n  .describe(\n    \"Start a saved service or a built-in terminal or desktop and wait until it is ready or failed.\",\n  )\n  .meta({ appkitTool: { ...writeTool.appkitTool, idempotent: true } });\n\nexport const stopLakeboxServiceOperationSchema = lakeboxServiceActionSchema\n  .describe(\"Stop one running service without removing its definition.\")\n  .meta({ appkitTool: { ...writeTool.appkitTool, idempotent: true } });\n\nexport const removeLakeboxServiceOperationSchema = lakeboxServiceActionSchema\n  .describe(\n    \"Stop and delete one saved service definition and its image root filesystem. Mounted home directories are preserved.\",\n  )\n  .meta({\n    appkitTool: {\n      agentTool: true,\n      effect: \"destructive\",\n      approval: true,\n      requiresUserContext: true,\n    },\n  });\n\nexport const getLakeboxServiceLogsOperationSchema = lakeboxServiceLogsRequestSchema\n  .describe(\"Read a bounded tail of one service log, including image pull and readiness output.\")\n  .meta(readTool);\n\nfunction rejectCredentialEnvKeys(\n  env: Readonly<Record<string, string>> | undefined,\n  context: z.RefinementCtx,\n): void {\n  for (const name of Object.keys(env ?? {})) {\n    if (name.startsWith(\"DATABRICKS_\") || name === \"SSH_AUTH_SOCK\") {\n      context.addIssue({\n        code: \"custom\",\n        path: [\"env\", name],\n        message:\n          \"Environment overlays cannot restore Databricks or SSH agent credentials; use a dedicated app-mediated capability.\",\n      });\n    }\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/client.ts","../src/schemas.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@dbx-tools/shared-lakebox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Browser-safe contracts for the app Lakebox, user services, commands, metrics, and routes",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/shared/lakebox"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "zod": "4.3.6"
+  },
+  "main": "./lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./client": {
+        "types": "./lib/src/client.d.ts",
+        "default": "./lib/src/client.js"
+      },
+      "./schemas": {
+        "types": "./lib/src/schemas.d.ts",
+        "default": "./lib/src/schemas.js"
+      },
+      "./*": {
+        "types": "./lib/src/*/index.d.ts",
+        "default": "./lib/src/*/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.9.132",
+  "types": "./lib/index.d.ts",
+  "dbxToolsConfig": {
+    "tags": [
+      "shared"
+    ]
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/src/client.d.ts",
+      "default": "./lib/src/client.js"
+    },
+    "./schemas": {
+      "types": "./lib/src/schemas.d.ts",
+      "default": "./lib/src/schemas.js"
+    },
+    "./*": {
+      "types": "./lib/src/*/index.d.ts",
+      "default": "./lib/src/*/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/client.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+
+/** AppKit plugin name used to publish and read the Lakebox browser client config. */
+export const LAKEBOX_PLUGIN_NAME = "lakebox";
+
+/** Default AppKit mount path for the Lakebox plugin API. */
+export const LAKEBOX_DEFAULT_BASE_PATH = `/api/${LAKEBOX_PLUGIN_NAME}`;
+
+/** Default AppKit root path for user-scoped Lakebox service routes. */
+export const LAKEBOX_DEFAULT_ROUTE_PREFIX = "/lakebox";
+
+/** Shared server route templates owned by the Lakebox plugin contract. */
+export const LAKEBOX_ROUTES = {
+  status: "/status",
+  start: "/start",
+  stop: "/stop",
+  commands: "/commands",
+  services: "/services",
+  service: "/services/:name",
+  serviceStart: "/services/:name/start",
+  serviceStop: "/services/:name/stop",
+  serviceLogs: "/services/:name/logs",
+  metrics: "/metrics",
+  metricsStream: "/metrics/stream",
+} as const;
+
+/** Browser-safe configuration published by the Lakebox AppKit plugin. */
+export const LakeboxClientConfigSchema = z
+  .object({
+    basePath: z
+      .string()
+      .startsWith("/")
+      .default(LAKEBOX_DEFAULT_BASE_PATH)
+      .describe("AppKit mount path for Lakebox API routes."),
+    routePrefix: z
+      .string()
+      .startsWith("/")
+      .default(LAKEBOX_DEFAULT_ROUTE_PREFIX)
+      .describe("AppKit root path beneath which each user's services are routed."),
+  })
+  .strict()
+  .describe("Lakebox plugin browser client configuration.");
+export type LakeboxClientConfig = z.infer<typeof LakeboxClientConfigSchema>;
+export type LakeboxClientConfigInput = z.input<typeof LakeboxClientConfigSchema>;
+
+/** Replace named route parameters with encoded browser-safe values. */
+export const lakeboxRoute = (
+  template: string,
+  parameters: Readonly<Record<string, string>> = {},
+): string =>
+  Object.entries(parameters).reduce(
+    (route, [name, value]) => route.replace(`:${name}`, encodeURIComponent(value)),
+    template,
+  );
+
+/**
+ * Returns the AppKit route for one user's service.
+ *
+ * The user hash is the only routing key: the server derives the service port
+ * from the same hash and service name, so no path or port mapping is stored.
+ */
+export function lakeboxServicePath(routePrefix: string, userHash: string, name: string): string {
+  return `${routePrefix.replace(/\/+$/, "")}/${userHash}/${name}`;
+}