pdauth 1.0.1

package/src/commands/tools.ts

@@ -0,0 +1,150 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { listMcpTools, invokeMcpTool, listAccounts } from '../pipedream.js';
+import { isConfigured, getDefaultUser } from '../config.js';
+
+export async function toolsCommand(
+  appSlug: string,
+  options: { user?: string; json?: 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(`Fetching tools for ${appSlug}...`).start();
+
+  try {
+    // Check if app is connected
+    const accounts = await listAccounts(userId);
+    const connected = accounts.find(a => a.app.nameSlug === appSlug);
+    
+    if (!connected) {
+      spinner.fail(`App not connected: ${appSlug}`);
+      console.log(chalk.gray(`\nRun: pdauth connect ${appSlug} --user ${userId}`));
+      process.exit(1);
+    }
+
+    const tools = await listMcpTools(userId, appSlug);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(tools, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n🔧 Tools for ${chalk.cyan(appSlug)} (${tools.length} available)\n`));
+
+    if (tools.length === 0) {
+      console.log(chalk.yellow('  No tools available for this app.\n'));
+      return;
+    }
+
+    for (const tool of tools) {
+      console.log(`  ${chalk.cyan(tool.name)}`);
+      if (tool.description) {
+        console.log(`  ${chalk.gray(tool.description.slice(0, 80))}${tool.description.length > 80 ? '...' : ''}`);
+      }
+      
+      const required = tool.inputSchema?.required || [];
+      const props = Object.keys(tool.inputSchema?.properties || {});
+      
+      if (props.length > 0) {
+        const propDisplay = props.map(p => required.includes(p) ? chalk.yellow(p) : chalk.gray(p)).join(', ');
+        console.log(`  ${chalk.dim('params:')} ${propDisplay}`);
+      }
+      console.log();
+    }
+
+    console.log(chalk.gray(`  Invoke: pdauth call ${appSlug}.<tool_name> key=value\n`));
+  } catch (error) {
+    spinner.fail('Failed to fetch tools');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+
+export async function callCommand(
+  toolSelector: string,
+  args: string[],
+  options: { user?: string; json?: boolean; args?: string }
+): Promise<void> {
+  if (!isConfigured()) {
+    console.error(chalk.red('Not configured. Run: pdauth config'));
+    process.exit(1);
+  }
+
+  // Parse tool selector: app.tool_name
+  const [appSlug, ...toolParts] = toolSelector.split('.');
+  const toolName = toolParts.join('.');
+
+  if (!appSlug || !toolName) {
+    console.error(chalk.red('Invalid tool selector. Use: app_slug.tool_name'));
+    console.error(chalk.gray('Example: pdauth call slack.send_message channel=general text="Hello"'));
+    process.exit(1);
+  }
+
+  const userId = options.user || getDefaultUser();
+
+  // Parse arguments
+  let toolArgs: Record<string, unknown> = {};
+  
+  if (options.args) {
+    // JSON args from --args flag
+    try {
+      toolArgs = JSON.parse(options.args);
+    } catch {
+      console.error(chalk.red('Invalid JSON in --args'));
+      process.exit(1);
+    }
+  } else {
+    // Parse key=value args
+    for (const arg of args) {
+      const eqIndex = arg.indexOf('=');
+      if (eqIndex === -1) continue;
+      
+      const key = arg.slice(0, eqIndex);
+      let value: unknown = arg.slice(eqIndex + 1);
+      
+      // Try to parse as JSON for complex values
+      try {
+        value = JSON.parse(value as string);
+      } catch {
+        // Keep as string
+      }
+      
+      toolArgs[key] = value;
+    }
+  }
+
+  const spinner = ora(`Calling ${appSlug}.${toolName}...`).start();
+
+  try {
+    // Check if app is connected
+    const accounts = await listAccounts(userId);
+    const connected = accounts.find(a => a.app.nameSlug === appSlug);
+    
+    if (!connected) {
+      spinner.fail(`App not connected: ${appSlug}`);
+      console.log(chalk.gray(`\nRun: pdauth connect ${appSlug} --user ${userId}`));
+      process.exit(1);
+    }
+
+    const result = await invokeMcpTool(userId, appSlug, toolName, toolArgs);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n✅ ${appSlug}.${toolName} completed\n`));
+    console.log(JSON.stringify(result, null, 2));
+    console.log();
+  } catch (error) {
+    spinner.fail('Tool call failed');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}

package/src/config.ts

@@ -0,0 +1,78 @@
+import Conf from 'conf';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface PdAuthConfig {
+  clientId: string;
+  clientSecret: string;
+  projectId: string;
+  environment: 'development' | 'production';
+}
+
+export interface UserMapping {
+  [externalUserId: string]: {
+    label?: string;
+    createdAt: string;
+  };
+}
+
+const schema = {
+  clientId: { type: 'string' as const, default: '' },
+  clientSecret: { type: 'string' as const, default: '' },
+  projectId: { type: 'string' as const, default: '' },
+  environment: { type: 'string' as const, default: 'development' },
+  defaultUser: { type: 'string' as const, default: 'default' },
+  users: { type: 'object' as const, default: {} },
+};
+
+const config = new Conf({
+  projectName: 'pdauth',
+  cwd: join(homedir(), '.config', 'pdauth'),
+  schema,
+});
+
+export function getConfig(): PdAuthConfig {
+  return {
+    clientId: config.get('clientId') as string,
+    clientSecret: config.get('clientSecret') as string,
+    projectId: config.get('projectId') as string,
+    environment: config.get('environment') as 'development' | 'production',
+  };
+}
+
+export function setConfig(values: Partial<PdAuthConfig>): void {
+  if (values.clientId !== undefined) config.set('clientId', values.clientId);
+  if (values.clientSecret !== undefined) config.set('clientSecret', values.clientSecret);
+  if (values.projectId !== undefined) config.set('projectId', values.projectId);
+  if (values.environment !== undefined) config.set('environment', values.environment);
+}
+
+export function isConfigured(): boolean {
+  const cfg = getConfig();
+  return !!(cfg.clientId && cfg.clientSecret && cfg.projectId);
+}
+
+export function getDefaultUser(): string {
+  return config.get('defaultUser') as string;
+}
+
+export function setDefaultUser(userId: string): void {
+  config.set('defaultUser', userId);
+  addUser(userId);
+}
+
+export function getUsers(): UserMapping {
+  return config.get('users') as UserMapping;
+}
+
+export function addUser(userId: string, label?: string): void {
+  const users = getUsers();
+  if (!users[userId]) {
+    users[userId] = { createdAt: new Date().toISOString(), label };
+    config.set('users', users);
+  }
+}
+
+export function getConfigPath(): string {
+  return config.path;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+// pdauth - Pipedream OAuth CLI
+// Programmatic API for library usage
+
+export * from './config.js';
+export * from './pipedream.js';
+export * from './commands/index.js';

package/src/pipedream.ts

@@ -0,0 +1,216 @@
+import { PipedreamClient } from '@pipedream/sdk';
+import { getConfig, isConfigured } from './config.js';
+
+let _client: PipedreamClient | null = null;
+
+export function getClient(): PipedreamClient {
+  if (!isConfigured()) {
+    throw new Error('Pipedream not configured. Run: pdauth config');
+  }
+
+  if (!_client) {
+    const config = getConfig();
+    _client = new PipedreamClient({
+      projectEnvironment: config.environment,
+      clientId: config.clientId,
+      clientSecret: config.clientSecret,
+      projectId: config.projectId,
+    });
+  }
+  return _client;
+}
+
+export function resetClient(): void {
+  _client = null;
+}
+
+export interface ConnectLinkResult {
+  token: string;
+  expiresAt: string;
+  connectLinkUrl: string;
+}
+
+export async function createConnectLink(
+  externalUserId: string,
+  appSlug: string
+): Promise<ConnectLinkResult> {
+  const client = getClient();
+  
+  const response = await client.tokens.create({
+    externalUserId,
+  });
+
+  const expiresAt =
+    typeof response.expiresAt === 'string'
+      ? response.expiresAt
+      : response.expiresAt
+        ? new Date(response.expiresAt).toISOString()
+        : new Date(Date.now() + 3600000).toISOString();
+
+  // Build connect link URL with app parameter
+  const baseUrl = response.connectLinkUrl || 'https://connect.pipedream.com';
+  const separator = baseUrl.includes('?') ? '&' : '?';
+  const connectLinkUrl = `${baseUrl}${separator}app=${encodeURIComponent(appSlug)}&connectLink=true`;
+
+  return {
+    token: response.token ?? '',
+    expiresAt,
+    connectLinkUrl,
+  };
+}
+
+export interface PipedreamAccount {
+  id: string;
+  name: string;
+  externalId?: string;
+  healthy: boolean;
+  dead: boolean;
+  app: {
+    id: string;
+    nameSlug: string;
+    name: string;
+    imgSrc?: string;
+  };
+  createdAt: string;
+  updatedAt: string;
+}
+
+export async function listAccounts(externalUserId: string): Promise<PipedreamAccount[]> {
+  const client = getClient();
+  const response = await client.accounts.list({ externalUserId });
+  return (response.data ?? []) as unknown as PipedreamAccount[];
+}
+
+export async function deleteAccount(accountId: string): Promise<boolean> {
+  const client = getClient();
+  try {
+    await client.accounts.delete(accountId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface PipedreamApp {
+  id: string;
+  nameSlug: string;
+  name: string;
+  authType: string;
+  description: string;
+  imgSrc: string;
+  categories: string[];
+}
+
+export async function searchApps(query?: string): Promise<PipedreamApp[]> {
+  const client = getClient();
+  const response = await client.apps.list(query ? { q: query } : {});
+  return (response.data ?? []) as unknown as PipedreamApp[];
+}
+
+export async function getApp(nameSlug: string): Promise<PipedreamApp | null> {
+  const apps = await searchApps(nameSlug);
+  return apps.find(app => app.nameSlug === nameSlug) || null;
+}
+
+export async function getAccessToken(): Promise<string> {
+  const client = getClient();
+  return client.rawAccessToken;
+}
+
+export function getMcpServerUrl(): string {
+  return 'https://remote.mcp.pipedream.net';
+}
+
+export async function getMcpHeaders(externalUserId: string, appSlug?: string): Promise<Record<string, string>> {
+  const accessToken = await getAccessToken();
+  const config = getConfig();
+  
+  const headers: Record<string, string> = {
+    'Authorization': `Bearer ${accessToken}`,
+    'x-pd-project-id': config.projectId,
+    'x-pd-environment': config.environment,
+    'x-pd-external-user-id': externalUserId,
+  };
+  
+  if (appSlug) {
+    headers['x-pd-app-slug'] = appSlug;
+  }
+  
+  return headers;
+}
+
+export interface McpTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+export async function listMcpTools(externalUserId: string, appSlug: string): Promise<McpTool[]> {
+  const headers = await getMcpHeaders(externalUserId, appSlug);
+  
+  const response = await fetch(getMcpServerUrl(), {
+    method: 'POST',
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      method: 'tools/list',
+      id: Date.now(),
+    }),
+  });
+
+  const text = await response.text();
+  // Parse SSE format: "event: message\ndata: {...}"
+  const dataMatch = text.match(/^data: (.+)$/m);
+  if (!dataMatch) {
+    throw new Error('Invalid MCP response');
+  }
+  const data = JSON.parse(dataMatch[1]) as { result?: { tools?: McpTool[] } };
+  return data.result?.tools ?? [];
+}
+
+export async function invokeMcpTool(
+  externalUserId: string,
+  appSlug: string,
+  toolName: string,
+  args: Record<string, unknown>
+): Promise<unknown> {
+  const headers = await getMcpHeaders(externalUserId, appSlug);
+  
+  const response = await fetch(getMcpServerUrl(), {
+    method: 'POST',
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      method: 'tools/call',
+      params: {
+        name: toolName,
+        arguments: args,
+      },
+      id: Date.now(),
+    }),
+  });
+
+  const text = await response.text();
+  // Parse SSE format: "event: message\ndata: {...}"
+  const dataMatch = text.match(/^data: (.+)$/m);
+  if (!dataMatch) {
+    throw new Error(`Invalid MCP response: ${text.slice(0, 200)}`);
+  }
+  const data = JSON.parse(dataMatch[1]) as { result?: unknown; error?: unknown };
+  if (data.error) {
+    throw new Error(JSON.stringify(data.error));
+  }
+  return data.result;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}