@valbuild/cli 0.150.0 → 0.150.2

package/src/connect.test.ts

@@ -1,4 +1,5 @@
-import { connectUrl, getGitHubOwnerAndRepo } from "./connect";
+import path from "path";
+import { connectUrl, getGitHubOwnerAndRepo, repoFolder } from "./connect";
 
 describe("val connect", () => {
   test("opens /new on your own hosting, with the repository and the project filled in", () => {
@@ -17,6 +18,36 @@ describe("val connect", () => {
     });
   });
 
+  test("in a monorepo, the app's folder goes with the repository", () => {
+    const url = new URL(
+      connectUrl("https://admin.val.build", {
+        project: null,
+        repo: { owner: "acme", repo: "monorepo" },
+        folder: "apps/web",
+      }),
+    );
+    expect(Object.fromEntries(url.searchParams)).toEqual({
+      hosting: "own",
+      repo: "acme/monorepo",
+      folder: "apps/web",
+    });
+    // At the top of the repository there is no folder to send.
+    expect(
+      connectUrl("https://admin.val.build", {
+        project: null,
+        repo: { owner: "acme", repo: "site" },
+        folder: "",
+      }),
+    ).toBe("https://admin.val.build/new?hosting=own&repo=acme%2Fsite");
+  });
+
+  test("the folder is the app's place in its repository, with forward slashes", () => {
+    const top = path.resolve("/work/monorepo");
+    expect(repoFolder(top, path.join(top, "apps", "web"))).toBe("apps/web");
+    expect(repoFolder(top, top)).toBe("");
+    expect(repoFolder(top, path.resolve("/elsewhere"))).toBe(null);
+  });
+
   test("with nothing found, it is /new on your own hosting alone", () => {
     expect(
       connectUrl("http://localhost:3000/", { project: null, repo: null }),

package/src/connect.ts

@@ -8,17 +8,20 @@ const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
 
 /**
  * `val connect`: opens admin's `/new` on "your own hosting", with what it can
- * tell from here filled in -- the project `val.config.ts` names and the
- * GitHub repository `origin` points at -- so the person only confirms. The
- * link is printed too, for when no browser opens (over SSH, in a container).
+ * tell from here filled in -- the project `val.config.ts` names, the GitHub
+ * repository `origin` points at, and which folder of it this app is in (a
+ * monorepo has several) -- so the person only confirms. The link is printed
+ * too, for when no browser opens (over SSH, in a container).
  */
 export async function connect(options: { root?: string }) {
   const { root } = options;
   const projectRoot = root ? path.resolve(root) : process.cwd();
 
   const project = await tryGetProject(projectRoot);
-  const gitRemote = await tryGetGitRemote(projectRoot);
+  const git = findGitDir(projectRoot);
+  const gitRemote = git ? await tryGetGitRemote(git.config) : null;
   const repo = gitRemote !== null ? getGitHubOwnerAndRepo(gitRemote) : null;
+  const folder = git ? repoFolder(git.top, projectRoot) : null;
 
   console.log("");
   if (project) {
@@ -28,7 +31,7 @@ export async function connect(options: { root?: string }) {
   }
   if (repo) {
     console.log(
-      `Found ${pc.bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")`,
+      `Found ${pc.bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")${folder ? `, this app in ${pc.bold(folder)}` : ""}`,
     );
   } else {
     console.log(
@@ -38,7 +41,7 @@ export async function connect(options: { root?: string }) {
     );
   }
 
-  const url = connectUrl(host, { project, repo });
+  const url = connectUrl(host, { project, repo, folder });
   const opened = openInBrowser(url);
   console.log(
     `\n${opened ? "Finish in your browser. If it did not open, go to:" : "Finish in your browser:"}\n${pc.cyan(url)}\n`,
@@ -55,11 +58,14 @@ export function connectUrl(
   found: {
     project: { orgName: string; projectName: string } | null;
     repo: { owner: string; repo: string } | null;
+    /** The app's folder in the repository, `apps/web`; "" or null at the top. */
+    folder?: string | null;
   },
 ): string {
   const params = new URLSearchParams({ hosting: "own" });
   if (found.repo) {
     params.set("repo", `${found.repo.owner}/${found.repo.repo}`);
+    if (found.folder) params.set("folder", found.folder);
   }
   if (found.project) {
     params.set("org", found.project.orgName);
@@ -141,12 +147,19 @@ export function getGitHubOwnerAndRepo(
   return match ? { owner: match[1], repo: match[2] } : null;
 }
 
-async function tryGetGitRemote(root: string): Promise<string | null> {
+/**
+ * Where the app is in its repository, with forward slashes: `apps/web`, or ""
+ * when it is at the top. Null when it is not inside the repository at all.
+ */
+export function repoFolder(top: string, projectRoot: string): string | null {
+  const relative = path.relative(top, projectRoot);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) return null;
+  return relative.split(path.sep).join("/");
+}
+
+async function tryGetGitRemote(gitConfigPath: string): Promise<string | null> {
   try {
-    const gitConfig = tryGetGitConfig(root);
-    if (!gitConfig) {
-      return null;
-    }
+    const gitConfig = fs.readFileSync(gitConfigPath, "utf-8");
     const remoteMatch = gitConfig.match(
       /\[remote "origin"\][\s\S]*?url = (.+)/,
     );
@@ -160,13 +173,14 @@ async function tryGetGitRemote(root: string): Promise<string | null> {
   }
 }
 
-function tryGetGitConfig(root: string): string | null {
+/** The repository `root` is in: its top folder and its `.git/config`. */
+function findGitDir(root: string): { top: string; config: string } | null {
   let currentDir = root;
   let lastDir = null;
   while (currentDir !== lastDir) {
     const gitConfigPath = path.join(currentDir, ".git", "config");
     if (fs.existsSync(gitConfigPath)) {
-      return fs.readFileSync(gitConfigPath, "utf-8");
+      return { top: currentDir, config: gitConfigPath };
     }
     lastDir = currentDir;
     currentDir = path.dirname(currentDir);

package/src/publish/buildArtifacts.ts

@@ -60,6 +60,14 @@ async function loadBuilder(): Promise<
       import("@valbuild/tanstack-build"),
       import("@valbuild/tanstack-build/node"),
     ]);
+    /*
+     * Native rolldown rather than its WebAssembly build, whose glue the site's
+     * lockfile picks and can break (`rolldown.ts` in tanstack-build). Asked
+     * for, because the project's own tanstack-build may predate the choice.
+     */
+    if ("useRolldown" in build && "nativeRolldown" in node) {
+      build.useRolldown(node.nativeRolldown);
+    }
     return { status: "ok", build, node };
   } catch (e) {
     return {
@@ -74,6 +82,49 @@ async function loadBuilder(): Promise<
   }
 }
 
+/**
+ * Whether `val publish` could build here: the builder loaded as a publish
+ * loads it, and its bundler made to parse and bundle a module. Nothing is
+ * read from the project and nothing is asked of content.
+ *
+ * What Val Build runs on an upgrade's install before a connected project
+ * may publish it, since the project's CI is what builds a connected publish:
+ * an upgrade that resolved a bundler which cannot load would otherwise land
+ * on the branch and fail every build after it (architecture/quirks.md,
+ * 2026-10-26).
+ */
+export async function checkBuildTools(): Promise<
+  { status: "ok" } | { status: "error"; message: string }
+> {
+  const loaded = await loadBuilder();
+  if (loaded.status === "error") return loaded;
+  try {
+    // A builder older than `loadRolldown` loaded its bundler on import.
+    if (!("loadRolldown" in loaded.build)) return { status: "ok" };
+    const { build, parseAstAsync } = await loaded.build.loadRolldown();
+    await parseAstAsync("export const checked = true;");
+    const ENTRY = "\0val-check-build-tools";
+    await build({
+      input: ENTRY,
+      cwd: "/",
+      write: false,
+      plugins: [
+        {
+          name: "val-check-build-tools",
+          resolveId: (id) => (id === ENTRY ? id : null),
+          load: (id) => (id === ENTRY ? "export default 1;" : null),
+        },
+      ],
+    });
+    return { status: "ok" };
+  } catch (e) {
+    return {
+      status: "error",
+      message: `rolldown loaded, and could not build: ${e instanceof Error ? e.message : String(e)}`,
+    };
+  }
+}
+
 /**
  * The `@valbuild/ui` this checkout runs: the one its `@valbuild/tanstack`
  * resolves, which is a transitive dependency pnpm does not hoist -- so it is

package/src/publish.ts

@@ -22,6 +22,8 @@ export async function publish(options: {
   linksOwnCss?: boolean;
   dryRun?: boolean;
   skipValidation?: boolean;
+  /** Let a validation warning stop the publish too, as `val validate --strict`. */
+  strict?: boolean;
 }): Promise<void> {
   // Content that does not validate is not published. This is the check that
   // lets the Studio trust a connected project's published content without
@@ -32,7 +34,8 @@ export async function publish(options: {
   // the Studio leaves to the server to repair (a local image in a remote
   // project, metadata to fill in) is printed and published, as it would be
   // from the Studio. Every site made on /new starts with its template's
-  // images local, so counting those would refuse its first publish.
+  // images local, so counting those would refuse its first publish: they are
+  // warnings, and refuse a publish only under --strict.
   if (!options.skipValidation) {
     const projectRoot = options.root
       ? path.resolve(options.root)
@@ -41,6 +44,7 @@ export async function publish(options: {
       projectRoot,
       fix: false,
       blockingOnly: true,
+      ...(options.strict ? { strict: true } : {}),
     });
     if (errorCount > 0) {
       error(

package/src/runValidation.imageset.test.ts

@@ -187,6 +187,10 @@ function errorsOf(events: ValidationEvent[]) {
   );
 }
 
+function warningsOf(events: ValidationEvent[]) {
+  return events.filter((e) => e.type === "validation-warning");
+}
+
 describe("val validate with remote image and file collections", () => {
   let root: string;
 
@@ -214,22 +218,22 @@ describe("val validate with remote image and file collections", () => {
   });
 
   // What `val publish` refuses on (`validateOnce({ blockingOnly })`): a
-  // local file still to upload is the Studio's to repair, and is published;
-  // a gallery keyed by a ref it does not know is a person's to fix.
-  test("an error the Studio repairs on save is marked as such, and a person's is not", async () => {
-    const events = errorsOf(
-      await run(
-        root,
-        ["content/images.val.ts", "content/local-images.val.ts"],
-        false,
-      ),
+  // local file still to upload is a warning, and is published; a gallery
+  // keyed by a ref it does not know is a person's to fix.
+  test("a local file still to upload is a warning, and a person's error is not repaired on save", async () => {
+    const events = await run(
+      root,
+      ["content/images.val.ts", "content/local-images.val.ts"],
+      false,
     );
-    const repaired = (sourcePath: string) =>
-      events
-        .filter((e) => e.sourcePath === sourcePath)
-        .map((e) => e.repairedOnSave === true);
-    expect(repaired(`/content/images.val.ts?p="${LOGO}"`)).toEqual([true]);
-    const local = events.filter((e) =>
+    expect(warningsOf(events).map((e) => [e.sourcePath, e.files])).toEqual([
+      [`/content/images.val.ts?p="${LOGO}"`, [LOGO]],
+    ]);
+    const errors = errorsOf(events);
+    expect(
+      errors.filter((e) => e.sourcePath.startsWith("/content/images.val.ts")),
+    ).toEqual([]);
+    const local = errors.filter((e) =>
       e.sourcePath.startsWith("/content/local-images.val.ts"),
     );
     expect(local.length).toBeGreaterThan(0);
@@ -264,10 +268,10 @@ describe("val validate with remote image and file collections", () => {
       "content/page.val.ts",
     ];
     // Before: the page is valid against both collections, and the two
-    // entries are fixable.
-    expect(
-      errorsOf(await run(root, modules, false)).map((e) => e.sourcePath),
-    ).toEqual([
+    // entries are warnings: local files still to upload.
+    const before = await run(root, modules, false);
+    expect(errorsOf(before)).toEqual([]);
+    expect(warningsOf(before).map((e) => e.sourcePath)).toEqual([
       `/content/files.val.ts?p="${DOC}"`,
       `/content/images.val.ts?p="${LOGO}"`,
     ]);

package/src/runValidation.test.ts

@@ -7,6 +7,10 @@ import {
   type ModulePath,
 } from "@valbuild/core";
 import { createService } from "@valbuild/server";
+import {
+  LOCAL_FILE_IN_REMOTE_PROJECT_HINT,
+  LOCAL_FILE_IN_REMOTE_PROJECT_WARNING,
+} from "@valbuild/shared/internal";
 import {
   createDefaultValFSHost,
   runValidation,
@@ -430,32 +434,69 @@ describe("runValidation", () => {
     }
   });
 
-  test("reports upload-remote error for local entry in a remote gallery", async () => {
-    const events: ValidationEvent[] = [];
+  describe("a local entry in a remote gallery", () => {
+    const run = async (fix: boolean) => {
+      const events: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix,
+        valFiles: ["content/basic-gallery-remote.val.ts"],
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        events.push(event);
+      }
+      return events;
+    };
+    const entry = `/content/basic-gallery-remote.val.ts?p="/public/val/images-remote/image.png"`;
 
-    for await (const event of runValidation({
-      root: tmpDir,
-      fix: false,
-      valFiles: ["content/basic-gallery-remote.val.ts"],
-      project: undefined,
-      remote: mockRemote,
-      fs: createDefaultValFSHost(),
-    })) {
-      events.push(event);
-    }
+    test("is a warning, not an error: the site serves it from public/", async () => {
+      const events = await run(false);
+      expect(events.at(-1)).toEqual({ type: "summary-success" });
+      expect(events.filter((e) => e.type === "validation-warning")).toEqual([
+        {
+          type: "validation-warning",
+          sourcePath: entry,
+          message: LOCAL_FILE_IN_REMOTE_PROJECT_WARNING,
+          files: ["/public/val/images-remote/image.png"],
+          hint: LOCAL_FILE_IN_REMOTE_PROJECT_HINT,
+          keyError: true,
+        },
+      ]);
+    });
 
-    expect(events.at(-1)).toEqual({
-      type: "summary-errors",
-      count: expect.any(Number),
+    test("is an error when the file does not exist", async () => {
+      fs.rmSync(
+        path.join(tmpDir, "public", "val", "images-remote", "image.png"),
+      );
+      const events = await run(false);
+      expect(events.filter((e) => e.type === "validation-warning")).toEqual([]);
+      // The gallery's own check reports the missing file too.
+      expect(events.at(-1)).toEqual({
+        type: "summary-errors",
+        count: expect.any(Number),
+      });
+      expect(
+        events.some(
+          (e) =>
+            e.type === "validation-error" &&
+            e.sourcePath === entry &&
+            /does not exist/.test(e.message),
+        ),
+      ).toBe(true);
+    });
+
+    test("is an error under --fix when it cannot be uploaded: not logged in", async () => {
+      fs.rmSync(path.join(tmpDir, ".val", "pat.json"), { force: true });
+      const events = await run(true);
+      expect(events.filter((e) => e.type === "validation-warning")).toEqual([]);
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+      const error = events.find((e) => e.type === "validation-error");
+      expect(error && "message" in error ? error.message : "").toMatch(
+        /not logged in/,
+      );
     });
-    const errors = events.filter((e) => e.type === "validation-error");
-    expect(
-      errors.some(
-        (e) =>
-          "message" in e &&
-          (e.message as string).includes("needs to be uploaded"),
-      ),
-    ).toBe(true);
   });
 
   test("uploads local entry in a remote gallery and rewrites the key when fix is true", async () => {

package/src/runValidation.ts

@@ -276,6 +276,15 @@ export async function* runValidation({
                 yield { type: "fix-applied", file, sourcePath };
               }
 
+              if (result.warning !== undefined) {
+                yield {
+                  type: "validation-warning",
+                  sourcePath,
+                  ...result.warning,
+                  ...(v.keyError ? { keyError: true } : {}),
+                };
+              }
+
               if (result.fixableErrorMessage !== undefined) {
                 fileErrors += 1;
                 yield {

package/src/validate.test.ts

@@ -221,7 +221,7 @@ describe("validate handlers", () => {
   });
 
   describe("handleRemoteFileUpload", () => {
-    test("should return error when fix is false", () => {
+    test("should return a warning when fix is false", () => {
       const ctx: FixHandlerContext = {
         ...baseContext,
         fix: false,
@@ -232,8 +232,8 @@ describe("validate handlers", () => {
       };
 
       // Expected behavior:
-      // When fix=false, handler should return error telling user to use --fix
-      // Should return success: false with message about using --fix
+      // When fix=false and the file exists, handler should return a warning
+      // naming the file (see validate.warnings.test.ts), not an error
 
       expect(ctx.fix).toBe(false);
     });
@@ -320,7 +320,7 @@ describe("validate handlers", () => {
       expect(ctx.fix).toBe(true);
     });
 
-    test("should return error when fix is false", () => {
+    test("should return a warning when fix is false", () => {
       const ctx: FixHandlerContext = {
         ...baseContext,
         fix: false,