tide-commander 0.52.0

package/dist/src/packages/server/routes/config.js

@@ -0,0 +1,347 @@
+/**
+ * Config Export/Import Routes
+ * Handles exporting and importing Tide Commander configuration
+ */
+import { Router } from 'express';
+import { createReadStream, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { readFile, writeFile, mkdir, rm } from 'fs/promises';
+import { join, dirname } from 'path';
+import os from 'os';
+import archiver from 'archiver';
+import { Extract } from 'unzip-stream';
+import { createLogger } from '../utils/index.js';
+const log = createLogger('ConfigRoutes');
+const router = Router();
+// Config directories
+const HOME_CONFIG_DIR = join(os.homedir(), '.tide-commander');
+const DATA_CONFIG_DIR = join(os.homedir(), '.local', 'share', 'tide-commander');
+const CONFIG_CATEGORIES = [
+    {
+        id: 'agents',
+        name: 'Agents',
+        description: 'Agent positions, names, and settings',
+        files: ['agents.json'],
+        sourceDir: 'data',
+    },
+    {
+        id: 'areas',
+        name: 'Areas',
+        description: 'Drawing areas and zones',
+        files: ['areas.json'],
+        sourceDir: 'data',
+    },
+    {
+        id: 'buildings',
+        name: 'Buildings',
+        description: 'Building configurations and PM2 settings',
+        files: ['buildings.json'],
+        sourceDir: 'data',
+    },
+    {
+        id: 'skills',
+        name: 'Skills',
+        description: 'Custom skills and their assignments',
+        files: ['skills.json'],
+        sourceDir: 'data',
+    },
+    {
+        id: 'custom-classes',
+        name: 'Custom Agent Classes',
+        description: 'Custom agent class definitions and instructions',
+        files: ['custom-agent-classes.json'],
+        sourceDir: 'data',
+    },
+    {
+        id: 'class-instructions',
+        name: 'Class Instructions',
+        description: 'Markdown instruction files for custom classes',
+        files: ['class-instructions/*'],
+        sourceDir: 'home',
+    },
+    {
+        id: 'prompts',
+        name: 'Agent Prompts',
+        description: 'Individual agent prompt files',
+        files: ['prompts/*'],
+        sourceDir: 'home',
+    },
+    {
+        id: 'custom-models',
+        name: 'Custom 3D Models',
+        description: 'GLB model files for custom agent classes',
+        files: ['custom-models/*'],
+        sourceDir: 'home',
+    },
+    {
+        id: 'hooks',
+        name: 'Hooks',
+        description: 'Hook scripts and settings',
+        files: ['hooks/*', 'hook-settings.json'],
+        sourceDir: 'home',
+    },
+    {
+        id: 'permissions',
+        name: 'Remembered Permissions',
+        description: 'Saved permission decisions',
+        files: ['remembered-permissions.json'],
+        sourceDir: 'home',
+    },
+    {
+        id: 'secrets',
+        name: 'Secrets',
+        description: 'Encrypted secrets (keys not included)',
+        files: ['secrets.json'],
+        sourceDir: 'data',
+    },
+];
+/**
+ * Get list of available config categories
+ */
+router.get('/categories', (_req, res) => {
+    const categories = CONFIG_CATEGORIES.map(cat => ({
+        id: cat.id,
+        name: cat.name,
+        description: cat.description,
+    }));
+    res.json(categories);
+});
+/**
+ * Helper to get files matching a pattern
+ */
+function getFilesForPattern(baseDir, pattern) {
+    const files = [];
+    if (pattern.endsWith('/*')) {
+        // Directory pattern - get all files in directory
+        const dirName = pattern.slice(0, -2);
+        const dirPath = join(baseDir, dirName);
+        if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+            const entries = readdirSync(dirPath);
+            for (const entry of entries) {
+                const entryPath = join(dirPath, entry);
+                if (statSync(entryPath).isFile()) {
+                    files.push(join(dirName, entry));
+                }
+            }
+        }
+    }
+    else {
+        // Single file pattern
+        const filePath = join(baseDir, pattern);
+        if (existsSync(filePath) && statSync(filePath).isFile()) {
+            files.push(pattern);
+        }
+    }
+    return files;
+}
+/**
+ * Export selected config categories as a ZIP file
+ * GET /api/config/export?categories=agents,buildings,skills
+ */
+router.get('/export', async (req, res) => {
+    try {
+        const categoriesParam = req.query.categories;
+        const selectedIds = categoriesParam ? categoriesParam.split(',') : CONFIG_CATEGORIES.map(c => c.id);
+        // Validate categories
+        const selectedCategories = CONFIG_CATEGORIES.filter(c => selectedIds.includes(c.id));
+        if (selectedCategories.length === 0) {
+            res.status(400).json({ error: 'No valid categories selected' });
+            return;
+        }
+        log.log(`Exporting config categories: ${selectedCategories.map(c => c.id).join(', ')}`);
+        // Set response headers for ZIP download
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const filename = `tide-commander-config-${timestamp}.zip`;
+        res.setHeader('Content-Type', 'application/zip');
+        res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+        // Create ZIP archive
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        archive.on('error', (err) => {
+            log.error('Archive error:', err);
+            if (!res.headersSent) {
+                res.status(500).json({ error: 'Failed to create archive' });
+            }
+        });
+        // Pipe archive to response
+        archive.pipe(res);
+        // Add manifest file
+        const manifest = {
+            version: '1.0',
+            exportedAt: new Date().toISOString(),
+            categories: selectedCategories.map(c => c.id),
+        };
+        archive.append(JSON.stringify(manifest, null, 2), { name: 'manifest.json' });
+        // Add files for each selected category
+        for (const category of selectedCategories) {
+            const baseDir = category.sourceDir === 'home' ? HOME_CONFIG_DIR : DATA_CONFIG_DIR;
+            for (const pattern of category.files) {
+                const files = getFilesForPattern(baseDir, pattern);
+                for (const file of files) {
+                    const filePath = join(baseDir, file);
+                    const archivePath = join(category.sourceDir, file);
+                    archive.file(filePath, { name: archivePath });
+                }
+            }
+        }
+        await archive.finalize();
+        log.log(`Config export completed: ${filename}`);
+    }
+    catch (error) {
+        log.error('Export error:', error);
+        if (!res.headersSent) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+});
+/**
+ * Preview what's in an uploaded config ZIP
+ * POST /api/config/preview (multipart/form-data with 'file' field)
+ */
+router.post('/preview', async (req, res) => {
+    try {
+        if (!req.body || !Buffer.isBuffer(req.body)) {
+            res.status(400).json({ error: 'No file uploaded' });
+            return;
+        }
+        // Create temp directory for extraction
+        const tempDir = join(os.tmpdir(), `tide-config-preview-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        try {
+            // Write buffer to temp file and extract
+            const tempZip = join(tempDir, 'upload.zip');
+            await writeFile(tempZip, req.body);
+            // Extract ZIP
+            await new Promise((resolve, reject) => {
+                createReadStream(tempZip)
+                    .pipe(Extract({ path: tempDir }))
+                    .on('close', resolve)
+                    .on('error', reject);
+            });
+            // Read manifest
+            const manifestPath = join(tempDir, 'manifest.json');
+            if (!existsSync(manifestPath)) {
+                res.status(400).json({ error: 'Invalid config file: missing manifest.json' });
+                return;
+            }
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            // Scan for available categories
+            const availableCategories = [];
+            for (const category of CONFIG_CATEGORIES) {
+                if (manifest.categories?.includes(category.id)) {
+                    const baseDir = join(tempDir, category.sourceDir);
+                    let fileCount = 0;
+                    for (const pattern of category.files) {
+                        const files = getFilesForPattern(baseDir, pattern);
+                        fileCount += files.length;
+                    }
+                    if (fileCount > 0) {
+                        availableCategories.push({
+                            id: category.id,
+                            name: category.name,
+                            description: category.description,
+                            fileCount,
+                        });
+                    }
+                }
+            }
+            res.json({
+                version: manifest.version,
+                exportedAt: manifest.exportedAt,
+                categories: availableCategories,
+            });
+        }
+        finally {
+            // Cleanup temp directory
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        log.error('Preview error:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * Import config from uploaded ZIP
+ * POST /api/config/import?categories=agents,buildings (multipart/form-data with 'file' field)
+ */
+router.post('/import', async (req, res) => {
+    try {
+        if (!req.body || !Buffer.isBuffer(req.body)) {
+            res.status(400).json({ error: 'No file uploaded' });
+            return;
+        }
+        const categoriesParam = req.query.categories;
+        if (!categoriesParam) {
+            res.status(400).json({ error: 'No categories specified' });
+            return;
+        }
+        const selectedIds = categoriesParam.split(',');
+        const selectedCategories = CONFIG_CATEGORIES.filter(c => selectedIds.includes(c.id));
+        if (selectedCategories.length === 0) {
+            res.status(400).json({ error: 'No valid categories selected' });
+            return;
+        }
+        log.log(`Importing config categories: ${selectedCategories.map(c => c.id).join(', ')}`);
+        // Create temp directory for extraction
+        const tempDir = join(os.tmpdir(), `tide-config-import-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        try {
+            // Write buffer to temp file and extract
+            const tempZip = join(tempDir, 'upload.zip');
+            await writeFile(tempZip, req.body);
+            // Extract ZIP
+            await new Promise((resolve, reject) => {
+                createReadStream(tempZip)
+                    .pipe(Extract({ path: tempDir }))
+                    .on('close', resolve)
+                    .on('error', reject);
+            });
+            // Verify manifest
+            const manifestPath = join(tempDir, 'manifest.json');
+            if (!existsSync(manifestPath)) {
+                res.status(400).json({ error: 'Invalid config file: missing manifest.json' });
+                return;
+            }
+            const imported = [];
+            // Import each selected category
+            for (const category of selectedCategories) {
+                const sourceBaseDir = join(tempDir, category.sourceDir);
+                const targetBaseDir = category.sourceDir === 'home' ? HOME_CONFIG_DIR : DATA_CONFIG_DIR;
+                const importedFiles = [];
+                for (const pattern of category.files) {
+                    const files = getFilesForPattern(sourceBaseDir, pattern);
+                    for (const file of files) {
+                        const sourcePath = join(sourceBaseDir, file);
+                        const targetPath = join(targetBaseDir, file);
+                        // Ensure target directory exists
+                        const targetDir = dirname(targetPath);
+                        if (!existsSync(targetDir)) {
+                            await mkdir(targetDir, { recursive: true });
+                        }
+                        // Copy file
+                        const content = await readFile(sourcePath);
+                        await writeFile(targetPath, content);
+                        importedFiles.push(file);
+                    }
+                }
+                if (importedFiles.length > 0) {
+                    imported.push({ category: category.id, files: importedFiles });
+                }
+            }
+            log.log(`Config import completed: ${imported.map(i => `${i.category}(${i.files.length})`).join(', ')}`);
+            res.json({
+                success: true,
+                imported,
+                message: 'Config imported successfully. Restart Tide Commander to apply changes.',
+            });
+        }
+        finally {
+            // Cleanup temp directory
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        log.error('Import error:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+export default router;

package/dist/src/packages/server/routes/custom-models.js

@@ -0,0 +1,170 @@
+/**
+ * Custom Models Routes
+ * REST API endpoints for custom 3D model operations
+ */
+import { Router } from 'express';
+import * as fs from 'fs';
+import { logger } from '../utils/logger.js';
+import { saveCustomModel, hasCustomModel, getCustomModelPath, getCustomClass, updateCustomClass, } from '../services/custom-class-service.js';
+const log = logger.files;
+const router = Router();
+// Maximum file size: 50MB
+const MAX_FILE_SIZE = 50 * 1024 * 1024;
+/**
+ * POST /api/custom-models/upload/:classId
+ * Upload a custom GLB model for a class
+ *
+ * Headers:
+ *   Content-Type: application/octet-stream or model/gltf-binary
+ *   X-Filename: optional original filename
+ *
+ * Body: Raw GLB file data
+ *
+ * Returns: { success: true, path: string, size: number }
+ */
+router.post('/upload/:classId', async (req, res) => {
+    try {
+        const { classId } = req.params;
+        if (!classId) {
+            res.status(400).json({ error: 'Missing classId parameter' });
+            return;
+        }
+        // Verify the class exists
+        const customClass = getCustomClass(classId);
+        if (!customClass) {
+            res.status(404).json({ error: 'Custom class not found' });
+            return;
+        }
+        // Collect body data
+        const chunks = [];
+        let totalSize = 0;
+        req.on('data', (chunk) => {
+            totalSize += chunk.length;
+            if (totalSize > MAX_FILE_SIZE) {
+                res.status(413).json({ error: 'File too large (max 50MB)' });
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            if (res.headersSent)
+                return; // Already responded with error
+            const buffer = Buffer.concat(chunks);
+            // Validate GLB magic number (glTF binary starts with 'glTF')
+            if (buffer.length < 4 || buffer.toString('ascii', 0, 4) !== 'glTF') {
+                res.status(400).json({ error: 'Invalid GLB file format' });
+                return;
+            }
+            // Save the model
+            const modelPath = saveCustomModel(classId, buffer);
+            // Update the class with the custom model path
+            updateCustomClass(classId, {
+                customModelPath: modelPath,
+                model: undefined, // Clear built-in model selection
+            });
+            log.log(`Uploaded custom model for class ${classId} (${buffer.length} bytes)`);
+            res.json({
+                success: true,
+                path: modelPath,
+                size: buffer.length,
+            });
+        });
+        req.on('error', (err) => {
+            log.error('Model upload error:', err);
+            if (!res.headersSent) {
+                res.status(500).json({ error: 'Upload failed' });
+            }
+        });
+    }
+    catch (err) {
+        log.error('Failed to upload custom model:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/custom-models/:classId
+ * Serve a custom model file
+ *
+ * Returns: GLB file binary data
+ */
+router.get('/:classId', async (req, res) => {
+    try {
+        const { classId } = req.params;
+        if (!classId) {
+            res.status(400).json({ error: 'Missing classId parameter' });
+            return;
+        }
+        const modelPath = getCustomModelPath(classId);
+        if (!modelPath) {
+            res.status(404).json({ error: 'Custom model not found' });
+            return;
+        }
+        const stats = fs.statSync(modelPath);
+        res.setHeader('Content-Type', 'model/gltf-binary');
+        res.setHeader('Content-Length', stats.size);
+        res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
+        const stream = fs.createReadStream(modelPath);
+        stream.pipe(res);
+    }
+    catch (err) {
+        log.error('Failed to serve custom model:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * DELETE /api/custom-models/:classId
+ * Delete a custom model and revert class to default model
+ */
+router.delete('/:classId', async (req, res) => {
+    try {
+        const { classId } = req.params;
+        if (!classId) {
+            res.status(400).json({ error: 'Missing classId parameter' });
+            return;
+        }
+        const customClass = getCustomClass(classId);
+        if (!customClass) {
+            res.status(404).json({ error: 'Custom class not found' });
+            return;
+        }
+        const modelPath = getCustomModelPath(classId);
+        if (modelPath && fs.existsSync(modelPath)) {
+            fs.unlinkSync(modelPath);
+            log.log(`Deleted custom model for class ${classId}`);
+        }
+        // Update class to use default model
+        updateCustomClass(classId, {
+            customModelPath: undefined,
+            model: 'character-male-a.glb', // Revert to default
+            animationMapping: undefined,
+            availableAnimations: undefined,
+            modelScale: undefined,
+        });
+        res.json({ success: true });
+    }
+    catch (err) {
+        log.error('Failed to delete custom model:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/custom-models/:classId/exists
+ * Check if a custom model exists for a class
+ */
+router.get('/:classId/exists', async (req, res) => {
+    try {
+        const { classId } = req.params;
+        if (!classId) {
+            res.status(400).json({ error: 'Missing classId parameter' });
+            return;
+        }
+        const exists = hasCustomModel(classId);
+        res.json({ exists, classId });
+    }
+    catch (err) {
+        log.error('Failed to check custom model:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+export default router;