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

package/dist/types.d.ts

@@ -13,6 +13,7 @@ export interface CommandExecutor {
     spawn(command: string, args: string[], options: {
         cwd?: string;
         env?: Record<string, string>;
+        streamStdin?: boolean;
         onStdout?: (data: Uint8Array) => void;
         onStderr?: (data: Uint8Array) => void;
     }): SpawnedProcess;

package/dist/vfs/chunked-vfs.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ChunkedVFS: composes FsMetadataStore + FsBlockStore into a VirtualFileSystem.
+ *
+ * Tiered storage: files <= inlineThreshold are stored inline in metadata;
+ * larger files are split into fixed-size chunks in the block store.
+ * Per-inode async mutex prevents interleaved read-modify-write corruption.
+ *
+ * Optional write buffering: when enabled, pwrite buffers dirty chunks in
+ * memory and flushes to the block store on fsync or auto-flush. Reads
+ * always see buffered data. When disabled (default), writes go directly
+ * to the block store.
+ */
+import type { VirtualFileSystem } from "../kernel/vfs.js";
+import type { FsBlockStore, FsMetadataStore, RetentionPolicy, VersionInfo } from "./types.js";
+/**
+ * Configuration for creating a ChunkedVFS instance via `createChunkedVfs()`.
+ *
+ * Requires a metadata store (directory tree, inodes) and a block store
+ * (key-value blob storage). Optional settings control tiered storage
+ * thresholds, write buffering, and versioning behavior.
+ */
+export interface ChunkedVfsOptions {
+    metadata: FsMetadataStore;
+    blocks: FsBlockStore;
+    /** Chunk size in bytes. Default: 4 MB. */
+    chunkSize?: number;
+    /** Max file size for inline storage. Default: 64 KB. */
+    inlineThreshold?: number;
+    /**
+     * Enable write buffering. When true, pwrite buffers dirty chunks in
+     * memory and flushes to the block store on fsync or auto-flush.
+     * When false, every pwrite immediately writes to the block store.
+     * Default: false.
+     */
+    writeBuffering?: boolean;
+    /**
+     * Auto-flush interval in ms. Only applies when writeBuffering is true.
+     * Dirty chunks are flushed to the block store on this interval.
+     * Default: 1000 (1 second).
+     */
+    autoFlushIntervalMs?: number;
+    /**
+     * Enable file versioning. When true, block keys use the format
+     * {ino}/{chunkIndex}/{randomId} so old blocks are never overwritten.
+     * The metadata store must implement FsMetadataStoreVersioning.
+     * Default: false.
+     */
+    versioning?: boolean;
+}
+/**
+ * Extended return type when versioning is enabled.
+ * Exposes the versioning API alongside the VirtualFileSystem.
+ */
+export interface ChunkedVfsVersioning {
+    /** Snapshot current state. Returns version number. */
+    createVersion(path: string): Promise<number>;
+    /** List all versions of a file, newest first. */
+    listVersions(path: string): Promise<VersionInfo[]>;
+    /** Restore file to a previous version. */
+    restoreVersion(path: string, version: number): Promise<void>;
+    /** Prune old versions according to policy. Returns count of versions pruned. */
+    pruneVersions(path: string, policy: RetentionPolicy): Promise<number>;
+    /** Find and delete orphaned blocks. Returns count of blocks deleted. */
+    collectGarbage(): Promise<number>;
+}
+export declare function createChunkedVfs(options: ChunkedVfsOptions): VirtualFileSystem;