@promptbook/cli 0.112.0-100 → 0.112.0-102

package/apps/agents-server/src/utils/upload/createBookEditorUploadHandler.ts

@@ -2,6 +2,7 @@
 
 import { upload } from '@vercel/blob/client';
 import type { number_percent, string_knowledge_source_content } from '@promptbook-local/types';
+import { isServerRoutedCdnUploadProvider, resolveCdnStorageProvider } from '../cdn/resolveCdnStorageProvider';
 import { getSafeCdnPath } from '../cdn/utils/getSafeCdnPath';
 import { normalizeUploadFilename } from '../normalization/normalizeUploadFilename';
 
@@ -75,6 +76,109 @@ type SharedUploadHandlerConfig = {
  */
 const DEFAULT_SHORT_URL_PREFIX = 'https://ptbk.io/k/';
 
+/**
+ * Response returned by the server-routed upload API.
+ *
+ * @private used by chat and book editors.
+ */
+type ServerRoutedUploadResponse = {
+    url: string;
+};
+
+/**
+ * Uploads a file through `/api/upload` for S3-compatible storage providers.
+ *
+ * @private used by chat and book editors.
+ */
+function uploadFileThroughServer(options: {
+    safeUploadPath: string;
+    file: File;
+    purpose: string;
+    abortSignal?: AbortSignal;
+    onProgress?: FileUploadProgressCallback;
+}): Promise<ServerRoutedUploadResponse> {
+    const { safeUploadPath, file, purpose, abortSignal, onProgress } = options;
+    const formData = new FormData();
+    formData.set('file', file);
+    formData.set('pathname', safeUploadPath);
+    formData.set('purpose', purpose);
+    formData.set('contentType', file.type || 'application/octet-stream');
+
+    return new Promise((resolve, reject) => {
+        const request = new XMLHttpRequest();
+
+        /**
+         * Removes abort listeners once the upload finishes.
+         */
+        const cleanup = () => {
+            abortSignal?.removeEventListener('abort', handleAbort);
+        };
+
+        /**
+         * Aborts the active XHR upload when the caller aborts.
+         */
+        const handleAbort = () => {
+            request.abort();
+            cleanup();
+            reject(new DOMException('Upload aborted.', 'AbortError'));
+        };
+
+        request.upload.addEventListener('progress', (event) => {
+            if (!event.lengthComputable) {
+                return;
+            }
+
+            onProgress?.((event.loaded / event.total) as number_percent, {
+                loadedBytes: event.loaded,
+                totalBytes: event.total,
+            });
+        });
+
+        request.addEventListener('load', () => {
+            cleanup();
+
+            if (request.status < 200 || request.status >= 300) {
+                reject(new Error(`Upload failed with HTTP ${request.status}: ${request.responseText}`));
+                return;
+            }
+
+            try {
+                const parsedResponse = JSON.parse(request.responseText) as Partial<ServerRoutedUploadResponse>;
+                if (typeof parsedResponse.url !== 'string' || parsedResponse.url.trim() === '') {
+                    reject(new Error('Upload response did not contain a file URL.'));
+                    return;
+                }
+
+                onProgress?.(1 as number_percent, {
+                    loadedBytes: file.size,
+                    totalBytes: file.size,
+                });
+                resolve({ url: parsedResponse.url });
+            } catch (error) {
+                reject(error);
+            }
+        });
+
+        request.addEventListener('error', () => {
+            cleanup();
+            reject(new Error('Upload failed before the server responded.'));
+        });
+
+        request.addEventListener('abort', () => {
+            cleanup();
+        });
+
+        if (abortSignal?.aborted) {
+            handleAbort();
+            return;
+        }
+
+        abortSignal?.addEventListener('abort', handleAbort);
+        request.open('POST', '/api/upload');
+        request.send(formData);
+    });
+}
+
 /**
  * Upload handler that normalizes the filename, uploads via `/api/upload`, and optionally returns a short URL.
  *
@@ -92,30 +196,44 @@ export function createFileUploadHandler<ReturnType extends string = string>(
 
     return async (file, optionsOrOnProgress) => {
         const { onProgress, abortSignal } = normalizeUploadOptions(optionsOrOnProgress);
+        const provider = resolveCdnStorageProvider();
+        const isServerRoutedUploadEnabled = isServerRoutedCdnUploadProvider(provider);
         const pathPrefix = process.env.NEXT_PUBLIC_CDN_PATH_PREFIX || '';
         const normalizedFilename = normalizeUploadFilename(file.name);
-        const uploadPath = pathBuilder(normalizedFilename, pathPrefix);
-        const safeUploadPath = getSafeCdnPath({ pathname: uploadPath });
-
-        const blob = await upload(safeUploadPath, file, {
-            access: 'public',
-            handleUploadUrl: '/api/upload',
-            clientPayload: JSON.stringify({
-                purpose,
-                contentType: file.type || 'application/octet-stream',
-            }),
-            abortSignal,
-            onUploadProgress: (progressEvent) => {
-                onProgress?.(progressEvent.percentage / 100, {
-                    loadedBytes: progressEvent.loaded,
-                    totalBytes: progressEvent.total,
-                });
-            },
+        const publicUploadPath = pathBuilder(normalizedFilename, pathPrefix);
+        const storageUploadPath = pathBuilder(normalizedFilename, isServerRoutedUploadEnabled ? '' : pathPrefix);
+        const safeUploadPath = getSafeCdnPath({
+            pathname: storageUploadPath,
+            pathPrefix: isServerRoutedUploadEnabled ? pathPrefix : undefined,
         });
 
+        const blob = isServerRoutedUploadEnabled
+            ? await uploadFileThroughServer({
+                  safeUploadPath,
+                  file,
+                  purpose,
+                  abortSignal,
+                  onProgress,
+              })
+            : await upload(safeUploadPath, file, {
+                  access: 'public',
+                  handleUploadUrl: '/api/upload',
+                  clientPayload: JSON.stringify({
+                      purpose,
+                      contentType: file.type || 'application/octet-stream',
+                  }),
+                  abortSignal,
+                  onUploadProgress: (progressEvent) => {
+                      onProgress?.(progressEvent.percentage / 100, {
+                          loadedBytes: progressEvent.loaded,
+                          totalBytes: progressEvent.total,
+                      });
+                  },
+              });
+
         if (returnShortUrl && process.env.NEXT_PUBLIC_CDN_PUBLIC_URL) {
-            const slashIndex = uploadPath.lastIndexOf('/');
-            const directoryPath = slashIndex === -1 ? '' : `${uploadPath.slice(0, slashIndex + 1)}`;
+            const slashIndex = publicUploadPath.lastIndexOf('/');
+            const directoryPath = slashIndex === -1 ? '' : `${publicUploadPath.slice(0, slashIndex + 1)}`;
             const longUrlPrefix = `${process.env.NEXT_PUBLIC_CDN_PUBLIC_URL}/${directoryPath}`;
             const shortUrl = blob.url.split(longUrlPrefix).join(shortUrlPrefix);
             return shortUrl as ReturnType;

package/esm/index.es.js

@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-100';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-102';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name

package/esm/src/book-components/Chat/MarkdownContent/MarkdownContent.d.ts

@@ -7,6 +7,7 @@ type MarkdownContentProps = {
     content: string_markdown;
     className?: string;
     onCreateAgent?: (bookContent: string) => void;
+    theme?: 'LIGHT' | 'DARK';
 };
 /**
  * Renders markdown content with support for code highlighting, math, and tables.

package/esm/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.112.0-99`).
+ * It follows semantic versioning (e.g., `0.112.0-101`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.112.0-100",
+    "version": "0.112.0-102",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,
@@ -159,6 +159,7 @@
         "@types/swagger-ui-react": "5.18.0",
         "@types/turndown": "5.0.6",
         "@vercel/blob": "1.1.1",
+        "@xmldom/xmldom": "^0.9.10",
         "@xterm/addon-fit": "0.11.0",
         "@xterm/xterm": "6.0.0",
         "better-sqlite3": "^11.10.0",
@@ -166,7 +167,6 @@
         "cross-fetch": "4.0.0",
         "destroyable": "0.12.145",
         "dompurify": "3.4.6",
-        "fast-xml-parser": "^5.2.5",
         "formidable": "3.5.4",
         "highlight.js": "11.11.1",
         "html-to-image": "1.11.13",

package/src/book-components/Chat/MarkdownContent/MarkdownContent.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { memo, useEffect, useMemo, useRef } from 'react';
+import { memo, useEffect, useMemo, useRef, useState } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
 import type { string_markdown } from '../../../types/string_markdown';
 import { classNames } from '../../_common/react-utils/classNames';
@@ -23,8 +23,37 @@ type MarkdownContentProps = {
 
     className?: string;
     onCreateAgent?: (bookContent: string) => void;
+    theme?: 'LIGHT' | 'DARK';
 };
 
+/**
+ * Visual theme consumed by nested code-block renderers.
+ *
+ * @private utility of `MarkdownContent` component
+ */
+type MarkdownContentTheme = NonNullable<MarkdownContentProps['theme']>;
+
+/**
+ * Resolves the active document theme when a host application does not pass an explicit theme.
+ *
+ * @private utility of `MarkdownContent` component
+ */
+function resolveMarkdownContentTheme(explicitTheme?: MarkdownContentTheme): MarkdownContentTheme {
+    if (explicitTheme) {
+        return explicitTheme;
+    }
+
+    if (typeof document !== 'undefined') {
+        const resolvedTheme = document.documentElement.dataset.themeResolved;
+
+        if (resolvedTheme === 'dark' || document.documentElement.classList.contains('dark')) {
+            return 'DARK';
+        }
+    }
+
+    return 'LIGHT';
+}
+
 /**
  * Returns a stable key for a `<details>` element based on its `<summary>` text.
  * Used to identify and restore open state across re-renders.
@@ -85,7 +114,7 @@ function resolveClickedDetailsElement(target: EventTarget | null, container: HTM
  * @public exported from `@promptbook/components`
  */
 export const MarkdownContent = memo(function MarkdownContent(props: MarkdownContentProps) {
-    const { content, className, onCreateAgent } = props;
+    const { content, className, onCreateAgent, theme } = props;
     const htmlContent = useMemo(
         () =>
             renderMarkdown(content, {
@@ -93,6 +122,9 @@ export const MarkdownContent = memo(function MarkdownContent(props: MarkdownCont
             }),
         [content],
     );
+    const [resolvedTheme, setResolvedTheme] = useState<MarkdownContentTheme>(() =>
+        resolveMarkdownContentTheme(theme),
+    );
     const containerRef = useRef<HTMLDivElement>(null);
     const rootsRef = useRef<Root[]>([]);
     /** Tracks which `<details>` elements (by summary key) are currently open */
@@ -100,6 +132,28 @@ export const MarkdownContent = memo(function MarkdownContent(props: MarkdownCont
     const onCreateAgentRef = useRef(onCreateAgent);
     onCreateAgentRef.current = onCreateAgent;
 
+    useEffect(() => {
+        if (theme) {
+            setResolvedTheme(theme);
+            return;
+        }
+
+        const updateTheme = () => setResolvedTheme(resolveMarkdownContentTheme());
+        updateTheme();
+
+        if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') {
+            return;
+        }
+
+        const observer = new MutationObserver(updateTheme);
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ['class', 'data-theme-resolved'],
+        });
+
+        return () => observer.disconnect();
+    }, [theme]);
+
     useEffect(() => {
         // Cleanup previous roots
         rootsRef.current.forEach((root) => root.unmount());
@@ -191,7 +245,14 @@ export const MarkdownContent = memo(function MarkdownContent(props: MarkdownCont
 
             // Render CodeBlock
             const root = createRoot(mountPoint);
-            root.render(<CodeBlock code={code} language={language} onCreateAgent={onCreateAgentRef.current} />);
+            root.render(
+                <CodeBlock
+                    code={code}
+                    language={language}
+                    onCreateAgent={onCreateAgentRef.current}
+                    theme={resolvedTheme}
+                />,
+            );
             rootsRef.current.push(root);
         });
 
@@ -203,7 +264,7 @@ export const MarkdownContent = memo(function MarkdownContent(props: MarkdownCont
             rootsRef.current.forEach((root) => root.unmount());
             rootsRef.current = [];
         };
-    }, [htmlContent]);
+    }, [htmlContent, resolvedTheme]);
 
     return (
         <div