typescript-virtual-container 1.2.8 → 1.3.0

package/dist/commands/sh.js

@@ -1,14 +1,13 @@
-import { getArg, ifFlag } from "./command-helpers";
+import { expandAsync } from "../utils/expand";
+import { ifFlag } from "./command-helpers";
 import { resolvePath } from "./helpers";
-import { runCommand } from "./index";
-/** Expand $VAR and ${VAR:-default} in a line using the current env */
-function expandVars(line, env, lastExit) {
-    return line
-        .replace(/\$\?/g, String(lastExit))
-        .replace(/\$\{([^}:]+):-([^}]*)\}/g, (_, n, d) => env[n] ?? d)
-        .replace(/\$\{([^}]+)\}/g, (_, n) => env[n] ?? "")
-        .replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, n) => env[n] ?? "")
-        .replace(/^~(\/|$)/, `${env.HOME ?? "/home/user"}$1`);
+import { runCommand } from "./runtime";
+/**
+ * Expand all shell forms including $(cmd) substitution.
+ * Delegates to centralised expandAsync (single-quote-aware, depth-tracked).
+ */
+async function expandVars(line, env, lastExit, ctx) {
+    return expandAsync(line, env, lastExit, (sub) => runCommand(sub, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env).then((r) => r.stdout ?? ""));
 }
 /** Very small shell interpreter: supports if/elif/else/fi, for/do/done, while/do/done */
 function parseBlocks(lines) {
@@ -21,7 +20,10 @@ function parseBlocks(lines) {
             continue;
         }
         if (line.startsWith("if ") || line === "if") {
-            const cond = line.replace(/^if\s+/, "").replace(/;\s*then\s*$/, "").trim();
+            const cond = line
+                .replace(/^if\s+/, "")
+                .replace(/;\s*then\s*$/, "")
+                .trim();
             const thenLines = [];
             const elifBlocks = [];
             const elseLines = [];
@@ -32,7 +34,10 @@ function parseBlocks(lines) {
                 const l = lines[i].trim();
                 if (l.startsWith("elif ")) {
                     section = "elif";
-                    elifCond = l.replace(/^elif\s+/, "").replace(/;\s*then\s*$/, "").trim();
+                    elifCond = l
+                        .replace(/^elif\s+/, "")
+                        .replace(/;\s*then\s*$/, "")
+                        .trim();
                     elifBlocks.push({ cond: elifCond, body: [] });
                 }
                 else if (l === "else") {
@@ -48,8 +53,13 @@ function parseBlocks(lines) {
                 }
                 i++;
             }
-            // biome-ignore lint/suspicious/noThenProperty: expected behavior for if/elif parsing
-            blocks.push({ type: "if", cond, then: thenLines, elif: elifBlocks, else_: elseLines });
+            blocks.push({
+                type: "if",
+                cond,
+                then_: thenLines,
+                elif: elifBlocks,
+                else_: elseLines,
+            });
         }
         else if (line.startsWith("for ")) {
             const m = line.match(/^for\s+(\w+)\s+in\s+(.+?)(?:\s*;\s*do)?$/);
@@ -57,8 +67,8 @@ function parseBlocks(lines) {
                 const body = [];
                 i++;
                 while (i < lines.length && lines[i]?.trim() !== "done") {
-                    const l = lines[i].trim();
-                    if (l !== "do")
+                    const l = lines[i].trim().replace(/^do\s+/, "");
+                    if (l && l !== "do")
                         body.push(l);
                     i++;
                 }
@@ -69,12 +79,15 @@ function parseBlocks(lines) {
             }
         }
         else if (line.startsWith("while ")) {
-            const cond = line.replace(/^while\s+/, "").replace(/;\s*do\s*$/, "").trim();
+            const cond = line
+                .replace(/^while\s+/, "")
+                .replace(/;\s*do\s*$/, "")
+                .trim();
             const body = [];
             i++;
             while (i < lines.length && lines[i]?.trim() !== "done") {
-                const l = lines[i].trim();
-                if (l !== "do")
+                const l = lines[i].trim().replace(/^do\s+/, "");
+                if (l && l !== "do")
                     body.push(l);
                 i++;
             }
@@ -88,7 +101,7 @@ function parseBlocks(lines) {
     return blocks;
 }
 async function evalCondition(cond, ctx) {
-    const expanded = expandVars(cond, ctx.env.vars, ctx.env.lastExitCode);
+    const expanded = await expandVars(cond, ctx.env.vars, ctx.env.lastExitCode, ctx);
     // test -f / test -d / [ ... ]
     const testMatch = expanded.match(/^\[?\s*(.+?)\s*\]?$/);
     if (testMatch) {
@@ -101,7 +114,7 @@ async function evalCondition(cond, ctx) {
             if (flag === "f")
                 return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "file";
             if (flag === "d")
-                return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "directory";
+                return (ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "directory");
             if (flag === "e")
                 return ctx.shell.vfs.exists(p);
             if (flag === "z")
@@ -146,7 +159,21 @@ async function runBlocks(blocks, ctx) {
     let output = "";
     for (const block of blocks) {
         if (block.type === "cmd") {
-            const expanded = expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode);
+            const expanded = await expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode, ctx);
+            // Bare VAR=val assignment(s) — handle before dispatching to runCommand
+            const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)/;
+            const tokens = expanded.trim().split(/\s+/);
+            if (tokens.length > 0 && assignRe.test(tokens[0])) {
+                const allAssign = tokens.every((t) => assignRe.test(t));
+                if (allAssign) {
+                    for (const tok of tokens) {
+                        const m = tok.match(assignRe);
+                        ctx.env.vars[m[1]] = m[2];
+                    }
+                    ctx.env.lastExitCode = 0;
+                    continue;
+                }
+            }
             const r = await runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
             ctx.env.lastExitCode = r.exitCode ?? 0;
             if (r.stdout)
@@ -158,7 +185,7 @@ async function runBlocks(blocks, ctx) {
         else if (block.type === "if") {
             let ran = false;
             if (await evalCondition(block.cond, ctx)) {
-                const sub = await runBlocks(parseBlocks(block.then), ctx);
+                const sub = await runBlocks(parseBlocks(block.then_), ctx);
                 if (sub.stdout)
                     output += `${sub.stdout}\n`;
                 ran = true;
@@ -181,7 +208,7 @@ async function runBlocks(blocks, ctx) {
             }
         }
         else if (block.type === "for") {
-            const listExpanded = expandVars(block.list, ctx.env.vars, ctx.env.lastExitCode);
+            const listExpanded = await expandVars(block.list, ctx.env.vars, ctx.env.lastExitCode, ctx);
             const items = listExpanded.trim().split(/\s+/);
             for (const item of items) {
                 ctx.env.vars[block.var] = item;
@@ -194,7 +221,7 @@ async function runBlocks(blocks, ctx) {
         }
         else if (block.type === "while") {
             let iterations = 0;
-            while (iterations < 1000 && await evalCondition(block.cond, ctx)) {
+            while (iterations < 1000 && (await evalCondition(block.cond, ctx))) {
                 const sub = await runBlocks(parseBlocks(block.body), ctx);
                 if (sub.stdout)
                     output += `${sub.stdout}\n`;
@@ -216,10 +243,13 @@ export const shCommand = {
         const { args, shell, cwd } = ctx;
         // sh -c "inline script"
         if (ifFlag(args, "-c")) {
-            const script = getArg(args, 1) ?? "";
+            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 = script
+                .split(/[;\n]/)
+                .map((l) => l.trim())
+                .filter((l) => l && !l.startsWith("#"));
             const blocks = parseBlocks(lines);
             return runBlocks(blocks, ctx);
         }
@@ -228,12 +258,21 @@ export const shCommand = {
         if (fileArg) {
             const p = resolvePath(cwd, fileArg);
             if (!shell.vfs.exists(p))
-                return { stderr: `sh: ${fileArg}: No such file or directory`, exitCode: 1 };
+                return {
+                    stderr: `sh: ${fileArg}: No such file or directory`,
+                    exitCode: 1,
+                };
             const content = shell.vfs.readFile(p);
-            const lines = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+            const lines = content
+                .split("\n")
+                .map((l) => l.trim())
+                .filter((l) => l && !l.startsWith("#"));
             const blocks = parseBlocks(lines);
             return runBlocks(blocks, ctx);
         }
-        return { stderr: "sh: invalid usage. Use: sh -c 'cmd' or sh <file>", exitCode: 1 };
+        return {
+            stderr: "sh: invalid usage. Use: sh -c 'cmd' or sh <file>",
+            exitCode: 1,
+        };
     },
 };

package/dist/commands/shift.d.ts

@@ -0,0 +1,5 @@
+import type { ShellModule } from "../types/commands";
+export declare const shiftCommand: ShellModule;
+export declare const trapCommand: ShellModule;
+export declare const returnCommand: ShellModule;
+//# sourceMappingURL=shift.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shift.d.ts","sourceRoot":"","sources":["../../src/commands/shift.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,YAAY,EAAE,WAoB1B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAezB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,WAW3B,CAAC"}

package/dist/commands/shift.js

@@ -0,0 +1,52 @@
+export const shiftCommand = {
+    name: "shift",
+    description: "Shift positional parameters",
+    category: "shell",
+    params: ["[n]"],
+    // shift is meaningful only inside sh scripts where positional params exist.
+    // In the current impl, positional params ($1 $2 …) aren't tracked in env by default.
+    // We store them under env.vars.__argv and shift there if present.
+    run: ({ args, env }) => {
+        if (!env)
+            return { exitCode: 0 };
+        const n = parseInt(args[0] ?? "1", 10) || 1;
+        const argv = env.vars.__argv?.split("\x00").filter(Boolean) ?? [];
+        env.vars.__argv = argv.slice(n).join("\x00");
+        // Update $1 $2 … in env
+        const shifted = argv.slice(n);
+        for (let i = 1; i <= 9; i++) {
+            env.vars[String(i)] = shifted[i - 1] ?? "";
+        }
+        return { exitCode: 0 };
+    },
+};
+export const trapCommand = {
+    name: "trap",
+    description: "Trap signals and events",
+    category: "shell",
+    params: ["[action] [signal...]"],
+    // Store trap handlers in env for EXIT signal support
+    run: ({ args, env }) => {
+        if (!env || args.length === 0)
+            return { exitCode: 0 };
+        const action = args[0] ?? "";
+        const signals = args.slice(1);
+        for (const sig of signals) {
+            env.vars[`__trap_${sig.toUpperCase()}`] = action;
+        }
+        return { exitCode: 0 };
+    },
+};
+export const returnCommand = {
+    name: "return",
+    description: "Return from a shell function",
+    category: "shell",
+    params: ["[n]"],
+    run: ({ args, env }) => {
+        const code = parseInt(args[0] ?? "0", 10);
+        if (env)
+            env.lastExitCode = code;
+        // Signal the caller via exitCode; function return is handled by runBlocks
+        return { exitCode: code };
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/commands/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,YAAY,EAAE,WAW1B,CAAC"}
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/commands/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,YAAY,EAAE,WAY1B,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/commands/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WAgCzB,CAAC"}
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/commands/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WAoCzB,CAAC"}

package/dist/commands/sort.js

@@ -12,7 +12,8 @@ export const sortCommand = {
         const files = args.filter((a) => !a.startsWith("-"));
         const getContent = () => {
             if (files.length > 0) {
-                return files.map((f) => {
+                return files
+                    .map((f) => {
                     try {
                         assertPathAccess(authUser, resolvePath(cwd, f), "sort");
                         return shell.vfs.readFile(resolvePath(cwd, f));
@@ -20,7 +21,8 @@ export const sortCommand = {
                     catch {
                         return "";
                     }
-                }).join("\n");
+                })
+                    .join("\n");
             }
             return stdin ?? "";
         };

package/dist/commands/source.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const sourceCommand: ShellModule;
+//# sourceMappingURL=source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/commands/source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,aAAa,EAAE,WA0C3B,CAAC"}

package/dist/commands/source.js

@@ -0,0 +1,34 @@
+import { resolvePath } from "./helpers";
+import { runCommand } from "./runtime";
+export const sourceCommand = {
+    name: "source",
+    aliases: ["."],
+    description: "Execute commands from a file in the current shell environment",
+    category: "shell",
+    params: ["<file> [args...]"],
+    run: async ({ args, authUser, hostname, cwd, shell, env }) => {
+        const fileArg = args[0];
+        if (!fileArg) {
+            return { stderr: "source: missing filename", exitCode: 1 };
+        }
+        const filePath = resolvePath(cwd, fileArg);
+        if (!shell.vfs.exists(filePath)) {
+            return {
+                stderr: `source: ${fileArg}: No such file or directory`,
+                exitCode: 1,
+            };
+        }
+        const content = shell.vfs.readFile(filePath);
+        let lastExitCode = 0;
+        for (const line of content.split("\n")) {
+            const l = line.trim();
+            if (!l || l.startsWith("#"))
+                continue;
+            const result = await runCommand(l, authUser, hostname, "shell", cwd, shell, undefined, env);
+            lastExitCode = result.exitCode ?? 0;
+            if (result.closeSession || result.switchUser)
+                return result;
+        }
+        return { exitCode: lastExitCode };
+    },
+};

package/dist/commands/sudo.js

@@ -1,5 +1,5 @@
 import { parseArgs } from "./command-helpers";
-import { runCommand } from "./index";
+import { runCommand } from "./runtime";
 function parseSudoArgs(args) {
     const { flags, flagsWithValues, positionals } = parseArgs(args, {
         flags: ["-i", "-S"],

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

@@ -1 +1 @@
-{"version":3,"file":"tar.d.ts","sourceRoot":"","sources":["../../src/commands/tar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WAqDxB,CAAC"}
+{"version":3,"file":"tar.d.ts","sourceRoot":"","sources":["../../src/commands/tar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WA0ExB,CAAC"}

package/dist/commands/tar.js

@@ -10,7 +10,9 @@ export const tarCommand = {
         const extract = ifFlag(args, ["-x"]);
         const list = ifFlag(args, ["-t"]);
         const fFlag = args.findIndex((a) => a.includes("f"));
-        const archiveName = fFlag !== -1 ? args[fFlag + 1] : args.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
+        const archiveName = fFlag !== -1
+            ? args[fFlag + 1]
+            : args.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
         if (!archiveName)
             return { stderr: "tar: no archive specified", exitCode: 1 };
         const archivePath = resolvePath(cwd, archiveName);
@@ -38,7 +40,10 @@ export const tarCommand = {
                     }
                 }
                 catch {
-                    return { stderr: `tar: ${f}: No such file or directory`, exitCode: 1 };
+                    return {
+                        stderr: `tar: ${f}: No such file or directory`,
+                        exitCode: 1,
+                    };
                 }
             }
             shell.writeFileAsUser(authUser, archivePath, JSON.stringify(entries));
@@ -50,7 +55,10 @@ export const tarCommand = {
                 entries = JSON.parse(shell.vfs.readFile(archivePath));
             }
             catch {
-                return { stderr: `tar: ${archiveName}: cannot open archive`, exitCode: 1 };
+                return {
+                    stderr: `tar: ${archiveName}: cannot open archive`,
+                    exitCode: 1,
+                };
             }
             if (list)
                 return { stdout: Object.keys(entries).join("\n"), exitCode: 0 };

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

@@ -1 +1 @@
-{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../src/commands/tee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WAoBxB,CAAC"}
+{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../src/commands/tee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WA0BxB,CAAC"}

package/dist/commands/tee.js

@@ -12,12 +12,14 @@ export const teeCommand = {
         for (const f of files) {
             const p = resolvePath(cwd, f);
             if (append) {
-                const existing = (() => { try {
-                    return shell.vfs.readFile(p);
-                }
-                catch {
-                    return "";
-                } })();
+                const existing = (() => {
+                    try {
+                        return shell.vfs.readFile(p);
+                    }
+                    catch {
+                        return "";
+                    }
+                })();
                 shell.writeFileAsUser(authUser, p, existing + input);
             }
             else {

package/dist/commands/test.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const testCommand: ShellModule;
+//# sourceMappingURL=test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/commands/test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAwHrD,eAAO,MAAM,WAAW,EAAE,WAczB,CAAC"}

package/dist/commands/test.js

@@ -0,0 +1,114 @@
+/**
+ * Evaluate a POSIX test expression.
+ * Supports: -f, -d, -e, -r, -w, -x, -s, -z, -n,
+ *           string =, !=, numeric -eq -ne -lt -le -gt -ge,
+ *           ! (negate), -a (and), -o (or).
+ */
+function evalTest(tokens, shell, cwd) {
+    // When called via [ command, ] is the last arg — strip it
+    // When called via test command, no brackets present
+    if (tokens[tokens.length - 1] === "]") {
+        tokens = tokens.slice(0, -1);
+    }
+    // Also strip leading [ if present (shouldn't normally happen but be safe)
+    if (tokens[0] === "[") {
+        tokens = tokens.slice(1);
+    }
+    if (tokens.length === 0)
+        return false;
+    // Negation
+    if (tokens[0] === "!")
+        return !evalTest(tokens.slice(1), shell, cwd);
+    // Boolean -a / -o (simple left-right, no precedence)
+    const andIdx = tokens.indexOf("-a");
+    if (andIdx !== -1) {
+        return (evalTest(tokens.slice(0, andIdx), shell, cwd) &&
+            evalTest(tokens.slice(andIdx + 1), shell, cwd));
+    }
+    const orIdx = tokens.indexOf("-o");
+    if (orIdx !== -1) {
+        return (evalTest(tokens.slice(0, orIdx), shell, cwd) ||
+            evalTest(tokens.slice(orIdx + 1), shell, cwd));
+    }
+    // Unary file tests
+    if (tokens.length === 2) {
+        const [flag, operand = ""] = tokens;
+        const resolvePath = (p) => p.startsWith("/") ? p : `${cwd}/${p}`.replace(/\/+/g, "/");
+        const path = resolvePath(operand);
+        switch (flag) {
+            case "-e":
+                return shell.vfs.exists(path);
+            case "-f":
+                return shell.vfs.exists(path) && shell.vfs.stat(path).type === "file";
+            case "-d":
+                return (shell.vfs.exists(path) && shell.vfs.stat(path).type === "directory");
+            case "-r":
+                return shell.vfs.exists(path); // all readable in virtual env
+            case "-w":
+                return shell.vfs.exists(path);
+            case "-x":
+                return shell.vfs.exists(path) && !!(shell.vfs.stat(path).mode & 0o111);
+            case "-s":
+                return (shell.vfs.exists(path) &&
+                    shell.vfs.stat(path).type === "file" &&
+                    shell.vfs.stat(path).size > 0);
+            case "-z":
+                return operand.length === 0;
+            case "-n":
+                return operand.length > 0;
+            case "-L":
+                return shell.vfs.isSymlink(path);
+        }
+    }
+    // Binary comparisons
+    if (tokens.length === 3) {
+        const [left = "", op, right = ""] = tokens;
+        const leftN = Number(left);
+        const rightN = Number(right);
+        switch (op) {
+            // String
+            case "=":
+            case "==":
+                return left === right;
+            case "!=":
+                return left !== right;
+            case "<":
+                return left < right;
+            case ">":
+                return left > right;
+            // Numeric
+            case "-eq":
+                return leftN === rightN;
+            case "-ne":
+                return leftN !== rightN;
+            case "-lt":
+                return leftN < rightN;
+            case "-le":
+                return leftN <= rightN;
+            case "-gt":
+                return leftN > rightN;
+            case "-ge":
+                return leftN >= rightN;
+        }
+    }
+    // Single string (truthy if non-empty)
+    if (tokens.length === 1)
+        return (tokens[0] ?? "").length > 0;
+    return false;
+}
+export const testCommand = {
+    name: "test",
+    aliases: ["["],
+    description: "Evaluate conditional expression",
+    category: "shell",
+    params: ["<expression>"],
+    run: ({ args, shell, cwd }) => {
+        try {
+            const result = evalTest([...args], shell, cwd);
+            return { exitCode: result ? 0 : 1 };
+        }
+        catch {
+            return { stderr: "test: malformed expression", exitCode: 2 };
+        }
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../src/commands/tr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,SAAS,EAAE,WAoBvB,CAAC"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../src/commands/tr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,SAAS,EAAE,WAsBvB,CAAC"}

package/dist/commands/tr.js

@@ -16,7 +16,9 @@ export const trCommand = {
         }
         else if (set2) {
             for (let i = 0; i < set1.length; i++) {
-                input = input.split(set1[i]).join(set2[i] ?? set2[set2.length - 1] ?? "");
+                input = input
+                    .split(set1[i])
+                    .join(set2[i] ?? set2[set2.length - 1] ?? "");
             }
         }
         return { stdout: input, exitCode: 0 };

package/dist/commands/true.d.ts

@@ -0,0 +1,4 @@
+import type { ShellModule } from "../types/commands";
+export declare const trueCommand: ShellModule;
+export declare const falseCommand: ShellModule;
+//# sourceMappingURL=true.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"true.d.ts","sourceRoot":"","sources":["../../src/commands/true.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,WAAW,EAAE,WAMzB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,WAM1B,CAAC"}

package/dist/commands/true.js

@@ -0,0 +1,14 @@
+export const trueCommand = {
+    name: "true",
+    description: "Return success exit code",
+    category: "shell",
+    params: [],
+    run: () => ({ exitCode: 0 }),
+};
+export const falseCommand = {
+    name: "false",
+    description: "Return failure exit code",
+    category: "shell",
+    params: [],
+    run: () => ({ exitCode: 1 }),
+};

package/dist/commands/type.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const typeCommand: ShellModule;
+//# sourceMappingURL=type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../src/commands/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WAuCzB,CAAC"}

package/dist/commands/type.js

@@ -0,0 +1,34 @@
+import { resolveModule } from "./registry";
+export const typeCommand = {
+    name: "type",
+    description: "Describe how a command would be interpreted",
+    category: "shell",
+    params: ["<command...>"],
+    run: ({ args, shell, env }) => {
+        if (args.length === 0)
+            return { stderr: "type: missing argument", exitCode: 1 };
+        const pathDirs = (env?.vars?.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+        const lines = [];
+        let exitCode = 0;
+        for (const name of args) {
+            if (resolveModule(name)) {
+                lines.push(`${name} is a shell builtin`);
+                continue;
+            }
+            let found = false;
+            for (const dir of pathDirs) {
+                const full = `${dir}/${name}`;
+                if (shell.vfs.exists(full)) {
+                    lines.push(`${name} is ${full}`);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                lines.push(`${name}: not found`);
+                exitCode = 1;
+            }
+        }
+        return { stdout: lines.join("\n"), exitCode };
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"uname.d.ts","sourceRoot":"","sources":["../../src/commands/uname.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,YAAY,EAAE,WAgB1B,CAAC"}
+{"version":3,"file":"uname.d.ts","sourceRoot":"","sources":["../../src/commands/uname.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,YAAY,EAAE,WAoB1B,CAAC"}

package/dist/commands/uname.js

@@ -11,7 +11,10 @@ export const unameCommand = {
         const machine = shell.properties?.arch ?? "x86_64";
         const hostname = shell.hostname;
         if (all)
-            return { stdout: `${sysname} ${hostname} ${release} #1 SMP ${machine} GNU/Linux`, exitCode: 0 };
+            return {
+                stdout: `${sysname} ${hostname} ${release} #1 SMP ${machine} GNU/Linux`,
+                exitCode: 0,
+            };
         if (ifFlag(args, ["-r"]))
             return { stdout: release, exitCode: 0 };
         if (ifFlag(args, ["-m"]))

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

@@ -1 +1 @@
-{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../src/commands/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WAwBzB,CAAC"}
+{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../src/commands/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WA8BzB,CAAC"}

package/dist/commands/uptime.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const uptimeCommand: ShellModule;
+//# sourceMappingURL=uptime.d.ts.map