@aria-cli/tools 1.0.19 → 1.0.31

package/dist/utils/retry.js

@@ -0,0 +1,133 @@
+function createAbortError() {
+    const err = new Error("AbortError");
+    err.name = "AbortError";
+    return err;
+}
+/**
+ * AbortSignal-aware sleep that rejects immediately if the signal fires during the delay.
+ */
+function abortAwareSleep(ms, signal) {
+    if (signal?.aborted) {
+        return Promise.reject(createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let abortHandler;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+            resolve();
+        }, ms);
+        if (signal) {
+            abortHandler = () => {
+                if (settled)
+                    return;
+                settled = true;
+                signal.removeEventListener("abort", abortHandler);
+                clearTimeout(timer);
+                reject(createAbortError());
+            };
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
+    });
+}
+function isAbortError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const domErr = err;
+    return domErr.name === "AbortError" || err.message === "AbortError";
+}
+function getErrorCode(err) {
+    if (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        typeof err.code === "string") {
+        return err.code;
+    }
+    if (err instanceof Error && err.cause) {
+        const cause = err.cause;
+        if (typeof cause.code === "string") {
+            return cause.code;
+        }
+    }
+    return undefined;
+}
+export async function fetchWithRetry(url, init, options) {
+    const maxAttempts = options?.maxAttempts ?? 3;
+    const baseDelayMs = options?.baseDelayMs ?? 1000;
+    const maxDelayMs = options?.maxDelayMs ?? 30000;
+    const retryableStatuses = options?.retryableStatuses ?? [429, 500, 502, 503, 504];
+    const retryableCodes = options?.retryableCodes ?? [
+        "ECONNRESET",
+        "ETIMEDOUT",
+        "EPIPE",
+        "ENETUNREACH",
+        "EHOSTUNREACH",
+        "ECONNREFUSED",
+        "EAI_AGAIN",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_SOCKET",
+    ];
+    const doFetch = options?.fetchFn ?? fetch;
+    const signal = init.signal ?? null;
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            const response = await doFetch(url, init);
+            // Check for Cloudflare 403 challenge
+            if (response.status === 403 && response.headers.get("cf-mitigated") === "challenge") {
+                if (attempt < maxAttempts - 1) {
+                    // Retry with simplified UA
+                    const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+                    await abortAwareSleep(delay, signal);
+                    continue;
+                }
+                // Last attempt - throw
+                throw new Error(`Cloudflare challenge after ${maxAttempts} attempts: ${response.status}`);
+            }
+            // Check for retryable status codes
+            if (!response.ok && retryableStatuses.includes(response.status)) {
+                if (attempt < maxAttempts - 1) {
+                    const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+                    await abortAwareSleep(delay, signal);
+                    continue;
+                }
+                // Last attempt - throw
+                throw new Error(`Request failed after ${maxAttempts} attempts: ${response.status}`);
+            }
+            return response;
+        }
+        catch (err) {
+            // Re-throw AbortError immediately — do not retry aborted requests
+            if (isAbortError(err)) {
+                throw err;
+            }
+            const code = getErrorCode(err);
+            if (code && retryableCodes.includes(code) && attempt < maxAttempts - 1) {
+                const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+                await abortAwareSleep(delay, signal);
+                continue;
+            }
+            lastError = err;
+            throw err;
+        }
+    }
+    throw lastError ?? new Error("fetchWithRetry: unreachable");
+}
+export async function fetchWithSsrf(url, init, retryOptions) {
+    const { fetchWithDnsPinning } = await import("../security/dns-pinning.js");
+    return fetchWithRetry(url, init, {
+        ...retryOptions,
+        fetchFn: async (attemptUrl, attemptInit) => {
+            return fetchWithDnsPinning(attemptUrl, attemptInit);
+        },
+    });
+}
+//# sourceMappingURL=retry.js.map

package/dist/utils/safe-parse-json.js

@@ -0,0 +1,161 @@
+/**
+ * Safe JSON extraction and parsing utilities for LLM output.
+ *
+ * Handles code fences, preamble text, bare JSON, and validates against Zod schemas.
+ * NEVER throws -- always returns a typed Result.
+ */
+const MAX_SCAN_CHARS = 12_000;
+const MAX_JSON_CANDIDATES = 16;
+function isJsonRootStart(char) {
+    return char === "{" || char === "[";
+}
+/**
+ * Find the end index of a balanced JSON root (object/array) starting at `start`.
+ * Returns -1 when no balanced root can be found.
+ */
+function findBalancedJsonEnd(input, start) {
+    if (start < 0 || start >= input.length)
+        return -1;
+    const first = input[start];
+    if (!isJsonRootStart(first))
+        return -1;
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < input.length; i++) {
+        const char = input[i];
+        if (!char)
+            continue;
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "{" || char === "[") {
+            stack.push(char);
+            continue;
+        }
+        if (char === "}" || char === "]") {
+            const opener = stack.pop();
+            if (!opener)
+                return -1;
+            if ((opener === "{" && char !== "}") || (opener === "[" && char !== "]")) {
+                return -1;
+            }
+            if (stack.length === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function collectJsonCandidates(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    const seen = new Set();
+    const candidates = [];
+    const add = (candidate) => {
+        if (candidates.length >= MAX_JSON_CANDIDATES)
+            return;
+        const value = candidate.trim();
+        if (!value || !isJsonRootStart(value[0] ?? ""))
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        candidates.push(value);
+    };
+    const collectFromText = (text) => {
+        const bounded = text.slice(0, MAX_SCAN_CHARS);
+        for (let i = 0; i < bounded.length && candidates.length < MAX_JSON_CANDIDATES; i++) {
+            const char = bounded[i];
+            if (!char || !isJsonRootStart(char))
+                continue;
+            const end = findBalancedJsonEnd(bounded, i);
+            if (end === -1)
+                continue;
+            add(bounded.slice(i, end + 1));
+            i = end;
+        }
+    };
+    // 1) Prefer explicit code-fence blocks first.
+    const fenceRegex = /```(?:json|JSON)?\s*\n?([\s\S]*?)```/g;
+    for (const match of trimmed.matchAll(fenceRegex)) {
+        const fenced = match[1]?.trim();
+        if (!fenced)
+            continue;
+        if (isJsonRootStart(fenced[0] ?? "")) {
+            add(fenced);
+        }
+        else {
+            collectFromText(fenced);
+        }
+        if (candidates.length >= MAX_JSON_CANDIDATES)
+            break;
+    }
+    // 2) Full-text scan (handles preamble + trailing text + multiple snippets).
+    if (candidates.length < MAX_JSON_CANDIDATES) {
+        if (isJsonRootStart(trimmed[0] ?? "")) {
+            add(trimmed);
+        }
+        collectFromText(trimmed);
+    }
+    return candidates;
+}
+/**
+ * Extract JSON substring from LLM output.
+ * Returns the first candidate found by robust balanced scanning.
+ */
+export function extractJson(raw) {
+    return collectJsonCandidates(raw)[0] ?? null;
+}
+/**
+ * Safely extract and parse JSON from LLM output with Zod validation.
+ * Handles code fences, preamble text, bare JSON.
+ * NEVER throws -- always returns a typed Result.
+ */
+export function safeParseJson(raw, schema) {
+    const candidates = collectJsonCandidates(raw);
+    if (candidates.length === 0) {
+        return { ok: false, reason: "no_json", raw };
+    }
+    let parseErrorRaw = null;
+    let schemaMismatchRaw = null;
+    for (const jsonStr of candidates) {
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonStr);
+        }
+        catch {
+            parseErrorRaw = jsonStr;
+            continue;
+        }
+        const validated = schema.safeParse(parsed);
+        if (validated.success) {
+            return { ok: true, data: validated.data };
+        }
+        schemaMismatchRaw = jsonStr;
+    }
+    if (schemaMismatchRaw) {
+        return { ok: false, reason: "schema_mismatch", raw: schemaMismatchRaw };
+    }
+    if (parseErrorRaw) {
+        return { ok: false, reason: "parse_error", raw: parseErrorRaw };
+    }
+    return { ok: false, reason: "no_json", raw };
+}
+//# sourceMappingURL=safe-parse-json.js.map

package/dist/utils/url.js

@@ -0,0 +1,20 @@
+/**
+ * Convert GitHub blob URLs to raw.githubusercontent.com URLs.
+ * GitHub blob URLs return HTML wrappers; raw URLs return actual file content.
+ */
+export function normalizeGitHubUrl(url) {
+    const match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/(.+)$/);
+    if (match) {
+        return `https://raw.githubusercontent.com/${match[1]}/${match[2]}/${match[3]}`;
+    }
+    return url;
+}
+/**
+ * Get configurable User-Agent string.
+ * Reads from ARIA_USER_AGENT env var, falls back to default.
+ */
+export function getUserAgent() {
+    const DEFAULT_UA = `Mozilla/5.0 (compatible; ARIA/1.0.0; +https://github.com/aria)`;
+    return process.env.ARIA_USER_AGENT ?? DEFAULT_UA;
+}
+//# sourceMappingURL=url.js.map

package/dist-cjs/ask-user-interaction.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AskUserPauseRequiredError = void 0;
+exports.isAskUserPauseRequiredError = isAskUserPauseRequiredError;
+const ASK_USER_PAUSE_REQUIRED_CODE = "ASK_USER_PAUSE_REQUIRED";
+class AskUserPauseRequiredError extends Error {
+    code = ASK_USER_PAUSE_REQUIRED_CODE;
+    questions;
+    constructor(questions, message = "ask_user requires additional answers before this run can continue.") {
+        super(message);
+        this.name = "AskUserPauseRequiredError";
+        this.questions = questions.map((question) => ({
+            question: question.question,
+            ...(Array.isArray(question.options) ? { options: [...question.options] } : {}),
+        }));
+    }
+}
+exports.AskUserPauseRequiredError = AskUserPauseRequiredError;
+function isAskUserPauseRequiredError(error) {
+    if (error instanceof AskUserPauseRequiredError)
+        return true;
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.code === ASK_USER_PAUSE_REQUIRED_CODE ||
+        (candidate.name === "AskUserPauseRequiredError" && Array.isArray(candidate.questions)));
+}
+//# sourceMappingURL=ask-user-interaction.js.map

package/dist-cjs/cache/web-cache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseCache = exports.fetchCache = exports.searchCache = exports.WebCache = void 0;
+class WebCache {
+    maxEntries;
+    ttlMs;
+    cache = new Map();
+    setCallCount = 0;
+    /** How often to run proactive eviction (every N set() calls) */
+    static EVICTION_INTERVAL = 100;
+    constructor(maxEntries = 100, ttlMs = 15 * 60 * 1000) {
+        this.maxEntries = maxEntries;
+        this.ttlMs = ttlMs;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry || Date.now() > entry.expiresAt) {
+            if (entry)
+                this.cache.delete(key);
+            return undefined;
+        }
+        // Touch for true LRU semantics (recently read becomes most-recent)
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        // Update-in-place should also refresh recency
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // Proactive eviction: sweep expired entries periodically to prevent memory bloat
+        this.setCallCount++;
+        if (this.setCallCount % WebCache.EVICTION_INTERVAL === 0) {
+            this.evictExpired();
+        }
+        if (this.cache.size >= this.maxEntries) {
+            // Evict least recently used (oldest key in Map iteration order)
+            const lruKey = this.cache.keys().next().value;
+            if (lruKey)
+                this.cache.delete(lruKey);
+        }
+        this.cache.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+    }
+    /**
+     * Proactively remove all expired entries from the cache.
+     * Called periodically from set() to prevent expired entries from
+     * consuming memory until they are accessed or evicted by LRU.
+     */
+    evictExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            if (entry.expiresAt <= now) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /** Remove all entries from the cache */
+    clear() {
+        this.cache.clear();
+    }
+    /** Current number of entries in the cache */
+    get size() {
+        return this.cache.size;
+    }
+}
+exports.WebCache = WebCache;
+exports.searchCache = new WebCache(100);
+exports.fetchCache = new WebCache(50);
+exports.browseCache = new WebCache(50);
+//# sourceMappingURL=web-cache.js.map

package/dist-cjs/definitions/arion.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Arion tool definitions
+ *
+ * Tools: hatch_arion, rest_arion, wake_arion, retire_arion (4 tools)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARION_TOOL_DEFINITIONS = void 0;
+const index_js_1 = require("../executors/index.js");
+const hatch_arion = {
+    name: "hatch_arion",
+    description: "Create a new arion persona with specified personality, traits, and beliefs. Requires user confirmation.",
+    category: "arion",
+    parameters: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "The arion's unique name" },
+            emoji: { type: "string", description: "Visual emoji identifier" },
+            traits: {
+                type: "array",
+                items: { type: "string" },
+                description: "Core personality traits",
+            },
+            style: {
+                type: "string",
+                enum: ["formal", "casual", "technical", "friendly"],
+                description: "Communication style",
+            },
+            beliefs: {
+                type: "array",
+                items: { type: "string" },
+                description: "Core beliefs to seed into memory",
+            },
+            background: { type: "string", description: "Brief backstory or context" },
+            quirks: {
+                type: "array",
+                items: { type: "string" },
+                description: "Unique behavioral quirks",
+            },
+            strengths: {
+                type: "array",
+                items: { type: "string" },
+                description: "Areas of particular strength",
+            },
+        },
+        required: ["name", "traits", "style"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeHatchArion,
+};
+const rest_arion = {
+    name: "rest_arion",
+    description: "Put an arion persona to rest. Triggers deep memory consolidation before resting.",
+    category: "arion",
+    parameters: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Name of the arion to rest" },
+        },
+        required: ["name"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeRestArion,
+};
+const wake_arion = {
+    name: "wake_arion",
+    description: "Wake a resting arion persona, making it available for use.",
+    category: "arion",
+    parameters: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Name of the resting arion to wake",
+            },
+        },
+        required: ["name"],
+    },
+    riskLevel: "moderate",
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeWakeArion,
+};
+const retire_arion = {
+    name: "retire_arion",
+    description: "Permanently retire an arion persona. This action cannot be undone.",
+    category: "arion",
+    parameters: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Name of the arion to retire" },
+        },
+        required: ["name"],
+    },
+    riskLevel: "dangerous",
+    requiresConfirmation: true,
+    isReadOnly: false,
+    loadingTier: "always",
+    execute: index_js_1.executeRetireArion,
+};
+/** Arion tool definitions (4) */
+exports.ARION_TOOL_DEFINITIONS = [hatch_arion, rest_arion, wake_arion, retire_arion];
+//# sourceMappingURL=arion.js.map