tsoft-cli 2.6.15 → 3.4.0

package/src/storage.js

@@ -0,0 +1,488 @@
+import fs from 'fs/promises';
+import path from 'path';
+import axios from 'axios';
+import * as config from './config.js';
+
+/**
+ * Store domain'i dizin adına uygun formata çevirir
+ * @param {string} domain - Store domain (örn: birtan.1isim.com)
+ * @returns {string} Normalized slug (örn: birtan-1isim-com)
+ */
+export function normalizeStoreDomain(domain) {
+    return domain.replace(/\./g, '-').toLowerCase();
+}
+
+/**
+ * Store'a özel config dizinini döner (CWD bazlı)
+ * @param {string} store - Store domain
+ * @returns {string} Config dizin path'i
+ */
+export function getStoreConfigDir(store) {
+    const storeSlug = normalizeStoreDomain(store);
+    return path.join(process.cwd(), '.tsoft', storeSlug);
+}
+
+/**
+ * Store'a özel config dosya path'ini döner
+ * @param {string} store - Store domain
+ * @returns {string} Config dosya path'i
+ */
+export function getStoreConfigFile(store) {
+    return path.join(getStoreConfigDir(store), 'config.json');
+}
+
+/**
+ * Store'a özel .env dosya path'ini döner
+ * @param {string} store - Store domain
+ * @returns {string} .env dosya path'i
+ */
+export function getStoreEnvFile(store) {
+    return path.join(getStoreConfigDir(store), '.env');
+}
+
+/**
+ * Aktif store'u ayarlar
+ * @param {string} store - Store domain
+ * @returns {Promise<void>}
+ */
+export async function setActiveStore(store) {
+    const activeStoreFile = path.join(process.cwd(), '.tsoft', 'active-store.txt');
+    await fs.mkdir(path.dirname(activeStoreFile), { recursive: true });
+    await fs.writeFile(activeStoreFile, store, 'utf-8');
+}
+
+/**
+ * Aktif store'u okur
+ * @returns {Promise<string|null>} Store domain veya null
+ */
+export async function getActiveStore() {
+    try {
+        const activeStoreFile = path.join(process.cwd(), '.tsoft', 'active-store.txt');
+        return (await fs.readFile(activeStoreFile, 'utf-8')).trim();
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+
+/**
+ * Authorization code'u access token'a çevirir
+ * @param {string} code - Authorization code
+ * @param {string} codeVerifier - PKCE code verifier
+ * @param {string} store - Store domain (callback'ten dönen store parametresi)
+ * @param {string} state - State (CSRF protection)
+ * @returns {Promise<object>} Token bilgileri
+ */
+export async function exchangeToken(code, codeVerifier, store, state) {
+    const tokenUrl = config.getTokenUrl(store);
+
+    try {
+        // Laravel Passport application/x-www-form-urlencoded formatında bekler
+        const params = new URLSearchParams();
+        params.append('grant_type', 'authorization_code');
+        params.append('client_id', config.CLIENT_ID);
+        params.append('redirect_uri', config.REDIRECT_URI);
+        params.append('code', code);
+        params.append('code_verifier', codeVerifier);
+        params.append('state', state);
+
+        const response = await axios.post(tokenUrl, params, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+            },
+        });
+
+        // Backend response: { status, message, data: { token, user } }
+        const responseData = response.data.data;
+
+        return {
+            accessToken: responseData.token.accessToken,
+            accessTokenExpiresAt: responseData.token.accessTokenExpiresAt,
+            refreshToken: responseData.token.refreshToken,
+            refreshTokenExpiresAt: responseData.token.refreshTokenExpiresAt,
+            tokenType: 'Bearer',
+            user: responseData.user,
+            store: store,
+        };
+    } catch (error) {
+        if (error.response?.data) {
+            console.error('Token exchange hatası:', error.response.data);
+        }
+        if (error.response) {
+            throw new Error(
+                `Token exchange hatası: ${error.response.status} - ${
+                    error.response.data.error_description ||
+                    error.response.data.message ||
+                    'Bilinmeyen hata'
+                }`
+            );
+        }
+        throw new Error(`Token exchange hatası: ${error.message}`);
+    }
+}
+
+/**
+ * Refresh token ile yeni access token alır
+ * @param {string} refreshToken - Refresh token
+ * @param {string} store - Store domain
+ * @returns {Promise<object>} Yeni token bilgileri
+ */
+export async function refreshAccessToken(refreshToken, store) {
+    const refreshUrl = config.getRefreshUrl(store);
+
+    try {
+        // Laravel Passport application/x-www-form-urlencoded formatında bekler
+        const params = new URLSearchParams();
+        params.append('grant_type', 'refresh_token');
+        params.append('refresh_token', refreshToken);
+        params.append('client_id', config.CLIENT_ID);
+
+        const response = await axios.post(refreshUrl, params, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+            },
+        });
+
+        // Backend response: { status, message, data: { token, user } }
+        const responseData = response.data.data;
+
+        return {
+            accessToken: responseData.token.accessToken,
+            accessTokenExpiresAt: responseData.token.accessTokenExpiresAt,
+            refreshToken: responseData.token.refreshToken,
+            refreshTokenExpiresAt: responseData.token.refreshTokenExpiresAt,
+            tokenType: 'Bearer',
+            user: responseData.user,
+        };
+    } catch (error) {
+        if (error.response?.data) {
+            console.error('Token refresh hatası:', error.response.data);
+        }
+        if (error.response) {
+            throw new Error(
+                `Token refresh hatası: ${error.response.status} - ${
+                    error.response.data.error_description ||
+                    error.response.data.message ||
+                    'Bilinmeyen hata'
+                }`
+            );
+        }
+        throw new Error(`Token refresh hatası: ${error.message}`);
+    }
+}
+
+/**
+ * Token'ı revoke eder
+ * @param {string} token - Access veya refresh token
+ * @param {string} store - Store domain
+ * @returns {Promise<void>}
+ */
+export async function revokeToken(token, store) {
+    const revokeUrl = config.getRevokeUrl(store);
+
+    try {
+        // Laravel Passport application/x-www-form-urlencoded formatında bekler
+        const params = new URLSearchParams();
+        params.append('token', token);
+        params.append('client_id', config.CLIENT_ID);
+
+        await axios.post(revokeUrl, params, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+            },
+        });
+    } catch (error) {
+        // Revoke hatalarını sessizce yoksay (token zaten geçersiz olabilir)
+        console.warn('Token revoke uyarısı:', error.message);
+    }
+}
+
+/**
+ * .env dosyası oluşturur
+ * @param {object} tokens - Token ve user bilgileri
+ * @param {string} store - Store domain
+ * @returns {Promise<void>}
+ */
+async function writeEnvFile(tokens, store) {
+    const envContent = `# tsoft CLI - Auto-generated credentials
+# Store: ${store}
+# Generated: ${new Date().toISOString()}
+
+TSOFT_ACCESS_TOKEN="${tokens.accessToken}"
+TSOFT_REFRESH_TOKEN="${tokens.refreshToken}"
+TSOFT_USER_ID=${tokens.user.id}
+TSOFT_USER_NAME="${tokens.user.name}"
+TSOFT_USER_SURNAME="${tokens.user.surname}"
+TSOFT_USER_EMAIL="${tokens.user.email}"
+TSOFT_STORE_DOMAIN="${store}"
+TSOFT_USER_VERSION="${tokens.user.version}"
+`;
+
+    const envFile = getStoreEnvFile(store);
+    await fs.writeFile(envFile, envContent, 'utf-8');
+    await fs.chmod(envFile, 0o600); // rw-------
+}
+
+/**
+ * Token'ları local config dosyasına kaydeder
+ * @param {object} tokens - Token bilgileri
+ * @param {string} store - Store domain
+ * @returns {Promise<void>}
+ */
+export async function saveTokens(tokens, store) {
+    const configDir = getStoreConfigDir(store);
+    await fs.mkdir(configDir, { recursive: true });
+
+    const configData = {
+        accessToken: tokens.accessToken,
+        accessTokenExpiresAt: tokens.accessTokenExpiresAt,
+        refreshToken: tokens.refreshToken,
+        refreshTokenExpiresAt: tokens.refreshTokenExpiresAt,
+        tokenType: tokens.tokenType,
+        store: store,
+        user: {
+            id: tokens.user.id,
+            name: tokens.user.name,
+            surname: tokens.user.surname,
+            email: tokens.user.email,
+            hasTwoFactor: tokens.user.hasTwoFactor,
+            hasRestrictedAccess: tokens.user.hasRestrictedAccess,
+            version: tokens.user.version,
+        },
+        updatedAt: new Date().toISOString(),
+    };
+
+    const configFile = getStoreConfigFile(store);
+    await fs.writeFile(configFile, JSON.stringify(configData, null, 2), 'utf-8');
+    await fs.chmod(configFile, 0o600);
+
+    // .env dosyasını da oluştur
+    await writeEnvFile(tokens, store);
+
+    // Aktif store'u ayarla
+    await setActiveStore(store);
+}
+
+/**
+ * Local config dosyasından token'ları yükler
+ * @param {string} [store] - Store domain (opsiyonel, belirtilmezse active store kullanılır)
+ * @returns {Promise<object|null>} Token bilgileri veya null
+ */
+export async function loadTokens(store = null) {
+    if (!store) {
+        store = await getActiveStore();
+        if (!store) {
+            return null; // Aktif store yok
+        }
+    }
+
+    try {
+        const configFile = getStoreConfigFile(store);
+        const data = await fs.readFile(configFile, 'utf-8');
+        return JSON.parse(data);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return null; // Dosya yok
+        }
+        throw error;
+    }
+}
+
+/**
+ * Token'ların geçerliliğini kontrol eder
+ * @param {object} tokens - Token bilgileri
+ * @returns {boolean} Token geçerli mi?
+ */
+export function isTokenValid(tokens) {
+    if (!tokens || !tokens.accessToken || !tokens.accessTokenExpiresAt) {
+        return false;
+    }
+
+    const expiresAt = new Date(tokens.accessTokenExpiresAt);
+    const now = new Date();
+
+    // 5 dakika önce expire olacaksa yenile
+    const bufferTime = 5 * 60 * 1000; // 5 dakika
+    return expiresAt.getTime() - now.getTime() > bufferTime;
+}
+
+/**
+ * Refresh token'ın geçerliliğini kontrol eder
+ * @param {object} tokens - Token bilgileri
+ * @returns {boolean} Refresh token geçerli mi?
+ */
+export function isRefreshTokenValid(tokens) {
+    if (!tokens || !tokens.refreshToken || !tokens.refreshTokenExpiresAt) {
+        return false;
+    }
+
+    const expiresAt = new Date(tokens.refreshTokenExpiresAt);
+    const now = new Date();
+
+    return expiresAt.getTime() > now.getTime();
+}
+
+/**
+ * Access token geçerliliğini kontrol eder, gerekirse refresh eder
+ * @param {object} tokens - Token bilgileri
+ * @returns {Promise<object>} Güncel token bilgileri
+ * @throws {Error} RELOGIN_REQUIRED - Refresh token da expire olduysa
+ */
+export async function ensureValidToken(tokens) {
+    if (!tokens) {
+        throw new Error('RELOGIN_REQUIRED');
+    }
+
+    // Access token geçerliyse direkt dön
+    if (isTokenValid(tokens)) {
+        return tokens;
+    }
+
+    // Refresh token geçerliyse refresh et
+    if (isRefreshTokenValid(tokens)) {
+        const newTokens = await refreshAccessToken(tokens.refreshToken, tokens.store);
+        await saveTokens(newTokens, tokens.store);
+        return await loadTokens(tokens.store);
+    }
+
+    // Her ikisi de geçersizse, otomatik re-login gerekiyor
+    throw new Error('RELOGIN_REQUIRED');
+}
+
+/**
+ * Store'un config dosyalarını siler (logout için)
+ * @param {string} [store] - Store domain (opsiyonel, belirtilmezse active store kullanılır)
+ * @returns {Promise<void>}
+ */
+export async function deleteConfig(store = null) {
+    if (!store) {
+        store = await getActiveStore();
+        if (!store) {
+            return; // Aktif store yok, bir şey yapma
+        }
+    }
+
+    try {
+        const configDir = getStoreConfigDir(store);
+        await fs.rm(configDir, { recursive: true, force: true });
+
+        // Active store dosyasını da sil
+        const activeStoreFile = path.join(process.cwd(), '.tsoft', 'active-store.txt');
+        await fs.unlink(activeStoreFile).catch(() => {}); // Hata varsa sessizce yoksay
+    } catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+
+/**
+ * Token'ın ne kadar süre geçerli olduğunu döner
+ * @param {object} tokens - Token bilgileri
+ * @returns {string} Kalan süre (human-readable)
+ */
+export function getTokenExpiry(tokens) {
+    if (!tokens || !tokens.accessTokenExpiresAt) {
+        return 'Bilinmiyor';
+    }
+
+    const expiresAt = new Date(tokens.accessTokenExpiresAt);
+    const now = new Date();
+    const diff = expiresAt.getTime() - now.getTime();
+
+    if (diff <= 0) {
+        return 'Süresi dolmuş';
+    }
+
+    const hours = Math.floor(diff / (1000 * 60 * 60));
+    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+
+    if (hours > 0) {
+        return `${hours} saat ${minutes} dakika`;
+    }
+    return `${minutes} dakika`;
+}
+
+/**
+ * Türkçe karakterleri URL dostu hale getirir
+ * @param {string} text - Dönüştürülecek metin
+ * @returns {string} Sluglaştırılmış metin
+ */
+export function slugify(text) {
+    const trMap = {
+        'ç': 'c', 'Ç': 'c',
+        'ğ': 'g', 'Ğ': 'g',
+        'ı': 'i', 'İ': 'i',
+        'ö': 'o', 'Ö': 'o',
+        'ş': 's', 'Ş': 's',
+        'ü': 'u', 'Ü': 'u',
+    };
+
+    return text
+        .split('')
+        .map(char => trMap[char] || char)
+        .join('')
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Aktif temayı ayarlar
+ * @param {string} theme - Tema adı
+ * @returns {Promise<void>}
+ */
+export async function setActiveTheme(theme) {
+    const activeThemeFile = path.join(process.cwd(), '.tsoft', 'active-theme.txt');
+    await fs.mkdir(path.dirname(activeThemeFile), { recursive: true });
+    await fs.writeFile(activeThemeFile, theme, 'utf-8');
+}
+
+/**
+ * Aktif temayı okur
+ * @returns {Promise<string|null>} Tema adı veya null
+ */
+export async function getActiveTheme() {
+    try {
+        const activeThemeFile = path.join(process.cwd(), '.tsoft', 'active-theme.txt');
+        return (await fs.readFile(activeThemeFile, 'utf-8')).trim();
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+
+/**
+ * Tema slug'ından UUID/folder adını bulur
+ * @param {string} themeSlug - Tema slug (örn: 'my-theme')
+ * @returns {Promise<Object>} {uuid, name, version, active}
+ */
+export async function getThemeUuidBySlug(themeSlug) {
+    const { createApiClient } = await import('./api-client.js');
+    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,
+        active: theme.active
+    };
+}
+

package/src/ui/help-renderer.js

@@ -0,0 +1,219 @@
+import chalk from 'chalk';
+import { createRequire } from 'module';
+import { TSOFT_COLORS, createTSoftGradient } from './prompt-wrapper.js';
+import { humanOut, isJsonMode, jsonOut } from '../output-mode.js';
+import { t } from '../i18n.js';
+import { loadTokens, getActiveStore, getActiveTheme } from '../storage.js';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Read version from package.json
+ */
+function getVersion() {
+    try {
+        const pkg = require('../../package.json');
+        return pkg.version || '0.0.0';
+    } catch {
+        return '0.0.0';
+    }
+}
+
+/**
+ * Hardcoded ASCII art for "TSOFT" — compact 5-line design
+ */
+const TSOFT_ASCII_ART = `
+ ████████╗███████╗ ██████╗ ███████╗████████╗
+    ██╔══╝██╔════╝██╔═══██╗██╔════╝╚══██╔══╝
+    ██║   ███████╗██║   ██║█████╗     ██║
+    ██║   ╚════██║██║   ██║██╔══╝     ██║
+    ██║   ███████║╚██████╔╝██║        ██║
+    ╚═╝   ╚══════╝ ╚═════╝ ╚═╝        ╚═╝
+`.trim();
+
+/**
+ * Command groups definition — maps group key to command entries.
+ * Each entry has a nameKey (locale) and command path for display.
+ */
+const COMMAND_GROUPS = [
+    {
+        groupKey: 'help.group.development',
+        commands: [
+            { display: 'theme dev',          descKey: 'help.cmd.theme_dev' },
+            { display: 'theme push',         descKey: 'help.cmd.theme_push' },
+            { display: 'theme section list', descKey: 'help.cmd.theme_section_list' },
+            { display: 'theme section add',  descKey: 'help.cmd.theme_section_add' },
+        ]
+    },
+    {
+        groupKey: 'help.group.theme_management',
+        commands: [
+            { display: 'theme list',   descKey: 'help.cmd.theme_list' },
+            { display: 'theme create', descKey: 'help.cmd.theme_create' },
+            { display: 'theme pull',   descKey: 'help.cmd.theme_pull' },
+            { display: 'theme use',    descKey: 'help.cmd.theme_use' },
+            { display: 'theme init',   descKey: 'help.cmd.theme_init' },
+        ]
+    },
+    {
+        groupKey: 'help.group.account',
+        commands: [
+            { display: 'login',      descKey: 'help.cmd.login' },
+            { display: 'logout',     descKey: 'help.cmd.logout' },
+            { display: 'whoami',     descKey: 'help.cmd.whoami' },
+            { display: 'org switch', descKey: 'help.cmd.org_switch' },
+        ]
+    }
+];
+
+/**
+ * Compute the max display name length across all command groups
+ * for consistent column alignment.
+ */
+function computeMaxNameWidth() {
+    let max = 0;
+    for (const group of COMMAND_GROUPS) {
+        for (const cmd of group.commands) {
+            if (cmd.display.length > max) max = cmd.display.length;
+        }
+    }
+    return max;
+}
+
+/**
+ * Render a single command group block.
+ * @param {object} group
+ * @param {number} maxWidth - max command name width for column alignment
+ * @returns {string[]} lines
+ */
+function renderGroup(group, maxWidth) {
+    const lines = [];
+    const groupName = t(group.groupKey);
+    lines.push('  ' + chalk.bold.white(groupName));
+    lines.push('');
+    for (const cmd of group.commands) {
+        const padding = ' '.repeat(maxWidth - cmd.display.length + 2);
+        const namePart = chalk.hex(TSOFT_COLORS.primary)('tsoft ' + cmd.display);
+        const descPart = chalk.dim(t(cmd.descKey));
+        lines.push('    ' + namePart + padding + descPart);
+    }
+    return lines;
+}
+
+/**
+ * Read contextual status data (logged-in user, store, active theme).
+ * Returns all nulls gracefully on any error.
+ * @returns {Promise<{store: string|null, tokens: object|null, activeTheme: string|null}>}
+ */
+async function loadStatusData() {
+    try {
+        const store = await getActiveStore();
+        const tokens = store ? await loadTokens(store) : null;
+        const activeTheme = await getActiveTheme();
+        return { store, tokens, activeTheme };
+    } catch {
+        return { store: null, tokens: null, activeTheme: null };
+    }
+}
+
+/**
+ * Build status block lines from context data.
+ * @param {{store: string|null, tokens: object|null, activeTheme: string|null}} status
+ * @returns {string[]} lines to print
+ */
+function buildStatusLines(status) {
+    const { store, tokens, activeTheme } = status;
+    const lines = [];
+    const orangeBullet = chalk.hex(TSOFT_COLORS.primary)('●');
+
+    // User line
+    if (tokens?.user?.email) {
+        const userText = t('help.status.logged_in', { email: tokens.user.email, store: store || '' });
+        lines.push('  ' + orangeBullet + ' ' + userText);
+    } else {
+        lines.push('  ' + chalk.dim('○ ' + t('help.status.not_logged_in')));
+    }
+
+    // Organization line — only shown when available
+    const orgName = tokens?.user?.organizationName;
+    if (orgName) {
+        lines.push('  ' + orangeBullet + ' ' + orgName);
+    }
+
+    // Theme line
+    if (activeTheme) {
+        const themeText = t('help.status.active_theme', { theme: activeTheme });
+        lines.push('  ' + orangeBullet + ' ' + themeText);
+    } else {
+        lines.push('  ' + chalk.dim('○ ' + t('help.status.no_theme')));
+    }
+
+    return lines;
+}
+
+/**
+ * Render the branded help to stdout.
+ * Wraps all human-readable output in humanOut().
+ * In JSON mode, outputs structured data instead.
+ *
+ * @param {import('commander').Command} _program — kept for future use / extensibility
+ */
+export async function renderBrandedHelp(_program) {
+    const status = await loadStatusData();
+
+    if (isJsonMode()) {
+        const groups = COMMAND_GROUPS.map(g => ({
+            group: t(g.groupKey),
+            commands: g.commands.map(c => ({
+                command: 'tsoft ' + c.display,
+                description: t(c.descKey)
+            }))
+        }));
+
+        const commands = groups.flatMap(g => g.commands);
+        jsonOut({
+            user: status.tokens?.user || null,
+            store: status.store,
+            activeTheme: status.activeTheme,
+            commands,
+            groups,
+        });
+        return;
+    }
+
+    humanOut(() => {
+        const version = getVersion();
+        const maxWidth = computeMaxNameWidth();
+
+        // Header — ASCII art with orange gradient
+        console.log('');
+        console.log(createTSoftGradient(TSOFT_ASCII_ART));
+        console.log('');
+
+        // Tagline + version
+        const tagline = chalk.dim(t('help.tagline'));
+        const versionBadge = chalk.dim('v' + version);
+        console.log('  ' + tagline + '  ' + versionBadge);
+
+        // Contextual status block
+        console.log('');
+        const statusLines = buildStatusLines(status);
+        for (const line of statusLines) {
+            console.log(line);
+        }
+        console.log('');
+
+        // Command groups
+        for (const group of COMMAND_GROUPS) {
+            const groupLines = renderGroup(group, maxWidth);
+            for (const line of groupLines) {
+                console.log(line);
+            }
+            console.log('');
+        }
+
+        // Footer hint
+        console.log('  ' + chalk.dim(t('help.footer')));
+        console.log('');
+    });
+}