@ranger-testing/ranger-cli 1.0.10 → 1.0.13

package/build/index.js

@@ -1,436 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { z } from 'zod';
-import { createServer } from 'http';
-const RANGER_API_BASE = process.env.RANGER_API_URL || 'http://localhost:8080';
-const PORT = parseInt(process.env.PORT || '8080', 10);
-// Tool classification - read tools can be used with mcp:read scope
-const READ_TOOLS = ['get_test_runs', 'get_active_tests'];
-const tokenInfoCache = new Map();
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-// Create API request function bound to a specific token
-function createApiClient(token) {
-    console.error(`[API Client] Created with customer token: ${token ? token.substring(0, 10) + '...' : 'none'}`);
-    // All requests now use customer token
-    const apiRequest = async (endpoint, options = {}) => {
-        const url = `${RANGER_API_BASE}${endpoint}`;
-        const headers = {
-            'Content-Type': 'application/json',
-            ...(token ? { Authorization: `Bearer ${token}` } : {}),
-            ...options.headers,
-        };
-        console.error(`[API Request] ${options.method || 'GET'} ${url}`);
-        const response = await fetch(url, {
-            ...options,
-            headers,
-        });
-        if (!response.ok) {
-            const body = await response.text();
-            console.error(`[API Error] ${response.status} ${response.statusText}: ${body}`);
-            throw new Error(`API request failed: ${response.status} ${response.statusText}`);
-        }
-        return response.json();
-    };
-    const getTokenInfo = async () => {
-        if (!token) {
-            throw new Error('No authorization token provided');
-        }
-        // Check cache
-        const cached = tokenInfoCache.get(token);
-        if (cached && cached.expiresAt > Date.now()) {
-            return { orgId: cached.orgId, scope: cached.scope, apiKeyId: cached.apiKeyId };
-        }
-        // Fetch from API using customer token
-        const data = await apiRequest('/api/v1/me');
-        const orgId = data.organizationId || data.organization?.id;
-        const scope = (data.scope || 'api:all');
-        const apiKeyId = data.apiKeyId;
-        if (!orgId) {
-            throw new Error('Could not determine organization ID from token');
-        }
-        if (!apiKeyId) {
-            throw new Error('Could not determine API key ID from token');
-        }
-        // Cache the result
-        tokenInfoCache.set(token, { orgId, scope, apiKeyId, expiresAt: Date.now() + CACHE_TTL_MS });
-        return { orgId, scope, apiKeyId };
-    };
-    // Helper to log MCP tool calls
-    const logToolCall = async (params) => {
-        try {
-            await apiRequest('/api/v1/mcp/tool-calls', {
-                method: 'POST',
-                body: JSON.stringify(params),
-            });
-        }
-        catch (error) {
-            // Log but don't fail the tool call if logging fails
-            console.error(`[MCP] Failed to log tool call: ${error}`);
-        }
-    };
-    return { apiRequest, getTokenInfo, logToolCall };
-}
-// Register all tools on an MCP server instance
-async function registerTools(server, token) {
-    const { apiRequest, getTokenInfo, logToolCall } = createApiClient(token);
-    // Get token info including scope
-    let tokenInfo;
-    try {
-        tokenInfo = await getTokenInfo();
-    }
-    catch (error) {
-        console.error(`[MCP] Failed to get token info: ${error}`);
-        // Register an error-only tool if we can't get token info
-        server.registerTool('error', {
-            description: 'Error tool - authentication failed',
-            inputSchema: {},
-        }, async () => ({
-            content: [{ type: 'text', text: `Authentication failed: ${error}` }],
-        }));
-        return;
-    }
-    const { orgId, scope } = tokenInfo;
-    // Check if scope allows MCP access
-    if (scope === 'api:all') {
-        console.error(`[MCP] Access denied: API key scope 'api:all' does not allow MCP access`);
-        server.registerTool('access_denied', {
-            description: 'Access denied - API key scope does not allow MCP access',
-            inputSchema: {},
-        }, async () => ({
-            content: [{
-                    type: 'text',
-                    text: 'Access denied: Your API key has scope "api:all" which does not allow MCP access. Please create an API key with scope "mcp:read" or "mcp:write" to use the MCP server.'
-                }],
-        }));
-        return;
-    }
-    // Determine which tools to register based on scope
-    const canRegisterTool = (toolName) => {
-        if (scope === 'mcp:write') {
-            return true; // Write scope can use all tools
-        }
-        if (scope === 'mcp:read') {
-            return READ_TOOLS.includes(toolName);
-        }
-        return false;
-    };
-    // Helper to wrap tool handlers with logging
-    const wrapWithLogging = (toolName, handler) => {
-        return async (args) => {
-            const startTime = Date.now();
-            try {
-                const result = await handler(args);
-                const durationMs = Date.now() - startTime;
-                await logToolCall({
-                    toolName,
-                    inputArgs: args,
-                    success: true,
-                    durationMs,
-                });
-                return result;
-            }
-            catch (error) {
-                const durationMs = Date.now() - startTime;
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                await logToolCall({
-                    toolName,
-                    inputArgs: args,
-                    success: false,
-                    errorMessage,
-                    durationMs,
-                });
-                throw error;
-            }
-        };
-    };
-    // Register tool: Get test runs
-    if (canRegisterTool('get_test_runs')) {
-        server.registerTool('get_test_runs', {
-            description: 'Get test runs for the organization associated with your API token',
-            inputSchema: {
-                limit: z
-                    .number()
-                    .optional()
-                    .describe('Maximum number of runs to return (default: 10)'),
-                offset: z
-                    .number()
-                    .optional()
-                    .describe('Pagination offset (default: 0)'),
-            },
-        }, wrapWithLogging('get_test_runs', async ({ limit, offset }) => {
-            const limitValue = limit || 10;
-            const offsetValue = offset || 0;
-            const data = await apiRequest(`/api/v1/mcp/test-runs?limit=${limitValue}&offset=${offsetValue}`);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(data, null, 2),
-                    },
-                ],
-            };
-        }));
-    }
-    // Register tool: Generate test plan
-    if (canRegisterTool('generate_test_plan')) {
-        server.registerTool('generate_test_plan', {
-            description: 'Create a draft test and trigger TestDetailsWriter to generate detailed test steps',
-            inputSchema: {
-                name: z.string().describe('Test name/title'),
-                description: z.string().optional().describe('Test description'),
-                targetUrl: z
-                    .string()
-                    .optional()
-                    .describe('Target URL for the test'),
-                additionalInstructions: z
-                    .string()
-                    .optional()
-                    .describe('Additional instructions for TestDetailsWriter'),
-                priority: z
-                    .enum(['p0', 'p1', 'p2', 'p3'])
-                    .optional()
-                    .describe('Test priority (default: p2)'),
-            },
-        }, wrapWithLogging('generate_test_plan', async ({ name, description, targetUrl, additionalInstructions, priority, }) => {
-            // Step 1: Create draft test
-            const createTestBody = {
-                test: {
-                    name,
-                    description,
-                    priority: priority || 'p2',
-                },
-            };
-            const createTestResponse = await apiRequest('/api/v1/mcp/tests', {
-                method: 'POST',
-                body: JSON.stringify(createTestBody),
-            });
-            const testId = createTestResponse.test.id;
-            // Step 2: Trigger TestDetailsWriter
-            const generateDetailsBody = {
-                eventType: 'GenerateTestDetails',
-                payload: {
-                    organizationId: orgId,
-                    testId,
-                    targetUrl,
-                    additionalInstructions,
-                    authenticationNeeded: true,
-                    updateStatusOnSuccess: true,
-                },
-            };
-            const generateResponse = await apiRequest('/api/v1/mcp/agent-jobs', {
-                method: 'POST',
-                body: JSON.stringify(generateDetailsBody),
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Test plan generation initiated:\n\nTest Created:\n- ID: ${testId}\n- Name: ${name}\n- Organization: ${orgId}\n\nTestDetailsWriter Job:\n- Event ID: ${generateResponse.eventId}\n\nThe AI agent will now generate detailed test steps. You can check the test status using the test ID: ${testId}`,
-                    },
-                ],
-            };
-        }));
-    }
-    // Register tool: Get active tests
-    if (canRegisterTool('get_active_tests')) {
-        server.registerTool('get_active_tests', {
-            description: 'Get active tests for the organization. Returns a summary of each test (id, name, status, priority). Use get_test_details for full test information.',
-            inputSchema: {
-                limit: z
-                    .number()
-                    .optional()
-                    .describe('Maximum number of tests to return (default: 20, max: 50)'),
-                offset: z
-                    .number()
-                    .optional()
-                    .describe('Pagination offset (default: 0)'),
-            },
-        }, wrapWithLogging('get_active_tests', async ({ limit, offset }) => {
-            const limitValue = Math.min(limit || 20, 50); // Cap at 50
-            const offsetValue = offset || 0;
-            const testStatuses = encodeURIComponent(JSON.stringify(['active']));
-            const data = await apiRequest(`/api/v1/mcp/tests?testStatuses=${testStatuses}&limit=${limitValue}&offset=${offsetValue}`);
-            // Return summarized test data to reduce response size
-            const summarizedTests = (data.items || []).map((test) => ({
-                id: test.id,
-                name: test.name,
-                status: test.status,
-                priority: test.priority,
-                description: test.description?.substring(0, 200) || null,
-                lastUpdated: test.lastUpdated,
-            }));
-            const total = data.totalCount || data.total || summarizedTests.length;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            tests: summarizedTests,
-                            total,
-                            limit: limitValue,
-                            offset: offsetValue,
-                            hasMore: total > offsetValue + limitValue,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }));
-    }
-    // Register tool: Update test status
-    if (canRegisterTool('update_test_status')) {
-        server.registerTool('update_test_status', {
-            description: 'Bulk update the status of multiple tests',
-            inputSchema: {
-                testIds: z
-                    .array(z.string())
-                    .describe('Array of test IDs to update (e.g., ["test_xxx", "test_yyy"])'),
-                status: z
-                    .enum([
-                    'active',
-                    'blocked_by_customer',
-                    'under_maintenance',
-                    'ignored',
-                    'draft',
-                    'ready_for_review',
-                    'requested',
-                    'expected_failure',
-                    'canceled',
-                    'suggested',
-                ])
-                    .describe('The new status to set for all tests'),
-                reason: z.string().describe('Reason for the status change'),
-                category: z
-                    .string()
-                    .optional()
-                    .describe('Optional category for the status change'),
-                updatedBy: z
-                    .string()
-                    .default('mcp-tool')
-                    .describe('Who is updating the status (default: mcp-tool)'),
-                triggerMaintenanceJobs: z
-                    .boolean()
-                    .optional()
-                    .describe('Whether to trigger maintenance jobs (default: false)'),
-                triggerCodegenJobs: z
-                    .boolean()
-                    .optional()
-                    .describe('Whether to trigger codegen jobs (default: false)'),
-            },
-        }, wrapWithLogging('update_test_status', async ({ testIds, status, reason, category, updatedBy, triggerMaintenanceJobs, triggerCodegenJobs, }) => {
-            const requestBody = {
-                bulkUpdateType: 'status',
-                ids: testIds,
-                change: {
-                    status,
-                    reason,
-                    category,
-                    updatedBy: updatedBy || 'mcp-tool',
-                },
-                triggerMaintenanceJobs,
-                triggerCodegenJobs,
-            };
-            const data = await apiRequest('/api/v1/mcp/tests/bulk-update', {
-                method: 'PATCH',
-                body: JSON.stringify(requestBody),
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Successfully updated ${data.updatedCount} test(s) to status "${status}".\n\nDetails:\n${JSON.stringify(data, null, 2)}`,
-                    },
-                ],
-            };
-        }));
-    }
-    // Register tool: Skip tests from description
-    if (canRegisterTool('skip_tests_from_description')) {
-        server.registerTool('skip_tests_from_description', {
-            description: 'Skip tests based on a user description by changing their status to under_maintenance',
-            inputSchema: {
-                userRequest: z
-                    .string()
-                    .describe('The user request describing which tests to skip (e.g., "skip all login tests")'),
-            },
-        }, wrapWithLogging('skip_tests_from_description', async ({ userRequest }) => {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `To skip tests based on the request: "${userRequest}"
-
-Follow these steps:
-
-1. Run get_active_tests to retrieve all active tests for the organization
-2. Review the test names and descriptions in the results
-3. Identify which test IDs are relevant to the user's request: "${userRequest}"
-4. Call update_test_status with:
-   - testIds: array of relevant test IDs you identified
-   - status: "under_maintenance"
-   - reason: "${userRequest}"
-   - updatedBy: the user's name or "mcp-tool"
-
-This will change the selected tests from "active" to "under_maintenance" status, effectively skipping them.`,
-                    },
-                ],
-            };
-        }));
-    }
-} // end registerTools
-// Factory function to create a new MCP server instance
-async function createMcpServer(token) {
-    const mcpServer = new McpServer({
-        name: 'ranger',
-        version: '1.0.0',
-    });
-    // Register all tools on this server instance with the token
-    await registerTools(mcpServer, token);
-    return mcpServer;
-}
-// Start the server
-async function main() {
-    const httpServer = createServer(async (req, res) => {
-        // Enable CORS
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-        if (req.method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        const url = new URL(req.url || '/', `http://localhost:${PORT}`);
-        // Extract token from Authorization header (supports both "Bearer <token>" and raw token)
-        const authHeader = req.headers.authorization;
-        const token = authHeader?.startsWith('Bearer ')
-            ? authHeader.slice(7)
-            : authHeader || undefined;
-        console.error(`[MCP] ${req.method} ${url.pathname} - Auth header: ${authHeader ? 'present' : 'missing'}, Token: ${token ? token.substring(0, 10) + '...' : 'none'}`);
-        if (url.pathname === '/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok' }));
-        }
-        else {
-            // Route all other paths to MCP handler
-            // Stateless mode - create a new server and transport for each request
-            // This allows horizontal scaling across multiple Cloud Run instances
-            const transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: undefined, // Stateless mode
-            });
-            // Create server with token bound to all API calls
-            const mcpServer = await createMcpServer(token);
-            await mcpServer.connect(transport);
-            await transport.handleRequest(req, res);
-        }
-    });
-    httpServer.listen(PORT, () => {
-        console.error(`Ranger MCP server running on http://localhost:${PORT}`);
-        console.error(`  MCP endpoint: http://localhost:${PORT}/mcp`);
-        console.error(`  Health check: http://localhost:${PORT}/health`);
-    });
-}
-main().catch((error) => {
-    console.error('Server error:', error);
-    process.exit(1);
-});

package/build/test-auth.js

@@ -1,13 +0,0 @@
-import { chromium } from 'playwright';
-async function main() {
-    const browser = await chromium.launch({ headless: false });
-    const context = await browser.newContext({
-        storageState: '/Users/adwithmukherjee/dev/lavender-core/lavender-core/.ranger/debug-tool/local/auth.json',
-    });
-    const page = await context.newPage();
-    await page.goto('http://localhost:3000');
-    // Keep browser open
-    console.log('Browser opened. Press Ctrl+C to close.');
-    await new Promise(() => { });
-}
-main().catch(console.error);