@matimo/bruno 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matimo/bruno",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Bruno CLI tools for Matimo — API collection execution, import, and validation",
   "files": [
     "tools",
@@ -9,9 +9,12 @@
   ],
   "dependencies": {
     "@usebruno/cli": "^3.3.0",
-    "@matimo/core": "0.1.3"
+    "@matimo/core": "0.1.4"
   },
   "peerDependencies": {
-    "matimo": "0.1.3"
+    "matimo": "0.1.4"
+  },
+  "scripts": {
+    "build": "tsc"
   }
 }

package/tools/bru-utils.js

@@ -0,0 +1,41 @@
+import { execFileSync } from 'child_process';
+export const BRU_MIN_VERSION_STR = '1.0.0';
+const BRU_MIN_VERSION = [1, 0, 0];
+/**
+ * Verify the Bruno CLI is installed and meets the minimum required version.
+ *
+ * - Throws if `bru` is not found in PATH (ENOENT).
+ * - Throws if the installed version is below {@link BRU_MIN_VERSION_STR}.
+ * - Skips silently if the version string cannot be parsed (graceful degradation).
+ */
+export function checkBruVersion() {
+    let versionOutput;
+    try {
+        versionOutput = execFileSync('bru', ['--version'], { encoding: 'utf-8', stdio: 'pipe' });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            throw new Error("Bruno CLI ('bru') is not installed or not in PATH. " +
+                'Install it with: npm install -g @usebruno/cli');
+        }
+        // Other error — skip version check (bru is installed but --version failed for another reason)
+        return;
+    }
+    const match = versionOutput.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return; // Unparseable output — skip check
+    const installed = [
+        parseInt(match[1], 10),
+        parseInt(match[2], 10),
+        parseInt(match[3], 10),
+    ];
+    const [iMaj, iMin, iPatch] = installed;
+    const [minMaj, minMin, minPatch] = BRU_MIN_VERSION;
+    const belowMin = iMaj < minMaj ||
+        (iMaj === minMaj && iMin < minMin) ||
+        (iMaj === minMaj && iMin === minMin && iPatch < minPatch);
+    if (belowMin) {
+        throw new Error(`Bruno CLI version ${versionOutput.trim()} is below the minimum required version ` +
+            `${BRU_MIN_VERSION_STR}. Upgrade with: npm install -g @usebruno/cli`);
+    }
+}

package/tools/bruno_add_request/definition.yaml

@@ -60,7 +60,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 10000
 
 output_schema:

package/tools/bruno_add_request/index.js

@@ -0,0 +1,82 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+const logger = getGlobalMatimoLogger();
+function generateBruContent(params) {
+    const requestName = params.request_name;
+    const method = params.method.toLowerCase();
+    const url = params.url;
+    const headers = params.headers || {};
+    const body = params.body;
+    const tests = params.tests;
+    const documentation = params.documentation;
+    let content = '';
+    content += `meta {\n  name: ${requestName}\n  type: http\n  seq: 1\n}\n\n`;
+    if (documentation) {
+        content += `docs {\n  ${documentation}\n}\n\n`;
+    }
+    content += `${method} {\n  url: ${url}\n  body: ${body ? 'json' : 'none'}\n  auth: inherit\n}\n\n`;
+    if (Object.keys(headers).length > 0) {
+        content += `headers {\n`;
+        for (const [k, v] of Object.entries(headers)) {
+            content += `  ${k}: ${v}\n`;
+        }
+        content += `}\n\n`;
+    }
+    if (body) {
+        content += `body:json {\n`;
+        content += body
+            .split('\n')
+            .map((line) => `  ${line}`)
+            .join('\n');
+        content += `\n}\n\n`;
+    }
+    if (tests) {
+        content += `tests {\n`;
+        content += tests
+            .split('\n')
+            .map((line) => `  ${line}`)
+            .join('\n');
+        content += `\n}\n`;
+    }
+    return content;
+}
+export default async function execute(params) {
+    const collectionPath = params.collection_path;
+    const requestName = params.request_name;
+    if (!collectionPath || !requestName) {
+        return {
+            success: false,
+            request_path: '',
+            request_name: '',
+            message: 'collection_path and request_name are required',
+        };
+    }
+    try {
+        logger.info(`Adding request ${requestName} to collection at ${collectionPath}`);
+        const absoluteCollectionPath = path.resolve(collectionPath);
+        // Write requests into a dedicated requests/ subfolder (consistent with Bruno convention)
+        const requestsDir = path.join(absoluteCollectionPath, 'requests');
+        await fs.mkdir(requestsDir, { recursive: true });
+        const filename = `${requestName.toLowerCase().replace(/\s+/g, '-')}.bru`;
+        const requestPath = path.join(requestsDir, filename);
+        const content = generateBruContent(params);
+        await fs.writeFile(requestPath, content, 'utf-8');
+        logger.info(`Request written to ${requestPath}`);
+        return {
+            success: true,
+            request_path: requestPath,
+            request_name: requestName,
+            message: `Request '${requestName}' added to collection successfully`,
+        };
+    }
+    catch (error) {
+        logger.error(`Add request failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            request_path: '',
+            request_name: requestName,
+            message: `Failed to add request: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}

package/tools/bruno_add_request/index.ts

@@ -1,4 +1,4 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 

package/tools/bruno_create_collection/definition.yaml

@@ -16,7 +16,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 15000
 
 output_schema:

package/tools/bruno_create_collection/index.js

@@ -0,0 +1,45 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+const logger = getGlobalMatimoLogger();
+export default async function execute(params) {
+    const collectionPath = params.collection_path;
+    const collectionName = params.collection_name;
+    if (!collectionPath || !collectionName) {
+        return {
+            success: false,
+            collection_path: '',
+            message: 'collection_path and collection_name parameters are required',
+            errors: ['collection_path and collection_name parameters are required'],
+        };
+    }
+    try {
+        logger.info(`Creating collection: ${collectionName} at ${collectionPath}`);
+        const absolutePath = path.resolve(collectionPath);
+        await fs.mkdir(absolutePath, { recursive: true });
+        const brunoJson = {
+            version: '1',
+            name: collectionName,
+            type: 'collection',
+            ignore: [],
+        };
+        const brunoJsonPath = path.join(absolutePath, 'bruno.json');
+        await fs.writeFile(brunoJsonPath, JSON.stringify(brunoJson, null, 2), 'utf-8');
+        logger.info('Collection created successfully');
+        return {
+            success: true,
+            collection_path: absolutePath,
+            message: `Collection "${collectionName}" created at ${absolutePath}`,
+            errors: [],
+        };
+    }
+    catch (error) {
+        logger.error(`Create collection failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            collection_path: collectionPath,
+            message: 'Collection creation failed',
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}

package/tools/bruno_create_collection/index.ts

@@ -1,4 +1,4 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 

package/tools/bruno_get_collection_info/definition.yaml

@@ -11,7 +11,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 10000
 
 output_schema:

package/tools/bruno_get_collection_info/index.js

@@ -0,0 +1,106 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+const logger = getGlobalMatimoLogger();
+async function scanBruFiles(dir, results) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory() && entry !== 'node_modules') {
+                await scanBruFiles(fullPath, results);
+            }
+            else if (!stat.isDirectory() && entry.endsWith('.bru')) {
+                try {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const methodMatch = content.match(/^(get|post|put|patch|delete|head|options)\s*\{/im);
+                    const method = methodMatch ? methodMatch[1].toUpperCase() : 'UNKNOWN';
+                    const nameMatch = content.match(/meta\s*\{[^}]*name:\s*(.+)/i);
+                    const name = nameMatch ? nameMatch[1].trim() : path.basename(entry, '.bru');
+                    const urlMatch = content.match(/^\s+url:\s*(.+)$/m);
+                    const url = urlMatch ? urlMatch[1].trim() : '';
+                    const tagsMatch = content.match(/tags:\s*\[([^\]]*)\]/);
+                    const tags = tagsMatch
+                        ? tagsMatch[1].split(',').map((t) => t.trim()).filter(Boolean)
+                        : [];
+                    const hasTests = /\btests\s*\{/.test(content);
+                    results.push({ name, method, url, path: fullPath, tags, has_tests: hasTests });
+                }
+                catch {
+                    results.push({
+                        name: path.basename(entry, '.bru'),
+                        method: 'UNKNOWN',
+                        url: '',
+                        path: fullPath,
+                        tags: [],
+                        has_tests: false,
+                    });
+                }
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+}
+export default async function execute(params) {
+    const collectionPath = params.collection_path;
+    if (!collectionPath) {
+        return {
+            success: false,
+            collection: undefined,
+            errors: ['collection_path parameter is required'],
+        };
+    }
+    try {
+        logger.info(`Getting collection info: ${collectionPath}`);
+        const absolutePath = path.resolve(collectionPath);
+        const brunoJsonPath = path.join(absolutePath, 'bruno.json');
+        let collectionName = path.basename(absolutePath);
+        // Verify the path exists before proceeding
+        try {
+            await fs.stat(absolutePath);
+        }
+        catch {
+            return {
+                success: false,
+                collection: undefined,
+                errors: [`Collection path not found: ${collectionPath}`],
+            };
+        }
+        try {
+            const raw = await fs.readFile(brunoJsonPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed.name)
+                collectionName = parsed.name;
+        }
+        catch {
+            // bruno.json missing — use dirname as name
+        }
+        const requests = [];
+        await scanBruFiles(absolutePath, requests);
+        return {
+            success: true,
+            collection: {
+                name: collectionName,
+                path: absolutePath,
+                requests,
+            },
+        };
+    }
+    catch (error) {
+        logger.error(`Get collection info failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            collection: undefined,
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}

package/tools/bruno_get_collection_info/index.ts

@@ -1,4 +1,4 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 

package/tools/bruno_import_openapi/definition.yaml

@@ -39,7 +39,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 30000
 
 output_schema:

package/tools/bruno_import_openapi/index.js

@@ -0,0 +1,93 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { execFileSync } from 'child_process';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { checkBruVersion } from '../bru-utils.js';
+const logger = getGlobalMatimoLogger();
+/** Count .bru files recursively — compatible with Node 18+. */
+async function countBruFilesRecursively(dir) {
+    let count = 0;
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory() && entry !== 'node_modules') {
+                count += await countBruFilesRecursively(fullPath);
+            }
+            else if (!stat.isDirectory() && entry.endsWith('.bru')) {
+                count++;
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return count;
+}
+export default async function execute(params) {
+    const specSource = params.spec_source;
+    const outputDirectory = params.output_directory;
+    if (!specSource || !outputDirectory) {
+        return {
+            success: false,
+            collection_path: '',
+            collection_name: '',
+            requests_created: 0,
+            message: 'spec_source and output_directory parameters are required',
+            errors: ['spec_source and output_directory parameters are required'],
+        };
+    }
+    checkBruVersion();
+    const collectionName = params.collection_name || 'Imported Collection';
+    const absoluteOutput = path.resolve(outputDirectory);
+    try {
+        logger.info(`Importing OpenAPI from: ${specSource} to ${absoluteOutput}`);
+        const args = [
+            'import', 'openapi',
+            '--source', specSource,
+            '--output', absoluteOutput,
+            '--collection-name', collectionName,
+        ];
+        if (params.group_by)
+            args.push('--group-by', params.group_by);
+        if (params.insecure === true)
+            args.push('--insecure');
+        logger.debug(`Executing: bru ${args.join(' ')}`);
+        execFileSync('bru', args, { encoding: 'utf-8', stdio: 'pipe' });
+        logger.info('OpenAPI import completed');
+        // Count generated .bru files using a Node 18-compatible recursive walk
+        let requestsCreated = 0;
+        try {
+            requestsCreated = await countBruFilesRecursively(absoluteOutput);
+        }
+        catch {
+            // best-effort count
+        }
+        return {
+            success: true,
+            collection_path: absoluteOutput,
+            collection_name: collectionName,
+            requests_created: requestsCreated,
+            message: `Collection "${collectionName}" imported from OpenAPI spec`,
+            errors: [],
+        };
+    }
+    catch (error) {
+        logger.error(`OpenAPI import failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            collection_path: absoluteOutput,
+            collection_name: collectionName,
+            requests_created: 0,
+            message: 'Import failed',
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}

package/tools/bruno_import_openapi/index.ts

@@ -1,8 +1,8 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { execFileSync } from 'child_process';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { checkBruVersion } from '../bru-utils';
+import { checkBruVersion } from '../bru-utils.js';
 
 const logger = getGlobalMatimoLogger();
 

package/tools/bruno_list_collections/definition.yaml

@@ -16,7 +16,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 10000
 
 output_schema:

package/tools/bruno_list_collections/index.js

@@ -0,0 +1,94 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+const logger = getGlobalMatimoLogger();
+async function countBruFilesRecursively(dir) {
+    let count = 0;
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory() && entry !== 'node_modules') {
+                count += await countBruFilesRecursively(fullPath);
+            }
+            else if (!stat.isDirectory() && entry.endsWith('.bru')) {
+                count++;
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return count;
+}
+async function findCollections(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return results;
+    }
+    if (entries.includes('bruno.json')) {
+        const brunoJsonPath = path.join(dir, 'bruno.json');
+        let name = path.basename(dir);
+        try {
+            const raw = await fs.readFile(brunoJsonPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed.name)
+                name = parsed.name;
+        }
+        catch {
+            // use dirname
+        }
+        // Count .bru files recursively so nested requests are included
+        const requestCount = await countBruFilesRecursively(dir);
+        results.push({ name, path: dir, request_count: requestCount });
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory() && entry !== 'node_modules') {
+                const nested = await findCollections(fullPath);
+                results.push(...nested);
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return results;
+}
+export default async function execute(params) {
+    const workspacePath = params.workspace_path;
+    if (!workspacePath) {
+        return { success: false, collections: [], errors: ['workspace_path parameter is required'] };
+    }
+    try {
+        logger.info(`Listing collections in: ${workspacePath}`);
+        const absolutePath = path.resolve(workspacePath);
+        let collections = await findCollections(absolutePath);
+        if (params.filter) {
+            const filter = params.filter.toLowerCase();
+            collections = collections.filter((c) => c.name.toLowerCase().includes(filter));
+        }
+        return { success: true, collections };
+    }
+    catch (error) {
+        logger.error(`List collections failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            collections: [],
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}

package/tools/bruno_list_collections/index.ts

@@ -1,4 +1,4 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 

package/tools/bruno_run_collection/definition.yaml

@@ -76,7 +76,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 120000
 
 output_schema:

package/tools/bruno_run_collection/index.js

@@ -0,0 +1,96 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { execFileSync } from 'child_process';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { checkBruVersion } from '../bru-utils.js';
+const logger = getGlobalMatimoLogger();
+export default async function execute(params) {
+    const collectionPath = params.collection_path;
+    if (!collectionPath) {
+        return {
+            success: false,
+            summary: { total_requests: 0, passed: 0, failed: 0, execution_time_ms: 0 },
+            results: [],
+            errors: ['collection_path parameter is required'],
+        };
+    }
+    checkBruVersion();
+    const absolutePath = path.resolve(collectionPath);
+    const reportPath = path.resolve(params.report_path ?? path.join(os.tmpdir(), `bru-report-${Date.now()}.json`));
+    try {
+        logger.info(`Running Bruno collection: ${absolutePath}`);
+        const args = ['run', '.', '-r', '--reporter-json', reportPath];
+        if (params.environment)
+            args.push('--env', params.environment);
+        if (params.env_file)
+            args.push('--env-file', params.env_file);
+        if (params.data_file)
+            args.push('--csv-file-path', params.data_file);
+        if (params.iteration_count)
+            args.push('--iteration-count', String(params.iteration_count));
+        if (params.delay_ms)
+            args.push('--delay', String(params.delay_ms));
+        if (params.tags)
+            args.push('--tags', params.tags);
+        if (params.exclude_tags)
+            args.push('--exclude-tags', params.exclude_tags);
+        if (params.tests_only === true)
+            args.push('--tests-only');
+        if (params.bail_on_failure === true)
+            args.push('--bail');
+        if (params.parallel === true)
+            args.push('--parallel');
+        args.push('--sandbox', params.sandbox_mode || 'safe');
+        logger.debug(`Executing: bru ${args.join(' ')}`);
+        let exitCode = 0;
+        try {
+            execFileSync('bru', args, { encoding: 'utf-8', stdio: 'pipe', cwd: absolutePath });
+        }
+        catch (execError) {
+            // bru exits non-zero when tests fail — that's OK, we still read the report
+            exitCode = 1;
+            logger.warn(`bru run exited with non-zero status: ${execError instanceof Error ? execError.message : String(execError)}`);
+        }
+        // Read JSON report written by --reporter-json
+        let reportData = {};
+        try {
+            const raw = await fs.readFile(reportPath, 'utf-8');
+            reportData = JSON.parse(raw);
+        }
+        catch {
+            logger.warn('Could not read/parse JSON report');
+        }
+        // Map Bruno report fields to schema-declared keys
+        const summaryRaw = reportData.summary ?? {};
+        const totalRequests = (summaryRaw.totalRequests ?? 0);
+        const passed = (summaryRaw.passedRequests ?? 0);
+        const failed = (summaryRaw.failedRequests ?? 0);
+        const executionTimeMs = (summaryRaw.totalTime ?? 0);
+        const rawResults = reportData.results ?? [];
+        const results = rawResults.map((r) => {
+            const req = r;
+            return {
+                name: req.suiteName ?? req.name ?? 'unknown',
+                success: req.status === 'pass' || req.passed === true,
+                status: req.response?.status ?? 0,
+            };
+        });
+        return {
+            success: exitCode === 0,
+            summary: { total_requests: totalRequests, passed, failed, execution_time_ms: executionTimeMs },
+            results,
+            report_path: reportPath,
+            errors: [],
+        };
+    }
+    catch (error) {
+        logger.error(`Collection execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            summary: { total_requests: 0, passed: 0, failed: 0, execution_time_ms: 0 },
+            results: [],
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}

package/tools/bruno_run_collection/index.ts

@@ -1,9 +1,9 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { execFileSync } from 'child_process';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { checkBruVersion } from '../bru-utils';
+import { checkBruVersion } from '../bru-utils.js';
 
 const logger = getGlobalMatimoLogger();
 

package/tools/bruno_run_request/definition.yaml

@@ -32,7 +32,7 @@ parameters:
 
 execution:
   type: function
-  code: index.ts
+  code: index.js
   timeout: 60000
 
 output_schema:

package/tools/bruno_run_request/index.js

@@ -0,0 +1,95 @@
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
+import { execFileSync } from 'child_process';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { checkBruVersion } from '../bru-utils.js';
+const logger = getGlobalMatimoLogger();
+/** Search recursively for a .bru file matching the given slug, return path relative to root. */
+async function findBruFile(root, slug) {
+    let entries;
+    try {
+        entries = await fs.readdir(root);
+    }
+    catch {
+        return null;
+    }
+    if (entries.includes(`${slug}.bru`)) {
+        return `${slug}.bru`;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(root, entry);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory() && entry !== 'node_modules') {
+                const found = await findBruFile(fullPath, slug);
+                if (found)
+                    return path.join(entry, found);
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return null;
+}
+export default async function execute(params) {
+    const collectionPath = params.collection_path;
+    const requestName = params.request_name;
+    if (!collectionPath || !requestName) {
+        return {
+            success: false,
+            request: requestName ?? '',
+            status: 0,
+            duration_ms: 0,
+            errors: ['collection_path and request_name parameters are required'],
+        };
+    }
+    checkBruVersion();
+    const absolutePath = path.resolve(collectionPath);
+    const slug = requestName.toLowerCase().replace(/\s+/g, '-');
+    try {
+        logger.info(`Running request: ${requestName} from ${absolutePath}`);
+        // Locate the .bru file (may be in a requests/ subfolder)
+        const bruRelPath = (await findBruFile(absolutePath, slug)) ?? `${slug}.bru`;
+        const args = ['run', bruRelPath];
+        if (params.environment)
+            args.push('--env', params.environment);
+        if (params.env_file)
+            args.push('--env-file', params.env_file);
+        args.push('--sandbox', params.sandbox_mode || 'safe');
+        logger.debug(`Executing: bru ${args.join(' ')}`);
+        const start = Date.now();
+        let success = true;
+        let output = '';
+        try {
+            output = execFileSync('bru', args, { encoding: 'utf-8', stdio: 'pipe', cwd: absolutePath });
+        }
+        catch (execError) {
+            success = false;
+            // Extract stdout/stderr from the error so assertion failures are visible
+            const err = execError;
+            output = [err.stdout, err.stderr, err.message].filter(Boolean).join('\n');
+        }
+        const durationMs = Date.now() - start;
+        // Parse status code from bru run output (e.g. "200 OK")
+        const statusMatch = output.match(/\b([1-5]\d{2})\b/);
+        const status = statusMatch ? parseInt(statusMatch[1], 10) : (success ? 200 : 0);
+        return {
+            success,
+            request: requestName,
+            status,
+            duration_ms: durationMs,
+            errors: success ? [] : [output],
+        };
+    }
+    catch (error) {
+        logger.error(`Request execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            success: false,
+            request: requestName,
+            status: 0,
+            duration_ms: 0,
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}

package/tools/bruno_run_request/index.ts

@@ -1,8 +1,8 @@
-import { getGlobalMatimoLogger } from '@matimo/core';
+import { getGlobalMatimoLogger } from '@matimo/core/runtime';
 import { execFileSync } from 'child_process';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { checkBruVersion } from '../bru-utils';
+import { checkBruVersion } from '../bru-utils.js';
 
 const logger = getGlobalMatimoLogger();