@absolutejs/deploy 0.14.1 → 0.15.0

package/dist/hetznerInfrastructure.js

@@ -0,0 +1,557 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// 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/cloudTarget.ts
+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 createCloudTarget = async (hooks, 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 prefix = options.logPrefix;
+  const noun = options.entityWord;
+  const existing = await hooks.findByName(options.name);
+  let current;
+  if (existing === undefined) {
+    log(`${prefix} creating ${noun} "${options.name}" in ${options.region}`);
+    current = await hooks.create();
+  } else {
+    log(`${prefix} reusing ${noun} "${options.name}" (id ${hooks.getId(existing)}, status ${hooks.getStatus(existing)})`);
+    current = existing;
+  }
+  const provisionStart = now();
+  let ipv4 = hooks.getIpv4(current);
+  while (!hooks.isReady(current) || ipv4 === undefined) {
+    if (now() - provisionStart > provisionTimeout) {
+      throw new Error(`${prefix} provision timeout after ${provisionTimeout}ms \u2014 ${noun} ${hooks.getId(current)} status "${hooks.getStatus(current)}", ipv4 ${ipv4 ?? "(unassigned)"}`);
+    }
+    await sleep(pollMs);
+    current = await hooks.fetch(hooks.getId(current));
+    ipv4 = hooks.getIpv4(current);
+    log(`${prefix} poll: status=${hooks.getStatus(current)} ipv4=${ipv4 ?? "(none yet)"}`);
+  }
+  log(`${prefix} ${noun} ready at ${ipv4}`);
+  const sshStart = now();
+  while (!await probeSsh(ipv4, port)) {
+    if (now() - sshStart > sshTimeout) {
+      throw new Error(`${prefix} SSH readiness timeout after ${sshTimeout}ms \u2014 ${ipv4}:${port} did not accept connections`);
+    }
+    await sleep(pollMs);
+    log(`${prefix} waiting on ssh ${ipv4}:${port}`);
+  }
+  log(`${prefix} 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 id = hooks.getId(current);
+  const resolvedIpv4 = ipv4;
+  return {
+    description: options.describeTarget(ssh.description),
+    destroy: () => hooks.destroy(id).then(() => {
+      log(`${prefix} destroyed ${noun} ${id}`);
+    }),
+    exec: ssh.exec,
+    id,
+    ipv4: resolvedIpv4,
+    upload: ssh.upload,
+    ...ssh.close !== undefined ? { close: ssh.close } : {}
+  };
+};
+
+// src/hetzner.ts
+var HETZNER_API_BASE = "https://api.hetzner.cloud/v1";
+
+class HetznerError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "HetznerError";
+    this.status = status;
+    this.body = body;
+  }
+}
+var createHetznerClient = (token, options = {}) => {
+  const base = options.baseUrl ?? HETZNER_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 HetznerError(`Hetzner Cloud 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 createHetznerClient(options.token);
+  }
+  throw new Error("[deploy/hetzner] either `token` or `client` must be provided");
+};
+var publicIpv4 = (server) => server.public_net.ipv4?.ip;
+var findHetznerServer = async (client, name) => {
+  const body = await client.request("GET", `/servers?name=${encodeURIComponent(name)}`);
+  const matches = body.servers.filter((server) => server.name === name);
+  if (matches.length === 0)
+    return;
+  if (matches.length > 1) {
+    throw new Error(`[deploy/hetzner] multiple servers named "${name}" (${matches.map((server) => server.id).join(", ")}). Hetzner shouldn't allow this \u2014 resolve manually.`);
+  }
+  return matches[0];
+};
+var listHetznerServers = async (options) => {
+  const client = resolveClient(options);
+  const path = options.labelSelector !== undefined ? `/servers?label_selector=${encodeURIComponent(options.labelSelector)}` : "/servers";
+  const body = await client.request("GET", path);
+  return body.servers;
+};
+var destroyHetznerServer = async (options) => {
+  const client = resolveClient(options);
+  try {
+    await client.request("DELETE", `/servers/${options.id}`);
+  } catch (error) {
+    if (error instanceof HetznerError && error.status === 404) {
+      return;
+    }
+    throw error;
+  }
+};
+var hetznerTarget = async (options) => {
+  const client = resolveClient(options);
+  const publicIpv4Enabled = options.disablePublicIpv4 !== true;
+  const publicIpv6Enabled = options.disablePublicIpv6 !== true;
+  const hooks = {
+    create: async () => {
+      const created = await client.request("POST", "/servers", {
+        name: options.name,
+        location: options.location,
+        server_type: options.serverType,
+        image: options.image,
+        ssh_keys: [...options.sshKeys],
+        start_after_create: true,
+        public_net: {
+          enable_ipv4: publicIpv4Enabled,
+          enable_ipv6: publicIpv6Enabled
+        },
+        ...options.labels !== undefined ? { labels: options.labels } : {},
+        ...options.userData !== undefined ? { user_data: options.userData } : {},
+        ...options.networkId !== undefined ? { networks: [options.networkId] } : {}
+      });
+      return created.server;
+    },
+    destroy: (id) => destroyHetznerServer({ client, id }),
+    fetch: async (id) => {
+      const refreshed = await client.request("GET", `/servers/${id}`);
+      return refreshed.server;
+    },
+    findByName: (name) => findHetznerServer(client, name),
+    getId: (server) => server.id,
+    getIpv4: publicIpv4,
+    getStatus: (server) => server.status,
+    isReady: (server) => server.status === "running"
+  };
+  const result = await createCloudTarget(hooks, {
+    describeTarget: (sshDescription) => `hetzner server "${options.name}" (${sshDescription})`,
+    entityWord: "server",
+    logPrefix: "[hetzner]",
+    name: options.name,
+    region: options.location,
+    ...options.user !== undefined ? { user: options.user } : {},
+    ...options.identity !== undefined ? { identity: options.identity } : {},
+    ...options.port !== undefined ? { port: options.port } : {},
+    ...options.provisionTimeoutMs !== undefined ? { provisionTimeoutMs: options.provisionTimeoutMs } : {},
+    ...options.sshReadinessTimeoutMs !== undefined ? { sshReadinessTimeoutMs: options.sshReadinessTimeoutMs } : {},
+    ...options.pollIntervalMs !== undefined ? { pollIntervalMs: options.pollIntervalMs } : {},
+    ...options.onLog !== undefined ? { onLog: options.onLog } : {},
+    ...options.probeSsh !== undefined ? { probeSsh: options.probeSsh } : {},
+    ...options.sleep !== undefined ? { sleep: options.sleep } : {},
+    ...options.now !== undefined ? { now: options.now } : {}
+  });
+  return {
+    description: result.description,
+    destroy: result.destroy,
+    exec: result.exec,
+    ipv4: result.ipv4,
+    serverId: result.id,
+    upload: result.upload,
+    ...result.close !== undefined ? { close: result.close } : {}
+  };
+};
+
+// src/infrastructureAdapter.ts
+var infrastructureAgent = (options, addresses) => {
+  if (!options)
+    return;
+  const host = options.preferPrivateNetwork ? addresses.privateIpv4 ?? addresses.publicIpv4 : addresses.publicIpv4 ?? addresses.privateIpv4;
+  if (!host)
+    return;
+  return {
+    url: `${options.protocol ?? "http"}://${host}:${options.port ?? 8081}/`,
+    ...options.audience ? { audience: options.audience } : {}
+  };
+};
+var leastPopulatedRegion = (regions, observed, requested) => {
+  const eligible = requested ? regions.filter((region) => region.region === requested) : [...regions];
+  if (eligible.length === 0)
+    return;
+  const counts = new Map(eligible.map((region) => [region.region, 0]));
+  for (const region of observed) {
+    if (counts.has(region))
+      counts.set(region, (counts.get(region) ?? 0) + 1);
+  }
+  const selected = [...counts].sort((left, right) => left[1] - right[1] || left[0].localeCompare(right[0]))[0]?.[0];
+  return eligible.find((region) => region.region === selected);
+};
+
+// src/hetznerInfrastructure.ts
+var stateFor = (status) => {
+  if (status === "running")
+    return "ready";
+  if (["initializing", "starting", "migrating", "rebuilding"].includes(status))
+    return "pending";
+  return "terminated";
+};
+var parseNodeId = (id) => {
+  const match = /^hetzner:([1-9][0-9]*)$/.exec(id);
+  if (!match?.[1])
+    throw new Error("[deploy/hetzner] invalid infrastructure node id");
+  return Number(match[1]);
+};
+var createHetznerInfrastructureProvider = (options) => {
+  if (options.regions.length === 0)
+    throw new Error("[deploy/hetzner] at least one fleet region is required");
+  const client = options.client ?? (options.token ? createHetznerClient(options.token) : undefined);
+  if (!client)
+    throw new Error("[deploy/hetzner] either `token` or `client` must be provided");
+  const labelKey = options.labelKey ?? "absolutejs-role";
+  const labelValue = options.labelValue ?? "absolutejs-paas-node";
+  const normalize = (server) => {
+    const publicIpv42 = server.public_net.ipv4?.ip;
+    const privateIpv4 = server.private_net?.[0]?.ip;
+    const agent = infrastructureAgent(options.agent, {
+      privateIpv4,
+      publicIpv4: publicIpv42
+    });
+    return {
+      id: `hetzner:${server.id}`,
+      label: server.name,
+      provider: "hetzner",
+      region: server.datacenter?.location.name ?? "unknown",
+      state: stateFor(server.status),
+      ...publicIpv42 ? { publicIpv4: publicIpv42 } : {},
+      ...privateIpv4 ? { privateIpv4 } : {},
+      ...agent ? { agent } : {}
+    };
+  };
+  const list = () => listHetznerServers({
+    client,
+    labelSelector: `${labelKey}=${labelValue}`
+  });
+  return {
+    capabilities: {
+      cloudInit: true,
+      idempotentProvisioning: true,
+      privateNetworking: true,
+      regionalPlacement: true,
+      regions: options.regions.map(({ region }) => region)
+    },
+    getNode: async (id) => {
+      const result = await client.request("GET", `/servers/${parseNodeId(id)}`);
+      return normalize(result.server);
+    },
+    listNodes: async () => (await list()).map(normalize),
+    name: "hetzner",
+    provisionNode: async (input) => {
+      const existing = await findHetznerServer(client, input.name);
+      if (existing)
+        return normalize(existing);
+      const servers = await list();
+      const region = leastPopulatedRegion(options.regions, servers.map((server) => server.datacenter?.location.name ?? "unknown"), input.region);
+      if (!region)
+        throw new Error(`[deploy/hetzner] region ${input.region ?? "(any)"} is not configured`);
+      const result = await client.request("POST", "/servers", {
+        image: region.image,
+        labels: { [labelKey]: labelValue },
+        location: region.region,
+        name: input.name,
+        public_net: { enable_ipv4: true, enable_ipv6: true },
+        server_type: region.serverType,
+        ssh_keys: [...region.sshKeys],
+        start_after_create: true,
+        ...region.networkId ? { networks: [region.networkId] } : {},
+        ...region.userData ? { user_data: region.userData } : {}
+      });
+      return normalize(result.server);
+    },
+    terminateNode: async (id) => destroyHetznerServer({ client, id: parseNodeId(id) })
+  };
+};
+export {
+  createHetznerInfrastructureProvider
+};
+
+//# debugId=E5D82A7D407A792564756E2164756E21
+//# sourceMappingURL=hetznerInfrastructure.js.map