@secure-exec/core 0.2.0-rc.2 → 0.2.1-rc.1

package/dist/vfs/host-block-store.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Host filesystem-backed FsBlockStore for local dev environments.
+ *
+ * Stores blocks as files on the host filesystem. Block key "ino/chunkIndex"
+ * maps to file at "{baseDir}/ino/chunkIndex". Directories are created on
+ * demand for inode subdirectories.
+ */
+import type { FsBlockStore } from "./types.js";
+export declare class HostBlockStore implements FsBlockStore {
+    private baseDir;
+    constructor(baseDir: string);
+    private keyToPath;
+    read(key: string): Promise<Uint8Array>;
+    readRange(key: string, offset: number, length: number): Promise<Uint8Array>;
+    write(key: string, data: Uint8Array): Promise<void>;
+    delete(key: string): Promise<void>;
+    deleteMany(keys: string[]): Promise<void>;
+    copy(srcKey: string, dstKey: string): Promise<void>;
+}

package/dist/vfs/host-block-store.js

@@ -0,0 +1,97 @@
+/**
+ * Host filesystem-backed FsBlockStore for local dev environments.
+ *
+ * Stores blocks as files on the host filesystem. Block key "ino/chunkIndex"
+ * maps to file at "{baseDir}/ino/chunkIndex". Directories are created on
+ * demand for inode subdirectories.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { KernelError } from "../kernel/types.js";
+export class HostBlockStore {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    keyToPath(key) {
+        return path.join(this.baseDir, key);
+    }
+    async read(key) {
+        const filePath = this.keyToPath(key);
+        try {
+            const buf = await fs.readFile(filePath);
+            return new Uint8Array(buf);
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === "ENOENT") {
+                throw new KernelError("ENOENT", `block not found: ${key}`);
+            }
+            throw err;
+        }
+    }
+    async readRange(key, offset, length) {
+        const filePath = this.keyToPath(key);
+        let handle;
+        try {
+            handle = await fs.open(filePath, "r");
+            const stat = await handle.stat();
+            const available = Math.max(0, stat.size - offset);
+            const toRead = Math.min(length, available);
+            if (toRead === 0) {
+                return new Uint8Array(0);
+            }
+            const buf = Buffer.alloc(toRead);
+            const { bytesRead } = await handle.read(buf, 0, toRead, offset);
+            return new Uint8Array(buf.buffer, buf.byteOffset, bytesRead);
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === "ENOENT") {
+                throw new KernelError("ENOENT", `block not found: ${key}`);
+            }
+            throw err;
+        }
+        finally {
+            if (handle)
+                await handle.close();
+        }
+    }
+    async write(key, data) {
+        const filePath = this.keyToPath(key);
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(filePath, data);
+    }
+    async delete(key) {
+        const filePath = this.keyToPath(key);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === "ENOENT") {
+                return;
+            }
+            throw err;
+        }
+    }
+    async deleteMany(keys) {
+        await Promise.all(keys.map((key) => this.delete(key)));
+    }
+    async copy(srcKey, dstKey) {
+        const srcPath = this.keyToPath(srcKey);
+        const dstPath = this.keyToPath(dstKey);
+        const dstDir = path.dirname(dstPath);
+        try {
+            await fs.mkdir(dstDir, { recursive: true });
+            await fs.copyFile(srcPath, dstPath);
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === "ENOENT") {
+                throw new KernelError("ENOENT", `block not found: ${srcKey}`);
+            }
+            throw err;
+        }
+    }
+}
+function isNodeError(err) {
+    return err instanceof Error && "code" in err;
+}

package/dist/vfs/memory-block-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pure JS Map-based FsBlockStore for ephemeral VMs and tests.
+ *
+ * All blocks live in memory as Uint8Array values keyed by string.
+ * Suitable for short-lived processes where persistence is not needed.
+ */
+import type { FsBlockStore } from "./types.js";
+export declare class InMemoryBlockStore implements FsBlockStore {
+    private blocks;
+    read(key: string): Promise<Uint8Array>;
+    readRange(key: string, offset: number, length: number): Promise<Uint8Array>;
+    write(key: string, data: Uint8Array): Promise<void>;
+    delete(key: string): Promise<void>;
+    deleteMany(keys: string[]): Promise<void>;
+    copy(srcKey: string, dstKey: string): Promise<void>;
+}

package/dist/vfs/memory-block-store.js

@@ -0,0 +1,45 @@
+/**
+ * Pure JS Map-based FsBlockStore for ephemeral VMs and tests.
+ *
+ * All blocks live in memory as Uint8Array values keyed by string.
+ * Suitable for short-lived processes where persistence is not needed.
+ */
+import { KernelError } from "../kernel/types.js";
+export class InMemoryBlockStore {
+    blocks = new Map();
+    async read(key) {
+        const data = this.blocks.get(key);
+        if (!data) {
+            throw new KernelError("ENOENT", `block not found: ${key}`);
+        }
+        return data;
+    }
+    async readRange(key, offset, length) {
+        const data = this.blocks.get(key);
+        if (!data) {
+            throw new KernelError("ENOENT", `block not found: ${key}`);
+        }
+        // Short read: return available bytes if range extends beyond block size.
+        const end = Math.min(offset + length, data.length);
+        return data.slice(offset, end);
+    }
+    async write(key, data) {
+        this.blocks.set(key, new Uint8Array(data));
+    }
+    async delete(key) {
+        this.blocks.delete(key);
+    }
+    async deleteMany(keys) {
+        for (const key of keys) {
+            this.blocks.delete(key);
+        }
+    }
+    async copy(srcKey, dstKey) {
+        const data = this.blocks.get(srcKey);
+        if (!data) {
+            throw new KernelError("ENOENT", `block not found: ${srcKey}`);
+        }
+        // Create a new copy, not a reference.
+        this.blocks.set(dstKey, new Uint8Array(data));
+    }
+}

package/dist/vfs/memory-metadata.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Pure JS Map-based FsMetadataStore for ephemeral VMs and tests.
+ *
+ * All data lives in memory. Root inode (ino=1, type='directory') is created
+ * at construction time. transaction() just calls the callback directly since
+ * single-threaded JS has no interleaving risk within synchronous sections.
+ *
+ * Optionally supports versioning when `{ versioning: true }` is passed to
+ * the constructor. Version retention (automatic cleanup of old versions)
+ * defaults to false. There is intentionally no background cleanup task;
+ * callers are expected to prune versions explicitly via ChunkedVFS.
+ */
+import type { CreateInodeAttrs, DentryInfo, DentryStatInfo, FsMetadataStore, FsMetadataStoreVersioning, InodeMeta, InodeType, VersionMeta } from "./types.js";
+export interface InMemoryMetadataStoreOptions {
+    /** Enable file versioning support. Default: false. */
+    versioning?: boolean;
+}
+export declare class InMemoryMetadataStore implements FsMetadataStore, FsMetadataStoreVersioning {
+    private nextIno;
+    private inodes;
+    private dentries;
+    private symlinkTargets;
+    private chunks;
+    private versioningEnabled;
+    private versions;
+    constructor(options?: InMemoryMetadataStoreOptions);
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    createInode(attrs: CreateInodeAttrs): Promise<number>;
+    getInode(ino: number): Promise<InodeMeta | null>;
+    updateInode(ino: number, updates: Partial<InodeMeta>): Promise<void>;
+    deleteInode(ino: number): Promise<void>;
+    lookup(parentIno: number, name: string): Promise<number | null>;
+    createDentry(parentIno: number, name: string, childIno: number, type: InodeType): Promise<void>;
+    removeDentry(parentIno: number, name: string): Promise<void>;
+    listDir(parentIno: number): Promise<DentryInfo[]>;
+    listDirWithStats(parentIno: number): Promise<DentryStatInfo[]>;
+    renameDentry(srcParentIno: number, srcName: string, dstParentIno: number, dstName: string): Promise<void>;
+    resolvePath(path: string): Promise<number>;
+    resolveParentPath(path: string): Promise<{
+        parentIno: number;
+        name: string;
+    }>;
+    readSymlink(ino: number): Promise<string>;
+    getChunkKey(ino: number, chunkIndex: number): Promise<string | null>;
+    setChunkKey(ino: number, chunkIndex: number, key: string): Promise<void>;
+    getAllChunkKeys(ino: number): Promise<{
+        chunkIndex: number;
+        key: string;
+    }[]>;
+    deleteAllChunks(ino: number): Promise<string[]>;
+    deleteChunksFrom(ino: number, startIndex: number): Promise<string[]>;
+    resolvePathSync(path: string): number;
+    lookupSync(parentIno: number, name: string): number | null;
+    getInodeSync(ino: number): InodeMeta | null;
+    createInodeSync(attrs: CreateInodeAttrs): number;
+    updateInodeSync(ino: number, updates: Partial<InodeMeta>): void;
+    createDentrySync(parentIno: number, name: string, childIno: number, type: InodeType): void;
+    deleteAllChunksSync(ino: number): string[];
+    createVersion(ino: number): Promise<number>;
+    getVersion(ino: number, version: number): Promise<VersionMeta | null>;
+    listVersions(ino: number): Promise<VersionMeta[]>;
+    getVersionChunkMap(ino: number, version: number): Promise<{
+        chunkIndex: number;
+        key: string;
+    }[]>;
+    deleteVersions(ino: number, versions: number[]): Promise<string[]>;
+    restoreVersion(ino: number, version: number): Promise<void>;
+    private resolveComponentsCore;
+    /**
+     * Get the parent path components for resolving a relative symlink.
+     * We need to reconstruct the parent directory path from the components
+     * we have already resolved (everything before the symlink).
+     */
+    private getPathComponents;
+}