@bevel-software/platform-core-backend 0.15.1 → 0.20.0

package/dist/modules/kb-fs/git-guarded-filesystem.js

@@ -0,0 +1,117 @@
+import path from 'node:path';
+import { LocalFilesystem, } from '@mastra/core/workspace';
+import { GitInternalsError } from '../../shared/domain-errors.js';
+import { assertNotGitInternals, hasGitInternalsSegment } from '../../shared/git-internals.js';
+/**
+ * A `LocalFilesystem` on which the repository's git folder does not exist.
+ *
+ * Every agent filesystem — the lock-aware writer and the read-only one —
+ * extends this, so each method a file tool reaches refuses a path that names
+ * the folder or resolves into it (see `shared/git-internals.ts`) before it
+ * does anything else, and a listing leaves the folder, and any link into it,
+ * out. The workspace tools check their path inputs up front as well; this is
+ * the floor under them, for whatever reaches the filesystem another way.
+ */
+export class GitGuardedFilesystem extends LocalFilesystem {
+    /**
+     * Refuse `inputPath` when it names the git folder or resolves into it.
+     *
+     * The caller's SPELLING is judged first, every way it could land: this
+     * filesystem's own resolver reads a backslash as an ordinary character and
+     * carries a leading climb out of the workspace, so a link reached either way
+     * used to resolve to nothing and pass. Where this filesystem would actually
+     * put the path is then judged too, when that is somewhere else again.
+     */
+    async assertNotGitInternals(inputPath) {
+        // ONE call carrying both the spelling and the place this filesystem
+        // would put it. Both are still judged — a link this resolver cannot
+        // place (a backslash-spelled one, a leading climb) is caught by the
+        // spelling's own readings, a link it follows by the place — but the rule
+        // walks the root once and probes a place both name once, where two calls
+        // walked the root twice and probed that place twice.
+        await assertNotGitInternals(this.basePath, inputPath, this.resolveAbsolutePath(inputPath));
+    }
+    async readFile(inputPath, options) {
+        await this.assertNotGitInternals(inputPath);
+        return super.readFile(inputPath, options);
+    }
+    async writeFile(inputPath, content, options) {
+        await this.assertNotGitInternals(inputPath);
+        return super.writeFile(inputPath, content, options);
+    }
+    async appendFile(inputPath, content) {
+        await this.assertNotGitInternals(inputPath);
+        return super.appendFile(inputPath, content);
+    }
+    async deleteFile(inputPath, options) {
+        await this.assertNotGitInternals(inputPath);
+        return super.deleteFile(inputPath, options);
+    }
+    async copyFile(src, dest, options) {
+        await this.assertNotGitInternals(src);
+        await this.assertNotGitInternals(dest);
+        return super.copyFile(src, dest, options);
+    }
+    async moveFile(src, dest, options) {
+        await this.assertNotGitInternals(src);
+        await this.assertNotGitInternals(dest);
+        return super.moveFile(src, dest, options);
+    }
+    async mkdir(inputPath, options) {
+        await this.assertNotGitInternals(inputPath);
+        return super.mkdir(inputPath, options);
+    }
+    async rmdir(inputPath, options) {
+        await this.assertNotGitInternals(inputPath);
+        return super.rmdir(inputPath, options);
+    }
+    /**
+     * The recursion is done HERE, not in `LocalFilesystem`: its recursive walk
+     * calls back into this override for every child directory, and the git
+     * folder would refuse the whole listing instead of being left out of it.
+     * Same order and naming as the base (each directory followed by its
+     * `dir/child` entries), with the git folder and links into it filtered first.
+     */
+    async readdir(inputPath, options) {
+        await this.assertNotGitInternals(inputPath);
+        const { recursive, maxDepth, ...flat } = options ?? {};
+        const entries = await super.readdir(inputPath, flat);
+        const dir = inputPath.replace(/\\/g, '/');
+        const visible = [];
+        for (const entry of entries) {
+            if (hasGitInternalsSegment(entry.name))
+                continue;
+            const childPath = path.posix.join(dir, entry.name);
+            if (entry.isSymlink) {
+                try {
+                    await this.assertNotGitInternals(childPath);
+                }
+                catch (err) {
+                    if (err instanceof GitInternalsError)
+                        continue;
+                    throw err;
+                }
+            }
+            visible.push(entry);
+            const depth = maxDepth ?? 100;
+            if (recursive && entry.type === 'directory' && depth > 0) {
+                const children = await this.readdir(childPath, { ...options, maxDepth: depth - 1 });
+                visible.push(...children.map((child) => ({ ...child, name: `${entry.name}/${child.name}` })));
+            }
+        }
+        return visible;
+    }
+    async exists(inputPath) {
+        await this.assertNotGitInternals(inputPath);
+        return super.exists(inputPath);
+    }
+    async stat(inputPath) {
+        await this.assertNotGitInternals(inputPath);
+        return super.stat(inputPath);
+    }
+    async realpath(inputPath) {
+        await this.assertNotGitInternals(inputPath);
+        return super.realpath(inputPath);
+    }
+}
+//# sourceMappingURL=git-guarded-filesystem.js.map

package/dist/modules/kb-fs/git-guarded-filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-guarded-filesystem.js","sourceRoot":"","sources":["../../../src/modules/kb-fs/git-guarded-filesystem.ts"],"names":[],"mappings":"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"}

package/dist/modules/kb-fs/locking-filesystem.d.ts

@@ -23,7 +23,10 @@
  *     The agent must delete entries individually via `deleteFile`.
  *   - `mkdir` followed by a `.gitkeep` write is the canonical way to land
  *     "create empty folder" as a one-file change — the locking write of
- *     `.gitkeep` carries the commit.
+ *     `.gitkeep` carries the commit. The same placeholder keeps a folder
+ *     whose last file was deleted or moved out: `delete_file` / `move_file`
+ *     write it through `writeFile` here (see `keepFolderOf` in the tools),
+ *     because a folder exists until it is deleted explicitly.
  *
  * Path conventions: Mastra's `inputPath` is workspace-relative (e.g.
  * `knowledge-base/Knowledge/Foo.md`) — the same shape the human
@@ -31,10 +34,21 @@
  * the user collide on the same key. That's why the human can't sneak
  * an edit in while the agent is writing the same file.
  */
-import { LocalFilesystem, type LocalFilesystemOptions, type CopyOptions, type FileContent, type RemoveOptions, type WriteOptions } from '@mastra/core/workspace';
+import { type LocalFilesystemOptions, type CopyOptions, type FileContent, type RemoveOptions, type WriteOptions } from '@mastra/core/workspace';
 import type { AuthUser, Change, IWorkflowService } from '@bevel-software/platform-shared';
 import type { FileChangeNotifier } from './file-change-notifier.js';
+import { GitGuardedFilesystem } from './git-guarded-filesystem.js';
 import type { ICreatorAccess } from '../access-model/creator.js';
+/**
+ * A pre-disk write validator: called with the (workspace-relative path, full
+ * candidate content) of a write; throw (or reject) to refuse it. `appliesTo`
+ * names the paths it guards — only a validator that declares it is also run
+ * for the ops whose candidate has to be read first (append, copy, move), so an
+ * unrelated copy never pays for reading its source.
+ */
+export type WriteValidator = ((path: string, content: FileContent) => void | Promise<void>) & {
+    appliesTo?: (path: string) => boolean;
+};
 /**
  * Dependencies the wrapper needs to talk to the workflow lock service.
  * Captured at construction time so every per-method call resolves to the
@@ -59,12 +73,16 @@ export interface LockingFilesystemContext {
     /**
      * Optional pre-disk write validator. Invoked with the (workspace-relative
      * path, full content) of every WHOLE-FILE write BEFORE the bytes land. Throw
-     * to refuse the write — nothing hits disk and the lock is released without a
-     * commit. Used to reject a `roles.yaml` edit that would lock out admins; see
-     * `roles-yaml-guard.ts`. Whole-file writes only (`writeFile` / `writeFiles`);
-     * partial ops (`appendFile`) are not validated.
+     * to refuse the write — nothing hits disk. It runs before the lock (so an
+     * ordinary refusal takes none) and again once the lock is held, on exactly
+     * the bytes that land, so a validator reading the current file judges the
+     * state it replaces; a refusal there releases the lock untouched. Used to
+     * reject a `roles.yaml` edit that would lock out admins (and, for agents,
+     * one that creates a role); see `roles-yaml-guard.ts`. `appendFile`,
+     * `copyFile` and `moveFile` are validated too, with the resulting content,
+     * when the destination is a path the validator's `appliesTo` claims.
      */
-    validateWrite?: (path: string, content: FileContent) => void;
+    validateWrite?: WriteValidator;
     /**
      * Post-commit hook for the BATCH `writeFiles` path (which commits via
      * `commitChanges` and so skips `runPendingCommit`'s emit). Single-file ops
@@ -73,22 +91,58 @@ export interface LockingFilesystemContext {
     fileChanges?: FileChangeNotifier;
     /**
      * Optional creator read-grant planner (see `modules/access/creator-access`).
-     * When present, a write/mkdir that CREATES a KB node the acting user can't
-     * read gets an automatic `read:` grant — seeded into a new directory's
-     * `access.md` or folded into a new markdown file's frontmatter — so the
-     * agent's creations don't vanish from the driving user's explorer under
-     * default-deny reads. Absent (tests, non-KB filesystems) → no grants.
+     * When present, a write/mkdir that starts a NEW FOLDER directly under one
+     * of the three roots the acting user can't read gets an automatic `read:`
+     * grant seeded into that folder's `access.md`, so the agent's creations
+     * don't vanish from the driving user's explorer under default-deny reads.
+     * Any other creation the user could not see is refused by the lock's read
+     * gate. Absent (tests, non-KB filesystems) → no grants.
      */
     creatorAccess?: ICreatorAccess;
 }
-export declare class LockingFilesystem extends LocalFilesystem {
+export declare class LockingFilesystem extends GitGuardedFilesystem {
     private readonly lockContext;
     constructor(options: LocalFilesystemOptions, lockContext: LockingFilesystemContext);
-    writeFile(inputPath: string, content: FileContent, options?: WriteOptions): Promise<void>;
+    /**
+     * `check` is the CALLER's under-lock judgement: it runs once the path's lock
+     * is held and before a byte lands — the same slot `validateWrite` uses,
+     * opened up so a caller whose verdict depends on what the path CURRENTLY
+     * holds (the write tools' `mode` gate: does this path exist?) reads a state
+     * nobody else can move. Judged before the lock instead, such a verdict is a
+     * guess: a human editor saving between the stat and the write would have its
+     * file replaced by a `create` that then reported `created`. Throwing refuses
+     * the write and releases the lock untouched; the caller gets what it threw.
+     */
+    writeFile(inputPath: string, content: FileContent, options?: WriteOptions, check?: () => void | Promise<void>): Promise<void>;
     appendFile(inputPath: string, content: FileContent): Promise<void>;
     deleteFile(inputPath: string, options?: RemoveOptions): Promise<void>;
     copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    /**
+     * Run `landing` and turn the filesystem's own "that name is taken" failure
+     * into the refusal every surface answers with — `A file named … already
+     * exists in ….` — so a copy that loses the race reads exactly like a copy
+     * that was refused by the look before it.
+     */
+    private asTakenRefusal;
     moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    /**
+     * The move itself, refusing a destination that is taken instead of replacing
+     * it — `fs.rename`, which `LocalFilesystem.moveFile` calls, replaces an
+     * existing file on every platform, and that is how a `.docx` renamed onto an
+     * existing `.md` handed the markdown file the Word bytes.
+     *
+     * The caller above (`move_file`) has already looked at the destination and
+     * refused a taken one with the sentence naming what is in the way. This runs
+     * with both paths' locks held and is the backstop under that look: a
+     * destination created in between — by a writer this process does not
+     * serialize with, the sidebar's own `moveEntry` among them — is refused
+     * atomically by the filesystem rather than overwritten. See
+     * `shared/rename-no-replace.ts`.
+     *
+     * `overwrite: true` is still honoured, for a caller that means it; nothing
+     * in the app passes it today.
+     */
+    private moveNoReplace;
     /**
      * Write several files and commit them as ONE atomic change — the multi-file
      * counterpart to `writeFile`, for the rare case where a set of files must
@@ -109,11 +163,28 @@ export declare class LockingFilesystem extends LocalFilesystem {
      * `writes[].path` is workspace-relative (like `writeFile`). We do the disk
      * write here; `commitChanges` only stages + commits what's on disk (the git
      * layer never writes content).
+     *
+     * `check` is the batch counterpart of `writeFile`'s: it runs once EVERY
+     * path's lock is held and before any byte lands, is handed this batch's
+     * writes in the order it was given them, and returns the subset that may
+     * still land (the same objects — the creator-grant transform has already
+     * been applied to their content). It is where a per-path verdict that
+     * depends on what a path currently holds belongs, because only here is that
+     * state one no other writer can move. A write it drops is never written: its
+     * path releases untouched, stays out of the commit's scope, and takes its
+     * creator-grant seed with it when no surviving write still wants one. A
+     * `check` that THROWS refuses the whole batch, untouched.
      */
     writeFiles(writes: {
         path: string;
         content: FileContent;
-    }[], summary: string, deletes?: string[]): Promise<Change | null>;
+    }[], summary: string, deletes?: string[], check?: (writes: readonly {
+        path: string;
+        content: FileContent;
+    }[]) => Promise<{
+        path: string;
+        content: FileContent;
+    }[]>): Promise<Change | null>;
     mkdir(inputPath: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
@@ -124,14 +195,25 @@ export declare class LockingFilesystem extends LocalFilesystem {
      * leaves nothing behind. See `LockingFilesystemContext.kbDirName`.
      */
     private assertInsideRepo;
+    /**
+     * Validate an op whose resulting bytes at `dest` are not in hand (append,
+     * copy, move): `candidate` is read only when the validator claims `dest`.
+     * Runs before the lock, like `writeFile`'s gate, and again under it. Returns
+     * the bytes judged, or null when no validator claims `dest`.
+     */
+    private validateResultingWrite;
+    /** The bytes at `inputPath`, or null when nothing is there. */
+    private readIfExists;
     /**
      * Land a `seed-access-md` creation-grant plan: under the access.md's own
      * lock (single acquire+release cycle → one commit), re-read the CURRENT
      * bytes and splice the grant into them — never a blind overwrite, so a
      * concurrent creator's just-landed grant on the same new directory
-     * survives. Best-effort by contract: a contended lock, read, write, or
-     * release failure here logs and returns — it must never fail the creation
-     * that triggered the seed.
+     * survives. A contended lock, read, write, or release failure here FAILS
+     * the creation that triggered the seed: the seed is planned only for a new
+     * folder at a root the acting user cannot read, and without the grant the
+     * folder would come into existence invisible to them — the very thing the
+     * read gate exists to prevent.
      */
     private seedAccessMd;
     /**
@@ -147,7 +229,20 @@ export declare class LockingFilesystem extends LocalFilesystem {
      * times before surfacing a structured failure — long enough to ride
      * out a human typing a quick edit, short enough that the agent doesn't
      * stall a whole turn waiting for someone to step away from a file.
+     *
+     * `check` runs once the lock is held and before `op`: a validator that
+     * depends on what is on disk judges the state the op will actually replace.
+     * A check refusal releases the lock UNTOUCHED — nothing was written, and the
+     * no-commit release would reset the path to HEAD, destroying a prior save's
+     * still-queued bytes — and so does every enclosing lock cycle it unwinds
+     * through. The caller receives exactly what `check` threw.
      */
     private withLock;
+    /**
+     * `withLock` without the unwrap: a `check` refusal leaves as a
+     * {@link CheckRefusal}, so a cycle nested inside another (a move's second
+     * lock) tells the enclosing one to release untouched too.
+     */
+    private lockedCycle;
 }
 //# sourceMappingURL=locking-filesystem.d.ts.map

package/dist/modules/kb-fs/locking-filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locking-filesystem.d.ts","sourceRoot":"","sources":["../../../src/modules/kb-fs/locking-filesystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAE1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,KAAK,EAAqB,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAOpF;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf;;;;;;;;OAQG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IAC7D;;;;OAIG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,cAAc,CAAC;CAChC;AAED,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;gBAGrD,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,wBAAwB;IAMxB,SAAS,CACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC;IAkBD,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAKlE,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAOzE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBxF;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,UAAU,CACd,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE,EAAE,EAChD,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,MAAM,EAAO,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA4SV,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC1E,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjF;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;;;;;OAQG;YACW,YAAY;IA0B1B;;;;;OAKG;YACW,UAAU;IAiBxB;;;;;;OAMG;YACW,QAAQ;CAoDvB"}
+{"version":3,"file":"locking-filesystem.d.ts","sourceRoot":"","sources":["../../../src/modules/kb-fs/locking-filesystem.ts"],"names":[],"mappings":"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"}