@valbuild/server 0.68.2 → 0.69.0

package/dist/valbuild-server.esm.js

@@ -1536,10 +1536,13 @@ class ValOps {
   }
 
   // #region analyzePatches
-  analyzePatches(sortedPatches) {
+  analyzePatches(sortedPatches, commits, currentCommitSha) {
     const patchesByModule = {};
     const fileLastUpdatedByPatchId = {};
     for (const patch of sortedPatches) {
+      if (patch.appliedAt) {
+        continue;
+      }
       for (const op of patch.patch) {
         if (op.op === "file") {
           const filePath = op.filePath;
@@ -1578,7 +1581,7 @@ class ValOps {
     const errors = {};
     for (const patchData of analysis.patches) {
       const path = patchData.path;
-      if (!sources[path]) {
+      if (sources[path] === undefined) {
         if (!errors[path]) {
           errors[path] = [];
         }
@@ -1855,6 +1858,8 @@ class ValOps {
       patchesByModule,
       fileLastUpdatedByPatchId
     } = patchAnalysis;
+    const patchedSourceFiles = {};
+    const previousSourceFiles = {};
     const applySourceFilePatches = async (path, patches) => {
       const sourceFileRes = await this.getSourceFile(path);
       const errors = [];
@@ -1870,6 +1875,7 @@ class ValOps {
         };
       }
       const sourceFile = sourceFileRes.data;
+      previousSourceFiles[path] = sourceFile;
       let tsSourceFile = ts.createSourceFile("<val>", sourceFile, ts.ScriptTarget.ES2015);
       const appliedPatches = [];
       const triedPatches = [];
@@ -1947,7 +1953,6 @@ class ValOps {
     const appliedPatches = {};
     const triedPatches = {};
     const skippedPatches = {};
-    const patchedSourceFiles = {};
 
     //
     const globalAppliedPatches = [];
@@ -1988,6 +1993,7 @@ class ValOps {
       sourceFilePatchErrors,
       binaryFilePatchErrors,
       patchedSourceFiles,
+      previousSourceFiles,
       patchedBinaryFilesDescriptors,
       appliedPatches,
       skippedPatches,
@@ -2005,7 +2011,7 @@ class ValOps {
     if (parentRef.type !== "head") {
       // There's room for some optimizations here: we could do this once, then re-use every time we create a patch, then again we only create one patch at a time
       const patchOps = await this.fetchPatches({
-        omitPatch: false
+        excludePatchOps: false
       });
       const patchAnalysis = this.analyzePatches(patchOps.patches);
       const tree = await this.getSources({
@@ -2029,7 +2035,7 @@ class ValOps {
         }
       });
     }
-    if (!source) {
+    if (source === undefined) {
       console.error(`Cannot patch. Module source at path: '${path}' does not exist`);
       return result.err({
         errorType: "other",
@@ -2341,6 +2347,13 @@ class ValOpsFS extends ValOps {
   async onInit() {
     // do nothing
   }
+  async getCommitSummary() {
+    return {
+      error: {
+        message: "Val is in development / local mode. Cannot generate summary"
+      }
+    };
+  }
   async getStat(params) {
     // In ValOpsFS, we don't have a websocket server to listen to file changes so we use long-polling.
     // If a file that Val depends on changes, we break the connection and tell the client to request again to get the latest values.
@@ -2522,7 +2535,7 @@ class ValOpsFS extends ValOps {
         }
         patches[parsedPatch.data.patchId] = {
           ...parsedPatch.data,
-          appliedAt: parsedBase ? parsedBase.data : null
+          appliedAt: null
         };
       }
     });
@@ -2542,17 +2555,9 @@ class ValOpsFS extends ValOps {
     return parentRef.type === "head" ? "head" : parentRef.patchId;
   }
   async fetchPatches(filters) {
-    const fetchPatchesRes = await this.fetchPatchesFromFS(!!filters.omitPatch);
-    const sortedPatches = this.createPatchChain(fetchPatchesRes.patches).filter(patchData => {
-      if (filters.authors && !(patchData.authorId === null || filters.authors.includes(patchData.authorId))) {
-        return false;
-      }
-      if (filters.moduleFilePaths && !filters.moduleFilePaths.includes(patchData.path)) {
-        return false;
-      }
-      return true;
-    }).map(patchData => {
-      if (filters.omitPatch) {
+    const fetchPatchesRes = await this.fetchPatchesFromFS(!!filters.excludePatchOps);
+    const sortedPatches = this.createPatchChain(fetchPatchesRes.patches).map(patchData => {
+      if (filters.excludePatchOps) {
         return {
           ...patchData,
           patch: undefined
@@ -2565,7 +2570,7 @@ class ValOpsFS extends ValOps {
       errors: fetchPatchesRes.errors
     };
   }
-  async fetchPatchesFromFS(omitPath) {
+  async fetchPatchesFromFS(excludePatchOps) {
     const patches = {};
     const {
       errors,
@@ -2574,7 +2579,7 @@ class ValOpsFS extends ValOps {
     for (const [patchIdS, patch] of Object.entries(allPatches)) {
       const patchId = patchIdS;
       patches[patchId] = {
-        patch: omitPath ? undefined : patch.patch,
+        patch: excludePatchOps ? undefined : patch.patch,
         parentRef: patch.parentRef,
         path: patch.path,
         baseSha: patch.baseSha,
@@ -3168,7 +3173,7 @@ const textEncoder = new TextEncoder();
 const PatchId = z.string().refine(s => !!s); // TODO: validate
 const CommitSha = z.string().refine(s => !!s); // TODO: validate
 z.string().refine(s => !!s); // TODO: validate
-const AuthorId = z.string().refine(s => !!s); // TODO: validate
+z.string().refine(s => !!s); // TODO: validate
 const ModuleFilePath = z.string().refine(s => !!s); // TODO: validate
 const Metadata = z.union([z.object({
   mimeType: z.string(),
@@ -3182,20 +3187,28 @@ const MetadataRes = z.object({
   metadata: Metadata,
   type: z.union([z.literal("file"), z.literal("image")]).nullable()
 });
-const BasePatchResponse = z.object({
-  path: ModuleFilePath,
-  patchId: PatchId,
-  authorId: AuthorId.nullable(),
-  createdAt: z.string().datetime(),
-  baseSha: z.string()
+const SummaryResponse = z.object({
+  commitSummary: z.string().nullable()
 });
-const GetPatches = z.object({
-  patches: z.array(z.intersection(z.object({
-    patch: Patch.optional()
-  }), BasePatchResponse)),
-  errors: z.array(z.object({
-    patchId: PatchId.optional(),
-    message: z.string()
+const GetApplicablePatches = z.object({
+  patches: z.array(z.object({
+    path: z.string(),
+    patch: Patch.nullable(),
+    patchId: z.string(),
+    authorId: z.string().nullable(),
+    baseSha: z.string(),
+    createdAt: z.string(),
+    applied: z.object({
+      commitSha: z.string()
+    }).nullable()
+  })),
+  commits: z.array(z.object({
+    commitSha: z.string(),
+    clientCommitSha: z.string(),
+    parentCommitSha: z.string(),
+    branch: z.string(),
+    creator: z.string(),
+    createdAt: z.string()
   })).optional()
 });
 const FilesResponse = z.object({
@@ -3232,7 +3245,7 @@ const DeletePatchesResponse = z.object({
     patchId: PatchId
   })).optional()
 });
-z.object({
+const SavePatchFileResponse = z.object({
   patchId: PatchId,
   filePath: ModuleFilePath
 });
@@ -3251,11 +3264,11 @@ const ProfilesResponse = z.object({
   }))
 });
 class ValOpsHttp extends ValOps {
-  constructor(hostUrl, project, commitSha,
+  constructor(contentUrl, project, commitSha,
   // TODO: CommitSha
   branch, apiKey, valModules, options) {
     super(valModules, options);
-    this.hostUrl = hostUrl;
+    this.contentUrl = contentUrl;
     this.project = project;
     this.commitSha = commitSha;
     this.branch = branch;
@@ -3267,6 +3280,70 @@ class ValOpsHttp extends ValOps {
   async onInit() {
     // TODO: unused for now. Implement or remove
   }
+  async getCommitSummary(preparedCommit) {
+    try {
+      var _res$headers$get;
+      const res = await fetch(`${this.contentUrl}/v1/${this.project}/commit-summary`, {
+        method: "POST",
+        headers: {
+          ...this.authHeaders,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          patchedSourceFiles: preparedCommit.patchedSourceFiles,
+          previousSourceFiles: preparedCommit.previousSourceFiles
+        })
+      });
+      if (res.ok) {
+        const json = await res.json();
+        const parsed = SummaryResponse.safeParse(json);
+        if (parsed.success) {
+          return {
+            commitSummary: parsed.data.commitSummary
+          };
+        }
+        console.error(`Could not parse summary response.  Error: ${fromError(parsed.error).toString()}`);
+        return {
+          error: {
+            message: `Cannot get the summary of your changes. An error has been logged. Possible cause: the current version of Val might be too old. Please try again later or contact the developers on your team.`
+          }
+        };
+      }
+      if (res.status === 401) {
+        console.error("Unauthorized to get summary");
+        return {
+          error: {
+            message: "Could not get summary. Although your user is authorized, the application has authorization issues. Contact the developers on your team and ask them to verify the api keys."
+          }
+        };
+      }
+      const unknownErrorMessage = `Could not get summary. HTTP error: ${res.status} ${res.statusText}`;
+      if ((_res$headers$get = res.headers.get("Content-Type")) !== null && _res$headers$get !== void 0 && _res$headers$get.includes("application/json")) {
+        const json = await res.json();
+        if (json.message) {
+          console.error("Summary error:", json.message);
+          return {
+            error: {
+              message: json.message
+            }
+          };
+        }
+      }
+      console.error(unknownErrorMessage);
+      return {
+        error: {
+          message: unknownErrorMessage
+        }
+      };
+    } catch (e) {
+      console.error("Could not get summary (connection error?):", e);
+      return {
+        error: {
+          message: `Could not get summary. Error: ${e instanceof Error ? e.message : JSON.stringify(e)}`
+        }
+      };
+    }
+  }
   async getStat(params) {
     if (!(params !== null && params !== void 0 && params.profileId)) {
       return {
@@ -3279,11 +3356,23 @@ class ValOpsHttp extends ValOps {
     const currentBaseSha = await this.getBaseSha();
     const currentSchemaSha = await this.getSchemaSha();
     const allPatchData = await this.fetchPatches({
-      omitPatch: true,
-      authors: undefined,
-      patchIds: undefined,
-      moduleFilePaths: undefined
+      excludePatchOps: true,
+      patchIds: undefined
     });
+    if ("error" in allPatchData && allPatchData.error && allPatchData.unauthorized) {
+      return {
+        type: "error",
+        error: allPatchData.error,
+        unauthorized: true
+      };
+    }
+    if ("error" in allPatchData && allPatchData.error && allPatchData.networkError) {
+      return {
+        type: "error",
+        error: allPatchData.error,
+        networkError: true
+      };
+    }
     // We think these errors will be picked up else where (?), so we only return an error here if there are no patches
     if (allPatchData.patches.length === 0) {
       let message;
@@ -3330,7 +3419,7 @@ class ValOpsHttp extends ValOps {
     };
   }
   async getWebSocketNonce(profileId) {
-    return fetch(`${this.hostUrl}/v1/${this.project}/websocket/nonces`, {
+    return fetch(`${this.contentUrl}/v1/${this.project}/websocket/nonces`, {
       method: "POST",
       body: JSON.stringify({
         branch: this.branch,
@@ -3407,16 +3496,12 @@ class ValOpsHttp extends ValOps {
     if (patchIds === undefined || patchIds.length === 0) {
       return this.fetchPatchesInternal({
         patchIds: patchIds,
-        authors: filters.authors,
-        moduleFilePaths: filters.moduleFilePaths,
-        omitPatch: filters.omitPatch
+        excludePatchOps: filters.excludePatchOps
       });
     }
     for (const res of await Promise.all(patchIdChunks.map(patchIdChunk => this.fetchPatchesInternal({
       patchIds: patchIdChunk,
-      authors: filters.authors,
-      moduleFilePaths: filters.moduleFilePaths,
-      omitPatch: filters.omitPatch
+      excludePatchOps: filters.excludePatchOps
     })))) {
       if ("error" in res) {
         return res;
@@ -3434,72 +3519,97 @@ class ValOpsHttp extends ValOps {
   async fetchPatchesInternal(filters) {
     const params = [];
     params.push(["branch", this.branch]);
+    params.push(["commit", this.commitSha]);
     if (filters.patchIds) {
       for (const patchId of filters.patchIds) {
         params.push(["patch_id", patchId]);
       }
     }
-    if (filters.authors) {
-      for (const author of filters.authors) {
-        params.push(["author_id", author]);
-      }
-    }
-    if (filters.omitPatch) {
-      params.push(["omit_patch", "true"]);
-    }
-    if (filters.moduleFilePaths) {
-      for (const moduleFilePath of filters.moduleFilePaths) {
-        params.push(["module_file_path", moduleFilePath]);
-      }
+    if (filters.excludePatchOps) {
+      params.push(["exclude_patch_ops", "true"]);
     }
     const searchParams = new URLSearchParams(params);
-    return fetch(`${this.hostUrl}/v1/${this.project}/patches${searchParams.size > 0 ? `?${searchParams.toString()}` : ""}`, {
-      headers: {
-        ...this.authHeaders,
-        "Content-Type": "application/json"
-      }
-    }).then(async res => {
+    try {
+      const patchesRes = await fetch(`${this.contentUrl}/v1/${this.project}/applicable/patches${searchParams.size > 0 ? `?${searchParams.toString()}` : ""}`, {
+        headers: this.authHeaders
+      });
       const patches = [];
-      if (res.ok) {
-        const json = await res.json();
-        const parsed = GetPatches.safeParse(json);
+      if (patchesRes.ok) {
+        const json = await patchesRes.json();
+        const parsed = GetApplicablePatches.safeParse(json);
         if (parsed.success) {
           const errors = [];
           const data = parsed.data;
           for (const patchesRes of data.patches) {
+            var _patchesRes$applied;
             patches.push({
               authorId: patchesRes.authorId,
               createdAt: patchesRes.createdAt,
-              appliedAt: null,
               patchId: patchesRes.patchId,
               path: patchesRes.path,
               baseSha: patchesRes.baseSha,
-              patch: filters.omitPatch ? undefined : patchesRes.patch
+              patch: patchesRes.patch,
+              appliedAt: (_patchesRes$applied = patchesRes.applied) !== null && _patchesRes$applied !== void 0 && _patchesRes$applied.commitSha ? {
+                commitSha: patchesRes.applied.commitSha
+              } : null
             });
           }
+          const commits = [];
+          if (data.commits) {
+            for (const commit of data.commits) {
+              commits.push({
+                commitSha: commit.commitSha,
+                clientCommitSha: commit.clientCommitSha,
+                parentCommitSha: commit.parentCommitSha,
+                branch: commit.branch,
+                creator: commit.creator,
+                createdAt: commit.createdAt
+              });
+            }
+          }
           return {
+            commits,
             patches,
             errors
           };
         }
+        console.error("Could not parse patches response. Error: " + fromError(parsed.error));
+        return {
+          patches,
+          error: {
+            message: `The response that Val got from the server was not in the expected format. This might be a transient error or a configuration issue. Please try again later.`
+          }
+        };
+      }
+      console.error("Could not get patches. HTTP error: " + patchesRes.status + " " + patchesRes.statusText);
+      if (patchesRes.status === 401) {
         return {
           patches,
           error: {
-            message: `Could not parse get patches response. Error: ${fromError(parsed.error)}`
+            message: "Although your user is authorized, the application has authorization issues. Contact the developers on your team and ask them to verify the api keys."
           }
         };
       }
       return {
         patches,
         error: {
-          message: "Could not get patches. HTTP error: " + res.status + " " + res.statusText
+          message: "Could not your changes. It is most likely due to a network issue. Check your network connection and please try again."
         }
       };
-    });
+    } catch (err) {
+      console.error("Could not get patches (connection error):", err instanceof Error ? err.message : JSON.stringify(err));
+      return {
+        patches: [],
+        networkError: true,
+        error: {
+          message: `Error: ${err instanceof Error ? err.message : JSON.stringify(err)}`
+        }
+      };
+    }
   }
   async saveSourceFilePatch(path, patch, parentRef, authorId) {
     const baseSha = await this.getBaseSha();
-    return fetch(`${this.hostUrl}/v1/${this.project}/patches`, {
+    return fetch(`${this.contentUrl}/v1/${this.project}/patches`, {
       method: "POST",
       headers: {
         ...this.authHeaders,
@@ -3516,7 +3626,7 @@ class ValOpsHttp extends ValOps {
         coreVersion: Internal.VERSION.core
       })
     }).then(async res => {
-      var _res$headers$get;
+      var _res$headers$get2;
       if (res.ok) {
         const parsed = SavePatchResponse.safeParse(await res.json());
         if (parsed.success) {
@@ -3535,7 +3645,7 @@ class ValOpsHttp extends ValOps {
           message: "Conflict: " + (await res.text())
         });
       }
-      if ((_res$headers$get = res.headers.get("Content-Type")) !== null && _res$headers$get !== void 0 && _res$headers$get.includes("application/json")) {
+      if ((_res$headers$get2 = res.headers.get("Content-Type")) !== null && _res$headers$get2 !== void 0 && _res$headers$get2.includes("application/json")) {
         const json = await res.json();
         return result.err({
           errorType: "other",
@@ -3554,7 +3664,45 @@ class ValOpsHttp extends ValOps {
     });
   }
   async saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data, type, metadata) {
-    throw Error("TODO: implement");
+    return fetch(`${this.contentUrl}/v1/${this.project}/patches/${patchId}/files`, {
+      method: "POST",
+      headers: {
+        ...this.authHeaders,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        filePath: filePath,
+        data,
+        type,
+        metadata
+      })
+    }).then(async res => {
+      if (res.ok) {
+        const parsed = SavePatchFileResponse.safeParse(await res.json());
+        if (parsed.success) {
+          return {
+            patchId: parsed.data.patchId,
+            filePath: parsed.data.filePath
+          };
+        }
+        return {
+          error: {
+            message: `Could not parse save patch file response. Error: ${fromError(parsed.error)}`
+          }
+        };
+      }
+      return {
+        error: {
+          message: "Could not save patch file. HTTP error: " + res.status + " " + res.statusText
+        }
+      };
+    }).catch(e => {
+      return {
+        error: {
+          message: `Could save source binary file in patch (connection error?): ${e.toString()}`
+        }
+      };
+    });
   }
   async getHttpFiles(files) {
     const params = new URLSearchParams();
@@ -3565,7 +3713,7 @@ class ValOpsHttp extends ValOps {
     params.set("body_sha",
     // We use this for cache invalidation
     Internal.getSHA256Hash(textEncoder.encode(stringifiedFiles)));
-    return fetch(`${this.hostUrl}/v1/${this.project}/files?${params}`, {
+    return fetch(`${this.contentUrl}/v1/${this.project}/files?${params}`, {
       method: "PUT",
       // Yes, PUT is weird. Weirder to have a body in a GET request.
       headers: {
@@ -3658,7 +3806,7 @@ class ValOpsHttp extends ValOps {
     const params = new URLSearchParams();
     params.set("file_path", filePath);
     try {
-      const metadataRes = await fetch(`${this.hostUrl}/v1/${this.project}/patches/${patchId}/files?${params}`, {
+      const metadataRes = await fetch(`${this.contentUrl}/v1/${this.project}/patches/${patchId}/files?${params}`, {
         headers: {
           ...this.authHeaders,
           "Content-Type": "application/json"
@@ -3712,7 +3860,7 @@ class ValOpsHttp extends ValOps {
     };
   }
   async deletePatches(patchIds) {
-    return fetch(`${this.hostUrl}/v1/${this.project}/patches`, {
+    return fetch(`${this.contentUrl}/v1/${this.project}/patches`, {
       method: "DELETE",
       headers: {
         ...this.authHeaders,
@@ -3758,11 +3906,44 @@ class ValOpsHttp extends ValOps {
       };
     });
   }
-  async commit(prepared, message, committer, newBranch) {
+  async getCommitMessage(preparedCommit) {
+    var _res$headers$get3;
+    const res = await fetch(`${this.contentUrl}/v1/${this.project}/commit-summary`, {
+      method: "POST",
+      headers: {
+        ...this.authHeaders,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        patchedSourceFiles: preparedCommit.patchedSourceFiles,
+        previousSourceFiles: preparedCommit.previousSourceFiles
+      })
+    });
+    if (res.ok) {
+      const json = await res.json();
+      return {
+        commitSummary: json.commitSummary
+      };
+    }
+    if ((_res$headers$get3 = res.headers.get("Content-Type")) !== null && _res$headers$get3 !== void 0 && _res$headers$get3.includes("application/json")) {
+      const json = await res.json();
+      return {
+        error: {
+          message: json.message
+        }
+      };
+    }
+    return {
+      error: {
+        message: "Could not get commit message. HTTP error: " + res.status + " " + res.statusText
+      }
+    };
+  }
+  async commit(prepared, message, committer, filesDirectory, newBranch) {
     try {
-      var _res$headers$get2;
+      var _res$headers$get4;
       const existingBranch = this.branch;
-      const res = await fetch(`${this.hostUrl}/v1/${this.project}/commit`, {
+      const res = await fetch(`${this.contentUrl}/v1/${this.project}/commit`, {
         method: "POST",
         headers: {
           ...this.authHeaders,
@@ -3774,6 +3955,7 @@ class ValOpsHttp extends ValOps {
           appliedPatches: prepared.appliedPatches,
           commit: this.commitSha,
           root: this.root,
+          filesDirectory,
           baseSha: await this.getBaseSha(),
           committer,
           message,
@@ -3796,7 +3978,7 @@ class ValOpsHttp extends ValOps {
           }
         };
       }
-      if ((_res$headers$get2 = res.headers.get("Content-Type")) !== null && _res$headers$get2 !== void 0 && _res$headers$get2.includes("application/json")) {
+      if ((_res$headers$get4 = res.headers.get("Content-Type")) !== null && _res$headers$get4 !== void 0 && _res$headers$get4.includes("application/json")) {
         const json = await res.json();
         if (json.isNotFastForward) {
           return {
@@ -3828,8 +4010,8 @@ class ValOpsHttp extends ValOps {
 
   // #region profiles
   async getProfiles() {
-    var _res$headers$get3;
-    const res = await fetch(`${this.hostUrl}/v1/${this.project}/profiles`, {
+    var _res$headers$get5;
+    const res = await fetch(`${this.contentUrl}/v1/${this.project}/profiles`, {
       headers: {
         ...this.authHeaders,
         "Content-Type": "application/json"
@@ -3843,7 +4025,7 @@ class ValOpsHttp extends ValOps {
       }
       return parsed.data.profiles;
     }
-    if ((_res$headers$get3 = res.headers.get("Content-Type")) !== null && _res$headers$get3 !== void 0 && _res$headers$get3.includes("application/json")) {
+    if ((_res$headers$get5 = res.headers.get("Content-Type")) !== null && _res$headers$get5 !== void 0 && _res$headers$get5.includes("application/json")) {
       const json = await res.json();
       throw Error(`Could not get profiles (status: ${res.status}): ${"message" in json ? json.message : "Unknown error"}`);
     }
@@ -3881,6 +4063,7 @@ const ValServer = (valModules, options, callbacks) => {
     url.searchParams.set("state", token);
     return url.toString();
   };
+  const commit = options.mode === "http" ? options.commit : undefined;
   const getAppErrorUrl = error => {
     if (!options.project) {
       throw new Error("Project is not set");
@@ -4343,6 +4526,22 @@ const ValServer = (valModules, options, callbacks) => {
           ...req.body,
           profileId: "id" in auth ? auth.id : undefined
         });
+        if (currentStat.type === "error" && currentStat.networkError) {
+          return {
+            status: 503,
+            json: {
+              message: "Network error"
+            }
+          };
+        }
+        if (currentStat.type === "error" && currentStat.unauthorized) {
+          return {
+            status: 401,
+            json: {
+              message: "Unauthorized"
+            }
+          };
+        }
         if (currentStat.type === "error") {
           return {
             status: 500,
@@ -4353,6 +4552,7 @@ const ValServer = (valModules, options, callbacks) => {
           status: 200,
           json: {
             ...currentStat,
+            mode: serverOps instanceof ValOpsFS ? "fs" : serverOps instanceof ValOpsHttp ? "http" : "unknown",
             config: options.config
           }
         };
@@ -4380,7 +4580,7 @@ const ValServer = (valModules, options, callbacks) => {
           };
         }
         const patches = req.body.patches;
-        const parentRef = req.body.parentRef;
+        let parentRef = req.body.parentRef;
         const authorId = "id" in auth ? auth.id : null;
         const newPatchIds = [];
         for (const patch of patches) {
@@ -4411,6 +4611,10 @@ const ValServer = (valModules, options, callbacks) => {
               };
             }
           } else {
+            parentRef = {
+              type: "patch",
+              patchId: createPatchRes.value.patchId
+            };
             newPatchIds.push(createPatchRes.value.patchId);
           }
         }
@@ -4418,10 +4622,7 @@ const ValServer = (valModules, options, callbacks) => {
           status: 200,
           json: {
             newPatchIds,
-            parentRef: {
-              type: "patch",
-              patchId: newPatchIds[newPatchIds.length - 1]
-            }
+            parentRef
           }
         };
       },
@@ -4446,13 +4647,10 @@ const ValServer = (valModules, options, callbacks) => {
             }
           };
         }
-        const omit_patch = query.omit_patch === true;
-        const authors = query.author;
+        const excludePatchOps = query.exclude_patch_ops === true;
         const fetchedPatchesRes = await serverOps.fetchPatches({
-          authors,
           patchIds: query.patch_id,
-          omitPatch: omit_patch,
-          moduleFilePaths: query.module_file_path
+          excludePatchOps: excludePatchOps
         });
         if (fetchedPatchesRes.error) {
           // Error is singular
@@ -4633,8 +4831,17 @@ const ValServer = (valModules, options, callbacks) => {
         }
         const patchOps = await serverOps.fetchPatches({
           patchIds: undefined,
-          omitPatch: false
+          excludePatchOps: false
         });
+        // We check authorization here, because it is the first call to the backend
+        if (patchOps.error && patchOps.unauthorized) {
+          return {
+            status: 401,
+            json: {
+              message: "Unauthorized"
+            }
+          };
+        }
         const patchAnalysis = serverOps.analyzePatches(patchOps.patches);
         let sourcesRes = await serverOps.getSources();
         const onlyPatchedTreeModules = await serverOps.getSources({
@@ -4713,17 +4920,16 @@ const ValServer = (valModules, options, callbacks) => {
     },
     "/profiles": {
       GET: async req => {
-        // const cookies = req.cookies;
-        // const auth = getAuth(cookies);
-        // if (auth.error) {
-        //   return {
-        //     status: 401,
-        //     json: {
-        //       message: auth.error,
-        //     },
-        //   };
-        // }
-
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
         const profiles = await serverOps.getProfiles();
         return {
           status: 200,
@@ -4733,6 +4939,49 @@ const ValServer = (valModules, options, callbacks) => {
         };
       }
     },
+    "/commit-summary": {
+      GET: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        const query = req.query;
+        const patchIds = query.patch_id;
+        const patches = await serverOps.fetchPatches({
+          patchIds,
+          excludePatchOps: false
+        });
+        const analysis = serverOps.analyzePatches(patches.patches, patches.commits, commit);
+        const preparedCommit = await serverOps.prepare({
+          ...analysis,
+          ...patches
+        });
+        const res = await serverOps.getCommitSummary(preparedCommit);
+        if (res.error) {
+          console.error("Failed to summarize", res.error);
+          return {
+            status: 400,
+            json: {
+              message: res.error.message
+            }
+          };
+        }
+        return {
+          status: 200,
+          json: {
+            baseSha: await serverOps.getBaseSha(),
+            patchIds,
+            commitSummary: res.commitSummary
+          }
+        };
+      }
+    },
     "/save": {
       POST: async req => {
         const cookies = req.cookies;
@@ -4765,9 +5014,9 @@ const ValServer = (valModules, options, callbacks) => {
         } = bodyRes.data;
         const patches = await serverOps.fetchPatches({
           patchIds,
-          omitPatch: false
+          excludePatchOps: false
         });
-        const analysis = serverOps.analyzePatches(patches.patches);
+        const analysis = serverOps.analyzePatches(patches.patches, patches.commits, commit);
         const preparedCommit = await serverOps.prepare({
           ...analysis,
           ...patches
@@ -4799,7 +5048,24 @@ const ValServer = (valModules, options, callbacks) => {
           };
         } else if (serverOps instanceof ValOpsHttp) {
           if (auth.error === undefined && auth.id) {
-            const commitRes = await serverOps.commit(preparedCommit, "Update content: " + Object.keys(analysis.patchesByModule) + " modules changed", auth.id);
+            var _options$config$ai, _options$config$files;
+            let message = body.message || "Update content: " + Object.keys(analysis.patchesByModule) + " modules changed";
+            if (!((_options$config$ai = options.config.ai) !== null && _options$config$ai !== void 0 && (_options$config$ai = _options$config$ai.commitMessages) !== null && _options$config$ai !== void 0 && _options$config$ai.disabled)) {
+              const res = await serverOps.getCommitMessage(preparedCommit);
+              console.log({
+                res
+              });
+              if (res.error) {
+                // ignore
+                console.error("Failed to get commit message", res.error.message);
+              } else {
+                message = res.commitSummary;
+              }
+            }
+            console.log({
+              message
+            });
+            const commitRes = await serverOps.commit(preparedCommit, message, auth.id, ((_options$config$files = options.config.files) === null || _options$config$files === void 0 ? void 0 : _options$config$files.directory) || "/public/val");
             if (commitRes.error) {
               console.error("Failed to commit", commitRes.error);
               if ("isNotFastForward" in commitRes && commitRes.isNotFastForward) {