synthos 0.8.0 → 0.10.0

package/src/service/useSharedDataRoutes.ts

@@ -0,0 +1,109 @@
+import { Application, Response } from 'express';
+import { SynthOSConfig } from "../init";
+import path from "path";
+import { v4 } from "uuid";
+
+export function useSharedDataRoutes(config: SynthOSConfig, app: Application): void {
+    app.get('/api/shared/data/:table', (req, res) => handleList(config, req.params.table, req.query, res));
+    app.get('/api/shared/data/:table/:id', (req, res) => handleGet(config, req.params.table, req.params.id, res));
+    app.post('/api/shared/data/:table', (req, res) => handleUpsert(config, req.params.table, req.body, res));
+    app.delete('/api/shared/data/:table/:id', (req, res) => handleDelete(config, req.params.table, req.params.id, res));
+}
+
+// ---------------------------------------------------------------------------
+// Route handlers
+// ---------------------------------------------------------------------------
+
+async function handleList(config: SynthOSConfig, table: string, query: Record<string, any>, res: Response): Promise<void> {
+    const sp = config.storageProvider;
+    const folder = sharedTableFolder(config, table);
+    if (!(await sp.checkIfExists(folder))) {
+        res.status(404).json({ error: 'table_not_found', table });
+        return;
+    }
+
+    const ids = (await sp.listFiles(folder)).filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''));
+
+    const rows: Record<string, any>[] = [];
+    for (const id of ids) {
+        const file = recordFile(folder, id);
+        try {
+            const row = JSON.parse(await sp.loadFile(file));
+            row.id = id;
+            rows.push(row);
+        } catch (err: unknown) {
+            console.error(err);
+        }
+    }
+
+    // Paginate when limit is provided
+    const limitParam = typeof query.limit === 'string' ? parseInt(query.limit, 10) : NaN;
+    if (!isNaN(limitParam) && limitParam > 0) {
+        const offset = Math.max(0, typeof query.offset === 'string' ? parseInt(query.offset, 10) || 0 : 0);
+        const items = rows.slice(offset, offset + limitParam);
+        res.json({ items, total: rows.length, offset, limit: limitParam, hasMore: offset + limitParam < rows.length });
+    } else {
+        res.json(rows);
+    }
+}
+
+async function handleGet(config: SynthOSConfig, table: string, id: string, res: Response): Promise<void> {
+    const sp = config.storageProvider;
+    const folder = sharedTableFolder(config, table);
+    if (!(await sp.checkIfExists(folder))) {
+        res.status(404).json({ error: 'table_not_found', table });
+        return;
+    }
+
+    const file = recordFile(folder, id);
+    try {
+        const row = JSON.parse(await sp.loadFile(file));
+        row.id = id;
+        res.json(row);
+    } catch (err: unknown) {
+        res.json({});
+    }
+}
+
+async function handleUpsert(config: SynthOSConfig, table: string, body: any, res: Response): Promise<void> {
+    const sp = config.storageProvider;
+    const id = body.id ?? v4();
+    const folder = sharedTableFolder(config, table);
+    const file = recordFile(folder, id);
+    try {
+        const row = { ...body, id };
+        await sp.ensureFolderExists(folder);
+        await sp.saveFile(file, JSON.stringify(row, null, 4));
+        res.json(row);
+    } catch (err: unknown) {
+        console.error(err);
+        res.status(500).send((err as Error).message);
+    }
+}
+
+async function handleDelete(config: SynthOSConfig, table: string, id: string, res: Response): Promise<void> {
+    const sp = config.storageProvider;
+    const folder = sharedTableFolder(config, table);
+    const file = recordFile(folder, id);
+    try {
+        if (await sp.checkIfExists(file)) {
+            await sp.deleteFile(file);
+        }
+        res.json({ success: true });
+    } catch (err: unknown) {
+        console.error(err);
+        res.status(500).send((err as Error).message);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function sharedTableFolder(config: SynthOSConfig, table: string): string {
+    return path.join(config.pagesFolder, 'shared', table);
+}
+
+function recordFile(folder: string, id: string): string {
+    return path.join(folder, `${id}.json`);
+}

package/src/service/useSharedFileRoutes.ts

@@ -0,0 +1,127 @@
+import { Application } from 'express';
+import express from 'express';
+import path from 'path';
+import { SynthOSConfig } from '../init';
+
+export function useSharedFileRoutes(config: SynthOSConfig, app: Application): void {
+    const sp = config.storageProvider;
+
+    // List files in the shared files folder
+    app.get('/api/shared/files', async (req, res) => {
+        try {
+            const folder = sharedFilesFolder(config);
+            if (!(await sp.checkIfExists(folder))) {
+                res.json({ files: [] });
+                return;
+            }
+
+            const entries = await sp.listFiles(folder);
+            const files: { name: string; size: number }[] = [];
+            for (const entry of entries) {
+                const stat = await sp.stat(path.join(folder, entry));
+                if (stat.isFile) {
+                    files.push({ name: entry, size: stat.size });
+                }
+            }
+            res.json({ files });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Download/serve a specific shared file
+    app.get('/api/shared/files/:filename', async (req, res) => {
+        try {
+            const filePath = safeFilePath(config, req.params.filename);
+            if (!filePath) {
+                res.status(400).json({ error: 'Invalid filename' });
+                return;
+            }
+
+            if (!(await sp.checkIfExists(filePath))) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+
+            res.type(path.extname(req.params.filename));
+            sp.createReadStream(filePath).pipe(res);
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Upload a shared file (raw body + x-filename header)
+    app.post('/api/shared/files', express.raw({ type: '*/*', limit: '50mb' }), async (req, res) => {
+        try {
+            const filename = req.headers['x-filename'] as string | undefined;
+            if (!filename || filename.trim().length === 0) {
+                res.status(400).json({ error: 'x-filename header is required' });
+                return;
+            }
+
+            const filePath = safeFilePath(config, filename);
+            if (!filePath) {
+                res.status(400).json({ error: 'Invalid filename' });
+                return;
+            }
+
+            const folder = sharedFilesFolder(config);
+            await sp.ensureFolderExists(folder);
+            await sp.saveBuffer(filePath, req.body as Buffer);
+
+            const stat = await sp.stat(filePath);
+            res.status(201).json({ name: filename, size: stat.size });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Delete a shared file
+    app.delete('/api/shared/files/:filename', async (req, res) => {
+        try {
+            const filePath = safeFilePath(config, req.params.filename);
+            if (!filePath) {
+                res.status(400).json({ error: 'Invalid filename' });
+                return;
+            }
+
+            if (!(await sp.checkIfExists(filePath))) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+
+            await sp.deleteFile(filePath);
+            res.json({ deleted: true });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function sharedFilesFolder(config: SynthOSConfig): string {
+    return path.join(config.pagesFolder, 'shared', 'files');
+}
+
+/**
+ * Resolve a filename inside the shared files folder with path-traversal protection.
+ * Returns the absolute path if safe, or null if the filename is invalid.
+ */
+function safeFilePath(config: SynthOSConfig, filename: string): string | null {
+    if (!filename || filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+        return null;
+    }
+    const folder = sharedFilesFolder(config);
+    const resolved = path.resolve(folder, filename);
+    if (!resolved.startsWith(path.resolve(folder))) {
+        return null;
+    }
+    return resolved;
+}

package/src/settings.ts

@@ -1,7 +1,7 @@
-import {checkIfExists, loadFile, saveFile} from './files';
 import path from 'path';
 import { ModelEntry, ProviderName, detectProvider } from './models';
 import { AgentConfig } from './agents';
+import { SynthOSConfig } from './init';
 
 let _settings: Partial<SettingsV2>|undefined;
 
@@ -39,6 +39,7 @@ export interface SettingsV2 {
     services?: ServicesConfig;
     connectors?: ServicesConfig;
     agents?: AgentConfig[];
+    toolbarPosition?: 'left' | 'right';
 }
 
 export const DefaultSettings: SettingsV2 = {
@@ -66,6 +67,7 @@ export const DefaultSettings: SettingsV2 = {
     services: {},
     connectors: {},
     agents: [],
+    toolbarPosition: 'left',
 };
 
 /**
@@ -124,8 +126,8 @@ function migrateV1toV2(raw: Record<string, unknown>): SettingsV2 {
     };
 }
 
-export async function hasConfiguredSettings(folder: string): Promise<boolean> {
-    const settings = await loadSettings(folder);
+export async function hasConfiguredSettings(config: SynthOSConfig): Promise<boolean> {
+    const settings = await loadSettings(config);
     const builder = getModelEntry(settings, 'builder');
     if (typeof builder.configuration.apiKey !== 'string' || builder.configuration.apiKey.length == 0) {
         return false;
@@ -136,18 +138,19 @@ export async function hasConfiguredSettings(folder: string): Promise<boolean> {
     return true;
 }
 
-export async function loadSettings(folder: string): Promise<SettingsV2> {
+export async function loadSettings(config: SynthOSConfig): Promise<SettingsV2> {
+    const sp = config.storageProvider;
     if (_settings == undefined) {
-        const filename = path.join(folder, 'settings.json');
-        if (await checkIfExists(filename)) {
+        const filename = path.join(config.pagesFolder, 'settings.json');
+        if (await sp.checkIfExists(filename)) {
             try {
-                const raw = JSON.parse(await loadFile(filename));
+                const raw = JSON.parse(await sp.loadFile(filename));
                 if (!raw.version) {
                     // V1 file — migrate
                     console.log('Migrating settings.json from v1 to v2...');
                     const migrated = migrateV1toV2(raw);
                     _settings = migrated;
-                    await saveFile(filename, JSON.stringify(migrated, null, 4));
+                    await sp.saveFile(filename, JSON.stringify(migrated, null, 4));
                 } else {
                     _settings = raw as Partial<SettingsV2>;
                 }
@@ -169,11 +172,12 @@ export async function loadSettings(folder: string): Promise<SettingsV2> {
     return merged;
 }
 
-export async function saveSettings(folder: string, settings: Partial<SettingsV2>): Promise<void> {
+export async function saveSettings(config: SynthOSConfig, settings: Partial<SettingsV2>): Promise<void> {
+    const sp = config.storageProvider;
     _settings = {..._settings, ...settings};
     if (settings.models) {
         _settings.models = settings.models;
     }
     _settings.version = 2;
-    await saveFile(path.join(folder, 'settings.json'), JSON.stringify(_settings, null, 4));
+    await sp.saveFile(path.join(config.pagesFolder, 'settings.json'), JSON.stringify(_settings, null, 4));
 }

package/src/storage/FsStorageProvider.ts

@@ -0,0 +1,87 @@
+import * as fs from 'fs/promises';
+import { createReadStream } from 'fs';
+import path from 'path';
+import { StorageProvider } from './StorageProvider';
+
+/**
+ * Default StorageProvider backed by the local filesystem via `fs/promises`.
+ * Mirrors the existing logic in `files.ts`.
+ */
+export class FsStorageProvider implements StorageProvider {
+    // --- Text file operations ---
+
+    async checkIfExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async loadFile(filePath: string): Promise<string> {
+        return await fs.readFile(filePath, 'utf8');
+    }
+
+    async saveFile(filePath: string, content: string): Promise<void> {
+        await fs.writeFile(filePath, content, 'utf8');
+    }
+
+    async deleteFile(filePath: string): Promise<void> {
+        await fs.unlink(filePath);
+    }
+
+    // --- Binary file operations ---
+
+    async saveBuffer(filePath: string, data: Buffer): Promise<void> {
+        await fs.writeFile(filePath, data);
+    }
+
+    async loadBuffer(filePath: string): Promise<Buffer> {
+        return await fs.readFile(filePath);
+    }
+
+    async stat(filePath: string): Promise<{ size: number; isFile: boolean }> {
+        const s = await fs.stat(filePath);
+        return { size: s.size, isFile: s.isFile() };
+    }
+
+    createReadStream(filePath: string): NodeJS.ReadableStream {
+        return createReadStream(filePath);
+    }
+
+    // --- Directory operations ---
+
+    async listFiles(dirPath: string): Promise<string[]> {
+        return (await fs.readdir(dirPath)).filter(file => !file.startsWith('.') && file.includes('.'));
+    }
+
+    async listFolders(dirPath: string): Promise<string[]> {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        return entries
+            .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map(entry => entry.name);
+    }
+
+    async ensureFolderExists(dirPath: string): Promise<void> {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+
+    async deleteFolder(dirPath: string): Promise<void> {
+        await fs.rm(dirPath, { recursive: true });
+    }
+
+    async copyFolderRecursive(srcPath: string, destPath: string): Promise<void> {
+        await this.ensureFolderExists(destPath);
+        const entries = await fs.readdir(srcPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const src = path.join(srcPath, entry.name);
+            const dest = path.join(destPath, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyFolderRecursive(src, dest);
+            } else {
+                await fs.copyFile(src, dest);
+            }
+        }
+    }
+}

package/src/storage/StorageProvider.ts

@@ -0,0 +1,34 @@
+/**
+ * Abstraction over user-mutable storage (pages, settings, themes, data, uploads).
+ *
+ * All paths are absolute. Callers build paths with `path.join(config.pagesFolder, ...)`
+ * exactly as they do today — the provider simply executes the I/O against
+ * whatever backend it wraps (local filesystem, blob storage, etc.).
+ *
+ * Package/read-only content (required-pages, default-themes, static-files,
+ * service-connectors) stays on local filesystem and is NOT routed through
+ * this interface.
+ */
+export interface StorageProvider {
+    // --- Text file operations ---
+
+    checkIfExists(filePath: string): Promise<boolean>;
+    loadFile(filePath: string): Promise<string>;
+    saveFile(filePath: string, content: string): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+
+    // --- Binary file operations (uploads / images) ---
+
+    saveBuffer(filePath: string, data: Buffer): Promise<void>;
+    loadBuffer(filePath: string): Promise<Buffer>;
+    stat(filePath: string): Promise<{ size: number; isFile: boolean }>;
+    createReadStream(filePath: string): NodeJS.ReadableStream;
+
+    // --- Directory operations ---
+
+    listFiles(dirPath: string): Promise<string[]>;
+    listFolders(dirPath: string): Promise<string[]>;
+    ensureFolderExists(dirPath: string): Promise<void>;
+    deleteFolder(dirPath: string): Promise<void>;
+    copyFolderRecursive(srcPath: string, destPath: string): Promise<void>;
+}

package/src/storage/index.ts

@@ -0,0 +1,2 @@
+export { StorageProvider } from './StorageProvider';
+export { FsStorageProvider } from './FsStorageProvider';

package/src/synthos-cli.ts

@@ -2,6 +2,7 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { server } from "./service";
 import { createConfig, init } from "./init";
+import { customizer } from "./customizer";
 
 const dynamicImport = new Function('specifier', `return import(specifier)`);
 
@@ -16,7 +17,7 @@ export async function run() {
                     default: 4242
                 })
                 .option('pages', {
-                    describe: `Include default pages when initializing a new .synthos folder.`,
+                    describe: `Include default pages when initializing a new local folder.`,
                     type: 'boolean',
                     default: true
                 })
@@ -32,9 +33,9 @@ export async function run() {
                 })
                 .demandOption([]);
         }, async (args) => {
-            const config = createConfig('.synthos', { debug: args.debug, debugPageUpdates: args.debugPageUpdates });
+            const config = await createConfig(customizer.localFolder, { debug: args.debug, debugPageUpdates: args.debugPageUpdates }, customizer);
             await init(config, args.pages);
-            await server(config).listen(args.port, async () => {
+            await server(config, customizer).listen(args.port, async () => {
                 console.log(`SynthOS server is running on http://localhost:${args.port}`);
                 
                 // Open using default browser

package/src/themes.ts

@@ -1,5 +1,5 @@
 import path from 'path';
-import { checkIfExists, listFiles, loadFile } from './files';
+import { checkIfExists, findFileInFolders, listFiles, listFilesFromFolders, loadFile } from './files';
 import { SynthOSConfig } from './init';
 
 export const THEME_VERSION = 2;
@@ -28,10 +28,29 @@ export function parseThemeFilename(filename: string): { name: string; version: n
 }
 
 /**
- * Find the CSS file for a theme by name in a folder.
+ * Find the CSS file for a theme by name in a user folder (via storageProvider).
  * Prefers the highest-versioned file (e.g. name.v2.css over name.css).
  */
-async function findThemeCssFile(folder: string, name: string): Promise<{ path: string; version: number } | undefined> {
+async function findUserThemeCssFile(config: SynthOSConfig, folder: string, name: string): Promise<{ path: string; version: number } | undefined> {
+    const sp = config.storageProvider;
+    if (!await sp.checkIfExists(folder)) return undefined;
+    const files = await sp.listFiles(folder);
+    let best: { path: string; version: number } | undefined;
+    for (const f of files) {
+        const parsed = parseThemeFilename(f);
+        if (parsed && parsed.name === name) {
+            if (!best || parsed.version > best.version) {
+                best = { path: path.join(folder, f), version: parsed.version };
+            }
+        }
+    }
+    return best;
+}
+
+/**
+ * Find the CSS file for a theme by name in a local-fs folder (package defaults).
+ */
+async function findDefaultThemeCssFile(folder: string, name: string): Promise<{ path: string; version: number } | undefined> {
     if (!await checkIfExists(folder)) return undefined;
     const files = await listFiles(folder);
     let best: { path: string; version: number } | undefined;
@@ -46,16 +65,29 @@ async function findThemeCssFile(folder: string, name: string): Promise<{ path: s
     return best;
 }
 
+export async function loadThemeVersion(name: string, config: SynthOSConfig): Promise<number> {
+    const local = await findUserThemeCssFile(config, userThemesFolder(config), name);
+    if (local) return local.version;
+    for (const folder of config.defaultThemesFolders) {
+        const def = await findDefaultThemeCssFile(folder, name);
+        if (def) return def.version;
+    }
+    return 1;
+}
+
 export async function loadThemeInfo(name: string, config: SynthOSConfig): Promise<ThemeInfo | undefined> {
-    // Check user's local themes first, then fall back to package defaults
+    const sp = config.storageProvider;
+
+    // Check user's local themes first (user storage)
     const localPath = path.join(userThemesFolder(config), `${name}.json`);
-    if (await checkIfExists(localPath)) {
-        const raw = await loadFile(localPath);
+    if (await sp.checkIfExists(localPath)) {
+        const raw = await sp.loadFile(localPath);
         return raw ? JSON.parse(raw) : undefined;
     }
 
-    const defaultPath = path.join(config.defaultThemesFolder, `${name}.json`);
-    if (await checkIfExists(defaultPath)) {
+    // Fall back to package defaults (local fs)
+    const defaultPath = await findFileInFolders(config.defaultThemesFolders, `${name}.json`);
+    if (defaultPath) {
         const raw = await loadFile(defaultPath);
         return raw ? JSON.parse(raw) : undefined;
     }
@@ -64,40 +96,44 @@ export async function loadThemeInfo(name: string, config: SynthOSConfig): Promis
 }
 
 export async function loadTheme(name: string, config: SynthOSConfig): Promise<string | undefined> {
-    // Check user's local themes first, then fall back to package defaults
-    const local = await findThemeCssFile(userThemesFolder(config), name);
+    const sp = config.storageProvider;
+
+    // Check user's local themes first (user storage)
+    const local = await findUserThemeCssFile(config, userThemesFolder(config), name);
     if (local) {
-        return await loadFile(local.path);
+        return await sp.loadFile(local.path);
     }
 
-    const def = await findThemeCssFile(config.defaultThemesFolder, name);
-    if (def) {
-        return await loadFile(def.path);
+    // Search all default theme folders (local fs)
+    for (const folder of config.defaultThemesFolders) {
+        const def = await findDefaultThemeCssFile(folder, name);
+        if (def) {
+            return await loadFile(def.path);
+        }
     }
 
     return undefined;
 }
 
 export async function listThemes(config: SynthOSConfig): Promise<string[]> {
+    const sp = config.storageProvider;
     const names = new Set<string>();
 
-    // Collect from user's local themes folder
+    // Collect from user's local themes folder (user storage)
     const localFolder = userThemesFolder(config);
-    if (await checkIfExists(localFolder)) {
-        const files = await listFiles(localFolder);
+    if (await sp.checkIfExists(localFolder)) {
+        const files = await sp.listFiles(localFolder);
         for (const f of files) {
             const parsed = parseThemeFilename(f);
             if (parsed) names.add(parsed.name);
         }
     }
 
-    // Collect from package defaults
-    if (await checkIfExists(config.defaultThemesFolder)) {
-        const files = await listFiles(config.defaultThemesFolder);
-        for (const f of files) {
-            const parsed = parseThemeFilename(f);
-            if (parsed) names.add(parsed.name);
-        }
+    // Collect from all default theme folders (local fs)
+    const defaultFiles = await listFilesFromFolders(config.defaultThemesFolders);
+    for (const f of defaultFiles) {
+        const parsed = parseThemeFilename(f);
+        if (parsed) names.add(parsed.name);
     }
 
     return Array.from(names).sort();
@@ -107,11 +143,12 @@ export async function listThemes(config: SynthOSConfig): Promise<string[]> {
  * Compare local theme versions against defaults and return themes that need upgrading.
  */
 export async function getOutdatedThemes(config: SynthOSConfig): Promise<string[]> {
+    const sp = config.storageProvider;
     const localFolder = userThemesFolder(config);
-    if (!await checkIfExists(localFolder)) return [];
+    if (!await sp.checkIfExists(localFolder)) return [];
 
-    const defaultFiles = await listFiles(config.defaultThemesFolder);
-    const localFiles = await listFiles(localFolder);
+    const defaultFiles = await listFilesFromFolders(config.defaultThemesFolders);
+    const localFiles = await sp.listFiles(localFolder);
 
     // Build maps: theme name → highest version
     const defaultVersions = new Map<string, number>();

package/static-files/favicon.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <defs>
+    <linearGradient id="g" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#a855f7"/>
+      <stop offset="100%" stop-color="#3b82f6"/>
+    </linearGradient>
+  </defs>
+  <rect width="32" height="32" rx="7" fill="#0f0f13"/>
+  <path d="M9 11 C9 8.8 10.8 7 13 7 L20 7 C22.2 7 24 8.8 24 11 C24 13.2 22.2 15 20 15 L13 15 C10.8 15 9 16.8 9 19 C9 21.2 10.8 23 13 23 L20 23" stroke="url(#g)" stroke-width="3" stroke-linecap="round" fill="none"/>
+  <circle cx="9" cy="11" r="2" fill="#a855f7"/>
+  <circle cx="23" cy="23" r="2" fill="#3b82f6"/>
+</svg>