tsoft-cli 2.6.15 → 3.4.1

package/src/commands/login.js

@@ -0,0 +1,94 @@
+import open from 'open';
+import chalk from 'chalk';
+import {generateCodeVerifier, generateCodeChallenge} from '../pkce.js';
+import {startCallbackServer} from '../server.js';
+import {exchangeToken, saveTokens} from '../storage.js';
+import * as config from '../config.js';
+import { isJsonMode, jsonOut } from '../output-mode.js';
+import { t } from '../i18n.js';
+
+/**
+ * Login komutu - OAuth2 Authorization Code Flow with PKCE
+ */
+export async function loginCommand() {
+    if (isJsonMode()) {
+        jsonOut({
+            status: 'error',
+            command: 'login',
+            error: {
+                message: t('login.json_error.message'),
+                hint: t('login.json_error.hint')
+            }
+        });
+        process.exit(1);
+    }
+
+    try {
+        console.log(chalk.cyan(t('login.starting') + '\n'));
+
+        // 1. PKCE parametrelerini oluştur
+        const codeVerifier = generateCodeVerifier();
+        const codeChallenge = generateCodeChallenge(codeVerifier);
+        const state = generateCodeVerifier(); // Random state for CSRF protection
+
+        // 2. Authorization URL'i oluştur
+        const authUrl = new URL(config.getAuthorizationUrl());
+        authUrl.searchParams.set('client_id', config.CLIENT_ID);
+        authUrl.searchParams.set('redirect_uri', config.REDIRECT_URI);
+        authUrl.searchParams.set('response_type', 'code');
+        authUrl.searchParams.set('scope', config.SCOPE);
+        authUrl.searchParams.set('state', state);
+        authUrl.searchParams.set('code_challenge', codeChallenge);
+        authUrl.searchParams.set('code_challenge_method', 'S256');
+        authUrl.searchParams.set('prompt', 'select_store');
+
+        // 3. Callback server'ı başlat
+        const serverPromise = startCallbackServer(config.CALLBACK_PORT);
+
+        // 4. Browser'ı aç
+        console.log(chalk.cyan(t('login.browser_opening')));
+        console.log(chalk.gray(`   ${authUrl.toString().substring(0, 80)}...`));
+        console.log();
+
+        await open(authUrl.toString());
+
+        console.log(chalk.yellow(t('login.waiting')));
+        console.log(chalk.gray('   ' + t('login.waiting_detail') + '\n'));
+
+        // 5. Callback'i bekle
+        const {code, state: returnedState, store} = await serverPromise;
+
+        // 6. State doğrula (CSRF koruması)
+        if (state !== returnedState) {
+            throw new Error(t('login.security_error'));
+        }
+
+        console.log(chalk.green(t('login.code_received')));
+        console.log(chalk.cyan(`✓ Store: ${store}\n`));
+
+        // 7. Token exchange
+        console.log(chalk.yellow(t('login.token_fetching')));
+        const tokens = await exchangeToken(code, codeVerifier, store, returnedState);
+
+        console.log(chalk.green(t('login.token_received')));
+
+        // 8. Token'ları kaydet
+        await saveTokens(tokens, store);
+
+        console.log(chalk.green(t('login.credentials_saved') + '\n'));
+
+        // Başarı mesajı
+        console.log(chalk.bold.green(t('login.success')));
+        console.log(chalk.gray(`   Store: ${store}`));
+        console.log(chalk.gray(`   Kullanıcı: ${tokens.user.name} ${tokens.user.surname}`));
+        console.log(chalk.gray(`   Email: ${tokens.user.email}`));
+        console.log(chalk.gray(`   Config: .tsoft/${store.replace(/\./g, '-').toLowerCase()}/\n`));
+
+        console.log(chalk.gray('💡 İpucu: ') + chalk.white(t('login.tip').replace('💡 ', '').replace('Tip: ', '') + '\n'));
+
+    } catch (error) {
+        console.error(chalk.red('\n❌ Hata: ') + error.message);
+        console.error(chalk.gray('\n' + t('login.error_log')));
+        process.exit(1);
+    }
+}

package/src/commands/logout.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import { loadTokens, revokeToken, deleteConfig } from '../storage.js';
+import { t } from '../i18n.js';
+
+/**
+ * Logout komutu - Token'ı revoke eder ve local config'i siler
+ */
+export async function logoutCommand() {
+  try {
+    console.log(chalk.cyan(t('logout.starting') + '\n'));
+
+    // Mevcut token'ları yükle
+    const tokens = await loadTokens();
+
+    if (!tokens) {
+      console.log(chalk.yellow(t('logout.not_logged_in')));
+      return;
+    }
+
+    console.log(chalk.cyan(`Store: ${tokens.store}\n`));
+
+    // Token'ı revoke et
+    if (tokens.accessToken && tokens.store) {
+      console.log(chalk.yellow(t('logout.revoking')));
+      try {
+        await revokeToken(tokens.accessToken, tokens.store);
+        console.log(chalk.green(t('logout.revoked')));
+      } catch (error) {
+        console.log(chalk.yellow(t('logout.revoke_failed')));
+      }
+    }
+
+    // Local config'i sil
+    await deleteConfig(tokens.store);
+    console.log(chalk.green(t('logout.credentials_cleared') + '\n'));
+
+    console.log(chalk.bold.green(t('logout.success')));
+    console.log(chalk.gray('   ' + t('logout.relogin_tip') + '\n'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Hata: ') + error.message);
+    process.exit(1);
+  }
+}

package/src/commands/org-switch.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import axios from 'axios';
+import { loadTokens, ensureValidToken, getActiveStore } from '../storage.js';
+import { brandedSelect, showSuccess, showError, showInfo } from '../ui/prompt-wrapper.js';
+import { isJsonMode, jsonOut } from '../output-mode.js';
+import { mapError } from '../errors/error-mapper.js';
+import { t } from '../i18n.js';
+
+/**
+ * Org switch komutu - Organizasyon seçimi
+ * GET /api/v3/public/organization/developer/orgs -> org listesi
+ * POST /api/v3/public/organization/developer/select-org -> org seçimi
+ */
+export async function orgSwitchCommand() {
+    if (isJsonMode()) {
+        jsonOut({ status: 'error', command: 'org switch', error: { message: t('org.switch.json_error.message'), hint: t('org.switch.json_error.hint') } });
+        process.exit(1);
+    }
+
+    try {
+        const store = await getActiveStore();
+        if (!store) {
+            showError(t('org.switch.no_store'));
+            return;
+        }
+
+        let tokens = await loadTokens(store);
+        if (!tokens) {
+            showError(t('org.switch.no_token'));
+            return;
+        }
+
+        tokens = await ensureValidToken(tokens);
+
+        const baseURL = `https://${store}/api/v3/public/organization/developer`;
+        const headers = {
+            'Authorization': `Bearer ${tokens.accessToken}`,
+            'Accept': 'application/json',
+        };
+
+        // 1. Org listesini getir
+        console.log(chalk.yellow(t('org.switch.loading')));
+
+        const orgsResponse = await axios.get(`${baseURL}/orgs`, { headers });
+        const organizations = orgsResponse.data?.data || orgsResponse.data || [];
+
+        if (!Array.isArray(organizations) || organizations.length === 0) {
+            showInfo(t('org.switch.no_orgs'));
+            return;
+        }
+
+        // 2. Org seçimi
+        const choices = organizations.map(org => ({
+            name: `${org.name}${org.is_system ? chalk.cyan(' [System]') : ''} ${chalk.gray('#' + org.id)}`,
+            value: org,
+        }));
+
+        const selectedOrg = await brandedSelect({
+            message: t('org.switch.select_prompt'),
+            choices,
+        }, t('org.switch.select_title'));
+
+        // 3. Seçimi kaydet
+        console.log(chalk.yellow('\n' + t('org.switch.selecting', { name: selectedOrg.name })));
+
+        await axios.post(`${baseURL}/select-org`, {
+            organization_id: selectedOrg.id,
+        }, { headers });
+
+        showSuccess(t('org.switch.success', { name: selectedOrg.name, id: selectedOrg.id }));
+
+    } catch (error) {
+        if (isJsonMode()) {
+            const mapped = mapError(error, { command: 'org switch' });
+            jsonOut({ status: 'error', command: 'org switch', error: { message: mapped.message, hint: mapped.hint } });
+            process.exit(1);
+        }
+        const message = error.response?.data?.message || error.message;
+        showError(t('org.switch.error', { error: message }));
+        process.exit(1);
+    }
+}

package/src/commands/theme-dev.js

@@ -0,0 +1,424 @@
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import {createWriteStream} from 'fs';
+import path from 'path';
+import AdmZip from 'adm-zip';
+import chokidar from 'chokidar';
+import {createApiClient} from '../api-client.js';
+import {normalizeStoreDomain, slugify, setActiveTheme, getActiveTheme, getActiveStore} from '../storage.js';
+import {brandedConfirm, brandedSelect, showWarning, showError, showInfo} from '../ui/prompt-wrapper.js';
+import { t } from '../i18n.js';
+
+async function getThemeUuid(themeSlug) {
+    const apiClient = await createApiClient();
+    const response = await apiClient.get('/theme');
+    const themes = response.data || [];
+
+    const theme = themes.find(t => slugify(t.name) === themeSlug);
+
+    if (!theme) {
+        throw new Error(`Tema bulunamadı: ${themeSlug}`);
+    }
+
+    return {
+        uuid: theme.theme_folder, name: theme.name, version: theme.version
+    };
+}
+
+async function checkLockStatus(themeUuid) {
+    const apiClient = await createApiClient();
+    return apiClient.post(`/theme/${themeUuid}/check-lock`, {});
+}
+
+async function acquireLock(themeUuid) {
+    const apiClient = await createApiClient();
+    return await apiClient.post(`/theme/${themeUuid}/acquire-lock`, {});
+}
+
+async function pullAndSync(themeUuid, themePath) {
+    const apiClient = await createApiClient();
+
+    console.log(chalk.yellow(t('dev.sync_pulling')));
+    const response = await apiClient.download(`/theme/${themeUuid}/download`, {});
+
+    await fs.mkdir(themePath, {recursive: true});
+    const zipPath = path.join(themePath, 'theme.zip');
+    const writer = createWriteStream(zipPath);
+
+    response.data.pipe(writer);
+
+    await new Promise((resolve, reject) => {
+        writer.on('finish', resolve);
+        writer.on('error', reject);
+    });
+
+    const zip = new AdmZip(zipPath);
+    zip.extractAllTo(themePath, true);
+    await fs.unlink(zipPath);
+
+    console.log(chalk.green(t('dev.sync_updated')));
+
+    console.log(chalk.yellow(t('dev.sync_marking')));
+
+    try {
+        await apiClient.post(`/theme/${themeUuid}/mark-synced`, {});
+        console.log(chalk.green(t('dev.sync_done') + '\n'));
+    } catch (error) {
+        if (error.message.startsWith('LOCK_STOLEN:')) {
+            throw error;
+        } else if (error.message.includes('lock owner') || error.message.includes('locked')) {
+            throw new Error('LOCK_LOST');
+        }
+        throw error;
+    }
+}
+
+async function handleFileChange(themeUuid, themePath, filePath) {
+    try {
+        const relativePath = path.relative(themePath, filePath);
+        const extension = path.extname(filePath).slice(1);
+
+        const allowedExtensions = ['theme', 'twig', 'css', 'js', 'md', 'json', 'svg', 'jpeg', 'jpg', 'png', 'gif', 'webp'];
+
+        if (!allowedExtensions.includes(extension)) {
+            return;
+        }
+
+        const content = await fs.readFile(filePath, 'utf-8');
+        const apiClient = await createApiClient();
+
+        const startTime = Date.now();
+
+        await apiClient.post(`/theme/${themeUuid}/file-manager?q=save`, {
+            path: relativePath, content: content
+        });
+
+        const duration = Date.now() - startTime;
+        console.log(chalk.green(`[${new Date().toLocaleTimeString()}] ` + t('dev.file_saved', { path: relativePath, duration })));
+
+        try {
+            await apiClient.post(`/theme/${themeUuid}/mark-synced`, {});
+        } catch (ackError) {
+        }
+
+    } catch (error) {
+        const relativePath = path.relative(themePath, filePath);
+
+        if (error.message.startsWith('LOCK_STOLEN:')) {
+            const lockOwner = error.message.split(':')[1];
+            console.log(chalk.red('\n' + t('dev.lock_stolen')));
+            console.log(chalk.yellow('   ' + t('dev.lock_stolen_owner', { owner: lockOwner })));
+            console.log(chalk.gray('   ' + t('dev.lock_stolen_stopping') + '\n'));
+            process.exit(1);
+        } else if (error.message === 'LOCK_LOST' || error.message.includes('lock owner') || error.message.includes('locked by another')) {
+            console.log(chalk.red('\n' + t('dev.lock_lost')));
+            console.log(chalk.yellow('   ' + t('dev.lock_stolen_stopping') + '\n'));
+            process.exit(1);
+        } else if (error.message.includes('not synced') || error.message.includes('developerSynced')) {
+            console.log(chalk.red('\n' + t('dev.not_synced_pulling') + '\n'));
+
+            try {
+                await pullAndSync(themeUuid, themePath);
+                await handleFileChange(themeUuid, themePath, filePath);
+            } catch (pullError) {
+                if (pullError.message.startsWith('LOCK_STOLEN:')) {
+                    const lockOwner = pullError.message.split(':')[1];
+                    console.log(chalk.red('\n' + t('dev.lock_stolen')));
+                    console.log(chalk.yellow('   ' + t('dev.lock_stolen_owner', { owner: lockOwner })));
+                    console.log(chalk.gray('   ' + t('dev.lock_stolen_stopping') + '\n'));
+                    process.exit(1);
+                } else if (pullError.message === 'LOCK_LOST') {
+                    console.log(chalk.red('\n' + t('dev.lock_lost')));
+                    console.log(chalk.yellow('   ' + t('dev.lock_stolen_stopping') + '\n'));
+                    process.exit(1);
+                }
+                throw pullError;
+            }
+        } else {
+            console.log(chalk.red(`[${new Date().toLocaleTimeString()}] ` + t('dev.file_error', { path: relativePath, error: error.message })));
+        }
+    }
+}
+
+async function handleFileDelete(themeUuid, themePath, filePath) {
+    try {
+        const relativePath = path.relative(themePath, filePath);
+        const apiClient = await createApiClient();
+
+        await apiClient.post(`/theme/${themeUuid}/file-manager?q=delete`, {
+            items: [{
+                path: relativePath, type: 'file'
+            }]
+        });
+
+        console.log(chalk.yellow(`[${new Date().toLocaleTimeString()}] ` + t('dev.file_deleted', { path: relativePath })));
+
+        try {
+            await apiClient.post(`/theme/${themeUuid}/mark-synced`, {});
+        } catch (ackError) {
+        }
+
+    } catch (error) {
+        const relativePath = path.relative(themePath, filePath);
+        console.log(chalk.red(`[${new Date().toLocaleTimeString()}] ` + t('dev.file_delete_failed', { path: relativePath, error: error.message })));
+    }
+}
+
+async function startFileWatcher(themeUuid, themePath) {
+    console.log(chalk.cyan(t('dev.watching') + '\n'));
+    console.log(chalk.gray(t('dev.env_running')));
+    console.log(chalk.gray('   ' + t('dev.exit_tip') + '\n'));
+
+    const watcher = chokidar.watch(themePath, {
+        ignored: /(^|[\/\\])\../, persistent: true, ignoreInitial: true, awaitWriteFinish: {
+            stabilityThreshold: 300, pollInterval: 100
+        }
+    });
+
+    watcher
+        .on('change', async (filePath) => {
+            await handleFileChange(themeUuid, themePath, filePath);
+        })
+        .on('add', async (filePath) => {
+            await handleFileChange(themeUuid, themePath, filePath);
+        })
+        .on('unlink', async (filePath) => {
+            await handleFileDelete(themeUuid, themePath, filePath);
+        });
+
+    return watcher;
+}
+
+function startKeepAlive(themeUuid) {
+    return setInterval(async () => {
+        try {
+            const apiClient = await createApiClient();
+            await apiClient.post(`/theme/${themeUuid}/mark-synced`, {});
+            console.log(chalk.gray(`[${new Date().toLocaleTimeString()}] 🔄 Keep-alive (mark-synced)`));
+        } catch (error) {
+            console.log(chalk.gray(`[${new Date().toLocaleTimeString()}] ` + t('dev.keepalive_error')));
+        }
+    }, 30000);
+}
+
+function setupGracefulShutdown(watcher, keepAliveInterval) {
+    process.on('SIGINT', async () => {
+        console.log(chalk.yellow('\n\n' + t('dev.stopping') + '\n'));
+
+        if (watcher) {
+            await watcher.close();
+            console.log(chalk.green(t('dev.watch_stopped')));
+        }
+
+        if (keepAliveInterval) {
+            clearInterval(keepAliveInterval);
+            console.log(chalk.green(t('dev.keepalive_stopped')));
+        }
+
+        console.log(chalk.gray('  ' + t('dev.lock_kept')));
+
+        console.log(chalk.green('\n' + t('dev.exit_success') + '\n'));
+        process.exit(0);
+    });
+}
+
+export async function themeDevCommand(themeName) {
+    try {
+        console.log(chalk.cyan(t('dev.starting') + '\n'));
+
+        const store = await getActiveStore();
+        const storeSlug = normalizeStoreDomain(store);
+
+        let themeSlug = themeName;
+        let themeInfo;
+
+        if (!themeSlug) {
+            themeSlug = await getActiveTheme();
+        }
+
+        if (themeSlug && !themeName) {
+            console.log(chalk.cyan(t('dev.active_site')) + ' ' + chalk.white(store));
+
+            const apiClient = await createApiClient();
+            const tempThemeInfo = await getThemeUuid(themeSlug);
+            console.log(chalk.cyan(t('dev.active_theme')) + ' ' + chalk.white(`${themeSlug} (${tempThemeInfo.name} v${tempThemeInfo.version})`));
+            console.log();
+
+            const continueWithActive = await brandedConfirm({
+                message: t('dev.continue_prompt'),
+                default: true
+            }, t('dev.continue_title'));
+
+            if (!continueWithActive) {
+                const response = await apiClient.get('/theme');
+                const themes = response.data || [];
+
+                if (themes.length === 0) {
+                    showWarning(t('dev.no_themes'));
+                    return;
+                }
+
+                console.log();
+                const themeChoices = themes.map(theme => ({
+                    name: `${theme.name} ${chalk.gray(`v${theme.version}`)} ${theme.active ? chalk.green('(Aktif)') : ''}`,
+                    value: theme,
+                    description: theme.description || `Klasör: ${theme.theme_folder}`
+                }));
+
+                const selectedTheme = await brandedSelect({
+                    message: t('dev.select_theme_prompt'), choices: themeChoices
+                }, t('dev.select_theme_title'));
+
+                themeSlug = slugify(selectedTheme.name);
+                themeInfo = {
+                    uuid: selectedTheme.theme_folder, name: selectedTheme.name, version: selectedTheme.version
+                };
+
+                await setActiveTheme(themeSlug);
+                console.log();
+            } else {
+                themeInfo = tempThemeInfo;
+            }
+        }
+
+        if (!themeSlug) {
+            const apiClient = await createApiClient();
+            const response = await apiClient.get('/theme');
+            const themes = response.data || [];
+
+            if (themes.length === 0) {
+                showWarning(t('dev.no_themes'));
+                return;
+            }
+
+            const themeChoices = themes.map(theme => ({
+                name: `${theme.name} ${chalk.gray(`v${theme.version}`)}`, value: theme
+            }));
+
+            const selectedTheme = await brandedSelect({
+                message: t('dev.select_theme_prompt'), choices: themeChoices
+            }, t('dev.select_theme_title'));
+
+            themeSlug = slugify(selectedTheme.name);
+            themeInfo = {
+                uuid: selectedTheme.theme_folder, name: selectedTheme.name, version: selectedTheme.version
+            };
+
+            await setActiveTheme(themeSlug);
+        } else if (!themeInfo) {
+            themeInfo = await getThemeUuid(themeSlug);
+        }
+
+        console.log(chalk.green(t('dev.active_theme_set', { slug: themeSlug })));
+
+        let themePath = path.join(process.cwd(), storeSlug, themeSlug);
+        console.log(chalk.green(t('dev.working_dir', { path: `${storeSlug}/${themeSlug}/` }) + '\n'));
+
+        // Fork check: foreign-org themes need fork before development
+        {
+            const apiClient = await createApiClient();
+            const orgResponse = await apiClient.get('/theme');
+            const currentTheme = (orgResponse.data || []).find(t => t.theme_folder === themeInfo.uuid);
+            const userOrg = orgResponse.user_organization;
+
+            if (currentTheme && currentTheme.organization_id != null && userOrg && !userOrg.is_system && currentTheme.organization_id !== userOrg.id) {
+                const forkConfirm = await brandedConfirm({
+                    message: t('dev.fork_warning', {
+                        name: currentTheme.name,
+                        version: currentTheme.version,
+                        org_id: currentTheme.organization_id,
+                        user_org: userOrg.name
+                    }),
+                    default: true
+                }, t('dev.fork_warning_title'));
+
+                if (!forkConfirm) {
+                    showInfo(t('dev.fork_cancelled'));
+                    return;
+                }
+
+                console.log(chalk.yellow(t('dev.forking')));
+                const forkResult = await apiClient.forkTheme(themeInfo.uuid);
+                const forkedData = forkResult.data;
+
+                themeInfo = { uuid: forkedData.uuid, name: forkedData.name, version: forkedData.version };
+                themeSlug = slugify(forkedData.name);
+                themePath = path.join(process.cwd(), storeSlug, themeSlug);
+
+                console.log(chalk.green(t('dev.fork_success', { name: forkedData.name })));
+                console.log(chalk.gray('  ' + t('dev.fork_source', { source: forkedData.source.name, version: forkedData.source.version })));
+                console.log();
+
+                // Check if forked theme directory already exists
+                const forkedExists = await fs.access(themePath).then(() => true).catch(() => false);
+                if (forkedExists) {
+                    const overwrite = await brandedConfirm({
+                        message: t('dev.dir_exists_prompt', { path: themePath }),
+                        default: false
+                    }, t('dev.dir_exists_title'));
+
+                    if (!overwrite) {
+                        showWarning(t('dev.fork_cancelled'));
+                        return;
+                    }
+                    await fs.rm(themePath, { recursive: true, force: true });
+                }
+            }
+        }
+
+        const exists = await fs.access(themePath).then(() => true).catch(() => false);
+        if (!exists) {
+            showError(t('dev.theme_not_found', { path: themePath }));
+            return;
+        }
+
+        console.log(chalk.yellow(t('dev.checking_lock')));
+        const lockStatus = await checkLockStatus(themeInfo.uuid);
+
+        if (!lockStatus.locked) {
+            console.log(chalk.green(t('dev.not_locked') + '\n'));
+            console.log(chalk.yellow(t('dev.acquiring_lock')));
+            await acquireLock(themeInfo.uuid);
+            console.log(chalk.green(t('dev.lock_acquired') + '\n'));
+
+            await pullAndSync(themeInfo.uuid, themePath);
+
+        } else if (lockStatus.isCurrentDeveloper) {
+            if (lockStatus.developerSynced) {
+                console.log(chalk.green(t('dev.already_locked')));
+                console.log(chalk.green(t('dev.already_synced') + '\n'));
+            } else {
+                console.log(chalk.yellow(t('dev.not_synced') + '\n'));
+                await pullAndSync(themeInfo.uuid, themePath);
+            }
+        } else {
+            const lockMessage = t('dev.lock_by_other', {
+                dev: lockStatus.developerUsername,
+                last_access: lockStatus.developerLastAccessedAt
+            });
+
+            const override = await brandedConfirm({
+                message: lockMessage, default: false
+            }, t('dev.lock_warning_title'));
+
+            if (!override) {
+                showInfo(t('dev.fork_cancelled'));
+                return;
+            }
+
+            console.log(chalk.yellow('\n' + t('dev.lock_override')));
+            await acquireLock(themeInfo.uuid);
+            console.log(chalk.green(t('dev.lock_acquired') + '\n'));
+
+            await pullAndSync(themeInfo.uuid, themePath);
+        }
+
+        const watcher = await startFileWatcher(themeInfo.uuid, themePath);
+        const keepAliveInterval = startKeepAlive(themeInfo.uuid);
+        setupGracefulShutdown(watcher, keepAliveInterval);
+
+    } catch (error) {
+        console.error(chalk.red('\n❌ Hata: ') + error.message);
+        process.exit(1);
+    }
+}