@superblocksteam/cli 0.0.11

package/dist/common/authenticated-command.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticatedApplicationCommand = exports.AuthenticatedCommand = void 0;
+const core_1 = require("@oclif/core");
+const sdk_1 = require("@superblocksteam/sdk");
+const util_1 = require("@superblocksteam/util");
+class AuthenticatedCommand extends core_1.Command {
+    async init() {
+        await super.init();
+        try {
+            const { token, superblocksBaseUrl } = await (0, util_1.getLocalTokenWithUrl)();
+            this.sdk = new sdk_1.SuperblocksSdk(token, superblocksBaseUrl);
+        }
+        catch {
+            this.error("Please run 'superblocks login' first", { exit: 1 });
+        }
+    }
+    async getBaseUrl() {
+        var _a;
+        const authConfig = await (0, util_1.getLocalTokenWithUrlIfExists)();
+        return (_a = authConfig === null || authConfig === void 0 ? void 0 : authConfig.superblocksBaseUrl) !== null && _a !== void 0 ? _a : "";
+    }
+    getSdk() {
+        if (!this.sdk) {
+            throw new Error("SDK not initialized");
+        }
+        return this.sdk;
+    }
+}
+exports.AuthenticatedCommand = AuthenticatedCommand;
+class AuthenticatedApplicationCommand extends AuthenticatedCommand {
+    constructor() {
+        super(...arguments);
+        this.applicationConfig = {
+            configType: "APPLICATION",
+            id: "",
+            defaultPageId: "",
+            apis: {},
+        };
+    }
+    async getEditModeUrl() {
+        const authConfig = await (0, util_1.getLocalTokenWithUrlIfExists)();
+        const baseUrl = authConfig === null || authConfig === void 0 ? void 0 : authConfig.superblocksBaseUrl;
+        return new URL(`/applications/${this.applicationConfig.id}/pages/${this.applicationConfig.defaultPageId}/edit`, baseUrl).toString();
+    }
+    async init() {
+        await super.init();
+        try {
+            this.applicationConfig = await (0, util_1.getSuperblocksApplicationConfigJson)();
+        }
+        catch (error) {
+            this.error(error.message, {
+                exit: 1,
+            });
+        }
+    }
+}
+exports.AuthenticatedApplicationCommand = AuthenticatedApplicationCommand;

package/dist/common/defaults/create-component-defaults.d.ts

@@ -0,0 +1,9 @@
+import { StatefulProperty } from "../types";
+export declare const getDefaultConfigTs: ({ id, name, displayName, statefulPropsRendered, eventHandlersRendered, }: {
+    id: string;
+    name: string;
+    displayName: string;
+    statefulPropsRendered: string;
+    eventHandlersRendered: string;
+}) => string;
+export declare const getDefaultComponentTsx: (statefulProps: StatefulProperty[], eventHandlers: string[]) => string;

package/dist/common/defaults/create-component-defaults.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultComponentTsx = exports.getDefaultConfigTs = void 0;
+const types_1 = require("../../util/types");
+const indent = (str, spaces) => {
+    const spacesString = " ".repeat(spaces);
+    return str
+        .split("\n")
+        .map((line) => `${spacesString}${line}`)
+        .join("\n");
+};
+function renderInputTypeAsTS(name, type, trailingChars, indentSpaces) {
+    return indent(`${name}: ${types_1.inputTypeDefinions[type].tsType}${trailingChars}`, indentSpaces);
+}
+const getDefaultConfigTs = ({ id, name, displayName, statefulPropsRendered, eventHandlersRendered, }) => `import { type ComponentConfig } from "@superblocksteam/cli";
+
+export default {
+  // DO NOT CHANGE THE ID ONCE THE COMPONENT HAS BEEN REGISTERED!
+  id: "${id}",
+  name: "${name}",
+  displayName: "${displayName}",
+  componentPath: "components/${name}/component.tsx",
+  statefulProperties: [${indent(statefulPropsRendered, 4).trim()}],
+  eventHandlers: [${indent(eventHandlersRendered, 4).trim()}],
+} satisfies ComponentConfig;
+`;
+exports.getDefaultConfigTs = getDefaultConfigTs;
+const getDefaultComponentTsx = (statefulProps, eventHandlers) => `import React from "react";
+
+// All stateful properties of your component are defined here.
+// These are the properties which are surfaced in the Superblocks properties panel
+// and can be referenced throughout your Superblocks Application
+interface StatefulProperties {
+${statefulProps
+    .map((v) => renderInputTypeAsTS(v.path, v.inputType, ";", 2) + "\n")
+    .join("")}}
+
+interface Props extends StatefulProperties {
+  // Call updateStatefulProperties to update one (or more) of your component's stateful properties.
+  // This will cause the component to rerender, and will also notify any other components
+  // in your Application which depend on the updated properties, so they also rerender
+  updateStatefulProperties: (props: Partial<StatefulProperties>) => void;
+
+  // Call the subsequent function(s) to trigger event(s) in Superblocks from your component.
+  // These events can be wired up to event handlers in your Superblocks App
+${eventHandlers.length === 0
+    ? "  // Note: no event handlers defined\n"
+    : eventHandlers.map((v) => indent(v, 2) + ": () => void;" + "\n").join("")}}
+
+export default function Component({
+  updateStatefulProperties${statefulProps.length > 0
+    ? ",\n" + statefulProps.map((v) => indent(v.path, 2)).join(",\n")
+    : ""}${eventHandlers.length > 0
+    ? ",\n" + eventHandlers.map((v) => indent(v, 2)).join(",\n")
+    : ""}
+}: Props) {
+  return <div>Hello World!</div>;
+}
+`;
+exports.getDefaultComponentTsx = getDefaultComponentTsx;

package/dist/common/types.d.ts

@@ -0,0 +1,7 @@
+import { type InputType } from "../util/types";
+export interface StatefulProperty {
+    label: string;
+    path: string;
+    inputType: InputType;
+    placeholder?: string;
+}

package/dist/common/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/version-control.d.ts

@@ -0,0 +1,21 @@
+import { ViewMode } from "@superblocksteam/sdk";
+import { VersionedResourceConfig } from "@superblocksteam/util";
+export type SuperblocksMetadata = {
+    cliVersion: string;
+    remote: string;
+    lastUpdated: number;
+    created: number;
+};
+export declare const LIVE_MODE = "live";
+export declare const modeFlagValues: string[];
+export declare function modeFlagToViewMode(modeFlag: ModeFlag): ViewMode;
+export type ModeFlag = (typeof modeFlagValues)[number];
+export declare const commonFlags: {
+    mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+};
+export declare const SELECT_PROMPT_HELP = "Use \u2191/\u2193 arrow keys, Enter to confirm";
+export declare const MULTI_SELECT_PROMPT_HELP = "Use \u2191/\u2193 arrow keys, Space to select, Enter to confirm";
+export declare const atLeastOneSelection: (value: string[]) => string | true;
+export declare function writeResourceToDisk(resourceType: string, resourceId: string, resource: any, now: number, rootPath: string, existingRelativeLocation?: string): Promise<VersionedResourceConfig>;
+export declare function getMode(task: any, mode: ModeFlag): Promise<ViewMode>;
+export declare function sortByKey(obj: unknown): unknown;

package/dist/common/version-control.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByKey = exports.getMode = exports.writeResourceToDisk = exports.atLeastOneSelection = exports.MULTI_SELECT_PROMPT_HELP = exports.SELECT_PROMPT_HELP = exports.commonFlags = exports.modeFlagToViewMode = exports.modeFlagValues = exports.LIVE_MODE = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const core_1 = require("@oclif/core");
+const util_1 = require("@superblocksteam/util");
+const colorette_1 = require("colorette");
+const fs = tslib_1.__importStar(require("fs-extra"));
+const lodash_1 = require("lodash");
+const lodash_2 = tslib_1.__importDefault(require("lodash"));
+const slugify_1 = tslib_1.__importDefault(require("slugify"));
+const yaml_1 = require("yaml");
+exports.LIVE_MODE = "live";
+exports.modeFlagValues = [exports.LIVE_MODE, "latest", "deployed"];
+function modeFlagToViewMode(modeFlag) {
+    switch (modeFlag) {
+        case exports.LIVE_MODE:
+            return "export-live";
+        case "latest":
+            return "export-latest";
+        case "deployed":
+            return "export-deployed";
+        default:
+            throw new Error(`Unsupported mode flag: ${modeFlag}`);
+    }
+}
+exports.modeFlagToViewMode = modeFlagToViewMode;
+exports.commonFlags = {
+    mode: core_1.Flags.string({
+        char: "m",
+        description: "Pull mode",
+        options: exports.modeFlagValues,
+    }),
+};
+exports.SELECT_PROMPT_HELP = "Use ↑/↓ arrow keys, Enter to confirm";
+exports.MULTI_SELECT_PROMPT_HELP = "Use ↑/↓ arrow keys, Space to select, Enter to confirm";
+const atLeastOneSelection = (value) => {
+    if ((0, lodash_1.isEmpty)(value)) {
+        return `Please select at least one item ${(0, colorette_1.bold)("by pressing space")}`;
+    }
+    return true;
+};
+exports.atLeastOneSelection = atLeastOneSelection;
+function slugifyName(originalName) {
+    return (0, slugify_1.default)(originalName, {
+        replacement: "_",
+        lower: true,
+    });
+}
+async function writeResourceToDisk(resourceType, resourceId, resource, now, rootPath, existingRelativeLocation) {
+    var _a;
+    switch (resourceType) {
+        case "APPLICATION": {
+            const parentDirName = "apps";
+            const newRelativeLocation = `${parentDirName}/${slugifyName(resource.application.name)}`;
+            const relativeLocation = existingRelativeLocation !== null && existingRelativeLocation !== void 0 ? existingRelativeLocation : newRelativeLocation;
+            const appDirName = node_path_1.default.resolve(rootPath, relativeLocation);
+            if (!(await fs.pathExists(appDirName))) {
+                await fs.mkdir(appDirName, { recursive: true });
+            }
+            const applicationContent = (0, yaml_1.stringify)(resource.application, {
+                sortMapEntries: true,
+            });
+            await fs.outputFile(`${appDirName}/application.yaml`, applicationContent);
+            if (resource.page) {
+                const pageContent = (0, yaml_1.stringify)(resource.page, {
+                    sortMapEntries: true,
+                });
+                await fs.outputFile(`${appDirName}/page.yaml`, pageContent);
+            }
+            const apiPromises = [];
+            const apisDirName = `${appDirName}/apis`;
+            await fs.ensureDir(apisDirName);
+            const applicationConfig = {
+                configType: "APPLICATION",
+                apis: {},
+                defaultPageId: (_a = resource.page) === null || _a === void 0 ? void 0 : _a.id,
+                id: resource.application.id,
+            };
+            if (resource.apis) {
+                for (const api of resource.apis) {
+                    const apiContent = (0, yaml_1.stringify)(api, {
+                        sortMapEntries: true,
+                    });
+                    const handleApi = async () => {
+                        await fs.outputFile(`${apisDirName}/${slugifyName(api.actions.name)}.yaml`, apiContent);
+                    };
+                    apiPromises.push(handleApi());
+                    applicationConfig.apis[api.id] = api.actions.name;
+                }
+                await Promise.all(apiPromises);
+            }
+            await fs.ensureDir(`${appDirName}/${util_1.SUPERBLOCKS_HOME_FOLDER_NAME}`);
+            await fs.writeFile(`${appDirName}/${util_1.RESOURCE_CONFIG_PATH}`, JSON.stringify(sortByKey(applicationConfig), null, 2));
+            return {
+                location: relativeLocation,
+                lastUpdated: now,
+                resourceType: "APPLICATION",
+            };
+        }
+        case "BACKEND": {
+            const parentDirName = "backends";
+            const newRelativeLocation = `${parentDirName}/${slugifyName(resource.actions.name)}`;
+            const relativeLocation = existingRelativeLocation !== null && existingRelativeLocation !== void 0 ? existingRelativeLocation : newRelativeLocation;
+            const backendDirName = node_path_1.default.resolve(rootPath, relativeLocation);
+            if (!(await fs.pathExists(backendDirName))) {
+                await fs.mkdir(backendDirName, { recursive: true });
+            }
+            const backendContent = (0, yaml_1.stringify)(resource, {
+                sortMapEntries: true,
+            });
+            await fs.outputFile(`${backendDirName}/api.yaml`, backendContent);
+            const backendConfig = {
+                id: resourceId,
+                configType: "BACKEND",
+            };
+            await fs.ensureDir(`${backendDirName}/${util_1.SUPERBLOCKS_HOME_FOLDER_NAME}`);
+            await fs.writeFile(`${backendDirName}/${util_1.RESOURCE_CONFIG_PATH}`, JSON.stringify(sortByKey(backendConfig), null, 2));
+            return {
+                location: relativeLocation,
+                lastUpdated: now,
+                resourceType: "BACKEND",
+            };
+        }
+        default: {
+            throw new Error(`Unsupported resource type: ${resourceType}`);
+        }
+    }
+}
+exports.writeResourceToDisk = writeResourceToDisk;
+async function getMode(task, mode) {
+    if (mode) {
+        return modeFlagToViewMode(mode);
+    }
+    const selectedMode = await task.prompt([
+        {
+            type: "Select",
+            name: "mode",
+            message: `Select fetch mode (${exports.SELECT_PROMPT_HELP})`,
+            choices: exports.modeFlagValues.map((mode) => ({
+                name: mode,
+                message: mode,
+            })),
+            initial: 0,
+            multiple: false,
+        },
+    ]);
+    return modeFlagToViewMode(selectedMode);
+}
+exports.getMode = getMode;
+function sortByKey(obj) {
+    if (lodash_2.default.isArray(obj)) {
+        return obj.map((item) => sortByKey(item));
+    }
+    if (lodash_2.default.isObject(obj)) {
+        const sortedKeys = Object.keys(obj).sort();
+        const sortedObj = {};
+        for (const key of sortedKeys) {
+            sortedObj[key] = sortByKey(lodash_2.default.get(obj, key));
+        }
+        return sortedObj;
+    }
+    return obj;
+}
+exports.sortByKey = sortByKey;

package/dist/exportedTypes.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { type UUID } from "crypto";
+import { type StatefulProperty } from "./common/types";
+export interface ComponentConfig {
+    id: UUID;
+    name: string;
+    displayName: string;
+    componentPath: string;
+    statefulProperties: StatefulProperty[];
+    /**
+     * Example: [{
+     *  label: "On Click",
+     *  path: "onClick",
+     * }]
+     */
+    eventHandlers: Array<{
+        label: string;
+        path: string;
+    }>;
+}

package/dist/exportedTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { run } from "@oclif/core";
+export * from "./exportedTypes";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const tslib_1 = require("tslib");
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
+tslib_1.__exportStar(require("./exportedTypes"), exports);

package/dist/util/identifiers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Suggest an identifier based on a label, e.g. `My Component` -> `myComponent`.
+ * @param label The label to suggest an identifier for.
+ * @param capitalizeFirst Whether to capitalize the first letter of the identifier.
+ */
+export declare function suggestIdentifier(label: string, capitalizeFirst?: boolean): string;
+export declare function isValidIdentifier(str: string): boolean;

package/dist/util/identifiers.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidIdentifier = exports.suggestIdentifier = void 0;
+// convert a string to upper camel case, e.g. "123 & this is my component, foo-bar" -> "123ThisIsMyComponentFooBar"
+function wordsToUpperCamelCase(str) {
+    return str
+        .split(/[^A-Za-z0-9_]+/)
+        .filter(Boolean)
+        .map((word) => word[0].toUpperCase() + word.slice(1))
+        .join("");
+}
+const digits = "Zero One Two Three Four Five Six Seven Eight Nine".split(" ");
+// convert digits to words, e.g. "123" -> "OneTwoThree"
+function digitsToWords(str) {
+    return str.replace(/\d/g, (char) => { var _a; return (_a = digits[parseInt(char, 10)]) !== null && _a !== void 0 ? _a : char; });
+}
+/**
+ * Suggest an identifier based on a label, e.g. `My Component` -> `myComponent`.
+ * @param label The label to suggest an identifier for.
+ * @param capitalizeFirst Whether to capitalize the first letter of the identifier.
+ */
+function suggestIdentifier(label, capitalizeFirst = false) {
+    const upperCamelCase = wordsToUpperCamelCase(label)
+        // convert any digits at the start of the string to words as these are not valid in identifiers
+        .replace(/^\d+/, digitsToWords);
+    if (capitalizeFirst) {
+        return upperCamelCase;
+    }
+    else {
+        return upperCamelCase[0].toLowerCase() + upperCamelCase.slice(1);
+    }
+}
+exports.suggestIdentifier = suggestIdentifier;
+function isValidIdentifier(str) {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(str);
+}
+exports.isValidIdentifier = isValidIdentifier;

package/dist/util/prompt.d.ts

@@ -0,0 +1,7 @@
+import { IPromptOptions } from "@oclif/core/lib/cli-ux";
+type ValidatorFn = (input: string) => string | boolean;
+/**
+ * A wrapper around `oclif`'s `ux.prompt` function that allows for validation of user responses.
+ */
+export declare function validatedPrompt(name: string, options: IPromptOptions | undefined, validator: ValidatorFn | RegExp): Promise<string>;
+export {};

package/dist/util/prompt.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatedPrompt = void 0;
+const core_1 = require("@oclif/core");
+/**
+ * A wrapper around `oclif`'s `ux.prompt` function that allows for validation of user responses.
+ */
+async function validatedPrompt(name, options, validator) {
+    let validatorFn;
+    if (validator === undefined) {
+        validatorFn = () => true;
+    }
+    else if (validator instanceof RegExp) {
+        validatorFn = (response) => validator.test(response);
+    }
+    else {
+        validatorFn = validator;
+    }
+    for (;;) {
+        const response = await core_1.ux.prompt(name, options);
+        const validationResult = validatorFn(response);
+        if (typeof validationResult === "string") {
+            core_1.ux.log(`Error: ${validationResult}`);
+        }
+        else if (validationResult === false) {
+            core_1.ux.log("Error: Invalid response");
+        }
+        else {
+            return response;
+        }
+    }
+}
+exports.validatedPrompt = validatedPrompt;

package/dist/util/types.d.ts

@@ -0,0 +1,9 @@
+export declare const supportedInputTypes: readonly ["text", "number", "boolean", "js"];
+export type InputType = (typeof supportedInputTypes)[number];
+interface TypeInfo {
+    tsType: string;
+    prompt: string;
+}
+export declare const inputTypeDefinions: Record<InputType, TypeInfo>;
+export declare function isValidInputType(input: string): input is InputType;
+export {};

package/dist/util/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidInputType = exports.inputTypeDefinions = exports.supportedInputTypes = void 0;
+exports.supportedInputTypes = ["text", "number", "boolean", "js"];
+exports.inputTypeDefinions = {
+    text: {
+        tsType: "string",
+        prompt: "text",
+    },
+    number: {
+        tsType: "number",
+        prompt: "number",
+    },
+    boolean: {
+        tsType: "boolean",
+        prompt: "boolean",
+    },
+    js: {
+        tsType: "any",
+        prompt: "any (raw js expression)",
+    },
+};
+function isValidInputType(input) {
+    return Object.prototype.hasOwnProperty.call(exports.inputTypeDefinions, input);
+}
+exports.isValidInputType = isValidInputType;

package/oclif.manifest.json

@@ -0,0 +1,151 @@
+{
+  "version": "0.0.11",
+  "commands": {
+    "init": {
+      "id": "init",
+      "description": "Interactively configure the current directory as a Superblocks project or initialize new services in an already configured Superblocks project directory",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> https://app.superblocks.com/applications/11111111-1111-1111-1111-111111111111/pages/22222222-2222-2222-2222-222222222222"
+      ],
+      "flags": {
+        "mode": {
+          "name": "mode",
+          "type": "option",
+          "char": "m",
+          "description": "Pull mode",
+          "multiple": false,
+          "options": [
+            "live",
+            "latest",
+            "deployed"
+          ]
+        }
+      },
+      "args": {
+        "resourceUrl": {
+          "name": "resourceUrl",
+          "description": "Superblocks resource URL (i.e. https://app.superblocks.com/applications/<application_id>/pages/<page_id>)",
+          "required": false
+        }
+      }
+    },
+    "login": {
+      "id": "login",
+      "description": "Authenticates with Superblocks cloud",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {
+        "token": {
+          "name": "token",
+          "type": "option",
+          "char": "t",
+          "description": "Superblocks user access token",
+          "multiple": false
+        },
+        "superblocksBaseUrl": {
+          "name": "superblocksBaseUrl",
+          "type": "option",
+          "char": "b",
+          "description": "Superblocks base URL",
+          "multiple": false
+        }
+      },
+      "args": {}
+    },
+    "pull": {
+      "id": "pull",
+      "description": "Download objects from Superblocks and save them locally",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %>  apps/my-app",
+        "<%= config.bin %> <%= command.id %>  backends/my-workflow",
+        "<%= config.bin %> <%= command.id %>  backends/my-scheduled-job"
+      ],
+      "flags": {
+        "mode": {
+          "name": "mode",
+          "type": "option",
+          "char": "m",
+          "description": "Pull mode",
+          "multiple": false,
+          "options": [
+            "live",
+            "latest",
+            "deployed"
+          ]
+        }
+      },
+      "args": {
+        "only": {
+          "name": "only",
+          "description": "Superblocks resource location to pull (i.e. apps/my-app or backends/my-workflow)",
+          "required": false
+        }
+      }
+    },
+    "components:create": {
+      "id": "components:create",
+      "description": "Creates a new Superblocks component in the current application folder",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {},
+      "args": {}
+    },
+    "components:register": {
+      "id": "components:register",
+      "description": "Registers all local component config files",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "superblocks components register"
+      ],
+      "flags": {},
+      "args": {}
+    },
+    "components:upload": {
+      "id": "components:upload",
+      "description": "Upload creates a production-ready bundle and saves the files for use outside of Local Development mode.",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "<%= config.bin %> components upload"
+      ],
+      "flags": {},
+      "args": {}
+    },
+    "components:watch": {
+      "id": "components:watch",
+      "description": "watch for changes to your custom components",
+      "strict": true,
+      "pluginName": "@superblocksteam/cli",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {},
+      "args": {}
+    }
+  }
+}