feat: full Cloud API coverage — 246 tools across 23 resource groups (supersedes #3)

.gitignore

@@ -61,3 +61,4 @@ jspm_packages/
 .env
 
 .history/
+.specs/

package.json

@@ -4,6 +4,7 @@
   "description": "MCP сервер для автоматизации развертывания приложений в Timeweb Cloud",
   "scripts": {
     "build": "tsdown && chmod 755 dist/index.js",
+    "prepare": "npm run build",
     "start": "node -r dotenv/config dist/index.js",
     "inspect": "export DANGEROUSLY_OMIT_AUTH=true && npx @modelcontextprotocol/inspector npm run start",
     "clean": "rm -rf dist",

src/actions/add-ai-agent-token-package.action.ts

@@ -0,0 +1,8 @@
+import { aiAgentsApiClient } from "../api";
+
+export const addAiAgentTokenPackageAction = async (
+  agentId: number,
+  count?: number
+): Promise<void> => {
+  await aiAgentsApiClient.addAgentTokenPackage(agentId, { count });
+};

src/actions/add-balancer-ips.action.ts

@@ -0,0 +1,8 @@
+import { balancersApiClient } from "../api";
+
+export const addBalancerIpsAction = async (
+  balancerId: number,
+  ips: string[]
+): Promise<void> => {
+  await balancersApiClient.addBalancerIps(balancerId, ips);
+};

src/actions/add-balancer-to-project.action.ts

@@ -0,0 +1,9 @@
+import { projectsApiClient } from "../api/projects";
+import { ProjectResource } from "../types/project.type";
+
+export const addBalancerToProjectAction = async (
+  projectId: number,
+  resourceId: number
+): Promise<ProjectResource> => {
+  return await projectsApiClient.addBalancerToProject(projectId, resourceId);
+};

src/actions/add-bucket-subdomain-certificate.action.ts

@@ -0,0 +1,7 @@
+import { s3BucketsApiClient } from "../api";
+
+export const addBucketSubdomainCertificateAction = async (
+  subdomain: string
+): Promise<void> => {
+  await s3BucketsApiClient.addBucketSubdomainCertificate(subdomain);
+};

src/actions/add-bucket-subdomains.action.ts

@@ -0,0 +1,9 @@
+import { s3BucketsApiClient } from "../api";
+import { AddedBucketSubdomain } from "../types/bucket-subdomain.type";
+
+export const addBucketSubdomainsAction = async (
+  bucketId: number,
+  subdomains: string[]
+): Promise<AddedBucketSubdomain[]> => {
+  return await s3BucketsApiClient.addBucketSubdomains(bucketId, subdomains);
+};

src/actions/add-bucket-to-project.action.ts

@@ -0,0 +1,9 @@
+import { projectsApiClient } from "../api/projects";
+import { ProjectResource } from "../types/project.type";
+
+export const addBucketToProjectAction = async (
+  projectId: number,
+  resourceId: number
+): Promise<ProjectResource> => {
+  return await projectsApiClient.addBucketToProject(projectId, resourceId);
+};

src/actions/add-cluster-to-project.action.ts

@@ -0,0 +1,9 @@
+import { projectsApiClient } from "../api/projects";
+import { ProjectResource } from "../types/project.type";
+
+export const addClusterToProjectAction = async (
+  projectId: number,
+  resourceId: number
+): Promise<ProjectResource> => {
+  return await projectsApiClient.addClusterToProject(projectId, resourceId);
+};

src/actions/add-database-to-project.action.ts

@@ -0,0 +1,9 @@
+import { projectsApiClient } from "../api/projects";
+import { ProjectResource } from "../types/project.type";
+
+export const addDatabaseToProjectAction = async (
+  projectId: number,
+  resourceId: number
+): Promise<ProjectResource> => {
+  return await projectsApiClient.addDatabaseToProject(projectId, resourceId);
+};

src/actions/add-dedicated-to-project.action.ts

@@ -0,0 +1,9 @@
+import { projectsApiClient } from "../api/projects";
+import { ProjectResource } from "../types/project.type";
+
+export const addDedicatedToProjectAction = async (
+  projectId: number,
+  resourceId: number
+): Promise<ProjectResource> => {
+  return await projectsApiClient.addDedicatedToProject(projectId, resourceId);
+};

src/actions/add-domain.action.ts

@@ -0,0 +1,5 @@
+import { domainsApiClient } from "../api";
+
+export const addDomainAction = async (fqdn: string): Promise<void> => {
+  await domainsApiClient.addDomain(fqdn);
+};

src/actions/add-knowledge-base-token-package.action.ts

@@ -0,0 +1,8 @@
+import { knowledgeBasesApiClient } from "../api";
+
+export const addKnowledgeBaseTokenPackageAction = async (
+  id: number,
+  count?: number
+): Promise<void> => {
+  await knowledgeBasesApiClient.addKnowledgeBaseTokenPackage(id, { count });
+};

src/actions/add-server-ip.action.ts

@@ -0,0 +1,9 @@
+import { serversApiClient, AddServerIpParams } from "../api/servers";
+import { ServerIp } from "../types/server-ip.type";
+
+export const addServerIpAction = async (
+  serverId: number,
+  params: AddServerIpParams
+): Promise<ServerIp> => {
+  return await serversApiClient.addServerIp(serverId, params);
+};

src/actions/add-server-to-project.action.ts

@@ -0,0 +1,9 @@
+import { projectsApiClient } from "../api/projects";
+import { ProjectResource } from "../types/project.type";
+
+export const addServerToProjectAction = async (
+  projectId: number,
+  resourceId: number
+): Promise<ProjectResource> => {
+  return await projectsApiClient.addServerToProject(projectId, resourceId);
+};

src/actions/add-ssh-keys-to-server.action.ts

@@ -0,0 +1,8 @@
+import { sshKeysApiClient } from "../api";
+
+export const addSshKeysToServerAction = async (
+  serverId: number,
+  sshKeyIds: number[]
+): Promise<void> => {
+  await sshKeysApiClient.addSshKeysToServer(serverId, sshKeyIds);
+};

src/actions/add-subdomain.action.ts

@@ -0,0 +1,9 @@
+import { domainsApiClient } from "../api";
+import { DomainSubdomain } from "../types/domain.type";
+
+export const addSubdomainAction = async (
+  fqdn: string,
+  subdomainFqdn: string
+): Promise<DomainSubdomain> => {
+  return await domainsApiClient.addSubdomain(fqdn, subdomainFqdn);
+};

src/actions/batch-create-mailboxes-v1.action.ts

@@ -0,0 +1,10 @@
+import { mailApiClient } from "../api";
+import { Mailbox } from "../types/mailbox.type";
+import { BatchCreateMailboxesV1RequestDto } from "../types/dto/batch-create-mailboxes-request.dto";
+
+export const batchCreateMailboxesV1Action = async (
+  domain: string,
+  data: BatchCreateMailboxesV1RequestDto
+): Promise<Mailbox[]> => {
+  return await mailApiClient.batchCreateMailboxesV1(domain, data);
+};

src/actions/batch-create-mailboxes.action.ts

@@ -0,0 +1,10 @@
+import { mailApiClient } from "../api";
+import { MailboxesBatchV2 } from "../types/mailbox.type";
+import { BatchCreateMailboxesV2RequestDto } from "../types/dto/batch-create-mailboxes-request.dto";
+
+export const batchCreateMailboxesAction = async (
+  domain: string,
+  data: BatchCreateMailboxesV2RequestDto
+): Promise<MailboxesBatchV2> => {
+  return await mailApiClient.batchCreateMailboxesV2(domain, data);
+};

src/actions/bind-floating-ip.action.ts

@@ -0,0 +1,9 @@
+import { dbaasApiClient } from "../api";
+import { BindFloatingIpRequestDto } from "../types/dto/bind-floating-ip-request.dto";
+
+export const bindFloatingIpAction = async (
+  floatingIpId: string,
+  data: BindFloatingIpRequestDto
+): Promise<void> => {
+  await dbaasApiClient.bindFloatingIp(floatingIpId, data);
+};

src/actions/check-domain.action.ts

@@ -0,0 +1,5 @@
+import { domainsApiClient } from "../api";
+
+export const checkDomainAction = async (fqdn: string): Promise<boolean> => {
+  return await domainsApiClient.checkDomain(fqdn);
+};

src/actions/clone-server.action.ts

@@ -0,0 +1,6 @@
+import { serversApiClient } from "../api";
+import { Server } from "../types/server.type";
+
+export const cloneServerAction = async (serverId: number): Promise<Server> => {
+  return await serversApiClient.cloneServer(serverId);
+};

src/actions/create-ai-agent.action.ts

@@ -0,0 +1,9 @@
+import { aiAgentsApiClient } from "../api";
+import { AiAgent } from "../types/ai-agent.type";
+import { CreateAiAgentRequestDto } from "../types/dto/create-ai-agent-request.dto";
+
+export const createAiAgentAction = async (
+  data: CreateAiAgentRequestDto
+): Promise<AiAgent> => {
+  return await aiAgentsApiClient.createAgent(data);
+};

src/actions/create-api-key.action.ts

@@ -0,0 +1,9 @@
+import { authApiClient } from "../api";
+import { CreatedApiKey } from "../types/api-key.type";
+import { CreateApiKeyRequestDto } from "../types/dto/create-api-key-request.dto";
+
+export const createApiKeyAction = async (
+  data: CreateApiKeyRequestDto
+): Promise<CreatedApiKey> => {
+  return await authApiClient.createApiKey(data);
+};

src/actions/create-balancer-rule.action.ts

@@ -0,0 +1,10 @@
+import { balancersApiClient } from "../api";
+import { BalancerRule } from "../types/balancer.type";
+import { CreateBalancerRuleRequestDto } from "../types/dto/create-balancer-rule-request.dto";
+
+export const createBalancerRuleAction = async (
+  balancerId: number,
+  data: CreateBalancerRuleRequestDto
+): Promise<BalancerRule> => {
+  return await balancersApiClient.createBalancerRule(balancerId, data);
+};

src/actions/create-balancer.action.ts

@@ -0,0 +1,9 @@
+import { balancersApiClient } from "../api";
+import { Balancer } from "../types/balancer.type";
+import { CreateBalancerRequestDto } from "../types/dto/create-balancer-request.dto";
+
+export const createBalancerAction = async (
+  data: CreateBalancerRequestDto
+): Promise<Balancer> => {
+  return await balancersApiClient.createBalancer(data);
+};

src/actions/create-bucket.action.ts

@@ -0,0 +1,9 @@
+import { s3BucketsApiClient } from "../api";
+import { Bucket } from "../types/bucket.type";
+import { CreateBucketRequestDto } from "../types/dto/create-bucket-request.dto";
+
+export const createBucketAction = async (
+  data: CreateBucketRequestDto
+): Promise<Bucket> => {
+  return await s3BucketsApiClient.createBucket(data);
+};

src/actions/create-container-registry.action.ts

@@ -0,0 +1,9 @@
+import { containerRegistryApiClient } from "../api";
+import { ContainerRegistry } from "../types/container-registry.type";
+import { CreateContainerRegistryRequestDto } from "../types/dto/create-container-registry-request.dto";
+
+export const createContainerRegistryAction = async (
+  data: CreateContainerRegistryRequestDto
+): Promise<ContainerRegistry> => {
+  return await containerRegistryApiClient.createContainerRegistry(data);
+};

src/actions/create-database-admin.action.ts

@@ -0,0 +1,10 @@
+import { dbaasApiClient } from "../api";
+import { DatabaseAdminEntity } from "../types/database-cluster.type";
+import { CreateDatabaseAdminRequestDto } from "../types/dto/create-database-admin-request.dto";
+
+export const createDatabaseAdminAction = async (
+  clusterId: number,
+  data: CreateDatabaseAdminRequestDto
+): Promise<DatabaseAdminEntity | null> => {
+  return await dbaasApiClient.createDatabaseAdmin(clusterId, data);
+};

src/actions/create-database-backup.action.ts

@@ -0,0 +1,9 @@
+import { dbaasApiClient } from "../api";
+import { DatabaseBackup } from "../types/database-cluster.type";
+
+export const createDatabaseBackupAction = async (
+  dbId: number,
+  comment?: string
+): Promise<DatabaseBackup | null> => {
+  return await dbaasApiClient.createDatabaseBackup(dbId, comment);
+};

src/actions/create-database-instance.action.ts

@@ -0,0 +1,10 @@
+import { dbaasApiClient } from "../api";
+import { DatabaseInstanceEntity } from "../types/database-cluster.type";
+import { CreateDatabaseInstanceRequestDto } from "../types/dto/create-database-instance-request.dto";
+
+export const createDatabaseInstanceAction = async (
+  clusterId: number,
+  data: CreateDatabaseInstanceRequestDto
+): Promise<DatabaseInstanceEntity | null> => {
+  return await dbaasApiClient.createDatabaseInstance(clusterId, data);
+};

src/actions/create-dedicated-server.action.ts

@@ -0,0 +1,9 @@
+import { dedicatedServersApiClient } from "../api";
+import { DedicatedServer } from "../types/dedicated-server.type";
+import { CreateDedicatedServerRequestDto } from "../types/dto/create-dedicated-server-request.dto";
+
+export const createDedicatedServerAction = async (
+  data: CreateDedicatedServerRequestDto
+): Promise<DedicatedServer> => {
+  return await dedicatedServersApiClient.createDedicatedServer(data);
+};

src/actions/create-dns-record.action.ts

@@ -0,0 +1,10 @@
+import { domainsApiClient } from "../api";
+import { DnsRecordV2 } from "../types/dns-record.type";
+import { CreateDnsRecordV2RequestDto } from "../types/dto/create-dns-record-request.dto";
+
+export const createDnsRecordAction = async (
+  fqdn: string,
+  data: CreateDnsRecordV2RequestDto
+): Promise<DnsRecordV2> => {
+  return await domainsApiClient.createDnsRecord(fqdn, data);
+};

src/actions/create-firewall-group.action.ts

@@ -0,0 +1,16 @@
+import { firewallApiClient } from "../api";
+import {
+  FirewallGroup,
+  FirewallPolicy,
+} from "../types/firewall-group.type";
+
+export const createFirewallGroupAction = async (
+  name: string,
+  description?: string,
+  policy?: FirewallPolicy
+): Promise<FirewallGroup> => {
+  return await firewallApiClient.createFirewallGroup(
+    { name, description },
+    policy
+  );
+};

src/actions/create-firewall-rule.action.ts

@@ -0,0 +1,10 @@
+import { firewallApiClient } from "../api";
+import { CreateFirewallRuleRequestDto } from "../types/dto/create-firewall-rule-request.dto";
+import { FirewallRule } from "../types/firewall-rule.type";
+
+export const createFirewallRuleAction = async (
+  groupId: string,
+  data: CreateFirewallRuleRequestDto
+): Promise<FirewallRule> => {
+  return await firewallApiClient.createFirewallRule(groupId, data);
+};

src/actions/create-image-download.action.ts

@@ -0,0 +1,10 @@
+import { imagesApiClient } from "../api";
+import { ImageDownload } from "../types/image-download.type";
+import { CreateImageDownloadRequestDto } from "../types/dto/create-image-download-request.dto";
+
+export const createImageDownloadAction = async (
+  imageId: string,
+  data: CreateImageDownloadRequestDto
+): Promise<ImageDownload> => {
+  return await imagesApiClient.createImageDownload(imageId, data);
+};

src/actions/create-image.action.ts

@@ -0,0 +1,9 @@
+import { imagesApiClient } from "../api";
+import { Image } from "../types/image.type";
+import { CreateImageRequestDto } from "../types/dto/create-image-request.dto";
+
+export const createImageAction = async (
+  data: CreateImageRequestDto
+): Promise<Image> => {
+  return await imagesApiClient.createImage(data);
+};

src/actions/create-k8s-cluster.action.ts

@@ -0,0 +1,9 @@
+import { kubernetesApiClient } from "../api";
+import { CreateK8sClusterRequestDto } from "../types/dto/create-k8s-cluster-request.dto";
+import { K8sCluster } from "../types/k8s-cluster.type";
+
+export const createK8sClusterAction = async (
+  data: CreateK8sClusterRequestDto
+): Promise<K8sCluster> => {
+  return await kubernetesApiClient.createCluster(data);
+};

src/actions/create-k8s-node-group.action.ts

@@ -0,0 +1,10 @@
+import { kubernetesApiClient } from "../api";
+import { CreateK8sNodeGroupRequestDto } from "../types/dto/create-k8s-node-group-request.dto";
+import { K8sNodeGroup } from "../types/k8s-node-group.type";
+
+export const createK8sNodeGroupAction = async (
+  clusterId: number,
+  data: CreateK8sNodeGroupRequestDto
+): Promise<K8sNodeGroup> => {
+  return await kubernetesApiClient.createNodeGroup(clusterId, data);
+};

src/actions/create-knowledge-base.action.ts

@@ -0,0 +1,9 @@
+import { knowledgeBasesApiClient } from "../api";
+import { KnowledgeBase } from "../types/knowledge-base.type";
+import { CreateKnowledgeBaseRequestDto } from "../types/dto/create-knowledge-base-request.dto";
+
+export const createKnowledgeBaseAction = async (
+  data: CreateKnowledgeBaseRequestDto
+): Promise<KnowledgeBase> => {
+  return await knowledgeBasesApiClient.createKnowledgeBase(data);
+};