@jam-nodes/playground 0.1.0

package/src/commands/credentials.ts

@@ -0,0 +1,242 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import {
+  getCredentials,
+  saveCredentials,
+  deleteCredentials,
+  listSavedCredentials,
+  getCredentialSource,
+  clearAllCredentials,
+  getStorePath,
+} from '../credentials/index.js';
+
+/**
+ * Known credential types and their required fields
+ */
+const CREDENTIAL_SCHEMAS: Record<
+  string,
+  Array<{ name: string; message: string; type?: 'input' | 'password' }>
+> = {
+  apollo: [{ name: 'apiKey', message: 'Apollo API Key:', type: 'password' }],
+  hunter: [{ name: 'apiKey', message: 'Hunter API Key:', type: 'password' }],
+  openai: [{ name: 'apiKey', message: 'OpenAI API Key:', type: 'password' }],
+  anthropic: [{ name: 'apiKey', message: 'Anthropic API Key:', type: 'password' }],
+  sendgrid: [{ name: 'apiKey', message: 'SendGrid API Key:', type: 'password' }],
+  hubspot: [{ name: 'apiKey', message: 'HubSpot API Key:', type: 'password' }],
+  clearbit: [{ name: 'apiKey', message: 'Clearbit API Key:', type: 'password' }],
+  dropcontact: [{ name: 'apiKey', message: 'Dropcontact API Key:', type: 'password' }],
+  twitter: [{ name: 'bearerToken', message: 'Twitter Bearer Token:', type: 'password' }],
+  linkedin: [{ name: 'accessToken', message: 'LinkedIn Access Token:', type: 'password' }],
+  reddit: [
+    { name: 'clientId', message: 'Reddit Client ID:', type: 'input' },
+    { name: 'clientSecret', message: 'Reddit Client Secret:', type: 'password' },
+  ],
+  dataforseo: [
+    { name: 'login', message: 'DataForSEO Login:', type: 'input' },
+    { name: 'password', message: 'DataForSEO Password:', type: 'password' },
+  ],
+};
+
+/**
+ * Credentials command - manage saved credentials
+ */
+export const credentialsCommand = new Command('credentials')
+  .alias('creds')
+  .description('Manage saved credentials');
+
+/**
+ * List saved credentials
+ */
+credentialsCommand
+  .command('list')
+  .description('List all saved credentials')
+  .action(async () => {
+    const saved = listSavedCredentials();
+
+    console.log();
+    console.log(chalk.bold('Saved Credentials'));
+    console.log(chalk.dim(`Store: ${getStorePath()}`));
+    console.log();
+
+    if (saved.length === 0) {
+      console.log(chalk.dim('No credentials saved yet.'));
+      console.log(chalk.dim('Use "jam-playground credentials set <service>" to add credentials.'));
+      return;
+    }
+
+    for (const service of saved) {
+      const source = await getCredentialSource(service);
+      const icon = source === 'env' ? '🌍' : '💾';
+      console.log(`  ${icon} ${chalk.bold(service)} ${chalk.dim(`(${source})`)}`);
+    }
+
+    console.log();
+    console.log(chalk.dim('🌍 = from environment, 💾 = saved to config'));
+  });
+
+/**
+ * Set credentials for a service
+ */
+credentialsCommand
+  .command('set <service>')
+  .description('Set credentials for a service')
+  .action(async (service: string) => {
+    const serviceLower = service.toLowerCase();
+
+    // Get schema for this service
+    const schema = CREDENTIAL_SCHEMAS[serviceLower];
+
+    if (!schema) {
+      console.log(chalk.yellow(`Unknown service: ${service}`));
+      console.log(chalk.dim('Known services:'));
+      console.log(chalk.dim(`  ${Object.keys(CREDENTIAL_SCHEMAS).join(', ')}`));
+      console.log();
+
+      // Allow custom single API key
+      const { proceed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'proceed',
+          message: 'Would you like to set a custom API key for this service?',
+          default: true,
+        },
+      ]);
+
+      if (!proceed) return;
+
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: `${service} API Key:`,
+          mask: '*',
+        },
+      ]);
+
+      saveCredentials(serviceLower, { apiKey });
+      console.log(chalk.green(`✓ ${service} credentials saved`));
+      return;
+    }
+
+    // Check if already exists
+    const existing = await getCredentials(serviceLower);
+    if (existing) {
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'overwrite',
+          message: `Credentials for ${service} already exist. Overwrite?`,
+          default: false,
+        },
+      ]);
+      if (!overwrite) return;
+    }
+
+    // Prompt for credentials
+    console.log();
+    console.log(chalk.dim(`Enter credentials for ${service}:`));
+
+    const answers = await inquirer.prompt(
+      schema.map((field) => ({
+        type: field.type || 'password',
+        name: field.name,
+        message: field.message,
+        mask: '*',
+      }))
+    );
+
+    saveCredentials(serviceLower, answers);
+    console.log(chalk.green(`✓ ${service} credentials saved`));
+  });
+
+/**
+ * Delete credentials for a service
+ */
+credentialsCommand
+  .command('delete <service>')
+  .alias('rm')
+  .description('Delete credentials for a service')
+  .action(async (service: string) => {
+    const serviceLower = service.toLowerCase();
+
+    // Check if exists
+    const existing = await getCredentials(serviceLower);
+    if (!existing) {
+      console.log(chalk.yellow(`No credentials found for ${service}`));
+      return;
+    }
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Delete credentials for ${service}?`,
+        default: false,
+      },
+    ]);
+
+    if (!confirm) return;
+
+    if (deleteCredentials(serviceLower)) {
+      console.log(chalk.green(`✓ ${service} credentials deleted`));
+    } else {
+      console.log(chalk.yellow(`Could not delete ${service} credentials`));
+    }
+  });
+
+/**
+ * Check credentials for a service
+ */
+credentialsCommand
+  .command('check <service>')
+  .description('Check if credentials exist for a service')
+  .action(async (service: string) => {
+    const serviceLower = service.toLowerCase();
+    const source = await getCredentialSource(serviceLower);
+
+    if (source) {
+      console.log(chalk.green(`✓ ${service} credentials found (${source})`));
+    } else {
+      console.log(chalk.red(`✗ ${service} credentials not found`));
+    }
+  });
+
+/**
+ * Clear all saved credentials
+ */
+credentialsCommand
+  .command('clear')
+  .description('Clear all saved credentials')
+  .action(async () => {
+    const saved = listSavedCredentials();
+
+    if (saved.length === 0) {
+      console.log(chalk.dim('No credentials to clear.'));
+      return;
+    }
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Delete all ${saved.length} saved credentials?`,
+        default: false,
+      },
+    ]);
+
+    if (!confirm) return;
+
+    clearAllCredentials();
+    console.log(chalk.green('✓ All credentials cleared'));
+  });
+
+/**
+ * Show credential store path
+ */
+credentialsCommand
+  .command('path')
+  .description('Show the credential store path')
+  .action(() => {
+    console.log(getStorePath());
+  });

package/src/commands/index.ts

@@ -0,0 +1,4 @@
+export { listCommand } from './list.js';
+export { runCommand } from './run.js';
+export { initCommand } from './init.js';
+export { credentialsCommand } from './credentials.js';

package/src/commands/init.ts

@@ -0,0 +1,80 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Template for .env file
+ */
+const ENV_TEMPLATE = `# jam-nodes Playground Configuration
+# Add your API keys below
+
+# Apollo.io (Contact Search)
+# JAM_APOLLO_API_KEY=your_api_key_here
+
+# Hunter.io (Email Finder)
+# JAM_HUNTER_API_KEY=your_api_key_here
+
+# OpenAI (AI Features)
+# JAM_OPENAI_API_KEY=your_api_key_here
+
+# Anthropic (AI Features)
+# JAM_ANTHROPIC_API_KEY=your_api_key_here
+
+# Twitter/X (Social Monitoring)
+# JAM_TWITTER_BEARER_TOKEN=your_bearer_token_here
+
+# Reddit (Social Monitoring)
+# JAM_REDDIT_CLIENT_ID=your_client_id_here
+# JAM_REDDIT_CLIENT_SECRET=your_client_secret_here
+
+# LinkedIn (Social Monitoring)
+# JAM_LINKEDIN_ACCESS_TOKEN=your_access_token_here
+
+# DataForSEO (SEO Tools)
+# JAM_DATAFORSEO_LOGIN=your_login_here
+# JAM_DATAFORSEO_PASSWORD=your_password_here
+
+# SendGrid (Email Sending)
+# JAM_SENDGRID_API_KEY=your_api_key_here
+
+# HubSpot (CRM)
+# JAM_HUBSPOT_API_KEY=your_api_key_here
+
+# Clearbit (Enrichment)
+# JAM_CLEARBIT_API_KEY=your_api_key_here
+
+# Dropcontact (Enrichment)
+# JAM_DROPCONTACT_API_KEY=your_api_key_here
+`;
+
+/**
+ * Init command - initializes a .env file with template
+ */
+export const initCommand = new Command('init')
+  .description('Initialize a .env file with credential template')
+  .option('-f, --force', 'Overwrite existing .env file')
+  .option('-p, --path <path>', 'Custom path for .env file', '.env')
+  .action((options) => {
+    const envPath = path.resolve(process.cwd(), options.path);
+
+    // Check if file exists
+    if (fs.existsSync(envPath) && !options.force) {
+      console.log(chalk.yellow(`⚠ ${options.path} already exists`));
+      console.log(chalk.dim('Use --force to overwrite'));
+      return;
+    }
+
+    // Write template
+    fs.writeFileSync(envPath, ENV_TEMPLATE, 'utf-8');
+
+    console.log(chalk.green(`✓ Created ${options.path}`));
+    console.log();
+    console.log(chalk.dim('Edit the file to add your API keys.'));
+    console.log(chalk.dim('Uncomment and fill in the keys you need.'));
+    console.log();
+    console.log(chalk.bold('Quick start:'));
+    console.log(chalk.dim('1. Open .env in your editor'));
+    console.log(chalk.dim('2. Add your API keys'));
+    console.log(chalk.dim('3. Run: jam-playground run <node-type>'));
+  });

package/src/commands/list.ts

@@ -0,0 +1,124 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createRegistry, type NodeCategory } from '@jam-nodes/core';
+import { builtInNodes } from '@jam-nodes/nodes';
+
+// 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);
+}
+
+/**
+ * Category colors for display
+ */
+const categoryColors: Record<NodeCategory, (text: string) => string> = {
+  logic: chalk.blue,
+  transform: chalk.green,
+  integration: chalk.magenta,
+  action: chalk.yellow,
+};
+
+/**
+ * Category labels for display
+ */
+const categoryLabels: Record<NodeCategory, string> = {
+  logic: 'Logic',
+  transform: 'Transform',
+  integration: 'Integration',
+  action: 'Action',
+};
+
+/**
+ * List command - displays all available nodes
+ */
+export const listCommand = new Command('list')
+  .description('List all available jam-nodes')
+  .option('-c, --category <category>', 'Filter by category (logic, transform, integration, action)')
+  .option('--json', 'Output as JSON')
+  .action((options) => {
+    const allDefinitions = registry.getAllDefinitions();
+
+    // Filter by category if specified
+    let definitions = allDefinitions;
+    if (options.category) {
+      const category = options.category.toLowerCase() as NodeCategory;
+      definitions = allDefinitions.filter((d) => d.category === category);
+
+      if (definitions.length === 0) {
+        console.log(chalk.yellow(`No nodes found in category: ${options.category}`));
+        console.log(chalk.dim(`Available categories: logic, transform, integration, action`));
+        return;
+      }
+    }
+
+    // JSON output
+    if (options.json) {
+      const output = definitions.map((d) => ({
+        type: d.type,
+        name: d.name,
+        description: d.description,
+        category: d.category,
+        estimatedDuration: d.estimatedDuration,
+        capabilities: d.capabilities,
+      }));
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+
+    // Group by category
+    const byCategory = definitions.reduce(
+      (acc, def) => {
+        const cat = def.category;
+        if (!acc[cat]) acc[cat] = [];
+        acc[cat].push(def);
+        return acc;
+      },
+      {} as Record<NodeCategory, typeof definitions>
+    );
+
+    // Header
+    console.log();
+    console.log(chalk.bold('Available jam-nodes'));
+    console.log(chalk.dim(`Total: ${definitions.length} nodes`));
+    console.log();
+
+    // Display by category
+    const categories: NodeCategory[] = ['logic', 'transform', 'integration', 'action'];
+
+    for (const category of categories) {
+      const nodes = byCategory[category];
+      if (!nodes || nodes.length === 0) continue;
+
+      const colorFn = categoryColors[category];
+      const label = categoryLabels[category];
+
+      console.log(colorFn(`━━━ ${label} (${nodes.length}) ━━━`));
+      console.log();
+
+      for (const node of nodes) {
+        console.log(`  ${chalk.bold(node.type)}`);
+        console.log(`  ${chalk.dim(node.name)} - ${node.description}`);
+
+        // Show capabilities if present
+        const caps = node.capabilities;
+        if (caps) {
+          const capList: string[] = [];
+          if (caps.supportsEnrichment) capList.push('enrichment');
+          if (caps.supportsBulkActions) capList.push('bulk');
+          if (caps.supportsRerun) capList.push('rerun');
+          if (caps.supportsApproval) capList.push('approval');
+          if (capList.length > 0) {
+            console.log(`  ${chalk.dim('Capabilities:')} ${capList.join(', ')}`);
+          }
+        }
+
+        console.log();
+      }
+    }
+
+    // Usage hint
+    console.log(chalk.dim('Run a node: jam-playground run <node-type>'));
+    console.log(chalk.dim('Example: jam-playground run conditional'));
+  });