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

package/src/modules/{workspace → kb-fs}/bevel-ignore.ts

@@ -1,12 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import ignore, { type Ignore } from 'ignore';
-
-/**
- * The ignore file's own name. Exported because the file-tree filter hides it
- * from non-admins, and both places must agree on the spelling.
- */
-export const IGNORE_FILENAME = '.bevelignore';
+import { IGNORE_FILENAME, isAbsence, type IgnoreRules } from '../../shared/fs.contract.js';
 
 /** One .bevelignore file's rules, scoped to the directory it lives in. */
 interface IgnoreLayer {
@@ -22,8 +17,13 @@ interface IgnoreLayer {
  * using standard gitignore syntax (negations, `**`, directory-only patterns, anchoring).
  * Deeper files combine with — and can override — rules from shallower files,
  * mirroring how git layers `.gitignore` files.
+ *
+ * The one implementation of {@link IgnoreRules}. A reader honours the files
+ * by walking with `ignore: true` (see `ITreeWalker.walk`); the walk layers
+ * them on the way down. The stack is used directly only to judge a single
+ * path, or to hand a walk the rules in force above its root.
  */
-export class BevelIgnoreStack {
+export class BevelIgnoreStack implements IgnoreRules {
   private constructor(private readonly layers: readonly IgnoreLayer[]) {}
 
   static empty(): BevelIgnoreStack {
@@ -31,36 +31,43 @@ export class BevelIgnoreStack {
   }
 
   /**
-   * Return a new stack that additionally includes a `.bevelignore` from `dir`
-   * (if present). If no `.bevelignore` exists in `dir`, returns this stack unchanged.
+   * Return a new stack that additionally includes a `.bevelignore` from `dir`.
+   * No file is no rules: the stack comes back unchanged. A file that is there
+   * but cannot be read is NOT — the rules are unknown and nothing under `dir`
+   * can be judged — so that error is the caller's (the walk makes it a hole).
    */
   async extendedWith(dir: string): Promise<BevelIgnoreStack> {
     const file = path.join(dir, IGNORE_FILENAME);
     let contents: string;
     try {
       contents = await fs.readFile(file, 'utf-8');
-    } catch {
-      return this;
+    } catch (err) {
+      if (isAbsence(err)) return this;
+      throw err;
     }
     const matcher = ignore().add(contents);
     return new BevelIgnoreStack([...this.layers, { root: dir, matcher }]);
   }
 
   /**
-   * Whether the given entry should be hidden from the file tree.
+   * Whether the given entry should be hidden from the file tree — layered
+   * like git: shallow to deep, the LAST rule that speaks wins, so a deeper
+   * `!pattern` restores what a shallower file hid.
    * @param absolutePath absolute path of the entry
    * @param isDirectory needed because gitignore patterns ending in `/` match directories only
    */
   isIgnored(absolutePath: string, isDirectory: boolean): boolean {
+    let ignored = false;
     for (const layer of this.layers) {
       const rel = path.relative(layer.root, absolutePath).replace(/\\/g, '/');
       // Skip entries that aren't under this layer's root (shouldn't happen in normal
       // recursion, but guards against absolute-path quirks on Windows).
       if (!rel || rel.startsWith('..')) continue;
       // Append trailing slash for directories so `foo/`-style rules match correctly.
-      const probe = isDirectory ? `${rel}/` : rel;
-      if (layer.matcher.ignores(probe)) return true;
+      const verdict = layer.matcher.test(isDirectory ? `${rel}/` : rel);
+      if (verdict.ignored) ignored = true;
+      else if (verdict.unignored) ignored = false;
     }
-    return false;
+    return ignored;
   }
 }

package/src/modules/kb-fs/file-change-notifier.ts

@@ -19,6 +19,9 @@
  * (id-repair) does so on its own, after the locks have already been released.
  */
 import type { AuthUser } from '@bevel-software/platform-shared';
+import { logger } from '../../shared/logging.js';
+
+const log = logger('file-change');
 
 export interface FilesChange {
   workspaceId: string;
@@ -47,7 +50,7 @@ export class FileChangeNotifier {
       try {
         listener(change);
       } catch (err) {
-        console.error('[file-change] listener threw:', err instanceof Error ? err.message : err);
+        log.error('listener threw:', { err });
       }
     }
   }

package/src/modules/kb-fs/git-guarded-filesystem.ts

@@ -0,0 +1,123 @@
+import path from 'node:path';
+import {
+  LocalFilesystem,
+  type CopyOptions,
+  type FileContent,
+  type FileEntry,
+  type FileStat,
+  type ListOptions,
+  type ReadOptions,
+  type RemoveOptions,
+  type WriteOptions,
+} 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. */
+  async assertNotGitInternals(inputPath: string): Promise<void> {
+    const absolutePath = this.resolveAbsolutePath(inputPath) ?? path.resolve(this.basePath, inputPath.replace(/^[\\/]+/, ''));
+    await assertNotGitInternals(this.basePath, inputPath, absolutePath);
+  }
+
+  override async readFile(inputPath: string, options?: ReadOptions): Promise<string | Buffer> {
+    await this.assertNotGitInternals(inputPath);
+    return super.readFile(inputPath, options);
+  }
+
+  override async writeFile(inputPath: string, content: FileContent, options?: WriteOptions): Promise<void> {
+    await this.assertNotGitInternals(inputPath);
+    return super.writeFile(inputPath, content, options);
+  }
+
+  override async appendFile(inputPath: string, content: FileContent): Promise<void> {
+    await this.assertNotGitInternals(inputPath);
+    return super.appendFile(inputPath, content);
+  }
+
+  override async deleteFile(inputPath: string, options?: RemoveOptions): Promise<void> {
+    await this.assertNotGitInternals(inputPath);
+    return super.deleteFile(inputPath, options);
+  }
+
+  override async copyFile(src: string, dest: string, options?: CopyOptions): Promise<void> {
+    await this.assertNotGitInternals(src);
+    await this.assertNotGitInternals(dest);
+    return super.copyFile(src, dest, options);
+  }
+
+  override async moveFile(src: string, dest: string, options?: CopyOptions): Promise<void> {
+    await this.assertNotGitInternals(src);
+    await this.assertNotGitInternals(dest);
+    return super.moveFile(src, dest, options);
+  }
+
+  override async mkdir(inputPath: string, options?: { recursive?: boolean }): Promise<void> {
+    await this.assertNotGitInternals(inputPath);
+    return super.mkdir(inputPath, options);
+  }
+
+  override async rmdir(inputPath: string, options?: RemoveOptions): Promise<void> {
+    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.
+   */
+  override async readdir(inputPath: string, options?: ListOptions): Promise<FileEntry[]> {
+    await this.assertNotGitInternals(inputPath);
+    const { recursive, maxDepth, ...flat } = options ?? {};
+    const entries = await super.readdir(inputPath, flat);
+    const dir = inputPath.replace(/\\/g, '/');
+    const visible: FileEntry[] = [];
+    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;
+  }
+
+  override async exists(inputPath: string): Promise<boolean> {
+    await this.assertNotGitInternals(inputPath);
+    return super.exists(inputPath);
+  }
+
+  override async stat(inputPath: string): Promise<FileStat> {
+    await this.assertNotGitInternals(inputPath);
+    return super.stat(inputPath);
+  }
+
+  override async realpath(inputPath: string): Promise<string> {
+    await this.assertNotGitInternals(inputPath);
+    return super.realpath(inputPath);
+  }
+}