@silexlabs/silex 3.0.1-0 → 3.0.1

package/src/ts/server/api/publicationApi.ts

@@ -17,13 +17,12 @@
 
 import { Router } from 'express'
 import { API_PUBLICATION_PUBLISH, API_PUBLICATION_STATUS, API_WEBSITE_ASSET_READ } from '../../constants'
-import { getJob } from '../jobs'
-import { ApiPublicationPublishBody, ApiPublicationPublishQuery, ApiPublicationPublishResponse, ApiPublicationStatusQuery, ApiPublicationStatusResponse, JobId, PublicationSettings, PublicationData as PublicationData, ConnectorType, ConnectorId, WebsiteId} from '../../types'
+import { ApiPublicationPublishBody, ApiPublicationPublishQuery, ApiPublicationPublishResponse, ApiPublicationStatusQuery, ApiPublicationStatusResponse, JobId, PublicationData, ConnectorType, ConnectorId, WebsiteId, ClientSideFile, ClientSideFileWithContent, ClientSideFileWithSrc} from '../../types'
 import { ConnectorFile, HostingConnector, StorageConnector, getConnector } from '../connectors/connectors'
 import { ServerConfig } from '../config'
 import { requiredParam } from '../utils/validation'
-import { join } from 'path'
 import { PublishEndEventType, PublishStartEventType, ServerEvent } from '../events'
+import { getJob, jobManager } from '../jobs'
 
 /**
  * @fileoverview Publication plugin for Silex
@@ -109,9 +108,9 @@ export default function (config: ServerConfig): Router {
 
       // Check params
       const data = body as PublicationData
-      const { files, publication, assets } = data
-      if(!files || !publication || !assets) {
-        throw new PublicationError('Missing data from request: files, publication or assets', 400)
+      const { files } = data
+      if(!files) {
+        throw new PublicationError('Missing files in body', 400)
       }
 
       // Hook for plugins
@@ -123,29 +122,23 @@ export default function (config: ServerConfig): Router {
       // Get storage connector which holds the assets
       const storage = await getStorageConnector(session, config, storageId)
 
-      // Publication
-      const assetsFiles: ConnectorFile[] = await Promise.all(assets.map(async asset => {
-        if(!asset.path) throw new PublicationError('Missing path in asset', 400)
-        if(!asset.src) throw new PublicationError('Missing src in asset', 400)
-        // Remove the / from the asset root if it starts with one
-        const prefix = API_WEBSITE_ASSET_READ.replace(/^\//, '')
-        // Get the asset url relative to the asset root
-        const src = asset.src.startsWith(prefix) ? asset.src.substring(prefix.length) : asset.src
+      // Load the content if necessary
+      const filesList: ConnectorFile[] = await Promise.all(files.map(async (file: ClientSideFile) => {
+        const fileWithContent = file as ClientSideFileWithContent
+        const fileWithSrc = file as ClientSideFileWithSrc
+        if(!fileWithContent.content && !fileWithSrc.src) throw new PublicationError('Missing content or src in file', 400)
+        const src = fileWithSrc.src
         return {
-          path: asset.path,
-          content: await storage.readAsset(session, websiteId, src),
+          // Destination
+          path: file.permalink ?? file.path,
+          // Content
+          content: fileWithContent.content ?? await storage.readAsset(session, websiteId, fileWithSrc.src),
         }
       }))
-      const filesList: ConnectorFile[] = files.flatMap<ConnectorFile>(file => ([{
-        path: file.htmlPath,
-        content: file.html,
-      }, {
-        path: file.cssPath,
-        content: file.css,
-      }])).concat(assetsFiles)
+
       res.json({
         url: await hostingConnector.getUrl(session, websiteId),
-        job: await hostingConnector.publish(session, websiteId, filesList),
+        job: await hostingConnector.publish(session, websiteId, filesList, jobManager),
       } as ApiPublicationPublishResponse)
     } catch (err) {
       console.error('Error publishing the website', err)

package/src/ts/server/api/websiteApi.ts

@@ -18,13 +18,13 @@
 import { Router } from 'express'
 import formidable from 'formidable'
 import PersistentFile from 'formidable/src/PersistentFile'
-import { API_WEBSITE_ASSET_READ, API_WEBSITE_ASSETS_WRITE, API_WEBSITE_READ, API_WEBSITE_WRITE, API_WEBSITE_DELETE, API_WEBSITE_META_READ, API_WEBSITE_META_WRITE, API_WEBSITE_LIST, API_WEBSITE_CREATE, API_PATH, API_WEBSITE_PATH } from '../../constants'
+import { API_WEBSITE_ASSET_READ, API_WEBSITE_ASSETS_WRITE, API_WEBSITE_READ, API_WEBSITE_WRITE, API_WEBSITE_DELETE, API_WEBSITE_META_READ, API_WEBSITE_META_WRITE, API_WEBSITE_LIST, API_WEBSITE_CREATE, API_PATH, API_WEBSITE_PATH, API_WEBSITE_DUPLICATE } from '../../constants'
 import { createReadStream } from 'fs'
-import { ApiError, ApiWebsiteAssetsReadParams, ApiWebsiteAssetsReadQuery, ApiWebsiteAssetsReadResponse, ApiWebsiteAssetsWriteQuery, ApiWebsiteAssetsWriteResponse, ApiWebsiteDeleteQuery, ApiWebsiteReadQuery, ApiWebsiteReadResponse, ApiWebsiteWriteBody, ApiWebsiteWriteQuery, ConnectorId, ConnectorType, WebsiteMeta, WebsiteData, WebsiteId, ApiWebsiteListQuery, ApiWebsiteListResponse, ApiWebsiteMetaReadQuery, ApiWebsiteMetaReadResponse, ApiWebsiteMetaWriteQuery, ApiWebsiteMetaWriteBody, WebsiteMetaFileContent, ApiWebsiteMetaWriteResponse, ApiWebsiteWriteResponse, ApiWebsiteCreateQuery, ApiWebsiteCreateBody } from '../../types'
+import { ApiError, ApiWebsiteAssetsReadParams, ApiWebsiteAssetsReadQuery, ApiWebsiteAssetsReadResponse, ApiWebsiteAssetsWriteQuery, ApiWebsiteAssetsWriteResponse, ApiWebsiteDeleteQuery, ApiWebsiteReadQuery, ApiWebsiteReadResponse, ApiWebsiteWriteBody, ApiWebsiteWriteQuery, ConnectorId, ConnectorType, WebsiteMeta, WebsiteData, WebsiteId, ApiWebsiteListQuery, ApiWebsiteListResponse, ApiWebsiteMetaReadQuery, ApiWebsiteMetaReadResponse, ApiWebsiteMetaWriteQuery, ApiWebsiteMetaWriteBody, WebsiteMetaFileContent, ApiWebsiteMetaWriteResponse, ApiWebsiteWriteResponse, ApiWebsiteCreateQuery, ApiWebsiteCreateBody, ApiWebsiteDuplicateQuery } from '../../types'
 import { ConnectorFile, ConnectorFileContent, ConnectorSession, StorageConnector, getConnector } from '../connectors/connectors'
 import { Readable } from 'stream'
 import { requiredParam } from '../utils/validation'
-import { basename } from 'path'
+import { basename, join } from 'path'
 import { ServerConfig } from '../config'
 import { ServerEvent, WebsiteStoreEndEventType, WebsiteStoreStartEventType, WebsiteAssetStoreStartEventType, WebsiteAssetStoreEndEventType } from '../events'
 
@@ -226,6 +226,23 @@ export default function (config: ServerConfig, opts = {}): Router {
     }
   })
 
+  // Duplicate website
+  router.post(API_WEBSITE_DUPLICATE, async (req, res) => {
+    try {
+      const query: ApiWebsiteDuplicateQuery = req.query as any
+      const websiteId= requiredParam<WebsiteId>(query.websiteId, 'New website id')
+      await duplicateWebsite(req['session'], websiteId, query.connectorId)
+      res.status(200).json({ message: 'Website duplicated' } as ApiError)
+    } catch (e) {
+      console.error('Error duplicating website data', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
   // Load assets
   router.get(API_WEBSITE_ASSET_READ + '/:path', async (req, res) => {
     {
@@ -261,11 +278,10 @@ export default function (config: ServerConfig, opts = {}): Router {
     try {
       // Check input
       const query: ApiWebsiteAssetsWriteQuery = req.query as any
-      const websiteId= requiredParam<WebsiteId>(query.websiteId as WebsiteId, 'Website id')
+      const websiteId = requiredParam<WebsiteId>(query.websiteId as WebsiteId, 'Website id')
 
       // Get the file data from the request
       const form = formidable({
-        filename: (name, ext, part, _form) => `${name}${ext}`,
         multiples: true,
         keepExtensions: true,
       })
@@ -278,7 +294,7 @@ export default function (config: ServerConfig, opts = {}): Router {
             console.error('Error parsing upload data', err)
             reject(new ApiError('Error parsing upload data: ' + err.message, 400))
           } else {
-            const files = ([].concat(_files['files[]']) as PersistentFile[])
+            const files = ([].concat(_files['files[]'] as PersistentFile) as PersistentFile[])
               .map(file => file.toJSON())
               .map(file => ({
                 path: `/${file.originalFilename}`,
@@ -293,16 +309,26 @@ export default function (config: ServerConfig, opts = {}): Router {
       config.emit(ServerEvent.WEBSITE_ASSET_STORE_START, { files, websiteId, connectorId } as WebsiteAssetStoreStartEventType)
 
       // Write the files
-      await writeAssets(req['session'], websiteId, files, connectorId)
+      const result = await writeAssets(req['session'], websiteId, files, connectorId)
+
+      // Base URL of silex serve
+      const baseUrl = new URL(config.url).pathname.replace(/\/$/, '')
 
       // Return the file URLs to insert in the website
       // As expected by grapesjs (https://grapesjs.com/docs/modules/Assets.html#uploading-assets)
+      const data = result.map(path =>
+        join(
+        // We should return path without this line, as it is saved, not as it is displayed
+        // But this url is sent straight to grapesjs, so we need to return the url as it is displayed
+          baseUrl, API_PATH, API_WEBSITE_PATH, API_WEBSITE_ASSET_READ,
+          path,
+        )
+        + `?websiteId=${websiteId}&connectorId=${connectorId ? connectorId : ''}` // As expected by wesite API (readAsset)
+      )
+
+      // Return the file URLs
       res.json({
-        data: files.map(file =>
-          API_PATH + API_WEBSITE_PATH + API_WEBSITE_ASSET_READ
-          + file.path
-          + `?websiteId=${websiteId}&connectorId=${connectorId ? connectorId : ''}` // As expected by wesite API (readAsset)
-        ),
+        data,
       } as ApiWebsiteAssetsWriteResponse)
 
       // Hook for plugins
@@ -381,6 +407,17 @@ export default function (config: ServerConfig, opts = {}): Router {
     return storageConnector.deleteWebsite(session, websiteId)
   }
 
+  /**
+   * Duplicate a website
+   */
+  async function duplicateWebsite(session: any, websiteId: string, connectorId?: string): Promise<void> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // Duplicate the website
+    return storageConnector.duplicateWebsite(session, websiteId)
+  }
+
   /**
    * Read an asset
    */
@@ -394,6 +431,7 @@ export default function (config: ServerConfig, opts = {}): Router {
 
   /**
    * Write an asset to the connector
+   * @returns File names on the storage connector, always starting with a slash
    */
   async function writeAssets(session: any, websiteId: string, files: ConnectorFile[], connectorId?: string): Promise<string[]> {
     // Get the desired connector
@@ -406,14 +444,19 @@ export default function (config: ServerConfig, opts = {}): Router {
     }))
 
     // Write the asset to the connector
-    await storageConnector.writeAssets(
+    const result = await storageConnector.writeAssets(
       session,
       websiteId,
       cleanPathFiles,
     )
 
     // Return the files URLs with the website id
-    return files.map(({ path }) => `${path}?websiteId=${websiteId}`)
+    return files
+      // Use the original path or the one returned by the connector
+      .map(({ path }, idx) => result && result[idx] ? result[idx] : path)
+      // Make it an absolute path with the website id and the connector id as query params
+      //.map((path) => toAssetUrl(path, config.url, websiteId, connectorId))
   }
+
   return router
 }

package/src/ts/server/cli.ts

@@ -25,11 +25,12 @@ const options = parse({
   'host': ['', 'Sets the host param of the express module "cookie-session".', 'string'],
   'port': [ 'p', 'Port to listen to', 'int'],
   'protocol': ['', 'Sets the protocol param of the express module "cookie-session".', 'string'],
-  'config': [ 'c', 'Path for the server side config file to load at startup', 'file'],
-  'client-config': ['', 'Path to client config file to be served on .silex-client.js', 'string'],
-  'fs-root': ['', 'Path to the root folder where to store websites. Used by the default connector (fs).', 'string'],
+  'server-config': [ 's', 'Path for the server side config file to load at startup', 'file'],
+  'client-config': ['c', 'Path to client config file to be served on .silex-client.js', 'file'],
+  'fs-root': ['', 'Path to the root folder where to store websites. Used by the default storage connector (fs).', 'string'],
+  'fs-hosting-root': ['', 'Path to the root folder where to publish websites. Used by the default hosting connector (fs).', 'string'],
   'session-name': ['', 'Sets the name param of the express module "cookie-session".', 'string'],
-  'session-secret': ['s', 'Session secret', 'string'],
+  'session-secret': ['', 'Session secret', 'string'],
   'ssl-port': [ false, 'Port to listen to for SSL/HTTPS', 'int'],
   'force-https': [ false, 'Force HTTPS', 'boolean'],
   'ssl-private-key': [ false, 'Path to private key for SSL', 'file'],
@@ -46,9 +47,10 @@ if(options['url']) process.env.SILEX_URL = options['url']
 if(options['host']) process.env.SILEX_HOST = options['host']
 if(options.port) process.env.SILEX_PORT = options.port
 if(options['protocol']) process.env.SILEX_PROTOCOL = options['protocol']
-if(options.config) process.env.SILEX_CONFIG = options.config
+if(options['server-config']) process.env.SILEX_SERVER_CONFIG = options['server-config']
 if(options['client-config']) process.env.SILEX_CLIENT_CONFIG = options['client-config']
 if(options['fs-root']) process.env.SILEX_FS_ROOT = options['fs-root']
+if(options['fs-hosting-root']) process.env.SILEX_FS_HOSTING_ROOT = options['fs-hosting-root']
 if(options['session-name']) process.env.SILEX_SESSION_NAME = options['session-name']
 if(options['session-secret']) process.env.SILEX_SESSION_SECRET = options['session-secret']
 if(options['ssl-port']) process.env.SILEX_SSL_PORT = options['ssl-port']

package/src/ts/server/config.ts

@@ -25,7 +25,7 @@
  */
 
 import { Config, Plugin } from '@silexlabs/silex-plugins'
-import { resolve } from 'path'
+import { join, resolve } from 'path'
 import { CLIENT_CONFIG_FILE_NAME } from '../constants'
 import { Application, Request, Response, Router } from 'express'
 import { readFile } from 'fs/promises'
@@ -49,8 +49,8 @@ export class ServerConfig extends Config {
   }
   public port = process.env.SILEX_PORT
   public debug = process.env.SILEX_DEBUG === 'true'
-  public url = process.env.SILEX_URL ?? `${process.env.SILEX_PROTOCOL}://${process.env.SILEX_HOST}:${process.env.SILEX_PORT}`
-  public userConfigPath: Plugin | undefined = process.env.SILEX_CONFIG
+  public url = process.env.SILEX_URL?.replace(/\/$/, '') ?? `${process.env.SILEX_PROTOCOL}://${process.env.SILEX_HOST}:${process.env.SILEX_PORT}`
+  public userConfigPath: Plugin | undefined = process.env.SILEX_SERVER_CONFIG
   public configFilePath: Plugin = resolve(__dirname, '../../../.silex.js')
 
   // All connectors or just the storage or hosting connectors
@@ -103,7 +103,7 @@ export class ServerConfig extends Config {
   async addRoutes(app: Application) {
     const path = process.env.SILEX_CLIENT_CONFIG
     if (path) {
-      console.log(`> Serving client side config ${path} at ${CLIENT_CONFIG_FILE_NAME}`)
+      console.info(`> Serving client side config ${path} at ${CLIENT_CONFIG_FILE_NAME}`)
       try {
         // Load the client config file
         let clientConfig = (await readFile(path as string)).toString()
@@ -111,7 +111,7 @@ export class ServerConfig extends Config {
         app.get(`/${CLIENT_CONFIG_FILE_NAME}`, async (req: Request, res: Response) => {
           // Reload each time in debug mode
           if (this.debug) {
-            console.log('[Debug mode] Reloading config file', path)
+            console.info('[Debug mode] Reloading config file', path)
             clientConfig = (await readFile(path)).toString()
           }
           // Send the config file
@@ -143,7 +143,7 @@ export class ServerConfig extends Config {
    */
   async loadUserConfig() {
     if (this.userConfigPath) {
-      console.log('> Loading user config', this.userConfigPath)
+      console.info('> Loading user config', this.userConfigPath)
       try {
         // Initiate the process with the config file which is just another plugin
         await this.addPlugin(this.userConfigPath, {})
@@ -158,12 +158,11 @@ export class ServerConfig extends Config {
    * This is the main config file
    */
   async loadSilexConfig() {
-    console.log('> Loading config', this.configFilePath)
+    console.info('> Loading config', this.configFilePath)
     try {
       // Initiate the process with the config file which is just another plugin
       await this.addPlugin(this.configFilePath, {})
     } catch(e) {
-      console.log(e.requireStack[0])
       // Check if the error is about the config file not found and not another module not found in the config file
       if(e.code === 'MODULE_NOT_FOUND' && (!e.requireStack || !e.requireStack.find(path => path === this.configFilePath))) {
         console.info('> /!\\ Config file not found', this.configFilePath)
@@ -177,13 +176,13 @@ export class ServerConfig extends Config {
     // Add default storage connectors
     if (!this.storageConnectors.length) {
       this.addStorageConnector(new FsStorage(null, {
-        path: process.env.SILEX_FS_ROOT,
+        path: process.env.SILEX_FS_ROOT || join(process.cwd(), '/silex/storage'),
       }))
     }
     // Add default hosting connectors
     if (!this.hostingConnectors.length) {
       this.addHostingConnector(new FsHosting(null, {
-        path: process.env.SILEX_FS_ROOT,
+        path: process.env.SILEX_FS_HOSTING_ROOT || join(process.cwd(), '/silex/hosting'),
       }))
     }
   }

package/src/ts/server/connectors/FsHosting.ts

@@ -15,29 +15,35 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+import fs from 'fs/promises'
 import { ConnectorFile, StorageConnector, HostingConnector, StatusCallback, ConnectorSession, contentToString, toConnectorData, ConnectorFileContent} from './connectors'
 import { join } from 'path'
-import { jobError, jobSuccess, startJob } from '../jobs'
 import { FsStorage } from './FsStorage'
 import { ConnectorType, JobData, JobStatus, PublicationJobData, WebsiteId } from '../../types'
+import { JobManager } from '../jobs'
 
 type FsSession = ConnectorSession
 
-interface FsOptions {
-  path?: string
-}
-
 export class FsHosting extends FsStorage implements HostingConnector<FsSession> {
   connectorId = 'fs-hosting'
   displayName = 'File system hosting'
-  icon = 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20stroke%3D%22currentColor%22%20stroke-width%3D%222%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22M6%202L6%2022%2018%2022%2018%207%2012%202%206%202Z%22%3E%3C%2Fpath%3E%3Cpath%20d%3D%22M18%202L12%202%2012%208%2018%208%2018%202Z%22%3E%3C%2Fpath%3E%3C%2Fsvg%3E'
   connectorType = ConnectorType.HOSTING
 
-  async publish(session: FsSession, id: WebsiteId, files: ConnectorFile[]): Promise<JobData> {
+  protected async initFs() {
+    const stat = await fs.stat(this.options.path).catch(() => null)
+    if (!stat) {
+      await fs.mkdir(join(this.options.path, 'assets'), { recursive: true })
+      await fs.mkdir(join(this.options.path, 'css'), { recursive: true })
+      console.info(`> [FsHosting] Created folders assets/ and css/ in ${this.options.path}`)
+    }
+  }
+
+  async publish(session: FsSession, id: WebsiteId, files: ConnectorFile[], {startJob, jobSuccess, jobError}: JobManager): Promise<JobData> {
     const job = startJob(`Publishing to ${this.displayName}`) as PublicationJobData
     job.logs = [[`Publishing to ${this.displayName}`]]
     job.errors = [[]]
-    this.writeAssets(session, id, files, async ({status, message}) => {
+    // Call write without id or folder so that it goes in / (path will be modified by publication transformers)
+    await this.write(session, '', files, '', async ({status, message}) => {
       // Update the job status
       job.status = status
       job.message = message

package/src/ts/server/connectors/FsStorage.ts

@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import fs, { stat } from 'fs/promises'
+import fs from 'fs/promises'
 import { createWriteStream } from 'fs'
 import { ConnectorFile, StorageConnector, StatusCallback, ConnectorSession, toConnectorData, ConnectorFileContent} from './connectors'
 import { dirname, join } from 'path'
@@ -32,13 +32,29 @@ import { fileURLToPath } from 'url'
 if(!globalThis.__dirname) {
   // @ts-ignore
   globalThis.__dirname = dirname(process.cwd() + '/src/ts/server/connectors/FsStorage.ts')
-  console.log('Redefining __dirname', globalThis.__dirname)
+  console.info('Redefining __dirname', globalThis.__dirname)
 }
 
+// Copy a folder recursively
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true })
+  const entries = await fs.readdir(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name)
+    const destPath = join(dest, entry.name)
+
+    entry.isDirectory() ?
+      await copyDir(srcPath, destPath) :
+      await fs.copyFile(srcPath, destPath)
+  }
+}
+
+
 type FsSession = ConnectorSession
 
 const USER_ICON = 'data:image/svg+xml,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' height=\'1em\' viewBox=\'0 0 448 512\'%3E%3Cpath d=\'M304 128a80 80 0 1 0 -160 0 80 80 0 1 0 160 0zM96 128a128 128 0 1 1 256 0A128 128 0 1 1 96 128zM49.3 464H398.7c-8.9-63.3-63.3-112-129-112H178.3c-65.7 0-120.1 48.7-129 112zM0 482.3C0 383.8 79.8 304 178.3 304h91.4C368.2 304 448 383.8 448 482.3c0 16.4-13.3 29.7-29.7 29.7H29.7C13.3 512 0 498.7 0 482.3z\'/%3E%3C/svg%3E'
-const FILE_ICON = 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20stroke%3D%22currentColor%22%20stroke-width%3D%222%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22M6%202L6%2022%2018%2022%2018%207%2012%202%206%202Z%22%3E%3C%2Fpath%3E%3Cpath%20d%3D%22M18%202L12%202%2012%208%2018%208%2018%202Z%22%3E%3C%2Fpath%3E%3C%2Fsvg%3E'
+const FILE_ICON = '/assets/laptop.png'
 
 interface FsOptions {
   path: string
@@ -64,7 +80,7 @@ export class FsStorage implements StorageConnector<FsSession> {
     this.initFs()
   }
 
-  private async initFs() {
+  protected async initFs() {
     const stat = await fs.stat(this.options.path).catch(() => null)
     if (!stat) {
       // create data folder with a default website
@@ -72,6 +88,7 @@ export class FsStorage implements StorageConnector<FsSession> {
       await fs.mkdir(join(this.options.path, id, this.options.assetsFolder), { recursive: true })
       await this.setWebsiteMeta({}, id, { name: 'Default website', connectorUserSettings: {} })
       await this.updateWebsite({}, id, defaultWebsiteData)
+      console.info(`> [FsStorage] Created ${id} in ${this.options.path}`)
     }
   }
 
@@ -136,7 +153,7 @@ export class FsStorage implements StorageConnector<FsSession> {
   async getWebsiteMeta(session: FsSession, id: WebsiteId): Promise<WebsiteMeta> {
     const websiteId = requiredParam<WebsiteId>(id, 'website id')
     // Get stats for website folder
-    const fileStat = await stat(join(this.options.path, websiteId))
+    const fileStat = await fs.stat(join(this.options.path, websiteId))
     const path = join(this.options.path, websiteId, WEBSITE_META_DATA_FILE)
     // Get meta file
     const content = await fs.readFile(path)
@@ -182,6 +199,18 @@ export class FsStorage implements StorageConnector<FsSession> {
     return fs.rmdir(path, { recursive: true })
   }
 
+  async duplicateWebsite(session: FsSession, websiteId: WebsiteId): Promise<void> {
+    const newWebsiteId = uuid()
+    const from = join(this.options.path, websiteId)
+    const to = join(this.options.path, newWebsiteId)
+    await copyDir(from, to)
+    const meta = await this.getWebsiteMeta(session, websiteId)
+    await this.setWebsiteMeta(session, newWebsiteId, {
+      ...meta,
+      name: `${meta.name} copy`,
+    })
+  }
+
   async listWebsites(session: any): Promise<WebsiteMeta[]> {
     const list = await fs.readdir(this.options.path)
     return Promise.all(list.map(async fileName => {
@@ -197,16 +226,20 @@ export class FsStorage implements StorageConnector<FsSession> {
   }
 
   async writeAssets(session: FsSession, id: WebsiteId, files: ConnectorFile[], statusCbk?: StatusCallback): Promise<void> {
+    return this.write(session, id, files, this.options.assetsFolder, statusCbk)
+  }
+
+  async write(session: FsSession, id: WebsiteId, files: ConnectorFile[], assetsFolder: string, statusCbk?: StatusCallback): Promise<void> {
     const filesStatuses = this.initStatus(files)
     let error: Error | null = null
     for (const fileStatus of filesStatuses) {
       const {file} = fileStatus
-      const path = join(this.options.path, id, this.options.assetsFolder, file.path)
+      const path = join(this.options.path, id, assetsFolder, file.path)
       if (typeof file.content === 'string' || Buffer.isBuffer(file.content)) {
         fileStatus.message = 'Writing'
         this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)
         try {
-          await fs.writeFile(path, file.content, 'binary')
+          await fs.writeFile(path, file.content)
         } catch(err) {
           fileStatus.message = `Error (${err})`
           this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)

package/src/ts/server/connectors/connectors.ts

@@ -18,6 +18,7 @@
 import { Readable } from 'stream'
 import { ServerConfig } from '../config'
 import { JobStatus, JobData, ConnectorData, ConnectorId, WebsiteId, ConnectorType, ConnectorUser, WebsiteMeta, WebsiteMetaFileContent, WebsiteData, ConnectorOptions } from '../../types'
+import { JobManager } from '../jobs'
 
 /**
  * @fileoverview define types for Silex connectors
@@ -66,10 +67,7 @@ export interface Connector<Session extends ConnectorSession = ConnectorSession>
   isLoggedIn(session: Session): Promise<boolean>
   setToken(session: Session, token: object): Promise<void>
   logout(session: Session): Promise<void>
-  getUser(session: Session): Promise<ConnectorUser>
-  // Handle website meta file
-  getWebsiteMeta(session: Session, websiteId: WebsiteId): Promise<WebsiteMeta>
-  setWebsiteMeta(session: Session, websiteId: WebsiteId, data: WebsiteMetaFileContent): Promise<void>
+  getUser(session: Session): Promise<ConnectorUser | null>
   // Get the connector options from login form
   // They are stored in the website meta file for hosting connectors
   // And in the user session for storage connectors
@@ -88,18 +86,22 @@ export interface StorageConnector<Session extends ConnectorSession = ConnectorSe
   createWebsite(session: Session, data: WebsiteMetaFileContent): Promise<WebsiteId>
   updateWebsite(session: Session, websiteId: WebsiteId, data: WebsiteData): Promise<void>
   deleteWebsite(session: Session, websiteId: WebsiteId): Promise<void>
+  duplicateWebsite(session: Session, websiteId: WebsiteId): Promise<void>
   // CRUD on assets
-  writeAssets(session: Session, websiteId: WebsiteId, files: ConnectorFile[], status?: StatusCallback): Promise<void>
+  writeAssets(session: Session, websiteId: WebsiteId, files: ConnectorFile[], status?: StatusCallback): Promise<string[] | void>
   readAsset(session: Session, websiteId: WebsiteId, fileName: string): Promise<ConnectorFileContent>
   deleteAssets(session: Session, websiteId: WebsiteId, fileNames: string[]): Promise<void>
   //getFileUrl(session: Session, websiteId: WebsiteId, path: string): Promise<string>
+  // Handle website meta file
+  getWebsiteMeta(session: Session, websiteId: WebsiteId): Promise<WebsiteMeta>
+  setWebsiteMeta(session: Session, websiteId: WebsiteId, data: WebsiteMetaFileContent): Promise<void>
 }
 
 /**
  * Hosting connectors are used to publish the website
  */
 export interface HostingConnector<Session extends ConnectorSession = ConnectorSession> extends Connector<Session> {
-  publish(session: Session, websiteId: WebsiteId, files: ConnectorFile[]): Promise<JobData>
+  publish(session: Session, websiteId: WebsiteId, files: ConnectorFile[], jobManager: JobManager): Promise<JobData> // Pass the jobManager as plugins do not neccessarily share the same module instance
   getUrl(session: Session, websiteId: WebsiteId): Promise<string>
 }
 

package/src/ts/server/events.ts

@@ -1,3 +1,20 @@
+/*
+ * Silex website builder, free/libre no-code tool for makers.
+ * Copyright (c) 2023 lexoyo and Silex Labs foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
 import { ConnectorId, PublicationData, WebsiteData, WebsiteId } from '../types'
 import { ConnectorFile } from './connectors/connectors'
 

package/src/ts/server/express.ts

@@ -33,7 +33,7 @@ export function create(config: ServerConfig): Application {
   // CORS
   const options = config.expressOptions
   if (options.cors) {
-    console.log('> CORS are ENABLED:', options.cors)
+    console.info('> CORS are ENABLED:', options.cors)
     app.use(cors({
       origin: options.cors,
     }))
@@ -45,7 +45,7 @@ export function create(config: ServerConfig): Application {
   app.use(bodyParser.json({ limit: options.jsonLimit }))
   app.use(bodyParser.text({ limit: options.textLimit }))
   app.use(bodyParser.urlencoded({ limit: options.urlencodedLimit }))
-  console.log('> Session name:', options.sessionName)
+  console.info('> Session name:', options.sessionName)
   app.use(cookieParser() as any)
   app.use(session({
     name: options.sessionName,

package/src/ts/server/index.ts

@@ -20,12 +20,18 @@ import api from './api/api'
 import { ServerConfig } from './config'
 import dotenv from 'dotenv'
 import { join } from 'path'
+import { DEV_MESSAGE } from '../constants'
 
 // Expose API to calling app as function silex()
 export * from './expose'
 
 // Main app
 export default async function silex() {
+  // Log Silex version
+  console.info(DEV_MESSAGE)
+  console.info(`Node version: ${process.version}`)
+  console.info(`CWD: ${process.cwd()}`)
+
   // Load env vars from .env file if any
   const curDirEnv = dotenv.config()
   if (curDirEnv.error) {

package/src/ts/server/jobs.ts

@@ -22,6 +22,7 @@ const TIME_TO_KEEP_AFTER_STOP = 60*10*1000 // 10 min
 
 // Store the jobs in memory
 const jobs = new Array<JobData>()
+const timers = new WeakMap<JobData, NodeJS.Timeout>()
 
 // Key which will change on server restart
 const processKey = Math.ceil(Math.random() * 1000000)
@@ -60,7 +61,8 @@ export function jobError(id: JobId, message = ''): boolean {
 // Remove a job from memory
 // This is also used in unit tests to avoid memory lea
 export function killJob(job: JobData) {
-  clearTimeout(job._timeout)
+  clearTimeout(timers.get(job))
+  timers.delete(job)
   jobs.splice(jobs.findIndex(j => job.jobId === j.jobId), 1)
 }
 
@@ -70,8 +72,18 @@ function end(id: JobId, status: JobStatus, message = ''): boolean {
   if(job) {
     job.status = status
     if(message) job.message = message
-    job._timeout = setTimeout(() => killJob(job), TIME_TO_KEEP_AFTER_STOP)
+    timers.set(job, setTimeout(() => killJob(job), TIME_TO_KEEP_AFTER_STOP))
     return true
   }
   return false
 }
+
+// Type definition of the job manager
+export interface JobManager {
+  startJob: typeof startJob
+  jobSuccess: typeof jobSuccess
+  jobError: typeof jobError
+}
+
+// Export the job manager
+export const jobManager: JobManager = { startJob, jobSuccess, jobError }