@jam-nodes/playground 0.1.0

package/src/commands/run.ts

@@ -0,0 +1,273 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createRegistry, type NodeExecutionContext } from '@jam-nodes/core';
+import { builtInNodes } from '@jam-nodes/nodes';
+import {
+  getCredentials,
+  saveCredentials,
+  getCredentialSource,
+} from '../credentials/index.js';
+import {
+  promptForNodeInput,
+  promptForCredentials,
+  promptSaveCredentials,
+  selectNode,
+} from '../ui/index.js';
+import { generateMockOutput } from '../utils/index.js';
+
+// Create and populate the registry
+const registry = createRegistry();
+for (const node of builtInNodes) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  registry.register(node as any);
+}
+
+/**
+ * Service names required by each node type
+ */
+const NODE_SERVICE_REQUIREMENTS: Record<string, string[]> = {
+  search_contacts: ['apollo'],
+  reddit_monitor: ['forumScout'],
+  twitter_monitor: ['twitter'],
+  linkedin_monitor: ['forumScout'],
+  sora_video: ['openai'],
+  seo_keyword_research: ['dataForSeo'],
+  seo_audit: ['dataForSeo'],
+  social_keyword_generator: ['anthropic'],
+  draft_emails: ['anthropic'],
+  social_ai_analyze: ['anthropic'],
+};
+
+/**
+ * Run command - executes a node with input
+ */
+export const runCommand = new Command('run')
+  .description('Run a jam-node interactively')
+  .argument('[node-type]', 'Node type to run (interactive selection if omitted)')
+  .option('-i, --input <json>', 'Input as JSON string')
+  .option('-m, --mock', 'Use mock mode (returns sample data without calling APIs)')
+  .option('--no-confirm', 'Skip confirmation prompt')
+  .action(async (nodeType: string | undefined, options) => {
+    try {
+      // If no node type specified, show selection
+      if (!nodeType) {
+        const nodes = registry.getAllMetadata();
+        nodeType = await selectNode(nodes);
+      }
+
+      // Get node definition
+      const definition = registry.getDefinition(nodeType);
+      if (!definition) {
+        console.error(chalk.red(`Unknown node type: ${nodeType}`));
+        console.log(chalk.dim('Use "jam-playground list" to see available nodes'));
+        process.exit(1);
+      }
+
+      // Display node info
+      console.log();
+      console.log(chalk.bold.cyan('┌─────────────────────────────────────────────────────────────┐'));
+      console.log(chalk.bold.cyan('│  ') + chalk.bold(definition.name).padEnd(57) + chalk.bold.cyan('│'));
+      console.log(chalk.bold.cyan('│  ') + chalk.dim(definition.description.slice(0, 55)).padEnd(57) + chalk.bold.cyan('│'));
+      console.log(chalk.bold.cyan('└─────────────────────────────────────────────────────────────┘'));
+
+      // Mock mode notice
+      if (options.mock) {
+        console.log();
+        console.log(chalk.yellow('⚡ Mock mode enabled - returning sample data without API calls'));
+      }
+
+      // Check for required services/credentials
+      const requiredServices = NODE_SERVICE_REQUIREMENTS[nodeType] || [];
+      const credentials: Record<string, Record<string, string>> = {};
+
+      if (requiredServices.length > 0 && !options.mock) {
+        console.log();
+        console.log(chalk.dim(`This node requires: ${requiredServices.join(', ')}`));
+
+        for (const service of requiredServices) {
+          const source = await getCredentialSource(service);
+
+          if (source) {
+            console.log(chalk.green(`✓ ${service} credentials found (${source})`));
+            const creds = await getCredentials(service);
+            if (creds) {
+              credentials[service] = creds;
+            }
+          } else {
+            console.log(chalk.yellow(`⚠ ${service} credentials not found`));
+
+            // Prompt for credentials
+            const creds = await promptForCredentials(service, [
+              { name: 'apiKey', message: `${service} API Key:`, type: 'password' },
+            ]);
+
+            credentials[service] = creds;
+
+            // Ask if they want to save
+            const shouldSave = await promptSaveCredentials();
+            if (shouldSave) {
+              saveCredentials(service, creds);
+              console.log(chalk.green(`✓ ${service} credentials saved`));
+            }
+          }
+        }
+      }
+
+      // Get input
+      let input: Record<string, unknown>;
+
+      if (options.input) {
+        try {
+          input = JSON.parse(options.input);
+        } catch {
+          console.error(chalk.red('Invalid JSON input'));
+          process.exit(1);
+        }
+      } else {
+        // Interactive input
+        input = await promptForNodeInput(definition.inputSchema);
+      }
+
+      // Display input summary
+      console.log();
+      console.log(chalk.dim('Input:'));
+      console.log(chalk.dim(JSON.stringify(input, null, 2)));
+
+      // Execute node
+      const spinner = ora({
+        text: `Executing ${definition.name}...`,
+        color: 'cyan',
+      }).start();
+
+      try {
+        let result;
+
+        if (options.mock) {
+          // Mock mode - generate sample output
+          await new Promise((resolve) => setTimeout(resolve, 500)); // Simulate delay
+          result = {
+            success: true,
+            output: generateMockOutput(nodeType, definition.outputSchema),
+          };
+        } else {
+          // Create execution context
+          const context: NodeExecutionContext = {
+            userId: 'playground',
+            workflowExecutionId: `playground_${Date.now()}`,
+            variables: {},
+            resolveNestedPath: (path: string) => {
+              // Simple implementation - look in variables
+              const parts = path.split('.');
+              let current: unknown = context.variables;
+              for (const part of parts) {
+                if (current && typeof current === 'object') {
+                  current = (current as Record<string, unknown>)[part];
+                } else {
+                  return undefined;
+                }
+              }
+              return current;
+            },
+            services: createMockServices(credentials),
+          };
+
+          // Validate input
+          const validatedInput = definition.inputSchema.parse(input);
+
+          // Execute
+          result = await definition.executor(validatedInput, context);
+        }
+
+        spinner.stop();
+
+        // Display result
+        console.log();
+        if (result.success) {
+          console.log(chalk.green.bold('✓ Success!'));
+          console.log();
+          console.log(chalk.dim('Output:'));
+          console.log(formatJson(result.output));
+        } else {
+          console.log(chalk.red.bold('✗ Failed'));
+          console.log(chalk.red(result.error || 'Unknown error'));
+        }
+      } catch (error) {
+        spinner.stop();
+        console.log();
+        console.log(chalk.red.bold('✗ Execution failed'));
+        console.log(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+
+        if (error instanceof Error && error.stack) {
+          console.log(chalk.dim(error.stack));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Format JSON with syntax highlighting
+ */
+function formatJson(data: unknown): string {
+  const json = JSON.stringify(data, null, 2);
+  return json
+    .replace(/"([^"]+)":/g, chalk.cyan('"$1":'))
+    .replace(/: "([^"]+)"/g, ': ' + chalk.green('"$1"'))
+    .replace(/: (\d+)/g, ': ' + chalk.yellow('$1'))
+    .replace(/: (true|false)/g, ': ' + chalk.magenta('$1'))
+    .replace(/: (null)/g, ': ' + chalk.dim('$1'));
+}
+
+/**
+ * Create mock service implementations that use credentials
+ */
+function createMockServices(
+  credentials: Record<string, Record<string, string>>
+): Record<string, unknown> {
+  // These are placeholder services that would need real implementations
+  // For playground purposes, they demonstrate the service injection pattern
+  return {
+    apollo: credentials['apollo']
+      ? {
+          searchContacts: async () => {
+            console.log(chalk.dim('Apollo API call would happen here...'));
+            return [];
+          },
+          enrichContact: async () => {
+            return null;
+          },
+        }
+      : undefined,
+    forumScout: credentials['forumScout']
+      ? {
+          searchReddit: async () => [],
+          searchLinkedIn: async () => [],
+        }
+      : undefined,
+    twitter: credentials['twitter']
+      ? {
+          search: async () => [],
+        }
+      : undefined,
+    openai: credentials['openai']
+      ? {
+          generateVideo: async () => ({ url: 'mock_url' }),
+        }
+      : undefined,
+    anthropic: credentials['anthropic']
+      ? {
+          complete: async () => 'mock response',
+          generateKeywords: async () => ['keyword1', 'keyword2'],
+        }
+      : undefined,
+    dataForSeo: credentials['dataForSeo']
+      ? {
+          getKeywords: async () => [],
+          runAudit: async () => ({ issues: [] }),
+        }
+      : undefined,
+  };
+}

package/src/credentials/env-provider.ts

@@ -0,0 +1,208 @@
+import Conf from 'conf';
+import { config } from 'dotenv';
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * Encrypted credential store using conf
+ * Stores credentials in ~/.config/jam-nodes-playground/
+ */
+const store = new Conf<{
+  credentials: Record<string, Record<string, string>>;
+}>({
+  projectName: 'jam-nodes-playground',
+  defaults: {
+    credentials: {},
+  },
+});
+
+/**
+ * Load environment variables from .env files
+ * Searches in current directory and parent directories
+ */
+function loadEnvFiles(): void {
+  // Load .env from current working directory
+  config();
+
+  // Also try .env.local
+  const localEnvPath = path.join(process.cwd(), '.env.local');
+  if (fs.existsSync(localEnvPath)) {
+    config({ path: localEnvPath });
+  }
+}
+
+// Load env files on import
+loadEnvFiles();
+
+/**
+ * Known credential name to environment variable mappings
+ */
+const ENV_VAR_MAPPINGS: Record<string, string[]> = {
+  hunter: ['JAM_HUNTER_API_KEY', 'HUNTER_API_KEY'],
+  apollo: ['JAM_APOLLO_API_KEY', 'APOLLO_API_KEY'],
+  sendgrid: ['JAM_SENDGRID_API_KEY', 'SENDGRID_API_KEY'],
+  openai: ['JAM_OPENAI_API_KEY', 'OPENAI_API_KEY'],
+  anthropic: ['JAM_ANTHROPIC_API_KEY', 'ANTHROPIC_API_KEY'],
+  twitter: ['JAM_TWITTER_BEARER_TOKEN', 'TWITTER_BEARER_TOKEN'],
+  reddit: ['JAM_REDDIT_CLIENT_ID', 'REDDIT_CLIENT_ID'],
+  linkedin: ['JAM_LINKEDIN_ACCESS_TOKEN', 'LINKEDIN_ACCESS_TOKEN'],
+  dataforseo: ['JAM_DATAFORSEO_LOGIN', 'DATAFORSEO_LOGIN'],
+  hubspot: ['JAM_HUBSPOT_API_KEY', 'HUBSPOT_API_KEY'],
+  clearbit: ['JAM_CLEARBIT_API_KEY', 'CLEARBIT_API_KEY'],
+  dropcontact: ['JAM_DROPCONTACT_API_KEY', 'DROPCONTACT_API_KEY'],
+};
+
+/**
+ * Check environment variables for credentials
+ */
+function getFromEnv(name: string): Record<string, string> | null {
+  const envVars = ENV_VAR_MAPPINGS[name.toLowerCase()];
+
+  if (envVars) {
+    for (const varName of envVars) {
+      const value = process.env[varName];
+      if (value) {
+        return { apiKey: value };
+      }
+    }
+  }
+
+  // Try generic pattern: JAM_{NAME}_API_KEY
+  const genericKey = `JAM_${name.toUpperCase()}_API_KEY`;
+  if (process.env[genericKey]) {
+    return { apiKey: process.env[genericKey] };
+  }
+
+  // Special handling for services with multiple env vars
+  if (name.toLowerCase() === 'dataforseo') {
+    const login = process.env['JAM_DATAFORSEO_LOGIN'] || process.env['DATAFORSEO_LOGIN'];
+    const password = process.env['JAM_DATAFORSEO_PASSWORD'] || process.env['DATAFORSEO_PASSWORD'];
+    if (login && password) {
+      return { login, password };
+    }
+  }
+
+  if (name.toLowerCase() === 'reddit') {
+    const clientId = process.env['JAM_REDDIT_CLIENT_ID'] || process.env['REDDIT_CLIENT_ID'];
+    const clientSecret = process.env['JAM_REDDIT_CLIENT_SECRET'] || process.env['REDDIT_CLIENT_SECRET'];
+    if (clientId && clientSecret) {
+      return { clientId, clientSecret };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get credentials for a service.
+ * Checks in order:
+ * 1. Environment variables
+ * 2. Saved credentials in config store
+ * 3. Returns null (caller should prompt user)
+ *
+ * @param name - Service name (e.g., 'hunter', 'apollo')
+ * @returns Credentials object or null if not found
+ */
+export async function getCredentials(
+  name: string
+): Promise<Record<string, string> | null> {
+  // 1. Check environment variables
+  const envCreds = getFromEnv(name);
+  if (envCreds) {
+    return envCreds;
+  }
+
+  // 2. Check saved credentials
+  const saved = store.get(`credentials.${name.toLowerCase()}`) as Record<string, string> | undefined;
+  if (saved && Object.keys(saved).length > 0) {
+    return saved;
+  }
+
+  // 3. Return null (caller should prompt)
+  return null;
+}
+
+/**
+ * Save credentials for a service.
+ *
+ * @param name - Service name
+ * @param credentials - Credential data to save
+ */
+export function saveCredentials(
+  name: string,
+  credentials: Record<string, string>
+): void {
+  store.set(`credentials.${name.toLowerCase()}`, credentials);
+}
+
+/**
+ * Delete credentials for a service.
+ *
+ * @param name - Service name
+ * @returns True if credentials were deleted
+ */
+export function deleteCredentials(name: string): boolean {
+  const key = `credentials.${name.toLowerCase()}`;
+  if (store.has(key)) {
+    store.delete(key);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * List all saved credential names.
+ *
+ * @returns Array of service names with saved credentials
+ */
+export function listSavedCredentials(): string[] {
+  const credentials = store.get('credentials');
+  return Object.keys(credentials);
+}
+
+/**
+ * Check if credentials exist for a service.
+ *
+ * @param name - Service name
+ * @returns True if credentials are available (env or saved)
+ */
+export async function hasCredentials(name: string): Promise<boolean> {
+  const creds = await getCredentials(name);
+  return creds !== null;
+}
+
+/**
+ * Get credential source for display.
+ *
+ * @param name - Service name
+ * @returns Source description or null
+ */
+export async function getCredentialSource(
+  name: string
+): Promise<'env' | 'saved' | null> {
+  const envCreds = getFromEnv(name);
+  if (envCreds) {
+    return 'env';
+  }
+
+  const saved = store.get(`credentials.${name.toLowerCase()}`) as Record<string, string> | undefined;
+  if (saved && Object.keys(saved).length > 0) {
+    return 'saved';
+  }
+
+  return null;
+}
+
+/**
+ * Clear all saved credentials.
+ */
+export function clearAllCredentials(): void {
+  store.set('credentials', {});
+}
+
+/**
+ * Get the path to the credential store.
+ */
+export function getStorePath(): string {
+  return store.path;
+}

package/src/credentials/index.ts

@@ -0,0 +1,10 @@
+export {
+  getCredentials,
+  saveCredentials,
+  deleteCredentials,
+  listSavedCredentials,
+  hasCredentials,
+  getCredentialSource,
+  clearAllCredentials,
+  getStorePath,
+} from './env-provider.js';

package/src/index.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import {
+  listCommand,
+  runCommand,
+  initCommand,
+  credentialsCommand,
+} from './commands/index.js';
+
+const program = new Command()
+  .name('jam-playground')
+  .description('Test jam-nodes interactively')
+  .version('0.1.0');
+
+// Add commands
+program.addCommand(listCommand);
+program.addCommand(runCommand);
+program.addCommand(initCommand);
+program.addCommand(credentialsCommand);
+
+// Default action (no command) - show help
+program.action(() => {
+  console.log();
+  console.log(chalk.bold.cyan('  jam-nodes Playground'));
+  console.log(chalk.dim('  Test workflow nodes interactively'));
+  console.log();
+  program.outputHelp();
+});
+
+// Parse arguments
+program.parse();

package/src/ui/index.ts

@@ -0,0 +1,9 @@
+export {
+  promptForCredentials,
+  promptCredentialSource,
+  promptSaveCredentials,
+  promptForNodeInput,
+  confirmRun,
+  selectNode,
+  generatePromptsFromSchema,
+} from './prompts.js';