@dexto/core 1.3.0 → 1.5.0

package/dist/approval/manager.js

@@ -1,12 +1,28 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
+import path from "node:path";
 import { ApprovalType, ApprovalStatus, DenialReason } from "./types.js";
 import { createApprovalRequest } from "./factory.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { ApprovalError } from "./errors.js";
+import { patternCovers } from "../tools/bash-pattern-utils.js";
 class ApprovalManager {
   handler;
   config;
   logger;
+  /**
+   * Bash command patterns approved for the current session.
+   * Patterns use simple glob syntax (e.g., "git *", "npm install *").
+   * Cleared when session ends.
+   */
+  bashPatterns = /* @__PURE__ */ new Set();
+  /**
+   * Directories approved for file access for the current session.
+   * Stores normalized absolute paths mapped to their approval type:
+   * - 'session': No directory prompt, follows tool config (working dir + user session-approved)
+   * - 'once': Prompts each time, but tool can execute
+   * Cleared when session ends.
+   */
+  approvedDirectories = /* @__PURE__ */ new Map();
   constructor(config, logger) {
     this.config = config;
     this.logger = logger.createChild(DextoLogComponent.APPROVAL);
@@ -14,6 +30,201 @@ class ApprovalManager {
       `ApprovalManager initialized with toolConfirmation.mode: ${config.toolConfirmation.mode}, elicitation.enabled: ${config.elicitation.enabled}`
     );
   }
+  // ==================== Bash Pattern Methods ====================
+  /**
+   * Add a bash command pattern to the approved list for this session.
+   * Patterns use simple glob syntax with * as wildcard.
+   *
+   * @example
+   * ```typescript
+   * manager.addBashPattern("git *");        // Approves all git commands
+   * manager.addBashPattern("npm install *"); // Approves npm install with any package
+   * ```
+   */
+  addBashPattern(pattern) {
+    this.bashPatterns.add(pattern);
+    this.logger.debug(`Added bash pattern: "${pattern}"`);
+  }
+  /**
+   * Check if a bash pattern key is covered by any approved pattern.
+   * Uses pattern-to-pattern covering for broader pattern support.
+   *
+   * @param patternKey The pattern key generated from the command (e.g., "git push *")
+   * @returns true if the pattern key is covered by an approved pattern
+   */
+  matchesBashPattern(patternKey) {
+    for (const storedPattern of this.bashPatterns) {
+      if (patternCovers(storedPattern, patternKey)) {
+        this.logger.debug(
+          `Pattern key "${patternKey}" is covered by approved pattern "${storedPattern}"`
+        );
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Clear all approved bash patterns.
+   * Should be called when session ends.
+   */
+  clearBashPatterns() {
+    const count = this.bashPatterns.size;
+    this.bashPatterns.clear();
+    if (count > 0) {
+      this.logger.debug(`Cleared ${count} bash patterns`);
+    }
+  }
+  /**
+   * Get the current set of approved bash patterns (for debugging/display).
+   */
+  getBashPatterns() {
+    return this.bashPatterns;
+  }
+  // ==================== Directory Access Methods ====================
+  /**
+   * Initialize the working directory as a session-approved directory.
+   * This should be called once during setup to ensure the working directory
+   * never triggers directory access prompts.
+   *
+   * @param workingDir The working directory path
+   */
+  initializeWorkingDirectory(workingDir) {
+    const normalized = path.resolve(workingDir);
+    this.approvedDirectories.set(normalized, "session");
+    this.logger.debug(`Initialized working directory as session-approved: "${normalized}"`);
+  }
+  /**
+   * Add a directory to the approved list for this session.
+   * Files within this directory (including subdirectories) will be allowed.
+   *
+   * @param directory Absolute path to the directory to approve
+   * @param type The approval type:
+   *   - 'session': No directory prompt on future accesses, follows tool config
+   *   - 'once': Will prompt again on future accesses, but tool can execute this time
+   * @example
+   * ```typescript
+   * manager.addApprovedDirectory("/external/project", 'session');
+   * // Now /external/project/src/file.ts is accessible without directory prompt
+   *
+   * manager.addApprovedDirectory("/tmp/files", 'once');
+   * // Tool can access, but will prompt again next time
+   * ```
+   */
+  addApprovedDirectory(directory, type = "session") {
+    const normalized = path.resolve(directory);
+    const existing = this.approvedDirectories.get(normalized);
+    if (existing === "session") {
+      this.logger.debug(
+        `Directory "${normalized}" already approved as 'session', not downgrading to '${type}'`
+      );
+      return;
+    }
+    this.approvedDirectories.set(normalized, type);
+    this.logger.debug(`Added approved directory: "${normalized}" (type: ${type})`);
+  }
+  /**
+   * Check if a file path is within any session-approved directory.
+   * This is used for PROMPTING decisions - only 'session' type directories count.
+   * Working directory and user session-approved directories return true.
+   *
+   * @param filePath The file path to check (can be relative or absolute)
+   * @returns true if the path is within a session-approved directory
+   */
+  isDirectorySessionApproved(filePath) {
+    const normalized = path.resolve(filePath);
+    for (const [approvedDir, type] of this.approvedDirectories) {
+      if (type !== "session") continue;
+      const relative = path.relative(approvedDir, normalized);
+      if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+        this.logger.debug(
+          `Path "${normalized}" is within session-approved directory "${approvedDir}"`
+        );
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a file path is within any approved directory (session OR once).
+   * This is used for EXECUTION decisions - both 'session' and 'once' types count.
+   * PathValidator uses this to determine if a tool can access the path.
+   *
+   * @param filePath The file path to check (can be relative or absolute)
+   * @returns true if the path is within any approved directory
+   */
+  isDirectoryApproved(filePath) {
+    const normalized = path.resolve(filePath);
+    for (const [approvedDir] of this.approvedDirectories) {
+      const relative = path.relative(approvedDir, normalized);
+      if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+        this.logger.debug(
+          `Path "${normalized}" is within approved directory "${approvedDir}"`
+        );
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Clear all approved directories.
+   * Should be called when session ends.
+   */
+  clearApprovedDirectories() {
+    const count = this.approvedDirectories.size;
+    this.approvedDirectories.clear();
+    if (count > 0) {
+      this.logger.debug(`Cleared ${count} approved directories`);
+    }
+  }
+  /**
+   * Get the current map of approved directories with their types (for debugging/display).
+   */
+  getApprovedDirectories() {
+    return this.approvedDirectories;
+  }
+  /**
+   * Get just the directory paths that are approved (for debugging/display).
+   */
+  getApprovedDirectoryPaths() {
+    return Array.from(this.approvedDirectories.keys());
+  }
+  /**
+   * Clear all session-scoped approvals (bash patterns and directories).
+   * Convenience method for clearing all session state at once.
+   */
+  clearSessionApprovals() {
+    this.clearBashPatterns();
+    this.clearApprovedDirectories();
+    this.logger.debug("Cleared all session approvals");
+  }
+  /**
+   * Request directory access approval.
+   * Convenience method for directory access requests.
+   *
+   * @example
+   * ```typescript
+   * const response = await manager.requestDirectoryAccess({
+   *   path: '/external/project/src/file.ts',
+   *   parentDir: '/external/project',
+   *   operation: 'write',
+   *   toolName: 'write_file',
+   *   sessionId: 'session-123'
+   * });
+   * ```
+   */
+  async requestDirectoryAccess(metadata) {
+    const { sessionId, timeout, ...directoryMetadata } = metadata;
+    const details = {
+      type: ApprovalType.DIRECTORY_ACCESS,
+      // Use provided timeout, fallback to config timeout, or undefined (no timeout)
+      timeout: timeout !== void 0 ? timeout : this.config.toolConfirmation.timeout,
+      metadata: directoryMetadata
+    };
+    if (sessionId !== void 0) {
+      details.sessionId = sessionId;
+    }
+    return this.requestApproval(details);
+  }
   /**
    * Request a generic approval
    */
@@ -27,7 +238,7 @@ class ApprovalManager {
     return this.handleApproval(request);
   }
   /**
-   * Handle approval requests (tool confirmation, elicitation, command confirmation, custom)
+   * Handle approval requests (tool confirmation, elicitation, command confirmation, directory access, custom)
    * @private
    */
   async handleApproval(request) {
@@ -84,7 +295,8 @@ class ApprovalManager {
     const { sessionId, timeout, ...toolMetadata } = metadata;
     const details = {
       type: ApprovalType.TOOL_CONFIRMATION,
-      timeout: timeout ?? this.config.toolConfirmation.timeout,
+      // Use provided timeout, fallback to config timeout, or undefined (no timeout)
+      timeout: timeout !== void 0 ? timeout : this.config.toolConfirmation.timeout,
       metadata: toolMetadata
     };
     if (sessionId !== void 0) {
@@ -117,7 +329,8 @@ class ApprovalManager {
     const { sessionId, timeout, ...commandMetadata } = metadata;
     const details = {
       type: ApprovalType.COMMAND_CONFIRMATION,
-      timeout: timeout ?? this.config.toolConfirmation.timeout,
+      // Use provided timeout, fallback to config timeout, or undefined (no timeout)
+      timeout: timeout !== void 0 ? timeout : this.config.toolConfirmation.timeout,
       metadata: commandMetadata
     };
     if (sessionId !== void 0) {
@@ -136,7 +349,8 @@ class ApprovalManager {
     const { sessionId, timeout, ...elicitationMetadata } = metadata;
     const details = {
       type: ApprovalType.ELICITATION,
-      timeout: timeout ?? this.config.elicitation.timeout,
+      // Use provided timeout, fallback to config timeout, or undefined (no timeout)
+      timeout: timeout !== void 0 ? timeout : this.config.elicitation.timeout,
       metadata: elicitationMetadata
     };
     if (sessionId !== void 0) {
@@ -211,6 +425,12 @@ class ApprovalManager {
   getPendingApprovals() {
     return this.handler?.getPending?.() ?? [];
   }
+  /**
+   * Get full pending approval requests
+   */
+  getPendingApprovalRequests() {
+    return this.handler?.getPendingRequests?.() ?? [];
+  }
   /**
    * Get current configuration
    */

package/dist/approval/schemas.cjs

@@ -34,6 +34,10 @@ __export(schemas_exports, {
   CustomApprovalResponseDataSchema: () => CustomApprovalResponseDataSchema,
   CustomApprovalResponseSchema: () => CustomApprovalResponseSchema,
   DenialReasonSchema: () => DenialReasonSchema,
+  DirectoryAccessMetadataSchema: () => DirectoryAccessMetadataSchema,
+  DirectoryAccessRequestSchema: () => DirectoryAccessRequestSchema,
+  DirectoryAccessResponseDataSchema: () => DirectoryAccessResponseDataSchema,
+  DirectoryAccessResponseSchema: () => DirectoryAccessResponseSchema,
   ElicitationMetadataSchema: () => ElicitationMetadataSchema,
   ElicitationRequestSchema: () => ElicitationRequestSchema,
   ElicitationResponseDataSchema: () => ElicitationResponseDataSchema,
@@ -46,14 +50,25 @@ __export(schemas_exports, {
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
 var import_types = require("./types.js");
+var import_display_types = require("../tools/display-types.js");
 const JsonSchema7Schema = import_zod.z.record(import_zod.z.unknown());
 const ApprovalTypeSchema = import_zod.z.nativeEnum(import_types.ApprovalType);
 const ApprovalStatusSchema = import_zod.z.nativeEnum(import_types.ApprovalStatus);
 const DenialReasonSchema = import_zod.z.nativeEnum(import_types.DenialReason);
+const ToolDisplayDataSchema = import_zod.z.custom((val) => (0, import_display_types.isValidDisplayData)(val), {
+  message: "Invalid ToolDisplayData"
+});
 const ToolConfirmationMetadataSchema = import_zod.z.object({
   toolName: import_zod.z.string().describe("Name of the tool to confirm"),
+  toolCallId: import_zod.z.string().describe("Unique tool call ID for tracking parallel tool calls"),
   args: import_zod.z.record(import_zod.z.unknown()).describe("Arguments for the tool"),
-  description: import_zod.z.string().optional().describe("Description of the tool")
+  description: import_zod.z.string().optional().describe("Description of the tool"),
+  displayPreview: ToolDisplayDataSchema.optional().describe(
+    "Preview display data for approval UI (e.g., diff preview)"
+  ),
+  suggestedPatterns: import_zod.z.array(import_zod.z.string()).optional().describe(
+    'Suggested patterns for session approval (for bash commands). E.g., ["git push *", "git *"] for command "git push origin main"'
+  )
 }).strict().describe("Tool confirmation metadata");
 const CommandConfirmationMetadataSchema = import_zod.z.object({
   toolName: import_zod.z.string().describe("Name of the tool executing the command"),
@@ -67,11 +82,17 @@ const ElicitationMetadataSchema = import_zod.z.object({
   context: import_zod.z.record(import_zod.z.unknown()).optional().describe("Additional context")
 }).strict().describe("Elicitation metadata");
 const CustomApprovalMetadataSchema = import_zod.z.record(import_zod.z.unknown()).describe("Custom metadata");
+const DirectoryAccessMetadataSchema = import_zod.z.object({
+  path: import_zod.z.string().describe("Full path being accessed"),
+  parentDir: import_zod.z.string().describe("Parent directory (what gets approved for session)"),
+  operation: import_zod.z.enum(["read", "write", "edit"]).describe("Type of file operation"),
+  toolName: import_zod.z.string().describe("Name of the tool requesting access")
+}).strict().describe("Directory access metadata");
 const BaseApprovalRequestSchema = import_zod.z.object({
   approvalId: import_zod.z.string().uuid().describe("Unique approval identifier"),
   type: ApprovalTypeSchema.describe("Type of approval"),
   sessionId: import_zod.z.string().optional().describe("Session identifier"),
-  timeout: import_zod.z.number().int().positive().describe("Timeout in milliseconds"),
+  timeout: import_zod.z.number().int().positive().optional().describe("Timeout in milliseconds (optional - no timeout if not specified)"),
   timestamp: import_zod.z.date().describe("When the request was created")
 }).describe("Base approval request");
 const ToolConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
@@ -90,14 +111,22 @@ const CustomApprovalRequestSchema = BaseApprovalRequestSchema.extend({
   type: import_zod.z.literal(import_types.ApprovalType.CUSTOM),
   metadata: CustomApprovalMetadataSchema
 }).strict();
+const DirectoryAccessRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.DIRECTORY_ACCESS),
+  metadata: DirectoryAccessMetadataSchema
+}).strict();
 const ApprovalRequestSchema = import_zod.z.discriminatedUnion("type", [
   ToolConfirmationRequestSchema,
   CommandConfirmationRequestSchema,
   ElicitationRequestSchema,
-  CustomApprovalRequestSchema
+  CustomApprovalRequestSchema,
+  DirectoryAccessRequestSchema
 ]);
 const ToolConfirmationResponseDataSchema = import_zod.z.object({
-  rememberChoice: import_zod.z.boolean().optional().describe("Remember this choice")
+  rememberChoice: import_zod.z.boolean().optional().describe("Remember this tool for the session (approves ALL uses of this tool)"),
+  rememberPattern: import_zod.z.string().optional().describe(
+    'Remember a command pattern for bash commands (e.g., "git *"). Only applicable for bash_exec tool approvals.'
+  )
 }).strict().describe("Tool confirmation response data");
 const CommandConfirmationResponseDataSchema = import_zod.z.object({
   // Command confirmations don't have remember choice - they're per-command
@@ -107,6 +136,9 @@ const ElicitationResponseDataSchema = import_zod.z.object({
   formData: import_zod.z.record(import_zod.z.unknown()).describe("Form data matching schema")
 }).strict().describe("Elicitation response data");
 const CustomApprovalResponseDataSchema = import_zod.z.record(import_zod.z.unknown()).describe("Custom response data");
+const DirectoryAccessResponseDataSchema = import_zod.z.object({
+  rememberDirectory: import_zod.z.boolean().optional().describe("Remember this directory for the session (allows all file access within it)")
+}).strict().describe("Directory access response data");
 const BaseApprovalResponseSchema = import_zod.z.object({
   approvalId: import_zod.z.string().uuid().describe("Must match request approvalId"),
   status: ApprovalStatusSchema.describe("Approval status"),
@@ -129,21 +161,26 @@ const ElicitationResponseSchema = BaseApprovalResponseSchema.extend({
 const CustomApprovalResponseSchema = BaseApprovalResponseSchema.extend({
   data: CustomApprovalResponseDataSchema.optional()
 }).strict();
+const DirectoryAccessResponseSchema = BaseApprovalResponseSchema.extend({
+  data: DirectoryAccessResponseDataSchema.optional()
+}).strict();
 const ApprovalResponseSchema = import_zod.z.union([
   ToolConfirmationResponseSchema,
   CommandConfirmationResponseSchema,
   ElicitationResponseSchema,
-  CustomApprovalResponseSchema
+  CustomApprovalResponseSchema,
+  DirectoryAccessResponseSchema
 ]);
 const ApprovalRequestDetailsSchema = import_zod.z.object({
   type: ApprovalTypeSchema,
   sessionId: import_zod.z.string().optional(),
-  timeout: import_zod.z.number().int().positive(),
+  timeout: import_zod.z.number().int().positive().optional().describe("Timeout in milliseconds (optional - no timeout if not specified)"),
   metadata: import_zod.z.union([
     ToolConfirmationMetadataSchema,
     CommandConfirmationMetadataSchema,
     ElicitationMetadataSchema,
-    CustomApprovalMetadataSchema
+    CustomApprovalMetadataSchema,
+    DirectoryAccessMetadataSchema
   ])
 }).superRefine((data, ctx) => {
   if (data.type === import_types.ApprovalType.TOOL_CONFIRMATION) {
@@ -173,6 +210,15 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
         path: ["metadata"]
       });
     }
+  } else if (data.type === import_types.ApprovalType.DIRECTORY_ACCESS) {
+    const result = DirectoryAccessMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match DirectoryAccessMetadataSchema for DIRECTORY_ACCESS type",
+        path: ["metadata"]
+      });
+    }
   } else if (data.type === import_types.ApprovalType.CUSTOM) {
     const result = CustomApprovalMetadataSchema.safeParse(data.metadata);
     if (!result.success) {
@@ -202,6 +248,10 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
   CustomApprovalResponseDataSchema,
   CustomApprovalResponseSchema,
   DenialReasonSchema,
+  DirectoryAccessMetadataSchema,
+  DirectoryAccessRequestSchema,
+  DirectoryAccessResponseDataSchema,
+  DirectoryAccessResponseSchema,
   ElicitationMetadataSchema,
   ElicitationRequestSchema,
   ElicitationResponseDataSchema,