@enactprotocol/shared 1.0.12

package/dist/utils/logger.js

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

package/dist/utils/silent-monitor.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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;
+}
+declare class McpSilentOperationMonitor implements SilentOperationMonitor {
+    private isMonitoring;
+    private violations;
+    private consoleOutput;
+    private processExitAttempts;
+    private readlineUsageDetected;
+    private startTime;
+    private originalConsoleLog;
+    private originalConsoleError;
+    private originalConsoleWarn;
+    private originalConsoleInfo;
+    private originalProcessExit;
+    private originalStdoutWrite;
+    private originalStderrWrite;
+    getOriginalConsoleError(): typeof console.error;
+    constructor();
+    startMonitoring(): void;
+    stopMonitoring(): SilentOperationReport;
+    isCurrentlyMonitoring(): boolean;
+    getViolations(): string[];
+}
+/**
+ * Global monitor instance
+ */
+declare const globalMonitor: McpSilentOperationMonitor;
+/**
+ * Decorator to ensure a function operates silently
+ */
+export declare function ensureSilent<T extends (...args: any[]) => any>(fn: T): T;
+/**
+ * Higher-order function to wrap MCP tool handlers for silent operation
+ */
+export declare function silentMcpTool<T extends (...args: any[]) => Promise<any>>(handler: T): T;
+/**
+ * Utility to check if environment is properly configured for silent operation
+ */
+export declare function validateSilentEnvironment(): {
+    valid: boolean;
+    issues: string[];
+};
+/**
+ * Logger specifically for MCP silent operation monitoring
+ */
+export declare const silentLogger: {
+    logViolation: (violation: string) => void;
+    logReport: (report: SilentOperationReport) => void;
+};
+export { globalMonitor, McpSilentOperationMonitor };
+export type { SilentOperationMonitor, SilentOperationReport };

package/dist/utils/silent-monitor.js

@@ -0,0 +1,242 @@
+/**
+ * Runtime silent operation monitor for MCP server
+ * This utility can be used to ensure the MCP server remains silent during operation
+ */
+class McpSilentOperationMonitor {
+    // Public getters for original methods
+    getOriginalConsoleError() {
+        return this.originalConsoleError;
+    }
+    constructor() {
+        this.isMonitoring = false;
+        this.violations = [];
+        this.consoleOutput = [];
+        this.processExitAttempts = 0;
+        this.readlineUsageDetected = false;
+        this.startTime = 0;
+        // 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() {
+        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) => {
+            const message = args.join(" ");
+            this.consoleOutput.push(`[LOG] ${message}`);
+            this.violations.push(`Console.log called: ${message}`);
+        };
+        console.error = (...args) => {
+            const message = args.join(" ");
+            this.consoleOutput.push(`[ERROR] ${message}`);
+            this.violations.push(`Console.error called: ${message}`);
+        };
+        console.warn = (...args) => {
+            const message = args.join(" ");
+            this.consoleOutput.push(`[WARN] ${message}`);
+            this.violations.push(`Console.warn called: ${message}`);
+        };
+        console.info = (...args) => {
+            const message = args.join(" ");
+            this.consoleOutput.push(`[INFO] ${message}`);
+            this.violations.push(`Console.info called: ${message}`);
+        };
+        // Hook process.exit
+        process.exit = ((code) => {
+            this.processExitAttempts++;
+            this.violations.push(`Process.exit called with code: ${code}`);
+            throw new Error(`Process exit intercepted: ${code}`);
+        });
+        // Hook stdout/stderr
+        process.stdout.write = ((chunk, ...args) => {
+            if (typeof chunk === "string" && chunk.trim()) {
+                this.consoleOutput.push(`[STDOUT] ${chunk}`);
+                this.violations.push(`Process.stdout.write called: ${chunk.substring(0, 100)}...`);
+            }
+            return true;
+        });
+        process.stderr.write = ((chunk, ...args) => {
+            if (typeof chunk === "string" && chunk.trim()) {
+                this.consoleOutput.push(`[STDERR] ${chunk}`);
+                this.violations.push(`Process.stderr.write called: ${chunk.substring(0, 100)}...`);
+            }
+            return true;
+        });
+        // Hook readline (if it gets required)
+        const originalRequire = require;
+        const monitor = this;
+        global.require = function (id) {
+            if (id === "readline" || id.includes("readline")) {
+                monitor.readlineUsageDetected = true;
+                monitor.violations.push("Readline module usage detected");
+            }
+            return originalRequire.apply(this, arguments);
+        };
+    }
+    stopMonitoring() {
+        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.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() {
+        return this.isMonitoring;
+    }
+    getViolations() {
+        return [...this.violations];
+    }
+}
+/**
+ * Global monitor instance
+ */
+const globalMonitor = new McpSilentOperationMonitor();
+/**
+ * Decorator to ensure a function operates silently
+ */
+export function ensureSilent(fn) {
+    return ((...args) => {
+        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;
+        }
+    });
+}
+/**
+ * Higher-order function to wrap MCP tool handlers for silent operation
+ */
+export function silentMcpTool(handler) {
+    return (async (...args) => {
+        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;
+        }
+    });
+}
+/**
+ * Utility to check if environment is properly configured for silent operation
+ */
+export function validateSilentEnvironment() {
+    const issues = [];
+    // 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) => {
+        // Use stderr directly to bypass any console mocking
+        process.stderr.write(`[SILENT-VIOLATION] ${new Date().toISOString()}: ${violation}\n`);
+    },
+    logReport: (report) => {
+        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 };

package/dist/utils/timeout.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parse timeout string to milliseconds
+ * Supports formats like "30s", "5m", "2h"
+ */
+export declare function parseTimeout(timeout: string): number;

package/dist/utils/timeout.js

@@ -0,0 +1,23 @@
+// src/utils/timeout.ts - Shared timeout parsing utility
+/**
+ * Parse timeout string to milliseconds
+ * Supports formats like "30s", "5m", "2h"
+ */
+export function parseTimeout(timeout) {
+    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
+    }
+}

package/dist/utils/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Displays the CLI version with nice formatting
+ */
+export declare function showVersion(): void;

package/dist/utils/version.js

@@ -0,0 +1,14 @@
+// src/utils/version.ts
+import pc from "picocolors";
+/**
+ * Displays the CLI version with nice formatting
+ */
+export function showVersion() {
+    // Bun automatically sets npm_package_version when running scripts via package.json
+    const version = process.env.npm_package_version || "0.0.1-dev";
+    const versionText = `v${version}`;
+    console.error(`
+${pc.bold("Enact CLI")} ${pc.cyan(versionText)}
+${pc.dim("A tool to create and publish enact documents.")}
+`);
+}

package/dist/web/env-manager-server.d.ts

@@ -0,0 +1,29 @@
+interface PackageEnvInfo {
+    namespace: string;
+    path: string;
+    variables: Record<string, string>;
+}
+/**
+ * Get all package namespaces with environment variables
+ */
+declare function getAllPackageNamespaces(): Promise<PackageEnvInfo[]>;
+/**
+ * Get environment variables for a specific package namespace
+ */
+declare function getPackageEnvVars(namespace: string): Promise<Record<string, string>>;
+/**
+ * Set environment variable for a package namespace
+ */
+declare function setPackageEnvVar(namespace: string, key: string, value: string): Promise<void>;
+/**
+ * Delete environment variable for a package namespace
+ */
+declare function deletePackageEnvVar(namespace: string, key: string): Promise<void>;
+/**
+ * Start the web server
+ */
+export declare function startEnvManagerServer(port?: number): Promise<{
+    server: any;
+    port: number;
+}>;
+export { getAllPackageNamespaces, getPackageEnvVars, setPackageEnvVar, deletePackageEnvVar, };