@vercel/container 12.0.0 → 14.0.0

package/dist/index.js

@@ -62,8 +62,8 @@ async function generateProjectManifest({
 var diagnostics = (0, import_build_utils.createDiagnostics)("container");
 
 // src/index.ts
-var import_node_fs15 = require("fs");
-var import_node_path15 = __toESM(require("path"));
+var import_node_fs17 = require("fs");
+var import_node_path17 = __toESM(require("path"));
 
 // src/util.ts
 var import_build_utils2 = require("@vercel/build-utils");
@@ -88,6 +88,9 @@ function write(line) {
 function info(message) {
   write(`\u25B2 container  ${message}`);
 }
+function warn(message) {
+  write(`\u25B2 container  Warning: ${message}`);
+}
 function step(message) {
   write(`  \u2192 ${message}`);
 }
@@ -1206,9 +1209,9 @@ function selectContainerEngine() {
 }
 
 // src/buildpacks/build.ts
-var import_node_fs11 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os7 = require("os");
-var import_node_path11 = require("path");
+var import_node_path13 = require("path");
 
 // src/buildpacks/cache.ts
 var import_node_crypto2 = require("crypto");
@@ -1371,6 +1374,16 @@ var distribution_default = {
       id: "vercel/ruby",
       version: "0.3.0",
       sha256: "7ee871c18ac1616658793d3d25639d7a1f65ade618f84c6596ef9e3f515b7202"
+    },
+    go: {
+      id: "vercel/go",
+      version: "0.1.0",
+      sha256: "b605ba5f75e3873f910f1c76c14eeca5dce62f906a5d0bcee8a2b335c81d2859"
+    },
+    rust: {
+      id: "vercel/rust",
+      version: "0.1.0",
+      sha256: "4817a493cda2e30f2a1adb7f121ecb77718046d114859b4146880fb2e24fb302"
     }
   }
 };
@@ -1520,7 +1533,7 @@ async function stageWorkspace({ files, workPath }, destinationDir) {
     const resolved = import_node_path5.posix.join(import_node_path5.posix.dirname(normalized), target);
     if (resolved === ".." || resolved.startsWith("../")) {
       throw new Error(
-        `Buildpack source symlink ${name} escapes the service root. Ruby buildpack services must be self-contained.`
+        `Buildpack source symlink ${name} escapes the service root. Buildpack services must be self-contained.`
       );
     }
     staged[normalized] = new import_build_utils3.FileBlob({ data: target, mode: file.mode });
@@ -1547,7 +1560,7 @@ async function stageWorkspace({ files, workPath }, destinationDir) {
         const target = (0, import_node_path5.relative)(sourceRoot, sourceTarget).split(import_node_path5.sep).join("/");
         if (target === ".." || target.startsWith("../") || (0, import_node_path5.isAbsolute)(target) || !(target in staged)) {
           throw new Error(
-            `Buildpack source ${name} follows a symlink to an excluded or outside-root file. Ruby buildpack services must be self-contained.`
+            `Buildpack source ${name} follows a symlink to an excluded or outside-root file. Buildpack services must be self-contained.`
           );
         }
       }
@@ -2330,13 +2343,108 @@ async function resolveLocalNodeToolchain(workPath, config, meta) {
 }
 
 // src/buildpacks/registry.ts
-var import_node_fs10 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path12 = require("path");
 
-// src/buildpacks/ruby.ts
+// src/buildpacks/go.ts
 var import_node_fs9 = require("fs");
 var import_node_path9 = require("path");
+var DEFAULT_GO_VERSION = "1";
+var GO_IMAGE_REPOSITORY = "docker.io/library/golang";
+var GO_BUILD_IMAGE_DISTRO = "bookworm";
+var GO_RUN_IMAGE = "gcr.io/distroless/cc-debian12";
+var OLDEST_IMAGE_MINOR = 21;
+var GO_CANDIDATE_ENTRYPOINTS = [
+  "main.go",
+  "cmd/api/main.go",
+  "cmd/server/main.go"
+];
+var GO_TARGET_ENV = "VERCEL_GO_TARGET";
+var VERSION_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/;
+var GO_DIRECTIVE_RE = /^\s*go[ \t]+(\S+)[ \t]*(?:\/\/[^\r\n]*)?$/m;
+var TOOLCHAIN_DIRECTIVE_RE = /^\s*toolchain[ \t]+go(\S+)[ \t]*(?:\/\/[^\r\n]*)?$/m;
+function parseImageVersion(value) {
+  if (value === void 0 || !VERSION_RE.test(value))
+    return void 0;
+  const parts = value.split(".").map(Number);
+  if (!parts.every(Number.isSafeInteger))
+    return void 0;
+  if (parts[0] > 1 || parts[0] === 1 && parts[1] >= OLDEST_IMAGE_MINOR) {
+    return { tag: value, parts: [parts[0], parts[1], parts[2] ?? 0] };
+  }
+  return void 0;
+}
+function compareImageVersions(a, b) {
+  return a.parts[0] - b.parts[0] || a.parts[1] - b.parts[1] || a.parts[2] - b.parts[2];
+}
+function selectGoVersion(workPath) {
+  const goMod = (0, import_node_path9.join)(workPath, "go.mod");
+  if (!(0, import_node_fs9.existsSync)(goMod))
+    return DEFAULT_GO_VERSION;
+  const contents = (0, import_node_fs9.readFileSync)(goMod, "utf8");
+  const toolchain = parseImageVersion(
+    TOOLCHAIN_DIRECTIVE_RE.exec(contents)?.[1]
+  );
+  const minimum = parseImageVersion(GO_DIRECTIVE_RE.exec(contents)?.[1]);
+  const declared = [toolchain, minimum].filter((version2) => version2 !== void 0).sort((a, b) => compareImageVersions(b, a));
+  return declared[0]?.tag ?? DEFAULT_GO_VERSION;
+}
+function packageDirectory(entrypoint) {
+  const path4 = entrypoint.replace(/\\/g, "/");
+  if (import_node_path9.posix.isAbsolute(path4) || path4.split("/").includes("..")) {
+    throw new Error(
+      `Invalid Go entrypoint ${JSON.stringify(entrypoint)}: it must be a path inside the service root.`
+    );
+  }
+  const normalized = import_node_path9.posix.normalize(path4).replace(/\/+$/, "");
+  const directory = normalized.endsWith(".go") ? import_node_path9.posix.dirname(normalized) : normalized;
+  return directory === "." ? "." : `./${directory}`;
+}
+function selectGoTarget({
+  workPath,
+  config,
+  buildEnv
+}) {
+  const entrypoint = readString(config?.buildpackEntrypoint);
+  if (entrypoint)
+    return packageDirectory(entrypoint);
+  if (buildEnv && GO_TARGET_ENV in buildEnv)
+    return void 0;
+  const candidate = GO_CANDIDATE_ENTRYPOINTS.find(
+    (name) => (0, import_node_fs9.existsSync)((0, import_node_path9.join)(workPath, name))
+  );
+  return candidate ? packageDirectory(candidate) : void 0;
+}
+var go = {
+  runtime: "go",
+  projectMarkers: ["go.mod"],
+  buildpacks: [vercelBuildpack("go")],
+  async resolveImage(workPath) {
+    const version2 = selectGoVersion(workPath);
+    return {
+      version: version2,
+      buildImage: `${GO_IMAGE_REPOSITORY}:${version2}-${GO_BUILD_IMAGE_DISTRO}`,
+      runImage: GO_RUN_IMAGE
+    };
+  },
+  platformEnv(params) {
+    const target = selectGoTarget(params);
+    return target ? { [GO_TARGET_ENV]: target } : {};
+  }
+};
+
+// src/buildpacks/ruby.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
 var import_smol_toml2 = require("smol-toml");
+
+// src/buildpacks/version.ts
+var VERSION_RE2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/;
+function isValidVersion(version2) {
+  return VERSION_RE2.test(version2) && version2.split(".").every((n) => Number.isSafeInteger(+n));
+}
+
+// src/buildpacks/ruby.ts
 var DEFAULT_RUBY_VERSION = "3.4";
 var RUBY_IMAGE_REPOSITORY = "docker.io/library/ruby";
 var RUBY_VERSION_DOCS = "https://vercel.link/ruby-version";
@@ -2346,7 +2454,6 @@ var RUBY_VERSION_FILES = [
   "mise.toml"
 ];
 var VERSION_FILE_RE = /^ruby[\s-]*(?:=\s*)?["']?([^\s#"']+)["']?/m;
-var VERSION_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/;
 var GEMFILE_RUBY_CALL_RE = /^\s*ruby\b(?!\s*:)/;
 var GEMFILE_RUBY_LINE_RE = /^\s*ruby(?:\s*\(\s*("[^"]*"|'[^']*')\s*\)|\s*("[^"]*"|'[^']*'))\s*(?:#.*)?$/;
 var GEMFILE_RAILS_GEM_RE = /^\s*gem\s+["']rails["']/m;
@@ -2360,10 +2467,10 @@ var ruby = {
     return { version: version2, buildImage: image, runImage: image };
   },
   validate({ workPath, buildEnv }) {
-    const gemfile = (0, import_node_path9.join)(workPath, "Gemfile");
-    if (!(0, import_node_fs9.existsSync)(gemfile))
+    const gemfile = (0, import_node_path10.join)(workPath, "Gemfile");
+    if (!(0, import_node_fs10.existsSync)(gemfile))
       return;
-    if (!GEMFILE_RAILS_GEM_RE.test((0, import_node_fs9.readFileSync)(gemfile, "utf8")))
+    if (!GEMFILE_RAILS_GEM_RE.test((0, import_node_fs10.readFileSync)(gemfile, "utf8")))
       return;
     if (buildEnv?.SECRET_KEY_BASE)
       return;
@@ -2372,18 +2479,15 @@ var ruby = {
     );
   }
 };
-function isValidVersion(version2) {
-  return VERSION_RE.test(version2) && version2.split(".").every((n) => Number.isSafeInteger(+n));
-}
 function selectRubyVersion(workPath) {
   for (const name of RUBY_VERSION_FILES) {
-    const file = (0, import_node_path9.join)(workPath, name);
-    if ((0, import_node_fs9.existsSync)(file)) {
-      return parseVersionFile(name, (0, import_node_fs9.readFileSync)(file, "utf8"));
+    const file = (0, import_node_path10.join)(workPath, name);
+    if ((0, import_node_fs10.existsSync)(file)) {
+      return parseVersionFile(name, (0, import_node_fs10.readFileSync)(file, "utf8"));
     }
   }
-  const gemfile = (0, import_node_path9.join)(workPath, "Gemfile");
-  return (0, import_node_fs9.existsSync)(gemfile) ? parseGemfileRubyVersion((0, import_node_fs9.readFileSync)(gemfile, "utf8")) : void 0;
+  const gemfile = (0, import_node_path10.join)(workPath, "Gemfile");
+  return (0, import_node_fs10.existsSync)(gemfile) ? parseGemfileRubyVersion((0, import_node_fs10.readFileSync)(gemfile, "utf8")) : void 0;
 }
 function parseVersionFile(name, contents) {
   let version2;
@@ -2419,8 +2523,69 @@ function parseGemfileRubyVersion(contents) {
   return [...version2.split("."), "0"].slice(0, 3).join(".");
 }
 
+// src/buildpacks/rust.ts
+var import_node_fs11 = require("fs");
+var import_node_path11 = require("path");
+var import_smol_toml3 = require("smol-toml");
+var DEFAULT_RUST_VERSION = "1";
+var RUST_IMAGE_REPOSITORY = "docker.io/library/rust";
+var RUST_BUILD_IMAGE_DISTRO = "bookworm";
+var RUST_RUN_IMAGE = "gcr.io/distroless/cc-debian12";
+var RUST_TOOLCHAIN_FILES = ["rust-toolchain", "rust-toolchain.toml"];
+var rust = {
+  runtime: "rust",
+  projectMarkers: ["Cargo.toml"],
+  buildpacks: [vercelBuildpack("rust")],
+  async resolveImage(workPath) {
+    const version2 = selectRustVersion(workPath) ?? DEFAULT_RUST_VERSION;
+    return {
+      version: version2,
+      buildImage: `${RUST_IMAGE_REPOSITORY}:${version2}-${RUST_BUILD_IMAGE_DISTRO}`,
+      runImage: RUST_RUN_IMAGE
+    };
+  }
+};
+function selectRustVersion(workPath) {
+  for (const name of RUST_TOOLCHAIN_FILES) {
+    const file = (0, import_node_path11.join)(workPath, name);
+    if ((0, import_node_fs11.existsSync)(file)) {
+      const channel = parseToolchainFile(name, (0, import_node_fs11.readFileSync)(file, "utf8"));
+      return channel !== void 0 && isValidVersion(channel) ? channel : void 0;
+    }
+  }
+  return void 0;
+}
+function parseToolchainFile(name, contents) {
+  const legacy = name === "rust-toolchain";
+  let document;
+  try {
+    document = (0, import_smol_toml3.parse)(contents);
+  } catch (error) {
+    if (!legacy) {
+      throw new Error(`Invalid ${name}: ${error.message}`);
+    }
+  }
+  if (document === void 0 || !("toolchain" in document)) {
+    return legacy ? contents.trim() || void 0 : void 0;
+  }
+  const { toolchain } = document;
+  if (typeof toolchain !== "object" || toolchain === null) {
+    throw new Error(`Invalid ${name}: [toolchain] must be a table.`);
+  }
+  const { channel } = toolchain;
+  if (channel === void 0) {
+    return void 0;
+  }
+  if (typeof channel !== "string" || channel.trim() === "") {
+    throw new Error(
+      `Invalid ${name}: toolchain.channel must be a string such as "1.90.0" or "stable".`
+    );
+  }
+  return channel.trim();
+}
+
 // src/buildpacks/registry.ts
-var BUILDPACKS = [ruby];
+var BUILDPACKS = [ruby, go, rust];
 function requestedBuildpack(config) {
   if (!config)
     return void 0;
@@ -2428,13 +2593,13 @@ function requestedBuildpack(config) {
 }
 function hasProjectMarkers(buildpack, workPath) {
   return buildpack.projectMarkers.some(
-    (name) => (0, import_node_fs10.existsSync)((0, import_node_path10.join)(workPath, name))
+    (name) => (0, import_node_fs12.existsSync)((0, import_node_path12.join)(workPath, name))
   );
 }
 
 // src/buildpacks/build.ts
 async function buildAndPushBuildpack(params) {
-  const sourceDir = (0, import_node_fs11.mkdtempSync)((0, import_node_path11.join)((0, import_node_os7.tmpdir)(), "vercel-cnb-source-"));
+  const sourceDir = (0, import_node_fs13.mkdtempSync)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "vercel-cnb-source-"));
   try {
     step("Staging buildpack source files");
     await stageWorkspace(params, sourceDir);
@@ -2448,9 +2613,24 @@ async function buildAndPushBuildpack(params) {
       workPath: sourceDir,
       buildEnv: params.buildEnv
     });
+    const buildCommand = readString(params.config.buildCommand);
+    if (buildCommand?.trim()) {
+      warn(
+        `The build command ${JSON.stringify(buildCommand)} is not supported and will be ignored.`
+      );
+    }
     const prereleaseUrl = getPrereleaseUrl();
     const buildpack = prereleaseUrl ? await withPrereleaseBuildpack(params.buildpack, prereleaseUrl) : params.buildpack;
     const image = await buildpack.resolveImage(sourceDir);
+    const derivedEnv = buildpack.platformEnv?.({
+      workPath: sourceDir,
+      config: params.config,
+      buildEnv: params.buildEnv
+    }) ?? {};
+    for (const [key, value] of Object.entries(derivedEnv)) {
+      debug(`Passing ${key}=${value} to the ${buildpack.runtime} buildpack`);
+    }
+    const buildEnv = { ...params.buildEnv, ...derivedEnv };
     const nodeToolchain = engine.name === "buildah" ? await resolveNodeToolchain(sourceDir, params.config, params.meta) : await resolveLocalNodeToolchain(
       sourceDir,
       params.config,
@@ -2533,7 +2713,7 @@ async function buildAndPushBuildpack(params) {
               image,
               imageRef: target.imageRef,
               credentials,
-              buildEnv: params.buildEnv,
+              buildEnv,
               nodeToolchain,
               cache
             },
@@ -2551,7 +2731,7 @@ async function buildAndPushBuildpack(params) {
     );
   } finally {
     try {
-      (0, import_node_fs11.rmSync)(sourceDir, { recursive: true, force: true });
+      (0, import_node_fs13.rmSync)(sourceDir, { recursive: true, force: true });
     } catch {
       debug(`Could not remove buildpack source snapshot ${sourceDir}.`);
     }
@@ -2559,8 +2739,8 @@ async function buildAndPushBuildpack(params) {
 }
 
 // src/image-source.ts
-var import_node_fs12 = require("fs");
-var import_node_path12 = __toESM(require("path"));
+var import_node_fs14 = require("fs");
+var import_node_path14 = __toESM(require("path"));
 var DETECT_SENTINEL = "<detect>";
 function resolveImageSource(options, context) {
   const { config, workPath, entrypoint } = options;
@@ -2574,8 +2754,8 @@ function resolveImageSource(options, context) {
   }
   const dockerfileConfigured = entrypointRef && isDockerfileRef(entrypointRef) ? entrypointRef : findDockerfile(workPath);
   const dockerfileRel = dockerfileConfigured ?? "Dockerfile";
-  const dockerfilePath = import_node_path12.default.join(workPath, dockerfileRel);
-  const hasDockerfile = dockerfileConfigured !== void 0 || !buildpack && (0, import_node_fs12.existsSync)(dockerfilePath);
+  const dockerfilePath = import_node_path14.default.join(workPath, dockerfileRel);
+  const hasDockerfile = dockerfileConfigured !== void 0 || !buildpack && (0, import_node_fs14.existsSync)(dockerfilePath);
   if (hasDockerfile) {
     return { kind: "dockerfile", dockerfileRel, dockerfilePath };
   }
@@ -2593,9 +2773,9 @@ function resolveImageSource(options, context) {
 
 // src/dev.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs13 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path13 = __toESM(require("path"));
+var import_node_path15 = __toESM(require("path"));
 var HOST_ONLY_ENV = /* @__PURE__ */ new Set([
   "TMPDIR",
   "TMP",
@@ -2625,8 +2805,8 @@ function isHostOnlyEnvVar(key) {
   return HOST_ONLY_ENV.has(key) || key.startsWith("__") || key.startsWith("XPC_") || key.startsWith("SSH_") || key.startsWith("Apple");
 }
 function writeEnvFile(env) {
-  const dir = (0, import_node_fs13.mkdtempSync)(import_node_path13.default.join((0, import_node_os8.tmpdir)(), "vercel-container-dev-env-"));
-  const file = import_node_path13.default.join(dir, "env");
+  const dir = (0, import_node_fs15.mkdtempSync)(import_node_path15.default.join((0, import_node_os8.tmpdir)(), "vercel-container-dev-env-"));
+  const file = import_node_path15.default.join(dir, "env");
   const lines = [];
   for (const [key, value] of Object.entries(env)) {
     if (value.includes("\n")) {
@@ -2634,7 +2814,7 @@ function writeEnvFile(env) {
     }
     lines.push(`${key}=${value}`);
   }
-  (0, import_node_fs13.writeFileSync)(file, `${lines.join("\n")}
+  (0, import_node_fs15.writeFileSync)(file, `${lines.join("\n")}
 `);
   return file;
 }
@@ -2725,14 +2905,14 @@ async function resolveDevImage(options, out, span) {
     );
   }
   const { dockerfilePath } = source;
-  if (!(0, import_node_fs13.existsSync)(dockerfilePath)) {
+  if (!(0, import_node_fs15.existsSync)(dockerfilePath)) {
     throw new Error(
       `Dockerfile not found at "${dockerfilePath}" for container service.`
     );
   }
   const serviceName = options.service?.name ?? "service";
   const tag = devImageTag(serviceName);
-  const contextDir = import_node_path13.default.dirname(dockerfilePath);
+  const contextDir = import_node_path15.default.dirname(dockerfilePath);
   const buildArgFlags2 = [];
   const buildEnv = options.meta?.buildEnv ?? {};
   for (const [key, value] of Object.entries(buildEnv)) {
@@ -2937,7 +3117,7 @@ async function startContainer(options, reuseKey) {
         }
       });
       const cleanupEnvFile = () => {
-        (0, import_node_fs13.rmSync)(import_node_path13.default.dirname(envFilePath), { recursive: true, force: true });
+        (0, import_node_fs15.rmSync)(import_node_path15.default.dirname(envFilePath), { recursive: true, force: true });
       };
       const shutdown = async () => {
         runningContainers.delete(reuseKey);
@@ -3014,12 +3194,12 @@ async function startContainer(options, reuseKey) {
 
 // src/prepare-cache.ts
 var import_build_utils5 = require("@vercel/build-utils");
-var import_node_fs14 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path16 = require("path");
 async function prepareCache(options) {
-  const root = (0, import_node_path14.resolve)(options.repoRootPath || options.workPath);
+  const root = (0, import_node_path16.resolve)(options.repoRootPath || options.workPath);
   if (!buildpackCacheEnabled()) {
-    (0, import_node_fs14.rmSync)((0, import_node_path14.join)(root, BUILDPACK_CACHE_DIR), { recursive: true, force: true });
+    (0, import_node_fs16.rmSync)((0, import_node_path16.join)(root, BUILDPACK_CACHE_DIR), { recursive: true, force: true });
     return {};
   }
   const start = Date.now();
@@ -3244,22 +3424,22 @@ async function resolveImageHandler(options, source, span) {
   if (meta?.isDev) {
     const serviceName2 = options.service?.name;
     const tag2 = devImageTag(
-      serviceName2 ?? import_node_path15.default.basename(dockerfileRel).split(".")[0]
+      serviceName2 ?? import_node_path17.default.basename(dockerfileRel).split(".")[0]
     );
     span?.setAttributes({ "container.mode": "dev", "image.tag": tag2 });
     return tag2;
   }
-  if (!(0, import_node_fs15.existsSync)(dockerfilePath)) {
+  if (!(0, import_node_fs17.existsSync)(dockerfilePath)) {
     throw new Error(
       `Dockerfile not found at "${dockerfilePath}" for container service.`
     );
   }
   const serviceName = options.service?.name;
   const repository = sanitizeRepository(
-    serviceName ?? import_node_path15.default.basename(dockerfileRel).split(".")[0]
+    serviceName ?? import_node_path17.default.basename(dockerfileRel).split(".")[0]
   );
   const tag = resolveImageTag();
-  const contextDir = import_node_path15.default.dirname(dockerfilePath);
+  const contextDir = import_node_path17.default.dirname(dockerfilePath);
   const buildArgs = buildArgsFromEnv(meta?.buildEnv);
   span?.setAttributes({
     "container.mode": "build_and_push",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/container",
-  "version": "12.0.0",
+  "version": "14.0.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -17,12 +17,12 @@
     "tar": "7.5.11"
   },
   "peerDependencies": {
-    "@vercel/build-utils": "14.14.0"
+    "@vercel/build-utils": "14.16.0"
   },
   "devDependencies": {
     "@types/node": "20.11.0",
     "vitest": "4.1.10",
-    "@vercel/build-utils": "14.14.0"
+    "@vercel/build-utils": "14.16.0"
   },
   "publishConfig": {
     "access": "public"
@@ -31,7 +31,7 @@
     "build": "node ../../utils/build-builder.mjs",
     "type-check": "tsc --noEmit",
     "test": "vitest run --config ../../vitest.config.mts",
-    "test-unit": "vitest run --config ../../vitest.config.mts test/unit.test.ts test/diagnostics.test.ts test/workspace.test.ts test/lifecycle-docker.test.ts test/ruby-version.test.ts test/docker-push.test.ts test/cache.test.ts",
+    "test-unit": "vitest run --config ../../vitest.config.mts test/unit.test.ts test/diagnostics.test.ts test/workspace.test.ts test/lifecycle-docker.test.ts test/ruby-version.test.ts test/go-version.test.ts test/rust-version.test.ts test/docker-push.test.ts test/cache.test.ts",
     "test-e2e": "vitest run --config ../../vitest.config.mts test/e2e.test.ts"
   }
 }