@magentrix-corp/magentrix-cli 1.0.0

package/actions/setup.js

@@ -0,0 +1,61 @@
+import { ensureApiKey } from "../utils/cli/helpers/ensureApiKey.js";
+import { ensureInstanceUrl } from "../utils/cli/helpers/ensureInstanceUrl.js";
+import Config from "../utils/config.js";
+import { getAccessToken, tryAuthenticate } from "../utils/magentrix/api/auth.js";
+import { ensureVSCodeFileAssociation } from "../utils/preferences.js";
+import { EXPORT_ROOT, HASHED_CWD } from "../vars/global.js";
+
+const config = new Config();
+
+/**
+ * Runs the global setup for the Magentrix CLI.
+ * 
+ * Prompts the user for their API key and instance URL if needed,
+ * validates credentials by attempting authentication,
+ * and saves them to the global config if successful.
+ * 
+ * @async
+ * @param {boolean} [forceNewData=false] - If true, always prompt for new data, even if values exist.
+ * @returns {Promise<{apiKey: string, instanceUrl: string}>} The saved API key and instance URL.
+ * @throws {Error} If authentication fails with provided credentials.
+ */
+export const setup = async () => {
+    // Prompt for API key and Instance URL if missing or if forceNewData is true
+    const apiKey = await ensureApiKey(true);
+    const instanceUrl = await ensureInstanceUrl(true);
+
+    // Validate credentials by attempting to fetch an access token
+    const tokenData = await tryAuthenticate(apiKey, instanceUrl);
+
+    console.log(); // Blank line for spacing
+
+    // Save values since authentication succeeded
+    config.save('instanceUrl', instanceUrl, { global: true, pathHash: HASHED_CWD });
+    console.log('✅ Instance URL saved securely!');
+
+    config.save('apiKey', apiKey, { global: true, pathHash: HASHED_CWD });
+    console.log('✅ API key saved securely!');
+
+    config.save(
+        'token',
+        { value: tokenData.token, validUntil: tokenData.validUntil },
+        { global: true, pathHash: HASHED_CWD }
+    );
+
+    // Set up the editor 
+    await ensureVSCodeFileAssociation('./');
+
+    console.log(); // Blank line for spacing
+
+    console.log('🎉 Setup complete.');
+
+    return {
+        apiKey,
+        instanceUrl,
+        token: {
+            value: tokenData.token,
+            validUntil: tokenData.validUntil
+        }
+    }
+
+};

package/actions/status.js

@@ -0,0 +1,17 @@
+import { showCurrentConflicts } from "../utils/cli/helpers/compare.js";
+import { ensureValidCredentials } from "../utils/cli/helpers/ensureCredentials.js";
+import { withSpinner } from "../utils/spinner.js";
+import { EXPORT_ROOT } from "../vars/global.js";
+
+export const status = async () => {
+    // Clear the terminal
+    process.stdout.write('\x1Bc');
+    
+    const credentials = await withSpinner('Authenticating...', async () => {
+        return await ensureValidCredentials();
+    });
+
+    console.log();
+
+    await showCurrentConflicts(EXPORT_ROOT, credentials.instanceUrl, credentials.token.value, true)
+};

package/bin/magentrix.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+// Imports
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { VERSION } from '../vars/config.js';
+import { setup } from '../actions/setup.js';
+import { main } from '../actions/main.js';
+import { pull } from '../actions/pull.js';
+import { create } from '../actions/create.js';
+import { autoPublish } from '../actions/autopublish.js';
+import { status } from '../actions/status.js';
+import { cacheDir, recacheFileIdIndex } from '../utils/cacher.js';
+import { EXPORT_ROOT } from '../vars/global.js';
+import { publish } from '../actions/publish.js';
+
+// ── Middleware ────────────────────────────────
+async function preMiddleware() {
+    await recacheFileIdIndex(EXPORT_ROOT);
+    await cacheDir(EXPORT_ROOT);
+}
+async function postMiddleware() {
+    await cacheDir(EXPORT_ROOT);
+}
+
+const withMiddleware = ({ pre, post }) => (fn) => async (...args) => {
+    if (pre) await pre(...args);
+    await fn(...args);
+    if (post) await post(...args);
+};
+
+// ── CLI Setup ────────────────────────────────
+const program = new Command();
+program
+    .name('magentrix')
+    .description('Manage Magentrix assets and automation')
+    .version(VERSION)
+    .configureHelp({
+        formatHelp: (cmd, helper) => {
+            const divider = chalk.gray('━'.repeat(60));
+            const titleBar = chalk.bold.bgBlue.white(' Magentrix CLI ');
+            const version = chalk.dim(`v${VERSION}`);
+
+            let help = `\n${divider}\n${titleBar} ${version}\n${divider}\n\n`;
+            help += `${chalk.dim('Manage Magentrix assets and automation')}\n\n`;
+
+            // Usage section
+            help += `${chalk.bold.yellow('USAGE')}\n`;
+            help += `  ${chalk.cyan('magentrix')} ${chalk.dim('<command> [options]')}\n\n`;
+
+            // Commands section
+            help += `${chalk.bold.yellow('COMMANDS')}\n`;
+            const commands = [
+                { name: 'setup', desc: 'Configure your Magentrix API key', icon: '⚙️  ' },
+                { name: 'pull', desc: 'Pull files from the remote server', icon: '📥 ' },
+                { name: 'create', desc: 'Create files locally', icon: '✨ ' },
+                { name: 'status', desc: 'Show file conflicts and sync status', icon: '📊 ' },
+                { name: 'publish', desc: 'Publish pending changes to the remote server', icon: '📤 ' },
+                { name: 'autopublish', desc: 'Watch & sync changes in real time', icon: '🔄 ' }
+            ];
+
+            const maxNameLen = Math.max(...commands.map(c => c.name.length));
+            commands.forEach(cmd => {
+                const padding = ' '.repeat(maxNameLen - cmd.name.length);
+                help += `  ${cmd.icon}${chalk.cyan.bold(cmd.name)}${padding}  ${chalk.dim(cmd.desc)}\n`;
+            });
+
+            help += `\n${chalk.bold.yellow('OPTIONS')}\n`;
+            help += `  ${chalk.cyan('-V, --version')}  ${chalk.dim('Output the version number')}\n`;
+            help += `  ${chalk.cyan('-h, --help')}     ${chalk.dim('Display this help message')}\n`;
+
+            help += `\n${chalk.bold.yellow('EXAMPLES')}\n`;
+            help += `  ${chalk.dim('# Initial setup')}\n`;
+            help += `  ${chalk.cyan('magentrix setup')}\n\n`;
+            help += `  ${chalk.dim('# Pull remote files')}\n`;
+            help += `  ${chalk.cyan('magentrix pull')}\n\n`;
+            help += `  ${chalk.dim('# Auto-sync on file changes')}\n`;
+            help += `  ${chalk.cyan('magentrix autopublish')}\n`;
+
+            help += `\n${divider}\n`;
+
+            return help;
+        }
+    });
+
+const withDefault = withMiddleware({ pre: preMiddleware, post: postMiddleware });
+
+// ── Error Handlers ───────────────────────────
+program.showHelpAfterError(false);
+program.configureOutput({
+    outputError: (str, write) => {
+        // Custom error message for unknown options
+        if (str.includes('unknown option')) {
+            const match = str.match(/'([^']+)'/);
+            const option = match ? match[1] : str;
+
+            console.error(`\n${chalk.bgRed.white.bold(' ERROR ')} ${chalk.redBright('Unknown option:')} ${chalk.bold(option)}`);
+            console.error(`${chalk.yellow('💡 Tip:')} Run ${chalk.cyan('magentrix --help')} to see available options.\n`);
+        }
+        // Custom error message for unknown commands
+        else if (str.includes('unknown command')) {
+            const match = str.match(/'([^']+)'/);
+            const command = match ? match[1] : str;
+
+            console.error(`\n${chalk.bgRed.white.bold(' ERROR ')} ${chalk.redBright('Unknown command:')} ${chalk.bold(command)}`);
+            console.error(`${chalk.yellow('💡 Tip:')} Run ${chalk.cyan('magentrix --help')} to see available commands.\n`);
+        }
+        // Generic errors
+        else {
+            console.error(`\n${chalk.bgRed.white.bold(' ERROR ')} ${chalk.redBright(str.trim())}\n`);
+        }
+    }
+});
+
+// ── Commands ─────────────────────────────────
+program.command('setup').description('Configure your Magentrix API key').action(withDefault(setup));
+program.command('pull').description('Pull files from the remote server').action(withDefault(pull));
+program.command('create').description('Create files locally').action(withDefault(create));
+program.command('status').description('Show file conflicts').action(withDefault(status));
+program.command('autopublish').description('Watch & sync changes in real time').action(withDefault(autoPublish));
+program.command('publish').description('Publish pending changes to the remote server').action(withDefault(publish));
+
+// ── Unknown Command Handler ──────────────────
+program.argument('[command]', 'command to run').action((cmd) => {
+    const runMain = async () => {
+        await preMiddleware();
+        await main();
+        await postMiddleware();
+    };
+
+    if (cmd) {
+        console.log(`\n${chalk.bgRed.white.bold(' ERROR ')} ${chalk.redBright(`Unknown command:`)} ${chalk.bold(cmd)}\n`);
+        console.log(`${chalk.yellow('💡  Tip:')} Run ${chalk.cyan('magentrix --help')} to view available commands.\n`);
+        process.exit(1);
+    } else {
+        runMain().catch(handleFatal);
+    }
+});
+
+// ── Global Error Handler ─────────────────────
+function handleFatal(err) {
+    const divider = chalk.gray('──────────────────────────────────────────────');
+    const header = `${chalk.bgRed.white.bold(' FATAL ERROR ')}`;
+
+    console.error(`\n${divider}\n${header}`);
+    console.error(`${chalk.redBright(err?.message || 'An unexpected error occurred.')}\n`);
+
+    if (process.env.DEBUG === 'true' && err?.stack) {
+        console.error(chalk.dim(err.stack));
+        console.error();
+    } else {
+        console.log(`${chalk.yellow('💡  Run with')} ${chalk.cyan('DEBUG=true')} ${chalk.yellow('for full details.')}`);
+    }
+
+    console.log(divider + '\n');
+    process.exit(1);
+}
+
+program.parseAsync(process.argv).catch(handleFatal);

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@magentrix-corp/magentrix-cli",
+  "version": "1.0.0",
+  "description": "CLI tool for synchronizing local files with Magentrix cloud platform",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "magentrix": "./bin/magentrix.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "magentrix",
+    "cli",
+    "sync",
+    "cloud",
+    "automation",
+    "development-tools"
+  ],
+  "author": "Magentrix Corporation",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mangoz1x/MagentrixCLI.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Mangoz1x/MagentrixCLI/issues"
+  },
+  "homepage": "https://github.com/Mangoz1x/MagentrixCLI#readme",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "actions/",
+    "utils/",
+    "vars/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^7.6.0",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^14.0.0",
+    "diff": "^8.0.2",
+    "extract-zip": "^2.0.1",
+    "fuzzy": "^0.1.3",
+    "inquirer": "^12.7.0",
+    "node-diff3": "^3.1.2",
+    "ora": "^8.2.0",
+    "pako": "^2.1.0",
+    "prompts": "^2.4.2",
+    "readline-sync": "^1.4.10",
+    "uuid": "^11.1.0"
+  }
+}

package/utils/cacher.js

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import Config from './config.js';
+import { findFileByTag, getFileTag, isPathLinkedToTagByLastKnownPath, setFileTag } from './filetag.js';
+import { compressString } from './compress.js';
+import { sha256 } from './hash.js';
+import { EXPORT_ROOT } from '../vars/global.js';
+
+const config = new Config();
+
+/**
+ * Recursively caches all files in a directory with tagging and content snapshotting
+ * @param {string} dir - Directory to cache
+ * @returns {Promise<void>}
+ */
+export const cacheDir = async (dir) => {
+    if (!fs.existsSync(dir)) return;
+
+    const absDir = path.resolve(dir);
+    const files = await walkFiles(absDir);
+
+    const cache = config.read('cachedFiles', { global: false, filename: 'fileCache.json' }) || {};
+
+    for (const file of files) {
+        const stats = fs.statSync(file);
+        if (!stats.isFile()) continue;
+
+        const checkFileTag = async (retry = true) => {
+            // Check file tag
+            const tag = await getFileTag(file);
+
+            if (!tag) {
+                // Try to repair if there is a tag linked to that path
+                const dirLinkedTag = isPathLinkedToTagByLastKnownPath(file);
+                if (dirLinkedTag && retry) {
+                    await setFileTag(file, dirLinkedTag);
+                    return await checkFileTag(false);
+                }
+                return null;
+            }
+
+            return tag;
+        }
+
+        const tag = await checkFileTag();
+        if (!tag) {
+            // There may not be a tag if the user manually created a file
+            // console.warn(`Warning: failed to tag file: ${file}`);
+            continue;
+        }
+
+        const content = fs.readFileSync(file, 'utf8');
+        const objectId = tag; // Use the tag so we don't get duplicates
+
+        cache[objectId] = {
+            tag,
+            lastKnownPath: file,
+            contentHash: sha256(content),
+            compressedContent: compressString(content),
+            size: stats.size,
+            mtimeMs: stats.mtimeMs,
+            dev: stats.dev,
+            ino: stats.ino
+        };
+    }
+
+    config.save('cachedFiles', cache, { global: false, filename: 'fileCache.json' });
+};
+
+export const recacheFileIdIndex = async (dir) => {
+    const files = await walkFiles(dir);
+    if (!files || files?.length < 1) return;
+    
+    for (const file of files) {
+        const tag = await getFileTag(file);
+        if (!tag) continue;
+        
+        // Update the index id cache
+        const lastKnownPath = findFileByTag(tag);
+        if (lastKnownPath !== file) {
+            await setFileTag(file, tag);
+        }
+    }
+}
+
+/**
+ * Recursively walks a directory and returns all file paths
+ * @param {string} dir
+ * @returns {Promise<string[]>}
+ */
+export async function walkFiles(dir, settings) {
+    const ignore = settings?.ignore || [];
+
+    if (!fs.existsSync(dir)) return;
+    let entries = fs.readdirSync(dir, { withFileTypes: true });
+    let paths = [];
+
+    for (const entry of entries) {
+        if (ignore.find(p => entry.path.startsWith(p) || entry.path === p)) {
+            continue;
+        }
+
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            paths.push(...await walkFiles(fullPath, settings));
+        } else if (entry.isFile()) {
+            paths.push(fullPath);
+        }
+    }
+
+    return paths;
+}

package/utils/cli/checkInstanceUrl.js

@@ -0,0 +1,29 @@
+/**
+ * Checks if the provided Magentrix instance URL is reachable by making a GET request.
+ * Throws an error if the response status is not 200 (OK), or if there is a network error.
+ *
+ * @async
+ * @param {string} instanceUrl - The https://subdomain.magentrixcloud.com URL to check.
+ * @throws {Error} Throws if the instance is unreachable or does not return 200 OK.
+ * @returns {Promise<void>} Resolves if the instance is reachable (status 200); otherwise throws.
+ */
+export const checkInstanceUrl = async (instanceUrl) => {
+    try {
+        // Native fetch is available in Node 18+; for older versions, use node-fetch.
+        const response = await fetch(instanceUrl, {
+            method: "GET",
+            // You can add a small timeout here using AbortController if needed.
+        });
+
+        if (response.status !== 200) {
+            throw new Error(
+                `Instance URL responded with status ${response.status} (${response.statusText}). Expected 200 OK.`
+            );
+        }
+    } catch (err) {
+        // Wrap and re-throw to provide a clear error message.
+        throw new Error(
+            `Failed to reach instance URL "${instanceUrl}": ${err.message || err}`
+        );
+    }
+};