synthos 0.8.0 → 0.9.0

package/src/service/useSharedDataRoutes.ts

@@ -0,0 +1,106 @@
+import { Application, Response } from 'express';
+import { SynthOSConfig } from "../init";
+import { checkIfExists, deleteFile, ensureFolderExists, listFiles, loadFile, saveFile } from "../files";
+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 folder = sharedTableFolder(config, table);
+    if (!(await checkIfExists(folder))) {
+        res.status(404).json({ error: 'table_not_found', table });
+        return;
+    }
+
+    const ids = (await 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 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 folder = sharedTableFolder(config, table);
+    if (!(await checkIfExists(folder))) {
+        res.status(404).json({ error: 'table_not_found', table });
+        return;
+    }
+
+    const file = recordFile(folder, id);
+    try {
+        const row = JSON.parse(await 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 id = body.id ?? v4();
+    const folder = sharedTableFolder(config, table);
+    const file = recordFile(folder, id);
+    try {
+        const row = { ...body, id };
+        await ensureFolderExists(folder);
+        await 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 folder = sharedTableFolder(config, table);
+    const file = recordFile(folder, id);
+    try {
+        if (await checkIfExists(file)) {
+            await 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,126 @@
+import { Application } from 'express';
+import express from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+import { SynthOSConfig } from '../init';
+import { checkIfExists, ensureFolderExists } from '../files';
+
+export function useSharedFileRoutes(config: SynthOSConfig, app: Application): void {
+    // List files in the shared files folder
+    app.get('/api/shared/files', async (req, res) => {
+        try {
+            const folder = sharedFilesFolder(config);
+            if (!(await checkIfExists(folder))) {
+                res.json({ files: [] });
+                return;
+            }
+
+            const entries = await fs.readdir(folder);
+            const files: { name: string; size: number }[] = [];
+            for (const entry of entries) {
+                const stat = await fs.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 checkIfExists(filePath))) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+
+            res.sendFile(filePath);
+        } 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 ensureFolderExists(folder);
+            await fs.writeFile(filePath, req.body as Buffer);
+
+            const stat = await fs.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 checkIfExists(filePath))) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+
+            await fs.unlink(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

@@ -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',
 };
 
 /**

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;
@@ -46,6 +46,16 @@ 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 findThemeCssFile(userThemesFolder(config), name);
+    if (local) return local.version;
+    for (const folder of config.defaultThemesFolders) {
+        const def = await findThemeCssFile(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 localPath = path.join(userThemesFolder(config), `${name}.json`);
@@ -54,8 +64,8 @@ export async function loadThemeInfo(name: string, config: SynthOSConfig): Promis
         return raw ? JSON.parse(raw) : undefined;
     }
 
-    const defaultPath = path.join(config.defaultThemesFolder, `${name}.json`);
-    if (await checkIfExists(defaultPath)) {
+    const defaultPath = await findFileInFolders(config.defaultThemesFolders, `${name}.json`);
+    if (defaultPath) {
         const raw = await loadFile(defaultPath);
         return raw ? JSON.parse(raw) : undefined;
     }
@@ -70,9 +80,12 @@ export async function loadTheme(name: string, config: SynthOSConfig): Promise<st
         return await loadFile(local.path);
     }
 
-    const def = await findThemeCssFile(config.defaultThemesFolder, name);
-    if (def) {
-        return await loadFile(def.path);
+    // Search all default theme folders
+    for (const folder of config.defaultThemesFolders) {
+        const def = await findThemeCssFile(folder, name);
+        if (def) {
+            return await loadFile(def.path);
+        }
     }
 
     return undefined;
@@ -91,13 +104,11 @@ export async function listThemes(config: SynthOSConfig): Promise<string[]> {
         }
     }
 
-    // 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
+    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();
@@ -110,7 +121,7 @@ export async function getOutdatedThemes(config: SynthOSConfig): Promise<string[]
     const localFolder = userThemesFolder(config);
     if (!await checkIfExists(localFolder)) return [];
 
-    const defaultFiles = await listFiles(config.defaultThemesFolder);
+    const defaultFiles = await listFilesFromFolders(config.defaultThemesFolders);
     const localFiles = await listFiles(localFolder);
 
     // Build maps: theme name → highest version

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>