kiwivm-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fujuntao
+
+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

@@ -0,0 +1,78 @@
+# kiwivm-mcp
+
+MCP server for managing KiwiVM (64clouds/BuyVM) VPS instances via Claude Code.
+
+## Setup
+
+### 1. Environment Variables
+
+```bash
+export KIWIVM_VEID=12345678
+export KIWIVM_API_KEY=your_api_key_here
+```
+
+Get your VEID and API key from the KiwiVM Control Panel → REST API page.
+
+### 2. Install
+
+```bash
+npx kiwivm-mcp
+```
+
+Requires **Node.js >= 24** (native TypeScript support).
+
+### 3. Claude Code Configuration
+
+Add to your Claude Code settings:
+
+```json
+{
+  "mcpServers": {
+    "kiwivm": {
+      "command": "npx",
+      "args": ["kiwivm-mcp"],
+      "env": {
+        "KIWIVM_VEID": "12345678",
+        "KIWIVM_API_KEY": "your_key"
+      }
+    }
+  }
+}
+```
+
+Or with global install:
+
+```bash
+npm install -g kiwivm-mcp
+```
+
+```json
+{
+  "mcpServers": {
+    "kiwivm": {
+      "command": "kiwivm-mcp",
+      "env": {
+        "KIWIVM_VEID": "12345678",
+        "KIWIVM_API_KEY": "your_key"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `kiwivm_power` | Start, stop, restart, or force kill the VPS |
+| `kiwivm_service_info` | Get plan details, IPs, OS, and bandwidth. Set `include_live=true` for live CPU, RAM, disk, uptime (may take 15s) |
+| `kiwivm_snapshot` | Create, list, delete, restore, toggle sticky, export/import snapshots |
+| `kiwivm_backup` | List automatic backups, copy backup to restorable snapshot |
+| `kiwivm_system` | Set hostname, PTR/rDNS, reset root password, manage SSH keys, list/reinstall OS templates |
+| `kiwivm_network` | Add/delete IPv6 /64 subnets, assign/delete/list private IP addresses |
+| `kiwivm_monitoring` | View raw usage stats, audit log, API rate limit status |
+| `kiwivm_admin` | View suspensions/policy violations, unsuspend, resolve violations |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "kiwivm-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for managing KiwiVM VPS instances",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "kiwivm-mcp": "src/index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FuJuntao/kiwivm-mcp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/**/*.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "lint": "biome lint src",
+    "format": "biome format --write src",
+    "check": "biome check src",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.12",
+    "@tsconfig/node-lts": "^24.0.0",
+    "@tsconfig/node-ts": "^23.6.4",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/node": "^24.0.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
+  }
+}

package/src/client.test.ts

@@ -0,0 +1,68 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { KiwiVMClient } from "./client.js";
+import { KiwiVMError } from "./types.js";
+
+global.fetch = vi.fn();
+
+const client = new KiwiVMClient({
+  veid: "12345",
+  apiKey: "test-key",
+});
+
+describe("KiwiVMClient", () => {
+  afterEach(() => vi.resetAllMocks());
+
+  it("sends POST with form-encoded body and returns success", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ error: 0 }),
+    } as Response);
+
+    const result = await client.call("restart");
+    expect(result.error).toBe(0);
+
+    const call = vi.mocked(fetch).mock.calls[0];
+    expect(call?.[0]).toBe("https://api.64clouds.com/v1/restart");
+    expect((call?.[1] as RequestInit).method).toBe("POST");
+    expect((call?.[1] as RequestInit).headers).toEqual({
+      "Content-Type": "application/x-www-form-urlencoded",
+    });
+
+    const body = (call?.[1] as RequestInit).body as URLSearchParams;
+    expect(body.get("veid")).toBe("12345");
+    expect(body.get("api_key")).toBe("test-key");
+  });
+
+  it("passes additional params to request body", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ error: 0 }),
+    } as Response);
+
+    await client.call("snapshot/create", { description: "test" });
+
+    const body = (vi.mocked(fetch).mock.calls[0]?.[1] as RequestInit)
+      .body as URLSearchParams;
+    expect(body.get("description")).toBe("test");
+  });
+
+  it("throws KiwiVMError on API error", async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ error: 1, message: "Invalid VEID" }),
+    } as Response);
+
+    await expect(client.call("restart")).rejects.toThrow(KiwiVMError);
+    await expect(client.call("restart")).rejects.toThrow("Invalid VEID");
+  });
+
+  it("throws on HTTP error", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+    } as Response);
+
+    await expect(client.call("restart")).rejects.toThrow("HTTP 500");
+  });
+});

package/src/client.ts

@@ -0,0 +1,55 @@
+import type { KiwiVMResponse } from "./types.js";
+import { KiwiVMError } from "./types.js";
+
+const API_BASE = "https://api.64clouds.com/v1";
+
+export interface ClientOptions {
+  veid: string;
+  apiKey: string;
+}
+
+export class KiwiVMClient {
+  private veid: string;
+  private apiKey: string;
+
+  constructor(options: ClientOptions) {
+    this.veid = options.veid;
+    this.apiKey = options.apiKey;
+  }
+
+  async call<T extends KiwiVMResponse = KiwiVMResponse>(
+    endpoint: string,
+    params: Record<string, string | number | boolean | undefined> = {},
+  ): Promise<T> {
+    const body = new URLSearchParams();
+    body.set("veid", this.veid);
+    body.set("api_key", this.apiKey);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined) {
+        body.set(key, String(value));
+      }
+    }
+
+    const response = await fetch(`${API_BASE}/${endpoint}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body,
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as T & KiwiVMResponse;
+
+    if (data.error !== 0) {
+      throw new KiwiVMError(
+        data.message ?? `API error: ${data.error}`,
+        data.error,
+        data,
+      );
+    }
+
+    return data as T;
+  }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { KiwiVMClient } from "./client.js";
+import { createAllTools } from "./tools/index.js";
+
+function main() {
+  const veid = process.env["KIWIVM_VEID"];
+  const apiKey = process.env["KIWIVM_API_KEY"];
+
+  if (!veid || !apiKey) {
+    console.error(
+      "Error: KIWIVM_VEID and KIWIVM_API_KEY environment variables are required",
+    );
+    process.exit(1);
+  }
+
+  const client = new KiwiVMClient({ veid, apiKey });
+  const server = new McpServer({ name: "kiwivm-mcp", version: "0.1.0" });
+
+  createAllTools(server, client);
+
+  server.connect(new StdioServerTransport()).catch(console.error);
+}
+
+main();

package/src/tools/admin.ts

@@ -0,0 +1,43 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import { callApi } from "./utils.js";
+
+export function createAdminTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_admin",
+    {
+      description:
+        "Administration: get suspension details, get policy violations, unsuspend VPS, " +
+        "resolve policy violations",
+      inputSchema: {
+        action: z.enum([
+          "getSuspensions",
+          "getPolicyViolations",
+          "unsuspend",
+          "resolvePolicyViolation",
+        ]),
+        record_id: z.string().optional(),
+      },
+    },
+    async ({ action, record_id }) => {
+      switch (action) {
+        case "getSuspensions":
+          return callApi(() => client.call("getSuspensionDetails"));
+        case "getPolicyViolations":
+          return callApi(() => client.call("getPolicyViolations"));
+        case "unsuspend":
+          return callApi(() =>
+            client.call("unsuspend", { recordId: record_id }),
+          );
+        case "resolvePolicyViolation":
+          return callApi(() =>
+            client.call("resolvePolicyViolation", { recordId: record_id }),
+          );
+      }
+    },
+  );
+}

package/src/tools/backups.ts

@@ -0,0 +1,36 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import type { Backup, KiwiVMResponse } from "../types.js";
+import { callApi } from "./utils.js";
+
+interface BackupListResponse extends KiwiVMResponse {
+  backups: Backup[];
+}
+
+export function createBackupTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_backup",
+    {
+      description:
+        "Manage automatic backups: list available backups, or copy a backup to a restorable snapshot",
+      inputSchema: {
+        action: z.enum(["list", "copyToSnapshot"]),
+        backup_token: z.string().optional(),
+      },
+    },
+    async ({ action, backup_token }) => {
+      switch (action) {
+        case "list":
+          return callApi(() => client.call<BackupListResponse>("backup/list"));
+        case "copyToSnapshot":
+          return callApi(() =>
+            client.call("backup/copyToSnapshot", { backupToken: backup_token }),
+          );
+      }
+    },
+  );
+}

package/src/tools/index.ts

@@ -0,0 +1,21 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { KiwiVMClient } from "../client.js";
+import { createAdminTools } from "./admin.js";
+import { createBackupTools } from "./backups.js";
+import { createInfoTools } from "./info.js";
+import { createMonitoringTools } from "./monitoring.js";
+import { createNetworkTools } from "./network.js";
+import { createPowerTools } from "./power.js";
+import { createSnapshotTools } from "./snapshots.js";
+import { createSystemTools } from "./system.js";
+
+export function createAllTools(server: McpServer, client: KiwiVMClient): void {
+  createPowerTools(server, client);
+  createInfoTools(server, client);
+  createSnapshotTools(server, client);
+  createBackupTools(server, client);
+  createSystemTools(server, client);
+  createNetworkTools(server, client);
+  createMonitoringTools(server, client);
+  createAdminTools(server, client);
+}

package/src/tools/info.ts

@@ -0,0 +1,28 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import type { LiveServiceInfo, ServiceInfo } from "../types.js";
+import { callApi } from "./utils.js";
+
+export function createInfoTools(server: McpServer, client: KiwiVMClient): void {
+  server.registerTool(
+    "kiwivm_service_info",
+    {
+      description:
+        "Get VPS service information including plan details, IP addresses, OS, and bandwidth usage. " +
+        "Set include_live=true for real-time status (CPU, RAM, disk, uptime, screenshot). " +
+        "Note: include_live may take up to 15 seconds to complete.",
+      inputSchema: {
+        include_live: z.boolean().optional(),
+      },
+    },
+    async ({ include_live }) => {
+      if (include_live) {
+        return callApi(() =>
+          client.call<LiveServiceInfo>("getLiveServiceInfo"),
+        );
+      }
+      return callApi(() => client.call<ServiceInfo>("getServiceInfo"));
+    },
+  );
+}

package/src/tools/monitoring.ts

@@ -0,0 +1,30 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import { callApi } from "./utils.js";
+
+export function createMonitoringTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_monitoring",
+    {
+      description:
+        "Monitoring and statistics: view raw usage stats, audit log, and API rate limit status",
+      inputSchema: {
+        action: z.enum(["usageStats", "auditLog", "rateLimit"]),
+      },
+    },
+    async ({ action }) => {
+      switch (action) {
+        case "usageStats":
+          return callApi(() => client.call("getRawUsageStats"));
+        case "auditLog":
+          return callApi(() => client.call("getAuditLog"));
+        case "rateLimit":
+          return callApi(() => client.call("getRateLimitStatus"));
+      }
+    },
+  );
+}

package/src/tools/network.ts

@@ -0,0 +1,42 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import { callApi } from "./utils.js";
+
+export function createNetworkTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_network",
+    {
+      description:
+        "Network management: add/delete IPv6 /64 subnets, assign/delete private IP addresses, " +
+        "list available private IPs",
+      inputSchema: {
+        action: z.enum([
+          "addIPv6",
+          "deleteIPv6",
+          "listPrivateIps",
+          "assignPrivateIp",
+          "deletePrivateIp",
+        ]),
+        ip: z.string().optional(),
+      },
+    },
+    async ({ action, ip }) => {
+      switch (action) {
+        case "addIPv6":
+          return callApi(() => client.call("ipv6/add"));
+        case "deleteIPv6":
+          return callApi(() => client.call("ipv6/delete", { ip }));
+        case "listPrivateIps":
+          return callApi(() => client.call("privateIp/getAvailableIps"));
+        case "assignPrivateIp":
+          return callApi(() => client.call("privateIp/assign", { ip }));
+        case "deletePrivateIp":
+          return callApi(() => client.call("privateIp/delete", { ip }));
+      }
+    },
+  );
+}

package/src/tools/power.ts

@@ -0,0 +1,21 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import { callApi } from "./utils.js";
+
+export function createPowerTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_power",
+    {
+      description:
+        "Control VPS power state (start, stop, restart, or force kill)",
+      inputSchema: {
+        action: z.enum(["start", "stop", "restart", "kill"]),
+      },
+    },
+    async ({ action }) => callApi(() => client.call(action)),
+  );
+}

package/src/tools/snapshots.ts

@@ -0,0 +1,76 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import type { KiwiVMResponse, Snapshot } from "../types.js";
+import { callApi } from "./utils.js";
+
+export function createSnapshotTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_snapshot",
+    {
+      description:
+        "Manage VPS snapshots: create, list, delete, restore, toggle sticky, export, import",
+      inputSchema: {
+        action: z.enum([
+          "create",
+          "list",
+          "delete",
+          "restore",
+          "toggleSticky",
+          "export",
+          "import",
+        ]),
+        description: z.string().optional(),
+        snapshot: z.string().optional(),
+        sticky: z.number().int().min(0).max(1).optional(),
+        source_veid: z.string().optional(),
+        source_token: z.string().optional(),
+      },
+    },
+    async (args) => {
+      switch (args.action) {
+        case "create":
+          return callApi(() =>
+            client.call("snapshot/create", {
+              description: args.description,
+            }),
+          );
+        case "list":
+          return callApi(() =>
+            client.call<KiwiVMResponse & { snapshots: Snapshot[] }>(
+              "snapshot/list",
+            ),
+          );
+        case "delete":
+          return callApi(() =>
+            client.call("snapshot/delete", { snapshot: args.snapshot }),
+          );
+        case "restore":
+          return callApi(() =>
+            client.call("snapshot/restore", { snapshot: args.snapshot }),
+          );
+        case "toggleSticky":
+          return callApi(() =>
+            client.call("snapshot/toggleSticky", {
+              snapshot: args.snapshot,
+              sticky: args.sticky,
+            }),
+          );
+        case "export":
+          return callApi(() =>
+            client.call("snapshot/export", { snapshot: args.snapshot }),
+          );
+        case "import":
+          return callApi(() =>
+            client.call("snapshot/import", {
+              sourceVeid: args.source_veid,
+              sourceToken: args.source_token,
+            }),
+          );
+      }
+    },
+  );
+}

package/src/tools/system.ts

@@ -0,0 +1,58 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { KiwiVMClient } from "../client.js";
+import { callApi } from "./utils.js";
+
+export function createSystemTools(
+  server: McpServer,
+  client: KiwiVMClient,
+): void {
+  server.registerTool(
+    "kiwivm_system",
+    {
+      description:
+        "System management: set hostname, set PTR/rDNS, reset root password, manage SSH keys, " +
+        "get available OS templates, reinstall OS",
+      inputSchema: {
+        action: z.enum([
+          "setHostname",
+          "setPTR",
+          "resetRootPassword",
+          "getSSHKeys",
+          "updateSSHKeys",
+          "getAvailableOS",
+          "reinstallOS",
+        ]),
+        new_hostname: z.string().optional(),
+        ip: z.string().optional(),
+        ptr: z.string().optional(),
+        ssh_keys: z.string().optional(),
+        os: z.string().optional(),
+      },
+    },
+    async (args) => {
+      switch (args.action) {
+        case "setHostname":
+          return callApi(() =>
+            client.call("setHostname", { newHostname: args.new_hostname }),
+          );
+        case "setPTR":
+          return callApi(() =>
+            client.call("setPTR", { ip: args.ip, ptr: args.ptr }),
+          );
+        case "resetRootPassword":
+          return callApi(() => client.call("resetRootPassword"));
+        case "getSSHKeys":
+          return callApi(() => client.call("getSshKeys"));
+        case "updateSSHKeys":
+          return callApi(() =>
+            client.call("updateSshKeys", { sshKeys: args.ssh_keys }),
+          );
+        case "getAvailableOS":
+          return callApi(() => client.call("getAvailableOS"));
+        case "reinstallOS":
+          return callApi(() => client.call("reinstallOS", { os: args.os }));
+      }
+    },
+  );
+}

package/src/tools/utils.ts

@@ -0,0 +1,23 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { KiwiVMError } from "../types.js";
+
+/**
+ * Wraps an API call, formatting the result or error as a CallToolResult.
+ */
+export async function callApi<T>(
+  fn: () => Promise<T>,
+): Promise<CallToolResult> {
+  try {
+    const result = await fn();
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  } catch (error) {
+    const message =
+      error instanceof KiwiVMError ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true,
+    };
+  }
+}

package/src/types.ts

@@ -0,0 +1,94 @@
+export interface KiwiVMResponse {
+  error: number;
+  message?: string;
+}
+
+export class KiwiVMError extends Error {
+  public readonly errorCode: number;
+  public readonly rawResponse: KiwiVMResponse;
+
+  constructor(message: string, errorCode: number, rawResponse: KiwiVMResponse) {
+    super(message);
+    this.name = "KiwiVMError";
+    this.errorCode = errorCode;
+    this.rawResponse = rawResponse;
+  }
+}
+
+export interface ServiceInfo extends KiwiVMResponse {
+  hostname?: string;
+  node_alias?: string;
+  node_location?: string;
+  location_ipv6_ready?: number;
+  plan?: string;
+  plan_monthly_data?: number;
+  plan_disk?: number;
+  plan_ram?: number;
+  plan_swap?: number;
+  os?: string;
+  email?: string;
+  data_counter?: number;
+  data_next_reset?: number;
+  ip_addresses?: string[];
+  private_ip_addresses?: string[];
+  ip_nullroutes?: Record<
+    string,
+    {
+      nullroute_timestamp: number;
+      nullroute_duration_s: number;
+      log: string;
+    }
+  >;
+  iso1?: string;
+  iso2?: string;
+  available_isos?: string[];
+  plan_max_ipv6s?: number;
+  rdns_api_available?: number;
+  plan_private_network_available?: number;
+  location_private_network_available?: number;
+  ptr?: Record<string, string>;
+  suspended?: number;
+  policy_violation?: number;
+  suspension_count?: number;
+  total_abuse_points?: number;
+  max_abuse_points?: number;
+}
+
+export interface LiveServiceInfo extends ServiceInfo {
+  vm_type?: "ovz" | "kvm";
+  vz_status?: Record<string, unknown>;
+  vz_quota?: Record<string, unknown>;
+  ve_status?: "Starting" | "Running" | "Stopped";
+  ve_mac1?: string;
+  ve_used_disk_space_b?: number;
+  ve_disk_quota_gb?: number;
+  is_cpu_throttled?: number;
+  is_disk_throttled?: number;
+  ssh_port?: number;
+  live_hostname?: string;
+  load_average?: string;
+  mem_available_kb?: number;
+  swap_total_kb?: number;
+  swap_available_kb?: number;
+  screendump_png_base64?: string;
+}
+
+export interface Snapshot {
+  fileName: string;
+  os: string;
+  description: string;
+  size: number;
+  md5: string;
+  sticky: number;
+  purgesIn: number;
+  downloadLink: string;
+  downloadLinkSSL: string;
+}
+
+export interface Backup {
+  backupToken: string;
+  size: number;
+  os: string;
+  md5: string;
+  timestamp: number;
+}