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

package/lib/src/services.d.ts

@@ -0,0 +1,101 @@
+import { type CreateLakeboxServiceRequest, type LakeboxBuiltInServiceName, type LakeboxService, type LakeboxUser } from "@dbx-tools/shared-lakebox";
+import { z } from "zod";
+export declare const LakeboxControllerDefinitionSchema: 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>;
+/** Service definition persisted in the user's Lakebox home. */
+export type LakeboxControllerDefinition = z.output<typeof LakeboxControllerDefinitionSchema>;
+export declare const LakeboxControllerServiceSchema: z.ZodObject<{
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        error: "error";
+        starting: "starting";
+        stopped: "stopped";
+        ready: "ready";
+    }>;
+    definition: 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>;
+    error: z.ZodOptional<z.ZodString>;
+    log: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** One service as reported by the remote controller. */
+export type LakeboxControllerService = z.infer<typeof LakeboxControllerServiceSchema>;
+/** Routing behavior derived from a saved definition. */
+export interface LakeboxServiceRoute {
+    port: number;
+    stripPrefix: boolean;
+    redirectToSlash: boolean;
+    htmlHead?: string;
+}
+/** Builds the package-owned definition for a built-in service. */
+export declare function builtInDefinition(name: LakeboxBuiltInServiceName, user: LakeboxUser): LakeboxControllerDefinition;
+/**
+ * Validates an agent or REST service request and resolves it to a persisted
+ * definition with injected variables and home-relative mounts.
+ */
+export declare function imageDefinition(input: CreateLakeboxServiceRequest, user: LakeboxUser): LakeboxControllerDefinition;
+/** Returns route behavior for a saved definition. */
+export declare function serviceRoute(definition: LakeboxControllerDefinition): LakeboxServiceRoute;
+/** Maps a controller report to the shared service shape. */
+export declare function toLakeboxService(service: LakeboxControllerService, user: LakeboxUser, routePrefix: string): LakeboxService;
+/** Resolve a routed service path against the browser app origin for agent output. */
+export declare function withServiceOrigin(service: LakeboxService, origin?: string): LakeboxService;
+/** Returns the stopped placeholder for a built-in service that has never started. */
+export declare function idleBuiltInService(name: LakeboxBuiltInServiceName, user: LakeboxUser, routePrefix: string): LakeboxService;

package/lib/src/services.js

@@ -0,0 +1,188 @@
+import { createLakeboxServiceRequestSchema, lakeboxServiceKindSchema, lakeboxServiceStateSchema, } from "@dbx-tools/shared-lakebox";
+import { lakeboxServicePath } from "@dbx-tools/shared-lakebox/client";
+import { z } from "zod";
+import { desktopEnvironment, desktopHtmlHead, desktopOpenUrl } from "./desktop.js";
+import { LAKEBOX_RUNTIME_ROOT, lakeboxServicePort } from "./user.js";
+const TTYD_CLIENT_OPTIONS = [
+    "term=xterm-256color",
+    "rendererType=webgl",
+    "cursorStyle=bar",
+    "copyOnSelect=true",
+    "rightClickSelectsWord=true",
+    "disableLeaveAlert=true",
+    "disableResizeOverlay=true",
+];
+export const LakeboxControllerDefinitionSchema = z
+    .object({
+    name: z.string().describe("Service name."),
+    kind: lakeboxServiceKindSchema,
+    image: z.string().optional().describe("OCI image for image services."),
+    pull: z.enum(["missing", "always"]).default("missing").describe("Image pull policy."),
+    command: z
+        .array(z.string())
+        .optional()
+        .describe("Argv; omitted to use the image entrypoint and command."),
+    env: z
+        .record(z.string(), z.string())
+        .describe("Container environment, including injected values."),
+    workingDirectory: z.string().optional().describe("Container working directory."),
+    mounts: z
+        .array(z
+        .object({
+        source: z
+            .string()
+            .startsWith("/")
+            .describe("Absolute host path beneath the user's home."),
+        target: z.string().startsWith("/").describe("Container path."),
+        readOnly: z.boolean().describe("Read-only bind."),
+    })
+        .strict())
+        .describe("Bind mounts."),
+    port: z.number().int().describe("Derived loopback port."),
+    readiness: z.enum(["tcp", "none"]).describe("Readiness check."),
+    readySeconds: z.number().int().positive().describe("Maximum readiness wait."),
+    autostart: z.boolean().describe("Whether the service restarts when the Lakebox starts."),
+    route: z.boolean().describe("Whether AppKit routes the service."),
+    stripPrefix: z.boolean().describe("Whether the route prefix is removed before forwarding."),
+    openPath: z.string().optional().describe("Entry path appended to the route."),
+})
+    .strict()
+    .describe("Service definition persisted in the user's Lakebox home and read by the controller.");
+export const LakeboxControllerServiceSchema = z
+    .object({
+    name: z.string(),
+    state: lakeboxServiceStateSchema,
+    definition: LakeboxControllerDefinitionSchema,
+    error: z.string().optional(),
+    log: z.string().optional(),
+})
+    .passthrough()
+    .describe("One service as reported by the remote controller.");
+/** Builds the package-owned definition for a built-in service. */
+export function builtInDefinition(name, user) {
+    const port = lakeboxServicePort(user.hash, name);
+    const common = {
+        name,
+        kind: name,
+        pull: "missing",
+        mounts: [],
+        port,
+        readiness: "tcp",
+        autostart: false,
+        route: true,
+        stripPrefix: true,
+    };
+    if (name === "terminal") {
+        return {
+            ...common,
+            readySeconds: 60,
+            env: injectedEnvironment(user, name, port),
+            command: [
+                `${LAKEBOX_RUNTIME_ROOT}/bin/ttyd`,
+                "--interface",
+                "127.0.0.1",
+                "--port",
+                String(port),
+                "--writable",
+                ...TTYD_CLIENT_OPTIONS.flatMap((option) => ["--client-option", option]),
+                "/bin/bash",
+                "-l",
+            ],
+        };
+    }
+    return {
+        ...common,
+        readySeconds: 180,
+        env: { ...desktopEnvironment(), ...injectedEnvironment(user, name, port) },
+        command: ["/bin/sh", `${LAKEBOX_RUNTIME_ROOT}/bin/desktop-session`],
+    };
+}
+/**
+ * Validates an agent or REST service request and resolves it to a persisted
+ * definition with injected variables and home-relative mounts.
+ */
+export function imageDefinition(input, user) {
+    const request = createLakeboxServiceRequestSchema.parse(input);
+    const port = lakeboxServicePort(user.hash, request.name);
+    return {
+        name: request.name,
+        kind: "image",
+        image: request.image,
+        pull: request.pull,
+        ...(request.command ? { command: request.command } : {}),
+        env: { ...request.env, ...injectedEnvironment(user, request.name, port, request.route) },
+        ...(request.workingDirectory ? { workingDirectory: request.workingDirectory } : {}),
+        mounts: request.mounts.map((mount) => ({
+            source: `${user.home}/${mount.source.replace(/^\.\/+|\/+$/g, "")}`,
+            target: mount.target,
+            readOnly: mount.readOnly,
+        })),
+        port,
+        readiness: request.route ? "tcp" : "none",
+        readySeconds: 300,
+        autostart: true,
+        route: request.route,
+        stripPrefix: request.stripPrefix,
+        ...(request.openPath ? { openPath: request.openPath.replace(/^\/+/, "") } : {}),
+    };
+}
+/** Returns route behavior for a saved definition. */
+export function serviceRoute(definition) {
+    return {
+        port: definition.port,
+        stripPrefix: definition.stripPrefix,
+        redirectToSlash: true,
+        ...(definition.kind === "desktop" ? { htmlHead: desktopHtmlHead } : {}),
+    };
+}
+/** Maps a controller report to the shared service shape. */
+export function toLakeboxService(service, user, routePrefix) {
+    const { definition } = service;
+    const path = lakeboxServicePath(routePrefix, user.hash, definition.name);
+    return {
+        name: definition.name,
+        kind: definition.kind,
+        ...(definition.image ? { image: definition.image } : {}),
+        ...(definition.openPath ? { openPath: definition.openPath } : {}),
+        state: service.state,
+        port: definition.port,
+        route: definition.route,
+        path,
+        ...(definition.route ? { openUrl: openUrl(definition, path) } : {}),
+        ...(service.error ? { error: service.error } : {}),
+        ...(service.log !== undefined ? { log: service.log } : {}),
+    };
+}
+/** Resolve a routed service path against the browser app origin for agent output. */
+export function withServiceOrigin(service, origin) {
+    if (!service.openUrl || !origin)
+        return service;
+    try {
+        const base = new URL(origin);
+        if (base.protocol !== "http:" && base.protocol !== "https:")
+            return service;
+        return { ...service, openUrl: new URL(service.openUrl, base).href };
+    }
+    catch {
+        return service;
+    }
+}
+/** Returns the stopped placeholder for a built-in service that has never started. */
+export function idleBuiltInService(name, user, routePrefix) {
+    return toLakeboxService({ name, state: "stopped", definition: builtInDefinition(name, user) }, user, routePrefix);
+}
+function openUrl(definition, path) {
+    if (definition.kind === "desktop")
+        return desktopOpenUrl(path);
+    return `${path}/${definition.openPath ?? ""}`;
+}
+function injectedEnvironment(user, name, port, route = true) {
+    const value = String(port);
+    return {
+        SERVICE_NAME: name,
+        SERVICE_PATH: route ? `${user.routePrefix}/${name}` : "",
+        SERVICE_PORT: value,
+        PORT: value,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"services.js","sourceRoot":"","sources":["../../src/services.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createLakeboxServiceRequestSchema,\n  lakeboxServiceKindSchema,\n  lakeboxServiceStateSchema,\n  type CreateLakeboxServiceRequest,\n  type LakeboxBuiltInServiceName,\n  type LakeboxService,\n  type LakeboxUser,\n} from \"@dbx-tools/shared-lakebox\";\nimport { lakeboxServicePath } from \"@dbx-tools/shared-lakebox/client\";\nimport { z } from \"zod\";\nimport { desktopEnvironment, desktopHtmlHead, desktopOpenUrl } from \"./desktop.ts\";\nimport { LAKEBOX_RUNTIME_ROOT, lakeboxServicePort } from \"./user.ts\";\n\nconst TTYD_CLIENT_OPTIONS = [\n  \"term=xterm-256color\",\n  \"rendererType=webgl\",\n  \"cursorStyle=bar\",\n  \"copyOnSelect=true\",\n  \"rightClickSelectsWord=true\",\n  \"disableLeaveAlert=true\",\n  \"disableResizeOverlay=true\",\n];\n\nexport const LakeboxControllerDefinitionSchema = z\n  .object({\n    name: z.string().describe(\"Service name.\"),\n    kind: lakeboxServiceKindSchema,\n    image: z.string().optional().describe(\"OCI image for image services.\"),\n    pull: z.enum([\"missing\", \"always\"]).default(\"missing\").describe(\"Image pull policy.\"),\n    command: z\n      .array(z.string())\n      .optional()\n      .describe(\"Argv; omitted to use the image entrypoint and command.\"),\n    env: z\n      .record(z.string(), z.string())\n      .describe(\"Container environment, including injected values.\"),\n    workingDirectory: z.string().optional().describe(\"Container working directory.\"),\n    mounts: z\n      .array(\n        z\n          .object({\n            source: z\n              .string()\n              .startsWith(\"/\")\n              .describe(\"Absolute host path beneath the user's home.\"),\n            target: z.string().startsWith(\"/\").describe(\"Container path.\"),\n            readOnly: z.boolean().describe(\"Read-only bind.\"),\n          })\n          .strict(),\n      )\n      .describe(\"Bind mounts.\"),\n    port: z.number().int().describe(\"Derived loopback port.\"),\n    readiness: z.enum([\"tcp\", \"none\"]).describe(\"Readiness check.\"),\n    readySeconds: z.number().int().positive().describe(\"Maximum readiness wait.\"),\n    autostart: z.boolean().describe(\"Whether the service restarts when the Lakebox starts.\"),\n    route: z.boolean().describe(\"Whether AppKit routes the service.\"),\n    stripPrefix: z.boolean().describe(\"Whether the route prefix is removed before forwarding.\"),\n    openPath: z.string().optional().describe(\"Entry path appended to the route.\"),\n  })\n  .strict()\n  .describe(\"Service definition persisted in the user's Lakebox home and read by the controller.\");\n/** Service definition persisted in the user's Lakebox home. */\nexport type LakeboxControllerDefinition = z.output<typeof LakeboxControllerDefinitionSchema>;\n\nexport const LakeboxControllerServiceSchema = z\n  .object({\n    name: z.string(),\n    state: lakeboxServiceStateSchema,\n    definition: LakeboxControllerDefinitionSchema,\n    error: z.string().optional(),\n    log: z.string().optional(),\n  })\n  .passthrough()\n  .describe(\"One service as reported by the remote controller.\");\n/** One service as reported by the remote controller. */\nexport type LakeboxControllerService = z.infer<typeof LakeboxControllerServiceSchema>;\n\n/** Routing behavior derived from a saved definition. */\nexport interface LakeboxServiceRoute {\n  port: number;\n  stripPrefix: boolean;\n  redirectToSlash: boolean;\n  htmlHead?: string;\n}\n\n/** Builds the package-owned definition for a built-in service. */\nexport function builtInDefinition(\n  name: LakeboxBuiltInServiceName,\n  user: LakeboxUser,\n): LakeboxControllerDefinition {\n  const port = lakeboxServicePort(user.hash, name);\n  const common = {\n    name,\n    kind: name,\n    pull: \"missing\" as const,\n    mounts: [],\n    port,\n    readiness: \"tcp\" as const,\n    autostart: false,\n    route: true,\n    stripPrefix: true,\n  };\n  if (name === \"terminal\") {\n    return {\n      ...common,\n      readySeconds: 60,\n      env: injectedEnvironment(user, name, port),\n      command: [\n        `${LAKEBOX_RUNTIME_ROOT}/bin/ttyd`,\n        \"--interface\",\n        \"127.0.0.1\",\n        \"--port\",\n        String(port),\n        \"--writable\",\n        ...TTYD_CLIENT_OPTIONS.flatMap((option) => [\"--client-option\", option]),\n        \"/bin/bash\",\n        \"-l\",\n      ],\n    };\n  }\n  return {\n    ...common,\n    readySeconds: 180,\n    env: { ...desktopEnvironment(), ...injectedEnvironment(user, name, port) },\n    command: [\"/bin/sh\", `${LAKEBOX_RUNTIME_ROOT}/bin/desktop-session`],\n  };\n}\n\n/**\n * Validates an agent or REST service request and resolves it to a persisted\n * definition with injected variables and home-relative mounts.\n */\nexport function imageDefinition(\n  input: CreateLakeboxServiceRequest,\n  user: LakeboxUser,\n): LakeboxControllerDefinition {\n  const request = createLakeboxServiceRequestSchema.parse(input);\n  const port = lakeboxServicePort(user.hash, request.name);\n  return {\n    name: request.name,\n    kind: \"image\",\n    image: request.image,\n    pull: request.pull,\n    ...(request.command ? { command: request.command } : {}),\n    env: { ...request.env, ...injectedEnvironment(user, request.name, port, request.route) },\n    ...(request.workingDirectory ? { workingDirectory: request.workingDirectory } : {}),\n    mounts: request.mounts.map((mount) => ({\n      source: `${user.home}/${mount.source.replace(/^\\.\\/+|\\/+$/g, \"\")}`,\n      target: mount.target,\n      readOnly: mount.readOnly,\n    })),\n    port,\n    readiness: request.route ? \"tcp\" : \"none\",\n    readySeconds: 300,\n    autostart: true,\n    route: request.route,\n    stripPrefix: request.stripPrefix,\n    ...(request.openPath ? { openPath: request.openPath.replace(/^\\/+/, \"\") } : {}),\n  };\n}\n\n/** Returns route behavior for a saved definition. */\nexport function serviceRoute(definition: LakeboxControllerDefinition): LakeboxServiceRoute {\n  return {\n    port: definition.port,\n    stripPrefix: definition.stripPrefix,\n    redirectToSlash: true,\n    ...(definition.kind === \"desktop\" ? { htmlHead: desktopHtmlHead } : {}),\n  };\n}\n\n/** Maps a controller report to the shared service shape. */\nexport function toLakeboxService(\n  service: LakeboxControllerService,\n  user: LakeboxUser,\n  routePrefix: string,\n): LakeboxService {\n  const { definition } = service;\n  const path = lakeboxServicePath(routePrefix, user.hash, definition.name);\n  return {\n    name: definition.name,\n    kind: definition.kind,\n    ...(definition.image ? { image: definition.image } : {}),\n    ...(definition.openPath ? { openPath: definition.openPath } : {}),\n    state: service.state,\n    port: definition.port,\n    route: definition.route,\n    path,\n    ...(definition.route ? { openUrl: openUrl(definition, path) } : {}),\n    ...(service.error ? { error: service.error } : {}),\n    ...(service.log !== undefined ? { log: service.log } : {}),\n  };\n}\n\n/** Resolve a routed service path against the browser app origin for agent output. */\nexport function withServiceOrigin(service: LakeboxService, origin?: string): LakeboxService {\n  if (!service.openUrl || !origin) return service;\n  try {\n    const base = new URL(origin);\n    if (base.protocol !== \"http:\" && base.protocol !== \"https:\") return service;\n    return { ...service, openUrl: new URL(service.openUrl, base).href };\n  } catch {\n    return service;\n  }\n}\n\n/** Returns the stopped placeholder for a built-in service that has never started. */\nexport function idleBuiltInService(\n  name: LakeboxBuiltInServiceName,\n  user: LakeboxUser,\n  routePrefix: string,\n): LakeboxService {\n  return toLakeboxService(\n    { name, state: \"stopped\", definition: builtInDefinition(name, user) },\n    user,\n    routePrefix,\n  );\n}\n\nfunction openUrl(definition: LakeboxControllerDefinition, path: string): string {\n  if (definition.kind === \"desktop\") return desktopOpenUrl(path);\n  return `${path}/${definition.openPath ?? \"\"}`;\n}\n\nfunction injectedEnvironment(\n  user: LakeboxUser,\n  name: string,\n  port: number,\n  route = true,\n): Record<string, string> {\n  const value = String(port);\n  return {\n    SERVICE_NAME: name,\n    SERVICE_PATH: route ? `${user.routePrefix}/${name}` : \"\",\n    SERVICE_PORT: value,\n    PORT: value,\n  };\n}\n"]}

package/lib/src/skills.d.ts

@@ -0,0 +1,5 @@
+import type { LocalSkillDirectoryMount } from "@dbx-tools/appkit-mastra";
+/** Default agent-workspace path for packaged Lakebox service recipes. */
+export declare const LAKEBOX_SKILLS_MOUNT = "/.dbx-tools/skills";
+/** Returns the packaged Lakebox recipe tree as a Mastra local skill mount. */
+export declare function lakeboxSkillMounts(): LocalSkillDirectoryMount[];

package/lib/src/skills.js

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Default agent-workspace path for packaged Lakebox service recipes. */
+export const LAKEBOX_SKILLS_MOUNT = "/.dbx-tools/skills";
+/** Returns the packaged Lakebox recipe tree as a Mastra local skill mount. */
+export function lakeboxSkillMounts() {
+    return [{ root: lakeboxSkillsRoot(), mountPath: LAKEBOX_SKILLS_MOUNT }];
+}
+function lakeboxSkillsRoot() {
+    const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(moduleDirectory, "../skills"),
+        resolve(moduleDirectory, "../../skills"),
+    ];
+    const root = candidates.find((candidate) => existsSync(candidate));
+    if (!root)
+        throw new Error("Packaged Lakebox skills are unavailable");
+    return root;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/user.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Deterministic Lakebox user and service-port derivation.
+ *
+ * One FNV-1a hash of the authenticated identity is the only routing key. It
+ * selects the Linux account, UID, persistent home, AppKit route segment, and,
+ * with a service name, the loopback service port. Nothing here is persisted:
+ * every caller recomputes the same values, and collisions fail closed where
+ * they are observed.
+ *
+ * @module
+ */
+import type { LakeboxUser } from "@dbx-tools/shared-lakebox";
+/** Platform account that owns the persistent volume and the SSH session. */
+export declare const LAKEBOX_AGENT_USER = "sandbox-agent";
+/** Persistent home mounted by the platform. Only this path survives a restart. */
+export declare const LAKEBOX_AGENT_HOME = "/home/sandbox-agent";
+/** Root of package-owned persistent state. */
+export declare const LAKEBOX_STATE_ROOT = "/home/sandbox-agent/.dbx-tools";
+/** Persistent backing directories for Lakebox user homes. */
+export declare const LAKEBOX_USERS_ROOT = "/home/sandbox-agent/.dbx-tools/users";
+/** Shared read-only runtime binaries, such as the container bundle and ttyd. */
+export declare const LAKEBOX_RUNTIME_ROOT = "/home/sandbox-agent/.dbx-tools/runtime";
+/** Per-boot runtime state root; reset with the root filesystem. */
+export declare const LAKEBOX_RUN_ROOT = "/run/lakebox";
+/** First derived Linux UID. The persistent idmapped volume stores UIDs below 65536. */
+export declare const LAKEBOX_UID_MIN = 20000;
+/** Number of derivable UIDs. */
+export declare const LAKEBOX_UID_COUNT = 40000;
+/** First derived service port. Platform listeners stay below this value. */
+export declare const LAKEBOX_PORT_MIN = 20000;
+/** Number of derivable service ports; the kernel ephemeral range starts at 32768. */
+export declare const LAKEBOX_PORT_COUNT = 12000;
+/** Normalizes an authenticated identity before hashing. */
+export declare function normalizeLakeboxIdentity(identity: string): string;
+/**
+ * Derives the Lakebox account for one authenticated identity.
+ *
+ * @param routePrefix - AppKit root for user service routes.
+ */
+export declare function lakeboxUser(identity: string, routePrefix: string): LakeboxUser;
+/** Returns the persistent backing directory for a user hash. */
+export declare function lakeboxPersistentHome(userHash: string): string;
+/** Derives the loopback port for one user's service. */
+export declare function lakeboxServicePort(userHash: string, serviceName: string): number;
+/** Returns whether a route segment has the shape of a user hash. */
+export declare function isLakeboxUserHash(value: string): boolean;

package/lib/src/user.js

@@ -0,0 +1,76 @@
+/**
+ * Deterministic Lakebox user and service-port derivation.
+ *
+ * One FNV-1a hash of the authenticated identity is the only routing key. It
+ * selects the Linux account, UID, persistent home, AppKit route segment, and,
+ * with a service name, the loopback service port. Nothing here is persisted:
+ * every caller recomputes the same values, and collisions fail closed where
+ * they are observed.
+ *
+ * @module
+ */
+import { hash } from "@dbx-tools/shared-core";
+/** Platform account that owns the persistent volume and the SSH session. */
+export const LAKEBOX_AGENT_USER = "sandbox-agent";
+/** Persistent home mounted by the platform. Only this path survives a restart. */
+export const LAKEBOX_AGENT_HOME = `/home/${LAKEBOX_AGENT_USER}`;
+/** Root of package-owned persistent state. */
+export const LAKEBOX_STATE_ROOT = `${LAKEBOX_AGENT_HOME}/.dbx-tools`;
+/** Persistent backing directories for Lakebox user homes. */
+export const LAKEBOX_USERS_ROOT = `${LAKEBOX_STATE_ROOT}/users`;
+/** Shared read-only runtime binaries, such as the container bundle and ttyd. */
+export const LAKEBOX_RUNTIME_ROOT = `${LAKEBOX_STATE_ROOT}/runtime`;
+/** Per-boot runtime state root; reset with the root filesystem. */
+export const LAKEBOX_RUN_ROOT = "/run/lakebox";
+/** First derived Linux UID. The persistent idmapped volume stores UIDs below 65536. */
+export const LAKEBOX_UID_MIN = 20_000;
+/** Number of derivable UIDs. */
+export const LAKEBOX_UID_COUNT = 40_000;
+/** First derived service port. Platform listeners stay below this value. */
+export const LAKEBOX_PORT_MIN = 20_000;
+/** Number of derivable service ports; the kernel ephemeral range starts at 32768. */
+export const LAKEBOX_PORT_COUNT = 12_000;
+const USER_PREFIX = "lakebox-";
+const HASH_ALPHABET = "0123456789abcdefghijklmnopqrstuv";
+/** Normalizes an authenticated identity before hashing. */
+export function normalizeLakeboxIdentity(identity) {
+    const normalized = identity.trim().toLowerCase();
+    if (!normalized)
+        throw new Error("Lakebox users require an authenticated identity");
+    return normalized;
+}
+/**
+ * Derives the Lakebox account for one authenticated identity.
+ *
+ * @param routePrefix - AppKit root for user service routes.
+ */
+export function lakeboxUser(identity, routePrefix) {
+    const userHash = digestText("lakebox-user", normalizeLakeboxIdentity(identity));
+    const name = `${USER_PREFIX}${userHash}`;
+    return {
+        hash: userHash,
+        name,
+        uid: LAKEBOX_UID_MIN + (digestValue("lakebox-uid", userHash) % LAKEBOX_UID_COUNT),
+        home: `/home/${name}`,
+        routePrefix: `${routePrefix.replace(/\/+$/, "")}/${userHash}`,
+    };
+}
+/** Returns the persistent backing directory for a user hash. */
+export function lakeboxPersistentHome(userHash) {
+    return `${LAKEBOX_USERS_ROOT}/${userHash}`;
+}
+/** Derives the loopback port for one user's service. */
+export function lakeboxServicePort(userHash, serviceName) {
+    return (LAKEBOX_PORT_MIN + (digestValue("lakebox-port", userHash, serviceName) % LAKEBOX_PORT_COUNT));
+}
+/** Returns whether a route segment has the shape of a user hash. */
+export function isLakeboxUserHash(value) {
+    return /^[0-9a-v]{7}$/.test(value);
+}
+function digestText(...values) {
+    return hash.fnvHashWithOptions({ length: 7, alphabet: HASH_ALPHABET }, ...values);
+}
+function digestValue(...values) {
+    return Number.parseInt(digestText(...values), 32);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/workspace.d.ts

@@ -0,0 +1,43 @@
+import { MastraSandbox, type CommandResult, type ExecuteCommandOptions, type SandboxInfo, type SandboxStartOptions, type SandboxStartResult, type WorkspaceSandbox, type WorkspaceSandboxResolver } from "@mastra/core/workspace";
+import type { LakeboxRuntime } from "./runtime.ts";
+/** Options for the Lakebox-backed Mastra workspace sandbox. */
+export interface LakeboxWorkspaceSandboxOptions {
+    /** Optional display name presented by Mastra instead of Lakebox. */
+    displayName?: string;
+}
+/**
+ * Mastra workspace sandbox backed by the app Lakebox.
+ *
+ * Commands run as the requesting user's Lakebox account through the shared
+ * {@link LakeboxRuntime}, so identity, credential scrubbing, and transport
+ * policy match the AppKit plugin tools and routes.
+ */
+export declare class LakeboxWorkspaceSandbox extends MastraSandbox {
+    readonly id: string;
+    readonly name: string;
+    private readonly runtime;
+    private readonly identity;
+    readonly provider = "appkit-lakebox";
+    status: WorkspaceSandbox["status"];
+    constructor(id: string, name: string, runtime: LakeboxRuntime, identity: string);
+    /** Creates or starts the app Lakebox. */
+    start(options?: SandboxStartOptions): Promise<SandboxStartResult>;
+    /** Leaves the shared Lakebox running; its platform idle timeout stops it. */
+    stop(): Promise<void>;
+    /** Releases this handle without changing the shared Lakebox. */
+    destroy(): Promise<void>;
+    /** Mastra snapshot hook. Lakeboxes do not expose snapshot operations. */
+    snapshot(): Promise<void>;
+    /** Runs a command as the current user's Lakebox account. */
+    executeCommand(command: string, args?: string[], options?: ExecuteCommandOptions): Promise<CommandResult>;
+    /** Returns the current Lakebox status in Mastra's sandbox shape. */
+    getInfo(): Promise<SandboxInfo>;
+    /** Returns agent instructions for services, routes, and command execution. */
+    getInstructions(): string;
+}
+/**
+ * Creates a request-scoped Mastra workspace resolver for the app Lakebox.
+ *
+ * Resolution never creates compute; the first command or service does.
+ */
+export declare function lakeboxWorkspaceSandbox(runtime: LakeboxRuntime, options?: LakeboxWorkspaceSandboxOptions): WorkspaceSandboxResolver;