neutrinos-cli 1.0.0

package/.configs/auth.json

@@ -0,0 +1,5 @@
+{
+    "clientId": "your-client-id",
+    "clientSecret": "your-client-secret",
+    "redirectUri": "http://localhost:3000/callback"
+}

package/.configs/preferences.json

@@ -0,0 +1,5 @@
+{
+    "theme": "light",
+    "language": "en",
+    "showNotifications": true
+}

package/.env

@@ -0,0 +1,6 @@
+PORT=32231
+ISSUER_URL=https://marketplace.neutrinos-apps.com
+IDS_CLIENT_ID=FYqh5ZhdbIp2SrQPGZYMe
+IDS_CLIENT_SECRET=7aJ3-A70E7rS-o5rBwspFeeefM6OfCfOODEy1xDn4iqLLVRreKgvkE9N61cz2I3pn8I0n_DjHAsxr3iDHnAQJw
+MARKETPLACE_URL=https://marketplace.neutrinos-apps.com/marketplace-headless/api/packages/
+MARKETPLACE_URL_PROD=https://marketplace.neutrinos-apps.com/marketplace-headless/api/packages/

package/README.md

@@ -0,0 +1,173 @@
+# neutrinos CLI
+
+neutrinos CLI is a command-line interface for managing, developing and publishing the packages.
+
+### Installation
+
+To install neutrinos CLI, use the following command:
+
+```sh
+npm i -g neutrinos-cli
+```
+
+### Usage
+
+```sh
+    neutrinos command [options]
+```
+
+### Commands
+
+- `new <name>` Create a new project
+- `generate` | `g` Generate a new plugin. Run "help generate" for more information.
+- `auth` Perform authentication tasks like login, logout, or status
+- `publish [options] [packageName]` Bundle and publish the plugin
+- `build <type> [pluginName]` Build the plugin
+- `start [options]` Start the live server for the plugin
+- `serve` Start the express server that serves the plugins
+
+### Options
+
+- `-v, --version` Output the version number
+- `-h, --help` Display help for command
+
+---
+
+## Commands
+
+---
+
+### `new <name>`
+
+##### Description
+
+- Create a new project with the given name. The project will be created in the current directory.
+
+##### Usage
+
+```sh
+    neutrinos new <name>
+```
+
+##### Arguments
+
+- `<name>` project or workspace name
+
+---
+
+### `generate` | `g`
+
+##### Description
+
+- Generate a new component or module
+
+##### Usage
+
+```sh
+    neutrinos generate [command] [argument] || neutrinos g [command] [argument]
+```
+
+##### commands
+
+- `component <name>` | `c <name>` Component is a package enabling drag and drop functionality within the canvas
+- `module <name>` | `m <name>` Module is a globally accessible package, available throughout the entire project on `alpha.plugins` | `ap`.
+- `attribute [command] [options]` | `a [command] [options]` Generate an Attribute for a component, Read the `ATTRIBUTE.md` file in projetc/workspcae directory for more help
+
+##### Arguments
+
+- `<name>` component or module name
+
+---
+
+## `Build <type> [pluginName]`
+
+#### Description
+
+- Build the plugins
+
+#### Usage
+
+```sh
+    neutrinos build <type> [pluginName]
+```
+
+#### Arguments
+
+- `<type>` The type of build, it can be one of `plugin` or `docker`
+- `pluginName` package Name of the component/module to build, it is an optional argument and if not pluginName it will build every package in the current workspace
+
+---
+
+## `start [options]`
+
+#### Description
+
+- Start the live server for the workspace
+
+#### Usage
+
+```sh
+    neutrinos start [options]
+```
+
+#### Options
+
+- `-p, --port <port>` Port to start the server on, default is 6969
+
+---
+
+## `serve`
+
+#### Description
+
+- Start the express server that serves the plugins
+
+#### Usage
+
+```sh
+    neutrinos serve
+```
+
+---
+
+### `auth [command]`
+
+#### Description
+
+- Perform authentication tasks like login or status
+
+#### Usage
+
+```sh
+    neutrinos auth [command]
+```
+
+#### Commands:
+
+- `login` Authenticate with the server
+- `state` Get the current state of auth
+
+---
+
+## `publish [PackageName] [options]`
+
+#### Description
+
+- Publish a package to the server
+
+#### Usage
+
+```sh
+    neutrinos publish [PackageName] [Options]
+```
+
+#### Arguments
+
+- `PackageName` The name of the component/module to publish, if not cli will show the list of packages inside the current workspace/project
+
+#### Options
+
+- `-t, --version-type <versionType>` Version type for verion up, it can be one of `patch`, `minor`, `major`
+- `-d, --display-name <displayName>` Display Name for the package
+- `-i, --icon <iconPath>` Path to the icon
+- `-m, --images <imagePaths...>` path to the image

package/bin/cli.js

@@ -0,0 +1,239 @@
+#! /usr/bin/env node
+//@ts-check
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+import dotenv from 'dotenv';
+dotenv.config({
+    path: join(__dirname, '../.env'),
+});
+////////////////////////////////////
+import { greenBright } from 'colorette';
+import { Command, InvalidArgumentError } from 'commander';
+import EventEmitter from 'node:events';
+import { cwd, env, exit } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import open from 'open';
+import { join } from 'path';
+import { init } from '../cli-auth/server.js';
+import { publish as alphaPublish } from '../commands/alpha-publish.js';
+import { addAttribute } from '../commands/attribute.js';
+import { build } from '../commands/build.js';
+import { deprecate } from '../commands/deprecate.js';
+import { servePlugin } from '../commands/dev.js';
+import { generate } from '../commands/generate.js';
+import { createWorkspace } from '../commands/new-workspace.js';
+import { publish } from '../commands/publish.js';
+import { startPluginsServer } from '../commands/serve.js';
+import { validateWorkspace } from '../utils/check-valid-ws.js';
+import { done, failed, inprogress, log } from '../utils/logger.js';
+import { authConfigJson } from '../utils/path-utils.js';
+export const createProgram = () => {
+    const program = new Command();
+
+    program.version('1.0.0', '-v, --version', 'Output the version number');
+
+    program
+        .command('new <name>')
+        .description('Create a new project')
+        .action((name) => {
+            createWorkspace(join(cwd(), name), name);
+        });
+    const generateCmd = program
+        .command('generate')
+        .alias('g')
+        .description('Generate a new plugin. Run "help generate" for more information.');
+
+    generateCmd
+        .command('component')
+        .alias('c')
+        .argument('<name>', 'Component name')
+        .option('-d,--description <description>', 'Description of the package')
+        .description('Generate a new component plugin')
+        .action(async (name, options) => {
+            await generate.component({
+                name,
+                dir: cwd(),
+                description: options.description,
+            });
+        });
+    generateCmd
+        .command('module')
+        .alias('m')
+        .argument('<name>', 'Module name')
+        .option('-d,--description <description>', 'Description of the package')
+        .description('Generate a new module plugin')
+        .action(async (name, options) => {
+            await generate.module({
+                name,
+                dir: cwd(),
+                description: options.description,
+            });
+        });
+    generateCmd
+        .command('attribute')
+        .alias('a')
+        .argument('[componentName]', 'Component name')
+        .option('-t , --type <attributeType>', 'Type of attribute can be property, event, validation')
+        .option(
+            '-u , --ui-type <uiType>',
+            'Ui-type of attribute can be ===> input, toggle, dropdown, multi-select, typed-input, range, color-picker, data-source, data-set, table-actions, data-mapping',
+        )
+        .option('-l , --label <label>', 'Label for an attribute')
+        .option('-e , --event <event>', 'Event name for an attribute if -t/--type is event')
+        .option('-c , --category <category>', 'Category for an attribute')
+        .option('-p , --placeholder <placeholder>', 'Placeholder for an attribute')
+        .option('-d , --defaultValue <defaultValue>', 'DefaultValue for an attribute')
+        .option('-o , --options <options...>', 'Options for an attribute')
+        .option('-f , --fieldMappings <FieldMappings>', 'FieldMappings for package')
+        .option('-n , --validation <validation>', 'Validation for an attribute')
+        .description('Generate an Attribute for component')
+        .action(async (componentName, options) => {
+            return await addAttribute(componentName, cwd(), options);
+        });
+
+    const authCommand = program.command('auth').description('perform: login, logout, or status');
+    authCommand
+        .command('login')
+        .description('authenticate with the server')
+        .action((action) => {
+            return new Promise(async (resolve, reject) => {
+                inprogress(`logging in...`);
+                const cliServer = await init({
+                    tokenSetPath: authConfigJson(),
+                });
+                if (!cliServer) {
+                    failed('Issuer not found');
+                    return;
+                }
+                const eventEmitter = new EventEmitter();
+                eventEmitter.on('cli-auth:login', () => {
+                    done('login successful');
+                    resolve();
+                    process.exit(0);
+                });
+                eventEmitter.on('cli-auth:login-failed', () => {
+                    failed('login failed');
+                    reject();
+                    process.exit(1);
+                });
+                process.on('SIGINT', () => {
+                    failed('exitting unexpectedly');
+                    cliServer.stop();
+                    exit(0);
+                });
+                process.on('SIGTERM', () => {
+                    failed('exitting unexpectedly');
+                    cliServer.stop();
+                    exit(0);
+                });
+                await cliServer.start(eventEmitter);
+                const url = `http://localhost:${env.PORT}/login`;
+                inprogress(`open to login ${greenBright(url)}`);
+                await open(url);
+            });
+        });
+    authCommand
+        .command('state')
+        .description('get the current state of auth')
+        .action(() => {
+            console.log('state');
+        });
+
+    program
+        .command('publish')
+        .argument('[packageName]', 'Component name')
+        .option(
+            '-t, --version-type <versionType>',
+            'Version type for verion up can be one of "patch", "minor", "major"',
+        )
+        .option('-d, --display-name <displayName>', 'Display Name for the package')
+        .option('-i, --icon <iconPath>', 'Icon path')
+        .option('-m, --images <imagePaths...>', 'Image paths')
+        .description('Bundle and publish the plugin')
+        .action(async (packageName, options) => {
+            if (
+                options.versionType &&
+                !['patch', 'minor', 'major'].includes((options.versionType || '').toLowerCase())
+            ) {
+                failed('Invalid version type should be one of "patch", "minor", "major"');
+                exit(0);
+            }
+            return await publish(packageName, cwd(), options);
+        });
+
+    program
+        .command('alpha:publish')
+        .argument('[packageName]', 'Component name')
+        .option(
+            '-t, --version-type <versionType>',
+            'Version type for version up can be one of "patch", "minor", "major"',
+        )
+        .option('-d, --display-name <displayName>', 'Display Name for the package')
+        .option('-i, --icon <iconPath>', 'Icon path')
+        .option('-m, --images <imagePaths...>', 'Image paths')
+        .option('--accept-defaults', 'Accept all default values')
+        .option('--all', 'Select all the packages')
+        .description('Bundle and publish the plugin')
+        .action(async (packageName, options) => {
+            if (
+                options.versionType &&
+                !['patch', 'minor', 'major'].includes((options.versionType || '').toLowerCase())
+            ) {
+                failed('Invalid version type should be one of "patch", "minor", "major"');
+                exit(0);
+            }
+            return await alphaPublish(packageName, cwd(), options);
+        });
+
+    program
+        .command('deprecate')
+        .option('-y, --yes', 'Confirmation to deprecate a package')
+        .option('--all', 'Select all the packages')
+        .argument('[packageName]', 'Package name')
+        .action(async (packageName, options) => {
+            return await deprecate(packageName, cwd(), options);
+        });
+
+    program
+        .command('build')
+        .argument('<type>', 'Type of build: "plugins" or "docker"', (value, prevValue) => {
+            if (value !== 'plugins' && value !== 'docker') {
+                throw new InvalidArgumentError('"build" can be "plugins" or "docker"');
+            }
+            return value;
+        })
+        .argument('[pluginName]', 'Name of the plugin')
+        .option('--module', 'Build the plugin as a module')
+        .option('--all', 'Build all the plugin of the workspace')
+        .description('Build the plugin')
+        .action((type, pluginName, options) => {
+            build[type](cwd(), pluginName, options || {});
+        });
+    program
+        .command('start')
+        .option('-p, --port <port>', 'Port number for serving the plugin')
+        .description('start the live server for the plugin')
+        .action((options) => {
+            servePlugin(cwd(), options.port || 6969);
+        });
+    program
+        .command('serve')
+        .description('Start the express server that serves the plugins')
+        .action(() => {
+            startPluginsServer(cwd());
+        });
+    program.hook('preAction', async (thisCmd, actionCmd) => {
+        const cmd = actionCmd.name();
+        if (cmd === 'new' || cmd === 'login') {
+            return;
+        }
+        if (!validateWorkspace(cwd())) {
+            log('Please run this command in a valid workspace directory');
+            exit(1);
+        }
+    });
+
+    return program;
+};
+
+const program = createProgram();
+program.parse(process.argv);

package/cli-auth/auth.js

@@ -0,0 +1,54 @@
+import EventEmitter from 'node:events';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { sep } from 'node:path';
+import { authUtils } from './services/auth-utils.js';
+
+/**
+ * @param {import('openid-client').Client} client
+ * @param {string} tokenSetPath
+ */
+export const auth = (client, tokenSetPath) => {
+    const authStateNonce = {
+        state: '',
+        nonce: '',
+    };
+    /**
+     *
+     * @param {import('fastify').FastifyRequest} req
+     * @param {import('fastify').FastifyReply} reply
+     */
+    return {
+        /**
+         * @param {import('fastify').FastifyInstance} server
+         * @param {EventEmitter} eventEmitter
+         */
+        mount: (server, eventEmitter) => {
+            server.get('/login', async (request, reply) => {
+                const redirectUrl = await authUtils.login(client, authStateNonce);
+                reply.redirect(redirectUrl);
+            });
+            server.get('/login-callback', async (request, reply) => {
+                const { tokenSet } = await authUtils.loginCallback(
+                    client.callbackParams(request),
+                    client,
+                    authStateNonce,
+                );
+                const dirPath = tokenSetPath.substring(0, tokenSetPath.lastIndexOf(sep));
+                if (!existsSync(dirPath)) {
+                    await mkdir(dirPath, { recursive: true });
+                }
+                await writeFile(tokenSetPath, JSON.stringify(tokenSet, null, 2), {
+                    encoding: 'utf-8',
+                });
+                if (tokenSet) {
+                    reply.send('Login successful');
+                    eventEmitter.emit('cli-auth:login');
+                    return;
+                }
+                reply.send('Login failed');
+                eventEmitter.emit('cli-auth:login-failed');
+            });
+        },
+    };
+};

package/cli-auth/publish.js

@@ -0,0 +1,7 @@
+export const publish = (server) => {
+    return {
+        publish: async () => {
+            console.log('Publishing the plugin...');
+        },
+    };
+};

package/cli-auth/server.js

@@ -0,0 +1,44 @@
+import fastify from 'fastify';
+import { env } from 'node:process';
+import { Issuer } from 'openid-client';
+import { auth } from './auth.js';
+
+/**
+ * @param {{tokenSetPath: string}} config
+ * @returns
+ */
+export const init = async (config) => {
+    if (!env.ISSUER_URL) {
+        console.error('Issuer URL not found');
+        return;
+    }
+    const issuer = await Issuer.discover(env.ISSUER_URL);
+    if (!issuer) {
+        console.error('Issuer not found');
+        return;
+    }
+    if (!env.IDS_CLIENT_ID || !env.IDS_CLIENT_SECRET) {
+        console.error('Client ID or Client Secret not found');
+        return;
+    }
+    const client = new issuer.Client({
+        client_id: env.IDS_CLIENT_ID,
+        client_secret: env.IDS_CLIENT_SECRET,
+    });
+    const server = fastify();
+    const auth_ = auth(client, config.tokenSetPath);
+    return {
+        start: async (eventEmitter) => {
+            const port = parseInt(env.PORT || '32231');
+            auth_.mount(server, eventEmitter);
+            await server.listen({
+                port,
+            });
+            return server;
+        },
+        stop: async () => {
+            await server.close();
+            return server;
+        },
+    };
+};

package/cli-auth/services/auth-utils.js

@@ -0,0 +1,68 @@
+import { randomBytes } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import { env } from 'node:process';
+
+export const authUtils = {
+    /**
+     * @param {import('openid-client').Client} client
+     * @param {{state: string, nonce: string}} authStateNonce
+     */
+    login: async (client, authStateNonce) => {
+        const authorizationRequest = {
+            redirect_uri: `http://localhost:${env.PORT}/login-callback`,
+            scope: 'openid profile email address phone offline_access user',
+            state: randomBytes(16).toString('hex'),
+            nonce: randomBytes(16).toString('hex'),
+            response_type: client.response_types[0],
+            prompt: 'consent',
+        };
+        authStateNonce.state = authorizationRequest.state;
+        authStateNonce.nonce = authorizationRequest.nonce;
+        const redirect = client.authorizationUrl(authorizationRequest);
+        return redirect;
+    },
+    /**
+     * @param {*} callbackParams
+     * @param {import('openid-client').Client} client
+     * @param {{state: string, nonce: string}} authStateNonce
+     * @returns {Promise<{redirect: string, tokenSet: null | any}>}
+     */
+    loginCallback: async (callbackParams, client, authStateNonce) => {
+        /** @type {{redirect: string, tokenSet: null | any}} */
+        const result = {
+            redirect: '',
+            tokenSet: null,
+        };
+        if (Object.keys(callbackParams).length === 0) {
+            result.redirect = '/login';
+            return result;
+        }
+        const tokenset = await client.callback(`http://localhost:${env.PORT}/login-callback`, callbackParams, {
+            nonce: authStateNonce.nonce,
+            state: authStateNonce.state,
+        });
+        authStateNonce.state = '';
+        authStateNonce.nonce = '';
+        result.tokenSet = tokenset;
+        result.redirect = '/login-success';
+        return result;
+    },
+    /**
+     * @param {import('openid-client').Client} client
+     * @param {string} tokenSetPath
+     * @returns {Promise<import('openid-client').IntrospectionResponse>}
+     */
+    verifyToken: async (client, tokenSetPath) => {
+        const tokenSet = JSON.parse(await readFile(tokenSetPath, 'utf-8'));
+        return await client.introspect(tokenSet.access_token);
+    },
+    /**
+     * @param {import('openid-client').Client} client
+     * @param {string} tokenSetPath
+     */
+    refreshToken: async (client, tokenSetPath) => {
+        const tokenSet = JSON.parse(await readFile(tokenSetPath, 'utf-8'));
+        const updatedTokenSet = await client.refresh(tokenSet.refresh_token);
+        await writeFile(tokenSetPath, JSON.stringify(updatedTokenSet, null, 2));
+    },
+};