@dexto/tools-process 1.5.0

package/dist/errors.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  ProcessError: () => ProcessError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_core = require("@dexto/core");
+var import_error_codes = require("./error-codes.js");
+class ProcessError {
+  constructor() {
+  }
+  /**
+   * Invalid command error
+   */
+  static invalidCommand(command, reason) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.INVALID_COMMAND,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.USER,
+      `Invalid command: ${command}. ${reason}`,
+      { command, reason }
+    );
+  }
+  /**
+   * Command blocked error
+   */
+  static commandBlocked(command, reason) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.COMMAND_BLOCKED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.FORBIDDEN,
+      `Command is blocked: ${command}. ${reason}`,
+      { command, reason }
+    );
+  }
+  /**
+   * Command too long error
+   */
+  static commandTooLong(length, maxLength) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.COMMAND_TOO_LONG,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.USER,
+      `Command too long: ${length} characters. Maximum allowed: ${maxLength}`,
+      { length, maxLength }
+    );
+  }
+  /**
+   * Command injection detected error
+   */
+  static commandInjection(command, pattern) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.INJECTION_DETECTED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.FORBIDDEN,
+      `Potential command injection detected in: ${command}. Pattern: ${pattern}`,
+      { command, pattern }
+    );
+  }
+  /**
+   * Command approval required error
+   */
+  static approvalRequired(command, reason) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.APPROVAL_REQUIRED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.FORBIDDEN,
+      `Command requires approval: ${command}${reason ? `. ${reason}` : ""}`,
+      { command, reason },
+      "Provide an approval function to execute dangerous commands"
+    );
+  }
+  /**
+   * Command approval denied error
+   */
+  static approvalDenied(command) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.APPROVAL_DENIED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.FORBIDDEN,
+      `Command approval denied by user: ${command}`,
+      { command }
+    );
+  }
+  /**
+   * Command execution failed error
+   */
+  static executionFailed(command, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.EXECUTION_FAILED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.SYSTEM,
+      `Command execution failed: ${command}. ${cause}`,
+      { command, cause }
+    );
+  }
+  /**
+   * Command timeout error
+   */
+  static timeout(command, timeout) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.TIMEOUT,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.TIMEOUT,
+      `Command timed out after ${timeout}ms: ${command}`,
+      { command, timeout },
+      "Increase timeout or optimize the command"
+    );
+  }
+  /**
+   * Permission denied error
+   */
+  static permissionDenied(command) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.PERMISSION_DENIED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.FORBIDDEN,
+      `Permission denied: ${command}`,
+      { command }
+    );
+  }
+  /**
+   * Command not found error
+   */
+  static commandNotFound(command) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.COMMAND_NOT_FOUND,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.NOT_FOUND,
+      `Command not found: ${command}`,
+      { command },
+      "Ensure the command is installed and available in PATH"
+    );
+  }
+  /**
+   * Invalid working directory error
+   */
+  static invalidWorkingDirectory(path, reason) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.WORKING_DIRECTORY_INVALID,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.USER,
+      `Invalid working directory: ${path}. ${reason}`,
+      { path, reason }
+    );
+  }
+  /**
+   * Process not found error
+   */
+  static processNotFound(processId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.PROCESS_NOT_FOUND,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.NOT_FOUND,
+      `Process not found: ${processId}`,
+      { processId }
+    );
+  }
+  /**
+   * Too many concurrent processes error
+   */
+  static tooManyProcesses(current, max) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.TOO_MANY_PROCESSES,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.USER,
+      `Too many concurrent processes: ${current}. Maximum allowed: ${max}`,
+      { current, max },
+      "Wait for running processes to complete or increase the limit"
+    );
+  }
+  /**
+   * Kill process failed error
+   */
+  static killFailed(processId, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.KILL_FAILED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.SYSTEM,
+      `Failed to kill process ${processId}: ${cause}`,
+      { processId, cause }
+    );
+  }
+  /**
+   * Output buffer full error
+   */
+  static outputBufferFull(processId, size, maxSize) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.OUTPUT_BUFFER_FULL,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.SYSTEM,
+      `Output buffer full for process ${processId}: ${size} bytes. Maximum: ${maxSize}`,
+      { processId, size, maxSize },
+      "Process output exceeded buffer limit"
+    );
+  }
+  /**
+   * Invalid configuration error
+   */
+  static invalidConfig(reason) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.INVALID_CONFIG,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.USER,
+      `Invalid Process configuration: ${reason}`,
+      { reason }
+    );
+  }
+  /**
+   * Service not initialized error
+   */
+  static notInitialized() {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.ProcessErrorCode.SERVICE_NOT_INITIALIZED,
+      import_core.ErrorScope.PROCESS,
+      import_core.ErrorType.SYSTEM,
+      "ProcessService has not been initialized",
+      {},
+      "Initialize the ProcessService before using it"
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProcessError
+});

package/dist/errors.d.cts

@@ -0,0 +1,90 @@
+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/errors.d.ts

@@ -0,0 +1,90 @@
+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/errors.js

@@ -0,0 +1,219 @@
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
+import { ProcessErrorCode } from "./error-codes.js";
+class ProcessError {
+  constructor() {
+  }
+  /**
+   * Invalid command error
+   */
+  static invalidCommand(command, reason) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.INVALID_COMMAND,
+      ErrorScope.PROCESS,
+      ErrorType.USER,
+      `Invalid command: ${command}. ${reason}`,
+      { command, reason }
+    );
+  }
+  /**
+   * Command blocked error
+   */
+  static commandBlocked(command, reason) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.COMMAND_BLOCKED,
+      ErrorScope.PROCESS,
+      ErrorType.FORBIDDEN,
+      `Command is blocked: ${command}. ${reason}`,
+      { command, reason }
+    );
+  }
+  /**
+   * Command too long error
+   */
+  static commandTooLong(length, maxLength) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.COMMAND_TOO_LONG,
+      ErrorScope.PROCESS,
+      ErrorType.USER,
+      `Command too long: ${length} characters. Maximum allowed: ${maxLength}`,
+      { length, maxLength }
+    );
+  }
+  /**
+   * Command injection detected error
+   */
+  static commandInjection(command, pattern) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.INJECTION_DETECTED,
+      ErrorScope.PROCESS,
+      ErrorType.FORBIDDEN,
+      `Potential command injection detected in: ${command}. Pattern: ${pattern}`,
+      { command, pattern }
+    );
+  }
+  /**
+   * Command approval required error
+   */
+  static approvalRequired(command, reason) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.APPROVAL_REQUIRED,
+      ErrorScope.PROCESS,
+      ErrorType.FORBIDDEN,
+      `Command requires approval: ${command}${reason ? `. ${reason}` : ""}`,
+      { command, reason },
+      "Provide an approval function to execute dangerous commands"
+    );
+  }
+  /**
+   * Command approval denied error
+   */
+  static approvalDenied(command) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.APPROVAL_DENIED,
+      ErrorScope.PROCESS,
+      ErrorType.FORBIDDEN,
+      `Command approval denied by user: ${command}`,
+      { command }
+    );
+  }
+  /**
+   * Command execution failed error
+   */
+  static executionFailed(command, cause) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.EXECUTION_FAILED,
+      ErrorScope.PROCESS,
+      ErrorType.SYSTEM,
+      `Command execution failed: ${command}. ${cause}`,
+      { command, cause }
+    );
+  }
+  /**
+   * Command timeout error
+   */
+  static timeout(command, timeout) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.TIMEOUT,
+      ErrorScope.PROCESS,
+      ErrorType.TIMEOUT,
+      `Command timed out after ${timeout}ms: ${command}`,
+      { command, timeout },
+      "Increase timeout or optimize the command"
+    );
+  }
+  /**
+   * Permission denied error
+   */
+  static permissionDenied(command) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.PERMISSION_DENIED,
+      ErrorScope.PROCESS,
+      ErrorType.FORBIDDEN,
+      `Permission denied: ${command}`,
+      { command }
+    );
+  }
+  /**
+   * Command not found error
+   */
+  static commandNotFound(command) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.COMMAND_NOT_FOUND,
+      ErrorScope.PROCESS,
+      ErrorType.NOT_FOUND,
+      `Command not found: ${command}`,
+      { command },
+      "Ensure the command is installed and available in PATH"
+    );
+  }
+  /**
+   * Invalid working directory error
+   */
+  static invalidWorkingDirectory(path, reason) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.WORKING_DIRECTORY_INVALID,
+      ErrorScope.PROCESS,
+      ErrorType.USER,
+      `Invalid working directory: ${path}. ${reason}`,
+      { path, reason }
+    );
+  }
+  /**
+   * Process not found error
+   */
+  static processNotFound(processId) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.PROCESS_NOT_FOUND,
+      ErrorScope.PROCESS,
+      ErrorType.NOT_FOUND,
+      `Process not found: ${processId}`,
+      { processId }
+    );
+  }
+  /**
+   * Too many concurrent processes error
+   */
+  static tooManyProcesses(current, max) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.TOO_MANY_PROCESSES,
+      ErrorScope.PROCESS,
+      ErrorType.USER,
+      `Too many concurrent processes: ${current}. Maximum allowed: ${max}`,
+      { current, max },
+      "Wait for running processes to complete or increase the limit"
+    );
+  }
+  /**
+   * Kill process failed error
+   */
+  static killFailed(processId, cause) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.KILL_FAILED,
+      ErrorScope.PROCESS,
+      ErrorType.SYSTEM,
+      `Failed to kill process ${processId}: ${cause}`,
+      { processId, cause }
+    );
+  }
+  /**
+   * Output buffer full error
+   */
+  static outputBufferFull(processId, size, maxSize) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.OUTPUT_BUFFER_FULL,
+      ErrorScope.PROCESS,
+      ErrorType.SYSTEM,
+      `Output buffer full for process ${processId}: ${size} bytes. Maximum: ${maxSize}`,
+      { processId, size, maxSize },
+      "Process output exceeded buffer limit"
+    );
+  }
+  /**
+   * Invalid configuration error
+   */
+  static invalidConfig(reason) {
+    return new DextoRuntimeError(
+      ProcessErrorCode.INVALID_CONFIG,
+      ErrorScope.PROCESS,
+      ErrorType.USER,
+      `Invalid Process configuration: ${reason}`,
+      { reason }
+    );
+  }
+  /**
+   * Service not initialized error
+   */
+  static notInitialized() {
+    return new DextoRuntimeError(
+      ProcessErrorCode.SERVICE_NOT_INITIALIZED,
+      ErrorScope.PROCESS,
+      ErrorType.SYSTEM,
+      "ProcessService has not been initialized",
+      {},
+      "Initialize the ProcessService before using it"
+    );
+  }
+}
+export {
+  ProcessError
+};

package/dist/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  CommandValidator: () => import_command_validator.CommandValidator,
+  ProcessError: () => import_errors.ProcessError,
+  ProcessErrorCode: () => import_error_codes.ProcessErrorCode,
+  ProcessService: () => import_process_service.ProcessService,
+  createBashExecTool: () => import_bash_exec_tool.createBashExecTool,
+  createBashOutputTool: () => import_bash_output_tool.createBashOutputTool,
+  createKillProcessTool: () => import_kill_process_tool.createKillProcessTool,
+  processToolsProvider: () => import_tool_provider.processToolsProvider
+});
+module.exports = __toCommonJS(index_exports);
+var import_tool_provider = require("./tool-provider.js");
+var import_process_service = require("./process-service.js");
+var import_command_validator = require("./command-validator.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+var import_bash_exec_tool = require("./bash-exec-tool.js");
+var import_bash_output_tool = require("./bash-output-tool.js");
+var import_kill_process_tool = require("./kill-process-tool.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandValidator,
+  ProcessError,
+  ProcessErrorCode,
+  ProcessService,
+  createBashExecTool,
+  createBashOutputTool,
+  createKillProcessTool,
+  processToolsProvider
+});

package/dist/index.d.cts

@@ -0,0 +1,11 @@
+export { processToolsProvider } from './tool-provider.cjs';
+export { ProcessService } from './process-service.cjs';
+export { CommandValidator } from './command-validator.cjs';
+export { ProcessError } from './errors.cjs';
+export { ProcessErrorCode } from './error-codes.cjs';
+export { CommandValidation, ExecuteOptions, OutputBuffer, ProcessConfig, ProcessHandle, ProcessInfo, ProcessOutput, ProcessResult } from './types.cjs';
+export { createBashExecTool } from './bash-exec-tool.cjs';
+export { createBashOutputTool } from './bash-output-tool.cjs';
+export { createKillProcessTool } from './kill-process-tool.cjs';
+import 'zod';
+import '@dexto/core';