@vercel/container 0.0.3 → 0.0.4

package/dist/index.js

@@ -87,6 +87,17 @@ function isDockerfileRef(ref) {
   const base = (0, import_node_path.basename)(ref).toLowerCase();
   return base === "dockerfile" || base === "containerfile" || base === "dockerfile.vercel" || base === "containerfile.vercel";
 }
+var DOCKERFILE_CANDIDATES = [
+  "Dockerfile.vercel",
+  "Containerfile.vercel"
+];
+function findDockerfile(workPath) {
+  return DOCKERFILE_CANDIDATES.find((name) => (0, import_node_fs.existsSync)((0, import_node_path.join)(workPath, name)));
+}
+function devImageTag(serviceName) {
+  const safe = serviceName.toLowerCase().replace(/[^a-z0-9-_.]/g, "-");
+  return `vercel-dev/${safe || "service"}:dev`;
+}
 function run(cmd, args, opts = {}) {
   return new Promise((resolve, reject) => {
     const child = (0, import_node_child_process.spawn)(cmd, args, {
@@ -1147,10 +1158,6 @@ ${detail}` : "")
     });
   });
 }
-function devImageTag(serviceName) {
-  const safe = serviceName.toLowerCase().replace(/[^a-z0-9-_.]/g, "-");
-  return `vercel-dev/${safe || "service"}:dev`;
-}
 function normalizeCommand(command) {
   if (typeof command === "string") {
     return [command];
@@ -1163,7 +1170,7 @@ function normalizeCommand(command) {
 async function resolveDevImage(options, out, span) {
   const { config, workPath, entrypoint } = options;
   const entrypointRef = readString(entrypoint);
-  const dockerfileConfigured = entrypointRef && isDockerfileRef(entrypointRef) ? entrypointRef : void 0;
+  const dockerfileConfigured = entrypointRef && isDockerfileRef(entrypointRef) ? entrypointRef : findDockerfile(workPath);
   const dockerfileRel = dockerfileConfigured ?? "Dockerfile";
   const dockerfilePath = import_node_path4.default.join(workPath, dockerfileRel);
   const hasDockerfile = dockerfileConfigured !== void 0 || (0, import_node_fs4.existsSync)(dockerfilePath);
@@ -1242,7 +1249,67 @@ function uniqueContainerName(serviceName) {
   const safe = serviceName.toLowerCase().replace(/[^a-z0-9-_.]/g, "-");
   return `vercel-dev-${safe || "service"}-${process.pid}-${Date.now().toString(36)}`;
 }
+async function assertDockerAvailable(out) {
+  try {
+    await runForwarded(
+      "docker",
+      ["info", "--format", "{{.ServerVersion}}"],
+      out,
+      {
+        quiet: true
+      }
+    );
+  } catch (err) {
+    const message = err.message ?? "";
+    if (/command not found/i.test(message)) {
+      throw new Error(
+        "Docker is required for `vercel dev` with containers, but the `docker` command was not found. Install Docker and ensure it is on your PATH."
+      );
+    }
+    throw new Error(
+      "Could not connect to the Docker daemon. Start Docker (e.g. open Docker Desktop) and run `vercel dev` again."
+    );
+  }
+}
+function containerExitMessage(exitCode, stderr) {
+  const detail = stderr.trim().split("\n").slice(-5).join("\n");
+  const looksLikeDaemonDown = exitCode === 125 || /cannot connect to the docker daemon/i.test(stderr);
+  if (looksLikeDaemonDown) {
+    return "Could not start the container: the Docker daemon is not running or is unreachable. Start Docker (e.g. open Docker Desktop) and try `vercel dev` again." + (detail ? `
+
+Docker reported:
+${detail}` : "");
+  }
+  return `The container exited (code ${exitCode}) before becoming ready.` + (detail ? `
+
+Docker reported:
+${detail}` : "");
+}
+var runningContainers = /* @__PURE__ */ new Map();
+var pendingContainers = /* @__PURE__ */ new Map();
+function containerReuseKey(options) {
+  return options.service?.name ?? `root:${options.workPath}`;
+}
 async function startDevServer(options) {
+  const reuseKey = containerReuseKey(options);
+  const existing = runningContainers.get(reuseKey);
+  if (existing && existing.isRunning()) {
+    return existing.result;
+  }
+  if (existing) {
+    runningContainers.delete(reuseKey);
+  }
+  const inFlight = pendingContainers.get(reuseKey);
+  if (inFlight) {
+    return inFlight;
+  }
+  const startPromise = startContainer(options, reuseKey).finally(() => {
+    pendingContainers.delete(reuseKey);
+  });
+  pendingContainers.set(reuseKey, startPromise);
+  return startPromise;
+}
+async function startContainer(options, reuseKey) {
   return withSpan(
     options.span,
     "container.dev.start",
@@ -1250,6 +1317,7 @@ async function startDevServer(options) {
     async (span) => {
       const { config, meta, onStdout, onStderr } = options;
       const out = { onStdout, onStderr };
+      await assertDockerAvailable(out);
       const image = await withSpan(
         span,
         "container.dev.resolve_image",
@@ -1297,12 +1365,22 @@ async function startDevServer(options) {
       const child = (0, import_node_child_process3.spawn)("docker", args, {
         stdio: ["ignore", "pipe", "pipe"]
       });
+      let runStderr = "";
       child.stdout?.on("data", (data) => onStdout?.(data));
-      child.stderr?.on("data", (data) => onStderr?.(data));
+      child.stderr?.on("data", (data) => {
+        runStderr += data.toString();
+        onStderr?.(data);
+      });
+      child.on("error", (err) => {
+        if (err.code === "ENOENT") {
+          runStderr += "Command not found: `docker`. Ensure Docker is installed and on your PATH, and that the Docker daemon is running.";
+        }
+      });
       const cleanupEnvFile = () => {
         (0, import_node_fs4.rmSync)(import_node_path4.default.dirname(envFilePath), { recursive: true, force: true });
       };
       const shutdown = async () => {
+        runningContainers.delete(reuseKey);
         try {
           await runForwarded("docker", ["stop", containerName], out, {
             quiet: true
@@ -1321,9 +1399,7 @@ async function startDevServer(options) {
       try {
         while (Date.now() < deadline) {
           if (child.exitCode !== null) {
-            throw new Error(
-              `Container "${options.service?.name}" exited (code ${child.exitCode}) before becoming ready.`
-            );
+            throw new Error(containerExitMessage(child.exitCode, runStderr));
           }
           try {
             hostPort = await readMappedHostPort(
@@ -1339,7 +1415,7 @@ async function startDevServer(options) {
         }
         if (hostPort === void 0) {
           throw new Error(
-            `Timed out waiting for container "${options.service?.name}" to publish port ${containerPort}.` + (lastErr ? ` Last error: ${lastErr.message}` : "")
+            `Timed out waiting for container "${containerName}" to publish port ${containerPort}.` + (lastErr ? ` Last error: ${lastErr.message}` : "")
           );
         }
       } catch (err) {
@@ -1352,11 +1428,26 @@ async function startDevServer(options) {
         "container.name": containerName
       });
       emit(out, `\u25B2 container  container ready on localhost:${hostPort}`);
-      return {
+      const result = {
         port: hostPort,
         pid: child.pid ?? 0,
-        shutdown
+        shutdown,
+        // The container is a long-running server; the dev server should keep it
+        // alive across requests instead of tearing it down after each response.
+        persistent: true
       };
+      const running = {
+        result,
+        containerName,
+        isRunning: () => child.exitCode === null
+      };
+      child.on("close", () => {
+        if (runningContainers.get(reuseKey) === running) {
+          runningContainers.delete(reuseKey);
+        }
+      });
+      runningContainers.set(reuseKey, running);
+      return result;
     }
   );
 }
@@ -1400,12 +1491,6 @@ function normalizeCommand2(command) {
   }
   return void 0;
 }
-var DOCKERFILE_CANDIDATES = ["Dockerfile.vercel", "Containerfile.vercel"];
-function findDockerfile(workPath) {
-  return DOCKERFILE_CANDIDATES.find(
-    (name) => (0, import_node_fs6.existsSync)(import_node_path6.default.join(workPath, name))
-  );
-}
 function sanitizeRepository(name) {
   const sanitized = name.toLowerCase().replace(/[^a-z0-9-_./]/g, "-").replace(/-+/g, "-").replace(/(^[-/.]+)|([-/.]+$)/g, "");
   return sanitized || "service";
@@ -1589,14 +1674,12 @@ async function resolveImageHandler(options, span) {
     return prebuiltImage;
   }
   if (meta?.isDev) {
-    if (prebuiltImage) {
-      span?.setAttributes({ "container.mode": "prebuilt_dev" });
-      info(`vercel dev: using prebuilt image ${prebuiltImage}`);
-      return prebuiltImage;
-    }
-    throw new Error(
-      '`vercel dev` cannot build container images from a Dockerfile. Specify a prebuilt "image" for local development.'
+    const serviceName2 = options.service?.name;
+    const tag2 = devImageTag(
+      serviceName2 ?? import_node_path6.default.basename(dockerfileRel).split(".")[0]
     );
+    span?.setAttributes({ "container.mode": "dev", "image.tag": tag2 });
+    return tag2;
   }
   if (!(0, import_node_fs6.existsSync)(dockerfilePath)) {
     throw new Error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/container",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -15,7 +15,7 @@
   "devDependencies": {
     "@types/node": "20.11.0",
     "vitest": "2.0.3",
-    "@vercel/build-utils": "13.32.1"
+    "@vercel/build-utils": "13.32.2"
   },
   "publishConfig": {
     "access": "public"