@trendify/cli 0.1.6 → 0.1.8

package/dist/shared/services/cli-update.service.js

@@ -0,0 +1,206 @@
+import { readFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+const DEFAULT_PACKAGE_NAME = '@trendify/cli';
+const VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u;
+function getPackageManifestPath() {
+    return new URL('../package.json', import.meta.url);
+}
+function getNpmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+function toErrorMessage(error) {
+    if (error instanceof Error && error.message.trim()) {
+        return error.message;
+    }
+    return 'Nao foi possivel concluir a operacao.';
+}
+function readInstalledPackageMetadata() {
+    try {
+        const manifestContents = readFileSync(getPackageManifestPath(), 'utf8');
+        const manifest = JSON.parse(manifestContents);
+        const packageName = typeof manifest.name === 'string' && manifest.name.trim().length > 0
+            ? manifest.name.trim()
+            : DEFAULT_PACKAGE_NAME;
+        return { packageName };
+    }
+    catch {
+        return { packageName: DEFAULT_PACKAGE_NAME };
+    }
+}
+function parseVersion(version) {
+    const match = VERSION_PATTERN.exec(version.trim());
+    if (!match) {
+        return null;
+    }
+    const [, major, minor, patch, prerelease] = match;
+    if (!major || !minor || !patch) {
+        return null;
+    }
+    return {
+        major: Number.parseInt(major, 10),
+        minor: Number.parseInt(minor, 10),
+        patch: Number.parseInt(patch, 10),
+        prerelease: prerelease ?? null,
+    };
+}
+function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) {
+        return left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' });
+    }
+    if (parsedLeft.major !== parsedRight.major) {
+        return parsedLeft.major - parsedRight.major;
+    }
+    if (parsedLeft.minor !== parsedRight.minor) {
+        return parsedLeft.minor - parsedRight.minor;
+    }
+    if (parsedLeft.patch !== parsedRight.patch) {
+        return parsedLeft.patch - parsedRight.patch;
+    }
+    if (parsedLeft.prerelease === parsedRight.prerelease) {
+        return 0;
+    }
+    if (parsedLeft.prerelease === null) {
+        return 1;
+    }
+    if (parsedRight.prerelease === null) {
+        return -1;
+    }
+    return parsedLeft.prerelease.localeCompare(parsedRight.prerelease, undefined, {
+        numeric: true,
+        sensitivity: 'base',
+    });
+}
+function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve({
+                code: code ?? 1,
+                stderr,
+                stdout,
+            });
+        });
+    });
+}
+async function fetchLatestPublishedVersion(packageName) {
+    const commandResult = await runCommand(getNpmCommand(), ['view', packageName, 'version', '--json', '--silent']);
+    if (commandResult.code !== 0) {
+        const message = commandResult.stderr.trim() || commandResult.stdout.trim() || 'Falha ao consultar o npm.';
+        throw new Error(message);
+    }
+    const stdout = commandResult.stdout.trim();
+    if (!stdout) {
+        throw new Error('O npm nao retornou a versao publicada mais recente.');
+    }
+    try {
+        const parsedOutput = JSON.parse(stdout);
+        if (typeof parsedOutput === 'string' && parsedOutput.trim()) {
+            return parsedOutput.trim();
+        }
+    }
+    catch {
+        if (stdout) {
+            return stdout.replace(/^"+|"+$/gu, '').trim();
+        }
+    }
+    throw new Error('Nao foi possivel interpretar a versao publicada retornada pelo npm.');
+}
+async function runCommandWithInheritedStdio(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], {
+            env: process.env,
+            stdio: 'inherit',
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+async function restartCli() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        throw new Error('Nao foi possivel identificar o entrypoint atual da CLI para reiniciar o processo.');
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [...process.execArgv, entrypoint, ...process.argv.slice(2)], {
+            env: process.env,
+            stdio: 'inherit',
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('spawn', () => {
+            resolve();
+        });
+    });
+}
+export async function checkForCliUpdate(currentVersion) {
+    const { packageName } = readInstalledPackageMetadata();
+    try {
+        const latestVersion = await fetchLatestPublishedVersion(packageName);
+        if (compareVersions(latestVersion, currentVersion) > 0) {
+            return {
+                currentVersion,
+                latestVersion,
+                packageName,
+                status: 'available',
+            };
+        }
+        return {
+            currentVersion,
+            latestVersion,
+            packageName,
+            status: 'current',
+        };
+    }
+    catch (error) {
+        return {
+            currentVersion,
+            message: toErrorMessage(error),
+            packageName,
+            status: 'error',
+        };
+    }
+}
+export async function runCliSelfUpdate(packageName, latestVersion) {
+    try {
+        const exitCode = await runCommandWithInheritedStdio(getNpmCommand(), [
+            'install',
+            '--global',
+            `${packageName}@${latestVersion}`,
+        ]);
+        if (exitCode !== 0) {
+            return {
+                error: `O npm encerrou a atualizacao com codigo ${exitCode}.`,
+                ok: false,
+            };
+        }
+        await restartCli();
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            error: toErrorMessage(error),
+            ok: false,
+        };
+    }
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const APP_VERSION = "0.1.6";
+export declare const APP_VERSION = "0.1.8";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1 +1 @@
-export const APP_VERSION = '0.1.6';
+export const APP_VERSION = '0.1.8';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@trendify/cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "CLI do Trendify para descoberta de temas e fluxos de conta.",
   "type": "module",
-  "main": "dist/cli.js",
-  "types": "dist/cli.d.ts",
+  "main": "dist/cli.entry.js",
+  "types": "dist/cli.entry.d.ts",
   "bin": {
-    "trendify": "dist/cli.js"
+    "trendify": "dist/cli.entry.js"
   },
   "files": [
     "dist",