@botlearn-course/daemon 0.0.20-beta.7 → 0.0.20-beta.9

package/dist/workspace-filesystem.d.ts

@@ -3,12 +3,18 @@ export declare const WORKSPACE_IMAGE_LOGICAL_BYTES: number;
 interface MountInfoEntry {
     target: string;
     filesystemType: string;
+    source: string;
     mountOptions: Set<string>;
+    superOptions: Set<string>;
+}
+export interface WorkspaceCapacityProbes {
+    statfsBytes(workspaceRoot: string): bigint;
+    backingFileBytes(imagePath: string): bigint;
 }
 export declare function parseWorkspaceMountInfo(text: string): MountInfoEntry[];
 export declare function nasWorkspaceEnabled(env?: NodeJS.ProcessEnv): boolean;
 export declare function workspaceFilesystemFlushCommand(env?: NodeJS.ProcessEnv): [string, string[]] | null;
 export declare function flushWorkspaceFilesystem(env?: NodeJS.ProcessEnv): Promise<void>;
 export declare function isWorkspaceQuotaExceededError(error: unknown): boolean;
-export declare function assertWorkspaceFilesystem(workspaceRoot: string, env?: NodeJS.ProcessEnv, mountInfo?: string): void;
+export declare function assertWorkspaceFilesystem(workspaceRoot: string, env?: NodeJS.ProcessEnv, mountInfo?: string, capacityProbes?: WorkspaceCapacityProbes): void;
 export {};

package/dist/workspace-filesystem.js

@@ -1,11 +1,20 @@
 import { execFile } from "node:child_process";
-import { readFileSync, statfsSync } from "node:fs";
+import { readFileSync, statfsSync, statSync } from "node:fs";
 import { promisify } from "node:util";
 import { assertRuntimeWorkspaceQuota } from "./workspace-quota.js";
 export const WORKSPACE_IMAGE_FORMAT = "botlearn-workspace-image/1";
 export const WORKSPACE_IMAGE_LOGICAL_BYTES = 3 * 1024 * 1024 * 1024;
 const RUNTIME_LAUNCHER = "/opt/botlearn/bin/botlearn-runtime-launcher";
 const execFileAsync = promisify(execFile);
+const defaultCapacityProbes = {
+    statfsBytes(workspaceRoot) {
+        const filesystem = statfsSync(workspaceRoot, { bigint: true });
+        return filesystem.blocks * filesystem.bsize;
+    },
+    backingFileBytes(imagePath) {
+        return BigInt(statSync(imagePath).size);
+    },
+};
 function decodeMountInfoPath(value) {
     return value.replace(/\\([0-7]{3})/gu, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
 }
@@ -20,7 +29,9 @@ export function parseWorkspaceMountInfo(text) {
         return {
             target: decodeMountInfoPath(fields[4]),
             filesystemType: filesystem[0],
+            source: decodeMountInfoPath(filesystem[1]),
             mountOptions: new Set(fields[5].split(",")),
+            superOptions: new Set(filesystem[2].split(",")),
         };
     });
 }
@@ -70,7 +81,7 @@ export function isWorkspaceQuotaExceededError(error) {
         || /\b(?:ENOSPC|EDQUOT|no space left on device|disk quota exceeded)\b/iu.test(detail)
         || (candidate.cause !== undefined && isWorkspaceQuotaExceededError(candidate.cause));
 }
-export function assertWorkspaceFilesystem(workspaceRoot, env = process.env, mountInfo) {
+export function assertWorkspaceFilesystem(workspaceRoot, env = process.env, mountInfo, capacityProbes) {
     if (!nasWorkspaceEnabled(env)) {
         assertRuntimeWorkspaceQuota(workspaceRoot);
         return;
@@ -84,17 +95,26 @@ export function assertWorkspaceFilesystem(workspaceRoot, env = process.env, moun
         return;
     const mount = parseWorkspaceMountInfo(mountInfo ?? readFileSync("/proc/self/mountinfo", "utf8"))
         .find((candidate) => candidate.target === workspaceRoot);
+    const validFilesystem = mount?.filesystemType === "ext4" || (mount?.filesystemType === "fuse.ext4"
+        && mount.source === "/mnt/botlearn-workspace-store/workspace.ext4"
+        && mount.superOptions.has("allow_other"));
     if (!mount
-        || mount.filesystemType !== "ext4"
+        || !validFilesystem
         || !mount.mountOptions.has("rw")
         || !mount.mountOptions.has("nodev")
         || !mount.mountOptions.has("nosuid")) {
         throw new Error("workspace_loop_mount_failed");
     }
-    if (env.NODE_ENV === "test")
+    if (env.NODE_ENV === "test" && capacityProbes === undefined)
         return;
-    const filesystem = statfsSync(workspaceRoot, { bigint: true });
-    if (filesystem.blocks * filesystem.bsize !== BigInt(WORKSPACE_IMAGE_LOGICAL_BYTES)) {
+    const probes = capacityProbes ?? defaultCapacityProbes;
+    // fuse2fs reports a zero-sized statfs view in veFaaS even though the exact backing
+    // image is mounted and enforces the filesystem boundary. The mount proof above pins
+    // that image, so its validated file size is the authoritative capacity for FUSE.
+    const boundedBytes = mount.filesystemType === "fuse.ext4"
+        ? probes.backingFileBytes(mount.source)
+        : probes.statfsBytes(workspaceRoot);
+    if (boundedBytes !== BigInt(WORKSPACE_IMAGE_LOGICAL_BYTES)) {
         throw new Error("workspace_quota_mismatch");
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botlearn-course/daemon",
-  "version": "0.0.20-beta.7",
+  "version": "0.0.20-beta.9",
   "description": "Lightweight BotLearn Course daemon: run course tasks on your own machine with your own agent runtime (BYOA).",
   "type": "module",
   "bin": {