tsoft-cli 1.4.2 → 2.0.0

package/packages/theme/src/services/StartTheme.ts

@@ -0,0 +1,363 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { exec } from 'node:child_process'
+import { openBrowser, unZIP, cliProgress, consola } from '@tsoft-cli/shared'
+import chokidar from 'chokidar'
+import type { FSWatcher } from 'chokidar'
+import { input } from '@inquirer/prompts'
+import type { Tsoft } from './Tsoft.js'
+import { Constants } from './Constants.js'
+import type { TThemeEnviroments } from '../types.js'
+import { themeFileNames, themeTypes } from '../enums.js'
+import { getFolderFromCWD, getOpenFilePlatformCode, saveThemeData, setPathForWebhookOperations } from '../utils/utils.js'
+import { clearScreen, displayAsciiArt } from '../utils/screen.js'
+
+export class StartTheme {
+  private tsoft: Tsoft
+  private themeName: string
+  private watcher: FSWatcher
+
+  constructor(TS: Tsoft) {
+    this.tsoft = TS
+  }
+
+  private async showProgress(): Promise<string> {
+    const themePath = getFolderFromCWD(this.tsoft.site, this.themeName)
+    const fileList = this.tsoft.fileManager
+      .listFilesRecursive(themePath)
+      .filter((file: string) => !file.includes(themeFileNames.env) && !file.includes(themeFileNames.themeTxt))
+    fileList.push(path.join(themePath, themeFileNames.theme))
+    const totalFiles = fileList.length
+
+    const progressBar = new cliProgress.SingleBar({
+      format: 'İlerleme |{bar}| {percentage}% || {value}/{total} Dosya Yüklendi',
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+      hideCursor: true,
+      clearOnComplete: true,
+    })
+    progressBar.start(totalFiles, 0)
+
+    for (let i = 0; i < totalFiles; i++) {
+      const file = fileList[i]
+      const fileName = this.tsoft.fileManager.getRelativePath(this.themeName, file)
+      const content = this.tsoft.fileManager.readFile(file)
+      const env = this.tsoft.themeManager.getEnvironment(this.themeName)
+
+      try {
+        await this.tsoft.saveFile(this.themeName, fileName, content, env.bearer)
+      } catch (error) {
+        consola.error(`Dosya yükleme hatası ${fileName}:`, error)
+      }
+      progressBar.update(i + 1)
+    }
+
+    progressBar.stop()
+
+    return 'Tüm dosyalar başarıyla yüklendi'
+  }
+
+  private async initializeAndAuthorize(): Promise<boolean> {
+    await this.tsoft.initialize(this.themeName)
+
+    const approval = await input({
+      message: 'Lütfen onay kodunu sağlayın:',
+      required: true,
+    })
+
+    if (approval) {
+      await Constants.APPROVAL.handler(this.tsoft.clientCredentials.setClientSecret(approval))
+      this.tsoft.buildEnvironment()
+      consola.success('Ortam dosyası başarıyla oluşturuldu.')
+      return true
+    } else {
+      consola.error('Onay kodu gerekli.')
+      return false
+    }
+  }
+
+  private async handleExistingEnvironment(themeEnvPath: string): Promise<boolean> {
+    let envData: TThemeEnviroments = {} as any
+
+    if (fs.existsSync(themeEnvPath)) {
+      try {
+        envData = JSON.parse(fs.readFileSync(themeEnvPath, 'utf-8'))
+      } catch (error) {
+        consola.warn(
+          `${themeEnvPath} dosyasında geçersiz JSON formatı. Bu dosya silinecek ve yeniden yetkilendirmeniz gerekecek.`,
+        )
+        fs.unlinkSync(themeEnvPath)
+        consola.info('Geçersiz ortam dosyası silindi. Başlatma işlemine devam ediliyor...')
+      }
+
+      if (envData.bearer) {
+        const bearerTokenValid = await this.tsoft.isTokenValid(this.themeName)
+
+        if (bearerTokenValid) {
+          consola.info(
+            'Geçerli bir taşıyıcı jetonuna sahip mevcut ortam dosyası bulundu. Mevcut yapılandırma ile devam ediliyor...',
+          )
+          return true
+        } else {
+          consola.warn('Mevcut taşıyıcı jetonu geçersiz. Yeniden yetkilendirmeniz gerekecek.')
+          fs.unlinkSync(themeEnvPath)
+        }
+      }
+    }
+
+    return false
+  }
+
+  private async changedThemeTxt() {
+    const themeTXT = getFolderFromCWD(this.tsoft.site, this.themeName, themeFileNames.themeTxt)
+    const themeFile = getFolderFromCWD(this.tsoft.site, this.themeName)
+    const result = fs.readFileSync(themeTXT).toString()
+    saveThemeData(themeFile, JSON.parse(result))
+  }
+
+  private async startWatching(themePath: string): Promise<void> {
+    this.watcher = chokidar.watch(themePath, {
+      ignored: /(^|[\/\\])(\.theme|(.*?)\.env)$/, // ignore .theme ve .env files
+      persistent: true,
+    })
+
+    this.watcher
+      .on('change', async (filePath: string) => {
+        if (filePath.includes(themeFileNames.themeTxt)) {
+          await this.changedThemeTxt()
+          return
+        }
+
+        consola.info(`Dosya değiştirildi ${filePath}`)
+        await this.handleFileChange(filePath)
+      })
+      .on('unlink', async (filePath: string) => {
+        consola.success(`Dosya silindi ${filePath}`)
+        await this.handleFileDeletion(filePath)
+      })
+      .on('unlinkDir', async (dirPath: string) => {
+        consola.success(`Dizin silindi ${dirPath}`)
+        await this.handleDirectoryDeletion(dirPath)
+      })
+
+    consola.start(`${themePath} dizinindeki dosya değişiklikleri izleniyor`)
+
+    const developmentURL = this.usageScreen()
+
+    process.stdin.setRawMode(true)
+    process.stdin.resume()
+    process.stdin.on('data', async (key) => {
+      await this.handleUserInput(key, developmentURL)
+    })
+  }
+
+  private usageScreen(): string {
+    clearScreen()
+
+    consola.log(
+      '\n' +
+        '********************************************************\n' +
+        '*                                                      *\n' +
+        '*  Dosya izlemeyi sonlandırmak için "q" tuşuna basın,  *\n' +
+        '*  Temayı güncellemek için "u" tuşuna basın,           *\n' +
+        '*  Temayı kaydetmek için "s" tuşuna basın,             *\n' +
+        '*  .theme dosyasını düzenlemek için "e" tuşuna basın,  *\n' +
+        '*  Tema dizinini açmak için "o" tuşuna basın.          *\n' +
+        '*  URL\'yi tarayıcıda açmak için "p" tuşuna basın.      *\n' +
+        '*                                                      *\n' +
+        '********************************************************\n',
+    )
+
+    const { clientId, clientSecret } = this.tsoft.themeManager.getEnvironment(this.themeName)
+    const url = 'https://' + this.tsoft.site + '?tsoft-cli=' + clientId + '&tsoft-cli-secret=' + clientSecret
+    consola.info('İzlenen tema: ' + this.themeName)
+    consola.info('Önizleme: \n')
+    consola.info(url + '\n')
+
+    return url
+  }
+
+  private async closeProcess(): Promise<void> {
+    consola.log('\n')
+    consola.info('Programdan çıkılıyor. Hoşça kalın!')
+    await this.watcher.close()
+    process.exit(0)
+  }
+
+  private async handleUserInput(input: Buffer, url: string): Promise<void> {
+    //CTRL+C
+    if (input[0] == 3) {
+      await this.closeProcess()
+    }
+
+    switch (input.toString().trim()) {
+      case 'p':
+        consola.start('URL tarayıcıda açılıyor...')
+        await openBrowser(url)
+        break
+
+      case 'u':
+        consola.start('Tema güncelleniyor...')
+        try {
+          const result = await this.updateTheme()
+          consola.success(result)
+        } catch (error) {
+          consola.error(`Tema güncelleme hatası:`, error)
+        }
+        break
+
+      case 's':
+        consola.start('Tüm dosyalar ilerleme ile yüklenmeye başlanıyor...')
+        try {
+          const result = await this.showProgress()
+          consola.success(result)
+        } catch (error) {
+          consola.error(`İlerleme gösterim hatası:`, error)
+        }
+        break
+
+      case 'e':
+        consola.start(`${themeFileNames.theme} dosyası düzenleniyor...`)
+        try {
+          await this.editThemeFile()
+        } catch (error) {
+          consola.error(`${themeFileNames.theme} dosyası düzenleme hatası:`, error)
+        }
+        break
+
+      case 'o':
+        consola.start('Tema dizini açılıyor...')
+        exec(`${getOpenFilePlatformCode()} ${getFolderFromCWD(this.tsoft.site, this.themeName)}`, (err) => {
+          if (err) {
+            consola.error('Tema dizini açılamadı:', err)
+          } else {
+            consola.success('Tema dizini başarıyla açıldı.')
+          }
+        })
+        break
+
+      case 'q':
+        await this.closeProcess()
+    }
+  }
+
+  private async handleFileChange(filePath: string): Promise<void> {
+    const { dirname, env } = this.setFileDirectoryOptions(filePath)
+    const content = fs.readFileSync(filePath).toString()
+
+    try {
+      await this.tsoft.saveFile(this.themeName, dirname, content, env.bearer)
+      consola.success(`Dosya başarıyla yüklendi ${dirname}`)
+    } catch (error) {
+      consola.error(`Dosya yükleme hatası ${dirname}:`, error)
+    }
+  }
+
+  private async handleFileDeletion(filePath: string): Promise<void> {
+    const { dirname, env } = this.setFileDirectoryOptions(filePath)
+
+    try {
+      await this.tsoft.deleteFile(this.themeName, dirname, env.bearer)
+      consola.success(`Dosya başarıyla silindi ${dirname}`)
+    } catch (error) {
+      consola.error(`Dosya silme hatası ${dirname}:`, error)
+    }
+  }
+
+  private async handleDirectoryDeletion(dirPath: string): Promise<void> {
+    const { dirname, env } = this.setFileDirectoryOptions(dirPath)
+
+    try {
+      await this.tsoft.deleteDirectory(this.themeName, dirname, env.bearer)
+      consola.success(`Dizin başarıyla silindi ${dirname}`)
+    } catch (error) {
+      consola.error(`Dizin silme hatası ${dirname}:`, error)
+    }
+  }
+
+  private setFileDirectoryOptions(dir: string): { dirname: string; env: TThemeEnviroments } {
+    return {
+      dirname: setPathForWebhookOperations(dir.replace(`${getFolderFromCWD(this.tsoft.site, this.themeName)}`, '')),
+      env: JSON.parse(
+        fs.readFileSync(
+          getFolderFromCWD(this.tsoft.site, this.themeName, `${this.themeName}${themeFileNames.env}`),
+          'utf-8',
+        ),
+      ) as TThemeEnviroments,
+    }
+  }
+
+  private async updateTheme(): Promise<string> {
+    const directoryName = path.basename(getFolderFromCWD(this.tsoft.site, this.themeName))
+    const response = await this.tsoft.updateTheme(directoryName)
+
+    if (response.status == true) {
+      return 'Successfully updated'
+    }
+
+    throw new Error('Update failed')
+  }
+
+  private async editThemeFile(): Promise<void> {
+    const themePath = getFolderFromCWD(this.tsoft.themeManager.site, this.themeName, themeFileNames.themeTxt)
+    if (!fs.existsSync(themePath)) {
+      consola.error(`${themeFileNames.themeTxt} file not found.`)
+      return
+    }
+
+    consola.start(`Opening ${themeFileNames.themeTxt} file: ${themePath}`)
+
+    exec(`${getOpenFilePlatformCode()} ${themePath}`, (err) => {
+      if (err) {
+        consola.error(`Failed to open ${themeFileNames.themeTxt} file:`, err)
+      } else {
+        consola.success(`${themeFileNames.themeTxt} file opened successfully.`)
+      }
+    })
+  }
+
+  public async start(themeName: string, recentlyCreated: boolean = false): Promise<void> {
+    this.themeName = themeName
+    await displayAsciiArt()
+    consola.start('Geliştirme ortamı aşağıdaki ayrıntılarla başlatılıyor:')
+    consola.info(`Site Adı: ${this.tsoft.site}`)
+    consola.info(`Tema Adı: ${this.themeName}`)
+    const themePath = getFolderFromCWD(this.tsoft.site, this.themeName)
+    const themeEnvPath = getFolderFromCWD(this.tsoft.site, this.themeName, `${this.themeName}${themeFileNames.env}`)
+
+    const existingEnvValid = await this.handleExistingEnvironment(themeEnvPath)
+    if (existingEnvValid) {
+      await this.startWatching(themePath)
+      return
+    }
+
+    const initializedAndAuthorized = await this.initializeAndAuthorize()
+    if (initializedAndAuthorized) {
+      if (recentlyCreated) {
+        const defaultZipFile = getFolderFromCWD(this.tsoft.site, this.themeName, themeFileNames.themeZip)
+
+        consola.start('Default tema dosyaları indirme işlemi başlatılıyor, lütfen bekleyin')
+        await this.tsoft.fileManager.downloadThemeZip(
+          defaultZipFile,
+          this.tsoft.clientCredentials.bearer,
+          themeTypes.default,
+        )
+        consola.success('Default tema dosyaları indirildi.')
+
+        consola.start('Zip dosyası çıkarma işlemi başlatılıyor.')
+        const unzipResult = await unZIP(defaultZipFile, themePath)
+        if (!unzipResult) {
+          consola.error('Zip dosyası çıkarılamadı')
+          throw new Error()
+        }
+
+        consola.success('Zip dosyası çıkarma işlemi tamamlandı.')
+
+        //delete zip
+        fs.unlinkSync(defaultZipFile)
+      }
+
+      await this.startWatching(themePath)
+    }
+  }
+}

package/packages/theme/src/services/SyncTheme.ts

@@ -0,0 +1,108 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { unZIP, consola } from '@tsoft-cli/shared'
+import { input } from '@inquirer/prompts'
+import { CreateTheme } from './CreateTheme.js'
+import { StartTheme } from './StartTheme.js'
+import { Tsoft } from './Tsoft.js'
+import { clearScreen } from '../utils/screen.js'
+import { themeFileNames } from '../enums.js'
+import { saveThemeTxt, slugify } from '../utils/utils.js'
+import type { TClientCredentialsRecoveryData, TThemeFile } from './types.js'
+
+export class SyncTheme {
+  private tsoft: Tsoft
+  private createTheme: CreateTheme
+
+  constructor(TS: Tsoft, CT: CreateTheme) {
+    this.tsoft = TS
+    this.createTheme = CT
+  }
+
+  public async start() {
+    let recoveryCode: string
+    let recoveryData: TClientCredentialsRecoveryData
+    while (!recoveryData) {
+      recoveryCode = await input({
+        message: 'Lütfen kurtarma anahtarını girin:',
+        required: true,
+      })
+
+      if (!recoveryData) {
+        continue
+      }
+
+      try {
+        recoveryData = await this.tsoft.startRecovery(recoveryCode)
+      } catch (error) {
+        consola.error(`Hata: ${error.message}`)
+        if (error.message.includes('Çok fazla deneme yapıldı')) {
+          return
+        }
+
+        continue
+      }
+
+      if (!recoveryData) {
+        consola.error('Kurtarma işlemi başarısız oldu. Lütfen geçerli bir kurtarma anahtarı girin.')
+      }
+    }
+
+    const { secret, public_key } = recoveryData
+
+    this.tsoft.clientCredentials.setClientSecret(secret).setClientId(public_key)
+    const authorizeResponse = await this.tsoft.clientCredentials.authorize()
+    if (!authorizeResponse) {
+      consola.error('Authorize işlemi başarısız oldu.')
+      throw new Error('Authorize işlemi başarısız oldu.')
+    }
+
+    const themeInformation = authorizeResponse.data.tokenable
+
+    if (!themeInformation) {
+      consola.error('Tokenable bilgisi alınamadı.')
+      throw new Error('Tokenable bilgisi alınamadı.')
+    }
+
+    const themeName = themeInformation.name
+    const themeNameSlug = slugify(themeName)
+    const themePath = await this.createTheme.createThemeDirectory(this.tsoft.site, themeNameSlug)
+
+    const themeData: TThemeFile = {
+      site: this.tsoft.site,
+      name: themeName,
+      author: themeInformation.author,
+      version: themeInformation.version,
+    }
+
+    saveThemeTxt(themePath, themeData)
+    this.tsoft.themeManager.setTheme(themeNameSlug)
+    clearScreen()
+
+    const zipFilePath = path.join(themePath, themeFileNames.themeZip)
+
+    try {
+      consola.start('Zip dosyası indiriliyor...')
+      await this.tsoft.fileManager.downloadThemeZip(zipFilePath, this.tsoft.clientCredentials.bearer)
+      consola.success('İndirme tamamlandı.')
+
+      consola.start('Dosyalar çıkarılıyor...')
+      const unzipResult = await unZIP(zipFilePath, themePath)
+      if (!unzipResult) {
+        throw 'Zip dosyası çıkarılamadı'
+      }
+
+      consola.success('Çıkarma işlemi tamamlandı.')
+      fs.unlinkSync(zipFilePath)
+    } catch (error) {
+      consola.error(`Zip dosyası ile ilgili bir hata oluştu: ${error.message}`)
+      return
+    }
+
+    this.tsoft.buildEnvironment()
+
+    const startTheme = new StartTheme(this.tsoft)
+    // Geliştirme ortamını başlat
+    await startTheme.start(themeNameSlug)
+  }
+}

package/packages/theme/src/services/ThemeManager.ts

@@ -0,0 +1,118 @@
+import fs from 'node:fs'
+import http from 'node:http'
+import https from 'node:https'
+import { consola } from '@tsoft-cli/shared'
+import { getFolderFromCWD, slugify } from '../utils/utils.js'
+import type { TClientCredentialsGetEnvironment, TThemeFile } from './types.js'
+import type { TThemeEnviroments } from '../types.js'
+import { themeFileNames } from '../enums.js'
+
+export class ThemeManager {
+  public site: string
+  public theme: string
+  public registered: boolean
+
+  constructor(site: string) {
+    this.site = site
+    this.theme = null
+    this.registered = false
+  }
+
+  public async initializeTheme(theme: string, reInit = false) {
+    this.theme = theme
+    const themePath = getFolderFromCWD(this.site, theme)
+    const themeEnvPath = getFolderFromCWD(this.site, theme, `${theme}${themeFileNames.env}`)
+
+    if (reInit) {
+      // await fs.rm(themePath, {recursive: true, force: true}, (err, file) => {});
+    }
+
+    if (!fs.existsSync(getFolderFromCWD(this.site))) {
+      fs.mkdirSync(getFolderFromCWD(this.site))
+    }
+    if (!fs.existsSync(themePath)) {
+      fs.mkdirSync(themePath)
+    }
+    if (reInit || !fs.existsSync(themeEnvPath)) {
+      fs.writeFileSync(themeEnvPath, '')
+      this.registered = false
+    } else {
+      const data = fs.readFileSync(themeEnvPath)
+      try {
+        const environment = JSON.parse(data.toString()) as TThemeEnviroments
+        this.registered = Boolean(environment.bearer)
+      } catch (e) {
+        this.registered = false
+      }
+    }
+
+    try {
+      const isValid = await this.checkSiteValidity()
+      if (!isValid) {
+        consola.error('Geçersiz site: Siteye ulaşılamıyor.')
+        return false
+      }
+    } catch (error) {
+      consola.error('Geçersiz site: Siteye ulaşılamıyor.', error.message)
+      return false
+    }
+
+    return true
+  }
+
+  public setTheme(theme: string) {
+    this.theme = slugify(theme)
+  }
+
+  public isRegistered() {
+    return this.registered
+  }
+
+  public buildEnvironment(environment: TClientCredentialsGetEnvironment) {
+    const envPath = getFolderFromCWD(this.site, this.theme, `${this.theme}${themeFileNames.env}`)
+    fs.writeFileSync(envPath, JSON.stringify(environment))
+  }
+
+  public getEnvironment(theme: string): TThemeEnviroments {
+    const themeEnvPath = getFolderFromCWD(this.site, slugify(theme), `${slugify(theme)}${themeFileNames.env}`)
+    return JSON.parse(fs.readFileSync(themeEnvPath).toString())
+  }
+
+  public getThemeInfo(directoryName: string): TThemeFile {
+    const themePath = getFolderFromCWD(this.site, slugify(directoryName), themeFileNames.themeTxt)
+
+    if (fs.existsSync(themePath)) {
+      const themeInfo = fs.readFileSync(themePath, 'utf-8')
+      try {
+        return JSON.parse(themeInfo)
+      } catch (error) {
+        consola.error(`${themeFileNames.themeTxt} dosyasını ayrıştırma hatası:`, error)
+        return null
+      }
+    } else {
+      consola.error(`${themeFileNames.themeTxt} dosyası bulunamadı:`, themePath)
+      return null
+    }
+  }
+
+  public checkSiteValidity(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const url = new URL(`https://${this.site}/Y/R`)
+      const request = url.protocol == 'https:' ? https : http
+
+      const req = request.get(url, (res) => {
+        if (res.statusCode === 200) {
+          return resolve(true)
+        }
+
+        return resolve(false)
+      })
+
+      req.on('error', (err) => {
+        return reject(err)
+      })
+
+      req.end()
+    })
+  }
+}