typescript-virtual-container 1.4.1 → 1.4.3

package/dist/commands/seq.d.ts

@@ -0,0 +1,4 @@
+import type { ShellModule } from "../types/commands";
+/** Generate sequences of numbers. seq LAST / seq FIRST LAST / seq FIRST INCREMENT LAST */
+export declare const seqCommand: ShellModule;
+//# sourceMappingURL=seq.d.ts.map

package/dist/commands/seq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seq.d.ts","sourceRoot":"","sources":["../../src/commands/seq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,0FAA0F;AAC1F,eAAO,MAAM,UAAU,EAAE,WAuCxB,CAAC"}

package/dist/commands/seq.js

@@ -0,0 +1,50 @@
+/** Generate sequences of numbers. seq LAST / seq FIRST LAST / seq FIRST INCREMENT LAST */
+export const seqCommand = {
+    name: "seq",
+    description: "Print a sequence of numbers",
+    category: "text",
+    params: ["[FIRST [INCREMENT]] LAST"],
+    run: ({ args }) => {
+        const nums = args.filter((a) => !a.startsWith("-") || /^-[\d.]/.test(a)).map(Number);
+        const sep = (() => { const i = args.indexOf("-s"); return i !== -1 ? (args[i + 1] ?? "\n") : "\n"; })();
+        const fmt = (() => { const i = args.indexOf("-f"); return i !== -1 ? (args[i + 1] ?? "%g") : null; })();
+        const width = args.includes("-w");
+        let first = 1, inc = 1, last;
+        if (nums.length === 1) {
+            last = nums[0];
+        }
+        else if (nums.length === 2) {
+            first = nums[0];
+            last = nums[1];
+        }
+        else {
+            first = nums[0];
+            inc = nums[1];
+            last = nums[2];
+        }
+        if (inc === 0)
+            return { stderr: "seq: zero increment\n", exitCode: 1 };
+        if ((inc > 0 && first > last) || (inc < 0 && first < last))
+            return { stdout: "", exitCode: 0 };
+        const results = [];
+        const maxSteps = 100000;
+        let steps = 0;
+        for (let n = first; inc > 0 ? n <= last : n >= last; n = Math.round((n + inc) * 1e10) / 1e10) {
+            if (++steps > maxSteps)
+                break;
+            let s;
+            if (fmt) {
+                s = fmt.replace("%g", String(n)).replace("%f", n.toFixed(6)).replace("%d", String(Math.trunc(n)));
+            }
+            else {
+                s = Number.isInteger(n) ? String(n) : n.toPrecision(12).replace(/\.?0+$/, "");
+            }
+            if (width) {
+                const maxLen = String(Math.trunc(last)).length;
+                s = s.padStart(maxLen, "0");
+            }
+            results.push(s);
+        }
+        return { stdout: `${results.join(sep)}\n`, exitCode: 0 };
+    },
+};

package/dist/commands/sh.d.ts

@@ -1,9 +1,3 @@
 import type { ShellModule } from "../types/commands";
-/**
- * Execute shell scripts or commands with a minimal shell interpreter.
- * Supports if/elif/else, for loops, while loops, and variable expansion.
- * @category shell
- * @params ["-c <script>", "[<file>]"]
- */
 export declare const shCommand: ShellModule;
 //# sourceMappingURL=sh.d.ts.map

package/dist/commands/sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGX,WAAW,EACX,MAAM,mBAAmB,CAAC;AA4R3B;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,WA4CvB,CAAC"}
+{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGX,WAAW,EACX,MAAM,mBAAmB,CAAC;AAqa3B,eAAO,MAAM,SAAS,EAAE,WAsCvB,CAAC"}

package/dist/commands/sh.js

@@ -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/modules/linuxRootfs.d.ts

@@ -6,8 +6,8 @@
  * Called once during VirtualShell initialization. Idempotent — skips
  * paths that already exist so FS-mode snapshots survive restarts.
  */
-import type { ShellProperties } from "../VirtualShell";
 import type VirtualFileSystem from "../VirtualFileSystem";
+import type { ShellProperties } from "../VirtualShell";
 import type { VirtualUserManager } from "../VirtualUserManager";
 /**
  * Sync `/etc/passwd`, `/etc/group`, and `/etc/shadow` from the

package/dist/modules/linuxRootfs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linuxRootfs.d.ts","sourceRoot":"","sources":["../../src/modules/linuxRootfs.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,iBAAiB,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAgHhE;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,kBAAkB,GACvB,IAAI,CAsCN;AAgED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAC1B,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,OAAO,uBAAuB,EAAE,oBAAoB,EAAE,GAC/D,IAAI,CAmJN;AAuND;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CACnC,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,kBAAkB,EACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,EACtB,cAAc,EAAE,MAAM,GACpB,IAAI,CAYN"}
+{"version":3,"file":"linuxRootfs.d.ts","sourceRoot":"","sources":["../../src/modules/linuxRootfs.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE;;;;;;GAMG;AAGH,OAAO,KAAK,iBAAiB,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAgHhE;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,kBAAkB,GACvB,IAAI,CAsCN;AAgED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAC1B,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,OAAO,uBAAuB,EAAE,oBAAoB,EAAE,GAC/D,IAAI,CAmJN;AAuND;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CACnC,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,kBAAkB,EACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,EACtB,cAAc,EAAE,MAAM,GACpB,IAAI,CAYN"}

package/dist/modules/linuxRootfs.js

@@ -394,18 +394,18 @@ function bootstrapTmp(vfs) {
 // ─── /root ────────────────────────────────────────────────────────────────────
 function bootstrapRoot(vfs) {
     ensureDir(vfs, "/root", 0o700);
-    ensureFile(vfs, "/root/.bashrc", `${[
+    ensureFile(vfs, "/home/root/.bashrc", `${[
         "# root .bashrc",
         "export PS1='\\[\\033[0;31m\\]\\u@\\h\\[\\033[0m\\]:\\[\\033[0;34m\\]\\w\\[\\033[0m\\]# '",
         "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
         "alias ll='ls -la'",
         "alias la='ls -A'",
     ].join("\n")}\n`);
-    ensureFile(vfs, "/root/.profile", "[ -f ~/.bashrc ] && . ~/.bashrc\n");
+    ensureFile(vfs, "/home/root/.profile", "[ -f ~/.bashrc ] && . ~/.bashrc\n");
     // Fix: /home/root should map to /root for root user
-    if (!vfs.exists("/home/root")) {
-        vfs.symlink("/root", "/home/root");
-    }
+    // if (!vfs.exists("/home/root")) {
+    // 	vfs.symlink("/root", "/home/root");
+    // }
 }
 // ─── /opt + /srv + /mnt + /media ─────────────────────────────────────────────
 function bootstrapMisc(vfs) {