@valbuild/server 0.93.0 → 0.95.0

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

@@ -659,7 +659,7 @@ function removeFromNode(document, node, key) {
   } else if (ts__default["default"].isObjectLiteralExpression(node)) {
     return fp.pipe(findObjectPropertyAssignment(node, key), fp.result.flatMap(assignment => {
       if (!assignment) {
-        return fp.result.err(new patch.PatchError("Cannot replace object element which does not exist"));
+        return fp.result.err(new patch.PatchError("Cannot remove object element which does not exist"));
       }
       return fp.result.ok(assignment);
     }), fp.result.map(assignment => [removeAt(document, node.properties, node.properties.indexOf(assignment))[0], assignment.initializer]));
@@ -1026,7 +1026,14 @@ class ValSourceFileHandler {
       });
       fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
     },
-    rmFile: fs__default["default"].rmSync
+    rmFile: fs__default["default"].rmSync,
+    readBuffer: fileName => {
+      try {
+        return fs__default["default"].readFileSync(fileName);
+      } catch {
+        return undefined;
+      }
+    }
   }) {
     this.projectRoot = projectRoot;
     this.compilerOptions = compilerOptions;
@@ -1074,7 +1081,14 @@ class ValModuleLoader {
       });
       fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
     },
-    rmFile: fs__default["default"].rmSync
+    rmFile: fs__default["default"].rmSync,
+    readBuffer: fileName => {
+      try {
+        return fs__default["default"].readFileSync(fileName);
+      } catch {
+        return undefined;
+      }
+    }
   }, disableCache = false) {
     this.projectRoot = projectRoot;
     this.compilerOptions = compilerOptions;
@@ -1367,7 +1381,14 @@ async function createService(projectRoot, opts, host = {
     });
     fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
   },
-  rmFile: fs__default["default"].rmSync
+  rmFile: fs__default["default"].rmSync,
+  readBuffer: fileName => {
+    try {
+      return fs__default["default"].readFileSync(fileName);
+    } catch {
+      return undefined;
+    }
+  }
 }, loader) {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
@@ -1700,8 +1721,10 @@ class ValOps {
           const filePath = op.filePath;
           fileLastUpdatedByPatchId[filePath] = {
             patchId: patch.patchId,
-            remote: op.remote
+            remote: op.remote,
+            isDelete: op.value === null
           };
+          continue;
         }
         const path = patch.path;
         if (!patchesByModule[path]) {
@@ -1776,15 +1799,19 @@ class ValOps {
         const fileFixOps = {};
         for (const op of patchData.patch) {
           if (op.op === "file") {
-            // NOTE: We insert the last patch_id that modify a file
-            // when constructing the url we use the patch id (and the file path)
-            // to fetch the right file
-            // NOTE: overwrite and use last patch_id if multiple patches modify the same file
-            fileFixOps[op.path.join("/")] = [{
-              op: "add",
-              path: op.path.concat(...(op.nestedFilePath || [])).concat("patch_id"),
-              value: patchId
-            }];
+            if (op.value !== null) {
+              // NOTE: We insert the last patch_id that modify a file
+              // when constructing the url we use the patch id (and the file path)
+              // to fetch the right file
+              // NOTE: overwrite and use last patch_id if multiple patches modify the same file
+              fileFixOps[op.path.join("/")] = [{
+                op: "add",
+                path: op.path.concat(...(op.nestedFilePath || [])).concat("patch_id"),
+                value: patchId
+              }];
+            }
+            // null value = delete: no patch_id to inject; the "remove" op in
+            // the patch already removes the metadata entry from the source
           } else {
             applicableOps.push(op);
           }
@@ -1897,6 +1924,21 @@ class ValOps {
     const files = {};
     const remoteFiles = {};
     const entries = Object.entries(schemas);
+    // Build a map of gallery directory → [ModuleFilePath, ...] across ALL modules
+    // (must include all modules, not just those being validated, since conflicts can come from any module)
+    const galleryDirectoryToModules = new Map();
+    for (const [moduleFilePathS, schema] of entries) {
+      const serialized = schema["executeSerialize"]();
+      if (serialized.type === "record" && serialized.mediaType && serialized.directory) {
+        const dir = serialized.directory;
+        const existing = galleryDirectoryToModules.get(dir);
+        if (existing) {
+          existing.push(moduleFilePathS);
+        } else {
+          galleryDirectoryToModules.set(dir, [moduleFilePathS]);
+        }
+      }
+    }
     const modulePathsToValidate = patchesByModule && Object.keys(patchesByModule);
     for (const [pathS, schema] of entries) {
       if (modulePathsToValidate && !modulePathsToValidate.includes(pathS)) {
@@ -1937,7 +1979,7 @@ class ValOps {
         };
         if (validationErrors) {
           for (const validationError of validationErrors) {
-            var _validationError$fixe, _validationError$fixe2, _validationError$fixe3, _validationError$fixe4;
+            var _validationError$fixe, _validationError$fixe2, _validationError$fixe3, _validationError$fixe4, _validationError$fixe5, _validationError$fixe6, _validationError$fixe7, _validationError$fixe8;
             if (isOnlyFileCheckValidationError(validationError)) {
               if (files[sourcePath]) {
                 throw new Error("Cannot have multiple files with same path. Path: " + sourcePath + "; Module: " + path);
@@ -2020,7 +2062,32 @@ class ValOps {
                   }
                 }
               }
-            } else {
+            } else if ((_validationError$fixe5 = validationError.fixes) !== null && _validationError$fixe5 !== void 0 && _validationError$fixe5.includes("images:check-unique-folder") || (_validationError$fixe6 = validationError.fixes) !== null && _validationError$fixe6 !== void 0 && _validationError$fixe6.includes("files:check-unique-folder")) {
+              const TYPE_ERROR_MESSAGE = `This is most likely a Val version mismatch or Val bug.`;
+              if (!validationError.value || typeof validationError.value !== "object") {
+                addError({
+                  message: `Could not find a directory value for gallery at ${sourcePath}. ${TYPE_ERROR_MESSAGE}`,
+                  typeError: true
+                });
+              } else {
+                const directory = "directory" in validationError.value && validationError.value.directory;
+                if (typeof directory !== "string") {
+                  addError({
+                    message: `Expected gallery validation error 'value' to have property 'directory' of type 'string'. Found: ${typeof directory}. ${TYPE_ERROR_MESSAGE}`,
+                    typeError: true
+                  });
+                } else {
+                  const modulesUsingDir = galleryDirectoryToModules.get(directory) ?? [];
+                  const conflictingModules = modulesUsingDir.filter(m => m !== path);
+                  if (conflictingModules.length > 0) {
+                    addError({
+                      message: `Gallery directory '${directory}' in ${path} conflicts with: ${conflictingModules.join(", ")}. Each gallery must use a unique directory.`
+                    });
+                  }
+                  // If conflictingModules is empty, directory is unique — silently drop the error.
+                }
+              }
+            } else if ((_validationError$fixe7 = validationError.fixes) !== null && _validationError$fixe7 !== void 0 && _validationError$fixe7.includes("images:check-all-files") || (_validationError$fixe8 = validationError.fixes) !== null && _validationError$fixe8 !== void 0 && _validationError$fixe8.includes("files:check-all-files")) ; else {
               addError(validationError);
             }
           }
@@ -2300,16 +2367,22 @@ class ValOps {
     await Promise.all(Object.entries(fileLastUpdatedByPatchId).map(async ([filePath, patchData]) => {
       const {
         patchId,
-        remote
+        remote,
+        isDelete
       } = patchData;
       if (globalAppliedPatches.includes(patchId)) {
-        // TODO: do we want to make sure the file is there? Then again, it should be rare that it happens (unless there's a Val bug) so it might be enough to fail later (at commit)
-        // TODO: include sha256? This way we can make sure we pick the right file since theoretically there could be multiple files with the same path in the same patch
-        // or is that the case? We are picking the latest file by path so, that should be enough?
-        patchedBinaryFilesDescriptors[filePath] = {
-          patchId,
-          remote
-        };
+        if (isDelete) {
+          // Signal file deletion via patchedSourceFiles null entry
+          patchedSourceFiles[filePath] = null;
+        } else {
+          // TODO: do we want to make sure the file is there? Then again, it should be rare that it happens (unless there's a Val bug) so it might be enough to fail later (at commit)
+          // TODO: include sha256? This way we can make sure we pick the right file since theoretically there could be multiple files with the same path in the same patch
+          // or is that the case? We are picking the latest file by path so, that should be enough?
+          patchedBinaryFilesDescriptors[filePath] = {
+            patchId,
+            remote
+          };
+        }
       } else {
         hasErrors = true;
         binaryFilePatchErrors[filePath] = {
@@ -2332,8 +2405,8 @@ class ValOps {
   }
 
   // #region createPatch
-  async createPatch(path, patch, patchId, parentRef, authorId) {
-    const saveRes = await this.saveSourceFilePatch(path, patch, patchId, parentRef, authorId);
+  async createPatch(path, patch, patchId, parentRef, sessionId, authorId) {
+    const saveRes = await this.saveSourceFilePatch(path, patch, patchId, parentRef, authorId, sessionId);
     if (fp.result.isErr(saveRes)) {
       console.error(`Could not save source patch at path: '${path}'. Error: ${saveRes.error.errorType === "other" ? saveRes.error.message : saveRes.error.errorType}`);
       if (saveRes.error.errorType === "patch-head-conflict") {
@@ -2355,8 +2428,8 @@ class ValOps {
   // #region abstract ops
 }
 function isOnlyFileCheckValidationError(validationError) {
-  var _validationError$fixe5;
-  if ((_validationError$fixe5 = validationError.fixes) !== null && _validationError$fixe5 !== void 0 && _validationError$fixe5.every(f => f === "file:check-metadata" || f === "image:check-metadata")) {
+  var _validationError$fixe9;
+  if ((_validationError$fixe9 = validationError.fixes) !== null && _validationError$fixe9 !== void 0 && _validationError$fixe9.every(f => f === "file:check-metadata" || f === "image:check-metadata")) {
     return true;
   }
   return false;
@@ -2725,11 +2798,17 @@ class ValOpsFS extends ValOps {
           parentPatchId: dir
         });
       } else {
-        if (includes && includes.length > 0 && !includes.includes(parsedPatch.data.patchId)) {
+        const patchId = parsedPatch.data.patchId;
+        if (includes && includes.length > 0 && !includes.includes(patchId)) {
           return;
         }
-        patches[parsedPatch.data.patchId] = {
-          ...parsedPatch.data,
+        patches[patchId] = {
+          path: parsedPatch.data.path,
+          patch: parsedPatch.data.patch,
+          parentRef: parsedPatch.data.parentRef,
+          baseSha: parsedPatch.data.baseSha,
+          createdAt: parsedPatch.data.createdAt,
+          authorId: parsedPatch.data.authorId,
           appliedAt: null
         };
       }
@@ -2900,7 +2979,7 @@ class ValOpsFS extends ValOps {
       };
     }
   }
-  async saveSourceFilePatch(path, patch, patchId, parentRef, authorId) {
+  async saveSourceFilePatch(path, patch, patchId, parentRef, authorId, sessionId) {
     const patchDir = this.getParentPatchIdFromParentRef(parentRef);
     try {
       const baseSha = await this.getBaseSha();
@@ -2910,6 +2989,7 @@ class ValOpsFS extends ValOps {
         parentRef,
         path,
         authorId,
+        sessionId,
         baseSha,
         coreVersion: core.Internal.VERSION.core,
         createdAt: new Date().toISOString()
@@ -2987,6 +3067,14 @@ class ValOpsFS extends ValOps {
     const patchFilePath = this.getBinaryFilePath(filePath, patchDir);
     const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDir);
     try {
+      if (data === null) {
+        this.host.deleteFile(patchFilePath);
+        this.host.deleteFile(metadataFilePath);
+        return {
+          patchId,
+          filePath
+        };
+      }
       const buffer = bufferFromDataUrl(data);
       if (!buffer) {
         return {
@@ -3247,7 +3335,11 @@ class ValOpsFS extends ValOps {
     for (const [filePath, data] of Object.entries(preparedCommit.patchedSourceFiles)) {
       const absPath = path__namespace["default"].join(this.rootDir, ...filePath.split("/"));
       try {
-        this.host.writeUf8File(absPath, data);
+        if (data === null) {
+          this.host.deleteFile(absPath);
+        } else {
+          this.host.writeUf8File(absPath, data);
+        }
         updatedFiles.push(absPath);
       } catch (err) {
         errors[absPath] = {
@@ -3336,12 +3428,6 @@ class ValOpsFS extends ValOps {
     return fp.result.ok(Object.fromEntries(Object.entries(patches.patches).map(([patchId, value]) => [patchId, this.getParentPatchIdFromParentRef(value.parentRef)])));
   }
 
-  // #region profiles
-  async getProfiles() {
-    // We do not have profiles in FS mode
-    return [];
-  }
-
   // #region fs file path helpers
   getPatchesDir() {
     return path__namespace["default"].join(this.rootDir, ValOpsFS.VAL_DIR, "patches");
@@ -3373,6 +3459,11 @@ class FSOpsHost {
       });
     }
   }
+  deleteFile(path) {
+    if (this.fileExists(path)) {
+      fs__default["default"].rmSync(path);
+    }
+  }
   moveDir(from, to) {
     fs__default["default"].renameSync(from, to);
   }
@@ -3445,7 +3536,9 @@ const FSPatch = zod.z.object({
   parentRef: internal.ParentRef,
   authorId: zod.z.string().refine(p => true).nullable(),
   createdAt: zod.z.string().datetime(),
-  coreVersion: zod.z.string().nullable() // TODO: use this to check if patch is compatible with current core version?
+  coreVersion: zod.z.string().nullable(),
+  // TODO: use this to check if patch is compatible with current core version?
+  sessionId: zod.z.string().nullable()
 });
 const FSPatchBase = zod.z.object({
   baseSha: zod.z.string().refine(p => true),
@@ -3547,17 +3640,6 @@ const CommitResponse = zod.z.object({
   commit: CommitSha,
   branch: zod.z.string()
 });
-const ProfilesResponse = zod.z.object({
-  profiles: zod.z.array(zod.z.object({
-    profileId: zod.z.string(),
-    fullName: zod.z.string(),
-    email: zod.z.string().optional(),
-    // TODO: make this required once this can be guaranteed
-    avatar: zod.z.object({
-      url: zod.z.string()
-    }).nullable()
-  }))
-});
 const NonceResponse = zod.z.object({
   nonce: zod.z.string(),
   url: zod.z.string()
@@ -4008,7 +4090,7 @@ class ValOpsHttp extends ValOps {
       };
     }
   }
-  async saveSourceFilePatch(path, patch, patchId, parentRef, authorId) {
+  async saveSourceFilePatch(path, patch, patchId, parentRef, authorId, sessionId) {
     const baseSha = await this.getBaseSha();
     return fetch(`${this.contentUrl}/v1/${this.project}/patches`, {
       method: "POST",
@@ -4020,6 +4102,7 @@ class ValOpsHttp extends ValOps {
         path,
         patch,
         authorId,
+        sessionId,
         patchId,
         parentPatchId: parentRef.type === "patch" ? parentRef.patchId : null,
         baseSha,
@@ -4443,31 +4526,6 @@ class ValOpsHttp extends ValOps {
       };
     }
   }
-
-  // #region profiles
-  async getProfiles() {
-    var _res$headers$get6;
-    const res = await fetch(`${this.contentUrl}/v1/${this.project}/profiles`, {
-      headers: {
-        ...this.authHeaders,
-        "Content-Type": "application/json"
-      }
-    });
-    if (res.ok) {
-      const parsed = ProfilesResponse.safeParse(await res.json());
-      if (parsed.error) {
-        console.error("Could not parse profiles response", parsed.error);
-        throw Error(`Could not get profiles from remote server: wrong format. You might need to upgrade Val.`);
-      }
-      return parsed.data.profiles;
-    }
-    if ((_res$headers$get6 = res.headers.get("Content-Type")) !== null && _res$headers$get6 !== void 0 && _res$headers$get6.includes("application/json")) {
-      const json = await res.json();
-      const message = internal.getErrorMessageFromUnknownJson(json, "Unknown error");
-      throw Error(`Could not get profiles (status: ${res.status}): ${message}`);
-    }
-    throw Error(`Could not get profiles. Got status: ${res.status}`);
-  }
 }
 
 const host = process.env.VAL_CONTENT_URL || core.DEFAULT_CONTENT_HOST;
@@ -4620,6 +4678,16 @@ function hasRemoteFileSchema(schema) {
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 const ValServer = (valModules, options, callbacks) => {
+  const ProfilesResponse = zod.z.object({
+    profiles: zod.z.array(zod.z.object({
+      profileId: zod.z.string(),
+      fullName: zod.z.string(),
+      email: zod.z.string().optional(),
+      avatar: zod.z.object({
+        url: zod.z.string()
+      }).nullable()
+    }))
+  });
   let serverOps;
   if (options.mode === "fs") {
     serverOps = new ValOpsFS(options.valContentUrl, options.cwd, valModules, {
@@ -5469,10 +5537,11 @@ const ValServer = (valModules, options, callbacks) => {
         }
         const patches = req.body.patches;
         let parentRef = req.body.parentRef;
+        const sessionId = req.body.sessionId ?? null;
         const authorId = "id" in auth ? auth.id : null;
         const newPatchIds = [];
         for (const patch of patches) {
-          const createPatchRes = await serverOps.createPatch(patch.path, patch.patch, patch.patchId, parentRef, authorId);
+          const createPatchRes = await serverOps.createPatch(patch.path, patch.patch, patch.patchId, parentRef, sessionId, authorId);
           if (fp.result.isErr(createPatchRes)) {
             if (createPatchRes.error.errorType === "patch-head-conflict") {
               return {
@@ -5833,13 +5902,87 @@ const ValServer = (valModules, options, callbacks) => {
             }
           };
         }
-        const profiles = await serverOps.getProfiles();
-        return {
-          status: 200,
-          json: {
-            profiles
+        if (!options.project) {
+          return {
+            status: 500,
+            json: {
+              message: "Project is not configured"
+            }
+          };
+        }
+        const authDataRes = await getRemoteFileAuth();
+        if (authDataRes.status !== 200) {
+          if (serverOps instanceof ValOpsFS && authDataRes.json.errorCode === "pat-error") {
+            return {
+              status: 200,
+              json: {
+                profiles: []
+              }
+            };
+          }
+          return {
+            status: 500,
+            json: {
+              message: authDataRes.json.message
+            }
+          };
+        }
+        const authData = authDataRes.json.remoteFileAuth;
+        const execFetch = async headers => {
+          try {
+            const upstreamUrl = `${options.valContentUrl}/v1/${options.project}/profiles`;
+            const upstreamRes = await fetch(upstreamUrl, {
+              method: "GET",
+              headers
+            });
+            if (!upstreamRes.ok) {
+              const text = await upstreamRes.text();
+              const isAuthError = upstreamRes.status === 401 || upstreamRes.status === 403;
+              return {
+                status: isAuthError ? 401 : 500,
+                json: {
+                  message: isAuthError ? `Profile authentication failed: ${upstreamRes.status} ${text}` : `Profiles failed: ${upstreamRes.status} ${text}`
+                }
+              };
+            }
+            const parseRes = ProfilesResponse.safeParse(await upstreamRes.json());
+            if (!parseRes.success) {
+              return {
+                status: 500,
+                json: {
+                  message: "Could not parse profiles response: " + zodValidationError.fromError(parseRes.error).toString()
+                }
+              };
+            }
+            return {
+              status: 200,
+              json: {
+                profiles: parseRes.data.profiles
+              }
+            };
+          } catch (err) {
+            return {
+              status: 500,
+              json: {
+                message: err instanceof Error ? err.message : "Profiles request failed"
+              }
+            };
           }
         };
+        if (serverOps instanceof ValOpsFS) {
+          return execFetch(getProfileAuthHeaders(authData, null, "application/json"));
+        }
+        if (!options.valSecret) {
+          return {
+            status: 500,
+            json: {
+              message: "Secret is not configured"
+            }
+          };
+        }
+        return withAuth(options.valSecret, cookies, "profiles", data => {
+          return execFetch(getProfileAuthHeaders(authData, data, "application/json"));
+        });
       }
     },
     "/commit-summary": {
@@ -6021,6 +6164,381 @@ const ValServer = (valModules, options, callbacks) => {
         }
       }
     },
+    //#region ai proxy
+    "/ai/initialize": {
+      POST: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        if (!options.project) {
+          return {
+            status: 500,
+            json: {
+              message: "Project is not configured"
+            }
+          };
+        }
+        const authDataRes = await getRemoteFileAuth();
+        if (authDataRes.status !== 200) {
+          return {
+            status: 500,
+            json: {
+              message: authDataRes.json.message
+            }
+          };
+        }
+        const authData = authDataRes.json.remoteFileAuth;
+        const execFetch = async headers => {
+          try {
+            const upstreamUrl = `${options.valContentUrl}/v1/${options.project}/ai/initialize`;
+            const upstreamRes = await fetch(upstreamUrl, {
+              method: "POST",
+              headers,
+              body: JSON.stringify({})
+            });
+            if (!upstreamRes.ok) {
+              const text = await upstreamRes.text();
+              return {
+                status: 500,
+                json: {
+                  message: `AI initialize failed: ${upstreamRes.status} ${text}`
+                }
+              };
+            }
+            const json = await upstreamRes.json();
+            const wsUrl = options.valContentUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:") + `/v1/${options.project}/ai/connect`;
+            return {
+              status: 200,
+              json: {
+                nonce: json.nonce,
+                wsUrl
+              }
+            };
+          } catch (err) {
+            return {
+              status: 500,
+              json: {
+                message: err instanceof Error ? err.message : "AI initialize error"
+              }
+            };
+          }
+        };
+        if (serverOps instanceof ValOpsFS) {
+          return execFetch(getProfileAuthHeaders(authData, null, "application/json"));
+        }
+        if (!options.valSecret) {
+          return {
+            status: 500,
+            json: {
+              message: "Secret is not configured"
+            }
+          };
+        }
+        return withAuth(options.valSecret, cookies, "ai/initialize", data => {
+          return execFetch(getProfileAuthHeaders(authData, data, "application/json"));
+        });
+      }
+    },
+    "/ai/sessions": {
+      GET: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        if (!options.project) {
+          return {
+            status: 500,
+            json: {
+              message: "Project is not configured"
+            }
+          };
+        }
+        const authDataRes = await getRemoteFileAuth();
+        if (authDataRes.status !== 200) {
+          return {
+            status: 500,
+            json: {
+              message: authDataRes.json.message
+            }
+          };
+        }
+        const authData = authDataRes.json.remoteFileAuth;
+        const execFetch = async headers => {
+          try {
+            const SessionsResponse = zod.z.object({
+              sessions: zod.z.array(zod.z.object({
+                id: zod.z.string(),
+                name: zod.z.string().nullable(),
+                createdAt: zod.z.string(),
+                updatedAt: zod.z.string()
+              })),
+              nextCursor: zod.z.object({
+                updatedAt: zod.z.string(),
+                id: zod.z.string()
+              }).nullable().optional()
+            });
+            const params = new URLSearchParams();
+            if (req.query.limit) params.set("limit", req.query.limit);
+            if (req.query.cursor_updatedAt) {
+              params.set("cursor_updatedAt", req.query.cursor_updatedAt);
+            }
+            if (req.query.cursor_id) {
+              params.set("cursor_id", req.query.cursor_id);
+            }
+            const qs = params.toString();
+            const upstreamUrl = `${options.valContentUrl}/v1/${options.project}/ai/sessions${qs ? `?${qs}` : ""}`;
+            const upstreamRes = await fetch(upstreamUrl, {
+              headers
+            });
+            if (!upstreamRes.ok) {
+              const text = await upstreamRes.text();
+              return {
+                status: 500,
+                json: {
+                  message: `AI sessions failed: ${upstreamRes.status} ${text}`
+                }
+              };
+            }
+            const json = SessionsResponse.safeParse(await upstreamRes.json());
+            if (!json.success) {
+              return {
+                status: 500,
+                json: {
+                  message: "Could not parse AI sessions response: " + zodValidationError.fromError(json.error).toString()
+                }
+              };
+            }
+            return {
+              status: 200,
+              json: json.data
+            };
+          } catch (err) {
+            return {
+              status: 500,
+              json: {
+                message: err instanceof Error ? err.message : "AI sessions error"
+              }
+            };
+          }
+        };
+        if (serverOps instanceof ValOpsFS) {
+          return execFetch(getProfileAuthHeaders(authData, null, "application/json"));
+        }
+        if (!options.valSecret) {
+          return {
+            status: 500,
+            json: {
+              message: "Secret is not configured"
+            }
+          };
+        }
+        return withAuth(options.valSecret, cookies, "ai/sessions", data => {
+          return execFetch(getProfileAuthHeaders(authData, data, "application/json"));
+        });
+      },
+      PATCH: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        if (!options.project) {
+          return {
+            status: 500,
+            json: {
+              message: "Project is not configured"
+            }
+          };
+        }
+        const pathParts = (req.path || "").split("/").filter(Boolean);
+        const sessionId = pathParts[0];
+        if (!sessionId) {
+          return {
+            status: 500,
+            json: {
+              message: "Missing sessionId in path"
+            }
+          };
+        }
+        const authDataRes = await getRemoteFileAuth();
+        if (authDataRes.status !== 200) {
+          return {
+            status: 500,
+            json: {
+              message: authDataRes.json.message
+            }
+          };
+        }
+        const authData = authDataRes.json.remoteFileAuth;
+        const execFetch = async headers => {
+          try {
+            const upstreamUrl = `${options.valContentUrl}/v1/${options.project}/ai/sessions/${encodeURIComponent(sessionId)}`;
+            const upstreamRes = await fetch(upstreamUrl, {
+              method: "PATCH",
+              headers,
+              body: JSON.stringify({
+                name: req.body.name
+              })
+            });
+            if (!upstreamRes.ok) {
+              const text = await upstreamRes.text();
+              return {
+                status: 500,
+                json: {
+                  message: `AI session rename failed: ${upstreamRes.status} ${text}`
+                }
+              };
+            }
+            return {
+              status: 200,
+              json: {}
+            };
+          } catch (err) {
+            return {
+              status: 500,
+              json: {
+                message: err instanceof Error ? err.message : "AI session rename error"
+              }
+            };
+          }
+        };
+        if (serverOps instanceof ValOpsFS) {
+          return execFetch(getProfileAuthHeaders(authData, null, "application/json"));
+        }
+        if (!options.valSecret) {
+          return {
+            status: 500,
+            json: {
+              message: "Secret is not configured"
+            }
+          };
+        }
+        return withAuth(options.valSecret, cookies, "ai/sessions/rename", data => {
+          return execFetch(getProfileAuthHeaders(authData, data, "application/json"));
+        });
+      }
+    },
+    "/ai/messages": {
+      GET: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        if (!options.project) {
+          return {
+            status: 500,
+            json: {
+              message: "Project is not configured"
+            }
+          };
+        }
+        const pathParts = (req.path || "").split("/").filter(Boolean);
+        const sessionId = pathParts[0];
+        if (!sessionId) {
+          return {
+            status: 500,
+            json: {
+              message: "Missing sessionId in path"
+            }
+          };
+        }
+        const authDataRes = await getRemoteFileAuth();
+        if (authDataRes.status !== 200) {
+          return {
+            status: 500,
+            json: {
+              message: authDataRes.json.message
+            }
+          };
+        }
+        const authData = authDataRes.json.remoteFileAuth;
+        const execFetch = async headers => {
+          try {
+            const SessionMessagesResponse = zod.z.object({
+              messages: zod.z.array(zod.z.object({
+                role: zod.z.string(),
+                content: zod.z.string()
+              })),
+              nextCursor: zod.z.object({
+                updatedAt: zod.z.string(),
+                id: zod.z.string()
+              }).nullable().optional()
+            });
+            const upstreamUrl = `${options.valContentUrl}/v1/${options.project}/ai/sessions/${encodeURIComponent(sessionId)}/messages`;
+            const upstreamRes = await fetch(upstreamUrl, {
+              headers
+            });
+            if (!upstreamRes.ok) {
+              const text = await upstreamRes.text();
+              return {
+                status: 500,
+                json: {
+                  message: `AI session messages failed: ${upstreamRes.status} ${text}`
+                }
+              };
+            }
+            const json = SessionMessagesResponse.safeParse(await upstreamRes.json());
+            if (!json.success) {
+              return {
+                status: 500,
+                json: {
+                  message: "Could not parse AI session messages response: " + zodValidationError.fromError(json.error).toString()
+                }
+              };
+            }
+            return {
+              status: 200,
+              json: json.data
+            };
+          } catch (err) {
+            return {
+              status: 500,
+              json: {
+                message: err instanceof Error ? err.message : "AI session messages error"
+              }
+            };
+          }
+        };
+        if (serverOps instanceof ValOpsFS) {
+          return execFetch(getProfileAuthHeaders(authData, null, "application/json"));
+        }
+        if (!options.valSecret) {
+          return {
+            status: 500,
+            json: {
+              message: "Secret is not configured"
+            }
+          };
+        }
+        return withAuth(options.valSecret, cookies, "ai/sessions/messages", data => {
+          return execFetch(getProfileAuthHeaders(authData, data, "application/json"));
+        });
+      }
+    },
     //#region files
     "/files": {
       GET: async req => {
@@ -6242,6 +6760,21 @@ async function withAuth(secret, cookies, errorMessageType, handler) {
     };
   }
 }
+function getProfileAuthHeaders(auth, data, type) {
+  if ("pat" in auth) {
+    return {
+      "x-val-pat": auth.pat,
+      "Content-Type": type
+    };
+  }
+  if ("apiKey" in auth && data) {
+    return {
+      ...getAuthHeaders(auth.apiKey, type),
+      "x-val-profile-id": data.sub
+    };
+  }
+  throw new Error("Invalid auth");
+}
 function getAuthHeaders(token, type) {
   if (!type) {
     return {
@@ -6769,6 +7302,9 @@ class ValFSHost {
   readFile(fileName) {
     return this.valFS.readFile(fileName);
   }
+  readBuffer(fileName) {
+    return this.valFS.readBuffer(fileName);
+  }
   realpath(path) {
     return this.valFS.realpath(path);
   }
@@ -7243,6 +7779,88 @@ async function createFixPatch(config, apply, sourcePath, validationError, remote
           metadata: v.metadata
         } : value
       });
+    } else if (fix === "images:check-all-files" || fix === "files:check-all-files") {
+      if (!moduleSource || typeof moduleSource !== "object") {
+        remainingErrors.push({
+          ...validationError,
+          message: "Unexpected error while checking gallery metadata (no moduleSource)",
+          fixes: undefined
+        });
+        continue;
+      }
+      const gallerySource = moduleSource;
+      for (const [entryKey, storedEntry] of Object.entries(gallerySource)) {
+        const filename = path__namespace["default"].join(config.projectRoot, entryKey);
+        let buffer;
+        try {
+          buffer = fs__default["default"].readFileSync(filename);
+        } catch {
+          if (apply) {
+            const removePath = patch.sourceToPatchPath(sourcePath).concat([entryKey]);
+            if (patch.isNotRoot(removePath)) {
+              patch$1.push({
+                op: "remove",
+                path: removePath
+              });
+            }
+          } else {
+            remainingErrors.push({
+              ...validationError,
+              message: `Could not read file: ${filename} - file might not exist or can not be accessed`,
+              fixes: undefined
+            });
+          }
+          continue;
+        }
+        if (fix === "images:check-all-files") {
+          const actualMetadata = await extractImageMetadata(filename, buffer);
+          const stored = storedEntry;
+          const metadataIsCorrect = stored.width === actualMetadata.width && stored.height === actualMetadata.height && stored.mimeType === actualMetadata.mimeType;
+          if (!metadataIsCorrect) {
+            if (apply) {
+              patch$1.push({
+                op: "replace",
+                path: patch.sourceToPatchPath(sourcePath).concat([entryKey]),
+                value: {
+                  ...stored,
+                  width: actualMetadata.width ?? 0,
+                  height: actualMetadata.height ?? 0,
+                  mimeType: actualMetadata.mimeType ?? "application/octet-stream"
+                }
+              });
+            } else {
+              remainingErrors.push({
+                ...validationError,
+                message: `Image metadata for '${entryKey}' is incorrect (width: ${stored.width ?? "<empty>"} vs ${actualMetadata.width}, height: ${stored.height ?? "<empty>"} vs ${actualMetadata.height}, mimeType: ${stored.mimeType ?? "<empty>"} vs ${actualMetadata.mimeType}). Use --fix to update.`
+              });
+            }
+          }
+        } else if (fix === "files:check-all-files") {
+          const actualMetadata = await extractFileMetadata(filename);
+          const stored = storedEntry;
+          const metadataIsCorrect = stored.mimeType === actualMetadata.mimeType;
+          if (!metadataIsCorrect) {
+            if (apply) {
+              patch$1.push({
+                op: "replace",
+                path: patch.sourceToPatchPath(sourcePath).concat([entryKey]),
+                value: {
+                  ...stored,
+                  mimeType: actualMetadata.mimeType ?? "application/octet-stream"
+                }
+              });
+            } else {
+              remainingErrors.push({
+                ...validationError,
+                message: `File metadata for '${entryKey}' has incorrect mimeType: '${stored.mimeType ?? "<empty>"}' vs '${actualMetadata.mimeType}'. Use --fix to update.`
+              });
+            }
+          }
+        } else {
+          const exhaustiveCheck = fix;
+          throw new Error(`Internal error: unhandled fix type ${exhaustiveCheck}`);
+        }
+      }
     } else if (fix === "file:check-remote" || fix === "image:check-remote") {
       const v = getRemoteValueFromValidationError(validationError);
       if (!v.success) {