npm - typescript-virtual-container - Versions diffs - 1.4.2 → 1.4.3 - Mend

typescript-virtual-container 1.4.2 → 1.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/README.md +72 -35
package/builds/self-standalone.js +160 -160
package/builds/self-standalone.js.map +4 -4
package/builds/standalone-wo-sftp.js +18 -18
package/builds/standalone-wo-sftp.js.map +3 -3
package/builds/standalone.js +46 -46
package/builds/standalone.js.map +3 -3
package/dist/VirtualFileSystem/index.d.ts +47 -0
package/dist/VirtualFileSystem/index.d.ts.map +1 -1
package/dist/VirtualFileSystem/index.js +159 -0
package/dist/VirtualShell/index.d.ts +29 -0
package/dist/VirtualShell/index.d.ts.map +1 -1
package/dist/VirtualShell/index.js +29 -0
package/dist/VirtualShell/shellParser.js +28 -1
package/dist/commands/export.d.ts.map +1 -1
package/dist/commands/export.js +5 -3
package/dist/commands/registry.d.ts.map +1 -1
package/dist/commands/registry.js +2 -0
package/dist/commands/runtime.d.ts.map +1 -1
package/dist/commands/runtime.js +28 -3
package/dist/commands/seq.d.ts +4 -0
package/dist/commands/seq.d.ts.map +1 -0
package/dist/commands/seq.js +50 -0
package/dist/commands/sh.d.ts +0 -6
package/dist/commands/sh.d.ts.map +1 -1
package/dist/commands/sh.js +153 -10
package/dist/types/pipeline.d.ts +6 -0
package/dist/types/pipeline.d.ts.map +1 -1
package/dist/types/vfs.d.ts +15 -0
package/dist/types/vfs.d.ts.map +1 -1
package/dist/utils/expand.d.ts +9 -0
package/dist/utils/expand.d.ts.map +1 -1
package/dist/utils/expand.js +84 -2
package/dist/utils/tokenize.d.ts.map +1 -1
package/dist/utils/tokenize.js +40 -0
package/package.json +1 -1
package/src/VirtualFileSystem/index.ts +164 -1
package/src/VirtualShell/index.ts +36 -0
package/src/VirtualShell/shellParser.ts +26 -1
package/src/commands/export.ts +5 -3
package/src/commands/registry.ts +2 -0
package/src/commands/runtime.ts +30 -3
package/src/commands/seq.ts +43 -0
package/src/commands/sh.ts +144 -19
package/src/types/pipeline.ts +6 -0
package/src/types/vfs.ts +17 -0
package/src/utils/expand.ts +75 -2
package/src/utils/tokenize.ts +20 -0

package/dist/commands/sh.js CHANGED Viewed

@@ -19,6 +19,38 @@ function parseBlocks(lines) {
             i++;
             continue;
         }
+        // Function definition: name() { or function name { or name() { body }
+        const funcMatchInline = line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{(.+)\}\s*$/);
+        const funcMatch = funcMatchInline ?? (line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{?\s*$/) ||
+            line.match(/^function\s+(\w+)\s*\{?\s*$/));
+        if (funcMatch) {
+            const funcName = funcMatch[1];
+            const body = [];
+            // Inline: name() { cmd; } — single-line form
+            if (funcMatchInline) {
+                body.push(...funcMatchInline[2].split(";").map((s) => s.trim()).filter(Boolean));
+                blocks.push({ type: "func", name: funcName, body });
+                i++;
+                continue;
+            }
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "}" && i < lines.length + 1) {
+                const l = lines[i].trim().replace(/^do\s+/, "");
+                if (l && l !== "{")
+                    body.push(l);
+                i++;
+            }
+            i++; // skip closing }
+            blocks.push({ type: "func", name: funcName, body });
+            continue;
+        }
+        // (( expr )) arithmetic statement
+        const arithMatch = line.match(/^\(\(\s*(.+?)\s*\)\)$/);
+        if (arithMatch) {
+            blocks.push({ type: "arith", expr: arithMatch[1] });
+            i++;
+            continue;
+        }
         if (line.startsWith("if ") || line === "if") {
             const cond = line
                 .replace(/^if\s+/, "")
@@ -174,7 +206,26 @@ async function runBlocks(blocks, ctx) {
                     continue;
                 }
             }
-            const r = await runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
+            const r = await (async () => {
+                // Check if expanded matches a registered function
+                const cmdName = expanded.trim().split(/\s+/)[0] ?? "";
+                const funcBody = ctx.env.vars[`__func_${cmdName}`];
+                if (funcBody) {
+                    // Set positional params $1 $2 ... from remaining args
+                    const funcArgs = expanded.trim().split(/\s+/).slice(1);
+                    const savedVars = { ...ctx.env.vars };
+                    funcArgs.forEach((a, i) => { ctx.env.vars[String(i + 1)] = a; });
+                    ctx.env.vars["0"] = cmdName;
+                    const funcLines = funcBody.split("\n");
+                    const funcResult = await runBlocks(parseBlocks(funcLines), ctx);
+                    // Restore positional params
+                    for (let pi = 1; pi <= funcArgs.length; pi++)
+                        delete ctx.env.vars[String(pi)];
+                    Object.assign(ctx.env.vars, { ...savedVars, ...ctx.env.vars });
+                    return funcResult;
+                }
+                return runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
+            })();
             ctx.env.lastExitCode = r.exitCode ?? 0;
             if (r.stdout)
                 output += `${r.stdout}\n`;
@@ -207,9 +258,35 @@ async function runBlocks(blocks, ctx) {
                 }
             }
         }
+        else if (block.type === "func") {
+            // Register function in env vars as __func_<name>=<body>
+            ctx.env.vars[`__func_${block.name}`] = block.body.join("\n");
+        }
+        else if (block.type === "arith") {
+            // (( expr )) — evaluate arithmetic, update vars
+            const { expandSync } = await import("../utils/expand");
+            const expr = expandSync(block.expr, ctx.env.vars, ctx.env.lastExitCode);
+            // Handle i++ / i-- / i+=N / i-=N
+            const incMatch = expr.match(/^(\w+)\s*(\+\+|--)$/);
+            if (incMatch) {
+                const val = parseInt(ctx.env.vars[incMatch[1]] ?? "0", 10);
+                ctx.env.vars[incMatch[1]] = String(incMatch[2] === "++" ? val + 1 : val - 1);
+            }
+            else {
+                const assignMatch = expr.match(/^(\w+)\s*([+\-*/])=\s*(.+)$/);
+                if (assignMatch) {
+                    const lhs = parseInt(ctx.env.vars[assignMatch[1]] ?? "0", 10);
+                    const rhs = parseInt(assignMatch[3], 10);
+                    const ops = { "+": lhs + rhs, "-": lhs - rhs, "*": lhs * rhs, "/": Math.floor(lhs / rhs) };
+                    ctx.env.vars[assignMatch[1]] = String(ops[assignMatch[2]] ?? lhs);
+                }
+            }
+        }
         else if (block.type === "for") {
             const listExpanded = await expandVars(block.list, ctx.env.vars, ctx.env.lastExitCode, ctx);
-            const items = listExpanded.trim().split(/\s+/);
+            // Apply brace expansion to each token in the list
+            const { expandBraces } = await import("../utils/expand");
+            const items = listExpanded.trim().split(/\s+/).flatMap(expandBraces);
             for (const item of items) {
                 ctx.env.vars[block.var] = item;
                 const sub = await runBlocks(parseBlocks(block.body), ctx);
@@ -239,6 +316,78 @@ async function runBlocks(blocks, ctx) {
  * @category shell
  * @params ["-c <script>", "[<file>]"]
  */
+/**
+ * Split a sh script into logical lines, respecting:
+ * - `{...}` braces (function bodies)
+ * - Newlines and semicolons at depth 0 only
+ */
+function splitShScript(script) {
+    const lines = [];
+    let current = "";
+    let depth = 0;
+    let inSingleQ = false;
+    let inDoubleQ = false;
+    let i = 0;
+    while (i < script.length) {
+        const ch = script[i];
+        if (!inSingleQ && !inDoubleQ) {
+            if (ch === "'") {
+                inSingleQ = true;
+                current += ch;
+                i++;
+                continue;
+            }
+            if (ch === '"') {
+                inDoubleQ = true;
+                current += ch;
+                i++;
+                continue;
+            }
+            if (ch === "{") {
+                depth++;
+                current += ch;
+                i++;
+                continue;
+            }
+            if (ch === "}") {
+                depth--;
+                current += ch;
+                i++;
+                // At depth 0, closing } ends the function body line
+                if (depth === 0) {
+                    const t = current.trim();
+                    if (t)
+                        lines.push(t);
+                    current = "";
+                    // Skip trailing ; or whitespace
+                    while (i < script.length && (script[i] === ";" || script[i] === " "))
+                        i++;
+                }
+                continue;
+            }
+            if (depth === 0 && (ch === ";" || ch === "\n")) {
+                const t = current.trim();
+                if (t && !t.startsWith("#"))
+                    lines.push(t);
+                current = "";
+                i++;
+                continue;
+            }
+        }
+        else if (inSingleQ && ch === "'") {
+            inSingleQ = false;
+        }
+        else if (inDoubleQ && ch === '"') {
+            inDoubleQ = false;
+        }
+        current += ch;
+        i++;
+    }
+    const t = current.trim();
+    if (t && !t.startsWith("#"))
+        lines.push(t);
+    return lines;
+}
 export const shCommand = {
     name: "sh",
     aliases: ["bash"],
@@ -252,10 +401,7 @@ export const shCommand = {
             const script = args[args.indexOf("-c") + 1] ?? "";
             if (!script)
                 return { stderr: "sh: -c requires a script", exitCode: 1 };
-            const lines = script
-                .split(/[;\n]/)
-                .map((l) => l.trim())
-                .filter((l) => l && !l.startsWith("#"));
+            const lines = splitShScript(script);
             const blocks = parseBlocks(lines);
             return runBlocks(blocks, ctx);
         }
@@ -269,10 +415,7 @@ export const shCommand = {
                     exitCode: 1,
                 };
             const content = shell.vfs.readFile(p);
-            const lines = content
-                .split("\n")
-                .map((l) => l.trim())
-                .filter((l) => l && !l.startsWith("#"));
+            const lines = splitShScript(content);
             const blocks = parseBlocks(lines);
             return runBlocks(blocks, ctx);
         }

package/dist/types/pipeline.d.ts CHANGED Viewed

@@ -10,6 +10,12 @@ export interface PipelineCommand {
     outputFile?: string;
     /** Append to output file (>> file) */
     appendOutput?: boolean;
+    /** Stderr redirection file path (2> file) */
+    stderrFile?: string;
+    /** Append stderr to file (2>> file) */
+    stderrAppend?: boolean;
+    /** Redirect stderr to stdout (2>&1) */
+    stderrToStdout?: boolean;
 }
 /** Logical operator connecting two statement groups. */
 export type LogicalOp = "&&" | "||" | ";";

package/dist/types/pipeline.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/types/pipeline.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC/B,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;~~CACvB~~;AAED,wDAAwD;AACxD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC;AAE1C,yCAAyC;AACzC,MAAM,WAAW,QAAQ;IACxB,uCAAuC;IACvC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACzB,8CAA8C;IAC9C,QAAQ,EAAE,QAAQ,CAAC;IACnB,0DAA0D;IAC1D,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,2CAA2C;IAC3C,IAAI,CAAC,EAAE,SAAS,CAAC;CACjB;AAED,2CAA2C;AAC3C,MAAM,WAAW,MAAM;IACtB,0CAA0C;IAC1C,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf"}
1	+ {"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/types/pipeline.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC/B,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uCAAuC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,wDAAwD;AACxD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC;AAE1C,yCAAyC;AACzC,MAAM,WAAW,QAAQ;IACxB,uCAAuC;IACvC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACzB,8CAA8C;IAC9C,QAAQ,EAAE,QAAQ,CAAC;IACnB,0DAA0D;IAC1D,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,2CAA2C;IAC3C,IAAI,CAAC,EAAE,SAAS,CAAC;CACjB;AAED,2CAA2C;AAC3C,MAAM,WAAW,MAAM;IACtB,0CAA0C;IAC1C,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/types/vfs.d.ts CHANGED Viewed

@@ -68,4 +68,19 @@ export type VfsSnapshotNode = VfsSnapshotFileNode | VfsSnapshotDirectoryNode;
 export interface VfsSnapshot {
     root: VfsSnapshotDirectoryNode;
 }
+/** Options for mounting a host directory into the VFS. */
+export interface MountOptions {
+    /** Absolute path inside the VM (e.g. `"/app"`). */
+    vPath: string;
+    /** Path on the host filesystem. Relative paths resolved from `process.cwd()`. */
+    hostPath: string;
+    /** When `true` (default), write operations inside the mount throw `EROFS`. */
+    readOnly?: boolean;
+}
+/** Describes an active mount point. */
+export interface MountPoint {
+    vPath: string;
+    hostPath: string;
+    readOnly: boolean;
+}
 //# sourceMappingURL=vfs.d.ts.map

package/dist/types/vfs.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"vfs.d.ts","sourceRoot":"","sources":["../../src/types/vfs.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,CAAC;AAE/C,oEAAoE;AACpE,MAAM,WAAW,WAAW;IAC3B,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,IAAI,CAAC;IAChB,6BAA6B;IAC7B,SAAS,EAAE,IAAI,CAAC;CAChB;AAED,0CAA0C;AAC1C,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,UAAU,EAAE,OAAO,CAAC;IACpB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;CACb;AAED,+CAA+C;AAC/C,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,kDAAkD;AAClD,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE1D,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAChC,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC7B,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,gEAAgE;AAChE,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,gDAAgD;AAChD,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,qDAAqD;AACrD,MAAM,WAAW,wBAAyB,SAAQ,mBAAmB;IACpE,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,kDAAkD;AAClD,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AAE7E,gDAAgD;AAChD,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,wBAAwB,CAAC;CAC/B"}
1	+ {"version":3,"file":"vfs.d.ts","sourceRoot":"","sources":["../../src/types/vfs.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,CAAC;AAE/C,oEAAoE;AACpE,MAAM,WAAW,WAAW;IAC3B,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,IAAI,CAAC;IAChB,6BAA6B;IAC7B,SAAS,EAAE,IAAI,CAAC;CAChB;AAED,0CAA0C;AAC1C,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,UAAU,EAAE,OAAO,CAAC;IACpB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;CACb;AAED,+CAA+C;AAC/C,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,kDAAkD;AAClD,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE1D,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAChC,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC7B,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,gEAAgE;AAChE,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,gDAAgD;AAChD,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,qDAAqD;AACrD,MAAM,WAAW,wBAAyB,SAAQ,mBAAmB;IACpE,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,kDAAkD;AAClD,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AAE7E,gDAAgD;AAChD,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,wBAAwB,CAAC;CAC/B;AAED,0DAA0D;AAC1D,MAAM,WAAW,YAAY;IAC5B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,uCAAuC;AACvC,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAK,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CAClB"}

package/dist/utils/expand.d.ts CHANGED Viewed

@@ -34,6 +34,15 @@ export declare function evalArith(expr: string, env: Record<string, string>): nu
  * @param lastExit  Last command exit code (for `$?`).
  * @param home      Home directory path (for `~`).
  */
+/**
+ * Expand brace expressions in a single token.
+ * - `{a,b,c}` → `["a", "b", "c"]`
+ * - `{1..5}` → `["1", "2", "3", "4", "5"]`
+ * - `{a..e}` → `["a", "b", "c", "d", "e"]`
+ * - `prefix{a,b}suffix` → `["prefixasuffix", "prefixbsuffix"]`
+ * Returns a single-element array when no brace expansion applies.
+ */
+export declare function expandBraces(token: string): string[];
 export declare function expandSync(input: string, env: Record<string, string>, lastExit?: number, home?: string): string;
 /**
  * Expand all shell forms including `$(cmd)` command substitution.

package/dist/utils/expand.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"expand.d.ts","sourceRoot":"","sources":["../../src/utils/expand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAuB3E;AAoCD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,QAAQ,SAAI,EACZ,IAAI,CAAC,EAAE,MAAM,GACX,MAAM,CA4DR;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,CAuDjB"}
1	+ {"version":3,"file":"expand.d.ts","sourceRoot":"","sources":["../../src/utils/expand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAuB3E;AAoCD;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA8DpD;AAED,wBAAgB,UAAU,CACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,QAAQ,SAAI,EACZ,IAAI,CAAC,EAAE,MAAM,GACX,MAAM,CA4DR;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,CAuDjB"}

package/dist/utils/expand.js CHANGED Viewed

@@ -82,6 +82,88 @@ function outsideSingleQuotes(input, replacer) {
  * @param lastExit  Last command exit code (for `$?`).
  * @param home      Home directory path (for `~`).
  */
+/**
+ * Expand brace expressions in a single token.
+ * - `{a,b,c}` → `["a", "b", "c"]`
+ * - `{1..5}` → `["1", "2", "3", "4", "5"]`
+ * - `{a..e}` → `["a", "b", "c", "d", "e"]`
+ * - `prefix{a,b}suffix` → `["prefixasuffix", "prefixbsuffix"]`
+ * Returns a single-element array when no brace expansion applies.
+ */
+export function expandBraces(token) {
+    // Find the first { not preceded by $
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < token.length; i++) {
+        const ch = token[i];
+        if (ch === "{" && token[i - 1] !== "$") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                const prefix = token.slice(0, start);
+                const inner = token.slice(start + 1, i);
+                const suffix = token.slice(i + 1);
+                // Range: {1..5} or {a..e}
+                const rangeMatch = inner.match(/^(-?\d+)\.\.(-?\d+)(?:\.\.-?(\d+))?$/) ||
+                    inner.match(/^([a-z])\.\.([a-z])$/);
+                if (rangeMatch) {
+                    const items = [];
+                    if (/\d/.test(rangeMatch[1])) {
+                        const from = parseInt(rangeMatch[1], 10);
+                        const to = parseInt(rangeMatch[2], 10);
+                        const step = rangeMatch[3] ? parseInt(rangeMatch[3], 10) : 1;
+                        const inc = from <= to ? step : -step;
+                        for (let n = from; from <= to ? n <= to : n >= to; n += inc) {
+                            items.push(String(n));
+                        }
+                    }
+                    else {
+                        const from = rangeMatch[1].charCodeAt(0);
+                        const to = rangeMatch[2].charCodeAt(0);
+                        const inc = from <= to ? 1 : -1;
+                        for (let c = from; from <= to ? c <= to : c >= to; c += inc) {
+                            items.push(String.fromCharCode(c));
+                        }
+                    }
+                    const expanded = items.map((v) => `${prefix}${v}${suffix}`);
+                    return expanded.flatMap(expandBraces);
+                }
+                // Comma list: {a,b,c} — split respecting nested braces
+                const parts = [];
+                let cur = "";
+                let d2 = 0;
+                for (const ch2 of inner) {
+                    if (ch2 === "{") {
+                        d2++;
+                        cur += ch2;
+                    }
+                    else if (ch2 === "}") {
+                        d2--;
+                        cur += ch2;
+                    }
+                    else if (ch2 === "," && d2 === 0) {
+                        parts.push(cur);
+                        cur = "";
+                    }
+                    else {
+                        cur += ch2;
+                    }
+                }
+                parts.push(cur);
+                if (parts.length > 1) {
+                    const expanded = parts.map((p) => `${prefix}${p}${suffix}`);
+                    return expanded.flatMap(expandBraces);
+                }
+                break;
+            }
+        }
+    }
+    return [token];
+}
 export function expandSync(input, env, lastExit = 0, home) {
     const homePath = home ?? env.HOME ?? "/home/user";
     return outsideSingleQuotes(input, (chunk) => {
@@ -111,8 +193,8 @@ export function expandSync(input, env, lastExit = 0, home) {
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):\+([^}]*)\}/g, (_, name, alt) => env[name] !== undefined && env[name] !== "" ? alt : "");
         // ${VAR}
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => env[name] ?? "");
-        // $VAR
-        s = s.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => env[name] ?? "");
+        // $VAR and positional params $1 $2 ...
+        s = s.replace(/\$([A-Za-z_][A-Za-z0-9_]*|\d+)/g, (_, name) => env[name] ?? "");
         return s;
     });
 }

package/dist/utils/tokenize.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../src/utils/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,~~CA0DvD~~"}
1	+ {"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../src/utils/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA8EvD"}

package/dist/utils/tokenize.js CHANGED Viewed

@@ -50,6 +50,46 @@ export function tokenizeCommand(input) {
             i++;
             continue;
         }
+        // Handle 2>&1, 2>>, 2>, >&, >>
+        if (!inQ && ch === "2" && (next === ">")) {
+            const rest = input.slice(i + 1);
+            if (rest.startsWith(">>&1") || rest.startsWith(">> &1")) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+                tokens.push("2>>&1");
+                i += 5;
+                continue;
+            }
+            if (rest.startsWith(">&1")) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+                tokens.push("2>&1");
+                i += 4;
+                continue;
+            }
+            if (rest.startsWith(">>")) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+                tokens.push("2>>");
+                i += 3;
+                continue;
+            }
+            if (rest.startsWith(">")) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+                tokens.push("2>");
+                i += 2;
+                continue;
+            }
+        }
         if ((ch === ">" || ch === "<") && !inQ) {
             if (current) {
                 tokens.push(current);

package/package.json CHANGED Viewed

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/VirtualFileSystem/index.ts CHANGED Viewed

@@ -75,6 +75,11 @@ class VirtualFileSystem extends EventEmitter {
 	private root: InternalDirectoryNode;
 	private readonly mode: VfsPersistenceMode;
 	private readonly snapshotFile: string | null;
+	/** Active host-directory mounts: vPath → { hostPath, readOnly } */
+	private readonly mounts = new Map<string, { hostPath: string; readOnly: boolean }>();
+	/** True when running in a browser environment (no host FS access). */
+	private static readonly isBrowser =
+		typeof process === "undefined" || typeof (process as NodeJS.Process).versions?.node === "undefined";
 	constructor(options: VfsOptions = {}) {
 		super();
@@ -219,7 +224,97 @@ class VirtualFileSystem extends EventEmitter {
 	// ── Public filesystem API ─────────────────────────────────────────────────
 	/** Creates a directory (and any missing parents). */
-	public mkdir(targetPath: string, mode: number = 0o755): void {
+	// ── Mount API ─────────────────────────────────────────────────────────────
+	/**
+	 * Mount a host directory into the VFS at `vPath`.
+	 *
+	 * Files inside `vPath` are read directly from the host filesystem via
+	 * `node:fs`. All standard VFS operations (`readFile`, `writeFile`,
+	 * `exists`, `stat`, `list`) are transparently delegated.
+	 *
+	 * In browser environments the mount is silently ignored — `vPath` remains
+	 * an empty in-memory directory.
+	 *
+	 * @param vPath     Absolute path inside the VM (e.g. `"/app"`).
+	 * @param hostPath  Path on the host filesystem — relative paths are
+	 *                  resolved from `process.cwd()`.
+	 * @param readOnly  When `true` (default), write operations inside the
+	 *                  mount throw `EROFS: read-only file system`.
+	 *
+	 * @example
+	 * ```ts
+	 * shell.vfs.mount("/app", "./src", { readOnly: true });
+	 * // cat /app/index.ts  — reads ./src/index.ts from host
+	 * ```
+	 */
+	public mount(
+		vPath: string,
+		hostPath: string,
+		{ readOnly = true }: { readOnly?: boolean } = {},
+	): void {
+		if (VirtualFileSystem.isBrowser) return; // silently degrade in browser
+		const normalized = normalizePath(vPath);
+		const resolved   = path.resolve(hostPath);
+		if (!fsSync.existsSync(resolved)) {
+			throw new Error(`VirtualFileSystem.mount: host path does not exist: "${resolved}"`);
+		}
+		if (!fsSync.statSync(resolved).isDirectory()) {
+			throw new Error(`VirtualFileSystem.mount: host path is not a directory: "${resolved}"`);
+		}
+		// Ensure the mount point exists in the VFS tree
+		this.mkdir(normalized);
+		this.mounts.set(normalized, { hostPath: resolved, readOnly });
+		this.emit("mount", { vPath: normalized, hostPath: resolved, readOnly });
+	}
+	/**
+	 * Unmount a previously mounted host directory.
+	 * The in-memory VFS directory at `vPath` is preserved but the host
+	 * delegation is removed.
+	 */
+	public unmount(vPath: string): void {
+		const normalized = normalizePath(vPath);
+		if (this.mounts.delete(normalized)) {
+			this.emit("unmount", { vPath: normalized });
+		}
+	}
+	/** List all active mounts. */
+	public getMounts(): Array<{ vPath: string; hostPath: string; readOnly: boolean }> {
+		return [...this.mounts.entries()].map(([vPath, opts]) => ({
+			vPath, ...opts,
+		}));
+	}
+	/**
+	 * If `targetPath` is inside a mount, return `{ hostPath, readOnly, relPath }`.
+	 * `relPath` is the path relative to the mount's host directory.
+	 * Returns `null` if the path is not under any mount.
+	 */
+	private resolveMount(targetPath: string): {
+		hostPath: string;
+		readOnly: boolean;
+		relPath:  string;
+		fullHostPath: string;
+	} | null {
+		const normalized = normalizePath(targetPath);
+		// Iterate mounts from most specific to least specific
+		const sorted = [...this.mounts.entries()].sort(
+			([a], [b]) => b.length - a.length,
+		);
+		for (const [vBase, opts] of sorted) {
+			if (normalized === vBase || normalized.startsWith(`${vBase}/`)) {
+				const relPath      = normalized.slice(vBase.length).replace(/^\//, "");
+				const fullHostPath = relPath ? path.join(opts.hostPath, relPath) : opts.hostPath;
+				return { hostPath: opts.hostPath, readOnly: opts.readOnly, relPath, fullHostPath };
+			}
+		}
+		return null;
+	}
+		public mkdir(targetPath: string, mode: number = 0o755): void {
 		const normalized = normalizePath(targetPath);
 		const existing = (() => {
 			try {
@@ -245,6 +340,15 @@ class VirtualFileSystem extends EventEmitter {
 		content: string | Buffer,
 		options: WriteFileOptions = {},
 	): void {
+		// Delegate to host FS if inside a mount
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (m.readOnly) throw new Error(`EROFS: read-only file system, open '${m.fullHostPath}'`);
+			const dir = path.dirname(m.fullHostPath);
+			if (!fsSync.existsSync(dir)) fsSync.mkdirSync(dir, { recursive: true });
+			fsSync.writeFileSync(m.fullHostPath, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
+			return;
+		}
 		const normalized = normalizePath(targetPath);
 		const { parent, name } = getParentDirectory(
 			this.root,
@@ -288,6 +392,11 @@ class VirtualFileSystem extends EventEmitter {
 	 * Gzip-compressed files are transparently decompressed.
 	 */
 	public readFile(targetPath: string): string {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: no such file or directory, open '${m.fullHostPath}'`);
+			return fsSync.readFileSync(m.fullHostPath, "utf8");
+		}
 		const normalized = normalizePath(targetPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "file") {
@@ -301,6 +410,11 @@ class VirtualFileSystem extends EventEmitter {
 	/** Reads file content as a Buffer (decompresses if needed). */
 	public readFileRaw(targetPath: string): Buffer {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: no such file or directory, open '${m.fullHostPath}'`);
+			return fsSync.readFileSync(m.fullHostPath);
+		}
 		const normalized = normalizePath(targetPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "file") {
@@ -314,6 +428,8 @@ class VirtualFileSystem extends EventEmitter {
 	/** Returns true when a file or directory exists at path. */
 	public exists(targetPath: string): boolean {
+		const m = this.resolveMount(targetPath);
+		if (m) return fsSync.existsSync(m.fullHostPath);
 		try {
 			getNode(this.root, normalizePath(targetPath));
 			return true;
@@ -329,6 +445,34 @@ class VirtualFileSystem extends EventEmitter {
 	/** Returns metadata for a file or directory. */
 	public stat(targetPath: string): VfsNodeStats {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: stat '${m.fullHostPath}'`);
+			const hst = fsSync.statSync(m.fullHostPath);
+			const name = m.relPath.split("/").pop() ?? m.fullHostPath.split("/").pop() ?? "";
+			const now = hst.mtime;
+			if (hst.isDirectory()) {
+				return {
+					type: "directory",
+					name,
+					path: normalizePath(targetPath),
+					mode: 0o755,
+					createdAt: hst.birthtime,
+					updatedAt: now,
+					childrenCount: fsSync.readdirSync(m.fullHostPath).length,
+				} satisfies import("../types/vfs").VfsDirectoryNode;
+			}
+			return {
+				type: "file",
+				name,
+				path: normalizePath(targetPath),
+				mode: m.readOnly ? 0o444 : 0o644,
+				createdAt: hst.birthtime,
+				updatedAt: now,
+				compressed: false,
+				size: hst.size,
+			} satisfies import("../types/vfs").VfsFileNode;
+		}
 		const normalized = normalizePath(targetPath);
 		const node = getNode(this.root, normalized);
 		const name = normalized === "/" ? "" : path.posix.basename(normalized);
@@ -359,6 +503,13 @@ class VirtualFileSystem extends EventEmitter {
 	/** Lists direct children names of a directory (sorted). */
 	public list(dirPath: string = "/"): string[] {
+		const m = this.resolveMount(dirPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) return [];
+			try {
+				return fsSync.readdirSync(m.fullHostPath).sort();
+			} catch { return []; }
+		}
 		const normalized = normalizePath(dirPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "directory") {
@@ -508,6 +659,18 @@ class VirtualFileSystem extends EventEmitter {
 	/** Removes a file or directory node. */
 	public remove(targetPath: string, options: RemoveOptions = {}): void {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (m.readOnly) throw new Error(`EROFS: read-only file system, unlink '${m.fullHostPath}'`);
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: no such file or directory, unlink '${m.fullHostPath}'`);
+			const hst = fsSync.statSync(m.fullHostPath);
+			if (hst.isDirectory()) {
+				fsSync.rmSync(m.fullHostPath, { recursive: options.recursive ?? false });
+			} else {
+				fsSync.unlinkSync(m.fullHostPath);
+			}
+			return;
+		}
 		const normalized = normalizePath(targetPath);
 		if (normalized === "/") throw new Error("Cannot remove root directory.");
 		const node = getNode(this.root, normalized);