@aria-cli/tools 1.0.19 → 1.0.33

package/dist/definitions/process/process.js

@@ -0,0 +1,387 @@
+/**
+ * process tool — ARIA Tool wrapper for background shell process management.
+ *
+ * Supports spawn/read/write/kill/list/send_key actions.
+ * Uses node:child_process (no native deps).
+ * Process registry forked from OpenClaw (MIT).
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+import { sanitizeEnv } from "../../executors/shell.js";
+import { createSessionSlug, addSession, getSession, getFinishedSession, appendOutput, drainSession, markExited, markBackgrounded, listRunningSessions, listFinishedSessions, } from "./process-registry.js";
+import { encodeKeySequence } from "./pty-keys.js";
+// ── Constants ───────────────────────────────────────────────────────
+const MAX_OUTPUT_CHARS = 200_000; // 200KB ring buffer cap per process
+const DEFAULT_SPAWN_TIMEOUT_MS = 30_000;
+const MAX_SPAWN_TIMEOUT_MS = 300_000; // 5 minutes
+const OUTPUT_SETTLE_MS = 200; // wait for initial output after spawn
+// ── Action handlers ─────────────────────────────────────────────────
+function handleSpawn(input, cwd) {
+    return new Promise((resolve) => {
+        const command = input.command;
+        if (!command) {
+            resolve({ success: false, message: "spawn requires 'command' parameter" });
+            return;
+        }
+        const sessionId = createSessionSlug();
+        const timeout = Math.min(input.timeout ?? DEFAULT_SPAWN_TIMEOUT_MS, MAX_SPAWN_TIMEOUT_MS);
+        const child = nodeSpawn("sh", ["-c", command], {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: sanitizeEnv(),
+            detached: false,
+        });
+        const session = {
+            id: sessionId,
+            command,
+            pid: child.pid,
+            startedAt: Date.now(),
+            cwd,
+            maxOutputChars: MAX_OUTPUT_CHARS,
+            totalOutputChars: 0,
+            pendingStdout: [],
+            pendingStderr: [],
+            pendingStdoutChars: 0,
+            pendingStderrChars: 0,
+            aggregated: "",
+            tail: "",
+            exited: false,
+            truncated: false,
+            backgrounded: true,
+            child,
+            stdin: child.stdin
+                ? {
+                    write: (data, cb) => child.stdin.write(data, cb),
+                    end: () => child.stdin.end(),
+                    destroy: () => child.stdin.destroy(),
+                    get destroyed() {
+                        return child.stdin.destroyed;
+                    },
+                }
+                : undefined,
+        };
+        addSession(session);
+        markBackgrounded(session);
+        child.stdout?.on("data", (chunk) => {
+            appendOutput(session, "stdout", chunk.toString());
+        });
+        child.stderr?.on("data", (chunk) => {
+            appendOutput(session, "stderr", chunk.toString());
+        });
+        child.on("error", (err) => {
+            markExited(session, null, null, "failed");
+            // Error after we already resolved is fine — the process just failed later
+        });
+        child.on("exit", (code, signal) => {
+            if (session.exited)
+                return;
+            const status = signal ? "killed" : code === 0 ? "completed" : "failed";
+            markExited(session, code, signal, status);
+        });
+        // Set up timeout to kill if it runs too long without interaction
+        if (timeout > 0) {
+            const timer = setTimeout(() => {
+                if (!session.exited) {
+                    try {
+                        child.kill("SIGTERM");
+                    }
+                    catch {
+                        // Process may have already exited
+                    }
+                }
+            }, timeout);
+            timer.unref();
+            // Clear timeout if process exits before timeout
+            child.on("exit", () => clearTimeout(timer));
+        }
+        // Wait briefly for initial output
+        setTimeout(() => {
+            const { stdout, stderr } = drainSession(session);
+            const initialOutput = [stdout && `stdout: ${stdout}`, stderr && `stderr: ${stderr}`]
+                .filter(Boolean)
+                .join("\n");
+            resolve({
+                success: true,
+                message: [
+                    `Process spawned with session_id: ${sessionId}`,
+                    `PID: ${child.pid}`,
+                    `Command: ${command}`,
+                    initialOutput && `\nInitial output:\n${initialOutput}`,
+                ]
+                    .filter(Boolean)
+                    .join("\n"),
+                data: { session_id: sessionId, pid: child.pid },
+            });
+        }, OUTPUT_SETTLE_MS);
+    });
+}
+function handleRead(input) {
+    const sessionId = input.session_id;
+    if (!sessionId) {
+        return { success: false, message: "read requires 'session_id' parameter" };
+    }
+    const session = getSession(sessionId);
+    if (session) {
+        const { stdout, stderr } = drainSession(session);
+        const hasOutput = stdout || stderr;
+        return {
+            success: true,
+            message: [
+                `Session: ${sessionId} (running, PID: ${session.pid})`,
+                hasOutput ? "" : "(no new output since last read)",
+                stdout && `stdout:\n${stdout}`,
+                stderr && `stderr:\n${stderr}`,
+            ]
+                .filter((s) => typeof s === "string" && s !== "")
+                .join("\n"),
+            data: {
+                session_id: sessionId,
+                status: "running",
+                pid: session.pid,
+                stdout,
+                stderr,
+                total_output_chars: session.totalOutputChars,
+                truncated: session.truncated,
+            },
+        };
+    }
+    const finished = getFinishedSession(sessionId);
+    if (finished) {
+        return {
+            success: true,
+            message: [
+                `Session: ${sessionId} (${finished.status})`,
+                `Exit code: ${finished.exitCode ?? "N/A"}`,
+                finished.exitSignal && `Signal: ${finished.exitSignal}`,
+                `Output:\n${finished.tail}`,
+                finished.truncated && "(output was truncated)",
+            ]
+                .filter(Boolean)
+                .join("\n"),
+            data: {
+                session_id: sessionId,
+                status: finished.status,
+                exit_code: finished.exitCode,
+                exit_signal: finished.exitSignal,
+                output: finished.tail,
+                total_output_chars: finished.totalOutputChars,
+                truncated: finished.truncated,
+            },
+        };
+    }
+    return { success: false, message: `No session found with id: ${sessionId}` };
+}
+async function handleWrite(input) {
+    const sessionId = input.session_id;
+    if (!sessionId) {
+        return { success: false, message: "write requires 'session_id' parameter" };
+    }
+    if (input.input === undefined || input.input === null) {
+        return { success: false, message: "write requires 'input' parameter" };
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+        const finished = getFinishedSession(sessionId);
+        if (finished) {
+            return {
+                success: false,
+                message: `Session ${sessionId} has already exited (${finished.status})`,
+            };
+        }
+        return { success: false, message: `No session found with id: ${sessionId}` };
+    }
+    if (!session.stdin || session.stdin.destroyed) {
+        return { success: false, message: `Session ${sessionId} stdin is not available` };
+    }
+    return new Promise((resolve) => {
+        session.stdin.write(input.input, (err) => {
+            if (err) {
+                resolve({
+                    success: false,
+                    message: `Failed to write to session ${sessionId}: ${err.message}`,
+                });
+                return;
+            }
+            resolve({
+                success: true,
+                message: `Wrote ${input.input.length} chars to session ${sessionId}`,
+                data: { session_id: sessionId, bytes_written: input.input.length },
+            });
+        });
+    });
+}
+function handleKill(input) {
+    const sessionId = input.session_id;
+    if (!sessionId) {
+        return { success: false, message: "kill requires 'session_id' parameter" };
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+        const finished = getFinishedSession(sessionId);
+        if (finished) {
+            return {
+                success: false,
+                message: `Session ${sessionId} has already exited (${finished.status})`,
+            };
+        }
+        return { success: false, message: `No session found with id: ${sessionId}` };
+    }
+    const signal = (input.signal ?? "SIGTERM");
+    if (session.child) {
+        try {
+            session.child.kill(signal);
+        }
+        catch {
+            // Process may have already exited
+        }
+    }
+    return {
+        success: true,
+        message: `Sent ${signal} to session ${sessionId} (PID: ${session.pid})`,
+        data: { session_id: sessionId, signal },
+    };
+}
+function handleList() {
+    const running = listRunningSessions().map((s) => ({
+        session_id: s.id,
+        command: s.command,
+        pid: s.pid,
+        status: s.exited ? "exited" : "running",
+        started_at: new Date(s.startedAt).toISOString(),
+        runtime_ms: Date.now() - s.startedAt,
+        total_output_chars: s.totalOutputChars,
+    }));
+    const finished = listFinishedSessions().map((s) => ({
+        session_id: s.id,
+        command: s.command,
+        status: s.status,
+        exit_code: s.exitCode,
+        started_at: new Date(s.startedAt).toISOString(),
+        ended_at: new Date(s.endedAt).toISOString(),
+        runtime_ms: s.endedAt - s.startedAt,
+        total_output_chars: s.totalOutputChars,
+    }));
+    const all = [...running, ...finished];
+    if (all.length === 0) {
+        return { success: true, message: "No active or recent sessions.", data: { sessions: [] } };
+    }
+    const lines = all.map((s) => `  ${s.session_id}: ${s.command} [${s.status}] (${s.runtime_ms}ms)`);
+    return {
+        success: true,
+        message: `Sessions (${all.length}):\n${lines.join("\n")}`,
+        data: { sessions: all },
+    };
+}
+async function handleSendKey(input) {
+    const sessionId = input.session_id;
+    if (!sessionId) {
+        return { success: false, message: "send_key requires 'session_id' parameter" };
+    }
+    if (!input.key) {
+        return { success: false, message: "send_key requires 'key' parameter" };
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+        const finished = getFinishedSession(sessionId);
+        if (finished) {
+            return {
+                success: false,
+                message: `Session ${sessionId} has already exited (${finished.status})`,
+            };
+        }
+        return { success: false, message: `No session found with id: ${sessionId}` };
+    }
+    if (!session.stdin || session.stdin.destroyed) {
+        return { success: false, message: `Session ${sessionId} stdin is not available` };
+    }
+    const { data: keyData, warnings } = encodeKeySequence({ keys: [input.key] });
+    if (!keyData) {
+        return {
+            success: false,
+            message: `Could not encode key: ${input.key}${warnings.length ? ` (${warnings.join(", ")})` : ""}`,
+        };
+    }
+    return new Promise((resolve) => {
+        session.stdin.write(keyData, (err) => {
+            if (err) {
+                resolve({
+                    success: false,
+                    message: `Failed to send key to session ${sessionId}: ${err.message}`,
+                });
+                return;
+            }
+            resolve({
+                success: true,
+                message: `Sent key '${input.key}' to session ${sessionId}${warnings.length ? ` (warnings: ${warnings.join(", ")})` : ""}`,
+                data: { session_id: sessionId, key: input.key, warnings },
+            });
+        });
+    });
+}
+// ── Tool definition ─────────────────────────────────────────────────
+export const processTool = {
+    name: "process",
+    description: "Manage background shell processes. Supports spawning long-running commands, reading their output, writing input, and killing them. Each process gets a human-readable session ID.",
+    category: "shell",
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["spawn", "read", "write", "kill", "list", "send_key"],
+                description: "Action to perform",
+            },
+            command: {
+                type: "string",
+                description: "Shell command to run (for spawn)",
+            },
+            session_id: {
+                type: "string",
+                description: "Session ID (from spawn result)",
+            },
+            input: {
+                type: "string",
+                description: "Input to write to stdin (for write)",
+            },
+            key: {
+                type: "string",
+                description: "Special key to send (for send_key): Enter, Tab, Ctrl+C, Up, Down, etc.",
+            },
+            timeout: {
+                type: "number",
+                description: "Timeout in ms (for spawn, default 30000)",
+            },
+            signal: {
+                type: "string",
+                description: "Signal to send (for kill, default SIGTERM)",
+            },
+        },
+        required: ["action"],
+    },
+    riskLevel: "dangerous",
+    isReadOnly: false,
+    loadingTier: "always",
+    async execute(rawInput, context) {
+        const input = rawInput;
+        const cwd = context.workingDir;
+        switch (input.action) {
+            case "spawn":
+                return handleSpawn(input, cwd);
+            case "read":
+                return handleRead(input);
+            case "write":
+                return handleWrite(input);
+            case "kill":
+                return handleKill(input);
+            case "list":
+                return handleList();
+            case "send_key":
+                return handleSendKey(input);
+            default:
+                return {
+                    success: false,
+                    message: `Unknown action: ${input.action}. Valid actions: spawn, read, write, kill, list, send_key`,
+                };
+        }
+    },
+};
+//# sourceMappingURL=process.js.map

package/dist/definitions/process/pty-keys.js

@@ -0,0 +1,255 @@
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, inlined escapeRegExp
+const ESC = "\x1b";
+const CR = "\r";
+const TAB = "\t";
+const BACKSPACE = "\x7f";
+export const BRACKETED_PASTE_START = `${ESC}[200~`;
+export const BRACKETED_PASTE_END = `${ESC}[201~`;
+const namedKeyMap = new Map([
+    ["enter", CR],
+    ["return", CR],
+    ["tab", TAB],
+    ["escape", ESC],
+    ["esc", ESC],
+    ["space", " "],
+    ["bspace", BACKSPACE],
+    ["backspace", BACKSPACE],
+    ["up", `${ESC}[A`],
+    ["down", `${ESC}[B`],
+    ["right", `${ESC}[C`],
+    ["left", `${ESC}[D`],
+    ["home", `${ESC}[1~`],
+    ["end", `${ESC}[4~`],
+    ["pageup", `${ESC}[5~`],
+    ["pgup", `${ESC}[5~`],
+    ["ppage", `${ESC}[5~`],
+    ["pagedown", `${ESC}[6~`],
+    ["pgdn", `${ESC}[6~`],
+    ["npage", `${ESC}[6~`],
+    ["insert", `${ESC}[2~`],
+    ["ic", `${ESC}[2~`],
+    ["delete", `${ESC}[3~`],
+    ["del", `${ESC}[3~`],
+    ["dc", `${ESC}[3~`],
+    ["btab", `${ESC}[Z`],
+    ["f1", `${ESC}OP`],
+    ["f2", `${ESC}OQ`],
+    ["f3", `${ESC}OR`],
+    ["f4", `${ESC}OS`],
+    ["f5", `${ESC}[15~`],
+    ["f6", `${ESC}[17~`],
+    ["f7", `${ESC}[18~`],
+    ["f8", `${ESC}[19~`],
+    ["f9", `${ESC}[20~`],
+    ["f10", `${ESC}[21~`],
+    ["f11", `${ESC}[23~`],
+    ["f12", `${ESC}[24~`],
+    ["kp/", `${ESC}Oo`],
+    ["kp*", `${ESC}Oj`],
+    ["kp-", `${ESC}Om`],
+    ["kp+", `${ESC}Ok`],
+    ["kp7", `${ESC}Ow`],
+    ["kp8", `${ESC}Ox`],
+    ["kp9", `${ESC}Oy`],
+    ["kp4", `${ESC}Ot`],
+    ["kp5", `${ESC}Ou`],
+    ["kp6", `${ESC}Ov`],
+    ["kp1", `${ESC}Oq`],
+    ["kp2", `${ESC}Or`],
+    ["kp3", `${ESC}Os`],
+    ["kp0", `${ESC}Op`],
+    ["kp.", `${ESC}On`],
+    ["kpenter", `${ESC}OM`],
+]);
+const modifiableNamedKeys = new Set([
+    "up",
+    "down",
+    "left",
+    "right",
+    "home",
+    "end",
+    "pageup",
+    "pgup",
+    "ppage",
+    "pagedown",
+    "pgdn",
+    "npage",
+    "insert",
+    "ic",
+    "delete",
+    "del",
+    "dc",
+]);
+export function encodeKeySequence(request) {
+    const warnings = [];
+    let data = "";
+    if (request.literal) {
+        data += request.literal;
+    }
+    if (request.hex?.length) {
+        for (const raw of request.hex) {
+            const byte = parseHexByte(raw);
+            if (byte === null) {
+                warnings.push(`Invalid hex byte: ${raw}`);
+                continue;
+            }
+            data += String.fromCharCode(byte);
+        }
+    }
+    if (request.keys?.length) {
+        for (const token of request.keys) {
+            data += encodeKeyToken(token, warnings);
+        }
+    }
+    return { data, warnings };
+}
+export function encodePaste(text, bracketed = true) {
+    if (!bracketed) {
+        return text;
+    }
+    return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+}
+function encodeKeyToken(raw, warnings) {
+    const token = raw.trim();
+    if (!token) {
+        return "";
+    }
+    if (token.length === 2 && token.startsWith("^")) {
+        const ctrl = toCtrlChar(token[1]);
+        if (ctrl) {
+            return ctrl;
+        }
+    }
+    const parsed = parseModifiers(token);
+    const base = parsed.base;
+    const baseLower = base.toLowerCase();
+    if (baseLower === "tab" && parsed.mods.shift) {
+        return `${ESC}[Z`;
+    }
+    const baseSeq = namedKeyMap.get(baseLower);
+    if (baseSeq) {
+        let seq = baseSeq;
+        if (modifiableNamedKeys.has(baseLower) && hasAnyModifier(parsed.mods)) {
+            const mod = xtermModifier(parsed.mods);
+            if (mod > 1) {
+                const modified = applyXtermModifier(seq, mod);
+                if (modified) {
+                    seq = modified;
+                    return seq;
+                }
+            }
+        }
+        if (parsed.mods.alt) {
+            return `${ESC}${seq}`;
+        }
+        return seq;
+    }
+    if (base.length === 1) {
+        return applyCharModifiers(base, parsed.mods);
+    }
+    if (parsed.hasModifiers) {
+        warnings.push(`Unknown key "${base}" for modifiers; sending literal.`);
+    }
+    return base;
+}
+function parseModifiers(token) {
+    const mods = { ctrl: false, alt: false, shift: false };
+    let rest = token;
+    let sawModifiers = false;
+    while (rest.length > 2 && rest[1] === "-") {
+        const mod = rest[0].toLowerCase();
+        if (mod === "c") {
+            mods.ctrl = true;
+        }
+        else if (mod === "m") {
+            mods.alt = true;
+        }
+        else if (mod === "s") {
+            mods.shift = true;
+        }
+        else {
+            break;
+        }
+        sawModifiers = true;
+        rest = rest.slice(2);
+    }
+    return { mods, base: rest, hasModifiers: sawModifiers };
+}
+function applyCharModifiers(char, mods) {
+    let value = char;
+    if (mods.shift && value.length === 1 && /[a-z]/.test(value)) {
+        value = value.toUpperCase();
+    }
+    if (mods.ctrl) {
+        const ctrl = toCtrlChar(value);
+        if (ctrl) {
+            value = ctrl;
+        }
+    }
+    if (mods.alt) {
+        value = `${ESC}${value}`;
+    }
+    return value;
+}
+function toCtrlChar(char) {
+    if (char.length !== 1) {
+        return null;
+    }
+    if (char === "?") {
+        return "\x7f";
+    }
+    const code = char.toUpperCase().charCodeAt(0);
+    if (code >= 64 && code <= 95) {
+        return String.fromCharCode(code & 0x1f);
+    }
+    return null;
+}
+function xtermModifier(mods) {
+    let mod = 1;
+    if (mods.shift) {
+        mod += 1;
+    }
+    if (mods.alt) {
+        mod += 2;
+    }
+    if (mods.ctrl) {
+        mod += 4;
+    }
+    return mod;
+}
+/** Inlined from OpenClaw src/utils.ts — escapes special regex characters */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function applyXtermModifier(sequence, modifier) {
+    const escPattern = escapeRegExp(ESC);
+    const csiNumber = new RegExp(`^${escPattern}\\[(\\d+)([~A-Z])$`);
+    const csiArrow = new RegExp(`^${escPattern}\\[(A|B|C|D|H|F)$`);
+    const numberMatch = sequence.match(csiNumber);
+    if (numberMatch) {
+        return `${ESC}[${numberMatch[1]};${modifier}${numberMatch[2]}`;
+    }
+    const arrowMatch = sequence.match(csiArrow);
+    if (arrowMatch) {
+        return `${ESC}[1;${modifier}${arrowMatch[1]}`;
+    }
+    return null;
+}
+function hasAnyModifier(mods) {
+    return mods.ctrl || mods.alt || mods.shift;
+}
+function parseHexByte(raw) {
+    const trimmed = raw.trim().toLowerCase();
+    const normalized = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+    if (!/^[0-9a-f]{1,2}$/.test(normalized)) {
+        return null;
+    }
+    const value = Number.parseInt(normalized, 16);
+    if (Number.isNaN(value) || value < 0 || value > 0xff) {
+        return null;
+    }
+    return value;
+}
+//# sourceMappingURL=pty-keys.js.map