@valbuild/cli 0.97.7 → 0.99.0

package/cli/dist/valbuild-cli-cli.cjs.dev.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() || "";
@@ -175,32 +100,13 @@ async function handleFileMetadata(ctx) {
     shouldApplyPatch: true
   };
 }
-async function handleRemoteFileUpload(ctx) {
-  var _resolvedRemoteFileAt;
-  if (!ctx.fix) {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`
-    };
-  }
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
-    };
-  }
-  const filePath = path__default["default"].join(ctx.projectRoot, fileRefProp);
+// Shared upload core used by both the single-field (handleRemoteFileUpload)
+// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
+// how they derive the local file ref, metadata and serialized image/file
+// schema; everything from auth through upload is identical.
+async function uploadRemoteFileCore(ctx, fileRef, metadata, schema) {
+  const filePath = path__default["default"].join(ctx.projectRoot, fileRef);
   if (!ctx.fs.fileExists(filePath)) {
     return {
       success: false,
@@ -240,21 +146,6 @@ async function handleRemoteFileUpload(ctx) {
       }]
     };
   }
-  if (!resolvedRemoteFileAtSourcePath.schema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
-    };
-  }
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`
-    };
-  }
   const projectName = ctx.project;
   let publicProjectId = ctx.publicProjectId;
   let remoteFileBuckets = ctx.remoteFileBuckets;
@@ -290,12 +181,6 @@ async function handleRemoteFileUpload(ctx) {
       errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`
     };
   }
-  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
-    };
-  }
   remoteFilesCounter += 1;
   const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
   if (!bucket) {
@@ -321,8 +206,6 @@ async function handleRemoteFileUpload(ctx) {
   const fileHash = core.Internal.remote.getFileHash(fileBuffer);
   const coreVersion = core.Internal.VERSION.core || "unknown";
   const fileExt = getFileExt(filePath);
-  const schema = resolveRemoteFileSchema;
-  const metadata = fileSourceMetadata;
   const ref = core.Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
     publicProjectId,
     coreVersion,
@@ -342,7 +225,7 @@ async function handleRemoteFileUpload(ctx) {
   }
   ctx.remoteFiles[ctx.sourcePath] = {
     ref,
-    metadata: fileSourceMetadata
+    metadata
   };
   return {
     success: true,
@@ -359,6 +242,131 @@ async function handleRemoteFileUpload(ctx) {
     }]
   };
 }
+async function handleRemoteFileUpload(ctx) {
+  var _resolvedRemoteFileAt;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
+  if (!fileRefProp) {
+    return {
+      success: false,
+      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
+    };
+  }
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
+    };
+  }
+  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
+    };
+  }
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+  return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
+}
+
+// Gallery (s.images({ remote: true }) / s.files({ remote: true })) upload.
+// Unlike a single image/file field, a gallery entry is keyed by its local file
+// path and the value is bare metadata (no FileSource), so we derive the file
+// ref from the key and synthesize the image/file schema from the record's
+// media options.
+async function handleRemoteGalleryFileUpload(ctx) {
+  var _ctx$validationError$;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const fix = (_ctx$validationError$ = ctx.validationError.fixes) === null || _ctx$validationError$ === void 0 ? void 0 : _ctx$validationError$[0];
+  const mediaType = fix === "files:upload-remote" ? "file" : "image";
+
+  // The gallery entry is keyed by its local file path; validateMediaKey carries
+  // that key as the error value.
+  const fileRef = ctx.validationError.value;
+  if (typeof fileRef !== "string") {
+    return {
+      success: false,
+      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolved = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+  const entrySource = resolved.source;
+  const metadata = entrySource && typeof entrySource === "object" && !Array.isArray(entrySource) ? entrySource : undefined;
+
+  // The gallery item schema is an ObjectSchema, not an image/file schema, so
+  // synthesize the serialized image/file schema (matching how single fields
+  // serialize) for the remote ref's validation hash.
+  //
+  // `accept`/`directory` come from the RECORD that holds the entry, resolved
+  // from the entry's PARENT path - not from the module root, which is only the
+  // record when the gallery is the whole module. A nested gallery
+  // (s.object({ gallery: s.images(...) })) would otherwise synthesize a schema
+  // with no options and bake a validation hash into the remote ref that can
+  // never validate, so a mismatch fails fast instead of uploading.
+  const [, parentModulePath] = core.Internal.splitModuleFilePathAndModulePath(core.Internal.parentOfSourcePath(ctx.sourcePath));
+  const recordSchema = core.Internal.resolvePath(parentModulePath, ctx.valModule.source, ctx.valModule.schema).schema;
+  if ((recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) !== "record") {
+    return {
+      success: false,
+      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${(recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) ?? "nothing"}`
+    };
+  }
+  const {
+    accept,
+    directory
+  } = recordSchema;
+  const schema = mediaType === "image" ? {
+    type: "image",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {}),
+      ...(directory ? {
+        directory
+      } : {})
+    }
+  } : {
+    type: "file",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {})
+    }
+  };
+  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+}
 async function handleRemoteFileDownload(ctx) {
   if (ctx.fix) {
     return {
@@ -416,6 +424,17 @@ async function handleUniqueFolderCheck(ctx) {
     success: true
   };
 }
+
+// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
+// entries by a remote URL while keeping the file on disk; everything else is
+// already a local path and is returned unchanged.
+function remoteKeyToLocalPath(key) {
+  const remoteRefRes = core.Internal.remote.splitRemoteRef(key);
+  if (remoteRefRes.status === "success") {
+    return `/${remoteRefRes.filePath}`;
+  }
+  return key;
+}
 async function handleCheckAllFiles(ctx) {
   const value = ctx.validationError.value;
   if (!value || typeof value.directory !== "string") {
@@ -434,7 +453,10 @@ async function handleCheckAllFiles(ctx) {
       errorMessage: `Could not get source for ${ctx.sourcePath}`
     };
   }
-  const trackedFiles = new Set(Object.keys(source));
+  // Gallery entries are keyed by their file path. Remote galleries key uploaded
+  // entries by a remote URL, but the file is kept on disk at its local path, so
+  // normalize remote-URL keys back to that local path for the on-disk checks.
+  const trackedFiles = new Set(Object.keys(source).map(remoteKeyToLocalPath));
 
   // Check that all tracked files exist on disk
   const missingTrackedFiles = [...trackedFiles].filter(f => {
@@ -489,6 +511,8 @@ const currentFixHandlers = {
   "file:add-metadata": handleFileMetadata,
   "image:upload-remote": handleRemoteFileUpload,
   "file:upload-remote": handleRemoteFileUpload,
+  "images:upload-remote": handleRemoteGalleryFileUpload,
+  "files:upload-remote": handleRemoteGalleryFileUpload,
   "image:download-remote": handleRemoteFileDownload,
   "file:download-remote": handleRemoteFileDownload,
   "image:check-remote": handleRemoteFileCheck,
@@ -511,15 +535,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 +884,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 +915,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 +1095,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 +1220,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 +1309,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 +1327,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 +1384,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 +1396,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 +1460,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 +1530,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 +2078,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 +2220,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 +2360,7 @@ async function main() {
         files
         connect
         versions
+        lsp
         debug
         delete-unappliable-patches
 
@@ -2394,6 +2390,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 +2426,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 +2487,8 @@ async function main() {
       });
     case "versions":
       return versions();
+    case "lsp":
+      return lsp();
     case "debug":
       return debug({
         root: flags.root,