@silexlabs/silex 3.0.1-0 → 3.0.1

package/src/ts/plugins/server/GitlabConnector.ts

@@ -15,13 +15,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import { API_CONNECTOR_LOGIN_CALLBACK, API_CONNECTOR_PATH, API_PATH, WEBSITE_DATA_FILE, WEBSITE_META_DATA_FILE } from '../../constants'
+import { API_CONNECTOR_LOGIN_CALLBACK, API_CONNECTOR_PATH, API_PATH, WEBSITE_DATA_FILE } from '../../constants'
 import { ServerConfig } from '../../server/config'
 import { ConnectorFile, ConnectorFileContent, StatusCallback, StorageConnector, contentToBuffer, contentToString, toConnectorData } from '../../server/connectors/connectors'
-import { ApiError, ConnectorType, ConnectorUser, WebsiteData, WebsiteId, WebsiteMeta, WebsiteMetaFileContent } from '../../types'
+import { ApiError, ConnectorType, ConnectorUser, WebsiteData, WebsiteId, WebsiteMeta, WebsiteMetaFileContent, JobStatus } from '../../types'
 import fetch from 'node-fetch'
 import crypto, { createHash } from 'crypto'
-import { PassThrough, Readable } from 'stream'
+import { join } from 'path'
 
 /**
  * Gitlab connector
@@ -34,12 +34,18 @@ export interface GitlabOptions {
   clientSecret: string
   branch: string
   assetsFolder: string
+  //metaRepo: string
+  //metaRepoFile: string
+  repoPrefix: string
+  scope: string
+  domain: string
+  timeOut: number
 }
 
-interface GitlabToken {
-  state: string
-  codeVerifier: string
-  codeChallenge: string
+export interface GitlabToken {
+  state?: string
+  codeVerifier?: string
+  codeChallenge?: string
   token?: {
     access_token: string
     token_type: string
@@ -50,22 +56,22 @@ interface GitlabToken {
     scope: string
   }
   userId?: number
+  username?: string
 }
 
-interface GitlabSession {
-  gitlab?: GitlabToken
-}
+export type GitlabSession = Record<string, GitlabToken>
 
 interface GitlabAction {
-  action: 'create' | 'delete' | 'move' | 'update'
-  file_path: string
+  action: 'create' | 'delete' | 'move' | 'update' | 'cherry-pick'
+  file_path?: string
   content?: string
+  commit_id?: string
 }
 
 interface GitlabWriteFile {
   branch: string
   commit_message: string
-  id: string
+  id?: string
   actions?: GitlabAction[]
   content?: string
   file_path?: string
@@ -90,98 +96,242 @@ interface GitlabCreateBranch {
   ref: string
 }
 
-async function wait(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms))
+interface GitlabGetTags {
+  per_page?: number
+}
+
+interface GitlabCreateTag {
+  tag_name: string
+  ref: string
+  message: string
+}
+
+interface GitlabFetchCommits {
+  ref_name: string
+  since: string
+}
+
+interface MetaRepoFileContent {
+  websites: {
+    [websiteId: string]: {
+      meta: WebsiteMetaFileContent,
+      createdAt: string,
+      updatedAt: string,
+    }
+  }
 }
 
+const svg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="1000"
+   height="963.197"
+   viewBox="0 0 1000 963.197"
+   version="1.1"
+   id="svg85">
+  <sodipodi:namedview
+     id="namedview87"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="1"
+     inkscape:cx="991.5"
+     inkscape:cy="964.5"
+     inkscape:window-width="1126"
+     inkscape:window-height="895"
+     inkscape:window-x="774"
+     inkscape:window-y="12"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg85" />
+  <defs
+     id="defs74">
+    <style
+       id="style72">.cls-1{fill:#e24329;}.cls-2{fill:#fc6d26;}.cls-3{fill:#fca326;}</style>
+  </defs>
+  <g
+     id="LOGO"
+     transform="matrix(5.2068817,0,0,5.2068817,-489.30756,-507.76085)">
+    <path
+       class="cls-1"
+       d="m 282.83,170.73 -0.27,-0.69 -26.14,-68.22 a 6.81,6.81 0 0 0 -2.69,-3.24 7,7 0 0 0 -8,0.43 7,7 0 0 0 -2.32,3.52 l -17.65,54 h -71.47 l -17.65,-54 a 6.86,6.86 0 0 0 -2.32,-3.53 7,7 0 0 0 -8,-0.43 6.87,6.87 0 0 0 -2.69,3.24 L 97.44,170 l -0.26,0.69 a 48.54,48.54 0 0 0 16.1,56.1 l 0.09,0.07 0.24,0.17 39.82,29.82 19.7,14.91 12,9.06 a 8.07,8.07 0 0 0 9.76,0 l 12,-9.06 19.7,-14.91 40.06,-30 0.1,-0.08 a 48.56,48.56 0 0 0 16.08,-56.04 z"
+       id="path76" />
+    <path
+       class="cls-2"
+       d="m 282.83,170.73 -0.27,-0.69 a 88.3,88.3 0 0 0 -35.15,15.8 L 190,229.25 c 19.55,14.79 36.57,27.64 36.57,27.64 l 40.06,-30 0.1,-0.08 a 48.56,48.56 0 0 0 16.1,-56.08 z"
+       id="path78" />
+    <path
+       class="cls-3"
+       d="m 153.43,256.89 19.7,14.91 12,9.06 a 8.07,8.07 0 0 0 9.76,0 l 12,-9.06 19.7,-14.91 c 0,0 -17.04,-12.89 -36.59,-27.64 -19.55,14.75 -36.57,27.64 -36.57,27.64 z"
+       id="path80" />
+    <path
+       class="cls-2"
+       d="M 132.58,185.84 A 88.19,88.19 0 0 0 97.44,170 l -0.26,0.69 a 48.54,48.54 0 0 0 16.1,56.1 l 0.09,0.07 0.24,0.17 39.82,29.82 c 0,0 17,-12.85 36.57,-27.64 z"
+       id="path82" />
+  </g>
+</svg>`
+const encodedSvg = encodeURIComponent(svg)
+const ICON = '/assets/gitlab.png'
+
 export default class GitlabConnector implements StorageConnector {
   connectorId = 'gitlab'
   connectorType = ConnectorType.STORAGE
   displayName = 'GitLab'
-  icon = 'http://gitlab.lcqb.upmc.fr/assets/favicon-075eba76312e8421991a0c1f89a89ee81678bcde72319dd3e8047e2a47cd3a42.ico'
+  icon = ICON
   disableLogout = false
-  color = '#ffffff'
-  background = '#FC6D26'
+  color = '#2B1B63'
+  background = 'rgba(252, 109, 38, 0.2)'
   options: GitlabOptions
 
   constructor(private config: ServerConfig, opts: Partial<GitlabOptions>) {
     this.options = {
       branch: 'main',
-      assetsFolder: '',
+      assetsFolder: 'assets',
+      //metaRepo: 'silex-meta',
+      //metaRepoFile: 'websites.json',
+      repoPrefix: 'silex_',
+      scope: 'api', // 'api+read_api+read_user+read_repository+write_repository+email+sudo+profile+openid'
       ...opts,
     } as GitlabOptions
     if(!this.options.clientId) throw new Error('Missing Gitlab client ID')
     if(!this.options.clientSecret) throw new Error('Missing Gitlab client secret')
+    if(!this.options.domain) throw new Error('Missing Gitlab domain')
+    if(!this.options.timeOut) this.options.timeOut = 15000 /* default value */
   }
 
   // **
   // Convenience methods for the Gitlab API
   private getAssetPath(path: string): string {
-    return `${this.options.assetsFolder}${path}`
+    return encodeURIComponent(join(this.options.assetsFolder, path))
   }
 
-  private async createFile(session: GitlabSession, websiteId: WebsiteId, path: string, content: string, isBase64 = false): Promise<void> {
+  isUsingOfficialInstance(): boolean {
+    const gitlabDomainRegexp = /(^|\b)(gitlab\.com)($|\b)/
+    return gitlabDomainRegexp.test(this.options.domain)
+  }
+
+  async createFile(session: GitlabSession, websiteId: WebsiteId, path: string, content: string, isBase64 = false): Promise<void> {
     // Remove leading slash
     const safePath = path.replace(/^\//, '')
+    const encodePath = decodeURIComponent(path)
     return this.callApi(session, `api/v4/projects/${websiteId}/repository/files/${safePath}`, 'POST', {
       id: websiteId,
       branch: this.options.branch,
       content,
-      commit_message: `Create file ${path} from Silex`,
+      commit_message: `Create file ${encodePath} from Silex`,
       encoding: isBase64 ? 'base64' : undefined,
     })
   }
 
-  private async updateFile(session: GitlabSession, websiteId: WebsiteId, path: string, content: string, isBase64 = false): Promise<void> {
+  async updateFile(session: GitlabSession, websiteId: WebsiteId, path: string, content: string, isBase64 = false): Promise<void> {
     // Remove leading slash
     const safePath = path.replace(/^\//, '')
+    const encodePath = decodeURIComponent(path)
     return this.callApi(session, `api/v4/projects/${websiteId}/repository/files/${safePath}`, 'PUT', {
       id: websiteId,
       branch: this.options.branch,
       content: await contentToString(content),
-      commit_message: `Update website asset ${path} from Silex`,
+      commit_message: `Update website asset ${encodePath} from Silex`,
       encoding: isBase64 ? 'base64' : undefined,
     })
   }
 
-  private async callApi(session: GitlabSession, path: string, method: 'POST' | 'GET' | 'PUT' | 'DELETE' = 'GET', body: GitlabWriteFile | GitlabGetToken | GitlabWebsiteName | GitlabCreateBranch | null = null, params: any = {}): Promise<any> {
-    const token = session?.gitlab?.token
-    const tokenParam = token ? `access_token=${token.access_token}&` : ''
-    const paramsStr = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent((v as any).toString())}`).join('&')
-    const url = `https://gitlab.com/${path}?${tokenParam}${paramsStr}`
+  async readFile(session: GitlabSession, websiteId: string, fileName: string): Promise<Buffer> {
+    const safePath = fileName.replace(/^\//, '')
+    // Call the API
+    const url = `${this.options.domain}/api/v4/projects/${websiteId}/repository/files/${safePath}?ref=${this.options.branch}&access_token=${this.getSessionToken(session).token?.access_token}`
     const response = await fetch(url, {
-      method,
+      method: 'GET',
       headers: {
         'Content-Type': 'application/json',
       },
-      body: body ? JSON.stringify(body) : undefined
     })
-    let json: { message: string, error: string } | any
-    // Handle the case when the server returns an non-JSON response (e.g. 400 Bad Request)
-    const text = await response.text()
+    const json = await response.json()
+    if(!response.ok) throw new ApiError(`Error reading file "${fileName}" from Gitlab: ${json?.message ?? json?.error ?? response.statusText}`, response.status)
+    // From base64 string to buffer
+    const buf = Buffer.from(json.content, 'base64')
+    // Return the image bytes
+    return buf
+  }
+
+  /*
+   * Get the meta repo path for the current user
+   * The meta repo contains a JSON file which contains the list of websites
+   */
+  //private getMetaRepoPath(session: GitlabSession): string {
+  //  if(!this.getSessionToken(session).username) throw new ApiError('Missing Gitlab user ID. User not logged in?', 401)
+  //  return encodeURIComponent(`${this.getSessionToken(session).username}/${this.options.metaRepo}`)
+  //}
+
+  ///**
+  // * Initialize the storage with a meta repo
+  // */
+  //private async initStorage(session: GitlabSession): Promise<void> {
+  //  // Create the meta repo
+  //  try {
+  //    const project = await this.callApi(session, 'api/v4/projects/', 'POST', {
+  //      name: this.options.metaRepo,
+  //    }) as any
+  //    return this.createFile(session, this.getMetaRepoPath(session), this.options.metaRepoFile, JSON.stringify({
+  //      websites: {}
+  //    } as MetaRepoFileContent))
+  //  } catch (e) {
+  //    console.error('Could not init storage', e.statusCode, e.httpStatusCode, e)
+  //    throw e
+  //  }
+  //}
+
+  /**
+   * Call the Gitlab API with the user's token and handle errors
+   */
+  async callApi(session: GitlabSession, path: string, method: 'POST' | 'GET' | 'PUT' | 'DELETE' = 'GET', body: GitlabWriteFile | GitlabGetToken | GitlabWebsiteName | GitlabCreateBranch | GitlabGetTags | GitlabCreateTag | GitlabFetchCommits | null = null, params: any = {}): Promise<any> {
+    const token = this.getSessionToken(session).token
+    const tokenParam = token ? `access_token=${token.access_token}&` : ''
+    const paramsStr = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent((v as any).toString())}`).join('&')
+    const url = `${this.options.domain}/${path}?${tokenParam}${paramsStr}`
+    const headers = {
+      'Content-Type': 'application/json',
+    }
+    if (method === 'GET' && body) {
+      console.error('Gitlab API error (4) - GET request with body', {url, method, body, params})
+    }
+    // With or without body
+    let response
     try {
-      json = JSON.parse(text)
+      response = await fetch(url, body && method !== 'GET' ? {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined
+      } : {
+        method,
+        headers,
+      })
     } catch (e) {
-      if(!response.ok) {
-        // A real error
-        throw e
-      } else {
-        // Useless error linked to the fact that the response is not JSON
-        //console.error('Gitlab API error - could not parse response', response.status, response.statusText, {url, method, body, params, text})
-        return text
-      }
+      console.error('Gitlab API error (0)', e)
+      throw new ApiError(`Gitlab API error (0): ${e.message} ${e.code} ${e.name} ${e.type}`, 500)
     }
-    if(!response.ok) {
-      if (response.status === 401 && session?.gitlab?.token?.refresh_token) {
+    let json: { message: string, error: string } | any
+    // Handle the case when the server returns a non-JSON response (e.g. 400 Bad Request)
+    const text = await response.text()
+    if (!response.ok) {
+      if (text.includes('A file with this name doesn\'t exist')) {
+        throw new ApiError('Gitlab API error (5): Not Found', 404)
+      } else if (response.status === 401 && this.getSessionToken(session).token?.refresh_token) {
         // Refresh the token
-        const token = session?.gitlab?.token
+        const token = this.getSessionToken(session).token
         const body = {
           grant_type: 'refresh_token',
-          refresh_token: token.refresh_token,
+          refresh_token: token?.refresh_token,
           client_id: this.options.clientId,
           client_secret: this.options.clientSecret,
         }
-        const response = await fetch('https://gitlab.com/oauth/token', {
+        const response = await fetch(this.options.domain + '/oauth/token', {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
@@ -190,18 +340,38 @@ export default class GitlabConnector implements StorageConnector {
         })
         const refreshJson = await response.json()
         if (response.ok) {
-          session.gitlab.token = {
-            ...token,
-            ...refreshJson,
-          }
+          this.setSessionToken(session, {
+            token: {
+              ...token,
+              ...refreshJson,
+            },
+          } as GitlabToken)
           return await this.callApi(session, path, method, body as any, params)
         } else {
-          //console.error('Gitlab API error - could not refresh token', response.status, response.statusText, { url, method, body, params, refreshJson })
-          throw new ApiError(`Gitlab API error: ${refreshJson?.message ?? response.statusText}`, response.status)
+          const message = typeof refreshJson?.message === 'object' ? Object.entries(refreshJson.message).map(entry => entry.join(' ')).join(' ') : refreshJson?.message ?? refreshJson?.error ?? response.statusText
+          console.error('Gitlab API error (2) - could not refresh token', response.status, response.statusText, {message}, 'refresh_token:', token?.refresh_token)
+          // Workaround for when the token is invalid
+          // It happens often which is not normal (refresh token should last 6 months)
+          this.logout(session)
+          // Notify the user
+          throw new ApiError(`Gitlab API error (2): ${message}`, response.status)
         }
       } else {
-        //console.error('Gitlab API error', response.status, response.statusText, { url, method, body, params, json })
-        throw new ApiError(`Gitlab API error: ${json?.message ?? json?.error ?? response.statusText}`, response.status)
+        const message = typeof json?.message === 'object' ? Object.entries(json.message).map(entry => entry.join(' ')).join(' ') : json?.message ?? json?.error ?? response.statusText
+        console.error('Gitlab API error (1)', response.status, response.statusText, {url, method, body, params, text, message})
+        throw new ApiError(`Gitlab API error (1): ${message}`, response.status)
+      }
+    }
+    try {
+      json = JSON.parse(text)
+    } catch (e) {
+      if(!response.ok) {
+        // A real error
+        throw e
+      } else {
+        // Useless error linked to the fact that the response is not JSON
+        console.error('Gitlab API error (3) - could not parse response', response.status, response.statusText, {url, method, body, params, text})
+        return text
       }
     }
     return json
@@ -245,14 +415,23 @@ export default class GitlabConnector implements StorageConnector {
     const codeChallenge = await this.generateCodeChallenge(codeVerifier)
 
     // Store the code verifier and code challenge in the session
-    session.gitlab = {
-      ...session.gitlab,
+    this.setSessionToken(session, {
+      ...this.getSessionToken(session),
       state,
       codeVerifier,
       codeChallenge,
-    }
-    const scope = 'api+read_api+read_user+read_repository+write_repository+email+sudo+profile+openid'
-    return `https://gitlab.com/oauth/authorize?client_id=${this.options.clientId}&redirect_uri=${redirect_uri}&response_type=code&state=${session.gitlab.state}&scope=${scope}&code_challenge=${codeChallenge}&code_challenge_method=S256`
+    })
+    return `${this.options.domain}/oauth/authorize?client_id=${this.options.clientId}&redirect_uri=${redirect_uri}&response_type=code&state=${this.getSessionToken(session).state}&scope=${this.options.scope}&code_challenge=${codeChallenge}&code_challenge_method=S256`
+  }
+
+  getSessionToken(session: GitlabSession | undefined): GitlabToken {
+    return (session ?? {})[this.connectorId] ?? {}
+  }
+  setSessionToken(session: GitlabSession, token: GitlabToken): void {
+    session[this.connectorId] = token
+  }
+  resetSessionToken(session: GitlabSession): void {
+    delete session[this.connectorId]
   }
 
   getOptions(formData: object): object {
@@ -268,7 +447,7 @@ export default class GitlabConnector implements StorageConnector {
   }
 
   async isLoggedIn(session: GitlabSession): Promise<boolean> {
-    return !!session?.gitlab?.token
+    return !!this.getSessionToken(session).token
   }
 
   /**
@@ -277,11 +456,21 @@ export default class GitlabConnector implements StorageConnector {
    * OAuth2 Step #2 from https://docs.gitlab.com/ee/api/oauth2.html#authorization-code-with-proof-key-for-code-exchange-pkce
    */
   async setToken(session: GitlabSession, loginResult: any): Promise<void> {
-    if(!loginResult.state || loginResult.state !== session.gitlab?.state) throw new ApiError('Invalid state', 401)
-    if(!session.gitlab?.codeVerifier) throw new ApiError('Missing code verifier', 401)
-    if(!session.gitlab?.codeChallenge) throw new ApiError('Missing code challenge', 401)
+    const sessionToken = this.getSessionToken(session)
+    if(!loginResult.state || loginResult.state !== sessionToken?.state) {
+      this.logout(session)
+      throw new ApiError('Invalid state', 401)
+    }
+    if(!sessionToken?.codeVerifier) {
+      this.logout(session)
+      throw new ApiError('Missing code verifier', 401)
+    }
+    if(!sessionToken?.codeChallenge) {
+      this.logout(session)
+      throw new ApiError('Missing code challenge', 401)
+    }
 
-    const token = await fetch('https://gitlab.com/oauth/token', {
+    const response = await fetch(this.options.domain + '/oauth/token', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -292,20 +481,31 @@ export default class GitlabConnector implements StorageConnector {
         code: loginResult.code,
         grant_type: 'authorization_code',
         redirect_uri: this.getRedirect(),
-        code_verifier: session.gitlab.codeVerifier,
+        code_verifier: sessionToken.codeVerifier,
       }),
     })
-      .then((response) => response.json())
 
-    session.gitlab = { token, state: session.gitlab.state, codeVerifier: session.gitlab.codeVerifier, codeChallenge: session.gitlab.codeChallenge }
+    const token = await response.json()
+
+    // Store the token in the session
+    this.setSessionToken(session, {
+      token,
+      ...this.getSessionToken(session),
+    })
 
     // We need to get the user ID for listWebsites
     const user = await this.callApi(session, 'api/v4/user') as any
-    session.gitlab.userId = user.id
+
+    // Store the user details in the session
+    this.setSessionToken(session, {
+      ...this.getSessionToken(session),
+      userId: user.id,
+      username: user.username,
+    })
   }
 
   async logout(session: GitlabSession): Promise<void> {
-    delete session.gitlab
+    this.resetSessionToken(session)
   }
 
   async getUser(session: GitlabSession): Promise<ConnectorUser> {
@@ -313,19 +513,49 @@ export default class GitlabConnector implements StorageConnector {
     return {
       name: user.name,
       email: user.email,
+      picture: user.avatar_url,
       storage: await toConnectorData(session, this as StorageConnector),
     }
   }
 
   async listWebsites(session: GitlabSession): Promise<WebsiteMeta[]> {
-    const projects = await this.callApi(session, `api/v4/users/${session.gitlab?.userId}/projects`) as any[]
-    return projects.map(p => ({
-      websiteId: p.id,
-      name: p.name,
-      createdAt: p.created_at,
-      updatedAt: p.last_activity_at,
-      connectorUserSettings: {},
-    }))
+    //try {
+    //  const result = await this.callApi(session, `api/v4/projects/${this.getMetaRepoPath(session)}/repository/files/${this.options.metaRepoFile}`, 'GET', null, {
+    //    ref: this.options.branch,
+    //  })
+    //  const { content } = result
+    //  const contentDecoded = Buffer.from(content, 'base64').toString('utf8')
+    //  const websites = (JSON.parse(contentDecoded) as MetaRepoFileContent).websites
+    //  return Object.entries(websites).map(([websiteId, {meta, createdAt, updatedAt}]) => ({
+    //    websiteId,
+    //    createdAt: new Date(createdAt),
+    //    updatedAt: new Date(updatedAt),
+    //    ...meta,
+    //  }))
+    //} catch (e) {
+    //  console.error('Could not list websites', e.statusCode, e.httpStatusCode, e.code)
+    //  if (e.statusCode === 404 || e.httpStatusCode === 404) {
+    //    await this.initStorage(session)
+    //    return []
+    //  } else {
+    //    throw e
+    //  }
+    //}
+    const userId = this.getSessionToken(session).userId
+    if(!userId) {
+      this.logout(session)
+      throw new ApiError('Missing Gitlab user ID. User not logged in?', 401)
+    }
+    const projects = await this.callApi(session, `api/v4/users/${userId}/projects`) as any[]
+    return projects
+      .filter(p => p.name.startsWith(this.options.repoPrefix))
+      .map(p => ({
+        websiteId: p.id,
+        name: p.name.replace(this.options.repoPrefix, ''),
+        createdAt: p.created_at,
+        updatedAt: p.last_activity_at,
+        connectorUserSettings: {},
+      }))
   }
 
   async readWebsite(session: GitlabSession, websiteId: string): Promise<WebsiteData> {
@@ -340,10 +570,10 @@ export default class GitlabConnector implements StorageConnector {
 
   async createWebsite(session: GitlabSession, websiteMeta: WebsiteMetaFileContent): Promise<WebsiteId> {
     const project = await this.callApi(session, 'api/v4/projects/', 'POST', {
-      name: websiteMeta.name,
+      name: this.options.repoPrefix + websiteMeta.name,
     }) as any
     await this.createFile(session, project.id, WEBSITE_DATA_FILE, JSON.stringify({} as WebsiteData))
-    await this.createFile(session, project.id, WEBSITE_META_DATA_FILE, JSON.stringify(websiteMeta))
+    //await this.createFile(session, project.id, WEBSITE_META_DATA_FILE, JSON.stringify(websiteMeta))
     //await this.updateWebsite(session, project.id, {} as WebsiteData)
     //await this.setWebsiteMeta(session, project.id, websiteMeta)
     return project.id
@@ -354,20 +584,85 @@ export default class GitlabConnector implements StorageConnector {
       branch: this.options.branch,
       commit_message: 'Update website data from Silex',
       content: JSON.stringify(websiteData),
-      file_path: WEBSITE_DATA_FILE,
       id: websiteId,
     })
   }
 
   async deleteWebsite(session: GitlabSession, websiteId: WebsiteId): Promise<void> {
+    // Delete repo
     await this.callApi(session, `api/v4/projects/${websiteId}`, 'DELETE')
+    //// Load the meta repo data
+    //const file = await this.callApi(session, `api/v4/projects/${this.getMetaRepoPath(session)}/repository/files/${this.options.metaRepoFile}`, 'GET', null, {
+    //  ref: this.options.branch,
+    //})
+    //const metaRepo = JSON.parse(Buffer.from(file.content, 'base64').toString('utf8')) as MetaRepoFileContent
+    //const data = metaRepo.websites[websiteId]
+    //if(!data) throw new ApiError(`Website ${websiteId} not found`, 404)
+    //// Update or create the website meta data
+    //delete metaRepo.websites[websiteId]
+    //// Save the meta repo data
+    //const project = await this.callApi(session, `api/v4/projects/${this.getMetaRepoPath(session)}/repository/files/${this.options.metaRepoFile}`, 'PUT', {
+    //  branch: this.options.branch,
+    //  commit_message: `Delete meta data of ${data.meta.name} (${websiteId}) from Silex`,
+    //  content: JSON.stringify(metaRepo),
+    //  file_path: this.options.metaRepoFile,
+    //})
+  }
+
+  async duplicateWebsite(session: GitlabSession, websiteId: string): Promise<void> {
+    // Get the repo meta data
+    const meta = await this.getWebsiteMeta(session, websiteId)
+    // List all the repository files
+    const blobs = await this.callApi(session, `api/v4/projects/${websiteId}/repository/tree`, 'GET', null, {
+      recursive: true,
+    })
+    const files = blobs
+      .filter(item => item.type === 'blob')
+      .map(item => item.path)
+    // Create a new repo
+    const newId = await this.createWebsite(session, {
+      ...meta,
+      name: meta.name + ' Copy ' + new Date().toISOString().replace(/T.*/, '') + ' ' + Math.random().toString(36).substring(2, 4),
+    })
+    // Upload all files
+    for(const file of files) {
+      const path = encodeURIComponent(file)
+      const content = await this.readFile(session, websiteId, path)
+      // From buffer to string
+      const contentStr = content.toString('base64')
+      switch(file) {
+      case WEBSITE_DATA_FILE:
+        await this.updateFile(session, newId, path, contentStr, true)
+        break
+      default:
+        await this.createFile(session, newId, path, contentStr, true)
+      }
+    }
   }
 
   async getWebsiteMeta(session: GitlabSession, websiteId: WebsiteId): Promise<WebsiteMeta> {
-    const project = await this.callApi(session, `api/v4/projects/${websiteId}/repository/files/${WEBSITE_META_DATA_FILE}`) as any
+    //const file = await this.callApi(session, `api/v4/projects/${this.getMetaRepoPath(session)}/repository/files/${this.options.metaRepoFile}`, 'GET', null, {
+    //  ref: this.options.branch,
+    //})
+    //const metaRepo = JSON.parse(Buffer.from(file.content, 'base64').toString('utf8')) as MetaRepoFileContent
+    //if(!metaRepo.websites[websiteId]) throw new ApiError(`Website ${websiteId} not found`, 404)
+    //return {
+    //  websiteId,
+    //  createdAt: new Date(metaRepo.websites[websiteId].createdAt),
+    //  updatedAt: new Date(metaRepo.websites[websiteId].updatedAt),
+    //  ...metaRepo.websites[websiteId].meta,
+    //}
+    // const response = await this.callApi(session, `api/v4/projects/${websiteId}/repository/files/${WEBSITE_META_DATA_FILE}`, 'GET', null, {
+    //   ref: this.options.branch,
+    // }) as any
+    // Base64 to string to JSON
+    // const contentDecoded = Buffer.from(response.content, 'base64').toString('utf8')
+    // const websiteMeta = JSON.parse(contentDecoded) as WebsiteMetaFileContent
+    const project = await this.callApi(session, `api/v4/projects/${websiteId}`)
     return {
-      websiteId: project.id,
-      name: project.name,
+      websiteId,
+      name: project.name.replace(this.options.repoPrefix, ''),
+      imageUrl: project.avatar_url,
       createdAt: project.created_at,
       updatedAt: project.last_activity_at,
       connectorUserSettings: {},
@@ -375,49 +670,69 @@ export default class GitlabConnector implements StorageConnector {
   }
 
   async setWebsiteMeta(session: GitlabSession, websiteId: WebsiteId, websiteMeta: WebsiteMetaFileContent): Promise<void> {
-    const project = await this.callApi(session, `api/v4/projects/${websiteId}/repository/files/${WEBSITE_META_DATA_FILE}`, 'PUT', {
-      branch: this.options.branch,
-      commit_message: 'Update website meta data from Silex',
-      content: JSON.stringify(websiteMeta),
-      file_path: WEBSITE_META_DATA_FILE,
-      id: websiteId,
-    })
+    //// Load the meta repo data
+    //const file = await this.callApi(session, `api/v4/projects/${this.getMetaRepoPath(session)}/repository/files/${this.options.metaRepoFile}`, 'GET', null, {
+    //  ref: this.options.branch,
+    //})
+    //const metaRepo = JSON.parse(Buffer.from(file.content, 'base64').toString('utf8')) as MetaRepoFileContent
+    //// Update or create the website meta data
+    //metaRepo.websites[websiteId] = {
+    //  updatedAt: new Date().toISOString(),
+    //  createdAt: metaRepo.websites[websiteId]?.createdAt ?? new Date().toISOString(),
+    //  meta: websiteMeta,
+    //}
+    //// Save the meta repo data
+    //const project = await this.callApi(session, `api/v4/projects/${this.getMetaRepoPath(session)}/repository/files/${this.options.metaRepoFile}`, 'PUT', {
+    //  branch: this.options.branch,
+    //  commit_message: `Update website meta data of ${websiteMeta.name} (${websiteId}) from Silex`,
+    //  content: JSON.stringify(metaRepo),
+    //  file_path: this.options.metaRepoFile,
+    //})
+
+    // Rename the repo if needed
+    const oldMeta = await this.getWebsiteMeta(session, websiteId)
+    if(websiteMeta.name !== oldMeta.name) {
+      await this.callApi(session, `api/v4/projects/${websiteId}`, 'PUT', {
+        name: this.options.repoPrefix + websiteMeta.name,
+      })
+    }
+    //// Update the metadata file
+    //await this.callApi(session, `api/v4/projects/${websiteId}/repository/files/${WEBSITE_META_DATA_FILE}`, 'PUT', {
+    //  branch: this.options.branch,
+    //  commit_message: 'Update website meta data from Silex',
+    //  content: JSON.stringify(websiteMeta),
+    //  file_path: WEBSITE_META_DATA_FILE,
+    //  id: websiteId,
+    //})
   }
 
   async writeAssets(session: GitlabSession, websiteId: string, files: ConnectorFile[], status?: StatusCallback | undefined): Promise<void> {
+    status && await status({ message: 'in progress...', status: JobStatus.IN_PROGRESS })
     // For each file
     for (const file of files) {
       // Convert to base64
       const content = (await contentToBuffer(file.content)).toString('base64')
+      const path = this.getAssetPath(file.path)
+
       try {
-        await this.updateFile(session, websiteId, this.getAssetPath(file.path), content, true)
+        await this.updateFile(session, websiteId, path, content, true)
       } catch (e) {
         // If the file does not exist, create it
-        if (e.statusCode === 404 || e.message.endsWith('A file with this name doesn\'t exist')) {
-          await this.createFile(session, websiteId, file.path, content, true)
+        if (e.statusCode === 404 || e.httpStatusCode === 404 || e.message.endsWith('A file with this name doesn\'t exist')) {
+          await this.createFile(session, websiteId, path, content, true)
         } else {
+          status && await status({ message: 'Error', status: JobStatus.ERROR })
           throw e
         }
       }
     }
+    status && await status({ message: 'Successfull', status: JobStatus.SUCCESS })
   }
 
   async readAsset(session: GitlabSession, websiteId: string, fileName: string): Promise<ConnectorFileContent> {
     // Remove leading slash
     const finalPath = this.getAssetPath(fileName)
-    // Call the API
-    const url = `https://gitlab.com/api/v4/projects/${websiteId}/repository/files/${finalPath}?ref=${this.options.branch}&access_token=${session.gitlab?.token?.access_token}`
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    })
-    const json = await response.json()
-    if(!response.ok) throw new ApiError(`Gitlab API error: ${json?.message ?? json?.error ?? response.statusText}`, response.status)
-    // From base64 string to buffer
-    const buf = Buffer.from(json.content, 'base64')
-    return buf
+    return this.readFile(session, websiteId, finalPath)
   }
 
   async deleteAssets(session: GitlabSession, websiteId: string, fileNames: string[]): Promise<void> {