feat: WASM based web simulator (#7164)
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 4.6
parent
a2aeab9234
commit
b2fb79d9f4
@@ -0,0 +1,677 @@
|
||||
/**
|
||||
* OPFS-backed filesystem for the FS Worker.
|
||||
*
|
||||
* Maintains a lightweight in-memory directory index (metadata only) for
|
||||
* synchronous path resolution and readdir. File I/O uses OPFS
|
||||
* SyncAccessHandles for synchronous read/write without any memfs layer.
|
||||
*
|
||||
* Async operations (open, mkdir, unlink, rmdir, rename) need OPFS directory
|
||||
* mutations which are inherently async. The FS Worker handles these by
|
||||
* briefly breaking out of its synchronous Atomics loop.
|
||||
*/
|
||||
|
||||
// --- Directory index node types ---
|
||||
|
||||
interface FileNode {
|
||||
name: string;
|
||||
kind: 'file';
|
||||
handle: FileSystemFileHandle;
|
||||
size: number;
|
||||
mtime: number;
|
||||
}
|
||||
|
||||
interface DirNode {
|
||||
name: string;
|
||||
kind: 'directory';
|
||||
handle: FileSystemDirectoryHandle;
|
||||
children: Map<string, FileNode | DirNode>;
|
||||
mtime: number;
|
||||
}
|
||||
|
||||
type FsNode = FileNode | DirNode;
|
||||
|
||||
// --- Open file tracking ---
|
||||
|
||||
interface OpenFlags {
|
||||
read: boolean;
|
||||
write: boolean;
|
||||
append: boolean;
|
||||
create: boolean;
|
||||
truncate: boolean;
|
||||
exclusive: boolean;
|
||||
}
|
||||
|
||||
/** Shared SyncAccessHandle with refcounting for multiple fds on the same file. */
|
||||
interface SharedHandle {
|
||||
syncHandle: FileSystemSyncAccessHandle;
|
||||
node: FileNode;
|
||||
refCount: number;
|
||||
}
|
||||
|
||||
interface OpenFd {
|
||||
/** Shared handle (null for directory fds). */
|
||||
shared: SharedHandle | null;
|
||||
/** The filesystem node (file or directory). */
|
||||
node: FsNode;
|
||||
/** Current read/write position. */
|
||||
position: number;
|
||||
flags: OpenFlags;
|
||||
}
|
||||
|
||||
// --- Flag parsing ---
|
||||
|
||||
function parseOpenFlags(flags: number | string): OpenFlags {
|
||||
if (typeof flags === 'string') {
|
||||
const f = flags;
|
||||
const plus = f.includes('+');
|
||||
return {
|
||||
read: f[0] === 'r' || plus,
|
||||
write: f[0] === 'w' || f[0] === 'a' || plus,
|
||||
append: f[0] === 'a',
|
||||
create: f[0] === 'w' || f[0] === 'a',
|
||||
truncate: f[0] === 'w' && !plus,
|
||||
exclusive: f.includes('x'),
|
||||
};
|
||||
}
|
||||
// Numeric flags (Node.js / Linux O_* values)
|
||||
const access = flags & 3;
|
||||
return {
|
||||
read: access === 0 || access === 2, // O_RDONLY=0, O_RDWR=2
|
||||
write: access === 1 || access === 2, // O_WRONLY=1, O_RDWR=2
|
||||
append: !!(flags & 0o2000), // O_APPEND
|
||||
create: !!(flags & 0o100), // O_CREAT
|
||||
truncate: !!(flags & 0o1000), // O_TRUNC
|
||||
exclusive: !!(flags & 0o200), // O_EXCL
|
||||
};
|
||||
}
|
||||
|
||||
// --- Stat result (compatible with serializeStat in fs-proxy-protocol) ---
|
||||
|
||||
class StatResult {
|
||||
dev = 0;
|
||||
ino: number;
|
||||
mode: number;
|
||||
nlink = 1;
|
||||
uid = 0;
|
||||
gid = 0;
|
||||
rdev = 0;
|
||||
size: number;
|
||||
blksize = 4096;
|
||||
blocks: number;
|
||||
atimeMs: number;
|
||||
mtimeMs: number;
|
||||
ctimeMs: number;
|
||||
birthtimeMs: number;
|
||||
private _isFile: boolean;
|
||||
|
||||
constructor(isFile: boolean, size: number, mtime: number, ino: number) {
|
||||
this._isFile = isFile;
|
||||
this.ino = ino;
|
||||
this.mode = isFile ? 0o100644 : 0o040755;
|
||||
this.size = size;
|
||||
this.blocks = Math.ceil(size / 512);
|
||||
this.atimeMs = mtime;
|
||||
this.mtimeMs = mtime;
|
||||
this.ctimeMs = mtime;
|
||||
this.birthtimeMs = mtime;
|
||||
}
|
||||
|
||||
isFile() { return this._isFile; }
|
||||
isDirectory() { return !this._isFile; }
|
||||
isSymbolicLink() { return false; }
|
||||
isCharacterDevice() { return false; }
|
||||
isBlockDevice() { return false; }
|
||||
isSocket() { return false; }
|
||||
isFIFO() { return false; }
|
||||
}
|
||||
|
||||
// --- Backend ---
|
||||
|
||||
export class OpfsBackend {
|
||||
private root: DirNode | null = null;
|
||||
private fdTable = new Map<number, OpenFd>();
|
||||
/** Path → shared SyncAccessHandle for refcounting across multiple fds. */
|
||||
private openHandles = new Map<string, SharedHandle>();
|
||||
private nextFd = 3; // 0-2 reserved for stdin/stdout/stderr
|
||||
private nextIno = 1;
|
||||
|
||||
/**
|
||||
* Initialize: get the OPFS directory for this radio and build the
|
||||
* in-memory directory index by scanning the OPFS tree.
|
||||
*/
|
||||
async init(radioKey: string): Promise<void> {
|
||||
const storageRoot = await navigator.storage.getDirectory();
|
||||
const edgetx = await storageRoot.getDirectoryHandle('edgetx-web', { create: true });
|
||||
const radioDir = await edgetx.getDirectoryHandle(radioKey, { create: true });
|
||||
|
||||
this.root = {
|
||||
name: '',
|
||||
kind: 'directory',
|
||||
handle: radioDir,
|
||||
children: new Map(),
|
||||
mtime: Date.now(),
|
||||
};
|
||||
|
||||
await this.scanDir(this.root);
|
||||
}
|
||||
|
||||
/** Whether the OPFS tree has any content for this radio. */
|
||||
get hasContent(): boolean {
|
||||
return this.root !== null && this.root.children.size > 0;
|
||||
}
|
||||
|
||||
/** Close all open handles (for shutdown). */
|
||||
closeAll(): void {
|
||||
for (const [fd] of this.fdTable) {
|
||||
try { this.close(fd); } catch { /* best effort */ }
|
||||
}
|
||||
}
|
||||
|
||||
// --- Async scan ---
|
||||
|
||||
private async scanDir(dir: DirNode): Promise<void> {
|
||||
for await (const [name, handle] of (dir.handle as any).entries()) {
|
||||
if (handle.kind === 'directory') {
|
||||
const child: DirNode = {
|
||||
name,
|
||||
kind: 'directory',
|
||||
handle: handle as FileSystemDirectoryHandle,
|
||||
children: new Map(),
|
||||
mtime: Date.now(),
|
||||
};
|
||||
dir.children.set(name, child);
|
||||
await this.scanDir(child);
|
||||
} else {
|
||||
const file = await (handle as FileSystemFileHandle).getFile();
|
||||
const child: FileNode = {
|
||||
name,
|
||||
kind: 'file',
|
||||
handle: handle as FileSystemFileHandle,
|
||||
size: file.size,
|
||||
mtime: file.lastModified,
|
||||
};
|
||||
dir.children.set(name, child);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- Synchronous path resolution ---
|
||||
|
||||
private normalizePath(path: string): string {
|
||||
return '/' + path.split('/').filter(Boolean).join('/');
|
||||
}
|
||||
|
||||
private resolve(path: string): FsNode {
|
||||
if (!this.root) throw this.err('ENOENT', path);
|
||||
|
||||
const segments = path.split('/').filter(Boolean);
|
||||
let node: FsNode = this.root;
|
||||
|
||||
for (const seg of segments) {
|
||||
if (seg === '.') continue;
|
||||
if (seg === '..') throw this.err('EINVAL', path);
|
||||
if (node.kind !== 'directory') throw this.err('ENOTDIR', path);
|
||||
const child = node.children.get(seg);
|
||||
if (!child) throw this.err('ENOENT', path);
|
||||
node = child;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
private resolveParent(path: string): { parent: DirNode; name: string } {
|
||||
if (!this.root) throw this.err('ENOENT', path);
|
||||
|
||||
const segments = path.split('/').filter(Boolean);
|
||||
if (segments.length === 0) throw this.err('EINVAL', path);
|
||||
|
||||
const name = segments.pop()!;
|
||||
let node: FsNode = this.root;
|
||||
|
||||
for (const seg of segments) {
|
||||
if (seg === '.') continue;
|
||||
if (seg === '..') throw this.err('EINVAL', path);
|
||||
if (node.kind !== 'directory') throw this.err('ENOTDIR', path);
|
||||
const child = node.children.get(seg);
|
||||
if (!child) throw this.err('ENOENT', path);
|
||||
node = child;
|
||||
}
|
||||
|
||||
if (node.kind !== 'directory') throw this.err('ENOTDIR', path);
|
||||
return { parent: node, name };
|
||||
}
|
||||
|
||||
// --- File operations ---
|
||||
|
||||
/** Open a file or directory. ASYNC (needs createSyncAccessHandle). */
|
||||
async open(path: string, flags: number | string, _mode: number): Promise<number> {
|
||||
const parsed = parseOpenFlags(flags);
|
||||
const normPath = this.normalizePath(path);
|
||||
|
||||
let node: FsNode;
|
||||
let created = false;
|
||||
|
||||
try {
|
||||
node = this.resolve(path);
|
||||
} catch (e: any) {
|
||||
if (e.code === 'ENOENT' && parsed.create) {
|
||||
node = await this.createFile(path);
|
||||
created = true;
|
||||
} else {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
if (!created && parsed.create && parsed.exclusive) {
|
||||
throw this.err('EEXIST', path);
|
||||
}
|
||||
|
||||
// Directory fd: no SyncAccessHandle, just a trackable fd for WASI
|
||||
if (node.kind === 'directory') {
|
||||
const fd = this.nextFd++;
|
||||
this.fdTable.set(fd, { shared: null, node, position: 0, flags: parsed });
|
||||
return fd;
|
||||
}
|
||||
|
||||
// File fd: reuse existing SyncAccessHandle if already open (refcounting)
|
||||
let shared = this.openHandles.get(normPath);
|
||||
if (shared) {
|
||||
shared.refCount++;
|
||||
} else {
|
||||
const syncHandle = await (node as FileNode).handle.createSyncAccessHandle();
|
||||
shared = { syncHandle, node: node as FileNode, refCount: 1 };
|
||||
this.openHandles.set(normPath, shared);
|
||||
}
|
||||
|
||||
if (parsed.truncate) {
|
||||
shared.syncHandle.truncate(0);
|
||||
shared.node.size = 0;
|
||||
shared.node.mtime = Date.now();
|
||||
}
|
||||
|
||||
const fd = this.nextFd++;
|
||||
this.fdTable.set(fd, {
|
||||
shared,
|
||||
node,
|
||||
position: parsed.append ? shared.syncHandle.getSize() : 0,
|
||||
flags: parsed,
|
||||
});
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
/** Close a file descriptor. Sync. */
|
||||
close(fd: number): void {
|
||||
const openFd = this.fdTable.get(fd);
|
||||
if (!openFd) throw this.err('EBADF', `fd ${fd}`);
|
||||
|
||||
if (openFd.shared) {
|
||||
openFd.shared.refCount--;
|
||||
if (openFd.shared.refCount <= 0) {
|
||||
openFd.shared.syncHandle.flush();
|
||||
openFd.shared.node.size = openFd.shared.syncHandle.getSize();
|
||||
openFd.shared.syncHandle.close();
|
||||
// Remove from openHandles
|
||||
for (const [path, h] of this.openHandles) {
|
||||
if (h === openFd.shared) {
|
||||
this.openHandles.delete(path);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.fdTable.delete(fd);
|
||||
}
|
||||
|
||||
/** Read from an open file. Sync. */
|
||||
read(fd: number, length: number, position: number | null): { data: Uint8Array; bytesRead: number } {
|
||||
const openFd = this.getFd(fd, 'file');
|
||||
const pos = position ?? openFd.position;
|
||||
const buf = new Uint8Array(length);
|
||||
const bytesRead = openFd.shared!.syncHandle.read(buf, { at: pos });
|
||||
|
||||
if (position === null) {
|
||||
openFd.position += bytesRead;
|
||||
}
|
||||
|
||||
return { data: buf, bytesRead };
|
||||
}
|
||||
|
||||
/** Write to an open file. Sync. */
|
||||
write(fd: number, data: Uint8Array, position: number | null): number {
|
||||
const openFd = this.getFd(fd, 'file');
|
||||
const sh = openFd.shared!;
|
||||
|
||||
let pos: number;
|
||||
if (openFd.flags.append) {
|
||||
pos = sh.syncHandle.getSize();
|
||||
} else {
|
||||
pos = position ?? openFd.position;
|
||||
}
|
||||
|
||||
const written = sh.syncHandle.write(data, { at: pos });
|
||||
|
||||
if (position === null || openFd.flags.append) {
|
||||
openFd.position = pos + written;
|
||||
}
|
||||
|
||||
sh.node.size = sh.syncHandle.getSize();
|
||||
sh.node.mtime = Date.now();
|
||||
return written;
|
||||
}
|
||||
|
||||
/** Get file status by fd. Sync. */
|
||||
fstat(fd: number): StatResult {
|
||||
const openFd = this.fdTable.get(fd);
|
||||
if (!openFd) throw this.err('EBADF', `fd ${fd}`);
|
||||
|
||||
if (openFd.node.kind === 'directory') {
|
||||
return new StatResult(false, 0, openFd.node.mtime, this.nextIno++);
|
||||
}
|
||||
|
||||
const size = openFd.shared ? openFd.shared.syncHandle.getSize() : (openFd.node as FileNode).size;
|
||||
return new StatResult(true, size, openFd.node.mtime, this.nextIno++);
|
||||
}
|
||||
|
||||
/** Get file status by path. Sync. */
|
||||
stat(path: string): StatResult {
|
||||
const node = this.resolve(path);
|
||||
const size = node.kind === 'file' ? node.size : 0;
|
||||
return new StatResult(node.kind === 'file', size, node.mtime, this.nextIno++);
|
||||
}
|
||||
|
||||
/** Same as stat (no symlink support). Sync. */
|
||||
lstat(path: string): StatResult {
|
||||
return this.stat(path);
|
||||
}
|
||||
|
||||
/** Truncate an open file. Sync. */
|
||||
ftruncate(fd: number, len: number): void {
|
||||
const openFd = this.getFd(fd, 'file');
|
||||
openFd.shared!.syncHandle.truncate(len);
|
||||
openFd.shared!.node.size = len;
|
||||
openFd.shared!.node.mtime = Date.now();
|
||||
}
|
||||
|
||||
/** Update timestamps by fd. Sync (in-memory only). */
|
||||
futimes(fd: number, _atime: number, mtime: number): void {
|
||||
const openFd = this.fdTable.get(fd);
|
||||
if (!openFd) throw this.err('EBADF', `fd ${fd}`);
|
||||
openFd.node.mtime = mtime;
|
||||
}
|
||||
|
||||
/** Update timestamps by path. Sync (in-memory only). */
|
||||
utimes(path: string, _atime: number, mtime: number): void {
|
||||
const node = this.resolve(path);
|
||||
node.mtime = mtime;
|
||||
}
|
||||
|
||||
/** Create a directory. ASYNC. */
|
||||
async mkdir(path: string): Promise<void> {
|
||||
const { parent, name } = this.resolveParent(path);
|
||||
|
||||
if (parent.children.has(name)) {
|
||||
throw this.err('EEXIST', path);
|
||||
}
|
||||
|
||||
const handle = await parent.handle.getDirectoryHandle(name, { create: true });
|
||||
parent.children.set(name, {
|
||||
name,
|
||||
kind: 'directory',
|
||||
handle,
|
||||
children: new Map(),
|
||||
mtime: Date.now(),
|
||||
});
|
||||
}
|
||||
|
||||
/** List directory contents. Sync (reads from in-memory index). */
|
||||
readdir(path: string, withFileTypes: boolean): any[] {
|
||||
const node = this.resolve(path);
|
||||
if (node.kind !== 'directory') throw this.err('ENOTDIR', path);
|
||||
|
||||
if (withFileTypes) {
|
||||
return Array.from(node.children.values()).map(child => ({
|
||||
name: child.name,
|
||||
isFile: () => child.kind === 'file',
|
||||
isDirectory: () => child.kind === 'directory',
|
||||
isSymbolicLink: () => false,
|
||||
isCharacterDevice: () => false,
|
||||
isBlockDevice: () => false,
|
||||
isSocket: () => false,
|
||||
isFIFO: () => false,
|
||||
}));
|
||||
}
|
||||
return Array.from(node.children.keys());
|
||||
}
|
||||
|
||||
/** Rename / move a file or directory. ASYNC. */
|
||||
async rename(oldPath: string, newPath: string): Promise<void> {
|
||||
const oldNode = this.resolve(oldPath);
|
||||
const { parent: oldParent, name: oldName } = this.resolveParent(oldPath);
|
||||
const { parent: newParent, name: newName } = this.resolveParent(newPath);
|
||||
|
||||
// Reject rename while file is open (SyncAccessHandle holds a lock)
|
||||
const normOld = this.normalizePath(oldPath);
|
||||
if (this.openHandles.has(normOld)) {
|
||||
throw this.err('EBUSY', oldPath);
|
||||
}
|
||||
|
||||
// Remove existing target if present
|
||||
if (newParent.children.has(newName)) {
|
||||
const existing = newParent.children.get(newName)!;
|
||||
if (existing.kind === 'directory' && existing.children.size > 0) {
|
||||
throw this.err('ENOTEMPTY', newPath);
|
||||
}
|
||||
await newParent.handle.removeEntry(newName, { recursive: false });
|
||||
newParent.children.delete(newName);
|
||||
}
|
||||
|
||||
// Use move() API if available (Chrome 110+, Firefox 129+)
|
||||
if (typeof (oldNode.handle as any).move === 'function') {
|
||||
await (oldNode.handle as any).move(newParent.handle, newName);
|
||||
oldParent.children.delete(oldName);
|
||||
oldNode.name = newName;
|
||||
newParent.children.set(newName, oldNode);
|
||||
} else if (oldNode.kind === 'file') {
|
||||
// Fallback: read content, create new file, delete old
|
||||
const file = await oldNode.handle.getFile();
|
||||
const content = new Uint8Array(await file.arrayBuffer());
|
||||
|
||||
const newHandle = await newParent.handle.getFileHandle(newName, { create: true });
|
||||
const syncHandle = await newHandle.createSyncAccessHandle();
|
||||
syncHandle.write(content);
|
||||
syncHandle.flush();
|
||||
const newSize = syncHandle.getSize();
|
||||
syncHandle.close();
|
||||
|
||||
await oldParent.handle.removeEntry(oldName);
|
||||
oldParent.children.delete(oldName);
|
||||
|
||||
newParent.children.set(newName, {
|
||||
name: newName,
|
||||
kind: 'file',
|
||||
handle: newHandle,
|
||||
size: newSize,
|
||||
mtime: Date.now(),
|
||||
});
|
||||
} else {
|
||||
throw this.err('ENOSYS', 'directory rename requires move() API');
|
||||
}
|
||||
}
|
||||
|
||||
/** Remove an empty directory. ASYNC. */
|
||||
async rmdir(path: string): Promise<void> {
|
||||
const { parent, name } = this.resolveParent(path);
|
||||
const child = parent.children.get(name);
|
||||
if (!child) throw this.err('ENOENT', path);
|
||||
if (child.kind !== 'directory') throw this.err('ENOTDIR', path);
|
||||
if (child.children.size > 0) throw this.err('ENOTEMPTY', path);
|
||||
|
||||
await parent.handle.removeEntry(name);
|
||||
parent.children.delete(name);
|
||||
}
|
||||
|
||||
/** Delete a file. ASYNC. */
|
||||
async unlink(path: string): Promise<void> {
|
||||
const { parent, name } = this.resolveParent(path);
|
||||
const child = parent.children.get(name);
|
||||
if (!child) throw this.err('ENOENT', path);
|
||||
if (child.kind === 'directory') throw this.err('EISDIR', path);
|
||||
|
||||
// Force-close any open SyncAccessHandle for this file
|
||||
const normPath = this.normalizePath(path);
|
||||
const existing = this.openHandles.get(normPath);
|
||||
if (existing) {
|
||||
existing.syncHandle.close();
|
||||
this.openHandles.delete(normPath);
|
||||
}
|
||||
|
||||
await parent.handle.removeEntry(name);
|
||||
parent.children.delete(name);
|
||||
}
|
||||
|
||||
// Unsupported (OPFS has no symlinks / hardlinks)
|
||||
link(): never { throw this.err('ENOSYS', 'hardlinks not supported'); }
|
||||
symlink(): never { throw this.err('ENOSYS', 'symlinks not supported'); }
|
||||
readlink(): never { throw this.err('ENOSYS', 'symlinks not supported'); }
|
||||
|
||||
/** Normalize path and verify it exists. Sync. */
|
||||
realpath(path: string): string {
|
||||
this.resolve(path);
|
||||
return this.normalizePath(path);
|
||||
}
|
||||
|
||||
/** Flush file data to OPFS. Sync. */
|
||||
fdatasync(fd: number): void {
|
||||
const openFd = this.getFd(fd, 'file');
|
||||
openFd.shared!.syncHandle.flush();
|
||||
}
|
||||
|
||||
/** Flush file data + metadata. Sync. */
|
||||
fsync(fd: number): void {
|
||||
this.fdatasync(fd);
|
||||
}
|
||||
|
||||
// --- Bulk operations (for main-thread UI) ---
|
||||
|
||||
/** Recursively delete all content under the OPFS root. ASYNC. */
|
||||
async wipe(): Promise<void> {
|
||||
if (!this.root) return;
|
||||
this.closeAll();
|
||||
await this.clearDir(this.root);
|
||||
}
|
||||
|
||||
/** Write a file into the OPFS tree, creating parent directories as needed. ASYNC. */
|
||||
async writeFile(path: string, data: Uint8Array): Promise<void> {
|
||||
// Ensure parent directories exist
|
||||
const segments = path.split('/').filter(Boolean);
|
||||
let dir = this.root!;
|
||||
for (let i = 0; i < segments.length - 1; i++) {
|
||||
const seg = segments[i];
|
||||
let child = dir.children.get(seg);
|
||||
if (!child) {
|
||||
const handle = await dir.handle.getDirectoryHandle(seg, { create: true });
|
||||
child = { name: seg, kind: 'directory', handle, children: new Map(), mtime: Date.now() };
|
||||
dir.children.set(seg, child);
|
||||
}
|
||||
if (child.kind !== 'directory') throw this.err('ENOTDIR', path);
|
||||
dir = child;
|
||||
}
|
||||
|
||||
const fileName = segments[segments.length - 1];
|
||||
let fileNode = dir.children.get(fileName);
|
||||
let fileHandle: FileSystemFileHandle;
|
||||
|
||||
if (fileNode && fileNode.kind === 'file') {
|
||||
fileHandle = fileNode.handle;
|
||||
} else {
|
||||
fileHandle = await dir.handle.getFileHandle(fileName, { create: true });
|
||||
}
|
||||
|
||||
const syncHandle = await fileHandle.createSyncAccessHandle();
|
||||
syncHandle.truncate(0);
|
||||
syncHandle.write(data);
|
||||
syncHandle.flush();
|
||||
const size = syncHandle.getSize();
|
||||
syncHandle.close();
|
||||
|
||||
dir.children.set(fileName, {
|
||||
name: fileName,
|
||||
kind: 'file',
|
||||
handle: fileHandle,
|
||||
size,
|
||||
mtime: Date.now(),
|
||||
});
|
||||
}
|
||||
|
||||
/** Read a file's full contents. ASYNC. */
|
||||
async readFile(path: string): Promise<Uint8Array> {
|
||||
const node = this.resolve(path);
|
||||
if (node.kind !== 'file') throw this.err('EISDIR', path);
|
||||
|
||||
const file = await node.handle.getFile();
|
||||
return new Uint8Array(await file.arrayBuffer());
|
||||
}
|
||||
|
||||
/** Recursively list all file paths under a directory. Sync. */
|
||||
listFiles(basePath = '/'): string[] {
|
||||
const result: string[] = [];
|
||||
const node = this.resolve(basePath);
|
||||
if (node.kind === 'directory') {
|
||||
this.listFilesRec(basePath, node, result);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// --- Private helpers ---
|
||||
|
||||
private async createFile(path: string): Promise<FileNode> {
|
||||
const { parent, name } = this.resolveParent(path);
|
||||
const handle = await parent.handle.getFileHandle(name, { create: true });
|
||||
const node: FileNode = {
|
||||
name,
|
||||
kind: 'file',
|
||||
handle,
|
||||
size: 0,
|
||||
mtime: Date.now(),
|
||||
};
|
||||
parent.children.set(name, node);
|
||||
return node;
|
||||
}
|
||||
|
||||
private async clearDir(dir: DirNode): Promise<void> {
|
||||
const names = Array.from(dir.children.keys());
|
||||
for (const name of names) {
|
||||
await dir.handle.removeEntry(name, { recursive: true });
|
||||
}
|
||||
dir.children.clear();
|
||||
}
|
||||
|
||||
private listFilesRec(basePath: string, dir: DirNode, result: string[]): void {
|
||||
for (const child of dir.children.values()) {
|
||||
const childPath = basePath === '/' ? `/${child.name}` : `${basePath}/${child.name}`;
|
||||
if (child.kind === 'directory') {
|
||||
this.listFilesRec(childPath, child, result);
|
||||
} else {
|
||||
result.push(childPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Get an open fd, throwing EBADF or EISDIR as appropriate. */
|
||||
private getFd(fd: number, expect: 'file'): OpenFd & { shared: SharedHandle };
|
||||
private getFd(fd: number, expect?: string): OpenFd;
|
||||
private getFd(fd: number, expect?: string): OpenFd {
|
||||
const openFd = this.fdTable.get(fd);
|
||||
if (!openFd) throw this.err('EBADF', `fd ${fd}`);
|
||||
if (expect === 'file' && !openFd.shared) throw this.err('EISDIR', `fd ${fd}`);
|
||||
return openFd;
|
||||
}
|
||||
|
||||
private err(code: string, detail: string): Error {
|
||||
const e = new Error(`${code}: ${detail}`);
|
||||
(e as any).code = code;
|
||||
return e;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user