@valbuild/server 0.94.0 → 0.95.0

package/dist/valbuild-server.esm.js

@@ -2374,8 +2374,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 (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") {
@@ -2767,11 +2767,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
         };
       }
@@ -2942,7 +2948,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();
@@ -2952,6 +2958,7 @@ class ValOpsFS extends ValOps {
         parentRef,
         path,
         authorId,
+        sessionId,
         baseSha,
         coreVersion: Internal.VERSION.core,
         createdAt: new Date().toISOString()
@@ -3390,12 +3397,6 @@ class ValOpsFS extends ValOps {
     return 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__default.join(this.rootDir, ValOpsFS.VAL_DIR, "patches");
@@ -3504,7 +3505,9 @@ const FSPatch = z.object({
   parentRef: ParentRef,
   authorId: z.string().refine(p => true).nullable(),
   createdAt: z.string().datetime(),
-  coreVersion: z.string().nullable() // TODO: use this to check if patch is compatible with current core version?
+  coreVersion: z.string().nullable(),
+  // TODO: use this to check if patch is compatible with current core version?
+  sessionId: z.string().nullable()
 });
 const FSPatchBase = z.object({
   baseSha: z.string().refine(p => true),
@@ -3606,17 +3609,6 @@ const CommitResponse = z.object({
   commit: CommitSha,
   branch: z.string()
 });
-const ProfilesResponse = z.object({
-  profiles: z.array(z.object({
-    profileId: z.string(),
-    fullName: z.string(),
-    email: z.string().optional(),
-    // TODO: make this required once this can be guaranteed
-    avatar: z.object({
-      url: z.string()
-    }).nullable()
-  }))
-});
 const NonceResponse = z.object({
   nonce: z.string(),
   url: z.string()
@@ -4067,7 +4059,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",
@@ -4079,6 +4071,7 @@ class ValOpsHttp extends ValOps {
         path,
         patch,
         authorId,
+        sessionId,
         patchId,
         parentPatchId: parentRef.type === "patch" ? parentRef.patchId : null,
         baseSha,
@@ -4502,31 +4495,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 = 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 || DEFAULT_CONTENT_HOST;
@@ -4679,6 +4647,16 @@ function hasRemoteFileSchema(schema) {
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 const ValServer = (valModules, options, callbacks) => {
+  const ProfilesResponse = z.object({
+    profiles: z.array(z.object({
+      profileId: z.string(),
+      fullName: z.string(),
+      email: z.string().optional(),
+      avatar: z.object({
+        url: z.string()
+      }).nullable()
+    }))
+  });
   let serverOps;
   if (options.mode === "fs") {
     serverOps = new ValOpsFS(options.valContentUrl, options.cwd, valModules, {
@@ -5528,10 +5506,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 (result.isErr(createPatchRes)) {
             if (createPatchRes.error.errorType === "patch-head-conflict") {
               return {
@@ -5892,13 +5871,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: " + 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": {
@@ -6080,6 +6133,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 = z.object({
+              sessions: z.array(z.object({
+                id: z.string(),
+                name: z.string().nullable(),
+                createdAt: z.string(),
+                updatedAt: z.string()
+              })),
+              nextCursor: z.object({
+                updatedAt: z.string(),
+                id: 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: " + 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 = z.object({
+              messages: z.array(z.object({
+                role: z.string(),
+                content: z.string()
+              })),
+              nextCursor: z.object({
+                updatedAt: z.string(),
+                id: 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: " + 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 => {
@@ -6301,6 +6729,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 {

package/package.json

@@ -16,7 +16,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.94.0",
+  "version": "0.95.0",
   "devDependencies": {
     "@prettier/sync": "^0.6.1",
     "@types/jest": "^30.0.0"
@@ -30,9 +30,9 @@
     "typescript": "^5.9.3",
     "zod": "^4.3.5",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.94.0",
-    "@valbuild/shared": "0.94.0",
-    "@valbuild/ui": "0.94.0"
+    "@valbuild/core": "0.95.0",
+    "@valbuild/shared": "0.95.0",
+    "@valbuild/ui": "0.95.0"
   },
   "engines": {
     "node": ">=18.17.0"