synthos 0.7.2 → 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

@@ -1,6 +1,7 @@
 import {checkIfExists, loadFile, saveFile} from './files';
 import path from 'path';
 import { ModelEntry, ProviderName, detectProvider } from './models';
+import { AgentConfig } from './agents';
 
 let _settings: Partial<SettingsV2>|undefined;
 
@@ -20,7 +21,6 @@ export type { ModelEntry } from './models';
 export interface SettingsV1 {
     serviceApiKey: string;
     model: string;
-    maxTokens: number;
     imageQuality: 'standard' | 'hd';
     instructions?: string;
     logCompletions?: boolean;
@@ -38,6 +38,8 @@ export interface SettingsV2 {
     features: string[];
     services?: ServicesConfig;
     connectors?: ServicesConfig;
+    agents?: AgentConfig[];
+    toolbarPosition?: 'left' | 'right';
 }
 
 export const DefaultSettings: SettingsV2 = {
@@ -47,7 +49,7 @@ export const DefaultSettings: SettingsV2 = {
         {
             use: 'builder',
             provider: 'Anthropic',
-            configuration: { apiKey: '', model: '', maxTokens: 32000 },
+            configuration: { apiKey: '', model: '' },
             imageQuality: 'standard',
             instructions: '',
             logCompletions: false,
@@ -55,7 +57,7 @@ export const DefaultSettings: SettingsV2 = {
         {
             use: 'chat',
             provider: 'Anthropic',
-            configuration: { apiKey: '', model: '', maxTokens: 32000 },
+            configuration: { apiKey: '', model: '' },
             imageQuality: 'standard',
             instructions: '',
             logCompletions: false,
@@ -63,7 +65,9 @@ export const DefaultSettings: SettingsV2 = {
     ],
     features: [],
     services: {},
-    connectors: {}
+    connectors: {},
+    agents: [],
+    toolbarPosition: 'left',
 };
 
 /**
@@ -100,7 +104,6 @@ function migrateV1toV2(raw: Record<string, unknown>): SettingsV2 {
                 configuration: {
                     apiKey: v1.serviceApiKey ?? '',
                     model,
-                    maxTokens: v1.maxTokens ?? 32000,
                 },
                 imageQuality: v1.imageQuality ?? 'standard',
                 instructions: v1.instructions ?? '',
@@ -112,7 +115,6 @@ function migrateV1toV2(raw: Record<string, unknown>): SettingsV2 {
                 configuration: {
                     apiKey: v1.serviceApiKey ?? '',
                     model: chatModel,
-                    maxTokens: v1.maxTokens ?? 32000,
                 },
                 imageQuality: v1.imageQuality ?? 'standard',
                 instructions: v1.instructions ?? '',
@@ -133,10 +135,6 @@ export async function hasConfiguredSettings(folder: string): Promise<boolean> {
     if (typeof builder.configuration.model !== 'string' || builder.configuration.model.length == 0) {
         return false;
     }
-    if (typeof builder.configuration.maxTokens !== 'number' || builder.configuration.maxTokens <= 0) {
-        return false;
-    }
-
     return true;
 }
 

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,7 +1,9 @@
 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;
+
 export interface ThemeInfo {
     mode: 'light' | 'dark';
     colors: Record<string, string>;
@@ -11,6 +13,49 @@ function userThemesFolder(config: SynthOSConfig): string {
     return path.join(config.pagesFolder, 'themes');
 }
 
+/**
+ * Extract the base theme name and version from a CSS filename.
+ * e.g. "nebula-dusk.v2.css" → { name: "nebula-dusk", version: 2 }
+ *      "nebula-dusk.css"    → { name: "nebula-dusk", version: 1 }
+ */
+export function parseThemeFilename(filename: string): { name: string; version: number } | undefined {
+    if (!filename.endsWith('.css')) return undefined;
+    const versionedMatch = filename.match(/^(.+)\.v(\d+)\.css$/);
+    if (versionedMatch) {
+        return { name: versionedMatch[1], version: parseInt(versionedMatch[2], 10) };
+    }
+    return { name: filename.replace(/\.css$/, ''), version: 1 };
+}
+
+/**
+ * Find the CSS file for a theme by name in a folder.
+ * 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> {
+    if (!await checkIfExists(folder)) return undefined;
+    const files = await 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;
+}
+
+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`);
@@ -19,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;
     }
@@ -30,14 +75,17 @@ 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 localPath = path.join(userThemesFolder(config), `${name}.css`);
-    if (await checkIfExists(localPath)) {
-        return await loadFile(localPath);
+    const local = await findThemeCssFile(userThemesFolder(config), name);
+    if (local) {
+        return await loadFile(local.path);
     }
 
-    const defaultPath = path.join(config.defaultThemesFolder, `${name}.css`);
-    if (await checkIfExists(defaultPath)) {
-        return await loadFile(defaultPath);
+    // 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;
@@ -51,21 +99,56 @@ export async function listThemes(config: SynthOSConfig): Promise<string[]> {
     if (await checkIfExists(localFolder)) {
         const files = await listFiles(localFolder);
         for (const f of files) {
-            if (f.endsWith('.css')) {
-                names.add(f.replace(/\.css$/, ''));
-            }
+            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) {
-            if (f.endsWith('.css')) {
-                names.add(f.replace(/\.css$/, ''));
-            }
-        }
+    // 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();
 }
+
+/**
+ * Compare local theme versions against defaults and return themes that need upgrading.
+ */
+export async function getOutdatedThemes(config: SynthOSConfig): Promise<string[]> {
+    const localFolder = userThemesFolder(config);
+    if (!await checkIfExists(localFolder)) return [];
+
+    const defaultFiles = await listFilesFromFolders(config.defaultThemesFolders);
+    const localFiles = await listFiles(localFolder);
+
+    // Build maps: theme name → highest version
+    const defaultVersions = new Map<string, number>();
+    for (const f of defaultFiles) {
+        const parsed = parseThemeFilename(f);
+        if (parsed) {
+            const cur = defaultVersions.get(parsed.name) ?? 0;
+            if (parsed.version > cur) defaultVersions.set(parsed.name, parsed.version);
+        }
+    }
+
+    const localVersions = new Map<string, number>();
+    for (const f of localFiles) {
+        const parsed = parseThemeFilename(f);
+        if (parsed) {
+            const cur = localVersions.get(parsed.name) ?? 0;
+            if (parsed.version > cur) localVersions.set(parsed.name, parsed.version);
+        }
+    }
+
+    const outdated: string[] = [];
+    for (const [name, defVer] of defaultVersions) {
+        const localVer = localVersions.get(name) ?? 0;
+        if (localVer < defVer) {
+            outdated.push(name);
+        }
+    }
+    return outdated;
+}

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>