@artyfacts/claude 1.3.9 → 1.3.11

package/dist/index.js

@@ -34,6 +34,7 @@ __export(index_exports, {
   ClaudeExecutor: () => ClaudeExecutor,
   ClaudeExecutorWithTools: () => ClaudeExecutorWithTools,
   ContextFetcher: () => ContextFetcher,
+  McpHandler: () => McpHandler,
   buildPromptWithContext: () => buildPromptWithContext,
   clearCredentials: () => clearCredentials,
   createApiClient: () => createApiClient,
@@ -41,6 +42,7 @@ __export(index_exports, {
   createExecutor: () => createExecutor,
   createExecutorWithTools: () => createExecutorWithTools,
   createListener: () => createListener,
+  createMcpHandler: () => createMcpHandler,
   executeTool: () => executeTool,
   getAllToolSchemas: () => getAllToolSchemas,
   getCredentials: () => getCredentials,
@@ -651,7 +653,9 @@ var EVENT_TYPES = [
   "task_assigned",
   "task_unblocked",
   "blocker_resolved",
-  "notification"
+  "notification",
+  "mcp_connect_request",
+  "connection_status"
 ];
 var ArtyfactsListener = class {
   config;
@@ -6010,12 +6014,201 @@ ${DEFAULT_SYSTEM_PROMPT2}` : DEFAULT_SYSTEM_PROMPT2;
 function createExecutorWithTools(config) {
   return new ClaudeExecutorWithTools(config);
 }
+
+// src/mcp.ts
+var import_child_process2 = require("child_process");
+var DEFAULT_BASE_URL3 = "https://artyfacts.dev/api/v1";
+var OAUTH_MCP_SERVERS = {
+  supabase: {
+    url: "https://mcp.supabase.com/mcp",
+    name: "supabase"
+  },
+  figma: {
+    url: "https://mcp.figma.com/mcp",
+    name: "figma"
+  }
+};
+var CREDENTIAL_MCP_CONFIGS = {
+  postgres: (config) => ({
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-postgres", config.connection_string]
+  }),
+  github: (config) => ({
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github"],
+    env: {
+      GITHUB_PERSONAL_ACCESS_TOKEN: config.api_key
+    }
+  }),
+  filesystem: (config) => ({
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", ...config.paths || []]
+  })
+};
+function addMcpServer(options) {
+  const { name, transport, url, command, args = [], env = {}, scope = "user" } = options;
+  const cliArgs = ["mcp", "add", "-s", scope, "-t", transport];
+  for (const [key, value] of Object.entries(env)) {
+    cliArgs.push("-e", `${key}=${value}`);
+  }
+  cliArgs.push(name);
+  if (transport === "http" && url) {
+    cliArgs.push(url);
+  } else if (transport === "stdio" && command) {
+    cliArgs.push("--", command, ...args);
+  } else {
+    return { success: false, error: "Invalid configuration: missing url or command" };
+  }
+  console.log(`[MCP] Running: claude ${cliArgs.join(" ")}`);
+  const result = (0, import_child_process2.spawnSync)("claude", cliArgs, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status === 0) {
+    return { success: true };
+  } else {
+    return {
+      success: false,
+      error: result.stderr || result.stdout || `Exit code ${result.status}`
+    };
+  }
+}
+var McpHandler = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl || DEFAULT_BASE_URL3
+    };
+  }
+  /**
+   * Handle an MCP connect request event
+   * Uses `claude mcp add` to configure the server dynamically
+   */
+  async handleConnectRequest(event) {
+    const { connection_id, platform, config: mcpConfig } = event.data;
+    try {
+      const serverName = mcpConfig?.server_name || platform;
+      const oauthServer = OAUTH_MCP_SERVERS[platform];
+      if (oauthServer) {
+        const result = addMcpServer({
+          name: serverName,
+          transport: "http",
+          url: oauthServer.url
+        });
+        if (!result.success) {
+          throw new Error(`Failed to add ${platform} MCP: ${result.error}`);
+        }
+        console.log(`[MCP] Added ${serverName} \u2192 ${oauthServer.url}`);
+        console.log(`[MCP] OAuth will prompt when you use ${platform} tools`);
+      } else {
+        const configBuilder = CREDENTIAL_MCP_CONFIGS[platform];
+        if (!configBuilder) {
+          throw new Error(`Unsupported MCP platform: ${platform}. Supported: ${[...Object.keys(OAUTH_MCP_SERVERS), ...Object.keys(CREDENTIAL_MCP_CONFIGS)].join(", ")}`);
+        }
+        if (!mcpConfig) {
+          throw new Error(`Platform ${platform} requires configuration (connection_string or api_key)`);
+        }
+        const serverConfig = configBuilder(mcpConfig);
+        const result = addMcpServer({
+          name: serverName,
+          transport: "stdio",
+          command: serverConfig.command,
+          args: serverConfig.args,
+          env: serverConfig.env
+        });
+        if (!result.success) {
+          throw new Error(`Failed to add ${platform} MCP: ${result.error}`);
+        }
+        console.log(`[MCP] Added ${serverName} for ${platform}`);
+      }
+      await this.updateConnectionStatus(connection_id, {
+        status: "active",
+        mcp_configured: true
+      });
+      this.config.onConfigured?.(connection_id, platform);
+    } catch (err) {
+      console.error(`[MCP] Failed to configure ${platform}:`, err);
+      await this.updateConnectionStatus(connection_id, {
+        status: "error",
+        mcp_configured: false,
+        error_message: err.message
+      });
+      this.config.onError?.(err, connection_id);
+    }
+  }
+  /**
+   * Check if a platform supports OAuth (no credentials needed)
+   */
+  static supportsOAuth(platform) {
+    return platform in OAUTH_MCP_SERVERS;
+  }
+  /**
+   * Get list of platforms with OAuth support
+   */
+  static getOAuthPlatforms() {
+    return Object.keys(OAUTH_MCP_SERVERS);
+  }
+  /**
+   * Update connection status in Artyfacts
+   */
+  async updateConnectionStatus(connectionId, update) {
+    try {
+      const response = await fetch(`${this.config.baseUrl}/connections/${connectionId}`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(update)
+      });
+      if (!response.ok) {
+        console.error(`[MCP] Failed to update connection status: ${response.status}`);
+      }
+    } catch (err) {
+      console.error("[MCP] Failed to update connection status:", err);
+    }
+  }
+  /**
+   * List configured MCP servers using `claude mcp list`
+   */
+  listServers() {
+    const result = (0, import_child_process2.spawnSync)("claude", ["mcp", "list"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim().split("\n").filter(Boolean);
+    }
+    return [];
+  }
+  /**
+   * Remove an MCP server using `claude mcp remove`
+   */
+  removeServer(serverName) {
+    const result = (0, import_child_process2.spawnSync)("claude", ["mcp", "remove", serverName], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status === 0) {
+      console.log(`[MCP] Removed server: ${serverName}`);
+      return true;
+    } else {
+      console.error(`[MCP] Failed to remove ${serverName}: ${result.stderr || result.stdout}`);
+      return false;
+    }
+  }
+};
+function createMcpHandler(config) {
+  return new McpHandler(config);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArtyfactsListener,
   ClaudeExecutor,
   ClaudeExecutorWithTools,
   ContextFetcher,
+  McpHandler,
   buildPromptWithContext,
   clearCredentials,
   createApiClient,
@@ -6023,6 +6216,7 @@ function createExecutorWithTools(config) {
   createExecutor,
   createExecutorWithTools,
   createListener,
+  createMcpHandler,
   executeTool,
   getAllToolSchemas,
   getCredentials,

package/dist/index.mjs

@@ -2,17 +2,19 @@ import {
   ArtyfactsListener,
   ClaudeExecutor,
   ContextFetcher,
+  McpHandler,
   buildPromptWithContext,
   clearCredentials,
   createContextFetcher,
   createExecutor,
   createListener,
+  createMcpHandler,
   getCredentials,
   loadCredentials,
   promptForApiKey,
   runDeviceAuth,
   saveCredentials
-} from "./chunk-G6HSQFKJ.mjs";
+} from "./chunk-VGAUMCRW.mjs";
 
 // node_modules/@anthropic-ai/sdk/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
@@ -5179,6 +5181,7 @@ export {
   ClaudeExecutor,
   ClaudeExecutorWithTools,
   ContextFetcher,
+  McpHandler,
   buildPromptWithContext,
   clearCredentials,
   createApiClient,
@@ -5186,6 +5189,7 @@ export {
   createExecutor,
   createExecutorWithTools,
   createListener,
+  createMcpHandler,
   executeTool,
   getAllToolSchemas,
   getCredentials,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artyfacts/claude",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "description": "Claude adapter for Artyfacts - Execute tasks using Claude Code CLI",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/cli.ts

@@ -13,7 +13,8 @@ import { Command } from 'commander';
 import { execSync, spawnSync } from 'child_process';
 import { getCredentials, clearCredentials, loadCredentials, promptForApiKey } from './auth';
 import { ClaudeExecutor, createExecutor, TaskContext } from './executor';
-import { ArtyfactsListener, createListener, TaskAssignedEvent } from './listener';
+import { ArtyfactsListener, createListener, TaskAssignedEvent, McpConnectRequestEvent } from './listener';
+import { McpHandler, createMcpHandler } from './mcp';
 
 // ============================================================================
 // Constants
@@ -431,6 +432,25 @@ async function runAgent(options: {
   // Track active tasks to prevent duplicate processing
   const activeTasks = new Set<string>();
 
+  // Create MCP handler for connection requests
+  const mcpHandler = createMcpHandler({
+    apiKey: credentials.apiKey,
+    baseUrl: options.baseUrl,
+    onConfigured: (connectionId, platform) => {
+      console.log(`\n🔧 [MCP] Configured ${platform} connection: ${connectionId}`);
+      console.log('   💡 Try using the tools now - OAuth will prompt when needed');
+    },
+    onError: (error, connectionId) => {
+      console.error(`\n❌ [MCP] Failed to configure connection ${connectionId}:`, error.message);
+    },
+  });
+
+  // Handle MCP connection requests
+  listener.on<McpConnectRequestEvent>('mcp_connect_request', async (event) => {
+    console.log(`\n🔗 [MCP] Connection request for ${event.data.platform}`);
+    await mcpHandler.handleConnectRequest(event);
+  });
+
   // Handle task assignments
   listener.on<TaskAssignedEvent>('task_assigned', async (event) => {
     const task = event.data;

package/src/index.ts

@@ -73,6 +73,7 @@ export type {
   TaskAssignedEvent,
   HeartbeatEvent,
   ConnectedEvent,
+  McpConnectRequestEvent,
   ArtyfactsEvent,
   EventCallback,
   ListenerConfig,
@@ -135,3 +136,16 @@ export type {
   ToolCall,
   ToolCallResult,
 } from './tools';
+
+// MCP Handler - Types
+export type {
+  McpServerConfig,
+  ClaudeSettingsJson,
+  McpHandlerConfig,
+} from './mcp';
+
+// MCP Handler - Classes
+export {
+  McpHandler,
+  createMcpHandler,
+} from './mcp';

package/src/listener.ts

@@ -27,6 +27,21 @@ export interface TaskAssignedEvent {
   };
 }
 
+export interface McpConnectRequestEvent {
+  type: 'mcp_connect_request';
+  timestamp: string;
+  data: {
+    connection_id: string;
+    platform: string;
+    config: {
+      server_name?: string;
+      connection_string?: string;
+      api_key?: string;
+      [key: string]: unknown;
+    };
+  };
+}
+
 export interface HeartbeatEvent {
   type: 'heartbeat';
   timestamp: string;
@@ -40,7 +55,7 @@ export interface ConnectedEvent {
   };
 }
 
-export type ArtyfactsEvent = TaskAssignedEvent | HeartbeatEvent | ConnectedEvent | {
+export type ArtyfactsEvent = TaskAssignedEvent | HeartbeatEvent | ConnectedEvent | McpConnectRequestEvent | {
   type: string;
   timestamp: string;
   data?: Record<string, unknown>;
@@ -77,6 +92,8 @@ const EVENT_TYPES = [
   'task_unblocked',
   'blocker_resolved',
   'notification',
+  'mcp_connect_request',
+  'connection_status',
 ] as const;
 
 // ============================================================================

package/src/mcp.ts

@@ -0,0 +1,314 @@
+/**
+ * MCP Connection Handler
+ * 
+ * Handles mcp_connect_request events from Artyfacts and configures
+ * MCP servers for the Claude adapter using `claude mcp add`.
+ * 
+ * @module mcp
+ */
+
+import { spawnSync } from 'child_process';
+import { McpConnectRequestEvent } from './listener';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface ClaudeSettingsJson {
+  mcpServers?: Record<string, McpServerConfig>;
+}
+
+export interface McpHandlerConfig {
+  /** Artyfacts API key for status updates */
+  apiKey: string;
+  /** Base URL for Artyfacts API */
+  baseUrl?: string;
+  /** Callback when MCP server is configured */
+  onConfigured?: (connectionId: string, platform: string) => void;
+  /** Callback on error */
+  onError?: (error: Error, connectionId: string) => void;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const DEFAULT_BASE_URL = 'https://artyfacts.dev/api/v1';
+
+// ============================================================================
+// MCP Server Configurations
+// ============================================================================
+
+/**
+ * URL-based MCP servers with built-in OAuth
+ * These open a browser for authentication automatically - no credentials needed!
+ * Uses `claude mcp add --transport http <name> <url>`
+ */
+const OAUTH_MCP_SERVERS: Record<string, { url: string; name: string }> = {
+  supabase: {
+    url: 'https://mcp.supabase.com/mcp',
+    name: 'supabase',
+  },
+  figma: {
+    url: 'https://mcp.figma.com/mcp',
+    name: 'figma',
+  },
+};
+
+/**
+ * Command-based MCP servers that need credentials
+ * Uses `claude mcp add <name> -- <command> <args...>`
+ */
+const CREDENTIAL_MCP_CONFIGS: Record<string, (config: Record<string, unknown>) => { 
+  command: string; 
+  args: string[];
+  env?: Record<string, string>;
+}> = {
+  postgres: (config) => ({
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-postgres', config.connection_string as string],
+  }),
+  github: (config) => ({
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-github'],
+    env: {
+      GITHUB_PERSONAL_ACCESS_TOKEN: config.api_key as string,
+    },
+  }),
+  filesystem: (config) => ({
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem', ...(config.paths as string[] || [])],
+  }),
+};
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Add an MCP server using `claude mcp add`
+ */
+function addMcpServer(options: {
+  name: string;
+  transport: 'http' | 'stdio';
+  url?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  scope?: 'local' | 'user' | 'project';
+}): { success: boolean; error?: string } {
+  const { name, transport, url, command, args = [], env = {}, scope = 'user' } = options;
+  
+  const cliArgs = ['mcp', 'add', '-s', scope, '-t', transport];
+  
+  // Add environment variables
+  for (const [key, value] of Object.entries(env)) {
+    cliArgs.push('-e', `${key}=${value}`);
+  }
+  
+  // Add name
+  cliArgs.push(name);
+  
+  if (transport === 'http' && url) {
+    // HTTP transport: claude mcp add -t http <name> <url>
+    cliArgs.push(url);
+  } else if (transport === 'stdio' && command) {
+    // Stdio transport: claude mcp add <name> -- <command> <args...>
+    cliArgs.push('--', command, ...args);
+  } else {
+    return { success: false, error: 'Invalid configuration: missing url or command' };
+  }
+  
+  console.log(`[MCP] Running: claude ${cliArgs.join(' ')}`);
+  
+  const result = spawnSync('claude', cliArgs, {
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  
+  if (result.status === 0) {
+    return { success: true };
+  } else {
+    return { 
+      success: false, 
+      error: result.stderr || result.stdout || `Exit code ${result.status}`,
+    };
+  }
+}
+
+// ============================================================================
+// McpHandler Class
+// ============================================================================
+
+export class McpHandler {
+  private config: Required<Pick<McpHandlerConfig, 'apiKey' | 'baseUrl'>> & McpHandlerConfig;
+
+  constructor(config: McpHandlerConfig) {
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+    };
+  }
+
+  /**
+   * Handle an MCP connect request event
+   * Uses `claude mcp add` to configure the server dynamically
+   */
+  async handleConnectRequest(event: McpConnectRequestEvent): Promise<void> {
+    const { connection_id, platform, config: mcpConfig } = event.data;
+
+    try {
+      const serverName = mcpConfig?.server_name || platform;
+
+      // Check if this is an OAuth-based server (no credentials needed!)
+      const oauthServer = OAUTH_MCP_SERVERS[platform];
+      if (oauthServer) {
+        // URL-based MCP server with built-in OAuth
+        const result = addMcpServer({
+          name: serverName,
+          transport: 'http',
+          url: oauthServer.url,
+        });
+        
+        if (!result.success) {
+          throw new Error(`Failed to add ${platform} MCP: ${result.error}`);
+        }
+        
+        console.log(`[MCP] Added ${serverName} → ${oauthServer.url}`);
+        console.log(`[MCP] OAuth will prompt when you use ${platform} tools`);
+      } else {
+        // Command-based MCP server - needs credentials
+        const configBuilder = CREDENTIAL_MCP_CONFIGS[platform];
+        if (!configBuilder) {
+          throw new Error(`Unsupported MCP platform: ${platform}. Supported: ${[...Object.keys(OAUTH_MCP_SERVERS), ...Object.keys(CREDENTIAL_MCP_CONFIGS)].join(', ')}`);
+        }
+        
+        if (!mcpConfig) {
+          throw new Error(`Platform ${platform} requires configuration (connection_string or api_key)`);
+        }
+
+        const serverConfig = configBuilder(mcpConfig);
+        const result = addMcpServer({
+          name: serverName,
+          transport: 'stdio',
+          command: serverConfig.command,
+          args: serverConfig.args,
+          env: serverConfig.env,
+        });
+        
+        if (!result.success) {
+          throw new Error(`Failed to add ${platform} MCP: ${result.error}`);
+        }
+        
+        console.log(`[MCP] Added ${serverName} for ${platform}`);
+      }
+
+      // Update connection status in Artyfacts
+      await this.updateConnectionStatus(connection_id, {
+        status: 'active',
+        mcp_configured: true,
+      });
+
+      // Callback
+      this.config.onConfigured?.(connection_id, platform);
+
+    } catch (err) {
+      console.error(`[MCP] Failed to configure ${platform}:`, err);
+      
+      // Update connection with error status
+      await this.updateConnectionStatus(connection_id, {
+        status: 'error',
+        mcp_configured: false,
+        error_message: (err as Error).message,
+      });
+
+      this.config.onError?.(err as Error, connection_id);
+    }
+  }
+  
+  /**
+   * Check if a platform supports OAuth (no credentials needed)
+   */
+  static supportsOAuth(platform: string): boolean {
+    return platform in OAUTH_MCP_SERVERS;
+  }
+  
+  /**
+   * Get list of platforms with OAuth support
+   */
+  static getOAuthPlatforms(): string[] {
+    return Object.keys(OAUTH_MCP_SERVERS);
+  }
+
+  /**
+   * Update connection status in Artyfacts
+   */
+  private async updateConnectionStatus(
+    connectionId: string,
+    update: { status: string; mcp_configured: boolean; error_message?: string }
+  ): Promise<void> {
+    try {
+      const response = await fetch(`${this.config.baseUrl}/connections/${connectionId}`, {
+        method: 'PATCH',
+        headers: {
+          'Authorization': `Bearer ${this.config.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(update),
+      });
+
+      if (!response.ok) {
+        console.error(`[MCP] Failed to update connection status: ${response.status}`);
+      }
+    } catch (err) {
+      console.error('[MCP] Failed to update connection status:', err);
+    }
+  }
+
+  /**
+   * List configured MCP servers using `claude mcp list`
+   */
+  listServers(): string[] {
+    const result = spawnSync('claude', ['mcp', 'list'], {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    
+    if (result.status === 0 && result.stdout) {
+      // Parse output - each line is a server name
+      return result.stdout.trim().split('\n').filter(Boolean);
+    }
+    return [];
+  }
+
+  /**
+   * Remove an MCP server using `claude mcp remove`
+   */
+  removeServer(serverName: string): boolean {
+    const result = spawnSync('claude', ['mcp', 'remove', serverName], {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    
+    if (result.status === 0) {
+      console.log(`[MCP] Removed server: ${serverName}`);
+      return true;
+    } else {
+      console.error(`[MCP] Failed to remove ${serverName}: ${result.stderr || result.stdout}`);
+      return false;
+    }
+  }
+}
+
+/**
+ * Create an MCP handler instance
+ */
+export function createMcpHandler(config: McpHandlerConfig): McpHandler {
+  return new McpHandler(config);
+}