@datename/fastcode-termux 0.1.6-beta → 0.1.8-beta.0

package/src/agent/shell-ast.ts

@@ -0,0 +1,227 @@
+/**
+ * Limited bash AST second opinion for Guardrails.
+ *
+ * This is deliberately not a replacement for the shape matcher. It only
+ * extracts the three entry classes we can safely re-feed into the existing
+ * classifier:
+ *
+ *   1. shell `-c` literal strings
+ *   2. `find ... -exec ... ;/+`
+ *   3. eval / source / `.` literal command strings
+ *
+ * plus one same-scope assignment (`X=rm; $X -rf /`). It only reports Hard
+ * Block upgrades; parse failures return no findings so the shape matcher's
+ * result is never downgraded.
+ */
+import parse from "bash-parser";
+
+export interface ShellAstHard {
+    code: string;
+    target: string;
+    reason: string;
+    alternatives: string[];
+}
+
+export interface ShellAstAnalysis {
+    derived: string[];
+    hard?: ShellAstHard;
+}
+
+const MAX_DEPTH = 4;
+
+export function analyzeShellAst(command: string): ShellAstAnalysis {
+    return analyze(command, 0);
+}
+
+function analyze(command: string, depth: number): ShellAstAnalysis {
+    if (depth > MAX_DEPTH)
+        return { derived: [] };
+    let ast: any;
+    try {
+        ast = parse(command, { mode: "bash" });
+    }
+    catch {
+        return { derived: [] };
+    }
+    const derived: string[] = [];
+    let hard: ShellAstHard | undefined;
+    const scope = new Map<string, string>();
+
+    const addDerived = (value: string) => {
+        const trimmed = value.trim();
+        if (trimmed && !derived.includes(trimmed))
+            derived.push(trimmed);
+    };
+    const addHard = (finding: ShellAstHard) => {
+        if (!hard)
+            hard = finding;
+    };
+    const wordText = (word: any): string => typeof word?.text === "string" ? word.text : "";
+    const wordIsDynamic = (word: any): boolean => {
+        if (Array.isArray(word?.expansion) && word.expansion.length > 0)
+            return true;
+        const text = wordText(word);
+        return /\$|`/.test(text);
+    };
+    const words = (value: any): any[] => Array.isArray(value) ? value : [];
+    const walkWord = (word: any) => {
+        for (const expansion of words(word?.expansion)) {
+            if (expansion?.type === "CommandExpansion") {
+                if (typeof expansion.command === "string")
+                    addDerived(expansion.command);
+                if (expansion.commandAST)
+                    walkNode(expansion.commandAST, scope, depth + 1);
+            }
+        }
+    };
+    const walkList = (commands: any[], assignments: Map<string, string>, level: number) => {
+        for (const node of commands)
+            walkNode(node, assignments, level);
+    };
+    const handleCommand = (node: any, assignments: Map<string, string>) => {
+        const prefix = words(node?.prefix);
+        for (const assignment of prefix) {
+            const text = wordText(assignment);
+            const eq = text.indexOf("=");
+            if (eq <= 0)
+                continue;
+            const name = text.slice(0, eq);
+            const value = text.slice(eq + 1);
+            // One same-scope assignment, literal values only. Nested command
+            // substitution / variable values are intentionally not tracked.
+            if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && value && !/[$`]/.test(value))
+                assignments.set(name, value);
+        }
+
+        const nameWord = node?.name;
+        const name = wordText(nameWord);
+        const suffix = words(node?.suffix);
+        const parameter = words(nameWord?.expansion).find((entry: any) => entry?.type === "ParameterExpansion")?.parameter;
+        if (parameter && assignments.has(parameter) && (name === `$${parameter}` || name === `\${${parameter}}`)) {
+            const suffixText = suffix.map(wordText);
+            // bash-parser strips double quotes; a suffix that looks like a
+            // redirect/operator may be a quoted literal argument. Do not turn
+            // it into a false Hard Block.
+            if (suffixText.every((text) => !/[<>|;&]/.test(text))) {
+                const resolved = `${assignments.get(parameter)} ${suffixText.join(" ")}`.trim();
+                if (resolved)
+                    addDerived(resolved);
+            }
+        }
+
+        if (name === "eval" || name === "source" || name === ".") {
+            if (suffix.length === 0)
+                return;
+            if (suffix.some(wordIsDynamic)) {
+                addHard({
+                    code: "dynamic_execution",
+                    target: name,
+                    reason: "non-literal-eval-source",
+                    alternatives: [
+                        "Use a literal, reviewed command string; dynamic eval/source cannot be audited.",
+                    ],
+                });
+                return;
+            }
+            addDerived(suffix.map(wordText).join(" "));
+        }
+
+        if (SHELL_COMMAND_NAMES.has(name)) {
+            const cIndex = suffix.findIndex((word: any) => /^-[a-z]*c$/i.test(wordText(word)));
+            if (cIndex >= 0 && suffix[cIndex + 1]) {
+                const script = suffix[cIndex + 1];
+                if (wordIsDynamic(script)) {
+                    addHard({
+                        code: "dynamic_execution",
+                        target: `${name} -c`,
+                        reason: "non-literal-shell-command",
+                        alternatives: [
+                            "Pass a literal, reviewed script string instead of a variable/command substitution.",
+                        ],
+                    });
+                    return;
+                }
+                addDerived(wordText(script));
+            }
+        }
+
+        if (name === "env") {
+            const start = suffix.findIndex((word: any) => {
+                const value = wordText(word);
+                return value && !value.startsWith("-") && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(value);
+            });
+            if (start >= 0)
+                addDerived(suffix.slice(start).map(wordText).join(" "));
+        }
+
+        if (name === "find") {
+            const execIndex = suffix.findIndex((word: any) => {
+                const value = wordText(word);
+                return value === "-exec" || value === "-execdir";
+            });
+            if (execIndex >= 0) {
+                const inner: string[] = [];
+                for (const word of suffix.slice(execIndex + 1)) {
+                    const value = wordText(word);
+                    if (value === ";" || value === "+")
+                        break;
+                    inner.push(value);
+                }
+                const executable = (inner[0] ?? "").replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
+                if (inner.length > 0 && INSPECT_EXECUTABLES.has(executable))
+                    addDerived(inner.join(" "));
+            }
+        }
+        for (const word of words(node?.prefix))
+            walkWord(word);
+        for (const word of words(node?.suffix))
+            walkWord(word);
+    };
+    const walkNode = (node: any, assignments: Map<string, string>, level: number): void => {
+        if (!node || typeof node !== "object" || level > MAX_DEPTH)
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walkNode(item, assignments, level);
+            return;
+        }
+        switch (node.type) {
+            case "Command":
+                handleCommand(node, assignments);
+                return;
+            case "Script":
+            case "CompoundList":
+                walkList(words(node.commands), new Map(assignments), level);
+                return;
+            case "Pipeline":
+                walkList(words(node.commands), assignments, level);
+                return;
+            case "LogicalExpression":
+                walkNode(node.left, assignments, level);
+                walkNode(node.right, assignments, level);
+                return;
+            case "Subshell":
+                walkNode(node.list, new Map(assignments), level + 1);
+                return;
+            case "CommandExpansion":
+                walkNode(node.commandAST, assignments, level + 1);
+                return;
+            default:
+                for (const value of Object.values(node))
+                    walkNode(value, assignments, level);
+        }
+    };
+
+    walkNode(ast, scope, depth);
+    return hard ? { derived, hard } : { derived };
+}
+
+const SHELL_COMMAND_NAMES = new Set(["sh", "bash", "zsh", "dash", "ksh", "fish"]);
+const INSPECT_EXECUTABLES = new Set([
+    "sh", "bash", "zsh", "dash", "ksh", "fish", "eval", "source", ".",
+    "rm", "rmdir", "rd", "del", "erase", "unlink", "shred", "truncate",
+    "git", "dd", "mkfs", "mke2fs", "fdisk", "diskpart", "format",
+    "docker", "kubectl", "chmod", "chown", "chgrp", "shutdown", "reboot",
+    "poweroff", "halt", "systemctl", "find", "curl", "wget", "base64",
+    "nc", "ncat", "netcat", "socat", "mv", "cp", "install", "tar", "rsync",
+]);

package/src/agent/shell-session.ts

@@ -1,5 +1,7 @@
 import { spawn, type ChildProcess, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { killProcessTree } from "./process-tree.js";
+import parse from "bash-parser";
+import { terminateProcessTree } from "./process-tree.js";
+import { normalizeTimeoutMs } from "./tools/validate.js";
 
 export type ShellJobStatus = "running" | "done" | "failed" | "killed" | "timeout";
 
@@ -21,6 +23,9 @@ export interface ShellJobView {
     bytes: number;
     startedAt: number;
     pid?: number;
+    /** Lifecycle visibility for /jobs and regression tests. */
+    timeoutArmed?: boolean;
+    foregroundAttached?: boolean;
 }
 
 interface ExecOptions {
@@ -33,7 +38,9 @@ interface ExecOptions {
 const OUTPUT_LIMIT = 1024 * 1024;
 const DEFAULT_BACKGROUND_MS = 2000;
 const DEFAULT_TIMEOUT_MS = 120_000;
-const MAX_POOL = 2;
+export const DEFAULT_SHELL_POOL_SIZE = 2;
+export const MAX_SHELL_POOL_SIZE = 6;
+let poolLimit = DEFAULT_SHELL_POOL_SIZE;
 const jobs = new Map<string, ShellJob>();
 const pool: ResidentShell[] = [];
 let spawns = 0;
@@ -56,6 +63,10 @@ class ShellJob {
     private readonly donePromise: Promise<void>;
     private resolveDone!: () => void;
     private waiters: Array<() => void> = [];
+    private timeoutTimer?: ReturnType<typeof setTimeout>;
+    private abortSignal?: AbortSignal;
+    private abortListener?: () => void;
+    private cleaned = false;
     constructor(command: string, cwd: string) {
         this.id = "sh_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 7);
         this.key = this.id.replace(/[^a-z0-9]/gi, "");
@@ -89,9 +100,45 @@ class ShellJob {
             return;
         this.status = status;
         this.exitCode = exitCode;
+        this.cleanupLifecycle();
         this.resolveDone();
         this.notify();
     }
+    /**
+     * Task-level timeout lives until the job actually finishes. Returning to
+     * the foreground only detaches the AbortSignal; it must not disarm this.
+     */
+    armTimeout(ms: number): void {
+        if (this.timeoutTimer || this.status !== "running")
+            return;
+        this.timeoutTimer = setTimeout(() => this.kill("timeout"), ms);
+        this.timeoutTimer.unref?.();
+    }
+    attachAbort(signal: AbortSignal | undefined): void {
+        if (!signal || this.abortListener)
+            return;
+        const listener = () => this.kill("killed");
+        this.abortSignal = signal;
+        this.abortListener = listener;
+        signal.addEventListener("abort", listener, { once: true });
+    }
+    /** Detach Esc/foreground cancellation but keep the timeout armed. */
+    detachForeground(): void {
+        if (this.abortSignal && this.abortListener)
+            this.abortSignal.removeEventListener("abort", this.abortListener);
+        this.abortSignal = undefined;
+        this.abortListener = undefined;
+    }
+    private cleanupLifecycle(): void {
+        if (this.cleaned)
+            return;
+        this.cleaned = true;
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = undefined;
+        }
+        this.detachForeground();
+    }
     waitForChange(ms: number): Promise<void> {
         if (this.status !== "running" || this.delivered < this.output.length)
             return Promise.resolve();
@@ -124,18 +171,23 @@ class ShellJob {
             exitCode: this.exitCode,
             bytes: this.output.length,
             startedAt: this.startedAt,
-            pid: this.child?.pid,
+            pid: this.child?.pid ?? this.resident?.child.pid,
+            timeoutArmed: Boolean(this.timeoutTimer),
+            foregroundAttached: Boolean(this.abortListener),
         };
     }
     kill(reason: "killed" | "timeout"): void {
         if (this.status !== "running")
             return;
-        this.append(reason === "timeout" ? "\n[command timed out: process tree killed]" : "\n[command aborted: process tree killed]");
+        this.append(reason === "timeout"
+            ? "\n[command timed out: process group killed; setsid descendants may escape]"
+            : "\n[command aborted: process group killed; setsid descendants may escape]");
         this.status = reason;
+        this.cleanupLifecycle();
         if (this.resident)
             this.resident.kill();
         else if (this.child)
-            killProcessTree(this.child, "SIGTERM");
+            terminateProcessTree(this.child);
         this.resolveDone();
         this.notify();
     }
@@ -146,6 +198,8 @@ class ResidentShell {
     job?: ShellJob;
     dead = false;
     private buffer = "";
+    private background = false;
+    private claimed = false;
     constructor(cwd: string) {
         const env = { ...process.env, FASTCODE_SANDBOX: "1", FASTCODE_SANDBOX_ROOT: cwd };
         this.child = spawn("sh", ["-s"], {
@@ -169,13 +223,23 @@ class ResidentShell {
                 pool.splice(index, 1);
         });
     }
-    run(job: ShellJob, timeoutMs: number): void {
+    claimIfIdle(): boolean {
+        if (this.dead || this.job || this.claimed)
+            return false;
+        this.claimed = true;
+        return true;
+    }
+    run(job: ShellJob, timeoutMs: number, background = false): void {
+        this.claimed = false;
         this.job = job;
+        this.background = background;
+        this.buffer = "";
         job.resident = this;
         const marker = `__FC_END_${job.key}__`;
+        const body = job.command.trim() ? ["(", job.command, ")"] : [":"];
         const script = [
             `if cd ${shellQuote(job.cwd)}; then`,
-            job.command,
+            ...body,
             "__fc_status=$?",
             "else",
             "__fc_status=1",
@@ -195,9 +259,13 @@ class ResidentShell {
     private consume(chunk: string): void {
         if (this.dead)
             return;
-        this.buffer += chunk;
-        if (!this.job)
+        // Output that arrives while no job owns the shell belongs to an
+        // already-finished background child. Never carry it into the next job.
+        if (!this.job) {
+            this.buffer = "";
             return;
+        }
+        this.buffer += chunk;
         const marker = `__FC_END_${this.job.key}__:`;
         const index = this.buffer.indexOf(marker);
         if (index < 0) {
@@ -226,20 +294,39 @@ class ResidentShell {
         const code = Number(rest.slice(0, newline).trim());
         this.buffer = rest.slice(newline + 1);
         this.job = undefined;
+        const background = this.background;
+        this.background = false;
         job.finish(Number.isFinite(code) && code === 0 ? "done" : "failed", Number.isFinite(code) ? code : 1);
+        // A background operator leaves a detached child writing into this
+        // shell's stdout pipe. Retire the resident so late output cannot be
+        // attributed to the next command.
+        if (background)
+            this.kill();
     }
     private fail(message: string, code?: number | null): void {
+        this.claimed = false;
         if (!this.job)
             return;
         const job = this.job;
         this.job = undefined;
+        this.background = false;
+        if (this.buffer) {
+            job.append(this.buffer);
+            this.buffer = "";
+        }
+        if (code === 0) {
+            job.finish("done", 0);
+            return;
+        }
         job.append(`\n${message}`);
         job.finish("failed", code ?? 1);
     }
     kill(): void {
         this.dead = true;
-        killProcessTree(this.child, "SIGTERM");
-        setTimeout(() => killProcessTree(this.child, "SIGKILL"), 2000);
+        this.claimed = false;
+        this.background = false;
+        this.buffer = "";
+        terminateProcessTree(this.child);
         const index = pool.indexOf(this);
         if (index >= 0)
             pool.splice(index, 1);
@@ -250,18 +337,21 @@ export async function executeShellCommand(command: string, cwd: string, options:
     pruneJobs();
     if (options.signal?.aborted)
         return { ok: false, status: "killed", output: "command aborted before start" };
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = normalizeTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
     const backgroundAfterMs = options.backgroundAfterMs ?? DEFAULT_BACKGROUND_MS;
-    const useResident = process.platform !== "win32" && !needsOneShot(command);
+    const shape = analyzeShellShape(command);
+    const useResident = process.platform !== "win32" && !shape.oneShot;
     let job: ShellJob | undefined;
     if (useResident) {
-        const resident = acquireResident(options.turn, cwd);
-        if (resident === "busy")
-            return { ok: false, status: "failed", output: "both pool shells are busy; poll or kill a session first" };
+        const resident = await acquireResident(options.turn, cwd, timeoutMs, options.signal);
         if (resident === "limit")
             return { ok: false, status: "failed", output: spawnLimitMessage() };
+        if (resident === "timeout")
+            return { ok: false, status: "timeout", output: "shell pool is busy; timed out waiting for a free resident shell" };
+        if (resident === "killed")
+            return { ok: false, status: "killed", output: "command aborted before start" };
         job = new ShellJob(command, cwd);
-        resident.run(job, timeoutMs);
+        resident.run(job, timeoutMs, shape.background);
     }
     else {
         if (!maySpawn(options.turn))
@@ -269,16 +359,15 @@ export async function executeShellCommand(command: string, cwd: string, options:
         job = startOneShot(command, cwd);
     }
     jobs.set(job.id, job);
-    const timer = setTimeout(() => job!.kill("timeout"), timeoutMs);
-    const onAbort = () => job!.kill("killed");
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    const cleanup = () => {
-        clearTimeout(timer);
-        options.signal?.removeEventListener("abort", onAbort);
-    };
+    job.armTimeout(timeoutMs);
+    job.attachAbort(options.signal);
+    if (options.signal?.aborted)
+        job.kill("killed");
     await Promise.race([job.done(), delay(backgroundAfterMs)]);
     if (job.status === "running") {
-        cleanup();
+        // Task keeps running: only the foreground Esc/abort association is
+        // released. The timeout stays armed until the job really finishes.
+        job.detachForeground();
         return {
             ok: true,
             status: "running",
@@ -287,7 +376,6 @@ export async function executeShellCommand(command: string, cwd: string, options:
             nextPollMs: job.nextPollMs,
         };
     }
-    cleanup();
     return syncResult(job);
 }
 
@@ -342,11 +430,74 @@ export function shutdownShells(): void {
     jobs.clear();
 }
 
-export function shellPoolStats(): { spawns: number; active: number; pool: number; maxSpawnPerTurn: number } {
+/**
+ * Exit-safe stop: send SIGTERM, wait briefly for close, then force SIGKILL.
+ * Use this when the process is about to exit and must not leave children.
+ */
+export async function shutdownShellsAsync(graceMs = 400): Promise<void> {
+    const running = Array.from(jobs.values()).filter((job) => job.status === "running");
+    const residents = pool.filter((resident) => !resident.dead);
+    for (const job of running)
+        job.kill("killed");
+    for (const resident of residents)
+        resident.kill();
+    pool.length = 0;
+    jobs.clear();
+    const children: ChildProcess[] = [];
+    for (const job of running) {
+        if (job.child)
+            children.push(job.child);
+    }
+    for (const resident of residents)
+        children.push(resident.child);
+    if (children.length === 0)
+        return;
+    await Promise.race([
+        Promise.all(children.map((child) => waitForChildClose(child, graceMs))),
+        delay(graceMs + 50),
+    ]);
+    for (const child of children) {
+        if (child.exitCode === null && child.signalCode === null)
+            terminateProcessTree(child, { graceMs: 0 });
+    }
+    await delay(50);
+}
+
+function waitForChildClose(child: ChildProcess, ms: number): Promise<void> {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const done = () => {
+            if (timer)
+                clearTimeout(timer);
+            child.removeListener("close", done);
+            resolve();
+        };
+        timer = setTimeout(done, ms);
+        child.once("close", done);
+    });
+}
+
+export function shellPoolSize(): number {
+    return poolLimit;
+}
+
+/** Clamp and apply the resident shell concurrency (1..6, default 2). */
+export function setShellPoolSize(size: number): number {
+    const parsed = Number(size);
+    poolLimit = Number.isFinite(parsed)
+        ? Math.min(MAX_SHELL_POOL_SIZE, Math.max(1, Math.floor(parsed)))
+        : DEFAULT_SHELL_POOL_SIZE;
+    return poolLimit;
+}
+
+export function shellPoolStats(): { spawns: number; active: number; pool: number; maxPool: number; maxSpawnPerTurn: number } {
     return {
         spawns,
         active: Array.from(jobs.values()).filter((job) => job.status === "running").length,
         pool: pool.filter((resident) => !resident.dead).length,
+        maxPool: poolLimit,
         maxSpawnPerTurn: maxSpawnPerTurn(),
     };
 }
@@ -374,22 +525,95 @@ function startOneShot(command: string, cwd: string): ShellJob {
     return job;
 }
 
-function acquireResident(turn: number | undefined, cwd: string): ResidentShell | "busy" | "limit" {
-    const idle = pool.find((resident) => !resident.dead && !resident.job);
-    if (idle)
-        return idle;
-    if (pool.filter((resident) => !resident.dead).length >= MAX_POOL)
-        return "busy";
-    if (!maySpawn(turn))
-        return "limit";
-    const resident = new ResidentShell(cwd);
-    pool.push(resident);
-    return resident;
+async function acquireResident(turn: number | undefined, cwd: string, waitMs: number, signal?: AbortSignal): Promise<ResidentShell | "limit" | "timeout" | "killed"> {
+    const deadline = Date.now() + waitMs;
+    while (true) {
+        for (const resident of pool) {
+            if (resident.claimIfIdle())
+                return resident;
+        }
+        const live = pool.filter((resident) => !resident.dead);
+        if (live.length < poolLimit && maySpawn(turn)) {
+            const resident = new ResidentShell(cwd);
+            resident.claimIfIdle();
+            pool.push(resident);
+            return resident;
+        }
+        // No free shell and no spawn budget: wait for a running command to
+        // finish instead of failing the third call with "both shells busy".
+        if (live.length === 0)
+            return "limit";
+        if (signal?.aborted)
+            return "killed";
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return "timeout";
+        await delay(Math.min(remaining, 50));
+    }
+}
+
+const INTERACTIVE_COMMANDS = new Set(["vim", "nano", "less", "more", "ssh", "su", "login", "read", "top", "htop", "tmux", "screen"]);
+const REPL_COMMANDS = new Set(["python", "python3", "node", "bash", "zsh", "fish", "irb", "sqlite3"]);
+const WRAPPER_COMMANDS = new Set(["sudo", "env", "nohup", "command", "time", "exec"]);
+
+interface ShellShape {
+    oneShot: boolean;
+    background: boolean;
 }
 
-function needsOneShot(command: string): boolean {
-    return /(^|\s)(vim|nano|less|more|ssh|su|login|read|top|htop|tmux|screen)(\s|$)/.test(command)
-        || /(^|\s)(python|python3|node|bash|zsh|fish|irb|sqlite3)(\s|$)/.test(command) && !/\s-(c|e|m)\s/.test(command);
+function analyzeShellShape(command: string): ShellShape {
+    let ast: any;
+    try {
+        ast = parse(command, { mode: "bash" });
+    }
+    catch {
+        // Fall back to the historical heuristic only when the parser cannot
+        // classify the command at all.
+        return {
+            oneShot: /(^|\s)(vim|nano|less|more|ssh|su|login|read|top|htop|tmux|screen)(\s|$)/.test(command)
+                || /(^|\s)(python|python3|node|bash|zsh|fish|irb|sqlite3)(\s|$)/.test(command) && !/\s-(c|e|m)\s/.test(command),
+            background: /(^|[^&>])&([^&>]|$)/.test(command),
+        };
+    }
+    let oneShot = false;
+    let background = false;
+    const walk = (node: any, depth = 0): void => {
+        if (!node || typeof node !== "object" || depth > 32)
+            return;
+        if (Array.isArray(node)) {
+            for (const entry of node)
+                walk(entry, depth + 1);
+            return;
+        }
+        // bash-parser also marks `cmd &> file` as async; only retire the
+        // resident for a real background operator, not a redirect.
+        if (node.async === true && /(^|[^&>])&([^&>]|$)/.test(command))
+            background = true;
+        if (node.type === "Command" && typeof node.name?.text === "string") {
+            const name = node.name.text;
+            const args = Array.isArray(node.suffix)
+                ? node.suffix.map((word: any) => typeof word?.text === "string" ? word.text : "").filter(Boolean)
+                : [];
+            const replOptions = (values: string[]) => values.some((arg: string) => /^(-c|-e|-m|-p|--eval|--print|--command)$/.test(arg));
+            if (INTERACTIVE_COMMANDS.has(name) || REPL_COMMANDS.has(name) && !replOptions(args))
+                oneShot = true;
+            if (WRAPPER_COMMANDS.has(name)) {
+                const wrappedIndex = args.findIndex((arg: string) => INTERACTIVE_COMMANDS.has(arg) || REPL_COMMANDS.has(arg));
+                if (wrappedIndex >= 0) {
+                    const wrappedName = args[wrappedIndex];
+                    if (INTERACTIVE_COMMANDS.has(wrappedName) ||
+                        REPL_COMMANDS.has(wrappedName) && !replOptions(args.slice(wrappedIndex + 1)))
+                        oneShot = true;
+                }
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (value && typeof value === "object")
+                walk(value, depth + 1);
+        }
+    };
+    walk(ast);
+    return { oneShot, background };
 }
 
 function maySpawn(turn: number | undefined): boolean {