@dexto/tools-process 1.5.8 → 1.6.1

package/dist/process-service.d.ts

@@ -1,22 +1,20 @@
-import { ProcessConfig, ExecuteOptions, ProcessResult, ProcessHandle, ProcessOutput, ProcessInfo } from './types.js';
-import { IDextoLogger } from '@dexto/core';
-
 /**
  * Process Service
  *
  * Secure command execution and process management for Dexto internal tools
  */
-
+import { ProcessConfig, ExecuteOptions, ProcessResult, ProcessHandle, ProcessOutput, ProcessInfo } from './types.js';
+import type { Logger } from '@dexto/core';
 /**
  * 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
+ * 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 {
+export declare class ProcessService {
     private config;
     private commandValidator;
     private initialized;
@@ -26,11 +24,11 @@ declare class ProcessService {
     /**
      * Create a new ProcessService with validated configuration.
      *
-     * @param config - Fully-validated configuration from provider schema.
+     * @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: IDextoLogger);
+    constructor(config: ProcessConfig, logger: Logger);
     /**
      * Initialize the service.
      * Safe to call multiple times - subsequent calls return the same promise.
@@ -83,6 +81,10 @@ declare class ProcessService {
      * 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
      */
@@ -92,5 +94,4 @@ declare class ProcessService {
      */
     cleanup(): Promise<void>;
 }
-
-export { ProcessService };
+//# sourceMappingURL=process-service.d.ts.map

package/dist/process-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-service.d.ts","sourceRoot":"","sources":["../src/process-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EACH,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,WAAW,EAEd,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAoB1C;;;;;;;;GAQG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,mBAAmB,CAA6C;IACxE,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;;OAMG;gBACS,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM;IAQjD;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B;;OAEG;YACW,YAAY;IAa1B;;;;OAIG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxC;;OAEG;IACG,cAAc,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,cAAmB,GAC7B,OAAO,CAAC,aAAa,GAAG,aAAa,CAAC;IAqDzC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IAEjD;;OAEG;YACW,eAAe;IA6B7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8KzB;;OAEG;YACW,mBAAmB;IAoKjC;;OAEG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IA6BjE;;OAEG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCnD;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAe7C;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,aAAa,CAAC;IAIpC;;OAEG;IACH,mBAAmB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAQnD;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAcjC"}

package/dist/process-service.js

@@ -15,7 +15,7 @@ class ProcessService {
   /**
    * Create a new ProcessService with validated configuration.
    *
-   * @param config - Fully-validated configuration from provider schema.
+   * @param config - Fully-validated configuration from the factory schema.
    *                 All required fields have values, defaults already applied.
    * @param logger - Logger instance for this service
    */
@@ -471,6 +471,16 @@ Process terminated by signal ${signal ?? "UNKNOWN"}`;
   getConfig() {
     return { ...this.config };
   }
+  /**
+   * Update the working directory at runtime (e.g., when workspace changes).
+   */
+  setWorkingDirectory(workingDirectory) {
+    const normalized = workingDirectory?.trim();
+    if (!normalized) return;
+    if (this.config.workingDirectory === normalized) return;
+    this.config = { ...this.config, workingDirectory: normalized };
+    this.logger.info(`ProcessService working directory set to ${normalized}`);
+  }
   /**
    * Resolve and confine cwd to the configured working directory
    */

package/dist/{tool-provider.cjs → tool-factory-config.cjs}

@@ -16,16 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var tool_provider_exports = {};
-__export(tool_provider_exports, {
-  processToolsProvider: () => processToolsProvider
+var tool_factory_config_exports = {};
+__export(tool_factory_config_exports, {
+  ProcessToolsConfigSchema: () => ProcessToolsConfigSchema
 });
-module.exports = __toCommonJS(tool_provider_exports);
+module.exports = __toCommonJS(tool_factory_config_exports);
 var import_zod = require("zod");
-var import_process_service = require("./process-service.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");
 const DEFAULT_SECURITY_LEVEL = "moderate";
 const DEFAULT_MAX_TIMEOUT = 6e5;
 const DEFAULT_MAX_CONCURRENT_PROCESSES = 5;
@@ -50,47 +46,9 @@ const ProcessToolsConfigSchema = import_zod.z.object({
     "Explicitly allowed commands (empty = all allowed with approval, strict mode only)"
   ),
   blockedCommands: import_zod.z.array(import_zod.z.string()).default(DEFAULT_BLOCKED_COMMANDS).describe("Blocked command patterns (applies to all security levels)"),
-  environment: import_zod.z.record(import_zod.z.string()).default(DEFAULT_ENVIRONMENT).describe("Custom environment variables to set for command execution"),
-  timeout: import_zod.z.number().int().positive().max(DEFAULT_MAX_TIMEOUT).optional().describe(
-    `Default timeout in milliseconds (max: ${DEFAULT_MAX_TIMEOUT / 1e3 / 60} minutes)`
-  )
+  environment: import_zod.z.record(import_zod.z.string()).default(DEFAULT_ENVIRONMENT).describe("Custom environment variables to set for command execution")
 }).strict();
-const processToolsProvider = {
-  type: "process-tools",
-  configSchema: ProcessToolsConfigSchema,
-  create: (config, context) => {
-    const { logger } = context;
-    logger.debug("Creating ProcessService for process tools");
-    const processService = new import_process_service.ProcessService(
-      {
-        securityLevel: config.securityLevel,
-        maxTimeout: config.maxTimeout,
-        maxConcurrentProcesses: config.maxConcurrentProcesses,
-        maxOutputBuffer: config.maxOutputBuffer,
-        workingDirectory: config.workingDirectory || process.cwd(),
-        allowedCommands: config.allowedCommands,
-        blockedCommands: config.blockedCommands,
-        environment: config.environment
-      },
-      logger
-    );
-    processService.initialize().catch((error) => {
-      logger.error(`Failed to initialize ProcessService: ${error.message}`);
-    });
-    logger.debug("ProcessService created - initialization will complete on first tool use");
-    return [
-      (0, import_bash_exec_tool.createBashExecTool)(processService),
-      (0, import_bash_output_tool.createBashOutputTool)(processService),
-      (0, import_kill_process_tool.createKillProcessTool)(processService)
-    ];
-  },
-  metadata: {
-    displayName: "Process Tools",
-    description: "Process execution and management (bash, output, kill)",
-    category: "process"
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  processToolsProvider
+  ProcessToolsConfigSchema
 });

package/dist/{tool-provider.d.ts → tool-factory-config.d.ts}

@@ -1,16 +1,13 @@
-import { z } from 'zod';
-import { CustomToolProvider } from '@dexto/core';
-
 /**
- * Process Tools Provider
+ * Process Tools Factory
  *
  * Provides process execution and management tools by wrapping ProcessService.
- * When registered, the provider initializes ProcessService and creates tools
+ * When registered, the factory initializes ProcessService and creates tools
  * for command execution and process management.
  */
-
+import { z } from 'zod';
 /**
- * Configuration schema for Process tools provider.
+ * Configuration schema for Process tools factory.
  *
  * This is the SINGLE SOURCE OF TRUTH for all configuration:
  * - Validation rules
@@ -21,7 +18,7 @@ import { CustomToolProvider } from '@dexto/core';
  * 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<{
+export declare const ProcessToolsConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"process-tools">;
     securityLevel: z.ZodDefault<z.ZodEnum<["strict", "moderate", "permissive"]>>;
     maxTimeout: z.ZodDefault<z.ZodNumber>;
@@ -31,9 +28,7 @@ declare const ProcessToolsConfigSchema: z.ZodObject<{
     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;
@@ -41,11 +36,10 @@ declare const ProcessToolsConfigSchema: z.ZodObject<{
     allowedCommands: string[];
     blockedCommands: string[];
     environment: Record<string, string>;
-    timeout?: number | undefined;
+    type: "process-tools";
     workingDirectory?: string | undefined;
 }, {
     type: "process-tools";
-    timeout?: number | undefined;
     securityLevel?: "strict" | "moderate" | "permissive" | undefined;
     maxTimeout?: number | undefined;
     maxConcurrentProcesses?: number | undefined;
@@ -55,18 +49,5 @@ declare const ProcessToolsConfigSchema: z.ZodObject<{
     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 };
+export type ProcessToolsConfig = z.output<typeof ProcessToolsConfigSchema>;
+//# sourceMappingURL=tool-factory-config.d.ts.map

package/dist/tool-factory-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory-config.d.ts","sourceRoot":"","sources":["../src/tool-factory-config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/{tool-provider.js → tool-factory-config.js}

@@ -1,8 +1,4 @@
 import { z } from "zod";
-import { ProcessService } from "./process-service.js";
-import { createBashExecTool } from "./bash-exec-tool.js";
-import { createBashOutputTool } from "./bash-output-tool.js";
-import { createKillProcessTool } from "./kill-process-tool.js";
 const DEFAULT_SECURITY_LEVEL = "moderate";
 const DEFAULT_MAX_TIMEOUT = 6e5;
 const DEFAULT_MAX_CONCURRENT_PROCESSES = 5;
@@ -27,46 +23,8 @@ const ProcessToolsConfigSchema = z.object({
     "Explicitly allowed commands (empty = all allowed with approval, strict mode only)"
   ),
   blockedCommands: z.array(z.string()).default(DEFAULT_BLOCKED_COMMANDS).describe("Blocked command patterns (applies to all security levels)"),
-  environment: z.record(z.string()).default(DEFAULT_ENVIRONMENT).describe("Custom environment variables to set for command execution"),
-  timeout: z.number().int().positive().max(DEFAULT_MAX_TIMEOUT).optional().describe(
-    `Default timeout in milliseconds (max: ${DEFAULT_MAX_TIMEOUT / 1e3 / 60} minutes)`
-  )
+  environment: z.record(z.string()).default(DEFAULT_ENVIRONMENT).describe("Custom environment variables to set for command execution")
 }).strict();
-const processToolsProvider = {
-  type: "process-tools",
-  configSchema: ProcessToolsConfigSchema,
-  create: (config, context) => {
-    const { logger } = context;
-    logger.debug("Creating ProcessService for process tools");
-    const processService = new ProcessService(
-      {
-        securityLevel: config.securityLevel,
-        maxTimeout: config.maxTimeout,
-        maxConcurrentProcesses: config.maxConcurrentProcesses,
-        maxOutputBuffer: config.maxOutputBuffer,
-        workingDirectory: config.workingDirectory || process.cwd(),
-        allowedCommands: config.allowedCommands,
-        blockedCommands: config.blockedCommands,
-        environment: config.environment
-      },
-      logger
-    );
-    processService.initialize().catch((error) => {
-      logger.error(`Failed to initialize ProcessService: ${error.message}`);
-    });
-    logger.debug("ProcessService created - initialization will complete on first tool use");
-    return [
-      createBashExecTool(processService),
-      createBashOutputTool(processService),
-      createKillProcessTool(processService)
-    ];
-  },
-  metadata: {
-    displayName: "Process Tools",
-    description: "Process execution and management (bash, output, kill)",
-    category: "process"
-  }
-};
 export {
-  processToolsProvider
+  ProcessToolsConfigSchema
 };

package/dist/tool-factory.cjs

@@ -0,0 +1,89 @@
+"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 tool_factory_exports = {};
+__export(tool_factory_exports, {
+  processToolsFactory: () => processToolsFactory
+});
+module.exports = __toCommonJS(tool_factory_exports);
+var import_process_service = require("./process-service.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");
+var import_tool_factory_config = require("./tool-factory-config.js");
+const processToolsFactory = {
+  configSchema: import_tool_factory_config.ProcessToolsConfigSchema,
+  metadata: {
+    displayName: "Process Tools",
+    description: "Process execution and management (bash, output, kill)",
+    category: "process"
+  },
+  create: (config) => {
+    const processConfig = {
+      securityLevel: config.securityLevel,
+      maxTimeout: config.maxTimeout,
+      maxConcurrentProcesses: config.maxConcurrentProcesses,
+      maxOutputBuffer: config.maxOutputBuffer,
+      workingDirectory: config.workingDirectory ?? process.cwd(),
+      allowedCommands: config.allowedCommands,
+      blockedCommands: config.blockedCommands,
+      environment: config.environment
+    };
+    let processService;
+    const resolveWorkingDirectory = (context) => context.workspace?.path ?? processConfig.workingDirectory ?? process.cwd();
+    const applyWorkspace = (context, service) => {
+      const workingDirectory = resolveWorkingDirectory(context);
+      service.setWorkingDirectory(workingDirectory);
+    };
+    const resolveInjectedService = (context) => {
+      const candidate = context.services?.processService;
+      if (!candidate) return null;
+      if (candidate instanceof import_process_service.ProcessService) return candidate;
+      const hasMethods = typeof candidate.executeCommand === "function" && typeof candidate.killProcess === "function" && typeof candidate.setWorkingDirectory === "function" && typeof candidate.getConfig === "function";
+      return hasMethods ? candidate : null;
+    };
+    const getProcessService = async (context) => {
+      const injectedService = resolveInjectedService(context);
+      if (injectedService) {
+        applyWorkspace(context, injectedService);
+        return injectedService;
+      }
+      if (processService) {
+        applyWorkspace(context, processService);
+        return processService;
+      }
+      const logger = context.logger;
+      processService = new import_process_service.ProcessService(processConfig, logger);
+      applyWorkspace(context, processService);
+      processService.initialize().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to initialize ProcessService: ${message}`);
+      });
+      return processService;
+    };
+    return [
+      (0, import_bash_exec_tool.createBashExecTool)(getProcessService),
+      (0, import_bash_output_tool.createBashOutputTool)(getProcessService),
+      (0, import_kill_process_tool.createKillProcessTool)(getProcessService)
+    ];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processToolsFactory
+});

package/dist/tool-factory.d.ts

@@ -0,0 +1,4 @@
+import type { ToolFactory } from '@dexto/agent-config';
+import { type ProcessToolsConfig } from './tool-factory-config.js';
+export declare const processToolsFactory: ToolFactory<ProcessToolsConfig>;
+//# sourceMappingURL=tool-factory.d.ts.map

package/dist/tool-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG7F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,kBAAkB,CA0E/D,CAAC"}

package/dist/tool-factory.js

@@ -0,0 +1,65 @@
+import { ProcessService } from "./process-service.js";
+import { createBashExecTool } from "./bash-exec-tool.js";
+import { createBashOutputTool } from "./bash-output-tool.js";
+import { createKillProcessTool } from "./kill-process-tool.js";
+import { ProcessToolsConfigSchema } from "./tool-factory-config.js";
+const processToolsFactory = {
+  configSchema: ProcessToolsConfigSchema,
+  metadata: {
+    displayName: "Process Tools",
+    description: "Process execution and management (bash, output, kill)",
+    category: "process"
+  },
+  create: (config) => {
+    const processConfig = {
+      securityLevel: config.securityLevel,
+      maxTimeout: config.maxTimeout,
+      maxConcurrentProcesses: config.maxConcurrentProcesses,
+      maxOutputBuffer: config.maxOutputBuffer,
+      workingDirectory: config.workingDirectory ?? process.cwd(),
+      allowedCommands: config.allowedCommands,
+      blockedCommands: config.blockedCommands,
+      environment: config.environment
+    };
+    let processService;
+    const resolveWorkingDirectory = (context) => context.workspace?.path ?? processConfig.workingDirectory ?? process.cwd();
+    const applyWorkspace = (context, service) => {
+      const workingDirectory = resolveWorkingDirectory(context);
+      service.setWorkingDirectory(workingDirectory);
+    };
+    const resolveInjectedService = (context) => {
+      const candidate = context.services?.processService;
+      if (!candidate) return null;
+      if (candidate instanceof ProcessService) return candidate;
+      const hasMethods = typeof candidate.executeCommand === "function" && typeof candidate.killProcess === "function" && typeof candidate.setWorkingDirectory === "function" && typeof candidate.getConfig === "function";
+      return hasMethods ? candidate : null;
+    };
+    const getProcessService = async (context) => {
+      const injectedService = resolveInjectedService(context);
+      if (injectedService) {
+        applyWorkspace(context, injectedService);
+        return injectedService;
+      }
+      if (processService) {
+        applyWorkspace(context, processService);
+        return processService;
+      }
+      const logger = context.logger;
+      processService = new ProcessService(processConfig, logger);
+      applyWorkspace(context, processService);
+      processService.initialize().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to initialize ProcessService: ${message}`);
+      });
+      return processService;
+    };
+    return [
+      createBashExecTool(getProcessService),
+      createBashOutputTool(getProcessService),
+      createKillProcessTool(getProcessService)
+    ];
+  }
+};
+export {
+  processToolsFactory
+};

package/dist/types.d.ts

@@ -6,7 +6,7 @@
 /**
  * Process execution options
  */
-interface ExecuteOptions {
+export interface ExecuteOptions {
     /** Working directory */
     cwd?: string | undefined;
     /** Timeout in milliseconds (max: 600000) */
@@ -24,7 +24,7 @@ interface ExecuteOptions {
  * Process execution result (foreground execution only)
  * For background execution, see ProcessHandle
  */
-interface ProcessResult {
+export interface ProcessResult {
     stdout: string;
     stderr: string;
     exitCode: number;
@@ -33,7 +33,7 @@ interface ProcessResult {
 /**
  * Background process handle
  */
-interface ProcessHandle {
+export interface ProcessHandle {
     processId: string;
     command: string;
     pid?: number | undefined;
@@ -43,7 +43,7 @@ interface ProcessHandle {
 /**
  * Process output (for retrieving from background processes)
  */
-interface ProcessOutput {
+export interface ProcessOutput {
     stdout: string;
     stderr: string;
     status: 'running' | 'completed' | 'failed';
@@ -53,7 +53,7 @@ interface ProcessOutput {
 /**
  * Process information
  */
-interface ProcessInfo {
+export interface ProcessInfo {
     processId: string;
     command: string;
     pid?: number | undefined;
@@ -66,7 +66,7 @@ interface ProcessInfo {
 /**
  * Command validation result
  */
-interface CommandValidation {
+export interface CommandValidation {
     isValid: boolean;
     error?: string;
     normalizedCommand?: string;
@@ -75,7 +75,7 @@ interface CommandValidation {
 /**
  * Process service configuration
  */
-interface ProcessConfig {
+export interface ProcessConfig {
     /** Security level for command execution */
     securityLevel: 'strict' | 'moderate' | 'permissive';
     /** Maximum timeout for commands in milliseconds */
@@ -96,7 +96,7 @@ interface ProcessConfig {
 /**
  * Output buffer management
  */
-interface OutputBuffer {
+export interface OutputBuffer {
     stdout: string[];
     stderr: string[];
     complete: boolean;
@@ -104,5 +104,4 @@ interface OutputBuffer {
     bytesUsed: number;
     truncated?: boolean;
 }
-
-export type { CommandValidation, ExecuteOptions, OutputBuffer, ProcessConfig, ProcessHandle, ProcessInfo, ProcessOutput, ProcessResult };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dexto/tools-process",
-  "version": "1.5.8",
-  "description": "Process tools provider for Dexto agents",
+  "version": "1.6.1",
+  "description": "Process tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,7 +20,8 @@
   ],
   "dependencies": {
     "zod": "^3.25.0",
-    "@dexto/core": "1.5.8"
+    "@dexto/agent-config": "1.6.1",
+    "@dexto/core": "1.6.1"
   },
   "devDependencies": {
     "tsup": "^8.0.0",
@@ -31,7 +32,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

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

@@ -1,17 +0,0 @@
-import { InternalTool } from '@dexto/core';
-import { ProcessService } from './process-service.cjs';
-import './types.cjs';
-
-/**
- * Bash Execute Tool
- *
- * Internal tool for executing shell commands.
- * Approval is handled at the ToolManager level with pattern-based approval.
- */
-
-/**
- * Create the bash_exec internal tool
- */
-declare function createBashExecTool(processService: ProcessService): InternalTool;
-
-export { createBashExecTool };

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

@@ -1,16 +0,0 @@
-import { InternalTool } from '@dexto/core';
-import { ProcessService } from './process-service.cjs';
-import './types.cjs';
-
-/**
- * Bash Output Tool
- *
- * Internal tool for retrieving output from background processes
- */
-
-/**
- * Create the bash_output internal tool
- */
-declare function createBashOutputTool(processService: ProcessService): InternalTool;
-
-export { createBashOutputTool };

package/dist/command-validator.d.cts

@@ -1,52 +0,0 @@
-import { ProcessConfig, CommandValidation } from './types.cjs';
-import { IDextoLogger } 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: IDextoLogger);
-    /**
-     * 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 };