opalserve 0.1.0

package/src/connectors/google-drive.ts

@@ -0,0 +1,217 @@
+import { BaseConnector } from './base.js';
+import { ConnectorConfig, Tool, ToolDefinition } from '../types/index.js';
+
+const GOOGLE_DRIVE_TOOL_DEFS: ToolDefinition[] = [
+  {
+    name: 'drive_list_files',
+    description: 'List files in Google Drive with optional filters',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        folderId: { type: 'string', description: 'Parent folder ID' },
+        mimeType: { type: 'string', description: 'Filter by MIME type' },
+        query: { type: 'string', description: 'Search query' },
+        pageSize: { type: 'number', default: 100 },
+        orderBy: { type: 'string', description: 'Sort order' },
+      },
+    },
+    tags: ['files', 'drive', 'google', 'list'],
+    capabilities: ['read', 'list'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 400 },
+  },
+  {
+    name: 'drive_get_file',
+    description: 'Get metadata for a specific file',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fileId: { type: 'string', description: 'File ID' },
+        fields: { type: 'string', description: 'Fields to return' },
+      },
+      required: ['fileId'],
+    },
+    tags: ['files', 'drive', 'google', 'metadata'],
+    capabilities: ['read', 'metadata'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+  {
+    name: 'drive_download_file',
+    description: 'Download file content from Google Drive',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fileId: { type: 'string', description: 'File ID' },
+        mimeType: { type: 'string', description: 'Expected MIME type' },
+      },
+      required: ['fileId'],
+    },
+    tags: ['files', 'drive', 'google', 'download'],
+    capabilities: ['read', 'download'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 500 },
+  },
+  {
+    name: 'drive_create_file',
+    description: 'Create a new file in Google Drive',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'File name' },
+        mimeType: { type: 'string', description: 'MIME type' },
+        parentFolderId: { type: 'string', description: 'Parent folder ID' },
+        content: { type: 'string', description: 'File content' },
+      },
+      required: ['name', 'mimeType'],
+    },
+    tags: ['files', 'drive', 'google', 'create'],
+    capabilities: ['write', 'create'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 300 },
+  },
+  {
+    name: 'drive_update_file',
+    description: 'Update file metadata or content',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fileId: { type: 'string', description: 'File ID' },
+        name: { type: 'string', description: 'New file name' },
+        content: { type: 'string', description: 'New content' },
+        addParents: { type: 'array', items: { type: 'string' }, description: 'Parent folder IDs to add' },
+        removeParents: { type: 'array', items: { type: 'string' }, description: 'Parent folder IDs to remove' },
+      },
+      required: ['fileId'],
+    },
+    tags: ['files', 'drive', 'google', 'update'],
+    capabilities: ['write', 'update'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 300 },
+  },
+  {
+    name: 'drive_delete_file',
+    description: 'Move a file to trash or permanently delete it',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fileId: { type: 'string', description: 'File ID' },
+        permanent: { type: 'boolean', default: false, description: 'Permanently delete vs trash' },
+      },
+      required: ['fileId'],
+    },
+    tags: ['files', 'drive', 'google', 'delete'],
+    capabilities: ['write', 'delete'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 100 },
+  },
+  {
+    name: 'drive_list_folders',
+    description: 'List folders in Google Drive',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        folderId: { type: 'string', description: 'Parent folder ID' },
+        query: { type: 'string', description: 'Search query' },
+      },
+    },
+    tags: ['folders', 'drive', 'google', 'list'],
+    capabilities: ['read', 'list'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 300 },
+  },
+  {
+    name: 'drive_create_folder',
+    description: 'Create a new folder in Google Drive',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Folder name' },
+        parentFolderId: { type: 'string', description: 'Parent folder ID' },
+      },
+      required: ['name'],
+    },
+    tags: ['folders', 'drive', 'google', 'create'],
+    capabilities: ['write', 'create'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 100 },
+  },
+  {
+    name: 'drive_share_file',
+    description: 'Share a file with specific users or make it public',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fileId: { type: 'string', description: 'File ID' },
+        role: { type: 'string', enum: ['reader', 'commenter', 'writer', 'owner'] },
+        type: { type: 'string', enum: ['user', 'group', 'domain', 'anyone'] },
+        email: { type: 'string', description: 'Email for user/group type' },
+        domain: { type: 'string', description: 'Domain for domain type' },
+        transferOwnership: { type: 'boolean', default: false },
+      },
+      required: ['fileId', 'role', 'type'],
+    },
+    tags: ['files', 'drive', 'google', 'sharing', 'permissions'],
+    capabilities: ['write', 'share'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+  {
+    name: 'drive_search_files',
+    description: 'Search for files using Google Drive query syntax',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query (Drive query syntax)' },
+        pageSize: { type: 'number', default: 100 },
+        orderBy: { type: 'string' },
+      },
+      required: ['query'],
+    },
+    tags: ['search', 'files', 'drive', 'google'],
+    capabilities: ['read', 'search'],
+    authRequirements: { required: ['google_service_account'] },
+    contextRequirements: { minTokens: 30, maxTokens: 400 },
+  },
+];
+
+export class GoogleDriveConnector extends BaseConnector {
+  id = 'google-drive';
+  name = 'Google Drive';
+  type = 'google-drive';
+  private serviceAccountPath?: string;
+
+  constructor(config: ConnectorConfig) {
+    super(config);
+    this.serviceAccountPath = config.auth?.credentials?.service_account_path;
+    this.tools = this.buildTools();
+  }
+
+  async connect(): Promise<void> {
+    if (!this.serviceAccountPath) {
+      console.warn('Google service account not configured');
+      this.connected = true;
+      return;
+    }
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async healthCheck(): Promise<{ healthy: boolean; latencyMs?: number }> {
+    const { result, latencyMs } = await this.measureLatency(async () => {
+      return this.connected;
+    });
+    return { healthy: result, latencyMs };
+  }
+
+  async refreshTools(): Promise<Tool[]> {
+    return this.tools;
+  }
+
+  private buildTools(): Tool[] {
+    return GOOGLE_DRIVE_TOOL_DEFS.map(def => this.createTool(def));
+  }
+}

package/src/connectors/index.ts

@@ -0,0 +1,86 @@
+export { BaseConnector, Connector } from './base.js';
+export { GitHubConnector } from './github.js';
+export { SlackConnector } from './slack.js';
+export { PostgresConnector } from './postgres.js';
+export { GoogleDriveConnector } from './google-drive.js';
+export { CustomConnector } from './custom.js';
+
+import { GitHubConnector } from './github.js';
+import { SlackConnector } from './slack.js';
+import { PostgresConnector } from './postgres.js';
+import { GoogleDriveConnector } from './google-drive.js';
+import { CustomConnector } from './custom.js';
+import type { ConnectorConfig, MCPServer, Server } from '../types/index.js';
+
+export function createConnector(type: string, config: ConnectorConfig): MCPServer {
+  switch (type) {
+    case 'github':
+      return new GitHubConnector(config);
+    case 'slack':
+      return new SlackConnector(config);
+    case 'postgres':
+      return new PostgresConnector(config);
+    case 'google-drive':
+      return new GoogleDriveConnector(config);
+    case 'custom':
+      return new CustomConnector(config);
+    default:
+      throw new Error(`Unknown connector type: ${type}`);
+  }
+}
+
+export function createAllConnectors(): Map<string, MCPServer> {
+  const connectors = new Map<string, MCPServer>();
+  
+  connectors.set('github', new GitHubConnector({
+    serverId: 'github',
+    auth: { type: 'api-key' },
+  }));
+
+  connectors.set('slack', new SlackConnector({
+    serverId: 'slack',
+    auth: { type: 'api-key' },
+  }));
+
+  connectors.set('postgres', new PostgresConnector({
+    serverId: 'postgres',
+    auth: { type: 'none' },
+  }));
+
+  connectors.set('google-drive', new GoogleDriveConnector({
+    serverId: 'google-drive',
+    auth: { type: 'oauth' },
+  }));
+
+  connectors.set('custom', new CustomConnector({
+    serverId: 'custom',
+    auth: { type: 'none' },
+  }));
+
+  return connectors;
+}
+
+export function createServerFromConnector(connector: MCPServer): Server {
+  return {
+    id: connector.id,
+    name: connector.name,
+    type: connector.type as Server['type'],
+    status: 'active',
+    description: `MCP server for ${connector.name}`,
+    version: '1.0.0',
+    capabilities: ['read', 'write'],
+    tags: [connector.type, 'mcp'],
+    health: {
+      status: 'healthy',
+      lastChecked: new Date().toISOString(),
+      errorCount: 0,
+    },
+    auth: {
+      type: 'none',
+      configured: false,
+    },
+    metadata: {},
+    registeredAt: new Date().toISOString(),
+    lastSeen: new Date().toISOString(),
+  };
+}

package/src/connectors/postgres.ts

@@ -0,0 +1,148 @@
+import { BaseConnector } from './base.js';
+import { ConnectorConfig, Tool, ToolDefinition } from '../types/index.js';
+
+const POSTGRES_TOOL_DEFS: ToolDefinition[] = [
+  {
+    name: 'postgres_query',
+    description: 'Execute a SQL query against the PostgreSQL database',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sql: { type: 'string', description: 'SQL query to execute' },
+        params: { type: 'array', description: 'Query parameters' },
+        timeout: { type: 'number', description: 'Query timeout in milliseconds' },
+      },
+      required: ['sql'],
+    },
+    tags: ['database', 'sql', 'postgres', 'query'],
+    capabilities: ['read', 'write', 'query'],
+    authRequirements: { required: ['postgres_url'] },
+    contextRequirements: { minTokens: 50, maxTokens: 500 },
+  },
+  {
+    name: 'postgres_list_tables',
+    description: 'List all tables in the database schema',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        schema: { type: 'string', default: 'public', description: 'Database schema name' },
+      },
+    },
+    tags: ['database', 'schema', 'postgres', 'tables'],
+    capabilities: ['read', 'metadata'],
+    authRequirements: { required: ['postgres_url'] },
+    contextRequirements: { minTokens: 30, maxTokens: 300 },
+  },
+  {
+    name: 'postgres_describe_table',
+    description: 'Get the schema/structure of a specific table',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        table: { type: 'string', description: 'Table name' },
+        schema: { type: 'string', default: 'public', description: 'Schema name' },
+      },
+      required: ['table'],
+    },
+    tags: ['database', 'schema', 'postgres', 'structure'],
+    capabilities: ['read', 'metadata'],
+    authRequirements: { required: ['postgres_url'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+  {
+    name: 'postgres_execute_transaction',
+    description: 'Execute multiple SQL statements as a transaction',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        statements: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              sql: { type: 'string' },
+              params: { type: 'array' },
+            },
+          },
+          description: 'Array of SQL statements to execute',
+        },
+        rollbackOnError: { type: 'boolean', default: true },
+      },
+      required: ['statements'],
+    },
+    tags: ['database', 'transaction', 'postgres'],
+    capabilities: ['write', 'transaction'],
+    authRequirements: { required: ['postgres_url'] },
+    contextRequirements: { minTokens: 50, maxTokens: 500 },
+  },
+  {
+    name: 'postgres_list_databases',
+    description: 'List all accessible databases',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+    tags: ['database', 'postgres', 'list'],
+    capabilities: ['read', 'metadata'],
+    authRequirements: { required: ['postgres_url'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+  {
+    name: 'postgres_explain_query',
+    description: 'Get the query execution plan without running the query',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sql: { type: 'string', description: 'SQL query to explain' },
+        analyze: { type: 'boolean', default: false, description: 'Run the query and show actual timings' },
+        verbose: { type: 'boolean', default: false },
+      },
+      required: ['sql'],
+    },
+    tags: ['database', 'postgres', 'optimization', 'explain'],
+    capabilities: ['read', 'analyze'],
+    authRequirements: { required: ['postgres_url'] },
+    contextRequirements: { minTokens: 50, maxTokens: 400 },
+  },
+];
+
+export class PostgresConnector extends BaseConnector {
+  id = 'postgres';
+  name = 'PostgreSQL';
+  type = 'postgres';
+  private connectionUrl?: string;
+
+  constructor(config: ConnectorConfig) {
+    super(config);
+    this.connectionUrl = config.auth?.credentials?.url;
+    this.tools = this.buildTools();
+  }
+
+  async connect(): Promise<void> {
+    if (!this.connectionUrl) {
+      console.warn('PostgreSQL connection URL not configured');
+      this.connected = true;
+      return;
+    }
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async healthCheck(): Promise<{ healthy: boolean; latencyMs?: number }> {
+    const { result, latencyMs } = await this.measureLatency(async () => {
+      return this.connected && !!this.connectionUrl;
+    });
+    return { healthy: result, latencyMs };
+  }
+
+  async refreshTools(): Promise<Tool[]> {
+    return this.tools;
+  }
+
+  private buildTools(): Tool[] {
+    return POSTGRES_TOOL_DEFS.map(def => this.createTool(def));
+  }
+}

package/src/connectors/slack.ts

@@ -0,0 +1,188 @@
+import { BaseConnector } from './base.js';
+import { ConnectorConfig, Tool, ToolDefinition } from '../types/index.js';
+
+const SLACK_TOOL_DEFS: ToolDefinition[] = [
+  {
+    name: 'slack_post_message',
+    description: 'Post a message to a Slack channel',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: 'Channel ID or name' },
+        text: { type: 'string', description: 'Message text' },
+        blocks: { type: 'array', description: 'Slack Block Kit blocks' },
+        thread_ts: { type: 'string', description: 'Parent message timestamp for threads' },
+      },
+      required: ['channel', 'text'],
+    },
+    tags: ['messaging', 'slack', 'post'],
+    capabilities: ['write', 'messaging'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+  {
+    name: 'slack_list_channels',
+    description: 'List all channels in the workspace',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        types: { type: 'array', items: { type: 'string' }, description: 'Channel types: public_channel, private_channel, im, mpim' },
+        exclude_archived: { type: 'boolean', default: true },
+        limit: { type: 'number', default: 100 },
+      },
+    },
+    tags: ['channels', 'slack', 'list'],
+    capabilities: ['read', 'list'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 300 },
+  },
+  {
+    name: 'slack_get_messages',
+    description: 'Retrieve messages from a Slack channel',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: 'Channel ID' },
+        latest: { type: 'string', description: 'Most recent message timestamp' },
+        oldest: { type: 'string', description: 'Oldest message timestamp' },
+        limit: { type: 'number', default: 100 },
+        inclusive: { type: 'boolean', default: false },
+      },
+      required: ['channel'],
+    },
+    tags: ['messages', 'slack', 'read'],
+    capabilities: ['read', 'messaging'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 500 },
+  },
+  {
+    name: 'slack_create_channel',
+    description: 'Create a new Slack channel',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Channel name' },
+        is_private: { type: 'boolean', default: false },
+        team_id: { type: 'string', description: 'Team to create channel in' },
+      },
+      required: ['name'],
+    },
+    tags: ['channels', 'slack', 'create'],
+    capabilities: ['write', 'create'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 100 },
+  },
+  {
+    name: 'slack_invite_users',
+    description: 'Invite users to a Slack channel',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: 'Channel ID' },
+        users: { type: 'array', items: { type: 'string' }, description: 'User IDs to invite' },
+      },
+      required: ['channel', 'users'],
+    },
+    tags: ['users', 'slack', 'invite'],
+    capabilities: ['write', 'admin'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 100 },
+  },
+  {
+    name: 'slack_search_messages',
+    description: 'Search for messages across Slack',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        count: { type: 'number', default: 20 },
+        highlight: { type: 'boolean', default: true },
+      },
+      required: ['query'],
+    },
+    tags: ['search', 'slack', 'messages'],
+    capabilities: ['read', 'search'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 400 },
+  },
+  {
+    name: 'slack_upload_file',
+    description: 'Upload a file to Slack',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channels: { type: 'array', items: { type: 'string' }, description: 'Channel IDs' },
+        file: { type: 'string', description: 'File content or URL' },
+        filename: { type: 'string', description: 'File name' },
+        title: { type: 'string', description: 'File title' },
+        initial_comment: { type: 'string', description: 'Initial comment' },
+      },
+      required: ['channels', 'file', 'filename'],
+    },
+    tags: ['files', 'slack', 'upload'],
+    capabilities: ['write', 'upload'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+  {
+    name: 'slack_get_user_info',
+    description: 'Get information about a Slack user',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        user: { type: 'string', description: 'User ID' },
+      },
+      required: ['user'],
+    },
+    tags: ['users', 'slack', 'info'],
+    capabilities: ['read', 'users'],
+    authRequirements: { required: ['slack_bot_token'] },
+    contextRequirements: { minTokens: 30, maxTokens: 200 },
+  },
+];
+
+export class SlackConnector extends BaseConnector {
+  id = 'slack';
+  name = 'Slack';
+  type = 'slack';
+  private token?: string;
+
+  constructor(config: ConnectorConfig) {
+    super(config);
+    this.token = config.auth?.credentials?.token;
+    this.tools = this.buildTools();
+  }
+
+  async connect(): Promise<void> {
+    if (!this.token) {
+      console.warn('Slack bot token not configured');
+      this.connected = true;
+      return;
+    }
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async healthCheck(): Promise<{ healthy: boolean; latencyMs?: number }> {
+    const { result, latencyMs } = await this.measureLatency(async () => {
+      if (!this.token) return false;
+      const response = await fetch('https://slack.com/api/auth.test', {
+        headers: { Authorization: `Bearer ${this.token}` },
+      });
+      const data = await response.json() as { ok: boolean };
+      return data.ok === true;
+    });
+    return { healthy: result, latencyMs };
+  }
+
+  async refreshTools(): Promise<Tool[]> {
+    return this.tools;
+  }
+
+  private buildTools(): Tool[] {
+    return SLACK_TOOL_DEFS.map(def => this.createTool(def));
+  }
+}