tport-cloud-mcp 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Biz59 LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,66 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# tport-cloud-mcp
+
+MCP server for [tport.cloud](https://tport.cloud): order and manage servers, managed databases and free DNS from
+Claude, Cursor or any MCP client. It runs on your machine over stdio and calls the tport.cloud API with your API key.
+
+## Set up
+
+1. In the console (https://app.tport.cloud) make an API key and tick only the scopes you want the assistant to have.
+   A key can only do what its scopes allow; the API refuses the rest (403 naming the missing scope).
+2. Add the server to your MCP client.
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "tport-cloud": {
+      "command": "npx",
+      "args": ["-y", "tport-cloud-mcp"],
+      "env": { "TPORT_API_KEY": "tpct_..." }
+    }
+  }
+}
+```
+
+Claude Code: `claude mcp add tport-cloud -e TPORT_API_KEY=tpct_... -- npx -y tport-cloud-mcp`
+
+| Env | Meaning |
+| --- | --- |
+| `TPORT_API_KEY` | Your API key (`tpct_...`). Needed for everything except `list_plans`. |
+| `TPORT_API_URL` | Optional, default `https://api.tport.cloud`. |
+
+## Tools
+
+| Tool | Does | Scope |
+| --- | --- | --- |
+| `list_plans` | Plans, prices, regions, images, installs, availability | none |
+| `list_servers`, `get_server`, `get_order` | Your servers and shared accounts, one in detail, an order's progress | `servers:read` |
+| `create_server` | Order a root server or shared account (charged from the balance) | `servers:create` |
+| `resize_server` | Move to another plan of the same kind | `servers:resize` |
+| `power` | Start, stop, restart | `servers:power` |
+| `delete_server` | Delete (typed name to confirm; unused days credited) | `servers:delete` |
+| `data_catalogue` | Database engines, add-ons, prices, sizes per region, availability | none |
+| `data_list`, `data_get` | Your managed databases, one in detail (the login, once) | `databases:read` |
+| `data_create`, `data_set_allow`, `data_resize`, `data_delete` | Order, allow list, resize, delete | `databases:write` |
+| `databases_list`, `databases_get` | Primary + standby PostgreSQL clusters | `databases:read` |
+| `databases_create`, `databases_set_allow`, `databases_delete` | Order, allow list, delete | `databases:write` |
+| `domains_list` | A server's own domains and the records to set | `dns:read` |
+| `domains_add`, `domains_check`, `domains_remove` | Your own domain on a small server | `dns:write` |
+| `dns_list_zones`, `dns_get_zone` | Zones and records on the free nameservers | `dns:read` |
+| `dns_add_zone`, `dns_delete_zone`, `dns_add_record`, `dns_delete_record` | Change zones and records | `dns:write` |
+| `get_billing` | Balance and ledger | `billing:read` |
+
+A new database's login is shown once, by the first `data_get` after setup, so your assistant sees it and it can't be
+read again. Deleting asks for the item's name in `confirm`, as the console does. Errors come back as the API's own message.
+
+## Develop
+
+```sh
+npm install
+npm test              # stub API on 127.0.0.1, end to end through an MCP client
+TPORT_LIVE=1 npm test # also read-only checks against the real API (add TPORT_API_KEY to list your servers)
+npm run build         # build/index.js, the `tport-cloud-mcp` bin
+```
+
+MIT licence. (c) Biz59 LLC.

package/build/api.js

@@ -0,0 +1,63 @@
+// Thin client for the tport.cloud API. Every call sends the API key as a Bearer token; the API checks the key's
+// scopes and answers 403 naming the missing one, so this client never second-guesses permissions.
+export const DEFAULT_API_URL = "https://api.tport.cloud";
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export class TportApi {
+    key;
+    base;
+    constructor(key, base = DEFAULT_API_URL) {
+        this.key = key;
+        this.base = base;
+        this.base = base.replace(/\/+$/, "");
+    }
+    async request(method, path, opts = {}) {
+        const url = new URL(this.base + path);
+        for (const [k, v] of Object.entries(opts.query ?? {})) {
+            if (v !== undefined && v !== "")
+                url.searchParams.set(k, String(v));
+        }
+        const headers = { Accept: "application/json", "User-Agent": "tport-cloud-mcp" };
+        if (this.key)
+            headers.Authorization = `Bearer ${this.key}`;
+        if (opts.body !== undefined)
+            headers["Content-Type"] = "application/json";
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+        });
+        const text = await res.text();
+        let data = text;
+        try {
+            data = text ? JSON.parse(text) : null;
+        }
+        catch {
+            // not JSON (a proxy error page): keep the text
+        }
+        if (!res.ok)
+            throw new ApiError(res.status, errorText(res.status, data));
+        return data;
+    }
+    get = (path, query) => this.request("GET", path, { query });
+    post = (path, body = {}) => this.request("POST", path, { body });
+    put = (path, body) => this.request("PUT", path, { body });
+    del = (path, query) => this.request("DELETE", path, { query });
+}
+// FastAPI sends {"detail": "..."} (or a list of validation errors); show the API's own words.
+function errorText(status, data) {
+    const detail = data?.detail;
+    if (typeof detail === "string")
+        return `${status}: ${detail}`;
+    if (Array.isArray(detail)) {
+        return `${status}: ` + detail.map((d) => `${(d.loc ?? []).slice(1).join(".")} ${d.msg ?? ""}`.trim()).join("; ");
+    }
+    if (status === 401)
+        return "401: the API key was refused (check TPORT_API_KEY; make one at https://app.tport.cloud)";
+    return `${status}: ${typeof data === "string" ? data.slice(0, 300) : JSON.stringify(data)}`;
+}

package/build/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// tport.cloud MCP server over stdio: `npx tport-cloud-mcp` with TPORT_API_KEY set (TPORT_API_URL to point elsewhere).
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { DEFAULT_API_URL, TportApi } from "./api.js";
+import { makeServer } from "./server.js";
+if (!process.env.TPORT_API_KEY) {
+    console.error("tport-cloud-mcp: set TPORT_API_KEY (make a key with the scopes you want at https://app.tport.cloud)");
+}
+const api = new TportApi(process.env.TPORT_API_KEY ?? "", process.env.TPORT_API_URL || DEFAULT_API_URL);
+await makeServer(api).connect(new StdioServerTransport());

package/build/server.js

@@ -0,0 +1,25 @@
+// The MCP server: lists TOOLS and runs them against the API; API errors come back as tool errors in the API's words.
+import { readFileSync } from "fs";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { TOOLS } from "./tools.js";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+export function makeServer(api) {
+    const server = new Server({ name: "tport-cloud-mcp", version: pkg.version }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOLS.map(({ name, description, inputSchema, annotations }) => ({ name, description, inputSchema, annotations })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const tool = TOOLS.find((t) => t.name === req.params.name);
+        if (!tool)
+            return { isError: true, content: [{ type: "text", text: `Unknown tool ${req.params.name}` }] };
+        try {
+            const out = await tool.run(api, req.params.arguments ?? {});
+            return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+        }
+        catch (e) {
+            return { isError: true, content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }] };
+        }
+    });
+    return server;
+}

package/build/tools.js

@@ -0,0 +1,306 @@
+const str = (description) => ({ type: "string", description });
+const int = (description) => ({ type: "integer", description });
+const strs = (description) => ({ type: "array", items: { type: "string" }, description });
+const obj = (properties, required = []) => ({ type: "object", properties, ...(required.length ? { required } : {}) });
+const id = (v) => encodeURIComponent(String(v ?? ""));
+const READ = { readOnlyHint: true };
+const DESTROY = { destructiveHint: true };
+const SERVER_ID = str("Server id from list_servers: srv-<n> (root server) or sh-<n> (shared account)");
+const CLUSTER_ID = str("Cluster id from databases_list: pg-<n>");
+const DATA_ID = str("Database id from data_list: db-<n>");
+const DATA_PRICE = int("Monthly price in cents from data_catalogue, without add-ons, e.g. 800");
+const REGION = str("Region id from list_plans, e.g. eu (Germany), us (US Central), uk, us-east, us-west, sg");
+// Only what was given goes in the body, so the API's own defaults apply to the rest.
+function pick(args, keys) {
+    return Object.fromEntries(keys.filter((k) => args[k] !== undefined).map((k) => [k, args[k]]));
+}
+export const TOOLS = [
+    {
+        name: "list_plans",
+        description: "What can be ordered: plans with monthly price (cents), vCPU, RAM, disk; regions; images; installs " +
+            "(python, node, postgresql...); which plan is available in which region. Managed databases by engine are in " +
+            "data_catalogue. No key needed.",
+        inputSchema: obj({ kind: str("Only plans of this kind: shared, root or pg") }),
+        annotations: READ,
+        run: async (api, a) => {
+            const cat = (await api.get("/api/catalogue"));
+            return a.kind && cat.plans ? { ...cat, plans: cat.plans.filter((p) => p.kind === a.kind) } : cat;
+        },
+    },
+    {
+        name: "list_servers",
+        description: "Your servers and shared accounts with status, plan, region and IP. Scope servers:read.",
+        inputSchema: obj({}),
+        annotations: READ,
+        run: (api) => api.get("/api/servers"),
+    },
+    {
+        name: "get_server",
+        description: "One server or shared account in detail: status, IP, plan, price, paid until, recent events. " +
+            "Scope servers:read.",
+        inputSchema: obj({ id: SERVER_ID }, ["id"]),
+        annotations: READ,
+        run: (api, a) => api.get(`/api/servers/${id(a.id)}`),
+    },
+    {
+        name: "create_server",
+        description: "Order a server (kind server = own root server) or a shared account (kind shared). The first 30 " +
+            "days are charged from the account balance; setup takes a few minutes (watch it with get_order or " +
+            "get_server). Ubuntu 24.04 only. A root server without ssh_keys answers a one-time root password once. " +
+            "Scope servers:create.",
+        inputSchema: obj({
+            kind: { type: "string", enum: ["server", "shared"], description: "server (default) or shared" },
+            plan: str("Plan id from list_plans"),
+            region: REGION,
+            name: str("Server name: lower-case letters, digits and dashes"),
+            ssh_keys: strs("Public SSH keys to install"),
+            installs: strs("Software to set up, from list_plans installs, optionally with a version: python, node:22, postgresql:18"),
+            access_mode: { type: "string", enum: ["root", "noroot"], description: "root (default) or noroot: your key on " +
+                    "your own user, no sudo, root login off. noroot needs user and confirm_no_root" },
+            user: str("noroot only: the login user name"),
+            confirm_no_root: str("noroot only: type the server name again to confirm you will have no root access"),
+        }, ["plan", "region", "name"]),
+        run: (api, a) => api.post("/api/orders", {
+            kind: a.kind ?? "server",
+            ...pick(a, ["plan", "region", "name", "ssh_keys", "installs", "access_mode", "user", "confirm_no_root"]),
+        }),
+    },
+    {
+        name: "get_order",
+        description: "An order's progress (queued, creating, ready, failed) with its item id. Not for data_create, " +
+            "which has no order: use data_list. Scope servers:read.",
+        inputSchema: obj({ order_id: int("Order id returned by create_server or databases_create") }, ["order_id"]),
+        annotations: READ,
+        run: (api, a) => api.get(`/api/orders/${id(a.order_id)}`),
+    },
+    {
+        name: "resize_server",
+        description: "Move a server or shared account to another plan of the same kind. Bigger: the difference for the " +
+            "days already paid is charged from the balance now. Smaller: the unused difference goes back, and only when " +
+            "the data fits in 80% of the new disk. Then the new price applies. Scope servers:resize.",
+        inputSchema: obj({ id: SERVER_ID, plan: str("The new plan id from list_plans") }, ["id", "plan"]),
+        run: (api, a) => api.post(`/api/servers/${id(a.id)}/resize`, { plan: a.plan }),
+    },
+    {
+        name: "power",
+        description: "Start, stop or restart a server. Scope servers:power.",
+        inputSchema: obj({
+            id: SERVER_ID,
+            action: { type: "string", enum: ["start", "stop", "restart"] },
+        }, ["id", "action"]),
+        run: (api, a) => api.post(`/api/servers/${id(a.id)}/power`, { action: a.action }),
+    },
+    {
+        name: "delete_server",
+        description: "Delete a server or shared account and everything on it; unused days go back to the balance. " +
+            "Cannot be undone. Scope servers:delete.",
+        inputSchema: obj({ id: SERVER_ID, confirm: str("The server's name, typed to confirm") }, ["id", "confirm"]),
+        annotations: DESTROY,
+        run: (api, a) => api.request("DELETE", `/api/servers/${id(a.id)}`, { body: { confirm: a.confirm } }),
+    },
+    {
+        name: "databases_list",
+        description: "Your primary + standby PostgreSQL clusters with status, plan and region. Databases of every engine are in " +
+            "data_list. Scope databases:read.",
+        inputSchema: obj({}),
+        annotations: READ,
+        run: (api) => api.get("/api/clusters"),
+    },
+    {
+        name: "databases_get",
+        description: "One PostgreSQL cluster: status, connection details, pooler, standby, allow list. " +
+            "Scope databases:read.",
+        inputSchema: obj({ id: CLUSTER_ID }, ["id"]),
+        annotations: READ,
+        run: (api, a) => api.get(`/api/clusters/${id(a.id)}`),
+    },
+    {
+        name: "databases_create",
+        description: "Order a primary + standby PostgreSQL cluster (plan kind pg from list_plans). For one database of " +
+            "any engine use data_create. The first 30 days are charged from the balance. Scope databases:write.",
+        inputSchema: obj({
+            plan: str("pg plan id from list_plans"),
+            region: REGION,
+            name: str("Cluster name: lower-case letters, digits and dashes"),
+            version: str("PostgreSQL major version (default: the newest offered)"),
+            allow: strs("IP addresses or CIDRs allowed to connect, e.g. 203.0.113.7/32"),
+        }, ["plan", "region", "name"]),
+        run: (api, a) => api.post("/api/orders", { kind: "pg", ...pick(a, ["plan", "region", "name", "version", "allow"]) }),
+    },
+    {
+        name: "databases_set_allow",
+        description: "Replace a cluster's allow list (who may connect). An empty list closes it. Scope databases:write.",
+        inputSchema: obj({ id: CLUSTER_ID, allow: strs("IP addresses or CIDRs") }, ["id", "allow"]),
+        run: (api, a) => api.put(`/api/clusters/${id(a.id)}/allow`, { allow: a.allow }),
+    },
+    {
+        name: "databases_delete",
+        description: "Delete a PostgreSQL cluster and its data; unused days go back to the balance. " +
+            "Cannot be undone. Scope databases:write.",
+        inputSchema: obj({ id: CLUSTER_ID, confirm: str("The cluster's name, typed to confirm") }, ["id", "confirm"]),
+        annotations: DESTROY,
+        run: (api, a) => api.request("DELETE", `/api/clusters/${id(a.id)}`, { body: { confirm: a.confirm } }),
+    },
+    {
+        name: "data_catalogue",
+        description: "Managed databases that can be ordered: PostgreSQL, MariaDB, CouchDB, SQLite, FAISS, Chroma, Qdrant, " +
+            "Weaviate, Milvus. For each engine its add-ons and prices, what each price buys per region (vCPU, RAM, disk) " +
+            "and whether it can be ordered there now. No key needed.",
+        inputSchema: obj({ engine: str("Only this engine, by its id, e.g. pgsql, mariadb, qdrant") }),
+        annotations: READ,
+        run: async (api, a) => {
+            const cat = (await api.get("/api/data/catalogue"));
+            return a.engine && cat.engines ? { ...cat, engines: cat.engines.filter((e) => e.id === a.engine) } : cat;
+        },
+    },
+    {
+        name: "data_list",
+        description: "Your managed databases with engine, status, size, region, address and allow list, never the login. " +
+            "Use it to watch a new database until its status is running. Scope databases:read.",
+        inputSchema: obj({}),
+        annotations: READ,
+        run: (api) => api.get("/api/data/services"),
+    },
+    {
+        // Not marked read-only: the first read after setup hands over the login and removes it from the API.
+        name: "data_get",
+        description: "One managed database in detail with recent events. The first call after setup also answers its login " +
+            "in credentials, once: it can't be read again, so give it to the user right away. Scope databases:read.",
+        inputSchema: obj({ id: DATA_ID }, ["id"]),
+        run: (api, a) => api.get(`/api/data/services/${id(a.id)}`),
+    },
+    {
+        name: "data_create",
+        description: "Order a managed database. The first 30 days, add-ons included, are charged from the balance; setup " +
+            "takes a few minutes (watch it with data_list). Nothing can connect until an IP is on its allow list. " +
+            "Scope databases:write.",
+        inputSchema: obj({
+            engine: str("Engine id from data_catalogue, e.g. pgsql"),
+            price_cents: DATA_PRICE,
+            region: str("Region id from data_catalogue: eu (Germany), us or in (India)"),
+            name: str("Database name: 2-31 characters, lower-case letters, digits and single dashes, starting with a letter"),
+            addons: strs("Add-on ids for this engine from data_catalogue, e.g. pgvector, postgis, spatialite"),
+            allow: strs("IP addresses or CIDRs allowed to connect, e.g. 203.0.113.7/32"),
+        }, ["engine", "price_cents", "region", "name"]),
+        run: (api, a) => api.post("/api/data/services", pick(a, ["engine", "price_cents", "region", "name", "addons", "allow"])),
+    },
+    {
+        name: "data_set_allow",
+        description: "Replace a managed database's allow list (who may connect). An empty list closes it. " +
+            "Scope databases:write.",
+        inputSchema: obj({ id: DATA_ID, allow: strs("IP addresses or CIDRs") }, ["id", "allow"]),
+        run: (api, a) => api.put(`/api/data/services/${id(a.id)}/allow`, { allow: a.allow }),
+    },
+    {
+        name: "data_resize",
+        description: "Move a running database to another price for its engine and region. Bigger: the difference for the " +
+            "days already paid is charged from the balance now. Smaller: the unused difference goes back, and only when the " +
+            "data fits in 80% of the new disk. Some steps can't be done in place and answer 409; pick a smaller step. " +
+            "Scope databases:write.",
+        inputSchema: obj({ id: DATA_ID, price_cents: DATA_PRICE }, ["id", "price_cents"]),
+        run: (api, a) => api.post(`/api/data/services/${id(a.id)}/resize`, { price_cents: a.price_cents }),
+    },
+    {
+        name: "data_delete",
+        description: "Delete a managed database and its data; unused days go back to the balance. Cannot be undone. " +
+            "Scope databases:write.",
+        inputSchema: obj({ id: DATA_ID, confirm: str("The database's name, typed to confirm") }, ["id", "confirm"]),
+        annotations: DESTROY,
+        run: (api, a) => api.request("DELETE", `/api/data/services/${id(a.id)}`, { body: { confirm: a.confirm } }),
+    },
+    {
+        name: "domains_list",
+        description: "A server's own domains: each one's status and the two records to set. A server with its own address " +
+            "(own_address true) needs only an A record at your DNS. Scope dns:read.",
+        inputSchema: obj({ server_id: SERVER_ID }, ["server_id"]),
+        annotations: READ,
+        run: (api, a) => api.get(`/api/servers/${id(a.server_id)}/domains`),
+    },
+    {
+        name: "domains_add",
+        description: "Add your own domain to a small server. Set the A and TXT records in the answer; we check them, turn on " +
+            "HTTPS and route the domain to the server. Scope dns:write.",
+        inputSchema: obj({ server_id: SERVER_ID, domain: str("Domain, e.g. shop.example.com") }, ["server_id", "domain"]),
+        run: (api, a) => api.post(`/api/servers/${id(a.server_id)}/domains`, { domain: a.domain }),
+    },
+    {
+        name: "domains_check",
+        description: "Check a domain's records again now, or restart one that stopped trying. Scope dns:write.",
+        inputSchema: obj({ server_id: SERVER_ID, domain_id: int("Domain id from domains_list") }, ["server_id", "domain_id"]),
+        run: (api, a) => api.post(`/api/servers/${id(a.server_id)}/domains/${id(a.domain_id)}/check`, {}),
+    },
+    {
+        name: "domains_remove",
+        description: "Take a domain off a server. Scope dns:write.",
+        inputSchema: obj({ server_id: SERVER_ID, domain_id: int("Domain id from domains_list") }, ["server_id", "domain_id"]),
+        annotations: DESTROY,
+        run: (api, a) => api.del(`/api/servers/${id(a.server_id)}/domains/${id(a.domain_id)}`),
+    },
+    {
+        name: "dns_list_zones",
+        description: "Your DNS zones on the free tport.cloud nameservers, the nameservers to set at your registrar and " +
+            "the record types offered. Scope dns:read.",
+        inputSchema: obj({}),
+        annotations: READ,
+        run: (api) => api.get("/api/dns"),
+    },
+    {
+        name: "dns_get_zone",
+        description: "All records of one zone. Scope dns:read.",
+        inputSchema: obj({ zone: str("Domain, e.g. example.com") }, ["zone"]),
+        annotations: READ,
+        run: (api, a) => api.get(`/api/dns/zones/${id(a.zone)}`),
+    },
+    {
+        name: "dns_add_zone",
+        description: "Host a domain on the free tport.cloud nameservers, optionally with an apex A/AAAA record. " +
+            "Scope dns:write.",
+        inputSchema: obj({ zone: str("Domain, e.g. example.com"), ip: str("Optional IPv4/IPv6 for the apex record") }, ["zone"]),
+        run: (api, a) => api.post("/api/dns/zones", { name: a.zone, ...pick(a, ["ip"]) }),
+    },
+    {
+        name: "dns_delete_zone",
+        description: "Delete a zone and all its records. Scope dns:write.",
+        inputSchema: obj({ zone: str("Domain"), confirm: str("The domain again, typed to confirm") }, ["zone", "confirm"]),
+        annotations: DESTROY,
+        run: (api, a) => api.del(`/api/dns/zones/${id(a.zone)}`, { confirm: a.confirm }),
+    },
+    {
+        name: "dns_add_record",
+        description: "Add a record (A, AAAA, CNAME, MX, TXT, SRV, CAA, NS...), or edit one by passing the old value in " +
+            "replace. Scope dns:write.",
+        inputSchema: obj({
+            zone: str("Domain"),
+            name: str("Record name: @ for the apex, or a label like www"),
+            type: str("Record type, e.g. A, CNAME, MX, TXT"),
+            value: str("Record value, e.g. an IP, a host name or the TXT text"),
+            ttl: int("TTL in seconds"),
+            priority: int("MX and SRV priority"),
+            weight: int("SRV weight"),
+            port: int("SRV port"),
+            flags: int("CAA flags (default 0)"),
+            tag: str("CAA tag: issue, issuewild or iodef"),
+            replace: str("Edit: the current value of the record this one replaces"),
+        }, ["zone", "type", "value"]),
+        run: (api, a) => api.post(`/api/dns/zones/${id(a.zone)}/records`, pick(a, ["name", "type", "value", "ttl", "priority", "weight", "port", "flags", "tag", "replace"])),
+    },
+    {
+        name: "dns_delete_record",
+        description: "Delete records by name and type, or just the one with this value. Scope dns:write.",
+        inputSchema: obj({
+            zone: str("Domain"),
+            name: str("Record name (@ for the apex)"),
+            type: str("Record type"),
+            content: str("Only the record with this value (otherwise every record of that name and type)"),
+        }, ["zone", "name", "type"]),
+        annotations: DESTROY,
+        run: (api, a) => api.del(`/api/dns/zones/${id(a.zone)}/records`, { name: a.name, type: a.type, content: a.content }),
+    },
+    {
+        name: "get_billing",
+        description: "Account balance, monthly spend and recent ledger lines. Scope billing:read.",
+        inputSchema: obj({}),
+        annotations: READ,
+        run: (api) => api.get("/api/billing"),
+    },
+];

package/package.json

@@ -1,6 +1,35 @@
-{
-  "name": "tport-cloud-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "tport-cloud-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for tport.cloud: servers, managed databases and free DNS from Claude, Cursor or any MCP client, with a scoped API key",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "tport-cloud-mcp": "build/index.js"
+  },
+  "files": ["build", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.9.0",
+    "vitest": "^3.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["mcp", "model-context-protocol", "tport.cloud", "vps", "postgresql", "mariadb", "qdrant", "dns", "cloud"],
+  "homepage": "https://tport.cloud",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/icedsg/tport-cloud-mcp"
+  },
+  "license": "MIT"
+}