@absolutejs/deploy 0.14.1 → 0.16.0

package/dist/linodeInfrastructure.js

@@ -0,0 +1,573 @@
+// @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/linode.ts
+var LINODE_API_BASE = "https://api.linode.com/v4";
+
+class LinodeError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "LinodeError";
+    this.status = status;
+    this.body = body;
+  }
+}
+var createLinodeClient = (token, options = {}) => {
+  const base = options.baseUrl ?? LINODE_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 LinodeError(`Linode 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 createLinodeClient(options.token);
+  }
+  throw new Error("[deploy/linode] either `token` or `client` must be provided");
+};
+var publicIpv4 = (instance) => {
+  for (const ip of instance.ipv4) {
+    if (!ip.startsWith("10.") && !ip.startsWith("192.168.") && !ip.startsWith("172.") && !ip.startsWith("169.254.")) {
+      return ip;
+    }
+  }
+  return;
+};
+var randomPassword = (length) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  let out = "";
+  for (const byte of bytes)
+    out += chars[byte % chars.length];
+  return out;
+};
+var findLinodeInstance = async (client, name) => {
+  const body = await client.request("GET", "/linode/instances?page_size=500");
+  const matches = body.data.filter((instance) => instance.label === name);
+  if (matches.length === 0)
+    return;
+  if (matches.length > 1) {
+    throw new Error(`[deploy/linode] multiple instances labeled "${name}" (${matches.map((instance) => instance.id).join(", ")}). Resolve manually before adopting.`);
+  }
+  return matches[0];
+};
+var listLinodeInstances = async (options) => {
+  const client = resolveClient(options);
+  const path = options.tag !== undefined ? `/linode/instances?tag=${encodeURIComponent(options.tag)}&page_size=500` : "/linode/instances?page_size=500";
+  const body = await client.request("GET", path);
+  return body.data;
+};
+var destroyLinodeInstance = async (options) => {
+  const client = resolveClient(options);
+  try {
+    await client.request("DELETE", `/linode/instances/${options.id}`);
+  } catch (error) {
+    if (error instanceof LinodeError && error.status === 404)
+      return;
+    throw error;
+  }
+};
+var linodeTarget = async (options) => {
+  const client = resolveClient(options);
+  const rootPass = options.rootPass ?? randomPassword(32);
+  const hooks = {
+    create: async () => {
+      const created = await client.request("POST", "/linode/instances", {
+        authorized_keys: [...options.sshKeys],
+        image: options.image,
+        label: options.name,
+        region: options.region,
+        root_pass: rootPass,
+        type: options.type,
+        ...options.tags !== undefined ? { tags: [...options.tags] } : {},
+        ...options.userData !== undefined ? { stackscript_data: { user_data: options.userData } } : {},
+        ...options.privateIp === true ? { private_ip: true } : {},
+        ...options.backupsEnabled === true ? { backups_enabled: true } : {}
+      });
+      return created;
+    },
+    destroy: (id) => destroyLinodeInstance({ client, id }),
+    fetch: (id) => client.request("GET", `/linode/instances/${id}`),
+    findByName: (name) => findLinodeInstance(client, name),
+    getId: (instance) => instance.id,
+    getIpv4: publicIpv4,
+    getStatus: (instance) => instance.status,
+    isReady: (instance) => instance.status === "running"
+  };
+  const result = await createCloudTarget(hooks, {
+    describeTarget: (sshDescription) => `linode "${options.name}" (${sshDescription})`,
+    entityWord: "instance",
+    logPrefix: "[linode]",
+    name: options.name,
+    region: options.region,
+    ...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,
+    instanceId: result.id,
+    ipv4: result.ipv4,
+    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/linodeInfrastructure.ts
+var isPrivate = (ip) => ip.startsWith("10.") || ip.startsWith("192.168.") || ip.startsWith("172.") || ip.startsWith("169.254.");
+var stateFor = (status) => {
+  if (status === "running")
+    return "ready";
+  if ([
+    "booting",
+    "rebooting",
+    "provisioning",
+    "migrating",
+    "rebuilding",
+    "cloning",
+    "restoring"
+  ].includes(status))
+    return "pending";
+  return "terminated";
+};
+var parseNodeId = (id) => {
+  const match = /^linode:([1-9][0-9]*)$/.exec(id);
+  if (!match?.[1])
+    throw new Error("[deploy/linode] invalid infrastructure node id");
+  return Number(match[1]);
+};
+var rootPassword = () => {
+  const bytes = crypto.getRandomValues(new Uint8Array(24));
+  return Buffer.from(bytes).toString("base64url");
+};
+var createLinodeInfrastructureProvider = (options) => {
+  if (options.regions.length === 0)
+    throw new Error("[deploy/linode] at least one fleet region is required");
+  const client = options.client ?? (options.token ? createLinodeClient(options.token) : undefined);
+  if (!client)
+    throw new Error("[deploy/linode] either `token` or `client` must be provided");
+  const tag = options.tag ?? "absolutejs-paas-node";
+  const normalize = (instance) => {
+    const publicIpv42 = instance.ipv4.find((ip) => !isPrivate(ip));
+    const privateIpv4 = instance.ipv4.find(isPrivate);
+    const agent = infrastructureAgent(options.agent, {
+      privateIpv4,
+      publicIpv4: publicIpv42
+    });
+    return {
+      id: `linode:${instance.id}`,
+      label: instance.label,
+      provider: "linode",
+      region: instance.region ?? "unknown",
+      state: stateFor(instance.status),
+      ...publicIpv42 ? { publicIpv4: publicIpv42 } : {},
+      ...privateIpv4 ? { privateIpv4 } : {},
+      ...agent ? { agent } : {}
+    };
+  };
+  const list = () => listLinodeInstances({ client, tag });
+  return {
+    capabilities: {
+      cloudInit: true,
+      idempotentProvisioning: true,
+      privateNetworking: true,
+      regionalPlacement: true,
+      regions: options.regions.map(({ region }) => region)
+    },
+    getNode: async (id) => {
+      const instance = await client.request("GET", `/linode/instances/${parseNodeId(id)}`);
+      return normalize(instance);
+    },
+    listNodes: async () => (await list()).map(normalize),
+    name: "linode",
+    provisionNode: async (input) => {
+      const existing = await findLinodeInstance(client, input.name);
+      if (existing)
+        return normalize(existing);
+      const instances = await list();
+      const region = leastPopulatedRegion(options.regions, instances.map((instance2) => instance2.region ?? "unknown"), input.region);
+      if (!region)
+        throw new Error(`[deploy/linode] region ${input.region ?? "(any)"} is not configured`);
+      const instance = await client.request("POST", "/linode/instances", {
+        authorized_keys: [...region.sshKeys],
+        image: region.image,
+        label: input.name,
+        private_ip: true,
+        region: region.region,
+        root_pass: rootPassword(),
+        tags: [tag],
+        type: region.type,
+        ...input.userData ?? region.userData ? { stackscript_data: { user_data: input.userData ?? region.userData } } : {}
+      });
+      return normalize(instance);
+    },
+    terminateNode: async (id) => destroyLinodeInstance({ client, id: parseNodeId(id) })
+  };
+};
+export {
+  createLinodeInfrastructureProvider
+};
+
+//# debugId=EBD657F73178F71564756E2164756E21
+//# sourceMappingURL=linodeInfrastructure.js.map