typescript-virtual-container 1.5.3 → 1.5.5

package/dist/commands/registry.js

@@ -3,6 +3,8 @@ import { aliasCommand, unaliasCommand } from "./alias";
 import { aptCacheCommand, aptCommand } from "./apt";
 import { awkCommand } from "./awk";
 import { base64Command } from "./base64";
+import { basenameCommand, dirnameCommand } from "./basename";
+import { bcCommand } from "./bc";
 import { catCommand } from "./cat";
 import { cdCommand } from "./cd";
 import { chmodCommand } from "./chmod";
@@ -21,8 +23,10 @@ import { echoCommand } from "./echo";
 import { envCommand } from "./env";
 import { exitCommand } from "./exit";
 import { exportCommand } from "./export";
+import { fileCommand } from "./file";
 import { findCommand } from "./find";
 import { freeCommand } from "./free";
+import { cmatrixCommand, cowsayCommand, cowthinkCommand, fortuneCommand, slCommand, yesCommand } from "./fun";
 import { grepCommand } from "./grep";
 import { groupsCommand } from "./groups";
 import { gunzipCommand, gzipCommand } from "./gzip";
@@ -32,10 +36,11 @@ import { historyCommand } from "./history";
 import { hostnameCommand } from "./hostname";
 import { htopCommand } from "./htop";
 import { idCommand } from "./id";
+import { ipCommand } from "./ip";
+import { bgCommand, fgCommand, jobsCommand } from "./jobs";
 import { killCommand } from "./kill";
+import { dmesgCommand, lastCommand } from "./last";
 import { lnCommand, readlinkCommand } from "./ln";
-import { seqCommand } from "./seq";
-import { statCommand } from "./stat";
 import { lsCommand } from "./ls";
 import { lsbReleaseCommand } from "./lsb-release";
 import { manCommand } from "./man";
@@ -54,12 +59,14 @@ import { python3Command } from "./python";
 import { readCommand } from "./read";
 import { rmCommand } from "./rm";
 import { sedCommand } from "./sed";
+import { seqCommand } from "./seq";
 import { setCommand } from "./set";
 import { shCommand } from "./sh";
 import { returnCommand, shiftCommand, trapCommand } from "./shift";
 import { sleepCommand } from "./sleep";
 import { sortCommand } from "./sort";
 import { sourceCommand } from "./source";
+import { statCommand } from "./stat";
 import { suCommand } from "./su";
 import { sudoCommand } from "./sudo";
 import { tailCommand } from "./tail";
@@ -67,6 +74,7 @@ import { tarCommand } from "./tar";
 import { teeCommand } from "./tee";
 import { testCommand } from "./test";
 import { touchCommand } from "./touch";
+import { sttyCommand, tputCommand } from "./tput";
 import { trCommand } from "./tr";
 import { treeCommand } from "./tree";
 import { falseCommand, trueCommand } from "./true";
@@ -75,6 +83,7 @@ import { unameCommand } from "./uname";
 import { uniqCommand } from "./uniq";
 import { unsetCommand } from "./unset";
 import { uptimeCommand } from "./uptime";
+import { wCommand } from "./w";
 import { wcCommand } from "./wc";
 import { wgetCommand } from "./wget";
 import { whichCommand } from "./which";
@@ -144,6 +153,21 @@ const BASE_COMMANDS = [
     exitCommand,
     // Editors
     nanoCommand,
+    wCommand,
+    basenameCommand,
+    dirnameCommand,
+    fileCommand,
+    tputCommand,
+    sttyCommand,
+    lastCommand,
+    dmesgCommand,
+    ipCommand,
+    yesCommand,
+    fortuneCommand,
+    cowsayCommand,
+    cowthinkCommand,
+    cmatrixCommand,
+    slCommand,
     htopCommand,
     // Network
     curlCommand,
@@ -162,6 +186,10 @@ const BASE_COMMANDS = [
     dpkgCommand,
     dpkgQueryCommand,
     // Shell (extended)
+    jobsCommand,
+    bgCommand,
+    fgCommand,
+    bcCommand,
     whichCommand,
     typeCommand,
     manCommand,

package/dist/commands/runtime.js

@@ -1,7 +1,7 @@
 /** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
 import { executeStatements } from "../SSHMimic/executor";
 import { parseScript } from "../VirtualShell/shellParser";
-import { expandAsync, expandBraces } from "../utils/expand";
+import { expandAsync, expandBraces, expandGlob } from "../utils/expand";
 import { tokenizeCommand } from "../utils/tokenize";
 import { resolveModule } from "./registry";
 /** Returns the home directory path for a given user. Root lives at /root. */
@@ -15,10 +15,11 @@ export function makeDefaultEnv(authUser, hostname) {
             HOME: userHome(authUser),
             USER: authUser,
             LOGNAME: authUser,
-            SHELL: "/bin/sh",
+            SHELL: "/bin/bash",
             TERM: "xterm-256color",
             HOSTNAME: hostname,
             PS1: "\\u@\\h:\\w\\$ ",
+            "0": "/bin/bash",
         },
         lastExitCode: 0,
     };
@@ -192,6 +193,26 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
         return { stderr: `${trimmed.split(" ")[0]}: maximum call depth (${MAX_CALL_DEPTH}) exceeded`, exitCode: 126 };
     }
     try {
+        // History expansion: !! and !n
+        if (trimmed === '!!' || /^!-?\d+$/.test(trimmed) || trimmed.startsWith('!! ')) {
+            const histPath = `${shellEnv.vars.HOME ?? `/home/${authUser}`}/.bash_history`;
+            if (shell.vfs.exists(histPath)) {
+                const lines = shell.vfs.readFile(histPath).split('\n').filter(Boolean);
+                let cmd;
+                if (trimmed === '!!' || trimmed.startsWith('!! ')) {
+                    cmd = lines[lines.length - 1];
+                }
+                else {
+                    const n = parseInt(trimmed.slice(1), 10);
+                    cmd = n > 0 ? lines[n - 1] : lines[lines.length + n];
+                }
+                if (cmd) {
+                    const suffix = trimmed.startsWith('!! ') ? trimmed.slice(3) : '';
+                    return runCommand(`${cmd}${suffix ? ` ${suffix}` : ''}`, authUser, hostname, mode, cwd, shell, stdin, shellEnv);
+                }
+            }
+            return { stderr: `${trimmed}: event not found`, exitCode: 1 };
+        }
         const rawTokens = tokenizeCommand(trimmed);
         const rawFirstWord = rawTokens[0]?.toLowerCase() ?? "";
         const aliasVal = shellEnv.vars[`__alias_${rawFirstWord}`];
@@ -252,7 +273,7 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
         }
         const commandName = parts[0]?.toLowerCase() ?? "";
         // Apply brace expansion to each arg token
-        const args = parts.slice(1).flatMap(expandBraces);
+        const args = parts.slice(1).flatMap(expandBraces).flatMap(token => expandGlob(token, cwd, shell.vfs));
         const mod = resolveModule(commandName);
         if (!mod) {
             const vfsBinary = resolveVfsBinary(commandName, shellEnv, shell, authUser);

package/dist/commands/set.js

@@ -11,11 +11,31 @@ export const setCommand = {
     run: ({ args, env }) => {
         if (args.length === 0) {
             const out = Object.entries(env.vars)
+                .filter(([k]) => !k.startsWith("__"))
                 .map(([k, v]) => `${k}=${v}`)
                 .join("\n");
             return { stdout: out, exitCode: 0 };
         }
         for (const arg of args) {
+            const flagMatch = arg.match(/^([+-])([a-zA-Z]+)$/);
+            if (flagMatch) {
+                const on = flagMatch[1] === "-";
+                for (const flag of flagMatch[2]) {
+                    if (flag === "e") {
+                        if (on)
+                            env.vars.__errexit = "1";
+                        else
+                            delete env.vars.__errexit;
+                    }
+                    if (flag === "x") {
+                        if (on)
+                            env.vars.__xtrace = "1";
+                        else
+                            delete env.vars.__xtrace;
+                    }
+                }
+                continue;
+            }
             if (arg.includes("=")) {
                 const eq = arg.indexOf("=");
                 env.vars[arg.slice(0, eq)] = arg.slice(eq + 1);

package/dist/commands/sh.js

@@ -125,6 +125,43 @@ function parseBlocks(lines) {
             }
             blocks.push({ type: "while", cond, body });
         }
+        else if (line.startsWith("case ") && line.endsWith(" in") || line.match(/^case\s+.+\s+in$/)) {
+            const caseExpr = line.replace(/^case\s+/, "").replace(/\s+in$/, "").trim();
+            const patterns = [];
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "esac") {
+                const pl = lines[i].trim();
+                if (!pl || pl === "esac") {
+                    i++;
+                    continue;
+                }
+                // pattern) or pattern1|pattern2)
+                const patMatch = pl.match(/^(.+?)\)\s*(.*)$/);
+                if (patMatch) {
+                    const pat = patMatch[1].trim();
+                    const body = [];
+                    if (patMatch[2]?.trim() && patMatch[2].trim() !== ";;") {
+                        body.push(patMatch[2].trim());
+                    }
+                    i++;
+                    while (i < lines.length) {
+                        const bl = lines[i].trim();
+                        if (bl === ";;" || bl === "esac")
+                            break;
+                        if (bl)
+                            body.push(bl);
+                        i++;
+                    }
+                    if (lines[i]?.trim() === ";;")
+                        i++; // skip ;;
+                    patterns.push({ pattern: pat, body });
+                }
+                else {
+                    i++;
+                }
+            }
+            blocks.push({ type: "case", expr: caseExpr, patterns });
+        }
         else {
             blocks.push({ type: "cmd", line });
         }
@@ -189,9 +226,12 @@ async function evalCondition(cond, ctx) {
 async function runBlocks(blocks, ctx) {
     let lastResult = { exitCode: 0 };
     let output = "";
+    let traceOutput = "";
     for (const block of blocks) {
         if (block.type === "cmd") {
             const expanded = await expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode, ctx);
+            if (ctx.env.vars.__xtrace)
+                traceOutput += `+ ${expanded}\n`;
             // 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+/);
@@ -231,6 +271,8 @@ async function runBlocks(blocks, ctx) {
                 output += `${r.stdout}\n`;
             if (r.stderr)
                 return { ...r, stdout: output.trim() };
+            if (ctx.env.vars.__errexit && (r.exitCode ?? 0) !== 0)
+                return { ...r, stdout: output.trim() };
             lastResult = r;
         }
         else if (block.type === "if") {
@@ -311,8 +353,34 @@ async function runBlocks(blocks, ctx) {
                 iterations++;
             }
         }
+        else if (block.type === "case") {
+            const expanded = await expandVars(block.expr, ctx.env.vars, ctx.env.lastExitCode, ctx);
+            for (const pat of block.patterns) {
+                const alts = pat.pattern.split("|").map((p) => p.trim());
+                const matched = alts.some((p) => {
+                    if (p === "*")
+                        return true;
+                    if (p.includes("*") || p.includes("?")) {
+                        const re = new RegExp(`^${p.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+                        return re.test(expanded);
+                    }
+                    return p === expanded;
+                });
+                if (matched) {
+                    const sub = await runBlocks(parseBlocks(pat.body), ctx);
+                    if (sub.stdout)
+                        output += `${sub.stdout}\n`;
+                    break;
+                }
+            }
+        }
     }
-    return { ...lastResult, stdout: output.trim() || lastResult.stdout };
+    const finalStdout = output.trim() || lastResult.stdout;
+    if (traceOutput) {
+        const traceStderr = (lastResult.stderr ? `${lastResult.stderr}\n` : "") + traceOutput.trim();
+        return { ...lastResult, stdout: finalStdout, stderr: traceStderr || lastResult.stderr };
+    }
+    return { ...lastResult, stdout: finalStdout };
 }
 /**
  * Execute shell scripts or commands with a minimal shell interpreter.
@@ -369,6 +437,11 @@ function splitShScript(script) {
                 }
                 continue;
             }
+            // Backslash-newline continuation: join lines
+            if (!inSingleQ && ch === '\\' && i + 1 < script.length && script[i + 1] === '\n') {
+                i += 2; // skip \ and \n
+                continue;
+            }
             if (depth === 0 && (ch === ";" || ch === "\n")) {
                 const t = current.trim();
                 if (t && !t.startsWith("#"))

package/dist/commands/tput.d.ts

@@ -0,0 +1,13 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Terminal control.
+ * @category shell
+ * @params ["<cap> [args...]"]
+ */
+export declare const tputCommand: ShellModule;
+/**
+ * Print or set terminal line settings.
+ * @category shell
+ * @params ["[args...]"]
+ */
+export declare const sttyCommand: ShellModule;

package/dist/commands/tput.js

@@ -0,0 +1,76 @@
+const CAPS = {
+    cols: 220, lines: 50, colors: 256,
+    bold: "\x1b[1m", dim: "\x1b[2m", smul: "\x1b[4m", rmul: "\x1b[24m",
+    rev: "\x1b[7m", smso: "\x1b[7m", rmso: "\x1b[27m",
+    sgr0: "\x1b[0m", el: "\x1b[K", ed: "\x1b[J",
+    clear: "\x1b[2J\x1b[H", cup: "", setaf: "", setab: "",
+};
+const ANSI_COLORS = [
+    "30", "31", "32", "33", "34", "35", "36", "37",
+    "90", "91", "92", "93", "94", "95", "96", "97",
+];
+/**
+ * Terminal control.
+ * @category shell
+ * @params ["<cap> [args...]"]
+ */
+export const tputCommand = {
+    name: "tput",
+    description: "Query terminfo database",
+    category: "shell",
+    params: ["<cap> [args...]"],
+    run: ({ args }) => {
+        const cap = args[0];
+        if (!cap)
+            return { stderr: "tput: missing capability", exitCode: 1 };
+        if (cap === "setaf" && args[1] !== undefined) {
+            const n = parseInt(args[1], 10);
+            const code = ANSI_COLORS[n] ?? "39";
+            return { stdout: `\x1b[${code}m`, exitCode: 0 };
+        }
+        if (cap === "setab" && args[1] !== undefined) {
+            const n = parseInt(args[1], 10);
+            const code = ANSI_COLORS[n]?.replace(/3/, "4").replace(/9/, "10") ?? "49";
+            return { stdout: `\x1b[${code}m`, exitCode: 0 };
+        }
+        if (cap === "cup" && args[1] !== undefined && args[2] !== undefined) {
+            return { stdout: `\x1b[${parseInt(args[1], 10) + 1};${parseInt(args[2], 10) + 1}H`, exitCode: 0 };
+        }
+        const val = CAPS[cap];
+        if (val === undefined)
+            return { stderr: `tput: unknown terminal capability '${cap}'`, exitCode: 1 };
+        return { stdout: String(val), exitCode: 0 };
+    },
+};
+/**
+ * Print or set terminal line settings.
+ * @category shell
+ * @params ["[args...]"]
+ */
+export const sttyCommand = {
+    name: "stty",
+    description: "Change and print terminal line settings",
+    category: "shell",
+    params: ["[args...]"],
+    run: ({ args }) => {
+        if (args.includes("-a") || args.includes("--all")) {
+            return {
+                stdout: [
+                    "speed 38400 baud; rows 50; columns 220; line = 0;",
+                    "intr = ^C; quit = ^\\; erase = ^?; kill = ^U; eof = ^D;",
+                    "eol = M-^?; eol2 = M-^?; swtch = <undef>; start = ^Q; stop = ^S;",
+                    "-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts",
+                    "brkint -icrnl ixon -ixoff -iuclc ixany imaxbel -iutf8",
+                    "opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0",
+                    "isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke",
+                ].join("\n"),
+                exitCode: 0,
+            };
+        }
+        if (args.includes("size")) {
+            return { stdout: "50 220", exitCode: 0 };
+        }
+        // silently accept set operations
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/w.d.ts

@@ -0,0 +1,7 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Show who is logged on and what they are doing.
+ * @category system
+ * @params ["[user]"]
+ */
+export declare const wCommand: ShellModule;

package/dist/commands/w.js

@@ -0,0 +1,38 @@
+import { userHome } from "./runtime";
+/**
+ * Show who is logged on and what they are doing.
+ * @category system
+ * @params ["[user]"]
+ */
+export const wCommand = {
+    name: "w",
+    description: "Show who is logged on and what they are doing",
+    category: "system",
+    params: ["[user]"],
+    run: ({ shell, authUser }) => {
+        const now = new Date();
+        const upSecs = Math.floor(performance.now() / 1000);
+        const upMins = Math.floor(upSecs / 60);
+        const upHours = Math.floor(upMins / 60);
+        const uptimeStr = upHours > 0
+            ? `${upHours}:${String(upMins % 60).padStart(2, "0")}`
+            : `${upMins} min`;
+        const timeStr = now.toTimeString().slice(0, 5);
+        // Read active sessions
+        shell.users.listActiveSessions?.();
+        const logPath = `${userHome(authUser)}/.lastlog`;
+        let loginTime = timeStr;
+        if (shell.vfs.exists(logPath)) {
+            try {
+                const log = JSON.parse(shell.vfs.readFile(logPath));
+                loginTime = new Date(log.at).toTimeString().slice(0, 5);
+            }
+            catch { }
+        }
+        const header = ` ${timeStr} up ${uptimeStr},  1 user,  load average: 0.${Math.floor(Math.random() * 30).toString().padStart(2, "0")}, 0.${Math.floor(Math.random() * 15).toString().padStart(2, "0")}, 0.${Math.floor(Math.random() * 10).toString().padStart(2, "0")}`;
+        const colHeader = "USER     TTY      FROM             LOGIN@   IDLE JCPU   PCPU WHAT";
+        const idle = "0.00s";
+        const row = `${authUser.padEnd(8)} pts/0    browser          ${loginTime}   ${idle}  0.01s  0.00s -bash`;
+        return { stdout: [header, colHeader, row].join("\n"), exitCode: 0 };
+    },
+};

package/dist/utils/expand.d.ts

@@ -56,3 +56,15 @@ export declare function expandSync(input: string, env: Record<string, string>, l
  * @param runCmd    Async callback to execute a command and return its stdout.
  */
 export declare function expandAsync(input: string, env: Record<string, string>, lastExit: number, runCmd: (cmd: string) => Promise<string>): Promise<string>;
+/**
+ * Expand a glob pattern against a VirtualShell VFS.
+ * Supports * (any chars in segment) and ** (any path).
+ * Returns the original pattern if no matches found (bash behavior).
+ */
+export declare function expandGlob(pattern: string, cwd: string, vfs: {
+    list: (p: string) => string[];
+    exists: (p: string) => boolean;
+    stat: (p: string) => {
+        type: string;
+    };
+}): string[];

package/dist/utils/expand.js

@@ -369,10 +369,12 @@ export function expandSync(input, env, lastExit = 0, home) {
         let s = chunk;
         // Tilde expansion — only at start of token or after `:` or whitespace
         s = s.replace(/(^|[\s:])~(\/|$)/g, (_, pre, post) => `${pre}${homePath}${post}`);
-        // $? $$ $#
+        // $? $$ $# $RANDOM $LINENO
         s = s.replace(/\$\?/g, String(lastExit));
         s = s.replace(/\$\$/g, "1");
         s = s.replace(/\$#/g, "0");
+        s = s.replace(/\$RANDOM\b/g, () => String(Math.floor(Math.random() * 32768)));
+        s = s.replace(/\$LINENO\b/g, "1");
         // $(( arithmetic )) — must come before ${ and $VAR to avoid conflicts
         s = expandArithmeticChunks(s, env);
         // ${#VAR} — string length
@@ -474,3 +476,87 @@ export async function expandAsync(input, env, lastExit, runCmd) {
             env[depthKey] = String(currentDepth);
     }
 }
+// ─── Glob expansion ──────────────────────────────────────────────────────────
+/**
+ * Expand a glob pattern against a VirtualShell VFS.
+ * Supports * (any chars in segment) and ** (any path).
+ * Returns the original pattern if no matches found (bash behavior).
+ */
+export function expandGlob(pattern, cwd, vfs) {
+    // No glob chars → return as-is
+    if (!pattern.includes('*') && !pattern.includes('?'))
+        return [pattern];
+    const isAbsolute = pattern.startsWith('/');
+    const base = isAbsolute ? '/' : cwd;
+    const relPattern = isAbsolute ? pattern.slice(1) : pattern;
+    const results = matchGlob(base, relPattern.split('/'), vfs);
+    if (results.length === 0)
+        return [pattern]; // no match → literal
+    return results.sort();
+}
+function matchGlob(dir, segments, vfs) {
+    if (segments.length === 0)
+        return [dir];
+    const [seg, ...rest] = segments;
+    if (!seg)
+        return [dir];
+    // ** matches zero or more path segments
+    if (seg === '**') {
+        const all = walkAll(dir, vfs);
+        return rest.length === 0 ? all : all.flatMap(d => {
+            try {
+                if (vfs.stat(d).type === 'directory')
+                    return matchGlob(d, rest, vfs);
+            }
+            catch { }
+            return [];
+        });
+    }
+    let entries = [];
+    try {
+        entries = vfs.list(dir);
+    }
+    catch {
+        return [];
+    }
+    const re = globToRegex(seg);
+    return entries
+        .filter(e => !e.startsWith('.') || seg.startsWith('.'))
+        .filter(e => re.test(e))
+        .flatMap(e => {
+        const full = dir === '/' ? `/${e}` : `${dir}/${e}`;
+        if (rest.length === 0)
+            return [full];
+        try {
+            if (vfs.stat(full).type === 'directory')
+                return matchGlob(full, rest, vfs);
+        }
+        catch { }
+        return [];
+    });
+}
+function walkAll(dir, vfs) {
+    const results = [dir];
+    let entries = [];
+    try {
+        entries = vfs.list(dir);
+    }
+    catch {
+        return results;
+    }
+    for (const e of entries) {
+        const full = dir === '/' ? `/${e}` : `${dir}/${e}`;
+        try {
+            if (vfs.stat(full).type === 'directory')
+                results.push(...walkAll(full, vfs));
+        }
+        catch { }
+    }
+    return results;
+}
+function globToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${escaped}$`);
+}

package/package.json

@@ -4,7 +4,13 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.5.3",
+  "version": "1.5.5",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,7 +32,7 @@
     "lint:write": "bunx --bun @biomejs/biome lint --write ./src",
     "test": "bun run test-salve",
     "test-battery": "bun test tests/",
-    "test-salve": "for f in tests/*.test.ts; do echo \"\\n🧪 Testing $f...\"; bun test \"$f\" --timeout 10000; sleep 0.25; done",
+    "test-salve": "for f in tests/*.test.ts; do echo \"\\n\ud83e\uddea Testing $f...\"; bun test \"$f\" --timeout 10000; sleep 0.25; done",
     "build": "tsc --project tsconfig.json",
     "deploy:npm": "bun publish --access public",
     "bench": "rm -rf .benchmark-shells/ && bun benchmark-virtualshell.ts",
@@ -59,4 +65,4 @@
   "dependencies": {
     "ssh2": "^1.17.0"
   }
-}
+}

package/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,50 +0,0 @@
-name: Bug report
-description: Report a reproducible problem
-labels: [bug]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for reporting a bug. Please fill out the details below.
-  - type: input
-    id: version
-    attributes:
-      label: Package version
-      placeholder: 1.0.0
-    validations:
-      required: true
-  - type: input
-    id: runtime
-    attributes:
-      label: Runtime and version
-      description: Node or Bun
-      placeholder: Node 20.12.0
-    validations:
-      required: true
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: Reproduction steps
-      placeholder: |
-        1. Start server with ...
-        2. Run command ...
-        3. Observe error ...
-    validations:
-      required: true
-  - type: textarea
-    id: expected
-    attributes:
-      label: Expected behavior
-    validations:
-      required: true
-  - type: textarea
-    id: actual
-    attributes:
-      label: Actual behavior
-    validations:
-      required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Logs or stack trace
-      render: shell

package/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,31 +0,0 @@
-name: Feature request
-description: Suggest an improvement
-labels: [enhancement]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for proposing an improvement.
-  - type: textarea
-    id: problem
-    attributes:
-      label: Problem statement
-      description: What problem are you trying to solve?
-    validations:
-      required: true
-  - type: textarea
-    id: proposal
-    attributes:
-      label: Proposed solution
-      description: Describe the API or behavior you want.
-    validations:
-      required: true
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Alternatives considered
-  - type: textarea
-    id: impact
-    attributes:
-      label: Breaking change impact
-      description: Does this change public API behavior?