@akash-chowdhury-24/deployhub 2.0.30 → 2.0.32

package/src/deployment/providers/ssh.js

@@ -1,9 +1,7 @@
-import { NodeSSH } from 'node-ssh';
-import fs from 'fs-extra';
 import path from 'path';
-import os from 'os';
 import { createLogger } from '../../logger/index.js';
 import { getEnvSettings } from '../../core/config.js';
+import { createSshExecSession } from '../ssh-connection.js';
 import {
   getNginxSitesAvailablePath,
   getNginxSitesEnabledPath,
@@ -11,7 +9,7 @@ import {
   resolveNginxSiteName,
 } from '../../utils/nginx.js';
 import { resolvePm2AppName } from '../../utils/pm2-app-name.js';
-import { shellQuote, formatRemoteCommandFailure } from '../../utils/shell-quote.js';
+import { shellQuote } from '../../utils/shell-quote.js';
 import { extractGunicornTarget } from '../../utils/python-app-target.js';
 import { resolvePhpVersion } from '../../utils/php-version.js';
 import {
@@ -64,94 +62,21 @@ export function createSshProvider(config, envName, env = process.env) {
 
   const log = createLogger('ssh');
 
-  // Defense-in-depth: never let a stuck SSH channel hang CI indefinitely.
-  // Override with DEPLOYHUB_SSH_EXEC_TIMEOUT_MS (ms). Backend start/stop uses a shorter bound.
-  const defaultExecTimeoutMs = Number(env.DEPLOYHUB_SSH_EXEC_TIMEOUT_MS) || 120_000;
+  const session = createSshExecSession({
+    host,
+    user,
+    keyPath,
+    sshKey,
+    sshPort,
+    env,
+    log,
+  });
+  const { connect, exec, defaultExecTimeoutMs } = session;
   const startStopTimeoutMs = Math.min(
     defaultExecTimeoutMs,
     Number(env.DEPLOYHUB_SSH_START_TIMEOUT_MS) || 60_000
   );
 
-  async function connect() {
-    if (!host || !user) {
-      throw new Error(
-        'SSH host and user are required. Set SSH_HOST and SSH_USER in .env (see .env.example comments).'
-      );
-    }
-
-    if (!sshKey && !keyPath) {
-      throw new Error(
-        'SSH authentication required. Set SSH_KEY_PATH (local) or SSH_KEY (CI secret) in .env — see .env.example.'
-      );
-    }
-
-    const ssh = new NodeSSH();
-    /** @type {import('node-ssh').SSHConnectOptions} */
-    const connectOpts = { host, username: user, port: sshPort };
-
-    if (sshKey) {
-      const tmpKeyPath = path.join(os.tmpdir(), 'deployhub-ssh-key');
-      await fs.writeFile(tmpKeyPath, sshKey, { mode: 0o600 });
-      connectOpts.privateKeyPath = tmpKeyPath;
-    } else if (keyPath) {
-      const expanded = keyPath.replace(/^~/, os.homedir());
-      connectOpts.privateKeyPath = path.resolve(expanded);
-    }
-
-    try {
-      await ssh.connect(connectOpts);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(
-        `SSH connection failed to ${user}@${host}:${sshPort} — ${msg}. Check SSH_HOST, SSH_USER, SSH_KEY_PATH, and that port ${sshPort} is open in your firewall/security group.`
-      );
-    }
-    return ssh;
-  }
-
-  /**
-   * @param {import('node-ssh').NodeSSH} ssh
-   * @param {string} command
-   * @param {{ timeoutMs?: number }} [opts]
-   */
-  async function exec(ssh, command, opts = {}) {
-    const timeoutMs = opts.timeoutMs ?? defaultExecTimeoutMs;
-    log.info(`$ ${command}`);
-
-    /** @type {ReturnType<typeof setTimeout> | undefined} */
-    let timer;
-    const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        reject(
-          new Error(
-            `SSH command timed out after ${timeoutMs}ms on ${user}@${host}. ` +
-              `The remote command may still be running — check the server. ` +
-              `Command: ${command.length > 240 ? `${command.slice(0, 240)}…` : command}`
-          )
-        );
-      }, timeoutMs);
-    });
-
-    let result;
-    try {
-      result = await Promise.race([ssh.execCommand(command), timeoutPromise]);
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-
-    if (result.code !== 0 && result.code !== null) {
-      const message = formatRemoteCommandFailure(
-        command,
-        result.code,
-        result.stderr,
-        result.stdout
-      );
-      log.error(message);
-      throw new Error(message);
-    }
-    return result;
-  }
-
   /**
    * Exact marker match in a null-delimited /proc file (cmdline or environ).
    * Uses grep -xF so DEPLOYHUB_APP=myapi does not match DEPLOYHUB_APP=myapi-staging.
@@ -441,8 +366,13 @@ export function createSshProvider(config, envName, env = process.env) {
 
     if (framework === 'dotnet') {
       await stopScopedBackendProcess(ssh, targetPath);
-      const dll = startCommand?.replace('dotnet ', '') || 'App.dll';
-      await startScopedNohup(ssh, targetPath, `dotnet ${dll}`);
+      // Discover the published DLL at runtime — csproj name is not always App.dll
+      // (same class of bug as the Docker CMD ["dotnet","App.dll"] hardcode).
+      await startScopedNohup(
+        ssh,
+        targetPath,
+        `sh -c 'dll=$(ls -1 *.dll 2>/dev/null | head -n1); test -n "$dll" || { echo "No .dll found in $(pwd) for .NET start" >&2; exit 1; }; exec dotnet "$dll"'`
+      );
       return;
     }
 
@@ -576,13 +506,35 @@ export function createSshProvider(config, envName, env = process.env) {
     log.success('Nginx config tested and reloaded');
   }
 
+  /**
+   * Make an existing remote directory writable by the SSH user so the next
+   * unzip/rsync is not blocked by www-data ownership from php-fpm or nginx.
+   * @param {import('node-ssh').NodeSSH} ssh
+   * @param {string} targetPath
+   */
+  async function ensureWritableDeployDir(ssh, targetPath) {
+    const targetQ = sh(targetPath);
+    const userQ = sh(user);
+    await exec(ssh, `mkdir -p ${targetQ}`);
+    await exec(
+      ssh,
+      `if [ -d ${targetQ} ]; then ` +
+        `chmod -R u+w ${targetQ} 2>/dev/null || true; ` +
+        `if [ ! -w ${targetQ} ]; then ` +
+          `sudo chown -R ${userQ}:${userQ} ${targetQ} 2>/dev/null || true; ` +
+          `chmod -R u+w ${targetQ} 2>/dev/null || true; ` +
+        `fi; ` +
+      `fi`
+    );
+  }
+
   /**
    * @param {import('node-ssh').NodeSSH} ssh
    * @param {string} remoteZip
    * @param {string} targetPath
    */
   async function extractToPath(ssh, remoteZip, targetPath) {
-    await exec(ssh, `mkdir -p ${sh(targetPath)}`);
+    await ensureWritableDeployDir(ssh, targetPath);
     await exec(ssh, `unzip -o ${sh(remoteZip)} -d ${sh(targetPath)}`);
   }
 
@@ -606,13 +558,13 @@ export function createSshProvider(config, envName, env = process.env) {
         await exec(ssh, `mkdir -p ${sh(remoteStaging)}`);
         await exec(ssh, `unzip -o ${sh(remoteZip)} -d ${sh(remoteStaging)}`);
 
-        await exec(ssh, `mkdir -p ${sh(frontendDeployPath)}`);
+        await ensureWritableDeployDir(ssh, frontendDeployPath);
         await exec(
           ssh,
           `rsync -a ${sh(remoteStaging)}/ ${sh(frontendDeployPath)}/ --exclude backend || cp -r ${sh(remoteStaging)}/* ${sh(frontendDeployPath)}/`
         );
 
-        await exec(ssh, `mkdir -p ${sh(backendDeployPath)}`);
+        await ensureWritableDeployDir(ssh, backendDeployPath);
         await exec(
           ssh,
           `rsync -a ${sh(remoteStaging)}/backend/ ${sh(backendDeployPath)}/ || cp -r ${sh(remoteStaging)}/backend/* ${sh(backendDeployPath)}/`

package/src/deployment/ssh-connection.js

@@ -0,0 +1,149 @@
+import { NodeSSH } from 'node-ssh';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { formatRemoteCommandFailure } from '../utils/shell-quote.js';
+
+/**
+ * Shared node-ssh connection + exec wrapper used by ssh.js and docker
+ * `remote.mode === "ssh"`. Do not duplicate this layer in providers.
+ *
+ * @param {{
+ *   host?: string,
+ *   user?: string,
+ *   keyPath?: string,
+ *   sshKey?: string,
+ *   sshPort?: number,
+ *   env?: Record<string, string|undefined>,
+ *   log?: { info: Function, error: Function },
+ * }} opts
+ */
+export function createSshExecSession(opts) {
+  const env = opts.env || process.env;
+  const host = opts.host;
+  const user = opts.user;
+  const sshKey = opts.sshKey || env.SSH_KEY;
+  const keyPath = opts.keyPath;
+  const sshPort = Number(opts.sshPort) || 22;
+  const log = opts.log || { info() {}, error() {} };
+
+  // Defense-in-depth: never let a stuck SSH channel hang CI indefinitely.
+  // Override with DEPLOYHUB_SSH_EXEC_TIMEOUT_MS (ms).
+  const defaultExecTimeoutMs = Number(env.DEPLOYHUB_SSH_EXEC_TIMEOUT_MS) || 120_000;
+
+  async function connect() {
+    if (!host || !user) {
+      throw new Error(
+        'SSH host and user are required. Set SSH_HOST and SSH_USER in .env (see .env.example comments).'
+      );
+    }
+
+    if (!sshKey && !keyPath) {
+      throw new Error(
+        'SSH authentication required. Set SSH_KEY_PATH (local) or SSH_KEY (CI secret) in .env — see .env.example.'
+      );
+    }
+
+    const ssh = new NodeSSH();
+    /** @type {import('node-ssh').SSHConnectOptions} */
+    const connectOpts = { host, username: user, port: sshPort };
+
+    if (sshKey) {
+      const tmpKeyPath = path.join(
+        os.tmpdir(),
+        `deployhub-ssh-key-${process.pid}-${Date.now()}`
+      );
+      await fs.writeFile(tmpKeyPath, sshKey, { mode: 0o600 });
+      connectOpts.privateKeyPath = tmpKeyPath;
+    } else if (keyPath) {
+      const expanded = keyPath.replace(/^~/, os.homedir());
+      connectOpts.privateKeyPath = path.resolve(expanded);
+    }
+
+    try {
+      await ssh.connect(connectOpts);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `SSH connection failed to ${user}@${host}:${sshPort} — ${msg}. Check SSH_HOST, SSH_USER, SSH_KEY_PATH, and that port ${sshPort} is open in your firewall/security group.`
+      );
+    }
+    return ssh;
+  }
+
+  /**
+   * @param {import('node-ssh').NodeSSH} ssh
+   * @param {string} command
+   * @param {{ timeoutMs?: number }} [execOpts]
+   */
+  async function runCommand(ssh, command, execOpts = {}) {
+    const timeoutMs = execOpts.timeoutMs ?? defaultExecTimeoutMs;
+    log.info(`$ ${command}`);
+
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new Error(
+            `SSH command timed out after ${timeoutMs}ms on ${user}@${host}. ` +
+              `The remote command may still be running — check the server. ` +
+              `Command: ${command.length > 240 ? `${command.slice(0, 240)}…` : command}`
+          )
+        );
+      }, timeoutMs);
+    });
+
+    let result;
+    try {
+      result = await Promise.race([ssh.execCommand(command), timeoutPromise]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+    return result;
+  }
+
+  /**
+   * @param {import('node-ssh').NodeSSH} ssh
+   * @param {string} command
+   * @param {{ timeoutMs?: number }} [execOpts]
+   */
+  async function exec(ssh, command, execOpts = {}) {
+    const result = await runCommand(ssh, command, execOpts);
+    if (result.code !== 0 && result.code !== null) {
+      const message = formatRemoteCommandFailure(
+        command,
+        result.code,
+        result.stderr,
+        result.stdout
+      );
+      log.error(message);
+      throw new Error(message);
+    }
+    return result;
+  }
+
+  /**
+   * Same timeout wrapper as exec(), but does not throw on non-zero exit.
+   * Used by doctor so a failed remote probe is classified, not a crash.
+   *
+   * @param {import('node-ssh').NodeSSH} ssh
+   * @param {string} command
+   * @param {{ timeoutMs?: number }} [execOpts]
+   */
+  async function execUnchecked(ssh, command, execOpts = {}) {
+    return runCommand(ssh, command, execOpts);
+  }
+
+  return {
+    connect,
+    exec,
+    execUnchecked,
+    host,
+    user,
+    sshPort,
+    defaultExecTimeoutMs,
+  };
+}
+
+export default { createSshExecSession };

package/src/detectors/frontend.detector.js

@@ -67,7 +67,7 @@ const FRAMEWORKS = {
       language: 'node',
       buildCommand: 'npm run build',
       startCommand: null,
-      buildOutput: 'public',
+      buildOutput: 'dist',
       testCommand: 'npm test',
       port: 80,
     },

package/src/utils/credential-inventory.js

@@ -197,6 +197,16 @@ export const SHARED_BY_DESIGN_DEPLOY_PAIRS = [
   },
 ];
 
+/**
+ * When docker `remote.mode === "ssh"`, the docker method also reads SSH_HOST,
+ * SSH_USER, SSH_KEY_PATH, SSH_SSH_PORT, and SSH_KEY at runtime — the same
+ * names as ssh/ec2/azure-vm/gcp-vm. Those keys are NOT in static
+ * DEPLOYMENT_ENV_KEYS.docker (local and raw docker do not use them), so they
+ * do not appear in the storage×deploy matrix. Per-environment secret prefixing
+ * already separates a docker-ssh env from a sibling ssh/ec2 env on the same
+ * config. Do not invent DOCKER_SSH_* aliases unless prefixing cannot apply.
+ */
+
 /**
  * @param {string[]} a
  * @param {string[]} b

package/src/utils/docker-image-deploy.js

@@ -29,6 +29,10 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
   const registryUrl = env.DOCKER_REGISTRY_URL || '';
   const registryUser = env.DOCKER_REGISTRY_USERNAME || '';
   const registryToken = env.DOCKER_REGISTRY_TOKEN || '';
+  // DOCKER_HOST here is only the raw CLI transport (tcp:// / ssh://).
+  // docker remote.mode "ssh" is resolved in docker.js and must not be injected
+  // into this shared helper — kubernetes.js uses the same context for build/push
+  // and has no remote SSH docker host.
   const dockerHost = env.DOCKER_HOST || '';
 
   if (tagSource === 'explicit') {

package/src/utils/docker-image.js

@@ -174,7 +174,7 @@ WORKDIR /app
 COPY ${dir}/ .
 EXPOSE ${port}
 ENV ASPNETCORE_URLS=http://+:${port}
-CMD ["dotnet", "App.dll"]
+CMD ["sh", "-c", "dll=$(ls *.dll 2>/dev/null | head -n1); exec dotnet \\"$dll\\""]
 `;
 }
 
@@ -191,7 +191,7 @@ export function isFrontendStaticFramework(framework) {
  * @param {string} framework
  */
 export function isNodeBackendFramework(framework) {
-  return ['express', 'nestjs', 'fastify', 'koa', 'nextjs'].includes(framework || '');
+  return ['express', 'nestjs', 'fastify', 'koa', 'nextjs', 'node'].includes(framework || '');
 }
 
 /**
@@ -201,7 +201,7 @@ export function isNodeBackendFramework(framework) {
  */
 export function isInterpretedBackendFramework(framework) {
   return [
-    ...['express', 'nestjs', 'fastify', 'koa', 'nextjs'],
+    ...['express', 'nestjs', 'fastify', 'koa', 'nextjs', 'node'],
     'fastapi',
     'django',
     'flask',

package/src/utils/docker-remote-mode.js

@@ -0,0 +1,33 @@
+/**
+ * Docker remote-host mode only — no node-ssh import.
+ * Keep this module free of connection code so deployment-env.js can classify
+ * env defs without loading NodeSSH (which would break jest node-ssh mocks).
+ *
+ * Kubernetes must not honor this: a Kubernetes deploy talks to the cluster via
+ * kubectl, not a remote Docker daemon.
+ */
+
+/** @typedef {'ssh'|'local'|'raw'} DockerRemoteMode */
+
+/**
+ * @param {Record<string, unknown>} [settings]
+ * @param {Record<string, string|undefined>} [env]
+ * @returns {DockerRemoteMode}
+ */
+export function resolveDockerRemoteMode(settings = {}, env = process.env) {
+  const remote = settings.remote;
+  const explicit =
+    remote && typeof remote === 'object'
+      ? /** @type {Record<string, unknown>} */ (remote).mode
+      : undefined;
+  if (explicit === 'ssh' || explicit === 'local' || explicit === 'raw') {
+    return explicit;
+  }
+  // Existing configs with a bare DOCKER_HOST keep the unmanaged CLI transport.
+  if (settings.dockerHost || env.DOCKER_HOST) {
+    return 'raw';
+  }
+  return 'local';
+}
+
+export default { resolveDockerRemoteMode };

package/src/utils/docker-remote.js

@@ -0,0 +1,214 @@
+/**
+ * Docker remote-host mode: local daemon, first-class SSH (node-ssh), or raw
+ * DOCKER_HOST (Docker CLI ssh:// / tcp:// transport).
+ *
+ * Kubernetes must not import or honor this module — a Kubernetes deploy talks
+ * to the cluster via kubectl, not a remote Docker daemon.
+ */
+
+import { shellQuote } from './shell-quote.js';
+import { createSshExecSession } from '../deployment/ssh-connection.js';
+import { resolveDockerRemoteMode } from './docker-remote-mode.js';
+
+export { resolveDockerRemoteMode };
+
+/**
+ * SSH identity for docker remote.mode === "ssh".
+ * Same env names as ec2 (SSH_HOST / SSH_USER / SSH_KEY_PATH / SSH_KEY).
+ * Per-environment prefixing already separates these from a sibling ssh/ec2 env.
+ *
+ * @param {Record<string, unknown>} settings
+ * @param {Record<string, string|undefined>} env
+ */
+export function resolveDockerSshTarget(settings, env = process.env) {
+  const host = String(settings.host || env.SSH_HOST || '');
+  const user = String(settings.user || env.SSH_USER || '');
+  const keyPath = settings.keyPath || env.SSH_KEY_PATH;
+  const sshKey = env.SSH_KEY;
+  const sshPort = Number(env.SSH_SSH_PORT || settings.sshPort) || 22;
+  return { host, user, keyPath, sshKey, sshPort };
+}
+
+/**
+ * @param {string} host
+ * @param {string} user
+ * @returns {string}
+ */
+export function formatRemoteDockerSshFailure(host, user) {
+  return (
+    `Could not reach ${host} via SSH as '${user}'. Check host,\n` +
+    `username, and key path.`
+  );
+}
+
+/**
+ * @param {string} host
+ * @param {string} user
+ * @returns {string}
+ */
+export function formatRemoteDockerNotInstalled(host, user) {
+  return (
+    `Docker is not installed on the remote host (${user}@${host}).\n` +
+    `Install Docker on the server first: https://docs.docker.com/engine/install/`
+  );
+}
+
+/**
+ * @param {string} host
+ * @param {string} user
+ * @returns {string}
+ */
+export function formatRemoteDockerPermissionDenied(host, user) {
+  return (
+    `SSH user '${user}' cannot access the Docker daemon on ${host}\n` +
+    `(permission denied).\n` +
+    `Run this on the remote server, then reconnect your SSH session:\n` +
+    `sudo usermod -aG docker ${user}`
+  );
+}
+
+/**
+ * @param {string} host
+ * @param {string} user
+ * @returns {string}
+ */
+export function formatRemoteDockerDaemonOk(host, user) {
+  return `Remote Docker daemon reachable (${user}@${host})`;
+}
+
+/**
+ * @param {{ code?: number|null, stdout?: string, stderr?: string }} result
+ * @returns {'ok'|'permission'|'not-installed'|'other'}
+ */
+export function classifyRemoteDockerPs(result) {
+  const stdout = String(result?.stdout || '');
+  const stderr = String(result?.stderr || '');
+  const combined = `${stderr}\n${stdout}`.toLowerCase();
+  const code = result?.code;
+
+  if (code === 0 || code === null) {
+    return 'ok';
+  }
+
+  if (
+    combined.includes('permission denied') ||
+    combined.includes('got permission denied while trying to connect to the docker daemon')
+  ) {
+    return 'permission';
+  }
+
+  if (
+    code === 127 ||
+    combined.includes('command not found') ||
+    /docker:\s*not found/.test(combined) ||
+    (combined.includes('no such file or directory') && combined.includes('docker'))
+  ) {
+    return 'not-installed';
+  }
+
+  return 'other';
+}
+
+/**
+ * Probe `docker ps` over the shared node-ssh session. Never throws — doctor
+ * wraps each check independently.
+ *
+ * @param {{
+ *   host: string,
+ *   user: string,
+ *   keyPath?: string,
+ *   sshKey?: string,
+ *   sshPort?: number,
+ *   env?: Record<string, string|undefined>,
+ * }} target
+ * @returns {Promise<{
+ *   sshOk: boolean,
+ *   sshError?: string,
+ *   kind?: ReturnType<typeof classifyRemoteDockerPs>,
+ *   detail?: string,
+ *   host: string,
+ *   user: string,
+ * }>}
+ */
+export async function probeRemoteDockerPs(target) {
+  const host = target.host;
+  const user = target.user;
+  if (!host || !user) {
+    return {
+      sshOk: false,
+      sshError: formatRemoteDockerSshFailure(host || '(missing host)', user || '(missing user)'),
+      host: host || '',
+      user: user || '',
+    };
+  }
+
+  const session = createSshExecSession({
+    host,
+    user,
+    keyPath: target.keyPath ? String(target.keyPath) : undefined,
+    sshKey: target.sshKey,
+    sshPort: target.sshPort,
+    env: target.env,
+  });
+
+  /** @type {import('node-ssh').NodeSSH | undefined} */
+  let ssh;
+  try {
+    ssh = await session.connect();
+    const result = await session.execUnchecked(ssh, 'docker ps');
+    const kind = classifyRemoteDockerPs(result);
+    const detail = String(result.stderr || result.stdout || '').trim();
+    return { sshOk: true, kind, detail, host, user };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      sshOk: false,
+      sshError: formatRemoteDockerSshFailure(host, user),
+      detail: msg,
+      host,
+      user,
+    };
+  } finally {
+    if (ssh) ssh.dispose();
+  }
+}
+
+/**
+ * Quoted remote docker commands (image/container/env interpolated via shellQuote).
+ * @param {string} imageRef
+ * @param {string} containerName
+ * @param {Record<string, string>} [runEnv]
+ */
+export function buildRemoteDockerCommands(imageRef, containerName, runEnv = {}) {
+  const image = shellQuote(imageRef);
+  const name = shellQuote(containerName);
+  /** @type {string[]} */
+  const envFlags = [];
+  for (const [key, value] of Object.entries(runEnv)) {
+    envFlags.push(`-e ${shellQuote(`${key}=${value}`)}`);
+  }
+  const envArg = envFlags.length > 0 ? `${envFlags.join(' ')} ` : '';
+
+  return {
+    stop: `docker stop ${name} 2>/dev/null || true`,
+    rm: `docker rm -f ${name} 2>/dev/null || true`,
+    pull: `docker pull ${image}`,
+    run: `docker run -d --rm --name ${name} ${envArg}${image}`,
+    ps: `docker ps --filter ${shellQuote(`name=^/${containerName}$`)} --format ${shellQuote('{{.Status}}')}`,
+    info: 'docker info',
+    /**
+     * @param {string} registry
+     * @param {string} username
+     * @param {string} token
+     */
+    login: (registry, username, token) =>
+      `echo ${shellQuote(token)} | docker login ${shellQuote(registry)} -u ${shellQuote(username)} --password-stdin`,
+  };
+}
+
+export default {
+  resolveDockerRemoteMode,
+  resolveDockerSshTarget,
+  probeRemoteDockerPs,
+  buildRemoteDockerCommands,
+};