typescript-virtual-container 1.1.1-b → 1.1.1-c

package/dist/VirtualFileSystem/index.js

@@ -0,0 +1,355 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { archiveExists, createTarBuffer, readSnapshotFromTar } from "./archive";
+import { getNode, getParentDirectory, normalizePath, splitPath } from "./path";
+import { applySnapshot, createSnapshot } from "./snapshot";
+import { renderTree } from "./tree";
+/**
+ * In-memory virtual filesystem with tar.gz mirror persistence.
+ *
+ * Paths are normalized to POSIX-like absolute paths. Use
+ * {@link VirtualFileSystem.restoreMirror} on startup and
+ * {@link VirtualFileSystem.flushMirror} to persist pending changes.
+ */
+class VirtualFileSystem {
+    root;
+    archivePath;
+    dirty = false;
+    computeNodeUsageBytes(node) {
+        if (node.type === "file") {
+            return node.content.length;
+        }
+        let total = 0;
+        for (const child of node.children.values()) {
+            total += this.computeNodeUsageBytes(child);
+        }
+        return total;
+    }
+    /**
+     * Creates a virtual filesystem instance.
+     *
+     * @param baseDir Base directory used to resolve mirror archive location.
+     */
+    constructor(baseDir = process.cwd()) {
+        const now = new Date();
+        this.archivePath = path.resolve(baseDir, ".vfs", "mirror.tar.gz");
+        this.root = {
+            type: "directory",
+            name: "",
+            mode: 0o755,
+            createdAt: now,
+            updatedAt: now,
+            children: new Map(),
+        };
+    }
+    /**
+     * Restores filesystem state from mirror archive.
+     *
+     * If archive does not exist or cannot be read, creates fresh mirror file.
+     */
+    async restoreMirror() {
+        await fs.mkdir(path.dirname(this.archivePath), { recursive: true });
+        try {
+            const compressed = await fs.readFile(this.archivePath);
+            const tarBuffer = gunzipSync(compressed);
+            const snapshot = await readSnapshotFromTar(tarBuffer);
+            applySnapshot(this.root, snapshot);
+            this.dirty = false;
+            return;
+        }
+        catch {
+            console.warn(`No valid mirror archive found at '${this.archivePath}'. Starting with empty filesystem.`);
+            await this.flushMirror();
+        }
+    }
+    /**
+     * Persists current filesystem state to mirror archive.
+     *
+     * No-op when nothing changed and archive already exists.
+     */
+    async flushMirror() {
+        if (!this.dirty && (await archiveExists(this.archivePath))) {
+            return;
+        }
+        await fs.mkdir(path.dirname(this.archivePath), { recursive: true });
+        const snapshotJson = JSON.stringify(createSnapshot(this.root), null, 2);
+        const tarBuffer = await createTarBuffer(snapshotJson);
+        const compressed = gzipSync(tarBuffer);
+        await fs.writeFile(this.archivePath, compressed);
+        this.dirty = false;
+    }
+    /**
+     * Creates directory and any missing parent directories.
+     *
+     * @param targetPath Absolute or relative path to directory.
+     * @param mode POSIX-like mode bits for new directories.
+     */
+    mkdir(targetPath, mode = 0o755) {
+        const normalized = normalizePath(targetPath);
+        const parts = splitPath(normalized);
+        let current = this.root;
+        for (const part of parts) {
+            const existing = current.children.get(part);
+            if (!existing) {
+                const now = new Date();
+                const nextDir = {
+                    type: "directory",
+                    name: part,
+                    mode,
+                    createdAt: now,
+                    updatedAt: now,
+                    children: new Map(),
+                };
+                current.children.set(part, nextDir);
+                current.updatedAt = now;
+                this.dirty = true;
+                current = nextDir;
+                continue;
+            }
+            if (existing.type !== "directory") {
+                throw new Error(`Cannot create directory '${normalized}': '${part}' is a file.`);
+            }
+            current = existing;
+        }
+    }
+    /**
+     * Writes UTF-8 text or binary content into file.
+     *
+     * Parent directories are created when missing.
+     *
+     * @param targetPath Destination file path.
+     * @param content File content as string or Buffer.
+     * @param options Optional write behavior (mode, compression).
+     */
+    writeFile(targetPath, content, options = {}) {
+        const normalized = normalizePath(targetPath);
+        const { parent, name } = getParentDirectory(this.root, normalized, true, (pathToCreate) => this.mkdir(pathToCreate));
+        const now = new Date();
+        const rawContent = Buffer.isBuffer(content)
+            ? content
+            : Buffer.from(content, "utf8");
+        const shouldCompress = options.compress ?? false;
+        const storedContent = shouldCompress ? gzipSync(rawContent) : rawContent;
+        const existing = parent.children.get(name);
+        if (existing && existing.type === "directory") {
+            throw new Error(`Cannot write file '${normalized}': path is a directory.`);
+        }
+        const createdAt = existing?.type === "file" ? existing.createdAt : now;
+        const mode = options.mode ?? (existing?.type === "file" ? existing.mode : 0o644);
+        parent.children.set(name, {
+            type: "file",
+            name,
+            mode,
+            createdAt,
+            updatedAt: now,
+            content: storedContent,
+            compressed: shouldCompress,
+        });
+        parent.updatedAt = now;
+        this.dirty = true;
+    }
+    /**
+     * Reads file content as UTF-8 text.
+     *
+     * Compressed files are transparently decompressed.
+     *
+     * @param targetPath Path to file.
+     * @returns UTF-8 string content.
+     */
+    readFile(targetPath) {
+        const node = getNode(this.root, targetPath);
+        if (node.type !== "file") {
+            throw new Error(`Cannot read '${targetPath}': not a file.`);
+        }
+        const raw = node.compressed ? gunzipSync(node.content) : node.content;
+        return raw.toString("utf8");
+    }
+    /**
+     * Checks whether node exists at path.
+     *
+     * @param targetPath Node path.
+     * @returns True when file or directory exists.
+     */
+    exists(targetPath) {
+        try {
+            getNode(this.root, targetPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Updates mode bits for file or directory.
+     *
+     * @param targetPath Node path.
+     * @param mode New POSIX-like mode.
+     */
+    chmod(targetPath, mode) {
+        const node = getNode(this.root, targetPath);
+        node.mode = mode;
+        node.updatedAt = new Date();
+        this.dirty = true;
+    }
+    /**
+     * Returns metadata for file or directory.
+     *
+     * @param targetPath Node path.
+     * @returns Typed stat object based on node type.
+     */
+    stat(targetPath) {
+        const normalized = normalizePath(targetPath);
+        const node = getNode(this.root, normalized);
+        if (node.type === "file") {
+            return {
+                type: "file",
+                name: node.name,
+                path: normalized,
+                mode: node.mode,
+                createdAt: node.createdAt,
+                updatedAt: node.updatedAt,
+                compressed: node.compressed,
+                size: node.content.length,
+            };
+        }
+        return {
+            type: "directory",
+            name: node.name,
+            path: normalized,
+            mode: node.mode,
+            createdAt: node.createdAt,
+            updatedAt: node.updatedAt,
+            childrenCount: node.children.size,
+        };
+    }
+    /**
+     * Lists direct children names of directory.
+     *
+     * @param dirPath Directory path, defaults to root.
+     * @returns Sorted child names.
+     */
+    list(dirPath = "/") {
+        const node = getNode(this.root, dirPath);
+        if (node.type !== "directory") {
+            throw new Error(`Cannot list '${dirPath}': not a directory.`);
+        }
+        return Array.from(node.children.keys()).sort();
+    }
+    /**
+     * Renders ASCII tree view of directory hierarchy.
+     *
+     * @param dirPath Directory path, defaults to root.
+     * @returns Multi-line tree string.
+     */
+    tree(dirPath = "/") {
+        const node = getNode(this.root, dirPath);
+        if (node.type !== "directory") {
+            throw new Error(`Cannot render tree for '${dirPath}': not a directory.`);
+        }
+        const rootLabel = dirPath === "/" ? "/" : path.posix.basename(normalizePath(dirPath));
+        return renderTree(node, rootLabel);
+    }
+    /**
+     * Computes total stored file bytes under a path.
+     *
+     * File usage is based on in-memory stored bytes, including compressed
+     * payload size when files are marked as compressed.
+     *
+     * @param targetPath File or directory path to measure, defaults to root.
+     * @returns Total byte usage for file content under target path.
+     */
+    getUsageBytes(targetPath = "/") {
+        const node = getNode(this.root, targetPath);
+        return this.computeNodeUsageBytes(node);
+    }
+    /**
+     * Compresses file content with gzip and flags node as compressed.
+     *
+     * @param targetPath Path to file.
+     */
+    compressFile(targetPath) {
+        const node = getNode(this.root, targetPath);
+        if (node.type !== "file") {
+            throw new Error(`Cannot compress '${targetPath}': not a file.`);
+        }
+        if (!node.compressed) {
+            node.content = gzipSync(node.content);
+            node.compressed = true;
+            node.updatedAt = new Date();
+            this.dirty = true;
+        }
+    }
+    /**
+     * Decompresses gzip-compressed file content.
+     *
+     * @param targetPath Path to file.
+     */
+    decompressFile(targetPath) {
+        const node = getNode(this.root, targetPath);
+        if (node.type !== "file") {
+            throw new Error(`Cannot decompress '${targetPath}': not a file.`);
+        }
+        if (node.compressed) {
+            node.content = gunzipSync(node.content);
+            node.compressed = false;
+            node.updatedAt = new Date();
+            this.dirty = true;
+        }
+    }
+    /**
+     * Removes file or directory node.
+     *
+     * @param targetPath Path to remove.
+     * @param options Removal options, including recursive delete.
+     */
+    remove(targetPath, options = {}) {
+        const normalized = normalizePath(targetPath);
+        if (normalized === "/") {
+            throw new Error("Cannot remove root directory.");
+        }
+        const { parent, name } = getParentDirectory(this.root, normalized, false, () => undefined);
+        const node = parent.children.get(name);
+        if (!node) {
+            throw new Error(`Path '${normalized}' does not exist.`);
+        }
+        if (node.type === "directory" &&
+            node.children.size > 0 &&
+            !options.recursive) {
+            throw new Error(`Directory '${normalized}' is not empty. Use recursive option.`);
+        }
+        parent.children.delete(name);
+        parent.updatedAt = new Date();
+        this.dirty = true;
+    }
+    /**
+     * Moves or renames node to destination path.
+     *
+     * @param fromPath Existing source path.
+     * @param toPath Destination path.
+     */
+    move(fromPath, toPath) {
+        const fromNormalized = normalizePath(fromPath);
+        const toNormalized = normalizePath(toPath);
+        if (fromNormalized === "/" || toNormalized === "/") {
+            throw new Error("Cannot move root directory.");
+        }
+        const { parent: fromParent, name: fromName } = getParentDirectory(this.root, fromNormalized, false, () => undefined);
+        const node = fromParent.children.get(fromName);
+        if (!node) {
+            throw new Error(`Path '${fromNormalized}' does not exist.`);
+        }
+        const { parent: toParent, name: toName } = getParentDirectory(this.root, toNormalized, true, (pathToCreate) => this.mkdir(pathToCreate));
+        if (toParent.children.has(toName)) {
+            throw new Error(`Destination '${toNormalized}' already exists.`);
+        }
+        fromParent.children.delete(fromName);
+        node.name = toName;
+        node.updatedAt = new Date();
+        toParent.children.set(toName, node);
+        fromParent.updatedAt = new Date();
+        toParent.updatedAt = new Date();
+        this.dirty = true;
+    }
+}
+export default VirtualFileSystem;

package/dist/VirtualFileSystem/internalTypes.d.ts

@@ -0,0 +1,18 @@
+export type InternalNode = InternalFileNode | InternalDirectoryNode;
+interface InternalBaseNode {
+    name: string;
+    mode: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface InternalFileNode extends InternalBaseNode {
+    type: "file";
+    content: Buffer;
+    compressed: boolean;
+}
+export interface InternalDirectoryNode extends InternalBaseNode {
+    type: "directory";
+    children: Map<string, InternalNode>;
+}
+export {};
+//# sourceMappingURL=internalTypes.d.ts.map

package/dist/VirtualFileSystem/internalTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalTypes.d.ts","sourceRoot":"","sources":["../../src/VirtualFileSystem/internalTypes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG,qBAAqB,CAAC;AAEpE,UAAU,gBAAgB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC9D,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACpC"}

package/dist/VirtualFileSystem/path.d.ts

@@ -0,0 +1,9 @@
+import type { InternalDirectoryNode, InternalNode } from "./internalTypes";
+export declare function normalizePath(rawPath: string): string;
+export declare function splitPath(normalizedPath: string): string[];
+export declare function getNode(root: InternalDirectoryNode, targetPath: string): InternalNode;
+export declare function getParentDirectory(root: InternalDirectoryNode, targetPath: string, createIfMissing: boolean, createPath: (pathToCreate: string) => void): {
+    parent: InternalDirectoryNode;
+    name: string;
+};
+//# sourceMappingURL=path.d.ts.map

package/dist/VirtualFileSystem/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/VirtualFileSystem/path.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE3E,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CASrD;AAED,wBAAgB,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAE1D;AAED,wBAAgB,OAAO,CACtB,IAAI,EAAE,qBAAqB,EAC3B,UAAU,EAAE,MAAM,GAChB,YAAY,CAsBd;AAED,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,qBAAqB,EAC3B,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,OAAO,EACxB,UAAU,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,GACxC;IAAE,MAAM,EAAE,qBAAqB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAuBjD"}

package/dist/VirtualFileSystem/path.js

@@ -0,0 +1,49 @@
+import * as path from "node:path";
+export function normalizePath(rawPath) {
+    if (!rawPath || rawPath.trim() === "") {
+        return "/";
+    }
+    const normalized = path.posix.normalize(rawPath.startsWith("/") ? rawPath : `/${rawPath}`);
+    return normalized === "" ? "/" : normalized;
+}
+export function splitPath(normalizedPath) {
+    return normalizedPath.split("/").filter(Boolean);
+}
+export function getNode(root, targetPath) {
+    const normalized = normalizePath(targetPath);
+    if (normalized === "/") {
+        return root;
+    }
+    const parts = splitPath(normalized);
+    let current = root;
+    for (const part of parts) {
+        if (current.type !== "directory") {
+            throw new Error(`Path '${normalized}' does not exist.`);
+        }
+        const next = current.children.get(part);
+        if (!next) {
+            throw new Error(`Path '${normalized}' does not exist.`);
+        }
+        current = next;
+    }
+    return current;
+}
+export function getParentDirectory(root, targetPath, createIfMissing, createPath) {
+    const normalized = normalizePath(targetPath);
+    if (normalized === "/") {
+        throw new Error("Root path has no parent directory.");
+    }
+    const parentPath = path.posix.dirname(normalized);
+    const name = path.posix.basename(normalized);
+    if (!name) {
+        throw new Error(`Invalid path '${targetPath}'.`);
+    }
+    if (createIfMissing) {
+        createPath(parentPath);
+    }
+    const parentNode = getNode(root, parentPath);
+    if (parentNode.type !== "directory") {
+        throw new Error(`Parent path '${parentPath}' is not a directory.`);
+    }
+    return { parent: parentNode, name };
+}

package/dist/VirtualFileSystem/snapshot.d.ts

@@ -0,0 +1,5 @@
+import type { VfsSnapshot } from "../types/vfs";
+import type { InternalDirectoryNode } from "./internalTypes";
+export declare function createSnapshot(root: InternalDirectoryNode): VfsSnapshot;
+export declare function applySnapshot(rootTarget: InternalDirectoryNode, snapshot: VfsSnapshot): void;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/VirtualFileSystem/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/VirtualFileSystem/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,WAAW,EAGX,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,qBAAqB,EAAgB,MAAM,iBAAiB,CAAC;AAgE3E,wBAAgB,cAAc,CAAC,IAAI,EAAE,qBAAqB,GAAG,WAAW,CAEvE;AAED,wBAAgB,aAAa,CAC5B,UAAU,EAAE,qBAAqB,EACjC,QAAQ,EAAE,WAAW,GACnB,IAAI,CAON"}

package/dist/VirtualFileSystem/snapshot.js

@@ -0,0 +1,59 @@
+function serializeNode(node) {
+    if (node.type === "file") {
+        return {
+            type: "file",
+            name: node.name,
+            mode: node.mode,
+            createdAt: node.createdAt.toISOString(),
+            updatedAt: node.updatedAt.toISOString(),
+            compressed: node.compressed,
+            contentBase64: node.content.toString("base64"),
+        };
+    }
+    return serializeDirectory(node);
+}
+function serializeDirectory(node) {
+    return {
+        type: "directory",
+        name: node.name,
+        mode: node.mode,
+        createdAt: node.createdAt.toISOString(),
+        updatedAt: node.updatedAt.toISOString(),
+        children: Array.from(node.children.values()).map((child) => serializeNode(child)),
+    };
+}
+function deserializeNode(node) {
+    if (node.type === "file") {
+        return {
+            type: "file",
+            name: node.name,
+            mode: node.mode,
+            createdAt: new Date(node.createdAt),
+            updatedAt: new Date(node.updatedAt),
+            content: Buffer.from(node.contentBase64, "base64"),
+            compressed: node.compressed,
+        };
+    }
+    return deserializeDirectory(node);
+}
+function deserializeDirectory(node) {
+    return {
+        type: "directory",
+        name: node.name,
+        mode: node.mode,
+        createdAt: new Date(node.createdAt),
+        updatedAt: new Date(node.updatedAt),
+        children: new Map(node.children.map((child) => [child.name, deserializeNode(child)])),
+    };
+}
+export function createSnapshot(root) {
+    return { root: serializeDirectory(root) };
+}
+export function applySnapshot(rootTarget, snapshot) {
+    const root = deserializeDirectory(snapshot.root);
+    rootTarget.name = root.name;
+    rootTarget.mode = root.mode;
+    rootTarget.createdAt = root.createdAt;
+    rootTarget.updatedAt = root.updatedAt;
+    rootTarget.children = root.children;
+}

package/dist/VirtualFileSystem/tree.d.ts

@@ -0,0 +1,3 @@
+import type { InternalDirectoryNode } from "./internalTypes";
+export declare function renderTree(node: InternalDirectoryNode, rootLabel: string): string;
+//# sourceMappingURL=tree.d.ts.map

package/dist/VirtualFileSystem/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/VirtualFileSystem/tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AA0B7D,wBAAgB,UAAU,CACzB,IAAI,EAAE,qBAAqB,EAC3B,SAAS,EAAE,MAAM,GACf,MAAM,CAIR"}

package/dist/VirtualFileSystem/tree.js

@@ -0,0 +1,19 @@
+function walkTree(node, indent, lines) {
+    const entries = Array.from(node.children.entries()).sort(([a], [b]) => a.localeCompare(b));
+    entries.forEach(([name, child], index) => {
+        const isLast = index === entries.length - 1;
+        const branch = isLast ? "`-- " : "|-- ";
+        const nextIndent = indent + (isLast ? "    " : "|   ");
+        if (child.type === "file") {
+            lines.push(`${indent}${branch}${name}${child.compressed ? " [gz]" : ""}`);
+            return;
+        }
+        lines.push(`${indent}${branch}${name}/`);
+        walkTree(child, nextIndent, lines);
+    });
+}
+export function renderTree(node, rootLabel) {
+    const lines = [rootLabel];
+    walkTree(node, "", lines);
+    return lines.join("\n");
+}

package/dist/VirtualShell/index.d.ts

@@ -0,0 +1,86 @@
+import type { CommandContext, CommandResult } from "../types/commands";
+import type { ShellStream } from "../types/streams";
+import VirtualFileSystem from "../VirtualFileSystem";
+import { VirtualUserManager } from "../VirtualUserManager";
+export interface ShellProperties {
+    kernel: string;
+    os: string;
+    arch: string;
+}
+/**
+ * Coordinates the virtual filesystem, user manager, and command runtime.
+ *
+ * Instances are used both by the SSH server facade and by the programmatic
+ * client API.
+ */
+declare class VirtualShell {
+    basePath: string;
+    vfs: VirtualFileSystem;
+    users: VirtualUserManager;
+    hostname: string;
+    properties: ShellProperties;
+    /**
+     * Creates a new virtual shell instance.
+     *
+     * @param hostname Virtual hostname used for prompts and idents.
+     * @param properties Customizable properties shown in `uname -a` and similar commands.
+     * @param basePath Optional base path for the virtual filesystem (defaults to process.cwd()).
+     */
+    constructor(hostname: string, properties?: ShellProperties, basePath?: string);
+    /**
+     * Registers a new command in the shell runtime.
+     *
+     * @param name Case-insensitive command name (no spaces).
+     * @param params List of parameter names for help text (no validation).
+     * @param callback Function invoked with command context on execution.
+     */
+    addCommand(name: string, params: string[], callback: (ctx: CommandContext) => CommandResult | Promise<CommandResult>): void;
+    /**
+     * Executes a command line string in the context of this shell instance.
+     *
+     * @param rawInput
+     * @param authUser
+     * @param cwd
+     */
+    executeCommand(rawInput: string, authUser: string, cwd: string): void;
+    /**
+     * Starts an interactive session with the shell.
+     *
+     * @param stream The stream for the interactive session.
+     * @param authUser The authenticated user for the session.
+     * @param sessionId The ID of the session.
+     * @param remoteAddress The address of the remote client.
+     */
+    startInteractiveSession(stream: ShellStream, authUser: string, sessionId: string | null, remoteAddress: string, terminalSize: {
+        cols: number;
+        rows: number;
+    }): void;
+    /**
+     * Returns virtual filesystem instance after server started.
+     *
+     * @returns VirtualFileSystem or null when not started.
+     */
+    getVfs(): VirtualFileSystem | null;
+    /**
+     * Returns user manager instance after server started.
+     *
+     * @returns VirtualUserManager or null when not started.
+     */
+    getUsers(): VirtualUserManager | null;
+    /**
+     * Returns hostname shown in prompts and idents.
+     *
+     * @returns Configured hostname label.
+     */
+    getHostname(): string;
+    /**
+     * Writes a file on behalf of a user with quota enforcement.
+     *
+     * @param authUser User performing the write.
+     * @param targetPath Destination path.
+     * @param content File content.
+     */
+    writeFileAsUser(authUser: string, targetPath: string, content: string | Buffer): void;
+}
+export { VirtualShell };
+//# sourceMappingURL=index.d.ts.map

package/dist/VirtualShell/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/VirtualShell/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,iBAAiB,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG3D,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACb;AA8BD;;;;;GAKG;AACH,cAAM,YAAY;IACjB,QAAQ,EAAE,MAAM,CAAO;IACvB,GAAG,EAAE,iBAAiB,CAAC;IACvB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,eAAe,CAAC;IAE5B;;;;;;OAMG;gBAEF,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,eAAe,EAC5B,QAAQ,CAAC,EAAE,MAAM;IAqBlB;;;;;;OAMG;IACH,UAAU,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,QAAQ,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,GACvE,IAAI;IASP;;;;;;OAMG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAIrE;;;;;;;OAOG;IAEH,uBAAuB,CACtB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAC1C,IAAI;IAcP;;;;OAIG;IACI,MAAM,IAAI,iBAAiB,GAAG,IAAI;IAIzC;;;;OAIG;IACI,QAAQ,IAAI,kBAAkB,GAAG,IAAI;IAI5C;;;;OAIG;IACI,WAAW,IAAI,MAAM;IAI5B;;;;;;OAMG;IACI,eAAe,CACrB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,MAAM,GACtB,IAAI;CAIP;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}