@agenticmail/enterprise 0.5.327 → 0.5.328

package/src/mcp/adapters/hashicorp-vault.adapter.ts

@@ -1,355 +0,0 @@
-/**
- * MCP Skill Adapter — HashiCorp Vault
- *
- * Maps HashiCorp Vault HTTP API endpoints to MCP tool handlers.
- * Covers secret reading/writing, secret listing, mount management, and health checks.
- *
- * The Vault address is dynamic, resolved from ctx.skillConfig.vaultAddr.
- *
- * Vault API docs: https://developer.hashicorp.com/vault/api-docs
- */
-
-import type {
-  SkillAdapter,
-  ToolHandler,
-  ToolResult,
-  ToolExecutionContext,
-} from '../framework/types.js';
-
-// ─── Helpers ────────────────────────────────────────────
-
-/** Resolve the Vault base URL from skill config. */
-function vaultUrl(ctx: ToolExecutionContext): string {
-  return (
-    ctx.skillConfig.vaultAddr || 'https://vault.example.com'
-  ).replace(/\/$/, '');
-}
-
-function vaultError(err: unknown): ToolResult {
-  if (err instanceof Error) {
-    const data = (err as any).data;
-    if (data && typeof data === 'object') {
-      const errors: string[] = data.errors || [];
-      if (errors.length > 0) {
-        return { content: `Vault API error: ${errors.join('; ')}`, isError: true };
-      }
-      const warnings: string[] = data.warnings || [];
-      if (warnings.length > 0) {
-        return { content: `Vault API warning: ${warnings.join('; ')}`, isError: true };
-      }
-    }
-    return { content: `Vault API error: ${err.message}`, isError: true };
-  }
-  return { content: `Vault API error: ${String(err)}`, isError: true };
-}
-
-// ─── Tool: vault_read_secret ────────────────────────────
-
-const readSecret: ToolHandler = {
-  description:
-    'Read a secret from HashiCorp Vault at a given path. Supports KV v1 and v2 engines. Returns secret key-value pairs.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'The secret path (e.g. "secret/data/myapp/config" for KV v2 or "secret/myapp/config" for KV v1)',
-      },
-      version: {
-        type: 'number',
-        description: 'Secret version to read (KV v2 only, omit for latest)',
-      },
-    },
-    required: ['path'],
-    additionalProperties: false,
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const baseUrl = vaultUrl(ctx);
-      const query: Record<string, string> = {};
-      if (params.version !== undefined) query.version = String(params.version);
-
-      const result = await ctx.apiExecutor.request({
-        method: 'GET',
-        url: `${baseUrl}/v1/${params.path}`,
-        query,
-      });
-
-      // KV v2 nests data under data.data; KV v1 uses data directly
-      const secretData = result.data?.data || result.data || {};
-      const metadata = result.data?.metadata || {};
-
-      const keys = Object.keys(secretData);
-      if (keys.length === 0) {
-        return {
-          content: `No secret data found at path "${params.path}".`,
-          metadata: { path: params.path, keyCount: 0 },
-        };
-      }
-
-      const lines = keys.map((k: string) => {
-        const value = secretData[k];
-        const displayValue = typeof value === 'string' && value.length > 50
-          ? `${value.substring(0, 50)}...`
-          : JSON.stringify(value);
-        return `  ${k}: ${displayValue}`;
-      });
-
-      const versionInfo = metadata.version ? ` (version ${metadata.version})` : '';
-
-      const content = [
-        `Secret at "${params.path}"${versionInfo}:`,
-        ...lines,
-      ].join('\n');
-
-      return {
-        content,
-        metadata: {
-          path: params.path,
-          keyCount: keys.length,
-          version: metadata.version,
-          keys,
-        },
-      };
-    } catch (err) {
-      return vaultError(err);
-    }
-  },
-};
-
-// ─── Tool: vault_list_secrets ───────────────────────────
-
-const listSecrets: ToolHandler = {
-  description:
-    'List secret keys at a given path in HashiCorp Vault. Returns a list of key names (not values).',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'The path to list (e.g. "secret/metadata/" for KV v2 or "secret/" for KV v1)',
-      },
-    },
-    required: ['path'],
-    additionalProperties: false,
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const baseUrl = vaultUrl(ctx);
-
-      const result = await ctx.apiExecutor.request({
-        method: 'LIST',
-        url: `${baseUrl}/v1/${params.path}`,
-      });
-
-      const keys: string[] = result.data?.keys || [];
-
-      if (keys.length === 0) {
-        return {
-          content: `No keys found at path "${params.path}".`,
-          metadata: { path: params.path, keyCount: 0 },
-        };
-      }
-
-      const lines = keys.map((k: string) => {
-        const isDir = k.endsWith('/');
-        return `• ${k}${isDir ? ' (directory)' : ''}`;
-      });
-
-      return {
-        content: `Found ${keys.length} key(s) at "${params.path}":\n\n${lines.join('\n')}`,
-        metadata: { path: params.path, keyCount: keys.length, keys },
-      };
-    } catch (err) {
-      return vaultError(err);
-    }
-  },
-};
-
-// ─── Tool: vault_write_secret ───────────────────────────
-
-const writeSecret: ToolHandler = {
-  description:
-    'Write a secret to HashiCorp Vault at a given path. Provide key-value pairs as the secret data.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'The secret path to write to (e.g. "secret/data/myapp/config")',
-      },
-      data: {
-        type: 'object',
-        description: 'Key-value pairs to store as the secret',
-      },
-      cas: {
-        type: 'number',
-        description: 'Check-and-Set version (KV v2 only). Set to 0 to create new, or current version to update.',
-      },
-    },
-    required: ['path', 'data'],
-    additionalProperties: false,
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const baseUrl = vaultUrl(ctx);
-      const body: Record<string, any> = {
-        data: params.data,
-      };
-      if (params.cas !== undefined) {
-        body.options = { cas: params.cas };
-      }
-
-      const result = await ctx.apiExecutor.request({
-        method: 'POST',
-        url: `${baseUrl}/v1/${params.path}`,
-        body,
-      });
-
-      const metadata = result.data || {};
-      const version = metadata.version || 'unknown';
-      const keys = Object.keys(params.data);
-
-      return {
-        content: `Secret written to "${params.path}" (version: ${version}). Keys: ${keys.join(', ')}`,
-        metadata: {
-          path: params.path,
-          version,
-          keys,
-        },
-      };
-    } catch (err) {
-      return vaultError(err);
-    }
-  },
-};
-
-// ─── Tool: vault_list_mounts ────────────────────────────
-
-const listMounts: ToolHandler = {
-  description:
-    'List all secret engine mounts in HashiCorp Vault. Returns mount paths, types, and descriptions.',
-  inputSchema: {
-    type: 'object',
-    properties: {},
-    additionalProperties: false,
-  },
-
-  async execute(_params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const baseUrl = vaultUrl(ctx);
-
-      const result = await ctx.apiExecutor.request({
-        method: 'GET',
-        url: `${baseUrl}/v1/sys/mounts`,
-      });
-
-      const mounts = result.data || result;
-      const mountPaths = Object.keys(mounts).filter((k: string) => !k.startsWith('request_id'));
-
-      if (mountPaths.length === 0) {
-        return {
-          content: 'No secret engine mounts found.',
-          metadata: { mountCount: 0 },
-        };
-      }
-
-      const lines = mountPaths.map((path: string) => {
-        const mount = mounts[path] || {};
-        const type = mount.type || 'unknown';
-        const description = mount.description || 'no description';
-        const version = mount.options?.version || '';
-        const versionPart = version ? ` v${version}` : '';
-        return `• ${path} — type: ${type}${versionPart}, description: ${description}`;
-      });
-
-      return {
-        content: `Found ${mountPaths.length} secret engine mount(s):\n\n${lines.join('\n')}`,
-        metadata: { mountCount: mountPaths.length },
-      };
-    } catch (err) {
-      return vaultError(err);
-    }
-  },
-};
-
-// ─── Tool: vault_get_health ─────────────────────────────
-
-const getHealth: ToolHandler = {
-  description:
-    'Check the health status of the HashiCorp Vault server. Returns initialization, seal status, and version info.',
-  inputSchema: {
-    type: 'object',
-    properties: {},
-    additionalProperties: false,
-  },
-
-  async execute(_params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const baseUrl = vaultUrl(ctx);
-
-      const result = await ctx.apiExecutor.request({
-        method: 'GET',
-        url: `${baseUrl}/v1/sys/health`,
-        query: { standbyok: 'true', sealedcode: '200', uninitcode: '200' },
-      });
-
-      const content = [
-        `Vault Health Status:`,
-        `  Initialized: ${result.initialized ? 'Yes' : 'No'}`,
-        `  Sealed: ${result.sealed ? 'Yes' : 'No'}`,
-        `  Standby: ${result.standby ? 'Yes' : 'No'}`,
-        `  Performance Standby: ${result.performance_standby ? 'Yes' : 'No'}`,
-        `  Version: ${result.version || 'unknown'}`,
-        `  Cluster Name: ${result.cluster_name || 'N/A'}`,
-        `  Cluster ID: ${result.cluster_id || 'N/A'}`,
-        `  Server Time: ${result.server_time_utc ? new Date(result.server_time_utc * 1000).toLocaleString() : 'unknown'}`,
-      ].join('\n');
-
-      return {
-        content,
-        metadata: {
-          initialized: result.initialized,
-          sealed: result.sealed,
-          standby: result.standby,
-          version: result.version,
-        },
-      };
-    } catch (err) {
-      return vaultError(err);
-    }
-  },
-};
-
-// ─── Adapter Export ─────────────────────────────────────
-
-export const hashicorpVaultAdapter: SkillAdapter = {
-  skillId: 'hashicorp-vault',
-  name: 'HashiCorp Vault',
-  // Base URL is dynamic from ctx.skillConfig.vaultAddr; tools use full URLs
-  baseUrl: 'https://vault.example.com/v1',
-  auth: {
-    type: 'api_key',
-    headerName: 'X-Vault-Token',
-  },
-  tools: {
-    vault_read_secret: readSecret,
-    vault_list_secrets: listSecrets,
-    vault_write_secret: writeSecret,
-    vault_list_mounts: listMounts,
-    vault_get_health: getHealth,
-  },
-  rateLimits: { requestsPerSecond: 10, burstLimit: 25 },
-  configSchema: {
-    vaultAddr: {
-      type: 'string' as const,
-      label: 'Vault Address',
-      description: 'The HashiCorp Vault server address',
-      required: true,
-      placeholder: 'https://vault.example.com',
-    },
-  },
-};

package/src/mcp/adapters/heroku.adapter.ts

@@ -1,291 +0,0 @@
-/**
- * MCP Skill Adapter — Heroku
- *
- * Maps Heroku Platform API endpoints to MCP tool handlers.
- * Provides access to app management, dyno listing, dyno restarts,
- * and config var retrieval.
- *
- * Heroku API docs: https://devcenter.heroku.com/articles/platform-api-reference
- */
-
-import type {
-  SkillAdapter,
-  ToolHandler,
-  ToolResult,
-  ToolExecutionContext,
-} from '../framework/types.js';
-
-// ─── Helpers ────────────────────────────────────────────
-
-function herokuError(err: unknown): ToolResult {
-  if (err instanceof Error) {
-    const data = (err as any).data;
-    if (data && typeof data === 'object') {
-      const msg = data.message || err.message;
-      const id = data.id || '';
-      const detail = id ? `${msg} (id: ${id})` : msg;
-      return { content: `Heroku API error: ${detail}`, isError: true };
-    }
-    return { content: `Heroku API error: ${err.message}`, isError: true };
-  }
-  return { content: `Heroku API error: ${String(err)}`, isError: true };
-}
-
-// ─── Tool: heroku_list_apps ─────────────────────────────
-
-const listApps: ToolHandler = {
-  description:
-    'List all Heroku apps accessible to the authenticated user. Returns app names, regions, stacks, and last updated times.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      range: {
-        type: 'string',
-        description: 'Range header for pagination (e.g. "id ..; max=50")',
-      },
-    },
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const headers: Record<string, string> = {};
-      if (params.range) headers['Range'] = params.range;
-
-      const result = await ctx.apiExecutor.request({
-        method: 'GET',
-        path: '/apps',
-        headers,
-      });
-
-      const apps: any[] = Array.isArray(result) ? result : [];
-      if (apps.length === 0) {
-        return { content: 'No Heroku apps found.' };
-      }
-
-      const lines = apps.map((app: any) => {
-        const name = app.name || 'unknown';
-        const region = app.region?.name || 'unknown';
-        const stack = app.build_stack?.name || app.stack?.name || 'unknown';
-        const updated = app.updated_at
-          ? new Date(app.updated_at).toISOString().slice(0, 16)
-          : 'unknown';
-        const webUrl = app.web_url || 'N/A';
-        return `${name} — region: ${region}, stack: ${stack}, updated: ${updated}\n  URL: ${webUrl}`;
-      });
-
-      return {
-        content: `Found ${apps.length} app(s):\n${lines.join('\n')}`,
-        metadata: { count: apps.length },
-      };
-    } catch (err) {
-      return herokuError(err);
-    }
-  },
-};
-
-// ─── Tool: heroku_get_app ───────────────────────────────
-
-const getApp: ToolHandler = {
-  description:
-    'Get detailed information about a specific Heroku app by name or ID.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      appIdOrName: {
-        type: 'string',
-        description: 'App name or UUID',
-      },
-    },
-    required: ['appIdOrName'],
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const result = await ctx.apiExecutor.get(`/apps/${params.appIdOrName}`);
-
-      return {
-        content: [
-          `App: ${result.name || 'unknown'}`,
-          `ID: ${result.id || 'unknown'}`,
-          `Region: ${result.region?.name || 'unknown'}`,
-          `Stack: ${result.build_stack?.name || result.stack?.name || 'unknown'}`,
-          `Web URL: ${result.web_url || 'N/A'}`,
-          `Git URL: ${result.git_url || 'N/A'}`,
-          `Owner: ${result.owner?.email || 'unknown'}`,
-          `Team: ${result.team?.name || 'personal'}`,
-          `Maintenance: ${result.maintenance ? 'ON' : 'OFF'}`,
-          `Created: ${result.created_at || 'unknown'}`,
-          `Updated: ${result.updated_at || 'unknown'}`,
-          `Slug Size: ${result.slug_size ? `${(result.slug_size / 1024 / 1024).toFixed(1)} MB` : 'N/A'}`,
-          `Repo Size: ${result.repo_size ? `${(result.repo_size / 1024 / 1024).toFixed(1)} MB` : 'N/A'}`,
-        ].join('\n'),
-        metadata: {
-          name: result.name,
-          id: result.id,
-          region: result.region?.name,
-          webUrl: result.web_url,
-        },
-      };
-    } catch (err) {
-      return herokuError(err);
-    }
-  },
-};
-
-// ─── Tool: heroku_list_dynos ────────────────────────────
-
-const listDynos: ToolHandler = {
-  description:
-    'List all dynos for a Heroku app. Returns dyno names, types, states, sizes, and commands.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      appIdOrName: {
-        type: 'string',
-        description: 'App name or UUID',
-      },
-    },
-    required: ['appIdOrName'],
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const result = await ctx.apiExecutor.get(`/apps/${params.appIdOrName}/dynos`);
-
-      const dynos: any[] = Array.isArray(result) ? result : [];
-      if (dynos.length === 0) {
-        return { content: `No dynos found for app "${params.appIdOrName}".` };
-      }
-
-      const lines = dynos.map((d: any) => {
-        const name = d.name || 'unknown';
-        const type = d.type || 'unknown';
-        const state = d.state || 'unknown';
-        const size = d.size || 'unknown';
-        const command = d.command || 'N/A';
-        const updated = d.updated_at
-          ? new Date(d.updated_at).toISOString().slice(0, 16)
-          : 'unknown';
-        return `${name} (${type}) — ${state}, size: ${size}, updated: ${updated}\n  command: ${command}`;
-      });
-
-      return {
-        content: `Found ${dynos.length} dyno(s) for "${params.appIdOrName}":\n${lines.join('\n')}`,
-        metadata: { count: dynos.length, app: params.appIdOrName },
-      };
-    } catch (err) {
-      return herokuError(err);
-    }
-  },
-};
-
-// ─── Tool: heroku_restart_dyno ──────────────────────────
-
-const restartDyno: ToolHandler = {
-  description:
-    'Restart a specific dyno or all dynos for a Heroku app. If dynoIdOrName is omitted, all dynos are restarted.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      appIdOrName: {
-        type: 'string',
-        description: 'App name or UUID',
-      },
-      dynoIdOrName: {
-        type: 'string',
-        description: 'Dyno name or UUID (e.g. "web.1"). Omit to restart all dynos.',
-      },
-    },
-    required: ['appIdOrName'],
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      if (params.dynoIdOrName) {
-        await ctx.apiExecutor.delete(
-          `/apps/${params.appIdOrName}/dynos/${params.dynoIdOrName}`,
-        );
-        return {
-          content: `Dyno "${params.dynoIdOrName}" restarted for app "${params.appIdOrName}".`,
-          metadata: { app: params.appIdOrName, dyno: params.dynoIdOrName },
-        };
-      } else {
-        await ctx.apiExecutor.delete(`/apps/${params.appIdOrName}/dynos`);
-        return {
-          content: `All dynos restarted for app "${params.appIdOrName}".`,
-          metadata: { app: params.appIdOrName, dyno: 'all' },
-        };
-      }
-    } catch (err) {
-      return herokuError(err);
-    }
-  },
-};
-
-// ─── Tool: heroku_get_config ────────────────────────────
-
-const getConfig: ToolHandler = {
-  description:
-    'Get config vars (environment variables) for a Heroku app. Returns all key-value pairs. Sensitive values may be masked.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      appIdOrName: {
-        type: 'string',
-        description: 'App name or UUID',
-      },
-    },
-    required: ['appIdOrName'],
-  },
-
-  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
-    try {
-      const result = await ctx.apiExecutor.get(`/apps/${params.appIdOrName}/config-vars`);
-
-      const vars = result && typeof result === 'object' ? result : {};
-      const entries = Object.entries(vars);
-
-      if (entries.length === 0) {
-        return { content: `No config vars found for app "${params.appIdOrName}".` };
-      }
-
-      const lines = entries.map(([key, value]) => {
-        // Mask potentially sensitive values
-        const masked = typeof value === 'string' && value.length > 4
-          ? `${value.slice(0, 2)}${'*'.repeat(Math.min(value.length - 4, 20))}${value.slice(-2)}`
-          : '****';
-        return `${key}=${masked}`;
-      });
-
-      return {
-        content: `Config vars for "${params.appIdOrName}" (${entries.length} var(s)):\n${lines.join('\n')}`,
-        metadata: { count: entries.length, app: params.appIdOrName, keys: entries.map(([k]) => k) },
-      };
-    } catch (err) {
-      return herokuError(err);
-    }
-  },
-};
-
-// ─── Adapter Export ─────────────────────────────────────
-
-export const herokuAdapter: SkillAdapter = {
-  skillId: 'heroku',
-  name: 'Heroku',
-  baseUrl: 'https://api.heroku.com',
-  auth: {
-    type: 'token',
-    headerPrefix: 'Bearer',
-  },
-  defaultHeaders: {
-    'Accept': 'application/vnd.heroku+json; version=3',
-  },
-  tools: {
-    heroku_list_apps: listApps,
-    heroku_get_app: getApp,
-    heroku_list_dynos: listDynos,
-    heroku_restart_dyno: restartDyno,
-    heroku_get_config: getConfig,
-  },
-  rateLimits: { requestsPerSecond: 10, burstLimit: 20 },
-};