@crazyrabbitltc/railway-mcp/build/services/project.service.js

Railway MCP Server - 146+ tools with 100% Railway API coverage, comprehensive MCP testing framework, and real infrastructure management through AI assistants. Enhanced version with enterprise features, based on original work by Jason Tan.

import { BaseService } from '../services/base.service.js';
import { createSuccessResponse, createErrorResponse, formatError } from '../utils/responses.js';
export class ProjectService extends BaseService {
    constructor() {
        super();
    }
    async listProjects() {
        try {
            const projects = await this.client.projects.listProjects();
            if (projects.length === 0) {
                return createSuccessResponse({
                    text: "No projects found.",
                    data: []
                });
            }
            const projectDetails = projects.map(project => {
                const environments = project.environments?.edges?.length || 0;
                const services = project.services?.edges?.length || 0;
                return `📁 ${project.name} (ID: ${project.id})
Description: ${project.description || 'No description'}
Environments: ${environments}
${environments > 0 ? `${project.environments.edges.map(edge => `- ${edge.node.name} (${edge.node.id})`).join('\n')}` : ''}
Services: ${services}
${services > 0 ? `${project.services.edges.map(edge => `- ${edge.node.name} (${edge.node.id})`).join('\n')}` : ''}
Created: ${new Date(project.createdAt).toLocaleString()}`;
            });
            return createSuccessResponse({
                text: `Projects:\n\n${projectDetails.join('\n\n')}`,
                data: projects
            });
        }
        catch (error) {
            return createErrorResponse(`Error listing projects: ${formatError(error)}`);
        }
    }
    async getProject(projectId) {
        try {
            const project = await this.client.projects.getProject(projectId);
            if (!project) {
                return createErrorResponse("Project not found.");
            }
            const environments = project.environments?.edges?.map(edge => edge.node) || [];
            const services = project.services?.edges?.map(edge => edge.node) || [];
            const environmentList = environments.map(env => `  🌍 ${env.name} (ID: ${env.id})`).join('\n');
            const serviceList = services.map(svc => `  🚀 ${svc.name} (ID: ${svc.id})`).join('\n');
            const info = `📁 Project: ${project.name} (ID: ${project.id})
Description: ${project.description || 'No description'}
Created: ${new Date(project.createdAt).toLocaleString()}
Subscription: ${project.subscriptionType || 'Free'}

Environments:
${environmentList || '  No environments'}

Services:
${serviceList || '  No services'}`;
            return createSuccessResponse({
                text: info,
                data: { project, environments, services }
            });
        }
        catch (error) {
            return createErrorResponse(`Error getting project details: ${formatError(error)}`);
        }
    }
    async createProject(name, teamId) {
        try {
            const project = await this.client.projects.createProject(name, teamId);
            return createSuccessResponse({
                text: `Created new project "${project.name}" (ID: ${project.id})`,
                data: project
            });
        }
        catch (error) {
            return createErrorResponse(`Error creating project: ${formatError(error)}`);
        }
    }
    async deleteProject(projectId) {
        try {
            await this.client.projects.deleteProject(projectId);
            return createSuccessResponse({
                text: "Project deleted successfully"
            });
        }
        catch (error) {
            return createErrorResponse(`Error deleting project: ${formatError(error)}`);
        }
    }
    async deleteProjects(projectIds) {
        try {
            const results = [];
            let deleted = 0;
            let failed = 0;
            for (const projectId of projectIds) {
                try {
                    await this.client.projects.deleteProject(projectId);
                    results.push(`✅ Successfully deleted project: ${projectId}`);
                    deleted++;
                }
                catch (error) {
                    results.push(`❌ Failed to delete project ${projectId}: ${formatError(error)}`);
                    failed++;
                }
            }
            const summary = `Batch deletion complete: ${deleted} successful, ${failed} failed`;
            return createSuccessResponse({
                text: `${summary}\n\n${results.join('\n')}`,
                data: { deleted, failed, results }
            });
        }
        catch (error) {
            return createErrorResponse(`Error in batch delete: ${formatError(error)}`);
        }
    }
    async listEnvironments(projectId) {
        try {
            const environments = await this.client.projects.listEnvironments(projectId);
            if (environments.length === 0) {
                return createSuccessResponse({
                    text: "No environments found in this project.",
                    data: []
                });
            }
            const environmentDetails = environments.map(env => `🌍 ${env.name} (ID: ${env.id})
Created: ${new Date(env.createdAt).toLocaleString()}
${env.isEphemeral ? '(Ephemeral)' : '(Permanent)'}
${env.unmergedChangesCount ? `Unmerged Changes: ${env.unmergedChangesCount}` : ''}`);
            return createSuccessResponse({
                text: `Environments in project:\n\n${environmentDetails.join('\n\n')}`,
                data: environments
            });
        }
        catch (error) {
            return createErrorResponse(`Error listing environments: ${formatError(error)}`);
        }
    }
}
// Initialize and export the singleton instance
export const projectService = new ProjectService();