@enactprotocol/shared 1.2.13 → 2.0.0

package/src/utils/env-loader.ts

@@ -1,370 +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";
-
-interface EnvVariable {
-	value: string;
-	description?: string;
-	source?: string;
-	required?: boolean;
-	encrypted?: boolean;
-	createdAt: string;
-	updatedAt: string;
-}
-
-interface PackageEnvConfig {
-	variables: Record<string, EnvVariable>;
-}
-
-// 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: string): string {
-	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: string): string {
-	return join(CONFIG_DIR, "env", packageNamespace, ".env");
-}
-
-/**
- * Simple decryption for encrypted values
- */
-function decryptValue(encryptedValue: string): string {
-	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: string,
-): Promise<PackageEnvConfig> {
-	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) as PackageEnvConfig;
-		} 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 as Error).message.includes("Unexpected token")) {
-			console.warn(
-				`Failed to read env config from ${envFile}: ${(error as Error).message}`,
-			);
-		}
-		return { variables: {} };
-	}
-}
-
-/**
- * Load environment variables from Enact configuration for a specific package namespace
- */
-export async function loadPackageEnvironmentVariables(
-	packageNamespace: string,
-): Promise<Record<string, string>> {
-	const config = await readPackageEnvConfig(packageNamespace);
-	const envVars: Record<string, string> = {};
-
-	// 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: string): Record<string, string> {
-	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 as 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: string,
-	toolEnvConfig?: Record<string, any>,
-): Promise<{
-	resolved: Record<string, string>;
-	missing: string[];
-	configLink?: string;
-}> {
-	// Start with system environment variables
-	const resolved: Record<string, string> = { ...process.env } as Record<
-		string,
-		string
-	>;
-
-	// 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 as Error).message}`,
-			);
-		}
-	}
-
-	const missing: string[] = [];
-
-	// 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: string | undefined;
-	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: string,
-): Promise<{
-	package: Record<
-		string,
-		{ value: string; encrypted: boolean; description?: string }
-	>;
-	system: Record<string, string>;
-}> {
-	const packageConfig = await readPackageEnvConfig(packageNamespace);
-
-	const packageVars: Record<
-		string,
-		{ value: string; encrypted: boolean; description?: string }
-	> = {};
-
-	// 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: Record<string, any> | undefined,
-	availableVars: Record<string, string>,
-): { valid: boolean; missing: string[]; errors: string[] } {
-	const missing: string[] = [];
-	const errors: string[] = [];
-
-	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(): string | null {
-	// 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: string[],
-	toolName: string,
-): string | null {
-	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/src/utils/help.ts

@@ -1,257 +0,0 @@
-// 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(`@enactprotocol/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

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