@reshapr/reshapr-cli 0.0.1

package/README.md

@@ -0,0 +1,44 @@
+# reshapr-cli
+
+This is the command line interface for the Reshapr project.
+
+## Installing the CLI
+
+```shell
+npm install -g @reshapr/reshapr-cli
+```
+
+## Running the CLI in dev mode
+
+After cloning the repository, you can run the CLI in development mode using the following commands.
+
+1. First, ensure you have the required dependencies installed. You can do this by running:
+
+```shell
+npm install
+```
+
+2. Next, you have to start the CLI in development mode using:
+
+```shell    
+npm run dev
+```
+
+This will keep the CLI running and watch for changes in the source code, allowing you to develop
+and test your changes in real-time.
+
+3. Finally, you have to link the `reshapr` binary to your JavaScript entrypoint for the CLI:
+
+```shell
+npm link
+```
+
+### Executing some commands
+
+```shell
+# Login to the reShapr local control-plane server
+reshapr login --server http://localhost:5555
+
+# Logout once your job is done.
+reshapr logout 
+```

package/dist/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { program } from 'commander';
+import * as yaml from 'js-yaml';
+import { loginCommand, infoCommand, logoutCommand, importCommand, attachCommand, quotasCommand } from './commands/index.js';
+import { ConfigUtil } from './utils/config.js';
+import { Logger } from './utils/logger.js';
+import { Context } from './utils/context.js';
+import { CLI_VERSION } from './version.js';
+import { CLI_NAME, CLI_LABEL } from './constants.js';
+program
+    .name(CLI_NAME)
+    .description(CLI_LABEL + ' CLI - A command line interface for ' + CLI_LABEL)
+    .version(CLI_VERSION)
+    .hook('preAction', (thisCommand, actionCommand) => {
+    ConfigUtil.readConfig();
+    if (actionCommand.name() != 'login' && actionCommand.name() != 'logout') {
+        if (!ConfigUtil.config.token) {
+            Logger.warn(`You are not logged in. Please login first using the \`${CLI_NAME} login\` command.`);
+            process.exit(1);
+        }
+        if (ConfigUtil.config.exp && ConfigUtil.config.exp < Date.now() / 1000) {
+            Logger.warn(`Your token has expired. Please login again using the \`${CLI_NAME} login\` command.`);
+            process.exit(1);
+        }
+    }
+    if (actionCommand.opts().output) {
+        Logger.mute();
+    }
+})
+    .hook('postAction', (thisCommand, actionCommand) => {
+    if (actionCommand.opts().output) {
+        Logger.unmute();
+        // Check requested format.
+        const format = actionCommand.opts().output.toLowerCase();
+        if (format !== 'json' && format !== 'yaml') {
+            Logger.error('Invalid output format. Supported formats are json and yaml.');
+            process.exit(1);
+        }
+        if (!Context.isEmpty()) {
+            if (Context.size() === 1) {
+                const firstKey = Object.keys(Context.getAll())[0];
+                if (format === 'json') {
+                    Logger.log(convertToJson(Context.get(firstKey)));
+                }
+                else if (format === 'yaml') {
+                    Logger.log(convertToYaml(Context.get(firstKey)));
+                }
+            }
+            else {
+                if (format === 'json') {
+                    Logger.log(convertToJson(Context.getAll()));
+                }
+                else if (format === 'yaml') {
+                    Logger.log(convertToYaml(Context.getAll()));
+                }
+            }
+        }
+    }
+});
+function convertToJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+function convertToYaml(data) {
+    return yaml.dump(data);
+}
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught Exception:', error);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    process.exit(1);
+});
+// Load commands.
+program.addCommand(loginCommand);
+program.addCommand(infoCommand);
+program.addCommand(logoutCommand);
+program.addCommand(importCommand);
+program.addCommand(attachCommand);
+program.addCommand(quotasCommand);
+program.parse(process.argv);

package/dist/commands/api-token.js

@@ -0,0 +1,123 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Option, program } from "commander";
+import inquirer from "inquirer";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const tokenCommand = program.command('api-token')
+    .description(`Manage API tokens in ${CLI_LABEL}`);
+/* List all api tokens */
+tokenCommand.command('list')
+    .description('List all API tokens')
+    .action(async () => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/tokens/apiTokens`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error(`Failed to fetch API tokens: ${response.statusText}`);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Error parsing secrets response: ' + err.message);
+    });
+    if (data != null) {
+        if (data.length === 0) {
+            Logger.info('No API tokens found.');
+        }
+        else {
+            Context.put('tokens', data);
+            const longestName = longestTokenName(data) + 1; // +1 for padding
+            Logger.log(`${'ID'.padEnd(13, ' ')}  ${'NAME'.padEnd(longestName, ' ')} VALID UNTIL`);
+            data.forEach((token) => {
+                Logger.log(`${token.id.padEnd(13, ' ')}  ${token.name.padEnd(longestName, ' ')} ${new Date(token.validUntil).toUTCString()}`);
+            });
+        }
+    }
+});
+function longestTokenName(tokens) {
+    return tokens.reduce((max, token) => {
+        return Math.max(max, token.name.length);
+    }, 0);
+}
+/* Create a new api token */
+tokenCommand.command('create <name>')
+    .description('Create a new API token')
+    .addOption(new Option('-v, --validity-days <days>', 'Number of days the token is valid for').choices(['1', '7', '30', '90']))
+    .action(async (name, options) => {
+    // Initialize the token request object.
+    let tokenRequest = {
+        name: name,
+        validityDays: 30
+    };
+    // Populate validityDays if provided.
+    if (options.validityDays) {
+        tokenRequest.validityDays = parseInt(options.validityDays, 10);
+    }
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/tokens/apiTokens`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        },
+        body: JSON.stringify(tokenRequest)
+    });
+    if (!response.ok) {
+        Logger.error(`Creating API token failed: ${response.statusText}`);
+        process.exit(1);
+    }
+    const token = await response.json().catch(err => {
+        Logger.error('Error parsing create token response: ' + err.message);
+    });
+    Context.put('token', token);
+    if (token != null) {
+        Logger.warn(`The API Token to register Gateway is: ${token.organizationId}-${token.token}`);
+        Logger.warn('Make sure to store it securely, as it will not be shown again.');
+    }
+});
+/* Delete an api token */
+tokenCommand.command('delete <tokenId>')
+    .description('Delete an API token by ID')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .action(async (tokenId, options) => {
+    if (!options.force) {
+        const confirm = await inquirer.prompt({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Deleting this API token will prevent Gateways that use it to connect to ${CLI_LABEL}. Are you sure you want to proceed?`,
+            default: false
+        });
+        if (!confirm.confirm) {
+            Logger.info('Deletion cancelled.');
+            return;
+        }
+    }
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/tokens/apiTokens/${tokenId}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error(`Failed to delete API token: ${response.statusText}`);
+        return;
+    }
+    Logger.info(`API token with ID ${tokenId} deleted successfully.`);
+});

package/dist/commands/attach.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'node:fs';
+import yoctoSpinner from 'yocto-spinner';
+import { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const attachCommand = new Command('attach')
+    .description(`Attach an artifact to a ${CLI_LABEL} Service`)
+    .option('-f, --file <file>', 'Path to the artifact file to atttach')
+    .option('-u, --url <url>', 'URL of the artifact to atttach')
+    .option('-s, --secret <artifactSecret>', 'Use a secret to authenticate the artifact to atttach')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (options) => {
+    if (!options.file && !options.url) {
+        Logger.error('You must provide either a file path or a URL to import.');
+        process.exit(1);
+    }
+    let body;
+    if (options.file) {
+        if (!fs.existsSync(options.file)) {
+            Logger.error(`File not found: ${options.file}`);
+            process.exit(1);
+        }
+        // We should encode in multipart/form-data
+        body = new FormData();
+        body.append('file', new Blob([fs.readFileSync(options.file)]), options.file.split('/').pop());
+    }
+    else if (options.url) {
+        // We should encode in application/x-www-form-urlencoded
+        body = new URLSearchParams();
+        body.append('url', options.url);
+        if (options.secret) {
+            body.append('secretName', options.secret);
+        }
+    }
+    const spinner = yoctoSpinner({ text: 'Attaching artifact...' }).start();
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/artifacts/attach`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+        },
+        body: body
+    });
+    if (!response.ok) {
+        Logger.error('Attach failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Failed to parse response: ' + err.message);
+        process.exit(1);
+    });
+    spinner.stop();
+    Context.put('artifact', data);
+    Logger.success('Attachment successful!');
+    Logger.info(`Discovered Artifact ${data.name} with ID: ${data.id}`);
+});