@dbx-tools/appkit-mastra 0.6.10 → 0.6.11

package/lib/src/remote-skills.js

@@ -1,19 +1,24 @@
 /**
  * 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.
+ * A {@link RemoteSkillSource} names WHERE a `SKILL.md` tree comes from - the
+ * {@link AITOOLS_SOURCE} constant, 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
+ * 1. the {@link AITOOLS_SOURCE} constant (`"aitools"`): Databricks' own skill
+ *    set, read straight from the public repo the `databricks aitools` CLI
+ *    sources from. No CLI, no Databricks auth - which is what makes it usable
+ *    inside a Databricks App container, where the CLI is not installed;
+ * 2. 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
+ * 3. otherwise a plain {@link fetch} of the source URL (built with
  *    {@link net.urlBuilder}), writing the downloaded `SKILL.md` to a staging
  *    dir.
  *
@@ -34,13 +39,13 @@
  */
 import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { join, posix } from "node:path";
+import { dirname, join, posix } from "node:path";
 import { appkit } from "@dbx-tools/appkit";
 import { exec } from "@dbx-tools/core";
 import { DatabricksFileSystem } from "@dbx-tools/databricks";
 import { localFS } from "@dbx-tools/fs";
 import { find } from "@dbx-tools/path";
-import { error, hash, log, net, string } from "@dbx-tools/shared-core";
+import { error, hash, json, log, net, object, string } from "@dbx-tools/shared-core";
 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";
@@ -56,29 +61,63 @@ const SKILLS_CLI_LAYOUT = [".agents", "skills"];
 const DEFAULT_MAX_DOWNLOAD_BYTES = 10 * 1024 * 1024;
 /** Stable temp directory holding one rebuilt skill tree per remote source. */
 const LOCAL_SKILLS_DIR = "mastra-local-skills";
+/* ------------------------------ AI Tools ------------------------------ */
+/**
+ * Source constant selecting Databricks' own AI Tools skill set.
+ *
+ * @example
+ * mastra({ remoteSkills: "aitools" });
+ */
+export const AITOOLS_SOURCE = "aitools";
+/**
+ * The PUBLIC repo `databricks aitools install` sources from. Reading it
+ * directly is what lets an app get the same skills the CLI installs without
+ * the CLI - which a Databricks App container does not ship.
+ */
+const AITOOLS_REPO = "databricks/databricks-agent-skills";
+/** Repo ref the skills are read from. Override per source with `ref`. */
+const AITOOLS_REF = "main";
+/** Skill files downloaded at once; the set is ~30 skills of a few files each. */
+const AITOOLS_CONCURRENCY = 8;
 /* ------------------------------- 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] };
+    const bag = isProvisionOptions(option) ? option : undefined;
+    const sources = toSourceList(bag ? bag.sources : option);
+    // An empty list is the same as no configuration at all.
+    if (!object.isOneOrMany(sources))
+        return undefined;
+    return { ...bag, sources };
 }
 /** A `sources`-bearing bag is the top-level options shape, not a single source. */
 function isProvisionOptions(value) {
-    return "sources" in value;
+    return object.isRecord(value) && "sources" in value;
 }
-/** Coerce a source entry to its normalized {@link RemoteSkillSourceOptions}. */
+/** One source or many, as a plain array. A source is never itself an array. */
+function toSourceList(input) {
+    return Array.isArray(input) ? [...input] : [input];
+}
+/** Flatten a source entry - string, `URL`, `{ url }`, or options bag - to a {@link NormalizedSource}. */
 function toSourceOptions(source) {
-    return typeof source === "string" ? { source } : source;
+    if (typeof source === "string")
+        return { source };
+    if (source instanceof URL)
+        return { source: source.toString() };
+    if ("source" in source)
+        return { ...source, source: toSourceString(source.source) };
+    return { source: source.url };
+}
+/** A {@link net.UrlLike} as the plain string the staging paths work with. */
+function toSourceString(source) {
+    if (typeof source === "string")
+        return source;
+    return source instanceof URL ? source.toString() : source.url;
+}
+/** True when a source selects the built-in Databricks AI Tools skill set. */
+function isAiToolsSource(source) {
+    return source.trim().toLowerCase() === AITOOLS_SOURCE;
 }
 /**
  * Materialize every configured remote skill source at app startup.
@@ -170,11 +209,59 @@ function resolveDatabricksBasePath(options, client) {
 async function stageSource(sourceOptions, stagingRoot, options) {
     const target = join(stagingRoot, `src-${hash.id()}`);
     await mkdir(target, { recursive: true });
+    // AI Tools resolves from a known repo layout, so it never needs the CLI.
+    if (isAiToolsSource(sourceOptions.source))
+        return stageAiTools(sourceOptions, target, options);
     const viaCli = await stageViaSkillsCli(sourceOptions, target);
     if (viaCli)
         return viaCli;
     return stageViaFetch(sourceOptions, target, options);
 }
+/**
+ * Materialize the Databricks AI Tools skills into `target`.
+ *
+ * Reads the repo's own generated `manifest.json` (which names each skill's
+ * files and whether it lives under `skills/` or `experimental/`) and downloads
+ * them - the same thing `databricks aitools install` does, minus the CLI and
+ * minus any Databricks auth, since the repo is public.
+ */
+async function stageAiTools(sourceOptions, target, options) {
+    const maxBytes = resolveMaxBytes(sourceOptions, options);
+    const ref = string.trimToNull(sourceOptions.ref) ?? AITOOLS_REF;
+    const manifest = json.parse((await download(aiToolsRawUrl(ref, "manifest.json"), maxBytes)).toString("utf8"), undefined);
+    const wanted = new Set(string.parseList(sourceOptions.skills));
+    const selected = Object.entries(manifest?.skills ?? {}).filter(([name, entry]) => wanted.size > 0
+        ? wanted.has(name)
+        : entry.repo_dir !== "experimental" || sourceOptions.experimental === true);
+    if (selected.length === 0) {
+        throw new Error(`no matching skills in ${AITOOLS_REPO}@${ref}`);
+    }
+    const files = selected.flatMap(([name, entry]) => (entry.files ?? []).map((file) => ({
+        url: aiToolsRawUrl(ref, `${entry.repo_dir ?? "skills"}/${name}/${file}`),
+        path: join(target, name, ...file.split("/")),
+    })));
+    await mapConcurrent(files, AITOOLS_CONCURRENCY, async (item) => {
+        const body = await download(item.url, maxBytes);
+        await mkdir(dirname(item.path), { recursive: true });
+        await writeFile(item.path, body);
+    });
+    logger.debug("aitools:staged", { ref, skills: selected.length, files: files.length });
+    return target;
+}
+/** Raw-content URL for a path in the AI Tools repo at `ref`. */
+function aiToolsRawUrl(ref, path) {
+    return `https://raw.githubusercontent.com/${AITOOLS_REPO}/${ref}/${path}`;
+}
+/** Run `worker` over `items`, at most `limit` in flight. */
+async function mapConcurrent(items, limit, worker) {
+    let cursor = 0;
+    const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (cursor < items.length) {
+            await worker(items[cursor++]);
+        }
+    });
+    await Promise.all(runners);
+}
 /**
  * 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
@@ -236,21 +323,29 @@ async function stageViaFetch(sourceOptions, target, options) {
     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 buffer = await download(url.toString(), resolveMaxBytes(sourceOptions, options));
     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;
 }
+/** The effective download ceiling: per-source, then top-level, then the default. */
+function resolveMaxBytes(sourceOptions, options) {
+    return sourceOptions.maxDownloadBytes ?? options.maxDownloadBytes ?? DEFAULT_MAX_DOWNLOAD_BYTES;
+}
+/** GET a URL, failing loudly on a non-2xx status or an oversized body. */
+async function download(url, maxBytes) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`download failed: ${response.status} ${response.statusText} (${url})`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.byteLength > maxBytes) {
+        throw new Error(`download exceeds ${maxBytes} bytes (${url})`);
+    }
+    return buffer;
+}
 /** Derive a skill directory name from a download URL's last path segment. */
 function deriveSkillName(urlString) {
     const url = net.urlBuilder(urlString);
@@ -327,4 +422,4 @@ async function pathExists(path) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-skills.js","sourceRoot":"","sources":["../../src/remote-skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAwB,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGvE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAElD,iFAAiF;AACjF,MAAM,4BAA4B,GAAG,8BAA8B,CAAC;AAEpE,iEAAiE;AACjE,SAAS,uBAAuB,CAAC,SAAiB;IAChD,OAAO,UAAU,SAAS,CAAC,IAAI,EAAE,oBAAoB,CAAC;AACxD,CAAC;AAED,2EAA2E;AAC3E,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAElC,+EAA+E;AAC/E,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAU,CAAC;AAEzD,8EAA8E;AAC9E,MAAM,0BAA0B,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAEpD,8EAA8E;AAC9E,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AA0E/C,6EAA6E;AAE7E,mEAAmE;AACnE,MAAM,UAAU,2BAA2B,CACzC,MAAsC;IAEtC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3C,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;IAC7D,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACtF,IAAI,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;QAC/B,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAClF,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,CAAC;IACD,0CAA0C;IAC1C,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;AAC/B,CAAC;AAED,mFAAmF;AACnF,SAAS,kBAAkB,CACzB,KAA8D;IAE9D,OAAO,SAAS,IAAI,KAAK,CAAC;AAC5B,CAAC;AAED,gFAAgF;AAChF,SAAS,eAAe,CAAC,MAAyB;IAChD,OAAO,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAsC;IAEtC,MAAM,OAAO,GAAG,2BAA2B,CAAC,MAAM,CAAC,CAAC;IACpD,MAAM,KAAK,GAA4B,EAAE,eAAe,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAC/E,IAAI,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAE3B,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,KAAK,KAAK,CAAC;IAClD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC,sBAAsB,EAAE,EAAE,MAAM,CAAC;IACzE,MAAM,kBAAkB,GAAG,yBAAyB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACtE,MAAM,WAAW,GAAG,kBAAkB;QACpC,CAAC,CAAC,IAAI,oBAAoB,CAAC;YACvB,MAAM,EAAE,MAAyB;YACjC,IAAI,EAAE,kBAAkB;YACxB,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,IAAI;SACjB,CAAC;QACJ,CAAC,CAAC,SAAS,CAAC;IAEd,MAAM,eAAe,GAAa,EAAE,CAAC;IACrC,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,IAAI,OAAoC,CAAC;IAEzC,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACrF,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,MAAM,aAAa,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,WAAW,GAAG,aAAa,CAAC,WAAW,IAAI,WAAW,CAAC;YAC7D,IAAI,CAAC;gBACH,OAAO,KAAK,MAAM,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;gBAC7D,MAAM,SAAS,GAAG,MAAM,WAAW,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBAC1E,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,SAAS,CAAC,CAAC;gBACjD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACxB,MAAM,IAAI,KAAK,CAAC,iCAAiC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;gBAC5E,CAAC;gBACD,IAAI,WAAW,IAAI,kBAAkB,EAAE,CAAC;oBACtC,MAAM,aAAa,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;oBACzC,UAAU,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;gBACpD,CAAC;qBAAM,CAAC;oBACN,MAAM,QAAQ,GAAG,MAAM,cAAc,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;oBACpE,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBAC/B,UAAU,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;gBACpD,CAAC;gBACD,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE;oBACjC,MAAM,EAAE,aAAa,CAAC,MAAM;oBAC5B,WAAW,EAAE,kBAAkB,IAAI,YAAY;oBAC/C,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;iBACtC,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,WAAW,EAAE,CAAC;oBAChB,MAAM,IAAI,KAAK,CACb,4CAA4C,aAAa,CAAC,MAAM,MAAM,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,EAC/F,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAC9B,CAAC;gBACJ,CAAC;gBACD,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE;oBAC5B,MAAM,EAAE,aAAa,CAAC,MAAM;oBAC5B,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC;iBAC/B,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;YAAS,CAAC;QACT,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IAED,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,UAAU,EAAE,CAAC;AAC7D,CAAC;AAED,0FAA0F;AAC1F,SAAS,yBAAyB,CAChC,OAAqC,EACrC,MAAuC;IAEvC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9B,IAAI,OAAO,CAAC,kBAAkB;QAAE,OAAO,OAAO,CAAC,kBAAkB,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC;IACtF,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACnD,yEAAyE;IACzE,6EAA6E;IAC7E,wCAAwC;IACxC,OAAO,KAAK,CAAC,CAAC,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,4BAA4B,CAAC;AAC/E,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,WAAW,CACxB,aAAuC,EACvC,WAAmB,EACnB,OAAqC;IAErC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IACrD,MAAM,KAAK,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAC9D,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,OAAO,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,iBAAiB,CAC9B,aAAuC,EACvC,MAAc;IAEd,MAAM,GAAG,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACrC,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAE3B,MAAM,IAAI,GAAG;QACX,GAAG,GAAG,CAAC,IAAI;QACX,KAAK;QACL,aAAa,CAAC,MAAM;QACpB,SAAS;QACT,gBAAgB;QAChB,QAAQ;QACR,IAAI;KACL,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3D,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC9B,CAAC;IACD,IAAI,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAEnF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE;QACjD,GAAG,EAAE,MAAM;QACX,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,SAAS;QACjB,KAAK,EAAE,KAAK;KACb,CAAC,CAAC;IACH,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,2BAA2B,MAAM,CAAC,QAAQ,MAAM,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,CACjF,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,iBAAiB,CAAC,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,gBAAgB;IAC7B,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;QAClD,IAAI,MAAM,UAAU,CAAC,GAAG,CAAC;YAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;IAC/E,CAAC;IAAC,MAAM,CAAC;QACP,8DAA8D;IAChE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,aAAa,CAC1B,aAAuC,EACvC,MAAc,EACd,OAAqC;IAErC,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACjD,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,WAAW,aAAa,CAAC,MAAM,mEAAmE,CACnG,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GACZ,aAAa,CAAC,gBAAgB,IAAI,OAAO,CAAC,gBAAgB,IAAI,0BAA0B,CAAC;IAC3F,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC7C,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,oBAAoB,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,CAAC,QAAQ,EAAE,GAAG,CACjF,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;IACzD,IAAI,MAAM,CAAC,UAAU,GAAG,QAAQ,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,oBAAoB,QAAQ,WAAW,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,cAAc,CAAC;IAC9E,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACpC,MAAM,KAAK,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3C,MAAM,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;IACpD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,6EAA6E;AAC7E,SAAS,eAAe,CAAC,SAAiB;IACxC,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACtC,MAAM,IAAI,GAAG,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;IAClE,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC;AACrD,CAAC;AAQD;;;GAGG;AACH,KAAK,UAAU,gBAAgB,CAAC,IAAY;IAC1C,IAAI,CAAC,CAAC,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC;QAAE,OAAO,EAAE,CAAC;IACzC,IAAI,MAAM,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3D,OAAO,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;IACD,MAAM,IAAI,GAAqB,EAAE,CAAC;IAClC,KAAK,MAAM,KAAK,IAAI,MAAM,OAAO,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QACjE,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;YAAE,SAAS;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,MAAM,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC;YAC5C,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,aAAa,CAAC,WAAuB,EAAE,IAAsB;IAC1E,MAAM,WAAW,CAAC,IAAI,EAAE,CAAC;IACzB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;YACtF,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC;YAChE,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YAC1E,MAAM,WAAW,CAAC,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,KAAK,UAAU,cAAc,CAAC,MAAc,EAAE,IAAsB;IAClE,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,GAAG,gBAAgB,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,EAAE,CAChG,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAC7B,CAAC;IACF,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,kBAAkB,CAAC,MAAc;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC;IACrB,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,mCAAmC;AACnC,KAAK,UAAU,UAAU,CAAC,IAAY;IACpC,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","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 under {@link localFS.tmpFS} and returned as an extra local skill path\n * for the current process.\n *\n * @module\n */\n\nimport { mkdir, readdir, readFile, rm, stat, writeFile } from \"node:fs/promises\";\nimport { createRequire } from \"node:module\";\nimport { join, posix } from \"node:path\";\nimport type { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport type { WorkspaceClientLike } from \"@dbx-tools/appkit\";\nimport { exec } from \"@dbx-tools/core\";\nimport { DatabricksFileSystem } from \"@dbx-tools/databricks\";\nimport { localFS, type LocalFileSystem } from \"@dbx-tools/fs\";\nimport { find } from \"@dbx-tools/path\";\nimport { error, hash, log, net, string } from \"@dbx-tools/shared-core\";\nimport type { FileSystem } from \"@dbx-tools/shared-fs\";\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/** Stable temp directory holding one rebuilt skill tree per remote source. */\nconst LOCAL_SKILLS_DIR = \"mastra-local-skills\";\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 under\n * {@link localFS.tmpFS} 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 DatabricksFileSystem({\n        client: client as WorkspaceClient,\n        root: databricksBasePath,\n        readOnly: false,\n        createRoot: true,\n      })\n    : undefined;\n\n  const localSkillPaths: string[] = [];\n  const skillNames: string[] = [];\n  let staging: LocalFileSystem | 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 initializedScratch(\"mastra-remote-skills\");\n        const stagedDir = await stageSource(sourceOptions, staging.root, 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 copySkillDirs(destination, staged);\n          skillNames.push(...staged.map((dir) => dir.name));\n        } else {\n          const localDir = await persistLocally(sourceOptions.source, 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) {\n      await rm(staging.root, { recursive: true, force: true }).catch(() => undefined);\n    }\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 `stagingRoot`, preferring the optional\n * `skills` CLI and falling back to a direct fetch.\n */\nasync function stageSource(\n  sourceOptions: RemoteSkillSourceOptions,\n  stagingRoot: string,\n  options: ProvisionRemoteSkillsOptions,\n): Promise<string> {\n  const target = join(stagingRoot, `src-${hash.id()}`);\n  await mkdir(target, { recursive: true });\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 exec.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/**\n * Copy every staged skill directory into {@link destination}, preserving the\n * `<skill>/<relative>` layout. The destination is just a {@link FileSystem},\n * so the Databricks Assistant tree and the local fallback share one copier.\n */\nasync function copySkillDirs(destination: FileSystem, dirs: StagedSkillDir[]): Promise<void> {\n  await destination.init();\n  for (const dir of dirs) {\n    for (const relative of find.findFiles(\"**/*\", { cwd: dir.absolutePath, nodir: true })) {\n      const buffer = await readFile(join(dir.absolutePath, relative));\n      const skillPath = posix.join(dir.name, relative.split(/[\\\\/]/).join(\"/\"));\n      await destination.writeFile(skillPath, buffer, { overwrite: true });\n    }\n  }\n}\n\n/**\n * Copy staged skill dirs into a STABLE local tree keyed by the source, and\n * return its root path.\n *\n * A given source resolves to the same content on almost every boot, so each\n * one owns a directory named for its {@link hash.fnvHash} rather than leaving\n * a fresh scratch dir behind per restart. Keying on the source (not the\n * content) is what keeps two different sources from overwriting each other.\n */\nasync function persistLocally(source: string, dirs: StagedSkillDir[]): Promise<string> {\n  const stable = await localFS.rebuildFS(`${LOCAL_SKILLS_DIR}/${hash.fnvHash(source)}`, (scratch) =>\n    copySkillDirs(scratch, dirs),\n  );\n  return stable.root;\n}\n\n/**\n * A scratch filesystem whose root exists on disk, for the paths that hand a\n * real directory to `node:fs` or a child process rather than going through\n * the {@link FileSystem} API.\n */\nasync function initializedScratch(prefix: string): Promise<LocalFileSystem> {\n  const scratch = localFS.scratchFS(prefix);\n  await scratch.init();\n  return scratch;\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"]}
+//# 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 - the\n * {@link AITOOLS_SOURCE} constant, a GitHub `owner/repo`, any git / GitLab URL,\n * or a direct download URL - and optional per-source policy.\n * {@link provisionRemoteSkills} materializes every source into a local\n * `SKILL.md` tree at app boot and returns the directories to hand Mastra as\n * extra skill scan paths.\n *\n * Resolution per source, in order:\n *\n * 1. the {@link AITOOLS_SOURCE} constant (`\"aitools\"`): Databricks' own skill\n *    set, read straight from the public repo the `databricks aitools` CLI\n *    sources from. No CLI, no Databricks auth - which is what makes it usable\n *    inside a Databricks App container, where the CLI is not installed;\n * 2. 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 * 3. 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 under {@link localFS.tmpFS} and returned as an extra local skill path\n * for the current process.\n *\n * @module\n */\n\nimport { mkdir, readdir, readFile, rm, stat, writeFile } from \"node:fs/promises\";\nimport { createRequire } from \"node:module\";\nimport { dirname, join, posix } from \"node:path\";\nimport type { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport type { WorkspaceClientLike } from \"@dbx-tools/appkit\";\nimport { exec } from \"@dbx-tools/core\";\nimport { DatabricksFileSystem } from \"@dbx-tools/databricks\";\nimport { localFS, type LocalFileSystem } from \"@dbx-tools/fs\";\nimport { find } from \"@dbx-tools/path\";\nimport { error, hash, json, log, net, object, string } from \"@dbx-tools/shared-core\";\nimport type { OneOrMany } from \"@dbx-tools/shared-core\";\nimport type { FileSystem } from \"@dbx-tools/shared-fs\";\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/** Stable temp directory holding one rebuilt skill tree per remote source. */\nconst LOCAL_SKILLS_DIR = \"mastra-local-skills\";\n\n/* ------------------------------ AI Tools ------------------------------ */\n\n/**\n * Source constant selecting Databricks' own AI Tools skill set.\n *\n * @example\n * mastra({ remoteSkills: \"aitools\" });\n */\nexport const AITOOLS_SOURCE = \"aitools\";\n\n/** The {@link AITOOLS_SOURCE} literal, for callers spelling the union out. */\nexport type AiToolsSource = typeof AITOOLS_SOURCE;\n\n/**\n * The PUBLIC repo `databricks aitools install` sources from. Reading it\n * directly is what lets an app get the same skills the CLI installs without\n * the CLI - which a Databricks App container does not ship.\n */\nconst AITOOLS_REPO = \"databricks/databricks-agent-skills\";\n\n/** Repo ref the skills are read from. Override per source with `ref`. */\nconst AITOOLS_REF = \"main\";\n\n/** Skill files downloaded at once; the set is ~30 skills of a few files each. */\nconst AITOOLS_CONCURRENCY = 8;\n\n/** The subset of the repo's generated `manifest.json` this module reads. */\ninterface AiToolsManifest {\n  skills?: Record<string, { files?: string[]; repo_dir?: string }>;\n}\n\n/* -------------------------------- types -------------------------------- */\n\n/**\n * One remote skill source and its per-source policy.\n *\n * `source` is {@link AITOOLS_SOURCE} or anything the `skills` ecosystem\n * understands: a GitHub `owner/repo` shorthand, a full GitHub / GitLab / git\n * URL, or a direct download URL to a `SKILL.md` or archive.\n */\nexport interface RemoteSkillSourceOptions {\n  /** `\"aitools\"`, a GitHub shorthand, a git / GitLab URL, or a download URL. */\n  source: net.UrlLike | AiToolsSource;\n  /** Install only these skill names from the source. */\n  skills?: string | string[];\n  /** Include experimental skills. `\"aitools\"` only. */\n  experimental?: boolean;\n  /** Pin the repo ref (tag / branch / sha). `\"aitools\"` only; defaults to `main`. */\n  ref?: 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: the {@link AITOOLS_SOURCE} constant, a URL-like\n * (string / `URL` / `{ url }`), or a {@link RemoteSkillSourceOptions} bag with\n * per-source policy.\n */\nexport type RemoteSkillSource = net.UrlLike | AiToolsSource | RemoteSkillSourceOptions;\n\n/**\n * The workspace `remoteSkills` option: one source, a non-empty list of them, or\n * a {@link ProvisionRemoteSkillsOptions} bag when top-level policy is needed.\n */\nexport type RemoteSkillsOption =\n  RemoteSkillSource | OneOrMany<RemoteSkillSource> | ProvisionRemoteSkillsOptions;\n\n/** A source entry with its `source` flattened to a plain string. */\ntype NormalizedSource = Omit<RemoteSkillSourceOptions, \"source\"> & { source: string };\n\n/** Top-level remote-skills provisioning options. */\nexport interface ProvisionRemoteSkillsOptions {\n  /** Sources to materialize at startup. */\n  sources: RemoteSkillSource | OneOrMany<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  const bag = isProvisionOptions(option) ? option : undefined;\n  const sources = toSourceList(bag ? bag.sources : (option as RemoteSkillSource));\n  // An empty list is the same as no configuration at all.\n  if (!object.isOneOrMany(sources)) return undefined;\n  return { ...bag, sources };\n}\n\n/** A `sources`-bearing bag is the top-level options shape, not a single source. */\nfunction isProvisionOptions(value: unknown): value is ProvisionRemoteSkillsOptions {\n  return object.isRecord(value) && \"sources\" in value;\n}\n\n/** One source or many, as a plain array. A source is never itself an array. */\nfunction toSourceList(\n  input: RemoteSkillSource | OneOrMany<RemoteSkillSource>,\n): RemoteSkillSource[] {\n  return Array.isArray(input) ? [...input] : [input];\n}\n\n/** Flatten a source entry - string, `URL`, `{ url }`, or options bag - to a {@link NormalizedSource}. */\nfunction toSourceOptions(source: RemoteSkillSource): NormalizedSource {\n  if (typeof source === \"string\") return { source };\n  if (source instanceof URL) return { source: source.toString() };\n  if (\"source\" in source) return { ...source, source: toSourceString(source.source) };\n  return { source: source.url };\n}\n\n/** A {@link net.UrlLike} as the plain string the staging paths work with. */\nfunction toSourceString(source: net.UrlLike): string {\n  if (typeof source === \"string\") return source;\n  return source instanceof URL ? source.toString() : source.url;\n}\n\n/** True when a source selects the built-in Databricks AI Tools skill set. */\nfunction isAiToolsSource(source: string): boolean {\n  return source.trim().toLowerCase() === AITOOLS_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 under\n * {@link localFS.tmpFS} 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 DatabricksFileSystem({\n        client: client as WorkspaceClient,\n        root: databricksBasePath,\n        readOnly: false,\n        createRoot: true,\n      })\n    : undefined;\n\n  const localSkillPaths: string[] = [];\n  const skillNames: string[] = [];\n  let staging: LocalFileSystem | 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 initializedScratch(\"mastra-remote-skills\");\n        const stagedDir = await stageSource(sourceOptions, staging.root, 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 copySkillDirs(destination, staged);\n          skillNames.push(...staged.map((dir) => dir.name));\n        } else {\n          const localDir = await persistLocally(sourceOptions.source, 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) {\n      await rm(staging.root, { recursive: true, force: true }).catch(() => undefined);\n    }\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 `stagingRoot`, preferring the optional\n * `skills` CLI and falling back to a direct fetch.\n */\nasync function stageSource(\n  sourceOptions: NormalizedSource,\n  stagingRoot: string,\n  options: ProvisionRemoteSkillsOptions,\n): Promise<string> {\n  const target = join(stagingRoot, `src-${hash.id()}`);\n  await mkdir(target, { recursive: true });\n  // AI Tools resolves from a known repo layout, so it never needs the CLI.\n  if (isAiToolsSource(sourceOptions.source)) return stageAiTools(sourceOptions, target, options);\n  const viaCli = await stageViaSkillsCli(sourceOptions, target);\n  if (viaCli) return viaCli;\n  return stageViaFetch(sourceOptions, target, options);\n}\n\n/**\n * Materialize the Databricks AI Tools skills into `target`.\n *\n * Reads the repo's own generated `manifest.json` (which names each skill's\n * files and whether it lives under `skills/` or `experimental/`) and downloads\n * them - the same thing `databricks aitools install` does, minus the CLI and\n * minus any Databricks auth, since the repo is public.\n */\nasync function stageAiTools(\n  sourceOptions: NormalizedSource,\n  target: string,\n  options: ProvisionRemoteSkillsOptions,\n): Promise<string> {\n  const maxBytes = resolveMaxBytes(sourceOptions, options);\n  const ref = string.trimToNull(sourceOptions.ref) ?? AITOOLS_REF;\n  const manifest = json.parse(\n    (await download(aiToolsRawUrl(ref, \"manifest.json\"), maxBytes)).toString(\"utf8\"),\n    undefined,\n  ) as AiToolsManifest | undefined;\n\n  const wanted = new Set(string.parseList(sourceOptions.skills));\n  const selected = Object.entries(manifest?.skills ?? {}).filter(([name, entry]) =>\n    wanted.size > 0\n      ? wanted.has(name)\n      : entry.repo_dir !== \"experimental\" || sourceOptions.experimental === true,\n  );\n  if (selected.length === 0) {\n    throw new Error(`no matching skills in ${AITOOLS_REPO}@${ref}`);\n  }\n\n  const files = selected.flatMap(([name, entry]) =>\n    (entry.files ?? []).map((file) => ({\n      url: aiToolsRawUrl(ref, `${entry.repo_dir ?? \"skills\"}/${name}/${file}`),\n      path: join(target, name, ...file.split(\"/\")),\n    })),\n  );\n  await mapConcurrent(files, AITOOLS_CONCURRENCY, async (item) => {\n    const body = await download(item.url, maxBytes);\n    await mkdir(dirname(item.path), { recursive: true });\n    await writeFile(item.path, body);\n  });\n\n  logger.debug(\"aitools:staged\", { ref, skills: selected.length, files: files.length });\n  return target;\n}\n\n/** Raw-content URL for a path in the AI Tools repo at `ref`. */\nfunction aiToolsRawUrl(ref: string, path: string): string {\n  return `https://raw.githubusercontent.com/${AITOOLS_REPO}/${ref}/${path}`;\n}\n\n/** Run `worker` over `items`, at most `limit` in flight. */\nasync function mapConcurrent<T>(\n  items: readonly T[],\n  limit: number,\n  worker: (item: T) => Promise<void>,\n): Promise<void> {\n  let cursor = 0;\n  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {\n    while (cursor < items.length) {\n      await worker(items[cursor++]!);\n    }\n  });\n  await Promise.all(runners);\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: NormalizedSource,\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 exec.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: NormalizedSource,\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 buffer = await download(url.toString(), resolveMaxBytes(sourceOptions, options));\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/** The effective download ceiling: per-source, then top-level, then the default. */\nfunction resolveMaxBytes(\n  sourceOptions: NormalizedSource,\n  options: ProvisionRemoteSkillsOptions,\n): number {\n  return sourceOptions.maxDownloadBytes ?? options.maxDownloadBytes ?? DEFAULT_MAX_DOWNLOAD_BYTES;\n}\n\n/** GET a URL, failing loudly on a non-2xx status or an oversized body. */\nasync function download(url: string, maxBytes: number): Promise<Buffer> {\n  const response = await fetch(url);\n  if (!response.ok) {\n    throw new Error(`download failed: ${response.status} ${response.statusText} (${url})`);\n  }\n  const buffer = Buffer.from(await response.arrayBuffer());\n  if (buffer.byteLength > maxBytes) {\n    throw new Error(`download exceeds ${maxBytes} bytes (${url})`);\n  }\n  return buffer;\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/**\n * Copy every staged skill directory into {@link destination}, preserving the\n * `<skill>/<relative>` layout. The destination is just a {@link FileSystem},\n * so the Databricks Assistant tree and the local fallback share one copier.\n */\nasync function copySkillDirs(destination: FileSystem, dirs: StagedSkillDir[]): Promise<void> {\n  await destination.init();\n  for (const dir of dirs) {\n    for (const relative of find.findFiles(\"**/*\", { cwd: dir.absolutePath, nodir: true })) {\n      const buffer = await readFile(join(dir.absolutePath, relative));\n      const skillPath = posix.join(dir.name, relative.split(/[\\\\/]/).join(\"/\"));\n      await destination.writeFile(skillPath, buffer, { overwrite: true });\n    }\n  }\n}\n\n/**\n * Copy staged skill dirs into a STABLE local tree keyed by the source, and\n * return its root path.\n *\n * A given source resolves to the same content on almost every boot, so each\n * one owns a directory named for its {@link hash.fnvHash} rather than leaving\n * a fresh scratch dir behind per restart. Keying on the source (not the\n * content) is what keeps two different sources from overwriting each other.\n */\nasync function persistLocally(source: string, dirs: StagedSkillDir[]): Promise<string> {\n  const stable = await localFS.rebuildFS(`${LOCAL_SKILLS_DIR}/${hash.fnvHash(source)}`, (scratch) =>\n    copySkillDirs(scratch, dirs),\n  );\n  return stable.root;\n}\n\n/**\n * A scratch filesystem whose root exists on disk, for the paths that hand a\n * real directory to `node:fs` or a child process rather than going through\n * the {@link FileSystem} API.\n */\nasync function initializedScratch(prefix: string): Promise<LocalFileSystem> {\n  const scratch = localFS.scratchFS(prefix);\n  await scratch.init();\n  return scratch;\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/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/agents.ts","../src/chart.ts","../src/config.ts","../src/databricks-aitools.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"}
+{"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

@@ -32,25 +32,25 @@
     "express": "^5.1.0",
     "pg": "^8.22.0",
     "zod": "4.3.6",
-    "@dbx-tools/appkit": "0.6.10",
-    "@dbx-tools/databricks": "0.6.10",
-    "@dbx-tools/genie": "0.6.10",
-    "@dbx-tools/fs": "0.6.10",
-    "@dbx-tools/model": "0.6.10",
-    "@dbx-tools/core": "0.6.10",
-    "@dbx-tools/path": "0.6.10",
-    "@dbx-tools/shared-core": "0.6.10",
-    "@dbx-tools/shared-fs": "0.6.10",
-    "@dbx-tools/shared-model": "0.6.10",
-    "@dbx-tools/shared-genie": "0.6.10",
-    "@dbx-tools/shared-mastra": "0.6.10"
+    "@dbx-tools/core": "0.6.11",
+    "@dbx-tools/fs": "0.6.11",
+    "@dbx-tools/databricks": "0.6.11",
+    "@dbx-tools/model": "0.6.11",
+    "@dbx-tools/genie": "0.6.11",
+    "@dbx-tools/shared-core": "0.6.11",
+    "@dbx-tools/appkit": "0.6.11",
+    "@dbx-tools/path": "0.6.11",
+    "@dbx-tools/shared-genie": "0.6.11",
+    "@dbx-tools/shared-mastra": "0.6.11",
+    "@dbx-tools/shared-fs": "0.6.11",
+    "@dbx-tools/shared-model": "0.6.11"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.10",
+  "version": "0.6.11",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/config.ts

@@ -23,7 +23,6 @@ import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from "@mastra/core/reque
 import type { PgVectorConfig, PostgresStoreConfig } from "@mastra/pg";
 
 import type { MastraAgentDefinition, MastraTools } from "./agents.ts";
-import type { DatabricksAIToolsOption } from "./databricks-aitools.ts";
 import type { GenieSpacesConfig } from "./genie.ts";
 import type { MastraIdentityMode } from "./identity.ts";
 import type { RemoteSkillsOption } from "./remote-skills.ts";
@@ -581,27 +580,6 @@ export interface MastraPluginConfig extends BasePluginConfig {
    * ```
    */
   remoteSkills?: RemoteSkillsOption;
-
-  /**
-   * Fold Databricks AI Tools skills (`databricks aitools`) into every
-   * default-workspace agent as extra local skill scan paths.
-   *
-   * `false` (default) off; `"auto"` runs the `databricks` CLI when it's
-   * installed and logs-and-continues when it isn't (never fails startup);
-   * `true` requires the CLI and fails startup otherwise. Pass an options bag to
-   * select `skills`, include `experimental` skills, or set an explicit `path`.
-   *
-   * Runs `databricks aitools install --path <dir>` to materialize a resolved,
-   * agent-agnostic set (`<name>/SKILL.md` trees) into a temp dir the agents
-   * then scan. The CLI is the source of truth.
-   *
-   * @example
-   * ```ts
-   * mastra({ databricksAITools: "auto" });
-   * mastra({ databricksAITools: { skills: ["databricks-core", "databricks-jobs"] } });
-   * ```
-   */
-  databricksAITools?: DatabricksAIToolsOption;
 }
 
 /**
@@ -623,12 +601,7 @@ export const MASTRA_CONFIG_SCHEMA: ConfigSchema = {
     remoteSkills: {
       type: ["string", "array", "object"],
       description:
-        "Remote Agent-Skill sources provisioned at startup (GitHub owner/repo, git/GitLab URL, or a direct SKILL.md/archive URL). Prefers the optional `skills` npm CLI, else a direct fetch; fails startup on error unless failOnError:false. Written to the Databricks user Assistant skills folder, or a local temp dir when no workspace is writable.",
-    },
-    databricksAITools: {
-      type: ["boolean", "string", "object"],
-      description:
-        'Fold Databricks AI Tools skills (databricks aitools) into agents as extra local skill paths. false (default) off; "auto" runs the databricks CLI when installed and logs-and-continues otherwise; true requires the CLI and fails startup otherwise. An object selects skills, experimental, or path.',
+        'Remote Agent-Skill sources provisioned at startup: "aitools" for Databricks\' own skill set (read from the public databricks/databricks-agent-skills repo, no CLI needed), a GitHub owner/repo, a git/GitLab URL, or a direct SKILL.md/archive URL. Non-aitools sources prefer the optional `skills` npm CLI, else a direct fetch; fails startup on error unless failOnError:false. Written to the Databricks user Assistant skills folder, or a local temp dir when no workspace is writable.',
     },
     storage: {
       type: ["boolean", "object"],

package/src/plugin.ts

@@ -77,7 +77,6 @@ import type { Pool } from "pg";
 import { buildAgents, FALLBACK_AGENT_ID, type BuiltAgents } from "./agents.ts";
 import { fetchChart } from "./chart.ts";
 import { attributedUserId, MASTRA_CONFIG_SCHEMA, type MastraPluginConfig } from "./config.ts";
-import { provisionDatabricksAITools } from "./databricks-aitools.ts";
 import {
   chartFetchDefaults,
   feedbackWriteDefaults,
@@ -1012,24 +1011,12 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
       });
     }
 
-    // Fold Databricks AI Tools skills (`databricks aitools`) in as extra local
-    // skill scan paths: reuse the CLI's installed tree when present, else shell
-    // out to the CLI to materialize a curated set.
-    const aiTools = await provisionDatabricksAITools(this.config.databricksAITools);
-    if (aiTools.localSkillPaths.length > 0) {
-      this.logger.info("databricks ai tools provisioned", {
-        source: aiTools.source,
-        localSkillPaths: aiTools.localSkillPaths.length,
-      });
-    }
-    const extraSkillPaths = [...provisioned.localSkillPaths, ...aiTools.localSkillPaths];
-
     this.built = await buildAgents({
       config: this.config,
       context: this.context,
       memoryBuilder,
       log: this.logger,
-      extraSkillPaths,
+      extraSkillPaths: provisioned.localSkillPaths,
     });
 
     // `mastra.server.apiRoutes` is only honored by Mastra's standalone