air-mcp-server 0.1.0

package/dist/packages/mcp-server/src/config.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const ConfigSchema: z.ZodObject<{
+    dbPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    dbPath: string;
+}, {
+    dbPath: string;
+}>;
+export type McpServerConfig = z.infer<typeof ConfigSchema>;
+export declare function resolveDbPath(args: string[], env?: NodeJS.ProcessEnv): string;
+export declare function resolveHttpPort(args: string[], env?: NodeJS.ProcessEnv): number;
+export declare function shouldShowHelp(args: string[]): boolean;
+export declare function formatHelp(transport: 'stdio' | 'http'): string;
+/**
+ * Parses simple CLI arguments like --db path/to/air.db
+ */
+export declare function parseArgs(args: string[]): McpServerConfig;

package/dist/packages/mcp-server/src/config.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigSchema = void 0;
+exports.resolveDbPath = resolveDbPath;
+exports.resolveHttpPort = resolveHttpPort;
+exports.shouldShowHelp = shouldShowHelp;
+exports.formatHelp = formatHelp;
+exports.parseArgs = parseArgs;
+const zod_1 = require("zod");
+const path = __importStar(require("path"));
+const air_home_1 = require("../../../core/utils/air-home");
+exports.ConfigSchema = zod_1.z.object({
+    dbPath: zod_1.z.string().min(1, 'DB path must be provided via --db or AIR_MCP_DB_PATH'),
+});
+const DEFAULT_HTTP_PORT = 3333;
+function readFlag(args, name) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === name && args[i + 1]) {
+            return args[i + 1];
+        }
+        if (arg.startsWith(`${name}=`)) {
+            return arg.slice(name.length + 1);
+        }
+    }
+    return undefined;
+}
+function resolveDbPath(args, env = process.env) {
+    const dbArg = readFlag(args, '--db');
+    const dbPath = dbArg ?? env.AIR_MCP_DB_PATH ?? env.AIR_DB_PATH;
+    if (dbPath) {
+        return path.resolve(dbPath);
+    }
+    return (0, air_home_1.getDatabasePath)();
+}
+function resolveHttpPort(args, env = process.env) {
+    const portValue = readFlag(args, '--port') ?? env.AIR_MCP_PORT;
+    if (!portValue) {
+        return DEFAULT_HTTP_PORT;
+    }
+    const parsed = Number.parseInt(portValue, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid port: ${portValue}`);
+    }
+    return parsed;
+}
+function shouldShowHelp(args) {
+    return args.includes('--help') || args.includes('-h');
+}
+function formatHelp(transport) {
+    const lines = [
+        'AIR MCP Server',
+        '',
+        'Configuration:',
+        '  --db <path>           Path to AIR SQLite database',
+        '  AIR_MCP_DB_PATH       Database path environment variable',
+        '  AIR_DB_PATH           Database path environment variable',
+        '  Fallback              ~/.air/air-data.db',
+    ];
+    if (transport === 'http') {
+        lines.push('  --port <number>       HTTP port for Streamable MCP transport');
+        lines.push('  AIR_MCP_PORT          HTTP port environment variable');
+    }
+    lines.push('');
+    lines.push('Examples:');
+    lines.push('  stdio: node scripts/air-mcp.cjs --db C:/path/to/air-data.db');
+    lines.push('  http:  node scripts/air-mcp.cjs --transport http --db C:/path/to/air-data.db --port 3333');
+    return lines.join('\n');
+}
+/**
+ * Parses simple CLI arguments like --db path/to/air.db
+ */
+function parseArgs(args) {
+    const parsed = {
+        dbPath: resolveDbPath(args),
+    };
+    const result = exports.ConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(`Invalid configuration: ${result.error.message}`);
+    }
+    return result.data;
+}

package/dist/packages/mcp-server/src/context.d.ts

@@ -0,0 +1,10 @@
+import { CodegenService } from '@air/codegen';
+import { McpServerConfig } from './config';
+/**
+ * Context holds shared services so tools don't instantiate them repeatedly.
+ */
+export interface McpContext {
+    config: McpServerConfig;
+    getCodegenService(): CodegenService;
+}
+export declare function createContext(config: McpServerConfig): McpContext;

package/dist/packages/mcp-server/src/context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+const codegen_1 = require("@air/codegen");
+function createContext(config) {
+    let _codegenService = null;
+    return {
+        config,
+        getCodegenService: () => {
+            if (!_codegenService) {
+                // Pass the configured DB path down to the CodegenService.
+                // It handles opening it natively in query_only mode.
+                _codegenService = new codegen_1.CodegenService({ dbPath: config.dbPath });
+            }
+            return _codegenService;
+        }
+    };
+}

package/dist/packages/mcp-server/src/http.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/mcp-server/src/http.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const express_js_1 = require("@modelcontextprotocol/sdk/server/express.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const server_1 = require("./server");
+const HTTP_BIND_HOST = '127.0.0.1';
+const MAX_HTTP_SESSIONS = 10;
+const HTTP_SESSION_IDLE_TTL_MS = 15 * 60 * 1000;
+const HTTP_SESSION_CLEANUP_INTERVAL_MS = 60 * 1000;
+function parseHttpArgs(args) {
+    const base = (0, config_1.parseArgs)(args);
+    return {
+        dbPath: base.dbPath,
+        port: (0, config_1.resolveHttpPort)(args),
+    };
+}
+async function main() {
+    if ((0, config_1.shouldShowHelp)(process.argv.slice(2))) {
+        console.error((0, config_1.formatHelp)('http'));
+        process.exit(0);
+    }
+    const config = parseHttpArgs(process.argv.slice(2));
+    const context = (0, context_1.createContext)({ dbPath: config.dbPath });
+    const app = (0, express_js_1.createMcpExpressApp)();
+    const sessions = new Map();
+    function getSessionId(req) {
+        const headerValue = req.headers['mcp-session-id'];
+        return typeof headerValue === 'string' ? headerValue : undefined;
+    }
+    function sendJsonRpcError(res, statusCode, message) {
+        res.status(statusCode).json({
+            jsonrpc: '2.0',
+            error: {
+                code: -32000,
+                message,
+            },
+            id: null,
+        });
+    }
+    function sendInternalServerError(res) {
+        res.status(500).json({
+            jsonrpc: '2.0',
+            error: {
+                code: -32603,
+                message: 'Internal server error',
+            },
+            id: null,
+        });
+    }
+    async function cleanupSession(sessionId, reason) {
+        const session = sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        sessions.delete(sessionId);
+        try {
+            await session.transport.close?.();
+        }
+        catch (error) {
+            console.error('[AIR MCP] Failed to close HTTP transport:', error);
+        }
+        try {
+            await session.server.close?.();
+        }
+        catch (error) {
+            console.error('[AIR MCP] Failed to close MCP server:', error);
+        }
+        console.error(`[AIR MCP] HTTP session cleaned up: ${sessionId} (${reason})`);
+    }
+    async function handleExistingSessionRequest(req, res) {
+        try {
+            const sessionId = getSessionId(req);
+            const session = sessionId ? sessions.get(sessionId) : undefined;
+            if (!session) {
+                res.status(400).send('Invalid or missing session ID');
+                return;
+            }
+            session.lastSeenAt = Date.now();
+            await session.transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error('[AIR MCP] HTTP existing-session error:', error);
+            if (!res.headersSent) {
+                sendInternalServerError(res);
+            }
+        }
+    }
+    const cleanupTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [sessionId, session] of sessions.entries()) {
+            if (now - session.lastSeenAt > HTTP_SESSION_IDLE_TTL_MS) {
+                void cleanupSession(sessionId, 'idle-timeout');
+            }
+        }
+    }, HTTP_SESSION_CLEANUP_INTERVAL_MS);
+    cleanupTimer.unref?.();
+    app.get('/health', (_req, res) => {
+        res.json({
+            ok: true,
+            server: 'air-mcp-server',
+            transport: 'streamable-http',
+        });
+    });
+    const handleMcpRequest = async (req, res) => {
+        const sessionId = getSessionId(req);
+        try {
+            const existingSession = sessionId ? sessions.get(sessionId) : undefined;
+            if (existingSession) {
+                existingSession.lastSeenAt = Date.now();
+                await existingSession.transport.handleRequest(req, res, req.body);
+                return;
+            }
+            if (!existingSession) {
+                if (sessionId || !(0, types_js_1.isInitializeRequest)(req.body)) {
+                    sendJsonRpcError(res, 400, 'Bad Request: No valid session ID provided');
+                    return;
+                }
+                if (sessions.size >= MAX_HTTP_SESSIONS) {
+                    sendJsonRpcError(res, 429, 'Too many active MCP HTTP sessions');
+                    return;
+                }
+                const server = (0, server_1.createMcpServer)(context);
+                const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+                    onsessioninitialized: (newSessionId) => {
+                        const now = Date.now();
+                        sessions.set(newSessionId, {
+                            id: newSessionId,
+                            server,
+                            transport,
+                            createdAt: now,
+                            lastSeenAt: now,
+                        });
+                    },
+                });
+                transport.onclose = () => {
+                    const activeSessionId = transport.sessionId;
+                    if (activeSessionId) {
+                        void cleanupSession(activeSessionId, 'transport-close');
+                    }
+                };
+                await server.connect(transport);
+                await transport.handleRequest(req, res, req.body);
+                return;
+            }
+        }
+        catch (error) {
+            console.error('[AIR MCP] HTTP transport error:', error);
+            if (!res.headersSent) {
+                sendInternalServerError(res);
+            }
+        }
+    };
+    app.post('/mcp', handleMcpRequest);
+    app.get('/mcp', handleExistingSessionRequest);
+    app.delete('/mcp', handleExistingSessionRequest);
+    const httpServer = app.listen(config.port, HTTP_BIND_HOST, (error) => {
+        if (error) {
+            console.error('[AIR MCP] Failed to start HTTP server:', error);
+            process.exit(1);
+        }
+        console.error(`[AIR MCP] Streamable HTTP server listening on http://${HTTP_BIND_HOST}:${config.port}/mcp`);
+        console.error(`[AIR MCP] Database path: ${config.dbPath}`);
+    });
+    async function shutdown(reason) {
+        clearInterval(cleanupTimer);
+        const activeSessionIds = [...sessions.keys()];
+        for (const sessionId of activeSessionIds) {
+            await cleanupSession(sessionId, reason);
+        }
+        await new Promise((resolve) => {
+            httpServer.close(() => resolve());
+        });
+    }
+    process.on('SIGINT', () => {
+        void shutdown('sigint').finally(() => process.exit(0));
+    });
+    process.on('SIGTERM', () => {
+        void shutdown('sigterm').finally(() => process.exit(0));
+    });
+}
+main().catch((error) => {
+    console.error('[AIR MCP] Fatal HTTP initialization error:', error);
+    process.exit(1);
+});

package/dist/packages/mcp-server/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/mcp-server/src/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const server_1 = require("./server");
+async function main() {
+    try {
+        if ((0, config_1.shouldShowHelp)(process.argv.slice(2))) {
+            console.error((0, config_1.formatHelp)('stdio'));
+            process.exit(0);
+        }
+        // 1. Parse arguments (e.g., node dist/index.js --db path/to/air.db)
+        const config = (0, config_1.parseArgs)(process.argv.slice(2));
+        // 2. Initialize context (CodegenService with read-only DB connection)
+        const context = (0, context_1.createContext)(config);
+        // 3. Create the MCP Server instance
+        const server = (0, server_1.createMcpServer)(context);
+        // 4. Wire up the stdio transport
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+        // Provide logging to stderr so it doesn't break the JSON stdio protocol on stdout
+        console.error(`[AIR MCP] Server running on stdio`);
+        console.error(`[AIR MCP] Database path: ${config.dbPath}`);
+        // Graceful shutdown
+        process.on('SIGINT', async () => {
+            console.error(`[AIR MCP] Shutting down...`);
+            await server.close();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.error(`[AIR MCP] Fatal initialization error:`, error);
+        process.exit(1);
+    }
+}
+main().catch(console.error);

package/dist/packages/mcp-server/src/server.d.ts

@@ -0,0 +1,18 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpContext } from './context';
+export type AirMcpToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+export type AirMcpToolResponse = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+};
+export type AirMcpToolHandler = {
+    definition: AirMcpToolDefinition;
+    handle: (args: unknown, context: McpContext) => Promise<AirMcpToolResponse>;
+};
+export declare function createMcpServer(context: McpContext): Server;

package/dist/packages/mcp-server/src/server.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const tools_1 = require("./tools");
+const AIR_MCP_INSTRUCTIONS = 'Use AIR tools first for questions about recorded AIR sessions, AIR flow reviews, or AIR generation context. ' +
+    'Prefer list_recorded_sessions instead of searching files or querying SQLite directly when the user asks to list or find sessions. ' +
+    'After selecting a session, use get_session_flow_review for a human-readable review and get_session_generation_context for structured machine-readable step data. ' +
+    'Do not inspect the AIR database via shell when an AIR MCP tool can answer the request.';
+function createMcpServer(context) {
+    const server = new index_js_1.Server({
+        name: 'air-mcp-server',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: AIR_MCP_INSTRUCTIONS,
+    });
+    const tools = (0, tools_1.getToolHandlers)();
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return {
+            tools: tools.map(tool => tool.definition),
+        };
+    });
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const tool = tools.find(t => t.definition.name === request.params.name);
+        if (!tool) {
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+        }
+        return tool.handle(request.params.arguments ?? {}, context);
+    });
+    return server;
+}

package/dist/packages/mcp-server/src/tools/get-session-flow-review.d.ts

@@ -0,0 +1,2 @@
+import { AirMcpToolHandler } from '../server';
+export declare const getSessionFlowReviewTool: AirMcpToolHandler;

package/dist/packages/mcp-server/src/tools/get-session-flow-review.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionFlowReviewTool = void 0;
+const zod_1 = require("zod");
+const privacy_1 = require("../utils/privacy");
+const errors_1 = require("../utils/errors");
+const GetSessionFlowReviewArgsSchema = zod_1.z.object({
+    sessionId: zod_1.z.string().min(1),
+});
+function getSessionIdFromArgs(args) {
+    if (args &&
+        typeof args === 'object' &&
+        'sessionId' in args &&
+        typeof args.sessionId === 'string') {
+        return args.sessionId;
+    }
+    return 'unknown';
+}
+exports.getSessionFlowReviewTool = {
+    definition: {
+        name: 'get_session_flow_review',
+        description: 'Return a human-readable AIR FlowReview for a recorded session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: {
+                    type: 'string',
+                    description: 'The AIR recorded session ID to review.',
+                },
+            },
+            required: ['sessionId'],
+            additionalProperties: false,
+        },
+    },
+    handle: async (args, context) => {
+        try {
+            const parsedArgs = GetSessionFlowReviewArgsSchema.parse(args || {});
+            const markdown = context
+                .getCodegenService()
+                .getFlowReviewMarkdown(parsedArgs.sessionId);
+            const wrapped = (0, privacy_1.wrapWithPrivacy)({ markdown });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(wrapped, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                throw (0, errors_1.createInvalidArgumentsError)(error.message);
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('Session not found')) {
+                throw (0, errors_1.createSessionNotFoundError)(getSessionIdFromArgs(args));
+            }
+            throw (0, errors_1.createDatabaseUnavailableError)(error instanceof Error ? error.message : 'Unknown database error');
+        }
+    },
+};

package/dist/packages/mcp-server/src/tools/get-session-generation-context.d.ts

@@ -0,0 +1,2 @@
+import { AirMcpToolHandler } from '../server';
+export declare const getSessionGenerationContextTool: AirMcpToolHandler;

package/dist/packages/mcp-server/src/tools/get-session-generation-context.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionGenerationContextTool = void 0;
+const zod_1 = require("zod");
+const privacy_1 = require("../utils/privacy");
+const errors_1 = require("../utils/errors");
+const GetSessionGenerationContextArgsSchema = zod_1.z.object({
+    sessionId: zod_1.z.string().min(1),
+    offset: zod_1.z.number().optional(),
+    limit: zod_1.z.number().optional(),
+});
+function normalizePagination(args) {
+    const rawOffset = args.offset ?? 0;
+    const offset = Math.max(Math.floor(rawOffset), 0);
+    const rawLimit = args.limit ?? 25;
+    const limit = Math.min(Math.max(Math.floor(rawLimit), 1), 100);
+    return { offset, limit };
+}
+function getSessionIdFromArgs(args) {
+    if (args &&
+        typeof args === 'object' &&
+        'sessionId' in args &&
+        typeof args.sessionId === 'string') {
+        return args.sessionId;
+    }
+    return 'unknown';
+}
+exports.getSessionGenerationContextTool = {
+    definition: {
+        name: 'get_session_generation_context',
+        description: 'Return a paginated machine-readable AIR GenerationContext for a recorded session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: {
+                    type: 'string',
+                    description: 'The AIR recorded session ID.',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Pagination offset. Default 0.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Pagination limit. Default 25, max 100.',
+                },
+            },
+            required: ['sessionId'],
+            additionalProperties: false,
+        },
+    },
+    handle: async (args, context) => {
+        try {
+            const parsedArgs = GetSessionGenerationContextArgsSchema.parse(args || {});
+            const { offset, limit } = normalizePagination(parsedArgs);
+            const service = context.getCodegenService();
+            const generationContext = service.buildGenerationContext(parsedArgs.sessionId);
+            const totalSteps = generationContext.steps.length;
+            const steps = generationContext.steps.slice(offset, offset + limit);
+            const hasMore = offset + limit < totalSteps;
+            const resolvedSteps = generationContext.steps.filter(s => s.locatorStatus === 'resolved').length;
+            const unresolvedSteps = generationContext.steps.filter(s => s.locatorStatus === 'unresolved').length;
+            const notApplicableSteps = generationContext.steps.filter(s => s.locatorStatus === 'not_applicable').length;
+            const assertionCount = generationContext.steps.reduce((sum, step) => sum + (step.assertions?.length || 0), 0);
+            const ignoredStepsCount = generationContext.ignoredSteps?.length ?? 0;
+            const response = {
+                schemaVersion: 'air:mcp-generation-context-response:v1',
+                generationContextSchemaVersion: generationContext.schemaVersion,
+                sessionId: generationContext.sessionId,
+                url: generationContext.url,
+                recordedAt: generationContext.recordedAt,
+                metadata: generationContext.metadata,
+                totalSteps,
+                offset,
+                limit,
+                hasMore,
+                summary: {
+                    resolvedSteps,
+                    unresolvedSteps,
+                    notApplicableSteps,
+                    assertionCount,
+                    ignoredStepsCount,
+                },
+                steps,
+                /**
+                 * Recorded steps not recommended for replay.
+                 * The LLM must NOT generate code from these unless explicitly requested.
+                 * Use for context, diagnostics, and fallback explanation only.
+                 */
+                ignoredSteps: generationContext.ignoredSteps ?? [],
+                /**
+                 * Typed generation rules for the IDE LLM.
+                 * Follow these rules in addition to any user-provided instructions.
+                 */
+                generationGuidance: generationContext.generationGuidance,
+            };
+            const wrapped = (0, privacy_1.wrapWithPrivacy)(response);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(wrapped, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                throw (0, errors_1.createInvalidArgumentsError)(error.message);
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('Session not found')) {
+                throw (0, errors_1.createSessionNotFoundError)(getSessionIdFromArgs(args));
+            }
+            throw (0, errors_1.createDatabaseUnavailableError)(error instanceof Error ? error.message : 'Unknown database error');
+        }
+    },
+};

package/dist/packages/mcp-server/src/tools/index.d.ts

@@ -0,0 +1,2 @@
+import type { AirMcpToolHandler } from '../server';
+export declare function getToolHandlers(): AirMcpToolHandler[];

package/dist/packages/mcp-server/src/tools/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolHandlers = getToolHandlers;
+const list_recorded_sessions_1 = require("./list-recorded-sessions");
+const get_session_flow_review_1 = require("./get-session-flow-review");
+const get_session_generation_context_1 = require("./get-session-generation-context");
+function getToolHandlers() {
+    return [
+        list_recorded_sessions_1.listRecordedSessionsTool,
+        get_session_flow_review_1.getSessionFlowReviewTool,
+        get_session_generation_context_1.getSessionGenerationContextTool,
+    ];
+}

package/dist/packages/mcp-server/src/tools/list-recorded-sessions.d.ts

@@ -0,0 +1,2 @@
+import { AirMcpToolHandler } from '../server';
+export declare const listRecordedSessionsTool: AirMcpToolHandler;