@workadventure/map-starter-kit-core 0.0.1 → 1.0.2

package/.github/workflows/release.yml

@@ -1,47 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches:
-      - main
-      - master
-
-permissions:
-  contents: read
-
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write # to be able to publish a GitHub release
-      issues: write # to be able to comment on released issues
-      pull-requests: write # to be able to comment on released pull requests
-      id-token: write # for npm trusted publishing (OIDC) and provenance
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Verify the integrity of provenance attestations and registry signatures
-        run: npm audit signatures
-
-      - name: Build JS File
-        run: npm run build  
-
-      - name: Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # npm: classic tokens are revoked (Dec 2025). Use Trusted Publishing (OIDC, no token)
-          # on npmjs.com, or a granular access token in NPM_TOKEN (npm token create / npmjs.com)
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npx semantic-release

package/semantic-release.config.js

@@ -1,8 +0,0 @@
-export const branches = ["master"];
-export const plugins = [
-    "@semantic-release/commit-analyzer",
-    "@semantic-release/release-notes-generator",
-    "@semantic-release/npm",
-    "@semantic-release/git",
-    "@semantic-release/github",
-];

package/src/controllers/FrontController.ts

@@ -1,95 +0,0 @@
-import express from 'express';
-import * as fs from "node:fs";
-import * as path from "node:path";
-import Mustache from 'mustache';
-import { getCoreRoot } from '../getCoreRoot.js';
-
-export class FrontController {
-    private app: express.Application;
-
-    constructor(app: express.Application) {
-        this.app = app;
-        // Assets are now configured in app.ts
-        this.setupRoutes();
-        this.setupRoutesStep1();
-        this.setupRoutesStep2();
-        this.setupRoutesStep3();
-        this.setupRoutesStep4();
-    }
-
-    private setupRoutes() {
-        // Route for the Mustache renderer on "/"
-        this.app.get('/', async (_, res) => {
-            try {
-                res.send(await this.renderTemplate('index'));
-            } catch (error) {
-                console.error('Error rendering template:', error);
-                res.status(500).send('Error rendering template');
-            }
-        });
-    }
-
-    /**
-     * Render a template file
-     * @param filename - The filename of the template to render
-     * @returns The rendered template
-     */
-    private async renderTemplate(filename: string): Promise<string> {
-        const coreRoot = getCoreRoot();
-        const templatesDir = path.join(coreRoot, 'src/views');
-        if(!fs.existsSync(templatesDir)) {
-            throw new Error(`Templates directory not found: ${templatesDir}`);
-        }
-        const templatePath = path.join(templatesDir, `${filename}.html`);
-        const template = await fs.promises.readFile(templatePath, 'utf-8');
-        // Render the template with Mustache (without data for now)
-        return Mustache.render(template, {});
-    }
-
-    /**
-     * Setup the routes for file "step1-git.html"
-     * @returns void
-     */
-    private setupRoutesStep1() {
-        this.app.get('/step1-git', async (_, res) => {
-            res.send(await this.renderTemplate('step1-git'));
-        });
-    }
-
-    /**
-     * Setup the routes for file "step2-hosting.html"
-     * @returns void
-     */
-    private setupRoutesStep2() {
-        this.app.get('/step2-hosting', async (_, res) => {
-            res.send(await this.renderTemplate('step2-hosting'));
-        });
-    }
-
-    /**
-     * Setup the routes for file "step3-steps.html"
-     * @returns void
-     */
-    private setupRoutesStep3() {
-        this.app.get('/step3-steps', async (_, res) => {
-            res.send(await this.renderTemplate('step3-steps'));
-        });
-        this.app.get('/step3-steps-selfhosted', async (_, res) => {
-            res.send(await this.renderTemplate('step3-steps-selfhosted'));
-        });
-    }
-
-    /**
-     * Setup the routes for file "step4-map.html"
-     * @returns void
-     */
-    private setupRoutesStep4() {
-        this.app.get('/step4-validated', async (_, res) => {
-            res.send(await this.renderTemplate('step4-validated'));
-        });
-        this.app.get('/step4-validated-selfhosted', async (_, res) => {
-            res.send(await this.renderTemplate('step4-validated-selfhosted'));
-        });
-    }
-    
-}

package/src/controllers/MapController.ts

@@ -1,104 +0,0 @@
-import express from 'express';
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export class MapController {
-    private router: express.Router;
-    private app: express.Application;
-
-    constructor(app: express.Application) {
-        this.app = app;
-        this.router = express.Router();
-        this.setupRoutes();
-        // Register the router on the application with the "/maps" prefix
-        this.app.use('/maps', this.router);
-    }
-
-    /**
-     * Setup the routes for the map controller
-     * @returns void
-     */
-    private setupRoutes() {
-        // Route to retrieve the list of maps with their properties
-        this.router.get('/list', async (_, res) => {
-            try {
-                const mapsDir = './';
-                const maps = await this.getMapsWithProperties(mapsDir);
-                res.json(maps);
-            } catch (error) {
-                console.error('Error getting maps list:', error);
-                res.status(500).json({ error: 'Error getting maps list' });
-            }
-        });
-    }
-
-    /**
-     * Get the list of maps with their properties
-     * @param dir - The directory to search for maps
-     * @param baseDir - The base directory to use for relative paths
-     * @returns The list of maps with their properties
-     */
-    private async getMapsWithProperties(dir: string, baseDir: string = dir): Promise<any[]> {
-        let files = await fs.promises.readdir(dir, { withFileTypes: true });
-        const maps: any[] = [];
-
-        for (const file of files) {
-            const fullPath = path.join(dir, file.name);
-
-            // Exclude the "dist" folder
-            if(file.name === 'dist') continue;
-
-            if (file.isDirectory()) {
-                // Recursively search subdirectories
-                const subMaps = await this.getMapsWithProperties(fullPath, baseDir);
-                maps.push(...subMaps);
-            } else if (file.name.endsWith('.tmj')) {
-                try {
-                    // Read and parse TMJ file
-                    const tmjContent = await fs.promises.readFile(fullPath, 'utf-8');
-                    const tmjData = JSON.parse(tmjContent);
-
-                    // Extract properties
-                    const properties = tmjData.properties || [];
-                    const findProperty = (key: string) => {
-                        const item = properties.find((p: any) => p.name === key);
-                        return item ? item.value : null;
-                    };
-
-                    // Get file stats for size and date
-                    const stats = await fs.promises.stat(fullPath);
-                    const fileSizeInMB = (stats.size / (1024 * 1024)).toFixed(2);
-                    const lastModified = stats.mtime;
-
-                    // Get relative path
-                    const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
-
-                    // Extract filename without extension
-                    const filename = path.basename(file.name, '.tmj');
-
-                    maps.push({
-                        path: relativePath,
-                        filename: filename,
-                        mapName: findProperty('mapName') || filename,
-                        mapImage: findProperty('mapImage') || null,
-                        mapDescription: findProperty('mapDescription') || '',
-                        mapCopyright: findProperty('mapCopyright') || '',
-                        size: fileSizeInMB,
-                        lastModified: lastModified.toISOString(),
-                        lastModifiedFormatted: lastModified.toLocaleDateString('fr-FR', {
-                            day: '2-digit',
-                            month: '2-digit',
-                            year: 'numeric',
-                            hour: '2-digit',
-                            minute: '2-digit'
-                        })
-                    });
-                } catch (error) {
-                    console.error(`Error reading TMJ file ${fullPath}:`, error);
-                }
-            }
-        }
-
-        return maps;
-    }
-}

package/src/controllers/UploaderController.ts

@@ -1,333 +0,0 @@
-import express from 'express';
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-
-const execAsync = promisify(exec);
-
-/** Metadata returned by map-storage for each map (WAM file). */
-export interface MapStorageMetadata {
-    copyright?: string;
-    description?: string;
-    name?: string;
-    thumbnail?: string;
-}
-
-/** Single map entry returned by map-storage GET /maps/ (value in the map). */
-export interface MapStorageEntry {
-    mapUrl: string;
-    wamFileUrl?: string;
-    metadata?: MapStorageMetadata;
-}
-
-/** Response shape: Map<wamfile, { mapUrl, metadata }>. In JSON this is a plain object. */
-export interface MapStorageListResponse {
-    [wamFile: string]: MapStorageEntry;
-}
-
-/** Hydrated map item returned by our API to the frontend. */
-export interface MapListItem {
-    wamFileUrl: string;
-    filename: string;
-    mapName: string | null;
-    mapDescription?: string;
-    mapCopyright?: string;
-    mapImage: string | null;
-    mapUrl: string;
-}
-
-/**
- * Converts the map-storage response (Map<wamfile, entry>) into a list of MapListItem.
- */
-export function hydrateMapStorageList(
-    raw: MapStorageListResponse,
-    mapStorageBaseUrl: string
-): MapListItem[] {
-    const list: MapListItem[] = [];
-    const baseUrl = mapStorageBaseUrl.replace(/\/$/, '');
-
-    for (const [wamFile, entry] of Object.entries(raw)) {
-        if (!entry || typeof entry !== 'object') continue;
-
-        const rawWamFileUrl = entry.wamFileUrl ?? wamFile;
-        const wamFileUrlNormalized = rawWamFileUrl.startsWith('http')
-            ? new URL(rawWamFileUrl).pathname.replace(/^\//, '')
-            : rawWamFileUrl.replace(/^\//, '');
-
-        const filename = wamFileUrlNormalized.split('/').pop() ?? wamFileUrlNormalized;
-        const nameFromFile = filename.replace(/\.(tmj|wam)$/i, '');
-
-        const meta = entry.metadata ?? {};
-        const mapUrl = entry.mapUrl ?? (entry as unknown as { mapUrl?: string }).mapUrl ?? '';
-
-        let mapImage: string | null = null;
-        if (meta.thumbnail) {
-            if (meta.thumbnail.startsWith('http')) {
-                mapImage = meta.thumbnail;
-            } else {
-                const thumbFile = meta.thumbnail.replace(/^\//, '');
-                const wamDir = wamFileUrlNormalized.includes('/')
-                    ? wamFileUrlNormalized.replace(/\/[^/]*$/, '')
-                    : '';
-                const thumbPath = wamDir ? `${wamDir}/${thumbFile}` : thumbFile;
-                mapImage = `${baseUrl}/${thumbPath}`;
-            }
-        }
-
-        list.push({
-            wamFileUrl: wamFileUrlNormalized,
-            filename,
-            mapName: meta.name ?? nameFromFile,
-            mapDescription: meta.description,
-            mapCopyright: meta.copyright,
-            mapImage,
-            mapUrl: mapUrl.startsWith('http') ? mapUrl : `${baseUrl}/${mapUrl.replace(/^\//, '')}`,
-        });
-    }
-
-    return list;
-}
-
-export class UploaderController {
-    private router: express.Router;
-    private app: express.Application;
-
-    constructor(app: express.Application) {
-        this.app = app;
-        this.router = express.Router();
-        this.setupMiddleware();
-        this.setupRoutes();
-        // Register the router on the application with the "/uploader" prefix
-        this.app.use('/uploader', this.router);
-    }
-
-    private setupMiddleware() {
-        // Middleware to parse JSON bodies
-        this.router.use(express.json());
-    }
-
-    private setupRoutes() {
-        // Route to configure MAP_STORAGE mode
-        this.router.post('/configure', async (req, res) => {
-            try {
-                const { mapStorageUrl, mapStorageApiKey, uploadDirectory } = req.body;
-
-                // Validate required fields
-                if (!mapStorageUrl || !mapStorageApiKey || !uploadDirectory) {
-                    return res.status(400).json({
-                        error: 'Missing required fields',
-                        required: ['mapStorageUrl', 'mapStorageApiKey', 'uploadDirectory']
-                    });
-                }
-
-                // Create or update .env.secret file
-                await this.createEnvSecretFile({
-                    mapStorageUrl,
-                    mapStorageApiKey,
-                    uploadDirectory
-                });
-
-                return res.json({
-                    success: true,
-                    message: 'Configuration updated successfully'
-                });
-            } catch (error) {
-                console.error('Error configuring uploader:', error);
-                return res.status(500).json({
-                    error: 'Error configuring uploader',
-                    message: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
-        });
-
-        // Route to get current configuration status
-        this.router.get('/status', async (_, res) => {
-            try {
-                const envSecretPath = path.join(process.cwd(), 'src/.env.secret');
-
-                const hasSecretFile = await fs.promises.access(envSecretPath)
-                    .then(() => true)
-                    .catch(() => false);
-
-                let secretConfig: {
-                    mapStorageUrl: string | null;
-                    mapStorageApiKey: string | null;
-                    uploadDirectory: string | null;
-                } | null = null;
-                if (hasSecretFile) {
-                    const secretContent = await fs.promises.readFile(envSecretPath, 'utf-8');
-                    const mapStorageUrl = secretContent.match(/MAP_STORAGE_URL=(.+)/)?.[1]?.trim();
-                    const mapStorageApiKey = secretContent.match(/MAP_STORAGE_API_KEY=(.+)/)?.[1]?.trim();
-                    const uploadDirectory = secretContent.match(/UPLOAD_DIRECTORY=(.+)/)?.[1]?.trim();
-
-                    secretConfig = {
-                        mapStorageUrl: mapStorageUrl || null,
-                        mapStorageApiKey: mapStorageApiKey || null, // Hide the actual key
-                        uploadDirectory: uploadDirectory || null
-                    };
-                }
-
-                res.json({
-                    hasSecretFile,
-                    secretConfig
-                });
-            } catch (error) {
-                console.error('Error getting uploader status:', error);
-                res.status(500).json({
-                    error: 'Error getting uploader status',
-                    message: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
-        });
-
-        // Route to get list of maps from map-storage (for self-hosted step4)
-        this.router.get('/maps-storage-list', async (_, res) => {
-            try {
-                const envSecretPath = path.join(process.cwd(), '.env.secret');
-                const hasSecretFile = await fs.promises.access(envSecretPath)
-                    .then(() => true)
-                    .catch(() => false);
-
-                if (!hasSecretFile) {
-                    return res.status(400).json({
-                        error: 'Configuration not found',
-                        message: 'Please configure the upload settings first.'
-                    });
-                }
-
-                const secretContent = await fs.promises.readFile(envSecretPath, 'utf-8');
-                const mapStorageUrl = secretContent.match(/MAP_STORAGE_URL=(.+)/)?.[1]?.trim();
-                const mapStorageApiKey = secretContent.match(/MAP_STORAGE_API_KEY=(.+)/)?.[1]?.trim();
-
-                if (!mapStorageUrl || !mapStorageApiKey) {
-                    return res.status(400).json({
-                        error: 'Missing map-storage configuration',
-                        message: 'MAP_STORAGE_URL and MAP_STORAGE_API_KEY must be set in .env.secret.'
-                    });
-                }
-
-                const baseUrl = mapStorageUrl.replace(/\/$/, '');
-                const listUrl = `${baseUrl}/maps/`;
-
-                const response = await fetch(listUrl, {
-                    method: 'GET',
-                    headers: {
-                        'Authorization': `Bearer ${mapStorageApiKey}`,
-                        'Content-Type': 'application/json'
-                    }
-                });
-
-                if (!response.ok) {
-                    const text = await response.text();
-                    console.error('Map-storage list error:', response.status, text);
-                    return res.status(response.status).json({
-                        error: 'Map-storage request failed',
-                        message: response.status === 401
-                            ? 'Invalid API key. Check MAP_STORAGE_API_KEY in your .env.secret.'
-                            : `Map-storage returned ${response.status}: ${text.slice(0, 200)}`
-                    });
-                }
-
-                const data = await response.json();
-                // Map-storage returns Map<wamfile, { mapUrl, metadata }> (as a plain object in JSON)
-                const raw = typeof data === 'object' && data !== null ? data : {};
-                const rawMap: MapStorageListResponse = !Array.isArray(raw) && typeof raw.maps === 'object' && raw.maps !== null
-                    ? (raw.maps as MapStorageListResponse)
-                    : !Array.isArray(raw)
-                    ? (raw as MapStorageListResponse)
-                    : {};
-                const maps = hydrateMapStorageList(rawMap, baseUrl);
-                const playBaseUrl = secretContent.match(/PLAY_BASE_URL=(.+)/)?.[1]?.trim() || null;
-                return res.json({ maps, mapStorageUrl: baseUrl, playBaseUrl });
-            } catch (error) {
-                console.error('Error fetching maps from map-storage:', error);
-                return res.status(500).json({
-                    error: 'Error fetching maps list',
-                    message: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
-        });
-
-        // Route to upload map
-        this.router.post('/upload', async (_, res) => {
-            try {
-                // Verify that configuration exists
-                const envSecretPath = path.join(process.cwd(), '.env.secret');
-
-                // Check if .env.secret exists
-                const hasSecretFile = await fs.promises.access(envSecretPath)
-                    .then(() => true)
-                    .catch(() => false);
-
-                if (!hasSecretFile) {
-                    return res.status(400).json({
-                        error: 'Configuration not found',
-                        message: 'Please configure the upload settings first using /uploader/configure'
-                    });
-                }
-
-                // Execute upload
-                await this.runUpload();
-
-                return res.json({
-                    success: true,
-                    message: 'Map uploaded successfully'
-                });
-            } catch (error) {
-                console.error('Error uploading map:', error);
-                return res.status(500).json({
-                    error: 'Error uploading map',
-                    message: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
-        });
-    }
-
-    private async runUpload(): Promise<void> {
-        const projectRoot = process.cwd();
-        
-        try {
-            // Execute npm run upload-only
-            // The command will read environment variables from .env and .env.secret
-            const { stdout, stderr } = await execAsync('npm run upload', {
-                cwd: projectRoot,
-                env: {
-                    ...process.env,
-                    // Ensure we're using the current process environment
-                    NODE_ENV: process.env.NODE_ENV || 'development'
-                },
-                maxBuffer: 10 * 1024 * 1024 // 10MB buffer for output
-            });
-
-            if (stderr && !stderr.includes('warning')) {
-                console.warn('Upload stderr:', stderr);
-            }
-            
-            console.info('Upload stdout:', stdout);
-            console.info('Upload completed successfully');
-        } catch (error) {
-            console.error('Error executing upload-only:', error);
-            throw error;
-        }
-    }
-
-    private async createEnvSecretFile(config: {
-        mapStorageUrl: string;
-        mapStorageApiKey: string;
-        uploadDirectory: string;
-    }): Promise<void> {
-        const envSecretPath = path.join(process.cwd(), '.env.secret');
-
-        // Create the .env.secret file with the provided configuration
-        const secretContent = `# Secret configuration file for MAP_STORAGE upload mode
-# This file is not committed to git (see .gitignore)
-
-MAP_STORAGE_URL=${config.mapStorageUrl}
-MAP_STORAGE_API_KEY=${config.mapStorageApiKey}
-UPLOAD_DIRECTORY=${config.uploadDirectory}
-`;
-
-        await fs.promises.writeFile(envSecretPath, secretContent, 'utf-8');
-    }
-}

package/src/getCoreRoot.ts

@@ -1,40 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-let coreRoot: string | null = null;
-
-/**
- * Returns the root directory of the "core" package (app + templates + public).
- * - When running from the project root: returns process.cwd().
- * - When running from packages/map-starter-kit-core or node_modules: returns the package directory.
- * Allows updating the core package without touching user files (maps, .env, tilesets).
- */
-export function getCoreRoot(): string {
-    if (coreRoot !== null) {
-        return coreRoot;
-    }
-    try {
-        const dir = path.dirname(fileURLToPath(import.meta.url));
-        const candidate = path.dirname(dir);
-        const packagePath = path.join(candidate, "package.json");
-        if (fs.existsSync(packagePath)) {
-            const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-            if (pkg.name === "@workadventure/map-starter-kit-core") {
-                coreRoot = candidate;
-                return coreRoot;
-            }
-        }
-    } catch {
-        // ignore
-    }
-    coreRoot = process.cwd();
-    return coreRoot;
-}
-
-/**
- * Override the core root (e.g. for tests or custom layout).
- */
-export function setCoreRoot(root: string): void {
-    coreRoot = root;
-}