@enactprotocol/shared 1.2.13 → 2.0.0

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

@@ -1,67 +0,0 @@
-/**
- * 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

@@ -1,242 +0,0 @@
-/**
- * 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

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

package/dist/utils/timeout.js

@@ -1,23 +0,0 @@
-// 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

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

package/dist/utils/version.js

@@ -1,35 +0,0 @@
-// src/utils/version.ts
-import pc from "picocolors";
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-/**
- * Displays the CLI version with nice formatting
- */
-export function showVersion() {
-    let version = "0.0.1-dev";
-    try {
-        // Try to get version from environment first (for npm scripts)
-        if (process.env.npm_package_version) {
-            version = process.env.npm_package_version;
-        }
-        else {
-            // When running as installed binary, read from package.json
-            // Go up from shared/dist/utils/version.js to find package.json
-            const currentFile = typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url);
-            const sharedDir = dirname(dirname(dirname(currentFile)));
-            const packageJsonPath = join(sharedDir, 'package.json');
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-            version = packageJson.version;
-        }
-    }
-    catch (error) {
-        // Fall back to default version if anything fails
-        version = "1.0.14";
-    }
-    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

@@ -1,29 +0,0 @@
-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, };