@alcyone-labs/arg-parser 2.4.2 → 2.6.0

package/dist/index.cjs

@@ -1075,6 +1075,29 @@ class ConfigurationManager {
     }
   }
 }
+const zodDxtOptionsSchema = zod.z.object({
+  sensitive: zod.z.boolean().optional().describe("Whether this field should be marked as sensitive in DXT user_config"),
+  localDefault: zod.z.string().optional().describe("Default value specific to DXT sandbox environment"),
+  type: zod.z.enum(["string", "directory", "file", "boolean", "number"]).optional().describe("DXT input type - determines UI component in DXT clients"),
+  multiple: zod.z.boolean().optional().describe("Allow multiple values (for arrays)"),
+  min: zod.z.number().optional().describe("Minimum value (for number type)"),
+  max: zod.z.number().optional().describe("Maximum value (for number type)"),
+  default: zod.z.any().optional().describe("DXT-specific default value (overrides localDefault if provided)"),
+  title: zod.z.string().optional().describe("Custom title for the user_config field")
+}).strict().refine(
+  (data2) => {
+    if ((data2.min !== void 0 || data2.max !== void 0) && data2.type !== "number") {
+      return false;
+    }
+    if (data2.min !== void 0 && data2.max !== void 0 && data2.min > data2.max) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "Invalid dxtOptions: min/max can only be used with type 'number', and min must be <= max"
+  }
+);
 const zodFlagSchema = zod.z.object({
   name: zod.z.string().min(1, "Flag name cannot be empty").describe(
     "The output property name, used as a return key `{name: value}`. Must be unique."
@@ -1111,6 +1134,11 @@ const zodFlagSchema = zod.z.object({
       "Must be a custom parser function"
     ),
     // Custom parser function (value: string) => any | Promise<any>
+    zod.z.custom(
+      (val) => val && typeof val === "object" && val._def,
+      "Must be a Zod schema"
+    ),
+    // Zod schema for structured JSON validation
     zod.z.string().refine(
       // String literal types
       (value) => ["boolean", "string", "number", "array", "object"].includes(
@@ -1121,7 +1149,7 @@ const zodFlagSchema = zod.z.object({
       }
     )
   ]).default("string").describe(
-    "Expected data type (constructor or string literal) or a custom parser function. Defaults to 'string'."
+    "Expected data type (constructor, string literal, custom parser function, or Zod schema). Defaults to 'string'."
   ),
   mandatory: zod.z.union([
     zod.z.boolean(),
@@ -1141,7 +1169,8 @@ const zodFlagSchema = zod.z.object({
   enum: zod.z.array(zod.z.any()).optional().describe("Array of allowed values for the flag."),
   env: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional().describe(
     "Environment variables that should be set from this flag's value in DXT packages."
-  )
+  ),
+  dxtOptions: zodDxtOptionsSchema.optional().describe("DXT-specific configuration options for enhanced DXT manifest generation")
 }).transform((obj) => {
   const newObj = { ...obj };
   if ("default" in newObj && newObj["default"] !== void 0 && !("defaultValue" in newObj)) {
@@ -1153,6 +1182,9 @@ const zodFlagSchema = zod.z.object({
   return newObj;
 });
 function getJsonSchemaTypeFromFlag(flagType) {
+  if (flagType && typeof flagType === "object" && flagType._def) {
+    return "object";
+  }
   if (typeof flagType === "function") {
     if (flagType === String) return "string";
     if (flagType === Number) return "number";
@@ -1336,6 +1368,353 @@ echo "Mock DXT build script for ${serverInfo.name}"`;
     return process.env["NODE_ENV"] === "test" || ((_a = process.argv[0]) == null ? void 0 : _a.includes("vitest")) || ((_b = process.argv[1]) == null ? void 0 : _b.includes("vitest")) || ((_c = process.argv[1]) == null ? void 0 : _c.includes("tinypool"));
   }
 }
+function detectEntryPoint() {
+  try {
+    if (process.argv[1] && fs__namespace.existsSync(process.argv[1])) {
+      return process.argv[1];
+    }
+    if (typeof require !== "undefined" && require.main && require.main.filename) {
+      return require.main.filename;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getEntryPointFromImportMeta(importMetaUrl) {
+  if (importMetaUrl.startsWith("file://")) {
+    return decodeURIComponent(importMetaUrl.replace("file://", ""));
+  }
+  return importMetaUrl;
+}
+function normalizePath(path2) {
+  return path2.trim();
+}
+function resolveLogPath(logPath, fallbackEntryPoint) {
+  if (typeof logPath === "string") {
+    const pathWithVariables2 = DxtPathResolver.substituteVariables(
+      logPath,
+      DxtPathResolver.detectContext()
+    );
+    const normalizedPath2 = normalizePath(pathWithVariables2);
+    if (path__namespace.isAbsolute(normalizedPath2)) {
+      return normalizedPath2;
+    }
+    if (normalizedPath2.startsWith("cwd:")) {
+      const relativePath = normalizedPath2.slice(4);
+      return path__namespace.resolve(process.cwd(), relativePath);
+    }
+    const entryPoint = detectEntryPoint() || fallbackEntryPoint;
+    if (entryPoint) {
+      return path__namespace.resolve(path__namespace.dirname(entryPoint), normalizedPath2);
+    }
+    console.warn(
+      `Warning: Could not detect entry point for log path resolution. Using process.cwd() as fallback. Path: ${normalizedPath2}`
+    );
+    return path__namespace.resolve(process.cwd(), normalizedPath2);
+  }
+  const { path: logFilePath, relativeTo = "entry", basePath } = logPath;
+  const pathWithVariables = DxtPathResolver.substituteVariables(
+    logFilePath,
+    DxtPathResolver.detectContext()
+  );
+  const normalizedPath = normalizePath(pathWithVariables);
+  switch (relativeTo) {
+    case "absolute":
+      if (basePath) {
+        const resolvedBasePath = DxtPathResolver.substituteVariables(
+          basePath,
+          DxtPathResolver.detectContext()
+        );
+        return path__namespace.resolve(resolvedBasePath, normalizedPath);
+      }
+      if (path__namespace.isAbsolute(normalizedPath)) {
+        return normalizedPath;
+      }
+      console.warn(
+        `Warning: relativeTo 'absolute' specified but no basePath provided and path is not absolute. Using process.cwd() as fallback. Path: ${normalizedPath}`
+      );
+      return path__namespace.resolve(process.cwd(), normalizedPath);
+    case "cwd":
+      return path__namespace.resolve(process.cwd(), normalizedPath);
+    case "entry":
+    default:
+      const entryPoint = detectEntryPoint() || fallbackEntryPoint;
+      if (entryPoint) {
+        return path__namespace.resolve(path__namespace.dirname(entryPoint), normalizedPath);
+      }
+      console.warn(
+        `Warning: Could not detect entry point for log path resolution. Using process.cwd() as fallback. Path: ${normalizedPath}`
+      );
+      return path__namespace.resolve(process.cwd(), normalizedPath);
+  }
+}
+function entryRelative(path2) {
+  return {
+    path: path2,
+    relativeTo: "entry"
+  };
+}
+function cwdRelative(path2) {
+  return {
+    path: path2,
+    relativeTo: "cwd"
+  };
+}
+function absolutePath(path2, basePath) {
+  return {
+    path: path2,
+    relativeTo: "absolute",
+    basePath
+  };
+}
+function legacyCwdPath(path2) {
+  return `cwd:${path2}`;
+}
+const _DxtPathResolver = class _DxtPathResolver {
+  /**
+   * Detects the current execution context
+   * @param forceRefresh - Force refresh of cached context
+   * @returns Path context information
+   */
+  static detectContext(forceRefresh = false) {
+    if (!forceRefresh && this._cachedContext) {
+      return this._cachedContext;
+    }
+    const context = {
+      isDxt: this.isDxtEnvironment(),
+      userHome: void 0,
+      cwd: typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : void 0
+    };
+    const entryPoint = detectEntryPoint();
+    if (entryPoint) {
+      context.entryDir = path__namespace.dirname(entryPoint);
+    }
+    if (context.isDxt) {
+      context.extensionDir = this.detectDxtExtensionDir();
+    }
+    this._cachedContext = context;
+    return context;
+  }
+  /**
+   * Checks if the current environment is a DXT environment
+   * @returns True if running in DXT, false otherwise
+   */
+  static isDxtEnvironment() {
+    if (process.env["DXT_EXTENSION_DIR"] || process.env["CLAUDE_DESKTOP_DXT"]) {
+      return true;
+    }
+    const dxtIndicators = [
+      "manifest.json",
+      // DXT packages have manifest.json
+      ".dxt"
+      // DXT marker file
+    ];
+    for (const indicator of dxtIndicators) {
+      const indicatorPath = path__namespace.join(process.cwd(), indicator);
+      if (fs__namespace.existsSync(indicatorPath)) {
+        if (indicator === "manifest.json") {
+          try {
+            const manifest = JSON.parse(fs__namespace.readFileSync(indicatorPath, "utf-8"));
+            if (manifest.server && manifest.user_config) {
+              return true;
+            }
+          } catch {
+          }
+        } else {
+          return true;
+        }
+      }
+    }
+    const cwd = process.cwd();
+    if (cwd.includes("claude-desktop") || cwd.includes("extensions")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Detects the DXT extension directory
+   * @returns DXT extension directory path or undefined
+   */
+  static detectDxtExtensionDir() {
+    if (process.env["DXT_EXTENSION_DIR"]) {
+      return process.env["DXT_EXTENSION_DIR"];
+    }
+    const cwd = process.cwd();
+    if (fs__namespace.existsSync(path__namespace.join(cwd, "manifest.json"))) {
+      return cwd;
+    }
+    let currentDir = cwd;
+    for (let i = 0; i < 3; i++) {
+      const parentDir = path__namespace.dirname(currentDir);
+      if (parentDir === currentDir) break;
+      if (fs__namespace.existsSync(path__namespace.join(parentDir, "manifest.json"))) {
+        return parentDir;
+      }
+      currentDir = parentDir;
+    }
+    return void 0;
+  }
+  /**
+   * Resolves a path with DXT variable substitution
+   * @param inputPath - Path that may contain DXT variables
+   * @param context - Optional context (will be detected if not provided)
+   * @param config - Optional configuration for variable substitution
+   * @returns Resolved absolute path
+   */
+  static resolvePath(inputPath, context, config) {
+    const ctx = context || this.detectContext();
+    const resolvedPath = this.substituteVariables(inputPath, ctx, config);
+    if (path__namespace.isAbsolute(resolvedPath)) {
+      return resolvedPath;
+    }
+    if (ctx.isDxt && ctx.extensionDir) {
+      return path__namespace.resolve(ctx.extensionDir, resolvedPath);
+    } else if (ctx.entryDir) {
+      return path__namespace.resolve(ctx.entryDir, resolvedPath);
+    } else {
+      return path__namespace.resolve(ctx.cwd || process.cwd(), resolvedPath);
+    }
+  }
+  /**
+   * Substitutes DXT variables in a path string
+   * @param inputPath - Path containing variables like ${HOME}, ${__dirname}, etc.
+   * @param context - Path context
+   * @param config - Variable substitution configuration
+   * @returns Path with variables substituted
+   */
+  static substituteVariables(inputPath, context, config) {
+    const safeHomedir = () => "/tmp";
+    const homeDir = context.userHome || safeHomedir();
+    const variables = {
+      // Standard DXT variables
+      HOME: homeDir,
+      DOCUMENTS: path__namespace.join(homeDir, "Documents"),
+      DOWNLOADS: path__namespace.join(homeDir, "Downloads"),
+      DESKTOP: path__namespace.join(homeDir, "Desktop"),
+      pathSeparator: path__namespace.sep,
+      // Context-specific variables
+      __dirname: context.isDxt && context.extensionDir ? context.extensionDir : context.entryDir || context.cwd || process.cwd(),
+      // DXT-specific variables
+      ...context.isDxt && context.extensionDir && {
+        DXT_DIR: context.extensionDir,
+        EXTENSION_DIR: context.extensionDir
+      },
+      // Custom variables override defaults
+      ...config == null ? void 0 : config.customVariables
+    };
+    return inputPath.replace(/\$\{([^}]*)\}/g, (match, variableName) => {
+      if (!variableName.trim()) {
+        if (config == null ? void 0 : config.allowUndefined) {
+          return match;
+        }
+        throw new Error(
+          `Undefined DXT variable: ${variableName}. Available variables: ${Object.keys(variables).join(", ")}`
+        );
+      }
+      const value = variables[variableName];
+      if (value !== void 0) {
+        return value;
+      }
+      if (config == null ? void 0 : config.allowUndefined) {
+        return match;
+      }
+      throw new Error(
+        `Undefined DXT variable: ${variableName}. Available variables: ${Object.keys(variables).join(", ")}`
+      );
+    });
+  }
+  /**
+   * Creates a path for user data storage
+   * @param filename - Name of the file or subdirectory
+   * @param context - Optional context (will be detected if not provided)
+   * @returns Absolute path for user data
+   */
+  static createUserDataPath(filename, context) {
+    const ctx = context || this.detectContext();
+    if (ctx.isDxt && ctx.extensionDir) {
+      return path__namespace.join(ctx.extensionDir, "data", filename);
+    } else {
+      const safeHomedir = () => "/tmp";
+      const userDataDir = process.env["XDG_DATA_HOME"] || path__namespace.join(ctx.userHome || safeHomedir(), ".local", "share");
+      const appName = this.getAppName(ctx);
+      return path__namespace.join(userDataDir, appName, filename);
+    }
+  }
+  /**
+   * Creates a path for temporary files
+   * @param filename - Name of the temporary file
+   * @param context - Optional context (will be detected if not provided)
+   * @returns Absolute path for temporary file
+   */
+  static createTempPath(filename, context) {
+    const ctx = context || this.detectContext();
+    if (ctx.isDxt && ctx.extensionDir) {
+      return path__namespace.join(ctx.extensionDir, "temp", filename);
+    } else {
+      const safeTmpdir = () => "/tmp";
+      const appName = this.getAppName(ctx);
+      return path__namespace.join(safeTmpdir(), appName, filename);
+    }
+  }
+  /**
+   * Creates a path for configuration files
+   * @param filename - Name of the configuration file
+   * @param context - Optional context (will be detected if not provided)
+   * @returns Absolute path for configuration file
+   */
+  static createConfigPath(filename, context) {
+    const ctx = context || this.detectContext();
+    if (ctx.isDxt && ctx.extensionDir) {
+      return path__namespace.join(ctx.extensionDir, "config", filename);
+    } else {
+      const safeHomedir = () => "/tmp";
+      const configDir = process.env["XDG_CONFIG_HOME"] || path__namespace.join(ctx.userHome || safeHomedir(), ".config");
+      const appName = this.getAppName(ctx);
+      return path__namespace.join(configDir, appName, filename);
+    }
+  }
+  /**
+   * Gets the application name for directory creation
+   * @param context - Path context
+   * @returns Application name or default
+   */
+  static getAppName(context) {
+    try {
+      const packageJsonPath = path__namespace.join(context.entryDir || context.cwd || process.cwd(), "package.json");
+      if (fs__namespace.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
+        return packageJson.name || "argparser-app";
+      }
+    } catch {
+    }
+    return "argparser-app";
+  }
+  /**
+   * Ensures a directory exists, creating it if necessary
+   * @param dirPath - Directory path to ensure
+   * @returns True if directory exists or was created successfully
+   */
+  static ensureDirectory(dirPath) {
+    try {
+      if (!fs__namespace.existsSync(dirPath)) {
+        fs__namespace.mkdirSync(dirPath, { recursive: true });
+      }
+      return true;
+    } catch (error) {
+      console.warn(`Failed to create directory: ${dirPath}`, error);
+      return false;
+    }
+  }
+  /**
+   * Clears the cached context (useful for testing)
+   */
+  static clearCache() {
+    this._cachedContext = null;
+  }
+};
+_DxtPathResolver._cachedContext = null;
+let DxtPathResolver = _DxtPathResolver;
 class DxtGenerator {
   constructor(argParserInstance) {
     this.argParserInstance = argParserInstance;
@@ -1745,100 +2124,128 @@ class DxtGenerator {
           silent: process.env["NO_SILENCE"] !== "1",
           unbundle: true,
           external: (id, importer) => {
-            const external = this.shouldModuleBeExternal(
-              id,
-              importer,
-              withNodeModules
-            );
-            if (Boolean(process.env["DEBUG"]))
-              console.log(
-                `[${simpleChalk.blue("External")}] ${simpleChalk.yellow(external ? "true" : "false")} for module: (${simpleChalk.green(id)}), path: '${simpleChalk.grey(importer ?? "")}'`
+            try {
+              const external = this.shouldModuleBeExternal(
+                id,
+                importer,
+                withNodeModules
               );
-            return external;
+              if (Boolean(process.env["DEBUG"]))
+                console.log(
+                  `[${simpleChalk.blue("External")}] ${simpleChalk.yellow(external ? "true" : "false")} for module: (${simpleChalk.green(id)}), path: '${simpleChalk.grey(importer ?? "")}'`
+                );
+              return Boolean(external);
+            } catch (error) {
+              console.warn(`Warning: Error in external function for ${id}:`, error);
+              return true;
+            }
           },
           noExternal: (id, importer) => {
-            const external = this.shouldModuleBeExternal(
-              id,
-              importer,
-              withNodeModules
-            );
-            if (Boolean(process.env["DEBUG"]))
-              console.log(
-                `[${simpleChalk.yellow("noExternal")}] ${simpleChalk.yellow(external === false ? "true" : "false")} for module: (${simpleChalk.green(id)}), path: '${simpleChalk.grey(importer ?? "")}'`
+            try {
+              const external = this.shouldModuleBeExternal(
+                id,
+                importer,
+                withNodeModules
               );
-            return external === false;
+              if (Boolean(process.env["DEBUG"]))
+                console.log(
+                  `[${simpleChalk.yellow("noExternal")}] ${simpleChalk.yellow(external === false ? "true" : "false")} for module: (${simpleChalk.green(id)}), path: '${simpleChalk.grey(importer ?? "")}'`
+                );
+              return Boolean(external === false);
+            } catch (error) {
+              console.warn(`Warning: Error in noExternal function for ${id}:`, error);
+              return false;
+            }
           },
           copy: async (options) => {
             var _a2;
-            const outputPaths = [
-              "package.json"
-            ];
-            if (withNodeModules) {
-              console.log(
-                simpleChalk.gray(
-                  "📦 Including node_modules in bundle (may take longer)..."
-                )
-              );
-              outputPaths.push("node_modules");
-            }
-            const dxtPackageRoot = entryDir !== "." && entryDir !== "" ? path__namespace.dirname(options.outDir) : options.outDir;
-            if (logoFilename) {
-              const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
-              const logoPath = path__namespace.join(currentDir, logoFilename);
-              if (fs__namespace.existsSync(logoPath)) {
-                console.log(simpleChalk.gray(`Adding logo from: ${logoPath}`));
-                outputPaths.push({
-                  from: logoPath,
-                  to: path__namespace.join(dxtPackageRoot, logoFilename)
-                });
+            try {
+              const outputPaths = [
+                "package.json"
+              ];
+              if (withNodeModules) {
+                console.log(
+                  simpleChalk.gray(
+                    "📦 Including node_modules in bundle (may take longer)..."
+                  )
+                );
+                outputPaths.push("node_modules");
               }
-            }
-            if ((_a2 = mcpConfig == null ? void 0 : mcpConfig.dxt) == null ? void 0 : _a2.include) {
-              console.log(
-                simpleChalk.gray(
-                  "📁 Including additional files from DXT configuration..."
-                )
-              );
-              for (const includeItem of mcpConfig.dxt.include) {
-                if (typeof includeItem === "string") {
-                  const sourcePath = path__namespace.resolve(projectRoot, includeItem);
-                  if (fs__namespace.existsSync(sourcePath)) {
-                    console.log(simpleChalk.gray(`  • ${includeItem}`));
-                    outputPaths.push({
-                      from: sourcePath,
-                      to: path__namespace.join(dxtPackageRoot, includeItem)
-                    });
-                  } else {
-                    console.warn(
-                      simpleChalk.yellow(
-                        `  ⚠ File not found: ${includeItem} (resolved to ${sourcePath})`
-                      )
-                    );
-                  }
-                } else {
-                  const sourcePath = path__namespace.resolve(
-                    projectRoot,
-                    includeItem.from
-                  );
-                  if (fs__namespace.existsSync(sourcePath)) {
-                    console.log(
-                      simpleChalk.gray(`  • ${includeItem.from} → ${includeItem.to}`)
+              const dxtPackageRoot = entryDir !== "." && entryDir !== "" ? path__namespace.dirname(options.outDir) : options.outDir;
+              if (logoFilename) {
+                const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
+                const logoPath = path__namespace.join(currentDir, logoFilename);
+                if (fs__namespace.existsSync(logoPath)) {
+                  console.log(simpleChalk.gray(`Adding logo from: ${logoPath}`));
+                  outputPaths.push({
+                    from: logoPath,
+                    to: path__namespace.join(dxtPackageRoot, logoFilename)
+                  });
+                }
+              }
+              if ((_a2 = mcpConfig == null ? void 0 : mcpConfig.dxt) == null ? void 0 : _a2.include) {
+                console.log(
+                  simpleChalk.gray(
+                    "📁 Including additional files from DXT configuration..."
+                  )
+                );
+                for (const includeItem of mcpConfig.dxt.include) {
+                  if (typeof includeItem === "string") {
+                    const resolvedIncludePath = DxtPathResolver.substituteVariables(
+                      includeItem,
+                      DxtPathResolver.detectContext(),
+                      { allowUndefined: true }
+                      // Allow undefined variables for flexibility
                     );
-                    outputPaths.push({
-                      from: sourcePath,
-                      to: path__namespace.join(dxtPackageRoot, includeItem.to)
-                    });
+                    const sourcePath = path__namespace.resolve(projectRoot, resolvedIncludePath);
+                    if (fs__namespace.existsSync(sourcePath)) {
+                      console.log(simpleChalk.gray(`  • ${resolvedIncludePath}`));
+                      outputPaths.push({
+                        from: sourcePath,
+                        to: path__namespace.join(dxtPackageRoot, resolvedIncludePath)
+                      });
+                    } else {
+                      console.warn(
+                        simpleChalk.yellow(
+                          `  ⚠ File not found: ${resolvedIncludePath} (resolved to ${sourcePath})`
+                        )
+                      );
+                    }
                   } else {
-                    console.warn(
-                      simpleChalk.yellow(
-                        `  ⚠ File not found: ${includeItem.from} (resolved to ${sourcePath})`
-                      )
+                    const resolvedFromPath = DxtPathResolver.substituteVariables(
+                      includeItem.from,
+                      DxtPathResolver.detectContext(),
+                      { allowUndefined: true }
+                    );
+                    const resolvedToPath = DxtPathResolver.substituteVariables(
+                      includeItem.to,
+                      DxtPathResolver.detectContext(),
+                      { allowUndefined: true }
                     );
+                    const sourcePath = path__namespace.resolve(projectRoot, resolvedFromPath);
+                    if (fs__namespace.existsSync(sourcePath)) {
+                      console.log(
+                        simpleChalk.gray(`  • ${resolvedFromPath} → ${resolvedToPath}`)
+                      );
+                      outputPaths.push({
+                        from: sourcePath,
+                        to: path__namespace.join(dxtPackageRoot, resolvedToPath)
+                      });
+                    } else {
+                      console.warn(
+                        simpleChalk.yellow(
+                          `  ⚠ File not found: ${resolvedFromPath} (resolved to ${sourcePath})`
+                        )
+                      );
+                    }
                   }
                 }
               }
+              return outputPaths;
+            } catch (error) {
+              console.warn(`Warning: Error in copy function:`, error);
+              return ["package.json"];
             }
-            return outputPaths;
           },
           platform: "node",
           plugins: []
@@ -1866,8 +2273,18 @@ export default ${JSON.stringify(buildConfig, null, 2)};
             simpleChalk.gray("📝 Debug config written to dxt/tsdown.config.dxt.ts")
           );
         }
-        await build(buildConfig);
-        console.log(simpleChalk.green("✅ TSDown bundling completed"));
+        try {
+          await build(buildConfig);
+          console.log(simpleChalk.green("✅ TSDown bundling completed"));
+        } catch (buildError) {
+          console.error(simpleChalk.red("❌ TSDown build failed with error:"));
+          console.error(buildError);
+          if (buildError instanceof Error) {
+            console.error(simpleChalk.red("Error message:"), buildError.message);
+            console.error(simpleChalk.red("Error stack:"), buildError.stack);
+          }
+          throw new Error(`TSDown DXT build failed: ${buildError instanceof Error ? buildError.message : String(buildError)}`);
+        }
         const detectedOutputFile = this.detectTsdownOutputFile(
           outputDir,
           relativeEntryPath.replace(/\.ts$/, ".js")
@@ -2126,7 +2543,7 @@ export default ${JSON.stringify(buildConfig, null, 2)};
         if (flag.enum) {
           properties2[flag.name].enum = flag.enum;
         }
-        if (flag.defaultValue !== void 0) {
+        if (flag.defaultValue !== void 0 && typeof flag.defaultValue !== "function") {
           properties2[flag.name].default = flag.defaultValue;
         }
         if (flag.mandatory) {
@@ -2301,11 +2718,62 @@ export default ${JSON.stringify(buildConfig, null, 2)};
       `Could not find package.json within ${maxAttempts} directories up from ${entryPointFile}. Please ensure your entry point is within a project that has a package.json file.`
     );
   }
+  /**
+   * Validate dxtOptions for common mistakes and security issues
+   * @param flag The flag with dxtOptions to validate
+   * @param envVar The environment variable name for context
+   */
+  validateDxtOptions(flag, envVar) {
+    const dxtOptions = flag.dxtOptions;
+    if (!dxtOptions) return;
+    if (dxtOptions.min !== void 0 && dxtOptions.max !== void 0) {
+      if (dxtOptions.min > dxtOptions.max) {
+        throw new Error(
+          `Invalid dxtOptions for ${envVar}: min (${dxtOptions.min}) cannot be greater than max (${dxtOptions.max})`
+        );
+      }
+    }
+    if (dxtOptions.type !== void 0) {
+      const validTypes = ["string", "directory", "file", "boolean", "number"];
+      if (!validTypes.includes(dxtOptions.type)) {
+        throw new Error(
+          `Invalid dxtOptions.type for ${envVar}: "${dxtOptions.type}". Must be one of: ${validTypes.join(", ")}`
+        );
+      }
+    }
+    if (dxtOptions.default !== void 0 && dxtOptions.type !== void 0) {
+      const defaultType = typeof dxtOptions.default;
+      if (dxtOptions.type === "number" && defaultType !== "number") {
+        throw new Error(
+          `Invalid dxtOptions.default for ${envVar}: expected number, got ${defaultType}`
+        );
+      }
+      if (dxtOptions.type === "boolean" && defaultType !== "boolean") {
+        throw new Error(
+          `Invalid dxtOptions.default for ${envVar}: expected boolean, got ${defaultType}`
+        );
+      }
+    }
+    const sensitiveKeywords = ["key", "token", "password", "secret", "auth"];
+    const envLower = envVar.toLowerCase();
+    const hasSensitiveKeyword = sensitiveKeywords.some((keyword2) => envLower.includes(keyword2));
+    if (hasSensitiveKeyword && dxtOptions.sensitive === false) {
+      console.warn(
+        `⚠️  Security Warning: ${envVar} contains sensitive keyword but dxtOptions.sensitive is false`
+      );
+    }
+    if (flag.mandatory === true && dxtOptions.sensitive !== false) {
+      console.warn(
+        `⚠️  Security Warning: ${envVar} is required and sensitive - consider providing a secure default or making it optional`
+      );
+    }
+  }
   /**
    * Generate environment variables and user configuration from ArgParser flags
    * @returns Object containing envVars and userConfig
    */
   generateEnvAndUserConfig() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const envVars = {};
     const userConfig = {};
     const shouldBeRequired = (flag) => {
@@ -2318,23 +2786,78 @@ export default ${JSON.stringify(buildConfig, null, 2)};
       return false;
     };
     const shouldBeSensitive = (flag) => {
+      var _a2;
+      if (((_a2 = flag.dxtOptions) == null ? void 0 : _a2.sensitive) !== void 0) {
+        return flag.dxtOptions.sensitive;
+      }
       const envVar = flag.env || flag.envVar;
       return !!envVar;
     };
+    const getDxtType = (flag) => {
+      var _a2;
+      if ((_a2 = flag.dxtOptions) == null ? void 0 : _a2.type) {
+        return flag.dxtOptions.type;
+      }
+      if (typeof flag.type === "string") {
+        const lowerType = flag.type.toLowerCase();
+        if (["string", "boolean", "number"].includes(lowerType)) {
+          return lowerType;
+        }
+      } else if (flag.type === String) {
+        return "string";
+      } else if (flag.type === Boolean) {
+        return "boolean";
+      } else if (flag.type === Number) {
+        return "number";
+      }
+      return "string";
+    };
+    const getDxtTitle = (flag, envVar) => {
+      var _a2;
+      if ((_a2 = flag.dxtOptions) == null ? void 0 : _a2.title) {
+        return flag.dxtOptions.title;
+      }
+      return envVar.replace(/_/g, " ").toLowerCase().replace(/\b\w/g, (l) => l.toUpperCase());
+    };
+    const getDxtDescription = (flag, envVar) => {
+      var _a2, _b2;
+      let baseDescription = flag.description || `${envVar} environment variable`;
+      const defaultValue = ((_a2 = flag.dxtOptions) == null ? void 0 : _a2.default) ?? ((_b2 = flag.dxtOptions) == null ? void 0 : _b2.localDefault) ?? flag.defaultValue;
+      if (defaultValue !== void 0 && typeof defaultValue !== "function") {
+        baseDescription += ` (default: ${defaultValue})`;
+      }
+      return baseDescription;
+    };
     const mainFlags = this.argParserInstance.flags;
     for (const flag of mainFlags) {
       const envVar = flag.env || flag.envVar;
       if (envVar) {
+        this.validateDxtOptions(flag, envVar);
         envVars[envVar] = `\${user_config.${envVar}}`;
-        userConfig[envVar] = {
-          type: "string",
-          title: envVar.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
-          description: flag.description || `${envVar} environment variable`,
+        const userConfigEntry = {
+          type: getDxtType(flag),
+          title: getDxtTitle(flag, envVar),
+          description: getDxtDescription(flag, envVar),
           required: shouldBeRequired(flag),
           // Respect the flag's mandatory setting
           sensitive: shouldBeSensitive(flag)
-          // Set to sensitive if tied to ENV
+          // Use dxtOptions or default logic
         };
+        if (((_a = flag.dxtOptions) == null ? void 0 : _a.multiple) !== void 0) {
+          userConfigEntry.multiple = flag.dxtOptions.multiple;
+        }
+        if (((_b = flag.dxtOptions) == null ? void 0 : _b.min) !== void 0) {
+          userConfigEntry.min = flag.dxtOptions.min;
+        }
+        if (((_c = flag.dxtOptions) == null ? void 0 : _c.max) !== void 0) {
+          userConfigEntry.max = flag.dxtOptions.max;
+        }
+        if (((_d = flag.dxtOptions) == null ? void 0 : _d.default) !== void 0 && typeof flag.dxtOptions.default !== "function") {
+          userConfigEntry.default = flag.dxtOptions.default;
+        } else if (((_e = flag.dxtOptions) == null ? void 0 : _e.localDefault) !== void 0 && typeof flag.dxtOptions.localDefault !== "function") {
+          userConfigEntry.default = flag.dxtOptions.localDefault;
+        }
+        userConfig[envVar] = userConfigEntry;
       }
     }
     if (typeof this.argParserInstance.getTools === "function") {
@@ -2344,16 +2867,32 @@ export default ${JSON.stringify(buildConfig, null, 2)};
         for (const flag of toolFlags) {
           const envVar = flag.env || flag.envVar;
           if (envVar && !envVars[envVar]) {
+            this.validateDxtOptions(flag, envVar);
             envVars[envVar] = `\${user_config.${envVar}}`;
-            userConfig[envVar] = {
-              type: "string",
-              title: envVar.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
-              description: flag.description || `${envVar} environment variable`,
+            const userConfigEntry = {
+              type: getDxtType(flag),
+              title: getDxtTitle(flag, envVar),
+              description: getDxtDescription(flag, envVar),
               required: shouldBeRequired(flag),
               // Respect the flag's mandatory setting
               sensitive: shouldBeSensitive(flag)
-              // Set to sensitive if tied to ENV
+              // Use dxtOptions or default logic
             };
+            if (((_f = flag.dxtOptions) == null ? void 0 : _f.multiple) !== void 0) {
+              userConfigEntry.multiple = flag.dxtOptions.multiple;
+            }
+            if (((_g = flag.dxtOptions) == null ? void 0 : _g.min) !== void 0) {
+              userConfigEntry.min = flag.dxtOptions.min;
+            }
+            if (((_h = flag.dxtOptions) == null ? void 0 : _h.max) !== void 0) {
+              userConfigEntry.max = flag.dxtOptions.max;
+            }
+            if (((_i = flag.dxtOptions) == null ? void 0 : _i.default) !== void 0 && typeof flag.dxtOptions.default !== "function") {
+              userConfigEntry.default = flag.dxtOptions.default;
+            } else if (((_j = flag.dxtOptions) == null ? void 0 : _j.localDefault) !== void 0 && typeof flag.dxtOptions.localDefault !== "function") {
+              userConfigEntry.default = flag.dxtOptions.localDefault;
+            }
+            userConfig[envVar] = userConfigEntry;
           }
         }
       }
@@ -2384,10 +2923,10 @@ export default ${JSON.stringify(buildConfig, null, 2)};
           );
         }
         const pathsMatcher = getTsconfig.createPathsMatcher(tsconfig);
-        if (!pathsMatcher) {
+        if (!pathsMatcher || typeof pathsMatcher !== "function") {
           if (Boolean(process.env["DEBUG"])) {
             console.log(
-              `  <${simpleChalk.gray("ts-paths")}> Failed to create paths matcher`
+              `  <${simpleChalk.gray("ts-paths")}> Failed to create paths matcher or matcher is not a function`
             );
           }
         } else {
@@ -3097,7 +3636,8 @@ const _FlagManager = class _FlagManager {
       validate: parsedFromZod["validate"],
       enum: parsedFromZod["enum"],
       mandatory: parsedFromZod["mandatory"],
-      env: parsedFromZod["env"]
+      env: parsedFromZod["env"],
+      dxtOptions: parsedFromZod["dxtOptions"]
     };
   }
   addFlag(flag) {
@@ -3146,97 +3686,6 @@ const _FlagManager = class _FlagManager {
 __flags = new WeakMap();
 _throwForDuplicateFlags = new WeakMap();
 let FlagManager = _FlagManager;
-function detectEntryPoint() {
-  try {
-    if (process.argv[1] && fs__namespace.existsSync(process.argv[1])) {
-      return process.argv[1];
-    }
-    if (typeof require !== "undefined" && require.main && require.main.filename) {
-      return require.main.filename;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function getEntryPointFromImportMeta(importMetaUrl) {
-  if (importMetaUrl.startsWith("file://")) {
-    return decodeURIComponent(importMetaUrl.replace("file://", ""));
-  }
-  return importMetaUrl;
-}
-function normalizePath(path2) {
-  return path2.trim();
-}
-function resolveLogPath(logPath, fallbackEntryPoint) {
-  if (typeof logPath === "string") {
-    const normalizedPath2 = normalizePath(logPath);
-    if (path__namespace.isAbsolute(normalizedPath2)) {
-      return normalizedPath2;
-    }
-    if (normalizedPath2.startsWith("cwd:")) {
-      const relativePath = normalizedPath2.slice(4);
-      return path__namespace.resolve(process.cwd(), relativePath);
-    }
-    const entryPoint = detectEntryPoint() || fallbackEntryPoint;
-    if (entryPoint) {
-      return path__namespace.resolve(path__namespace.dirname(entryPoint), normalizedPath2);
-    }
-    console.warn(
-      `Warning: Could not detect entry point for log path resolution. Using process.cwd() as fallback. Path: ${normalizedPath2}`
-    );
-    return path__namespace.resolve(process.cwd(), normalizedPath2);
-  }
-  const { path: logFilePath, relativeTo = "entry", basePath } = logPath;
-  const normalizedPath = normalizePath(logFilePath);
-  switch (relativeTo) {
-    case "absolute":
-      if (basePath) {
-        return path__namespace.resolve(basePath, normalizedPath);
-      }
-      if (path__namespace.isAbsolute(normalizedPath)) {
-        return normalizedPath;
-      }
-      console.warn(
-        `Warning: relativeTo 'absolute' specified but no basePath provided and path is not absolute. Using process.cwd() as fallback. Path: ${normalizedPath}`
-      );
-      return path__namespace.resolve(process.cwd(), normalizedPath);
-    case "cwd":
-      return path__namespace.resolve(process.cwd(), normalizedPath);
-    case "entry":
-    default:
-      const entryPoint = detectEntryPoint() || fallbackEntryPoint;
-      if (entryPoint) {
-        return path__namespace.resolve(path__namespace.dirname(entryPoint), normalizedPath);
-      }
-      console.warn(
-        `Warning: Could not detect entry point for log path resolution. Using process.cwd() as fallback. Path: ${normalizedPath}`
-      );
-      return path__namespace.resolve(process.cwd(), normalizedPath);
-  }
-}
-function entryRelative(path2) {
-  return {
-    path: path2,
-    relativeTo: "entry"
-  };
-}
-function cwdRelative(path2) {
-  return {
-    path: path2,
-    relativeTo: "cwd"
-  };
-}
-function absolutePath(path2, basePath) {
-  return {
-    path: path2,
-    relativeTo: "absolute",
-    basePath
-  };
-}
-function legacyCwdPath(path2) {
-  return `cwd:${path2}`;
-}
 class ArgParserError extends Error {
   constructor(message, cmdChain = []) {
     super(message);
@@ -3379,7 +3828,21 @@ const _ArgParserBase = class _ArgParserBase {
       const result = flag["type"](value);
       value = result && typeof result.then === "function" ? await result : result;
     } else if (typeof flag["type"] === "object") {
-      value = new flag["type"](value);
+      if (flag["type"] && flag["type"]._def) {
+        try {
+          const parsedJson = typeof value === "string" ? JSON.parse(value) : value;
+          value = flag["type"].parse(parsedJson);
+        } catch (error) {
+          if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON for flag '${flag["name"]}': ${error.message}`);
+          } else {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Validation failed for flag '${flag["name"]}': ${errorMessage}`);
+          }
+        }
+      } else {
+        value = new flag["type"](value);
+      }
     }
     if (flag["enum"] && flag["enum"].length > 0) {
       const allowedValues = flag["enum"].map((v) => typeof v === "string" ? `'${v}'` : v).join(", ");
@@ -3751,7 +4214,28 @@ ${cyan("Flags:")}
         const descriptionLines = Array.isArray(flag["description"]) ? flag["description"] : [flag["description"]];
         const metaLines = [];
         let typeName = "unknown";
-        if (typeof flag["type"] === "function") {
+        let typeDetails = [];
+        if (flag["type"] && typeof flag["type"] === "object" && flag["type"]._def) {
+          typeName = "JSON object";
+          try {
+            const zodSchema = flag["type"];
+            const def = zodSchema._def;
+            if (def.shape) {
+              const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+              const properties2 = Object.keys(shape);
+              if (properties2.length > 0) {
+                if (properties2.length <= 4) {
+                  typeDetails.push(`Properties: ${properties2.join(", ")}`);
+                } else {
+                  typeDetails.push(`Properties: ${properties2.slice(0, 4).join(", ")}, ... (${properties2.length} total)`);
+                }
+              }
+            }
+            typeDetails.push("Expected: JSON string");
+          } catch (error) {
+            typeDetails.push("Expected: JSON string");
+          }
+        } else if (typeof flag["type"] === "function") {
           typeName = flag["type"].name || "custom function";
           if (typeName === "Boolean") typeName = "boolean";
           if (typeName === "String") typeName = "string";
@@ -3762,6 +4246,9 @@ ${cyan("Flags:")}
           typeName = flag["type"];
         }
         metaLines.push(`Type: ${typeName}`);
+        if (typeDetails.length > 0) {
+          metaLines.push(...typeDetails);
+        }
         if (flag["flagOnly"]) {
           metaLines.push("Flag only (no value expected)");
         }
@@ -4514,7 +5001,9 @@ _buildRecursiveString_fn = function(parser, level, visited = /* @__PURE__ */ new
         `${flagIndent}  Description: ${Array.isArray(flag["description"]) ? flag["description"].join(" | ") : flag["description"]}`
       );
       let typeName = "unknown";
-      if (typeof flag["type"] === "function") {
+      if (flag["type"] && typeof flag["type"] === "object" && flag["type"]._def) {
+        typeName = "Zod schema";
+      } else if (typeof flag["type"] === "function") {
         typeName = flag["type"].name || "custom function";
       } else if (typeof flag["type"] === "string") {
         typeName = flag["type"];
@@ -4581,7 +5070,9 @@ _buildRecursiveJson_fn = function(parser, visited = /* @__PURE__ */ new Set()) {
   config.flags = flags.map((flag) => {
     var _a;
     let typeName = "unknown";
-    if (typeof flag["type"] === "function") {
+    if (flag["type"] && typeof flag["type"] === "object" && flag["type"]._def) {
+      typeName = "Zod schema";
+    } else if (typeof flag["type"] === "function") {
       typeName = flag["type"].name || "custom function";
     } else if (typeof flag["type"] === "string") {
       typeName = flag["type"];
@@ -5004,6 +5495,25 @@ function createMcpErrorResponse(error) {
   };
 }
 function convertFlagToJsonSchemaProperty(flag) {
+  if (flag.type && typeof flag.type === "object" && flag.type._def) {
+    const zodSchema = flag.type;
+    try {
+      const property2 = zod.z.toJSONSchema(zodSchema);
+      if (flag.description) {
+        property2.description = flag.description;
+      }
+      const isRequired2 = !!(flag.mandatory || flag.required);
+      return { property: property2, isRequired: isRequired2 };
+    } catch (error) {
+      console.warn(`Failed to convert Zod schema to JSON Schema for flag '${flag.name}':`, error);
+      const property2 = {
+        type: "object",
+        description: flag.description || `${flag.name} parameter (Zod schema)`
+      };
+      const isRequired2 = !!(flag.mandatory || flag.required);
+      return { property: property2, isRequired: isRequired2 };
+    }
+  }
   const property = {
     type: getJsonSchemaTypeFromFlag(flag.type),
     description: flag.description || `${flag.name} parameter`
@@ -5110,8 +5620,11 @@ function extractSimplifiedResponse(mcpResponse) {
   };
 }
 function mapArgParserFlagToZodSchema(flag) {
-  let zodSchema = zod.z.string();
   const flagTypeOpt = flag["type"];
+  if (flagTypeOpt && typeof flagTypeOpt === "object" && flagTypeOpt._def) {
+    return flagTypeOpt;
+  }
+  let zodSchema = zod.z.string();
   let typeName;
   if (typeof flagTypeOpt === "function") {
     typeName = flagTypeOpt.name.toLowerCase().replace("constructor", "");
@@ -24958,6 +25471,7 @@ exports.ArgParserFuzzyTester = ArgParserFuzzyTester;
 exports.ArgParserMcp = ArgParserMcp;
 exports.ConfigPlugin = ConfigPlugin;
 exports.ConfigPluginRegistry = ConfigPluginRegistry;
+exports.DxtPathResolver = DxtPathResolver;
 exports.EnvConfigPlugin = EnvConfigPlugin;
 exports.JsonConfigPlugin = JsonConfigPlugin;
 exports.OutputSchemaPatterns = OutputSchemaPatterns;
@@ -24992,5 +25506,6 @@ exports.isValidMcpToolName = isValidMcpToolName;
 exports.legacyCwdPath = legacyCwdPath;
 exports.resolveLogPath = resolveLogPath;
 exports.sanitizeMcpToolName = sanitizeMcpToolName;
+exports.zodDxtOptionsSchema = zodDxtOptionsSchema;
 exports.zodFlagSchema = zodFlagSchema;
 //# sourceMappingURL=index.cjs.map