@framers/agentos-ext-cloud-digitalocean 0.1.0 → 0.1.2

package/src/index.ts

@@ -1,130 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview DigitalOcean Cloud Extension for AgentOS.
- *
- * Provides 6 tools for managing App Platform apps, Droplets, DNS records,
- * and deployments via the DigitalOcean REST API v2.
- *
- * @module @framers/agentos-ext-cloud-digitalocean
- */
-
-import { DigitalOceanService } from './DigitalOceanService.js';
-import type { DigitalOceanConfig } from './DigitalOceanService.js';
-import { DOCreateAppTool } from './tools/createApp.js';
-import { DOCreateDropletTool } from './tools/createDroplet.js';
-import { DOListResourcesTool } from './tools/listResources.js';
-import { DODeployAppTool } from './tools/deployApp.js';
-import { DOManageDnsTool } from './tools/manageDns.js';
-import { DODeleteResourceTool } from './tools/deleteResource.js';
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface DigitalOceanCloudOptions {
-  token?: string;
-  secrets?: Record<string, string>;
-}
-
-// ---------------------------------------------------------------------------
-// Secret Resolution
-// ---------------------------------------------------------------------------
-
-function resolveConfig(opts: DigitalOceanCloudOptions, secrets: Record<string, string>): DigitalOceanConfig {
-  return {
-    token:
-      opts.token ?? secrets['digitalocean.token']
-      ?? process.env.DIGITALOCEAN_TOKEN ?? process.env.DO_API_TOKEN ?? '',
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Extension Context
-// ---------------------------------------------------------------------------
-
-export interface ExtensionContext {
-  options?: Record<string, unknown>;
-  secrets?: Record<string, string>;
-  getSecret?: (key: string) => string | undefined;
-  logger?: { info: (msg: string) => void };
-}
-
-export interface ExtensionPack {
-  name: string;
-  version: string;
-  descriptors: Array<{ id: string; kind: string; priority?: number; payload: unknown }>;
-  onActivate?: () => Promise<void>;
-  onDeactivate?: () => Promise<void>;
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createExtensionPack(context: ExtensionContext): ExtensionPack {
-  const opts = (context.options ?? {}) as DigitalOceanCloudOptions;
-  const secrets = opts.secrets ?? context.secrets ?? {};
-  const config = resolveConfig(opts, secrets);
-
-  const service = new DigitalOceanService(config);
-
-  const createAppTool = new DOCreateAppTool(service);
-  const createDropletTool = new DOCreateDropletTool(service);
-  const listResourcesTool = new DOListResourcesTool(service);
-  const deployAppTool = new DODeployAppTool(service);
-  const manageDnsTool = new DOManageDnsTool(service);
-  const deleteResourceTool = new DODeleteResourceTool(service);
-
-  return {
-    name: '@framers/agentos-ext-cloud-digitalocean',
-    version: '0.1.0',
-    descriptors: [
-      { id: 'doCreateApp', kind: 'tool', priority: 40, payload: createAppTool },
-      { id: 'doCreateDroplet', kind: 'tool', priority: 40, payload: createDropletTool },
-      { id: 'doListResources', kind: 'tool', priority: 40, payload: listResourcesTool },
-      { id: 'doDeployApp', kind: 'tool', priority: 40, payload: deployAppTool },
-      { id: 'doManageDns', kind: 'tool', priority: 40, payload: manageDnsTool },
-      { id: 'doDeleteResource', kind: 'tool', priority: 40, payload: deleteResourceTool },
-    ],
-    onActivate: async () => {
-      if (!config.token) {
-        throw new Error(
-          'DigitalOcean: no API token provided. Set DIGITALOCEAN_TOKEN or DO_API_TOKEN environment variable, '
-          + 'or provide it via secrets["digitalocean.token"].',
-        );
-      }
-      await service.initialize();
-    },
-    onDeactivate: async () => {
-      await service.shutdown();
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Public exports
-// ---------------------------------------------------------------------------
-
-export { DigitalOceanService } from './DigitalOceanService.js';
-export type {
-  DigitalOceanConfig,
-  DOApp,
-  DOAppSpec,
-  DOAppServiceSpec,
-  DOAppStaticSiteSpec,
-  DOAppEnvVar,
-  DODeployment,
-  DODroplet,
-  DODomain,
-  DODomainRecord,
-  CreateAppOptions,
-  CreateDropletOptions,
-} from './DigitalOceanService.js';
-export { DOCreateAppTool } from './tools/createApp.js';
-export { DOCreateDropletTool } from './tools/createDroplet.js';
-export { DOListResourcesTool } from './tools/listResources.js';
-export { DODeployAppTool } from './tools/deployApp.js';
-export { DOManageDnsTool } from './tools/manageDns.js';
-export { DODeleteResourceTool } from './tools/deleteResource.js';
-
-export default createExtensionPack;

package/src/tools/createApp.ts

@@ -1,69 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview DOCreateAppTool — create an App Platform app from a Git repository.
- */
-
-import type { DigitalOceanService, DOApp } from '../DigitalOceanService.js';
-
-export interface CreateAppInput {
-  name: string;
-  gitUrl: string;
-  branch?: string;
-  region?: string;
-  buildCommand?: string;
-  runCommand?: string;
-  outputDir?: string;
-  isStatic?: boolean;
-  envVars?: Record<string, string>;
-  instanceSizeSlug?: string;
-}
-
-export class DOCreateAppTool {
-  readonly id = 'doCreateApp';
-  readonly name = 'doCreateApp';
-  readonly displayName = 'Create DO App';
-  readonly description = 'Create a DigitalOcean App Platform app from a Git repository with auto-detected settings. Supports both services (Node.js, Python, Go, etc.) and static sites. Configures build/run commands, environment variables, region, and instance size.';
-  readonly category = 'cloud';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = true;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      name: { type: 'string', description: 'App name (must be lowercase, alphanumeric, and hyphens only)' },
-      gitUrl: { type: 'string', description: 'Git repository clone URL (e.g. "https://github.com/user/repo")' },
-      branch: { type: 'string', description: 'Git branch to deploy from (default: "main")' },
-      region: { type: 'string', description: 'Region slug (e.g. "nyc", "sfo", "ams", "sgp"). Default: "nyc"' },
-      buildCommand: { type: 'string', description: 'Build command override (e.g. "npm run build")' },
-      runCommand: { type: 'string', description: 'Run command for services (e.g. "npm start")' },
-      outputDir: { type: 'string', description: 'Output directory for static sites (e.g. "dist", "build")' },
-      isStatic: { type: 'boolean', description: 'Whether to deploy as a static site (default: false, deploys as service)' },
-      envVars: { type: 'object', description: 'Environment variables as key-value pairs' },
-      instanceSizeSlug: { type: 'string', description: 'Instance size slug (e.g. "basic-xxs", "basic-xs", "professional-xs")' },
-    },
-    required: ['name', 'gitUrl'],
-  };
-
-  constructor(private service: DigitalOceanService) {}
-
-  async execute(args: CreateAppInput): Promise<{ success: boolean; data?: DOApp; error?: string }> {
-    try {
-      const app = await this.service.createApp({
-        name: args.name,
-        gitUrl: args.gitUrl,
-        branch: args.branch,
-        region: args.region,
-        buildCommand: args.buildCommand,
-        runCommand: args.runCommand,
-        outputDir: args.outputDir,
-        isStatic: args.isStatic,
-        envVars: args.envVars,
-        instanceSizeSlug: args.instanceSizeSlug,
-      });
-
-      return { success: true, data: app };
-    } catch (err: any) {
-      return { success: false, error: err.message };
-    }
-  }
-}

package/src/tools/createDroplet.ts

@@ -1,74 +0,0 @@
-// @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

@@ -1,64 +0,0 @@
-// @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

@@ -1,41 +0,0 @@
-// @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

@@ -1,66 +0,0 @@
-// @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

@@ -1,131 +0,0 @@
-// @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 };
-    }
-  }
-}