@absolutejs/deploy 0.1.0 → 0.3.0

package/README.md

@@ -110,7 +110,85 @@ Default is `null` (no verify). Recommend always wiring one — a green deploy th
 - `listReleases()` returns the sorted list.
 - `prune({ keep: N })` removes the N oldest.
 
-## DigitalOcean Droplet — first deploy
+## `@absolutejs/deploy/digitalocean` — provision-or-reuse from code (0.2.0)
+
+Skip the click-through DO dashboard. `digitalOceanTarget(options)` looks
+up a droplet by name; creates it via the v2 API if absent; waits for
+`status === 'active'` + IPv4; waits for SSH; returns a `Target` ready to
+hand to `createDeployer`.
+
+```ts
+import { createDeployer } from '@absolutejs/deploy';
+import { digitalOceanTarget } from '@absolutejs/deploy/digitalocean';
+
+const target = await digitalOceanTarget({
+  token: process.env.DO_TOKEN!,
+  name: 'absolutejs-prod-1',          // idempotency key
+  region: 'nyc3',
+  size: 's-1vcpu-1gb',
+  image: 'ubuntu-22-04-x64',
+  sshKeys: [process.env.DO_KEY_FINGERPRINT!],
+  tags: ['absolutejs'],
+  userData: '#!/bin/bash\ncurl -fsSL https://bun.sh/install | bash',
+  onLog: (line) => console.log(line),
+});
+
+console.log(`droplet ${target.dropletId} at ${target.ipv4}`);
+
+const deployer = createDeployer({ appName: 'my-app', target });
+await deployer.deploy({ source: { kind: 'directory', path: './build' } });
+
+// Tear it down when you're done:
+await target.destroy();
+```
+
+Idempotent by `name` — calling twice returns the same droplet, no
+duplicates created. Pair with `cloud-init` user data to install Bun /
+configure the deploy user / set up firewall rules on first boot, then
+the deploy pipeline runs against an SSH-ready box.
+
+Admin helpers: `listDigitalOceanDroplets({ token, tag? })` for
+inventory; `destroyDigitalOceanDroplet({ token, id })` for cleanup
+(404 is treated as idempotent success). Narrow `DigitalOceanClientLike`
+interface so you can BYO `request(method, path, body?)` for retry /
+observability — the bundled `createDigitalOceanClient(token)` is just
+a sensible default.
+
+## `@absolutejs/deploy/hetzner` — provision-or-reuse from code (0.3.0)
+
+Same shape as the DigitalOcean adapter, Hetzner Cloud v1 API
+mappings underneath. Hetzner-specific differences: locations
+(`nbg1` / `fsn1` / `hel1` / `ash` / `hil`), server types
+(`cx22` / `cpx11` / `ccx13` / …), labels (key-value, not array),
+and public-net IPv4/IPv6 are independently toggleable.
+
+```ts
+import { createDeployer } from '@absolutejs/deploy';
+import { hetznerTarget } from '@absolutejs/deploy/hetzner';
+
+const target = await hetznerTarget({
+  token: process.env.HETZNER_TOKEN!,
+  name: 'absolutejs-prod-1',
+  location: 'nbg1',
+  serverType: 'cx22',
+  image: 'ubuntu-22.04',
+  sshKeys: [process.env.HETZNER_KEY_FINGERPRINT!],
+  labels: { env: 'prod', team: 'platform' },
+  userData: '#!/bin/bash\ncurl -fsSL https://bun.sh/install | bash',
+});
+
+const deployer = createDeployer({ appName: 'my-app', target });
+await deployer.deploy({ source: { kind: 'directory', path: './build' } });
+await target.destroy();
+```
+
+Hetzner enforces unique server names per project, so the
+idempotency contract is structural — `name` collisions never
+happen. Admin helpers: `listHetznerServers({ token, labelSelector?
+})` (Hetzner's `'env=prod'` / `'env in (prod,staging)'` syntax);
+`destroyHetznerServer({ token, id })` (404 idempotent success).
+
+## DigitalOcean Droplet — first deploy (manual)
 
 Assuming a fresh Ubuntu/Debian Droplet:
 
@@ -129,9 +207,9 @@ bun run my-deploy-script.ts
 
 The first run creates `/srv/<appName>/releases/<id>/`, drops a systemd unit at `/etc/systemd/system/<appName>.service` (if you're using `systemdManager`), starts the service, and probes. Subsequent runs just add a new release dir and swap the symlink.
 
-## What v0.0.1 does NOT include
+## What v0.3.0 does NOT include
 
-- Provider-specific HTTP-API adapters (Cloudflare Workers, Fly Machines, AWS Fargate, GCP Cloud Run).
+- Provider-specific HTTP-API adapters beyond DigitalOcean + Hetzner (Cloudflare Workers, Fly Machines, AWS Fargate, GCP Cloud Run). Linode / Vultr follow the same shape and are next on the list.
 - Bun installation on the remote — caller does it once, out of band.
 - Multi-target / fan-out deploys (caller iterates).
 - Zero-downtime port-swap (start new release on a fresh port, then nginx-reload). The default pipeline does stop-then-start; for true zero-downtime, replace the `restart` step.

package/dist/digitalocean.d.ts

@@ -0,0 +1,146 @@
+/**
+ * @absolutejs/deploy/digitalocean — provision-or-reuse Target adapter
+ * for DigitalOcean droplets.
+ *
+ * What it does:
+ *
+ *   1. Looks up a droplet by `name`. If present and active, reuses it.
+ *   2. If not present, creates it via the DO v2 API and waits for
+ *      `status === 'active'` with a public IPv4 assigned.
+ *   3. Waits for SSH readiness (TCP connect on port 22 with backoff,
+ *      or a caller-supplied probe).
+ *   4. Returns a Target that wraps sshTarget against the droplet's
+ *      public IPv4, plus `dropletId`, `ipv4`, and a `destroy()` helper.
+ *
+ * Idempotent by name — calling twice with the same name returns the
+ * same droplet, no duplicates created. If multiple droplets share
+ * the name, throws (the caller has drifted state to clean up).
+ *
+ * Narrow DigitalOceanClientLike interface keeps the dots-on-the-i
+ * SDK out as a hard dep. Default client uses `fetch` against
+ * `api.digitalocean.com`; pass your own for retry / observability.
+ */
+import type { Target } from './targets';
+/**
+ * Minimal subset of DO API calls we make. Lets callers BYO a client
+ * with retry / observability / etc. (e.g. wrap got, undici, or a
+ * tenant-scoped client that injects different tokens per call).
+ */
+export type DigitalOceanClientLike = {
+    request: <T = unknown>(method: 'GET' | 'POST' | 'DELETE', path: string, body?: unknown) => Promise<T>;
+};
+/** A DigitalOcean droplet record, narrowed to what we inspect. */
+export type DigitalOceanDroplet = {
+    id: number;
+    name: string;
+    status: 'new' | 'active' | 'off' | 'archive';
+    region?: {
+        slug: string;
+    };
+    size_slug?: string;
+    networks: {
+        v4: Array<{
+            ip_address: string;
+            type: 'public' | 'private';
+        }>;
+        v6?: Array<{
+            ip_address: string;
+            type: 'public' | 'private';
+        }>;
+    };
+    tags?: string[];
+};
+export type DigitalOceanTargetOptions = {
+    /** API token (https://cloud.digitalocean.com/account/api/tokens). Required unless `client` is set. */
+    token?: string;
+    /** Custom client. Overrides token-built default. */
+    client?: DigitalOceanClientLike;
+    /** Droplet name. Also the idempotency key. */
+    name: string;
+    /** Region slug — `'nyc3'`, `'sfo3'`, `'ams3'`, etc. */
+    region: string;
+    /** Size slug — `'s-1vcpu-1gb'`, `'s-2vcpu-4gb'`, etc. */
+    size: string;
+    /** Image slug, snapshot id, or backup id. e.g. `'ubuntu-22-04-x64'`. */
+    image: string | number;
+    /** SSH key fingerprints OR numeric ids. At least one required to ssh in. */
+    sshKeys: ReadonlyArray<string | number>;
+    /** Tags applied at creation. Useful for `listDroplets({ tag })`. */
+    tags?: ReadonlyArray<string>;
+    /** cloud-init user data — a shell script or YAML config. */
+    userData?: string;
+    /** VPC UUID. Defaults to the account's default VPC for the region. */
+    vpcUuid?: string;
+    /** Enable IPv6. Default false. */
+    ipv6?: boolean;
+    /** Enable monitoring agent. Default false. */
+    monitoring?: boolean;
+    /** SSH login user. Default `'root'`. */
+    user?: string;
+    /** Path to SSH identity file forwarded to sshTarget. */
+    identity?: string;
+    /** SSH port. Default 22. */
+    port?: number;
+    /** Max time to wait for droplet `active` + IPv4. Default 5 min. */
+    provisionTimeoutMs?: number;
+    /** Max time to wait for SSH probe to succeed. Default 2 min. */
+    sshReadinessTimeoutMs?: number;
+    /** Poll interval for provision + ssh probe. Default 5 s. */
+    pollIntervalMs?: number;
+    /** Called with status updates (one line each). Default: noop. */
+    onLog?: (line: string) => void;
+    /**
+     * Override the SSH readiness probe. Default opens a TCP socket to
+     * `host:port`. Tests pass a fake probe to skip real network IO.
+     */
+    probeSsh?: (host: string, port: number) => Promise<boolean>;
+    /**
+     * Sleep used between polls. Default `setTimeout`-based. Tests can
+     * pass a synchronous resolver to skip real waits.
+     */
+    sleep?: (ms: number) => Promise<void>;
+    /** Wall clock. Defaults to `Date.now`. Tests can swap. */
+    now?: () => number;
+};
+export type DigitalOceanTarget = Target & {
+    readonly dropletId: number;
+    readonly ipv4: string;
+    /** Destroy the droplet via the DO API. */
+    destroy: () => Promise<void>;
+};
+export declare class DigitalOceanError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+/**
+ * fetch-backed default client. Talks JSON to `api.digitalocean.com/v2`.
+ * Throws DigitalOceanError on non-2xx with the response body attached
+ * so the caller can switch on `err.status`.
+ */
+export declare const createDigitalOceanClient: (token: string, options?: {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}) => DigitalOceanClientLike;
+/**
+ * Find a droplet by name. Returns undefined if absent.
+ * Throws if more than one droplet shares the name (drifted state).
+ */
+export declare const findDigitalOceanDroplet: (client: DigitalOceanClientLike, name: string) => Promise<DigitalOceanDroplet | undefined>;
+/** List droplets, optionally filtered by tag. Useful for cleanup tasks. */
+export declare const listDigitalOceanDroplets: (options: {
+    token?: string;
+    client?: DigitalOceanClientLike;
+    tag?: string;
+}) => Promise<DigitalOceanDroplet[]>;
+/** Destroy a droplet by id. No-op if already gone. */
+export declare const destroyDigitalOceanDroplet: (options: {
+    token?: string;
+    client?: DigitalOceanClientLike;
+    id: number;
+}) => Promise<void>;
+/**
+ * Provision-or-reuse a DO droplet by name, wait for SSH, return a
+ * Target. Idempotent: same name → same droplet.
+ */
+export declare const digitalOceanTarget: (options: DigitalOceanTargetOptions) => Promise<DigitalOceanTarget>;

package/dist/digitalocean.js

@@ -0,0 +1,369 @@
+// @bun
+// src/targets.ts
+import { mkdir } from "fs/promises";
+import { join } from "path";
+var decodeChunks = async (reader, onLine) => {
+  if (!reader)
+    return "";
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let collected = "";
+  const stream = reader.getReader();
+  try {
+    while (true) {
+      const { done, value } = await stream.read();
+      if (done)
+        break;
+      const chunk = decoder.decode(value, { stream: true });
+      collected += chunk;
+      if (!onLine)
+        continue;
+      buffer += chunk;
+      let newline = buffer.indexOf(`
+`);
+      while (newline !== -1) {
+        const line = buffer.slice(0, newline).replace(/\r$/, "");
+        if (line.length > 0)
+          onLine(line);
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf(`
+`);
+      }
+    }
+    const tail = decoder.decode();
+    collected += tail;
+    if (onLine && (buffer + tail).length > 0)
+      onLine((buffer + tail).replace(/\r$/, ""));
+  } finally {
+    stream.releaseLock();
+  }
+  return collected;
+};
+var runSpawn = async (argv, options) => {
+  const proc = Bun.spawn(argv, {
+    cwd: options.cwd,
+    env: options.env,
+    stderr: "pipe",
+    stdin: options.stdin === undefined ? "ignore" : "pipe",
+    stdout: "pipe"
+  });
+  if (options.stdin !== undefined && proc.stdin) {
+    const sink = proc.stdin;
+    const wrote = sink.write(options.stdin);
+    if (wrote && typeof wrote.then === "function") {
+      await wrote;
+    }
+    const ended = sink.end();
+    if (ended && typeof ended.then === "function") {
+      await ended;
+    }
+  }
+  const timeout = options.timeoutMs ?? 600000;
+  let timer;
+  if (timeout > 0) {
+    timer = setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {}
+    }, timeout);
+  }
+  const stdoutPromise = decodeChunks(proc.stdout, options.onLog ? (line) => options.onLog(line, "stdout") : undefined);
+  const stderrPromise = decodeChunks(proc.stderr, options.onLog ? (line) => options.onLog(line, "stderr") : undefined);
+  const [stdout, stderr, exitCode] = await Promise.all([
+    stdoutPromise,
+    stderrPromise,
+    proc.exited
+  ]);
+  if (timer)
+    clearTimeout(timer);
+  return { exitCode: exitCode ?? -1, stderr, stdout };
+};
+var localTarget = (options) => {
+  const baseEnv = { ...options.env };
+  const ensureRoot = async () => {
+    await mkdir(options.root, { recursive: true });
+  };
+  return {
+    description: `local ${options.root}`,
+    exec: async (cmd, opts) => {
+      await ensureRoot();
+      return runSpawn(["sh", "-c", cmd], {
+        cwd: opts?.cwd ?? options.root,
+        env: { ...process.env, ...baseEnv, ...opts?.env ?? {} },
+        onLog: opts?.onLog,
+        stdin: opts?.stdin,
+        timeoutMs: opts?.timeoutMs
+      });
+    },
+    upload: async (localPath, remotePath, opts) => {
+      await ensureRoot();
+      const dest = remotePath.startsWith("/") ? remotePath : join(options.root, remotePath);
+      const argv = ["rsync", "-a"];
+      if (opts?.deleteOrphans)
+        argv.push("--delete");
+      for (const pattern of opts?.exclude ?? [])
+        argv.push("--exclude", pattern);
+      argv.push(localPath, dest);
+      const result = await runSpawn(argv, { timeoutMs: 600000 });
+      if (result.exitCode !== 0) {
+        throw new Error(`local upload failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+      }
+    }
+  };
+};
+var sshTargetString = (options) => {
+  const user = options.user ?? "root";
+  return `${user}@${options.host}`;
+};
+var sshBaseFlags = (options) => {
+  const flags = [];
+  if (options.port !== undefined && options.port !== 22)
+    flags.push("-p", String(options.port));
+  if (options.identity !== undefined)
+    flags.push("-i", options.identity);
+  flags.push("-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=accept-new");
+  for (const flag of options.sshFlags ?? [])
+    flags.push(flag);
+  return flags;
+};
+var shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+var buildRemoteCmd = (cmd, opts) => {
+  const env = opts?.env;
+  const envPrefix = env ? Object.entries(env).map(([k, v]) => `${k}=${shellQuote(v)}`).join(" ") + " " : "";
+  if (opts?.cwd) {
+    return `cd ${shellQuote(opts.cwd)} && ${envPrefix}${cmd}`;
+  }
+  return `${envPrefix}${cmd}`;
+};
+var sshTarget = (options) => {
+  const remote = sshTargetString(options);
+  const useRsync = options.rsync ?? true;
+  return {
+    description: `ssh ${remote}${options.port && options.port !== 22 ? `:${options.port}` : ""}`,
+    exec: async (cmd, opts) => {
+      const argv = ["ssh", ...sshBaseFlags(options)];
+      for (const name of options.forwardEnv ?? [])
+        argv.push("-o", `SendEnv=${name}`);
+      argv.push(remote, buildRemoteCmd(cmd, opts));
+      return runSpawn(argv, {
+        onLog: opts?.onLog,
+        stdin: opts?.stdin,
+        timeoutMs: opts?.timeoutMs
+      });
+    },
+    upload: async (localPath, remotePath, opts) => {
+      if (useRsync) {
+        const sshCmd = ["ssh", ...sshBaseFlags(options)].map((part) => part.includes(" ") ? `'${part}'` : part).join(" ");
+        const argv2 = ["rsync", "-az", "-e", sshCmd];
+        if (opts?.deleteOrphans)
+          argv2.push("--delete");
+        for (const pattern of opts?.exclude ?? [])
+          argv2.push("--exclude", pattern);
+        argv2.push(localPath, `${remote}:${remotePath}`);
+        const result2 = await runSpawn(argv2, { timeoutMs: 600000 });
+        if (result2.exitCode !== 0) {
+          throw new Error(`rsync upload failed (exit ${result2.exitCode}): ${result2.stderr || result2.stdout}`);
+        }
+        return;
+      }
+      const argv = ["scp", "-r", ...sshBaseFlags(options), localPath, `${remote}:${remotePath}`];
+      const result = await runSpawn(argv, { timeoutMs: 600000 });
+      if (result.exitCode !== 0) {
+        throw new Error(`scp upload failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+      }
+    }
+  };
+};
+
+// src/digitalocean.ts
+var DO_API_BASE = "https://api.digitalocean.com/v2";
+
+class DigitalOceanError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "DigitalOceanError";
+    this.status = status;
+    this.body = body;
+  }
+}
+var createDigitalOceanClient = (token, options = {}) => {
+  const base = options.baseUrl ?? DO_API_BASE;
+  const f = options.fetch ?? fetch;
+  return {
+    request: async (method, path, body) => {
+      const init = {
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        method
+      };
+      if (body !== undefined)
+        init.body = JSON.stringify(body);
+      const response = await f(`${base}${path}`, init);
+      if (response.status === 204)
+        return;
+      const text = await response.text();
+      const parsed = text.length > 0 ? JSON.parse(text) : undefined;
+      if (!response.ok) {
+        throw new DigitalOceanError(`DigitalOcean API ${method} ${path} failed: ${response.status} ${response.statusText}`, response.status, parsed);
+      }
+      return parsed;
+    }
+  };
+};
+var resolveClient = (options) => {
+  if (options.client !== undefined)
+    return options.client;
+  if (options.token !== undefined && options.token.length > 0) {
+    return createDigitalOceanClient(options.token);
+  }
+  throw new Error("[deploy/digitalocean] either `token` or `client` must be provided");
+};
+var publicIpv4 = (droplet) => droplet.networks.v4.find((net) => net.type === "public")?.ip_address;
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultProbeSsh = async (host, port) => {
+  const PROBE_TIMEOUT_MS = 2000;
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(value);
+    };
+    const timer = setTimeout(() => settle(false), PROBE_TIMEOUT_MS);
+    Bun.connect({
+      hostname: host,
+      port,
+      socket: {
+        data: () => {},
+        error: () => {
+          clearTimeout(timer);
+          settle(false);
+        },
+        open: (socket) => {
+          clearTimeout(timer);
+          socket.end();
+          settle(true);
+        }
+      }
+    }).catch(() => {
+      clearTimeout(timer);
+      settle(false);
+    });
+  });
+};
+var findDigitalOceanDroplet = async (client, name) => {
+  const body = await client.request("GET", `/droplets?name=${encodeURIComponent(name)}`);
+  const matches = body.droplets.filter((droplet) => droplet.name === name);
+  if (matches.length === 0)
+    return;
+  if (matches.length > 1) {
+    throw new Error(`[deploy/digitalocean] multiple droplets named "${name}" (${matches.map((droplet) => droplet.id).join(", ")}). Resolve manually before adopting.`);
+  }
+  return matches[0];
+};
+var listDigitalOceanDroplets = async (options) => {
+  const client = resolveClient(options);
+  const path = options.tag !== undefined ? `/droplets?tag_name=${encodeURIComponent(options.tag)}` : "/droplets";
+  const body = await client.request("GET", path);
+  return body.droplets;
+};
+var destroyDigitalOceanDroplet = async (options) => {
+  const client = resolveClient(options);
+  try {
+    await client.request("DELETE", `/droplets/${options.id}`);
+  } catch (error) {
+    if (error instanceof DigitalOceanError && error.status === 404) {
+      return;
+    }
+    throw error;
+  }
+};
+var digitalOceanTarget = async (options) => {
+  const client = resolveClient(options);
+  const log = options.onLog ?? (() => {});
+  const probeSsh = options.probeSsh ?? defaultProbeSsh;
+  const sleep = options.sleep ?? defaultSleep;
+  const now = options.now ?? Date.now;
+  const pollMs = options.pollIntervalMs ?? 5000;
+  const provisionTimeout = options.provisionTimeoutMs ?? 5 * 60000;
+  const sshTimeout = options.sshReadinessTimeoutMs ?? 2 * 60000;
+  const port = options.port ?? 22;
+  const existing = await findDigitalOceanDroplet(client, options.name);
+  let current;
+  if (existing === undefined) {
+    log(`[do] creating droplet "${options.name}" in ${options.region}`);
+    const created = await client.request("POST", "/droplets", {
+      name: options.name,
+      region: options.region,
+      size: options.size,
+      image: options.image,
+      ssh_keys: [...options.sshKeys],
+      ...options.tags !== undefined ? { tags: [...options.tags] } : {},
+      ...options.userData !== undefined ? { user_data: options.userData } : {},
+      ...options.vpcUuid !== undefined ? { vpc_uuid: options.vpcUuid } : {},
+      ...options.ipv6 === true ? { ipv6: true } : {},
+      ...options.monitoring === true ? { monitoring: true } : {}
+    });
+    current = created.droplet;
+  } else {
+    log(`[do] reusing droplet "${options.name}" (id ${existing.id}, status ${existing.status})`);
+    current = existing;
+  }
+  const provisionStart = now();
+  let ipv4 = publicIpv4(current);
+  while (current.status !== "active" || ipv4 === undefined) {
+    if (now() - provisionStart > provisionTimeout) {
+      throw new Error(`[deploy/digitalocean] provision timeout after ${provisionTimeout}ms \u2014 droplet ${current.id} status "${current.status}", ipv4 ${ipv4 ?? "(unassigned)"}`);
+    }
+    await sleep(pollMs);
+    const refreshed = await client.request("GET", `/droplets/${current.id}`);
+    current = refreshed.droplet;
+    ipv4 = publicIpv4(current);
+    log(`[do] poll: status=${current.status} ipv4=${ipv4 ?? "(none yet)"}`);
+  }
+  log(`[do] droplet active at ${ipv4}`);
+  const sshStart = now();
+  while (!await probeSsh(ipv4, port)) {
+    if (now() - sshStart > sshTimeout) {
+      throw new Error(`[deploy/digitalocean] SSH readiness timeout after ${sshTimeout}ms \u2014 ${ipv4}:${port} did not accept connections`);
+    }
+    await sleep(pollMs);
+    log(`[do] waiting on ssh ${ipv4}:${port}`);
+  }
+  log(`[do] ssh ready at ${ipv4}:${port}`);
+  const ssh = sshTarget({
+    host: ipv4,
+    ...options.user !== undefined ? { user: options.user } : {},
+    ...options.identity !== undefined ? { identity: options.identity } : {},
+    ...options.port !== undefined ? { port: options.port } : {}
+  });
+  const dropletId = current.id;
+  const resolvedIpv4 = ipv4;
+  return {
+    description: `digitalocean droplet "${options.name}" (${ssh.description})`,
+    dropletId,
+    ipv4: resolvedIpv4,
+    destroy: () => destroyDigitalOceanDroplet({ client, id: dropletId }).then(() => {
+      log(`[do] destroyed droplet ${dropletId}`);
+    }),
+    exec: ssh.exec,
+    upload: ssh.upload,
+    ...ssh.close !== undefined ? { close: ssh.close } : {}
+  };
+};
+export {
+  listDigitalOceanDroplets,
+  findDigitalOceanDroplet,
+  digitalOceanTarget,
+  destroyDigitalOceanDroplet,
+  createDigitalOceanClient,
+  DigitalOceanError
+};
+
+//# debugId=54E293FAC3F67A4164756E2164756E21
+//# sourceMappingURL=digitalocean.js.map