@framers/agentos-ext-cloud-digitalocean 0.1.0

package/src/tools/createDroplet.ts

@@ -0,0 +1,74 @@
+// @ts-nocheck
+/**
+ * @fileoverview DOCreateDropletTool — create a VPS Droplet with specified region, size, and image.
+ */
+
+import type { DigitalOceanService, DODroplet } from '../DigitalOceanService.js';
+
+export interface CreateDropletInput {
+  name: string;
+  region: string;
+  size: string;
+  image: string;
+  sshKeys?: (string | number)[];
+  userData?: string;
+  backups?: boolean;
+  ipv6?: boolean;
+  tags?: string[];
+}
+
+export class DOCreateDropletTool {
+  readonly id = 'doCreateDroplet';
+  readonly name = 'doCreateDroplet';
+  readonly displayName = 'Create DO Droplet';
+  readonly description = 'Create a DigitalOcean Droplet (VPS instance) with a specified region, size, and OS image. Supports SSH key injection, cloud-init user data scripts, backups, IPv6, and tagging.';
+  readonly category = 'cloud';
+  readonly version = '0.1.0';
+  readonly hasSideEffects = true;
+
+  readonly inputSchema = {
+    type: 'object' as const,
+    properties: {
+      name: { type: 'string', description: 'Droplet hostname (e.g. "my-server-01")' },
+      region: { type: 'string', description: 'Region slug (e.g. "nyc1", "sfo3", "ams3", "sgp1", "lon1")' },
+      size: { type: 'string', description: 'Size slug (e.g. "s-1vcpu-1gb", "s-2vcpu-4gb", "s-4vcpu-8gb")' },
+      image: { type: 'string', description: 'Image slug or ID (e.g. "ubuntu-24-04-x64", "debian-12-x64", "docker-20-04")' },
+      sshKeys: {
+        type: 'array',
+        items: { type: ['string', 'number'] },
+        description: 'SSH key IDs or fingerprints to embed in the Droplet',
+      },
+      userData: { type: 'string', description: 'Cloud-init user data script for automated setup' },
+      backups: { type: 'boolean', description: 'Enable weekly backups (default: false)' },
+      ipv6: { type: 'boolean', description: 'Enable IPv6 networking (default: false)' },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags to apply to the Droplet for organization and filtering',
+      },
+    },
+    required: ['name', 'region', 'size', 'image'],
+  };
+
+  constructor(private service: DigitalOceanService) {}
+
+  async execute(args: CreateDropletInput): Promise<{ success: boolean; data?: DODroplet; error?: string }> {
+    try {
+      const droplet = await this.service.createDroplet({
+        name: args.name,
+        region: args.region,
+        size: args.size,
+        image: args.image,
+        sshKeys: args.sshKeys,
+        userData: args.userData,
+        backups: args.backups,
+        ipv6: args.ipv6,
+        tags: args.tags,
+      });
+
+      return { success: true, data: droplet };
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+}

package/src/tools/deleteResource.ts

@@ -0,0 +1,64 @@
+// @ts-nocheck
+/**
+ * @fileoverview DODeleteResourceTool — delete an app or droplet from DigitalOcean.
+ */
+
+import type { DigitalOceanService } from '../DigitalOceanService.js';
+
+export interface DeleteResourceInput {
+  resourceType: 'app' | 'droplet';
+  resourceId: string;
+}
+
+export class DODeleteResourceTool {
+  readonly id = 'doDeleteResource';
+  readonly name = 'doDeleteResource';
+  readonly displayName = 'Delete DO Resource';
+  readonly description = 'Permanently delete a DigitalOcean App Platform app or Droplet. This action is irreversible — the resource and all associated data will be destroyed.';
+  readonly category = 'cloud';
+  readonly version = '0.1.0';
+  readonly hasSideEffects = true;
+
+  readonly inputSchema = {
+    type: 'object' as const,
+    properties: {
+      resourceType: {
+        type: 'string',
+        enum: ['app', 'droplet'],
+        description: 'Type of resource to delete',
+      },
+      resourceId: {
+        type: 'string',
+        description: 'Resource ID to delete (app UUID or droplet numeric ID)',
+      },
+    },
+    required: ['resourceType', 'resourceId'],
+  };
+
+  constructor(private service: DigitalOceanService) {}
+
+  async execute(args: DeleteResourceInput): Promise<{ success: boolean; data?: { message: string }; error?: string }> {
+    try {
+      switch (args.resourceType) {
+        case 'app': {
+          await this.service.deleteApp(args.resourceId);
+          return { success: true, data: { message: `App ${args.resourceId} has been deleted.` } };
+        }
+
+        case 'droplet': {
+          const dropletId = parseInt(args.resourceId, 10);
+          if (isNaN(dropletId)) {
+            return { success: false, error: `Invalid droplet ID: "${args.resourceId}". Must be a numeric ID.` };
+          }
+          await this.service.deleteDroplet(dropletId);
+          return { success: true, data: { message: `Droplet ${dropletId} has been deleted.` } };
+        }
+
+        default:
+          return { success: false, error: `Unknown resource type: ${args.resourceType}. Use "app" or "droplet".` };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+}

package/src/tools/deployApp.ts

@@ -0,0 +1,41 @@
+// @ts-nocheck
+/**
+ * @fileoverview DODeployAppTool — trigger a new deployment on an existing App Platform app.
+ */
+
+import type { DigitalOceanService, DODeployment } from '../DigitalOceanService.js';
+
+export interface DeployAppInput {
+  appId: string;
+  forceBuild?: boolean;
+}
+
+export class DODeployAppTool {
+  readonly id = 'doDeployApp';
+  readonly name = 'doDeployApp';
+  readonly displayName = 'Deploy DO App';
+  readonly description = 'Trigger a new deployment on an existing DigitalOcean App Platform app. Pulls the latest code from the configured Git repository and builds/deploys it. Optionally force a full rebuild.';
+  readonly category = 'cloud';
+  readonly version = '0.1.0';
+  readonly hasSideEffects = true;
+
+  readonly inputSchema = {
+    type: 'object' as const,
+    properties: {
+      appId: { type: 'string', description: 'App ID to deploy (use doListResources to find app IDs)' },
+      forceBuild: { type: 'boolean', description: 'Force a complete rebuild instead of incremental (default: false)' },
+    },
+    required: ['appId'],
+  };
+
+  constructor(private service: DigitalOceanService) {}
+
+  async execute(args: DeployAppInput): Promise<{ success: boolean; data?: DODeployment; error?: string }> {
+    try {
+      const deployment = await this.service.createDeployment(args.appId, args.forceBuild);
+      return { success: true, data: deployment };
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+}

package/src/tools/listResources.ts

@@ -0,0 +1,66 @@
+// @ts-nocheck
+/**
+ * @fileoverview DOListResourcesTool — list all apps and/or droplets on a DigitalOcean account.
+ */
+
+import type { DigitalOceanService, DOApp, DODroplet } from '../DigitalOceanService.js';
+
+export interface ListResourcesInput {
+  resourceType?: 'apps' | 'droplets' | 'all';
+  page?: number;
+  perPage?: number;
+  tag?: string;
+}
+
+export interface ListResourcesResult {
+  apps?: DOApp[];
+  droplets?: DODroplet[];
+}
+
+export class DOListResourcesTool {
+  readonly id = 'doListResources';
+  readonly name = 'doListResources';
+  readonly displayName = 'List DO Resources';
+  readonly description = 'List all DigitalOcean App Platform apps and/or Droplets. Filter by resource type (apps, droplets, or both) and optionally by tag. Returns names, statuses, regions, IPs, and deployment info.';
+  readonly category = 'cloud';
+  readonly version = '0.1.0';
+  readonly hasSideEffects = false;
+
+  readonly inputSchema = {
+    type: 'object' as const,
+    properties: {
+      resourceType: {
+        type: 'string',
+        enum: ['apps', 'droplets', 'all'],
+        description: 'Which resource type to list (default: "all")',
+      },
+      page: { type: 'number', description: 'Page number for pagination (default: 1)' },
+      perPage: { type: 'number', description: 'Items per page (default: 20, max: 200)' },
+      tag: { type: 'string', description: 'Filter droplets by tag name' },
+    },
+    required: [] as string[],
+  };
+
+  constructor(private service: DigitalOceanService) {}
+
+  async execute(args: ListResourcesInput): Promise<{ success: boolean; data?: ListResourcesResult; error?: string }> {
+    try {
+      const resourceType = args.resourceType ?? 'all';
+      const page = args.page ?? 1;
+      const perPage = args.perPage ?? 20;
+      const result: ListResourcesResult = {};
+
+      if (resourceType === 'apps' || resourceType === 'all') {
+        result.apps = await this.service.listApps(page, perPage);
+      }
+
+      if (resourceType === 'droplets' || resourceType === 'all') {
+        result.droplets = await this.service.listDroplets(page, perPage, args.tag);
+      }
+
+      return { success: true, data: result };
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+}

package/src/tools/manageDns.ts

@@ -0,0 +1,131 @@
+// @ts-nocheck
+/**
+ * @fileoverview DOManageDnsTool — manage DNS records on a DigitalOcean domain.
+ */
+
+import type { DigitalOceanService, DODomain, DODomainRecord } from '../DigitalOceanService.js';
+
+export interface ManageDnsInput {
+  action: 'list-domains' | 'add-domain' | 'list' | 'add' | 'update' | 'delete';
+  domain?: string;
+  recordId?: number;
+  recordType?: string;
+  name?: string;
+  data?: string;
+  ttl?: number;
+  priority?: number;
+  port?: number;
+  weight?: number;
+}
+
+export class DOManageDnsTool {
+  readonly id = 'doManageDns';
+  readonly name = 'doManageDns';
+  readonly displayName = 'Manage DO DNS';
+  readonly description = 'Manage DNS records on a DigitalOcean domain. Supports listing domains, adding domains, and full CRUD on DNS records (A, AAAA, CNAME, MX, TXT, SRV, NS, CAA). Use action "list-domains" to see all domains, "add-domain" to register a new domain, "list" to view records, "add"/"update"/"delete" to manage records.';
+  readonly category = 'cloud';
+  readonly version = '0.1.0';
+  readonly hasSideEffects = true;
+
+  readonly inputSchema = {
+    type: 'object' as const,
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['list-domains', 'add-domain', 'list', 'add', 'update', 'delete'],
+        description: 'Action to perform on DNS',
+      },
+      domain: { type: 'string', description: 'Domain name (e.g. "example.com"). Required for all actions except "list-domains".' },
+      recordId: { type: 'number', description: 'Record ID (required for "update" and "delete" actions)' },
+      recordType: { type: 'string', description: 'DNS record type (e.g. "A", "AAAA", "CNAME", "MX", "TXT", "SRV", "NS", "CAA")' },
+      name: { type: 'string', description: 'Record name/hostname (e.g. "@", "www", "mail")' },
+      data: { type: 'string', description: 'Record data/value (e.g. IP address, CNAME target, MX server)' },
+      ttl: { type: 'number', description: 'Time-to-live in seconds (default: 1800)' },
+      priority: { type: 'number', description: 'Priority (for MX and SRV records)' },
+      port: { type: 'number', description: 'Port (for SRV records)' },
+      weight: { type: 'number', description: 'Weight (for SRV records)' },
+    },
+    required: ['action'],
+  };
+
+  constructor(private service: DigitalOceanService) {}
+
+  async execute(args: ManageDnsInput): Promise<{
+    success: boolean;
+    data?: DODomain | DODomain[] | DODomainRecord | DODomainRecord[] | { message: string };
+    error?: string;
+  }> {
+    try {
+      switch (args.action) {
+        case 'list-domains': {
+          const domains = await this.service.listDomains();
+          return { success: true, data: domains };
+        }
+
+        case 'add-domain': {
+          if (!args.domain) {
+            return { success: false, error: 'Domain name is required for "add-domain" action.' };
+          }
+          const domain = await this.service.addDomain(args.domain);
+          return { success: true, data: domain };
+        }
+
+        case 'list': {
+          if (!args.domain) {
+            return { success: false, error: 'Domain name is required for "list" action.' };
+          }
+          const records = await this.service.listDomainRecords(args.domain);
+          return { success: true, data: records };
+        }
+
+        case 'add': {
+          if (!args.domain) {
+            return { success: false, error: 'Domain name is required for "add" action.' };
+          }
+          if (!args.recordType || !args.name || !args.data) {
+            return { success: false, error: 'recordType, name, and data are required for "add" action.' };
+          }
+          const record = await this.service.createDomainRecord(args.domain, {
+            type: args.recordType,
+            name: args.name,
+            data: args.data,
+            ttl: args.ttl,
+            priority: args.priority,
+            port: args.port,
+            weight: args.weight,
+          });
+          return { success: true, data: record };
+        }
+
+        case 'update': {
+          if (!args.domain || args.recordId == null) {
+            return { success: false, error: 'Domain name and recordId are required for "update" action.' };
+          }
+          const updated = await this.service.updateDomainRecord(args.domain, args.recordId, {
+            type: args.recordType,
+            name: args.name,
+            data: args.data,
+            ttl: args.ttl,
+            priority: args.priority,
+            port: args.port,
+            weight: args.weight,
+          });
+          return { success: true, data: updated };
+        }
+
+        case 'delete': {
+          if (!args.domain || args.recordId == null) {
+            return { success: false, error: 'Domain name and recordId are required for "delete" action.' };
+          }
+          await this.service.deleteDomainRecord(args.domain, args.recordId);
+          return { success: true, data: { message: `Record ${args.recordId} deleted from ${args.domain}.` } };
+        }
+
+        default:
+          return { success: false, error: `Unknown action: ${args.action}` };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+}