@enactprotocol/shared 1.0.12

package/src/utils/help.ts

@@ -0,0 +1,257 @@
+// src/utils/help.ts
+import pc from "picocolors";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+/**
+ * Get the package version from package.json
+ */
+function getVersion(): string {
+	try {
+		const packageJsonPath = join(__dirname, "../../package.json");
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		return packageJson.version || "0.1.0";
+	} catch (error) {
+		// Fallback version if package.json can't be read
+		return "0.1.0";
+	}
+}
+
+/**
+ * Show the main help message
+ */
+export function showHelp(): void {
+	const version = getVersion();
+	console.error(`
+${pc.bold("Enact CLI")} ${pc.dim(`v${version}`)}
+${pc.dim("A CLI tool for managing and publishing Enact tools")}
+
+${pc.bold("Usage:")}
+  ${pc.cyan("enact")} ${pc.green("<command>")} [options]
+
+${pc.bold("Commands:")}
+  ${pc.green("auth")}       Manage authentication (login, logout, status, token)
+  ${pc.green("env")}        Manage environment variables (set, get, list, delete)
+  ${pc.green("exec")}       Execute a tool by fetching and running it
+  ${pc.green("init")}       Create a new tool definition
+  ${pc.green("mcp")}        MCP client integration (install, list, status)
+  ${pc.green("publish")}    Publish a tool to the registry
+  ${pc.green("search")}     Search for tools in the registry
+  ${pc.green("sign")}       Sign and verify tools with cryptographic signatures
+  ${pc.green("remote")}     Manage remote servers (add, list, remove)
+  ${pc.green("user")}       User operations (get public key)
+
+${pc.bold("Global Options:")}
+  ${pc.yellow("--help, -h")}     Show help message
+  ${pc.yellow("--version, -v")}  Show version information
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")}                           ${pc.dim("# Interactive mode")}
+  ${pc.cyan("enact")} ${pc.green("search")} ${pc.yellow("--tags")} web,api         ${pc.dim("# Search tools by tags")}
+  ${pc.cyan("enact")} ${pc.green("exec")} enact/text/slugify      ${pc.dim("# Execute a tool")}
+  ${pc.cyan("enact")} ${pc.green("mcp")} install ${pc.yellow("--client")} claude-desktop ${pc.dim("# Install MCP server")}
+  ${pc.cyan("enact")} ${pc.green("mcp")} install ${pc.yellow("--client")} goose       ${pc.dim("# Install for Goose AI")}
+  ${pc.cyan("enact")} ${pc.green("env")} set API_KEY --encrypt   ${pc.dim("# Set encrypted env var")}
+  ${pc.cyan("enact")} ${pc.green("sign")} verify my-tool.yaml     ${pc.dim("# Verify tool signatures")}
+  ${pc.cyan("enact")} ${pc.green("publish")} my-tool.yaml           ${pc.dim("# Publish a tool")}
+  ${pc.cyan("enact")} ${pc.green("auth")} login                   ${pc.dim("# Login with OAuth")}
+  ${pc.cyan("enact")} ${pc.green("init")} ${pc.yellow("--minimal")}               ${pc.dim("# Create minimal tool template")}
+
+${pc.bold("More Help:")}
+  ${pc.cyan("enact")} ${pc.green("<command>")} ${pc.yellow("--help")}          ${pc.dim("# Show command-specific help")}
+`);
+}
+
+/**
+ * Show version information
+ */
+export function showVersion(): void {
+	const version = getVersion();
+	console.error(`enact-cli v${version}`);
+}
+
+/**
+ * Show help for the auth command
+ */
+export function showAuthHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("<subcommand>")} [options]
+
+${pc.bold("Manage authentication for Enact registry")}
+
+${pc.bold("Subcommands:")}
+  ${pc.blue("login")}       Login using OAuth
+  ${pc.blue("logout")}      Logout and clear stored credentials
+  ${pc.blue("status")}      Check authentication status
+  ${pc.blue("token")}       Display current authentication token
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+  ${pc.yellow("--server, -s")}   Specify server URL
+  ${pc.yellow("--port, -p")}     Specify port for OAuth callback
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("login")}
+  ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("status")}
+  ${pc.cyan("enact")} ${pc.green("auth")} ${pc.blue("login")} ${pc.yellow("--server")} https://api.example.com
+`);
+}
+
+/**
+ * Show help for the init command
+ */
+export function showInitHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("init")} [options] [name]
+
+${pc.bold("Create a new tool definition file")}
+
+${pc.bold("Arguments:")}
+  ${pc.blue("name")}         Name for the new tool (optional)
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+  ${pc.yellow("--minimal, -m")}  Create a minimal tool template
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("init")}
+  ${pc.cyan("enact")} ${pc.green("init")} my-awesome-tool
+  ${pc.cyan("enact")} ${pc.green("init")} ${pc.yellow("--minimal")} simple-tool
+`);
+}
+
+/**
+ * Show help for the publish command
+ */
+export function showPublishHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("publish")} [options] [file]
+
+${pc.bold("Publish a tool to the Enact registry")}
+
+${pc.bold("Arguments:")}
+  ${pc.blue("file")}         The tool definition file to publish (YAML format)
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+  ${pc.yellow("--url")}          Specify the registry URL
+  ${pc.yellow("--token, -t")}    Specify authentication token
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("publish")} my-tool.yaml
+  ${pc.cyan("enact")} ${pc.green("publish")} ${pc.yellow("--url")} https://registry.example.com my-tool.yaml
+  ${pc.cyan("enact")} ${pc.green("publish")} ${pc.yellow("--token")} abc123 my-tool.yaml
+`);
+}
+
+/**
+ * Show help for the search command
+ */
+export function showSearchHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("search")} [options] [query]
+
+${pc.bold("Search for tools in the Enact registry")}
+
+${pc.bold("Arguments:")}
+  ${pc.blue("query")}        Search query (optional)
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+  ${pc.yellow("--limit, -l")}    Limit number of results (default: 20)
+  ${pc.yellow("--tags")}         Filter by tags (comma-separated)
+  ${pc.yellow("--author, -a")}   Filter by author
+  ${pc.yellow("--format, -f")}   Output format (table, json, minimal)
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("search")}
+  ${pc.cyan("enact")} ${pc.green("search")} "web scraper"
+  ${pc.cyan("enact")} ${pc.green("search")} ${pc.yellow("--tags")} web,api ${pc.yellow("--limit")} 10
+  ${pc.cyan("enact")} ${pc.green("search")} ${pc.yellow("--author")} johndoe ${pc.yellow("--format")} json
+`);
+}
+
+/**
+ * Show help for the remote command
+ */
+export function showRemoteHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("<subcommand>")} [options]
+
+${pc.bold("Manage remote Enact registry servers")}
+
+${pc.bold("Subcommands:")}
+  ${pc.blue("add")}         Add a new remote server
+  ${pc.blue("list")}        List all configured remote servers
+  ${pc.blue("remove")}      Remove a remote server
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("add")}
+  ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("list")}
+  ${pc.cyan("enact")} ${pc.green("remote")} ${pc.blue("remove")} origin
+`);
+}
+
+/**
+ * Show help for the user command
+ */
+export function showUserHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("<subcommand>")} [options]
+
+${pc.bold("User operations for Enact registry")}
+
+${pc.bold("Subcommands:")}
+  ${pc.blue("public-key")}  Get user's public key
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+  ${pc.yellow("--server, -s")}   Specify server URL
+  ${pc.yellow("--token, -t")}    Specify authentication token
+  ${pc.yellow("--format, -f")}   Output format (default, json)
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("public-key")}
+  ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("public-key")} ${pc.yellow("--format")} json
+  ${pc.cyan("enact")} ${pc.green("user")} ${pc.blue("public-key")} ${pc.yellow("--server")} https://api.example.com
+`);
+}
+
+/**
+ * Show help for the env command
+ */
+export function showEnvHelp(): void {
+	console.error(`
+${pc.bold("Usage:")} ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("<subcommand>")} [options]
+
+${pc.bold("Environment variable management for Enact CLI")}
+
+${pc.bold("Subcommands:")}
+  ${pc.blue("set")} ${pc.magenta("<name>")} [value]      Set an environment variable
+  ${pc.blue("get")} ${pc.magenta("<name>")}              Get an environment variable
+  ${pc.blue("list")}                    List all environment variables
+  ${pc.blue("delete")} ${pc.magenta("<name>")}           Delete an environment variable
+  ${pc.blue("copy")} ${pc.magenta("<from>")} ${pc.magenta("<to>")}        Copy variables between scopes
+  ${pc.blue("export")} [format]         Export variables (env|json|yaml)
+  ${pc.blue("clear")}                   Clear all environment variables
+
+${pc.bold("Options:")}
+  ${pc.yellow("--help, -h")}     Show this help message
+  ${pc.yellow("--global")}       Use global scope (default)
+  ${pc.yellow("--project")}      Use project scope
+  ${pc.yellow("--encrypt")}      Encrypt sensitive values
+  ${pc.yellow("--format")}       Output format (table|json)
+  ${pc.yellow("--show")}         Show actual values (default: hidden)
+
+${pc.bold("Examples:")}
+  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("set")} OPENAI_API_KEY ${pc.yellow("--encrypt")}
+  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("set")} DATABASE_URL postgres://... ${pc.yellow("--project")}
+  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("get")} OPENAI_API_KEY ${pc.yellow("--show")}
+  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("list")} ${pc.yellow("--project")} ${pc.yellow("--format")} json
+  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("copy")} global project
+  ${pc.cyan("enact")} ${pc.green("env")} ${pc.blue("export")} env > .env
+`);
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './env-loader';
+export { showHelp } from './help';
+export * from './logger';
+export * from './silent-monitor';
+export * from './timeout';
+export { showVersion } from './version';

package/src/utils/logger.ts

@@ -0,0 +1,83 @@
+// src/utils/logger.ts
+import pc from "picocolors";
+
+export enum LogLevel {
+	DEBUG = 0,
+	INFO = 1,
+	SUCCESS = 2,
+	WARN = 3,
+	ERROR = 4,
+}
+
+// Default log level
+let currentLogLevel = LogLevel.INFO;
+
+/**
+ * Sets the current log level
+ */
+export function setLogLevel(level: LogLevel): void {
+	currentLogLevel = level;
+}
+
+/**
+ * Debug log - only shown when log level is DEBUG
+ */
+export function debug(message: string): void {
+	if (currentLogLevel <= LogLevel.DEBUG) {
+		console.error(pc.dim(`🔍 ${message}`));
+	}
+}
+
+/**
+ * Info log - general information
+ */
+export function info(message: string): void {
+	if (currentLogLevel <= LogLevel.INFO) {
+		console.error(pc.blue(`ℹ️ ${message}`));
+	}
+}
+
+/**
+ * Success log - operation completed successfully
+ */
+export function success(message: string): void {
+	if (currentLogLevel <= LogLevel.SUCCESS) {
+		console.error(pc.green(`✓ ${message}`));
+	}
+}
+
+/**
+ * Warning log - non-critical issues
+ */
+export function warn(message: string): void {
+	if (currentLogLevel <= LogLevel.WARN) {
+		console.error(pc.yellow(`⚠️ ${message}`));
+	}
+}
+
+/**
+ * Error log - critical issues
+ */
+export function error(message: string, details?: any): void {
+	if (currentLogLevel <= LogLevel.ERROR) {
+		console.error(pc.red(`✗ Error: ${message}`));
+
+		if (details && currentLogLevel === LogLevel.DEBUG) {
+			console.error(pc.dim("Details:"));
+			console.error(details);
+		}
+	}
+}
+
+/**
+ * Table log - display tabular data
+ */
+export function table(data: any[], columns?: string[]): void {
+	if (currentLogLevel <= LogLevel.INFO) {
+		if (columns) {
+			console.table(data, columns);
+		} else {
+			console.table(data);
+		}
+	}
+}

package/src/utils/silent-monitor.ts

@@ -0,0 +1,328 @@
+/**
+ * Runtime silent operation monitor for MCP server
+ * This utility can be used to ensure the MCP server remains silent during operation
+ */
+
+interface SilentOperationMonitor {
+	startMonitoring(): void;
+	stopMonitoring(): SilentOperationReport;
+	isCurrentlyMonitoring(): boolean;
+	getViolations(): string[];
+}
+
+interface SilentOperationReport {
+	violations: string[];
+	consoleOutputDetected: string[];
+	processExitAttempts: number;
+	readlineUsageDetected: boolean;
+	duration: number;
+	timestamp: string;
+}
+
+class McpSilentOperationMonitor implements SilentOperationMonitor {
+	private isMonitoring = false;
+	private violations: string[] = [];
+	private consoleOutput: string[] = [];
+	private processExitAttempts = 0;
+	private readlineUsageDetected = false;
+	private startTime = 0;
+
+	private originalConsoleLog: typeof console.log;
+	private originalConsoleError: typeof console.error;
+	private originalConsoleWarn: typeof console.warn;
+	private originalConsoleInfo: typeof console.info;
+	private originalProcessExit: typeof process.exit;
+	private originalStdoutWrite: typeof process.stdout.write;
+	private originalStderrWrite: typeof process.stderr.write;
+
+	// Public getters for original methods
+	public getOriginalConsoleError(): typeof console.error {
+		return this.originalConsoleError;
+	}
+
+	constructor() {
+		// Store original methods
+		this.originalConsoleLog = console.log;
+		this.originalConsoleError = console.error;
+		this.originalConsoleWarn = console.warn;
+		this.originalConsoleInfo = console.info;
+		this.originalProcessExit = process.exit;
+		this.originalStdoutWrite = process.stdout.write;
+		this.originalStderrWrite = process.stderr.write;
+	}
+
+	startMonitoring(): void {
+		if (this.isMonitoring) {
+			return;
+		}
+
+		this.isMonitoring = true;
+		this.violations = [];
+		this.consoleOutput = [];
+		this.processExitAttempts = 0;
+		this.readlineUsageDetected = false;
+		this.startTime = Date.now();
+
+		// Hook console methods
+		console.log = (...args: any[]) => {
+			const message = args.join(" ");
+			this.consoleOutput.push(`[LOG] ${message}`);
+			this.violations.push(`Console.log called: ${message}`);
+		};
+
+		console.error = (...args: any[]) => {
+			const message = args.join(" ");
+			this.consoleOutput.push(`[ERROR] ${message}`);
+			this.violations.push(`Console.error called: ${message}`);
+		};
+
+		console.warn = (...args: any[]) => {
+			const message = args.join(" ");
+			this.consoleOutput.push(`[WARN] ${message}`);
+			this.violations.push(`Console.warn called: ${message}`);
+		};
+
+		console.info = (...args: any[]) => {
+			const message = args.join(" ");
+			this.consoleOutput.push(`[INFO] ${message}`);
+			this.violations.push(`Console.info called: ${message}`);
+		};
+
+		// Hook process.exit
+		process.exit = ((code?: number) => {
+			this.processExitAttempts++;
+			this.violations.push(`Process.exit called with code: ${code}`);
+			throw new Error(`Process exit intercepted: ${code}`);
+		}) as any;
+
+		// Hook stdout/stderr
+		process.stdout.write = ((chunk: any, ...args: any[]) => {
+			if (typeof chunk === "string" && chunk.trim()) {
+				this.consoleOutput.push(`[STDOUT] ${chunk}`);
+				this.violations.push(
+					`Process.stdout.write called: ${chunk.substring(0, 100)}...`,
+				);
+			}
+			return true;
+		}) as any;
+
+		process.stderr.write = ((chunk: any, ...args: any[]) => {
+			if (typeof chunk === "string" && chunk.trim()) {
+				this.consoleOutput.push(`[STDERR] ${chunk}`);
+				this.violations.push(
+					`Process.stderr.write called: ${chunk.substring(0, 100)}...`,
+				);
+			}
+			return true;
+		}) as any;
+
+		// Hook readline (if it gets required)
+		const originalRequire = require;
+		const monitor = this;
+		(global as any).require = function (id: string) {
+			if (id === "readline" || id.includes("readline")) {
+				monitor.readlineUsageDetected = true;
+				monitor.violations.push("Readline module usage detected");
+			}
+			return originalRequire.apply(this, arguments as any);
+		};
+	}
+
+	stopMonitoring(): SilentOperationReport {
+		if (!this.isMonitoring) {
+			throw new Error("Monitor is not currently running");
+		}
+
+		// Restore original methods
+		console.log = this.originalConsoleLog;
+		console.error = this.originalConsoleError;
+		console.warn = this.originalConsoleWarn;
+		console.info = this.originalConsoleInfo;
+		process.exit = this.originalProcessExit;
+		process.stdout.write = this.originalStdoutWrite;
+		process.stderr.write = this.originalStderrWrite;
+
+		// Restore require
+		(global as any).require = require;
+
+		this.isMonitoring = false;
+
+		return {
+			violations: [...this.violations],
+			consoleOutputDetected: [...this.consoleOutput],
+			processExitAttempts: this.processExitAttempts,
+			readlineUsageDetected: this.readlineUsageDetected,
+			duration: Date.now() - this.startTime,
+			timestamp: new Date().toISOString(),
+		};
+	}
+
+	isCurrentlyMonitoring(): boolean {
+		return this.isMonitoring;
+	}
+
+	getViolations(): string[] {
+		return [...this.violations];
+	}
+}
+
+/**
+ * Global monitor instance
+ */
+const globalMonitor = new McpSilentOperationMonitor();
+
+/**
+ * Decorator to ensure a function operates silently
+ */
+export function ensureSilent<T extends (...args: any[]) => any>(fn: T): T {
+	return ((...args: any[]) => {
+		const wasMonitoring = globalMonitor.isCurrentlyMonitoring();
+
+		if (!wasMonitoring) {
+			globalMonitor.startMonitoring();
+		}
+
+		try {
+			const result = fn(...args);
+
+			// Handle both sync and async functions
+			if (result && typeof result.then === "function") {
+				return result.finally(() => {
+					if (!wasMonitoring) {
+						const report = globalMonitor.stopMonitoring();
+						if (report.violations.length > 0) {
+							throw new Error(
+								`Silent operation violated: ${report.violations.join(", ")}`,
+							);
+						}
+					}
+				});
+			} else {
+				if (!wasMonitoring) {
+					const report = globalMonitor.stopMonitoring();
+					if (report.violations.length > 0) {
+						throw new Error(
+							`Silent operation violated: ${report.violations.join(", ")}`,
+						);
+					}
+				}
+				return result;
+			}
+		} catch (error) {
+			if (!wasMonitoring && globalMonitor.isCurrentlyMonitoring()) {
+				globalMonitor.stopMonitoring();
+			}
+			throw error;
+		}
+	}) as T;
+}
+
+/**
+ * Higher-order function to wrap MCP tool handlers for silent operation
+ */
+export function silentMcpTool<T extends (...args: any[]) => Promise<any>>(
+	handler: T,
+): T {
+	return (async (...args: any[]) => {
+		const monitor = new McpSilentOperationMonitor();
+		monitor.startMonitoring();
+
+		try {
+			const result = await handler(...args);
+			const report = monitor.stopMonitoring();
+
+			if (report.violations.length > 0) {
+				// Log violations using the original console methods for debugging
+				globalMonitor.getOriginalConsoleError()(
+					"🚨 MCP Tool Handler Violations:",
+					report.violations,
+				);
+
+				// In production, you might want to return an error response instead of throwing
+				if (process.env.NODE_ENV === "production") {
+					return {
+						content: [
+							{
+								type: "text",
+								text: "Internal error: Silent operation requirements violated",
+							},
+						],
+						isError: true,
+					};
+				}
+			}
+
+			return result;
+		} catch (error) {
+			const report = monitor.stopMonitoring();
+
+			if (report.violations.length > 0) {
+				globalMonitor.getOriginalConsoleError()(
+					"🚨 MCP Tool Handler Violations during error:",
+					report.violations,
+				);
+			}
+
+			throw error;
+		}
+	}) as T;
+}
+
+/**
+ * Utility to check if environment is properly configured for silent operation
+ */
+export function validateSilentEnvironment(): {
+	valid: boolean;
+	issues: string[];
+} {
+	const issues: string[] = [];
+
+	// Check environment variables
+	if (process.env.CI !== "true") {
+		issues.push('CI environment variable not set to "true"');
+	}
+
+	if (process.env.ENACT_SKIP_INTERACTIVE !== "true") {
+		issues.push('ENACT_SKIP_INTERACTIVE not set to "true"');
+	}
+
+	if (process.env.DEBUG === "true" || process.env.VERBOSE === "true") {
+		issues.push("DEBUG or VERBOSE environment variables are enabled");
+	}
+
+	// Check if we're in a TTY (which might indicate interactive mode)
+	if (process.stdin.isTTY) {
+		issues.push("Process is running in TTY mode (potentially interactive)");
+	}
+
+	return {
+		valid: issues.length === 0,
+		issues,
+	};
+}
+
+/**
+ * Logger specifically for MCP silent operation monitoring
+ */
+export const silentLogger = {
+	logViolation: (violation: string) => {
+		// Use stderr directly to bypass any console mocking
+		process.stderr.write(
+			`[SILENT-VIOLATION] ${new Date().toISOString()}: ${violation}\n`,
+		);
+	},
+
+	logReport: (report: SilentOperationReport) => {
+		if (report.violations.length > 0) {
+			process.stderr.write(
+				`[SILENT-REPORT] ${report.timestamp}: ${report.violations.length} violations in ${report.duration}ms\n`,
+			);
+			report.violations.forEach((violation) => {
+				process.stderr.write(`  - ${violation}\n`);
+			});
+		}
+	},
+};
+
+export { globalMonitor, McpSilentOperationMonitor };
+export type { SilentOperationMonitor, SilentOperationReport };

package/src/utils/timeout.ts

@@ -0,0 +1,26 @@
+// src/utils/timeout.ts - Shared timeout parsing utility
+
+/**
+ * Parse timeout string to milliseconds
+ * Supports formats like "30s", "5m", "2h"
+ */
+export function parseTimeout(timeout: string): number {
+	const match = timeout.match(/^(\d+)([smh])$/);
+	if (!match) {
+		return 30000; // Default 30 seconds
+	}
+
+	const value = parseInt(match[1]);
+	const unit = match[2];
+
+	switch (unit) {
+		case "s":
+			return value * 1000;
+		case "m":
+			return value * 60 * 1000;
+		case "h":
+			return value * 60 * 60 * 1000;
+		default:
+			return 30000; // Default fallback
+	}
+}