@dbx-tools/appkit-mastra 0.9.61 → 0.9.64

package/lib/src/skill-cache.js

@@ -0,0 +1,194 @@
+/**
+ * AppKit-backed caching for Databricks workspace skill mounts.
+ *
+ * @module
+ */
+import { randomUUID } from "node:crypto";
+import { CacheManager } from "@databricks/appkit";
+import { hash, object } from "@dbx-tools/shared-core";
+import { filesystems } from "./filesystems.js";
+const CACHE_NAMESPACE = "mastra:workspace-skills";
+const DEFAULT_MAX_SCOPED_MOUNTS = 256;
+const scopedMounts = new Map();
+/** Default remote skill metadata and content cache lifetime. */
+export const DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS = 5 * 60 * 1000;
+/**
+ * Cache read-only filesystem operations through AppKit while delegating
+ * mutations to the current request's source.
+ */
+export class AppKitCachedFileSystem {
+    backend = "appkit-cache";
+    id;
+    readOnly;
+    root;
+    source;
+    host;
+    ttlSec;
+    userKey;
+    constructor(options) {
+        this.host = options.host;
+        this.source = options.source;
+        this.root = options.source.root;
+        this.readOnly = options.source.readOnly;
+        this.ttlSec = cacheTtlSec(options.ttlMs);
+        this.userKey = options.userKey;
+        this.id = `appkit-skill-cache-${hash.fnvHash(this.host, this.userKey, this.root)}`;
+    }
+    /** Rebind cache misses and writes to the current request's OBO filesystem. */
+    bind(source) {
+        if (source.root !== this.root || source.readOnly !== this.readOnly) {
+            throw new Error("Cannot rebind a workspace skill cache to a different filesystem scope");
+        }
+        this.source = source;
+    }
+    async init() {
+        await this.source.init();
+    }
+    /** Keep the shared scope alive when one request releases its workspace view. */
+    close() {
+        return Promise.resolve();
+    }
+    resolvePath(inputPath) {
+        return this.source.resolvePath(inputPath);
+    }
+    async readFile(inputPath, options) {
+        const value = await this.cached("readFile", inputPath, undefined, async (source) => ({
+            base64: Buffer.from(await source.readFile(inputPath)).toString("base64"),
+        }));
+        const bytes = Buffer.from(value.base64, "base64");
+        return options?.encoding ? bytes.toString(options.encoding) : bytes;
+    }
+    async writeFile(inputPath, content, options) {
+        await this.mutate((source) => source.writeFile(inputPath, content, options));
+    }
+    async appendFile(inputPath, content) {
+        await this.mutate((source) => source.appendFile(inputPath, content));
+    }
+    async deleteFile(inputPath, options) {
+        await this.mutate((source) => source.deleteFile(inputPath, options));
+    }
+    async copyFile(sourcePath, destinationPath, options) {
+        await this.mutate((source) => source.copyFile(sourcePath, destinationPath, options));
+    }
+    async moveFile(sourcePath, destinationPath, options) {
+        await this.mutate((source) => source.moveFile(sourcePath, destinationPath, options));
+    }
+    async mkdir(inputPath, options) {
+        await this.mutate((source) => source.mkdir(inputPath, options));
+    }
+    async rmdir(inputPath, options) {
+        await this.mutate((source) => source.rmdir(inputPath, options));
+    }
+    async readdir(inputPath, options) {
+        return this.cached("readdir", inputPath, options, (source) => source.readdir(inputPath, options));
+    }
+    async exists(inputPath) {
+        return this.cached("exists", inputPath, undefined, (source) => source.exists(inputPath));
+    }
+    async stat(inputPath) {
+        const value = await this.cached("stat", inputPath, undefined, async (source) => serializeStat(await source.stat(inputPath)));
+        return deserializeStat(value);
+    }
+    /** Rotate this scope's cache generation so the next read reloads it. */
+    async invalidate() {
+        const cache = await CacheManager.getInstance();
+        await cache.set(this.generationKey(cache), randomUUID(), {
+            ttl: this.ttlSec * 2,
+        });
+    }
+    async cached(operation, inputPath, options, load) {
+        const source = this.source;
+        const cache = await CacheManager.getInstance();
+        const generation = await this.generation(cache);
+        return cache.getOrExecute([
+            CACHE_NAMESPACE,
+            this.host,
+            this.root,
+            generation,
+            operation,
+            source.resolvePath(inputPath),
+            object.toStableKey(options ?? {}),
+        ], () => load(source), this.userKey, { ttl: this.ttlSec });
+    }
+    async generation(cache) {
+        return cache.getOrExecute([CACHE_NAMESPACE, "generation", this.host, this.root], async () => randomUUID(), this.userKey, { ttl: this.ttlSec * 2 });
+    }
+    generationKey(cache) {
+        return cache.generateKey([CACHE_NAMESPACE, "generation", this.host, this.root], this.userKey);
+    }
+    async mutate(run) {
+        const source = this.source;
+        await run(source);
+        await this.invalidate();
+    }
+}
+/** Return one stable Mastra mount per resolved user, host, and source root. */
+export function cachedWorkspaceSkillMount(options) {
+    const cacheKey = object.toStableKey({
+        host: options.host,
+        readOnly: options.source.readOnly,
+        root: options.source.root,
+        userKey: options.userKey,
+    });
+    const existing = scopedMounts.get(cacheKey);
+    if (existing) {
+        existing.cache.bind(options.source);
+        scopedMounts.delete(cacheKey);
+        scopedMounts.set(cacheKey, existing);
+        return { cacheKey, filesystem: existing.adapter };
+    }
+    const cache = new AppKitCachedFileSystem(options);
+    const entry = {
+        adapter: filesystems(cache, {
+            id: cache.id,
+            readOnly: options.source.readOnly,
+        }),
+        cache,
+        host: options.host,
+        root: options.source.root,
+        userKey: options.userKey,
+    };
+    scopedMounts.set(cacheKey, entry);
+    trimScopedMounts();
+    return { cacheKey, filesystem: entry.adapter };
+}
+/** Invalidate one user's cached workspace skill scope. */
+export async function clearWorkspaceSkillCache(options) {
+    const matches = [...scopedMounts.entries()].filter(([, entry]) => entry.host === options.host &&
+        entry.userKey === options.userKey &&
+        (options.root === undefined || entry.root === options.root));
+    await Promise.all(matches.map(([, entry]) => entry.cache.invalidate()));
+}
+function cacheTtlSec(ttlMs = DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS) {
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+        throw new Error("Workspace skill cache ttlMs must be a positive finite number");
+    }
+    return Math.max(1, Math.ceil(ttlMs / 1000));
+}
+function serializeStat(value) {
+    const { accessedAt, createdAt, modifiedAt, ...stat } = value;
+    return {
+        ...stat,
+        ...(accessedAt ? { accessedAt: accessedAt.getTime() } : {}),
+        ...(createdAt ? { createdAt: createdAt.getTime() } : {}),
+        ...(modifiedAt ? { modifiedAt: modifiedAt.getTime() } : {}),
+    };
+}
+function deserializeStat(value) {
+    const { accessedAt, createdAt, modifiedAt, ...stat } = value;
+    return {
+        ...stat,
+        ...(accessedAt !== undefined ? { accessedAt: new Date(accessedAt) } : {}),
+        ...(createdAt !== undefined ? { createdAt: new Date(createdAt) } : {}),
+        ...(modifiedAt !== undefined ? { modifiedAt: new Date(modifiedAt) } : {}),
+    };
+}
+function trimScopedMounts() {
+    while (scopedMounts.size > DEFAULT_MAX_SCOPED_MOUNTS) {
+        const oldest = scopedMounts.keys().next().value;
+        if (oldest === undefined)
+            return;
+        scopedMounts.delete(oldest);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skill-cache.js","sourceRoot":"","sources":["../../src/skill-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit-backed caching for Databricks workspace skill mounts.\n *\n * @module\n */\n\nimport { randomUUID } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { hash, object } from \"@dbx-tools/shared-core\";\nimport type {\n  CopyOptions,\n  FileContent,\n  FileEntry,\n  FileStat,\n  FileSystem,\n  ListOptions,\n  MakeDirectoryOptions,\n  ReadFileOptions,\n  RemoveOptions,\n  WriteFileOptions,\n} from \"@dbx-tools/shared-fs\";\n\nimport { filesystems, type MastraFileSystemAdapter } from \"./filesystems.ts\";\n\nconst CACHE_NAMESPACE = \"mastra:workspace-skills\";\nconst DEFAULT_MAX_SCOPED_MOUNTS = 256;\n\ninterface CachedFileStat extends Omit<FileStat, \"accessedAt\" | \"createdAt\" | \"modifiedAt\"> {\n  accessedAt?: number;\n  createdAt?: number;\n  modifiedAt?: number;\n}\n\ninterface ScopedMountEntry {\n  adapter: MastraFileSystemAdapter;\n  cache: AppKitCachedFileSystem;\n  host: string;\n  root: string;\n  userKey: string;\n}\n\nconst scopedMounts = new Map<string, ScopedMountEntry>();\n\n/** Default remote skill metadata and content cache lifetime. */\nexport const DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS = 5 * 60 * 1000;\n\n/** Options for one AppKit-cached workspace skill filesystem. */\nexport interface AppKitCachedFileSystemOptions {\n  host: string;\n  source: FileSystem;\n  ttlMs?: number;\n  userKey: string;\n}\n\n/** Stable Mastra mount plus the identity key used for source reuse. */\nexport interface CachedWorkspaceSkillMount {\n  cacheKey: string;\n  filesystem: MastraFileSystemAdapter;\n}\n\n/**\n * Cache read-only filesystem operations through AppKit while delegating\n * mutations to the current request's source.\n */\nexport class AppKitCachedFileSystem implements FileSystem<\"appkit-cache\"> {\n  readonly backend = \"appkit-cache\" as const;\n  readonly id: string;\n  readonly readOnly: boolean;\n  readonly root: string;\n\n  private source: FileSystem;\n  private readonly host: string;\n  private readonly ttlSec: number;\n  private readonly userKey: string;\n\n  constructor(options: AppKitCachedFileSystemOptions) {\n    this.host = options.host;\n    this.source = options.source;\n    this.root = options.source.root;\n    this.readOnly = options.source.readOnly;\n    this.ttlSec = cacheTtlSec(options.ttlMs);\n    this.userKey = options.userKey;\n    this.id = `appkit-skill-cache-${hash.fnvHash(this.host, this.userKey, this.root)}`;\n  }\n\n  /** Rebind cache misses and writes to the current request's OBO filesystem. */\n  bind(source: FileSystem): void {\n    if (source.root !== this.root || source.readOnly !== this.readOnly) {\n      throw new Error(\"Cannot rebind a workspace skill cache to a different filesystem scope\");\n    }\n    this.source = source;\n  }\n\n  async init(): Promise<void> {\n    await this.source.init();\n  }\n\n  /** Keep the shared scope alive when one request releases its workspace view. */\n  close(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  resolvePath(inputPath: string): string {\n    return this.source.resolvePath(inputPath);\n  }\n\n  async readFile(inputPath: string): Promise<Uint8Array>;\n  async readFile(\n    inputPath: string,\n    options: ReadFileOptions & { encoding: string },\n  ): Promise<string>;\n  async readFile(inputPath: string, options?: ReadFileOptions): Promise<string | Uint8Array> {\n    const value = await this.cached(\"readFile\", inputPath, undefined, async (source) => ({\n      base64: Buffer.from(await source.readFile(inputPath)).toString(\"base64\"),\n    }));\n    const bytes = Buffer.from(value.base64, \"base64\");\n    return options?.encoding ? bytes.toString(options.encoding as BufferEncoding) : bytes;\n  }\n\n  async writeFile(\n    inputPath: string,\n    content: FileContent,\n    options?: WriteFileOptions,\n  ): Promise<void> {\n    await this.mutate((source) => source.writeFile(inputPath, content, options));\n  }\n\n  async appendFile(inputPath: string, content: FileContent): Promise<void> {\n    await this.mutate((source) => source.appendFile(inputPath, content));\n  }\n\n  async deleteFile(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.mutate((source) => source.deleteFile(inputPath, options));\n  }\n\n  async copyFile(\n    sourcePath: string,\n    destinationPath: string,\n    options?: CopyOptions,\n  ): Promise<void> {\n    await this.mutate((source) => source.copyFile(sourcePath, destinationPath, options));\n  }\n\n  async moveFile(\n    sourcePath: string,\n    destinationPath: string,\n    options?: CopyOptions,\n  ): Promise<void> {\n    await this.mutate((source) => source.moveFile(sourcePath, destinationPath, options));\n  }\n\n  async mkdir(inputPath: string, options?: MakeDirectoryOptions): Promise<void> {\n    await this.mutate((source) => source.mkdir(inputPath, options));\n  }\n\n  async rmdir(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.mutate((source) => source.rmdir(inputPath, options));\n  }\n\n  async readdir(inputPath: string, options?: ListOptions): Promise<FileEntry[]> {\n    return this.cached(\"readdir\", inputPath, options, (source) =>\n      source.readdir(inputPath, options),\n    );\n  }\n\n  async exists(inputPath: string): Promise<boolean> {\n    return this.cached(\"exists\", inputPath, undefined, (source) => source.exists(inputPath));\n  }\n\n  async stat(inputPath: string): Promise<FileStat> {\n    const value = await this.cached(\"stat\", inputPath, undefined, async (source) =>\n      serializeStat(await source.stat(inputPath)),\n    );\n    return deserializeStat(value);\n  }\n\n  /** Rotate this scope's cache generation so the next read reloads it. */\n  async invalidate(): Promise<void> {\n    const cache = await CacheManager.getInstance();\n    await cache.set(this.generationKey(cache), randomUUID(), {\n      ttl: this.ttlSec * 2,\n    });\n  }\n\n  private async cached<T>(\n    operation: string,\n    inputPath: string,\n    options: unknown,\n    load: (source: FileSystem) => Promise<T>,\n  ): Promise<T> {\n    const source = this.source;\n    const cache = await CacheManager.getInstance();\n    const generation = await this.generation(cache);\n    return cache.getOrExecute(\n      [\n        CACHE_NAMESPACE,\n        this.host,\n        this.root,\n        generation,\n        operation,\n        source.resolvePath(inputPath),\n        object.toStableKey(options ?? {}),\n      ],\n      () => load(source),\n      this.userKey,\n      { ttl: this.ttlSec },\n    );\n  }\n\n  private async generation(cache: CacheManager): Promise<string> {\n    return cache.getOrExecute(\n      [CACHE_NAMESPACE, \"generation\", this.host, this.root],\n      async () => randomUUID(),\n      this.userKey,\n      { ttl: this.ttlSec * 2 },\n    );\n  }\n\n  private generationKey(cache: CacheManager): string {\n    return cache.generateKey([CACHE_NAMESPACE, \"generation\", this.host, this.root], this.userKey);\n  }\n\n  private async mutate(run: (source: FileSystem) => Promise<void>): Promise<void> {\n    const source = this.source;\n    await run(source);\n    await this.invalidate();\n  }\n}\n\n/** Return one stable Mastra mount per resolved user, host, and source root. */\nexport function cachedWorkspaceSkillMount(\n  options: AppKitCachedFileSystemOptions,\n): CachedWorkspaceSkillMount {\n  const cacheKey = object.toStableKey({\n    host: options.host,\n    readOnly: options.source.readOnly,\n    root: options.source.root,\n    userKey: options.userKey,\n  });\n  const existing = scopedMounts.get(cacheKey);\n  if (existing) {\n    existing.cache.bind(options.source);\n    scopedMounts.delete(cacheKey);\n    scopedMounts.set(cacheKey, existing);\n    return { cacheKey, filesystem: existing.adapter };\n  }\n\n  const cache = new AppKitCachedFileSystem(options);\n  const entry: ScopedMountEntry = {\n    adapter: filesystems(cache, {\n      id: cache.id,\n      readOnly: options.source.readOnly,\n    }),\n    cache,\n    host: options.host,\n    root: options.source.root,\n    userKey: options.userKey,\n  };\n  scopedMounts.set(cacheKey, entry);\n  trimScopedMounts();\n  return { cacheKey, filesystem: entry.adapter };\n}\n\n/** Invalidate one user's cached workspace skill scope. */\nexport async function clearWorkspaceSkillCache(options: {\n  host: string;\n  root?: string;\n  userKey: string;\n}): Promise<void> {\n  const matches = [...scopedMounts.entries()].filter(\n    ([, entry]) =>\n      entry.host === options.host &&\n      entry.userKey === options.userKey &&\n      (options.root === undefined || entry.root === options.root),\n  );\n  await Promise.all(matches.map(([, entry]) => entry.cache.invalidate()));\n}\n\nfunction cacheTtlSec(ttlMs = DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS): number {\n  if (!Number.isFinite(ttlMs) || ttlMs <= 0) {\n    throw new Error(\"Workspace skill cache ttlMs must be a positive finite number\");\n  }\n  return Math.max(1, Math.ceil(ttlMs / 1000));\n}\n\nfunction serializeStat(value: FileStat): CachedFileStat {\n  const { accessedAt, createdAt, modifiedAt, ...stat } = value;\n  return {\n    ...stat,\n    ...(accessedAt ? { accessedAt: accessedAt.getTime() } : {}),\n    ...(createdAt ? { createdAt: createdAt.getTime() } : {}),\n    ...(modifiedAt ? { modifiedAt: modifiedAt.getTime() } : {}),\n  };\n}\n\nfunction deserializeStat(value: CachedFileStat): FileStat {\n  const { accessedAt, createdAt, modifiedAt, ...stat } = value;\n  return {\n    ...stat,\n    ...(accessedAt !== undefined ? { accessedAt: new Date(accessedAt) } : {}),\n    ...(createdAt !== undefined ? { createdAt: new Date(createdAt) } : {}),\n    ...(modifiedAt !== undefined ? { modifiedAt: new Date(modifiedAt) } : {}),\n  };\n}\n\nfunction trimScopedMounts(): void {\n  while (scopedMounts.size > DEFAULT_MAX_SCOPED_MOUNTS) {\n    const oldest = scopedMounts.keys().next().value;\n    if (oldest === undefined) return;\n    scopedMounts.delete(oldest);\n  }\n}\n"]}

package/lib/src/workspaces.d.ts

@@ -60,6 +60,11 @@ export interface WorkspaceMountContribution {
     mounts: Record<string, WorkspaceFilesystem>;
     /** Paths within the composite namespace where `SKILL.md` files are scanned. */
     skillPaths?: string[];
+    /**
+     * Stable identity for this contribution. When every non-empty contribution
+     * supplies one, Mastra reuses the resolved source across requests.
+     */
+    cacheKey?: string;
 }
 /** Contributes filesystem mounts (and optional skill paths) for one request. */
 export type WorkspaceMountResolver = (context: WorkspaceMountContext) => WorkspaceMountContribution | Promise<WorkspaceMountContribution>;
@@ -94,6 +99,11 @@ export interface CreateWorkspaceOptions {
     skills?: SkillsResolver;
     /** Forwarded to Mastra when skill discovery is enabled. */
     checkSkillFileMtime?: boolean;
+    /**
+     * AppKit cache TTL for Databricks skill metadata and content.
+     * Defaults to five minutes.
+     */
+    workspaceSkillRefreshTtlMs?: number;
     /** Enable BM25 keyword search over indexed workspace content. */
     bm25?: boolean;
     /**