@vucinatim/agentic-devtools 0.1.3 → 0.1.4

package/README.md

@@ -138,6 +138,21 @@ GitHub Actions Trusted Publishing over local write tokens. Use
 `setup-publishing npm` to run npm's official Trusted Publishing setup command
 through the package.
 
+### Railway Coverage
+
+The Railway tool now targets parity with Railway's documented public API for:
+
+- projects and project members
+- environments
+- services and service instances
+- deployments
+- variables
+- Railway-managed and custom domains
+- volumes
+
+This does not currently claim parity for undocumented dashboard-only concepts
+such as canvas grouping internals.
+
 Trusted Publishing notes:
 
 - npm currently documents Trusted Publishing for GitHub-hosted GitHub Actions,

package/docs/auth-and-setup-guidelines.md

@@ -159,6 +159,19 @@ Validation guidance:
   workspace-compatible reads
 - keep identity-only queries such as `me` as separate optional capabilities
 
+Current Railway management scope should cover the documented public API for:
+
+- projects and project members
+- environments
+- services and service instances
+- deployments
+- variables
+- service domains and custom domains
+- volumes
+
+Do not claim parity for dashboard-only or undocumented organization surfaces
+until Railway documents them as stable public API.
+
 ## Namecheap
 
 Namecheap is Tier 3.

package/docs/usage.md

@@ -157,6 +157,23 @@ Validation behavior:
 - identity-style `me` queries are not treated as the compatibility baseline for
   all bearer tokens
 
+Railway capability coverage:
+
+- read and mutate projects
+- list project members
+- read and mutate environments
+- read and mutate services
+- read and mutate service instance settings and limits
+- deploy and redeploy service instances
+- inspect deployments and list deployment history
+- upsert and delete variables
+- create, update, and delete Railway-managed and custom domains
+- create and delete volumes
+
+Not currently included as a supported public contract:
+
+- undocumented dashboard canvas/group organization internals
+
 Namecheap supports:
 
 - guided local setup through `agentic-devtools connect namecheap`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vucinatim/agentic-devtools",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "private": false,
   "description": "MCP-first devtools for AI agents.",
   "type": "module",

package/src/tools/railway/client.mjs

@@ -86,6 +86,16 @@ export const createRailwayClient = ({
     );
   };
 
+  const requireResolvedProjectId = async (projectId, operation) => {
+    try {
+      return await resolveProjectId(projectId);
+    } catch (error) {
+      throw new RailwayApiError(
+        error instanceof Error ? error.message : `${operation} requires a Railway project id.`,
+      );
+    }
+  };
+
   const getCurrentViewer = async () => {
     requireAccountToken("getRailwayViewer");
     const data = await request(`
@@ -231,6 +241,27 @@ export const createRailwayClient = ({
     };
   };
 
+  const getProjectMembers = async (projectId) => {
+    requireAccountToken("getRailwayProjectMembers");
+    const id = await requireResolvedProjectId(projectId, "getRailwayProjectMembers");
+    const data = await request(
+      `
+        query RailwayProjectMembers($projectId: String!) {
+          projectMembers(projectId: $projectId) {
+            id
+            role
+            user {
+              name
+              email
+            }
+          }
+        }
+      `,
+      { projectId: id },
+    );
+    return data.projectMembers;
+  };
+
   const listEnvironments = async ({ projectId, isEphemeral } = {}) => {
     const resolvedProjectId = await resolveProjectId(projectId);
     const data = await request(
@@ -308,6 +339,675 @@ export const createRailwayClient = ({
     };
   };
 
+  const getService = async (serviceId) => {
+    const data = await request(
+      `
+        query RailwayService($id: String!) {
+          service(id: $id) {
+            id
+            name
+            icon
+            createdAt
+            updatedAt
+            deletedAt
+            featureFlags
+            project {
+              id
+              name
+            }
+          }
+        }
+      `,
+      { id: serviceId },
+    );
+    return {
+      ...data.service,
+      projectId: data.service.project?.id ?? null,
+      projectName: data.service.project?.name ?? null,
+    };
+  };
+
+  const getServiceInstance = async ({ serviceId, environmentId }) => {
+    const data = await request(
+      `
+        query RailwayServiceInstance($serviceId: String!, $environmentId: String!) {
+          serviceInstance(serviceId: $serviceId, environmentId: $environmentId) {
+            id
+            serviceId
+            serviceName
+            environmentId
+            rootDirectory
+            railwayConfigFile
+            buildCommand
+            startCommand
+            healthcheckPath
+            cronSchedule
+            latestDeployment {
+              id
+              status
+              url
+              staticUrl
+            }
+            domains {
+              serviceDomains {
+                id
+                domain
+              }
+              customDomains {
+                id
+                domain
+              }
+            }
+          }
+        }
+      `,
+      { serviceId, environmentId },
+    );
+    return data.serviceInstance;
+  };
+
+  const getServiceInstanceLimits = async ({ serviceId, environmentId }) => {
+    const data = await request(
+      `
+        query RailwayServiceInstanceLimits($serviceId: String!, $environmentId: String!) {
+          serviceInstanceLimits(serviceId: $serviceId, environmentId: $environmentId)
+        }
+      `,
+      { serviceId, environmentId },
+    );
+    return data.serviceInstanceLimits;
+  };
+
+  const getDeployment = async (deploymentId) => {
+    const data = await request(
+      `
+        query RailwayDeployment($id: String!) {
+          deployment(id: $id) {
+            id
+            status
+            createdAt
+            updatedAt
+            statusUpdatedAt
+            canRedeploy
+            canRollback
+            deploymentStopped
+            environmentId
+            projectId
+            serviceId
+            url
+            staticUrl
+            service {
+              id
+              name
+            }
+            environment {
+              id
+              name
+            }
+          }
+        }
+      `,
+      { id: deploymentId },
+    );
+    return {
+      ...data.deployment,
+      serviceName: data.deployment.service?.name ?? null,
+      environmentName: data.deployment.environment?.name ?? null,
+    };
+  };
+
+  const listDeployments = async ({
+    projectId,
+    environmentId,
+    serviceId,
+    first = 20,
+    after = null,
+    before = null,
+    last = null,
+  } = {}) => {
+    const resolvedProjectId =
+      projectId == null && auth.kind === "project"
+        ? await requireResolvedProjectId(null, "listRailwayDeployments")
+        : projectId;
+
+    const input = compactObject({
+      projectId: resolvedProjectId,
+      environmentId,
+      serviceId,
+    });
+
+    const data = await request(
+      `
+        query RailwayDeployments(
+          $input: DeploymentListInput!
+          $first: Int
+          $after: String
+          $before: String
+          $last: Int
+        ) {
+          deployments(
+            input: $input
+            first: $first
+            after: $after
+            before: $before
+            last: $last
+          ) {
+            edges {
+              node {
+                id
+                status
+                createdAt
+                updatedAt
+                environmentId
+                projectId
+                serviceId
+                url
+                staticUrl
+              }
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `,
+      { input, first, after, before, last },
+    );
+
+    return {
+      deployments: connectionNodes(data.deployments),
+      pageInfo: data.deployments?.pageInfo ?? null,
+    };
+  };
+
+  const createProject = async (input = {}) => {
+    requireAccountToken("createRailwayProject");
+    const data = await request(
+      `
+        mutation RailwayProjectCreate($input: ProjectCreateInput!) {
+          projectCreate(input: $input) {
+            id
+            name
+            description
+            workspace {
+              id
+              name
+            }
+          }
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return data.projectCreate;
+  };
+
+  const updateProject = async ({ projectId, ...input } = {}) => {
+    requireAccountToken("updateRailwayProject");
+    const id = await requireResolvedProjectId(projectId, "updateRailwayProject");
+    const data = await request(
+      `
+        mutation RailwayProjectUpdate($id: String!, $input: ProjectUpdateInput!) {
+          projectUpdate(id: $id, input: $input) {
+            id
+            name
+            description
+            prDeploys
+            focusedPrEnvironments
+            botPrEnvironments
+            isPublic
+          }
+        }
+      `,
+      { id, input: compactObject(input) },
+    );
+    return data.projectUpdate;
+  };
+
+  const deleteProject = async (projectId) => {
+    requireAccountToken("deleteRailwayProject");
+    const id = await requireResolvedProjectId(projectId, "deleteRailwayProject");
+    const deleted = await request(
+      `
+        mutation RailwayProjectDelete($id: String!) {
+          projectDelete(id: $id)
+        }
+      `,
+      { id },
+    );
+    return {
+      deleted: Boolean(deleted.projectDelete),
+      projectId: id,
+    };
+  };
+
+  const transferProject = async ({ projectId, workspaceId } = {}) => {
+    requireAccountToken("transferRailwayProject");
+    const id = await requireResolvedProjectId(projectId, "transferRailwayProject");
+    const transferred = await request(
+      `
+        mutation RailwayProjectTransfer($projectId: String!, $input: ProjectTransferInput!) {
+          projectTransfer(projectId: $projectId, input: $input)
+        }
+      `,
+      {
+        projectId: id,
+        input: { workspaceId },
+      },
+    );
+    return {
+      transferred: Boolean(transferred.projectTransfer),
+      projectId: id,
+      workspaceId,
+    };
+  };
+
+  const createService = async (input = {}) => {
+    const data = await request(
+      `
+        mutation RailwayServiceCreate($input: ServiceCreateInput!) {
+          serviceCreate(input: $input) {
+            id
+            name
+            icon
+            projectId
+          }
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return data.serviceCreate;
+  };
+
+  const updateService = async ({ serviceId, ...input } = {}) => {
+    const data = await request(
+      `
+        mutation RailwayServiceUpdate($id: String!, $input: ServiceUpdateInput!) {
+          serviceUpdate(id: $id, input: $input) {
+            id
+            name
+            icon
+            projectId
+          }
+        }
+      `,
+      { id: serviceId, input: compactObject(input) },
+    );
+    return data.serviceUpdate;
+  };
+
+  const connectService = async ({ serviceId, ...input } = {}) => {
+    const data = await request(
+      `
+        mutation RailwayServiceConnect($id: String!, $input: ServiceConnectInput!) {
+          serviceConnect(id: $id, input: $input) {
+            id
+            name
+            icon
+            projectId
+          }
+        }
+      `,
+      { id: serviceId, input: compactObject(input) },
+    );
+    return data.serviceConnect;
+  };
+
+  const disconnectService = async (serviceId) => {
+    const disconnected = await request(
+      `
+        mutation RailwayServiceDisconnect($id: String!) {
+          serviceDisconnect(id: $id)
+        }
+      `,
+      { id: serviceId },
+    );
+    return {
+      disconnected: Boolean(disconnected.serviceDisconnect),
+      serviceId,
+    };
+  };
+
+  const deleteService = async ({ serviceId, environmentId } = {}) => {
+    const deleted = await request(
+      `
+        mutation RailwayServiceDelete($id: String!, $environmentId: String) {
+          serviceDelete(id: $id, environmentId: $environmentId)
+        }
+      `,
+      { id: serviceId, environmentId },
+    );
+    return {
+      deleted: Boolean(deleted.serviceDelete),
+      serviceId,
+      environmentId: environmentId ?? null,
+    };
+  };
+
+  const updateServiceInstance = async ({
+    serviceId,
+    environmentId,
+    ...input
+  } = {}) => {
+    const updated = await request(
+      `
+        mutation RailwayServiceInstanceUpdate(
+          $serviceId: String!
+          $environmentId: String
+          $input: ServiceInstanceUpdateInput!
+        ) {
+          serviceInstanceUpdate(
+            serviceId: $serviceId
+            environmentId: $environmentId
+            input: $input
+          )
+        }
+      `,
+      {
+        serviceId,
+        environmentId,
+        input: compactObject(input),
+      },
+    );
+    return {
+      updated: Boolean(updated.serviceInstanceUpdate),
+      serviceId,
+      environmentId: environmentId ?? null,
+    };
+  };
+
+  const deployService = async ({
+    serviceId,
+    environmentId,
+    commitSha,
+    latestCommit,
+  } = {}) => {
+    const deployment = await request(
+      `
+        mutation RailwayServiceInstanceDeploy(
+          $serviceId: String!
+          $environmentId: String!
+          $commitSha: String
+          $latestCommit: Boolean
+        ) {
+          serviceInstanceDeploy(
+            serviceId: $serviceId
+            environmentId: $environmentId
+            commitSha: $commitSha
+            latestCommit: $latestCommit
+          ) {
+            id
+            status
+            environmentId
+            serviceId
+            url
+            staticUrl
+          }
+        }
+      `,
+      { serviceId, environmentId, commitSha, latestCommit },
+    );
+    return deployment.serviceInstanceDeploy;
+  };
+
+  const redeployService = async ({ serviceId, environmentId } = {}) => {
+    const deployment = await request(
+      `
+        mutation RailwayServiceInstanceRedeploy(
+          $serviceId: String!
+          $environmentId: String!
+        ) {
+          serviceInstanceRedeploy(
+            serviceId: $serviceId
+            environmentId: $environmentId
+          ) {
+            id
+            status
+            environmentId
+            serviceId
+            url
+            staticUrl
+          }
+        }
+      `,
+      { serviceId, environmentId },
+    );
+    return deployment.serviceInstanceRedeploy;
+  };
+
+  const updateServiceInstanceLimits = async ({
+    serviceId,
+    environmentId,
+    memoryGB,
+    vCPUs,
+  } = {}) => {
+    const updated = await request(
+      `
+        mutation RailwayServiceInstanceLimitsUpdate(
+          $input: ServiceInstanceLimitsUpdateInput!
+        ) {
+          serviceInstanceLimitsUpdate(input: $input)
+        }
+      `,
+      {
+        input: compactObject({
+          serviceId,
+          environmentId,
+          memoryGB,
+          vCPUs,
+        }),
+      },
+    );
+    return {
+      updated: Boolean(updated.serviceInstanceLimitsUpdate),
+      serviceId,
+      environmentId,
+      memoryGB: memoryGB ?? null,
+      vCPUs: vCPUs ?? null,
+    };
+  };
+
+  const createEnvironment = async (input = {}) => {
+    const environment = await request(
+      `
+        mutation RailwayEnvironmentCreate($input: EnvironmentCreateInput!) {
+          environmentCreate(input: $input) {
+            id
+            name
+            isEphemeral
+            projectId
+          }
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return environment.environmentCreate;
+  };
+
+  const deleteEnvironment = async (environmentId) => {
+    const deleted = await request(
+      `
+        mutation RailwayEnvironmentDelete($id: String!) {
+          environmentDelete(id: $id)
+        }
+      `,
+      { id: environmentId },
+    );
+    return {
+      deleted: Boolean(deleted.environmentDelete),
+      environmentId,
+    };
+  };
+
+  const upsertVariable = async (input = {}) => {
+    const updated = await request(
+      `
+        mutation RailwayVariableUpsert($input: VariableUpsertInput!) {
+          variableUpsert(input: $input)
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return {
+      updated: Boolean(updated.variableUpsert),
+      name: input.name ?? null,
+      environmentId: input.environmentId ?? null,
+      serviceId: input.serviceId ?? null,
+      projectId: input.projectId ?? null,
+    };
+  };
+
+  const deleteVariable = async (input = {}) => {
+    const deleted = await request(
+      `
+        mutation RailwayVariableDelete($input: VariableDeleteInput!) {
+          variableDelete(input: $input)
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return {
+      deleted: Boolean(deleted.variableDelete),
+      name: input.name ?? null,
+      environmentId: input.environmentId ?? null,
+      serviceId: input.serviceId ?? null,
+      projectId: input.projectId ?? null,
+    };
+  };
+
+  const createServiceDomain = async (input = {}) => {
+    const domain = await request(
+      `
+        mutation RailwayServiceDomainCreate($input: ServiceDomainCreateInput!) {
+          serviceDomainCreate(input: $input) {
+            id
+            domain
+          }
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return domain.serviceDomainCreate;
+  };
+
+  const updateServiceDomain = async (input = {}) => {
+    const updated = await request(
+      `
+        mutation RailwayServiceDomainUpdate($input: ServiceDomainUpdateInput!) {
+          serviceDomainUpdate(input: $input)
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return {
+      updated: Boolean(updated.serviceDomainUpdate),
+      serviceDomainId: input.serviceDomainId ?? null,
+    };
+  };
+
+  const deleteServiceDomain = async (serviceDomainId) => {
+    const deleted = await request(
+      `
+        mutation RailwayServiceDomainDelete($id: String!) {
+          serviceDomainDelete(id: $id)
+        }
+      `,
+      { id: serviceDomainId },
+    );
+    return {
+      deleted: Boolean(deleted.serviceDomainDelete),
+      serviceDomainId,
+    };
+  };
+
+  const createCustomDomain = async (input = {}) => {
+    const domain = await request(
+      `
+        mutation RailwayCustomDomainCreate($input: CustomDomainCreateInput!) {
+          customDomainCreate(input: $input) {
+            id
+            domain
+          }
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return domain.customDomainCreate;
+  };
+
+  const updateCustomDomain = async ({
+    customDomainId,
+    environmentId,
+    targetPort,
+  } = {}) => {
+    const updated = await request(
+      `
+        mutation RailwayCustomDomainUpdate(
+          $id: String!
+          $environmentId: String!
+          $targetPort: Int
+        ) {
+          customDomainUpdate(
+            id: $id
+            environmentId: $environmentId
+            targetPort: $targetPort
+          )
+        }
+      `,
+      { id: customDomainId, environmentId, targetPort },
+    );
+    return {
+      updated: Boolean(updated.customDomainUpdate),
+      customDomainId,
+    };
+  };
+
+  const deleteCustomDomain = async (customDomainId) => {
+    const deleted = await request(
+      `
+        mutation RailwayCustomDomainDelete($id: String!) {
+          customDomainDelete(id: $id)
+        }
+      `,
+      { id: customDomainId },
+    );
+    return {
+      deleted: Boolean(deleted.customDomainDelete),
+      customDomainId,
+    };
+  };
+
+  const createVolume = async (input = {}) => {
+    const volume = await request(
+      `
+        mutation RailwayVolumeCreate($input: VolumeCreateInput!) {
+          volumeCreate(input: $input) {
+            id
+          }
+        }
+      `,
+      { input: compactObject(input) },
+    );
+    return volume.volumeCreate;
+  };
+
+  const deleteVolume = async (volumeId) => {
+    const deleted = await request(
+      `
+        mutation RailwayVolumeDelete($volumeId: String!) {
+          volumeDelete(volumeId: $volumeId)
+        }
+      `,
+      { volumeId },
+    );
+    return {
+      deleted: Boolean(deleted.volumeDelete),
+      volumeId,
+    };
+  };
+
   const doctorProject = async ({ projectId } = {}) => {
     const project = await getProject(projectId);
     const primaryEnvironmentId =
@@ -364,10 +1064,41 @@ export const createRailwayClient = ({
     getCurrentViewer,
     validateAccountToken,
     listProjects,
+    createProject,
+    updateProject,
+    deleteProject,
+    transferProject,
+    getProjectMembers,
     getProjectTokenContext,
     getProject,
     listEnvironments,
     getEnvironment,
+    createEnvironment,
+    deleteEnvironment,
+    getService,
+    getServiceInstance,
+    getServiceInstanceLimits,
+    createService,
+    updateService,
+    connectService,
+    disconnectService,
+    deleteService,
+    updateServiceInstance,
+    deployService,
+    redeployService,
+    updateServiceInstanceLimits,
+    getDeployment,
+    listDeployments,
+    upsertVariable,
+    deleteVariable,
+    createServiceDomain,
+    updateServiceDomain,
+    deleteServiceDomain,
+    createCustomDomain,
+    updateCustomDomain,
+    deleteCustomDomain,
+    createVolume,
+    deleteVolume,
     doctorProject,
   };
 };
@@ -382,6 +1113,11 @@ const connectionNodes = (connection) => {
   return nodes;
 };
 
+const compactObject = (value) =>
+  Object.fromEntries(
+    Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined),
+  );
+
 const hasErrors = (payload) =>
   typeof payload === "object" &&
   payload !== null &&

package/src/tools/railway/mcp.mjs

@@ -24,7 +24,8 @@ Optional environment variables:
   RAILWAY_PROJECT_ID
   RAILWAY_API_ENDPOINT
 
-Project tokens can inspect a single project. Account tokens can inspect account identity and list projects.
+Project tokens can manage resources scoped to the attached project environment.
+Account and workspace tokens can inspect and manage broader Railway resources.
 
 If env vars are not provided, use the connectRailway tool to open the browser-based setup flow and save a local Railway token.
 `;
@@ -47,7 +48,7 @@ const createServer = () => {
     },
     {
       instructions:
-        "Use these tools for read-only Railway project, environment, service, domain, and deployment inspection. Do not attempt deployment or variable mutation through this plugin.",
+        "Use these tools to inspect and manage Railway projects, environments, services, domains, variables, deployments, and volumes through the documented public API. Prefer read tools first, then use targeted write tools. Delete tools are destructive and should be used deliberately.",
     },
   );
 
@@ -156,6 +157,21 @@ const createServer = () => {
       ),
   );
 
+  server.registerTool(
+    "listRailwayProjectMembers",
+    {
+      description:
+        "List members of a Railway project. Requires an account or workspace token.",
+      inputSchema: {
+        projectId: z.string().min(1).optional(),
+      },
+    },
+    async ({ projectId } = {}) =>
+      createToolResult(
+        await withClient((client) => client.getProjectMembers(projectId)),
+      ),
+  );
+
   server.registerTool(
     "inspectRailwayProjectToken",
     {
@@ -183,6 +199,74 @@ const createServer = () => {
       ),
   );
 
+  server.registerTool(
+    "createRailwayProject",
+    {
+      description:
+        "Create a Railway project. Requires an account or workspace token.",
+      inputSchema: {
+        name: z.string().min(1).optional(),
+        description: z.string().optional(),
+        workspaceId: z.string().min(1).optional(),
+        defaultEnvironmentName: z.string().min(1).optional(),
+        isMonorepo: z.boolean().optional(),
+        isPublic: z.boolean().optional(),
+        prDeploys: z.boolean().optional(),
+        runtime: z.string().min(1).optional(),
+        repo: z.unknown().optional(),
+      },
+    },
+    async (args = {}) =>
+      createToolResult(await withClient((client) => client.createProject(args))),
+  );
+
+  server.registerTool(
+    "updateRailwayProject",
+    {
+      description:
+        "Update Railway project settings such as name, description, or PR environment behavior.",
+      inputSchema: {
+        projectId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        description: z.string().optional(),
+        baseEnvironmentId: z.string().min(1).optional(),
+        botPrEnvironments: z.boolean().optional(),
+        focusedPrEnvironments: z.boolean().optional(),
+        isPublic: z.boolean().optional(),
+        prDeploys: z.boolean().optional(),
+      },
+    },
+    async (args = {}) =>
+      createToolResult(await withClient((client) => client.updateProject(args))),
+  );
+
+  server.registerTool(
+    "deleteRailwayProject",
+    {
+      description:
+        "Delete a Railway project. Destructive. Requires an account or workspace token.",
+      inputSchema: {
+        projectId: z.string().min(1).optional(),
+      },
+    },
+    async ({ projectId } = {}) =>
+      createToolResult(await withClient((client) => client.deleteProject(projectId))),
+  );
+
+  server.registerTool(
+    "transferRailwayProject",
+    {
+      description:
+        "Transfer a Railway project to another workspace. Requires an account or workspace token.",
+      inputSchema: {
+        projectId: z.string().min(1).optional(),
+        workspaceId: z.string().min(1),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.transferProject(args))),
+  );
+
   server.registerTool(
     "listRailwayEnvironments",
     {
@@ -214,6 +298,452 @@ const createServer = () => {
       ),
   );
 
+  server.registerTool(
+    "createRailwayEnvironment",
+    {
+      description:
+        "Create a Railway environment inside a project.",
+      inputSchema: {
+        projectId: z.string().min(1),
+        name: z.string().min(1),
+        ephemeral: z.boolean().optional(),
+        sourceEnvironmentId: z.string().min(1).optional(),
+        skipInitialDeploys: z.boolean().optional(),
+        stageInitialChanges: z.boolean().optional(),
+        applyChangesInBackground: z.boolean().optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.createEnvironment(args))),
+  );
+
+  server.registerTool(
+    "deleteRailwayEnvironment",
+    {
+      description:
+        "Delete a Railway environment. Destructive.",
+      inputSchema: {
+        environmentId: z.string().min(1),
+      },
+    },
+    async ({ environmentId }) =>
+      createToolResult(
+        await withClient((client) => client.deleteEnvironment(environmentId)),
+      ),
+  );
+
+  server.registerTool(
+    "getRailwayService",
+    {
+      description: "Inspect one Railway service.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+      },
+    },
+    async ({ serviceId }) =>
+      createToolResult(await withClient((client) => client.getService(serviceId))),
+  );
+
+  server.registerTool(
+    "getRailwayServiceInstance",
+    {
+      description:
+        "Inspect one Railway service instance in a specific environment.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.getServiceInstance(args)),
+      ),
+  );
+
+  server.registerTool(
+    "getRailwayServiceInstanceLimits",
+    {
+      description:
+        "Get resource limits for a Railway service instance.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.getServiceInstanceLimits(args)),
+      ),
+  );
+
+  server.registerTool(
+    "createRailwayService",
+    {
+      description:
+        "Create a Railway service from a repo, image, template, or as an empty service.",
+      inputSchema: {
+        projectId: z.string().min(1),
+        environmentId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        icon: z.string().min(1).optional(),
+        branch: z.string().min(1).optional(),
+        templateId: z.string().min(1).optional(),
+        templateServiceId: z.string().min(1).optional(),
+        source: z.unknown().optional(),
+        registryCredentials: z.unknown().optional(),
+        variables: z.unknown().optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.createService(args))),
+  );
+
+  server.registerTool(
+    "updateRailwayService",
+    {
+      description:
+        "Update a Railway service name or icon.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        name: z.string().min(1).optional(),
+        icon: z.string().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.updateService(args))),
+  );
+
+  server.registerTool(
+    "connectRailwayService",
+    {
+      description:
+        "Connect an existing Railway service to a repo or image source.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        repo: z.string().min(1).optional(),
+        image: z.string().min(1).optional(),
+        branch: z.string().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.connectService(args))),
+  );
+
+  server.registerTool(
+    "disconnectRailwayService",
+    {
+      description:
+        "Disconnect a Railway service from its current source.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+      },
+    },
+    async ({ serviceId }) =>
+      createToolResult(
+        await withClient((client) => client.disconnectService(serviceId)),
+      ),
+  );
+
+  server.registerTool(
+    "deleteRailwayService",
+    {
+      description:
+        "Delete a Railway service. Destructive.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.deleteService(args))),
+  );
+
+  server.registerTool(
+    "updateRailwayServiceInstance",
+    {
+      description:
+        "Update build, deploy, region, healthcheck, cron, or source settings for a Railway service instance.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1).optional(),
+        buildCommand: z.string().optional(),
+        builder: z.string().min(1).optional(),
+        cronSchedule: z.string().optional(),
+        dockerfilePath: z.string().optional(),
+        drainingSeconds: z.number().int().min(0).optional(),
+        healthcheckPath: z.string().optional(),
+        healthcheckTimeout: z.number().int().min(0).optional(),
+        ipv6EgressEnabled: z.boolean().optional(),
+        multiRegionConfig: z.unknown().optional(),
+        nixpacksPlan: z.unknown().optional(),
+        numReplicas: z.number().int().min(0).optional(),
+        overlapSeconds: z.number().int().min(0).optional(),
+        preDeployCommand: z.array(z.string()).optional(),
+        railwayConfigFile: z.string().optional(),
+        region: z.string().optional(),
+        registryCredentials: z.unknown().optional(),
+        restartPolicyMaxRetries: z.number().int().min(0).optional(),
+        restartPolicyType: z.string().min(1).optional(),
+        rootDirectory: z.string().optional(),
+        sleepApplication: z.boolean().optional(),
+        source: z.unknown().optional(),
+        startCommand: z.string().optional(),
+        watchPatterns: z.array(z.string()).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.updateServiceInstance(args)),
+      ),
+  );
+
+  server.registerTool(
+    "deployRailwayService",
+    {
+      description:
+        "Trigger a Railway deployment for a service instance.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+        commitSha: z.string().min(1).optional(),
+        latestCommit: z.boolean().optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.deployService(args))),
+  );
+
+  server.registerTool(
+    "redeployRailwayService",
+    {
+      description:
+        "Redeploy the latest Railway deployment for a service instance.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.redeployService(args))),
+  );
+
+  server.registerTool(
+    "updateRailwayServiceInstanceLimits",
+    {
+      description:
+        "Update vCPU or memory limits for a Railway service instance.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+        memoryGB: z.number().positive().optional(),
+        vCPUs: z.number().positive().optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.updateServiceInstanceLimits(args)),
+      ),
+  );
+
+  server.registerTool(
+    "getRailwayDeployment",
+    {
+      description: "Inspect one Railway deployment.",
+      inputSchema: {
+        deploymentId: z.string().min(1),
+      },
+    },
+    async ({ deploymentId }) =>
+      createToolResult(
+        await withClient((client) => client.getDeployment(deploymentId)),
+      ),
+  );
+
+  server.registerTool(
+    "listRailwayDeployments",
+    {
+      description:
+        "List Railway deployments for a project, environment, or service.",
+      inputSchema: {
+        projectId: z.string().min(1).optional(),
+        environmentId: z.string().min(1).optional(),
+        serviceId: z.string().min(1).optional(),
+        first: z.number().int().min(1).max(100).optional(),
+        after: z.string().min(1).optional(),
+        before: z.string().min(1).optional(),
+        last: z.number().int().min(1).max(100).optional(),
+      },
+    },
+    async (args = {}) =>
+      createToolResult(await withClient((client) => client.listDeployments(args))),
+  );
+
+  server.registerTool(
+    "upsertRailwayVariable",
+    {
+      description:
+        "Create or update a Railway variable.",
+      inputSchema: {
+        projectId: z.string().min(1),
+        environmentId: z.string().min(1),
+        name: z.string().min(1),
+        value: z.string(),
+        serviceId: z.string().min(1).optional(),
+        skipDeploys: z.boolean().optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.upsertVariable(args))),
+  );
+
+  server.registerTool(
+    "deleteRailwayVariable",
+    {
+      description:
+        "Delete a Railway variable.",
+      inputSchema: {
+        projectId: z.string().min(1),
+        environmentId: z.string().min(1),
+        name: z.string().min(1),
+        serviceId: z.string().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.deleteVariable(args))),
+  );
+
+  server.registerTool(
+    "createRailwayServiceDomain",
+    {
+      description:
+        "Create a Railway-managed service domain.",
+      inputSchema: {
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+        targetPort: z.number().int().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.createServiceDomain(args)),
+      ),
+  );
+
+  server.registerTool(
+    "updateRailwayServiceDomain",
+    {
+      description:
+        "Update a Railway-managed service domain target port or domain binding.",
+      inputSchema: {
+        serviceDomainId: z.string().min(1),
+        serviceId: z.string().min(1),
+        environmentId: z.string().min(1),
+        domain: z.string().min(1),
+        targetPort: z.number().int().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.updateServiceDomain(args)),
+      ),
+  );
+
+  server.registerTool(
+    "deleteRailwayServiceDomain",
+    {
+      description:
+        "Delete a Railway-managed service domain.",
+      inputSchema: {
+        serviceDomainId: z.string().min(1),
+      },
+    },
+    async ({ serviceDomainId }) =>
+      createToolResult(
+        await withClient((client) => client.deleteServiceDomain(serviceDomainId)),
+      ),
+  );
+
+  server.registerTool(
+    "createRailwayCustomDomain",
+    {
+      description:
+        "Add a custom domain to a Railway service.",
+      inputSchema: {
+        projectId: z.string().min(1),
+        environmentId: z.string().min(1),
+        serviceId: z.string().min(1),
+        domain: z.string().min(1),
+        targetPort: z.number().int().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.createCustomDomain(args)),
+      ),
+  );
+
+  server.registerTool(
+    "updateRailwayCustomDomain",
+    {
+      description:
+        "Update a custom Railway domain target port.",
+      inputSchema: {
+        customDomainId: z.string().min(1),
+        environmentId: z.string().min(1),
+        targetPort: z.number().int().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(
+        await withClient((client) => client.updateCustomDomain(args)),
+      ),
+  );
+
+  server.registerTool(
+    "deleteRailwayCustomDomain",
+    {
+      description:
+        "Delete a custom Railway domain.",
+      inputSchema: {
+        customDomainId: z.string().min(1),
+      },
+    },
+    async ({ customDomainId }) =>
+      createToolResult(
+        await withClient((client) => client.deleteCustomDomain(customDomainId)),
+      ),
+  );
+
+  server.registerTool(
+    "createRailwayVolume",
+    {
+      description:
+        "Create a Railway volume.",
+      inputSchema: {
+        projectId: z.string().min(1),
+        mountPath: z.string().min(1),
+        environmentId: z.string().min(1).optional(),
+        serviceId: z.string().min(1).optional(),
+        region: z.string().min(1).optional(),
+      },
+    },
+    async (args) =>
+      createToolResult(await withClient((client) => client.createVolume(args))),
+  );
+
+  server.registerTool(
+    "deleteRailwayVolume",
+    {
+      description:
+        "Delete a Railway volume. Destructive.",
+      inputSchema: {
+        volumeId: z.string().min(1),
+      },
+    },
+    async ({ volumeId }) =>
+      createToolResult(await withClient((client) => client.deleteVolume(volumeId))),
+  );
+
   server.registerTool(
     "doctorRailwayProject",
     {