@valbuild/cli 0.97.7 → 0.98.0

package/cli/dist/valbuild-cli-cli.cjs.prod.js

@@ -4,16 +4,13 @@ var meow = require('meow');
 var chalk = require('chalk');
 var path = require('path');
 var pc = require('picocolors');
-var fs = require('fs/promises');
+var fs$1 = require('fs/promises');
 var fastGlob = require('fast-glob');
 var core = require('@valbuild/core');
 var server = require('@valbuild/server');
-var vm = require('node:vm');
-var ts = require('typescript');
-var z = require('zod');
-var node_module = require('node:module');
 var internal = require('@valbuild/shared/internal');
-var fs$1 = require('fs');
+var ts = require('typescript');
+var fs = require('fs');
 var JSZip = require('jszip');
 var readline = require('readline');
 
@@ -41,11 +38,9 @@ var meow__default = /*#__PURE__*/_interopDefault(meow);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var pc__default = /*#__PURE__*/_interopDefault(pc);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var vm__default = /*#__PURE__*/_interopDefault(vm);
-var ts__default = /*#__PURE__*/_interopDefault(ts);
-var z__default = /*#__PURE__*/_interopDefault(z);
 var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 
@@ -64,76 +59,6 @@ function info(message, opts = {}) {
   console.log(chalk__default["default"].blue("️ℹ️ : ") + message);
 }
 
-const ValConfigSchema = z__default["default"].object({
-  project: z__default["default"].string().optional(),
-  root: z__default["default"].string().optional(),
-  files: z__default["default"].object({
-    directory: z__default["default"].string().refine(val => (val === "/public" || val.startsWith("/public/") && !val.endsWith("/")) &&
-    // Reject path traversal so the directory cannot escape /public
-    !val.split("/").some(segment => segment === "." || segment === ".."), {
-      message: "files.directory must start with '/public', must not end with '/' and must not contain '.' or '..' segments"
-    })
-  }).optional(),
-  gitCommit: z__default["default"].string().optional(),
-  gitBranch: z__default["default"].string().optional(),
-  defaultTheme: z__default["default"].union([z__default["default"].literal("light"), z__default["default"].literal("dark")]).optional(),
-  ai: z__default["default"].object({
-    commitMessages: z__default["default"].object({
-      disabled: z__default["default"].boolean().optional()
-    }).optional()
-  }).optional()
-});
-async function evalValConfigFile(projectRoot, configFileName) {
-  const valConfigPath = path__default["default"].join(projectRoot, configFileName);
-  let code = null;
-  try {
-    code = await fs__default["default"].readFile(valConfigPath, "utf-8");
-  } catch {
-    //
-  }
-  if (!code) {
-    return null;
-  }
-  const transpiled = ts__default["default"].transpileModule(code, {
-    compilerOptions: {
-      target: ts__default["default"].ScriptTarget.ES2020,
-      module: ts__default["default"].ModuleKind.CommonJS,
-      esModuleInterop: true
-    },
-    fileName: valConfigPath
-  });
-  const projectRootRequire = node_module.createRequire(valConfigPath);
-  const exportsObj = {};
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const sandbox = {
-    exports: exportsObj,
-    module: {
-      exports: exportsObj
-    },
-    require: projectRootRequire,
-    // NOTE: this is a security risk, but this code is running in the users own environment at the CLI level
-    __filename: valConfigPath,
-    __dirname: projectRoot,
-    console,
-    process
-  };
-  sandbox.global = sandbox;
-  const context = vm__default["default"].createContext(sandbox);
-  const script = new vm__default["default"].Script(transpiled.outputText, {
-    filename: valConfigPath
-  });
-  script.runInContext(context);
-  const valConfig = sandbox.module.exports.config;
-  if (!valConfig) {
-    throw Error(`Val config file at path: '${valConfigPath}' must export a config object. Got: ${valConfig}`);
-  }
-  const result = ValConfigSchema.safeParse(valConfig);
-  if (!result.success) {
-    throw Error(`Val config file at path: '${valConfigPath}' has invalid schema: ${result.error.message}`);
-  }
-  return result.data;
-}
-
 function getFileExt(filePath) {
   // NOTE: We do not import the path module. This code is copied in different projects. We want the same implementation and which means that this might running in browser where path is not available).
   return filePath.split(".").pop() || "";
@@ -511,15 +436,15 @@ function createDefaultValFSHost() {
   return {
     ...ts__default["default"].sys,
     writeFile: (fileName, data, encoding) => {
-      fs__default$1["default"].mkdirSync(path__default["default"].dirname(fileName), {
+      fs__default["default"].mkdirSync(path__default["default"].dirname(fileName), {
         recursive: true
       });
-      fs__default$1["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
+      fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
     },
-    rmFile: fs__default$1["default"].rmSync,
+    rmFile: fs__default["default"].rmSync,
     readBuffer: fileName => {
       try {
-        return fs__default$1["default"].readFileSync(fileName);
+        return fs__default["default"].readFileSync(fileName);
       } catch {
         return undefined;
       }
@@ -860,7 +785,7 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const filePath = path__default["default"].join(projectRoot, moduleFilePath);
   let fileContent;
   try {
-    fileContent = fs__default$1["default"].readFileSync(filePath, "utf-8");
+    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
   } catch {
     cache.set(moduleFilePath, null);
     return null;
@@ -891,7 +816,7 @@ async function validate({
   // errors found. Re-reads config and val files each call so it always reflects
   // the latest state on disk (used both for one-shot and watch mode).
   async function runOnce() {
-    const valConfigFile = (await evalValConfigFile(projectRoot, "val.config.ts")) || (await evalValConfigFile(projectRoot, "val.config.js"));
+    const valConfigFile = await server.findAndEvalValConfigFile(projectRoot);
     const resolvedValConfigFile = valConfigFile ? {
       ...valConfigFile,
       project: process.env.VAL_PROJECT || valConfigFile.project
@@ -1071,11 +996,11 @@ async function validate({
     if (prettier) {
       for (const file of fixedFiles) {
         const filePath = path__default["default"].join(projectRoot, file);
-        const fileContent = await fs__default["default"].readFile(filePath, "utf-8");
+        const fileContent = await fs__default$1["default"].readFile(filePath, "utf-8");
         const formattedContent = await prettier.format(fileContent, {
           filepath: filePath
         });
-        await fs__default["default"].writeFile(filePath, formattedContent);
+        await fs__default$1["default"].writeFile(filePath, formattedContent);
       }
     }
 
@@ -1196,7 +1121,7 @@ async function listUnusedFiles({
 }) {
   var _valConfigFile$files;
   const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
-  const valConfigFile = (await evalValConfigFile(projectRoot, "val.config.ts")) || (await evalValConfigFile(projectRoot, "val.config.js"));
+  const valConfigFile = await server.findAndEvalValConfigFile(projectRoot);
   // Strip the leading "/" so it is relative to the project root (e.g. "public/val").
   const managedDir = ((valConfigFile === null || valConfigFile === void 0 || (_valConfigFile$files = valConfigFile.files) === null || _valConfigFile$files === void 0 ? void 0 : _valConfigFile$files.directory) ?? "/public/val").replace(/^\//, "");
   const service = await server.createService(projectRoot);
@@ -1285,7 +1210,7 @@ const getVersions = () => {
   };
 };
 
-const host$1 = process.env.VAL_BUILD_URL || "https://admin.val.build";
+const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
 async function connect(options) {
   const {
     root
@@ -1303,11 +1228,11 @@ async function connect(options) {
   if (maybeGitOwnerAndRepo) {
     params.set("github_repo", [maybeGitOwnerAndRepo.owner, maybeGitOwnerAndRepo.repo].join("/"));
   }
-  const url = `${host$1}/connect?${params.toString()}`;
+  const url = `${host}/connect?${params.toString()}`;
   console.log(pc__default["default"].dim(`\nFollow the instructions in your browser to complete the setup:\n${pc__default["default"].cyan(url)}\n`));
 }
 async function tryGetProject(projectRoot) {
-  const valConfigFile = (await evalValConfigFile(projectRoot, "val.config.ts")) || (await evalValConfigFile(projectRoot, "val.config.js"));
+  const valConfigFile = await server.findAndEvalValConfigFile(projectRoot);
   if (valConfigFile && valConfigFile.project) {
     const parts = valConfigFile.project.split("/");
     if (parts.length === 2) {
@@ -1360,8 +1285,8 @@ function tryGetGitConfig(root) {
   let lastDir = null;
   while (currentDir !== lastDir) {
     const gitConfigPath = path__default["default"].join(currentDir, ".git", "config");
-    if (fs__default$1["default"].existsSync(gitConfigPath)) {
-      return fs__default$1["default"].readFileSync(gitConfigPath, "utf-8");
+    if (fs__default["default"].existsSync(gitConfigPath)) {
+      return fs__default["default"].readFileSync(gitConfigPath, "utf-8");
     }
     lastDir = currentDir;
     currentDir = path__default["default"].dirname(currentDir);
@@ -1372,83 +1297,54 @@ function tryGetGitConfig(root) {
   return null;
 }
 
-const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
+/**
+ * Terminal wrapper around the login device flow in `@valbuild/server`.
+ * The flow itself (polling, token persistence) is shared with
+ * `@valbuild/language-server`.
+ */
 async function login(options) {
   try {
-    var _response$headers$get;
     console.log(pc__default["default"].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 = response.headers.get("content-type")) !== null && _response$headers$get !== void 0 && _response$headers$get.includes("application/json"))) {
-      const text = await response.text();
-      console.error(pc__default["default"].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__default["default"].red("Unexpected response from the server."), json);
-      process.exit(1);
-    }
+    const {
+      nonce,
+      url
+    } = await server.startValLogin();
     console.log(pc__default["default"].green("Open the following URL in your browser to log in:"));
     console.log(pc__default["default"].underline(pc__default["default"].blue(url)));
     console.log(pc__default["default"].dim("\nWaiting for login confirmation...\n"));
-
-    // Step 2: Poll for login confirmation
-    const result = await pollForConfirmation(token);
-
-    // Step 3: Save the token
-    const filePath = server.getPersonalAccessTokenPath(options.root || process.cwd());
-    saveToken(result, filePath);
+    const result = await server.awaitValLoginConfirmation(nonce);
+    const filePath = server.persistPersonalAccessToken(options.root || process.cwd(), result);
+    console.log(pc__default["default"].green(`Token for ${pc__default["default"].cyan(result.profile.email)} saved to ${pc__default["default"].cyan(filePath)}`));
   } catch (error) {
-    console.error(pc__default["default"].red("An error occurred during the login process. Check your internet connection. Details:"), error instanceof Error ? error.message : JSON.stringify(error, null, 2));
-    process.exit(1);
-  }
-}
-const MAX_DURATION = 5 * 60 * 1000; // 5 minutes
-async function pollForConfirmation(token) {
-  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__default["default"].red("An error occurred on the server."));
+    if (error instanceof server.ValLoginError) {
+      console.error(pc__default["default"].red(error.message), error.details ?? "");
       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__default["default"].red("Unexpected response from the server."));
-          process.exit(1);
-        }
-      }
-    }
+    console.error(pc__default["default"].red("An error occurred during the login process. Check your internet connection. Details:"), error instanceof Error ? error.message : JSON.stringify(error, null, 2));
+    process.exit(1);
   }
-  console.error(pc__default["default"].red("Login confirmation timed out."));
-  process.exit(1);
 }
-function saveToken(result, filePath) {
-  fs__default$1["default"].mkdirSync(path__default["default"].dirname(filePath), {
-    recursive: true
-  });
-  fs__default$1["default"].writeFileSync(filePath, JSON.stringify(result, null, 2));
-  console.log(pc__default["default"].green(`Token for ${pc__default["default"].cyan(result.profile.email)} saved to ${pc__default["default"].cyan(filePath)}`));
+
+/**
+ * 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.
+ */
+async function lsp() {
+  const {
+    main
+  } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@valbuild/language-server')); });
+  // Transport (`--stdio`, `--node-ipc`, `--socket=`) is read from argv by the
+  // server itself, so the flags pass straight through.
+  main();
 }
 
 /**
@@ -1465,10 +1361,10 @@ class DebugContextError extends Error {}
 async function createDebugContext(options) {
   var _config$files;
   const projectRoot = options.root ? path__default["default"].resolve(options.root) : process.cwd();
-  if (!fs__default$1["default"].existsSync(projectRoot)) {
+  if (!fs__default["default"].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 server.findAndEvalValConfigFile(projectRoot);
   if (!config) {
     throw new DebugContextError(`Could not find val.config.ts nor val.config.js in: ${projectRoot}`);
   }
@@ -1535,8 +1431,8 @@ async function createDebugContext(options) {
  */
 function readAuth(projectRoot) {
   const patFile = server.getPersonalAccessTokenPath(projectRoot);
-  if (fs__default$1["default"].existsSync(patFile)) {
-    const contents = fs__default$1["default"].readFileSync(patFile, "utf-8");
+  if (fs__default["default"].existsSync(patFile)) {
+    const contents = fs__default["default"].readFileSync(patFile, "utf-8");
     const parsed = server.parsePersonalAccessTokenFile(contents);
     if (parsed.success) {
       return {
@@ -2083,7 +1979,7 @@ function readProjectValVersions(projectRoot) {
 function readLocalFile(projectRoot, projectRelativePath) {
   const absPath = path__default["default"].join(projectRoot, projectRelativePath);
   try {
-    return fs__default$1["default"].readFileSync(absPath, "utf-8");
+    return fs__default["default"].readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -2225,10 +2121,10 @@ async function writeZip(outPath, entries) {
     type: "nodebuffer",
     compression: "DEFLATE"
   });
-  fs__default$1["default"].mkdirSync(path__default["default"].dirname(outPath), {
+  fs__default["default"].mkdirSync(path__default["default"].dirname(outPath), {
     recursive: true
   });
-  fs__default$1["default"].writeFileSync(outPath, buffer);
+  fs__default["default"].writeFileSync(outPath, buffer);
 }
 function timestamp() {
   return new Date().toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
@@ -2365,6 +2261,7 @@ async function main() {
         files
         connect
         versions
+        lsp
         debug
         delete-unappliable-patches
 
@@ -2394,6 +2291,13 @@ async function main() {
       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
@@ -2423,11 +2327,6 @@ async function main() {
         --verbose                List every pending patch, not just the failing ones
     `, {
     flags: {
-      port: {
-        type: "number",
-        alias: "p",
-        default: 4123
-      },
       root: {
         type: "string",
         alias: "r"
@@ -2489,6 +2388,8 @@ async function main() {
       });
     case "versions":
       return versions();
+    case "lsp":
+      return lsp();
     case "debug":
       return debug({
         root: flags.root,