@signageos/cli 2.5.0 → 2.6.0-rc.0

package/dist/Applet/Generate/appletGenerateCommand.js

@@ -109,7 +109,7 @@ const DEPENDENCIES = {
         '@babel/core@7',
         '@babel/preset-env@7',
     ],
-    rspack: ['@rspack/core@latest', '@rspack/cli@latest'],
+    rspack: ['@rspack/core@^1.4.11', '@rspack/cli@^1.4.11'],
 };
 const RUNSCRIPTS = {
     common: {

package/dist/CustomScript/customScriptFacade.d.ts

@@ -1,7 +1,7 @@
 import * as z from 'zod';
 import RestApi from '@signageos/sdk/dist/RestApi/RestApi';
 import { ICustomScriptVersion } from '@signageos/sdk/dist/RestApi/CustomScript/Version/ICustomScriptVersion';
-declare const PlatformSchema: z.ZodObject<{
+export declare const PlatformSchema: z.ZodObject<{
     /** List of files/directories that are part of the custom script for a particular platform. */
     rootDir: z.ZodString;
     /** Main file of the particular platform script that will be executed. */
@@ -23,7 +23,7 @@ declare const ConfigSchema: z.ZodObject<{
     name: z.ZodString;
     version: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    dangerLevel: z.ZodString;
+    dangerLevel: z.ZodOptional<z.ZodString>;
     /**
      * Config of individual custom script implementations for each target platform.
      *
@@ -50,7 +50,6 @@ declare const ConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     version: string;
     name: string;
-    dangerLevel: string;
     platforms: Record<string, {
         rootDir: string;
         mainFile: string;
@@ -59,10 +58,10 @@ declare const ConfigSchema: z.ZodObject<{
     configDefinition: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
     description?: string | undefined;
     uid?: string | undefined;
+    dangerLevel?: string | undefined;
 }, {
     version: string;
     name: string;
-    dangerLevel: string;
     platforms: Record<string, {
         rootDir: string;
         mainFile: string;
@@ -71,6 +70,7 @@ declare const ConfigSchema: z.ZodObject<{
     configDefinition: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
     description?: string | undefined;
     uid?: string | undefined;
+    dangerLevel?: string | undefined;
 }>;
 export type CustomScriptConfig = z.infer<typeof ConfigSchema>;
 /**
@@ -87,7 +87,6 @@ export interface CodeArchive {
 export declare function getConfig(workDir: string): Promise<{
     version: string;
     name: string;
-    dangerLevel: string;
     platforms: Record<string, {
         rootDir: string;
         mainFile: string;
@@ -96,6 +95,7 @@ export declare function getConfig(workDir: string): Promise<{
     configDefinition: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
     description?: string | undefined;
     uid?: string | undefined;
+    dangerLevel?: string | undefined;
 }>;
 /**
  * Add data to the config file .sosconfig.json

package/dist/CustomScript/customScriptFacade.js

@@ -45,6 +45,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformSchema = void 0;
 exports.getConfig = getConfig;
 exports.addToConfigFile = addToConfigFile;
 exports.ensureCustomScriptVersion = ensureCustomScriptVersion;
@@ -61,7 +62,7 @@ const fileSystem_1 = require("../Lib/fileSystem");
 const runtimeFileSystem_1 = require("@signageos/sdk/dist/Development/runtimeFileSystem");
 const CONFIG_FILE_NAME = '.sosconfig.json';
 const CUSTOM_SCRIPTS_BUILDS_DIRNAME = 'custom_scripts_builds';
-const PlatformSchema = z.strictObject({
+exports.PlatformSchema = z.strictObject({
     /** List of files/directories that are part of the custom script for a particular platform. */
     rootDir: z.string(),
     /** Main file of the particular platform script that will be executed. */
@@ -74,14 +75,14 @@ const ConfigSchema = z.object({
     name: z.string(),
     version: z.string(),
     description: z.string().optional(),
-    dangerLevel: z.string(),
+    dangerLevel: z.string().optional(),
     /**
      * Config of individual custom script implementations for each target platform.
      *
      * A Custom Script is only a virtual unit that consists of multiple platform-specific scripts.
      * This record is a mapping of platform names to their respective platform-specific scripts.
      */
-    platforms: z.record(z.string(), PlatformSchema),
+    platforms: z.record(z.string(), exports.PlatformSchema),
     configDefinition: z.array(z.object({}).passthrough()), // outsource validation to API because it's a bit complex
 });
 /**
@@ -171,7 +172,7 @@ function ensureCustomScript(restApi, config) {
             name: config.name,
             title: config.name, // TODO change
             description: config.description,
-            dangerLevel: config.dangerLevel,
+            dangerLevel: config.dangerLevel ? config.dangerLevel : 'normal', // default to 'normal' if not provided
         });
         // TODO ask for permission or read from CLI arg
         (0, log_1.log)('info', chalk_1.default.yellow('Adding Custom Script uid to the config file'));

package/dist/Plugin/Generate/pluginGenerateCommand.d.ts

@@ -0,0 +1,7 @@
+export declare const pluginGenerate: {
+    name: "generate";
+    description: string;
+    optionList: never[];
+    commands: never[];
+    run(): Promise<void>;
+};

package/dist/Plugin/Generate/pluginGenerateCommand.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginGenerate = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const log_1 = require("@signageos/sdk/dist/Console/log");
+const commandDefinition_1 = require("../../Command/commandDefinition");
+const git_1 = require("../../Lib/git");
+const customScriptFacade_1 = require("../../CustomScript/customScriptFacade");
+const pluginGenerateFacade_1 = require("./pluginGenerateFacade");
+exports.pluginGenerate = (0, commandDefinition_1.createCommandDefinition)({
+    name: 'generate',
+    description: 'Generates a local repository for developing a Plugin',
+    optionList: [],
+    commands: [],
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, git_1.throwErrorIfGitNotInstalled)();
+            const { targetDir, name, description } = yield (0, pluginGenerateFacade_1.askForParameters)();
+            yield (0, pluginGenerateFacade_1.downloadBoilerplateCode)(targetDir);
+            yield (0, customScriptFacade_1.addToConfigFile)(targetDir, { name, description });
+            (0, log_1.log)('info', `Plugin ${chalk_1.default.green(name)} has been generated in ${chalk_1.default.green(targetDir)}.`);
+            (0, log_1.log)('info', 'Next steps:');
+            (0, log_1.log)('info', `  - Open the folder ${chalk_1.default.green(targetDir)} and read the ${chalk_1.default.green('README.md')} file.`);
+        });
+    },
+});

package/dist/Plugin/Generate/pluginGenerateFacade.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Prompts the user for the parameters needed to generate a plugin.
+ */
+export declare function askForParameters(): Promise<{
+    targetDir: any;
+    name: any;
+    description: any;
+}>;
+/**
+ * Downloads the latest version of the boilerplate code from the GitHub repository.
+ */
+export declare function downloadBoilerplateCode(targetDir: string): Promise<void>;

package/dist/Plugin/Generate/pluginGenerateFacade.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askForParameters = askForParameters;
+exports.downloadBoilerplateCode = downloadBoilerplateCode;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const log_1 = require("@signageos/sdk/dist/Console/log");
+const git_1 = require("../../Lib/git");
+/**
+ * Prompts the user for the parameters needed to generate a plugin.
+ */
+function askForParameters() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const throwCanceledError = () => {
+            throw new Error('Plugin generation was canceled.');
+        };
+        const { name, description } = yield (0, prompts_1.default)([
+            {
+                type: 'text',
+                name: 'name',
+                message: 'Type name',
+            },
+            {
+                type: 'text',
+                name: 'description',
+                message: 'Type description',
+            },
+        ], { onCancel: throwCanceledError });
+        const targetDir = name;
+        (0, log_1.log)('info', `Generating Plugin with these parameters:\n` +
+            `  - Directory: ${chalk_1.default.green(targetDir)}\n` +
+            `  - Name: ${chalk_1.default.green(name)}\n` +
+            `  - Description: ${chalk_1.default.green(description)}\n`);
+        const { confirm } = yield (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Confirm',
+        });
+        if (!confirm) {
+            throwCanceledError();
+        }
+        return {
+            targetDir,
+            name,
+            description,
+        };
+    });
+}
+/**
+ * Downloads the latest version of the boilerplate code from the GitHub repository.
+ */
+function downloadBoilerplateCode(targetDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const URL = 'https://github.com/signageos/plugins-boilerplate';
+        yield (0, git_1.cloneGitRepository)(URL, targetDir);
+        // we just want the code, not the git history
+        yield fs.remove(path.join(targetDir, '.git'));
+    });
+}

package/dist/Plugin/Upload/pluginUploadCommand.d.ts

@@ -0,0 +1,25 @@
+import { CommandLineOptions } from '../../Command/commandDefinition';
+export declare const OPTION_LIST: readonly [{
+    readonly name: "no-default-organization";
+    readonly type: BooleanConstructor;
+    readonly description: "Prevent using the defaultOrganizationUid from ~/.sosrc";
+}, {
+    readonly name: "organization-uid";
+    readonly type: StringConstructor;
+    readonly description: "Organization UID";
+}];
+export declare const pluginUpload: {
+    name: "upload";
+    description: string;
+    optionList: readonly [{
+        readonly name: "no-default-organization";
+        readonly type: BooleanConstructor;
+        readonly description: "Prevent using the defaultOrganizationUid from ~/.sosrc";
+    }, {
+        readonly name: "organization-uid";
+        readonly type: StringConstructor;
+        readonly description: "Organization UID";
+    }];
+    commands: never[];
+    run(options: CommandLineOptions<typeof OPTION_LIST>): Promise<void>;
+};

package/dist/Plugin/Upload/pluginUploadCommand.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginUpload = exports.OPTION_LIST = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const log_1 = require("@signageos/sdk/dist/Console/log");
+const commandDefinition_1 = require("../../Command/commandDefinition");
+const organizationFacade_1 = require("../../Organization/organizationFacade");
+const customScriptFacade_1 = require("../../CustomScript/customScriptFacade");
+const pluginFacade_1 = require("../pluginFacade");
+const util_1 = require("util");
+const helper_1 = require("../../helper");
+const debug_1 = __importDefault(require("debug"));
+const Debug = (0, debug_1.default)('@signageos/cli:Plugin:Upload:Command');
+exports.OPTION_LIST = [organizationFacade_1.NO_DEFAULT_ORGANIZATION_OPTION, organizationFacade_1.ORGANIZATION_UID_OPTION];
+exports.pluginUpload = (0, commandDefinition_1.createCommandDefinition)({
+    name: 'upload',
+    description: 'Uploads current plugin version',
+    optionList: exports.OPTION_LIST,
+    commands: [],
+    run(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentDirectory = process.cwd();
+            const organizationUid = yield (0, organizationFacade_1.getOrganizationUidOrDefaultOrSelect)(options);
+            const organization = yield (0, organizationFacade_1.getOrganization)(organizationUid);
+            const restApi = yield (0, helper_1.createOrganizationRestApi)(organization);
+            const config = yield (0, customScriptFacade_1.getConfig)(currentDirectory);
+            const schema = yield (0, pluginFacade_1.loadSchemas)(currentDirectory);
+            const pluginVersion = yield (0, pluginFacade_1.ensurePluginVersion)(restApi, config, schema);
+            for (const platform of Object.keys(config.platforms)) {
+                const platformConfig = config.platforms[platform];
+                if (!platformConfig) {
+                    console.warn(`Skipping platform ${platform} due to missing configuration`);
+                    continue;
+                }
+                yield (0, pluginFacade_1.uploadCode)({
+                    restApi,
+                    workDir: currentDirectory,
+                    platform,
+                    config: platformConfig,
+                    pluginVersion,
+                });
+            }
+            if (!(0, util_1.isDeepStrictEqual)(pluginVersion.configDefinition, config.configDefinition)) {
+                Debug('Config definition is different, updating plugin version.');
+                yield restApi.plugin.version.update({
+                    pluginUid: pluginVersion.pluginUid,
+                    version: pluginVersion.version,
+                    configDefinition: config.configDefinition,
+                    schema: [schema],
+                });
+            }
+            else {
+                Debug('Config definition is the same, skipping update.');
+            }
+            (0, log_1.log)('info', `Plugin ${chalk_1.default.green(config.name)} version ${chalk_1.default.green(config.version)} has been uploaded.`);
+        });
+    },
+});

package/dist/Plugin/pluginCommand.d.ts

@@ -0,0 +1,27 @@
+export declare const plugin: {
+    name: "plugin";
+    description: string;
+    optionList: never[];
+    commands: ({
+        name: "generate";
+        description: string;
+        optionList: never[];
+        commands: never[];
+        run(): Promise<void>;
+    } | {
+        name: "upload";
+        description: string;
+        optionList: readonly [{
+            readonly name: "no-default-organization";
+            readonly type: BooleanConstructor;
+            readonly description: "Prevent using the defaultOrganizationUid from ~/.sosrc";
+        }, {
+            readonly name: "organization-uid";
+            readonly type: StringConstructor;
+            readonly description: "Organization UID";
+        }];
+        commands: never[];
+        run(options: import("../Command/commandDefinition").CommandLineOptions<typeof import("./Upload/pluginUploadCommand").OPTION_LIST>): Promise<void>;
+    })[];
+    run(): Promise<never>;
+};

package/dist/Plugin/pluginCommand.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const commandDefinition_1 = require("../Command/commandDefinition");
+const pluginGenerateCommand_1 = require("./Generate/pluginGenerateCommand");
+const pluginUploadCommand_1 = require("./Upload/pluginUploadCommand");
+exports.plugin = (0, commandDefinition_1.createCommandDefinition)({
+    name: 'plugin',
+    description: 'Plugin management',
+    optionList: [],
+    commands: [pluginGenerateCommand_1.pluginGenerate, pluginUploadCommand_1.pluginUpload],
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Unknown command');
+        });
+    },
+});

package/dist/Plugin/pluginFacade.d.ts

@@ -0,0 +1,62 @@
+import z from 'zod';
+import RestApi from '@signageos/sdk/dist/RestApi/RestApi';
+import { IPluginVersion } from '@signageos/sdk/dist/RestApi/Plugin/Version/IPluginVersion';
+import { PlatformConfig } from '../CustomScript/customScriptFacade';
+export declare function ensurePluginVersion(restApi: RestApi, config: PluginConfig, schema: any): Promise<import("@signageos/sdk/dist/RestApi/Plugin/Version/PluginVersion").PluginVersion>;
+export declare function uploadCode({ restApi, workDir, platform, config, pluginVersion, }: {
+    restApi: RestApi;
+    workDir: string;
+    platform: string;
+    config: PlatformConfig;
+    pluginVersion: IPluginVersion;
+}): Promise<void>;
+export declare function loadSchemas(workDir: string): Promise<any>;
+export declare const ConfigSchema: z.ZodObject<{
+    uid: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    /**
+     * Config of individual plugin script implementations for each target platform.
+     *
+     * A plugin Script is only a virtual unit that consists of multiple platform-specific scripts.
+     * This record is a mapping of platform names to their respective platform-specific scripts.
+     */
+    platforms: z.ZodRecord<z.ZodString, z.ZodObject<{
+        rootDir: z.ZodString;
+        mainFile: z.ZodString;
+        runtime: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        rootDir: string;
+        mainFile: string;
+        runtime: string;
+    }, {
+        rootDir: string;
+        mainFile: string;
+        runtime: string;
+    }>>;
+    configDefinition: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    name: string;
+    platforms: Record<string, {
+        rootDir: string;
+        mainFile: string;
+        runtime: string;
+    }>;
+    configDefinition: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+    description?: string | undefined;
+    uid?: string | undefined;
+}, {
+    version: string;
+    name: string;
+    platforms: Record<string, {
+        rootDir: string;
+        mainFile: string;
+        runtime: string;
+    }>;
+    configDefinition: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+    description?: string | undefined;
+    uid?: string | undefined;
+}>;
+export type PluginConfig = z.infer<typeof ConfigSchema>;