@dbx-tools/appkit-mastra 0.6.4 → 0.6.6

package/lib/src/remote-skills.js

@@ -0,0 +1,302 @@
+/**
+ * Startup provisioning of remote Agent-Skill sources for a Mastra workspace.
+ *
+ * A {@link RemoteSkillSource} names WHERE a `SKILL.md` tree comes from - a
+ * GitHub `owner/repo`, any git / GitLab URL, or a direct download URL - and
+ * optional per-source policy. {@link provisionRemoteSkills} materializes every
+ * source into a local `SKILL.md` tree at app boot and returns the directories
+ * to hand Mastra as extra skill scan paths.
+ *
+ * Resolution per source, in order:
+ *
+ * 1. the OPTIONAL `skills` npm CLI (peer dep): if installed, each source is
+ *    copied into a staging dir with `skills add <source> --agent <dir> --copy`,
+ *    which understands every source format the ecosystem does (GitHub
+ *    shorthand, git URLs, archive/download URLs);
+ * 2. otherwise a plain {@link fetch} of the source URL (built with
+ *    {@link net.urlBuilder}), writing the downloaded `SKILL.md` to a staging
+ *    dir.
+ *
+ * A source that resolves through neither path fails app startup, unless the
+ * source (or the top-level call) sets `failOnError: false`, in which case it is
+ * logged and skipped so one bad source never takes the app down.
+ *
+ * The default destination is the Databricks workspace Assistant skills tree
+ * (`/Workspace/.assistant/skills`, the same tree a "save this as a skill"
+ * action writes to), so provisioned skills persist across restarts and are
+ * discovered by the built-in Assistant-skills mount. Pass `userEmail` (or an
+ * explicit `databricksBasePath`) to target `/Users/<email>/.assistant/skills`
+ * instead. When no Databricks client is resolvable at startup, the tree is
+ * written to a local temp dir and returned as an extra local skill path for
+ * the current process.
+ *
+ * @module
+ */
+import { mkdtemp, cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join, posix } from "node:path";
+import { appkit } from "@dbx-tools/appkit";
+import { spawn } from "@dbx-tools/core";
+import { findFiles } from "@dbx-tools/path";
+import { error, log, net, string } from "@dbx-tools/shared-core";
+import { DatabricksWorkspaceFilesystem } from "./filesystems.js";
+const logger = log.logger("mastra/remote-skills");
+/** Shared Assistant skills tree in the Databricks workspace (default target). */
+const ASSISTANT_SHARED_SKILLS_PATH = "/Workspace/.assistant/skills";
+/** Assistant skills directory for a specific Databricks user. */
+function userAssistantSkillsPath(userEmail) {
+    return `/Users/${userEmail.trim()}/.assistant/skills`;
+}
+/** npm agent id the `skills` CLI installs a bare `SKILL.md` tree under. */
+const SKILLS_CLI_AGENT = "agents";
+/** Where the `skills` CLI drops a plain `SKILL.md` tree under a target dir. */
+const SKILLS_CLI_LAYOUT = [".agents", "skills"];
+/** Cap on a direct-fetch download body, matching the `skills` CLI default. */
+const DEFAULT_MAX_DOWNLOAD_BYTES = 10 * 1024 * 1024;
+/* ------------------------------- helpers ------------------------------- */
+/** Normalize the `remoteSkills` option into a flat options bag. */
+export function normalizeRemoteSkillsOption(option) {
+    if (option === undefined)
+        return undefined;
+    if (typeof option === "string")
+        return { sources: [option] };
+    if (Array.isArray(option))
+        return option.length > 0 ? { sources: option } : undefined;
+    if (isProvisionOptions(option)) {
+        const sources = Array.isArray(option.sources) ? option.sources : [option.sources];
+        return sources.length > 0 ? { ...option, sources } : undefined;
+    }
+    // A lone RemoteSkillSourceOptions object.
+    return { sources: [option] };
+}
+/** A `sources`-bearing bag is the top-level options shape, not a single source. */
+function isProvisionOptions(value) {
+    return "sources" in value;
+}
+/** Coerce a source entry to its normalized {@link RemoteSkillSourceOptions}. */
+function toSourceOptions(source) {
+    return typeof source === "string" ? { source } : source;
+}
+/**
+ * Materialize every configured remote skill source at app startup.
+ *
+ * Writes each resolved `SKILL.md` tree to the Databricks user Assistant skills
+ * folder when a writable workspace is available, else to a local temp dir
+ * returned in {@link ProvisionedRemoteSkills.localSkillPaths}.
+ */
+export async function provisionRemoteSkills(option) {
+    const options = normalizeRemoteSkillsOption(option);
+    const empty = { localSkillPaths: [], skillNames: [] };
+    if (!options)
+        return empty;
+    const failDefault = options.failOnError !== false;
+    const client = options.client ?? appkit.tryGetExecutionContext()?.client;
+    const databricksBasePath = resolveDatabricksBasePath(options, client);
+    const destination = databricksBasePath
+        ? new DatabricksWorkspaceFilesystem({ client, basePath: databricksBasePath, readOnly: false })
+        : undefined;
+    const localSkillPaths = [];
+    const skillNames = [];
+    let staging;
+    try {
+        const sources = Array.isArray(options.sources) ? options.sources : [options.sources];
+        for (const entry of sources) {
+            const sourceOptions = toSourceOptions(entry);
+            const failOnError = sourceOptions.failOnError ?? failDefault;
+            try {
+                staging ??= await mkdtemp(join(tmpdir(), "mastra-remote-skills-"));
+                const stagedDir = await stageSource(sourceOptions, staging, options);
+                const staged = await collectSkillDirs(stagedDir);
+                if (staged.length === 0) {
+                    throw new Error(`no SKILL.md found for source "${sourceOptions.source}"`);
+                }
+                if (destination && databricksBasePath) {
+                    await uploadSkillDirs(destination, staged);
+                    skillNames.push(...staged.map((dir) => dir.name));
+                }
+                else {
+                    const localDir = await persistLocally(staged);
+                    localSkillPaths.push(localDir);
+                    skillNames.push(...staged.map((dir) => dir.name));
+                }
+                logger.debug("source:provisioned", {
+                    source: sourceOptions.source,
+                    destination: databricksBasePath ?? "local-temp",
+                    skills: staged.map((dir) => dir.name),
+                });
+            }
+            catch (err) {
+                if (failOnError) {
+                    throw new Error(`failed to provision remote skill source "${sourceOptions.source}": ${error.errorMessage(err)}`, { cause: error.toError(err) });
+                }
+                logger.warn("source:skipped", {
+                    source: sourceOptions.source,
+                    error: error.errorMessage(err),
+                });
+            }
+        }
+    }
+    finally {
+        if (staging)
+            await rm(staging, { recursive: true, force: true }).catch(() => undefined);
+    }
+    return { localSkillPaths, databricksBasePath, skillNames };
+}
+/** Resolve the Databricks Assistant skills destination, or `undefined` for local temp. */
+function resolveDatabricksBasePath(options, client) {
+    if (!client)
+        return undefined;
+    if (options.databricksBasePath)
+        return options.databricksBasePath.trim() || undefined;
+    const email = string.trimToNull(options.userEmail);
+    // A named user targets their personal Assistant tree (the "save a skill"
+    // target); otherwise the shared workspace Assistant tree, which the built-in
+    // Assistant-skills mount already scans.
+    return email ? userAssistantSkillsPath(email) : ASSISTANT_SHARED_SKILLS_PATH;
+}
+/**
+ * Stage one source into a fresh dir under `staging`, preferring the optional
+ * `skills` CLI and falling back to a direct fetch.
+ */
+async function stageSource(sourceOptions, staging, options) {
+    const target = await mkdtemp(join(staging, "src-"));
+    const viaCli = await stageViaSkillsCli(sourceOptions, target);
+    if (viaCli)
+        return viaCli;
+    return stageViaFetch(sourceOptions, target, options);
+}
+/**
+ * Copy a source into `target` with the `skills` CLI when it is installed.
+ * Returns the dir holding the copied `SKILL.md` trees, or `undefined` when the
+ * CLI is absent (so the caller can fall back to a fetch).
+ */
+async function stageViaSkillsCli(sourceOptions, target) {
+    const cli = await resolveSkillsCli();
+    if (!cli)
+        return undefined;
+    const args = [
+        ...cli.args,
+        "add",
+        sourceOptions.source,
+        "--agent",
+        SKILLS_CLI_AGENT,
+        "--copy",
+        "-y",
+    ];
+    for (const skill of string.parseList(sourceOptions.skills)) {
+        args.push("--skill", skill);
+    }
+    if (string.parseList(sourceOptions.skills).length === 0)
+        args.push("--skill", "*");
+    const result = await spawn(cli.command, args, {
+        cwd: target,
+        stdout: "capture",
+        stderr: "capture",
+        check: false,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`skills CLI failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+    return join(target, ...SKILLS_CLI_LAYOUT);
+}
+/**
+ * Locate the optional `skills` CLI bin, resolved from THIS package's module
+ * graph. Returns `undefined` when the peer dep isn't installed, so the caller
+ * falls back to a direct fetch.
+ */
+async function resolveSkillsCli() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("skills/package.json");
+        const bin = join(pkgPath, "..", "bin", "cli.mjs");
+        if (await pathExists(bin))
+            return { command: process.execPath, args: [bin] };
+    }
+    catch {
+        // peer dep absent or unresolvable - fetch fallback handles it
+    }
+    return undefined;
+}
+/**
+ * Fetch a source URL and write the downloaded `SKILL.md` under `target`.
+ * Used when the `skills` CLI isn't installed; supports a direct `SKILL.md` URL.
+ */
+async function stageViaFetch(sourceOptions, target, options) {
+    const url = net.urlBuilder(sourceOptions.source);
+    if (!url) {
+        throw new Error(`source "${sourceOptions.source}" is not a URL and the optional "skills" package is not installed`);
+    }
+    const maxBytes = sourceOptions.maxDownloadBytes ?? options.maxDownloadBytes ?? DEFAULT_MAX_DOWNLOAD_BYTES;
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        throw new Error(`download failed: ${response.status} ${response.statusText} (${url.toString()})`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.byteLength > maxBytes) {
+        throw new Error(`download exceeds ${maxBytes} bytes (${url.toString()})`);
+    }
+    const name = string.toSlug(deriveSkillName(url.toString())) || "remote-skill";
+    const skillDir = join(target, name);
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(join(skillDir, "SKILL.md"), buffer);
+    return target;
+}
+/** Derive a skill directory name from a download URL's last path segment. */
+function deriveSkillName(urlString) {
+    const url = net.urlBuilder(urlString);
+    const last = url?.pathname.split("/").filter(Boolean).pop() ?? "";
+    return last.replace(/\.(md|zip|tar|tgz|gz)$/i, "");
+}
+/**
+ * Collect every skill directory under `root`: a `root/SKILL.md` (root IS the
+ * skill) or each immediate child dir that contains a `SKILL.md`.
+ */
+async function collectSkillDirs(root) {
+    if (!(await pathExists(root)))
+        return [];
+    if (await pathExists(join(root, "SKILL.md"))) {
+        const name = posix.basename(root.split(/[\\/]/).join("/"));
+        return [{ name, absolutePath: root }];
+    }
+    const dirs = [];
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = join(root, entry.name);
+        if (await pathExists(join(dir, "SKILL.md"))) {
+            dirs.push({ name: entry.name, absolutePath: dir });
+        }
+    }
+    return dirs;
+}
+/** Upload each staged skill directory into the Databricks destination tree. */
+async function uploadSkillDirs(destination, dirs) {
+    await destination.init?.();
+    for (const dir of dirs) {
+        for (const relative of findFiles("**/*", { cwd: dir.absolutePath, nodir: true })) {
+            const buffer = await readFile(join(dir.absolutePath, relative));
+            const remotePath = posix.join("/", dir.name, relative.split(/[\\/]/).join("/"));
+            await destination.writeFile(remotePath, buffer, { overwrite: true });
+        }
+    }
+}
+/** Copy staged skill dirs into a persistent local temp dir; return its path. */
+async function persistLocally(dirs) {
+    const base = await mkdtemp(join(tmpdir(), "mastra-local-skills-"));
+    for (const dir of dirs) {
+        await cp(dir.absolutePath, join(base, dir.name), { recursive: true });
+    }
+    return base;
+}
+/** Best-effort existence check. */
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-skills.js","sourceRoot":"","sources":["../../src/remote-skills.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Startup provisioning of remote Agent-Skill sources for a Mastra workspace.\n *\n * A {@link RemoteSkillSource} names WHERE a `SKILL.md` tree comes from - a\n * GitHub `owner/repo`, any git / GitLab URL, or a direct download URL - and\n * optional per-source policy. {@link provisionRemoteSkills} materializes every\n * source into a local `SKILL.md` tree at app boot and returns the directories\n * to hand Mastra as extra skill scan paths.\n *\n * Resolution per source, in order:\n *\n * 1. the OPTIONAL `skills` npm CLI (peer dep): if installed, each source is\n *    copied into a staging dir with `skills add <source> --agent <dir> --copy`,\n *    which understands every source format the ecosystem does (GitHub\n *    shorthand, git URLs, archive/download URLs);\n * 2. otherwise a plain {@link fetch} of the source URL (built with\n *    {@link net.urlBuilder}), writing the downloaded `SKILL.md` to a staging\n *    dir.\n *\n * A source that resolves through neither path fails app startup, unless the\n * source (or the top-level call) sets `failOnError: false`, in which case it is\n * logged and skipped so one bad source never takes the app down.\n *\n * The default destination is the Databricks workspace Assistant skills tree\n * (`/Workspace/.assistant/skills`, the same tree a \"save this as a skill\"\n * action writes to), so provisioned skills persist across restarts and are\n * discovered by the built-in Assistant-skills mount. Pass `userEmail` (or an\n * explicit `databricksBasePath`) to target `/Users/<email>/.assistant/skills`\n * instead. When no Databricks client is resolvable at startup, the tree is\n * written to a local temp dir and returned as an extra local skill path for\n * the current process.\n *\n * @module\n */\n\nimport { mkdtemp, cp, mkdir, readdir, readFile, rm, stat, writeFile } from \"node:fs/promises\";\nimport { createRequire } from \"node:module\";\nimport { tmpdir } from \"node:os\";\nimport { join, posix } from \"node:path\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport type { WorkspaceClientLike } from \"@dbx-tools/appkit\";\nimport { spawn } from \"@dbx-tools/core\";\nimport { findFiles } from \"@dbx-tools/path\";\nimport { error, log, net, string } from \"@dbx-tools/shared-core\";\n\nimport { DatabricksWorkspaceFilesystem } from \"./filesystems.ts\";\n\nconst logger = log.logger(\"mastra/remote-skills\");\n\n/** Shared Assistant skills tree in the Databricks workspace (default target). */\nconst ASSISTANT_SHARED_SKILLS_PATH = \"/Workspace/.assistant/skills\";\n\n/** Assistant skills directory for a specific Databricks user. */\nfunction userAssistantSkillsPath(userEmail: string): string {\n  return `/Users/${userEmail.trim()}/.assistant/skills`;\n}\n\n/** npm agent id the `skills` CLI installs a bare `SKILL.md` tree under. */\nconst SKILLS_CLI_AGENT = \"agents\";\n\n/** Where the `skills` CLI drops a plain `SKILL.md` tree under a target dir. */\nconst SKILLS_CLI_LAYOUT = [\".agents\", \"skills\"] as const;\n\n/** Cap on a direct-fetch download body, matching the `skills` CLI default. */\nconst DEFAULT_MAX_DOWNLOAD_BYTES = 10 * 1024 * 1024;\n\n/* -------------------------------- types -------------------------------- */\n\n/**\n * One remote skill source and its per-source policy.\n *\n * `source` is anything the `skills` ecosystem understands: a GitHub\n * `owner/repo` shorthand, a full GitHub / GitLab / git URL, or a direct\n * download URL to a `SKILL.md` or archive.\n */\nexport interface RemoteSkillSourceOptions {\n  /** GitHub shorthand, git / GitLab URL, or a direct download URL. */\n  source: string;\n  /** Install only these skill names from the source (CLI path only). */\n  skills?: string | string[];\n  /** Override the byte ceiling on a direct-fetch download for this source. */\n  maxDownloadBytes?: number;\n  /**\n   * When `false`, a source that fails to resolve is logged and skipped instead\n   * of failing app startup. Overrides the top-level {@link ProvisionRemoteSkillsOptions.failOnError}.\n   */\n  failOnError?: boolean;\n}\n\n/**\n * A remote skill source: a bare source string (GitHub shorthand / URL) or a\n * {@link RemoteSkillSourceOptions} with per-source policy.\n */\nexport type RemoteSkillSource = string | RemoteSkillSourceOptions;\n\n/**\n * The workspace `remoteSkills` option. A single source, a list, or a\n * {@link ProvisionRemoteSkillsOptions} bag when top-level policy is needed.\n */\nexport type RemoteSkillsOption =\n  RemoteSkillSource | RemoteSkillSource[] | ProvisionRemoteSkillsOptions;\n\n/** Top-level remote-skills provisioning options. */\nexport interface ProvisionRemoteSkillsOptions {\n  /** Sources to materialize at startup. */\n  sources: RemoteSkillSource | RemoteSkillSource[];\n  /**\n   * Fail app startup when a source can't be resolved. Defaults to `true`. A\n   * per-source `failOnError` wins over this.\n   */\n  failOnError?: boolean;\n  /**\n   * Absolute Databricks path that roots the destination Assistant skills tree.\n   * Defaults to the OBO user's `/Users/<email>/.assistant/skills`.\n   */\n  databricksBasePath?: string;\n  /** Auth-scoped Databricks client. Defaults to the AppKit execution context. */\n  client?: WorkspaceClientLike;\n  /** User email used to derive the default Databricks destination. */\n  userEmail?: string;\n  /** Byte ceiling on a direct-fetch download. Defaults to 10 MiB. */\n  maxDownloadBytes?: number;\n}\n\n/** What {@link provisionRemoteSkills} resolved. */\nexport interface ProvisionedRemoteSkills {\n  /**\n   * Extra LOCAL skill scan paths to hand Mastra (a temp dir per source that\n   * couldn't be written to Databricks). Empty when everything landed in the\n   * Databricks Assistant tree, which the built-in mount already scans.\n   */\n  localSkillPaths: string[];\n  /** Absolute Databricks destination each source was written to, if any. */\n  databricksBasePath?: string;\n  /** Names of every skill directory that was provisioned. */\n  skillNames: string[];\n}\n\n/* ------------------------------- helpers ------------------------------- */\n\n/** Normalize the `remoteSkills` option into a flat options bag. */\nexport function normalizeRemoteSkillsOption(\n  option: RemoteSkillsOption | undefined,\n): ProvisionRemoteSkillsOptions | undefined {\n  if (option === undefined) return undefined;\n  if (typeof option === \"string\") return { sources: [option] };\n  if (Array.isArray(option)) return option.length > 0 ? { sources: option } : undefined;\n  if (isProvisionOptions(option)) {\n    const sources = Array.isArray(option.sources) ? option.sources : [option.sources];\n    return sources.length > 0 ? { ...option, sources } : undefined;\n  }\n  // A lone RemoteSkillSourceOptions object.\n  return { sources: [option] };\n}\n\n/** A `sources`-bearing bag is the top-level options shape, not a single source. */\nfunction isProvisionOptions(\n  value: RemoteSkillSourceOptions | ProvisionRemoteSkillsOptions,\n): value is ProvisionRemoteSkillsOptions {\n  return \"sources\" in value;\n}\n\n/** Coerce a source entry to its normalized {@link RemoteSkillSourceOptions}. */\nfunction toSourceOptions(source: RemoteSkillSource): RemoteSkillSourceOptions {\n  return typeof source === \"string\" ? { source } : source;\n}\n\n/**\n * Materialize every configured remote skill source at app startup.\n *\n * Writes each resolved `SKILL.md` tree to the Databricks user Assistant skills\n * folder when a writable workspace is available, else to a local temp dir\n * returned in {@link ProvisionedRemoteSkills.localSkillPaths}.\n */\nexport async function provisionRemoteSkills(\n  option: RemoteSkillsOption | undefined,\n): Promise<ProvisionedRemoteSkills> {\n  const options = normalizeRemoteSkillsOption(option);\n  const empty: ProvisionedRemoteSkills = { localSkillPaths: [], skillNames: [] };\n  if (!options) return empty;\n\n  const failDefault = options.failOnError !== false;\n  const client = options.client ?? appkit.tryGetExecutionContext()?.client;\n  const databricksBasePath = resolveDatabricksBasePath(options, client);\n  const destination = databricksBasePath\n    ? new DatabricksWorkspaceFilesystem({ client, basePath: databricksBasePath, readOnly: false })\n    : undefined;\n\n  const localSkillPaths: string[] = [];\n  const skillNames: string[] = [];\n  let staging: string | undefined;\n\n  try {\n    const sources = Array.isArray(options.sources) ? options.sources : [options.sources];\n    for (const entry of sources) {\n      const sourceOptions = toSourceOptions(entry);\n      const failOnError = sourceOptions.failOnError ?? failDefault;\n      try {\n        staging ??= await mkdtemp(join(tmpdir(), \"mastra-remote-skills-\"));\n        const stagedDir = await stageSource(sourceOptions, staging, options);\n        const staged = await collectSkillDirs(stagedDir);\n        if (staged.length === 0) {\n          throw new Error(`no SKILL.md found for source \"${sourceOptions.source}\"`);\n        }\n        if (destination && databricksBasePath) {\n          await uploadSkillDirs(destination, staged);\n          skillNames.push(...staged.map((dir) => dir.name));\n        } else {\n          const localDir = await persistLocally(staged);\n          localSkillPaths.push(localDir);\n          skillNames.push(...staged.map((dir) => dir.name));\n        }\n        logger.debug(\"source:provisioned\", {\n          source: sourceOptions.source,\n          destination: databricksBasePath ?? \"local-temp\",\n          skills: staged.map((dir) => dir.name),\n        });\n      } catch (err) {\n        if (failOnError) {\n          throw new Error(\n            `failed to provision remote skill source \"${sourceOptions.source}\": ${error.errorMessage(err)}`,\n            { cause: error.toError(err) },\n          );\n        }\n        logger.warn(\"source:skipped\", {\n          source: sourceOptions.source,\n          error: error.errorMessage(err),\n        });\n      }\n    }\n  } finally {\n    if (staging) await rm(staging, { recursive: true, force: true }).catch(() => undefined);\n  }\n\n  return { localSkillPaths, databricksBasePath, skillNames };\n}\n\n/** Resolve the Databricks Assistant skills destination, or `undefined` for local temp. */\nfunction resolveDatabricksBasePath(\n  options: ProvisionRemoteSkillsOptions,\n  client: WorkspaceClientLike | undefined,\n): string | undefined {\n  if (!client) return undefined;\n  if (options.databricksBasePath) return options.databricksBasePath.trim() || undefined;\n  const email = string.trimToNull(options.userEmail);\n  // A named user targets their personal Assistant tree (the \"save a skill\"\n  // target); otherwise the shared workspace Assistant tree, which the built-in\n  // Assistant-skills mount already scans.\n  return email ? userAssistantSkillsPath(email) : ASSISTANT_SHARED_SKILLS_PATH;\n}\n\n/**\n * Stage one source into a fresh dir under `staging`, preferring the optional\n * `skills` CLI and falling back to a direct fetch.\n */\nasync function stageSource(\n  sourceOptions: RemoteSkillSourceOptions,\n  staging: string,\n  options: ProvisionRemoteSkillsOptions,\n): Promise<string> {\n  const target = await mkdtemp(join(staging, \"src-\"));\n  const viaCli = await stageViaSkillsCli(sourceOptions, target);\n  if (viaCli) return viaCli;\n  return stageViaFetch(sourceOptions, target, options);\n}\n\n/**\n * Copy a source into `target` with the `skills` CLI when it is installed.\n * Returns the dir holding the copied `SKILL.md` trees, or `undefined` when the\n * CLI is absent (so the caller can fall back to a fetch).\n */\nasync function stageViaSkillsCli(\n  sourceOptions: RemoteSkillSourceOptions,\n  target: string,\n): Promise<string | undefined> {\n  const cli = await resolveSkillsCli();\n  if (!cli) return undefined;\n\n  const args = [\n    ...cli.args,\n    \"add\",\n    sourceOptions.source,\n    \"--agent\",\n    SKILLS_CLI_AGENT,\n    \"--copy\",\n    \"-y\",\n  ];\n  for (const skill of string.parseList(sourceOptions.skills)) {\n    args.push(\"--skill\", skill);\n  }\n  if (string.parseList(sourceOptions.skills).length === 0) args.push(\"--skill\", \"*\");\n\n  const result = await spawn(cli.command, args, {\n    cwd: target,\n    stdout: \"capture\",\n    stderr: \"capture\",\n    check: false,\n  });\n  if (result.exitCode !== 0) {\n    throw new Error(\n      `skills CLI failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`,\n    );\n  }\n  return join(target, ...SKILLS_CLI_LAYOUT);\n}\n\n/**\n * Locate the optional `skills` CLI bin, resolved from THIS package's module\n * graph. Returns `undefined` when the peer dep isn't installed, so the caller\n * falls back to a direct fetch.\n */\nasync function resolveSkillsCli(): Promise<{ command: string; args: string[] } | undefined> {\n  try {\n    const require = createRequire(import.meta.url);\n    const pkgPath = require.resolve(\"skills/package.json\");\n    const bin = join(pkgPath, \"..\", \"bin\", \"cli.mjs\");\n    if (await pathExists(bin)) return { command: process.execPath, args: [bin] };\n  } catch {\n    // peer dep absent or unresolvable - fetch fallback handles it\n  }\n  return undefined;\n}\n\n/**\n * Fetch a source URL and write the downloaded `SKILL.md` under `target`.\n * Used when the `skills` CLI isn't installed; supports a direct `SKILL.md` URL.\n */\nasync function stageViaFetch(\n  sourceOptions: RemoteSkillSourceOptions,\n  target: string,\n  options: ProvisionRemoteSkillsOptions,\n): Promise<string> {\n  const url = net.urlBuilder(sourceOptions.source);\n  if (!url) {\n    throw new Error(\n      `source \"${sourceOptions.source}\" is not a URL and the optional \"skills\" package is not installed`,\n    );\n  }\n  const maxBytes =\n    sourceOptions.maxDownloadBytes ?? options.maxDownloadBytes ?? DEFAULT_MAX_DOWNLOAD_BYTES;\n  const response = await fetch(url.toString());\n  if (!response.ok) {\n    throw new Error(\n      `download failed: ${response.status} ${response.statusText} (${url.toString()})`,\n    );\n  }\n  const buffer = Buffer.from(await response.arrayBuffer());\n  if (buffer.byteLength > maxBytes) {\n    throw new Error(`download exceeds ${maxBytes} bytes (${url.toString()})`);\n  }\n  const name = string.toSlug(deriveSkillName(url.toString())) || \"remote-skill\";\n  const skillDir = join(target, name);\n  await mkdir(skillDir, { recursive: true });\n  await writeFile(join(skillDir, \"SKILL.md\"), buffer);\n  return target;\n}\n\n/** Derive a skill directory name from a download URL's last path segment. */\nfunction deriveSkillName(urlString: string): string {\n  const url = net.urlBuilder(urlString);\n  const last = url?.pathname.split(\"/\").filter(Boolean).pop() ?? \"\";\n  return last.replace(/\\.(md|zip|tar|tgz|gz)$/i, \"\");\n}\n\n/** A skill directory (holding a `SKILL.md`) staged on local disk. */\ninterface StagedSkillDir {\n  name: string;\n  absolutePath: string;\n}\n\n/**\n * Collect every skill directory under `root`: a `root/SKILL.md` (root IS the\n * skill) or each immediate child dir that contains a `SKILL.md`.\n */\nasync function collectSkillDirs(root: string): Promise<StagedSkillDir[]> {\n  if (!(await pathExists(root))) return [];\n  if (await pathExists(join(root, \"SKILL.md\"))) {\n    const name = posix.basename(root.split(/[\\\\/]/).join(\"/\"));\n    return [{ name, absolutePath: root }];\n  }\n  const dirs: StagedSkillDir[] = [];\n  for (const entry of await readdir(root, { withFileTypes: true })) {\n    if (!entry.isDirectory()) continue;\n    const dir = join(root, entry.name);\n    if (await pathExists(join(dir, \"SKILL.md\"))) {\n      dirs.push({ name: entry.name, absolutePath: dir });\n    }\n  }\n  return dirs;\n}\n\n/** Upload each staged skill directory into the Databricks destination tree. */\nasync function uploadSkillDirs(\n  destination: DatabricksWorkspaceFilesystem,\n  dirs: StagedSkillDir[],\n): Promise<void> {\n  await destination.init?.();\n  for (const dir of dirs) {\n    for (const relative of findFiles(\"**/*\", { cwd: dir.absolutePath, nodir: true })) {\n      const buffer = await readFile(join(dir.absolutePath, relative));\n      const remotePath = posix.join(\"/\", dir.name, relative.split(/[\\\\/]/).join(\"/\"));\n      await destination.writeFile(remotePath, buffer, { overwrite: true });\n    }\n  }\n}\n\n/** Copy staged skill dirs into a persistent local temp dir; return its path. */\nasync function persistLocally(dirs: StagedSkillDir[]): Promise<string> {\n  const base = await mkdtemp(join(tmpdir(), \"mastra-local-skills-\"));\n  for (const dir of dirs) {\n    await cp(dir.absolutePath, join(base, dir.name), { recursive: true });\n  }\n  return base;\n}\n\n/** Best-effort existence check. */\nasync function pathExists(path: string): Promise<boolean> {\n  try {\n    await stat(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"]}

package/lib/src/workspaces.d.ts

@@ -42,6 +42,14 @@ export interface CreateWorkspaceOptions {
     checkSkillFileMtime?: boolean;
     /** Enable BM25 keyword search over indexed workspace content. */
     bm25?: boolean;
+    /**
+     * Extra LOCAL skill scan paths added to every request's skill discovery.
+     * Used by the plugin to surface remote skills provisioned to a local temp
+     * dir at startup (see `remote-skills.ts`). Databricks-hosted remote skills
+     * need no entry here - they land in the Assistant tree the built-in mount
+     * already scans.
+     */
+    extraSkillPaths?: string[];
 }
 /**
  * Create a Mastra {@link Workspace} with per-request Databricks mounts.

package/lib/src/workspaces.js

@@ -47,7 +47,11 @@ const logger = log.logger("mastra/workspaces");
 export function createWorkspace(options = {}) {
     const { id, name } = resolveWorkspaceIdentity(options);
     const resolvers = buildMountResolvers(options);
-    const skills = options.skills ?? (resolvers.length > 0 ? buildWorkspaceSkillsResolver(resolvers) : undefined);
+    const extraSkillPaths = options.extraSkillPaths ?? [];
+    const skills = options.skills ??
+        (resolvers.length > 0 || extraSkillPaths.length > 0
+            ? buildWorkspaceSkillsResolver(resolvers, extraSkillPaths)
+            : undefined);
     const checkSkillFileMtime = options.checkSkillFileMtime ?? options.assistantSkills !== false;
     const bm25 = options.bm25 !== false;
     logger.debug("workspace:create", {
@@ -59,6 +63,7 @@ export function createWorkspace(options = {}) {
         customSkillsResolver: Boolean(options.skills),
         checkSkillFileMtime,
         bm25,
+        extraSkillPaths: extraSkillPaths.length,
     });
     return new Workspace({
         id,
@@ -236,11 +241,12 @@ async function resolveWorkspaceFilesystem(resolvers, context) {
  * Build the dynamic {@link SkillsResolver} that collects `skillPaths` from
  * every mount resolver on each request.
  */
-function buildWorkspaceSkillsResolver(resolvers) {
+function buildWorkspaceSkillsResolver(resolvers, extraSkillPaths = []) {
     return async (context) => {
         const { skillPaths } = await resolveWorkspaceContribution(resolvers, context);
-        logger.debug("skills:resolved", { skillPaths });
-        return skillPaths ?? [];
+        const merged = [...(skillPaths ?? []), ...extraSkillPaths];
+        logger.debug("skills:resolved", { skillPaths, extraSkillPaths });
+        return merged;
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspaces.js","sourceRoot":"","sources":["../../src/workspaces.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mastra workspace factory for Databricks Apps.\n *\n * Builds a per-request {@link Workspace} whose filesystem is a\n * {@link CompositeFilesystem} over Databricks paths resolved from the\n * OBO client on {@link MASTRA_USER_KEY}. Optional mount resolver\n * contributions merge extra filesystems and skill scan roots; built-in\n * Assistant skill trees are toggled with `assistantSkills` (on by default).\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { log, string, token } from \"@dbx-tools/shared-core\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport {\n  CompositeFilesystem,\n  Workspace,\n  type SkillsContext,\n  type SkillsResolver,\n  type WorkspaceFilesystem,\n} from \"@mastra/core/workspace\";\n\nimport { MASTRA_SCOPES_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, type User } from \"./config.ts\";\nimport { DatabricksWorkspaceFilesystem, emptyFilesystem } from \"./filesystems.ts\";\n\n/* ------------------------------ constants ------------------------------ */\n\n/** Shared Assistant skills tree in the workspace namespace. */\nconst ASSISTANT_SHARED_SKILLS_PATH = \"/Workspace/.assistant/skills\";\n\n/** Composite mount for {@link ASSISTANT_SHARED_SKILLS_PATH}. */\nconst ASSISTANT_WORKSPACE_SKILLS_MOUNT = \"/workspace_skills\";\n\n/** Composite mount for the caller's `/.assistant/skills` tree. */\nconst ASSISTANT_USER_SKILLS_MOUNT = \"/workspace_user_skills\";\n\n/** OAuth scopes that gate Databricks workspace file mounts. */\nconst WORKSPACE_FILE_SCOPES = [\"workspace\", \"workspace.workspace\", \"all-apis\"] as const;\n\nconst logger = log.logger(\"mastra/workspaces\");\n\n/* -------------------------------- types -------------------------------- */\n\n/** Per-request context for mount resolvers. */\ninterface WorkspaceMountContext {\n  requestContext?: RequestContext;\n}\n\n/** Mount map plus optional Mastra skill scan roots for one resolver. */\ninterface WorkspaceMountContribution {\n  mounts: Record<string, WorkspaceFilesystem>;\n  /** Paths within the composite namespace where `SKILL.md` files are scanned. */\n  skillPaths?: string[];\n}\n\n/** Contributes filesystem mounts (and optional skill paths) for one request. */\ntype WorkspaceMountResolver = (\n  context: WorkspaceMountContext,\n) => WorkspaceMountContribution | Promise<WorkspaceMountContribution>;\n\n/** Options for {@link createWorkspace}. */\nexport interface CreateWorkspaceOptions {\n  /** Workspace id; derived from `name` or `\"workspace\"` when omitted. */\n  id?: string;\n  /** Display name; derived from `id` when omitted. */\n  name?: string;\n  /**\n   * Mount read-only Assistant skill trees from `/Workspace/.assistant/skills`\n   * and `/Users/<email>/.assistant/skills`. Defaults to `true`.\n   */\n  assistantSkills?: boolean;\n  /** Extra per-request mount resolvers (run after built-in options). */\n  mounts?: WorkspaceMountResolver[];\n  /** Replace the auto-built dynamic skills resolver. */\n  skills?: SkillsResolver;\n  /** Forwarded to Mastra when skill discovery is enabled. */\n  checkSkillFileMtime?: boolean;\n  /** Enable BM25 keyword search over indexed workspace content. */\n  bm25?: boolean;\n}\n\n/**\n * Create a Mastra {@link Workspace} with per-request Databricks mounts.\n *\n * @example Assistant skills only (default for agents in this plugin)\n * ```ts\n * createWorkspace()\n * ```\n *\n * @example Assistant skills plus a custom mount resolver\n * ```ts\n * createWorkspace({\n *   assistantSkills: true,\n *   mounts: [\n *     async ({ requestContext }) => ({\n *       mounts: { \"/data\": myFilesystem },\n *       skillPaths: [],\n *     }),\n *   ],\n * })\n * ```\n */\nexport function createWorkspace(options: CreateWorkspaceOptions = {}): Workspace {\n  const { id, name } = resolveWorkspaceIdentity(options);\n  const resolvers = buildMountResolvers(options);\n  const skills =\n    options.skills ?? (resolvers.length > 0 ? buildWorkspaceSkillsResolver(resolvers) : undefined);\n  const checkSkillFileMtime = options.checkSkillFileMtime ?? options.assistantSkills !== false;\n  const bm25 = options.bm25 !== false;\n  logger.debug(\"workspace:create\", {\n    id,\n    name,\n    resolverCount: resolvers.length,\n    assistantSkills: options.assistantSkills !== false,\n    customMountResolvers: options.mounts?.length ?? 0,\n    customSkillsResolver: Boolean(options.skills),\n    checkSkillFileMtime,\n    bm25,\n  });\n\n  return new Workspace({\n    id,\n    name,\n    filesystem: (context) => resolveWorkspaceFilesystem(resolvers, context),\n    ...(skills\n      ? {\n          skills,\n          checkSkillFileMtime,\n        }\n      : {}),\n    bm25,\n  });\n}\n\n/* ---------------------------- private helpers ---------------------------- */\n\n/**\n * Map an OBO user email to their Assistant skills directory in the\n * workspace namespace.\n */\nfunction userAssistantSkillsPath(userEmail: string): string {\n  return `/Users/${userEmail.trim()}/.assistant/skills`;\n}\n\n/**\n * Return whether the request token carries a scope that allows workspace\n * file API access (`workspace` or `all-apis` on {@link MASTRA_SCOPES_KEY}).\n */\nfunction hasWorkspaceFileScope(requestContext: RequestContext | undefined): boolean {\n  return token.includesAccessTokenScope(\n    requestContext?.get(MASTRA_SCOPES_KEY),\n    WORKSPACE_FILE_SCOPES,\n  );\n}\n\n/**\n * Built-in mount resolver for Assistant `SKILL.md` trees.\n *\n * Mounts {@link ASSISTANT_SHARED_SKILLS_PATH} when scope checks pass and\n * `/Users/<email>/.assistant/skills` when {@link MASTRA_USER_EMAIL_KEY} is\n * set. Returns empty mounts when the OBO user or client is missing.\n * Mastra owns filesystem initialization.\n */\nfunction resolveAssistantSkillsMounts(context: WorkspaceMountContext): WorkspaceMountContribution {\n  const mounts: Record<string, DatabricksWorkspaceFilesystem> = {};\n  const requestContext = context.requestContext;\n\n  if (!shouldMountAssistantSkills(requestContext)) {\n    logger.debug(\"assistant-skills:skipped\", {\n      reason: !requestContext ? \"no-request-context\" : \"missing-workspace-scope\",\n      nodeEnv: process.env.NODE_ENV,\n      scopes: context.requestContext?.get(MASTRA_SCOPES_KEY),\n    });\n    return { mounts, skillPaths: [] };\n  }\n\n  const user = requestContext!.get(MASTRA_USER_KEY) as User | undefined;\n  const client = user?.executionContext.client;\n  if (!client) {\n    logger.debug(\"assistant-skills:skipped\", {\n      reason: \"missing-obo-client\",\n      userId: user?.id,\n    });\n    return { mounts, skillPaths: [] };\n  }\n\n  mounts[ASSISTANT_WORKSPACE_SKILLS_MOUNT] = databricksFilesystem(\n    client,\n    ASSISTANT_SHARED_SKILLS_PATH,\n  );\n\n  const email = resolveScopedEmail(requestContext);\n  if (email) {\n    mounts[ASSISTANT_USER_SKILLS_MOUNT] = databricksFilesystem(\n      client,\n      userAssistantSkillsPath(email),\n      false,\n    );\n  }\n\n  logger.debug(\"assistant-skills:mounted\", {\n    sharedPath: ASSISTANT_SHARED_SKILLS_PATH,\n    sharedMount: ASSISTANT_WORKSPACE_SKILLS_MOUNT,\n    userMount: email ? ASSISTANT_USER_SKILLS_MOUNT : undefined,\n    userPath: email ? userAssistantSkillsPath(email) : undefined,\n    mountKeys: Object.keys(mounts),\n  });\n\n  return { mounts, skillPaths: Object.keys(mounts) };\n}\n\n/**\n * Fill in `id` and `name` when either is omitted on {@link CreateWorkspaceOptions}.\n * Slugifies `name` into `id`; tokenizes `id` into a display `name`.\n */\nfunction resolveWorkspaceIdentity(options: CreateWorkspaceOptions): {\n  id: string;\n  name: string;\n} {\n  let id = options.id;\n  let name = options.name;\n  if (!id) {\n    id = name ? string.toSlug(name) : \"workspace\";\n  }\n  if (!name) {\n    name = Array.from(string.tokenize(id)).join(\" \");\n  }\n  return { id, name };\n}\n\n/** Collect built-in and caller-supplied mount resolvers for one workspace. */\nfunction buildMountResolvers(options: CreateWorkspaceOptions): WorkspaceMountResolver[] {\n  const resolvers: WorkspaceMountResolver[] = [];\n  const { assistantSkills = true, mounts } = options;\n  if (assistantSkills) {\n    resolvers.push(resolveAssistantSkillsMounts);\n  }\n  if (mounts?.length) {\n    resolvers.push(...mounts);\n  }\n  logger.debug(\"mounts:resolvers\", {\n    assistantSkills,\n    builtInResolver: assistantSkills,\n    customResolverCount: mounts?.length ?? 0,\n    totalResolverCount: resolvers.length,\n  });\n  return resolvers;\n}\n\n/**\n * Gate Assistant skill mounts on request context.\n *\n * Always allows mounts in development; in other environments requires\n * {@link hasWorkspaceFileScope}.\n */\nfunction shouldMountAssistantSkills(\n  requestContext: RequestContext | undefined,\n): requestContext is RequestContext {\n  if (!requestContext) return false;\n  if (process.env.NODE_ENV === \"development\") return true;\n  return hasWorkspaceFileScope(requestContext);\n}\n\n/** Read the trimmed OBO user email stamped on {@link MASTRA_USER_EMAIL_KEY}. */\nfunction resolveScopedEmail(requestContext: RequestContext | undefined): string | undefined {\n  const email = requestContext?.get(MASTRA_USER_EMAIL_KEY) as string | undefined;\n  return email?.trim() || undefined;\n}\n\n/** Construct a read-only {@link DatabricksWorkspaceFilesystem} for `basePath`. */\nfunction databricksFilesystem(\n  client: WorkspaceClient,\n  basePath: string,\n  readOnly: boolean = true,\n): DatabricksWorkspaceFilesystem {\n  return new DatabricksWorkspaceFilesystem({\n    client,\n    basePath,\n    readOnly,\n  });\n}\n\n/**\n * Run every mount resolver for one request and merge mounts plus skill paths.\n * Later resolvers overwrite mount keys from earlier ones.\n */\nasync function resolveWorkspaceContribution(\n  resolvers: WorkspaceMountResolver[],\n  context: WorkspaceMountContext,\n): Promise<WorkspaceMountContribution> {\n  const mounts: Record<string, WorkspaceFilesystem> = {};\n  const skillPaths: string[] = [];\n\n  for (const [index, resolver] of resolvers.entries()) {\n    const contribution = await resolver(context);\n    logger.debug(\"mounts:resolver\", {\n      index,\n      mountKeys: Object.keys(contribution.mounts),\n      skillPaths: contribution.skillPaths ?? [],\n    });\n    Object.assign(mounts, contribution.mounts);\n    if (contribution.skillPaths?.length) {\n      skillPaths.push(...contribution.skillPaths);\n    }\n  }\n\n  logger.debug(\"mounts:merged\", {\n    mountKeys: Object.keys(mounts),\n    skillPaths,\n  });\n\n  return { mounts, skillPaths };\n}\n\n/**\n * Dynamic filesystem resolver passed to Mastra {@link Workspace}.\n *\n * Returns a {@link CompositeFilesystem} when any mount resolved; otherwise\n * {@link emptyFilesystem}.\n */\nasync function resolveWorkspaceFilesystem(\n  resolvers: WorkspaceMountResolver[],\n  context: WorkspaceMountContext,\n): Promise<WorkspaceFilesystem> {\n  const { mounts } = await resolveWorkspaceContribution(resolvers, context);\n  const mountKeys = Object.keys(mounts);\n  if (mountKeys.length === 0) {\n    logger.debug(\"filesystem:empty\", {\n      hasRequestContext: Boolean(context.requestContext),\n    });\n    return emptyFilesystem();\n  }\n  logger.debug(\"filesystem:composite\", { mountKeys });\n  return new CompositeFilesystem({ mounts });\n}\n\n/**\n * Build the dynamic {@link SkillsResolver} that collects `skillPaths` from\n * every mount resolver on each request.\n */\nfunction buildWorkspaceSkillsResolver(resolvers: WorkspaceMountResolver[]): SkillsResolver {\n  return async (context: SkillsContext) => {\n    const { skillPaths } = await resolveWorkspaceContribution(resolvers, context);\n    logger.debug(\"skills:resolved\", { skillPaths });\n    return skillPaths ?? [];\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspaces.js","sourceRoot":"","sources":["../../src/workspaces.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mastra workspace factory for Databricks Apps.\n *\n * Builds a per-request {@link Workspace} whose filesystem is a\n * {@link CompositeFilesystem} over Databricks paths resolved from the\n * OBO client on {@link MASTRA_USER_KEY}. Optional mount resolver\n * contributions merge extra filesystems and skill scan roots; built-in\n * Assistant skill trees are toggled with `assistantSkills` (on by default).\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { log, string, token } from \"@dbx-tools/shared-core\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport {\n  CompositeFilesystem,\n  Workspace,\n  type SkillsContext,\n  type SkillsResolver,\n  type WorkspaceFilesystem,\n} from \"@mastra/core/workspace\";\n\nimport { MASTRA_SCOPES_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, type User } from \"./config.ts\";\nimport { DatabricksWorkspaceFilesystem, emptyFilesystem } from \"./filesystems.ts\";\n\n/* ------------------------------ constants ------------------------------ */\n\n/** Shared Assistant skills tree in the workspace namespace. */\nconst ASSISTANT_SHARED_SKILLS_PATH = \"/Workspace/.assistant/skills\";\n\n/** Composite mount for {@link ASSISTANT_SHARED_SKILLS_PATH}. */\nconst ASSISTANT_WORKSPACE_SKILLS_MOUNT = \"/workspace_skills\";\n\n/** Composite mount for the caller's `/.assistant/skills` tree. */\nconst ASSISTANT_USER_SKILLS_MOUNT = \"/workspace_user_skills\";\n\n/** OAuth scopes that gate Databricks workspace file mounts. */\nconst WORKSPACE_FILE_SCOPES = [\"workspace\", \"workspace.workspace\", \"all-apis\"] as const;\n\nconst logger = log.logger(\"mastra/workspaces\");\n\n/* -------------------------------- types -------------------------------- */\n\n/** Per-request context for mount resolvers. */\ninterface WorkspaceMountContext {\n  requestContext?: RequestContext;\n}\n\n/** Mount map plus optional Mastra skill scan roots for one resolver. */\ninterface WorkspaceMountContribution {\n  mounts: Record<string, WorkspaceFilesystem>;\n  /** Paths within the composite namespace where `SKILL.md` files are scanned. */\n  skillPaths?: string[];\n}\n\n/** Contributes filesystem mounts (and optional skill paths) for one request. */\ntype WorkspaceMountResolver = (\n  context: WorkspaceMountContext,\n) => WorkspaceMountContribution | Promise<WorkspaceMountContribution>;\n\n/** Options for {@link createWorkspace}. */\nexport interface CreateWorkspaceOptions {\n  /** Workspace id; derived from `name` or `\"workspace\"` when omitted. */\n  id?: string;\n  /** Display name; derived from `id` when omitted. */\n  name?: string;\n  /**\n   * Mount read-only Assistant skill trees from `/Workspace/.assistant/skills`\n   * and `/Users/<email>/.assistant/skills`. Defaults to `true`.\n   */\n  assistantSkills?: boolean;\n  /** Extra per-request mount resolvers (run after built-in options). */\n  mounts?: WorkspaceMountResolver[];\n  /** Replace the auto-built dynamic skills resolver. */\n  skills?: SkillsResolver;\n  /** Forwarded to Mastra when skill discovery is enabled. */\n  checkSkillFileMtime?: boolean;\n  /** Enable BM25 keyword search over indexed workspace content. */\n  bm25?: boolean;\n  /**\n   * Extra LOCAL skill scan paths added to every request's skill discovery.\n   * Used by the plugin to surface remote skills provisioned to a local temp\n   * dir at startup (see `remote-skills.ts`). Databricks-hosted remote skills\n   * need no entry here - they land in the Assistant tree the built-in mount\n   * already scans.\n   */\n  extraSkillPaths?: string[];\n}\n\n/**\n * Create a Mastra {@link Workspace} with per-request Databricks mounts.\n *\n * @example Assistant skills only (default for agents in this plugin)\n * ```ts\n * createWorkspace()\n * ```\n *\n * @example Assistant skills plus a custom mount resolver\n * ```ts\n * createWorkspace({\n *   assistantSkills: true,\n *   mounts: [\n *     async ({ requestContext }) => ({\n *       mounts: { \"/data\": myFilesystem },\n *       skillPaths: [],\n *     }),\n *   ],\n * })\n * ```\n */\nexport function createWorkspace(options: CreateWorkspaceOptions = {}): Workspace {\n  const { id, name } = resolveWorkspaceIdentity(options);\n  const resolvers = buildMountResolvers(options);\n  const extraSkillPaths = options.extraSkillPaths ?? [];\n  const skills =\n    options.skills ??\n    (resolvers.length > 0 || extraSkillPaths.length > 0\n      ? buildWorkspaceSkillsResolver(resolvers, extraSkillPaths)\n      : undefined);\n  const checkSkillFileMtime = options.checkSkillFileMtime ?? options.assistantSkills !== false;\n  const bm25 = options.bm25 !== false;\n  logger.debug(\"workspace:create\", {\n    id,\n    name,\n    resolverCount: resolvers.length,\n    assistantSkills: options.assistantSkills !== false,\n    customMountResolvers: options.mounts?.length ?? 0,\n    customSkillsResolver: Boolean(options.skills),\n    checkSkillFileMtime,\n    bm25,\n    extraSkillPaths: extraSkillPaths.length,\n  });\n\n  return new Workspace({\n    id,\n    name,\n    filesystem: (context) => resolveWorkspaceFilesystem(resolvers, context),\n    ...(skills\n      ? {\n          skills,\n          checkSkillFileMtime,\n        }\n      : {}),\n    bm25,\n  });\n}\n\n/* ---------------------------- private helpers ---------------------------- */\n\n/**\n * Map an OBO user email to their Assistant skills directory in the\n * workspace namespace.\n */\nfunction userAssistantSkillsPath(userEmail: string): string {\n  return `/Users/${userEmail.trim()}/.assistant/skills`;\n}\n\n/**\n * Return whether the request token carries a scope that allows workspace\n * file API access (`workspace` or `all-apis` on {@link MASTRA_SCOPES_KEY}).\n */\nfunction hasWorkspaceFileScope(requestContext: RequestContext | undefined): boolean {\n  return token.includesAccessTokenScope(\n    requestContext?.get(MASTRA_SCOPES_KEY),\n    WORKSPACE_FILE_SCOPES,\n  );\n}\n\n/**\n * Built-in mount resolver for Assistant `SKILL.md` trees.\n *\n * Mounts {@link ASSISTANT_SHARED_SKILLS_PATH} when scope checks pass and\n * `/Users/<email>/.assistant/skills` when {@link MASTRA_USER_EMAIL_KEY} is\n * set. Returns empty mounts when the OBO user or client is missing.\n * Mastra owns filesystem initialization.\n */\nfunction resolveAssistantSkillsMounts(context: WorkspaceMountContext): WorkspaceMountContribution {\n  const mounts: Record<string, DatabricksWorkspaceFilesystem> = {};\n  const requestContext = context.requestContext;\n\n  if (!shouldMountAssistantSkills(requestContext)) {\n    logger.debug(\"assistant-skills:skipped\", {\n      reason: !requestContext ? \"no-request-context\" : \"missing-workspace-scope\",\n      nodeEnv: process.env.NODE_ENV,\n      scopes: context.requestContext?.get(MASTRA_SCOPES_KEY),\n    });\n    return { mounts, skillPaths: [] };\n  }\n\n  const user = requestContext!.get(MASTRA_USER_KEY) as User | undefined;\n  const client = user?.executionContext.client;\n  if (!client) {\n    logger.debug(\"assistant-skills:skipped\", {\n      reason: \"missing-obo-client\",\n      userId: user?.id,\n    });\n    return { mounts, skillPaths: [] };\n  }\n\n  mounts[ASSISTANT_WORKSPACE_SKILLS_MOUNT] = databricksFilesystem(\n    client,\n    ASSISTANT_SHARED_SKILLS_PATH,\n  );\n\n  const email = resolveScopedEmail(requestContext);\n  if (email) {\n    mounts[ASSISTANT_USER_SKILLS_MOUNT] = databricksFilesystem(\n      client,\n      userAssistantSkillsPath(email),\n      false,\n    );\n  }\n\n  logger.debug(\"assistant-skills:mounted\", {\n    sharedPath: ASSISTANT_SHARED_SKILLS_PATH,\n    sharedMount: ASSISTANT_WORKSPACE_SKILLS_MOUNT,\n    userMount: email ? ASSISTANT_USER_SKILLS_MOUNT : undefined,\n    userPath: email ? userAssistantSkillsPath(email) : undefined,\n    mountKeys: Object.keys(mounts),\n  });\n\n  return { mounts, skillPaths: Object.keys(mounts) };\n}\n\n/**\n * Fill in `id` and `name` when either is omitted on {@link CreateWorkspaceOptions}.\n * Slugifies `name` into `id`; tokenizes `id` into a display `name`.\n */\nfunction resolveWorkspaceIdentity(options: CreateWorkspaceOptions): {\n  id: string;\n  name: string;\n} {\n  let id = options.id;\n  let name = options.name;\n  if (!id) {\n    id = name ? string.toSlug(name) : \"workspace\";\n  }\n  if (!name) {\n    name = Array.from(string.tokenize(id)).join(\" \");\n  }\n  return { id, name };\n}\n\n/** Collect built-in and caller-supplied mount resolvers for one workspace. */\nfunction buildMountResolvers(options: CreateWorkspaceOptions): WorkspaceMountResolver[] {\n  const resolvers: WorkspaceMountResolver[] = [];\n  const { assistantSkills = true, mounts } = options;\n  if (assistantSkills) {\n    resolvers.push(resolveAssistantSkillsMounts);\n  }\n  if (mounts?.length) {\n    resolvers.push(...mounts);\n  }\n  logger.debug(\"mounts:resolvers\", {\n    assistantSkills,\n    builtInResolver: assistantSkills,\n    customResolverCount: mounts?.length ?? 0,\n    totalResolverCount: resolvers.length,\n  });\n  return resolvers;\n}\n\n/**\n * Gate Assistant skill mounts on request context.\n *\n * Always allows mounts in development; in other environments requires\n * {@link hasWorkspaceFileScope}.\n */\nfunction shouldMountAssistantSkills(\n  requestContext: RequestContext | undefined,\n): requestContext is RequestContext {\n  if (!requestContext) return false;\n  if (process.env.NODE_ENV === \"development\") return true;\n  return hasWorkspaceFileScope(requestContext);\n}\n\n/** Read the trimmed OBO user email stamped on {@link MASTRA_USER_EMAIL_KEY}. */\nfunction resolveScopedEmail(requestContext: RequestContext | undefined): string | undefined {\n  const email = requestContext?.get(MASTRA_USER_EMAIL_KEY) as string | undefined;\n  return email?.trim() || undefined;\n}\n\n/** Construct a read-only {@link DatabricksWorkspaceFilesystem} for `basePath`. */\nfunction databricksFilesystem(\n  client: WorkspaceClient,\n  basePath: string,\n  readOnly: boolean = true,\n): DatabricksWorkspaceFilesystem {\n  return new DatabricksWorkspaceFilesystem({\n    client,\n    basePath,\n    readOnly,\n  });\n}\n\n/**\n * Run every mount resolver for one request and merge mounts plus skill paths.\n * Later resolvers overwrite mount keys from earlier ones.\n */\nasync function resolveWorkspaceContribution(\n  resolvers: WorkspaceMountResolver[],\n  context: WorkspaceMountContext,\n): Promise<WorkspaceMountContribution> {\n  const mounts: Record<string, WorkspaceFilesystem> = {};\n  const skillPaths: string[] = [];\n\n  for (const [index, resolver] of resolvers.entries()) {\n    const contribution = await resolver(context);\n    logger.debug(\"mounts:resolver\", {\n      index,\n      mountKeys: Object.keys(contribution.mounts),\n      skillPaths: contribution.skillPaths ?? [],\n    });\n    Object.assign(mounts, contribution.mounts);\n    if (contribution.skillPaths?.length) {\n      skillPaths.push(...contribution.skillPaths);\n    }\n  }\n\n  logger.debug(\"mounts:merged\", {\n    mountKeys: Object.keys(mounts),\n    skillPaths,\n  });\n\n  return { mounts, skillPaths };\n}\n\n/**\n * Dynamic filesystem resolver passed to Mastra {@link Workspace}.\n *\n * Returns a {@link CompositeFilesystem} when any mount resolved; otherwise\n * {@link emptyFilesystem}.\n */\nasync function resolveWorkspaceFilesystem(\n  resolvers: WorkspaceMountResolver[],\n  context: WorkspaceMountContext,\n): Promise<WorkspaceFilesystem> {\n  const { mounts } = await resolveWorkspaceContribution(resolvers, context);\n  const mountKeys = Object.keys(mounts);\n  if (mountKeys.length === 0) {\n    logger.debug(\"filesystem:empty\", {\n      hasRequestContext: Boolean(context.requestContext),\n    });\n    return emptyFilesystem();\n  }\n  logger.debug(\"filesystem:composite\", { mountKeys });\n  return new CompositeFilesystem({ mounts });\n}\n\n/**\n * Build the dynamic {@link SkillsResolver} that collects `skillPaths` from\n * every mount resolver on each request.\n */\nfunction buildWorkspaceSkillsResolver(\n  resolvers: WorkspaceMountResolver[],\n  extraSkillPaths: string[] = [],\n): SkillsResolver {\n  return async (context: SkillsContext) => {\n    const { skillPaths } = await resolveWorkspaceContribution(resolvers, context);\n    const merged = [...(skillPaths ?? []), ...extraSkillPaths];\n    logger.debug(\"skills:resolved\", { skillPaths, extraSkillPaths });\n    return merged;\n  };\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/agents.ts","../src/chart.ts","../src/config.ts","../src/defaults.ts","../src/filesystems.ts","../src/genie.ts","../src/history.ts","../src/identity.ts","../src/mcp.ts","../src/memory.ts","../src/mlflow.ts","../src/model.ts","../src/observability.ts","../src/pagination.ts","../src/plugin.ts","../src/processors.ts","../src/rest.ts","../src/server.ts","../src/serving-sanitize.ts","../src/serving.ts","../src/statement.ts","../src/storage-schema.ts","../src/summarize.ts","../src/threads.ts","../src/validation.ts","../src/workspaces.ts","../src/writer.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/agents.ts","../src/chart.ts","../src/config.ts","../src/defaults.ts","../src/filesystems.ts","../src/genie.ts","../src/history.ts","../src/identity.ts","../src/mcp.ts","../src/memory.ts","../src/mlflow.ts","../src/model.ts","../src/observability.ts","../src/pagination.ts","../src/plugin.ts","../src/processors.ts","../src/remote-skills.ts","../src/rest.ts","../src/server.ts","../src/serving-sanitize.ts","../src/serving.ts","../src/statement.ts","../src/storage-schema.ts","../src/summarize.ts","../src/threads.ts","../src/validation.ts","../src/workspaces.ts","../src/writer.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -9,9 +9,13 @@
     "@types/express": "^5.0.5",
     "@types/node": "^24.6.0",
     "@types/pg": "^8",
+    "skills": "^1",
     "tsx": "^4.23.0",
     "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "skills": "^1"
+  },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
     "@databricks/sdk-experimental": "^0.17.0",
@@ -28,21 +32,22 @@
     "express": "^5.1.0",
     "pg": "^8.22.0",
     "zod": "4.3.6",
-    "@dbx-tools/appkit": "0.6.4",
-    "@dbx-tools/core": "0.6.4",
-    "@dbx-tools/genie": "0.6.4",
-    "@dbx-tools/model": "0.6.4",
-    "@dbx-tools/shared-genie": "0.6.4",
-    "@dbx-tools/shared-mastra": "0.6.4",
-    "@dbx-tools/shared-core": "0.6.4",
-    "@dbx-tools/shared-model": "0.6.4"
+    "@dbx-tools/appkit": "0.6.6",
+    "@dbx-tools/genie": "0.6.6",
+    "@dbx-tools/model": "0.6.6",
+    "@dbx-tools/core": "0.6.6",
+    "@dbx-tools/path": "0.6.6",
+    "@dbx-tools/shared-core": "0.6.6",
+    "@dbx-tools/shared-mastra": "0.6.6",
+    "@dbx-tools/shared-model": "0.6.6",
+    "@dbx-tools/shared-genie": "0.6.6"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.4",
+  "version": "0.6.6",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -57,6 +62,11 @@
     "src",
     "lib"
   ],
+  "peerDependenciesMeta": {
+    "skills": {
+      "optional": true
+    }
+  },
   "dbxToolsConfig": {
     "tags": [
       "node"