tsoft-cli 1.0.2 → 1.1.1

package/bin/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { start } = require('../src/commands/start');
+const { save } = require('../src/commands/save');
+const { createTheme } = require('../src/commands/create');
+
+program
+    .command('start')
+    .description('Start development environment for a selected site and theme.')
+    .action(() => {
+        start();
+    });
+
+program
+    .command('save <site> <theme>')
+    .description('Saving the file changes to the server.')
+    .action((site, theme) => {
+        save(site, theme);
+    });
+
+program
+    .command('create')
+    .description('Create a new theme')
+    .action(() => {
+        createTheme();
+    });
+
+program.parse(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsoft-cli",
-  "version": "1.0.2",
-  "description": "",
+  "version": "1.1.1",
+  "description": "A theme development cli for developers who want to create themes for T-Soft.",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -10,15 +10,15 @@
   "author": "",
   "license": "ISC",
   "bin": {
-    "tsoft-cli": "./bin/tsoft-cli.js"
+    "tsoft-cli": "./bin/index.js"
   },
   "dependencies": {
-    "axios": "^1.7.2",
     "chokidar": "^3.6.0",
+    "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
-    "fs": "^0.0.1-security",
-    "inquirer": "^9.2.23",
-    "lodash": "^4.17.21"
+    "enquirer": "^2.4.1",
+    "figlet": "^1.7.0",
+    "fs": "^0.0.1-security"
   },
   "type": "commonjs"
 }

package/src/client-credentials.js

@@ -0,0 +1,87 @@
+const buildPostRequest = require('./request');
+
+class ClientCredentials {
+    site;
+    clientId;
+    clientSecret;
+    bearer;
+
+    constructor(site) {
+        this.site = site;
+    }
+
+    getEnvironment() {
+        return {
+            site: this.site,
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            bearer: this.bearer
+        }
+    }
+
+    set clientId(clientId) {
+        this.clientId = clientId;
+    }
+
+    get clientId() {
+        return this.clientId;
+    }
+
+    setClientSecret(clientSecret) {
+        this.clientSecret = clientSecret;
+        return this;
+    }
+
+    async register(CLIENT_UUID) {
+
+        const uri = "api/v3/admin/auth/auth-application";
+        const result = await this.buildPostRequest(uri, {
+            body: JSON.stringify({
+                uuid: CLIENT_UUID,
+            })
+        });
+
+        if (result.status === true) {
+            this.clientId = result.data.public_key;
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+
+    async authorize() {
+        const uri = "api/v3/admin/auth/auth-application/authorize";
+        await this.buildPostRequest(uri, {
+            body: JSON.stringify({
+                public_key: this.clientId,
+                secret: this.clientSecret
+            })
+        }).then((result) => {
+            if (result.status === true) {
+                this.bearer = result.data.token.plainTextToken
+            }
+        });
+
+    }
+
+
+    async buildPostRequest(uri, options = {}) {
+        return buildPostRequest(this.site, uri, options);
+    }
+
+    async validateToken(token) {
+        const uri = 'api/v3/admin/auth/me';
+        const response = await buildPostRequest(this.site, uri, {
+            body: JSON.stringify({
+                _method: 'GET'
+            }),
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        return response.message === 'ok'; // response.ok true ise token geçerli
+    }
+}
+
+module.exports = ClientCredentials;

package/src/commands/create.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+const { Input } = require('enquirer');
+
+async function createTheme() {
+    const sitePrompt = new Input({
+        name: 'siteName',
+        message: 'Çalışmak istediğiniz sitenin adı:'
+    });
+
+    const themeNamePrompt = new Input({
+        name: 'themeName',
+        message: 'Tema adı:'
+    });
+
+    const directoryNamePrompt = new Input({
+        name: 'directoryName',
+        message: 'Tema dizin ismi (a-z yalnızca İngilizce karakterler):',
+        validate: input => /^[a-z]+$/.test(input) ? true : 'Yalnızca küçük İngilizce harfler kullanabilirsiniz.'
+    });
+
+    const authorPrompt = new Input({
+        name: 'author',
+        message: 'Author (isteğe bağlı):'
+    });
+
+    const versionPrompt = new Input({
+        name: 'version',
+        message: 'Version (isteğe bağlı, varsayılan 1.0.0):',
+        initial: '1.0.0'
+    });
+
+    const siteName = await sitePrompt.run();
+    const themeName = await themeNamePrompt.run();
+    const directoryName = await directoryNamePrompt.run();
+    const author = await authorPrompt.run();
+    const version = await versionPrompt.run();
+
+    const cwd = process.cwd();
+    const themePath = path.join(cwd, siteName, directoryName);
+
+    if (!fs.existsSync(themePath)) {
+        fs.mkdirSync(themePath, { recursive: true });
+    }
+
+    const themeData = {
+        siteName,
+        themeName,
+        directoryName,
+        author,
+        version
+    };
+
+    fs.writeFileSync(path.join(themePath, '.theme'), JSON.stringify(themeData, null, 2));
+
+    console.log(`Tema "${themeName}" başarıyla oluşturuldu.`);
+}
+
+module.exports = {
+    createTheme
+};

package/src/commands/save.js

@@ -0,0 +1,17 @@
+const Tsoft = require('../tsoft');
+
+async function save(site, theme) {
+    const t = new Tsoft(site);
+    const isValid = await t.isTokenValid(theme);
+
+    if (isValid) {
+        await t.saveOnlineStore(theme);
+        console.log('Online store saved successfully.');
+    } else {
+        console.log('Invalid Bearer token. Please re-authenticate.');
+    }
+}
+
+module.exports = {
+    save
+};

package/src/commands/start.js

@@ -0,0 +1,272 @@
+const Tsoft = require('../tsoft');
+const constants = require('../constants');
+const fs = require('fs');
+const path = require('path');
+const {Input, Select, Confirm, prompt} = require('enquirer');
+const chokidar = require('chokidar');
+const figlet = require('figlet');
+const readline = require('readline');
+const cliProgress = require('cli-progress');
+const {exec} = require('child_process');
+
+async function displayAsciiArt() {
+    return new Promise((resolve, reject) => {
+        figlet('T-SOFT', {
+            font: 'Standard',
+        }, (err, data) => {
+            if (err) {
+                console.log('Something went wrong...');
+                console.dir(err);
+                reject(err);
+                return;
+            }
+            console.log(data);
+            resolve();
+        });
+    });
+}
+
+async function showProgress(tsoft, theme) {
+    const themePath = path.join(process.cwd(), tsoft.site, theme);
+    const fileList = tsoft.fileManager.listFilesRecursive(themePath).filter(file => !file.includes('.env'));
+    const totalFiles = fileList.length;
+
+    // Create a new progress bar instance and use shades_classic theme
+    const progressBar = new cliProgress.SingleBar({
+        format: 'Progress |{bar}| {percentage}% || {value}/{total} Files Uploaded',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        clearOnComplete: false
+    });
+    progressBar.start(totalFiles, 0);
+
+    for (let i = 0; i < totalFiles; i++) {
+        const file = fileList[i];
+        const fileName = tsoft.fileManager.getRelativePath(theme, file);
+        const content = tsoft.fileManager.readFile(file);
+        const env = tsoft.themeManager.getEnvironment(theme);
+
+
+        try {
+            await tsoft.saveFile(theme, fileName, content, env.bearer);
+        } catch (error) {
+            console.error(`Error uploading file ${fileName}:`, error);
+        }
+        progressBar.update(i + 1);
+    }
+
+    progressBar.stop();
+
+    return 'All files uploaded with progress shown successfully';
+}
+
+async function updateTheme(tsoft, theme) {
+    const directoryName = path.basename(path.join(process.cwd(), tsoft.site, theme));
+    const response = await tsoft.updateTheme(directoryName);
+    if (response.status === true) {
+        return 'Successfully updated';
+    } else {
+        throw new Error('Update failed');
+    }
+}
+
+function clearScreen() {
+    process.stdout.write('\x1B[2J\x1B[0f');
+}
+
+async function editThemeFile(themeManager, directoryName) {
+    const themePath = path.join(process.cwd(), themeManager.site, directoryName, '.theme');
+
+    if (!fs.existsSync(themePath)) {
+        console.error('.theme file not found.');
+        return;
+    }
+
+    console.log(`Opening .theme file: ${themePath}`);
+    const openCommand = process.platform === 'win32' ? 'start' :
+        process.platform === 'darwin' ? 'open' :
+            'xdg-open';
+
+    exec(`${openCommand} ${themePath}`, (err) => {
+        if (err) {
+            console.error('Failed to open .theme file:', err);
+        } else {
+            console.log('.theme file opened successfully.');
+        }
+    });
+}
+
+function info() {
+    console.log('\n' +
+        '********************************************************\n' +
+        '*                                                      *\n' +
+        '*  Press "q" to quit watching, "u" to update theme,    *\n' +
+        '*  "s" to save the theme, "e" to edit .theme file.     *\n' +
+        '*                                                      *\n' +
+        '********************************************************\n'
+    );
+}
+
+async function start() {
+    process.stdout.write('\x1B[2J\x1B[0f');
+    await displayAsciiArt();
+    const cwd = process.cwd();
+    const sites = fs.readdirSync(cwd).filter(file => {
+        return file.charAt(0) !== '.' && !['node_modules', 'build', 'dist'].includes(file);
+    }).filter(file => fs.statSync(path.join(cwd, file)).isDirectory());
+
+    if (sites.length === 0) {
+        console.error('No sites found in the current directory.');
+        return;
+    }
+
+    const sitePrompt = new Select({
+        name: 'selectedSite',
+        message: 'Please select a site:',
+        choices: sites
+    });
+
+    const selectedSite = await sitePrompt.run();
+
+    const sitePath = path.join(cwd, selectedSite);
+    const themes = fs.readdirSync(sitePath).filter(file => fs.statSync(path.join(sitePath, file)).isDirectory());
+
+    if (themes.length === 0) {
+        console.error('No themes found in the selected site directory.');
+        return;
+    }
+
+    const themePrompt = new Select({
+        name: 'selectedTheme',
+        message: 'Please select a theme:',
+        choices: themes
+    });
+
+    const selectedTheme = await themePrompt.run();
+    const themeEnvPath = path.join(sitePath, selectedTheme, `${selectedTheme}.env`);
+
+    // Check if .env file exists and contains a valid JSON with a bearer attribute
+    let envData = {};
+    if (fs.existsSync(themeEnvPath)) {
+        try {
+            envData = JSON.parse(fs.readFileSync(themeEnvPath, 'utf-8'));
+        } catch (error) {
+            console.warn(`Invalid JSON format in ${themeEnvPath}. This file will be deleted and you will need to reauthorize.`);
+            fs.unlinkSync(themeEnvPath);
+            console.info('Invalid environment file deleted. Proceeding with initialization...');
+        }
+
+        if (envData.bearer) {
+            const tsoft = new Tsoft(selectedSite);
+            const bearerTokenValid = await tsoft.isTokenValid(selectedTheme);
+
+            if (bearerTokenValid) {
+                console.info('Existing environment file with a valid bearer token found. Proceeding with existing configuration...');
+                // Start watching for file changes
+                await startWatching(selectedSite, selectedTheme, tsoft);
+                return;
+            } else {
+                console.warn('Existing bearer token is invalid. You will need to reauthorize.');
+                fs.unlinkSync(themeEnvPath);
+            }
+        }
+    }
+
+    let t = new Tsoft(selectedSite);
+    const initializeResult = await t.initialize(selectedTheme, {reset: false});
+
+    const approvalPrompt = new Input({
+        name: 'approval',
+        message: 'Please provide the approval code:'
+    });
+
+    const approval = await approvalPrompt.run();
+
+    if (approval) {
+        await constants.APPROVAL.handler(t.clientCredentials.setClientSecret(approval));
+        t.buildEnvironment();
+        console.info('You are ready to go');
+
+        // Start watching for file changes
+        await startWatching(selectedSite, selectedTheme, t);
+    }
+}
+
+async function startWatching(site, theme, tsoft) {
+    const themePath = path.join(process.cwd(), site, theme);
+    const envPath = path.join(themePath, `${theme}.env`);
+
+    if (!fs.existsSync(envPath)) {
+        console.error('Environment file not found. Please initialize the theme first.');
+        return;
+    }
+
+    const watcher = chokidar.watch(themePath, {
+        ignored: /(^|[\/\\])\../, // ignore dotfiles
+        persistent: true
+    });
+
+    watcher.on('change', async (filePath) => {
+        console.log(`File ${filePath} has been changed`);
+
+        const env = JSON.parse(fs.readFileSync(envPath, 'utf-8'));
+        const fileName = filePath.replace(`${themePath}/`, '');
+        const content = fs.readFileSync(filePath).toString();
+
+        try {
+            const result = await tsoft.saveFile(theme, fileName, content, env.bearer);
+            console.log(`File ${fileName} uploaded successfully`);
+        } catch (error) {
+            console.error(`Error uploading file ${fileName}:`, error);
+        }
+    });
+
+    console.log(`Watching for file changes in ${themePath}`);
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    info();
+
+    rl.on('line', async (input) => {
+        if (input.trim() === 'q') {
+            console.log('Quitting file watch...');
+            watcher.close();
+            rl.close();
+            process.exit(0);
+        } else if (input.trim() === 'u') {
+            console.log('Updating theme...');
+            try {
+                const result = await updateTheme(tsoft, theme);
+                console.log(result);
+                info();
+            } catch (error) {
+                console.error(`Error updating theme:`, error);
+            }
+        } else if (input.trim() === 's') {
+            clearScreen();
+            console.log('Starting to upload all files with progress...');
+            try {
+                const result = await showProgress(tsoft, theme);
+                console.log(result);
+                info();
+            } catch (error) {
+                console.error(`Error showing progress:`, error);
+            }
+        } else if (input.trim() === 'e') {
+            console.log('Editing .theme file...');
+            try {
+                await editThemeFile(tsoft.themeManager, theme);
+            } catch (error) {
+                console.error(`Error editing .theme file:`, error);
+            }
+        }
+    });
+}
+
+module.exports = {
+    start
+};

package/src/constants.js

@@ -0,0 +1,16 @@
+const handleAuthorization = async (credentialHandler) => {
+    await credentialHandler.authorize();
+};
+module.exports = Object.freeze({
+    INITIALIZE: {
+        type: 'input',
+        name: 'site',
+        message: 'Lütfen site adresini giriniz (örnek: https://tsoft.com.tr):'
+    },
+    APPROVAL: {
+        type: 'input',
+        name: 'approval',
+        message: 'Parolanızı giriniz (Lütfen panelden onaylayınız):',
+        handler: handleAuthorization
+    }
+});

package/src/file-manager.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+
+class FileManager {
+    constructor(site) {
+        this.site = site;
+        this.cwd = process.cwd();
+    }
+
+    listFilesRecursive(directory, fileList = []) {
+        const files = fs.readdirSync(directory);
+        files.forEach(file => {
+            const fullPath = path.join(directory, file);
+            if (fs.statSync(fullPath).isDirectory()) {
+                this.listFilesRecursive(fullPath, fileList);
+            } else {
+                fileList.push(fullPath);
+            }
+        });
+        return fileList;
+    }
+
+    getRelativePath(theme, file) {
+        const themePath = path.join(this.cwd, this.site, theme);
+        return file.replace(`${themePath}/`, '');
+    }
+
+    readFile(file) {
+        return fs.readFileSync(file).toString();
+    }
+}
+
+module.exports = FileManager;

package/src/request.js

@@ -0,0 +1,16 @@
+module.exports = (site, uri, options = {}) => {
+    return fetch("https://" + site + '/' + uri, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...options.headers ?? {}
+        },
+        body: options.body
+    })
+        .then((response) => response.json())
+        .then((result) => {
+            return result
+        })
+        .catch((error) => console.error(error));
+}

package/src/theme-manager.js

@@ -0,0 +1,74 @@
+const fs = require('fs');
+const path = require('path');
+
+class ThemeManager {
+    constructor(site) {
+        this.site = site;
+        this.cwd = process.cwd();
+        this.theme = null;
+        this.registered = false;
+    }
+
+    async initializeTheme(theme, reInit = false) {
+
+        this.theme = theme;
+        const themePath = path.join(this.cwd, this.site, theme);
+        const themeEnvPath = path.join(themePath, `${theme}.env`);
+
+
+        if (reInit) {
+           ///await fs.rm(themePath, {recursive: true, force: true}, (err, file) => {});
+        }
+
+        if (!fs.existsSync(path.join(this.cwd, this.site))) {
+            fs.mkdirSync(path.join(this.cwd, 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());
+                this.registered = Boolean(environment.bearer);
+            } catch (e) {
+                this.registered = false;
+            }
+        }
+    }
+
+    isRegistered() {
+        return this.registered;
+    }
+
+    buildEnvironment(environment) {
+        const envPath = path.join(this.cwd, this.site, this.theme, `${this.theme}.env`);
+        fs.writeFileSync(envPath, JSON.stringify(environment));
+    }
+
+    getEnvironment(theme) {
+        const themeEnvPath = path.join(this.cwd, this.site, theme, `${theme}.env`);
+        return JSON.parse(fs.readFileSync(themeEnvPath));
+    }
+
+    getThemeInfo(directoryName) {
+        const themePath = path.join(process.cwd(), this.site, directoryName, '.theme');
+        if (fs.existsSync(themePath)) {
+            const themeInfo = fs.readFileSync(themePath, 'utf-8');
+            try {
+                return JSON.parse(themeInfo);
+            } catch (error) {
+                console.error('Error parsing .theme file:', error);
+                return null;
+            }
+        } else {
+            console.error('.theme file not found in', themePath);
+            return null;
+        }
+    }
+}
+
+module.exports = ThemeManager;

package/src/tsoft.js

@@ -0,0 +1,110 @@
+const ClientCredentials = require('./client-credentials');
+const constants = require('./constants');
+const FileManager = require('./file-manager');
+const ThemeManager = require('./theme-manager');
+const path = require("path");
+const buildPostRequest = require('./request');
+
+class Tsoft {
+    static TSOFT_CLI_UUID = '7583a318-8542-4ec8-980c-48ea67031be3';
+    static ONLINESTORE_SAVE_URI = 'api/v3/admin/online-store-2/theme/file-manager?q=save';
+    static UPDATE_THEME_URI = 'api/v3/admin/online-store-2/theme/update-theme';
+
+
+    constructor(site) {
+        this.site = site;
+        this.themeManager = new ThemeManager(site);
+        this.fileManager = new FileManager(site);
+        this.clientCredentials = new ClientCredentials(site);
+    }
+
+    async initialize(theme, reInit = false) {
+        await this.themeManager.initializeTheme(theme, reInit);
+        if (!this.themeManager.isRegistered()) {
+            return await this.register(Tsoft.TSOFT_CLI_UUID);
+        } else {
+            console.warn('You are already registered');
+        }
+    }
+
+    buildEnvironment() {
+        this.themeManager.buildEnvironment(this.clientCredentials.getEnvironment());
+    }
+
+    async authorize() {
+        await this.clientCredentials.authorize();
+    }
+
+    async register(CLIENT_UUID) {
+        const response = await this.clientCredentials.register(CLIENT_UUID);
+        return response === true ? constants.APPROVAL : null;
+    }
+
+    async saveOnlineStore(theme) {
+        const fileList = this.fileManager.listFilesRecursive(
+            path.join(process.cwd(), this.site, theme)
+        );
+        await Promise.all(fileList.filter(file => !file.includes('.env')).map(async file => {
+            const fileName = this.fileManager.getRelativePath(theme, file);
+            const content = this.fileManager.readFile(file);
+            const env = this.themeManager.getEnvironment(theme);
+            const result = await buildPostRequest(this.site, Tsoft.ONLINESTORE_SAVE_URI, {
+                headers: {
+                    Authorization: `Bearer ${env.bearer}`
+                },
+                body: JSON.stringify({
+                    theme: theme,
+                    path: fileName,
+                    content: content
+                })
+            });
+            console.log({
+                result: result
+            })
+        }));
+    }
+
+    async saveFile(theme, fileName, content, bearerToken) {
+        const response = await buildPostRequest(this.site, Tsoft.ONLINESTORE_SAVE_URI, {
+            headers: {
+                Authorization: `Bearer ${bearerToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                theme: theme,
+                path: fileName,
+                content: content
+            })
+        });
+
+        return response;
+    }
+
+
+    async isTokenValid(theme) {
+        const env = this.themeManager.getEnvironment(theme);
+        return await this.clientCredentials.validateToken(env.bearer);
+    }
+
+    async updateTheme(directoryName) {
+        const env = this.themeManager.getEnvironment(directoryName);
+        const themeInfo = this.themeManager.getThemeInfo(directoryName); // .theme bilgisi alınıyor
+
+        const response = await buildPostRequest(this.site, Tsoft.UPDATE_THEME_URI, {
+            headers: {
+                Authorization: `Bearer ${env.bearer}`,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            },
+            body: JSON.stringify({
+                theme: directoryName,
+                themeInfo: themeInfo
+            })
+        });
+
+        return response;
+    }
+
+}
+
+module.exports = Tsoft;

package/bin/tsoft-cli.js

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-const Common = require('../src/common');
-const { program } = require('commander');
-const axios = require('axios');
-const chokidar = require('chokidar');
-const path = require('path');
-const fs = require('fs');
-const _ = require('lodash');
-
-program
-    .command('init')
-    .description('Initialize the CLI')
-    .action(() => {
-        init();
-    });
-
-program.parse(process.argv);
-
-function init() {
-     (async () => {
-        const {default: inquirer} = await import('inquirer');
-
-        const tsoft = new Common();
-
-        if (Common.skip !== true) {
-            await tsoft.handleStep1(
-                (await inquirer.prompt(
-                    [
-                        {
-                            type: 'input',
-                            name: 'step1',
-                            message: 'Site Adresi https://(tsoft.com.tr):'
-                        },
-                    ]
-                ))
-            )
-
-            await tsoft.handleStep2(
-                (await inquirer.prompt(
-                    [
-                        {
-                            type: 'input',
-                            name: 'step2',
-                            message: 'Parola (Panelden Onaylayın):'
-                        },
-                    ]
-                ))
-            )
-
-            await tsoft.handleStep3(
-                (await inquirer.prompt(
-                    [
-                        {
-                            type: 'input',
-                            name: 'step3',
-                            message: 'Tema Adı:'
-                        },
-                    ]
-                ))
-            )
-        } else {
-
-            const debouncedSendFileChange = _.debounce(async (data) => {
-                try {
-                    const response = await axios.post('https://'+this.site+'/api', { data });
-                    console.log('API response:', response.data);
-                } catch (error) {
-                    console.error('Error sending API request:', error);
-                }
-            }, 1000);
-
-            const watchDirectory = path.join(__dirname, 'themes'); // İzlemek istediğiniz dizinin yolunu belirtin
-            const watcher = chokidar.watch(watchDirectory, {
-                persistent: true,
-                ignored: /(^|[\/\\])\../,
-                ignoreInitial: true,
-                followSymlinks: true,
-                depth: 99,
-                awaitWriteFinish: {
-                    stabilityThreshold: 2000,
-                    pollInterval: 100
-                }
-            });
-
-            watcher.on('all', (event, filePath) => {
-                if (event === 'change' || event === 'add' || event === 'unlink') {
-                    console.log(`File ${filePath} has been ${event}`);
-
-                    // Dosya değişikliğinde dosya içeriğini oku ve debounce edilmiş API'ye gönder
-                    fs.readFile(filePath, 'utf8', (err, data) => {
-                        if (err) {
-                            console.error('Error reading file:', err);
-                            return;
-                        }
-
-                        debouncedSendFileChange(data);
-                    });
-                }
-            });
-
-        }
-
-    })();
-}
-
-
-

package/src/common.js

@@ -1,117 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-
-class Common {
-    static CLIENT_UUID = "7583a318-8542-4ec8-980c-48ea67031be3";
-
-
-    site = null;
-    public_key = null;
-    secret = null;
-
-    theme = null;
-
-    bearer = null;
-
-    static skip = false;
-
-    constructor() {
-        try {
-            const environment = JSON.parse(fs.readFileSync(path.join(__dirname, '.environment'), 'utf8'))
-
-            this.site = environment.site;
-            this.public_key = environment.public_key;
-            this.secret = environment.secret;
-            this.theme = environment.theme;
-            this.bearer = environment.bearer;
-
-            Common.skip = true;
-        } catch (error) {
-
-        }
-    }
-
-    handleEnv(envObject) {
-        const filePath = path.join(__dirname, '.environment');
-
-        fs.writeFile(filePath, envObject, (err) => {
-            if (err) {
-                console.error('Error writing file:', err);
-            } else {
-                console.log('File written successfully');
-            }
-        });
-    }
-
-    async handleStep1(message) {
-        this.site = message.step1;
-        await this.authorizationRequest();
-    }
-
-    async handleStep2(message) {
-        this.secret = message.step2;
-        await this.login();
-    }
-
-    async handleStep3(message) {
-        this.theme = message.step3;
-
-        this.handleEnv(JSON.stringify({
-            site: this.site,
-            public_key: this.public_key,
-            secret: this.secret,
-            theme: this.theme,
-            bearer: this.bearer
-        }));
-    }
-
-
-    async authorizationRequest() {
-        const myHeaders = new Headers();
-        myHeaders.append("Content-Type", "application/json");
-        myHeaders.append("Accept", "application/json");
-
-        const raw = JSON.stringify({
-            "uuid": Common.CLIENT_UUID,
-        });
-
-        const requestOptions = {
-            method: "POST",
-            headers: myHeaders,
-            body: raw,
-            redirect: "follow"
-        };
-
-        fetch("https://" + this.site + "/api/v3/admin/auth/auth-application", requestOptions)
-            .then((response) => response.json())
-            .then((result) => {
-                this.public_key = result.public_key
-            })
-            .catch((error) => console.error(error));
-    }
-
-    async login() {
-        const myHeaders = new Headers();
-        const formdata = new FormData();
-        formdata.append("public_key", this.public_key);
-        formdata.append("secret", this.secret);
-
-        const requestOptions = {
-            method: "POST",
-            headers: myHeaders,
-            body: formdata,
-            redirect: "follow"
-        };
-
-        fetch("https://" + this.site + "/api/v3/admin/auth/auth-application/authorize", requestOptions)
-            .then((response) => response.json())
-            .then((result) => {
-                this.bearer = result?.token?.plainTextToken;
-            })
-            .catch((error) => console.error(error));
-    }
-
-
-}
-
-module.exports = Common;