cowork-os 0.3.21 → 0.3.25

package/connectors/templates/mcp-connector/src/index.ts

@@ -0,0 +1,330 @@
+import * as readline from 'readline';
+
+// ==================== MCP Types ====================
+
+type JSONRPCId = string | number;
+
+type JSONRPCRequest = {
+  jsonrpc: '2.0';
+  id: JSONRPCId;
+  method: string;
+  params?: Record<string, any>;
+};
+
+type JSONRPCNotification = {
+  jsonrpc: '2.0';
+  method: string;
+  params?: Record<string, any>;
+};
+
+type JSONRPCResponse = {
+  jsonrpc: '2.0';
+  id: JSONRPCId;
+  result?: any;
+  error?: { code: number; message: string; data?: any };
+};
+
+type MCPToolProperty = {
+  type: string;
+  description?: string;
+  enum?: string[];
+  default?: any;
+  items?: MCPToolProperty;
+  properties?: Record<string, MCPToolProperty>;
+  required?: string[];
+};
+
+type MCPTool = {
+  name: string;
+  description?: string;
+  inputSchema: {
+    type: 'object';
+    properties?: Record<string, MCPToolProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+  };
+};
+
+type MCPServerInfo = {
+  name: string;
+  version: string;
+  protocolVersion?: string;
+  capabilities?: {
+    tools?: { listChanged?: boolean };
+  };
+};
+
+const PROTOCOL_VERSION = '2024-11-05';
+
+const MCP_METHODS = {
+  INITIALIZE: 'initialize',
+  INITIALIZED: 'notifications/initialized',
+  SHUTDOWN: 'shutdown',
+  TOOLS_LIST: 'tools/list',
+  TOOLS_CALL: 'tools/call',
+} as const;
+
+const MCP_ERROR_CODES = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  SERVER_NOT_INITIALIZED: -32002,
+} as const;
+
+// ==================== Tool Provider ====================
+
+type ToolProvider = {
+  getTools(): MCPTool[];
+  executeTool(name: string, args: Record<string, any>): Promise<any>;
+};
+
+// ==================== MCP Stdio Server ====================
+
+class StdioMCPServer {
+  private initialized = false;
+  private rl: readline.Interface | null = null;
+
+  constructor(
+    private toolProvider: ToolProvider,
+    private serverInfo: MCPServerInfo
+  ) {}
+
+  start(): void {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false,
+    });
+
+    this.rl.on('line', (line) => this.handleLine(line));
+    this.rl.on('close', () => this.stop());
+
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+  }
+
+  stop(): void {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    process.exit(0);
+  }
+
+  private handleLine(line: string): void {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+
+    try {
+      const message = JSON.parse(trimmed);
+      this.handleMessage(message);
+    } catch (error) {
+      this.sendError(0, MCP_ERROR_CODES.PARSE_ERROR, 'Parse error');
+    }
+  }
+
+  private async handleMessage(message: any): Promise<void> {
+    if ('id' in message && message.id !== null) {
+      await this.handleRequest(message as JSONRPCRequest);
+      return;
+    }
+
+    if ('method' in message) {
+      await this.handleNotification(message as JSONRPCNotification);
+    }
+  }
+
+  private async handleRequest(request: JSONRPCRequest): Promise<void> {
+    const { id, method, params } = request;
+
+    try {
+      let result: any;
+
+      switch (method) {
+        case MCP_METHODS.INITIALIZE:
+          result = this.handleInitialize(params);
+          break;
+        case MCP_METHODS.TOOLS_LIST:
+          this.requireInitialized();
+          result = this.handleToolsList();
+          break;
+        case MCP_METHODS.TOOLS_CALL:
+          this.requireInitialized();
+          result = await this.handleToolsCall(params);
+          break;
+        case MCP_METHODS.SHUTDOWN:
+          result = this.handleShutdown();
+          break;
+        default:
+          throw this.createError(MCP_ERROR_CODES.METHOD_NOT_FOUND, `Method not found: ${method}`);
+      }
+
+      this.sendResult(id, result);
+    } catch (error: any) {
+      if (error.code !== undefined) {
+        this.sendError(id, error.code, error.message, error.data);
+      } else {
+        this.sendError(id, MCP_ERROR_CODES.INTERNAL_ERROR, error?.message || 'Internal error');
+      }
+    }
+  }
+
+  private async handleNotification(notification: JSONRPCNotification): Promise<void> {
+    const { method } = notification;
+
+    if (method === MCP_METHODS.INITIALIZED) {
+      this.initialized = true;
+    }
+  }
+
+  private handleInitialize(_params: any): {
+    protocolVersion: string;
+    capabilities: MCPServerInfo['capabilities'];
+    serverInfo: MCPServerInfo;
+  } {
+    if (this.initialized) {
+      throw this.createError(MCP_ERROR_CODES.INVALID_REQUEST, 'Already initialized');
+    }
+
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: this.serverInfo.capabilities,
+      serverInfo: this.serverInfo,
+    };
+  }
+
+  private handleToolsList(): { tools: MCPTool[] } {
+    return { tools: this.toolProvider.getTools() };
+  }
+
+  private async handleToolsCall(params: any): Promise<any> {
+    const { name, arguments: args } = params || {};
+    if (!name) {
+      throw this.createError(MCP_ERROR_CODES.INVALID_PARAMS, 'Tool name is required');
+    }
+
+    try {
+      const result = await this.toolProvider.executeTool(name, args || {});
+
+      if (typeof result === 'string') {
+        return { content: [{ type: 'text', text: result }] };
+      }
+
+      if (result && typeof result === 'object') {
+        if (result.content && Array.isArray(result.content)) {
+          return result;
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      }
+
+      return { content: [{ type: 'text', text: String(result) }] };
+    } catch (error: any) {
+      return {
+        content: [{ type: 'text', text: `Error: ${error?.message || 'Tool failed'}` }],
+        isError: true,
+      };
+    }
+  }
+
+  private handleShutdown(): Record<string, never> {
+    setImmediate(() => this.stop());
+    return {};
+  }
+
+  private sendResult(id: JSONRPCId, result: any): void {
+    const response: JSONRPCResponse = { jsonrpc: '2.0', id, result };
+    this.sendMessage(response);
+  }
+
+  private sendError(id: JSONRPCId, code: number, message: string, data?: any): void {
+    const response: JSONRPCResponse = {
+      jsonrpc: '2.0',
+      id,
+      error: { code, message, data },
+    };
+    this.sendMessage(response);
+  }
+
+  private sendMessage(message: JSONRPCResponse | JSONRPCNotification): void {
+    process.stdout.write(JSON.stringify(message) + '\n');
+  }
+
+  private requireInitialized(): void {
+    if (!this.initialized) {
+      throw this.createError(MCP_ERROR_CODES.SERVER_NOT_INITIALIZED, 'Server not initialized');
+    }
+  }
+
+  private createError(code: number, message: string, data?: any): { code: number; message: string; data?: any } {
+    return { code, message, data };
+  }
+}
+
+// ==================== Example Tools ====================
+
+const CONNECTOR_PREFIX = process.env.CONNECTOR_PREFIX || 'example';
+
+const tools: MCPTool[] = [
+  {
+    name: `${CONNECTOR_PREFIX}.health`,
+    description: 'Check connector health and authentication status',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: `${CONNECTOR_PREFIX}.echo`,
+    description: 'Echo input for testing',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'Text to echo back' },
+      },
+      required: ['text'],
+      additionalProperties: false,
+    },
+  },
+];
+
+const handlers: Record<string, (args: Record<string, any>) => Promise<any>> = {
+  [`${CONNECTOR_PREFIX}.health`]: async () => ({
+    ok: true,
+    data: {
+      status: 'ok',
+      connector: CONNECTOR_PREFIX,
+    },
+  }),
+  [`${CONNECTOR_PREFIX}.echo`]: async (args) => ({
+    ok: true,
+    data: {
+      echo: args.text,
+    },
+  }),
+};
+
+const toolProvider: ToolProvider = {
+  getTools: () => tools,
+  executeTool: async (name, args) => {
+    const handler = handlers[name];
+    if (!handler) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    return handler(args);
+  },
+};
+
+const serverInfo: MCPServerInfo = {
+  name: `Connector (${CONNECTOR_PREFIX})`,
+  version: '0.1.0',
+  protocolVersion: PROTOCOL_VERSION,
+  capabilities: {
+    tools: { listChanged: false },
+  },
+};
+
+const server = new StdioMCPServer(toolProvider, serverInfo);
+server.start();

package/connectors/templates/mcp-connector/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src"]
+}

package/connectors/zendesk-mcp/README.md

@@ -0,0 +1,40 @@
+# Zendesk MCP Connector (MVP)
+
+This connector exposes Zendesk Support APIs to CoWork OS through MCP tools.
+
+## Requirements
+
+Provide credentials via environment variables:
+
+- `ZENDESK_SUBDOMAIN` (required unless `ZENDESK_BASE_URL` provided)
+- `ZENDESK_EMAIL` (required for API token auth)
+- `ZENDESK_API_TOKEN` (required for API token auth)
+
+Optional:
+- `ZENDESK_ACCESS_TOKEN` (OAuth bearer token)
+- `ZENDESK_BASE_URL` (override full base URL, e.g., `https://your-domain.zendesk.com`)
+- Optional refresh: `ZENDESK_CLIENT_ID`, `ZENDESK_CLIENT_SECRET`, `ZENDESK_REFRESH_TOKEN`
+
+## Build & Run
+
+```bash
+npm install
+npm run build
+npm start
+```
+
+## Add to CoWork MCP Settings
+
+- **Command**: `node`
+- **Args**: `/absolute/path/to/connectors/zendesk-mcp/dist/index.js`
+- **Env**: set the variables above
+
+## Tools
+
+- `zendesk.health`
+- `zendesk.search_tickets`
+- `zendesk.get_ticket`
+- `zendesk.create_ticket`
+- `zendesk.update_ticket`
+
+See `docs/enterprise-connectors.md` for the connector contract.