@valbuild/cli 0.97.7 → 0.99.0

package/src/__fixtures__/basic/content/basic-gallery-remote-existing.val.ts

@@ -0,0 +1,20 @@
+import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/basic-gallery-remote-existing.val.ts",
+  s.images({
+    directory: "/public/val/images-remote2",
+    accept: "image/*",
+    remote: true,
+  }),
+
+  {
+    "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc1/f/def4/p/public/val/images-remote2/image.png":
+      {
+        width: 1,
+        height: 1,
+        mimeType: "image/png",
+        alt: null,
+      },
+  },
+);

package/src/__fixtures__/basic/content/basic-gallery-remote.val.ts

@@ -0,0 +1,19 @@
+import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/basic-gallery-remote.val.ts",
+  s.images({
+    directory: "/public/val/images-remote",
+    accept: "image/*",
+    remote: true,
+  }),
+
+  {
+    "/public/val/images-remote/image.png": {
+      width: 1,
+      height: 1,
+      mimeType: "image/png",
+      alt: null,
+    },
+  },
+);

package/src/__fixtures__/basic/val.config.ts

@@ -1,5 +1,7 @@
 import { initVal } from "@valbuild/core";
 
-const { s, c, config } = initVal();
+// NOTE: initVal() must be called with an options object for `config` to be
+// defined - the CLI requires val.config to export a config object.
+const { s, c, config } = initVal({});
 
 export { s, c, config };

package/src/__fixtures__/basic/val.modules.ts

@@ -13,4 +13,6 @@ export default modules(config, [
   { def: () => import("./content/basic-gallery-fail-on-non-unique-dir.val") },
   { def: () => import("./content/basic-gallery-missing-tracked.val") },
   { def: () => import("./content/basic-gallery-wrong-metadata.val") },
+  { def: () => import("./content/basic-gallery-remote.val") },
+  { def: () => import("./content/basic-gallery-remote-existing.val") },
 ]);

package/src/cli.ts

@@ -6,6 +6,7 @@ import { getVersions } from "./getVersions";
 import { connect } from "./connect";
 import chalk from "chalk";
 import { login } from "./login";
+import { lsp } from "./lsp";
 import { debug } from "./debug";
 import { deleteUnappliablePatches } from "./deleteUnappliablePatches";
 
@@ -24,6 +25,7 @@ async function main(): Promise<void> {
         files
         connect
         versions
+        lsp
         debug
         delete-unappliable-patches
 
@@ -53,6 +55,13 @@ async function main(): Promise<void> {
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
 
+      Command: lsp
+      Description: start the Val language server (used by editor integrations)
+      Options:
+        --stdio                  Communicate over stdin/stdout
+        --node-ipc               Communicate over Node IPC
+        --socket=[port]          Communicate over a socket
+
       Command: debug
       Description: Create a self-contained snapshot (the pending patches plus the modules they
         touch or reference) that Val developers can replay to reproduce validation and save
@@ -83,11 +92,6 @@ async function main(): Promise<void> {
     `,
     {
       flags: {
-        port: {
-          type: "number",
-          alias: "p",
-          default: 4123,
-        },
         root: {
           type: "string",
           alias: "r",
@@ -155,6 +159,8 @@ async function main(): Promise<void> {
       });
     case "versions":
       return versions();
+    case "lsp":
+      return lsp();
     case "debug":
       return debug({
         root: flags.root,

package/src/connect.ts

@@ -1,7 +1,7 @@
 import pc from "picocolors";
 import fs from "fs";
 import path from "path";
-import { evalValConfigFile } from "./utils/evalValConfigFile";
+import { findAndEvalValConfigFile } from "./utils/evalValConfigFile";
 
 const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
 
@@ -39,9 +39,7 @@ async function tryGetProject(projectRoot: string): Promise<{
   orgName: string;
   projectName: string;
 } | null> {
-  const valConfigFile =
-    (await evalValConfigFile(projectRoot, "val.config.ts")) ||
-    (await evalValConfigFile(projectRoot, "val.config.js"));
+  const valConfigFile = await findAndEvalValConfigFile(projectRoot);
 
   if (valConfigFile && valConfigFile.project) {
     const parts = valConfigFile.project.split("/");

package/src/debug/context.ts

@@ -9,7 +9,7 @@ import {
   ValOpsFS,
   ValOpsHttp,
 } from "@valbuild/server";
-import { evalValConfigFile } from "../utils/evalValConfigFile";
+import { findAndEvalValConfigFile } from "../utils/evalValConfigFile";
 
 /**
  * Everything the debug commands need in order to talk to the same ops the
@@ -56,9 +56,7 @@ export async function createDebugContext(options: {
   if (!fs.existsSync(projectRoot)) {
     throw new DebugContextError(`Project root does not exist: ${projectRoot}`);
   }
-  const config =
-    (await evalValConfigFile(projectRoot, "val.config.ts")) ||
-    (await evalValConfigFile(projectRoot, "val.config.js"));
+  const config = await findAndEvalValConfigFile(projectRoot);
   if (!config) {
     throw new DebugContextError(
       `Could not find val.config.ts nor val.config.js in: ${projectRoot}`,

package/src/listUnusedFiles.ts

@@ -8,14 +8,12 @@ import {
 import { createService } from "@valbuild/server";
 import { glob } from "fast-glob";
 import path from "path";
-import { evalValConfigFile } from "./utils/evalValConfigFile";
+import { findAndEvalValConfigFile } from "./utils/evalValConfigFile";
 
 export async function listUnusedFiles({ root }: { root?: string }) {
   const projectRoot = root ? path.resolve(root) : process.cwd();
 
-  const valConfigFile =
-    (await evalValConfigFile(projectRoot, "val.config.ts")) ||
-    (await evalValConfigFile(projectRoot, "val.config.js"));
+  const valConfigFile = await findAndEvalValConfigFile(projectRoot);
   // Strip the leading "/" so it is relative to the project root (e.g. "public/val").
   const managedDir = (valConfigFile?.files?.directory ?? "/public/val").replace(
     /^\//,

package/src/login.ts

@@ -1,56 +1,44 @@
 import pc from "picocolors";
-import fs from "fs";
-import path from "path";
-import { getPersonalAccessTokenPath } from "@valbuild/server";
-
-const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
-
+import {
+  awaitValLoginConfirmation,
+  persistPersonalAccessToken,
+  startValLogin,
+  ValLoginError,
+} from "@valbuild/server";
+
+/**
+ * Terminal wrapper around the login device flow in `@valbuild/server`.
+ * The flow itself (polling, token persistence) is shared with
+ * `@valbuild/language-server`.
+ */
 export async function login(options: { root?: string }) {
   try {
     console.log(pc.cyan("\nStarting login process...\n"));
 
-    // Step 1: Initiate login and get token and URL
-    const response = await fetch(`${host}/api/login`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    });
-    let token;
-    let url;
-    if (!response.headers.get("content-type")?.includes("application/json")) {
-      const text = await response.text();
-      console.error(
-        pc.red(
-          "Unexpected failure while trying to login (content type was not JSON). ",
-        ),
-        text
-          ? `Server response: ${text} (status: ${response.status})`
-          : `Status: ${response.status}`,
-      );
-      process.exit(1);
-    }
-    const json = await response.json();
-    if (json) {
-      token = json.nonce;
-      url = json.url;
-    }
-    if (!token || !url) {
-      console.error(pc.red("Unexpected response from the server."), json);
-      process.exit(1);
-    }
+    const { nonce, url } = await startValLogin();
 
     console.log(pc.green("Open the following URL in your browser to log in:"));
     console.log(pc.underline(pc.blue(url)));
     console.log(pc.dim("\nWaiting for login confirmation...\n"));
 
-    // Step 2: Poll for login confirmation
-    const result = await pollForConfirmation(token);
+    const result = await awaitValLoginConfirmation(nonce);
 
-    // Step 3: Save the token
-    const filePath = getPersonalAccessTokenPath(options.root || process.cwd());
-    saveToken(result, filePath);
+    const filePath = persistPersonalAccessToken(
+      options.root || process.cwd(),
+      result,
+    );
+    console.log(
+      pc.green(
+        `Token for ${pc.cyan(
+          result.profile.email,
+        )} saved to ${pc.cyan(filePath)}`,
+      ),
+    );
   } catch (error) {
+    if (error instanceof ValLoginError) {
+      console.error(pc.red(error.message), error.details ?? "");
+      process.exit(1);
+    }
     console.error(
       pc.red(
         "An error occurred during the login process. Check your internet connection. Details:",
@@ -60,56 +48,3 @@ export async function login(options: { root?: string }) {
     process.exit(1);
   }
 }
-
-const MAX_DURATION = 5 * 60 * 1000; // 5 minutes
-async function pollForConfirmation(token: string): Promise<{
-  profile: { email: string };
-  pat: string;
-}> {
-  const start = Date.now();
-  while (Date.now() - start < MAX_DURATION) {
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    const response = await fetch(
-      `${host}/api/login?token=${token}&consume=true`,
-      { method: "POST" },
-    );
-    if (response.status === 500) {
-      console.error(pc.red("An error occurred on the server."));
-      process.exit(1);
-    }
-    if (response.status === 200) {
-      const json = await response.json();
-      if (json) {
-        if (
-          typeof json.profile.email === "string" &&
-          typeof json.pat === "string"
-        ) {
-          return json;
-        } else {
-          console.error(pc.red("Unexpected response from the server."));
-          process.exit(1);
-        }
-      }
-    }
-  }
-  console.error(pc.red("Login confirmation timed out."));
-  process.exit(1);
-}
-
-function saveToken(
-  result: {
-    profile: { email: string };
-    pat: string;
-  },
-  filePath: string,
-) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(result, null, 2));
-  console.log(
-    pc.green(
-      `Token for ${pc.cyan(
-        result.profile.email,
-      )} saved to ${pc.cyan(filePath)}`,
-    ),
-  );
-}

package/src/lsp.ts

@@ -0,0 +1,19 @@
+/**
+ * Start the Val language server.
+ *
+ * Editors normally resolve `@valbuild/language-server` from the project's
+ * `node_modules` and launch its `val-language-server` binary directly. This
+ * subcommand exists so the server is discoverable from the CLI and easy to
+ * start by hand when debugging an editor integration:
+ *
+ *     npx val lsp --stdio
+ *
+ * The import is dynamic so that `vscode-languageserver` is not loaded on every
+ * `val` invocation.
+ */
+export async function lsp(): Promise<void> {
+  const { main } = await import("@valbuild/language-server");
+  // Transport (`--stdio`, `--node-ipc`, `--socket=`) is read from argv by the
+  // server itself, so the flags pass straight through.
+  main();
+}

package/src/runValidation.test.ts

@@ -383,4 +383,105 @@ describe("runValidation", () => {
       service.dispose();
     }
   });
+
+  test("reports upload-remote error for local entry in a remote gallery", async () => {
+    const events: ValidationEvent[] = [];
+
+    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);
+    }
+
+    expect(events.at(-1)).toEqual({
+      type: "summary-errors",
+      count: expect.any(Number),
+    });
+    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 () => {
+    const uploadRemote: IValRemote = {
+      remoteHost: DEFAULT_VAL_REMOTE_HOST,
+      getSettings: async () => ({
+        success: true,
+        data: {
+          publicProjectId: "pubproj",
+          remoteFileBuckets: [{ bucket: "01" }],
+        },
+      }),
+      uploadFile: async () => ({ success: true }),
+    };
+    // Upload requires a personal access token on disk.
+    fs.mkdirSync(path.join(tmpDir, ".val"), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, ".val", "pat.json"),
+      JSON.stringify({ pat: "test-pat" }),
+    );
+
+    const events: ValidationEvent[] = [];
+    for await (const event of runValidation({
+      root: tmpDir,
+      fix: true,
+      valFiles: ["content/basic-gallery-remote.val.ts"],
+      project: "test/project",
+      remote: uploadRemote,
+      fs: createDefaultValFSHost(),
+    })) {
+      events.push(event);
+    }
+
+    expect(events.some((e) => e.type === "remote-uploaded")).toBe(true);
+    expect(events.some((e) => e.type === "fix-applied")).toBe(true);
+
+    const service = await createService(tmpDir, createDefaultValFSHost());
+    try {
+      const result = await service.get(
+        "/content/basic-gallery-remote.val.ts" as ModuleFilePath,
+        "" as ModulePath,
+        { validate: false },
+      );
+      const source = result.source as Record<string, unknown>;
+      // The local-path key is replaced by a remote URL key (file kept on disk).
+      expect(source).not.toHaveProperty("/public/val/images-remote/image.png");
+      const keys = Object.keys(source);
+      expect(keys).toHaveLength(1);
+      expect(keys[0]).toContain("pubproj");
+      expect(keys[0]).toContain("public/val/images-remote/image.png");
+    } finally {
+      service.dispose();
+    }
+  });
+
+  test("does not flag a kept-on-disk file behind a remote gallery key", async () => {
+    const events: ValidationEvent[] = [];
+
+    for await (const event of runValidation({
+      root: tmpDir,
+      fix: false,
+      valFiles: ["content/basic-gallery-remote-existing.val.ts"],
+      project: undefined,
+      remote: mockRemote,
+      fs: createDefaultValFSHost(),
+    })) {
+      events.push(event);
+    }
+
+    // The file kept on disk under the remote URL key must not be reported as
+    // untracked, and the remote URL key must not be reported as missing.
+    expect(events.at(-1)).toEqual({ type: "summary-success" });
+    expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0);
+  });
 });