import { quickStart, defineTool } from '@claude-flow/mcp';

// Create and start server
const server = await quickStart({
  transport: 'stdio',
  name: 'My MCP Server',
});

// Register custom tools
server.registerTool(defineTool(
  'greet',
  'Greet a user',
  {
    type: 'object',
    properties: {
      name: { type: 'string', description: 'User name' }
    },
    required: ['name']
  },
  async ({ name }) => ({ message: `Hello, ${name}!` })
));

// Start listening
await server.start();

import { createMCPServer } from '@claude-flow/mcp';

const server = createMCPServer({
  transport: 'stdio',
  name: 'Stdio Server',
}, logger);

await server.start();

const server = createMCPServer({
  transport: 'http',
  host: 'localhost',
  port: 3000,
  corsEnabled: true,
  corsOrigins: ['http://localhost:8080'],
  auth: {
    enabled: true,
    method: 'token',
    tokens: ['secret-token'],
  },
}, logger);

await server.start();
// Server at http://localhost:3000
// WebSocket at ws://localhost:3000/ws

const server = createMCPServer({
  transport: 'websocket',
  host: 'localhost',
  port: 3001,
  maxConnections: 100,
  heartbeatInterval: 30000,
}, logger);

await server.start();
// WebSocket at ws://localhost:3001/ws

import { createToolRegistry, defineTool } from '@claude-flow/mcp';

const registry = createToolRegistry(logger);

// Register tool
registry.register({
  name: 'calculate',
  description: 'Perform calculations',
  inputSchema: {
    type: 'object',
    properties: {
      expression: { type: 'string' }
    }
  },
  handler: async ({ expression }) => {
    return { result: eval(expression) };
  },
  category: 'math',
  tags: ['calculator'],
});

// Execute tool
const result = await registry.execute('calculate', { expression: '2 + 2' });

// Search tools
const mathTools = registry.getByCategory('math');
const stats = registry.getStats();

import { createSessionManager } from '@claude-flow/mcp';

const sessions = createSessionManager(logger, {
  maxSessions: 100,
  sessionTimeout: 30 * 60 * 1000, // 30 minutes
});

// Create session
const session = sessions.createSession('http');

// Initialize with client info
sessions.initializeSession(session.id, {
  protocolVersion: { major: 2024, minor: 11, patch: 5 },
  capabilities: { tools: { listChanged: true } },
  clientInfo: { name: 'Claude', version: '1.0' },
});

// Get metrics
const metrics = sessions.getSessionMetrics();
// { total: 1, active: 1, authenticated: 0, expired: 0 }

import { createConnectionPool } from '@claude-flow/mcp';

const pool = createConnectionPool({
  maxConnections: 10,
  minConnections: 2,
  idleTimeout: 30000,
  acquireTimeout: 5000,
}, logger, 'http');

// Acquire connection
const conn = await pool.acquire();

// Use connection...

// Release back to pool
pool.release(conn);

// Get stats
const stats = pool.getStats();
// { totalConnections: 5, idleConnections: 4, busyConnections: 1, ... }

interface IMCPServer {
  start(): Promise<void>;
  stop(): Promise<void>;
  registerTool(tool: MCPTool): boolean;
  registerTools(tools: MCPTool[]): { registered: number; failed: string[] };
  getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;
  getMetrics(): MCPServerMetrics;
  getSessions(): MCPSession[];
  getSession(sessionId: string): MCPSession | undefined;
  terminateSession(sessionId: string): boolean;
}

interface MCPTool<TInput = unknown, TOutput = unknown> {
  name: string;
  description: string;
  inputSchema: JSONSchema;
  handler: (input: TInput, context?: ToolContext) => Promise<TOutput>;
  category?: string;
  tags?: string[];
  cacheable?: boolean;
  cacheTTL?: number;
  timeout?: number;
}

interface ITransport {
  readonly type: TransportType;
  start(): Promise<void>;
  stop(): Promise<void>;
  onRequest(handler: RequestHandler): void;
  onNotification(handler: NotificationHandler): void;
  sendNotification?(notification: MCPNotification): Promise<void>;
  getHealthStatus(): Promise<TransportHealthStatus>;
}

import { createMCPServer, createTextResource } from '@claude-flow/mcp';

const server = createMCPServer({ transport: 'stdio' }, logger);
const resourceRegistry = server.getResourceRegistry();

// Register a text resource
const { resource, handler } = createTextResource(
  'file://readme.txt',
  'README',
  'Welcome to the application!',
  { mimeType: 'text/plain' }
);
resourceRegistry.registerResource(resource, handler);

// Register with custom handler
resourceRegistry.registerResource(
  {
    uri: 'db://users/{id}',
    name: 'User Data',
    description: 'Get user by ID',
    mimeType: 'application/json',
  },
  async (uri) => {
    const id = uri.split('/').pop();
    const user = await fetchUser(id);
    return [{ uri, mimeType: 'application/json', text: JSON.stringify(user) }];
  }
);

// Subscribe to updates
resourceRegistry.subscribe('file://readme.txt', (uri, content) => {
  console.log('Resource updated:', uri);
});

import { createMCPServer, definePrompt, textMessage, interpolate } from '@claude-flow/mcp';

const server = createMCPServer({ transport: 'stdio' }, logger);
const promptRegistry = server.getPromptRegistry();

// Define a prompt with arguments
const codeReviewPrompt = definePrompt(
  'code_review',
  'Review code for quality and best practices',
  async (args) => [
    textMessage('user', `Please review this ${args.language} code:\n\n${args.code}`),
  ],
  {
    title: 'Code Review',
    arguments: [
      { name: 'code', description: 'The code to review', required: true },
      { name: 'language', description: 'Programming language', required: false },
    ],
  }
);

promptRegistry.register(codeReviewPrompt);

// Get prompt with arguments
const result = await promptRegistry.get('code_review', {
  code: 'function hello() { return "world"; }',
  language: 'JavaScript',
});

import { createMCPServer } from '@claude-flow/mcp';

const server = createMCPServer({ transport: 'stdio' }, logger);
const taskManager = server.getTaskManager();

// Create a long-running task
const taskId = taskManager.createTask(async (reportProgress, signal) => {
  for (let i = 0; i <= 100; i += 10) {
    if (signal.aborted) throw new Error('Task cancelled');

    reportProgress({
      progress: i,
      total: 100,
      message: `Processing... ${i}%`,
    });

    await new Promise(r => setTimeout(r, 100));
  }

  return { success: true, processedItems: 100 };
});

// Get task status
const status = taskManager.getTask(taskId);

// Wait for completion
const result = await taskManager.waitForTask(taskId);

// Cancel a task
taskManager.cancelTask(taskId, 'User requested cancellation');

const server = createMCPServer({
  auth: {
    enabled: true,
    method: 'token',
    tokens: ['your-secret-token'],
  },
}, logger);

const server = createMCPServer({
  transport: 'http',
  corsEnabled: true,
  corsOrigins: ['https://your-domain.com'],
}, logger);

const ErrorCodes = {
  PARSE_ERROR: -32700,
  INVALID_REQUEST: -32600,
  METHOD_NOT_FOUND: -32601,
  INVALID_PARAMS: -32602,
  INTERNAL_ERROR: -32603,
  SERVER_NOT_INITIALIZED: -32002,
  AUTHENTICATION_REQUIRED: -32001,
};