@deimoscloud/coreai 0.1.0

package/src/adapters/mcp/types.ts

@@ -0,0 +1,258 @@
+/**
+ * MCP Integration Types
+ *
+ * Types for MCP server configuration and integration.
+ */
+
+/**
+ * Transport type for MCP servers
+ */
+export type McpTransportType = 'stdio' | 'http' | 'sse';
+
+/**
+ * Configuration for a stdio-based MCP server
+ */
+export interface StdioServerConfig {
+  transport: 'stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+}
+
+/**
+ * Configuration for an HTTP-based MCP server
+ */
+export interface HttpServerConfig {
+  transport: 'http' | 'sse';
+  url: string;
+  headers?: Record<string, string>;
+}
+
+/**
+ * Union type for all MCP server configurations
+ */
+export type McpServerConfig = StdioServerConfig | HttpServerConfig;
+
+/**
+ * MCP server definition from config
+ */
+export interface McpServerDefinition {
+  /**
+   * Unique name for this server
+   */
+  name: string;
+
+  /**
+   * Server configuration
+   */
+  config: McpServerConfig;
+
+  /**
+   * Whether this server is enabled
+   */
+  enabled?: boolean;
+
+  /**
+   * Description of what this server provides
+   */
+  description?: string;
+}
+
+/**
+ * MCP config file structure (e.g., mcp.json)
+ */
+export interface McpConfigFile {
+  /**
+   * MCP servers to connect to
+   */
+  mcpServers?: Record<string, McpServerConfig>;
+}
+
+/**
+ * Information about a connected MCP server
+ */
+export interface McpServerInfo {
+  /**
+   * Server name
+   */
+  name: string;
+
+  /**
+   * Server version (if available)
+   */
+  version?: string;
+
+  /**
+   * Protocol version
+   */
+  protocolVersion?: string;
+
+  /**
+   * Server capabilities
+   */
+  capabilities?: McpCapabilities;
+
+  /**
+   * Server instructions (if any)
+   */
+  instructions?: string;
+
+  /**
+   * Whether the server is connected
+   */
+  connected: boolean;
+}
+
+/**
+ * MCP server capabilities
+ */
+export interface McpCapabilities {
+  tools?: boolean;
+  resources?: boolean;
+  prompts?: boolean;
+  logging?: boolean;
+}
+
+/**
+ * MCP tool definition
+ */
+export interface McpTool {
+  /**
+   * Tool name
+   */
+  name: string;
+
+  /**
+   * Tool description
+   */
+  description?: string;
+
+  /**
+   * Input schema for the tool
+   */
+  inputSchema: {
+    type: 'object';
+    properties?: Record<string, unknown>;
+    required?: string[];
+  };
+
+  /**
+   * Tool annotations
+   */
+  annotations?: {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+  };
+}
+
+/**
+ * MCP resource definition
+ */
+export interface McpResource {
+  /**
+   * Resource URI
+   */
+  uri: string;
+
+  /**
+   * Resource name
+   */
+  name: string;
+
+  /**
+   * Resource description
+   */
+  description?: string;
+
+  /**
+   * MIME type
+   */
+  mimeType?: string;
+}
+
+/**
+ * Result of calling an MCP tool
+ */
+export interface McpToolResult {
+  /**
+   * Tool output content
+   */
+  content: McpContent[];
+
+  /**
+   * Whether the tool call resulted in an error
+   */
+  isError?: boolean;
+
+  /**
+   * Structured content (if tool has outputSchema)
+   */
+  structuredContent?: Record<string, unknown>;
+}
+
+/**
+ * Content returned by MCP tools and resources
+ */
+export type McpContent = McpTextContent | McpImageContent | McpResourceContent;
+
+/**
+ * Text content
+ */
+export interface McpTextContent {
+  type: 'text';
+  text: string;
+}
+
+/**
+ * Image content
+ */
+export interface McpImageContent {
+  type: 'image';
+  data: string;
+  mimeType: string;
+}
+
+/**
+ * Embedded resource content
+ */
+export interface McpResourceContent {
+  type: 'resource';
+  resource: {
+    uri: string;
+    text?: string;
+    blob?: string;
+    mimeType?: string;
+  };
+}
+
+/**
+ * Error from MCP operations
+ */
+export class McpError extends Error {
+  constructor(
+    message: string,
+    public readonly code: McpErrorCode,
+    public readonly server?: string,
+    cause?: Error
+  ) {
+    super(message, { cause });
+    this.name = 'McpError';
+  }
+}
+
+/**
+ * MCP error codes
+ */
+export type McpErrorCode =
+  | 'connection_failed'
+  | 'connection_closed'
+  | 'server_not_found'
+  | 'tool_not_found'
+  | 'resource_not_found'
+  | 'invalid_config'
+  | 'transport_error'
+  | 'protocol_error'
+  | 'timeout';

package/src/adapters/native/filesystem.test.ts

@@ -0,0 +1,350 @@
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { FilesystemAdapter, createFilesystemAdapter } from './filesystem.js';
+import { AdapterError } from '../types.js';
+
+describe('FilesystemAdapter', () => {
+  let tempDir: string;
+  let adapter: FilesystemAdapter;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'filesystem-adapter-test-'));
+    adapter = createFilesystemAdapter({ basePath: tempDir });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('constructor', () => {
+    it('should create adapter with base path', () => {
+      const info = adapter.getInfo();
+      expect(info.type).toBe('state');
+      expect(info.provider).toBe('filesystem');
+      expect(info.implementation).toBe('native');
+      expect(info.connected).toBe(false);
+    });
+  });
+
+  describe('connect', () => {
+    it('should connect when base path exists', async () => {
+      await adapter.connect();
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    it('should create base path if it does not exist', async () => {
+      const newPath = join(tempDir, 'new-dir');
+      const newAdapter = createFilesystemAdapter({ basePath: newPath });
+
+      await newAdapter.connect();
+      expect(newAdapter.isConnected()).toBe(true);
+    });
+
+    it('should throw if base path is a file', async () => {
+      const filePath = join(tempDir, 'file.txt');
+      writeFileSync(filePath, 'content');
+
+      const fileAdapter = createFilesystemAdapter({ basePath: filePath });
+      await expect(fileAdapter.connect()).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should disconnect', async () => {
+      await adapter.connect();
+      await adapter.disconnect();
+      expect(adapter.isConnected()).toBe(false);
+    });
+  });
+
+  describe('read', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should read file content', async () => {
+      writeFileSync(join(tempDir, 'test.txt'), 'hello world');
+
+      const content = await adapter.read('test.txt');
+      expect(content).toBe('hello world');
+    });
+
+    it('should read file from subdirectory', async () => {
+      mkdirSync(join(tempDir, 'subdir'));
+      writeFileSync(join(tempDir, 'subdir', 'file.txt'), 'nested content');
+
+      const content = await adapter.read('subdir/file.txt');
+      expect(content).toBe('nested content');
+    });
+
+    it('should throw for non-existent file', async () => {
+      await expect(adapter.read('nonexistent.txt')).rejects.toThrow(AdapterError);
+    });
+
+    it('should throw if not connected', async () => {
+      await adapter.disconnect();
+      await expect(adapter.read('test.txt')).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('write', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should write file content', async () => {
+      await adapter.write('output.txt', 'new content');
+
+      const content = readFileSync(join(tempDir, 'output.txt'), 'utf-8');
+      expect(content).toBe('new content');
+    });
+
+    it('should overwrite existing file', async () => {
+      writeFileSync(join(tempDir, 'existing.txt'), 'old content');
+
+      await adapter.write('existing.txt', 'new content');
+
+      const content = readFileSync(join(tempDir, 'existing.txt'), 'utf-8');
+      expect(content).toBe('new content');
+    });
+
+    it('should create parent directories with recursive option', async () => {
+      await adapter.write('deep/nested/file.txt', 'content', { recursive: true });
+
+      const content = readFileSync(join(tempDir, 'deep/nested/file.txt'), 'utf-8');
+      expect(content).toBe('content');
+    });
+
+    it('should throw for non-existent parent without recursive', async () => {
+      await expect(adapter.write('nonexistent/file.txt', 'content')).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('exists', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should return true for existing file', async () => {
+      writeFileSync(join(tempDir, 'exists.txt'), 'content');
+
+      const exists = await adapter.exists('exists.txt');
+      expect(exists).toBe(true);
+    });
+
+    it('should return true for existing directory', async () => {
+      mkdirSync(join(tempDir, 'subdir'));
+
+      const exists = await adapter.exists('subdir');
+      expect(exists).toBe(true);
+    });
+
+    it('should return false for non-existent path', async () => {
+      const exists = await adapter.exists('nonexistent');
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('list', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should list directory contents', async () => {
+      writeFileSync(join(tempDir, 'file1.txt'), 'content1');
+      writeFileSync(join(tempDir, 'file2.txt'), 'content2');
+      mkdirSync(join(tempDir, 'subdir'));
+
+      const entries = await adapter.list('.');
+      expect(entries.length).toBe(3);
+
+      const names = entries.map((e) => e.name).sort();
+      expect(names).toEqual(['file1.txt', 'file2.txt', 'subdir']);
+
+      const file1 = entries.find((e) => e.name === 'file1.txt');
+      expect(file1?.type).toBe('file');
+      expect(file1?.size).toBeDefined();
+
+      const subdir = entries.find((e) => e.name === 'subdir');
+      expect(subdir?.type).toBe('directory');
+    });
+
+    it('should throw for non-existent directory', async () => {
+      await expect(adapter.list('nonexistent')).rejects.toThrow(AdapterError);
+    });
+
+    it('should throw if path is a file', async () => {
+      writeFileSync(join(tempDir, 'file.txt'), 'content');
+      await expect(adapter.list('file.txt')).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('delete', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should delete a file', async () => {
+      writeFileSync(join(tempDir, 'to-delete.txt'), 'content');
+
+      await adapter.delete('to-delete.txt');
+
+      const exists = await adapter.exists('to-delete.txt');
+      expect(exists).toBe(false);
+    });
+
+    it('should delete empty directory', async () => {
+      mkdirSync(join(tempDir, 'empty-dir'));
+
+      await adapter.delete('empty-dir');
+
+      const exists = await adapter.exists('empty-dir');
+      expect(exists).toBe(false);
+    });
+
+    it('should delete non-empty directory with recursive', async () => {
+      mkdirSync(join(tempDir, 'non-empty'));
+      writeFileSync(join(tempDir, 'non-empty', 'file.txt'), 'content');
+
+      await adapter.delete('non-empty', { recursive: true });
+
+      const exists = await adapter.exists('non-empty');
+      expect(exists).toBe(false);
+    });
+
+    it('should throw for non-empty directory without recursive', async () => {
+      mkdirSync(join(tempDir, 'non-empty'));
+      writeFileSync(join(tempDir, 'non-empty', 'file.txt'), 'content');
+
+      await expect(adapter.delete('non-empty')).rejects.toThrow(AdapterError);
+    });
+
+    it('should not throw for non-existent path', async () => {
+      await expect(adapter.delete('nonexistent')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('mkdir', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should create directory', async () => {
+      await adapter.mkdir('new-dir');
+
+      const exists = await adapter.exists('new-dir');
+      expect(exists).toBe(true);
+    });
+
+    it('should create nested directories with recursive', async () => {
+      await adapter.mkdir('a/b/c', { recursive: true });
+
+      const exists = await adapter.exists('a/b/c');
+      expect(exists).toBe(true);
+    });
+
+    it('should not throw if directory already exists', async () => {
+      mkdirSync(join(tempDir, 'existing-dir'));
+
+      await expect(adapter.mkdir('existing-dir')).resolves.toBeUndefined();
+    });
+
+    it('should throw for nested path without recursive', async () => {
+      await expect(adapter.mkdir('a/b/c')).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('move', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should move/rename a file', async () => {
+      writeFileSync(join(tempDir, 'source.txt'), 'content');
+
+      await adapter.move('source.txt', 'dest.txt');
+
+      expect(await adapter.exists('source.txt')).toBe(false);
+      expect(await adapter.exists('dest.txt')).toBe(true);
+
+      const content = await adapter.read('dest.txt');
+      expect(content).toBe('content');
+    });
+
+    it('should move/rename a directory', async () => {
+      mkdirSync(join(tempDir, 'source-dir'));
+      writeFileSync(join(tempDir, 'source-dir', 'file.txt'), 'content');
+
+      await adapter.move('source-dir', 'dest-dir');
+
+      expect(await adapter.exists('source-dir')).toBe(false);
+      expect(await adapter.exists('dest-dir')).toBe(true);
+      expect(await adapter.exists('dest-dir/file.txt')).toBe(true);
+    });
+
+    it('should throw for non-existent source', async () => {
+      await expect(adapter.move('nonexistent', 'dest')).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('copy', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should copy a file', async () => {
+      writeFileSync(join(tempDir, 'source.txt'), 'content');
+
+      await adapter.copy('source.txt', 'copy.txt');
+
+      expect(await adapter.exists('source.txt')).toBe(true);
+      expect(await adapter.exists('copy.txt')).toBe(true);
+
+      const content = await adapter.read('copy.txt');
+      expect(content).toBe('content');
+    });
+
+    it('should copy a directory recursively', async () => {
+      mkdirSync(join(tempDir, 'source-dir'));
+      mkdirSync(join(tempDir, 'source-dir', 'nested'));
+      writeFileSync(join(tempDir, 'source-dir', 'file.txt'), 'content');
+      writeFileSync(join(tempDir, 'source-dir', 'nested', 'nested.txt'), 'nested');
+
+      await adapter.copy('source-dir', 'copy-dir');
+
+      expect(await adapter.exists('source-dir')).toBe(true);
+      expect(await adapter.exists('copy-dir')).toBe(true);
+      expect(await adapter.exists('copy-dir/file.txt')).toBe(true);
+      expect(await adapter.exists('copy-dir/nested/nested.txt')).toBe(true);
+
+      const content = await adapter.read('copy-dir/nested/nested.txt');
+      expect(content).toBe('nested');
+    });
+
+    it('should throw for non-existent source', async () => {
+      await expect(adapter.copy('nonexistent', 'dest')).rejects.toThrow(AdapterError);
+    });
+  });
+
+  describe('path traversal protection', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should prevent path traversal with ..', async () => {
+      await expect(adapter.read('../outside.txt')).rejects.toThrow(AdapterError);
+    });
+
+    it('should prevent path traversal with absolute paths', async () => {
+      await expect(adapter.read('/etc/passwd')).rejects.toThrow(AdapterError);
+    });
+  });
+});
+
+describe('createFilesystemAdapter', () => {
+  it('should create a filesystem adapter', () => {
+    const adapter = createFilesystemAdapter({ basePath: '/tmp' });
+    expect(adapter).toBeInstanceOf(FilesystemAdapter);
+  });
+});