@enactprotocol/shared 1.2.13 → 2.0.1

package/dist/utils/config.js

@@ -1,342 +0,0 @@
-// src/utils/config.ts
-import { homedir } from "os";
-import { join } from "path";
-import { existsSync } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
-// Define config paths
-const CONFIG_DIR = join(homedir(), ".enact");
-const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-const TRUSTED_KEYS_DIR = join(CONFIG_DIR, "trusted-keys");
-/**
- * Ensure config directory and file exist
- */
-export async function ensureConfig() {
-    if (!existsSync(CONFIG_DIR)) {
-        await mkdir(CONFIG_DIR, { recursive: true });
-    }
-    if (!existsSync(CONFIG_FILE)) {
-        const defaultConfig = {
-            history: [],
-            urls: {
-                frontend: DEFAULT_FRONTEND_URL,
-                api: DEFAULT_API_URL,
-            },
-        };
-        await writeFile(CONFIG_FILE, JSON.stringify(defaultConfig, null, 2));
-    }
-}
-/**
- * Read the config file
- */
-export async function readConfig() {
-    await ensureConfig();
-    try {
-        const data = await readFile(CONFIG_FILE, "utf8");
-        const config = JSON.parse(data);
-        // Migrate old configs that don't have URLs section
-        if (!config.urls) {
-            config.urls = {
-                frontend: DEFAULT_FRONTEND_URL,
-                api: DEFAULT_API_URL,
-            };
-            await writeConfig(config);
-        }
-        return config;
-    }
-    catch (error) {
-        console.error("Failed to read config:", error.message);
-        return {
-            history: [],
-            urls: {
-                frontend: DEFAULT_FRONTEND_URL,
-                api: DEFAULT_API_URL,
-            },
-        };
-    }
-}
-/**
- * Write to the config file
- */
-export async function writeConfig(config) {
-    await ensureConfig();
-    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-/**
- * Add a file to the publish history
- */
-export async function addToHistory(filePath) {
-    const config = await readConfig();
-    if (!config.history) {
-        config.history = [];
-    }
-    // Add to history if not already there
-    if (!config.history.includes(filePath)) {
-        config.history.unshift(filePath);
-        // Keep history to a reasonable size
-        config.history = config.history.slice(0, 10);
-        await writeConfig(config);
-    }
-}
-/**
- * Get the publish history
- */
-export async function getHistory() {
-    const config = await readConfig();
-    return config.history || [];
-}
-/**
- * Set the default publish URL
- */
-export async function setDefaultUrl(url) {
-    const config = await readConfig();
-    config.defaultUrl = url;
-    await writeConfig(config);
-}
-/**
- * Get the default publish URL
- */
-export async function getDefaultUrl() {
-    const config = await readConfig();
-    return config.defaultUrl;
-}
-// Default URLs
-const DEFAULT_FRONTEND_URL = "https://enact.tools";
-const DEFAULT_API_URL = "https://xjnhhxwxovjifdxdwzih.supabase.co";
-// Default trusted public key (Enact Protocol official key)
-const DEFAULT_ENACT_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8VyE3jGm5yT2mKnPx1dQF7q8Z2Kv
-7mX9YnE2mK8vF3tY9pL6xH2dF8sK3mN7wQ5vT2gR8sL4xN6pM9uE3wF2Qw==
------END PUBLIC KEY-----`;
-/**
- * Get the frontend URL with fallbacks
- */
-export async function getFrontendUrl() {
-    // 1. Environment variable override
-    if (process.env.ENACT_FRONTEND_URL) {
-        return process.env.ENACT_FRONTEND_URL;
-    }
-    // 2. Config file setting
-    const config = await readConfig();
-    if (config.urls?.frontend) {
-        return config.urls.frontend;
-    }
-    // 3. Default
-    return DEFAULT_FRONTEND_URL;
-}
-/**
- * Get the API URL with fallbacks
- */
-export async function getApiUrl() {
-    // 1. Environment variable override
-    if (process.env.ENACT_API_URL) {
-        return process.env.ENACT_API_URL;
-    }
-    // 2. Config file setting
-    const config = await readConfig();
-    if (config.urls?.api) {
-        return config.urls.api;
-    }
-    // 3. Default
-    return DEFAULT_API_URL;
-}
-/**
- * Set the frontend URL in config
- */
-export async function setFrontendUrl(url) {
-    const config = await readConfig();
-    if (!config.urls) {
-        config.urls = {};
-    }
-    config.urls.frontend = url;
-    await writeConfig(config);
-}
-/**
- * Set the API URL in config
- */
-export async function setApiUrl(url) {
-    const config = await readConfig();
-    if (!config.urls) {
-        config.urls = {};
-    }
-    config.urls.api = url;
-    await writeConfig(config);
-}
-/**
- * Reset URLs to defaults
- */
-export async function resetUrls() {
-    const config = await readConfig();
-    if (config.urls) {
-        delete config.urls.frontend;
-        delete config.urls.api;
-    }
-    await writeConfig(config);
-}
-/**
- * Get current URL configuration
- */
-export async function getUrlConfig() {
-    const config = await readConfig();
-    // Determine frontend URL source
-    let frontendValue = DEFAULT_FRONTEND_URL;
-    let frontendSource = "default";
-    if (config.urls?.frontend) {
-        frontendValue = config.urls.frontend;
-        frontendSource = "config";
-    }
-    if (process.env.ENACT_FRONTEND_URL) {
-        frontendValue = process.env.ENACT_FRONTEND_URL;
-        frontendSource = "environment";
-    }
-    // Determine API URL source
-    let apiValue = DEFAULT_API_URL;
-    let apiSource = "default";
-    if (config.urls?.api) {
-        apiValue = config.urls.api;
-        apiSource = "config";
-    }
-    if (process.env.ENACT_API_URL) {
-        apiValue = process.env.ENACT_API_URL;
-        apiSource = "environment";
-    }
-    return {
-        frontend: { value: frontendValue, source: frontendSource },
-        api: { value: apiValue, source: apiSource },
-    };
-}
-/**
- * Ensure trusted keys directory exists with default key
- */
-async function ensureTrustedKeysDir() {
-    if (!existsSync(CONFIG_DIR)) {
-        await mkdir(CONFIG_DIR, { recursive: true });
-    }
-    if (!existsSync(TRUSTED_KEYS_DIR)) {
-        await mkdir(TRUSTED_KEYS_DIR, { recursive: true });
-    }
-    // Create default Enact Protocol key if it doesn't exist
-    const defaultKeyFile = join(TRUSTED_KEYS_DIR, "enact-protocol-official.pem");
-    const defaultMetaFile = join(TRUSTED_KEYS_DIR, "enact-protocol-official.meta");
-    if (!existsSync(defaultKeyFile)) {
-        await writeFile(defaultKeyFile, DEFAULT_ENACT_PUBLIC_KEY);
-    }
-    if (!existsSync(defaultMetaFile)) {
-        const defaultMeta = {
-            name: "Enact Protocol Official",
-            description: "Official Enact Protocol signing key for verified tools",
-            addedAt: new Date().toISOString(),
-            source: "default",
-            keyFile: "enact-protocol-official.pem"
-        };
-        await writeFile(defaultMetaFile, JSON.stringify(defaultMeta, null, 2));
-    }
-}
-/**
- * Read all trusted keys from directory
- */
-export async function getTrustedKeys() {
-    await ensureTrustedKeysDir();
-    const keys = [];
-    try {
-        const { readdir } = await import('fs/promises');
-        const files = await readdir(TRUSTED_KEYS_DIR);
-        // Get all .pem files
-        const pemFiles = files.filter(f => f.endsWith('.pem'));
-        for (const pemFile of pemFiles) {
-            try {
-                const keyId = pemFile.replace('.pem', '');
-                const keyPath = join(TRUSTED_KEYS_DIR, pemFile);
-                const metaPath = join(TRUSTED_KEYS_DIR, `${keyId}.meta`);
-                // Read the public key
-                const publicKey = await readFile(keyPath, 'utf8');
-                // Read metadata if it exists
-                let meta = {
-                    name: keyId,
-                    addedAt: new Date().toISOString(),
-                    source: "user",
-                    keyFile: pemFile
-                };
-                if (existsSync(metaPath)) {
-                    try {
-                        const metaData = await readFile(metaPath, 'utf8');
-                        meta = { ...meta, ...JSON.parse(metaData) };
-                    }
-                    catch {
-                        // Use defaults if meta file is corrupted
-                    }
-                }
-                keys.push({
-                    id: keyId,
-                    name: meta.name,
-                    publicKey: publicKey.trim(),
-                    description: meta.description,
-                    addedAt: meta.addedAt,
-                    source: meta.source,
-                    keyFile: pemFile
-                });
-            }
-            catch (error) {
-                console.warn(`Warning: Could not read key file ${pemFile}:`, error);
-            }
-        }
-    }
-    catch (error) {
-        console.error("Failed to read trusted keys directory:", error);
-    }
-    return keys;
-}
-/**
- * Add a trusted key
- */
-export async function addTrustedKey(keyData) {
-    await ensureTrustedKeysDir();
-    const keyFile = `${keyData.id}.pem`;
-    const metaFile = `${keyData.id}.meta`;
-    const keyPath = join(TRUSTED_KEYS_DIR, keyFile);
-    const metaPath = join(TRUSTED_KEYS_DIR, metaFile);
-    // Check if key already exists
-    if (existsSync(keyPath)) {
-        throw new Error(`Key with ID '${keyData.id}' already exists`);
-    }
-    // Write the public key file
-    await writeFile(keyPath, keyData.publicKey);
-    // Write the metadata file
-    const meta = {
-        name: keyData.name,
-        description: keyData.description,
-        addedAt: new Date().toISOString(),
-        source: keyData.source || "user",
-        keyFile
-    };
-    await writeFile(metaPath, JSON.stringify(meta, null, 2));
-}
-/**
- * Remove a trusted key
- */
-export async function removeTrustedKey(keyId) {
-    const keyPath = join(TRUSTED_KEYS_DIR, `${keyId}.pem`);
-    const metaPath = join(TRUSTED_KEYS_DIR, `${keyId}.meta`);
-    if (!existsSync(keyPath)) {
-        throw new Error(`Trusted key '${keyId}' not found`);
-    }
-    // Remove both files
-    const { unlink } = await import('fs/promises');
-    await unlink(keyPath);
-    if (existsSync(metaPath)) {
-        await unlink(metaPath);
-    }
-}
-/**
- * Get a specific trusted key
- */
-export async function getTrustedKey(keyId) {
-    const keys = await getTrustedKeys();
-    return keys.find(k => k.id === keyId) || null;
-}
-/**
- * Check if a public key is trusted
- */
-export async function isKeyTrusted(publicKey) {
-    const keys = await getTrustedKeys();
-    return keys.some(k => k.publicKey.trim() === publicKey.trim());
-}

package/dist/utils/env-loader.d.ts

@@ -1,54 +0,0 @@
-/**
- * Extract package namespace from tool name (excluding tool name)
- * e.g., "kgroves88/dagger/social/bluesky-poster" -> "kgroves88/dagger/social"
- */
-declare function extractPackageNamespace(toolName: string): string;
-/**
- * Load environment variables from Enact configuration for a specific package namespace
- */
-export declare function loadPackageEnvironmentVariables(packageNamespace: string): Promise<Record<string, string>>;
-/**
- * Resolve environment variables for a tool definition with package namespace support
- * Combines system environment, Enact package configuration, and tool-specific requirements
- * Following the Enact protocol format:
- * env:
- *   VARIABLE_NAME:
- *     description: string
- *     source: string
- *     required: boolean
- *     default: string (optional)
- */
-export declare function resolveToolEnvironmentVariables(toolName: string, toolEnvConfig?: Record<string, any>): Promise<{
-    resolved: Record<string, string>;
-    missing: string[];
-    configLink?: string;
-}>;
-/**
- * Get available environment variables for a package namespace
- */
-export declare function getPackageEnvironmentVariables(packageNamespace: string): Promise<{
-    package: Record<string, {
-        value: string;
-        encrypted: boolean;
-        description?: string;
-    }>;
-    system: Record<string, string>;
-}>;
-/**
- * Validate that all required environment variables are available
- * Following the Enact protocol format for environment variables
- */
-export declare function validateRequiredEnvironmentVariables(toolEnvConfig: Record<string, any> | undefined, availableVars: Record<string, string>): {
-    valid: boolean;
-    missing: string[];
-    errors: string[];
-};
-export { extractPackageNamespace };
-/**
- * Get the web server URL if it's running
- */
-export declare function getWebServerUrl(): string | null;
-/**
- * Generate a configuration link for missing environment variables
- */
-export declare function generateConfigLink(missingVars: string[], toolName: string): string | null;

package/dist/utils/env-loader.js

@@ -1,270 +0,0 @@
-// src/utils/env-loader.ts - Environment variable loader for Enact tools with package namespace support
-import { join } from "path";
-import { homedir } from "os";
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { config as loadDotenv } from "dotenv";
-// Configuration paths
-const CONFIG_DIR = join(homedir(), ".enact");
-/**
- * Extract package namespace from tool name (excluding tool name)
- * e.g., "kgroves88/dagger/social/bluesky-poster" -> "kgroves88/dagger/social"
- */
-function extractPackageNamespace(toolName) {
-    const parts = toolName.split("/");
-    if (parts.length < 2) {
-        throw new Error('Tool name must be in format "org/package" or "org/package/tool"');
-    }
-    // Use all path parts except the last one (tool name)
-    // For tools like "kgroves88/dagger/social/bluesky-poster",
-    // we want the package path "kgroves88/dagger/social"
-    if (parts.length >= 2) {
-        return parts.slice(0, -1).join("/");
-    }
-    return parts[0]; // fallback for edge cases
-}
-/**
- * Get the environment file path for a package namespace
- */
-function getPackageEnvPath(packageNamespace) {
-    return join(CONFIG_DIR, "env", packageNamespace, ".env");
-}
-/**
- * Simple decryption for encrypted values
- */
-function decryptValue(encryptedValue) {
-    try {
-        return Buffer.from(encryptedValue, "base64").toString("utf8");
-    }
-    catch {
-        return encryptedValue; // Return as-is if decryption fails
-    }
-}
-/**
- * Read environment configuration for a package namespace
- */
-async function readPackageEnvConfig(packageNamespace) {
-    const envFile = getPackageEnvPath(packageNamespace);
-    if (!existsSync(envFile)) {
-        return { variables: {} };
-    }
-    try {
-        const data = await readFile(envFile, "utf8");
-        // Check if it's a simple .env file (KEY=value format) or JSON
-        if (data.trim().startsWith("{")) {
-            // It's JSON format (legacy package-managed variables)
-            return JSON.parse(data);
-        }
-        else {
-            // It's simple .env format (project mode), return empty since these are handled separately
-            return { variables: {} };
-        }
-    }
-    catch (error) {
-        // Only warn if it's not a simple .env file parsing issue
-        if (!error.message.includes("Unexpected token")) {
-            console.warn(`Failed to read env config from ${envFile}: ${error.message}`);
-        }
-        return { variables: {} };
-    }
-}
-/**
- * Load environment variables from Enact configuration for a specific package namespace
- */
-export async function loadPackageEnvironmentVariables(packageNamespace) {
-    const config = await readPackageEnvConfig(packageNamespace);
-    const envVars = {};
-    // Load variables from the package namespace
-    for (const [name, envVar] of Object.entries(config.variables)) {
-        const value = envVar.encrypted ? decryptValue(envVar.value) : envVar.value;
-        envVars[name] = value;
-    }
-    return envVars;
-}
-/**
- * Load environment variables from a package-based .env file
- */
-function loadPackageEnvFile(toolName) {
-    if (!toolName) {
-        return {};
-    }
-    try {
-        const packageNamespace = extractPackageNamespace(toolName);
-        const packageEnvPath = getPackageEnvPath(packageNamespace);
-        if (!existsSync(packageEnvPath)) {
-            return {};
-        }
-        // Load .env file and return the parsed variables
-        const result = loadDotenv({ path: packageEnvPath });
-        return result.parsed || {};
-    }
-    catch (error) {
-        console.warn(`Warning: Failed to load package .env file: ${error.message}`);
-        return {};
-    }
-}
-/**
- * Resolve environment variables for a tool definition with package namespace support
- * Combines system environment, Enact package configuration, and tool-specific requirements
- * Following the Enact protocol format:
- * env:
- *   VARIABLE_NAME:
- *     description: string
- *     source: string
- *     required: boolean
- *     default: string (optional)
- */
-export async function resolveToolEnvironmentVariables(toolName, toolEnvConfig) {
-    // Start with system environment variables
-    const resolved = { ...process.env };
-    // Load package .env file (if it exists) - priority 2
-    const packageEnvVars = loadPackageEnvFile(toolName);
-    Object.assign(resolved, packageEnvVars);
-    // Load package-specific environment variables if we have a tool name - priority 3 (highest)
-    if (toolName) {
-        try {
-            const packageNamespace = extractPackageNamespace(toolName);
-            const packageJsonEnvVars = await loadPackageEnvironmentVariables(packageNamespace);
-            // Override with package-managed JSON variables (highest priority)
-            Object.assign(resolved, packageJsonEnvVars);
-        }
-        catch (error) {
-            // If we can't extract package namespace, continue without package env vars
-            console.warn(`Warning: Could not load package environment variables: ${error.message}`);
-        }
-    }
-    const missing = [];
-    // Check tool-specific environment requirements following Enact protocol
-    if (toolEnvConfig) {
-        for (const [varName, config] of Object.entries(toolEnvConfig)) {
-            if (typeof config === "object" && config !== null) {
-                // Enact protocol: each env var has description, source, required, and optional default
-                const isRequired = config.required === true;
-                const defaultValue = config.default;
-                const source = config.source;
-                // Check if variable is already resolved
-                if (!(varName in resolved) || resolved[varName] === "") {
-                    if (defaultValue !== undefined) {
-                        resolved[varName] = String(defaultValue);
-                    }
-                    else if (isRequired) {
-                        missing.push(varName);
-                    }
-                }
-                // Handle different sources as specified in the Enact protocol
-                if (source && resolved[varName]) {
-                    // The source field tells us where the value should come from
-                    // For now, we'll just ensure the variable is available
-                    // In the future, this could be extended to support different sources
-                    // like "user", "system", "config", etc.
-                }
-            }
-        }
-    }
-    // Generate and show configuration link if there are missing variables
-    let configLink;
-    if (missing.length > 0) {
-        configLink = generateConfigLink(missing, toolName) || undefined;
-        if (configLink) {
-            console.log(`\n🔧 Missing environment variables: ${missing.join(", ")}`);
-            console.log(`📋 Configure them here: ${configLink}\n`);
-        }
-        else {
-            console.log(`\n⚠️  Missing required environment variables: ${missing.join(", ")}`);
-            console.log(`💡 Set them using the 'enact env set' command or your system environment\n`);
-        }
-    }
-    return { resolved, missing, configLink };
-}
-/**
- * Get available environment variables for a package namespace
- */
-export async function getPackageEnvironmentVariables(packageNamespace) {
-    const packageConfig = await readPackageEnvConfig(packageNamespace);
-    const packageVars = {};
-    // Process package variables
-    for (const [name, envVar] of Object.entries(packageConfig.variables)) {
-        packageVars[name] = {
-            value: envVar.encrypted ? "[encrypted]" : envVar.value,
-            encrypted: envVar.encrypted || false,
-            description: envVar.description,
-        };
-    }
-    // System environment variables (filtered to avoid exposing sensitive data)
-    const system = Object.fromEntries(Object.entries(process.env)
-        .filter(([key]) => 
-    // Only include environment variables that look like they might be relevant for tools
-    key.includes("API") ||
-        key.includes("TOKEN") ||
-        key.includes("KEY") ||
-        key.includes("URL") ||
-        key.includes("HOST") ||
-        key.includes("PORT") ||
-        key.startsWith("ENACT_") ||
-        key.startsWith("NODE_") ||
-        key.startsWith("NPM_"))
-        .map(([key, value]) => [key, value || ""]));
-    return { package: packageVars, system };
-}
-/**
- * Validate that all required environment variables are available
- * Following the Enact protocol format for environment variables
- */
-export function validateRequiredEnvironmentVariables(toolEnvConfig, availableVars) {
-    const missing = [];
-    const errors = [];
-    if (!toolEnvConfig) {
-        return { valid: true, missing, errors };
-    }
-    for (const [varName, config] of Object.entries(toolEnvConfig)) {
-        if (typeof config === "object" && config !== null) {
-            // Enact protocol: description, source, required are all required fields
-            // default is optional
-            const isRequired = config.required === true;
-            const hasDefault = config.default !== undefined;
-            const description = config.description || "";
-            const source = config.source || "";
-            if (isRequired &&
-                !hasDefault &&
-                (!(varName in availableVars) || availableVars[varName] === "")) {
-                missing.push(varName);
-                const errorMsg = `Required environment variable '${varName}' is not set`;
-                const detailMsg = description ? ` - ${description}` : "";
-                const sourceMsg = source ? ` (source: ${source})` : "";
-                errors.push(`${errorMsg}${detailMsg}${sourceMsg}`);
-            }
-        }
-    }
-    return {
-        valid: missing.length === 0,
-        missing,
-        errors,
-    };
-}
-// Export the package namespace extraction function for use in other modules
-export { extractPackageNamespace };
-// Load .env file if it exists
-loadDotenv();
-/**
- * Get the web server URL if it's running
- */
-export function getWebServerUrl() {
-    // For now, default to localhost:5555 as that's the standard port
-    // When running via MCP (npx -p @enactprotocol/cli enact-mcp), the web server is automatically started
-    // TODO: In the future, we could check if the server is actually responding or get the port dynamically
-    return "http://localhost:5555";
-}
-/**
- * Generate a configuration link for missing environment variables
- */
-export function generateConfigLink(missingVars, toolName) {
-    const webUrl = getWebServerUrl();
-    if (!webUrl) {
-        return null;
-    }
-    // Extract package namespace from tool name (exclude tool name itself)
-    const packageNamespace = extractPackageNamespace(toolName);
-    const encodedVars = encodeURIComponent(JSON.stringify(missingVars));
-    const encodedPackage = encodeURIComponent(packageNamespace);
-    return `${webUrl}/?vars=${encodedVars}&package=${encodedPackage}`;
-}

package/dist/utils/help.d.ts

@@ -1,36 +0,0 @@
-/**
- * Show the main help message
- */
-export declare function showHelp(): void;
-/**
- * Show version information
- */
-export declare function showVersion(): void;
-/**
- * Show help for the auth command
- */
-export declare function showAuthHelp(): void;
-/**
- * Show help for the init command
- */
-export declare function showInitHelp(): void;
-/**
- * Show help for the publish command
- */
-export declare function showPublishHelp(): void;
-/**
- * Show help for the search command
- */
-export declare function showSearchHelp(): void;
-/**
- * Show help for the remote command
- */
-export declare function showRemoteHelp(): void;
-/**
- * Show help for the user command
- */
-export declare function showUserHelp(): void;
-/**
- * Show help for the env command
- */
-export declare function showEnvHelp(): void;