@dexto/tools-process 1.5.8 → 1.6.1

package/dist/error-codes.d.cts

@@ -1,26 +0,0 @@
-/**
- * Process Service Error Codes
- *
- * Standardized error codes for process execution and management
- */
-declare enum ProcessErrorCode {
-    INVALID_COMMAND = "PROCESS_INVALID_COMMAND",
-    COMMAND_BLOCKED = "PROCESS_COMMAND_BLOCKED",
-    COMMAND_TOO_LONG = "PROCESS_COMMAND_TOO_LONG",
-    INJECTION_DETECTED = "PROCESS_INJECTION_DETECTED",
-    APPROVAL_REQUIRED = "PROCESS_APPROVAL_REQUIRED",
-    APPROVAL_DENIED = "PROCESS_APPROVAL_DENIED",
-    EXECUTION_FAILED = "PROCESS_EXECUTION_FAILED",
-    TIMEOUT = "PROCESS_TIMEOUT",
-    PERMISSION_DENIED = "PROCESS_PERMISSION_DENIED",
-    COMMAND_NOT_FOUND = "PROCESS_COMMAND_NOT_FOUND",
-    WORKING_DIRECTORY_INVALID = "PROCESS_WORKING_DIRECTORY_INVALID",
-    PROCESS_NOT_FOUND = "PROCESS_NOT_FOUND",
-    TOO_MANY_PROCESSES = "PROCESS_TOO_MANY_PROCESSES",
-    KILL_FAILED = "PROCESS_KILL_FAILED",
-    OUTPUT_BUFFER_FULL = "PROCESS_OUTPUT_BUFFER_FULL",
-    INVALID_CONFIG = "PROCESS_INVALID_CONFIG",
-    SERVICE_NOT_INITIALIZED = "PROCESS_SERVICE_NOT_INITIALIZED"
-}
-
-export { ProcessErrorCode };

package/dist/errors.d.cts

@@ -1,90 +0,0 @@
-import { DextoRuntimeError } from '@dexto/core';
-
-/**
- * Process Service Errors
- *
- * Error classes for process execution and management
- */
-
-interface ProcessErrorContext {
-    command?: string;
-    processId?: string;
-    timeout?: number;
-    [key: string]: unknown;
-}
-/**
- * Factory class for creating Process-related errors
- */
-declare class ProcessError {
-    private constructor();
-    /**
-     * Invalid command error
-     */
-    static invalidCommand(command: string, reason: string): DextoRuntimeError;
-    /**
-     * Command blocked error
-     */
-    static commandBlocked(command: string, reason: string): DextoRuntimeError;
-    /**
-     * Command too long error
-     */
-    static commandTooLong(length: number, maxLength: number): DextoRuntimeError;
-    /**
-     * Command injection detected error
-     */
-    static commandInjection(command: string, pattern: string): DextoRuntimeError;
-    /**
-     * Command approval required error
-     */
-    static approvalRequired(command: string, reason?: string): DextoRuntimeError;
-    /**
-     * Command approval denied error
-     */
-    static approvalDenied(command: string): DextoRuntimeError;
-    /**
-     * Command execution failed error
-     */
-    static executionFailed(command: string, cause: string): DextoRuntimeError;
-    /**
-     * Command timeout error
-     */
-    static timeout(command: string, timeout: number): DextoRuntimeError;
-    /**
-     * Permission denied error
-     */
-    static permissionDenied(command: string): DextoRuntimeError;
-    /**
-     * Command not found error
-     */
-    static commandNotFound(command: string): DextoRuntimeError;
-    /**
-     * Invalid working directory error
-     */
-    static invalidWorkingDirectory(path: string, reason: string): DextoRuntimeError;
-    /**
-     * Process not found error
-     */
-    static processNotFound(processId: string): DextoRuntimeError;
-    /**
-     * Too many concurrent processes error
-     */
-    static tooManyProcesses(current: number, max: number): DextoRuntimeError;
-    /**
-     * Kill process failed error
-     */
-    static killFailed(processId: string, cause: string): DextoRuntimeError;
-    /**
-     * Output buffer full error
-     */
-    static outputBufferFull(processId: string, size: number, maxSize: number): DextoRuntimeError;
-    /**
-     * Invalid configuration error
-     */
-    static invalidConfig(reason: string): DextoRuntimeError;
-    /**
-     * Service not initialized error
-     */
-    static notInitialized(): DextoRuntimeError;
-}
-
-export { ProcessError, type ProcessErrorContext };

package/dist/kill-process-tool.d.cts

@@ -1,16 +0,0 @@
-import { InternalTool } from '@dexto/core';
-import { ProcessService } from './process-service.cjs';
-import './types.cjs';
-
-/**
- * Kill Process Tool
- *
- * Internal tool for terminating background processes
- */
-
-/**
- * Create the kill_process internal tool
- */
-declare function createKillProcessTool(processService: ProcessService): InternalTool;
-
-export { createKillProcessTool };

package/dist/process-service.d.cts

@@ -1,96 +0,0 @@
-import { ProcessConfig, ExecuteOptions, ProcessResult, ProcessHandle, ProcessOutput, ProcessInfo } from './types.cjs';
-import { IDextoLogger } from '@dexto/core';
-
-/**
- * Process Service
- *
- * Secure command execution and process management for Dexto internal tools
- */
-
-/**
- * ProcessService - Handles command execution and process management
- *
- * This service receives fully-validated configuration from the Process Tools Provider.
- * All defaults have been applied by the provider's schema, so the service trusts the config
- * and uses it as-is without any fallback logic.
- *
- * TODO: Add tests for this class
- */
-declare class ProcessService {
-    private config;
-    private commandValidator;
-    private initialized;
-    private initPromise;
-    private backgroundProcesses;
-    private logger;
-    /**
-     * Create a new ProcessService with validated configuration.
-     *
-     * @param config - Fully-validated configuration from provider schema.
-     *                 All required fields have values, defaults already applied.
-     * @param logger - Logger instance for this service
-     */
-    constructor(config: ProcessConfig, logger: IDextoLogger);
-    /**
-     * Initialize the service.
-     * Safe to call multiple times - subsequent calls return the same promise.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Internal initialization logic.
-     */
-    private doInitialize;
-    /**
-     * Ensure the service is initialized before use.
-     * Tools should call this at the start of their execute methods.
-     * Safe to call multiple times - will await the same initialization promise.
-     */
-    ensureInitialized(): Promise<void>;
-    /**
-     * Execute a command
-     */
-    executeCommand(command: string, options?: ExecuteOptions): Promise<ProcessResult | ProcessHandle>;
-    private static readonly SIGKILL_TIMEOUT_MS;
-    /**
-     * Kill a process tree (process group on Unix, taskkill on Windows)
-     */
-    private killProcessTree;
-    /**
-     * Execute command in foreground with timeout and abort support
-     */
-    private executeForeground;
-    /**
-     * Execute command in background
-     */
-    private executeInBackground;
-    /**
-     * Get output from a background process
-     */
-    getProcessOutput(processId: string): Promise<ProcessOutput>;
-    /**
-     * Kill a background process
-     */
-    killProcess(processId: string): Promise<void>;
-    /**
-     * List all background processes
-     */
-    listProcesses(): Promise<ProcessInfo[]>;
-    /**
-     * Get buffer size in bytes
-     */
-    private getBufferSize;
-    /**
-     * Get service configuration
-     */
-    getConfig(): Readonly<ProcessConfig>;
-    /**
-     * Resolve and confine cwd to the configured working directory
-     */
-    private resolveSafeCwd;
-    /**
-     * Cleanup completed processes
-     */
-    cleanup(): Promise<void>;
-}
-
-export { ProcessService };

package/dist/tool-provider.d.cts

@@ -1,72 +0,0 @@
-import { z } from 'zod';
-import { CustomToolProvider } from '@dexto/core';
-
-/**
- * Process Tools Provider
- *
- * Provides process execution and management tools by wrapping ProcessService.
- * When registered, the provider initializes ProcessService and creates tools
- * for command execution and process management.
- */
-
-/**
- * Configuration schema for Process tools provider.
- *
- * This is the SINGLE SOURCE OF TRUTH for all configuration:
- * - Validation rules
- * - Default values (using constants above)
- * - Documentation
- * - Type definitions
- *
- * Services receive fully-validated config from this schema and use it as-is,
- * with no additional defaults or fallbacks needed.
- */
-declare const ProcessToolsConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"process-tools">;
-    securityLevel: z.ZodDefault<z.ZodEnum<["strict", "moderate", "permissive"]>>;
-    maxTimeout: z.ZodDefault<z.ZodNumber>;
-    maxConcurrentProcesses: z.ZodDefault<z.ZodNumber>;
-    maxOutputBuffer: z.ZodDefault<z.ZodNumber>;
-    workingDirectory: z.ZodOptional<z.ZodString>;
-    allowedCommands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    blockedCommands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    environment: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    type: "process-tools";
-    securityLevel: "strict" | "moderate" | "permissive";
-    maxTimeout: number;
-    maxConcurrentProcesses: number;
-    maxOutputBuffer: number;
-    allowedCommands: string[];
-    blockedCommands: string[];
-    environment: Record<string, string>;
-    timeout?: number | undefined;
-    workingDirectory?: string | undefined;
-}, {
-    type: "process-tools";
-    timeout?: number | undefined;
-    securityLevel?: "strict" | "moderate" | "permissive" | undefined;
-    maxTimeout?: number | undefined;
-    maxConcurrentProcesses?: number | undefined;
-    maxOutputBuffer?: number | undefined;
-    allowedCommands?: string[] | undefined;
-    blockedCommands?: string[] | undefined;
-    environment?: Record<string, string> | undefined;
-    workingDirectory?: string | undefined;
-}>;
-type ProcessToolsConfig = z.output<typeof ProcessToolsConfigSchema>;
-/**
- * Process tools provider.
- *
- * Wraps ProcessService and provides process operation tools:
- * - bash_exec: Execute bash commands (foreground or background)
- * - bash_output: Retrieve output from background processes
- * - kill_process: Terminate background processes
- *
- * When registered via customToolRegistry, ProcessService is automatically
- * initialized and process operation tools become available to the agent.
- */
-declare const processToolsProvider: CustomToolProvider<'process-tools', ProcessToolsConfig>;
-
-export { processToolsProvider };

package/dist/types.d.cts

@@ -1,108 +0,0 @@
-/**
- * Process Service Types
- *
- * Types and interfaces for command execution and process management
- */
-/**
- * Process execution options
- */
-interface ExecuteOptions {
-    /** Working directory */
-    cwd?: string | undefined;
-    /** Timeout in milliseconds (max: 600000) */
-    timeout?: number | undefined;
-    /** Run command in background */
-    runInBackground?: boolean | undefined;
-    /** Environment variables */
-    env?: Record<string, string> | undefined;
-    /** Description of what the command does (5-10 words) */
-    description?: string | undefined;
-    /** Abort signal for cancellation support */
-    abortSignal?: AbortSignal | undefined;
-}
-/**
- * Process execution result (foreground execution only)
- * For background execution, see ProcessHandle
- */
-interface ProcessResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    duration: number;
-}
-/**
- * Background process handle
- */
-interface ProcessHandle {
-    processId: string;
-    command: string;
-    pid?: number | undefined;
-    startedAt: Date;
-    description?: string | undefined;
-}
-/**
- * Process output (for retrieving from background processes)
- */
-interface ProcessOutput {
-    stdout: string;
-    stderr: string;
-    status: 'running' | 'completed' | 'failed';
-    exitCode?: number | undefined;
-    duration?: number | undefined;
-}
-/**
- * Process information
- */
-interface ProcessInfo {
-    processId: string;
-    command: string;
-    pid?: number | undefined;
-    status: 'running' | 'completed' | 'failed';
-    startedAt: Date;
-    completedAt?: Date | undefined;
-    exitCode?: number | undefined;
-    description?: string | undefined;
-}
-/**
- * Command validation result
- */
-interface CommandValidation {
-    isValid: boolean;
-    error?: string;
-    normalizedCommand?: string;
-    requiresApproval?: boolean;
-}
-/**
- * Process service configuration
- */
-interface ProcessConfig {
-    /** Security level for command execution */
-    securityLevel: 'strict' | 'moderate' | 'permissive';
-    /** Maximum timeout for commands in milliseconds */
-    maxTimeout: number;
-    /** Maximum concurrent background processes */
-    maxConcurrentProcesses: number;
-    /** Maximum output buffer size in bytes */
-    maxOutputBuffer: number;
-    /** Explicitly allowed commands (empty = all allowed with approval) */
-    allowedCommands: string[];
-    /** Blocked command patterns */
-    blockedCommands: string[];
-    /** Custom environment variables */
-    environment: Record<string, string>;
-    /** Working directory (defaults to process.cwd()) */
-    workingDirectory?: string | undefined;
-}
-/**
- * Output buffer management
- */
-interface OutputBuffer {
-    stdout: string[];
-    stderr: string[];
-    complete: boolean;
-    lastRead: number;
-    bytesUsed: number;
-    truncated?: boolean;
-}
-
-export type { CommandValidation, ExecuteOptions, OutputBuffer, ProcessConfig, ProcessHandle, ProcessInfo, ProcessOutput, ProcessResult };