@artyfacts/claude 1.3.8 → 1.3.10

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.8",
+  "version": "1.3.10",
   "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
@@ -305,13 +306,21 @@ async function checkAndClaimTasks(
         });
 
         if (result.success) {
-          await completeTask({
-            baseUrl,
-            apiKey,
-            taskId: taskUuid,  // Use UUID instead of section_id
-            output: result.output,
-            summary: result.summary,
-          });
+          try {
+            await completeTask({
+              baseUrl,
+              apiKey,
+              taskId: taskUuid,  // Use UUID instead of section_id
+              output: result.output,
+              summary: result.summary,
+            });
+          } catch (err) {
+            // Ignore "already complete" - means Claude completed it via MCP
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (!errMsg.includes('already complete')) {
+              throw err;
+            }
+          }
           console.log(`  → ✅ Completed! ${result.summary}`);
         } else {
           console.log(`  → ❌ Failed: ${result.error}`);
@@ -423,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('   ⚠️  Restart Claude Desktop to use the new MCP server');
+    },
+    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;
@@ -460,14 +488,22 @@ async function runAgent(options: {
       const result = await executor!.execute(taskContext);
 
       if (result.success) {
-        // Complete task via API
-        await completeTask({
-          baseUrl: options.baseUrl,
-          apiKey: credentials.apiKey,
-          taskId: task.taskId,
-          output: result.output,
-          summary: result.summary,
-        });
+        // Complete task via API (Claude may have already done this via MCP tool)
+        try {
+          await completeTask({
+            baseUrl: options.baseUrl,
+            apiKey: credentials.apiKey,
+            taskId: task.taskId,
+            output: result.output,
+            summary: result.summary,
+          });
+        } catch (err) {
+          // Ignore "already complete" - means Claude completed it via MCP
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (!errMsg.includes('already complete')) {
+            throw err;
+          }
+        }
 
         console.log(`  → ✅ Completed! ${result.summary}`);
       } else {
@@ -491,9 +527,19 @@ async function runAgent(options: {
   // Start listening
   listener.connect();
 
+  // Poll for tasks periodically (every 30 seconds) as a backup to SSE
+  // This catches tasks that were created before we connected or if SSE events are missed
+  const POLL_INTERVAL_MS = 30_000;
+  const pollInterval = setInterval(() => {
+    if (!options.dryRun) {
+      checkAndClaimTasks(options.baseUrl, credentials.apiKey, credentials.agentId, activeTasks, executor!, options.dryRun);
+    }
+  }, POLL_INTERVAL_MS);
+
   // Handle shutdown
   const shutdown = () => {
     console.log('\n👋 Disconnecting...');
+    clearInterval(pollInterval);
     listener.disconnect();
     process.exit(0);
   };

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;
 
 // ============================================================================