@dbx-tools/appkit-mastra 0.9.118 → 0.9.120

package/src/workspaces.ts

@@ -15,7 +15,6 @@
 import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { ConfigurationError } from "@databricks/appkit";
 import type { WorkspaceClient } from "@databricks/appkit";
 import { appkit, pluginRegistry } from "@dbx-tools/appkit";
 import {
@@ -25,7 +24,7 @@ import {
 } from "@dbx-tools/appkit/files-cache";
 import { DatabricksFileSystem, workspaceClient } from "@dbx-tools/databricks";
 import { LocalFileSystem } from "@dbx-tools/fs";
-import { match, type PathMatchInput } from "@dbx-tools/path";
+import { find, match, type PathMatchInput } from "@dbx-tools/path";
 import { errorUtils, log, object, stringUtils, token } from "@dbx-tools/shared-core";
 import {
   fs as sharedFS,
@@ -61,7 +60,6 @@ import {
 } from "./filesystems.ts";
 import { MontySandbox } from "./monty-sandbox.ts";
 import type { LocalSkillMount } from "./remote-skills.ts";
-import { DatabricksSandbox, type DatabricksWorkspaceSandboxOptions } from "./sandbox.ts";
 import { ORGANIZATION_ASSISTANT_PATH, personalWorkspacePath } from "./skill-paths.ts";
 
 /* ------------------------------ constants ------------------------------ */
@@ -79,6 +77,7 @@ const CACHEABLE_FILESYSTEM_OPERATIONS = [
 const logger = log.logger("mastra/workspaces");
 let workspaceSourceSequence = 0;
 const databricksWorkspaceOptions = new WeakMap<Workspace, DatabricksWorkspaceOptions>();
+const sharedSkillFilesystems = new Map<string, Promise<FileSystem>>();
 
 /* -------------------------------- types -------------------------------- */
 
@@ -174,16 +173,10 @@ type WorkspaceMountResolver = (
 
 /**
  * Sandbox selection for {@link databricksWorkspace}. Monty is the default;
- * command execution can be disabled or replaced with Databricks Sandbox or any
- * Mastra provider/resolver.
+ * command execution can be disabled or replaced with any Mastra provider/resolver.
  */
 export type WorkspaceSandboxSelection =
-  | false
-  | "databricks"
-  | "monty"
-  | DatabricksWorkspaceSandboxOptions
-  | WorkspaceSandbox
-  | WorkspaceSandboxResolver;
+  false | true | "monty" | WorkspaceSandbox | WorkspaceSandboxResolver;
 
 /** Native Mastra workspace options plus Databricks path shortcuts. */
 export interface DatabricksWorkspaceOptions extends Omit<
@@ -208,9 +201,8 @@ export interface DatabricksWorkspaceOptions extends Omit<
   /** AppKit plugin context used to discover optional sibling capabilities. */
   pluginContext?: pluginRegistry.PluginContextLike;
   /**
-   * Command sandbox. Defaults to Monty. Pass `false` to disable it,
-   * `"databricks"` or Databricks Sandbox options to select the remote provider,
-   * or an explicit Mastra sandbox/provider resolver.
+   * Command sandbox. Defaults to Monty. Pass `false` to disable it, or an
+   * explicit Mastra sandbox/provider resolver for a remote transport.
    */
   sandbox?: WorkspaceSandboxSelection;
   /** Add user-scoped `/tmp` only when no configured Databricks path mounts writable. */
@@ -418,49 +410,9 @@ function resolveWorkspaceSandbox(
 ): WorkspaceSandbox | WorkspaceSandboxResolver | undefined {
   const configured = selection ?? "monty";
   if (configured === false) return undefined;
-  if (configured === "monty") return new MontySandbox();
+  if (configured === true || configured === "monty") return new MontySandbox();
   if (typeof configured === "function" || isSandbox(configured)) return configured;
-
-  const options: DatabricksWorkspaceSandboxOptions =
-    configured === "databricks" ? { provider: "databricks" } : configured;
-  return ({ requestContext }) => {
-    const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;
-    if (!user) {
-      throw ConfigurationError.resourceNotFound(
-        "Databricks sandbox user context",
-        "Invoke command tools from an agent turn served by the Mastra plugin.",
-      );
-    }
-    const configuredId =
-      typeof options.sandboxId === "function"
-        ? options.sandboxId({ requestContext })
-        : options.sandboxId;
-    const sandboxId = configuredId ?? defaultSandboxId(workspaceId, user.id);
-    const client =
-      typeof options.client === "function"
-        ? options.client({ requestContext })
-        : (options.client ?? (user.executionContext.client as WorkspaceClient));
-    const {
-      provider: _provider,
-      sandboxId: _sandboxId,
-      client: _client,
-      ...sandboxOptions
-    } = options;
-    return new DatabricksSandbox({
-      ...sandboxOptions,
-      client,
-      sandboxId,
-      displayName: options.displayName ?? `Mastra ${workspaceName}`,
-    });
-  };
-}
-
-function defaultSandboxId(workspaceId: string, userId: string): string {
-  const digest = createHash("sha256")
-    .update(object.toStableKey({ workspaceId, userId }))
-    .digest("hex")
-    .slice(0, 32);
-  return `mastra-${digest}`;
+  throw new TypeError(`Unsupported workspace sandbox for ${workspaceId} (${workspaceName})`);
 }
 
 function isSandbox(value: unknown): value is WorkspaceSandbox {
@@ -471,10 +423,9 @@ function isSandbox(value: unknown): value is WorkspaceSandbox {
 
 function sandboxName(selection: WorkspaceSandboxSelection | undefined): string {
   if (selection === undefined || selection === false) return "disabled";
-  if (selection === "monty") return "monty";
-  if (selection === "databricks") return "databricks";
+  if (selection === true || selection === "monty") return "monty";
   if (typeof selection === "function") return "resolver";
-  return isSandbox(selection) ? selection.provider : (selection.provider ?? "databricks");
+  return selection.provider;
 }
 
 /**
@@ -844,25 +795,58 @@ function userTempFilesystem(
 function localSkillMountResolvers(mounts: readonly LocalSkillMount[]): WorkspaceMountResolver[] {
   const unique = new Map<string, LocalSkillMount>();
   for (const entry of mounts) {
-    const root = entry.root.trim();
-    if (!root) continue;
-    unique.set(`${entry.mountPath}\0${root}`, { root, mountPath: entry.mountPath });
+    const identity = "root" in entry ? entry.root.trim() : entry.filesystem.id;
+    if (!identity) continue;
+    unique.set(`${entry.mountPath}\0${identity}`, entry);
   }
-  return [...unique.values()].map(({ root, mountPath }) => {
-    const mount = posixPath.normalizeRoot(mountPath);
-    const source = new LocalFileSystem({
-      root,
-      readOnly: true,
-      createRoot: false,
-    });
-    const filesystem = filesystems(source, { readOnly: true });
-    return () => ({
-      mounts: { [mount]: filesystem },
-      skillPaths: [mount],
-    });
+  return [...unique.values()].map((entry) => {
+    const mount = posixPath.normalizeRoot(entry.mountPath);
+    const filesystem = inMemorySkillFilesystem(entry);
+    return async () => {
+      const source = await filesystem;
+      return {
+        mounts: { [mount]: filesystems(source, { readOnly: true }) },
+        skillPaths: [mount],
+      };
+    };
   });
 }
 
+function inMemorySkillFilesystem(mount: LocalSkillMount): Promise<FileSystem> {
+  const key = "root" in mount ? `root:${mount.root}` : `filesystem:${mount.filesystem.id}`;
+  const existing = sharedSkillFilesystems.get(key);
+  if (existing) return existing;
+  const loaded = loadInMemorySkillFilesystem(mount).catch((error) => {
+    if (sharedSkillFilesystems.get(key) === loaded) sharedSkillFilesystems.delete(key);
+    throw error;
+  });
+  sharedSkillFilesystems.set(key, loaded);
+  return loaded;
+}
+
+async function loadInMemorySkillFilesystem(mount: LocalSkillMount): Promise<FileSystem> {
+  if ("filesystem" in mount) {
+    await mount.filesystem.init();
+    return mount.filesystem;
+  }
+  const source = new LocalFileSystem({
+    root: mount.root,
+    readOnly: true,
+    createRoot: false,
+  });
+  await source.init();
+  const memory = new MemoryFileSystem({
+    id: `skills-${createHash("sha256").update(mount.root).digest("hex").slice(0, 16)}`,
+    root: "/",
+  });
+  await memory.init();
+  for await (const relative of find.findFiles("**/*", { cwd: mount.root, nodir: true })) {
+    await memory.writeFile(relative, await source.readFile(relative), { overwrite: true });
+  }
+  await source.close();
+  return memory;
+}
+
 /**
  * Gate skill-folder mounts on the request's token.
  *
@@ -912,7 +896,7 @@ async function databricksFilesystem(
     logger.debug("databricks-mount:skipped", {
       root,
       readOnly,
-      error: errorUtils.errorMessage(err),
+      error: errorUtils.toError(err),
     });
   }
   return undefined;
@@ -961,7 +945,7 @@ function verifyFirstFileSystemAccess<TFileSystem extends FileSystem>(
       readCheck = undefined;
       logger.debug("databricks-mount:read-check-failed", {
         root,
-        error: errorUtils.errorMessage(error),
+        error: errorUtils.toError(error),
       });
       throw error;
     }
@@ -992,7 +976,7 @@ function verifyFirstFileSystemAccess<TFileSystem extends FileSystem>(
             if (!writeVerified) {
               logger.debug("databricks-mount:write-check-failed", {
                 root,
-                error: errorUtils.errorMessage(error),
+                error: errorUtils.toError(error),
               });
             }
             throw error;
@@ -1095,7 +1079,7 @@ async function resolveDistinctSkillPaths(
     } catch (error) {
       logger.debug("skill-path:skipped", {
         path,
-        error: errorUtils.errorMessage(error),
+        error: errorUtils.toError(error),
       });
     }
   }

package/src/writer.ts

@@ -44,7 +44,7 @@ export async function safeWriteProgress(
   } catch (err) {
     log.warn("writer:error", {
       ...context,
-      error: errorUtils.errorMessage(err),
+      error: errorUtils.toError(err),
     });
   }
 }

package/lib/src/sandbox.d.ts

@@ -1,107 +0,0 @@
-/**
- * Databricks Sandbox adapter for Mastra workspaces.
- *
- * Implements Mastra's foreground command surface over the Databricks Sandbox
- * REST API. Sandboxes are created lazily, retain their home directory across
- * inactivity stops, and execute untrusted shell commands outside the App
- * container.
- *
- * @module
- */
-import type { WorkspaceClient } from "@databricks/appkit";
-import type { RequestContext } from "@mastra/core/request-context";
-import type { CommandResult, ExecuteCommandOptions, ProviderStatus, SandboxInfo, WorkspaceSandbox } from "@mastra/core/workspace";
-import { type MontySandboxOptions } from "./monty-sandbox.ts";
-/** Options for one Databricks-backed Mastra sandbox. */
-export interface DatabricksSandboxOptions {
-    /** AppKit workspace client used for every sandbox API call. */
-    client: WorkspaceClient;
-    /** Resource id, with or without the `sandboxes/` prefix. */
-    sandboxId: string;
-    /** Human-readable Databricks label. */
-    displayName?: string;
-    /** Server-side idle timeout in protobuf duration form. Defaults to `900s`. */
-    inactivityTimeout?: string;
-    /** Maximum time to wait for the sandbox to become runnable. */
-    startupTimeoutMs?: number;
-    /** Default command timeout. Per-call `options.timeout` wins. */
-    commandTimeoutMs?: number;
-    /**
-     * Provider used only when Databricks Sandbox is definitively unavailable.
-     * Disabled by default. Pass `"monty"`, Monty options, or another Mastra
-     * sandbox to enable a fallback explicitly.
-     */
-    fallback?: false | "monty" | MontySandboxOptions | WorkspaceSandbox;
-}
-/** Databricks options accepted by the higher-level workspace factory. */
-export interface DatabricksWorkspaceSandboxOptions extends Omit<DatabricksSandboxOptions, "client" | "sandboxId"> {
-    /** Provider discriminator. Defaults to `databricks`. */
-    provider?: "databricks";
-    /**
-     * Credential source. Defaults to the active request's AppKit client, which
-     * uses OBO credentials when the turn runs in a user context.
-     */
-    client?: WorkspaceClient | ((context: {
-        requestContext: RequestContext;
-    }) => WorkspaceClient);
-    /**
-     * Fixed id or per-request resolver. Omit to derive a stable, opaque id from
-     * the workspace and attributed user.
-     */
-    sandboxId?: string | ((context: {
-        requestContext: RequestContext;
-    }) => string);
-}
-/** Mastra sandbox backed by Databricks serverless Sandbox compute. */
-export declare class DatabricksSandbox implements WorkspaceSandbox {
-    readonly id: string;
-    readonly name: string;
-    status: ProviderStatus;
-    error?: string;
-    private readonly client;
-    private readonly displayName;
-    private readonly inactivityTimeout;
-    private readonly startupTimeoutMs;
-    private readonly commandTimeoutMs;
-    private readonly fallbackConfig;
-    private readonly createdAt;
-    private remoteCreatedAt?;
-    private lastUsedAt?;
-    private activeFallback?;
-    private fallbackPromise?;
-    private startPromise?;
-    constructor(options: DatabricksSandboxOptions);
-    get provider(): string;
-    /** Ensure the remote sandbox exists and has reached its running state. */
-    start(): Promise<void>;
-    private startWithSignal;
-    private performStart;
-    /** Databricks home persistence is not a cloneable Mastra checkpoint. */
-    snapshot(): Promise<void>;
-    get supportsCheckpoints(): boolean;
-    /** Stop compute while preserving the sandbox home directory. */
-    stop(): Promise<void>;
-    /** Permanently delete the sandbox and its persisted home directory. */
-    destroy(): Promise<void>;
-    /** Execute one foreground shell command in the remote sandbox. */
-    executeCommand(command: string, args?: string[], options?: ExecuteCommandOptions): Promise<CommandResult>;
-    /** Activate the configured fallback once across concurrent command failures. */
-    private activateFallback;
-    /** Start and publish the configured fallback after rechecking active state. */
-    private startFallback;
-    /** Execute through the active fallback or return an unsupported result. */
-    private executeFallback;
-    /** Whether the adapter currently knows the remote sandbox to be running. */
-    isReady(): Promise<boolean>;
-    /** Report Mastra-facing sandbox metadata. */
-    getInfo(): Promise<SandboxInfo>;
-    /** Explain the Databricks execution boundary to the agent. */
-    getInstructions(): string;
-    private get resourcePath();
-    private getOrCreate;
-    private get;
-    private mutate;
-    private waitForState;
-    private rememberCreatedAt;
-    private request;
-}