@signageos/cli 2.5.0 → 2.6.0-rc.0

package/dist/Plugin/pluginFacade.js

@@ -0,0 +1,251 @@
+"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.ConfigSchema = void 0;
+exports.ensurePluginVersion = ensurePluginVersion;
+exports.uploadCode = uploadCode;
+exports.loadSchemas = loadSchemas;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs-extra"));
+const zod_1 = __importDefault(require("zod"));
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const log_1 = require("@signageos/sdk/dist/Console/log");
+const archive_1 = require("../Lib/archive");
+const fileSystem_1 = require("../Lib/fileSystem");
+const runtimeFileSystem_1 = require("@signageos/sdk/dist/Development/runtimeFileSystem");
+const customScriptFacade_1 = require("../CustomScript/customScriptFacade");
+const PLUGIN_BUILDS_DIRNAME = 'plugin_builds';
+function ensurePluginVersion(restApi, config, schema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plugin = yield ensurePlugin(restApi, config);
+        const pluginVersion = yield restApi.plugin.version.get({
+            pluginUid: plugin.uid,
+            version: config.version,
+        });
+        if (pluginVersion) {
+            return pluginVersion;
+        }
+        const response = yield (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'newVersion',
+            message: `Do you want to create new plugin version ${config.version}?`,
+        });
+        if (!response.newVersion) {
+            throw new Error('Plugin version creation was canceled.');
+        }
+        (0, log_1.log)('info', chalk_1.default.yellow(`Creating Plugin version ${config.version}`));
+        return yield restApi.plugin.version.create({
+            pluginUid: plugin.uid,
+            version: config.version,
+            description: 'testts',
+            schema: schema.schema,
+            configDefinition: config.configDefinition,
+        });
+    });
+}
+function ensurePlugin(restApi, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (config.uid) {
+            const plugin = yield restApi.plugin.get(config.uid);
+            if (plugin) {
+                yield restApi.plugin.update(plugin.uid, {
+                    name: config.name,
+                    title: config.name,
+                    description: config.description,
+                });
+                return plugin;
+            }
+            throw new Error(`Plugin with uid "${config.uid}" not found`);
+        }
+        const response = yield (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'create',
+            message: `Plugin "${config.name}" does not exist. Do you want to create it?`,
+        });
+        if (!response.create) {
+            throw new Error('Plugin upload was canceled.');
+        }
+        (0, log_1.log)('info', chalk_1.default.yellow(`Creating Plugin "${config.name}"`));
+        const createdPlugin = yield restApi.plugin.create({
+            name: config.name,
+            title: config.name,
+            description: config.description,
+        });
+        // TODO ask for permission or read from CLI arg
+        (0, log_1.log)('info', chalk_1.default.yellow('Adding Plugin uid to the config file'));
+        yield (0, customScriptFacade_1.addToConfigFile)(process.cwd(), { uid: createdPlugin.uid });
+        return createdPlugin;
+    });
+}
+function uploadCode(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ restApi, workDir, platform, config, pluginVersion, }) {
+        const { mainFile, runtime } = config;
+        const codeArchive = yield generatePluginPlatformCodeArchive(workDir, config, pluginVersion, platform);
+        const pluginVersionPlatform = yield restApi.plugin.version.platform.get({
+            pluginUid: pluginVersion.pluginUid,
+            version: pluginVersion.version,
+            platform,
+        });
+        if ((pluginVersionPlatform === null || pluginVersionPlatform === void 0 ? void 0 : pluginVersionPlatform.md5Checksum) === codeArchive.md5Checksum) {
+            (0, log_1.log)('info', chalk_1.default.yellow(`Skipping upload for ${platform} - no changes detected`));
+            return;
+        }
+        try {
+            (0, log_1.log)('info', chalk_1.default.yellow(`Uploading files for ${platform}`));
+            yield uploadCodeArchive({
+                restApi,
+                pluginVersion,
+                platform,
+                codeArchive,
+            });
+            yield restApi.plugin.version.platform.update({
+                pluginUid: pluginVersion.pluginUid,
+                version: pluginVersion.version,
+                platform,
+                mainFile,
+                runtime,
+                md5Checksum: codeArchive.md5Checksum,
+            });
+        }
+        finally {
+            yield codeArchive.delete();
+        }
+    });
+}
+function uploadCodeArchive(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ restApi, pluginVersion, platform, codeArchive, }) {
+        const filePath = codeArchive.filePath;
+        const fileSize = (yield fs.stat(filePath)).size;
+        const fileStream = fs.createReadStream(filePath);
+        yield restApi.plugin.version.platform.archive.upload({
+            pluginUid: pluginVersion.pluginUid,
+            version: pluginVersion.version,
+            platform,
+            md5Checksum: codeArchive.md5Checksum,
+            size: fileSize,
+            stream: fileStream,
+        });
+    });
+}
+/**
+ * Generates an archive with the code for a particular platform, defined by the provided configuration.
+ *
+ * Archive is generated and stored in the runtime /tmp/signageos/plugin_scripts_builds/:uid/:version/ directory.
+ * After archive isn't needed anymore, it should be deleted using the delete method.
+ */
+function generatePluginPlatformCodeArchive(workDir, config, pluginVersion, platform) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const buildsDir = yield ensureBuildsDirectory(pluginVersion);
+        const archiveFileName = `${platform}.zip`;
+        const archiveFilePath = path.join(buildsDir, archiveFileName);
+        yield (0, archive_1.generateZip)(workDir, config.rootDir, archiveFilePath);
+        const md5Checksum = yield (0, fileSystem_1.getFileMD5Checksum)(archiveFilePath);
+        return {
+            filePath: archiveFilePath,
+            md5Checksum,
+            delete() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield fs.unlink(archiveFilePath);
+                });
+            },
+        };
+    });
+}
+/**
+ * Ensure that the runtime directory for plugin script version exists in the current working directory.
+ *
+ * This directory is used to store temporary files generated by the CLI.
+ */
+function ensureBuildsDirectory(pluginVersion) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const runtimeDir = yield ensureRuntimeDir();
+        const buildsDir = path.join(runtimeDir, pluginVersion.pluginUid, pluginVersion.version);
+        yield fs.ensureDir(buildsDir);
+        return buildsDir;
+    });
+}
+/**
+ * Ensure that the runtime directory exists in the current working directory.
+ *
+ * This directory is used to store temporary files generated by the CLI.
+ */
+function ensureRuntimeDir() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const runtimeDir = path.join(os.tmpdir(), runtimeFileSystem_1.RUNTIME_DIRNAME, PLUGIN_BUILDS_DIRNAME);
+        yield fs.ensureDir(runtimeDir);
+        return runtimeDir;
+    });
+}
+function loadSchemas(workDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filePath = getConfigFilePath(workDir);
+        if (!(yield fs.pathExists(filePath))) {
+            throw new Error(`Config file schema.json not found`);
+        }
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(fileContent);
+    });
+}
+function getConfigFilePath(workDir) {
+    return path.join(workDir, 'schema.json');
+}
+exports.ConfigSchema = zod_1.default.object({
+    uid: zod_1.default.string().optional(),
+    name: zod_1.default.string(),
+    version: zod_1.default.string(),
+    description: zod_1.default.string().optional(),
+    /**
+     * 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: zod_1.default.record(zod_1.default.string(), customScriptFacade_1.PlatformSchema),
+    configDefinition: zod_1.default.array(zod_1.default.object({}).passthrough()), // outsource validation to API because it's a bit complex
+});

package/dist/Runner/Generate/runnerGenerateCommand.d.ts

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

package/dist/Runner/Generate/runnerGenerateCommand.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.runnerGenerate = 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 runnerGenerateFacade_1 = require("./runnerGenerateFacade");
+exports.runnerGenerate = (0, commandDefinition_1.createCommandDefinition)({
+    name: 'generate',
+    description: 'Generates a local repository for developing a Runner',
+    optionList: [],
+    commands: [],
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, git_1.throwErrorIfGitNotInstalled)();
+            const { targetDir, name, description } = yield (0, runnerGenerateFacade_1.askForParameters)();
+            yield (0, runnerGenerateFacade_1.downloadBoilerplateCode)(targetDir);
+            yield (0, customScriptFacade_1.addToConfigFile)(targetDir, { name, description });
+            (0, log_1.log)('info', `Runner ${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/Runner/Generate/runnerGenerateFacade.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Prompts the user for the parameters needed to generate a runner.
+ */
+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/Runner/Generate/runnerGenerateFacade.js

@@ -0,0 +1,107 @@
+"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 runner.
+ */
+function askForParameters() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const throwCanceledError = () => {
+            throw new Error('Runner 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 Runner 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* () {
+        // TODO: Update this URL to point to the actual runner boilerplate repository
+        const URL = 'https://github.com/signageos/runners-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/Runner/Upload/runnerUploadCommand.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 runnerUpload: {
+    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/Runner/Upload/runnerUploadCommand.js

@@ -0,0 +1,72 @@
+"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.runnerUpload = exports.OPTION_LIST = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const util_1 = require("util");
+const debug_1 = __importDefault(require("debug"));
+const log_1 = require("@signageos/sdk/dist/Console/log");
+const commandDefinition_1 = require("../../Command/commandDefinition");
+const helper_1 = require("../../helper");
+const organizationFacade_1 = require("../../Organization/organizationFacade");
+const runnerFacede_1 = require("../runnerFacede");
+const customScriptFacade_1 = require("../../CustomScript/customScriptFacade");
+const Debug = (0, debug_1.default)('@signageos/cli:Runner:Upload:Command');
+exports.OPTION_LIST = [organizationFacade_1.NO_DEFAULT_ORGANIZATION_OPTION, organizationFacade_1.ORGANIZATION_UID_OPTION];
+exports.runnerUpload = (0, commandDefinition_1.createCommandDefinition)({
+    name: 'upload',
+    description: 'Uploads current runner 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, runnerFacede_1.loadSchemas)(currentDirectory);
+            const runnerVersion = yield (0, runnerFacede_1.ensureRunnerVersion)(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, runnerFacede_1.uploadCode)({
+                    restApi,
+                    workDir: currentDirectory,
+                    platform,
+                    config: platformConfig,
+                    runnerVersion,
+                });
+            }
+            if (!(0, util_1.isDeepStrictEqual)(runnerVersion.configDefinition, config.configDefinition)) {
+                Debug('Config definition is different, updating runner version.');
+                yield restApi.runner.version.update({
+                    runnerUid: runnerVersion.runnerUid,
+                    version: runnerVersion.version,
+                    configDefinition: config.configDefinition,
+                    input: schema.input,
+                    output: schema.output,
+                    description: config.description,
+                });
+            }
+            else {
+                Debug('Config definition is the same, skipping update.');
+            }
+            (0, log_1.log)('info', `Runner ${chalk_1.default.green(config.name)} version ${chalk_1.default.green(config.version)} has been uploaded.`);
+        });
+    },
+});

package/dist/Runner/runnerCommand.d.ts

@@ -0,0 +1,27 @@
+export declare const runner: {
+    name: "runner";
+    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/runnerUploadCommand").OPTION_LIST>): Promise<void>;
+    })[];
+    run(): Promise<never>;
+};

package/dist/Runner/runnerCommand.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.runner = void 0;
+const commandDefinition_1 = require("../Command/commandDefinition");
+const runnerGenerateCommand_1 = require("./Generate/runnerGenerateCommand");
+const runnerUploadCommand_1 = require("./Upload/runnerUploadCommand");
+exports.runner = (0, commandDefinition_1.createCommandDefinition)({
+    name: 'runner',
+    description: 'Runner management',
+    optionList: [],
+    commands: [runnerGenerateCommand_1.runnerGenerate, runnerUploadCommand_1.runnerUpload],
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Unknown command');
+        });
+    },
+});

package/dist/Runner/runnerFacede.d.ts

@@ -0,0 +1,15 @@
+import RestApi from '@signageos/sdk/dist/RestApi/RestApi';
+import { PlatformConfig } from '../CustomScript/customScriptFacade';
+import { IRunnerVersion } from '@signageos/sdk/dist/RestApi/Runner/Version/IRunnerVersion';
+import z from 'zod';
+import { ConfigSchema } from '../Plugin/pluginFacade';
+export declare function ensureRunnerVersion(restApi: RestApi, config: RunnerConfig, schema: any): Promise<IRunnerVersion>;
+export declare function uploadCode({ restApi, workDir, platform, config, runnerVersion, }: {
+    restApi: RestApi;
+    workDir: string;
+    platform: string;
+    config: PlatformConfig;
+    runnerVersion: IRunnerVersion;
+}): Promise<void>;
+export declare function loadSchemas(workDir: string): Promise<any>;
+export type RunnerConfig = z.infer<typeof ConfigSchema>;