@dexto/core 1.1.10 → 1.2.0

package/dist/approval/providers/factory.js

@@ -0,0 +1,15 @@
+import "../../chunk-C6A6W6XS.js";
+import { randomUUID } from "crypto";
+function createApprovalRequest(details) {
+  return {
+    approvalId: randomUUID(),
+    type: details.type,
+    sessionId: details.sessionId,
+    timeout: details.timeout,
+    timestamp: /* @__PURE__ */ new Date(),
+    metadata: details.metadata
+  };
+}
+export {
+  createApprovalRequest
+};

package/dist/approval/providers/noop-approval-provider.cjs

@@ -0,0 +1,54 @@
+"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 noop_approval_provider_exports = {};
+__export(noop_approval_provider_exports, {
+  NoOpApprovalProvider: () => NoOpApprovalProvider
+});
+module.exports = __toCommonJS(noop_approval_provider_exports);
+var import_logger = require("../../logger/index.js");
+class NoOpApprovalProvider {
+  defaultStatus;
+  constructor(options) {
+    this.defaultStatus = options.defaultStatus;
+  }
+  async requestApproval(request) {
+    import_logger.logger.info(
+      `Auto-${this.defaultStatus} approval '${request.type}', approvalId: ${request.approvalId}`
+    );
+    const response = {
+      approvalId: request.approvalId,
+      status: this.defaultStatus
+    };
+    if (request.sessionId !== void 0) {
+      response.sessionId = request.sessionId;
+    }
+    return response;
+  }
+  cancelApproval(_approvalId) {
+  }
+  cancelAllApprovals() {
+  }
+  getPendingApprovals() {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoOpApprovalProvider
+});

package/dist/approval/providers/noop-approval-provider.d.ts

@@ -0,0 +1,18 @@
+import type { ApprovalProvider, ApprovalRequest, ApprovalResponse, ApprovalStatus } from '../types.js';
+/**
+ * No-op approval provider that automatically approves or denies all requests
+ * without user interaction.
+ *
+ * Used for auto-approve and auto-deny modes.
+ */
+export declare class NoOpApprovalProvider implements ApprovalProvider {
+    private defaultStatus;
+    constructor(options: {
+        defaultStatus: ApprovalStatus;
+    });
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    cancelApproval(_approvalId: string): void;
+    cancelAllApprovals(): void;
+    getPendingApprovals(): string[];
+}
+//# sourceMappingURL=noop-approval-provider.d.ts.map

package/dist/approval/providers/noop-approval-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-approval-provider.d.ts","sourceRoot":"","sources":["../../../src/approval/providers/noop-approval-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACjB,MAAM,aAAa,CAAC;AAGrB;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IACzD,OAAO,CAAC,aAAa,CAAiB;gBAE1B,OAAO,EAAE;QAAE,aAAa,EAAE,cAAc,CAAA;KAAE;IAIhD,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAiB1E,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIzC,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,MAAM,EAAE;CAGlC"}

package/dist/approval/providers/noop-approval-provider.js

@@ -0,0 +1,31 @@
+import "../../chunk-C6A6W6XS.js";
+import { logger } from "../../logger/index.js";
+class NoOpApprovalProvider {
+  defaultStatus;
+  constructor(options) {
+    this.defaultStatus = options.defaultStatus;
+  }
+  async requestApproval(request) {
+    logger.info(
+      `Auto-${this.defaultStatus} approval '${request.type}', approvalId: ${request.approvalId}`
+    );
+    const response = {
+      approvalId: request.approvalId,
+      status: this.defaultStatus
+    };
+    if (request.sessionId !== void 0) {
+      response.sessionId = request.sessionId;
+    }
+    return response;
+  }
+  cancelApproval(_approvalId) {
+  }
+  cancelAllApprovals() {
+  }
+  getPendingApprovals() {
+    return [];
+  }
+}
+export {
+  NoOpApprovalProvider
+};

package/dist/approval/schemas.cjs

@@ -0,0 +1,204 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  ApprovalRequestDetailsSchema: () => ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema: () => ApprovalRequestSchema,
+  ApprovalResponseSchema: () => ApprovalResponseSchema,
+  ApprovalStatusSchema: () => ApprovalStatusSchema,
+  ApprovalTypeSchema: () => ApprovalTypeSchema,
+  BaseApprovalRequestSchema: () => BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema: () => BaseApprovalResponseSchema,
+  CommandConfirmationMetadataSchema: () => CommandConfirmationMetadataSchema,
+  CommandConfirmationRequestSchema: () => CommandConfirmationRequestSchema,
+  CommandConfirmationResponseDataSchema: () => CommandConfirmationResponseDataSchema,
+  CommandConfirmationResponseSchema: () => CommandConfirmationResponseSchema,
+  CustomApprovalMetadataSchema: () => CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema: () => CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema: () => CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema: () => CustomApprovalResponseSchema,
+  ElicitationMetadataSchema: () => ElicitationMetadataSchema,
+  ElicitationRequestSchema: () => ElicitationRequestSchema,
+  ElicitationResponseDataSchema: () => ElicitationResponseDataSchema,
+  ElicitationResponseSchema: () => ElicitationResponseSchema,
+  ToolConfirmationMetadataSchema: () => ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema: () => ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema: () => ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema: () => ToolConfirmationResponseSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_types = require("./types.js");
+const ApprovalTypeSchema = import_zod.z.nativeEnum(import_types.ApprovalType);
+const ApprovalStatusSchema = import_zod.z.nativeEnum(import_types.ApprovalStatus);
+const ToolConfirmationMetadataSchema = import_zod.z.object({
+  toolName: import_zod.z.string().describe("Name of the tool to confirm"),
+  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")
+}).strict().describe("Tool confirmation metadata");
+const CommandConfirmationMetadataSchema = import_zod.z.object({
+  toolName: import_zod.z.string().describe("Name of the tool executing the command"),
+  command: import_zod.z.string().describe("The normalized command to execute"),
+  originalCommand: import_zod.z.string().optional().describe("The original command before normalization")
+}).strict().describe("Command confirmation metadata");
+const ElicitationMetadataSchema = import_zod.z.object({
+  schema: import_zod.z.record(import_zod.z.unknown()).describe("JSON Schema for the form"),
+  prompt: import_zod.z.string().describe("Prompt to show the user"),
+  serverName: import_zod.z.string().describe("MCP server requesting input"),
+  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 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"),
+  timestamp: import_zod.z.date().describe("When the request was created")
+}).describe("Base approval request");
+const ToolConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.TOOL_CONFIRMATION),
+  metadata: ToolConfirmationMetadataSchema
+}).strict();
+const CommandConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.COMMAND_CONFIRMATION),
+  metadata: CommandConfirmationMetadataSchema
+}).strict();
+const ElicitationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.ELICITATION),
+  metadata: ElicitationMetadataSchema
+}).strict();
+const CustomApprovalRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.CUSTOM),
+  metadata: CustomApprovalMetadataSchema
+}).strict();
+const ApprovalRequestSchema = import_zod.z.discriminatedUnion("type", [
+  ToolConfirmationRequestSchema,
+  CommandConfirmationRequestSchema,
+  ElicitationRequestSchema,
+  CustomApprovalRequestSchema
+]);
+const ToolConfirmationResponseDataSchema = import_zod.z.object({
+  rememberChoice: import_zod.z.boolean().optional().describe("Remember this choice")
+}).strict().describe("Tool confirmation response data");
+const CommandConfirmationResponseDataSchema = import_zod.z.object({
+  // Command confirmations don't have remember choice - they're per-command
+  // Could add command pattern remembering in future (e.g., "remember git push *")
+}).strict().describe("Command confirmation response data");
+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 BaseApprovalResponseSchema = import_zod.z.object({
+  approvalId: import_zod.z.string().uuid().describe("Must match request approvalId"),
+  status: ApprovalStatusSchema.describe("Approval status"),
+  sessionId: import_zod.z.string().optional().describe("Session identifier")
+}).describe("Base approval response");
+const ToolConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ToolConfirmationResponseDataSchema.optional()
+}).strict();
+const CommandConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: CommandConfirmationResponseDataSchema.optional()
+}).strict();
+const ElicitationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ElicitationResponseDataSchema.optional()
+}).strict();
+const CustomApprovalResponseSchema = BaseApprovalResponseSchema.extend({
+  data: CustomApprovalResponseDataSchema.optional()
+}).strict();
+const ApprovalResponseSchema = import_zod.z.union([
+  ToolConfirmationResponseSchema,
+  CommandConfirmationResponseSchema,
+  ElicitationResponseSchema,
+  CustomApprovalResponseSchema
+]);
+const ApprovalRequestDetailsSchema = import_zod.z.object({
+  type: ApprovalTypeSchema,
+  sessionId: import_zod.z.string().optional(),
+  timeout: import_zod.z.number().int().positive(),
+  metadata: import_zod.z.union([
+    ToolConfirmationMetadataSchema,
+    CommandConfirmationMetadataSchema,
+    ElicitationMetadataSchema,
+    CustomApprovalMetadataSchema
+  ])
+}).superRefine((data, ctx) => {
+  if (data.type === import_types.ApprovalType.TOOL_CONFIRMATION) {
+    const result = ToolConfirmationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match ToolConfirmationMetadataSchema for TOOL_CONFIRMATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === import_types.ApprovalType.COMMAND_CONFIRMATION) {
+    const result = CommandConfirmationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match CommandConfirmationMetadataSchema for COMMAND_CONFIRMATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === import_types.ApprovalType.ELICITATION) {
+    const result = ElicitationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match ElicitationMetadataSchema for ELICITATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === import_types.ApprovalType.CUSTOM) {
+    const result = CustomApprovalMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match CustomApprovalMetadataSchema for CUSTOM type",
+        path: ["metadata"]
+      });
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema,
+  ApprovalResponseSchema,
+  ApprovalStatusSchema,
+  ApprovalTypeSchema,
+  BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema,
+  CommandConfirmationMetadataSchema,
+  CommandConfirmationRequestSchema,
+  CommandConfirmationResponseDataSchema,
+  CommandConfirmationResponseSchema,
+  CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema,
+  ElicitationMetadataSchema,
+  ElicitationRequestSchema,
+  ElicitationResponseDataSchema,
+  ElicitationResponseSchema,
+  ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema
+});