@botlearn-course/daemon 0.0.20-beta.8 → 0.0.20

package/dist/workspace.d.ts

@@ -20,9 +20,9 @@ export declare function runtimeProfileDir(agentRunId: string): string;
 export declare function runtimeProfileRunRootDir(agentRunId: string): string;
 export declare function runtimeSessionRootDir(runtimeSessionId: string, sandboxGeneration: number): string;
 /**
- * per-session workspace（ADR-015 §7）：NAS managed sandbox 使用稳定路径
- * `<root>/sessions/<runtime_session_id>/workspace`；旧 provider 保留 generation 路径。
- * 两种路径都由 daemon 在 session.open 时创建。
+ * per-session workspace（ADR-015 §7）：managed sandbox 使用稳定路径
+ * `<root>/sessions/<runtime_session_id>/workspace`。该路径不含 generation，
+ * 因为 NAS image 跨 generation 重新挂载后必须解析到同一个目录。
  */
 export declare function runtimeSessionWorkspaceDir(runtimeSessionId: string, sandboxGeneration: number): string;
 export declare function runtimeSessionTranscriptPath(runtimeSessionId: string, sandboxGeneration: number, agentRunId: string): string;

package/dist/workspace.js

@@ -4,7 +4,6 @@ import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import { TextDecoder } from "node:util";
 import { daemonHome } from "./auth-store.js";
-import { nasWorkspaceEnabled } from "./workspace-filesystem.js";
 /**
  * 每 run 隔离工作区（spec §4）：
  *
@@ -54,9 +53,9 @@ export function runtimeSessionRootDir(runtimeSessionId, sandboxGeneration) {
     return path.join(daemonHome(), "agent-service-sessions", runtimeSessionId, `generation-${sandboxGeneration}`);
 }
 /**
- * per-session workspace（ADR-015 §7）：NAS managed sandbox 使用稳定路径
- * `<root>/sessions/<runtime_session_id>/workspace`；旧 provider 保留 generation 路径。
- * 两种路径都由 daemon 在 session.open 时创建。
+ * per-session workspace（ADR-015 §7）：managed sandbox 使用稳定路径
+ * `<root>/sessions/<runtime_session_id>/workspace`。该路径不含 generation，
+ * 因为 NAS image 跨 generation 重新挂载后必须解析到同一个目录。
  */
 export function runtimeSessionWorkspaceDir(runtimeSessionId, sandboxGeneration) {
     assertSafeId(runtimeSessionId, "runtime_session_id");
@@ -65,10 +64,7 @@ export function runtimeSessionWorkspaceDir(runtimeSessionId, sandboxGeneration)
     }
     const managedRoot = process.env.BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT?.trim();
     if (managedRoot) {
-        if (nasWorkspaceEnabled()) {
-            return path.join(managedRoot, "sessions", runtimeSessionId, "workspace");
-        }
-        return path.join(managedRoot, runtimeSessionId, `generation-${sandboxGeneration}`);
+        return path.join(managedRoot, "sessions", runtimeSessionId, "workspace");
     }
     return path.join(runtimeSessionRootDir(runtimeSessionId, sandboxGeneration), "workspace");
 }
@@ -77,9 +73,7 @@ function managedRuntimeSessionParentDir(runtimeSessionId) {
     const managedRoot = process.env.BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT?.trim();
     if (!managedRoot)
         return null;
-    return nasWorkspaceEnabled()
-        ? path.join(managedRoot, "sessions", runtimeSessionId)
-        : path.join(managedRoot, runtimeSessionId);
+    return path.join(managedRoot, "sessions", runtimeSessionId);
 }
 export function runtimeSessionTranscriptPath(runtimeSessionId, sandboxGeneration, agentRunId) {
     assertSafeId(agentRunId, "agent_run_id");
@@ -218,8 +212,7 @@ export function workspaceCopyV1Supported() {
 }
 const COPY_STAGING_SUFFIX = "[A-Za-z0-9][A-Za-z0-9_-]{0,127}-[0-9a-f]{8}-[0-9a-f]{4}-" +
     "[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-const MANAGED_COPY_STAGING_PATTERN = new RegExp(`^generation-[1-9][0-9]*\\.workspace-copy-${COPY_STAGING_SUFFIX}$`);
-const LOCAL_COPY_STAGING_PATTERN = new RegExp(`^workspace\\.workspace-copy-${COPY_STAGING_SUFFIX}$`);
+const COPY_STAGING_PATTERN = new RegExp(`^workspace\\.workspace-copy-${COPY_STAGING_SUFFIX}$`);
 async function childDirectories(root) {
     try {
         return (await fs.readdir(root, { withFileTypes: true }))
@@ -236,16 +229,13 @@ async function childDirectories(root) {
 export async function cleanupRuntimeSessionWorkspaceCopyStaging() {
     const managedRoot = process.env.BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT?.trim();
     if (managedRoot) {
-        const sessionRoot = nasWorkspaceEnabled()
-            ? path.join(managedRoot, "sessions")
-            : managedRoot;
+        const sessionRoot = path.join(managedRoot, "sessions");
         for (const sessionName of await childDirectories(sessionRoot)) {
             if (!SAFE_ID_PATTERN.test(sessionName))
                 continue;
             const sessionParent = path.join(sessionRoot, sessionName);
             for (const name of await childDirectories(sessionParent)) {
-                if (MANAGED_COPY_STAGING_PATTERN.test(name)
-                    || LOCAL_COPY_STAGING_PATTERN.test(name)) {
+                if (COPY_STAGING_PATTERN.test(name)) {
                     await fs.rm(path.join(sessionParent, name), { recursive: true, force: true });
                 }
             }
@@ -261,7 +251,7 @@ export async function cleanupRuntimeSessionWorkspaceCopyStaging() {
                 continue;
             const generationParent = path.join(sessionParent, generationName);
             for (const name of await childDirectories(generationParent)) {
-                if (LOCAL_COPY_STAGING_PATTERN.test(name)) {
+                if (COPY_STAGING_PATTERN.test(name)) {
                     await fs.rm(path.join(generationParent, name), { recursive: true, force: true });
                 }
             }
@@ -721,9 +711,7 @@ export function removeRuntimeSessionWorkspace(runtimeSessionId, sandboxGeneratio
     });
     const managedRoot = process.env.BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT?.trim();
     if (managedRoot && !preserveManagedWorkspace) {
-        const sessionRoot = nasWorkspaceEnabled()
-            ? path.join(managedRoot, "sessions", runtimeSessionId)
-            : path.join(managedRoot, runtimeSessionId);
+        const sessionRoot = path.join(managedRoot, "sessions", runtimeSessionId);
         rmSync(sessionRoot, { recursive: true, force: true });
     }
 }

package/package.json

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

package/dist/workspace-materialization.d.ts

@@ -1,16 +0,0 @@
-export declare const WORKSPACE_MATERIALIZATION_SCHEMA: "agent-workspace-materialization/1";
-export interface WorkspaceMaterializationMarker {
-    schemaVersion: typeof WORKSPACE_MATERIALIZATION_SCHEMA;
-    sandboxId: string;
-    sandboxGeneration: number;
-    runtimeSessionId: string;
-    workspaceContinuityState: "healthy" | "degraded";
-    snapshotId: string | null;
-    revision: number;
-    contentSha256: string | null;
-    writtenAt: string;
-}
-export declare function workspaceMaterializationMarkerPath(sandboxId: string, runtimeSessionId: string): string;
-export declare function writeWorkspaceMaterializationMarker(marker: WorkspaceMaterializationMarker): void;
-export declare function readWorkspaceMaterializationMarker(sandboxId: string, runtimeSessionId: string): WorkspaceMaterializationMarker | null;
-export declare function removeWorkspaceMaterializationMarker(sandboxId: string, runtimeSessionId: string): boolean;

package/dist/workspace-materialization.js

@@ -1,136 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
-import path from "node:path";
-import { ensureDaemonHome } from "./auth-store.js";
-export const WORKSPACE_MATERIALIZATION_SCHEMA = "agent-workspace-materialization/1";
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const SHA256 = /^[0-9a-f]{64}$/;
-function assertUuid(value, label) {
-    if (!UUID.test(value))
-        throw new Error(label + " must be a UUID");
-}
-function markerDirectory(sandboxId) {
-    assertUuid(sandboxId, "sandboxId");
-    return path.join(ensureDaemonHome(), "agent-service-sandboxes", sandboxId, "workspace-materializations");
-}
-export function workspaceMaterializationMarkerPath(sandboxId, runtimeSessionId) {
-    assertUuid(runtimeSessionId, "runtimeSessionId");
-    return path.join(markerDirectory(sandboxId), runtimeSessionId + ".json");
-}
-function validateMarker(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new Error("workspace materialization marker must be an object");
-    }
-    const marker = raw;
-    const expectedKeys = [
-        "schemaVersion",
-        "sandboxId",
-        "sandboxGeneration",
-        "runtimeSessionId",
-        "workspaceContinuityState",
-        "snapshotId",
-        "revision",
-        "contentSha256",
-        "writtenAt",
-    ].sort();
-    if (Object.keys(marker).sort().some((key, index) => key !== expectedKeys[index]) ||
-        Object.keys(marker).length !== expectedKeys.length)
-        throw new Error("workspace materialization marker fields are invalid");
-    if (marker.schemaVersion !== WORKSPACE_MATERIALIZATION_SCHEMA) {
-        throw new Error("workspace materialization marker schema is unsupported");
-    }
-    if (typeof marker.sandboxId !== "string")
-        throw new Error("sandboxId is required");
-    if (typeof marker.runtimeSessionId !== "string") {
-        throw new Error("runtimeSessionId is required");
-    }
-    assertUuid(marker.sandboxId, "sandboxId");
-    assertUuid(marker.runtimeSessionId, "runtimeSessionId");
-    if (!Number.isSafeInteger(marker.sandboxGeneration) ||
-        marker.sandboxGeneration < 1 ||
-        !Number.isSafeInteger(marker.revision) ||
-        marker.revision < 0 ||
-        typeof marker.writtenAt !== "string" ||
-        Number.isNaN(Date.parse(marker.writtenAt)))
-        throw new Error("workspace materialization marker values are invalid");
-    if (marker.workspaceContinuityState !== "healthy" &&
-        marker.workspaceContinuityState !== "degraded")
-        throw new Error("workspace materialization continuity is invalid");
-    if (marker.snapshotId !== null) {
-        if (typeof marker.snapshotId !== "string")
-            throw new Error("snapshotId is invalid");
-        assertUuid(marker.snapshotId, "snapshotId");
-    }
-    const revisionZero = marker.revision === 0;
-    if (revisionZero !== (marker.snapshotId === null) ||
-        revisionZero !== (marker.contentSha256 === null) ||
-        (!revisionZero &&
-            (typeof marker.contentSha256 !== "string" || !SHA256.test(marker.contentSha256)))) {
-        throw new Error("workspace materialization marker pointer is inconsistent");
-    }
-    return marker;
-}
-export function writeWorkspaceMaterializationMarker(marker) {
-    validateMarker(marker);
-    const directory = markerDirectory(marker.sandboxId);
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(directory, 0o700);
-    }
-    catch {
-        // Windows best effort.
-    }
-    const target = workspaceMaterializationMarkerPath(marker.sandboxId, marker.runtimeSessionId);
-    const staging = target + ".tmp-" + process.pid + "-" + randomBytes(4).toString("hex");
-    try {
-        writeFileSync(staging, JSON.stringify(marker), { encoding: "utf8", mode: 0o600 });
-        const file = openSync(staging, "r");
-        try {
-            fsyncSync(file);
-        }
-        finally {
-            closeSync(file);
-        }
-        renameSync(staging, target);
-        try {
-            chmodSync(target, 0o600);
-        }
-        catch {
-            // Windows best effort.
-        }
-        try {
-            const parent = openSync(directory, "r");
-            try {
-                fsyncSync(parent);
-            }
-            finally {
-                closeSync(parent);
-            }
-        }
-        catch {
-            // Some platforms cannot fsync a directory.
-        }
-    }
-    catch (error) {
-        try {
-            unlinkSync(staging);
-        }
-        catch {
-            // Staging may not have been created.
-        }
-        throw error;
-    }
-}
-export function readWorkspaceMaterializationMarker(sandboxId, runtimeSessionId) {
-    const file = workspaceMaterializationMarkerPath(sandboxId, runtimeSessionId);
-    if (!existsSync(file))
-        return null;
-    return validateMarker(JSON.parse(readFileSync(file, "utf8")));
-}
-export function removeWorkspaceMaterializationMarker(sandboxId, runtimeSessionId) {
-    const file = workspaceMaterializationMarkerPath(sandboxId, runtimeSessionId);
-    if (!existsSync(file))
-        return false;
-    unlinkSync(file);
-    return true;
-}

package/dist/workspace-quota.d.ts

@@ -1,4 +0,0 @@
-export declare const RUNTIME_WORKSPACE_QUOTA_BYTES: number;
-export declare const RUNTIME_WORKSPACE_INODE_QUOTA = 2000;
-export declare function assertRuntimeWorkspaceQuota(workspaceRoot: string): void;
-export declare function applyRuntimeWorkspaceQuota(runtimeSessionId: string, sandboxGeneration: number): Promise<void>;

package/dist/workspace-quota.js

@@ -1,42 +0,0 @@
-import { execFile } from "node:child_process";
-import { readFileSync, statfsSync, statSync } from "node:fs";
-import { promisify } from "node:util";
-export const RUNTIME_WORKSPACE_QUOTA_BYTES = 512 * 1024 * 1024;
-export const RUNTIME_WORKSPACE_INODE_QUOTA = 2_000;
-const WORKSPACE_BACKING_BYTES = 3 * 1024 * 1024 * 1024;
-const QUOTA_MARKER = "/var/lib/botlearn-runtime/workspace-quota.ready";
-const RUNTIME_LAUNCHER = "/opt/botlearn/bin/botlearn-runtime-launcher";
-const execFileAsync = promisify(execFile);
-export function assertRuntimeWorkspaceQuota(workspaceRoot) {
-    if (process.env.BOTLEARN_DAEMON_ENABLE_FAKE_RUNTIME === "1" || process.env.NODE_ENV === "test") {
-        return;
-    }
-    if (process.env.BOTLEARN_RUNTIME_WORKSPACE_QUOTA_BYTES !== String(RUNTIME_WORKSPACE_QUOTA_BYTES) ||
-        process.env.BOTLEARN_RUNTIME_WORKSPACE_INODE_QUOTA !== String(RUNTIME_WORKSPACE_INODE_QUOTA)) {
-        throw new Error("workspace_runtime_quota_unverified");
-    }
-    const filesystem = statfsSync(workspaceRoot, { bigint: true });
-    const marker = statSync(QUOTA_MARKER);
-    if (filesystem.blocks * filesystem.bsize < BigInt(WORKSPACE_BACKING_BYTES) ||
-        marker.uid !== 0 || (marker.mode & 0o777) !== 0o600 ||
-        readFileSync(QUOTA_MARKER, "utf8") !== "workspace-filesystem-quota/1\n") {
-        throw new Error("workspace_runtime_quota_probe_failed");
-    }
-}
-export async function applyRuntimeWorkspaceQuota(runtimeSessionId, sandboxGeneration) {
-    if (process.env.BOTLEARN_DAEMON_ENABLE_FAKE_RUNTIME === "1" || process.env.NODE_ENV === "test") {
-        return;
-    }
-    const args = ["--workspace-quota-apply", runtimeSessionId, String(sandboxGeneration)];
-    if (process.env.BOTLEARN_RUNTIME_LAUNCH_MODE === "sudo") {
-        await execFileAsync("/usr/bin/sudo", ["-n", "--", RUNTIME_LAUNCHER, ...args], {
-            timeout: 10_000,
-        });
-        return;
-    }
-    if (process.env.BOTLEARN_RUNTIME_LAUNCH_MODE === "direct-uid") {
-        await execFileAsync(RUNTIME_LAUNCHER, args, { timeout: 10_000 });
-        return;
-    }
-    throw new Error("workspace_runtime_quota_helper_unavailable");
-}

package/dist/workspace-restore.d.ts

@@ -1,42 +0,0 @@
-import { type WorkspaceEntry, type WorkspaceEntrySetLimits } from "./workspace-entry-set.js";
-export declare class WorkspaceRestoreError extends Error {
-    readonly code: string;
-    readonly retryable: boolean;
-    constructor(code: string, retryable?: boolean);
-}
-export interface WorkspaceRestoreDescriptor {
-    sandboxId: string;
-    sandboxGeneration: number;
-    runtimeSessionId: string;
-    continuityState: "healthy" | "degraded";
-    continuityErrorCode: string | null;
-    snapshotId: string | null;
-    revision: number;
-    contentSha256: string | null;
-    expectedFileCount: number;
-    expectedEntryCount: number;
-    expectedTotalBytes: number;
-}
-export interface WorkspaceRestoreOptions {
-    workspaceDirectory: string;
-    controlDirectory: string;
-    descriptor: WorkspaceRestoreDescriptor;
-    entrySet: unknown;
-    limits: WorkspaceEntrySetLimits;
-    requiredFreeBytes: number;
-    downloadFile(entry: WorkspaceEntry, partPath: string): Promise<void>;
-}
-export interface WorkspaceRestoreCapacityOptions {
-    workspaceDirectory: string;
-    descriptor: WorkspaceRestoreDescriptor;
-    requiredFreeBytes: number;
-    entryCopies?: 1 | 2;
-}
-export declare function workspaceRestoreJournalPath(controlDirectory: string, runtimeSessionId: string): string;
-export declare function recoverWorkspaceRestoreSwap(options: {
-    workspaceDirectory: string;
-    controlDirectory: string;
-    descriptor: WorkspaceRestoreDescriptor;
-}): boolean;
-export declare function restoreWorkspaceSnapshot(options: WorkspaceRestoreOptions): Promise<void>;
-export declare function assertWorkspaceRestoreCapacity(options: WorkspaceRestoreCapacityOptions): void;