@dexto/tools-process 1.6.0 → 1.6.2

package/dist/bash-output-tool.d.cts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { Tool } from '@dexto/core';
-import { ProcessServiceGetter } from './bash-exec-tool.cjs';
-import './process-service.cjs';
-import './types.cjs';
-
-/**
- * Bash Output Tool
- *
- * Internal tool for retrieving output from background processes
- */
-
-declare const BashOutputInputSchema: z.ZodObject<{
-    process_id: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    process_id: string;
-}, {
-    process_id: string;
-}>;
-/**
- * Create the bash_output internal tool
- */
-declare function createBashOutputTool(getProcessService: ProcessServiceGetter): Tool<typeof BashOutputInputSchema>;
-
-export { createBashOutputTool };

package/dist/command-pattern-utils.d.cts

@@ -1,30 +0,0 @@
-/**
- * Utility functions for generating approval patterns for shell commands.
- *
- * Pattern-based approvals allow users to approve command patterns like "git *"
- * that automatically cover future matching commands (e.g., "git status", "git push").
- */
-/**
- * Commands that should never get auto-approve pattern suggestions.
- * These require explicit approval each time for safety.
- */
-declare const DANGEROUS_COMMAND_PREFIXES: readonly ["rm", "chmod", "chown", "chgrp", "sudo", "su", "dd", "mkfs", "fdisk", "parted", "kill", "killall", "pkill", "shutdown", "reboot", "halt", "poweroff"];
-declare function isDangerousCommand(command: string): boolean;
-/**
- * Generate the pattern key for a shell command.
- *
- * Examples:
- * - "ls -la" → "ls *" (flags don't count as subcommand)
- * - "git push origin" → "git push *" (first non-flag arg is subcommand)
- * - "rm -rf /" → null (dangerous command)
- */
-declare function generateCommandPatternKey(command: string): string | null;
-/**
- * Generate suggested patterns for UI selection.
- * Returns progressively broader patterns from specific to general.
- *
- * Example: "git push origin main" → ["git push *", "git *"]
- */
-declare function generateCommandPatternSuggestions(command: string): string[];
-
-export { DANGEROUS_COMMAND_PREFIXES, generateCommandPatternKey, generateCommandPatternSuggestions, isDangerousCommand };

package/dist/command-pattern-utils.test.d.cts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/command-validator.d.cts

@@ -1,52 +0,0 @@
-import { ProcessConfig, CommandValidation } from './types.cjs';
-import { Logger } from '@dexto/core';
-
-/**
- * Command Validator
- *
- * Security-focused command validation for process execution
- */
-
-/**
- * CommandValidator - Validates commands for security and policy compliance
- *
- * Security checks:
- * 1. Command length limits
- * 2. Dangerous command patterns
- * 3. Command injection detection
- * 4. Allowed/blocked command lists
- * 5. Shell metacharacter analysis
- * TODO: Add tests for this class
- */
-declare class CommandValidator {
-    private config;
-    private logger;
-    constructor(config: ProcessConfig, logger: Logger);
-    /**
-     * Validate a command for security and policy compliance
-     */
-    validateCommand(command: string): CommandValidation;
-    /**
-     * Detect command injection attempts
-     */
-    private detectInjection;
-    /**
-     * Determine if a command requires approval
-     * Handles compound commands (with &&, ||, ;) by checking each sub-command
-     */
-    private determineApprovalRequirement;
-    /**
-     * Get list of blocked commands
-     */
-    getBlockedCommands(): string[];
-    /**
-     * Get list of allowed commands
-     */
-    getAllowedCommands(): string[];
-    /**
-     * Get security level
-     */
-    getSecurityLevel(): string;
-}
-
-export { CommandValidator };

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,25 +0,0 @@
-import { z } from 'zod';
-import { Tool } from '@dexto/core';
-import { ProcessServiceGetter } from './bash-exec-tool.cjs';
-import './process-service.cjs';
-import './types.cjs';
-
-/**
- * Kill Process Tool
- *
- * Internal tool for terminating background processes
- */
-
-declare const KillProcessInputSchema: z.ZodObject<{
-    process_id: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    process_id: string;
-}, {
-    process_id: string;
-}>;
-/**
- * Create the kill_process internal tool
- */
-declare function createKillProcessTool(getProcessService: ProcessServiceGetter): Tool<typeof KillProcessInputSchema>;
-
-export { createKillProcessTool };

package/dist/process-service.d.cts

@@ -1,100 +0,0 @@
-import { ProcessConfig, ExecuteOptions, ProcessResult, ProcessHandle, ProcessOutput, ProcessInfo } from './types.cjs';
-import { Logger } 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 Factory.
- * All defaults have been applied by the factory'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 the factory schema.
-     *                 All required fields have values, defaults already applied.
-     * @param logger - Logger instance for this service
-     */
-    constructor(config: ProcessConfig, logger: Logger);
-    /**
-     * 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>;
-    /**
-     * Update the working directory at runtime (e.g., when workspace changes).
-     */
-    setWorkingDirectory(workingDirectory: string): void;
-    /**
-     * Resolve and confine cwd to the configured working directory
-     */
-    private resolveSafeCwd;
-    /**
-     * Cleanup completed processes
-     */
-    cleanup(): Promise<void>;
-}
-
-export { ProcessService };

package/dist/tool-factory-config.d.cts

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Process Tools Factory
- *
- * Provides process execution and management tools by wrapping ProcessService.
- * When registered, the factory initializes ProcessService and creates tools
- * for command execution and process management.
- */
-
-/**
- * Configuration schema for Process tools factory.
- *
- * 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>>;
-}, "strict", z.ZodTypeAny, {
-    type: "process-tools";
-    securityLevel: "strict" | "moderate" | "permissive";
-    maxTimeout: number;
-    maxConcurrentProcesses: number;
-    maxOutputBuffer: number;
-    allowedCommands: string[];
-    blockedCommands: string[];
-    environment: Record<string, string>;
-    workingDirectory?: string | undefined;
-}, {
-    type: "process-tools";
-    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>;
-
-export { type ProcessToolsConfig, ProcessToolsConfigSchema };

package/dist/tool-factory.d.cts

@@ -1,7 +0,0 @@
-import { ToolFactory } from '@dexto/agent-config';
-import { ProcessToolsConfig } from './tool-factory-config.cjs';
-import 'zod';
-
-declare const processToolsFactory: ToolFactory<ProcessToolsConfig>;
-
-export { processToolsFactory };

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 };