openship 0.6.6 → 0.6.8

package/dist/{chunk-OBPKYXQL.js → chunk-MUWVC5R4.js}

@@ -5,38 +5,46 @@ const require = __ospCreateRequire(import.meta.url);
 import {
   checkGit,
   installGit
-} from "./chunk-A4GXYE4L.js";
+} from "./chunk-NIYD7MD2.js";
 import {
   createDockerBuildContext,
-  normalizeDockerRelativePath,
-  resolveDockerfileCandidates,
-  resolveWithinDirectory
-} from "./chunk-LUKYPVJ4.js";
+  resolveDockerBuildArgs
+} from "./chunk-6GU6JSK6.js";
 import {
   prepareStackOutput,
   resolveProjectDir,
   resolveStaticOutputPath,
   runLocalBuild
-} from "./chunk-YIMOCZBZ.js";
+} from "./chunk-5DJOB7IX.js";
 import {
   BuildLogger,
+  dockerBuildContextDirectory,
+  droppedRuntimeEnvMessage,
   injectGitToken,
+  normalizeDockerRelativePath,
+  resolveContextDockerfileCandidates,
+  resolveDockerfileCandidates,
+  resolveWithinDirectory,
   runBuildPipeline,
+  splitRuntimeEnv,
   sq,
   transferLocalDirectory
-} from "./chunk-LH2PLRQO.js";
+} from "./chunk-AHJYP7DG.js";
+import {
+  isRuntimeNotFoundError
+} from "./chunk-N5YZMO33.js";
 import {
   PRICING,
   STACKS,
   SYSTEM,
   TRANSFER_EXCLUDES,
   buildOutputTransferExcludes,
-  isRuntimeNotFoundError,
   missingOutputDirectoryMessage,
+  nodeBinPathExport,
   packageManagerEnsureCommand,
   safeErrorMessage,
   shellSplitWords
-} from "./chunk-UJ6JZM65.js";
+} from "./chunk-WEZFTL4V.js";
 
 // ../../packages/adapters/src/runtime/cloud.ts
 import { readFile } from "fs/promises";
@@ -719,9 +727,11 @@ function restartPolicyForWorkload(policy) {
   return "always";
 }
 function resolveCloudWorkloadCmd(opts) {
-  const { commandArgv, startCommand, workdir } = opts;
+  const { commandArgv, startCommand, workdir, binPathExport } = opts;
   if (commandArgv != null) return commandArgv.length > 0 ? commandArgv : void 0;
-  return startCommand ? ["sh", "-c", `cd ${sq(workdir)} && ${startCommand}`] : void 0;
+  if (!startCommand) return void 0;
+  const body = `cd ${sq(workdir)} && ${startCommand}`;
+  return ["sh", "-c", binPathExport ? `${binPathExport} && ${body}` : body];
 }
 function exposeTarget(port, serviceName, slug, domain = SYSTEM.DOMAINS.CLOUD_DOMAIN) {
   const service = `service "${serviceName}" on port ${port}`;
@@ -1320,6 +1330,14 @@ function resolveCopyDestinationPath(copy, sourcePath, destination, destinationIs
   const basename = posix.basename(sourcePath.replace(/\/+$/g, "")) || ".";
   return posix.normalize(posix.join(destination, basename));
 }
+function cloudBuildContextPath(config) {
+  return dockerBuildContextDirectory(config) || normalizeDockerRelativePath(config.rootDirectory);
+}
+function compileCloudDockerfilePlan(source, config) {
+  return compileDockerfileToWorkspacePlan(source, {
+    buildArgs: resolveDockerBuildArgs(config)
+  });
+}
 var PAGE_CONTAINER_PREFIX = "page:";
 async function provisionCloudWorkspace(client, config, logger) {
   logger?.log(`Creating workspace from image "${config.image}"...
@@ -1338,15 +1356,22 @@ async function provisionCloudWorkspace(client, config, logger) {
       }
     });
   } catch (err) {
-    logger?.log(`Failed to create workspace from image "${config.image}": ${formatCloudError(err)}
-`, "error");
+    logger?.log(
+      `Failed to create workspace from image "${config.image}": ${formatCloudError(err)}
+`,
+      "error"
+    );
     throw err;
   }
   const ws = client.workspace(wsData.id);
   try {
     if (config.mode === "temporary" && config.ttl) {
       try {
-        await ws.lifecycle.makeTemporary({ ttl: config.ttl, ttl_action: "remove", remove_on_exit: true });
+        await ws.lifecycle.makeTemporary({
+          ttl: config.ttl,
+          ttl_action: "remove",
+          remove_on_exit: true
+        });
       } catch {
       }
     }
@@ -1386,6 +1411,7 @@ var CloudRuntime = class {
   name = "cloud";
   capabilities = /* @__PURE__ */ new Set([
     "build",
+    "prebuiltImage",
     "deploy",
     "multiServiceDeploy",
     "stop",
@@ -1537,6 +1563,94 @@ var CloudRuntime = class {
     this.activeBuilds.get(sessionId)?.workspaceIds.delete(workspaceId);
   }
   // ── Build lifecycle ────────────────────────────────────────────────────
+  /**
+   * Materialize a prebuilt container image as the same opaque artifact Cloud's
+   * deploy path already understands: a temporary workspace id.
+   *
+   * Unlike a source build, no command is executed in the workspace. Creating it
+   * directly from the application image preserves the image's own ENTRYPOINT,
+   * CMD and WORKDIR; deploy keeps those defaults when `prebuiltImage` is set.
+   */
+  async prepareImage(config, logger) {
+    const log = logger ?? new BuildLogger();
+    const startedAt = Date.now();
+    const activeBuild = this.createActiveBuild(config.sessionId);
+    let workspaceId;
+    const discardWorkspace = async () => {
+      if (!workspaceId) return;
+      await this.ws(workspaceId).delete().catch(() => {
+      });
+      this.builtArtifacts.delete(workspaceId);
+      this.untrackActiveBuildWorkspace(config.sessionId, workspaceId);
+    };
+    const cancelled = async () => {
+      await discardWorkspace();
+      log.step("build", "failed", "Image preparation cancelled");
+      return {
+        sessionId: config.sessionId,
+        status: "cancelled",
+        // Keep the ref even after our best-effort delete: the pipeline can make
+        // an idempotent cleanup retry if that delete failed mid-cancellation.
+        imageRef: workspaceId,
+        durationMs: Date.now() - startedAt,
+        artifactOwned: true
+      };
+    };
+    try {
+      if (activeBuild.abort.signal.aborted) return await cancelled();
+      const imageRef = config.imageRef.trim();
+      if (!imageRef) throw new Error("Prebuilt image reference is required");
+      log.step("build", "running", `Creating workspace from prebuilt image ${imageRef}`);
+      const provisioned = await this.provisionWorkspace(
+        {
+          name: config.slug ?? `image-${config.projectId.slice(0, 20)}`,
+          image: imageRef,
+          mode: "temporary",
+          resources: config.resources,
+          env: config.envVars,
+          ttl: "15m"
+        },
+        log
+      );
+      workspaceId = provisioned.workspaceId;
+      this.trackActiveBuildWorkspace(config.sessionId, workspaceId);
+      if (activeBuild.abort.signal.aborted) return await cancelled();
+      this.builtArtifacts.set(workspaceId, {
+        workspaceId,
+        runtime: {
+          workdir: "/",
+          env: {},
+          exposedPorts: [],
+          baseImage: imageRef
+        }
+      });
+      log.step("build", "completed", `Prebuilt image workspace ${workspaceId} is ready`);
+      return {
+        sessionId: config.sessionId,
+        status: "deploying",
+        imageRef: workspaceId,
+        durationMs: Date.now() - startedAt,
+        artifactOwned: true
+      };
+    } catch (err) {
+      if (activeBuild.abort.signal.aborted) return await cancelled();
+      await discardWorkspace();
+      const message = formatCloudError(err);
+      log.step("build", "failed", `Image preparation failed: ${message}`);
+      return {
+        sessionId: config.sessionId,
+        status: "failed",
+        // Same retry contract as cancellation. Undefined means provisioning
+        // failed before Oblien handed us an owned workspace.
+        imageRef: workspaceId,
+        durationMs: Date.now() - startedAt,
+        errorMessage: `Image preparation failed: ${message}`,
+        artifactOwned: true
+      };
+    } finally {
+      this.activeBuilds.delete(config.sessionId);
+    }
+  }
   async build(config, logger) {
     const log = logger ?? new BuildLogger();
     const activeBuild = this.createActiveBuild(config.sessionId);
@@ -1595,7 +1709,9 @@ var CloudRuntime = class {
                 resolveProjectDir(buildDir, config.rootDirectory)
               );
               if (selfContained) {
-                log.log("Detected self-contained build output \u2014 uploading the bundle (no install on cloud).\n");
+                log.log(
+                  "Detected self-contained build output \u2014 uploading the bundle (no install on cloud).\n"
+                );
                 await transferLocalDirectory(
                   selfContained.bundleDir,
                   { kind: "cloud-runtime", runtime: rt, path: "/app" },
@@ -1633,7 +1749,11 @@ var CloudRuntime = class {
                 log.log("Installing production dependencies on cloud...\n");
                 const pmEnsure = packageManagerEnsureCommand(config.packageManager);
                 const fullInstall = pmEnsure ? `${pmEnsure} && ${installCmd}` : installCmd;
-                await this.execAndStream(rt, ["sh", "-c", `cd /app && ${fullInstall}`], log.callback);
+                await this.execAndStream(
+                  rt,
+                  ["sh", "-c", `cd /app && ${fullInstall}`],
+                  log.callback
+                );
               }
             }
           });
@@ -1718,7 +1838,7 @@ var CloudRuntime = class {
     try {
       log.log("Build strategy: Dockerfile plan (build in Oblien workspaces)\n");
       source = await this.resolveDockerfileBuildSource(config, log);
-      const plan = compileDockerfileToWorkspacePlan(source.dockerfile);
+      const plan = compileCloudDockerfilePlan(source.dockerfile, config);
       const blocking = plan.diagnostics.filter(
         (item) => item.severity === "error" || item.severity === "unsupported"
       );
@@ -1792,7 +1912,7 @@ var CloudRuntime = class {
       logger.log("Using Dockerfile content from source metadata.\n");
       return {
         kind: "remote",
-        contextRelativePath: normalizeDockerRelativePath(config.rootDirectory),
+        contextRelativePath: cloudBuildContextPath(config),
         dockerfile: config.dockerfileContent,
         cleanup: async () => {
         }
@@ -1807,9 +1927,9 @@ var CloudRuntime = class {
       requireRepositoryDockerfile: true,
       onLog: logger.callback
     });
-    const dockerfilePath = resolveWithinDirectory(context.contextDir, context.dockerfileName);
+    const dockerfilePath = resolveWithinDirectory(context.buildContextDir, context.dockerfileName);
     const dockerfile = await readFile(dockerfilePath, "utf-8");
-    const contextRoot = resolveWithinDirectory(context.contextDir, context.rootDirectory);
+    const contextRoot = context.contextSubdir ? context.buildContextDir : resolveWithinDirectory(context.contextDir, context.rootDirectory);
     return {
       kind: "local",
       contextRoot,
@@ -1818,7 +1938,10 @@ var CloudRuntime = class {
     };
   }
   async resolveRemoteDockerfileBuildSource(config, logger) {
-    const candidates = resolveDockerfileCandidates(config.rootDirectory, config.dockerfilePath);
+    const contextSubdir = dockerBuildContextDirectory(config);
+    const candidates = contextSubdir ? resolveContextDockerfileCandidates(contextSubdir, config.dockerfilePath).map(
+      (candidate) => `${contextSubdir}/${candidate}`
+    ) : resolveDockerfileCandidates(config.rootDirectory, config.dockerfilePath);
     const sourceLabel = config.commitSha ? `${config.branch}@${config.commitSha.slice(0, 7)}` : config.branch;
     const checkoutRef = config.commitSha ?? "FETCH_HEAD";
     const sourceDir = "/openship/dockerfile-source";
@@ -1867,11 +1990,9 @@ var CloudRuntime = class {
         logger.log(`Checking Dockerfile candidate: ${candidate}
 `);
         const dockerfile = await executor.exec(
-          [
-            `cd ${sq(sourceDir)}`,
-            `test -f ${sq(candidate)}`,
-            `cat ${sq(candidate)}`
-          ].join(" && "),
+          [`cd ${sq(sourceDir)}`, `test -f ${sq(candidate)}`, `cat ${sq(candidate)}`].join(
+            " && "
+          ),
           { timeout: 3e4 }
         ).catch(() => null);
         if (dockerfile !== null) {
@@ -1881,7 +2002,7 @@ var CloudRuntime = class {
           sourceWorkspaceId = void 0;
           return {
             kind: "remote",
-            contextRelativePath: normalizeDockerRelativePath(config.rootDirectory),
+            contextRelativePath: cloudBuildContextPath(config),
             dockerfile,
             cleanup: async () => {
               await this.ws(workspaceId).delete().catch(() => {
@@ -2063,6 +2184,25 @@ var CloudRuntime = class {
     const contextSource = contextRelativePath ? joinWorkspacePath(repoRoot, contextRelativePath) : contextRoot;
     const prepareContextCommands = contextRelativePath ? [
       `echo "Copying Dockerfile context ${contextRelativePath}..."`,
+      // `cp -a` FOLLOWS a symlinked source directory, so a repo that tracks
+      // `svc -> /` and declares `build: ./svc` would copy the workspace's root
+      // filesystem into its own build context. The lexical `..` refusal above
+      // cannot see that; only a resolved path can. Same class as
+      // GHSA-443m-7g52-94w8, reachable through the build context rather than
+      // rootDirectory, and asserted here for the same reason the docker paths
+      // assert it: at the sink.
+      // `pwd -P` rather than `readlink -f`: it is a POSIX shell builtin, so it
+      // exists in every workspace image, and it answers both questions at once —
+      // the `cd` fails when the context is not a directory, and the resolved path
+      // reveals a symlink that left the checkout.
+      // BOTH sides resolved, and an unresolvable either side is fatal: an empty
+      // `__root` would turn the prefix test into `"/"*`, which every absolute path
+      // matches — a containment check that passes vacuously is worse than none.
+      // `|| __x=""` keeps `set -e` from killing the script before the message.
+      `__root="$(cd ${sq(repoRoot)} && pwd -P)" || __root=""`,
+      `__ctx="$(cd ${sq(contextSource)} 2>/dev/null && pwd -P)" || __ctx=""`,
+      `if [ -z "$__root" ] || [ -z "$__ctx" ]; then echo "Build context ${contextRelativePath} is not a directory in this repository." >&2; exit 1; fi`,
+      `case "$__ctx/" in "$__root/"*) ;; *) echo "Build context ${contextRelativePath} resolves outside this repository." >&2; exit 1 ;; esac`,
       `mkdir -p ${sq(contextRoot)}`,
       `cp -a ${sq(`${contextSource}/.`)} ${sq(contextRoot)}/`
     ] : ['echo "Using repository root as Dockerfile context."'];
@@ -2082,8 +2222,10 @@ var CloudRuntime = class {
       ...prepareContextCommands,
       'echo "Dockerfile context prepared."'
     ].join("\n");
-    logger.log(`Preparing Dockerfile build workspace for repository clone (branch: ${config.branch})...
-`);
+    logger.log(
+      `Preparing Dockerfile build workspace for repository clone (branch: ${config.branch})...
+`
+    );
     await this.ensureWorkspaceGit(targetRuntime, logger, "Dockerfile build workspace");
     logger.log(`Cloning Dockerfile context in build workspace (branch: ${config.branch})...
 `);
@@ -2336,8 +2478,8 @@ var CloudRuntime = class {
       }
     }
     const builtArtifact = this.builtArtifacts.get(workspaceId);
-    const prodPaths = config.productionPaths;
-    const workDir = builtArtifact?.runtime.workdir ?? (prodPaths?.length ? "/app/production" : "/app");
+    const prodPaths = config.prebuiltImage ? void 0 : config.productionPaths;
+    const workDir = config.prebuiltImage ? "/" : builtArtifact?.runtime.workdir ?? (prodPaths?.length ? "/app/production" : "/app");
     if (prodPaths?.length) {
       try {
         const rt = await ws.runtime();
@@ -2384,23 +2526,48 @@ fi`;
         );
       }
     }
-    const startCommand = builtArtifact?.runtime.startCommand || config.startCommand || "npm start";
+    const startCommand = builtArtifact?.runtime.startCommand || config.startCommand || (config.prebuiltImage ? void 0 : "npm start");
+    const projectEnv = splitRuntimeEnv(config.envVars);
+    if (projectEnv.dropped.length > 0) {
+      onLog?.({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "warn",
+        message: droppedRuntimeEnvMessage(projectEnv.dropped)
+      });
+    }
     const envArray = toEnvArray2({
       ...builtArtifact?.runtime.env ?? {},
-      ...config.envVars
+      ...Object.fromEntries(projectEnv.entries)
     });
     const restartPolicy = config.restartPolicy === "no" ? "never" : config.restartPolicy ?? "always";
-    try {
-      await ws.workloads.create({
-        name: "app",
-        cmd: ["sh", "-c", `cd ${workDir} && ${startCommand}`],
-        working_dir: workDir,
-        env: [...envArray, `PORT=${config.port}`],
-        restart_policy: restartPolicy,
-        max_restarts: 10
+    const workloadCmd = resolveCloudWorkloadCmd({
+      startCommand,
+      workdir: workDir,
+      binPathExport: builtArtifact || config.prebuiltImage ? "" : nodeBinPathExport(config.packageManager, [workDir, "/app"])
+    });
+    if (workloadCmd) {
+      try {
+        if (config.prebuiltImage) {
+          await ws.workloads.delete("app").catch(() => {
+          });
+        }
+        await ws.workloads.create({
+          name: "app",
+          cmd: workloadCmd,
+          working_dir: workDir,
+          env: [...envArray, `PORT=${config.port}`],
+          restart_policy: restartPolicy,
+          max_restarts: 10
+        });
+      } catch (err) {
+        throw new Error(`Failed to create workload: ${err instanceof Error ? err.message : err}`);
+      }
+    } else {
+      log({
+        timestamp: now2(),
+        level: "info",
+        message: "Using the prebuilt image's default command and working directory.\n"
       });
-    } catch (err) {
-      throw new Error(`Failed to create workload: ${err instanceof Error ? err.message : err}`);
     }
     let url;
     const primaryEndpoint = primaryPublicEndpoint(config);
@@ -2538,7 +2705,9 @@ fi`;
         pg = result.page;
       } catch (err) {
         if (isOutputPathError(err)) throw outputDirError();
-        throw new Error(`Failed to create static page for slug "${pageSlug}": ${safeErrorMessage(err)}`);
+        throw new Error(
+          `Failed to create static page for slug "${pageSlug}": ${safeErrorMessage(err)}`
+        );
       }
       return { ...pg, url: void 0 };
     };
@@ -2553,7 +2722,9 @@ fi`;
         });
         page = result.page;
       } catch (err) {
-        throw new Error(`Failed to redeploy static page for slug "${pageSlug}": ${safeErrorMessage(err)}`);
+        throw new Error(
+          `Failed to redeploy static page for slug "${pageSlug}": ${safeErrorMessage(err)}`
+        );
       }
     } else {
       if (existingPage) {
@@ -2695,15 +2866,7 @@ fi`;
   }
   async purge(deployment) {
     if (deployment.containerId?.startsWith(PAGE_CONTAINER_PREFIX)) {
-      const slug = deployment.containerId.slice(5);
-      try {
-        if (this.adminProxy?.deletePage) {
-          await this.adminProxy.deletePage(slug);
-        } else {
-          await this.client.pages.delete(slug);
-        }
-      } catch {
-      }
+      await this.destroy(deployment.containerId);
       return;
     }
     if (!deployment.containerId) return;
@@ -2717,10 +2880,7 @@ fi`;
         err instanceof Error ? err.message : err
       );
     }
-    try {
-      await this.destroy(deployment.containerId);
-    } catch {
-    }
+    await this.destroy(deployment.containerId);
   }
   // ── Observability ──────────────────────────────────────────────────────
   async getContainerInfo(containerId) {
@@ -3183,6 +3343,7 @@ function clampShellWindow(value, fallback, min, max) {
 }
 
 export {
+  compileCloudDockerfilePlan,
   PAGE_CONTAINER_PREFIX,
   provisionCloudWorkspace,
   HostBuildForbiddenError,

package/dist/chunk-N5YZMO33.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+
+// ../../packages/adapters/src/system/errors.ts
+var SSH_AUTH_ERROR_PATTERNS = [
+  "All configured authentication methods failed"
+];
+var RETRYABLE_CONNECTION_ERROR_PATTERNS = [
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "Timed out",
+  "Not connected",
+  "Connection lost",
+  "read ECONNRESET",
+  "Handshake failed",
+  "keepalive timeout",
+  "SSH connection closed before ready",
+  // ssh2 emits "Channel open failure: open failed" / "Channel open failure: …"
+  // when the SSH SERVER refuses a new channel - typically because the cached
+  // connection has gone half-dead (peer-side LOGOUT, network blip,
+  // remote sshd MaxSessions). The inner SshExecutor retries `exec`/
+  // `streamExec` on this, but `pipeLocal`, `transferIn`, and any other
+  // channel-bearing op bubble it up. Listing it here lets `withExecutor`
+  // drop the dead connection and retry transparently - fixes the
+  // "first redeploy fails, second click works" pattern.
+  "Channel open failure",
+  "open failed"
+  // NOT "socket hang up": it is what an HTTP client reports for ANY far end that vanished
+  // mid-request, including a permission-denied Docker socket and a wedged channel, neither
+  // of which a fresh connection fixes. A match here makes `withExecutor` replay its whole
+  // callback — and those callbacks install mail, create mailboxes and ensure the edge, so a
+  // non-retryable cause becomes a repeated mutation. `core/connectivity.ts` labels it
+  // without retrying, `api/lib/remote-state.ts` still maps it to a 503, and the bridge's
+  // 502 carries the real reason — so leaving it out here costs no diagnosis.
+];
+var SshDisconnectedError = class extends Error {
+  constructor(message = "SSH connection lost") {
+    super(message);
+    this.name = "SshDisconnectedError";
+  }
+};
+function isSshDisconnectedError(err) {
+  return err instanceof SshDisconnectedError || err instanceof Error && err.name === "SshDisconnectedError";
+}
+function isSshAuthError(err) {
+  if (!(err instanceof Error)) return false;
+  return SSH_AUTH_ERROR_PATTERNS.some((pattern) => err.message.includes(pattern));
+}
+var HostChannelUnavailableError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "HostChannelUnavailableError";
+    this.code = code;
+  }
+};
+function isRetryableRemoteConnectionError(err) {
+  if (isSshDisconnectedError(err)) return true;
+  if (!(err instanceof Error)) return false;
+  return RETRYABLE_CONNECTION_ERROR_PATTERNS.some(
+    (pattern) => err.message.includes(pattern)
+  );
+}
+function isRemoteConnectionError(err) {
+  return isSshAuthError(err) || isRetryableRemoteConnectionError(err);
+}
+var MAX_COMMAND_CHARS = 120;
+function commandForError(command) {
+  const oneLine = command.trim().replace(/\s+/g, " ");
+  return oneLine.length > MAX_COMMAND_CHARS ? `${oneLine.slice(0, MAX_COMMAND_CHARS)}\u2026 (${command.length} chars)` : oneLine;
+}
+function isRuntimeNotFoundError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.statusCode === 404) return true;
+  return typeof e.message === "string" && /no such (container|image|volume|network)/i.test(e.message);
+}
+
+// ../../packages/adapters/src/system/debug.ts
+function isTruthy(value) {
+  if (!value) return false;
+  return ["1", "true", "yes", "on", "debug"].includes(value.toLowerCase());
+}
+function isSystemDebugEnabled() {
+  return isTruthy(process.env.SYSTEM_DEBUG_LOGS);
+}
+function systemDebug(scope, message) {
+  if (!isSystemDebugEnabled()) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  console.log(`[system-debug] ${timestamp} [${scope}] ${message}`);
+}
+function formatDuration(startMs) {
+  return `${Date.now() - startMs}ms`;
+}
+
+export {
+  SshDisconnectedError,
+  isSshAuthError,
+  HostChannelUnavailableError,
+  isRetryableRemoteConnectionError,
+  isRemoteConnectionError,
+  commandForError,
+  isRuntimeNotFoundError,
+  systemDebug,
+  formatDuration
+};