@aria-cli/tools 1.0.19 → 1.0.31

package/dist-cjs/executors/self-diagnose.d.ts

@@ -1,89 +0,0 @@
-/**
- * @aria/tools - Self-diagnose tool executor
- *
- * Pure signal diagnostic tool. 5 sections, zero noise:
- * 1. runtime  — process health + resource leaks
- * 2. errors   — structured errors from JSONL (active + rotated)
- * 3. crashes  — crash markers + dumps
- * 4. databases — sizes, WAL health, schema version
- * 5. daemon   — daemon audit + delegation journal
- */
-import type { ToolContext, ToolResult } from "../types.js";
-export interface SelfDiagnoseInput {
-    focus?: string;
-    sections?: string[];
-    since?: string;
-    limit?: number;
-}
-export interface RuntimeInfo {
-    pid: number;
-    uptime_s: number;
-    heap_mb: number;
-    rss_mb: number;
-    node_version: string;
-    platform: string;
-    arch: string;
-    cwd: string;
-    session_id: string | null;
-    socket_dirs: number;
-    owner_files: number;
-    relaunch_pending: boolean;
-}
-export interface ErrorEntry {
-    timestamp: string;
-    severity: string;
-    category: string;
-    message: string;
-    stackTrace: string;
-    source: string;
-}
-export interface CrashInfo {
-    file: string;
-    size?: number;
-    timestamp?: string;
-    error_message?: string;
-    content?: Record<string, unknown>;
-}
-export interface DbInfo {
-    name: string;
-    size_mb: string;
-    wal_mb: string | null;
-    modified: string;
-    schema_version?: number;
-}
-export interface DaemonEntry {
-    source: string;
-    entries: unknown[];
-}
-export interface NetworkInfo {
-    node_id: string | null;
-    display_name: string | null;
-    listen_port: number | null;
-    external_endpoint: string | null;
-    peer_count: number;
-    peers: Array<{
-        node_id: string;
-        name: string;
-        status: string;
-        last_seen: string | null;
-    }>;
-    tls_certs_present: boolean;
-    trusted_cas: number;
-    recent_tunnel_events: unknown[];
-    recent_diagnostics: unknown[];
-}
-export interface SelfDiagnoseOutput {
-    runtime: RuntimeInfo | null;
-    errors: ErrorEntry[] | null;
-    crashes: CrashInfo[] | null;
-    databases: DbInfo[] | null;
-    daemon: DaemonEntry[] | null;
-    network: NetworkInfo | null;
-    _meta: {
-        sections_requested: string[];
-        sections_returned: string[];
-        elapsed_ms: number;
-        errors: string[];
-    };
-}
-export declare function executeSelfDiagnose(input: SelfDiagnoseInput, ctx: ToolContext): Promise<ToolResult>;

package/dist-cjs/executors/session-history.d.ts

@@ -1,75 +0,0 @@
-/**
- * @aria/tools - Session History tool executor
- *
- * Implementation of session history operations for ARIA tool system.
- * Provides list, search, get, current, stats, delete, and set_title actions
- * against the SessionHistory SQLite database.
- */
-import type { ToolContext, ToolResult, SessionHistoryRef } from "../types.js";
-export type SessionHistoryAction = "list" | "search" | "get" | "current" | "stats" | "delete" | "set_title";
-export interface SessionHistoryInput {
-    /** Action to perform */
-    action: SessionHistoryAction;
-    /** Search query (for 'search' action) */
-    query?: string;
-    /** Session ID or prefix (for 'get', 'delete', 'set_title') */
-    sessionId?: string;
-    /** New title (for 'set_title' action) */
-    title?: string;
-    /** Max results (default 20) */
-    limit?: number;
-    /** Pagination offset (default 0) */
-    offset?: number;
-    /** Max messages to return per session (for 'get', default 50) */
-    messageLimit?: number;
-}
-export interface SessionListOutput {
-    sessions: Array<{
-        id: string;
-        title: string | null;
-        arion: string;
-        model: string;
-        messageCount: number;
-        updatedAt: string;
-        completedAt?: string;
-        preview: string;
-    }>;
-    total: number;
-    limit: number;
-    offset: number;
-}
-export interface SessionGetOutput {
-    id: string;
-    arion: string;
-    model: string;
-    messageCount: number;
-    messages: Array<{
-        role: string;
-        content: string;
-        createdAt: string;
-        toolCallId?: string;
-    }>;
-    metrics?: Array<{
-        turnCount?: number;
-        inputTokens?: number;
-        outputTokens?: number;
-        estimatedCost?: number;
-        wallTimeMs?: number;
-    }>;
-}
-export interface SessionCurrentOutput {
-    sessionId: string;
-}
-export interface SessionStatsOutput {
-    totalSessions: number;
-    incompleteSessions: number;
-}
-/**
- * Get the SessionHistoryRef — from ToolContext if wired, otherwise create
- * a fallback instance by dynamically importing @aria/cli's SessionHistory.
- */
-export declare function getSessionHistory(ctx: ToolContext): Promise<SessionHistoryRef | null>;
-/**
- * Execute a session_history action.
- */
-export declare function executeSessionHistory(input: SessionHistoryInput, ctx: ToolContext): Promise<ToolResult>;

package/dist-cjs/executors/shell-safety.d.ts

@@ -1,27 +0,0 @@
-/**
- * @aria/tools - Shell command risk classifier
- *
- * Statically classifies shell commands into risk tiers to gate execution:
- * - "safe"     : read-only, execute immediately without approval
- * - "moderate" : requires runtime policy handling (approval, allowlist, or autorun)
- * - "blocked"  : catastrophic, hard-denied — never execute
- */
-export type ShellRisk = "safe" | "moderate" | "blocked";
-/** Patterns that are unconditionally blocked — catastrophic risk. */
-export declare const BLOCKED_PATTERNS: RegExp[];
-/**
- * Classify a shell command's risk level.
- *
- * - "safe"     — skip approval, execute immediately
- * - "moderate" — handle via runtime policy (approval, allowlist, or autorun)
- * - "blocked"  — never execute, return error immediately
- */
-export declare function classifyCommand(command: string): ShellRisk;
-/**
- * Classify argv-based process execution (spawn/exec) with shell-aware behavior.
- *
- * When callers explicitly invoke a shell interpreter with `-c`, classify the
- * payload command text itself. This preserves catastrophic-command blocking
- * while avoiding false positives that would block every `bash -c ...` call.
- */
-export declare function classifyExecInvocation(program: string, args?: string[]): ShellRisk;

package/dist-cjs/executors/shell.d.ts

@@ -1,168 +0,0 @@
-/**
- * @aria/tools - Shell tool executors
- *
- * Implementation of shell operations for ARIA tool system.
- */
-import type { ProcessInfoRef, ToolContext, ToolResult } from "../types.js";
-/**
- * Environment variables that are dangerous in ALL contexts — including
- * the host's own process.env. These enable code injection or library
- * hijacking and should never reach child processes.
- */
-export declare const BLOCKED_ENV_VARS: Set<string>;
-export declare function isBlockedGitEnvVar(key: string): boolean;
-/**
- * Strip git-context env keys from a source env object.
- */
-export declare function sanitizeGitEnv(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): Record<string, string>;
-/**
- * Additional variables blocked from tool-injected input (inputEnv, ctx.env)
- * but NOT from process.env. The host's PATH/HOME/SHELL are legitimate —
- * only tool-provided overrides are dangerous (hijacking resolution paths).
- */
-export declare const BLOCKED_INPUT_ENV_VARS: Set<string>;
-/**
- * Merges environment variables from context and input.
- *
- * Three-tier filtering:
- * - process.env: filtered through BLOCKED_ENV_VARS (injection-only vars like LD_PRELOAD)
- * - ctx.env / inputEnv: filtered through BLOCKED_INPUT_ENV_VARS (also blocks PATH/HOME/SHELL hijacking)
- */
-export declare function mergeEnv(ctx: ToolContext, inputEnv?: Record<string, string>): Record<string, string>;
-/**
- * Sanitize environment for child processes without requiring a ToolContext.
- *
- * Applies the same two-tier filtering as mergeEnv:
- * - process.env is filtered through BLOCKED_ENV_VARS
- * - inputEnv (caller-supplied overrides) is filtered through BLOCKED_INPUT_ENV_VARS
- *
- * Intended for executors (e.g. PTY) that do not have a ToolContext.
- */
-export declare function sanitizeEnv(inputEnv?: Record<string, string>): Record<string, string>;
-export interface BashInput {
-    /** Shell command to execute */
-    command: string;
-    /** Working directory override */
-    cwd?: string;
-    /** Additional environment variables */
-    env?: Record<string, string>;
-    /** Timeout in milliseconds */
-    timeout?: number;
-}
-export interface BashOutput {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-/**
- * Executes a command through bash shell.
- * Supports shell features like pipes, redirection, and variable expansion.
- */
-export declare function executeBash(input: BashInput, ctx: ToolContext): Promise<ToolResult>;
-export interface ExecInput {
-    /** Program to execute */
-    program: string;
-    /** Arguments to pass to the program */
-    args?: string[];
-    /** Working directory override */
-    cwd?: string;
-    /** Additional environment variables */
-    env?: Record<string, string>;
-    /** Timeout in milliseconds */
-    timeout?: number;
-}
-export interface ExecOutput {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-/**
- * Executes a program directly without shell interpretation.
- * Safer than bash as it doesn't expand shell metacharacters.
- */
-export declare function executeExec(input: ExecInput, ctx: ToolContext): Promise<ToolResult>;
-export interface SpawnInput {
-    /** Program to execute */
-    program: string;
-    /** Arguments to pass to the program */
-    args?: string[];
-    /** Working directory override */
-    cwd?: string;
-    /** Additional environment variables */
-    env?: Record<string, string>;
-    /** Start as interactive PTY session (enables write_stdin). Default: false */
-    interactive?: boolean;
-}
-export interface SpawnOutput {
-    pid: number;
-}
-/**
- * Spawns a background process and returns immediately with its PID.
- * The process is detached and will continue running after the parent exits.
- */
-export declare function executeSpawn(input: SpawnInput, ctx: ToolContext): Promise<ToolResult>;
-export interface KillInput {
-    /** Process ID to kill */
-    pid: number;
-    /** Signal to send (default: SIGTERM) */
-    signal?: string;
-}
-export interface KillOutput {
-    pid: number;
-    signal: string;
-}
-/**
- * Sends a signal to terminate a process by PID.
- */
-export declare function executeKill(input: KillInput, ctx: ToolContext): Promise<ToolResult>;
-export interface ListProcessesInput {
-    /** Include exited process snapshots from recent registry history */
-    includeExited?: boolean;
-}
-export interface ListProcessesOutput {
-    processes: ProcessInfoRef[];
-    count: number;
-}
-export declare function executeListProcesses(rawInput: unknown, ctx: ToolContext): Promise<ToolResult>;
-export interface WaitProcessInput {
-    /** PID to wait on */
-    pid: number;
-    /** Max wait duration in milliseconds (max 300000, default 30000) */
-    timeoutMs?: number;
-    /** Deprecated alias for timeoutMs */
-    timeout?: number;
-}
-export interface WaitProcessOutput {
-    pid: number;
-    status: "running" | "exited";
-    exited: boolean;
-    timedOut: boolean;
-    waitedMs: number;
-    command: string | null;
-    args: string[];
-    cwd: string | null;
-    interactive: boolean;
-    startedAt: string;
-    endedAt: string | null;
-    runtimeMs: number;
-    exitCode: number | null;
-    signal: string | null;
-}
-export declare function executeWaitProcess(rawInput: unknown, ctx: ToolContext): Promise<ToolResult>;
-export interface WriteStdinInput {
-    /** PID of the interactive process to write to */
-    pid: number;
-    /** Input string to send to the process */
-    input: string;
-    /** Milliseconds to wait for output after writing (max 30000) */
-    timeout?: number;
-}
-export interface WriteStdinOutput {
-    /** Recent output from the session after writing */
-    output: string;
-}
-/**
- * Sends input to an interactive PTY session by PID.
- * Requires the process to have been spawned with interactive=true.
- */
-export declare function executeWriteStdin(rawInput: unknown, ctx: ToolContext): Promise<ToolResult>;

package/dist-cjs/executors/utils.d.ts

@@ -1,20 +0,0 @@
-/**
- * @aria/tools - Shared executor utilities
- *
- * Common helper functions used across all executor modules.
- */
-import type { ToolResult } from "../types.js";
-export { getErrorMessage } from "@aria-cli/types";
-/**
- * Creates a successful result.
- */
-export declare function success(message: string, data?: unknown): ToolResult;
-/**
- * Creates a failure result.
- */
-export declare function fail(message: string, data?: unknown): ToolResult;
-/**
- * Checks if a resolved path is within the allowed base directory.
- * Prevents path traversal attacks.
- */
-export declare function isPathWithinBase(resolvedPath: string, baseDir: string): boolean;

package/dist-cjs/executors/web.d.ts

@@ -1,89 +0,0 @@
-/**
- * @aria/tools - Web tool executors
- *
- * Implementation of web operations for ARIA tool system.
- */
-import type { ToolContext, ToolResult } from "../types.js";
-export interface WebSearchInput {
-    /** Search query */
-    query: string;
-    /** Maximum number of results */
-    limit?: number;
-    /** Search topic classification */
-    topic?: "general" | "news";
-    /** Restrict results to these domains */
-    domains?: string[];
-    /** Exclude results from these domains */
-    excludeDomains?: string[];
-    /** Restrict results by freshness window */
-    timeRange?: "day" | "week" | "month" | "year";
-}
-export interface WebSearchResult {
-    title: string;
-    url: string;
-    content: string;
-    score?: number;
-}
-export interface WebSearchOutput {
-    query: string;
-    results: WebSearchResult[];
-}
-/**
- * Searches the web using the SearchProviderRouter with automatic fallback.
- * Providers are selected based on available API keys (Brave, Tavily, Jina, Exa,
- * Firecrawl, DuckDuckGo). DuckDuckGo is always available as a last resort.
- *
- * Results are cached via LRU+TTL cache for 15 minutes.
- */
-export declare function executeWebSearch(input: WebSearchInput, ctx: ToolContext): Promise<ToolResult>;
-export interface WebFetchInput {
-    /** URL to fetch */
-    url: string;
-    /** Response format: 'text', 'html', or 'json' */
-    format?: "text" | "html" | "json";
-    /** Custom headers to include in the request */
-    headers?: Record<string, string>;
-    /** Request timeout in milliseconds (default: 30000) */
-    timeoutMs?: number;
-    /** Maximum response size in bytes (default: 1MB) */
-    maxSizeBytes?: number;
-}
-export interface WebFetchOutput {
-    content: unknown;
-    status: number;
-    contentType?: string;
-    fromCache: boolean;
-    fetchedAt: string;
-    finalUrl: string;
-    contentBytes: number;
-    truncated: boolean;
-}
-/**
- * Fetches content from a URL with retry resilience, caching, and security wrapping.
- * Uses fetchWithRetry for automatic retry on transient failures (429, 5xx, ECONNRESET).
- * Results are cached via LRU+TTL cache for 15 minutes.
- */
-export declare function executeWebFetch(input: WebFetchInput, ctx: ToolContext): Promise<ToolResult>;
-export interface BrowseInput {
-    /** URL to browse */
-    url: string;
-    /** Timeout in milliseconds (default: 30000) */
-    timeoutMs?: number;
-}
-export interface BrowseOutput {
-    url: string;
-    title: string;
-    content: string;
-    fromCache: boolean;
-    fetchedAt: string;
-    finalUrl: string;
-    contentBytes: number;
-    truncated: boolean;
-}
-/**
- * Browses a URL by fetching its HTML content and extracting Markdown.
- * Uses Readability.js + Turndown for article extraction with three-tier fallback.
- * Supports GitHub URL normalization, retry on transient failures, LRU+TTL caching,
- * and nonce-based external content wrapping.
- */
-export declare function executeBrowse(input: BrowseInput, ctx: ToolContext): Promise<ToolResult>;

package/dist-cjs/extraction/content-extraction.d.ts

@@ -1,48 +0,0 @@
-/**
- * Content Extraction — HTML to Markdown conversion with article detection
- *
- * Three-tier fallback strategy:
- * 1. Readability.js (Mozilla) + Turndown for article-like content
- * 2. Turndown raw HTML if Readability fails
- * 3. Regex-based strip if both fail
- */
-/**
- * Result of content extraction
- */
-export interface ExtractedContent {
-    /** Page title */
-    title: string;
-    /** Extracted content as Markdown */
-    content: string;
-    /** Whether Readability detected article-like content */
-    isArticle: boolean;
-}
-/**
- * Checks whether a Content-Type header value represents HTML content
- * that should be processed through Readability/Turndown extraction.
- */
-export declare function isHtmlContentType(contentType: string | undefined | null): boolean;
-/**
- * Extracts content from a response body, checking Content-Type first.
- * Non-HTML content types (JSON, PDF, images, etc.) are returned as-is
- * or with a descriptive message rather than being fed through Readability.
- *
- * @param body - The response body text
- * @param url - The source URL
- * @param contentType - The Content-Type header value (optional)
- * @returns Extracted content
- */
-export declare function extractFromResponse(body: string, url: string, contentType?: string | null): Promise<ExtractedContent>;
-/**
- * Extracts content from HTML and converts to Markdown.
- *
- * Strategy:
- * 1. Try Readability.js (article detection) + Turndown
- * 2. Fall back to Turndown on raw HTML
- * 3. Fall back to regex-based tag stripping
- *
- * @param html - The HTML content to extract from
- * @param url - The source URL (for link resolution)
- * @returns Extracted content with title and article detection
- */
-export declare function extractContent(html: string, url: string): Promise<ExtractedContent>;

package/dist-cjs/extraction/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Content extraction utilities
- */
-export { extractContent, type ExtractedContent } from "./content-extraction.js";