pdauth 1.0.1

package/src/cli.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import {
+  configCommand,
+  appsCommand,
+  appInfoCommand,
+  connectCommand,
+  statusCommand,
+  disconnectCommand,
+  toolsCommand,
+  callCommand,
+  proxyCommand,
+} from './commands/index.js';
+
+const program = new Command();
+
+program
+  .name('pdauth')
+  .description('🔐 Pipedream OAuth CLI - Give AI agents access to 2500+ APIs via dynamic OAuth')
+  .version('1.0.0');
+
+// Config command
+program
+  .command('config')
+  .description('Configure Pipedream credentials')
+  .option('-s, --show', 'Show current configuration')
+  .option('--set <key=value>', 'Set a configuration value')
+  .action(configCommand);
+
+// Apps commands
+program
+  .command('apps')
+  .description('List available apps (2500+ APIs)')
+  .option('-s, --search <query>', 'Search for apps')
+  .option('-j, --json', 'Output as JSON')
+  .action(appsCommand);
+
+program
+  .command('app <slug>')
+  .description('Get info about a specific app')
+  .option('-j, --json', 'Output as JSON')
+  .action(appInfoCommand);
+
+// Connect command
+program
+  .command('connect <app>')
+  .description('Generate OAuth link for an app')
+  .option('-u, --user <id>', 'User ID (default: "default")')
+  .option('-j, --json', 'Output as JSON')
+  .option('-c, --copy', 'Copy link to clipboard')
+  .action(connectCommand);
+
+// Status command
+program
+  .command('status')
+  .description('List connected accounts')
+  .option('-u, --user <id>', 'User ID (default: "default")')
+  .option('-a, --all', 'Show all users')
+  .option('-j, --json', 'Output as JSON')
+  .action(statusCommand);
+
+// Disconnect command
+program
+  .command('disconnect <app>')
+  .description('Disconnect an app')
+  .option('-u, --user <id>', 'User ID')
+  .option('-f, --force', 'Skip confirmation')
+  .action(disconnectCommand);
+
+// Tools command
+program
+  .command('tools <app>')
+  .description('List available MCP tools for an app')
+  .option('-u, --user <id>', 'User ID')
+  .option('-j, --json', 'Output as JSON')
+  .action(toolsCommand);
+
+// Call command
+program
+  .command('call <tool>')
+  .description('Invoke an MCP tool (format: app.tool_name)')
+  .argument('[args...]', 'Tool arguments as key=value pairs')
+  .option('-u, --user <id>', 'User ID')
+  .option('-j, --json', 'Output as JSON')
+  .option('-a, --args <json>', 'Arguments as JSON')
+  .action(callCommand);
+
+// Proxy command - make authenticated API requests
+program
+  .command('proxy <app> <path>')
+  .description('Make authenticated API request via Pipedream proxy')
+  .option('-X, --method <method>', 'HTTP method (GET|POST|PUT|DELETE|PATCH)', 'GET')
+  .option('-u, --user <id>', 'User ID')
+  .option('-d, --data <json>', 'Request body as JSON string')
+  .option('-H, --header <header>', 'Custom header (repeatable)', (v, p: string[]) => p.concat([v]), [] as string[])
+  .option('-q, --query <param>', 'Query parameter (repeatable)', (v, p: string[]) => p.concat([v]), [] as string[])
+  .option('-j, --json', 'Output response as JSON (compact)')
+  .option('-v, --verbose', 'Show request details')
+  .action(proxyCommand);
+
+// Quick auth link helper
+program
+  .command('link <app>')
+  .description('Alias for connect - generate OAuth link')
+  .option('-u, --user <id>', 'User ID')
+  .option('-j, --json', 'Output as JSON')
+  .option('-c, --copy', 'Copy to clipboard')
+  .action(connectCommand);
+
+program.parse();

package/src/commands/apps.ts

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { searchApps, getApp } from '../pipedream.js';
+import { isConfigured } from '../config.js';
+
+export async function appsCommand(options: { search?: string; json?: boolean }): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Fetching apps...').start();
+
+  try {
+    const apps = await searchApps(options.search);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(apps, null, 2));
+      return;
+    }
+
+    if (apps.length === 0) {
+      console.log(chalk.yellow(`No apps found${options.search ? ` for "${options.search}"` : ''}`));
+      return;
+    }
+
+    console.log(chalk.bold(`\n📦 Available Apps${options.search ? ` matching "${options.search}"` : ''}\n`));
+    
+    for (const app of apps.slice(0, 50)) {
+      console.log(`  ${chalk.cyan(app.nameSlug.padEnd(30))} ${chalk.gray(app.name)}`);
+      if (app.description) {
+        console.log(`  ${' '.repeat(30)} ${chalk.dim(app.description.slice(0, 60))}${app.description.length > 60 ? '...' : ''}`);
+      }
+    }
+
+    if (apps.length > 50) {
+      console.log(chalk.gray(`\n  ... and ${apps.length - 50} more. Use --search to filter.`));
+    }
+    
+    console.log(chalk.gray(`\n  Total: ${apps.length} apps\n`));
+    console.log(chalk.gray('  Browse all: https://mcp.pipedream.com\n'));
+  } catch (error) {
+    spinner.fail('Failed to fetch apps');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+
+export async function appInfoCommand(appSlug: string, options: { json?: boolean }): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  const spinner = ora(`Fetching ${appSlug}...`).start();
+
+  try {
+    const app = await getApp(appSlug);
+    spinner.stop();
+
+    if (!app) {
+      console.error(chalk.red(`App not found: ${appSlug}`));
+      process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(app, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n📦 ${app.name}\n`));
+    console.log(`  ${chalk.gray('Slug:')} ${chalk.cyan(app.nameSlug)}`);
+    console.log(`  ${chalk.gray('Auth:')} ${app.authType}`);
+    if (app.description) {
+      console.log(`  ${chalk.gray('Description:')} ${app.description}`);
+    }
+    if (app.categories?.length) {
+      console.log(`  ${chalk.gray('Categories:')} ${app.categories.join(', ')}`);
+    }
+    console.log(`  ${chalk.gray('MCP Server:')} https://mcp.pipedream.com/app/${app.nameSlug}`);
+    console.log();
+  } catch (error) {
+    spinner.fail('Failed to fetch app');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import { getConfig, setConfig, isConfigured, getConfigPath, type PdAuthConfig } from '../config.js';
+import { createInterface } from 'readline';
+
+async function prompt(question: string, defaultValue?: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const displayDefault = defaultValue ? ` [${defaultValue}]` : '';
+    rl.question(`${question}${displayDefault}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+export async function configCommand(options: { show?: boolean; set?: string }): Promise<void> {
+  if (options.show) {
+    const cfg = getConfig();
+    console.log(chalk.bold('\n📋 Current Configuration\n'));
+    console.log(`  ${chalk.gray('Path:')} ${getConfigPath()}`);
+    console.log(`  ${chalk.gray('Client ID:')} ${cfg.clientId ? chalk.green(cfg.clientId.slice(0, 8) + '...') : chalk.red('not set')}`);
+    console.log(`  ${chalk.gray('Client Secret:')} ${cfg.clientSecret ? chalk.green('********') : chalk.red('not set')}`);
+    console.log(`  ${chalk.gray('Project ID:')} ${cfg.projectId ? chalk.green(cfg.projectId) : chalk.red('not set')}`);
+    console.log(`  ${chalk.gray('Environment:')} ${chalk.cyan(cfg.environment)}`);
+    console.log(`  ${chalk.gray('Status:')} ${isConfigured() ? chalk.green('✓ Configured') : chalk.red('✗ Not configured')}\n`);
+    return;
+  }
+
+  if (options.set) {
+    // Format: key=value
+    const [key, ...valueParts] = options.set.split('=');
+    const value = valueParts.join('=');
+    
+    const validKeys = ['clientId', 'clientSecret', 'projectId', 'environment'];
+    if (!validKeys.includes(key)) {
+      console.error(chalk.red(`Invalid key: ${key}. Valid keys: ${validKeys.join(', ')}`));
+      process.exit(1);
+    }
+    
+    setConfig({ [key]: value } as Partial<PdAuthConfig>);
+    console.log(chalk.green(`✓ Set ${key}`));
+    return;
+  }
+
+  // Interactive configuration
+  console.log(chalk.bold('\n🔐 Pipedream OAuth Configuration\n'));
+  console.log(chalk.gray('Get your credentials at: https://pipedream.com/settings/api\n'));
+
+  const current = getConfig();
+
+  const clientId = await prompt('Client ID', current.clientId || undefined);
+  const clientSecret = await prompt('Client Secret', current.clientSecret ? '********' : undefined);
+  const projectId = await prompt('Project ID', current.projectId || undefined);
+  const environment = await prompt('Environment (development/production)', current.environment || 'development');
+
+  setConfig({
+    clientId,
+    clientSecret: clientSecret === '********' ? current.clientSecret : clientSecret,
+    projectId,
+    environment: environment as 'development' | 'production',
+  });
+
+  console.log(chalk.green('\n✓ Configuration saved!\n'));
+}

package/src/commands/connect.ts

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createConnectLink, getApp } from '../pipedream.js';
+import { isConfigured, getDefaultUser, addUser } from '../config.js';
+
+export async function connectCommand(
+  appSlug: string,
+  options: { user?: string; json?: boolean; copy?: boolean }
+): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  const userId = options.user || getDefaultUser();
+  addUser(userId);
+
+  const spinner = ora(`Generating OAuth link for ${appSlug}...`).start();
+
+  try {
+    // Verify app exists
+    const app = await getApp(appSlug);
+    if (!app) {
+      spinner.fail(`App not found: ${appSlug}`);
+      console.log(chalk.gray('Run: pdauth apps --search <query> to find available apps'));
+      process.exit(1);
+    }
+
+    const result = await createConnectLink(userId, appSlug);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify({
+        app: appSlug,
+        appName: app.name,
+        user: userId,
+        connectLinkUrl: result.connectLinkUrl,
+        expiresAt: result.expiresAt,
+      }, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n🔗 OAuth Link for ${chalk.cyan(app.name)}\n`));
+    console.log(`  ${chalk.gray('User:')} ${userId}`);
+    console.log(`  ${chalk.gray('Expires:')} ${new Date(result.expiresAt).toLocaleString()}\n`);
+    
+    console.log(chalk.bold('  Link:\n'));
+    console.log(`  ${chalk.underline.blue(result.connectLinkUrl)}\n`);
+    
+    console.log(chalk.gray('  Share this link to authorize access.\n'));
+    console.log(chalk.gray('  After authorization, run: pdauth status\n'));
+
+    // Try to copy to clipboard (cross-platform)
+    if (options.copy) {
+      try {
+        const { execSync } = await import('child_process');
+        const platform = process.platform;
+        
+        if (platform === 'darwin') {
+          execSync(`echo "${result.connectLinkUrl}" | pbcopy`);
+        } else if (platform === 'linux') {
+          execSync(`echo "${result.connectLinkUrl}" | xclip -selection clipboard 2>/dev/null || echo "${result.connectLinkUrl}" | xsel --clipboard 2>/dev/null`);
+        } else if (platform === 'win32') {
+          execSync(`echo ${result.connectLinkUrl} | clip`);
+        }
+        console.log(chalk.green('  ✓ Copied to clipboard!\n'));
+      } catch {
+        // Clipboard not available, skip silently
+      }
+    }
+  } catch (error) {
+    spinner.fail('Failed to generate link');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,6 @@
+export { configCommand } from './config.js';
+export { appsCommand, appInfoCommand } from './apps.js';
+export { connectCommand } from './connect.js';
+export { statusCommand, disconnectCommand } from './status.js';
+export { toolsCommand, callCommand } from './tools.js';
+export { proxyCommand } from './proxy.js';

package/src/commands/proxy.ts

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getClient, listAccounts } from '../pipedream.js';
+import { isConfigured, getDefaultUser } from '../config.js';
+
+interface ProxyOptions {
+  method?: string;
+  user?: string;
+  data?: string;
+  header?: string[];
+  query?: string[];
+  json?: boolean;
+  verbose?: boolean;
+}
+
+function parseParams(params: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const p of params) {
+    const [key, ...rest] = p.split('=');
+    if (key) {
+      result[key] = rest.join('=');
+    }
+  }
+  return result;
+}
+
+function parseHeaders(headers: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const h of headers) {
+    const colonIndex = h.indexOf(':');
+    if (colonIndex > 0) {
+      const key = h.slice(0, colonIndex).trim();
+      const value = h.slice(colonIndex + 1).trim();
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export async function proxyCommand(
+  app: string,
+  path: string,
+  options: ProxyOptions
+): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  const userId = options.user || getDefaultUser();
+  const method = (options.method || 'GET').toUpperCase();
+
+  if (options.verbose) {
+    console.log(chalk.gray(`User: ${userId}`));
+    console.log(chalk.gray(`App: ${app}`));
+    console.log(chalk.gray(`Path: ${path}`));
+    console.log(chalk.gray(`Method: ${method}`));
+  }
+
+  const spinner = ora('Finding account...').start();
+
+  try {
+    // 1. Get account ID for app + user
+    const accounts = await listAccounts(userId);
+    const account = accounts.find(a => a.app.nameSlug === app);
+
+    if (!account) {
+      spinner.fail(`No ${app} account connected for user ${userId}`);
+      const connectedApps = accounts.map(a => a.app.nameSlug).join(', ');
+      console.log(chalk.gray(`Connected apps: ${connectedApps || 'none'}`));
+      console.log(chalk.gray(`\nRun: pdauth connect ${app} --user ${userId}`));
+      process.exit(1);
+    }
+
+    if (options.verbose) {
+      spinner.succeed(`Using account: ${account.name} (${account.id})`);
+    }
+
+    // 2. Build request
+    const client = getClient();
+    const params = parseParams(options.query || []);
+    const headers = parseHeaders(options.header || []);
+
+    let body: Record<string, unknown> | undefined;
+    if (options.data) {
+      try {
+        body = JSON.parse(options.data);
+      } catch (e) {
+        spinner.fail('Invalid JSON in --data');
+        process.exit(1);
+      }
+    }
+
+    const request = {
+      url: path,
+      externalUserId: userId,
+      accountId: account.id,
+      params: Object.keys(params).length > 0 ? params : undefined,
+      headers: Object.keys(headers).length > 0 ? headers : undefined,
+      body,
+    };
+
+    if (options.verbose) {
+      console.log(chalk.gray('\nRequest:'));
+      console.log(chalk.gray(JSON.stringify(request, null, 2)));
+      console.log();
+    }
+
+    spinner.text = `${method} ${path}...`;
+
+    // 3. Call proxy based on method
+    let response: unknown;
+
+    switch (method) {
+      case 'GET':
+        response = await client.proxy.get(request);
+        break;
+      case 'POST':
+        response = await client.proxy.post(request as Parameters<typeof client.proxy.post>[0]);
+        break;
+      case 'PUT':
+        response = await client.proxy.put(request as Parameters<typeof client.proxy.put>[0]);
+        break;
+      case 'DELETE':
+        response = await client.proxy.delete(request);
+        break;
+      case 'PATCH':
+        response = await client.proxy.patch(request as Parameters<typeof client.proxy.patch>[0]);
+        break;
+      default:
+        spinner.fail(`Unsupported method: ${method}`);
+        process.exit(1);
+    }
+
+    spinner.stop();
+
+    // 4. Output response
+    if (options.json) {
+      console.log(JSON.stringify(response));
+    } else if (typeof response === 'object' && response !== null) {
+      console.log(JSON.stringify(response, null, 2));
+    } else {
+      console.log(response);
+    }
+  } catch (error) {
+    spinner.fail('Request failed');
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk.red(message));
+
+    if (options.verbose && error instanceof Error && error.stack) {
+      console.error(chalk.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,143 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { listAccounts, deleteAccount } from '../pipedream.js';
+import { isConfigured, getDefaultUser, getUsers } from '../config.js';
+
+export async function statusCommand(options: { user?: string; json?: boolean; all?: boolean }): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Fetching connected accounts...').start();
+
+  try {
+    if (options.all) {
+      // Show all users
+      const users = getUsers();
+      const userIds = Object.keys(users);
+      
+      if (userIds.length === 0) {
+        spinner.stop();
+        console.log(chalk.yellow('No users registered. Run: pdauth connect <app> --user <id>'));
+        return;
+      }
+
+      const allAccounts: Array<{ userId: string; accounts: Awaited<ReturnType<typeof listAccounts>> }> = [];
+      
+      for (const userId of userIds) {
+        const accounts = await listAccounts(userId);
+        allAccounts.push({ userId, accounts });
+      }
+      
+      spinner.stop();
+
+      if (options.json) {
+        console.log(JSON.stringify(allAccounts, null, 2));
+        return;
+      }
+
+      console.log(chalk.bold('\n📊 All Connected Accounts\n'));
+      
+      for (const { userId, accounts } of allAccounts) {
+        const userMeta = users[userId];
+        const label = userMeta?.label ? ` (${userMeta.label})` : '';
+        console.log(chalk.bold(`  👤 ${userId}${label}`));
+        
+        if (accounts.length === 0) {
+          console.log(chalk.gray('     No connected accounts\n'));
+        } else {
+          for (const account of accounts) {
+            const status = account.dead ? chalk.red('✗ dead') : 
+                          account.healthy ? chalk.green('✓ healthy') : chalk.yellow('⚠ unhealthy');
+            console.log(`     ${chalk.cyan(account.app.nameSlug.padEnd(25))} ${status}`);
+          }
+          console.log();
+        }
+      }
+      return;
+    }
+
+    const userId = options.user || getDefaultUser();
+    const accounts = await listAccounts(userId);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify({ user: userId, accounts }, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n📊 Connected Accounts for ${chalk.cyan(userId)}\n`));
+
+    if (accounts.length === 0) {
+      console.log(chalk.yellow('  No connected accounts.\n'));
+      console.log(chalk.gray('  Run: pdauth connect <app> to authorize an app\n'));
+      return;
+    }
+
+    for (const account of accounts) {
+      const status = account.dead ? chalk.red('✗ dead') : 
+                    account.healthy ? chalk.green('✓ healthy') : chalk.yellow('⚠ unhealthy');
+      
+      console.log(`  ${chalk.cyan(account.app.nameSlug.padEnd(25))} ${account.app.name}`);
+      console.log(`  ${' '.repeat(25)} ${chalk.gray('Status:')} ${status}`);
+      console.log(`  ${' '.repeat(25)} ${chalk.gray('Account ID:')} ${account.id}`);
+      console.log(`  ${' '.repeat(25)} ${chalk.gray('Connected:')} ${new Date(account.createdAt).toLocaleDateString()}`);
+      console.log();
+    }
+
+    console.log(chalk.gray(`  Total: ${accounts.length} connected app(s)\n`));
+  } catch (error) {
+    spinner.fail('Failed to fetch accounts');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+
+export async function disconnectCommand(
+  appSlugOrAccountId: string,
+  options: { user?: string; force?: boolean }
+): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  const userId = options.user || getDefaultUser();
+  const spinner = ora('Finding account...').start();
+
+  try {
+    const accounts = await listAccounts(userId);
+    
+    // Find account by app slug or account ID
+    const account = accounts.find(
+      a => a.app.nameSlug === appSlugOrAccountId || a.id === appSlugOrAccountId
+    );
+
+    if (!account) {
+      spinner.fail(`No connected account found: ${appSlugOrAccountId}`);
+      process.exit(1);
+    }
+
+    if (!options.force) {
+      spinner.stop();
+      console.log(chalk.yellow(`\n⚠️  This will disconnect ${chalk.cyan(account.app.name)} for user ${userId}`));
+      console.log(chalk.gray('  Run with --force to confirm\n'));
+      process.exit(0);
+    }
+
+    spinner.text = `Disconnecting ${account.app.name}...`;
+    const success = await deleteAccount(account.id);
+    
+    if (success) {
+      spinner.succeed(`Disconnected ${account.app.name}`);
+    } else {
+      spinner.fail(`Failed to disconnect ${account.app.name}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail('Failed to disconnect');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}