@hailer/mcp 0.2.7 → 1.0.21

package/dist/mcp/tools/workflow.js

@@ -388,7 +388,7 @@ const installWorkflowSchema = zod_1.z.object({
             ]).describe("Field type"),
             key: zod_1.z.string().optional().describe("Readable field name (like SQL column name) - RECOMMENDED"),
             required: zod_1.z.boolean().optional().describe("Whether field is required"),
-            data: zod_1.z.array(zod_1.z.string()).optional().describe("For textpredefinedoptions: string array like [\"Low\", \"Medium\", \"High\"]. For activitylink: target workflow IDs"),
+            data: zod_1.z.array(zod_1.z.string()).optional().describe("For textpredefinedoptions: string array like [\"Low\", \"Medium\", \"High\"]. For activitylink: target workflow IDs. NOTE: 'options' also accepted, will be converted to 'data'"),
             placeholder: zod_1.z.string().optional().describe("Placeholder text"),
             unit: zod_1.z.string().optional().describe("Unit for numeric/textunit fields"),
             description: zod_1.z.string().optional().describe("Field description"),
@@ -441,14 +441,61 @@ exports.installWorkflowTool = {
                         }],
                 };
             }
+            // Transform templates: fix common LLM mistakes
+            const transformedTemplates = args.workflowTemplates.map((template) => {
+                let result = { ...template };
+                // Transform fields
+                if (template.fields) {
+                    const transformedFields = {};
+                    for (const [fieldId, field] of Object.entries(template.fields)) {
+                        const f = { ...field };
+                        // Convert options/predefinedOptions/selectOptions → data
+                        if (!f.data) {
+                            if (f.options) {
+                                f.data = f.options;
+                                delete f.options;
+                            }
+                            else if (f.predefinedOptions) {
+                                f.data = f.predefinedOptions;
+                                delete f.predefinedOptions;
+                            }
+                            else if (f.selectOptions) {
+                                // Handle both array and object selectOptions
+                                f.data = Array.isArray(f.selectOptions)
+                                    ? f.selectOptions.map((o) => o.label || o.value || o)
+                                    : Object.values(f.selectOptions);
+                                delete f.selectOptions;
+                            }
+                        }
+                        // Remove disallowed properties
+                        delete f.name; // Only 'label' is allowed
+                        delete f.sequence; // Not supported
+                        delete f.order; // Not supported
+                        transformedFields[fieldId] = f;
+                    }
+                    result.fields = transformedFields;
+                }
+                // Transform phases - remove sequence/order
+                if (template.phases) {
+                    const transformedPhases = {};
+                    for (const [phaseId, phase] of Object.entries(template.phases)) {
+                        const p = { ...phase };
+                        delete p.sequence;
+                        delete p.order;
+                        transformedPhases[phaseId] = p;
+                    }
+                    result.phases = transformedPhases;
+                }
+                return result;
+            });
             logger.debug('Calling v3.workflow.install', {
                 workspaceId,
-                templatesCount: args.workflowTemplates.length
+                templatesCount: transformedTemplates.length
             });
             // Call v3.workflow.install endpoint
             const result = await context.hailer.request('v3.workflow.install', [
                 workspaceId,
-                args.workflowTemplates
+                transformedTemplates
             ]);
             logger.debug('Workflow installation successful', { result });
             // Refresh context.init.processes cache so new workflows are immediately available
@@ -465,46 +512,68 @@ exports.installWorkflowTool = {
                 logger.warn('Failed to refresh workflow cache after installation', { error: refreshError });
                 // Non-fatal - the workflow was created, just cache is stale
             }
-            // Build success response
-            let responseText = `✅ **Workflow Installation Successful**\n\n`;
-            responseText += `**Workspace:** ${workspaceId}\n`;
-            responseText += `**Workflows Installed:** ${args.workflowTemplates.length}\n\n`;
-            // Show workflow names and their real IDs
-            const templates = args.workflowTemplates;
-            const workflowMappings = templates
-                .filter((wf) => wf._id)
-                .map((wf) => `- ${wf.name}: \`${result[wf._id]}\` (from workflow _id \`${wf._id}\`)`)
-                .join('\n');
-            if (workflowMappings) {
-                responseText += `**Created Workflows:**\n${workflowMappings}\n\n`;
+            // Build success response - clearly separate workflow/field/phase IDs
+            const templates = transformedTemplates;
+            // Extract workflow ID (the one that starts with workflow template ID or is for the workflow)
+            // The result maps template IDs to real IDs
+            const workflowIds = [];
+            const fieldIds = {};
+            const phaseIds = {};
+            for (const [templateId, realId] of Object.entries(result)) {
+                if (templateId.startsWith('_0') || templateId.startsWith('_00')) {
+                    // Workflow ID (_0001, _0002, etc.)
+                    workflowIds.push(realId);
+                }
+                else if (templateId.startsWith('_1')) {
+                    // Field ID (_1000, _1001, etc.)
+                    fieldIds[templateId] = realId;
+                }
+                else if (templateId.startsWith('_2')) {
+                    // Phase ID (_2000, _2001, etc.)
+                    phaseIds[templateId] = realId;
+                }
+                else {
+                    // Fallback - assume workflow ID if no underscore pattern
+                    workflowIds.push(realId);
+                }
             }
-            responseText += `**Complete ID Mapping (template_id → real_id):**\n`;
-            responseText += `\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`\n\n`;
-            responseText += `💡 **Next Steps:**\n`;
-            responseText += `- Use \`list_workflows\` to see the new workflows in context\n`;
-            responseText += `- Use \`create_activity\` with the real workflow IDs to create activities\n`;
-            responseText += `- Field IDs from mapping are used when setting activity field values\n\n`;
-            responseText += `**Example Activity Creation:**\n`;
-            responseText += `\`\`\`javascript\n`;
-            if (templates[0]?._id) {
-                const firstTemplate = templates[0];
-                const workflowId = result[firstTemplate._id];
-                const firstFieldId = Object.keys(firstTemplate.fields || {})[0];
-                const realFieldId = firstFieldId ? result[firstFieldId] : 'field_id';
-                responseText += `// Using workflow: ${firstTemplate.name}\n`;
-                responseText += `create_activity({\n`;
-                responseText += `  workflowId: "${workflowId}",\n`;
-                responseText += `  name: "New Activity",\n`;
-                responseText += `  fields: { "${realFieldId}": "value" }\n`;
-                responseText += `});\n`;
+            let responseText = `✅ **Workflow "${templates[0]?.name || 'Unknown'}" Created**\n\n`;
+            // MOST IMPORTANT - Workflow ID for create_activity
+            responseText += `**🎯 WORKFLOW ID (use this for create_activity):**\n`;
+            responseText += `\`${workflowIds[0] || 'check list_workflows'}\`\n\n`;
+            // Field IDs
+            if (Object.keys(fieldIds).length > 0) {
+                responseText += `**📋 Field IDs:**\n`;
+                for (const [tpl, real] of Object.entries(fieldIds)) {
+                    const fieldDef = templates[0]?.fields?.[tpl];
+                    const label = fieldDef?.label || tpl;
+                    responseText += `- ${label}: \`${real}\`\n`;
+                }
+                responseText += `\n`;
             }
-            else {
-                responseText += `create_activity({\n`;
-                responseText += `  workflowId: result._0001,\n`;
-                responseText += `  name: "New Activity",\n`;
-                responseText += `  fields: { [result._1000]: "value" }\n`;
-                responseText += `});\n`;
+            // Phase IDs
+            if (Object.keys(phaseIds).length > 0) {
+                responseText += `**🏷️ Phase IDs:**\n`;
+                for (const [tpl, real] of Object.entries(phaseIds)) {
+                    const phaseDef = templates[0]?.phases?.[tpl];
+                    const name = phaseDef?.name || tpl;
+                    responseText += `- ${name}: \`${real}\`\n`;
+                }
+                responseText += `\n`;
             }
+            // Example
+            const firstFieldId = Object.values(fieldIds)[0];
+            const firstPhaseId = Object.values(phaseIds)[0];
+            responseText += `**Example create_activity:**\n`;
+            responseText += `\`\`\`json\n`;
+            responseText += `{\n`;
+            responseText += `  "workflowId": "${workflowIds[0] || 'WORKFLOW_ID'}",\n`;
+            responseText += `  "name": "New Activity",\n`;
+            if (firstPhaseId)
+                responseText += `  "phaseId": "${firstPhaseId}",\n`;
+            if (firstFieldId)
+                responseText += `  "fields": { "${firstFieldId}": "value" }\n`;
+            responseText += `}\n`;
             responseText += `\`\`\``;
             return {
                 content: [{

package/dist/mcp/webhook-handler.js

@@ -62,12 +62,15 @@ const WEBHOOK_SECRET_FILE = 'webhook-secret.txt';
  * Constant-time string comparison to prevent timing attacks
  */
 function timingSafeEqual(a, b) {
-    if (a.length !== b.length) {
-        // Still perform comparison to maintain constant time
-        crypto.timingSafeEqual(Buffer.from(a), Buffer.from(a));
+    const bufA = Buffer.from(a);
+    const bufB = Buffer.from(b);
+    if (bufA.length !== bufB.length) {
+        // Compare against dummy buffer of same length to maintain constant time
+        const dummy = Buffer.alloc(bufA.length);
+        crypto.timingSafeEqual(bufA, dummy);
         return false;
     }
-    return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+    return crypto.timingSafeEqual(bufA, bufB);
 }
 /**
  * Generate HMAC-SHA256 signature for webhook payload

package/dist/mcp-server.js

@@ -121,7 +121,7 @@ class MCPServerService {
                 status: 'ok',
                 timestamp: new Date().toISOString(),
                 service: 'hailer-mcp-server',
-                version: '0.1.0'
+                version: config_1.APP_VERSION
             };
             res.json(health);
         });
@@ -141,11 +141,11 @@ class MCPServerService {
                 daemons: status
             });
         });
-        // MCP Protocol endpoint - JSON-RPC 2.0 over SSE
-        this.app.post('/api/mcp', async (req, res) => {
-            req.logger.debug('MCP request received', { method: req.body?.method });
+        // MCP Protocol handler - shared by both routes
+        const mcpHandler = async (req, res, apiKeyOverride) => {
+            const apiKey = apiKeyOverride || req.query.apiKey;
+            req.logger.debug('MCP request received', { method: req.body?.method, apiKey: apiKey?.slice(0, 8) + '...' });
             try {
-                const apiKey = req.query.apiKey;
                 const mcpRequest = req.body;
                 let result;
                 if (mcpRequest.method === 'tools/list') {
@@ -225,7 +225,7 @@ class MCPServerService {
                         capabilities: { tools: {} },
                         serverInfo: {
                             name: 'hailer-mcp-server',
-                            version: '1.0.0'
+                            version: config_1.APP_VERSION
                         }
                     };
                 }
@@ -264,6 +264,22 @@ class MCPServerService {
                     this.sendMcpError(res, req.body?.id || null, -32000, `Server error: ${errorMessage}`, 500);
                 }
             }
+        };
+        // MCP Protocol endpoint - JSON-RPC 2.0 over SSE
+        // Route 1: /api/mcp?apiKey=xxx (standard format)
+        this.app.post('/api/mcp', (req, res) => mcpHandler(req, res));
+        // Route 2: /:apiKey (simplified format - API key as path)
+        // Matches 16-64 char alphanumeric keys, but ONLY for MCP requests (has jsonrpc field)
+        // Non-MCP requests (webhooks) pass through to later routes
+        this.app.post('/:apiKey([a-zA-Z0-9_-]{16,64})', (req, res, next) => {
+            if (req.body?.jsonrpc) {
+                // MCP request - handle it
+                mcpHandler(req, res, req.params.apiKey);
+            }
+            else {
+                // Not MCP (likely webhook) - pass to next route
+                next();
+            }
         });
         // ===== Bot Configuration API (only when MCP_CLIENT_ENABLED=true) =====
         if (config_1.environment.MCP_CLIENT_ENABLED) {

package/dist/stdio-server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stdio MCP Server for Claude Desktop
+ *
+ * Uses @modelcontextprotocol/sdk with StdioServerTransport for
+ * JSON-RPC communication via stdin/stdout.
+ *
+ * This is the entry point when running as Claude Desktop MCP connector.
+ */
+import { ToolRegistry } from './mcp/tool-registry';
+/**
+ * Start the stdio MCP server with all registered tools
+ */
+export declare function startStdioServer(toolRegistry: ToolRegistry): Promise<void>;
+//# sourceMappingURL=stdio-server.d.ts.map

package/dist/stdio-server.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Stdio MCP Server for Claude Desktop
+ *
+ * Uses @modelcontextprotocol/sdk with StdioServerTransport for
+ * JSON-RPC communication via stdin/stdout.
+ *
+ * This is the entry point when running as Claude Desktop MCP connector.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStdioServer = startStdioServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const logger_1 = require("./lib/logger");
+const tool_registry_1 = require("./mcp/tool-registry");
+const UserContextCache_1 = require("./mcp/UserContextCache");
+const config_1 = require("./config");
+const logger = (0, logger_1.createLogger)({ component: 'stdio-server' });
+/**
+ * Start the stdio MCP server with all registered tools
+ */
+async function startStdioServer(toolRegistry) {
+    logger.info('Starting stdio MCP server for Claude Desktop');
+    // Get API key from environment (set in Claude Desktop config)
+    const apiKey = process.env.MCP_CLIENT_API_KEY;
+    if (!apiKey) {
+        logger.error('MCP_CLIENT_API_KEY environment variable is required for stdio mode');
+        process.exit(1);
+    }
+    // Create MCP server
+    const server = new mcp_js_1.McpServer({
+        name: 'hailer-mcp-server',
+        version: '1.0.0',
+    });
+    // Get tool definitions (filtered by allowed groups, excluding NUCLEAR unless enabled)
+    const allowedGroups = config_1.environment.ENABLE_NUCLEAR_TOOLS
+        ? [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND, tool_registry_1.ToolGroup.NUCLEAR]
+        : [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND];
+    const toolDefinitions = toolRegistry.getToolDefinitions({ allowedGroups });
+    logger.info('Registering tools for stdio server', {
+        toolCount: toolDefinitions.length,
+        allowedGroups,
+    });
+    // Register each tool with the MCP server
+    for (const toolDef of toolDefinitions) {
+        server.tool(toolDef.name, toolDef.description, toolDef.inputSchema.properties ? toolDef.inputSchema : { type: 'object', properties: {} }, async (args) => {
+            const startTime = Date.now();
+            logger.debug('Tool call received', { toolName: toolDef.name, args });
+            try {
+                // Get user context (cached)
+                const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+                // Execute the tool
+                const result = await toolRegistry.executeTool(toolDef.name, args, userContext);
+                const duration = Date.now() - startTime;
+                logger.info('Tool call completed', { toolName: toolDef.name, duration });
+                // Handle different result formats
+                if (result && typeof result === 'object' && 'content' in result) {
+                    // Result is already in MCP format { content: [...] }
+                    return result;
+                }
+                // Wrap result in MCP format
+                return {
+                    content: [{
+                            type: 'text',
+                            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.error('Tool call failed', error, { toolName: toolDef.name, duration });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+        });
+    }
+    // Create stdio transport
+    const transport = new stdio_js_1.StdioServerTransport();
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        logger.info('Received SIGINT, shutting down stdio server');
+        await server.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        logger.info('Received SIGTERM, shutting down stdio server');
+        await server.close();
+        process.exit(0);
+    });
+    // Connect and start serving
+    logger.info('Connecting stdio transport');
+    await server.connect(transport);
+    logger.info('Stdio MCP server is running');
+}
+//# sourceMappingURL=stdio-server.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "0.2.7",
+  "version": "1.0.21",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"
@@ -14,11 +14,11 @@
     "build": "tsc",
     "start": "node dist/app.js",
     "lint": "eslint src/",
-    "build-dev-push": "rm -rf build/docker-dev && docker build --target artifacts --output build/docker-dev . -f Dockerfile.build-dev && docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-dev -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):dev -f ./Dockerfile.dev .",
-    "build-debug-push": "docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-debug -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):debug -f ./Dockerfile.debug .",
-    "build-prod-push": "rm -rf build/docker-prod && docker build --target artifacts --output build/docker-prod . -f Dockerfile.build-prod && docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs) -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):prod -f ./Dockerfile.prod .",
-    "build-k3d": "docker build -f Dockerfile.debug . -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs) && k3d image import $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs) -c hailer",
-    "build-k3d-dummy": "docker build --target artifacts --output build/docker-dev . -f Dockerfile.build-dev && docker build -f Dockerfile.dev . -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-dev && k3d image import $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-dev -c hailer",
+    "build-dev-push": "rm -rf build/docker-dev && docker build --target artifacts --output build/docker-dev . -f Dockerfile.build-dev && docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs)-dev -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):dev -f ./Dockerfile.dev .",
+    "build-debug-push": "docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs)-debug -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):debug -f ./Dockerfile.debug .",
+    "build-prod-push": "rm -rf build/docker-prod && docker build --target artifacts --output build/docker-prod . -f Dockerfile.build-prod && docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs) -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):prod -f ./Dockerfile.prod .",
+    "build-k3d": "docker build -f Dockerfile.debug . -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs) && k3d image import $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs) -c hailer",
+    "build-k3d-dummy": "docker build --target artifacts --output build/docker-dev . -f Dockerfile.build-dev && docker build -f Dockerfile.dev . -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs)-dev && k3d image import $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs | sed 's/@hailer\\//hailer-/'):$(npm pkg get version | xargs)-dev -c hailer",
     "mcp-server": "hailer-mcp",
     "server": "tsx src/client/server.ts",
     "server:prod": "node dist/client/server.js",

package/scripts/test-hal-tools.ts

@@ -0,0 +1,154 @@
+#!/usr/bin/env npx ts-node
+/**
+ * HAL Tools Test - Simple version
+ * Just calls each tool and shows the result. No magic.
+ */
+
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+
+dotenv.config({ path: path.join(__dirname, '..', '.env.local') });
+
+const MCP_URL = process.env.MCP_SERVER_URL || 'http://localhost:3030/api/mcp';
+
+async function call(apiKey: string, tool: string, args: Record<string, unknown> = {}) {
+  console.log(`\n>>> ${tool}`);
+  console.log(`    args: ${JSON.stringify(args)}`);
+
+  const res = await fetch(`${MCP_URL}?apiKey=${apiKey}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: '1',
+      method: 'tools/call',
+      params: { name: tool, arguments: args },
+    }),
+  });
+
+  const text = await res.text();
+  for (const line of text.split('\n')) {
+    if (line.startsWith('data: ')) {
+      const data = JSON.parse(line.substring(6));
+      if (data.error) {
+        console.log(`<<< ERROR: ${data.error.message}`);
+        return { error: true, data: null };
+      }
+      const content = data.result?.content?.[0]?.text || '';
+      // Show first 500 chars
+      console.log(`<<< ${content.substring(0, 500)}${content.length > 500 ? '...' : ''}`);
+      return { error: false, content };
+    }
+  }
+  console.log('<<< NO RESPONSE');
+  return { error: true, data: null };
+}
+
+async function main() {
+  const apiKey = process.env.MCP_CLIENT_API_KEY;
+  if (!apiKey) {
+    console.error('Set MCP_CLIENT_API_KEY in .env.local');
+    process.exit(1);
+  }
+
+  console.log('=== HAL TOOLS TEST ===\n');
+
+  // Get a workflow to work with
+  const wf = await call(apiKey, 'list_workflows_minimal', {});
+  const wfMatch = wf.content?.match(/`([a-f0-9]{24})`/);
+  const workflowId = wfMatch?.[1];
+  console.log(`\n[Using workflowId: ${workflowId}]`);
+
+  if (!workflowId) {
+    console.log('No workflow found, stopping');
+    process.exit(1);
+  }
+
+  // Get phase
+  const ph = await call(apiKey, 'list_workflow_phases', { workflowId });
+  const phMatch = ph.content?.match(/`([a-f0-9]{24})`/);
+  const phaseId = phMatch?.[1];
+  console.log(`\n[Using phaseId: ${phaseId}]`);
+
+  // Schema
+  await call(apiKey, 'get_workflow_schema', { workflowId, phaseId });
+
+  // List activities
+  await call(apiKey, 'list_activities', { workflowId, phaseId, fields: '[]' });
+
+  // Count
+  await call(apiKey, 'count_activities', { workflowId });
+
+  // Create activity
+  const created = await call(apiKey, 'create_activity', {
+    workflowId,
+    name: `TEST_${Date.now()}`
+  });
+  const actMatch = created.content?.match(/\*\*ID\*\*:\s*([a-f0-9]{24})/);
+  const activityId = actMatch?.[1];
+  console.log(`\n[Created activityId: ${activityId}]`);
+
+  if (activityId) {
+    // Show it
+    await call(apiKey, 'show_activity_by_id', { activityId });
+
+    // Update it
+    await call(apiKey, 'update_activity', { activityId, name: `UPDATED_${Date.now()}` });
+
+    // Delete it (this tool doesn't exist yet)
+    await call(apiKey, 'delete_activity', { activityId });
+  }
+
+  // Insights
+  await call(apiKey, 'list_insights', {});
+
+  const sources = [{
+    name: 'src',
+    workflowId,
+    fields: [{ meta: 'name', name: 'Name', as: 'name' }]
+  }];
+
+  await call(apiKey, 'preview_insight', { sources, query: 'SELECT * FROM src LIMIT 3' });
+
+  const ins = await call(apiKey, 'create_insight', {
+    name: `TEST_${Date.now()}`,
+    sources,
+    query: 'SELECT * FROM src LIMIT 3'
+  });
+  const insMatch = ins.content?.match(/`([a-f0-9]{24})`/);
+  const insightId = insMatch?.[1];
+
+  if (insightId) {
+    await call(apiKey, 'get_insight_data', { insightId });
+    await call(apiKey, 'remove_insight', { insightId });
+  }
+
+  // Discussions
+  await call(apiKey, 'list_my_discussions', {});
+
+  if (activityId) {
+    await call(apiKey, 'join_discussion', { activityId });
+    // Get discussion from activity
+    const act = await call(apiKey, 'show_activity_by_id', { activityId });
+    const discMatch = act.content?.match(/discussion.*?([a-f0-9]{24})/i);
+    const discussionId = discMatch?.[1];
+
+    if (discussionId) {
+      await call(apiKey, 'fetch_discussion_messages', { discussionId });
+      await call(apiKey, 'add_discussion_message', { discussionId, content: 'TEST' });
+      await call(apiKey, 'get_activity_from_discussion', { discussionId });
+      await call(apiKey, 'leave_discussion', { discussionId });
+    }
+  }
+
+  // Other
+  await call(apiKey, 'list_workflows', {});
+  await call(apiKey, 'list_apps', {});
+  await call(apiKey, 'list_templates', {});
+  await call(apiKey, 'get_workspace_balance', {});
+  await call(apiKey, 'search_workspace_users', { query: 'test' });
+
+  console.log('\n=== DONE ===');
+}
+
+main().catch(console.error);