@aria-cli/tools 1.0.19 → 1.0.31

package/dist-cjs/definitions/patch/patch-parser.js

@@ -0,0 +1,216 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, rewired to ARIA Tool interface
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_CHANGE_CONTEXT_MARKER = exports.CHANGE_CONTEXT_MARKER = exports.EOF_MARKER = exports.MOVE_TO_MARKER = exports.UPDATE_FILE_MARKER = exports.DELETE_FILE_MARKER = exports.ADD_FILE_MARKER = exports.END_PATCH_MARKER = exports.BEGIN_PATCH_MARKER = void 0;
+exports.normalizeUnicodeSpaces = normalizeUnicodeSpaces;
+exports.parsePatchText = parsePatchText;
+exports.checkPatchBoundariesLenient = checkPatchBoundariesLenient;
+exports.parseOneHunk = parseOneHunk;
+exports.parseUpdateFileChunk = parseUpdateFileChunk;
+// ── Marker Constants ───────────────────────────────────────────────
+exports.BEGIN_PATCH_MARKER = "*** Begin Patch";
+exports.END_PATCH_MARKER = "*** End Patch";
+exports.ADD_FILE_MARKER = "*** Add File: ";
+exports.DELETE_FILE_MARKER = "*** Delete File: ";
+exports.UPDATE_FILE_MARKER = "*** Update File: ";
+exports.MOVE_TO_MARKER = "*** Move to: ";
+exports.EOF_MARKER = "*** End of File";
+exports.CHANGE_CONTEXT_MARKER = "@@ ";
+exports.EMPTY_CHANGE_CONTEXT_MARKER = "@@";
+// ── Unicode Normalization ──────────────────────────────────────────
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizeUnicodeSpaces(value) {
+    return value.replace(UNICODE_SPACES, " ");
+}
+// ── Parser ─────────────────────────────────────────────────────────
+function parsePatchText(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Invalid patch: input is empty.");
+    }
+    const lines = trimmed.split(/\r?\n/);
+    const validated = checkPatchBoundariesLenient(lines);
+    const hunks = [];
+    const lastLineIndex = validated.length - 1;
+    let remaining = validated.slice(1, lastLineIndex);
+    let lineNumber = 2;
+    while (remaining.length > 0) {
+        const { hunk, consumed } = parseOneHunk(remaining, lineNumber);
+        hunks.push(hunk);
+        lineNumber += consumed;
+        remaining = remaining.slice(consumed);
+    }
+    return { hunks, patch: validated.join("\n") };
+}
+function checkPatchBoundariesLenient(lines) {
+    const strictError = checkPatchBoundariesStrict(lines);
+    if (!strictError) {
+        return lines;
+    }
+    if (lines.length < 4) {
+        throw new Error(strictError);
+    }
+    const first = lines[0];
+    const last = lines[lines.length - 1];
+    if ((first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') && last?.endsWith("EOF")) {
+        const inner = lines.slice(1, lines.length - 1);
+        const innerError = checkPatchBoundariesStrict(inner);
+        if (!innerError) {
+            return inner;
+        }
+        throw new Error(innerError);
+    }
+    throw new Error(strictError);
+}
+function checkPatchBoundariesStrict(lines) {
+    const firstLine = lines[0]?.trim();
+    const lastLine = lines[lines.length - 1]?.trim();
+    if (firstLine === exports.BEGIN_PATCH_MARKER && lastLine === exports.END_PATCH_MARKER) {
+        return null;
+    }
+    if (firstLine !== exports.BEGIN_PATCH_MARKER) {
+        return "The first line of the patch must be '*** Begin Patch'";
+    }
+    return "The last line of the patch must be '*** End Patch'";
+}
+function parseOneHunk(lines, lineNumber) {
+    if (lines.length === 0) {
+        throw new Error(`Invalid patch hunk at line ${lineNumber}: empty hunk`);
+    }
+    const firstLine = lines[0].trim();
+    if (firstLine.startsWith(exports.ADD_FILE_MARKER)) {
+        const targetPath = firstLine.slice(exports.ADD_FILE_MARKER.length);
+        let contents = "";
+        let consumed = 1;
+        for (const addLine of lines.slice(1)) {
+            if (addLine.startsWith("+")) {
+                contents += `${addLine.slice(1)}\n`;
+                consumed += 1;
+            }
+            else {
+                break;
+            }
+        }
+        return {
+            hunk: { kind: "add", path: targetPath, contents },
+            consumed,
+        };
+    }
+    if (firstLine.startsWith(exports.DELETE_FILE_MARKER)) {
+        const targetPath = firstLine.slice(exports.DELETE_FILE_MARKER.length);
+        return {
+            hunk: { kind: "delete", path: targetPath },
+            consumed: 1,
+        };
+    }
+    if (firstLine.startsWith(exports.UPDATE_FILE_MARKER)) {
+        const targetPath = firstLine.slice(exports.UPDATE_FILE_MARKER.length);
+        let remaining = lines.slice(1);
+        let consumed = 1;
+        let movePath;
+        const moveCandidate = remaining[0]?.trim();
+        if (moveCandidate?.startsWith(exports.MOVE_TO_MARKER)) {
+            movePath = moveCandidate.slice(exports.MOVE_TO_MARKER.length);
+            remaining = remaining.slice(1);
+            consumed += 1;
+        }
+        const chunks = [];
+        while (remaining.length > 0) {
+            if (remaining[0].trim() === "") {
+                remaining = remaining.slice(1);
+                consumed += 1;
+                continue;
+            }
+            if (remaining[0].startsWith("***")) {
+                break;
+            }
+            const { chunk, consumed: chunkLines } = parseUpdateFileChunk(remaining, lineNumber + consumed, chunks.length === 0);
+            chunks.push(chunk);
+            remaining = remaining.slice(chunkLines);
+            consumed += chunkLines;
+        }
+        if (chunks.length === 0) {
+            throw new Error(`Invalid patch hunk at line ${lineNumber}: Update file hunk for path '${targetPath}' is empty`);
+        }
+        return {
+            hunk: {
+                kind: "update",
+                path: targetPath,
+                movePath,
+                chunks,
+            },
+            consumed,
+        };
+    }
+    throw new Error(`Invalid patch hunk at line ${lineNumber}: '${lines[0]}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`);
+}
+function parseUpdateFileChunk(lines, lineNumber, allowMissingContext) {
+    if (lines.length === 0) {
+        throw new Error(`Invalid patch hunk at line ${lineNumber}: Update hunk does not contain any lines`);
+    }
+    const firstLine = lines[0];
+    let changeContext;
+    let startIndex = 0;
+    if (firstLine === exports.EMPTY_CHANGE_CONTEXT_MARKER) {
+        startIndex = 1;
+    }
+    else if (firstLine.startsWith(exports.CHANGE_CONTEXT_MARKER)) {
+        changeContext = firstLine.slice(exports.CHANGE_CONTEXT_MARKER.length);
+        startIndex = 1;
+    }
+    else if (!allowMissingContext) {
+        throw new Error(`Invalid patch hunk at line ${lineNumber}: Expected update hunk to start with a @@ context marker, got: '${firstLine}'`);
+    }
+    if (startIndex >= lines.length) {
+        throw new Error(`Invalid patch hunk at line ${lineNumber + 1}: Update hunk does not contain any lines`);
+    }
+    const chunk = {
+        changeContext,
+        oldLines: [],
+        newLines: [],
+        isEndOfFile: false,
+    };
+    let parsedLines = 0;
+    for (const line of lines.slice(startIndex)) {
+        if (line === exports.EOF_MARKER) {
+            if (parsedLines === 0) {
+                throw new Error(`Invalid patch hunk at line ${lineNumber + 1}: Update hunk does not contain any lines`);
+            }
+            chunk.isEndOfFile = true;
+            parsedLines += 1;
+            break;
+        }
+        const marker = line[0];
+        if (!marker) {
+            chunk.oldLines.push("");
+            chunk.newLines.push("");
+            parsedLines += 1;
+            continue;
+        }
+        if (marker === " ") {
+            const content = line.slice(1);
+            chunk.oldLines.push(content);
+            chunk.newLines.push(content);
+            parsedLines += 1;
+            continue;
+        }
+        if (marker === "+") {
+            chunk.newLines.push(line.slice(1));
+            parsedLines += 1;
+            continue;
+        }
+        if (marker === "-") {
+            chunk.oldLines.push(line.slice(1));
+            parsedLines += 1;
+            continue;
+        }
+        if (parsedLines === 0) {
+            throw new Error(`Invalid patch hunk at line ${lineNumber + 1}: Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`);
+        }
+        break;
+    }
+    return { chunk, consumed: parsedLines + startIndex };
+}
+//# sourceMappingURL=patch-parser.js.map

package/dist-cjs/definitions/patch/sandbox-paths.js

@@ -0,0 +1,114 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, rewired to ARIA Tool interface
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSandboxInputPath = resolveSandboxInputPath;
+exports.resolveSandboxPath = resolveSandboxPath;
+exports.assertSandboxPath = assertSandboxPath;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizeUnicodeSpaces(str) {
+    return str.replace(UNICODE_SPACES, " ");
+}
+function expandPath(filePath) {
+    const normalized = normalizeUnicodeSpaces(filePath);
+    if (normalized === "~") {
+        return node_os_1.default.homedir();
+    }
+    if (normalized.startsWith("~/")) {
+        return node_os_1.default.homedir() + normalized.slice(1);
+    }
+    return normalized;
+}
+function resolveToCwd(filePath, cwd) {
+    const expanded = expandPath(filePath);
+    if (node_path_1.default.isAbsolute(expanded)) {
+        return expanded;
+    }
+    return node_path_1.default.resolve(cwd, expanded);
+}
+function resolveSandboxInputPath(filePath, cwd) {
+    return resolveToCwd(filePath, cwd);
+}
+function resolveSandboxPath(params) {
+    const resolved = resolveSandboxInputPath(params.filePath, params.cwd);
+    const rootResolved = node_path_1.default.resolve(params.root);
+    const relative = node_path_1.default.relative(rootResolved, resolved);
+    if (!relative || relative === "") {
+        return { resolved, relative: "" };
+    }
+    if (relative.startsWith("..") || node_path_1.default.isAbsolute(relative)) {
+        throw new Error(`Path escapes sandbox root (${shortPath(rootResolved)}): ${params.filePath}`);
+    }
+    return { resolved, relative };
+}
+async function assertSandboxPath(params) {
+    const resolved = resolveSandboxPath(params);
+    await assertNoSymlinkEscape(resolved.relative, node_path_1.default.resolve(params.root), {
+        allowFinalSymlink: params.allowFinalSymlink,
+    });
+    return resolved;
+}
+async function assertNoSymlinkEscape(relative, root, options) {
+    if (!relative) {
+        return;
+    }
+    const rootReal = await tryRealpath(root);
+    const parts = relative.split(node_path_1.default.sep).filter(Boolean);
+    let current = root;
+    for (let idx = 0; idx < parts.length; idx += 1) {
+        const part = parts[idx];
+        const isLast = idx === parts.length - 1;
+        current = node_path_1.default.join(current, part);
+        try {
+            const stat = await promises_1.default.lstat(current);
+            if (stat.isSymbolicLink()) {
+                // Unlinking a symlink itself is safe even if it points outside the root. What we
+                // must prevent is traversing through a symlink to reach targets outside root.
+                if (options?.allowFinalSymlink && isLast) {
+                    return;
+                }
+                const target = await tryRealpath(current);
+                if (!isPathInside(rootReal, target)) {
+                    throw new Error(`Symlink escapes sandbox root (${shortPath(rootReal)}): ${shortPath(current)}`);
+                }
+                current = target;
+            }
+        }
+        catch (err) {
+            const anyErr = err;
+            if (anyErr.code === "ENOENT") {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+async function tryRealpath(value) {
+    try {
+        return await promises_1.default.realpath(value);
+    }
+    catch {
+        return node_path_1.default.resolve(value);
+    }
+}
+function isPathInside(root, target) {
+    const relative = node_path_1.default.relative(root, target);
+    if (!relative || relative === "") {
+        return true;
+    }
+    return !(relative.startsWith("..") || node_path_1.default.isAbsolute(relative));
+}
+function shortPath(value) {
+    if (value.startsWith(node_os_1.default.homedir())) {
+        return `~${value.slice(node_os_1.default.homedir().length)}`;
+    }
+    return value;
+}
+//# sourceMappingURL=sandbox-paths.js.map

package/dist-cjs/definitions/process/index.js

@@ -0,0 +1,9 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, rewired to ARIA Tool interface
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTool = void 0;
+var process_js_1 = require("./process.js");
+Object.defineProperty(exports, "processTool", { enumerable: true, get: function () { return process_js_1.processTool; } });
+//# sourceMappingURL=index.js.map

package/dist-cjs/definitions/process/process-registry.js

@@ -0,0 +1,232 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime (PI_BASH_JOB_TTL_MS env, gateway refs),
+// rewired imports to local session-slug
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionSlug = createSessionSlug;
+exports.addSession = addSession;
+exports.getSession = getSession;
+exports.getFinishedSession = getFinishedSession;
+exports.deleteSession = deleteSession;
+exports.appendOutput = appendOutput;
+exports.drainSession = drainSession;
+exports.markExited = markExited;
+exports.markBackgrounded = markBackgrounded;
+exports.tail = tail;
+exports.trimWithCap = trimWithCap;
+exports.listRunningSessions = listRunningSessions;
+exports.listFinishedSessions = listFinishedSessions;
+exports.clearFinished = clearFinished;
+exports.resetProcessRegistryForTests = resetProcessRegistryForTests;
+exports.setJobTtlMs = setJobTtlMs;
+const session_slug_js_1 = require("./session-slug.js");
+const DEFAULT_JOB_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const MIN_JOB_TTL_MS = 60 * 1000; // 1 minute
+const MAX_JOB_TTL_MS = 3 * 60 * 60 * 1000; // 3 hours
+const DEFAULT_PENDING_OUTPUT_CHARS = 30_000;
+function clampTtl(value) {
+    if (!value || Number.isNaN(value)) {
+        return DEFAULT_JOB_TTL_MS;
+    }
+    return Math.min(Math.max(value, MIN_JOB_TTL_MS), MAX_JOB_TTL_MS);
+}
+let jobTtlMs = DEFAULT_JOB_TTL_MS;
+const runningSessions = new Map();
+const finishedSessions = new Map();
+let sweeper = null;
+function isSessionIdTaken(id) {
+    return runningSessions.has(id) || finishedSessions.has(id);
+}
+function createSessionSlug() {
+    return (0, session_slug_js_1.createSessionSlug)(isSessionIdTaken);
+}
+function addSession(session) {
+    runningSessions.set(session.id, session);
+    startSweeper();
+}
+function getSession(id) {
+    return runningSessions.get(id);
+}
+function getFinishedSession(id) {
+    return finishedSessions.get(id);
+}
+function deleteSession(id) {
+    runningSessions.delete(id);
+    finishedSessions.delete(id);
+}
+function appendOutput(session, stream, chunk) {
+    session.pendingStdout ??= [];
+    session.pendingStderr ??= [];
+    session.pendingStdoutChars ??= sumPendingChars(session.pendingStdout);
+    session.pendingStderrChars ??= sumPendingChars(session.pendingStderr);
+    const buffer = stream === "stdout" ? session.pendingStdout : session.pendingStderr;
+    const bufferChars = stream === "stdout" ? session.pendingStdoutChars : session.pendingStderrChars;
+    const pendingCap = Math.min(session.pendingMaxOutputChars ?? DEFAULT_PENDING_OUTPUT_CHARS, session.maxOutputChars);
+    buffer.push(chunk);
+    let pendingChars = bufferChars + chunk.length;
+    if (pendingChars > pendingCap) {
+        session.truncated = true;
+        pendingChars = capPendingBuffer(buffer, pendingChars, pendingCap);
+    }
+    if (stream === "stdout") {
+        session.pendingStdoutChars = pendingChars;
+    }
+    else {
+        session.pendingStderrChars = pendingChars;
+    }
+    session.totalOutputChars += chunk.length;
+    const aggregated = trimWithCap(session.aggregated + chunk, session.maxOutputChars);
+    session.truncated =
+        session.truncated || aggregated.length < session.aggregated.length + chunk.length;
+    session.aggregated = aggregated;
+    session.tail = tail(session.aggregated, 2000);
+}
+function drainSession(session) {
+    const stdout = session.pendingStdout.join("");
+    const stderr = session.pendingStderr.join("");
+    session.pendingStdout = [];
+    session.pendingStderr = [];
+    session.pendingStdoutChars = 0;
+    session.pendingStderrChars = 0;
+    return { stdout, stderr };
+}
+function markExited(session, exitCode, exitSignal, status) {
+    session.exited = true;
+    session.exitCode = exitCode;
+    session.exitSignal = exitSignal;
+    session.tail = tail(session.aggregated, 2000);
+    moveToFinished(session, status);
+}
+function markBackgrounded(session) {
+    session.backgrounded = true;
+}
+function moveToFinished(session, status) {
+    runningSessions.delete(session.id);
+    // Clean up child process stdio streams to prevent FD leaks
+    if (session.child) {
+        session.child.stdin?.destroy?.();
+        session.child.stdout?.destroy?.();
+        session.child.stderr?.destroy?.();
+        session.child.removeAllListeners();
+        delete session.child;
+    }
+    // Clean up stdin wrapper
+    if (session.stdin) {
+        if (typeof session.stdin.destroy === "function") {
+            session.stdin.destroy();
+        }
+        else if (typeof session.stdin.end === "function") {
+            session.stdin.end();
+        }
+        try {
+            session.stdin.destroyed = true;
+        }
+        catch {
+            // Ignore if read-only
+        }
+        delete session.stdin;
+    }
+    if (!session.backgrounded) {
+        return;
+    }
+    finishedSessions.set(session.id, {
+        id: session.id,
+        command: session.command,
+        startedAt: session.startedAt,
+        endedAt: Date.now(),
+        cwd: session.cwd,
+        status,
+        exitCode: session.exitCode,
+        exitSignal: session.exitSignal,
+        aggregated: session.aggregated,
+        tail: session.tail,
+        truncated: session.truncated,
+        totalOutputChars: session.totalOutputChars,
+    });
+}
+function tail(text, max = 2000) {
+    if (text.length <= max) {
+        return text;
+    }
+    return text.slice(text.length - max);
+}
+function sumPendingChars(buffer) {
+    let total = 0;
+    for (const chunk of buffer) {
+        total += chunk.length;
+    }
+    return total;
+}
+function capPendingBuffer(buffer, pendingChars, cap) {
+    if (pendingChars <= cap) {
+        return pendingChars;
+    }
+    const last = buffer.at(-1);
+    if (last && last.length >= cap) {
+        buffer.length = 0;
+        buffer.push(last.slice(last.length - cap));
+        return cap;
+    }
+    while (buffer.length && buffer[0] !== undefined && pendingChars - buffer[0].length >= cap) {
+        pendingChars -= buffer[0].length;
+        buffer.shift();
+    }
+    if (buffer.length && buffer[0] !== undefined && pendingChars > cap) {
+        const overflow = pendingChars - cap;
+        buffer[0] = buffer[0].slice(overflow);
+        pendingChars = cap;
+    }
+    return pendingChars;
+}
+function trimWithCap(text, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    return text.slice(text.length - max);
+}
+function listRunningSessions() {
+    return Array.from(runningSessions.values()).filter((s) => s.backgrounded);
+}
+function listFinishedSessions() {
+    return Array.from(finishedSessions.values());
+}
+function clearFinished() {
+    finishedSessions.clear();
+}
+function resetProcessRegistryForTests() {
+    runningSessions.clear();
+    finishedSessions.clear();
+    stopSweeper();
+}
+function setJobTtlMs(value) {
+    if (value === undefined || Number.isNaN(value)) {
+        return;
+    }
+    jobTtlMs = clampTtl(value);
+    stopSweeper();
+    startSweeper();
+}
+function pruneFinishedSessions() {
+    const cutoff = Date.now() - jobTtlMs;
+    for (const [id, session] of finishedSessions.entries()) {
+        if (session.endedAt < cutoff) {
+            finishedSessions.delete(id);
+        }
+    }
+}
+function startSweeper() {
+    if (sweeper) {
+        return;
+    }
+    sweeper = setInterval(pruneFinishedSessions, Math.max(30_000, jobTtlMs / 6));
+    sweeper.unref?.();
+}
+function stopSweeper() {
+    if (!sweeper) {
+        return;
+    }
+    clearInterval(sweeper);
+    sweeper = null;
+}
+//# sourceMappingURL=process-registry.js.map