@fabioplunser/epd 0.1.0 → 0.1.1

package/dist/cli.js

@@ -1484,9 +1484,9 @@ function declFor(cfg) {
     extra: cfg.proxy.extra
   };
 }
-async function readDecls(host2, cfg) {
+async function readDecls(host, cfg) {
   const dir = paths(cfg).proxyAppsDir;
-  const out = await host2.capture(`for f in ${shq(dir)}/*.json; do [ -f "$f" ] || continue; echo "###EPD_FILE"; cat "$f"; done`, { allowFailure: true });
+  const out = await host.capture(`for f in ${shq(dir)}/*.json; do [ -f "$f" ] || continue; echo "###EPD_FILE"; cat "$f"; done`, { allowFailure: true });
   const decls = [];
   for (const chunk of out.split("###EPD_FILE")) {
     const t = chunk.trim();
@@ -1495,7 +1495,7 @@ async function readDecls(host2, cfg) {
     try {
       decls.push(JSON.parse(t));
     } catch {
-      log.warn(`${host2.name}: ignoring an unreadable proxy declaration`);
+      log.warn(`${host.name}: ignoring an unreadable proxy declaration`);
     }
   }
   return decls;
@@ -1647,18 +1647,18 @@ function dynamicConfig(cfg, endpoints, accessories = []) {
         middlewares[key] = {
           redirectRegex: { regex: "^https?://[^/]+(.*)", replacement: `${route.redirect.to.replace(/\/$/, "")}$1`, permanent: route.redirect.permanent }
         };
-        const svcKey2 = `${owner.key}-${route.port}`;
-        ensureService(services, svcKey2, owner.urlsFor(route.port), route, owner.health);
+        const svcKey = `${owner.key}-${route.port}`;
+        ensureService(services, svcKey, owner.urlsFor(route.port), route, owner.health);
         routers[routerKey] = {
           rule,
           entryPoints: [entrypoint],
           middlewares: [...mws, key],
-          service: svcKey2,
+          service: svcKey,
           ...route.ssl ? { tls: tlsFor(route) } : {},
           ...route.priority !== undefined ? { priority: route.priority } : {}
         };
         if (route.ssl && cfg.proxy.httpsRedirect) {
-          routers[`${routerKey}-http`] = { rule, entryPoints: ["web"], middlewares: [key], service: svcKey2 };
+          routers[`${routerKey}-http`] = { rule, entryPoints: ["web"], middlewares: [key], service: svcKey };
         }
         return;
       }
@@ -1743,18 +1743,18 @@ function containerSpec(d, cfg, staticHash) {
   args.push(d.image);
   return args;
 }
-async function ensureProxy(host2, cfg, opts = {}) {
+async function ensureProxy(host, cfg, opts = {}) {
   if (!cfg.proxy.enabled)
     return;
   const p = paths(cfg);
   const containerMode = cfg.mode === "docker";
-  await host2.writeFile(p.proxyApp, JSON.stringify(declFor(cfg), null, 2), "644");
-  const merged = mergeDecls(await readDecls(host2, cfg));
+  await host.writeFile(p.proxyApp, JSON.stringify(declFor(cfg), null, 2), "644");
+  const merged = mergeDecls(await readDecls(host, cfg));
   if (!Object.keys(merged.entrypoints).length)
     merged.entrypoints = cfg.proxy.entrypoints;
   const where = containerMode ? CONTAINER_PATHS : { dynamicDir: p.proxyDynamicDir, acmeFile: `${p.acmeDir}/acme.json` };
   const staticJson = JSON.stringify(staticConfig(merged, where), null, 2);
-  await host2.writeFile(p.proxyStatic, staticJson, "644");
+  await host.writeFile(p.proxyStatic, staticJson, "644");
   if (merged.dnsEnv.length) {
     const lines = merged.dnsEnv.map((name) => {
       const value = opts.secrets?.[name];
@@ -1763,7 +1763,7 @@ async function ensureProxy(host2, cfg, opts = {}) {
       }
       return `${name}=${value}`;
     });
-    await host2.writeFile(p.proxyEnv, lines.join(`
+    await host.writeFile(p.proxyEnv, lines.join(`
 `), "600");
   }
   if (merged.dashboard && merged.dashboardHost) {
@@ -1779,23 +1779,23 @@ async function ensureProxy(host2, cfg, opts = {}) {
         }
       }
     };
-    await host2.writeFile(`${p.proxyDynamicDir}/_dashboard.yml`, JSON.stringify(dash, null, 2), "644");
+    await host.writeFile(`${p.proxyDynamicDir}/_dashboard.yml`, JSON.stringify(dash, null, 2), "644");
   }
   const specHash = hash32(staticJson + JSON.stringify(merged)).toString(36);
   if (containerMode)
-    await ensureProxyContainer(host2, cfg, merged, specHash, opts);
+    await ensureProxyContainer(host, cfg, merged, specHash, opts);
   else
-    await ensureProxyProcess(host2, cfg, merged, specHash, opts);
+    await ensureProxyProcess(host, cfg, merged, specHash, opts);
 }
-async function ensureProxyContainer(host2, cfg, merged, specHash, opts) {
+async function ensureProxyContainer(host, cfg, merged, specHash, opts) {
   const spec = containerSpec(merged, cfg, specHash);
-  const state = await host2.capture(`docker inspect -f '{{.State.Running}} {{index .Config.Labels "epd.spec"}}' ${PROXY_CONTAINER} 2>/dev/null || echo "missing"`);
+  const state = await host.capture(`docker inspect -f '{{.State.Running}} {{index .Config.Labels "epd.spec"}}' ${PROXY_CONTAINER} 2>/dev/null || echo "missing"`);
   const [running, currentHash] = state.split(/\s+/);
   if (!opts.force && running === "true" && currentHash === specHash) {
-    log.host(host2.name, "proxy is up to date");
+    log.host(host.name, "proxy is up to date");
     return;
   }
-  await host2.exec(`docker network inspect ${shq(merged.network)} >/dev/null 2>&1 || docker network create ${shq(merged.network)} >/dev/null
+  await host.exec(`docker network inspect ${shq(merged.network)} >/dev/null 2>&1 || docker network create ${shq(merged.network)} >/dev/null
 docker rm -f ${PROXY_CONTAINER} >/dev/null 2>&1 || true
 docker pull ${shq(merged.image)} >/dev/null
 ${spec.map((a) => shq(a)).join(" ")} >/dev/null
@@ -1804,15 +1804,15 @@ docker inspect -f '{{.State.Running}}' ${PROXY_CONTAINER} | grep -q true || {
   echo "traefik failed to start:" >&2
   docker logs --tail 40 ${PROXY_CONTAINER} >&2 || true
   exit 1
-}`, { label: `${host2.name}: start proxy` });
-  log.host(host2.name, `proxy running (${entrypointSummary(merged)})`);
+}`, { label: `${host.name}: start proxy` });
+  log.host(host.name, `proxy running (${entrypointSummary(merged)})`);
 }
 var TRAEFIK_FALLBACK_VERSION = "v3.3.7";
-async function ensureProxyProcess(host2, cfg, merged, specHash, opts) {
+async function ensureProxyProcess(host, cfg, merged, specHash, opts) {
   const p = paths(cfg);
   const wanted = merged.version ?? (/^traefik:(v\d+\.\d+\.\d+)$/.exec(merged.image)?.[1] ?? "");
   const needsPrivilegedPort = Object.values(merged.entrypoints).some((port) => port < 1024);
-  await host2.exec(`mkdir -p ${shq(`${p.proxyDir}/bin`)} ${shq(p.proxyLogDir)}
+  await host.exec(`mkdir -p ${shq(`${p.proxyDir}/bin`)} ${shq(p.proxyLogDir)}
 want=${shq(wanted)}
 if [ -z "$want" ]; then
   # Piping curl straight into grep -m1 closes the pipe early, which pipefail
@@ -1845,7 +1845,7 @@ if [ "$have" != "$want" ]; then
   rm -rf "$tmp"
 fi
 ${needsPrivilegedPort ? `command -v setcap >/dev/null 2>&1 && setcap 'cap_net_bind_service=+ep' ${shq(p.proxyBin)} 2>/dev/null || echo "note: could not grant the traefik binary permission to bind ports below 1024" >&2` : ""}
-true`, { stream: true, label: `${host2.name}: install traefik` });
+true`, { stream: true, label: `${host.name}: install traefik` });
   const ecosystem = {
     apps: [
       {
@@ -1865,17 +1865,17 @@ true`, { stream: true, label: `${host2.name}: install traefik` });
       }
     ]
   };
-  await host2.writeFile(p.proxyEcosystem, JSON.stringify(ecosystem, null, 2), "600");
-  const jlist = await host2.capture(`${pathPrelude(cfg)} pm2 jlist 2>/dev/null || echo '[]'`, {
+  await host.writeFile(p.proxyEcosystem, JSON.stringify(ecosystem, null, 2), "600");
+  const jlist = await host.capture(`${pathPrelude(cfg)} pm2 jlist 2>/dev/null || echo '[]'`, {
     sudo: false,
     allowFailure: true
   });
-  const running = await host2.test(`${pathPrelude(cfg)} pm2 describe ${PROXY_PROCESS} >/dev/null 2>&1`);
+  const running = await host.test(`${pathPrelude(cfg)} pm2 describe ${PROXY_PROCESS} >/dev/null 2>&1`);
   if (!opts.force && running && jlist.includes(specHash)) {
-    log.host(host2.name, "proxy is up to date");
+    log.host(host.name, "proxy is up to date");
     return;
   }
-  await host2.exec(`${pathPrelude(cfg)} pm2 delete ${PROXY_PROCESS} >/dev/null 2>&1 || true
+  await host.exec(`${pathPrelude(cfg)} pm2 delete ${PROXY_PROCESS} >/dev/null 2>&1 || true
 ${pathPrelude(cfg)} pm2 start ${shq(p.proxyEcosystem)} --update-env
 ${pathPrelude(cfg)} pm2 save --force >/dev/null 2>&1 || true
 sleep 2
@@ -1883,29 +1883,29 @@ ${pathPrelude(cfg)} pm2 describe ${PROXY_PROCESS} | grep -q online || {
   echo "traefik failed to start:" >&2
   tail -n 40 ${shq(`${p.proxyLogDir}/err.log`)} >&2 2>/dev/null || true
   exit 1
-}`, { sudo: false, label: `${host2.name}: start proxy` });
-  log.host(host2.name, `proxy running (${entrypointSummary(merged)})`);
+}`, { sudo: false, label: `${host.name}: start proxy` });
+  log.host(host.name, `proxy running (${entrypointSummary(merged)})`);
 }
 function entrypointSummary(d) {
   return Object.entries(d.entrypoints).map(([name, port]) => `${name}:${port}`).join(" ");
 }
-async function writeRoutes(host2, cfg, endpoints, accessories = []) {
+async function writeRoutes(host, cfg, endpoints, accessories = []) {
   if (!cfg.proxy.enabled)
     return;
   const doc = dynamicConfig(cfg, endpoints, accessories);
-  await host2.writeFile(paths(cfg).proxyDynamic, JSON.stringify(doc, null, 2), "644");
-  await host2.exec(`sleep ${Math.max(1, cfg.proxy.reloadWait)}`);
+  await host.writeFile(paths(cfg).proxyDynamic, JSON.stringify(doc, null, 2), "644");
+  await host.exec(`sleep ${Math.max(1, cfg.proxy.reloadWait)}`);
 }
-async function removeRoutes(host2, cfg) {
-  await host2.exec(`rm -f ${shq(paths(cfg).proxyDynamic)} ${shq(paths(cfg).proxyApp)}`, { allowFailure: true });
+async function removeRoutes(host, cfg) {
+  await host.exec(`rm -f ${shq(paths(cfg).proxyDynamic)} ${shq(paths(cfg).proxyApp)}`, { allowFailure: true });
 }
-async function proxyState(host2, cfg) {
+async function proxyState(host, cfg) {
   if (cfg.mode === "docker") {
-    const out2 = await host2.capture(`docker inspect -f '{{.State.Running}}|{{.Config.Image}}|{{.State.Status}}' ${PROXY_CONTAINER} 2>/dev/null || echo 'false||absent'`, { allowFailure: true });
-    const [running, image, status2] = out2.split("|");
-    return { running: running === "true", image: image ?? "", status: status2 ?? "absent" };
+    const out = await host.capture(`docker inspect -f '{{.State.Running}}|{{.Config.Image}}|{{.State.Status}}' ${PROXY_CONTAINER} 2>/dev/null || echo 'false||absent'`, { allowFailure: true });
+    const [running, image, status] = out.split("|");
+    return { running: running === "true", image: image ?? "", status: status ?? "absent" };
   }
-  const out = await host2.capture(`describe=$(${pathPrelude(cfg)} pm2 describe ${PROXY_PROCESS} 2>/dev/null || true)
+  const out = await host.capture(`describe=$(${pathPrelude(cfg)} pm2 describe ${PROXY_PROCESS} 2>/dev/null || true)
 printf '%s' "$describe" | awk -F'\u2502' '/status/ {gsub(/ /,"",$3); print $3; exit}' || true
 version_out=$(${shq(paths(cfg).proxyBin)} version 2>/dev/null || true)
 printf '%s' "$version_out" | awk '/[Vv]ersion:/ {print "traefik " $2; exit}' || true`, { sudo: false, allowFailure: true });
@@ -1931,8 +1931,8 @@ class DeployLock {
   async acquire(what) {
     const dir = paths(this.cfg).lock;
     const info = { by: who(), at: new Date().toISOString(), what };
-    for (const host2 of this.hosts) {
-      const res = await host2.exec(`mkdir -p ${shq(paths(this.cfg).app)}
+    for (const host of this.hosts) {
+      const res = await host.exec(`mkdir -p ${shq(paths(this.cfg).app)}
 if mkdir ${shq(dir)} 2>/dev/null; then
   printf '%s' ${shq(JSON.stringify(info))} > ${shq(dir)}/info
   echo acquired
@@ -1946,27 +1946,27 @@ fi`, { allowFailure: true });
         try {
           held = JSON.parse(res.stdout || "{}");
         } catch {}
-        throw new EpdError(`${this.cfg.name} is locked on ${host2.name}`, held.by ? `Held by ${held.by} since ${held.at} (${held.what}).
+        throw new EpdError(`${this.cfg.name} is locked on ${host.name}`, held.by ? `Held by ${held.by} since ${held.at} (${held.what}).
 If that deploy died, run: epd lock release` : "Run `epd lock release` if a previous deploy was interrupted.");
       }
-      this.held.push(host2);
+      this.held.push(host);
     }
     log.debug(`lock acquired on ${this.held.length} host(s)`);
   }
   async release() {
     const dir = paths(this.cfg).lock;
-    for (const host2 of this.held.splice(0)) {
-      await host2.exec(`rm -rf ${shq(dir)}`, { allowFailure: true });
+    for (const host of this.held.splice(0)) {
+      await host.exec(`rm -rf ${shq(dir)}`, { allowFailure: true });
     }
   }
   static async forceRelease(cfg, hosts) {
-    for (const host2 of hosts)
-      await host2.exec(`rm -rf ${shq(paths(cfg).lock)}`, { allowFailure: true });
+    for (const host of hosts)
+      await host.exec(`rm -rf ${shq(paths(cfg).lock)}`, { allowFailure: true });
   }
   static async status(cfg, hosts) {
     const out = [];
-    for (const host2 of hosts) {
-      const raw = await host2.readFile(`${paths(cfg).lock}/info`);
+    for (const host of hosts) {
+      const raw = await host.readFile(`${paths(cfg).lock}/info`);
       let info = null;
       if (raw) {
         try {
@@ -1975,7 +1975,7 @@ If that deploy died, run: epd lock release` : "Run `epd lock release` if a previ
           info = { by: "unknown", at: "unknown", what: "unknown" };
         }
       }
-      out.push({ host: host2.name, info });
+      out.push({ host: host.name, info });
     }
     return out;
   }
@@ -2074,34 +2074,34 @@ EPD_TARGETS
 done
 `;
 }
-async function waitHealthy(host2, targets, health) {
+async function waitHealthy(host, targets, health) {
   if (!targets.length)
     return;
-  const res = await host2.exec(healthScript(targets, health), {
+  const res = await host.exec(healthScript(targets, health), {
     allowFailure: true,
-    label: `${host2.name}: health check`
+    label: `${host.name}: health check`
   });
   if (res.code === 0 && res.stdout.includes("EPD_HEALTHY"))
     return;
   const detail = res.stdout.replace("EPD_UNHEALTHY:", "").trim() || res.stderr;
-  throw new EpdError(`${host2.name}: new version did not become healthy within ${health.timeout}s`, `Still failing:${detail ? ` ${detail}` : ""}
+  throw new EpdError(`${host.name}: new version did not become healthy within ${health.timeout}s`, `Still failing:${detail ? ` ${detail}` : ""}
 Check \`epd logs\` \u2014 the old version is still serving traffic.`);
 }
 
 // src/core/state.ts
-async function readState(host2, cfg) {
-  const raw = await host2.readFile(paths(cfg).state);
+async function readState(host, cfg) {
+  const raw = await host.readFile(paths(cfg).state);
   if (!raw)
     return null;
   try {
     return JSON.parse(raw);
   } catch {
-    log.warn(`${host2.name}: state file is corrupt, treating this host as fresh`);
+    log.warn(`${host.name}: state file is corrupt, treating this host as fresh`);
     return null;
   }
 }
-async function writeState(host2, cfg, state) {
-  await host2.writeFile(paths(cfg).state, JSON.stringify(state, null, 2), "644");
+async function writeState(host, cfg, state) {
+  await host.writeFile(paths(cfg).state, JSON.stringify(state, null, 2), "644");
 }
 function emptyState(cfg) {
   return {
@@ -2210,7 +2210,7 @@ async function ensureBuilder() {
   log.info('creating buildx builder "epd"');
   await run(["docker", "buildx", "create", "--name", "epd", "--use", "--bootstrap"], { stream: true });
 }
-async function loginRegistry(host2, cfg, env) {
+async function loginRegistry(host, cfg, env) {
   if (!cfg.registry)
     return;
   const password = env[cfg.registry.passwordEnv];
@@ -2218,25 +2218,25 @@ async function loginRegistry(host2, cfg, env) {
     throw new EpdError(`registry password: ${cfg.registry.passwordEnv} is not set`, "Export it, or put it in .env next to epd.yml.");
   }
   const server = cfg.registry.server ?? "";
-  await host2.exec(`printf '%s' ${shq(password)} | docker login ${server ? shq(server) + " " : ""}--username ${shq(cfg.registry.username)} --password-stdin >/dev/null`, { label: `${host2.name}: docker login` });
+  await host.exec(`printf '%s' ${shq(password)} | docker login ${server ? shq(server) + " " : ""}--username ${shq(cfg.registry.username)} --password-stdin >/dev/null`, { label: `${host.name}: docker login` });
 }
-async function ensureImage(host2, cfg, version) {
+async function ensureImage(host, cfg, version) {
   const ref = imageRef(cfg, version);
-  if (await host2.test(`docker image inspect ${shq(ref)} >/dev/null 2>&1`)) {
-    log.host(host2.name, `image ${version} already present`);
+  if (await host.test(`docker image inspect ${shq(ref)} >/dev/null 2>&1`)) {
+    log.host(host.name, `image ${version} already present`);
     return;
   }
   if (cfg.registry) {
-    log.host(host2.name, `pulling ${ref}`);
-    await host2.exec(`docker pull ${shq(ref)} >/dev/null`, { label: `${host2.name}: docker pull` });
+    log.host(host.name, `pulling ${ref}`);
+    await host.exec(`docker pull ${shq(ref)} >/dev/null`, { label: `${host.name}: docker pull` });
   } else {
-    log.host(host2.name, `shipping ${ref} over ssh (no registry configured)`);
-    await host2.pipeInto("gunzip | docker load", ["/bin/sh", "-c", `docker save ${shq(ref)} | gzip -1`]);
+    log.host(host.name, `shipping ${ref} over ssh (no registry configured)`);
+    await host.pipeInto("gunzip | docker load", ["/bin/sh", "-c", `docker save ${shq(ref)} | gzip -1`]);
   }
 }
-async function pruneImages(host2, cfg, keep, inUse) {
+async function pruneImages(host, cfg, keep, inUse) {
   const keepRefs = inUse.map((v) => imageRef(cfg, v));
-  await host2.exec(`keep=${shq(keepRefs.join(" "))}
+  await host.exec(`keep=${shq(keepRefs.join(" "))}
 docker images --filter "label=epd.app=${cfg.name}" --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' 2>/dev/null \\
   | sort -k2 -r | tail -n +$(( ${keep} + 1 )) | awk '{print $1}' | while read -r img; do
     case " $keep " in *" $img "*) continue;; esac
@@ -2271,10 +2271,10 @@ function envFileContent(vars) {
   return Object.entries(vars).map(([k, v]) => `${k}=${v}`).join(`
 `);
 }
-async function writeServiceEnv(host2, cfg, svc, env) {
+async function writeServiceEnv(host, cfg, svc, env) {
   const secrets = resolveSecrets(svc.secrets, env, `servers.${svc.name}`);
   const file = `${paths(cfg).app}/env.${svc.name}`;
-  await host2.writeFile(file, envFileContent({ ...svc.env, ...secrets }), "600");
+  await host.writeFile(file, envFileContent({ ...svc.env, ...secrets }), "600");
   return file;
 }
 function dockerRunArgs(o) {
@@ -2301,7 +2301,7 @@ function dockerRunArgs(o) {
     args.push(...parseCommand(svc.command));
   return args;
 }
-async function startSlot(host2, cfg, svc, slot, version, envFile) {
+async function startSlot(host, cfg, svc, slot, version, envFile) {
   const names = [];
   const lines = [
     `old=$(docker ps -a -q --filter "label=epd.app=${cfg.name}" --filter "label=epd.service=${svc.name}" --filter "label=epd.slot=${slot}")`,
@@ -2310,19 +2310,19 @@ async function startSlot(host2, cfg, svc, slot, version, envFile) {
   for (let i = 0;i < svc.replicas; i++) {
     const name = containerName(cfg.name, svc.name, slot, i);
     names.push(name);
-    const args = dockerRunArgs({ cfg, svc, slot, version, replica: i, serverHost: host2.name, envFile });
+    const args = dockerRunArgs({ cfg, svc, slot, version, replica: i, serverHost: host.name, envFile });
     lines.push(`docker rm -f ${shq(name)} >/dev/null 2>&1 || true`);
     lines.push(`${args.map((a) => shq(a)).join(" ")} >/dev/null`);
   }
-  await host2.exec(lines.join(`
-`), { label: `${host2.name}: start ${svc.name}/${slot}` });
+  await host.exec(lines.join(`
+`), { label: `${host.name}: start ${svc.name}/${slot}` });
   return names;
 }
-async function containerIps(host2, cfg, names) {
+async function containerIps(host, cfg, names) {
   if (!names.length)
     return {};
   const tpl = `{{ with (index .NetworkSettings.Networks ${JSON.stringify(cfg.proxy.network)}) }}{{ .IPAddress }}{{ end }}`;
-  const out = await host2.capture(names.map((n) => `echo "${n} $(docker inspect -f ${shq(tpl)} ${shq(n)} 2>/dev/null)"`).join(`
+  const out = await host.capture(names.map((n) => `echo "${n} $(docker inspect -f ${shq(tpl)} ${shq(n)} 2>/dev/null)"`).join(`
 `));
   const map = {};
   for (const line of out.split(`
@@ -2333,21 +2333,21 @@ async function containerIps(host2, cfg, names) {
   }
   return map;
 }
-async function stopSlot(host2, cfg, svc, slot, opts) {
+async function stopSlot(host, cfg, svc, slot, opts) {
   const teardown = `names=$(docker ps -a -q --filter "label=epd.app=${cfg.name}" --filter "label=epd.service=${svc.name}" --filter "label=epd.slot=${slot}")
 if [ -n "$names" ]; then
   sleep ${opts.drain}
   docker stop --timeout ${svc.stopTimeout} $names >/dev/null 2>&1 || true
   ${opts.remove ? "docker rm -f $names >/dev/null 2>&1 || true" : ""}
 fi`;
-  await host2.exec(opts.detach ? `nohup setsid bash -c ${shq(teardown)} >/dev/null 2>&1 < /dev/null &
-disown 2>/dev/null || true` : teardown, { allowFailure: true, label: `${host2.name}: stop ${svc.name}/${slot}` });
+  await host.exec(opts.detach ? `nohup setsid bash -c ${shq(teardown)} >/dev/null 2>&1 < /dev/null &
+disown 2>/dev/null || true` : teardown, { allowFailure: true, label: `${host.name}: stop ${svc.name}/${slot}` });
 }
-async function removeApp(host2, cfg) {
-  await host2.exec(`ids=$(docker ps -a -q --filter "label=epd.app=${cfg.name}")
+async function removeApp(host, cfg) {
+  await host.exec(`ids=$(docker ps -a -q --filter "label=epd.app=${cfg.name}")
 [ -n "$ids" ] && docker rm -f $ids >/dev/null 2>&1 || true`, { allowFailure: true });
 }
-async function listContainers(host2, cfg) {
+async function listContainers(host, cfg) {
   const fmt = [
     "{{.Names}}",
     '{{.Label "epd.service"}}',
@@ -2359,7 +2359,7 @@ async function listContainers(host2, cfg) {
     "{{.Image}}",
     "{{.CreatedAt}}"
   ].join("\t");
-  const out = await host2.capture(`docker ps -a --filter "label=epd.app=${cfg.name}" --format ${shq(fmt)} 2>/dev/null || true`, { allowFailure: true });
+  const out = await host.capture(`docker ps -a --filter "label=epd.app=${cfg.name}" --format ${shq(fmt)} 2>/dev/null || true`, { allowFailure: true });
   return out.split(`
 `).filter(Boolean).map((line) => {
     const [name, service, slot, version, replica, status, state, image, created] = line.split("\t");
@@ -2376,11 +2376,11 @@ async function listContainers(host2, cfg) {
     };
   });
 }
-async function startAccessory(host2, cfg, acc, env, opts) {
+async function startAccessory(host, cfg, acc, env, opts) {
   const name = accessoryContainer(cfg.name, acc.name);
   const secrets = resolveSecrets(acc.secrets, env, `accessories.${acc.name}`);
   const envFile = `${paths(cfg).app}/env.acc.${acc.name}`;
-  await host2.writeFile(envFile, envFileContent({ ...acc.env, ...secrets }), "600");
+  await host.writeFile(envFile, envFileContent({ ...acc.env, ...secrets }), "600");
   const args = [
     "docker",
     "run",
@@ -2411,12 +2411,12 @@ async function startAccessory(host2, cfg, acc, env, opts) {
   args.push(...acc.dockerOptions, acc.image);
   if (acc.command)
     args.push(...parseCommand(acc.command));
-  await host2.exec(`if docker inspect ${shq(name)} >/dev/null 2>&1; then
+  await host.exec(`if docker inspect ${shq(name)} >/dev/null 2>&1; then
   ${opts.recreate ? `docker rm -f ${shq(name)} >/dev/null` : `docker start ${shq(name)} >/dev/null 2>&1 || true; exit 0`}
 fi
 docker pull ${shq(acc.image)} >/dev/null
-${args.map((a) => shq(a)).join(" ")} >/dev/null`, { label: `${host2.name}: accessory ${acc.name}` });
-  log.host(host2.name, `accessory ${acc.name} running`);
+${args.map((a) => shq(a)).join(" ")} >/dev/null`, { label: `${host.name}: accessory ${acc.name}` });
+  log.host(host.name, `accessory ${acc.name} running`);
 }
 
 // src/deploy/process.ts
@@ -2427,34 +2427,34 @@ var pm2 = (cfg, args) => `${pathPrelude(cfg)} pm2 ${args}`;
 function releaseDir(cfg, version) {
   return `${paths(cfg).releases}/${version}`;
 }
-async function uploadSource(host2, cfg, version) {
+async function uploadSource(host, cfg, version) {
   const dest = releaseDir(cfg, version);
   const p = paths(cfg);
-  await host2.exec(`mkdir -p ${shq(p.releases)} ${shq(p.shared)}`, asUser);
+  await host.exec(`mkdir -p ${shq(p.releases)} ${shq(p.shared)}`, asUser);
   if (cfg.process.source === "git") {
     if (!existsSync4(join5(cfg.root, ".git")))
       throw new EpdError('process.source is "git" but this is not a git repository');
-    log.host(host2.name, `uploading HEAD as ${version}`);
-    await host2.pipeInto(`mkdir -p ${shq(dest)} && tar -x -C ${shq(dest)}`, ["/bin/sh", "-c", `git -C ${shq(cfg.root)} archive --format=tar HEAD`]);
+    log.host(host.name, `uploading HEAD as ${version}`);
+    await host.pipeInto(`mkdir -p ${shq(dest)} && tar -x -C ${shq(dest)}`, ["/bin/sh", "-c", `git -C ${shq(cfg.root)} archive --format=tar HEAD`]);
     return;
   }
-  const previous = await host2.capture(`ls -1dt ${shq(p.releases)}/*/ 2>/dev/null | head -n 1 || true`, { ...asUser, allowFailure: true });
+  const previous = await host.capture(`ls -1dt ${shq(p.releases)}/*/ 2>/dev/null | head -n 1 || true`, { ...asUser, allowFailure: true });
   const args = ["rsync", "-az", "--delete", "--human-readable", "--info=stats1"];
   for (const ex of cfg.process.exclude)
     args.push("--exclude", ex);
   if (previous)
     args.push("--link-dest", previous.replace(/\/$/, ""));
-  args.push("-e", host2.rsyncShell());
-  args.push(`${cfg.root.replace(/\/$/, "")}/`, `${host2.target}:${dest}/`);
-  await host2.exec(`mkdir -p ${shq(dest)}`, asUser);
-  log.host(host2.name, `uploading ${version}`);
-  await run(args, { cwd: cfg.root, label: `rsync \u2192 ${host2.name}` });
+  args.push("-e", host.rsyncShell());
+  args.push(`${cfg.root.replace(/\/$/, "")}/`, `${host.target}:${dest}/`);
+  await host.exec(`mkdir -p ${shq(dest)}`, asUser);
+  log.host(host.name, `uploading ${version}`);
+  await run(args, { cwd: cfg.root, label: `rsync \u2192 ${host.name}` });
 }
-async function buildRelease(host2, cfg, version, env) {
+async function buildRelease(host, cfg, version, env) {
   const dest = releaseDir(cfg, version);
   const secrets = resolveSecrets(cfg.secrets, env, "env.secret");
   const envFile = paths(cfg).envFile;
-  await host2.writeFile(envFile, Object.entries({ ...cfg.env, ...secrets }).map(([k, v]) => `${k}=${v}`).join(`
+  await host.writeFile(envFile, Object.entries({ ...cfg.env, ...secrets }).map(([k, v]) => `${k}=${v}`).join(`
 `), "600");
   const steps = [`cd ${shq(dest)}`, pathPrelude(cfg), `set -a; . ${shq(envFile)}; set +a`];
   if (cfg.process.install)
@@ -2462,9 +2462,9 @@ async function buildRelease(host2, cfg, version, env) {
   if (cfg.process.build)
     steps.push(cfg.process.build);
   if (steps.length > 3) {
-    log.host(host2.name, "installing and building");
-    await host2.exec(steps.join(`
-`), { ...asUser, stream: true, label: `${host2.name}: build` });
+    log.host(host.name, "installing and building");
+    await host.exec(steps.join(`
+`), { ...asUser, stream: true, label: `${host.name}: build` });
   }
 }
 function ecosystem(cfg, svc, slot, version, env) {
@@ -2502,34 +2502,34 @@ function ecosystem(cfg, svc, slot, version, env) {
   }
   return { apps };
 }
-async function startSlot2(host2, cfg, svc, slot, version, env) {
+async function startSlot2(host, cfg, svc, slot, version, env) {
   const secrets = resolveSecrets(svc.secrets, env, `servers.${svc.name}`);
   const doc = ecosystem(cfg, svc, slot, version, { ...svc.env, ...secrets });
   const file = `${paths(cfg).app}/pm2.${svc.name}.${slot}.json`;
-  await host2.writeFile(file, JSON.stringify(doc, null, 2), "600");
+  await host.writeFile(file, JSON.stringify(doc, null, 2), "600");
   const stale = Array.from({ length: 16 }, (_, i) => processName(cfg.name, svc.name, slot, i));
-  await host2.exec(`for name in ${stale.map((n) => shq(n)).join(" ")}; do ${pathPrelude(cfg)} pm2 delete "$name" >/dev/null 2>&1 || true; done
+  await host.exec(`for name in ${stale.map((n) => shq(n)).join(" ")}; do ${pathPrelude(cfg)} pm2 delete "$name" >/dev/null 2>&1 || true; done
 ${pm2(cfg, `start ${shq(file)} --update-env`)}
-${pm2(cfg, "save --force")} >/dev/null 2>&1 || true`, { ...asUser, label: `${host2.name}: pm2 start ${svc.name}/${slot}` });
+${pm2(cfg, "save --force")} >/dev/null 2>&1 || true`, { ...asUser, label: `${host.name}: pm2 start ${svc.name}/${slot}` });
 }
-async function stopSlot2(host2, cfg, svc, slot, drain, opts = {}) {
+async function stopSlot2(host, cfg, svc, slot, drain, opts = {}) {
   const names = Array.from({ length: 16 }, (_, i) => processName(cfg.name, svc.name, slot, i));
   const teardown = `sleep ${drain}
 for name in ${names.map((n) => shq(n)).join(" ")}; do
   ${pathPrelude(cfg)} pm2 delete "$name" >/dev/null 2>&1 || true
 done
 ${pm2(cfg, "save --force")} >/dev/null 2>&1 || true`;
-  await host2.exec(opts.detach ? `nohup setsid bash -c ${shq(teardown)} >/dev/null 2>&1 < /dev/null &
-disown 2>/dev/null || true` : teardown, { ...asUser, allowFailure: true, label: `${host2.name}: pm2 stop ${svc.name}/${slot}` });
+  await host.exec(opts.detach ? `nohup setsid bash -c ${shq(teardown)} >/dev/null 2>&1 < /dev/null &
+disown 2>/dev/null || true` : teardown, { ...asUser, allowFailure: true, label: `${host.name}: pm2 stop ${svc.name}/${slot}` });
 }
-async function removeApp2(host2, cfg) {
-  await host2.exec(`${pathPrelude(cfg)} pm2 jlist 2>/dev/null | tr ',' '\\n' | grep -o '"name":"epd-${cfg.name}-[^"]*"' | cut -d'"' -f4 | sort -u | while read -r n; do
+async function removeApp2(host, cfg) {
+  await host.exec(`${pathPrelude(cfg)} pm2 jlist 2>/dev/null | tr ',' '\\n' | grep -o '"name":"epd-${cfg.name}-[^"]*"' | cut -d'"' -f4 | sort -u | while read -r n; do
   ${pathPrelude(cfg)} pm2 delete "$n" >/dev/null 2>&1 || true
 done
 ${pm2(cfg, "save --force")} >/dev/null 2>&1 || true`, { ...asUser, allowFailure: true });
 }
-async function listProcesses(host2, cfg) {
-  const out = await host2.capture(`${pm2(cfg, "jlist")} 2>/dev/null || echo '[]'`, { ...asUser, allowFailure: true });
+async function listProcesses(host, cfg) {
+  const out = await host.capture(`${pm2(cfg, "jlist")} 2>/dev/null || echo '[]'`, { ...asUser, allowFailure: true });
   const jsonStart = out.indexOf("[");
   let parsed = [];
   try {
@@ -2546,9 +2546,9 @@ async function listProcesses(host2, cfg) {
     memory: p.monit?.memory ?? 0
   }));
 }
-async function finalizeRelease(host2, cfg, version) {
+async function finalizeRelease(host, cfg, version) {
   const p = paths(cfg);
-  await host2.exec(`ln -sfn ${shq(releaseDir(cfg, version))} ${shq(p.current)}.tmp && mv -Tf ${shq(p.current)}.tmp ${shq(p.current)}
+  await host.exec(`ln -sfn ${shq(releaseDir(cfg, version))} ${shq(p.current)}.tmp && mv -Tf ${shq(p.current)}.tmp ${shq(p.current)}
 ls -1dt ${shq(p.releases)}/*/ 2>/dev/null | tail -n +$(( ${cfg.keepReleases} + 1 )) | while read -r d; do
   case "$d" in *${shq(version)}*) continue;; esac
   rm -rf "$d"
@@ -2558,7 +2558,7 @@ done`, { ...asUser, allowFailure: true });
 // src/deploy/deploy.ts
 async function deploy(loaded, opts = {}) {
   const { config: cfg, env } = loaded;
-  const started2 = Date.now();
+  const started = Date.now();
   const services = selectServices(cfg, opts.onlyServices);
   const targetHosts = selectHosts(cfg, services, opts.onlyHosts);
   const hosts = targetHosts.map((h) => host(h, cfg.ssh));
@@ -2575,15 +2575,15 @@ async function deploy(loaded, opts = {}) {
     await hook(cfg, "pre_deploy", cfg.hooks.preDeploy, version);
   await withLock(cfg, hosts, `deploy ${version}`, opts.skipLock ?? false, async () => {
     log.step("Preparing servers");
-    await pool(hosts, 8, async (host2) => {
-      await verifyHost(host2, cfg);
+    await pool(hosts, 8, async (host) => {
+      await verifyHost(host, cfg);
       if (cfg.mode === "docker")
-        await ensureNetwork(host2, cfg);
+        await ensureNetwork(host, cfg);
     });
     await deployAccessories(cfg, env, opts.recreateAccessories ?? false);
     if (cfg.proxy.enabled && proxyHosts(cfg).length) {
       log.step("Checking proxy");
-      await pool(proxyHosts(cfg).filter((h) => targetHosts.includes(h)).map((h) => host(h, cfg.ssh)), 4, (host2) => ensureProxy(host2, cfg, { secrets: env }));
+      await pool(proxyHosts(cfg).filter((h) => targetHosts.includes(h)).map((h) => host(h, cfg.ssh)), 4, (host) => ensureProxy(host, cfg, { secrets: env }));
     }
     const live = new Map;
     for (const h of allHosts(cfg)) {
@@ -2593,61 +2593,61 @@ async function deploy(loaded, opts = {}) {
         m.set(svc, s.slot);
       live.set(h, m);
     }
-    const deployHost = async (host2) => {
-      await deployToHost({ cfg, env, host: host2, services, version, opts, live });
+    const deployHost = async (host) => {
+      await deployToHost({ cfg, env, host, services, version, opts, live });
     };
     if (cfg.strategy === "parallel") {
       await pool(hosts, hosts.length, deployHost);
     } else {
-      for (const host2 of hosts)
-        await deployHost(host2);
+      for (const host of hosts)
+        await deployHost(host);
     }
     if (cfg.proxy.crossHost) {
       log.step("Syncing routes across hosts");
-      await pool(proxyHosts(cfg).map((h) => host(h, cfg.ssh)), 4, async (host2) => {
-        await writeRoutes(host2, cfg, buildEndpoints(cfg, host2.name, live), buildAccessoryEndpoints(cfg, host2.name));
+      await pool(proxyHosts(cfg).map((h) => host(h, cfg.ssh)), 4, async (host) => {
+        await writeRoutes(host, cfg, buildEndpoints(cfg, host.name, live), buildAccessoryEndpoints(cfg, host.name));
       });
     }
   });
   if (!opts.skipHooks && cfg.hooks.postDeploy)
     await hook(cfg, "post_deploy", cfg.hooks.postDeploy, version);
-  log.ok(`Deployed ${cfg.name} ${version} in ${dur(Date.now() - started2)}`);
+  log.ok(`Deployed ${cfg.name} ${version} in ${dur(Date.now() - started)}`);
   printUrls(cfg);
 }
 async function deployToHost(d) {
-  const { cfg, env, host: host2, version, opts, live } = d;
-  const services = d.services.filter((s) => s.hosts.includes(host2.name));
+  const { cfg, env, host, version, opts, live } = d;
+  const services = d.services.filter((s) => s.hosts.includes(host.name));
   if (!services.length)
     return;
-  log.step(`${host2.name}: deploying ${services.map((s) => s.name).join(", ")}`);
+  log.step(`${host.name}: deploying ${services.map((s) => s.name).join(", ")}`);
   if (cfg.mode === "docker") {
-    await loginRegistry(host2, cfg, env);
-    await ensureImage(host2, cfg, version);
+    await loginRegistry(host, cfg, env);
+    await ensureImage(host, cfg, version);
   } else if (!opts.reuse) {
-    await uploadSource(host2, cfg, version);
-    await buildRelease(host2, cfg, version, env);
+    await uploadSource(host, cfg, version);
+    await buildRelease(host, cfg, version, env);
   } else {
     const dir = releaseDir(cfg, version);
-    if (!await host2.test(`[ -d ${JSON.stringify(dir)} ]`)) {
-      throw new EpdError(`${host2.name}: release ${version} is not on this server`, "Deploy it normally first.");
+    if (!await host.test(`[ -d ${JSON.stringify(dir)} ]`)) {
+      throw new EpdError(`${host.name}: release ${version} is not on this server`, "Deploy it normally first.");
     }
   }
-  const state = await readState(host2, cfg) ?? emptyState(cfg);
+  const state = await readState(host, cfg) ?? emptyState(cfg);
   const previous = new Map;
-  const started2 = [];
+  const started = [];
   try {
     for (const svc of services) {
       const current = state.services[svc.name]?.slot;
       if (current)
         previous.set(svc.name, current);
       const slot = current ? otherSlot(current) : "blue";
-      log.host(host2.name, `${svc.name}: starting ${svc.replicas} replica(s) on ${slot}`);
+      log.host(host.name, `${svc.name}: starting ${svc.replicas} replica(s) on ${slot}`);
       let probes = [];
       if (cfg.mode === "docker") {
-        const envFile = await writeServiceEnv(host2, cfg, svc, env);
-        const names = await startSlot(host2, cfg, svc, slot, version, envFile);
-        started2.push({ svc, slot });
-        const ips = usesHostPorts(cfg) ? {} : await containerIps(host2, cfg, names);
+        const envFile = await writeServiceEnv(host, cfg, svc, env);
+        const names = await startSlot(host, cfg, svc, slot, version, envFile);
+        started.push({ svc, slot });
+        const ips = usesHostPorts(cfg) ? {} : await containerIps(host, cfg, names);
         probes = names.map((name, i) => ({
           label: name,
           address: usesHostPorts(cfg) ? "127.0.0.1" : ips[name] ?? "",
@@ -2655,10 +2655,10 @@ async function deployToHost(d) {
         }));
         const noIp = probes.find((p) => !p.address);
         if (noIp)
-          throw new EpdError(`${host2.name}: ${noIp.label} did not get an IP on the ${cfg.proxy.network} network`, "Check `epd logs`.");
+          throw new EpdError(`${host.name}: ${noIp.label} did not get an IP on the ${cfg.proxy.network} network`, "Check `epd logs`.");
       } else {
-        await startSlot2(host2, cfg, svc, slot, version, env);
-        started2.push({ svc, slot });
+        await startSlot2(host, cfg, svc, slot, version, env);
+        started.push({ svc, slot });
         probes = Array.from({ length: svc.replicas }, (_, i) => ({
           label: `${svc.name}#${i}`,
           address: "127.0.0.1",
@@ -2666,52 +2666,52 @@ async function deployToHost(d) {
         }));
       }
       if (!opts.skipHealth && svc.proxied) {
-        log.host(host2.name, `${svc.name}: waiting for health check${svc.health.path ? ` ${svc.health.path}` : " (tcp)"}`);
-        await waitHealthy(host2, probes, svc.health);
-        log.host(host2.name, `${svc.name}: healthy`);
+        log.host(host.name, `${svc.name}: waiting for health check${svc.health.path ? ` ${svc.health.path}` : " (tcp)"}`);
+        await waitHealthy(host, probes, svc.health);
+        log.host(host.name, `${svc.name}: healthy`);
       } else if (!opts.skipHealth) {
-        await confirmUp(host2, cfg, svc, slot);
+        await confirmUp(host, cfg, svc, slot);
       }
-      live.get(host2.name)?.set(svc.name, slot) ?? live.set(host2.name, new Map([[svc.name, slot]]));
+      live.get(host.name)?.set(svc.name, slot) ?? live.set(host.name, new Map([[svc.name, slot]]));
       state.services[svc.name] = {
         slot,
         replicas: svc.replicas,
         version,
-        endpoints: endpointsFor(cfg, svc, slot, host2.name).map((e) => e.url)
+        endpoints: endpointsFor(cfg, svc, slot, host.name).map((e) => e.url)
       };
     }
     const hasSvcRoutes = services.some((s) => s.routes.length);
-    const hasAccRoutes = cfg.accessories.some((a) => a.routes.length && (cfg.proxy.crossHost || a.host === host2.name));
+    const hasAccRoutes = cfg.accessories.some((a) => a.routes.length && (cfg.proxy.crossHost || a.host === host.name));
     if (cfg.proxy.enabled && (hasSvcRoutes || hasAccRoutes)) {
-      await writeRoutes(host2, cfg, buildEndpoints(cfg, host2.name, live), buildAccessoryEndpoints(cfg, host2.name));
-      log.host(host2.name, "routes updated");
+      await writeRoutes(host, cfg, buildEndpoints(cfg, host.name, live), buildAccessoryEndpoints(cfg, host.name));
+      log.host(host.name, "routes updated");
     }
     for (const svc of services) {
       const old = previous.get(svc.name);
       if (!old)
         continue;
       const drain = Math.max(svc.drain, cfg.proxy.reloadWait + 2);
-      log.host(host2.name, `${svc.name}: retiring ${old} (${drain}s drain, in the background)`);
+      log.host(host.name, `${svc.name}: retiring ${old} (${drain}s drain, in the background)`);
       if (cfg.mode === "docker")
-        await stopSlot(host2, cfg, svc, old, { drain, remove: true, detach: true });
+        await stopSlot(host, cfg, svc, old, { drain, remove: true, detach: true });
       else
-        await stopSlot2(host2, cfg, svc, old, drain, { detach: true });
+        await stopSlot2(host, cfg, svc, old, drain, { detach: true });
     }
-    await writeState(host2, cfg, recordDeploy(state, version, process.env.USER ?? "epd", cfg.keepReleases));
+    await writeState(host, cfg, recordDeploy(state, version, process.env.USER ?? "epd", cfg.keepReleases));
     if (cfg.mode === "docker") {
-      await pruneImages(host2, cfg, cfg.keepReleases, [version, ...state.history.slice(0, 2).map((h) => h.version)]);
+      await pruneImages(host, cfg, cfg.keepReleases, [version, ...state.history.slice(0, 2).map((h) => h.version)]);
     } else {
-      await finalizeRelease(host2, cfg, version);
+      await finalizeRelease(host, cfg, version);
     }
-    log.host(host2.name, c.green("done"));
+    log.host(host.name, c.green("done"));
   } catch (error) {
-    log.error(`${host2.name}: deploy failed, rolling back this host`);
-    for (const { svc, slot } of started2) {
+    log.error(`${host.name}: deploy failed, rolling back this host`);
+    for (const { svc, slot } of started) {
       try {
         if (cfg.mode === "docker")
-          await stopSlot(host2, cfg, svc, slot, { drain: 0, remove: true });
+          await stopSlot(host, cfg, svc, slot, { drain: 0, remove: true });
         else
-          await stopSlot2(host2, cfg, svc, slot, 0);
+          await stopSlot2(host, cfg, svc, slot, 0);
       } catch {}
     }
     if (!d.opts.skipHooks && cfg.hooks.onFailure) {
@@ -2722,18 +2722,18 @@ async function deployToHost(d) {
     throw error;
   }
 }
-async function confirmUp(host2, cfg, svc, slot) {
+async function confirmUp(host, cfg, svc, slot) {
   if (cfg.mode === "docker") {
-    const containers = await listContainers(host2, cfg);
+    const containers = await listContainers(host, cfg);
     const bad = containers.filter((ct) => ct.service === svc.name && ct.slot === slot && !ct.running);
     if (bad.length) {
-      throw new EpdError(`${host2.name}: ${bad.map((b) => b.name).join(", ")} exited right after starting`, `Run: epd logs --service ${svc.name}`);
+      throw new EpdError(`${host.name}: ${bad.map((b) => b.name).join(", ")} exited right after starting`, `Run: epd logs --service ${svc.name}`);
     }
   } else {
-    const procs = await listProcesses(host2, cfg);
+    const procs = await listProcesses(host, cfg);
     const bad = procs.filter((p) => p.name.includes(`-${svc.name}-${slot}-`) && p.status !== "online");
     if (bad.length) {
-      throw new EpdError(`${host2.name}: ${bad.map((b) => b.name).join(", ")} is ${bad[0].status}`, `Run: epd logs --service ${svc.name}`);
+      throw new EpdError(`${host.name}: ${bad.map((b) => b.name).join(", ")} is ${bad[0].status}`, `Run: epd logs --service ${svc.name}`);
     }
   }
 }
@@ -2874,22 +2874,22 @@ Options
     log.step(`Preparing ${hosts.length} host(s) for ${c.bold(cfg.name)}`);
     if (cfg.mode === "docker")
       await requireLocal("docker", "Install Docker Desktop or the docker engine to build images.");
-    await pool(hosts, 4, async (host2) => {
-      await host2.ping();
-      log.host(host2.name, "reachable");
+    await pool(hosts, 4, async (host) => {
+      await host.ping();
+      log.host(host.name, "reachable");
       if (cfg.mode === "docker") {
-        await installDocker(host2);
-        await ensureNetwork(host2, cfg);
+        await installDocker(host);
+        await ensureNetwork(host, cfg);
       } else {
-        await installSystemPackages(host2);
-        await installProcessRuntime(host2, cfg);
+        await installSystemPackages(host);
+        await installProcessRuntime(host, cfg);
       }
-      await ensureDirs(host2, cfg);
-      await reservePorts(host2, cfg);
+      await ensureDirs(host, cfg);
+      await reservePorts(host, cfg);
     });
     if (cfg.proxy.enabled && proxyHosts(cfg).length) {
       log.step("Starting the proxy");
-      await pool(proxyHosts(cfg).filter((h) => names.includes(h)).map((h) => host(h, cfg.ssh)), 4, (host2) => ensureProxy(host2, cfg, { secrets: loaded.env, force: true }));
+      await pool(proxyHosts(cfg).filter((h) => names.includes(h)).map((h) => host(h, cfg.ssh)), 4, (host) => ensureProxy(host, cfg, { secrets: loaded.env, force: true }));
     }
     log.ok("servers are ready");
     if (ctx.values["skip-deploy"]) {
@@ -3250,12 +3250,12 @@ Examples
         const known = cfg.accessories.map((a) => a.name);
         throw new EpdError(`no such accessory "${accName}"`, known.length ? `Known: ${known.join(", ")}` : "No accessories configured.");
       }
-      const host3 = host(acc.host, cfg.ssh);
+      const host2 = host(acc.host, cfg.ssh);
       const container = accessoryContainer(cfg.name, acc.name);
-      log.info(`${host3.name}: ${container} $ ${command}`);
-      const code2 = await host3.interactive(`docker exec ${ctx.values.interactive ? "-it" : ""} ${shq(container)} ${cmdArgs}`);
-      if (code2 !== 0)
-        process.exitCode = code2;
+      log.info(`${host2.name}: ${container} $ ${command}`);
+      const code = await host2.interactive(`docker exec ${ctx.values.interactive ? "-it" : ""} ${shq(container)} ${cmdArgs}`);
+      if (code !== 0)
+        process.exitCode = code;
       return;
     }
     const host2 = await pickHost(ctx, cfg);
@@ -3270,18 +3270,18 @@ Examples
       const dir = `${paths(cfg).current}`;
       const script = `cd ${shq(dir)} && ${pathPrelude(cfg)} && set -a && . ${shq(paths(cfg).envFile)} && set +a && ${command}`;
       log.info(`${host2.name}: ${command}`);
-      const code2 = await host2.interactive(script, { sudo: false });
-      if (code2 !== 0)
-        process.exitCode = code2;
+      const code = await host2.interactive(script, { sudo: false });
+      if (code !== 0)
+        process.exitCode = code;
       return;
     }
     if (ctx.values.reuse) {
       const slot = state.services[svc.name]?.slot;
       const container = `epd-${cfg.name}-${svc.name}-${slot}-0`;
       log.info(`${host2.name}: ${container} $ ${command}`);
-      const code2 = await host2.interactive(`docker exec ${ctx.values.interactive ? "-it" : ""} ${shq(container)} ${cmdArgs}`);
-      if (code2 !== 0)
-        process.exitCode = code2;
+      const code = await host2.interactive(`docker exec ${ctx.values.interactive ? "-it" : ""} ${shq(container)} ${cmdArgs}`);
+      if (code !== 0)
+        process.exitCode = code;
       return;
     }
     const envFile = `${paths(cfg).app}/env.${svc.name}`;
@@ -3360,12 +3360,12 @@ Options
     const hosts = names.map((h) => host(h, cfg.ssh));
     switch (sub) {
       case "status": {
-        for (const host2 of hosts) {
-          const s = await proxyState(host2, cfg);
-          const listening = cfg.mode === "docker" ? await host2.capture(`docker port ${PROXY_CONTAINER} 2>/dev/null | sort -u || true`, { allowFailure: true }) : Object.entries(cfg.proxy.entrypoints).map(([n, p]) => `${n} -> :${p}`).join(`
+        for (const host of hosts) {
+          const s = await proxyState(host, cfg);
+          const listening = cfg.mode === "docker" ? await host.capture(`docker port ${PROXY_CONTAINER} 2>/dev/null | sort -u || true`, { allowFailure: true }) : Object.entries(cfg.proxy.entrypoints).map(([n, p]) => `${n} -> :${p}`).join(`
 `);
-          const apps = await host2.capture(`ls -1 ${shq(paths(cfg).proxyDynamicDir)} 2>/dev/null | sed 's/\\.yml$//' || true`, { allowFailure: true });
-          log.plain(`${c.magenta(host2.name)}  ${s.running ? c.green("running") : c.red(s.status)}  ${c.gray(s.image)}`);
+          const apps = await host.capture(`ls -1 ${shq(paths(cfg).proxyDynamicDir)} 2>/dev/null | sed 's/\\.yml$//' || true`, { allowFailure: true });
+          log.plain(`${c.magenta(host.name)}  ${s.running ? c.green("running") : c.red(s.status)}  ${c.gray(s.image)}`);
           if (listening)
             log.plain(listening.split(`
 `).map((l) => `  ${l}`).join(`
@@ -3377,8 +3377,8 @@ Options
         return;
       }
       case "reboot": {
-        await pool(hosts, 4, async (host2) => {
-          await ensureProxy(host2, cfg, { force: true, secrets: loaded.env });
+        await pool(hosts, 4, async (host) => {
+          await ensureProxy(host, cfg, { force: true, secrets: loaded.env });
         });
         log.ok("proxy restarted");
         return;
@@ -3386,40 +3386,40 @@ Options
       case "logs": {
         const lines = String(ctx.values.lines ?? "100");
         const follow = Boolean(ctx.values.follow);
-        for (const host2 of hosts) {
+        for (const host of hosts) {
           const cmd = cfg.mode === "docker" ? `docker logs ${follow ? "-f " : ""}--tail ${lines} ${PROXY_CONTAINER} 2>&1` : `${pathPrelude(cfg)} pm2 logs ${PROXY_PROCESS} --lines ${lines}${follow ? "" : " --nostream"} 2>&1`;
           if (follow) {
-            log.info(`following proxy on ${host2.name} \u2014 Ctrl-C to stop`);
-            await host2.interactive(cmd, { sudo: cfg.mode === "docker" ? undefined : false });
+            log.info(`following proxy on ${host.name} \u2014 Ctrl-C to stop`);
+            await host.interactive(cmd, { sudo: cfg.mode === "docker" ? undefined : false });
           } else {
-            const out = await host2.exec(`${cmd} || true`, { allowFailure: true, sudo: cfg.mode === "docker" ? undefined : false });
-            log.plain(c.magenta(host2.name));
+            const out = await host.exec(`${cmd} || true`, { allowFailure: true, sudo: cfg.mode === "docker" ? undefined : false });
+            log.plain(c.magenta(host.name));
             log.plain(out.stdout || c.gray("  no output"));
           }
         }
         return;
       }
       case "routes": {
-        for (const host2 of hosts) {
-          const doc = await host2.readFile(paths(cfg).proxyDynamic);
-          log.plain(c.magenta(host2.name));
+        for (const host of hosts) {
+          const doc = await host.readFile(paths(cfg).proxyDynamic);
+          log.plain(c.magenta(host.name));
           log.plain(doc ?? c.gray("  no routes written yet"));
         }
         return;
       }
       case "remove": {
-        for (const host2 of hosts) {
-          await removeRoutes(host2, cfg);
-          const left = await host2.capture(`ls -1 ${shq(paths(cfg).proxyDynamicDir)}/*.yml 2>/dev/null | wc -l`, { allowFailure: true });
+        for (const host of hosts) {
+          await removeRoutes(host, cfg);
+          const left = await host.capture(`ls -1 ${shq(paths(cfg).proxyDynamicDir)}/*.yml 2>/dev/null | wc -l`, { allowFailure: true });
           if (Number(left.trim()) === 0) {
             if (cfg.mode === "docker") {
-              await host2.exec(`docker rm -f ${PROXY_CONTAINER} >/dev/null 2>&1 || true`, { allowFailure: true });
+              await host.exec(`docker rm -f ${PROXY_CONTAINER} >/dev/null 2>&1 || true`, { allowFailure: true });
             } else {
-              await host2.exec(`${pathPrelude(cfg)} pm2 delete ${PROXY_PROCESS} >/dev/null 2>&1 || true`, { allowFailure: true, sudo: false });
+              await host.exec(`${pathPrelude(cfg)} pm2 delete ${PROXY_PROCESS} >/dev/null 2>&1 || true`, { allowFailure: true, sudo: false });
             }
-            log.host(host2.name, "routes removed, proxy stopped (no apps left)");
+            log.host(host.name, "routes removed, proxy stopped (no apps left)");
           } else {
-            log.host(host2.name, `routes removed, proxy still serving ${left.trim()} other app(s)`);
+            log.host(host.name, `routes removed, proxy still serving ${left.trim()} other app(s)`);
           }
         }
         return;
@@ -3560,8 +3560,8 @@ If a deploy was killed halfway, release it by hand.`,
     }
     if (sub !== "status")
       throw new EpdError(`unknown subcommand "${sub}"`, "Try: status, release");
-    for (const { host: host2, info } of await DeployLock.status(cfg, hosts)) {
-      log.plain(info ? `${c.magenta(host2)}  ${c.yellow("locked")} by ${info.by} ${c.gray(`${info.at} \u2014 ${info.what}`)}` : `${c.magenta(host2)}  ${c.green("free")}`);
+    for (const { host, info } of await DeployLock.status(cfg, hosts)) {
+      log.plain(info ? `${c.magenta(host)}  ${c.yellow("locked")} by ${info.by} ${c.gray(`${info.at} \u2014 ${info.what}`)}` : `${c.magenta(host)}  ${c.green("free")}`);
     }
   }
 };
@@ -3593,16 +3593,16 @@ Options
         return;
       }
     }
-    await pool(names.map((h) => host(h, cfg.ssh)), 4, async (host2) => {
-      await removeRoutes(host2, cfg);
+    await pool(names.map((h) => host(h, cfg.ssh)), 4, async (host) => {
+      await removeRoutes(host, cfg);
       if (cfg.mode === "docker")
-        await removeApp(host2, cfg);
+        await removeApp(host, cfg);
       else
-        await removeApp2(host2, cfg);
+        await removeApp2(host, cfg);
       if (!ctx.values["keep-data"]) {
-        await host2.exec(`rm -rf ${shq(paths(cfg).app)} ${shq(`${paths(cfg).portsDir}/${cfg.portBase}`)}`, { allowFailure: true });
+        await host.exec(`rm -rf ${shq(paths(cfg).app)} ${shq(`${paths(cfg).portsDir}/${cfg.portBase}`)}`, { allowFailure: true });
       }
-      log.host(host2.name, "removed");
+      log.host(host.name, "removed");
     });
     log.ok(`${cfg.name} removed from ${names.length} host(s)`);
     log.info(`the shared proxy is still running \u2014 ${c.cyan("epd proxy remove")} stops it if nothing else uses it`);
@@ -3755,7 +3755,7 @@ var commands = [
 ];
 
 // src/cli.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.1";
 var USAGE = `${c.bold("epd")} \u2014 Easy Project Deployer ${c.gray(`v${VERSION}`)}
 
 ${c.bold("Usage")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabioplunser/epd",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Easy Project Deployer — deploy any project to one or many servers with Docker or PM2, fronted by Traefik.",
   "type": "module",
   "author": "Fabio Plünser",
@@ -8,7 +8,7 @@
   "homepage": "https://github.com/FabioPlunser/epd#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/FabioPlunser/epd.git"
+    "url": "https://github.com/FabioPlunser/epd"
   },
   "bugs": {
     "url": "https://github.com/FabioPlunser/epd/issues"