@deimoscloud/coreai 0.1.9 → 0.1.10

package/src/adapters/mcp/types.ts

@@ -1,258 +0,0 @@
-/**
- * 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

@@ -1,350 +0,0 @@
-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);
-  });
-});