@aria-cli/tools 1.0.12 → 1.0.14

package/dist/definitions/process/process.js

@@ -1,386 +0,0 @@
-/**
- * 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`,
-                };
-        }
-    },
-};

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

@@ -1,254 +0,0 @@
-// 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;
-}