mcp-insomnia 0.1.0

package/README.md

@@ -0,0 +1,125 @@
+# MCP-Insomnia
+
+MCP-Insomnia is an MCP (Model Context Protocol) server that enables AI agents to create and manage API collections in Insomnia-compatible format. This server provides tools and resources for managing collections, requests, and environments that can be exported to Insomnia.
+
+## Installation
+
+### Prerequisites
+
+- Node.js 18+
+- npm or yarn
+
+### Install from NPM
+
+```bash
+npm install -g mcp-insomnia
+```
+
+### Install from Source
+
+```bash
+git clone https://github.com/anggasct/mcp-insomnia.git
+cd mcp-insomnia
+npm install
+npm run build
+```
+
+### Add to MCP Configuration
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "insomnia": {
+      "command": "mcp-insomnia"
+    }
+  }
+}
+```
+
+Or if installed from source:
+
+```json
+{
+  "mcpServers": {
+    "insomnia": {
+      "command": "node",
+      "args": ["/path/to/mcp-insomnia/dist/index.js"]
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Collection Management
+
+- `create_collection` - Create new collection/workspace
+- `list_collections` - List all collections
+- `export_collection` - Export collection to JSON format
+- `import_from_insomnia_export` - Import collections from a standard Insomnia V4 export file
+
+### Folder Management  
+
+- `create_folder` - Create folder within collection
+
+### Request Management
+
+- `create_request_in_collection` - Create new request
+- `update_request` - Update existing request
+- `delete_request` - Delete request
+- `execute_request` - Execute request and view response
+
+### Environment Management
+
+- `set_environment_variable` - Set environment variable
+- `get_environment_variables` - Get environment variables
+
+## Available Resources
+
+- `insomnia://collections` - List all collections
+- `insomnia://requests` - List all requests. Can be filtered by `?collectionId={id}`.
+- `insomnia://environments` - List environment variables. Can be filtered by `?collectionId={id}`.
+- `insomnia://collection/{id}` - Specific collection details
+- `insomnia://request/{id}` - Specific request details
+- `insomnia://request/{id}/history` - Get the execution history for a specific request
+- `insomnia://search?q={keyword}` - Search across all collections, folders, and requests.
+- `insomnia://stats` - Global statistics
+
+## Usage Examples
+
+### Create Collection
+
+```
+Create a new collection named "API Testing" for testing endpoints
+```
+
+### Add Request
+
+```
+Add GET request to "API Testing" collection with:
+- Name: Get Users
+- URL: https://jsonplaceholder.typicode.com/users
+- Headers: Content-Type: application/json
+```
+
+### Set Environment Variable
+
+```
+Set environment variable "baseUrl" with value "https://api.example.com" for "API Testing" collection
+```
+
+### Execute Request
+
+```
+Execute "Get Users" request using the configured environment variables
+```
+
+## Data Storage
+
+Data is stored in `~/.mcp-insomnia/collections.json` in JSON format.
+
+## License
+
+MIT License

package/dist/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm --prefix .. run build)",
+      "Bash(npm:*)"
+    ],
+    "deny": []
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { createInsomniaTools } from './tools.js';
+import { createInsomniaResources } from './resources.js';
+const server = new Server({
+    name: 'mcp-insomnia',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+const tools = createInsomniaTools();
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        })),
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name } = request.params;
+    const tool = tools.find(t => t.name === name);
+    if (!tool) {
+        throw new Error(`Tool ${name} not found`);
+    }
+    return await tool.handler(request);
+});
+const resources = createInsomniaResources();
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: resources.map(resource => ({
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType,
+        })),
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const resource = resources.find(r => r.uri === uri || uri.startsWith(r.uri.replace('{id}', '')));
+    if (!resource) {
+        throw new Error(`Resource ${uri} not found`);
+    }
+    return await resource.handler(request);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('MCP Insomnia server running on stdio');
+}
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC1J,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,MAAM,MAAM,GAAG,IAAI,MAAM,CACvB;IACE,IAAI,EAAE,cAAc;IACpB,OAAO,EAAE,OAAO;CACjB,EACD;IACE,YAAY,EAAE;QACZ,KAAK,EAAE,EAAE;QACT,SAAS,EAAE,EAAE;KACd;CACF,CACF,CAAC;AAEF,MAAM,KAAK,GAAG,mBAAmB,EAAE,CAAC;AAEpC,MAAM,CAAC,iBAAiB,CACtB,sBAAsB,EACtB,KAAK,IAAI,EAAE;IACT,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACxB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC,CAAC;KACJ,CAAC;AACJ,CAAC,CACF,CAAC;AAEF,MAAM,CAAC,iBAAiB,CACtB,qBAAqB,EACrB,KAAK,EAAE,OAAO,EAAE,EAAE;IAChB,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAC9C,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,YAAY,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC,CACF,CAAC;AAEF,MAAM,SAAS,GAAG,uBAAuB,EAAE,CAAC;AAE5C,MAAM,CAAC,iBAAiB,CACtB,0BAA0B,EAC1B,KAAK,IAAI,EAAE;IACT,OAAO;QACL,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACpC,GAAG,EAAE,QAAQ,CAAC,GAAG;YACjB,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,QAAQ,EAAE,QAAQ,CAAC,QAAQ;SAC5B,CAAC,CAAC;KACJ,CAAC;AACJ,CAAC,CACF,CAAC;AAEF,MAAM,CAAC,iBAAiB,CACtB,yBAAyB,EACzB,KAAK,EAAE,OAAO,EAAE,EAAE;IAChB,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAC/B,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IACjG,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,YAAY,GAAG,YAAY,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,MAAM,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACzC,CAAC,CACF,CAAC;AAEF,KAAK,UAAU,IAAI;IACjB,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,OAAO,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;AACxD,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACrB,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;IACtC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/resources.d.ts

@@ -0,0 +1,11 @@
+import { ReadResourceRequest } from '@modelcontextprotocol/sdk/types.js';
+interface Resource {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+    handler: (request: ReadResourceRequest) => Promise<any>;
+}
+export declare function createInsomniaResources(): Resource[];
+export {};
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../src/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAIzE,UAAU,QAAQ;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACzD;AAED,wBAAgB,uBAAuB,IAAI,QAAQ,EAAE,CAuepD"}

package/dist/resources.js

@@ -0,0 +1,449 @@
+import { storage } from './storage.js';
+export function createInsomniaResources() {
+    return [
+        {
+            uri: 'insomnia://collections',
+            name: 'Collections',
+            description: 'List all collections with folder structure',
+            mimeType: 'application/json',
+            handler: async () => {
+                const collections = storage.getAllCollections();
+                const result = Array.from(collections.entries()).map(([id, structure]) => ({
+                    id,
+                    name: structure.workspace.name,
+                    description: structure.workspace.description,
+                    scope: structure.workspace.scope,
+                    created: new Date(structure.workspace.created).toISOString(),
+                    modified: new Date(structure.workspace.modified).toISOString(),
+                    folders: structure.folders.map(folder => ({
+                        id: folder._id,
+                        name: folder.name,
+                        description: folder.description,
+                        parentId: folder.parentId,
+                        created: new Date(folder.created).toISOString(),
+                        modified: new Date(folder.modified).toISOString(),
+                    })),
+                    requestCount: structure.requests.length,
+                    environmentCount: structure.environments.length,
+                }));
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://requests',
+            name: 'Requests',
+            description: 'List all requests in collections with metadata. Can be filtered with ?collectionId={id}',
+            mimeType: 'application/json',
+            handler: async (request) => {
+                const allRequests = [];
+                const uri = request.params.uri;
+                const url = new URL(uri);
+                const collectionIdFilter = url.searchParams.get('collectionId');
+                const collections = collectionIdFilter
+                    ? new Map([[collectionIdFilter, storage.getCollection(collectionIdFilter)]])
+                    : storage.getAllCollections();
+                for (const [collectionId, structure] of collections.entries()) {
+                    if (!structure)
+                        continue; // Skip if a filtered collection is not found
+                    const requests = structure.requests.map(request => ({
+                        id: request._id,
+                        collectionId,
+                        collectionName: structure.workspace.name,
+                        parentId: request.parentId,
+                        parentName: structure.folders.find(f => f._id === request.parentId)?.name ?? 'Root',
+                        name: request.name,
+                        description: request.description,
+                        method: request.method,
+                        url: request.url,
+                        hasAuthentication: !!request.authentication,
+                        headerCount: request.headers?.length || 0,
+                        parameterCount: request.parameters?.length || 0,
+                        hasBody: !!request.body,
+                        created: new Date(request.created).toISOString(),
+                        modified: new Date(request.modified).toISOString(),
+                    }));
+                    allRequests.push(...requests);
+                }
+                allRequests.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(allRequests, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://environments',
+            name: 'Environments',
+            description: 'List environment variables per collection. Can be filtered with ?collectionId={id}',
+            mimeType: 'application/json',
+            handler: async (request) => {
+                const allEnvironments = [];
+                const uri = request.params.uri;
+                const url = new URL(uri);
+                const collectionIdFilter = url.searchParams.get('collectionId');
+                const collections = collectionIdFilter
+                    ? new Map([[collectionIdFilter, storage.getCollection(collectionIdFilter)]])
+                    : storage.getAllCollections();
+                for (const [collectionId, structure] of collections.entries()) {
+                    if (!structure)
+                        continue; // Skip if a filtered collection is not found
+                    const environments = structure.environments.map(env => ({
+                        id: env._id,
+                        collectionId,
+                        collectionName: structure.workspace.name,
+                        name: env.name,
+                        description: env.description,
+                        variableCount: Object.keys(env.data || {}).length,
+                        variables: Object.entries(env.data || {}).map(([key, value]) => ({
+                            key,
+                            value: typeof value === 'string' && value.length > 100 ? `${value.substring(0, 100)}...` : value,
+                            type: typeof value,
+                        })),
+                        isPrivate: env.isPrivate || false,
+                        created: new Date(env.created).toISOString(),
+                        modified: new Date(env.modified).toISOString(),
+                    }));
+                    allEnvironments.push(...environments);
+                }
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(allEnvironments, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://collection/{id}',
+            name: 'Collection Detail',
+            description: 'Full details of a specific collection',
+            mimeType: 'application/json',
+            handler: async (request) => {
+                const uri = request.params.uri;
+                const collectionId = uri.replace('insomnia://collection/', '');
+                const structure = storage.getCollection(collectionId);
+                if (!structure) {
+                    throw new Error(`Collection with ID ${collectionId} not found`);
+                }
+                const result = {
+                    workspace: {
+                        id: structure.workspace._id,
+                        name: structure.workspace.name,
+                        description: structure.workspace.description,
+                        scope: structure.workspace.scope,
+                        created: new Date(structure.workspace.created).toISOString(),
+                        modified: new Date(structure.workspace.modified).toISOString(),
+                    },
+                    structure: {
+                        folders: structure.folders.map(folder => ({
+                            id: folder._id,
+                            name: folder.name,
+                            description: folder.description,
+                            parentId: folder.parentId,
+                            requestCount: structure.requests.filter(r => r.parentId === folder._id).length,
+                        })),
+                        requests: structure.requests.map(request => ({
+                            id: request._id,
+                            name: request.name,
+                            method: request.method,
+                            url: request.url,
+                            parentId: request.parentId,
+                            parentName: request.parentId === collectionId
+                                ? 'Root'
+                                : structure.folders.find(f => f._id === request.parentId)?.name ?? 'Unknown',
+                            hasAuth: !!request.authentication,
+                            authType: request.authentication?.type,
+                        })),
+                        environments: structure.environments.map(env => ({
+                            id: env._id,
+                            name: env.name,
+                            variableCount: Object.keys(env.data || {}).length,
+                        })),
+                    },
+                    statistics: {
+                        totalRequests: structure.requests.length,
+                        totalFolders: structure.folders.length,
+                        totalEnvironments: structure.environments.length,
+                        methodBreakdown: structure.requests.reduce((acc, req) => {
+                            acc[req.method] = (acc[req.method] || 0) + 1;
+                            return acc;
+                        }, {}),
+                        authenticationBreakdown: structure.requests.reduce((acc, req) => {
+                            const authType = req.authentication?.type ?? 'none';
+                            acc[authType] = (acc[authType] || 0) + 1;
+                            return acc;
+                        }, {}),
+                    },
+                };
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://request/{id}',
+            name: 'Request Detail',
+            description: 'Full details of a specific request',
+            mimeType: 'application/json',
+            handler: async (request) => {
+                const uri = request.params.uri;
+                const requestId = uri.replace('insomnia://request/', '');
+                let targetRequest = null;
+                let collectionInfo = null;
+                const collections = storage.getAllCollections();
+                for (const [collectionId, structure] of collections.entries()) {
+                    const foundRequest = structure.requests.find(r => r._id === requestId);
+                    if (foundRequest) {
+                        targetRequest = foundRequest;
+                        collectionInfo = {
+                            id: collectionId,
+                            name: structure.workspace.name,
+                            parentName: foundRequest.parentId === collectionId
+                                ? 'Root'
+                                : structure.folders.find(f => f._id === foundRequest.parentId)?.name ?? 'Unknown',
+                        };
+                        break;
+                    }
+                }
+                if (!targetRequest) {
+                    throw new Error(`Request with ID ${requestId} not found`);
+                }
+                const result = {
+                    id: targetRequest._id,
+                    name: targetRequest.name,
+                    description: targetRequest.description,
+                    method: targetRequest.method,
+                    url: targetRequest.url,
+                    collection: collectionInfo,
+                    headers: targetRequest.headers || [],
+                    parameters: targetRequest.parameters || [],
+                    body: targetRequest.body || null,
+                    authentication: targetRequest.authentication ? {
+                        type: targetRequest.authentication.type,
+                        hasCredentials: !!(targetRequest.authentication.username ?? targetRequest.authentication.token),
+                    } : null,
+                    metadata: {
+                        created: new Date(targetRequest.created).toISOString(),
+                        modified: new Date(targetRequest.modified).toISOString(),
+                        hasHeaders: (targetRequest.headers || []).length > 0,
+                        hasParameters: (targetRequest.parameters || []).length > 0,
+                        hasBody: !!targetRequest.body,
+                        hasAuthentication: !!targetRequest.authentication,
+                    },
+                };
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://request/{id}/history',
+            name: 'Request Execution History',
+            description: 'Get the execution history of a specific request',
+            mimeType: 'application/json',
+            handler: async (request) => {
+                const uri = request.params.uri;
+                const requestId = uri.replace('insomnia://request/', '').replace('/history', '');
+                let targetRequest = null;
+                const collections = storage.getAllCollections();
+                for (const structure of collections.values()) {
+                    const foundRequest = structure.requests.find(r => r._id === requestId);
+                    if (foundRequest) {
+                        targetRequest = foundRequest;
+                        break;
+                    }
+                }
+                if (!targetRequest) {
+                    throw new Error(`Request with ID ${requestId} not found`);
+                }
+                const history = (targetRequest.history || []).map(h => ({
+                    id: h._id,
+                    timestamp: new Date(h.timestamp).toISOString(),
+                    response: {
+                        statusCode: h.response.statusCode,
+                        statusMessage: h.response.statusMessage,
+                        duration: h.response.duration,
+                        size: h.response.size,
+                        headers: h.response.headers,
+                        body: h.response.body,
+                    },
+                    error: h.error,
+                }));
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(history, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://search',
+            name: 'Search',
+            description: 'Search for a keyword across all collections, folders, and requests. Use with ?q=keyword',
+            mimeType: 'application/json',
+            handler: async (request) => {
+                const uri = request.params.uri;
+                const url = new URL(uri);
+                const keyword = url.searchParams.get('q');
+                if (!keyword) {
+                    throw new Error('Search keyword must be provided with ?q=');
+                }
+                const searchResults = [];
+                const collections = storage.getAllCollections();
+                const lowerCaseKeyword = keyword.toLowerCase();
+                for (const [collectionId, structure] of collections.entries()) {
+                    // Search in workspace
+                    if (structure.workspace.name.toLowerCase().includes(lowerCaseKeyword) ||
+                        (structure.workspace.description || '').toLowerCase().includes(lowerCaseKeyword)) {
+                        searchResults.push({
+                            type: 'Collection',
+                            id: collectionId,
+                            name: structure.workspace.name,
+                            match: 'Name or description',
+                        });
+                    }
+                    // Search in folders
+                    for (const folder of structure.folders) {
+                        if (folder.name.toLowerCase().includes(lowerCaseKeyword) ||
+                            (folder.description || '').toLowerCase().includes(lowerCaseKeyword)) {
+                            searchResults.push({
+                                type: 'Folder',
+                                id: folder._id,
+                                name: folder.name,
+                                collection: { id: collectionId, name: structure.workspace.name },
+                                match: 'Name or description',
+                            });
+                        }
+                    }
+                    // Search in requests
+                    for (const req of structure.requests) {
+                        let matchReason = '';
+                        if (req.name.toLowerCase().includes(lowerCaseKeyword))
+                            matchReason = 'Name';
+                        else if ((req.description || '').toLowerCase().includes(lowerCaseKeyword))
+                            matchReason = 'Description';
+                        else if (req.url.toLowerCase().includes(lowerCaseKeyword))
+                            matchReason = 'URL';
+                        else if (req.method.toLowerCase().includes(lowerCaseKeyword))
+                            matchReason = 'Method';
+                        if (matchReason) {
+                            searchResults.push({
+                                type: 'Request',
+                                id: req._id,
+                                name: req.name,
+                                collection: { id: collectionId, name: structure.workspace.name },
+                                match: matchReason,
+                            });
+                        }
+                    }
+                }
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(searchResults, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            uri: 'insomnia://stats',
+            name: 'Statistics',
+            description: 'Global statistics of all collections',
+            mimeType: 'application/json',
+            handler: async () => {
+                const collections = storage.getAllCollections();
+                const totalCollections = collections.size;
+                let totalRequests = 0;
+                let totalFolders = 0;
+                let totalEnvironments = 0;
+                let totalEnvironmentVariables = 0;
+                const methodStats = {};
+                const authStats = {};
+                const recentActivity = [];
+                for (const [collectionId, structure] of collections.entries()) {
+                    totalRequests += structure.requests.length;
+                    totalFolders += structure.folders.length;
+                    totalEnvironments += structure.environments.length;
+                    structure.environments.forEach(env => {
+                        totalEnvironmentVariables += Object.keys(env.data || {}).length;
+                    });
+                    structure.requests.forEach(request => {
+                        methodStats[request.method] = (methodStats[request.method] || 0) + 1;
+                        const authType = request.authentication?.type ?? 'none';
+                        authStats[authType] = (authStats[authType] || 0) + 1;
+                        recentActivity.push({
+                            type: 'request',
+                            id: request._id,
+                            name: request.name,
+                            collectionName: structure.workspace.name,
+                            method: request.method,
+                            modified: request.modified,
+                        });
+                    });
+                    recentActivity.push({
+                        type: 'collection',
+                        id: collectionId,
+                        name: structure.workspace.name,
+                        requestCount: structure.requests.length,
+                        modified: structure.workspace.modified,
+                    });
+                }
+                recentActivity.sort((a, b) => b.modified - a.modified);
+                const result = {
+                    summary: {
+                        totalCollections,
+                        totalRequests,
+                        totalFolders,
+                        totalEnvironments,
+                        totalEnvironmentVariables,
+                    },
+                    methodBreakdown: methodStats,
+                    authenticationBreakdown: authStats,
+                    recentActivity: recentActivity.slice(0, 20),
+                    averages: {
+                        requestsPerCollection: totalCollections > 0 ? Math.round(totalRequests / totalCollections * 100) / 100 : 0,
+                        foldersPerCollection: totalCollections > 0 ? Math.round(totalFolders / totalCollections * 100) / 100 : 0,
+                        environmentsPerCollection: totalCollections > 0 ? Math.round(totalEnvironments / totalCollections * 100) / 100 : 0,
+                    },
+                };
+                return {
+                    contents: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+    ];
+}
+//# sourceMappingURL=resources.js.map