neutrinos-cli 1.0.0

package/commands/new-workspace.js

@@ -0,0 +1,142 @@
+import { bold } from 'colorette';
+import { execSync } from 'node:child_process';
+// prettier-ignore
+import { cpSync,mkdirSync,readFileSync,rmSync,writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { exit } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { done, failed, inprogress } from '../utils/logger.js';
+// prettier-ignore
+import { pluginJsonPath,pluginServerTemplatesPath } from '../utils/path-utils.js';
+import { prettify } from '../utils/prettify.js';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+export const createWorkspace = async (dir, name) => {
+    process.on('SIGINT', () => {
+        cleanUp(dir);
+        exit(0);
+    });
+    process.on('SIGTERM', () => {
+        cleanUp(dir);
+        exit(0);
+    });
+    try {
+        createWorkspaceDirectory(dir);
+    } catch (err) {
+        handleWorkspaceDirectoryCreationError(err, dir);
+    }
+    try {
+        initializeNpmProject(dir);
+        copyProjectTemplate(dir);
+        await createPluginJson(dir, name);
+        await initializePackages(dir);
+        await createReadme(dir, name);
+        initializeGit(dir);
+        initializeStaticServer(dir);
+        done(`Plugin Workspace created successfully: ${bold(dir)}`);
+    } catch (err) {
+        handleWorkspaceCreationError(err, dir);
+    }
+};
+
+const createWorkspaceDirectory = (dir) => {
+    mkdirSync(dir);
+    done(`Created workspace directory: ${bold(dir)}`);
+};
+
+const initializeNpmProject = (dir) => {
+    execSync(`npm init -y`, {
+        cwd: dir,
+    });
+    done(`Initialized npm project in workspace`);
+};
+
+const copyProjectTemplate = (dir) => {
+    cpSync(join(__dirname, '../templates/project'), dir, {
+        recursive: true,
+    });
+};
+
+const createPluginJson = async (dir, name) => {
+    writeFileSync(
+        pluginJsonPath(dir),
+        await prettify(
+            {
+                name,
+                components: { selectorPrefix: 'comp' },
+                modules: { idPrefix: 'mod' },
+            },
+            'json',
+        ),
+    );
+    done(`Created plugin.json in workspace`);
+};
+
+const createReadme = async (dir, name) => {
+    writeFileSync(
+        join(dir, 'README.md'),
+        await prettify(`# ${name}\n\nThis is a new workspace for creating plugins for studio`, 'markdown'),
+    );
+    done(`Created README.md in workspace`);
+};
+
+const initializeGit = (dir) => {
+    writeFileSync(join(dir, '.gitignore'), ['node_modules', 'dist', 'build', 'coverage'].join('\n'));
+    execSync(`git init`, {
+        cwd: dir,
+    });
+    done(`Initialized git in workspace`);
+};
+
+const cleanUp = (dir) => {
+    inprogress('Cleaning up...');
+    rmSync(dir, { recursive: true });
+    done('Cleaned up workspace');
+};
+
+const initializePackages = async (dir) => {
+    inprogress(`Adding default npm scripts to workspace...`);
+    const pkgJson = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+    const scripts = {
+        build: 'alpha build',
+        start: 'alpha start',
+        serve: 'alpha serve',
+    };
+    pkgJson.devDependencies = {
+        lit: '^3.1.4',
+        typescript: '^5.2.2',
+    };
+    pkgJson.dependencies = {
+        express: '^4.19.2',
+        '@jatahworx/alpha-annotations-lib': '^1.0.9',
+    };
+
+    pkgJson.workspaces = ['packages/*'];
+    pkgJson.type = 'module';
+    Object.assign(pkgJson.scripts, {}, scripts);
+    writeFileSync(join(dir, 'package.json'), await prettify(pkgJson, 'json'));
+    execSync(`npm install`, {
+        cwd: dir,
+    });
+    done(`Installed default packages in workspace: ${bold(dir)}`);
+    done(`Added default npm scripts to workspace: ${bold(dir)}`);
+};
+
+const initializeStaticServer = (dir) => {
+    cpSync(pluginServerTemplatesPath(), join(dir, 'plugins-server'), {
+        recursive: true,
+    });
+    done(`Initialized static server in workspace`);
+};
+
+const handleWorkspaceDirectoryCreationError = (err, dir) => {
+    failed(`Failed to create workspace directory: ${bold(dir)}`, err);
+    exit(1);
+};
+
+const handleWorkspaceCreationError = (err, dir) => {
+    failed(`Failed to create workspace: ${bold(dir)}`, err);
+    cleanUp(dir);
+    return;
+};

package/commands/publish.js

@@ -0,0 +1,334 @@
+//@ts-check
+import AdmZip from 'adm-zip';
+import FormData from 'form-data';
+import { remove } from 'fs-extra';
+import { execSync } from 'node:child_process';
+import { createReadStream, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { copyIconToAsset, copyImagesToAsset, getPackageIcon, getPackageImages } from '../utils/copy-utils.js';
+import { getPackageMetadata } from '../utils/get-package-info.js';
+import { inquiry, multipleInquiry } from '../utils/inquirer-utils.js';
+import { done, failed, inprogress } from '../utils/logger.js';
+import { publishToMarketplace } from '../utils/marketplace-api-utils.js';
+import { getLoggedInUserSession } from '../utils/user-seesion-utils.js';
+
+const DISPLAY_NAME_QUERY = {
+    type: 'input',
+    name: 'name',
+    message: 'Enter the Display Name of the package :',
+};
+const ICON_FILE_PATH_QUERY = {
+    type: 'input',
+    name: 'value',
+    message: 'Enter the path to the icon of the package :',
+};
+const IMAGES_FILE_PATH_QUERY = {
+    type: 'input',
+    name: 'value',
+    message: 'Enter the path to images of the package :',
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {string} wsPath
+ * @param {any} options
+ */
+export const publish = async (name, wsPath, options) => {
+    const session = await getLoggedInUserSession();
+    const { packageName, componentDirPath } = await getPackageMetadata(wsPath, name);
+    await handlePackagePublish(packageName, componentDirPath, wsPath, options, session);
+    done('Published Successfully');
+};
+
+/**
+ *
+ * @param {string} packageName
+ * @param {string} componentDirPath
+ * @param {string} wsPath
+ * @param {any} options
+ * @param {any} session
+ */
+const handlePackagePublish = async (packageName, componentDirPath, wsPath, options, session) => {
+    const pkgJsonPath = join(componentDirPath, 'package.json');
+    let pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    if (!pkgJson.alpha) {
+        throw new Error('It is not an alpha package');
+    }
+    if (pkgJson.alpha.deprecated) {
+        throw new Error('This is a deprecated package');
+    }
+    if (pkgJson.alpha.packageId) {
+        await publishPackageVersion(packageName, wsPath, pkgJson, options, componentDirPath, pkgJsonPath, session);
+    } else {
+        await publishNewPackage(packageName, wsPath, pkgJson, options, componentDirPath, pkgJsonPath, session);
+    }
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {string} wsPath
+ * @param {any} pkgJson
+ * @param {any} options
+ * @param {string} componentDirPath
+ * @param {string} pkgJsonPath
+ * @param {any} session
+ */
+const publishPackageVersion = async (name, wsPath, pkgJson, options, componentDirPath, pkgJsonPath, session) => {
+    await incrementPackageVersion(wsPath, pkgJson.name, options);
+    pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+
+    const iconForPkg = options.icon || (await getIconPath(componentDirPath));
+    const imagesForPkg = options.images?.length
+        ? JSON.stringify(options.images)
+        : JSON.stringify(await getImagesPath(componentDirPath));
+
+    const publishArgs = createVersionPublishArgs(name, pkgJson, iconForPkg, imagesForPkg);
+    inprogress('Publishing...');
+    const { version } = await uploadPackageFiles(
+        wsPath,
+        componentDirPath,
+        publishArgs,
+        pkgJson.alpha.packageId,
+        session,
+    );
+    if (version.version_id) {
+        updatePackageJson(pkgJsonPath, pkgJson, pkgJson.alpha.packageId, version.version_id);
+    }
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {string} wsPath
+ * @param {any} pkgJson
+ * @param {any} options
+ * @param {string} componentDirPath
+ * @param {string} pkgJsonPath
+ * @param {any} session
+ */
+const publishNewPackage = async (name, wsPath, pkgJson, options, componentDirPath, pkgJsonPath, session) => {
+    const displayName = options.displayName || (await inquiry(DISPLAY_NAME_QUERY)).name || name;
+    const iconForPkg = options.icon || (await getIconPath(componentDirPath));
+    const imagesForPkg = options.images?.length ? options.images : await getImagesPath(componentDirPath);
+
+    const publishArgs = createNewPackagePublishArgs(name, pkgJson, displayName, iconForPkg, imagesForPkg);
+    inprogress('Publishing...');
+    const response = await uploadPackageFiles(wsPath, componentDirPath, publishArgs, '', session);
+    if (response.package) {
+        updatePackageJson(
+            pkgJsonPath,
+            pkgJson,
+            response.package.package_id,
+            response.package.latest_version.version_id,
+        );
+    }
+};
+
+/**
+ *
+ * @param {string} componentDirPath
+ * @returns
+ */
+const getIconPath = async (componentDirPath) => {
+    const icon = getPackageIcon(componentDirPath);
+    return icon || (await inquiry(ICON_FILE_PATH_QUERY)).value;
+};
+
+/**
+ *
+ * @param {string} componentDirPath
+ * @returns
+ */
+const getImagesPath = async (componentDirPath) => {
+    const images = getPackageImages(componentDirPath);
+    if (images.length) {
+        return images;
+    }
+    const imagesAns = await multipleInquiry(IMAGES_FILE_PATH_QUERY);
+    return imagesAns.map((img) => img.value);
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {any} pkgJson
+ * @param {string} iconForPkg
+ * @param {string} imagesForPkg
+ * @returns
+ */
+const createVersionPublishArgs = (name, pkgJson, iconForPkg, imagesForPkg) => ({
+    name,
+    version_number: pkgJson.version,
+    metadata: JSON.stringify({
+        platform: 'alpha',
+        type: pkgJson.alpha.component ? 'component' : 'module',
+    }),
+    icon_file_path: iconForPkg,
+    image_file_path: imagesForPkg,
+});
+
+/**
+ *
+ * @param {string} name
+ * @param {any} pkgJson
+ * @param {string} displayName
+ * @param {string} iconForPkg
+ * @param {string[]} imagesForPkg
+ * @returns
+ */
+const createNewPackagePublishArgs = (name, pkgJson, displayName, iconForPkg, imagesForPkg) => ({
+    package_metadata: JSON.stringify({
+        platform: 'alpha',
+        type: pkgJson.alpha.component ? 'component' : 'module',
+    }),
+    display_name: displayName,
+    name,
+    version_number: pkgJson.version,
+    package_type: 'zip',
+    version_metadata: JSON.stringify({
+        platform: 'alpha',
+        type: pkgJson.alpha.component ? 'component' : 'module',
+    }),
+    description: pkgJson.description || 'Package published by CLI',
+    icon_file_path: iconForPkg,
+    image_file_path: JSON.stringify(imagesForPkg),
+});
+
+/**
+ *
+ * @param {string} wsPath
+ * @param {string} pkgName
+ * @param {any} options
+ */
+const incrementPackageVersion = async (wsPath, pkgName, options) => {
+    if (!pkgName) throw new Error('Package name is required');
+    const versionType =
+        options.versionType ||
+        (
+            await inquiry({
+                type: 'list',
+                name: 'type',
+                choices: ['patch', 'minor', 'major'],
+                message: 'Choose the Version type :',
+            })
+        ).type;
+    execSync(`npm version ${versionType} -w ${pkgName}`, {
+        cwd: wsPath,
+        stdio: 'inherit',
+    });
+};
+
+/**
+ *
+ * @param {string} wsPath
+ * @param {string} componentDirPath
+ * @param {any} publishArgs
+ * @param {string} path
+ * @param {any} session
+ * @returns
+ */
+const uploadPackageFiles = async (wsPath, componentDirPath, publishArgs, path = '', session) => {
+    const form = createFormData(publishArgs, componentDirPath);
+
+    const zipFile = await createZipFile(wsPath, componentDirPath, publishArgs.name);
+    form.append('zip_file', zipFile);
+
+    return publishToMarketplace(form, path, session, false);
+};
+
+/**
+ *
+ * @param {any} publishArgs
+ * @param {string} componentDirPath
+ * @returns
+ */
+const createFormData = (publishArgs, componentDirPath) => {
+    const form = new FormData();
+    for (let key in publishArgs) {
+        form.append(key, publishArgs[key]);
+    }
+
+    appendIconToForm(form, publishArgs.icon_file_path, componentDirPath);
+    appendImagesToForm(form, JSON.parse(publishArgs.image_file_path), componentDirPath);
+
+    return form;
+};
+
+/**
+ *
+ * @param {FormData} form
+ * @param {string} iconPath
+ * @param {string} componentDirPath
+ */
+const appendIconToForm = (form, iconPath, componentDirPath) => {
+    if (existsSync(iconPath)) {
+        copyIconToAsset(iconPath, componentDirPath);
+        form.append('icon', createReadStream(iconPath));
+    } else {
+        failed("Invalid icon path or icon doesn't exist");
+    }
+};
+
+/**
+ *
+ * @param {FormData} form
+ * @param {string[]} imagesPaths
+ * @param {string} componentDirPath
+ */
+const appendImagesToForm = (form, imagesPaths, componentDirPath) => {
+    //@ts-ignore
+    imagesPaths.forEach((imgPath) => {
+        if (existsSync(imgPath)) {
+            copyImagesToAsset(imgPath, componentDirPath);
+            form.append('images', createReadStream(imgPath));
+        } else {
+            failed("Invalid images path or image doesn't exist");
+        }
+    });
+};
+
+/**
+ *
+ * @param {string} wsPath
+ * @param {string} componentDirPath
+ * @param {string} packageName
+ * @returns
+ */
+const createZipFile = async (wsPath, componentDirPath, packageName) => {
+    const componentDistPath = join(componentDirPath, 'dist');
+    execSync(`npm run build plugins ${packageName}`, {
+        cwd: wsPath,
+        stdio: 'inherit',
+    });
+
+    //@ts-ignore
+    const zip = new AdmZip();
+    zip.addLocalFolder(componentDistPath);
+    const zipBuffer = zip.toBuffer();
+
+    const zipFilePath = join(componentDistPath, `${packageName.toLowerCase()}.zip`);
+    writeFileSync(zipFilePath, zipBuffer);
+
+    const readStream = createReadStream(zipFilePath);
+    readStream.on('close', () =>
+        remove(zipFilePath, (err) => {
+            if (err) console.error('Error deleting file:', err);
+        }),
+    );
+
+    return readStream;
+};
+
+/**
+ *
+ * @param {string} pkgJsonPath
+ * @param {any} pkgJson
+ * @param {string} packageId
+ * @param {string} versionId
+ */
+const updatePackageJson = (pkgJsonPath, pkgJson, packageId, versionId) => {
+    Object.assign(pkgJson.alpha, { packageId, versionId });
+    writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+};

package/commands/select-packages.mjs

@@ -0,0 +1,36 @@
+//@ts-check
+import checkbox from '@inquirer/checkbox';
+import { existsSync, globSync, readFileSync } from 'node:fs';
+import { basename, join, sep } from 'node:path';
+
+export const selectPackages = async (dirname, all = false, pluginName) => {
+    /**@type {string[]} */
+    const packagesDir = JSON.parse(readFileSync(join(dirname, 'package.json'), 'utf-8')).workspaces;
+    const packageNames = globSync(packagesDir, { cwd: join(dirname) });
+    const packages = packageNames
+        .map((name) => join(dirname, name))
+        .filter((p) => {
+            return existsSync(join(p, 'package.json'));
+        });
+    if (pluginName) {
+        const pluginPath = packages.filter((p) => basename(p) === pluginName);
+        return pluginPath;
+    }
+    if (all) {
+        return packages;
+    }
+    const selectedPackages = await checkbox({
+        message: 'Select the packages',
+        instructions: ' [NOTE: Press <space> to toggle selection, <return> to submit]',
+        choices: packages.map((p) => {
+            return {
+                name: p.split(sep).pop(),
+                value: p,
+                // checked: true,
+            };
+        }),
+        required: true,
+        pageSize: 10,
+    });
+    return selectedPackages;
+};

package/commands/serve.js

@@ -0,0 +1,27 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { platform } from 'node:process';
+import { failed } from '../utils/logger.js';
+import { pluginServerRoot } from '../utils/path-utils.js';
+
+export const startPluginsServer = async (wsPath) => {
+    const serverRoot = pluginServerRoot(wsPath);
+    if (!existsSync(serverRoot)) {
+        failed('The plugins server is not found in the workspace');
+        return;
+    }
+    const index = 'index.js';
+    const cmd = platform === 'win32' ? `node.exe` : `node`;
+    const args = ['--watch', `"${index}"`];
+    const execuatable = `${cmd} ${args.join(' ')}`;
+    execSync(execuatable, {
+        cwd: serverRoot,
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            PORT: '666',
+            BASE_PATH: '/plugins-service',
+            PLUGIN_DIR_ROOT: 'plugins',
+        },
+    });
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "neutrinos-cli",
+    "version": "1.0.0",
+    "main": "./bin/cli.js",
+    "type": "module",
+    "bin": {
+        "neutrinos": "bin/cli.js"
+    },
+    "files": [
+        ".configs",
+        "bin",
+        "cli-auth",
+        "commands",
+        "templates",
+        "utils",
+        "setup.js",
+        ".env",
+        "package.json"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "postinstall": "node ./setup.js"
+    },
+    "author": "",
+    "license": "ISC",
+    "keywords": [],
+    "description": "",
+    "dependencies": {
+        "fastify": "^5.4.0"
+    }
+}

package/setup.js

@@ -0,0 +1,55 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+
+/**
+ * Ensure that the config folder exists
+ * @param {string} configDir
+ */
+export const ensureConfigFolder = async (configDir) => {
+    try {
+        await mkdir(configDir, { recursive: true });
+    } catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+};
+
+export const ensureDefaultPreferences = async (configDir, preferences) => {
+    const preferencesPath = `${configDir}/preferences.json`;
+    try {
+        await mkdir(configDir, { recursive: true });
+        await writeFile(preferencesPath, JSON.stringify(preferences, null, 4));
+    } catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+};
+
+export const ensureAuthConfig = async (configDir, authConfig) => {
+    const authConfigPath = `${configDir}/auth.json`;
+    try {
+        await mkdir(configDir, { recursive: true });
+        await writeFile(authConfigPath, JSON.stringify(authConfig, null, 4));
+    } catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+};
+
+const CONFIG_DIR = './.configs';
+
+ensureConfigFolder(CONFIG_DIR);
+
+ensureAuthConfig(CONFIG_DIR, {
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    redirectUri: 'http://localhost:3000/callback',
+});
+
+ensureDefaultPreferences(CONFIG_DIR, {
+    theme: 'light',
+    language: 'en',
+    showNotifications: true,
+});