@zenith-open/zenithcms-plugin-ai-architect-ui 1.0.0

package/dist/admin/src/lib/ApiError.js

@@ -0,0 +1,34 @@
+/**
+ * Unified, typed error for all API-layer failures.
+ *
+ * Every `api` call throws `ApiError` on failure, so callers can catch
+ * with predictable properties instead of casting `unknown` / `any`.
+ *
+ * ```ts
+ * import api from './api'
+ * import { ApiError } from './ApiError'
+ *
+ * try {
+ * await api.post('/collections', data)
+ * } catch (err) {
+ * if (err instanceof ApiError) {
+ * console.error((err as { status?: number }).status, (err as { code?: string }).code, (err instanceof Error ? err.message : String(err)))
+ * }
+ * }
+ * ```
+ */
+export class ApiError extends Error {
+    /** HTTP status code, or 0 for network/tenant errors */
+    status;
+    /** Machine-readable short code: 'ERR_NETWORK', 'ERR_NO_TENANT', 'ERR_CSRF', etc. */
+    code;
+    /** The raw response payload (if any) */
+    response;
+    constructor(opts) {
+        super(opts.message);
+        this.name = 'ApiError';
+        this.status = opts.status ?? 0;
+        this.code = opts.code ?? 'ERR_UNKNOWN';
+        this.response = opts.response;
+    }
+}

package/dist/admin/src/lib/api.d.ts

@@ -0,0 +1,31 @@
+interface ApiResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+declare const apiInstance: {
+    defaults: {
+        headers: Record<string, string>;
+    };
+    get<T = any>(path: string, config?: {
+        params?: any;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse<T>>;
+    post<T = any>(path: string, body?: any, config?: {
+        headers?: Record<string, string>;
+        params?: any;
+    }): Promise<ApiResponse<T>>;
+    patch<T = any>(path: string, body?: any, config?: {
+        headers?: Record<string, string>;
+        params?: any;
+    }): Promise<ApiResponse<T>>;
+    put<T = any>(path: string, body?: any, config?: {
+        headers?: Record<string, string>;
+        params?: any;
+    }): Promise<ApiResponse<T>>;
+    delete<T = any>(path: string, config?: {
+        headers?: Record<string, string>;
+        params?: any;
+    }): Promise<ApiResponse<T>>;
+};
+export default apiInstance;

package/dist/admin/src/lib/api.js

@@ -0,0 +1,240 @@
+import { useTenantStore } from './tenantStore';
+import { ApiError } from './ApiError';
+let isRefreshing = false;
+let failedQueue = [];
+const processQueue = (error, _token = null) => {
+    failedQueue.forEach((prom) => {
+        if (error) {
+            prom.reject(error);
+        }
+        else {
+            prom.resolve(_token);
+        }
+    });
+    failedQueue = [];
+};
+// Wrapped version ensures rejection handler throws don't break the redirect
+const safeProcessQueue = (error, token) => {
+    try {
+        processQueue(error, token);
+    }
+    catch { /* ignore — queue handlers should not throw */ }
+};
+const getCookie = (name) => {
+    if (typeof document === 'undefined')
+        return null;
+    const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+    return match ? decodeURIComponent(match[2]) : null;
+};
+// Security: Never hardcode localhost as a fallback in production.
+// If VITE_API_URL is not set, fall back to '/api/v1' (same-host relative path).
+// If the admin and API are on different hosts, VITE_API_URL must be explicitly configured.
+let BASE_URL = import.meta.env.VITE_API_URL || '/api/v1';
+if (import.meta.env.PROD && BASE_URL.startsWith('http://') && !BASE_URL.includes('localhost') && !BASE_URL.includes('127.0.0.1')) {
+    console.warn('Insecure HTTP API URL used in production. Upgrading to HTTPS.');
+    BASE_URL = BASE_URL.replace('http://', 'https://');
+}
+function buildUrl(path, config) {
+    if (path.startsWith('http'))
+        return path;
+    let url = `${BASE_URL}${path}`;
+    if (config?.params) {
+        const searchParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(config.params)) {
+            if (value !== undefined && value !== null) {
+                searchParams.append(key, String(value));
+            }
+        }
+        const qs = searchParams.toString();
+        if (qs)
+            url += (path.includes('?') ? '&' : '?') + qs;
+    }
+    return url;
+}
+function isFormData(body) {
+    return typeof FormData !== 'undefined' && body instanceof FormData;
+}
+async function fetchWithAuth(method, path, body, config) {
+    const url = buildUrl(path, config);
+    const headers = {
+        'Content-Type': 'application/json',
+        ...config?.headers,
+    };
+    const storeToken = useTenantStore.getState().token;
+    if (storeToken) {
+        headers['Authorization'] = `Bearer ${storeToken}`;
+    }
+    // Apply default headers set dynamically via api.defaults.headers
+    if (apiInstance.defaults.headers) {
+        for (const [key, value] of Object.entries(apiInstance.defaults.headers)) {
+            if (value !== undefined && !headers[key]) {
+                headers[key] = value;
+            }
+        }
+    }
+    // Ensure active site ID is dynamically set on every request to prevent tenant leaking
+    const currentSiteId = useTenantStore.getState().activeSiteId;
+    if (currentSiteId && !headers['x-zenith-site-id']) {
+        headers['x-zenith-site-id'] = currentSiteId;
+    }
+    // Hard tenant guard — abort any tenant-scoped request missing x-zenith-site-id.
+    // Exempt: auth, site listing, uploads, health, and protocol paths that run before
+    // a site is selected (globals editor, document locks, collab presence, media proxy).
+    const isTenantExempt = path.startsWith('/auth') ||
+        path === '/sites' ||
+        path.startsWith('/sites?') ||
+        path.startsWith('/sites/') ||
+        path.startsWith('/uploads') ||
+        path.startsWith('/health') ||
+        path.startsWith('/system') ||
+        path.startsWith('/globals') ||
+        path.startsWith('/locks') ||
+        path.startsWith('/presence') ||
+        path.startsWith('/media') ||
+        path.startsWith('/versions') ||
+        path.startsWith('/releases') ||
+        path.startsWith('/workspaces');
+    if (!currentSiteId && !headers['x-zenith-site-id'] && !isTenantExempt) {
+        throw new ApiError({
+            message: 'Missing tenant context: x-zenith-site-id is required for this request. ' +
+                'Ensure activeSiteId is set in localStorage before making API calls.',
+            code: 'ERR_NO_TENANT',
+        });
+    }
+    // Double-Submit Cookie CSRF for mutating requests
+    if (['post', 'put', 'delete', 'patch'].includes(method.toLowerCase())) {
+        const csrfToken = getCookie('XSRF-TOKEN');
+        if (csrfToken) {
+            headers['x-csrf-token'] = csrfToken;
+        }
+    }
+    // Don't set Content-Type for FormData (browser sets it with boundary)
+    if (isFormData(body)) {
+        delete headers['Content-Type'];
+    }
+    const fetchOptions = {
+        method,
+        headers,
+        credentials: 'include',
+    };
+    if (body !== undefined) {
+        fetchOptions.body = isFormData(body) ? body : JSON.stringify(body);
+    }
+    try {
+        return await fetch(url, fetchOptions).then(async (response) => {
+            let data;
+            try {
+                data = await response.json();
+            }
+            catch {
+                data = null;
+            }
+            return { data, status: response.status, headers: response.headers };
+        });
+    }
+    catch {
+        // Network error — throw ApiError so callers catch a consistent shape
+        throw new ApiError({ message: 'Network Error', code: 'ERR_NETWORK' });
+    }
+}
+async function request(method, path, body, config) {
+    const result = await fetchWithAuth(method, path, body, config);
+    // Handle 401 with token refresh (skip for login requests, as 401 means invalid credentials)
+    if (result.status === 401 && !path.includes('/login')) {
+        if (isRefreshing) {
+            // Queue this request until refresh completes
+            return new Promise((resolve, reject) => {
+                failedQueue.push({ resolve, reject });
+            }).then(async () => {
+                return fetchWithAuth(method, path, body, config);
+            });
+        }
+        isRefreshing = true;
+        try {
+            const newToken = await refreshToken();
+            safeProcessQueue(null, newToken);
+            return fetchWithAuth(method, path, body, config);
+        }
+        catch (refreshError) {
+            safeProcessQueue(refreshError, null);
+            if (refreshError?.status === 401 && !window.location.pathname.includes('/login')) {
+                localStorage.clear();
+                window.location.href = '/login';
+            }
+            throw refreshError;
+        }
+        finally {
+            isRefreshing = false;
+        }
+    }
+    // Throw for non-2xx status codes (ApiError with response payload)
+    if (result.status >= 400) {
+        const errorMsg = result.data?.error?.message || result.data?.message || '';
+        if (result.status === 403 && (errorMsg.includes('Access denied to this site') || errorMsg.includes('site_access') || errorMsg.includes('Forbidden'))) {
+            useTenantStore.getState().setActiveSiteId('');
+            localStorage.removeItem('activeSiteId');
+            if (!window.location.pathname.includes('/sites')) {
+                window.location.href = '/sites';
+            }
+        }
+        throw new ApiError({
+            message: result.data?.message || `Request failed with status ${result.status}`,
+            status: result.status,
+            code: 'ERR_HTTP',
+            response: { data: result.data, status: result.status, headers: result.headers },
+        });
+    }
+    return result;
+}
+async function refreshToken() {
+    const res = await fetch(`${BASE_URL}/auth/refresh`, {
+        method: 'POST',
+        credentials: 'include',
+        headers: { 'Content-Type': 'application/json' },
+    });
+    if (!res.ok)
+        throw new ApiError({ message: 'Token refresh failed', status: res.status, code: 'ERR_REFRESH' });
+    const body = await res.json();
+    const newToken = body?.token || body?.accessToken;
+    if (newToken) {
+        useTenantStore.getState().setToken(newToken);
+    }
+    return newToken || '';
+}
+const getInitialSiteId = () => {
+    if (typeof window !== 'undefined' && window.localStorage) {
+        // First try from the store (which persists), fall back to raw localStorage for backward compatibility
+        const storeSiteId = useTenantStore.getState().activeSiteId;
+        if (storeSiteId)
+            return storeSiteId;
+        const legacySiteId = window.localStorage.getItem('activeSiteId');
+        if (legacySiteId) {
+            useTenantStore.getState().setActiveSiteId(legacySiteId);
+            return legacySiteId;
+        }
+    }
+    return '';
+};
+const apiInstance = {
+    defaults: {
+        headers: {
+            ...(getInitialSiteId() ? { 'x-zenith-site-id': getInitialSiteId() } : {})
+        },
+    },
+    async get(path, config) {
+        return request('GET', path, undefined, config);
+    },
+    async post(path, body, config) {
+        return request('POST', path, body, config);
+    },
+    async patch(path, body, config) {
+        return request('PATCH', path, body, config);
+    },
+    async put(path, body, config) {
+        return request('PUT', path, body, config);
+    },
+    async delete(path, config) {
+        return request('DELETE', path, undefined, config);
+    },
+};
+export default apiInstance;

package/dist/admin/src/lib/tenantStore.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Central store for authentication and multi‑tenant context.
+ * It persists to localStorage so the values survive page reloads.
+ */
+interface TenantState {
+    token: string | null;
+    activeSiteId: string | null;
+    activeSiteName: string | null;
+    setToken: (token: string | null) => void;
+    setActiveSiteId: (siteId: string | null, siteName?: string | null) => void;
+}
+export declare const useTenantStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<TenantState>, "setState" | "persist"> & {
+    setState(partial: TenantState | Partial<TenantState> | ((state: TenantState) => TenantState | Partial<TenantState>), replace?: false | undefined): unknown;
+    setState(state: TenantState | ((state: TenantState) => TenantState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TenantState, {
+            activeSiteId: string | null;
+            activeSiteName: string | null;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TenantState) => void) => () => void;
+        onFinishHydration: (fn: (state: TenantState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<TenantState, {
+            activeSiteId: string | null;
+            activeSiteName: string | null;
+        }, unknown>>;
+    };
+}>;
+export {};

package/dist/admin/src/lib/tenantStore.js

@@ -0,0 +1,46 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+function getLegacyToken() {
+    try {
+        return localStorage.getItem('token');
+    }
+    catch {
+        return null;
+    }
+}
+function getLegacySiteId() {
+    try {
+        return localStorage.getItem('activeSiteId');
+    }
+    catch {
+        return null;
+    }
+}
+function getLegacySiteName() {
+    try {
+        return localStorage.getItem('activeSiteName');
+    }
+    catch {
+        return null;
+    }
+}
+export const useTenantStore = create()(persist((set) => ({
+    // First try the persisted store; fall back to legacy localStorage keys
+    token: getLegacyToken(),
+    activeSiteId: getLegacySiteId(),
+    activeSiteName: getLegacySiteName(),
+    setToken: (token) => set({ token }),
+    setActiveSiteId: (siteId, siteName) => set((state) => ({
+        activeSiteId: siteId,
+        activeSiteName: siteName ?? state.activeSiteName,
+    })),
+}), {
+    name: 'zenith-tenant-store',
+    // SECURITY: Never persist the auth token to localStorage — it must live in
+    // memory only. The server uses HttpOnly cookies for actual authentication.
+    // Storing the token in localStorage makes it extractable via XSS attacks.
+    partialize: (state) => ({
+        activeSiteId: state.activeSiteId,
+        activeSiteName: state.activeSiteName,
+    }),
+}));

package/dist/admin/src/lib/utils.d.ts

@@ -0,0 +1,15 @@
+import { type ClassValue } from 'clsx';
+/**
+ * Utility for merging Tailwind classes with clsx
+ */
+export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Extracts purely text strings from a nested JSON structure (e.g. Zenith blocks)
+ * Ideal for passing document content to AI APIs.
+ */
+export declare function extractTextFromBlocks(content: any): string;
+/**
+ * Generate a stable unique ID. Uses crypto.randomUUID() with a safe fallback
+ * for non-HTTPS contexts where the API throws a DOMException.
+ */
+export declare function uid(): string;

package/dist/admin/src/lib/utils.js

@@ -0,0 +1,40 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+/**
+ * Utility for merging Tailwind classes with clsx
+ */
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+/**
+ * Extracts purely text strings from a nested JSON structure (e.g. Zenith blocks)
+ * Ideal for passing document content to AI APIs.
+ */
+export function extractTextFromBlocks(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map(extractTextFromBlocks).filter(Boolean).join(' ');
+    }
+    if (typeof content === 'object') {
+        return Object.values(content).map(extractTextFromBlocks).filter(Boolean).join(' ');
+    }
+    return String(content);
+}
+/**
+ * Generate a stable unique ID. Uses crypto.randomUUID() with a safe fallback
+ * for non-HTTPS contexts where the API throws a DOMException.
+ */
+export function uid() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        try {
+            return crypto.randomUUID();
+        }
+        catch {
+            // Fallback for non-secure contexts (http, localhost without HTTPS)
+        }
+    }
+    return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './plugin';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './plugin';

package/dist/plugin-ai-architect-ui/src/AIWriterPage.d.ts

@@ -0,0 +1,2 @@
+declare const AIWriterPage: () => import("react").JSX.Element;
+export default AIWriterPage;