@valbuild/cli 0.137.0 → 0.138.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.137.0",
+  "version": "0.138.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -26,15 +26,33 @@
     "picocolors": "^1.1.1",
     "zod": "^4.4.3",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.137.0",
+    "@valbuild/core": "0.138.0",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/server": "0.137.0",
-    "@valbuild/shared": "0.137.0",
-    "@valbuild/language-server": "0.137.0"
+    "@valbuild/language-server": "0.138.0",
+    "@valbuild/server": "0.138.0",
+    "@valbuild/shared": "0.138.0"
   },
   "peerDependencies": {
     "prettier": "*",
-    "typescript": ">=5.0.0"
+    "typescript": ">=5.0.0",
+    "rolldown": ">=1.2.5",
+    "@tanstack/router-generator": ">=1.167.0",
+    "@tanstack/router-plugin": ">=1.168.0",
+    "@valbuild/tanstack-build": "^0.136.10"
+  },
+  "peerDependenciesMeta": {
+    "@valbuild/tanstack-build": {
+      "optional": true
+    },
+    "rolldown": {
+      "optional": true
+    },
+    "@tanstack/router-generator": {
+      "optional": true
+    },
+    "@tanstack/router-plugin": {
+      "optional": true
+    }
   },
   "preconstruct": {
     "entrypoints": [
@@ -47,8 +65,12 @@
   "devDependencies": {
     "@jest/globals": "^30.5.0",
     "@prettier/sync": "^0.6.1",
+    "@tanstack/router-generator": "1.167.32",
+    "@tanstack/router-plugin": "1.168.34",
     "prettier": "~3.8.5",
-    "tsx": "^4.23.12"
+    "rolldown": "^1.2.5",
+    "tsx": "^4.23.12",
+    "@valbuild/tanstack-build": "0.136.10"
   },
   "scripts": {
     "start": "tsx src/cli.ts --",

package/src/ciReport.ts

@@ -0,0 +1,39 @@
+import pc from "picocolors";
+import { ciReportFromEnv, reportCiRun } from "./publish/reportCiRun";
+
+/**
+ * `val ci-report` -- a thin shell around `reportCiRun`. It never fails the
+ * job: the build's own result is what the job's status is, and a report that
+ * could not be sent is said and then left.
+ */
+export async function ciReport(options: {
+  root?: string;
+  status?: string;
+  commit?: string;
+  branch?: string;
+  url?: string;
+}): Promise<void> {
+  const read = ciReportFromEnv({
+    status: options.status,
+    ...(options.commit ? { commit: options.commit } : {}),
+    ...(options.branch ? { branch: options.branch } : {}),
+    ...(options.url ? { url: options.url } : {}),
+  });
+  if (read.status === "error") {
+    console.error(pc.yellow(`val ci-report: ${read.message}`));
+    return;
+  }
+  const sent = await reportCiRun({
+    root: options.root ?? process.cwd(),
+    report: read.report,
+  });
+  if (sent.status === "error") {
+    console.error(pc.yellow(`val ci-report: not reported. ${sent.message}`));
+    return;
+  }
+  console.log(
+    pc.dim(
+      `Reported the build of ${read.report.commit.slice(0, 7)} as ${read.report.status}.`,
+    ),
+  );
+}

package/src/cli.ts

@@ -10,6 +10,7 @@ import { lsp } from "./lsp";
 import { debug } from "./debug";
 import { deleteUnappliablePatches } from "./deleteUnappliablePatches";
 import { publish } from "./publish";
+import { ciReport } from "./ciReport";
 
 async function main(): Promise<void> {
   const { input, flags, showHelp } = meow(
@@ -50,19 +51,35 @@ async function main(): Promise<void> {
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
 
+      Command: ci-report
+      Description: tell content how CI's build of a commit went, for a connected
+                   project's workflow. Run as its last step, whatever the build did:
+                   a failed build then reads "Published, not on the site yet" in the
+                   Studio, with a link to the run. Never fails the job.
+      Options:
+        --status [failed|succeeded]  How the build went
+        --commit [sha]           The commit built (default GITHUB_SHA)
+        --branch [name]          Its branch (default GITHUB_REF_NAME, else the project's)
+        --url [url]              The run (default this GitHub Actions run)
+
       Command: publish
-      Description: publish this project's build through content.val.build.
-        Declares the build's artifacts, uploads the ones content does not already hold,
-        and has content verify it by building and rendering a canary before the site
-        changes. Authenticates with VAL_PROJECT_TOKEN, or with the "val login" token in
-        .val/pat.json (which needs the project, as "<org>/<project>", in val.config or
-        VAL_PROJECT). Never as a flag: an argument is visible to anyone who can list
-        processes, and it is kept in shell history and in every CI log.
+      Description: build this project and publish it through content.val.build.
+        Asks content what to build against, builds the site and its dependency layer from
+        the checkout (needs @valbuild/tanstack-build, rolldown, @tanstack/router-generator
+        and @tanstack/router-plugin installed), declares the artifacts, uploads the ones
+        content does not already hold, and has content verify it by building and rendering
+        a canary before the site changes. With --artifacts, or a .val/publish directory,
+        it publishes that build instead of making one. Authenticates with VAL_PROJECT_TOKEN,
+        or with the "val login" token in .val/pat.json (which needs the project, as
+        "<org>/<project>", in val.config or VAL_PROJECT). Never as a flag: an argument is
+        visible to anyone who can list processes, and it is kept in shell history and in
+        every CI log.
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
-        --artifacts [dir]        The built artifacts (default <root>/.val/publish). The path
-                                 of each file under it is its artifact key: server, client,
-                                 css, rsc, layer, or a path under chunk/server, chunk/client,
+        --artifacts [dir]        Publish a build made elsewhere (default: build the checkout,
+                                 unless <root>/.val/publish exists). The path of each file
+                                 under it is its artifact key: server, client, css, rsc,
+                                 layer, source, or a path under chunk/server, chunk/client,
                                  chunk/rsc, asset, public
         --commit [sha]           The commit this build is of (default VAL_GIT_COMMIT,
                                  else GITHUB_SHA, else git HEAD)
@@ -173,6 +190,12 @@ async function main(): Promise<void> {
         verbose: {
           type: "boolean",
         },
+        status: {
+          type: "string",
+        },
+        url: {
+          type: "string",
+        },
       },
       hardRejection: false,
     },
@@ -221,6 +244,14 @@ async function main(): Promise<void> {
         yes: flags.yes,
         verbose: flags.verbose,
       });
+    case "ci-report":
+      return ciReport({
+        root: flags.root,
+        status: flags.status,
+        commit: flags.commit,
+        branch: flags.branch,
+        url: flags.url,
+      });
     case "publish":
       return publish({
         root: flags.root,

package/src/publish/__fixtures__/buildPublishProbe.ts

@@ -0,0 +1,226 @@
+/**
+ * `val publish` with no artifacts: builds a small file-based TanStack project
+ * from its checkout and publishes it to the fake content service, twice --
+ * once against a content service that holds no layer for the project, and
+ * once against one that holds the layer the first run built.
+ *
+ * A separate process because `@rolldown/browser` is ESM-only and jest runs
+ * CommonJS here (the same reason as @valbuild/tanstack-build's probes). The
+ * assertions stay in buildPublish.test.ts -- this only reports.
+ *
+ * The project is written to a temporary directory whose `node_modules` is
+ * this package's, so its one layered dependency resolves the way it would in
+ * a checkout after `npm install`.
+ */
+import fs from "fs";
+import os from "os";
+import path from "path";
+import zlib from "zlib";
+import {
+  FAKE_BUILD_TARGET,
+  startFakeContentService,
+  type FakeContentService,
+} from "../fakeContent";
+import { runPublish, type PublishResult } from "../runPublish";
+
+const TOKEN = "val_pt_probe";
+const COMMIT = "1234567890abcdef1234567890abcdef12345678";
+
+const PROJECT: Record<string, string> = {
+  "package.json": JSON.stringify({
+    name: "probe-site",
+    private: true,
+    type: "module",
+    dependencies: {
+      react: "^19.0.0",
+      "@tanstack/react-router": "^1.0.0",
+      "@tanstack/react-start": "^1.0.0",
+      // Not in the base set, so it has to be layered.
+      picocolors: "^1.0.0",
+    },
+  }),
+  "src/router.tsx": `import { createRouter } from "@tanstack/react-router";
+import { routeTree } from "./routeTree.gen";
+export function getRouter() {
+  return createRouter({ routeTree });
+}
+`,
+  "src/routes/__root.tsx": `import { Outlet, createRootRoute } from "@tanstack/react-router";
+import "../styles.css";
+export const Route = createRootRoute({ component: () => <Outlet /> });
+`,
+  "src/routes/index.tsx": `import { createFileRoute } from "@tanstack/react-router";
+import pc from "picocolors";
+import logo from "../logo.png";
+export const Route = createFileRoute("/")({
+  component: () => (
+    <h1>
+      <img src={logo} alt="" />
+      {pc.bold("hello from the checkout")}
+    </h1>
+  ),
+});
+`,
+  // A route in a folder called "build": the project's, not a build's output.
+  "src/routes/build/index.tsx": `import { createFileRoute } from "@tanstack/react-router";
+export const Route = createFileRoute("/build/")({
+  component: () => <p>the build page</p>,
+});
+`,
+  "src/styles.css": `h1 { color: rebeccapurple; }\n`,
+  "public/robots.txt": "User-agent: *\n",
+};
+
+type Report = {
+  result: PublishResult;
+  declared: Array<{
+    buildHash: string;
+    commit: string | null;
+    branch: string | null;
+    layerRev: string | null;
+    linksOwnCss: boolean | null;
+    keys: string[];
+  }>;
+  buildTargetCalls: number;
+  /** The rev inside the layer artifact, when one was uploaded. */
+  uploadedLayerRev: string | null;
+  /** Whether the source artifact holds the project's own route file. */
+  sourceHasRoute: boolean;
+  /** Whether the client build carries the page's text. */
+  clientHasPage: boolean;
+  /** Whether the imported image reached the build, inlined. */
+  clientHasLogo: boolean;
+  /** Whether the route in `src/routes/build/` was built and stored. */
+  buildRouteBuilt: boolean;
+  /** Whether the checkout was left exactly as it was found. */
+  checkoutUntouched: boolean;
+};
+
+/** A 1x1 PNG: small enough to inline, so the page carries it as a data URI. */
+const LOGO = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==",
+  "base64",
+);
+
+function writeProject(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "val-publish-probe-"));
+  for (const [key, text] of Object.entries(PROJECT)) {
+    const file = path.join(root, ...key.split("/"));
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text);
+  }
+  fs.writeFileSync(path.join(root, "src", "logo.png"), LOGO);
+  fs.symlinkSync(
+    path.join(__dirname, "..", "..", "..", "node_modules"),
+    path.join(root, "node_modules"),
+    "dir",
+  );
+  return root;
+}
+
+function listed(root: string): string[] {
+  const out: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === "node_modules") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else out.push(path.relative(root, full));
+    }
+  };
+  walk(root);
+  return out.sort();
+}
+
+async function publishOnce(
+  root: string,
+  fake: FakeContentService,
+): Promise<Report> {
+  const before = listed(root);
+  const result = await runPublish({
+    root,
+    commit: COMMIT,
+    branch: "main",
+    env: { VAL_PROJECT_TOKEN: TOKEN, VAL_CONTENT_URL: fake.url },
+    sleep: () => Promise.resolve(),
+    log: () => undefined,
+  });
+  const declared = [...fake.declarations.values()].map((body) => {
+    const d = body as {
+      buildHash: string;
+      commit: string | null;
+      branch: string | null;
+      layerRev: string | null;
+      linksOwnCss: boolean | null;
+      artifacts: Array<{ key: string }>;
+    };
+    return {
+      buildHash: d.buildHash,
+      commit: d.commit,
+      branch: d.branch,
+      layerRev: d.layerRev,
+      linksOwnCss: d.linksOwnCss,
+      keys: d.artifacts.map((a) => a.key).sort(),
+    };
+  });
+  const layer = fake.stored.get("layer");
+  const source = fake.stored.get("source");
+  // The route is split off, so its text is in a client chunk.
+  const clientText = [...fake.stored.entries()]
+    .filter(([key]) => key === "client" || key.startsWith("chunk/client/"))
+    .map(([, body]) => body.toString("utf8"))
+    .join("\n");
+  return {
+    result,
+    declared,
+    buildTargetCalls: fake.calls.filter((c) => c.path === "/v1/build-target")
+      .length,
+    uploadedLayerRev: layer
+      ? (JSON.parse(zlib.gunzipSync(layer).toString("utf8")) as { rev: string })
+          .rev
+      : null,
+    sourceHasRoute: source
+      ? "src/routes/index.tsx" in
+        (JSON.parse(source.toString("utf8")) as Record<string, string>)
+      : false,
+    clientHasPage: clientText.includes("hello from the checkout"),
+    clientHasLogo: clientText.includes(
+      `data:image/png;base64,${LOGO.toString("base64")}`,
+    ),
+    buildRouteBuilt:
+      clientText.includes("the build page") &&
+      (source
+        ? "src/routes/build/index.tsx" in
+          (JSON.parse(source.toString("utf8")) as Record<string, string>)
+        : false),
+    checkoutUntouched: JSON.stringify(listed(root)) === JSON.stringify(before),
+  };
+}
+
+(async () => {
+  const root = writeProject();
+  try {
+    const first = await startFakeContentService({ token: TOKEN });
+    const fresh = await publishOnce(root, first).finally(() => first.close());
+
+    // Content now holds the layer the first run sent, so the second names it.
+    const second = await startFakeContentService({
+      token: TOKEN,
+      buildTarget: {
+        ...FAKE_BUILD_TARGET,
+        project: {
+          ...FAKE_BUILD_TARGET.project,
+          rev: fresh.uploadedLayerRev,
+        },
+      },
+    });
+    const held = await publishOnce(root, second).finally(() => second.close());
+
+    process.stdout.write(`${JSON.stringify({ fresh, held })}\n`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+})().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.stack : error}\n`);
+  process.exit(1);
+});

package/src/publish/artifacts.ts

@@ -31,10 +31,10 @@ export type CollectedArtifacts = {
  * imports it at, so a normalised name produces a bundle whose imports resolve
  * to nothing, at runtime, in the isolate.
  *
- * **This is the seam with the build.** `val publish` uploads artifacts; it does
- * not produce them. Whatever builds the project - today the platform's own
- * builder, which is where the wire, rolldown and dependency-layer steps live -
- * writes this directory, and this reads it.
+ * **This is the seam with the build.** Whatever built the project writes this
+ * directory, and this reads it: `buildArtifacts` when `val publish` builds the
+ * checkout itself, or anything else that lays out the same keys, handed over
+ * with `--artifacts`. One path for bytes to leave by, whoever built them.
  */
 export async function collectArtifacts(
   dir: string,