@builder.io/ai-utils 0.81.1 → 0.81.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.81.1",
+  "version": "0.81.3",
   "description": "Builder.io AI utils",
   "files": [
     "src"

package/src/builder-config.d.ts

@@ -20,18 +20,18 @@ export declare const BuilderConfigDatabaseSchema: z.ZodObject<{
 export type BuilderConfigDatabase = z.infer<typeof BuilderConfigDatabaseSchema>;
 /** `hosting` block in `builder.config.json` — see First Class Hosting spec. */
 export declare const BuilderConfigHostingEnvironmentSchema: z.ZodObject<{
-    build: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    prod: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    build: z.ZodCatch<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodString>>>>;
+    prod: z.ZodCatch<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodString>>>>;
 }, z.core.$strip>;
 export type BuilderConfigHostingEnvironment = z.infer<typeof BuilderConfigHostingEnvironmentSchema>;
 export declare const BuilderConfigHostingSchema: z.ZodObject<{
-    buildCommand: z.ZodOptional<z.ZodString>;
-    nodeVersion: z.ZodOptional<z.ZodString>;
-    buildOutputDir: z.ZodOptional<z.ZodString>;
-    environment: z.ZodOptional<z.ZodObject<{
-        build: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        prod: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>>;
+    buildCommand: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    nodeVersion: z.ZodCatch<z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>>;
+    buildOutputDir: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    environment: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        build: z.ZodCatch<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodString>>>>;
+        prod: z.ZodCatch<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodString>>>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type BuilderConfigHosting = z.infer<typeof BuilderConfigHostingSchema>;
 export declare const BuilderConfigSchema: z.ZodObject<{
@@ -41,13 +41,13 @@ export declare const BuilderConfigSchema: z.ZodObject<{
         schemaDir: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     hosting: z.ZodOptional<z.ZodObject<{
-        buildCommand: z.ZodOptional<z.ZodString>;
-        nodeVersion: z.ZodOptional<z.ZodString>;
-        buildOutputDir: z.ZodOptional<z.ZodString>;
-        environment: z.ZodOptional<z.ZodObject<{
-            build: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            prod: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strip>>;
+        buildCommand: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        nodeVersion: z.ZodCatch<z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>>;
+        buildOutputDir: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        environment: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            build: z.ZodCatch<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodString>>>>;
+            prod: z.ZodCatch<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodString>>>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BuilderConfig = z.infer<typeof BuilderConfigSchema>;

package/src/builder-config.js

@@ -17,16 +17,45 @@ export const BuilderConfigDatabaseSchema = z.object({
     migrations: z.literal("drizzle"),
     schemaDir: z.string().default("drizzle"),
 });
+/**
+ * Env values are always strings at runtime, but JSON authors commonly write
+ * booleans/numbers (e.g. `"DISABLE_AUTH": true`). Coerce them to strings rather
+ * than rejecting, and drop any single value that can't be coerced (object/array/
+ * null) instead of failing the whole map — a malformed value must not silently
+ * discard the entire hosting config downstream.
+ */
+const HostingEnvRecordSchema = z.preprocess((input) => {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return input;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            result[key] = String(value);
+        }
+    }
+    return result;
+}, z.record(z.string(), z.string()));
 /** `hosting` block in `builder.config.json` — see First Class Hosting spec. */
 export const BuilderConfigHostingEnvironmentSchema = z.object({
-    build: z.record(z.string(), z.string()).optional(),
-    prod: z.record(z.string(), z.string()).optional(),
+    build: HostingEnvRecordSchema.optional().catch(undefined),
+    prod: HostingEnvRecordSchema.optional().catch(undefined),
 });
+// `nodeVersion` is commonly authored as a JSON number (e.g. `"nodeVersion": 20`),
+// so coerce it to a string. `buildCommand`/`buildOutputDir` accept strings only.
+const NodeVersionSchema = z
+    .union([z.string(), z.number()])
+    .transform((value) => String(value));
+// `.catch(undefined)` per field so one malformed field (e.g. an object-valued
+// buildOutputDir) is dropped individually instead of invalidating the whole
+// hosting block.
 export const BuilderConfigHostingSchema = z.object({
-    buildCommand: z.string().optional(),
-    nodeVersion: z.string().optional(),
-    buildOutputDir: z.string().optional(),
-    environment: BuilderConfigHostingEnvironmentSchema.optional(),
+    buildCommand: z.string().optional().catch(undefined),
+    nodeVersion: NodeVersionSchema.optional().catch(undefined),
+    buildOutputDir: z.string().optional().catch(undefined),
+    environment: BuilderConfigHostingEnvironmentSchema.optional().catch(undefined),
 });
 export const BuilderConfigSchema = z.object({
     database: BuilderConfigDatabaseSchema.optional(),

package/src/builder-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/builder-config.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { BuilderConfigHostingSchema } from "./builder-config";
+describe("BuilderConfigHostingSchema", () => {
+    it("coerces boolean/number env values to strings", () => {
+        var _a, _b;
+        const parsed = BuilderConfigHostingSchema.parse({
+            buildOutputDir: "dist",
+            environment: {
+                prod: { DISABLE_AUTH: true },
+                build: { PORT: 3000, NITRO_PRESET: "netlify" },
+            },
+        });
+        expect(parsed.buildOutputDir).toBe("dist");
+        expect((_a = parsed.environment) === null || _a === void 0 ? void 0 : _a.prod).toEqual({ DISABLE_AUTH: "true" });
+        expect((_b = parsed.environment) === null || _b === void 0 ? void 0 : _b.build).toEqual({
+            PORT: "3000",
+            NITRO_PRESET: "netlify",
+        });
+    });
+    it("coerces a numeric nodeVersion to a string", () => {
+        const parsed = BuilderConfigHostingSchema.parse({
+            nodeVersion: 20,
+            buildOutputDir: "dist",
+        });
+        expect(parsed.nodeVersion).toBe("20");
+        expect(parsed.buildOutputDir).toBe("dist");
+    });
+    it("does not coerce numeric buildCommand/buildOutputDir (strings only)", () => {
+        const parsed = BuilderConfigHostingSchema.parse({
+            buildCommand: 123,
+            buildOutputDir: 456,
+            nodeVersion: "20",
+        });
+        expect(parsed.buildCommand).toBeUndefined();
+        expect(parsed.buildOutputDir).toBeUndefined();
+        expect(parsed.nodeVersion).toBe("20");
+    });
+    it("drops a single uncoercible env value but keeps the rest of the block", () => {
+        var _a;
+        const parsed = BuilderConfigHostingSchema.parse({
+            buildOutputDir: "dist",
+            environment: {
+                prod: { GOOD: "yes", BAD: { nested: "object" } },
+            },
+        });
+        expect(parsed.buildOutputDir).toBe("dist");
+        expect((_a = parsed.environment) === null || _a === void 0 ? void 0 : _a.prod).toEqual({ GOOD: "yes" });
+    });
+    it("drops a malformed field instead of invalidating the whole block", () => {
+        const parsed = BuilderConfigHostingSchema.parse({
+            buildCommand: "npm run build",
+            buildOutputDir: { nested: "object" },
+        });
+        expect(parsed.buildCommand).toBe("npm run build");
+        expect(parsed.buildOutputDir).toBeUndefined();
+    });
+});

package/src/projects.d.ts

@@ -487,7 +487,9 @@ export interface OrgAgentConfig {
     enabledTools: string[];
     longLived: boolean;
 }
-export type BranchType = "code-review" | "setup-project" | "org-agent" | "snapshot-build" | "design-system-indexing" | "deploy" | "default";
+export type BranchType = "code-review" | "setup-project"
+/** Hidden branch the webapp creates when the user picks manual setup. */
+ | "manual-setup" | "org-agent" | "snapshot-build" | "design-system-indexing" | "deploy" | "default";
 /** Category of work a branch represents, auto-assigned during prompt analysis. */
 export type BranchCategory = "feature" | "fix" | "research" | "other";
 export interface BranchSharedData {
@@ -1735,4 +1737,9 @@ export declare const DuplicateBranchOptionsSchema: z.ZodObject<{
     friendlyName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type DuplicateBranchOptions = z.infer<typeof DuplicateBranchOptionsSchema>;
+export declare const EnsureMainBranchExistsOptionsSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    branchName: z.ZodString;
+}, z.core.$strip>;
+export type EnsureMainBranchExistsOptions = z.infer<typeof EnsureMainBranchExistsOptionsSchema>;
 export {};

package/src/projects.js

@@ -659,3 +659,11 @@ export const DuplicateBranchOptionsSchema = z.object({
         description: "Optional friendly (display) name for the new branch.",
     }),
 });
+export const EnsureMainBranchExistsOptionsSchema = z.object({
+    projectId: z.string().min(1).meta({
+        description: "Project to ensure the main branch exists for.",
+    }),
+    branchName: z.string().min(1).meta({
+        description: "Branch whose head ref seeds the main branch when it doesn't exist yet. No-op for non-internalHost projects.",
+    }),
+});