@dexto/core 1.1.10 → 1.2.0

package/dist/process/process-service.js

@@ -0,0 +1,410 @@
+import "../chunk-C6A6W6XS.js";
+import { spawn } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+import { CommandValidator } from "./command-validator.js";
+import { ProcessError } from "./errors.js";
+import { logger } from "../logger/index.js";
+const DEFAULT_TIMEOUT = 12e4;
+const DEFAULT_MAX_TIMEOUT = 6e5;
+const DEFAULT_MAX_CONCURRENT_PROCESSES = 5;
+const DEFAULT_MAX_OUTPUT_BUFFER = 1024 * 1024;
+class ProcessService {
+  config;
+  commandValidator;
+  initialized = false;
+  backgroundProcesses = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = {
+      securityLevel: config.securityLevel || "moderate",
+      maxTimeout: config.maxTimeout || DEFAULT_MAX_TIMEOUT,
+      maxConcurrentProcesses: config.maxConcurrentProcesses || DEFAULT_MAX_CONCURRENT_PROCESSES,
+      maxOutputBuffer: config.maxOutputBuffer || DEFAULT_MAX_OUTPUT_BUFFER,
+      allowedCommands: config.allowedCommands || [],
+      blockedCommands: config.blockedCommands || [],
+      environment: config.environment || {},
+      workingDirectory: config.workingDirectory
+    };
+    this.commandValidator = new CommandValidator(this.config);
+  }
+  /**
+   * Initialize the service
+   */
+  async initialize() {
+    if (this.initialized) {
+      logger.debug("ProcessService already initialized");
+      return;
+    }
+    this.backgroundProcesses.clear();
+    this.initialized = true;
+    logger.info("ProcessService initialized successfully");
+  }
+  /**
+   * Execute a command
+   */
+  async executeCommand(command, options = {}) {
+    if (!this.initialized) {
+      throw ProcessError.notInitialized();
+    }
+    const validation = this.commandValidator.validateCommand(command);
+    if (!validation.isValid || !validation.normalizedCommand) {
+      throw ProcessError.invalidCommand(command, validation.error || "Unknown error");
+    }
+    const normalizedCommand = validation.normalizedCommand;
+    if (validation.requiresApproval) {
+      if (!options.approvalFunction) {
+        throw ProcessError.approvalRequired(
+          normalizedCommand,
+          "Command requires approval but no approval mechanism provided"
+        );
+      }
+      logger.info(
+        `Command requires approval: ${normalizedCommand} - requesting user confirmation`
+      );
+      const approved = await options.approvalFunction(normalizedCommand);
+      if (!approved) {
+        logger.info(`Command approval denied: ${normalizedCommand}`);
+        throw ProcessError.approvalDenied(normalizedCommand);
+      }
+      logger.info(`Command approved: ${normalizedCommand}`);
+    }
+    const rawTimeout = options.timeout !== void 0 && Number.isFinite(options.timeout) ? options.timeout : DEFAULT_TIMEOUT;
+    const timeout = Math.max(1, Math.min(rawTimeout, this.config.maxTimeout));
+    const cwd = this.resolveSafeCwd(options.cwd);
+    const env = {};
+    for (const [key, value] of Object.entries({
+      ...process.env,
+      ...this.config.environment,
+      ...options.env
+    })) {
+      if (value !== void 0) {
+        env[key] = value;
+      }
+    }
+    if (options.runInBackground) {
+      return await this.executeInBackground(normalizedCommand, options);
+    }
+    return await this.executeForeground(normalizedCommand, {
+      cwd,
+      timeout,
+      env,
+      ...options.description !== void 0 && { description: options.description }
+    });
+  }
+  /**
+   * Execute command in foreground with timeout
+   */
+  executeForeground(command, options) {
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let stdout = "";
+      let stderr = "";
+      let killed = false;
+      let closed = false;
+      logger.debug(`Executing command: ${command}`);
+      const child = spawn(command, {
+        cwd: options.cwd,
+        env: options.env,
+        shell: true
+      });
+      const timeoutHandle = setTimeout(() => {
+        killed = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!closed && child.exitCode === null) {
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+      }, options.timeout);
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code, signal) => {
+        closed = true;
+        clearTimeout(timeoutHandle);
+        const duration = Date.now() - startTime;
+        if (killed) {
+          reject(ProcessError.timeout(command, options.timeout));
+          return;
+        }
+        let exitCode = typeof code === "number" ? code : 1;
+        if (code === null) {
+          stderr += `
+Process terminated by signal ${signal ?? "UNKNOWN"}`;
+        }
+        logger.debug(
+          `Command completed with exit code ${exitCode} in ${duration}ms: ${command}`
+        );
+        resolve({
+          stdout,
+          stderr,
+          exitCode,
+          duration
+        });
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeoutHandle);
+        if (error.code === "ENOENT") {
+          reject(ProcessError.commandNotFound(command));
+        } else if (error.code === "EACCES") {
+          reject(ProcessError.permissionDenied(command));
+        } else {
+          reject(ProcessError.executionFailed(command, error.message));
+        }
+      });
+    });
+  }
+  /**
+   * Execute command in background
+   */
+  async executeInBackground(command, options) {
+    const runningCount = Array.from(this.backgroundProcesses.values()).filter(
+      (p) => p.status === "running"
+    ).length;
+    if (runningCount >= this.config.maxConcurrentProcesses) {
+      throw ProcessError.tooManyProcesses(runningCount, this.config.maxConcurrentProcesses);
+    }
+    const processId = crypto.randomBytes(4).toString("hex");
+    const cwd = this.resolveSafeCwd(options.cwd);
+    const env = {};
+    for (const [key, value] of Object.entries({
+      ...process.env,
+      ...this.config.environment,
+      ...options.env
+    })) {
+      if (value !== void 0) {
+        env[key] = value;
+      }
+    }
+    logger.debug(`Starting background process ${processId}: ${command}`);
+    const child = spawn(command, {
+      cwd,
+      env,
+      shell: true,
+      detached: false
+    });
+    const outputBuffer = {
+      stdout: [],
+      stderr: [],
+      complete: false,
+      lastRead: Date.now(),
+      bytesUsed: 0,
+      truncated: false
+    };
+    const bgProcess = {
+      processId,
+      command,
+      child,
+      startedAt: /* @__PURE__ */ new Date(),
+      status: "running",
+      outputBuffer,
+      description: options.description
+    };
+    this.backgroundProcesses.set(processId, bgProcess);
+    const bgTimeout = Math.max(
+      1,
+      Math.min(options.timeout || DEFAULT_TIMEOUT, this.config.maxTimeout)
+    );
+    const killTimer = setTimeout(() => {
+      if (bgProcess.status === "running") {
+        logger.warn(
+          `Background process ${processId} timed out after ${bgTimeout}ms, sending SIGTERM`
+        );
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (bgProcess.status === "running") {
+            logger.warn(
+              `Background process ${processId} did not respond to SIGTERM, sending SIGKILL`
+            );
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+      }
+    }, bgTimeout);
+    child.stdout?.on("data", (data) => {
+      const chunk = data.toString();
+      const chunkBytes = Buffer.byteLength(chunk, "utf8");
+      if (outputBuffer.bytesUsed + chunkBytes <= this.config.maxOutputBuffer) {
+        outputBuffer.stdout.push(chunk);
+        outputBuffer.bytesUsed += chunkBytes;
+      } else {
+        if (!outputBuffer.truncated) {
+          outputBuffer.truncated = true;
+          logger.warn(`Output buffer full for process ${processId}`);
+        }
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const chunk = data.toString();
+      const chunkBytes = Buffer.byteLength(chunk, "utf8");
+      if (outputBuffer.bytesUsed + chunkBytes <= this.config.maxOutputBuffer) {
+        outputBuffer.stderr.push(chunk);
+        outputBuffer.bytesUsed += chunkBytes;
+      } else {
+        if (!outputBuffer.truncated) {
+          outputBuffer.truncated = true;
+          logger.warn(`Error buffer full for process ${processId}`);
+        }
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      bgProcess.status = code === 0 ? "completed" : "failed";
+      bgProcess.exitCode = code ?? void 0;
+      bgProcess.completedAt = /* @__PURE__ */ new Date();
+      bgProcess.outputBuffer.complete = true;
+      logger.debug(`Background process ${processId} completed with exit code ${code}`);
+    });
+    child.on("error", (error) => {
+      clearTimeout(killTimer);
+      bgProcess.status = "failed";
+      bgProcess.completedAt = /* @__PURE__ */ new Date();
+      bgProcess.outputBuffer.complete = true;
+      const chunk = `Error: ${error.message}`;
+      const chunkBytes = Buffer.byteLength(chunk, "utf8");
+      if (bgProcess.outputBuffer.bytesUsed + chunkBytes <= this.config.maxOutputBuffer) {
+        bgProcess.outputBuffer.stderr.push(chunk);
+        bgProcess.outputBuffer.bytesUsed += chunkBytes;
+      } else {
+        if (!bgProcess.outputBuffer.truncated) {
+          bgProcess.outputBuffer.truncated = true;
+          logger.warn(`Error buffer full for process ${processId}`);
+        }
+      }
+      logger.error(`Background process ${processId} failed: ${error.message}`);
+    });
+    return {
+      processId,
+      command,
+      pid: child.pid,
+      startedAt: bgProcess.startedAt,
+      description: options.description
+    };
+  }
+  /**
+   * Get output from a background process
+   */
+  async getProcessOutput(processId) {
+    if (!this.initialized) {
+      throw ProcessError.notInitialized();
+    }
+    const bgProcess = this.backgroundProcesses.get(processId);
+    if (!bgProcess) {
+      throw ProcessError.processNotFound(processId);
+    }
+    const stdout = bgProcess.outputBuffer.stdout.join("");
+    const stderr = bgProcess.outputBuffer.stderr.join("");
+    bgProcess.outputBuffer.stdout = [];
+    bgProcess.outputBuffer.stderr = [];
+    bgProcess.outputBuffer.lastRead = Date.now();
+    bgProcess.outputBuffer.bytesUsed = 0;
+    return {
+      stdout,
+      stderr,
+      status: bgProcess.status,
+      exitCode: bgProcess.exitCode,
+      duration: bgProcess.completedAt ? bgProcess.completedAt.getTime() - bgProcess.startedAt.getTime() : void 0
+    };
+  }
+  /**
+   * Kill a background process
+   */
+  async killProcess(processId) {
+    if (!this.initialized) {
+      throw ProcessError.notInitialized();
+    }
+    const bgProcess = this.backgroundProcesses.get(processId);
+    if (!bgProcess) {
+      throw ProcessError.processNotFound(processId);
+    }
+    if (bgProcess.status !== "running") {
+      logger.debug(`Process ${processId} is not running (status: ${bgProcess.status})`);
+      return;
+    }
+    try {
+      bgProcess.child.kill("SIGTERM");
+      setTimeout(() => {
+        if (bgProcess.child.exitCode === null) {
+          bgProcess.child.kill("SIGKILL");
+        }
+      }, 5e3);
+      logger.debug(`Process ${processId} sent SIGTERM`);
+    } catch (error) {
+      throw ProcessError.killFailed(
+        processId,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * List all background processes
+   */
+  async listProcesses() {
+    if (!this.initialized) {
+      throw ProcessError.notInitialized();
+    }
+    return Array.from(this.backgroundProcesses.values()).map((bgProcess) => ({
+      processId: bgProcess.processId,
+      command: bgProcess.command,
+      pid: bgProcess.child.pid,
+      status: bgProcess.status,
+      startedAt: bgProcess.startedAt,
+      completedAt: bgProcess.completedAt,
+      exitCode: bgProcess.exitCode,
+      description: bgProcess.description
+    }));
+  }
+  /**
+   * Get buffer size in bytes
+   */
+  getBufferSize(buffer) {
+    const stdoutSize = buffer.stdout.reduce((sum, line) => sum + line.length, 0);
+    const stderrSize = buffer.stderr.reduce((sum, line) => sum + line.length, 0);
+    return stdoutSize + stderrSize;
+  }
+  /**
+   * Get service configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Resolve and confine cwd to the configured working directory
+   */
+  resolveSafeCwd(cwd) {
+    const baseDir = this.config.workingDirectory || process.cwd();
+    if (!cwd) return baseDir;
+    const candidate = path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(baseDir, cwd);
+    const rel = path.relative(baseDir, candidate);
+    const outside = rel.startsWith("..") || path.isAbsolute(rel);
+    if (outside) {
+      throw ProcessError.invalidWorkingDirectory(
+        cwd,
+        `Working directory must be within ${baseDir}`
+      );
+    }
+    return candidate;
+  }
+  /**
+   * Cleanup completed processes
+   */
+  async cleanup() {
+    const now = Date.now();
+    const CLEANUP_AGE = 36e5;
+    for (const [processId, bgProcess] of this.backgroundProcesses.entries()) {
+      if (bgProcess.status !== "running" && bgProcess.completedAt) {
+        const age = now - bgProcess.completedAt.getTime();
+        if (age > CLEANUP_AGE) {
+          this.backgroundProcesses.delete(processId);
+          logger.debug(`Cleaned up old process ${processId}`);
+        }
+      }
+    }
+  }
+}
+export {
+  ProcessService
+};

package/dist/{storage/backend/database-backend.cjs → process/types.cjs}

@@ -12,5 +12,5 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var database_backend_exports = {};
-module.exports = __toCommonJS(database_backend_exports);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/process/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Process Service Types
+ *
+ * Types and interfaces for command execution and process management
+ */
+/**
+ * Process execution options
+ */
+export 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;
+    /** Optional approval function for dangerous commands - called when CommandValidator flags requiresApproval */
+    approvalFunction?: (command: string) => Promise<boolean>;
+}
+/**
+ * Process execution result (foreground execution only)
+ * For background execution, see ProcessHandle
+ */
+export interface ProcessResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}
+/**
+ * Background process handle
+ */
+export interface ProcessHandle {
+    processId: string;
+    command: string;
+    pid?: number | undefined;
+    startedAt: Date;
+    description?: string | undefined;
+}
+/**
+ * Process output (for retrieving from background processes)
+ */
+export interface ProcessOutput {
+    stdout: string;
+    stderr: string;
+    status: 'running' | 'completed' | 'failed';
+    exitCode?: number | undefined;
+    duration?: number | undefined;
+}
+/**
+ * Process information
+ */
+export 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
+ */
+export interface CommandValidation {
+    isValid: boolean;
+    error?: string;
+    normalizedCommand?: string;
+    requiresApproval?: boolean;
+}
+/**
+ * Process service configuration
+ */
+export 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
+ */
+export interface OutputBuffer {
+    stdout: string[];
+    stderr: string[];
+    complete: boolean;
+    lastRead: number;
+    bytesUsed: number;
+    truncated?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/process/types.d.ts.map

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

package/dist/prompts/error-codes.cjs

@@ -0,0 +1,38 @@
+"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 error_codes_exports = {};
+__export(error_codes_exports, {
+  PromptErrorCode: () => PromptErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var PromptErrorCode = /* @__PURE__ */ ((PromptErrorCode2) => {
+  PromptErrorCode2["PROMPT_NOT_FOUND"] = "prompt_not_found";
+  PromptErrorCode2["PROMPT_EMPTY_CONTENT"] = "prompt_empty_content";
+  PromptErrorCode2["PROMPT_PROVIDER_NOT_FOUND"] = "prompt_provider_not_found";
+  PromptErrorCode2["PROMPT_NAME_REQUIRED"] = "prompt_name_required";
+  PromptErrorCode2["PROMPT_INVALID_NAME"] = "prompt_invalid_name";
+  PromptErrorCode2["PROMPT_MISSING_TEXT"] = "prompt_missing_text";
+  PromptErrorCode2["PROMPT_MISSING_REQUIRED_ARGUMENTS"] = "prompt_missing_required_arguments";
+  PromptErrorCode2["PROMPT_ALREADY_EXISTS"] = "prompt_already_exists";
+  return PromptErrorCode2;
+})(PromptErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromptErrorCode
+});

package/dist/prompts/error-codes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prompt-specific error codes
+ * Includes prompt resolution, validation, and provider errors
+ */
+export declare enum PromptErrorCode {
+    PROMPT_NOT_FOUND = "prompt_not_found",
+    PROMPT_EMPTY_CONTENT = "prompt_empty_content",
+    PROMPT_PROVIDER_NOT_FOUND = "prompt_provider_not_found",
+    PROMPT_NAME_REQUIRED = "prompt_name_required",
+    PROMPT_INVALID_NAME = "prompt_invalid_name",
+    PROMPT_MISSING_TEXT = "prompt_missing_text",
+    PROMPT_MISSING_REQUIRED_ARGUMENTS = "prompt_missing_required_arguments",
+    PROMPT_ALREADY_EXISTS = "prompt_already_exists"
+}
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/prompts/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/prompts/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IAEvB,gBAAgB,qBAAqB;IACrC,oBAAoB,yBAAyB;IAC7C,yBAAyB,8BAA8B;IAGvD,oBAAoB,yBAAyB;IAC7C,mBAAmB,wBAAwB;IAC3C,mBAAmB,wBAAwB;IAC3C,iCAAiC,sCAAsC;IACvE,qBAAqB,0BAA0B;CAClD"}

package/dist/prompts/error-codes.js

@@ -0,0 +1,15 @@
+import "../chunk-C6A6W6XS.js";
+var PromptErrorCode = /* @__PURE__ */ ((PromptErrorCode2) => {
+  PromptErrorCode2["PROMPT_NOT_FOUND"] = "prompt_not_found";
+  PromptErrorCode2["PROMPT_EMPTY_CONTENT"] = "prompt_empty_content";
+  PromptErrorCode2["PROMPT_PROVIDER_NOT_FOUND"] = "prompt_provider_not_found";
+  PromptErrorCode2["PROMPT_NAME_REQUIRED"] = "prompt_name_required";
+  PromptErrorCode2["PROMPT_INVALID_NAME"] = "prompt_invalid_name";
+  PromptErrorCode2["PROMPT_MISSING_TEXT"] = "prompt_missing_text";
+  PromptErrorCode2["PROMPT_MISSING_REQUIRED_ARGUMENTS"] = "prompt_missing_required_arguments";
+  PromptErrorCode2["PROMPT_ALREADY_EXISTS"] = "prompt_already_exists";
+  return PromptErrorCode2;
+})(PromptErrorCode || {});
+export {
+  PromptErrorCode
+};