synthos 0.8.0 → 0.9.0

package/src/models/openai.ts

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { AgentCompletion, completePrompt, PromptCompletionArgs, RequestError } from './types';
+import { AgentCompletion, completePrompt, PromptCompletionArgs, RequestError, isMultimodalContent } from './types';
 
 export interface OpenaiArgs {
     apiKey: string;
@@ -15,23 +15,43 @@ export interface OpenaiArgs {
  * Pure function — no SDK dependency.
  */
 export function buildOpenAIRequest(args: PromptCompletionArgs): {
-    input: { role: string; content: string }[];
+    input: { role: string; content: string | any[] }[];
     text?: { format: any };
 } {
-    const input: { role: string; content: string }[] = [];
+    const input: { role: string; content: string | any[] }[] = [];
     if (args.history) {
         for (const msg of args.history) {
             input.push({ role: msg.role, content: msg.content });
         }
     }
-    input.push({ role: 'user', content: args.prompt.content });
+
+    // Build user content — multimodal when ContentBlock[] is provided
+    const promptContent = args.prompt.content;
+    if (isMultimodalContent(promptContent)) {
+        const parts: any[] = promptContent.map(block => {
+            if (block.type === 'text') {
+                return { type: 'input_text', text: block.text };
+            }
+            return {
+                type: 'input_image',
+                image_url: `data:${block.mediaType};base64,${block.data}`,
+            };
+        });
+        input.push({ role: 'user', content: parts });
+    } else {
+        input.push({ role: 'user', content: promptContent });
+    }
 
     if (args.jsonMode || args.jsonSchema) {
-        const inputText = input.map(m => m.content).join(' ');
+        const inputText = input.map(m => typeof m.content === 'string' ? m.content : '').join(' ');
         if (!/json/i.test(inputText)) {
             const last = input[input.length - 1];
             if (last) {
-                last.content += '\nReturn JSON.';
+                if (typeof last.content === 'string') {
+                    last.content += '\nReturn JSON.';
+                } else if (Array.isArray(last.content)) {
+                    last.content.push({ type: 'input_text', text: '\nReturn JSON.' });
+                }
             }
         }
     }

package/src/models/types.ts

@@ -25,6 +25,30 @@ export interface Provider {
     detectModel(model: string): boolean;
 }
 
+// ---------------------------------------------------------------------------
+// Multimodal content
+// ---------------------------------------------------------------------------
+
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+
+export interface ImageBlock {
+    type: 'image';
+    mediaType: string;
+    data: string;
+}
+
+export type ContentBlock = TextBlock | ImageBlock;
+
+export type MessageContent = string | ContentBlock[];
+
+/** Type guard: returns true when content is a multimodal ContentBlock array. */
+export function isMultimodalContent(content: MessageContent): content is ContentBlock[] {
+    return Array.isArray(content);
+}
+
 // ---------------------------------------------------------------------------
 // Messages
 // ---------------------------------------------------------------------------
@@ -39,8 +63,10 @@ export interface SystemMessage extends Message {
     role: 'system';
 }
 
-export interface UserMessage extends Message {
+export interface UserMessage {
     role: 'user';
+    content: MessageContent;
+    name?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -61,6 +87,10 @@ export interface PromptCompletionArgs {
     jsonMode?: boolean;
     /** JSON schema for structured output. When provided, the model is asked to return JSON conforming to this schema. */
     jsonSchema?: Record<string, unknown>;
+    /** When true, system content is wrapped with cache_control for Anthropic prompt caching. */
+    cacheSystem?: boolean;
+    /** JSON schema for structured output via constrained decoding (Anthropic output_config). */
+    outputSchema?: Record<string, unknown>;
 }
 
 export type completePrompt<TValue = string> = (args: PromptCompletionArgs) => Promise<AgentCompletion<TValue>>;

package/src/pages.ts

@@ -1,12 +1,28 @@
-import {checkIfExists, deleteFile, deleteFolder, ensureFolderExists, listFiles, listFolders, loadFile, saveFile} from './files';
+import {checkIfExists, copyFolderRecursive, deleteFile, deleteFolder, ensureFolderExists, listFiles, listFolders, loadFile, saveFile} from './files';
 import path from 'path';
 
-// Page State Cache
-const _pages: { [name: string]: string } = {};
-
-export const REQUIRED_PAGES = ['builder', 'pages', 'settings', 'apis', 'scripts'];
+/**
+ * Derive the list of required page names by scanning *.html files
+ * across one or more requiredPages folders.
+ */
+export async function getRequiredPages(requiredPagesFolders: string[]): Promise<string[]> {
+    const result: string[] = [];
+    const seen = new Set<string>();
+    for (const folder of requiredPagesFolders) {
+        if (!await checkIfExists(folder)) continue;
+        const entries = await listFolders(folder);
+        for (const entry of entries) {
+            if (seen.has(entry)) continue;
+            if (await checkIfExists(path.join(folder, entry, 'page.html'))) {
+                seen.add(entry);
+                result.push(entry);
+            }
+        }
+    }
+    return result;
+}
 
-export const PAGE_VERSION = 2;
+export const PAGE_VERSION = 3;
 
 export interface PageInfo {
     name: string;
@@ -22,8 +38,8 @@ export interface PageInfo {
 
 export type PageMetadata = Omit<PageInfo, 'name'>;
 
-export async function loadPageMetadata(pagesFolder: string, name: string, fallbackFolder?: string): Promise<PageMetadata | undefined> {
-    // 1. Try user override: .synthos/pages/<name>/page.json
+export async function loadPageMetadata(pagesFolder: string, name: string, fallbackFolders?: string[]): Promise<PageMetadata | undefined> {
+    // 1. Try user override: <localFolder>/pages/<name>/page.json
     const metadataPath = path.join(pagesFolder, 'pages', name, 'page.json');
     if (await checkIfExists(metadataPath)) {
         try {
@@ -35,16 +51,18 @@ export async function loadPageMetadata(pagesFolder: string, name: string, fallba
         }
     }
 
-    // 2. Try fallback: fallbackFolder/<name>.json
-    if (fallbackFolder) {
-        const fallbackPath = path.join(fallbackFolder, `${name}.json`);
-        if (await checkIfExists(fallbackPath)) {
-            try {
-                const raw = await loadFile(fallbackPath);
-                const parsed = JSON.parse(raw);
-                return parseMetadata(parsed);
-            } catch {
-                // fall through
+    // 2. Try fallback folders: fallbackFolder/<name>/page.json
+    if (fallbackFolders) {
+        for (const folder of fallbackFolders) {
+            const candidate = path.join(folder, name, 'page.json');
+            if (await checkIfExists(candidate)) {
+                try {
+                    const raw = await loadFile(candidate);
+                    const parsed = JSON.parse(raw);
+                    return parseMetadata(parsed);
+                } catch {
+                    // fall through
+                }
             }
         }
     }
@@ -83,7 +101,7 @@ const DEFAULT_METADATA: PageMetadata = {
     mode: 'unlocked',
 };
 
-export async function listPages(pagesFolder: string, fallbackPagesFolder: string): Promise<PageInfo[]> {
+export async function listPages(pagesFolder: string, fallbackPagesFolders: string[]): Promise<PageInfo[]> {
     const pageMap = new Map<string, PageInfo>();
 
     // Folder-based pages under pages/ subdirectory
@@ -128,13 +146,15 @@ export async function listPages(pagesFolder: string, fallbackPagesFolder: string
         }
     }
 
-    // Add pages from fallback (required) pages folder
-    const fallbackFiles = (await listFiles(fallbackPagesFolder)).filter(file => file.endsWith('.html'));
-    for (const file of fallbackFiles) {
-        const name = file.replace(/\.html$/, '');
-        if (!pageMap.has(name)) {
-            // System page not yet in map — check for user override, then fallback .json
-            const metadata = await loadPageMetadata(pagesFolder, name, fallbackPagesFolder);
+    // Add pages from fallback (required) pages folders
+    for (const folder of fallbackPagesFolders) {
+        if (!await checkIfExists(folder)) continue;
+        const dirs = await listFolders(folder);
+        for (const name of dirs) {
+            if (pageMap.has(name)) continue;
+            if (!await checkIfExists(path.join(folder, name, 'page.html'))) continue;
+            // System page not yet in map — check for user override, then fallback page.json
+            const metadata = await loadPageMetadata(pagesFolder, name, fallbackPagesFolders);
             pageMap.set(name, {
                 name,
                 title: metadata?.title ?? '',
@@ -156,22 +176,27 @@ export async function listPages(pagesFolder: string, fallbackPagesFolder: string
     return entries;
 }
 
-export async function loadPageState(pagesFolder: string, name: string, reset: boolean): Promise<string|undefined> {
-    if (!_pages[name] || reset) {
-        // Try folder-based path under pages/ first, then fall back to flat file
-        const folderPath = path.join(pagesFolder, 'pages', name, 'page.html');
-        const flatPath = path.join(pagesFolder, `${name}.html`);
-
-        if (await checkIfExists(folderPath)) {
-            _pages[name] = await loadFile(folderPath);
-        } else if (await checkIfExists(flatPath)) {
-            _pages[name] = await loadFile(flatPath);
-        } else {
-            return undefined;
-        }
+export async function loadPageState(pagesFolder: string, name: string): Promise<string|undefined> {
+    // Check for working-state version files first
+    const latestVersion = await getLatestVersion(pagesFolder, name);
+    if (latestVersion > 0) {
+        const versionHtml = await loadPageVersion(pagesFolder, name, latestVersion);
+        if (versionHtml) return versionHtml;
     }
 
-    return _pages[name];
+    // Fall back to saved baseline
+    const folderPath = path.join(pagesFolder, 'pages', name, 'page.html');
+    const directFolderPath = path.join(pagesFolder, name, 'page.html');
+    const flatPath = path.join(pagesFolder, `${name}.html`);
+
+    if (await checkIfExists(folderPath)) {
+        return loadFile(folderPath);
+    } else if (await checkIfExists(directFolderPath)) {
+        return loadFile(directFolderPath);
+    } else if (await checkIfExists(flatPath)) {
+        return loadFile(flatPath);
+    }
+    return undefined;
 }
 
 export function normalizePageName(name: string|undefined): string|undefined {
@@ -179,7 +204,6 @@ export function normalizePageName(name: string|undefined): string|undefined {
 }
 
 export async function savePageState(pagesFolder: string, name: string, content: string, title?: string, categories?: string[]): Promise<void> {
-    _pages[name] = content;
     const pageFolder = path.join(pagesFolder, 'pages', name);
     await ensureFolderExists(pageFolder);
     await saveFile(path.join(pageFolder, 'page.html'), content);
@@ -202,10 +226,6 @@ export async function savePageState(pagesFolder: string, name: string, content:
     }
 }
 
-export function updatePageState(name: string, content: string): void {
-    _pages[name] = content;
-}
-
 export async function deletePage(pagesFolder: string, name: string): Promise<void> {
     // Delete folder-based page: <pagesFolder>/pages/<name>/
     const folderPath = path.join(pagesFolder, 'pages', name);
@@ -219,8 +239,65 @@ export async function deletePage(pagesFolder: string, name: string): Promise<voi
         await deleteFile(flatPath);
     }
 
-    // Clear in-memory cache
-    delete _pages[name];
+}
+
+// ---------------------------------------------------------------------------
+// Page versioning — per-edit version snapshots for undo support
+// ---------------------------------------------------------------------------
+
+/**
+ * Save a version snapshot: <pagesFolder>/pages/<name>/page.v<version>.html
+ */
+export async function savePageVersion(pagesFolder: string, name: string, version: number, html: string): Promise<void> {
+    const pageFolder = path.join(pagesFolder, 'pages', name);
+    await ensureFolderExists(pageFolder);
+    await saveFile(path.join(pageFolder, `page.v${version}.html`), html);
+}
+
+/**
+ * Load a version snapshot (returns undefined if the file doesn't exist).
+ */
+export async function loadPageVersion(pagesFolder: string, name: string, version: number): Promise<string | undefined> {
+    const filePath = path.join(pagesFolder, 'pages', name, `page.v${version}.html`);
+    if (!await checkIfExists(filePath)) return undefined;
+    return loadFile(filePath);
+}
+
+/**
+ * Scan page.v*.html files and return the highest version number (0 if none).
+ */
+export async function getLatestVersion(pagesFolder: string, name: string): Promise<number> {
+    const pageFolder = path.join(pagesFolder, 'pages', name);
+    if (!await checkIfExists(pageFolder)) return 0;
+    const files = await listFiles(pageFolder);
+    let max = 0;
+    for (const file of files) {
+        const match = file.match(/^page\.v(\d+)\.html$/);
+        if (match) {
+            const v = parseInt(match[1], 10);
+            if (v > max) max = v;
+        }
+    }
+    return max;
+}
+
+/**
+ * Delete all page.v*.html version files for a page.
+ */
+export async function clearVersions(pagesFolder: string, name: string): Promise<void> {
+    const pageFolder = path.join(pagesFolder, 'pages', name);
+    if (!await checkIfExists(pageFolder)) return;
+    const files = await listFiles(pageFolder);
+    for (const file of files) {
+        if (/^page\.v\d+\.html$/.test(file)) {
+            await deleteFile(path.join(pageFolder, file));
+        }
+    }
+}
+
+export interface CopyPageOptions {
+    copyTables?: boolean;   // default false
+    copyFiles?: boolean;    // default true
 }
 
 export async function copyPage(
@@ -229,14 +306,36 @@ export async function copyPage(
     targetName: string,
     title: string,
     categories: string[],
-    requiredPagesFolder: string
+    requiredPagesFolders: string[],
+    options?: CopyPageOptions
 ): Promise<void> {
-    // Load source HTML from user folder, then try required folder as fallback
-    let html = await loadPageState(pagesFolder, sourceName, true);
-    if (!html) {
-        const requiredPath = path.join(requiredPagesFolder, `${sourceName}.html`);
-        if (await checkIfExists(requiredPath)) {
-            html = await loadFile(requiredPath);
+    const copyTables = options?.copyTables ?? false;
+    const copyFiles = options?.copyFiles ?? true;
+
+    // Resolve source page folder: user pages first, then required pages
+    let sourceFolder: string | undefined;
+    const userSourceFolder = path.join(pagesFolder, 'pages', sourceName);
+    if (await checkIfExists(path.join(userSourceFolder, 'page.html'))) {
+        sourceFolder = userSourceFolder;
+    } else {
+        for (const folder of requiredPagesFolders) {
+            const candidate = path.join(folder, sourceName);
+            if (await checkIfExists(path.join(candidate, 'page.html'))) {
+                sourceFolder = candidate;
+                break;
+            }
+        }
+    }
+
+    // Load source HTML
+    let html: string | undefined;
+    if (sourceFolder) {
+        html = await loadFile(path.join(sourceFolder, 'page.html'));
+    } else {
+        // Try legacy flat file
+        const flatPath = path.join(pagesFolder, `${sourceName}.html`);
+        if (await checkIfExists(flatPath)) {
+            html = await loadFile(flatPath);
         }
     }
 
@@ -260,4 +359,27 @@ export async function copyPage(
         mode: 'unlocked',
     };
     await savePageMetadata(pagesFolder, targetName, metadata);
+
+    // Copy additional content from source if a folder was resolved
+    if (sourceFolder) {
+        const targetFolder = path.join(pagesFolder, 'pages', targetName);
+
+        if (copyTables) {
+            const entries = await listFolders(sourceFolder);
+            for (const entry of entries) {
+                if (entry === 'files') continue; // handled separately
+                await copyFolderRecursive(
+                    path.join(sourceFolder, entry),
+                    path.join(targetFolder, entry)
+                );
+            }
+        }
+
+        if (copyFiles) {
+            const filesDir = path.join(sourceFolder, 'files');
+            if (await checkIfExists(filesDir)) {
+                await copyFolderRecursive(filesDir, path.join(targetFolder, 'files'));
+            }
+        }
+    }
 }

package/src/service/server.ts

@@ -3,11 +3,15 @@ import { usePageRoutes } from './usePageRoutes';
 import { useApiRoutes } from './useApiRoutes';
 import { SynthOSConfig } from '../init';
 import { useDataRoutes } from './useDataRoutes';
+import { useFileRoutes } from './useFileRoutes';
+import { useSharedDataRoutes } from './useSharedDataRoutes';
+import { useSharedFileRoutes } from './useSharedFileRoutes';
 import { useConnectorRoutes } from './useConnectorRoutes';
 import { useAgentRoutes } from './useAgentRoutes';
 import { cyan, yellow, formatTime } from './debugLog';
+import { customizer as defaultCustomizer, Customizer } from '../customizer';
 
-export function server(config: SynthOSConfig): Application {
+export function server(config: SynthOSConfig, customizer: Customizer = defaultCustomizer): Application {
     const app = express();
 
     // Debug request-logging middleware
@@ -25,23 +29,46 @@ export function server(config: SynthOSConfig): Application {
     // Middleware to parse URL-encoded data (form data)
     app.use(express.urlencoded({ extended: true }));
 
-    // Middleware to parse JSON data
-    app.use(express.json());
+    // Middleware to parse JSON data (10 MB limit for image attachments)
+    app.use(express.json({ limit: '10mb' }));
+
+    // Favicon — serve from static files
+    app.get('/favicon.ico', (_req, res) => res.redirect('/static/favicon.svg'));
+    app.get('/favicon.svg', (_req, res) => res.redirect('/static/favicon.svg'));
+
+    // Serve static files from staticFilesFolders (first folder wins)
+    for (const folder of config.staticFilesFolders) {
+        app.use('/static', express.static(folder, { maxAge: '1h' }));
+    }
 
     // Page handling routes
-    usePageRoutes(config, app);
+    if (customizer.isEnabled('pages')) usePageRoutes(config, app, customizer);
 
     // API routes
-    useApiRoutes(config, app);
+    if (customizer.isEnabled('api')) useApiRoutes(config, app, customizer);
 
     // Connector routes
-    useConnectorRoutes(config, app);
+    if (customizer.isEnabled('connectors')) useConnectorRoutes(config, app);
 
     // Agent routes
-    useAgentRoutes(config, app);
+    if (customizer.isEnabled('agents')) useAgentRoutes(config, app, customizer);
 
     // Data routes
-    useDataRoutes(config, app);
+    if (customizer.isEnabled('data')) useDataRoutes(config, app);
+
+    // File routes
+    if (customizer.isEnabled('files')) useFileRoutes(config, app);
+
+    // Shared data routes
+    if (customizer.isEnabled('shared-data')) useSharedDataRoutes(config, app);
+
+    // Shared file routes
+    if (customizer.isEnabled('shared-files')) useSharedFileRoutes(config, app);
+
+    // Custom routes from the Customizer
+    for (const installer of customizer.getExtraRoutes()) {
+        installer(config, app);
+    }
 
     return app;
-}
+}