@vertesia/ui 1.5.0 → 1.6.0-dev.20260918.061604Z

package/src/boot/vite.ts

@@ -0,0 +1,118 @@
+/** Node-only adapter. Import from @vertesia/ui/boot/vite, never from browser code. */
+import { readFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { type AppBranding, brandedBootOptions, escapeBrandHtml } from './branding.js';
+import { injectBootScreenHtml } from './index.js';
+
+const VIRTUAL_ID = 'virtual:vertesia-branding';
+const RESOLVED_ID = `\0${VIRTUAL_ID}`;
+const MIME: Record<string, string> = {
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.woff2': 'font/woff2',
+    '.woff': 'font/woff',
+    '.otf': 'font/otf',
+    '.ttf': 'font/ttf',
+    '.avif': 'image/avif',
+};
+
+/** Inline local assets so React and pre-React markup work under any gateway base path. */
+export function resolveBrandingAssets(branding: AppBranding, moduleUrl: URL, watch: (file: string) => void = () => {}) {
+    function asset(value: string, base = moduleUrl): string {
+        if (/^(https?:|data:|#)/i.test(value)) return value;
+        const url = new URL(value, base);
+        if (url.protocol !== 'file:') throw new Error(`Unsupported branding asset URL: ${value}`);
+        const file = fileURLToPath(url);
+        const mime = MIME[extname(file).toLowerCase()];
+        if (!mime) throw new Error(`Unsupported branding asset type: ${file}`);
+        watch(file);
+        return `data:${mime};base64,${readFileSync(file).toString('base64')}`;
+    }
+    function source(value: string, css: boolean): string {
+        const url = new URL(value, moduleUrl);
+        const file = fileURLToPath(url);
+        watch(file);
+        const text = readFileSync(file, 'utf8');
+        return css
+            ? text.replace(
+                  /url\(\s*['"]?([^'"\s)]+)['"]?\s*\)/g,
+                  (_match, path: string) => `url("${asset(path, url)}")`,
+              )
+            : text.replace(
+                  /(<(?:img|source|link)\b[^>]*?\s)(src|href)=["']([^"']+)["']/gi,
+                  (_match, tag: string, attr: string, path: string) =>
+                      `${tag}${attr}="${escapeBrandHtml(asset(path, url))}"`,
+              );
+    }
+    return {
+        ...branding,
+        logo: branding.logo && {
+            ...branding.logo,
+            light: asset(branding.logo.light),
+            dark: branding.logo.dark ? asset(branding.logo.dark) : undefined,
+        },
+        loadingIcon: branding.loadingIcon && {
+            ...branding.loadingIcon,
+            light: asset(branding.loadingIcon.light),
+            dark: branding.loadingIcon.dark ? asset(branding.loadingIcon.dark) : undefined,
+        },
+        favicon: branding.favicon ? asset(branding.favicon) : undefined,
+        font: branding.font && {
+            ...branding.font,
+            regular: asset(branding.font.regular),
+            bold: branding.font.bold ? asset(branding.font.bold) : undefined,
+        },
+        boot: branding.boot && {
+            html: branding.boot.html ? source(branding.boot.html, false) : undefined,
+            styles: branding.boot.styles ? source(branding.boot.styles, true) : undefined,
+        },
+    } satisfies AppBranding;
+}
+
+export function createAppBrandingPlugin(branding: AppBranding, moduleUrl: URL) {
+    const watched = new Set<string>();
+    const resolve = () => resolveBrandingAssets(branding, moduleUrl, (file) => watched.add(file));
+    return {
+        name: 'vertesia-app-branding',
+        resolveId(id: string) {
+            if (id === VIRTUAL_ID) return RESOLVED_ID;
+        },
+        load(this: { addWatchFile(file: string): void }, id: string) {
+            if (id !== RESOLVED_ID) return;
+            const resolved = resolve();
+            for (const file of watched) this.addWatchFile(file);
+            return `export default ${JSON.stringify(resolved)};`;
+        },
+        handleHotUpdate<Module>(context: {
+            file: string;
+            server: {
+                moduleGraph: { getModuleById(id: string): Module | undefined; invalidateModule(module: Module): void };
+                ws: { send(payload: { type: 'full-reload' }): void };
+            };
+        }) {
+            if (!watched.has(context.file)) return;
+            const module = context.server.moduleGraph.getModuleById(RESOLVED_ID);
+            if (module) context.server.moduleGraph.invalidateModule(module);
+            context.server.ws.send({ type: 'full-reload' });
+            return [];
+        },
+        transformIndexHtml(html: string) {
+            const resolved = resolve();
+            const title = escapeBrandHtml(resolved.title ?? resolved.name);
+            let result = html.replace(/<title\b[^>]*>[\s\S]*?<\/title>/i, `<title>${title}</title>`);
+            if (resolved.favicon) {
+                result = result.replace(/<link\b(?=[^>]*\brel=["'](?:shortcut )?icon["'])[^>]*>/gi, '');
+                result = result.replace(
+                    '</head>',
+                    `<link rel="icon" href="${escapeBrandHtml(resolved.favicon)}"></head>`,
+                );
+            }
+            return injectBootScreenHtml(result, brandedBootOptions(resolved));
+        },
+    };
+}

package/src/core/components/shadcn/button.tsx

@@ -5,7 +5,6 @@ import { Slot } from '@radix-ui/react-slot';
 // pinned to the fallback language regardless of LanguageProvider changes.
 import { useUITranslation } from '@vertesia/ui/i18n';
 import { cva, type VariantProps } from 'class-variance-authority';
-import clsx from 'clsx';
 import { Check, CopyIcon, Loader2 } from 'lucide-react';
 import * as React from 'react';
 import { useEffect, useState } from 'react';
@@ -149,7 +148,7 @@ const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
 
         const buttonElement = (
             <Comp
-                className={clsx(cn(buttonVariants({ variant, size })), className)}
+                className={cn(buttonVariants({ variant, size }), className)}
                 disabled={isDisabled || isLoading || props.disabled}
                 ref={ref}
                 onClick={onClick}

package/src/core/components/shadcn/filters/filter-styles.ts

@@ -20,13 +20,13 @@ export const calendarStyles = `
   min-width: 32px !important;
   height: 32px !important;
   border-radius: 4px !important;
-  border: 1px solid hsl(var(--border)) !important;
-  background: hsl(var(--background)) !important;
-  color: hsl(var(--foreground)) !important;
+  border: 1px solid var(--border) !important;
+  background: var(--background) !important;
+  color: var(--foreground) !important;
 }
 
 .calendar-wrapper .react-calendar__navigation__arrow:hover {
-  background: oklch(var(--muted)) !important;
+  background: var(--muted) !important;
 }
 
 .calendar-wrapper .react-calendar__tile {

package/src/core/components/shadcn/label.tsx

@@ -17,7 +17,7 @@ const Label: React.ForwardRefExoticComponent<
     ({ className, required, ...props }, ref) => (
         <LabelPrimitive.Root ref={ref} className={cn(labelVariants(), className)} {...props}>
             {props.children}
-            {required && <span className="text-destructive-foreground ms-1">*</span>}
+            {required && <span className="text-destructive ms-1">*</span>}
         </LabelPrimitive.Root>
     ),
 );

package/src/env/index.test.ts

@@ -92,3 +92,130 @@ describe('VertesiaEnvironment runtime configuration', () => {
         expect(window.AUTH_MODE).toBe('central');
     });
 });
+
+describe('VertesiaEnvironment build configuration', () => {
+    const buildEnv = {
+        VITE_FIREBASE_API_KEY: 'build-key',
+        VITE_FIREBASE_AUTH_DOMAIN: 'project.firebaseapp.com',
+        VITE_FIREBASE_PROJECT_ID: 'project',
+        VITE_FIREBASE_APP_ID: 'build-app',
+    };
+
+    afterEach(() => vi.unstubAllGlobals());
+
+    it('enables Firebase only with an explicit mode and complete build settings', () => {
+        vi.stubGlobal('window', {});
+        const env = new VertesiaEnvironment().init(baseProps, { ...buildEnv, VITE_AUTH_MODE: 'firebase' });
+        expect(env.firebase?.apiKey).toBe('build-key');
+        expect(env.firebase?.authDomain).toBe('project.firebaseapp.com');
+        expect(window.AUTH_MODE).toBe('firebase');
+    });
+
+    it.each([buildEnv, { VITE_FIREBASE_API_KEY: 'unused-key' }])(
+        'retains central auth when Firebase values exist without an explicit mode',
+        (settings) => {
+            vi.stubGlobal('window', {});
+            const env = new VertesiaEnvironment().init(baseProps, settings);
+            expect(env.firebase).toBeUndefined();
+            expect(window.AUTH_MODE).toBeUndefined();
+        },
+    );
+
+    it('allows explicit central mode even with Firebase build settings', () => {
+        vi.stubGlobal('window', {});
+        const env = new VertesiaEnvironment().init(baseProps, { ...buildEnv, VITE_AUTH_MODE: 'central' });
+        expect(env.firebase).toBeUndefined();
+        expect(window.AUTH_MODE).toBe('central');
+    });
+
+    it('rejects incomplete settings when Firebase is selected', () => {
+        vi.stubGlobal('window', {});
+        expect(() =>
+            new VertesiaEnvironment().init(baseProps, {
+                VITE_AUTH_MODE: 'firebase',
+                VITE_FIREBASE_API_KEY: 'key',
+            }),
+        ).toThrow('VITE_FIREBASE_AUTH_DOMAIN, VITE_FIREBASE_PROJECT_ID, VITE_FIREBASE_APP_ID');
+    });
+
+    it('rejects an unknown mode', () => {
+        vi.stubGlobal('window', {});
+        expect(() => new VertesiaEnvironment().init(baseProps, { VITE_AUTH_MODE: 'typo' })).toThrow(
+            'VITE_AUTH_MODE must be firebase or central',
+        );
+    });
+
+    it('preserves gateway Firebase configuration ahead of conflicting build settings', () => {
+        const firebase = {
+            apiKey: 'runtime-key',
+            authDomain: 'gateway.example.com',
+            projectId: 'runtime',
+            appId: 'runtime-app',
+        };
+        vi.stubGlobal('window', { __VERTESIA_RUNTIME_CONFIG__: { authMode: 'firebase', firebase } });
+        const env = new VertesiaEnvironment().init(baseProps, { VITE_AUTH_MODE: 'central' });
+        expect(env.firebase).toEqual(firebase);
+        expect(window.AUTH_MODE).toBe('firebase');
+    });
+
+    it('preserves gateway central mode ahead of Firebase build settings', () => {
+        vi.stubGlobal('window', { __VERTESIA_RUNTIME_CONFIG__: { authMode: 'central' } });
+        const env = new VertesiaEnvironment().init(baseProps, buildEnv);
+        expect(env.firebase).toBeUndefined();
+        expect(window.AUTH_MODE).toBe('central');
+    });
+
+    it('leaves the existing central default unchanged without settings', () => {
+        vi.stubGlobal('window', {});
+        const env = new VertesiaEnvironment().init(baseProps, {});
+        expect(env.firebase).toBeUndefined();
+        expect(window.AUTH_MODE).toBeUndefined();
+    });
+});
+
+describe('build-time default workspace', () => {
+    it('reads and trims Vertesia IDs independently of the Firebase project', () => {
+        const env = new VertesiaEnvironment().init(baseProps, {
+            VITE_VERTESIA_ACCOUNT_ID: ' account-1 ',
+            VITE_VERTESIA_PROJECT_ID: ' project-1 ',
+        });
+        expect(env.defaultAuthSelection).toEqual({ accountId: 'account-1', projectId: 'project-1' });
+    });
+    it('ignores blank settings and preserves an explicit selection as a whole pair', () => {
+        expect(
+            new VertesiaEnvironment().init(baseProps, { VITE_VERTESIA_ACCOUNT_ID: ' ' }).defaultAuthSelection,
+        ).toBeUndefined();
+        const env = new VertesiaEnvironment().init(
+            { ...baseProps, defaultAuthSelection: { accountId: 'explicit' } },
+            { VITE_VERTESIA_ACCOUNT_ID: 'build', VITE_VERTESIA_PROJECT_ID: 'other-project' },
+        );
+        expect(env.defaultAuthSelection).toEqual({ accountId: 'explicit' });
+    });
+});
+
+describe('fixed Firebase tenant', () => {
+    afterEach(() => vi.unstubAllGlobals());
+
+    it('combines an app tenant with gateway credentials', () => {
+        vi.stubGlobal('window', {
+            __VERTESIA_RUNTIME_CONFIG__: {
+                authMode: 'firebase',
+                firebase: {
+                    apiKey: 'gateway',
+                    authDomain: 'app.example.com',
+                    projectId: 'project',
+                    appId: 'app',
+                },
+            },
+        });
+        const env = new VertesiaEnvironment().init(baseProps, { VITE_FIREBASE_TENANT_ID: ' example-tenant ' });
+        expect(env.firebase?.tenantId).toBe('example-tenant');
+        expect(env.firebase?.apiKey).toBe('gateway');
+    });
+
+    it('does not enable Firebase just because a tenant is supplied', () => {
+        vi.stubGlobal('window', {});
+        const env = new VertesiaEnvironment().init(baseProps, { VITE_FIREBASE_TENANT_ID: 'tenant' });
+        expect(env.firebase).toBeUndefined();
+    });
+});

package/src/env/index.ts

@@ -15,6 +15,14 @@ export interface EnvProps {
         zeno: string;
         studio: string;
         sts: string; // Security Token Service endpoint
+        /**
+         * Central Auth broker that issues the sign-in redirect and hosts `/logout`.
+         *
+         * Optional: when unset the session falls back to the long-standing broker, so an app that
+         * does not set it keeps its current behaviour exactly. Set it to move one environment at a
+         * time onto a different broker.
+         */
+        auth?: string;
         git?: string; // Smart HTTP app source git endpoint
         mcp?: string;
         /** Appgen app-gateway endpoint (serves live development previews and app bundles). */
@@ -26,7 +34,11 @@ export interface EnvProps {
         projectId: string;
         appId?: string;
         providerType?: string;
+        /** Fixed Identity Platform tenant, preserved throughout sign-in. */
+        tenantId?: string;
     };
+    /** Default workspace selection when the URL does not explicitly select an account or project. */
+    defaultAuthSelection?: { accountId?: string; projectId?: string };
     region?: string;
     datadogRum?: boolean;
     datadogLogs?: boolean;
@@ -87,14 +99,68 @@ function injectedRuntimeConfig(): VertesiaRuntimeConfig | undefined {
     return runtimeConfig;
 }
 
+/** Public build-time settings, for example Vite's import.meta.env. */
+export type AppBuildEnvironment = Record<string, string | boolean | undefined>;
+
+function buildRuntimeConfig(env?: AppBuildEnvironment): VertesiaRuntimeConfig | undefined {
+    if (!env) return undefined;
+    const value = (name: string) => (typeof env[name] === 'string' ? env[name].trim() : '');
+    const mode = value('VITE_AUTH_MODE');
+    if (mode && mode !== 'firebase' && mode !== 'central') {
+        throw new Error('VITE_AUTH_MODE must be firebase or central');
+    }
+    // Firebase build settings are only consumed after an explicit opt-in.
+    if (!mode) return undefined;
+    if (mode === 'central') return { authMode: 'central' };
+    const fields = {
+        apiKey: 'VITE_FIREBASE_API_KEY',
+        authDomain: 'VITE_FIREBASE_AUTH_DOMAIN',
+        projectId: 'VITE_FIREBASE_PROJECT_ID',
+        appId: 'VITE_FIREBASE_APP_ID',
+    };
+    const missing = Object.values(fields).filter((name) => !value(name));
+    if (missing.length) {
+        throw new Error(`Firebase authentication requires: ${missing.join(', ')}`);
+    }
+    return {
+        authMode: 'firebase',
+        firebase: {
+            apiKey: value(fields.apiKey),
+            authDomain: value(fields.authDomain),
+            projectId: value(fields.projectId),
+            appId: value(fields.appId),
+        },
+    };
+}
+
 export class VertesiaEnvironment implements Readonly<EnvProps> {
     constructor(private _props?: EnvProps | undefined) {}
 
-    init(props?: EnvProps) {
-        const runtimeConfig = injectedRuntimeConfig();
+    init(props?: EnvProps, buildEnv?: AppBuildEnvironment) {
+        // Host runtime configuration takes precedence over static deployment defaults.
+        const runtimeConfig = injectedRuntimeConfig() ?? buildRuntimeConfig(buildEnv);
         const runtimeFirebase = runtimeConfig?.authMode === 'firebase' ? runtimeConfig.firebase : undefined;
         this._props = props && runtimeFirebase && !props.firebase ? { ...props, firebase: runtimeFirebase } : props;
-        if (runtimeConfig && window.AUTH_MODE === undefined) window.AUTH_MODE = runtimeConfig.authMode;
+        const tenantId =
+            typeof buildEnv?.VITE_FIREBASE_TENANT_ID === 'string' ? buildEnv.VITE_FIREBASE_TENANT_ID.trim() : '';
+        if (this._props?.firebase && tenantId && !this._props.firebase.tenantId) {
+            this._props = { ...this._props, firebase: { ...this._props.firebase, tenantId } };
+        }
+        if (this._props && this._props.defaultAuthSelection === undefined && buildEnv) {
+            const accountId =
+                typeof buildEnv.VITE_VERTESIA_ACCOUNT_ID === 'string'
+                    ? buildEnv.VITE_VERTESIA_ACCOUNT_ID.trim() || undefined
+                    : undefined;
+            const projectId =
+                typeof buildEnv.VITE_VERTESIA_PROJECT_ID === 'string'
+                    ? buildEnv.VITE_VERTESIA_PROJECT_ID.trim() || undefined
+                    : undefined;
+            if (accountId || projectId)
+                this._props = { ...this._props, defaultAuthSelection: { accountId, projectId } };
+        }
+        if (runtimeConfig && typeof window !== 'undefined' && window.AUTH_MODE === undefined) {
+            window.AUTH_MODE = runtimeConfig.authMode;
+        }
         return this;
     }
 
@@ -173,6 +239,10 @@ export class VertesiaEnvironment implements Readonly<EnvProps> {
         return this._props?.devAuthToken;
     }
 
+    get defaultAuthSelection() {
+        return this._props?.defaultAuthSelection;
+    }
+
     get authTokenProvider() {
         return this._props?.authTokenProvider;
     }

package/src/features/agent/PayloadBuilder.tsx

@@ -39,6 +39,10 @@ function getExecutableProvider(provider: ExecutionEnvironmentRef['provider']): M
 }
 
 export interface ScheduledWorkflowConfig {
+    run_as?: import('@vertesia/common').ScheduleRunAs;
+    /** Local datetime input; serialize as delegation_expires_at (ISO or null) for schedule requests. */
+    delegation_expiry_input?: string;
+    request_id?: string;
     name: string;
     description?: string;
     cron_expression: string;
@@ -328,7 +332,12 @@ export class PayloadBuilder {
                 this._model_options = interaction.model_options as ModelOptions | undefined;
                 if (interaction.runtime?.environment) {
                     const envId = interaction.runtime.environment;
-                    this.vertesia.environments.retrieve(envId).then((environment) => (this.environment = environment));
+                    this.vertesia.environments
+                        .retrieve(envId)
+                        .then((environment) => (this.environment = environment))
+                        .catch(() => {
+                            this.environment = undefined;
+                        });
                 }
             }
             this.onStateChanged();