spectrum-cli 3.2.0 → 5.0.0

package/src/chart/metadata.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const { execSync } = require('child_process');
+const { SEMVER_PATTERN } = require('../preflight');
+const CHARTS_DIR = 'charts';
+
+function getChartFiles() {
+    try {
+        if (!fs.existsSync(CHARTS_DIR)) {
+            return [];
+        }
+
+        const entries = fs.readdirSync(CHARTS_DIR, { withFileTypes: true });
+        const chartFiles = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => `${CHARTS_DIR}/${entry.name}/Chart.yaml`)
+            .filter((chartFilePath) => fs.existsSync(chartFilePath));
+
+        return chartFiles;
+    } catch (error) {
+        return [];
+    }
+}
+
+function getChartName(chartFilePath) {
+    try {
+        if (!chartFilePath || !fs.existsSync(chartFilePath)) {
+            return null;
+        }
+
+        const chartYaml = fs.readFileSync(chartFilePath, 'utf8');
+        const nameMatch = chartYaml.match(/^\s*name:\s*([^\s#]+)\s*$/m);
+        return nameMatch ? nameMatch[1] : null;
+    } catch (error) {
+        return null;
+    }
+}
+
+function isSemver(version) {
+    return SEMVER_PATTERN.test(version);
+}
+
+function compareSemver(a, b) {
+    const parse = (value) => {
+        const [rawMain, rawMeta] = String(value || '').split('+', 2);
+        const [rawVersion, rawPre] = rawMain.split('-', 2);
+        const versionParts = rawVersion.split('.').map((part) => Number(part));
+        const preParts = rawPre ? rawPre.split('.') : [];
+        return { versionParts, preParts, hasPre: Boolean(rawPre), meta: rawMeta || '' };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+
+    for (let i = 0; i < 3; i += 1) {
+        const diff = (pa.versionParts[i] || 0) - (pb.versionParts[i] || 0);
+        if (diff !== 0) return diff;
+    }
+
+    if (pa.hasPre && !pb.hasPre) return -1;
+    if (!pa.hasPre && pb.hasPre) return 1;
+    if (!pa.hasPre && !pb.hasPre) return 0;
+
+    const len = Math.max(pa.preParts.length, pb.preParts.length);
+    for (let i = 0; i < len; i += 1) {
+        const aa = pa.preParts[i];
+        const bb = pb.preParts[i];
+        if (aa === undefined) return -1;
+        if (bb === undefined) return 1;
+        const aNum = /^\d+$/.test(aa);
+        const bNum = /^\d+$/.test(bb);
+        if (aNum && bNum) {
+            const diff = Number(aa) - Number(bb);
+            if (diff !== 0) return diff;
+            continue;
+        }
+        if (aNum && !bNum) return -1;
+        if (!aNum && bNum) return 1;
+        if (aa < bb) return -1;
+        if (aa > bb) return 1;
+    }
+
+    return 0;
+}
+
+function getLatestRemoteChartVersion(chartName) {
+    const safeChartName = String(chartName || '').trim();
+    if (!safeChartName) return null;
+
+    const prefix = `chart-${safeChartName}-`;
+    let output = '';
+    try {
+        output = execSync(`git ls-remote --tags origin "refs/tags/${prefix}*"`, { stdio: 'pipe', encoding: 'utf8' });
+    } catch (error) {
+        return null;
+    }
+
+    const versions = String(output || '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.split(/\s+/)[1] || '')
+        .map((ref) => ref.replace('refs/tags/', ''))
+        .filter((tag) => tag.startsWith(prefix))
+        .map((tag) => tag.slice(prefix.length))
+        .filter((version) => isSemver(version));
+
+    if (versions.length === 0) {
+        return null;
+    }
+
+    versions.sort(compareSemver);
+    return versions[versions.length - 1];
+}
+
+module.exports = { getChartFiles, getChartName, isSemver, compareSemver, getLatestRemoteChartVersion };

package/src/chart/registry.js

@@ -0,0 +1,139 @@
+const { logSuccess, logError, getRemoteUrl } = require('../common/utils');
+const { parseGitlabUrl } = require('../integrations/gitlab-url');
+const HELM_REGISTRY_CHANNEL = 'stable';
+const REGISTRY_WAIT_TIMEOUT_MS = 10 * 60 * 1000;
+const REGISTRY_WAIT_INTERVAL_MS = 15 * 1000;
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getGitlabProject() {
+    const baseUrl = getRemoteUrl();
+    if (!baseUrl) {
+        return null;
+    }
+    try {
+        return parseGitlabUrl(baseUrl);
+    } catch (error) {
+        return null;
+    }
+}
+
+function helmIndexHasChartVersion(indexYamlContent, chartName, version) {
+    const escapedChartName = String(chartName || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const chartHeadingPattern = new RegExp(`^${escapedChartName}:\\s*(#.*)?$`);
+    const lines = String(indexYamlContent || '').split('\n');
+    let inEntries = false;
+    let inChart = false;
+    let entriesIndent = 0;
+    let chartIndent = 0;
+
+    for (const rawLine of lines) {
+        const line = rawLine.replace(/\r$/, '');
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+
+        const indent = line.match(/^\s*/)[0].length;
+
+        if (/^entries:\s*(#.*)?$/.test(trimmed) && indent === 0) {
+            inEntries = true;
+            inChart = false;
+            entriesIndent = indent;
+            continue;
+        }
+
+        if (inEntries && indent <= entriesIndent) {
+            inEntries = false;
+            inChart = false;
+        }
+
+        if (!inEntries) {
+            continue;
+        }
+
+        if (chartHeadingPattern.test(trimmed)) {
+            inChart = true;
+            chartIndent = indent;
+            continue;
+        }
+
+        if (inChart && indent <= chartIndent) {
+            inChart = false;
+        }
+
+        if (!inChart) {
+            continue;
+        }
+
+        const versionMatch = trimmed.match(/^-?\s*version:\s*["']?([^"'\s#]+)["']?\s*(#.*)?$/);
+        if (versionMatch && versionMatch[1] === String(version)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+async function fetchChartVersionFromRegistry(chartName, version) {
+    const project = getGitlabProject();
+    if (!project) {
+        return { ok: false, reason: 'Не удалось определить GitLab-проект из remote "origin".' };
+    }
+
+    const accessToken = process.env.GITLAB_PRIVATE_TOKEN;
+    if (!accessToken) {
+        return {
+            ok: false,
+            reason: 'Не задана переменная окружения GITLAB_PRIVATE_TOKEN. Она нужна для проверки публикации чарта в Helm-registry.'
+        };
+    }
+
+    const indexUrl = `${project.origin}/api/v4/projects/${project.encodedPath}/packages/helm/${HELM_REGISTRY_CHANNEL}/index.yaml`;
+    let response;
+    try {
+        response = await fetch(indexUrl, { headers: { 'PRIVATE-TOKEN': accessToken } });
+    } catch (error) {
+        return { ok: false, reason: `Не удалось запросить Helm-registry (${indexUrl}): ${error.message}.` };
+    }
+
+    if (!response.ok) {
+        return { ok: false, reason: `Helm-registry вернул HTTP ${response.status} (${indexUrl}).` };
+    }
+
+    const indexYaml = await response.text();
+    return {
+        ok: true,
+        found: helmIndexHasChartVersion(indexYaml, chartName, version),
+        indexUrl
+    };
+}
+
+async function waitForChartInRegistry(chartName, version, options = {}) {
+    const timeoutMs = options.timeoutMs === undefined ? REGISTRY_WAIT_TIMEOUT_MS : options.timeoutMs;
+    const intervalMs = options.intervalMs === undefined ? REGISTRY_WAIT_INTERVAL_MS : options.intervalMs;
+    const sleepFn = options.sleep || sleep;
+    const deadline = Date.now() + timeoutMs;
+
+    while (true) {
+        const result = await fetchChartVersionFromRegistry(chartName, version);
+        if (!result.ok) {
+            logError('❌', '%s', result.reason);
+            return false;
+        }
+        if (result.found) {
+            logSuccess('📦', 'Версия %s чарта %s опубликована в Helm-registry.', version, chartName);
+            return true;
+        }
+        if (Date.now() >= deadline) {
+            logError('❌', 'Версия %s чарта %s не появилась в Helm-registry за отведенное время.', version, chartName);
+            return false;
+        }
+        logSuccess('⏳', 'Версия %s чарта %s еще не опубликована, продолжаю ожидание...', version, chartName);
+        await sleepFn(intervalMs);
+    }
+}
+
+module.exports = { helmIndexHasChartVersion, fetchChartVersionFromRegistry, waitForChartInRegistry };

package/src/chart/routes.js

@@ -0,0 +1,244 @@
+const fs = require('fs');
+const path = require('path');
+function normalizeList(list) {
+    const result = [];
+    const seen = new Set();
+    for (const item of (Array.isArray(list) ? list : [])) {
+        const value = String(item || '').trim();
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+
+function ensureEndsWithDollar(value) {
+    const text = String(value || '').trim();
+    if (!text) {
+        return '';
+    }
+    return text.endsWith('$') ? text : `${text}$`;
+}
+
+function normalizeToBeList(list) {
+    return normalizeList(list.map(ensureEndsWithDollar));
+}
+
+function segmentToPattern(segment) {
+    if (segment === 'index') {
+        return '';
+    }
+    if (/^\[\[\.\.\..+\]\]$/.test(segment)) {
+        return '.*';
+    }
+    if (/^\[\.\.\..+\]$/.test(segment)) {
+        return '.+';
+    }
+    if (/^\[.+\]$/.test(segment)) {
+        return '[^/]+';
+    }
+    return segment;
+}
+
+function toRouteFromFileSegments(segments) {
+    const transformed = segments.map(segmentToPattern).filter(Boolean);
+    const route = `/${transformed.join('/')}`.replace(/\/+/g, '/');
+    return route === '' ? '/' : route;
+}
+
+function parseApiRouteFromAppFile(filePath) {
+    const rel = filePath.replace(/\\/g, '/').replace(/^app\/api\//, '').replace(/(^|\/)route\.[^.]+$/, '');
+    if (!rel) {
+        return '/api';
+    }
+    return `/api/${toRouteFromFileSegments(rel.split('/')).replace(/^\//, '')}`.replace(/\/+$/, '');
+}
+
+function parseApiRouteFromPagesFile(filePath) {
+    const rel = filePath.replace(/\\/g, '/').replace(/^pages\/api\//, '').replace(/\.[^.]+$/, '');
+    const route = toRouteFromFileSegments(rel.split('/'));
+    return `/api${route === '/' ? '' : route}`.replace(/\/+$/, '') || '/api';
+}
+
+function parsePageRouteFromPagesFile(filePath) {
+    const rel = filePath.replace(/\\/g, '/').replace(/^pages\//, '').replace(/\.[^.]+$/, '');
+    const chunks = rel.split('/').filter(Boolean);
+    const first = chunks[0] || '';
+    const excludedFiles = new Set(['_app', '_document', '_error', '404', '500']);
+    if (first === 'api' || excludedFiles.has(first)) {
+        return null;
+    }
+    return toRouteFromFileSegments(chunks);
+}
+
+function parsePageRouteFromAppFile(filePath) {
+    const rel = filePath.replace(/\\/g, '/').replace(/^app\//, '').replace(/(^|\/)page\.[^.]+$/, '');
+    if (rel.startsWith('api/')) {
+        return null;
+    }
+    if (!rel) {
+        return '/';
+    }
+    const chunks = rel
+        .split('/')
+        .filter(Boolean)
+        .filter((part) => !/^\(.+\)$/.test(part) && !part.startsWith('@'));
+    return toRouteFromFileSegments(chunks);
+}
+
+function collectFilesRecursively(dirPath, matcher) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+
+    const stack = [dirPath];
+    const found = [];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        } catch (error) {
+            return found;
+        }
+
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && matcher(fullPath)) {
+                found.push(fullPath);
+            }
+        }
+    }
+    return found;
+}
+
+function collectRoutesFromFilesystem(sourcePath) {
+    const api = [];
+    const pages = [];
+    const appDirCandidates = [path.join(sourcePath, 'app'), path.join(sourcePath, 'src', 'app')];
+    const pagesDirCandidates = [path.join(sourcePath, 'pages'), path.join(sourcePath, 'src', 'pages')];
+
+    for (const appDir of appDirCandidates) {
+        const appApiFiles = collectFilesRecursively(
+            path.join(appDir, 'api'),
+            (file) => /[\\/]route\.(js|jsx|ts|tsx|mjs|cjs)$/.test(file)
+        );
+        for (const absFile of appApiFiles) {
+            const rel = path.relative(path.join(appDir, 'api'), absFile).replace(/\\/g, '/');
+            api.push(parseApiRouteFromAppFile(`app/api/${rel}`));
+        }
+
+        const appPageFiles = collectFilesRecursively(appDir, (file) => /[\\/]page\.(js|jsx|ts|tsx|mdx)$/.test(file));
+        for (const absFile of appPageFiles) {
+            const rel = path.relative(appDir, absFile).replace(/\\/g, '/');
+            const route = parsePageRouteFromAppFile(`app/${rel}`);
+            if (route) {
+                pages.push(route);
+            }
+        }
+    }
+
+    for (const pagesDir of pagesDirCandidates) {
+        const pagesApiFiles = collectFilesRecursively(path.join(pagesDir, 'api'), (file) => /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(file));
+        for (const absFile of pagesApiFiles) {
+            const rel = path.relative(path.join(pagesDir, 'api'), absFile).replace(/\\/g, '/');
+            api.push(parseApiRouteFromPagesFile(`pages/api/${rel}`));
+        }
+
+        const pagesFiles = collectFilesRecursively(pagesDir, (file) => /\.(js|jsx|ts|tsx|mdx)$/.test(file));
+        for (const absFile of pagesFiles) {
+            const rel = path.relative(pagesDir, absFile).replace(/\\/g, '/');
+            const route = parsePageRouteFromPagesFile(`pages/${rel}`);
+            if (route) {
+                pages.push(route);
+            }
+        }
+    }
+
+    return {
+        api: normalizeList(api),
+        pages: normalizeList(pages)
+    };
+}
+
+function readJsonIfExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (error) {
+        return null;
+    }
+}
+
+function collectRoutesFromBuildArtifacts(sourcePath) {
+    const api = [];
+    const pages = [];
+
+    const routesManifest = readJsonIfExists(path.join(sourcePath, '.next', 'routes-manifest.json'));
+    if (routesManifest) {
+        const combined = []
+            .concat(routesManifest.staticRoutes || [])
+            .concat(routesManifest.dynamicRoutes || [])
+            .concat(routesManifest.dataRoutes || []);
+        for (const routeInfo of combined) {
+            const route = routeInfo.page || routeInfo.pathname || routeInfo.route;
+            if (!route || typeof route !== 'string') {
+                continue;
+            }
+            if (route.startsWith('/api')) {
+                api.push(route);
+            } else {
+                pages.push(route);
+            }
+        }
+    }
+
+    const appRoutesManifest = readJsonIfExists(path.join(sourcePath, '.next', 'server', 'app-path-routes-manifest.json'))
+        || readJsonIfExists(path.join(sourcePath, '.next', 'server', 'app-paths-manifest.json'))
+        || readJsonIfExists(path.join(sourcePath, '.next', 'app-path-routes-manifest.json'));
+    if (appRoutesManifest && typeof appRoutesManifest === 'object') {
+        Object.entries(appRoutesManifest).forEach(([key, routeValue]) => {
+            const route = typeof routeValue === 'string' ? routeValue : key;
+            if (typeof route !== 'string') {
+                return;
+            }
+            if (route.startsWith('/_')) {
+                return;
+            }
+            if (route.startsWith('/api')) {
+                api.push(route);
+            } else {
+                pages.push(route);
+            }
+        });
+    }
+
+    const pagesManifest = readJsonIfExists(path.join(sourcePath, '.next', 'server', 'pages-manifest.json'));
+    if (pagesManifest && typeof pagesManifest === 'object') {
+        Object.keys(pagesManifest).forEach((route) => {
+            if (route === '/_app' || route === '/_document' || route === '/_error' || route === '/404' || route === '/500') {
+                return;
+            }
+            if (route.startsWith('/api')) {
+                api.push(route);
+            } else {
+                pages.push(route);
+            }
+        });
+    }
+
+    return {
+        api: normalizeList(api),
+        pages: normalizeList(pages)
+    };
+}
+
+module.exports = { normalizeList, normalizeToBeList, collectRoutesFromFilesystem, collectRoutesFromBuildArtifacts };

package/src/chart/start.js

@@ -0,0 +1,98 @@
+const path = require('path');
+const { logSuccess, logError, execCommand } = require('../common/utils');
+const { runCommand } = require('../cli/command-executor');
+const { requireGitRepo, requireCleanWorkingTree, requireOnMainBranch, requireCurrentBranchUpToDateWithRemote, requireSingleChart, requireTagMissing, requireChartChangelogVersion } = require('../preflight');
+const { getLatestRemoteChartVersion, compareSemver } = require('./metadata');
+const { fetchChartVersionFromRegistry, waitForChartInRegistry } = require('./registry');
+function chartStart(options = {}) {
+    const force = Boolean(options.force);
+    const wait = options.wait !== false;
+
+    return runCommand({
+        name: 'chart start',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'clean-working-tree', run: requireCleanWorkingTree },
+            { name: 'on-main-branch', run: requireOnMainBranch },
+            { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
+            { name: 'single-chart', run: requireSingleChart },
+            {
+                name: 'chart-changelog-version',
+                requires: ['chartFilePath'],
+                run: (ctx) => requireChartChangelogVersion(path.dirname(ctx.chartFilePath))
+            },
+            {
+                name: 'tag-missing',
+                requires: ['chartName', 'version'],
+                run: (ctx) => requireTagMissing(`chart-${ctx.chartName}-${ctx.version}`)
+            },
+            {
+                name: 'version-not-downgrade',
+                requires: ['chartName', 'version'],
+                run: (ctx) => {
+                    const latestVersion = getLatestRemoteChartVersion(ctx.chartName);
+                    if (!latestVersion) {
+                        return { ok: true };
+                    }
+                    if (compareSemver(ctx.version, latestVersion) > 0) {
+                        return { ok: true, data: { latestChartVersion: latestVersion } };
+                    }
+                    if (force) {
+                        logError('⚠️', 'Версия %s не больше последней версии тега %s. Продолжаю из-за --force.', ctx.version, latestVersion);
+                        return { ok: true, data: { latestChartVersion: latestVersion } };
+                    }
+                    return {
+                        ok: false,
+                        reason: `Версия "${ctx.version}" не больше последней версии тега "${latestVersion}" на origin. Для сознательного отката используйте --force.`
+                    };
+                }
+            },
+            {
+                name: 'registry-version-missing',
+                requires: ['chartName', 'version'],
+                run: async (ctx) => {
+                    const result = await fetchChartVersionFromRegistry(ctx.chartName, ctx.version);
+                    if (!result.ok) return { ok: false, reason: result.reason };
+                    if (result.found) {
+                        return { ok: false, reason: `Версия ${ctx.version} чарта ${ctx.chartName} уже опубликована в Helm-registry.` };
+                    }
+                    return { ok: true };
+                }
+            }
+        ],
+        steps: [
+            {
+                name: 'create-tag',
+                run: (ctx) => {
+                    const tagName = `chart-${ctx.chartName}-${ctx.version}`;
+                    if (!execCommand(`git tag "${tagName}"`)) {
+                        logError('❌', 'Не удалось создать тег %s.', tagName);
+                        return false;
+                    }
+                    logSuccess('🔖', 'Создан тег %s.', tagName);
+                    return true;
+                }
+            },
+            {
+                name: 'push-tag',
+                run: (ctx) => {
+                    const tagName = `chart-${ctx.chartName}-${ctx.version}`;
+                    if (!execCommand(`git push origin "${tagName}"`)) {
+                        logError('❌', 'Не удалось отправить тег %s в origin.', tagName);
+                        return false;
+                    }
+                    logSuccess('🚀', 'Тег %s отправлен в origin.', tagName);
+                    return true;
+                }
+            },
+            ...(wait
+                ? [{
+                    name: 'wait-for-registry',
+                    run: (ctx) => waitForChartInRegistry(ctx.chartName, ctx.version)
+                }]
+                : [])
+        ]
+    });
+}
+
+module.exports = { chartStart };