@superblocksteam/cli 0.0.11

package/dist/commands/components/watch.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.healthEndpointMiddleware = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const util_1 = require("@superblocksteam/util");
+const vite_custom_component_reload_plugin_1 = require("@superblocksteam/vite-custom-component-reload-plugin");
+const plugin_react_1 = tslib_1.__importDefault(require("@vitejs/plugin-react"));
+const colorette_1 = require("colorette");
+const vite_1 = require("vite");
+const vite_plugin_externals_1 = require("vite-plugin-externals");
+const authenticated_command_1 = require("../../common/authenticated-command");
+function healthEndpointMiddleware() {
+    return {
+        name: "health-endpoint-middleware",
+        configureServer: (server) => {
+            server.middlewares.use("/health", (req, res) => {
+                res.setHeader("Cache-Control", "no-cache");
+                res.setHeader("Content-Type", "application/json");
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                const response = {
+                    status: "up",
+                    uptime: Math.floor(process.uptime()),
+                };
+                res.write(JSON.stringify(response) + "\n");
+                res.end();
+            });
+        },
+    };
+}
+exports.healthEndpointMiddleware = healthEndpointMiddleware;
+class Watch extends authenticated_command_1.AuthenticatedApplicationCommand {
+    async run() {
+        core_1.ux.action.start("Registering components...");
+        const components = await (0, util_1.getComponentConfigs)();
+        await this.getSdk().registerComponents(this.applicationConfig.id, components);
+        core_1.ux.action.stop();
+        this.log((0, colorette_1.yellow)("Remember to refresh your application to see any newly registered components."));
+        this.log();
+        this.log((0, colorette_1.green)(`Visit ${await this.getBaseUrl()} and access your application in edit mode to see your components! 🐨`));
+        const port = 3002;
+        const editModeUrl = await this.getEditModeUrl();
+        const viteLogger = (0, vite_1.createLogger)();
+        viteLogger.info = (message) => {
+            this.log(message);
+        };
+        viteLogger.warn = (msg) => {
+            this.log((0, colorette_1.yellow)(msg));
+        };
+        viteLogger.warnOnce = (msg) => {
+            this.log((0, colorette_1.yellow)(msg));
+        };
+        viteLogger.error = (msg) => {
+            this.log((0, colorette_1.red)(msg));
+        };
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        viteLogger.clearScreen = () => { };
+        await (async () => {
+            const server = await (0, vite_1.createServer)({
+                configFile: false,
+                build: {
+                    rollupOptions: {
+                        input: [
+                        // eslint-disable-next-line no-warning-comments
+                        /* TODO */
+                        ],
+                        preserveEntrySignatures: "strict",
+                        output: {
+                            entryFileNames: "[name].js",
+                        },
+                    },
+                    copyPublicDir: true,
+                    write: true,
+                },
+                base: `http://localhost:${port}`,
+                server: {
+                    port,
+                },
+                customLogger: viteLogger,
+                plugins: [
+                    healthEndpointMiddleware(),
+                    (0, plugin_react_1.default)(),
+                    (0, vite_plugin_externals_1.viteExternalsPlugin)({
+                        react: "React",
+                        "react-dom": "ReactDOM",
+                    }),
+                    (0, vite_custom_component_reload_plugin_1.appendHotReloadEventPlugin)(),
+                ],
+            });
+            await server.listen();
+            this.log((0, colorette_1.green)(`Local server started at port ${port}`));
+            this.log((0, colorette_1.green)(`Visit your application at:`));
+            this.log();
+            this.log((0, colorette_1.bgGreen)((0, colorette_1.bold)((0, colorette_1.white)(`${editModeUrl}?devMode=true`))));
+            this.log();
+            this.log((0, colorette_1.yellow)("Remember to refresh your already open Application page and turn on local development in Superblocks to connect to your local server!"));
+        })();
+    }
+}
+Watch.description = "watch for changes to your custom components";
+exports.default = Watch;

package/dist/commands/init.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../common/authenticated-command";
+export default class Initialize extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        resourceUrl: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private createTasks;
+    private getResourcesToInitialize;
+    private findDuplicates;
+}

package/dist/commands/init.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const util_1 = require("@superblocksteam/util");
+const fs = tslib_1.__importStar(require("fs-extra"));
+const listr2_1 = require("listr2");
+const lodash_1 = require("lodash");
+const authenticated_command_1 = require("../common/authenticated-command");
+const version_control_1 = require("../common/version-control");
+class Initialize extends authenticated_command_1.AuthenticatedCommand {
+    async run() {
+        const { flags, args } = await this.parse(Initialize);
+        const tasks = this.createTasks(flags, args);
+        try {
+            await tasks.run();
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+    }
+    createTasks(flags, args) {
+        const tasks = new listr2_1.Listr([
+            {
+                title: "Checking for existing Superblocks project...",
+                task: async (ctx) => {
+                    ctx.fetchedResources = {};
+                    ctx.writtenResources = {};
+                    ctx.now = Date.now();
+                    try {
+                        ctx.existingSuperblocksConfig = (await (0, util_1.getSuperblocksMonorepoConfigJson)())[0];
+                    }
+                    catch {
+                        // no existing superblocks config
+                    }
+                },
+            },
+            {
+                title: "Fetching applications, workflows and scheduled jobs...",
+                task: (ctx, task) => task.newListr([
+                    {
+                        title: "Fetching applications...",
+                        task: async (ctx, task) => {
+                            if (args.resourceUrl) {
+                                task.skip("Skipping fetching applications");
+                            }
+                            // applications choices
+                            const applications = await this.getSdk().fetchApplications();
+                            for (const app of applications) {
+                                if (app.isEditable) {
+                                    0;
+                                    ctx.fetchedResources[app.id] = {
+                                        resourceType: "APPLICATION",
+                                        name: app.name,
+                                    };
+                                }
+                            }
+                            task.title += `: completed`;
+                        },
+                    },
+                ]),
+            },
+            {
+                title: "Selecting resources to initialize...",
+                task: async (ctx, task) => {
+                    const viewMode = await (0, version_control_1.getMode)(task, flags.mode);
+                    ctx.viewMode = viewMode;
+                    const resourceIdsToInitialize = await this.getResourcesToInitialize(ctx, task, args);
+                    ctx.resourceIdsToInitialize = resourceIdsToInitialize;
+                },
+            },
+            {
+                title: "Writing resources to a disk...",
+                task: async (ctx, task) => {
+                    const subtasks = [];
+                    const now = Date.now();
+                    for (const resourceId of ctx.resourceIdsToInitialize) {
+                        const resource = ctx.fetchedResources[resourceId];
+                        switch (resource.resourceType) {
+                            case "APPLICATION": {
+                                subtasks.push({
+                                    title: `Fetching application ${resource.name}...`,
+                                    task: async (_ctx, task) => {
+                                        const application = await this.getSdk().fetchApplication(resourceId, ctx.viewMode);
+                                        task.title += `: fetched`;
+                                        ctx.writtenResources[resourceId] =
+                                            await (0, version_control_1.writeResourceToDisk)("APPLICATION", resourceId, application, now, process.cwd());
+                                        task.title += `: done`;
+                                    },
+                                });
+                                break;
+                            }
+                            case "BACKEND": {
+                                subtasks.push({
+                                    title: `Fetching backend ${resource.name}...`,
+                                    task: async (_ctx, task) => {
+                                        const backend = await this.getSdk().fetchApi(resourceId, ctx.viewMode);
+                                        task.title += `: fetched`;
+                                        ctx.writtenResources[resourceId] =
+                                            await (0, version_control_1.writeResourceToDisk)("BACKEND", resourceId, backend, now, process.cwd());
+                                        task.title += `: done`;
+                                    },
+                                });
+                                break;
+                            }
+                            default: {
+                                this.error(`Unsupported resource type, resurce: ${JSON.stringify(resource)}`);
+                            }
+                        }
+                    }
+                    return task.newListr(subtasks, {
+                        concurrent: true,
+                    });
+                },
+            },
+            {
+                title: "Updating Superblocks project file...",
+                task: async (ctx) => {
+                    var _a, _b, _c, _d;
+                    const superblocksConfig = {
+                        configType: "ROOT",
+                        resources: {},
+                        metadata: {
+                            cliVersion: this.config.version,
+                            remote: this.getSdk().superblocksBaseUrl,
+                            lastUpdated: ctx.now,
+                            created: (_b = (_a = ctx.existingSuperblocksConfig) === null || _a === void 0 ? void 0 : _a.metadata.created) !== null && _b !== void 0 ? _b : ctx.now,
+                        },
+                    };
+                    superblocksConfig.metadata.lastUpdated = ctx.now;
+                    // new resources
+                    for (const [resourceId, resource] of Object.entries(ctx.writtenResources)) {
+                        superblocksConfig.resources[resourceId] = resource;
+                    }
+                    // existing resources
+                    for (const [resourceId, resource] of Object.entries((_d = (_c = ctx.existingSuperblocksConfig) === null || _c === void 0 ? void 0 : _c.resources) !== null && _d !== void 0 ? _d : {})) {
+                        superblocksConfig.resources[resourceId] = resource;
+                    }
+                    if (!(await fs.exists(util_1.SUPERBLOCKS_HOME_FOLDER_NAME))) {
+                        await fs.mkdir(util_1.SUPERBLOCKS_HOME_FOLDER_NAME);
+                    }
+                    // create superblocks.json file
+                    await fs.writeFile(util_1.RESOURCE_CONFIG_PATH, JSON.stringify((0, version_control_1.sortByKey)(superblocksConfig), null, 2));
+                },
+            },
+        ], {
+            concurrent: false,
+        });
+        return tasks;
+    }
+    async getResourcesToInitialize(ctx, task, args) {
+        var _a, _b;
+        if (args.resourceUrl) {
+            try {
+                const resourceUrl = new URL(args.resourceUrl);
+                if (resourceUrl.pathname.startsWith("/applications") ||
+                    resourceUrl.pathname.startsWith("/workflows") ||
+                    resourceUrl.pathname.startsWith("/scheduled-jobs")) {
+                    return [resourceUrl.pathname.split("/")[2]];
+                }
+                throw new Error(`Failed to parse resource URL: ${args.resourceUrl}`);
+            }
+            catch {
+                throw new Error(`Invalid resource URL: ${args.resourceUrl}`);
+            }
+        }
+        else {
+            const choices = [];
+            const initialSelections = [];
+            let counter = 0;
+            for (const [resourceId, resource] of Object.entries(ctx.fetchedResources)) {
+                choices.push({
+                    name: resourceId,
+                    message: `${resource.name} (${resource.resourceType})`,
+                    disabled: (_a = ctx.existingSuperblocksConfig) === null || _a === void 0 ? void 0 : _a.resources[resourceId],
+                });
+                if ((_b = ctx.existingSuperblocksConfig) === null || _b === void 0 ? void 0 : _b.resources[resourceId]) {
+                    initialSelections.push(counter);
+                }
+                counter++;
+            }
+            const resourceIdsToInitialize = await task.prompt([
+                {
+                    type: "AutoComplete",
+                    name: "resourceIdsToInitialize",
+                    message: `Select resources to initialize (${version_control_1.MULTI_SELECT_PROMPT_HELP})`,
+                    choices: choices,
+                    initial: initialSelections,
+                    multiple: true,
+                    validate: version_control_1.atLeastOneSelection,
+                    prefix: "▸",
+                    indicator: "◉",
+                },
+            ]);
+            const duplicates = await this.findDuplicates(resourceIdsToInitialize, ctx.fetchedResources);
+            if (!(0, lodash_1.isEmpty)(duplicates)) {
+                this.error(`Duplicate resources selected: ${duplicates
+                    .map((duplicate) => `${duplicate.name} (${duplicate.resourceType}) id: ${duplicate.id}`)
+                    .join(", ")}. Please make sure to select unique resources or rename them so that they have unique names.`);
+            }
+            // filter out disabled resources
+            return resourceIdsToInitialize.filter((resourceId) => { var _a; return !((_a = ctx.existingSuperblocksConfig) === null || _a === void 0 ? void 0 : _a.resources[resourceId]); });
+        }
+    }
+    async findDuplicates(selectedResourcesIds, resources) {
+        const selectedResources = selectedResourcesIds
+            .map((id) => {
+            return { ...resources[id], id };
+        })
+            .filter((resource) => resource !== undefined);
+        const countResourceNamesByType = {};
+        for (const resource of selectedResources) {
+            if (!countResourceNamesByType[resource.resourceType]) {
+                countResourceNamesByType[resource.resourceType] = {};
+            }
+            if (countResourceNamesByType[resource.resourceType][resource.name]) {
+                countResourceNamesByType[resource.resourceType][resource.name] += 1;
+            }
+            else {
+                countResourceNamesByType[resource.resourceType][resource.name] = 1;
+            }
+        }
+        return selectedResources.filter((resource) => countResourceNamesByType[resource.resourceType][resource.name] > 1);
+    }
+}
+Initialize.description = "Interactively configure the current directory as a Superblocks project or initialize new services in an already configured Superblocks project directory";
+Initialize.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",
+];
+Initialize.flags = version_control_1.commonFlags;
+Initialize.args = {
+    resourceUrl: core_1.Args.string({
+        description: "Superblocks resource URL (i.e. https://app.superblocks.com/applications/<application_id>/pages/<page_id>)",
+        required: false,
+    }),
+};
+exports.default = Initialize;

package/dist/commands/login.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@oclif/core";
+export default class Login extends Command {
+    static description: string;
+    static flags: {
+        token: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        superblocksBaseUrl: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/login.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const sdk_1 = require("@superblocksteam/sdk");
+const util_1 = require("@superblocksteam/util");
+const colorette_1 = require("colorette");
+// eslint-disable-next-line unicorn/prefer-module -- enquirer is not ESM
+const { Select } = require("enquirer");
+class Login extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Login);
+        let token = flags.token;
+        let superblocksBaseUrl = flags.superblocksUrl;
+        if (!token) {
+            const result = await (0, util_1.getLocalTokenWithUrlIfExists)();
+            if (result) {
+                ({ token, superblocksBaseUrl } = result);
+            }
+            else {
+                const customChoice = "Custom (enter your own)";
+                const selectPrompt = new Select({
+                    message: "Select the Superblocks base URL",
+                    choices: [
+                        "https://app.superblocks.com/",
+                        "https://eu.superblocks.com/",
+                        customChoice,
+                    ],
+                });
+                superblocksBaseUrl = await selectPrompt.run();
+                if (superblocksBaseUrl === customChoice) {
+                    superblocksBaseUrl = await core_1.ux.prompt("Enter the Superblocks base URL (then press Enter)", { type: "normal" });
+                }
+                const tokenPageUrl = new URL("personal-settings#profile", superblocksBaseUrl).href;
+                token = await core_1.ux.prompt(`Enter your Superblocks access token (then press Enter) which can be found at ${tokenPageUrl}`, { type: "mask" });
+            }
+        }
+        this.log();
+        try {
+            const sdk = new sdk_1.SuperblocksSdk(token, superblocksBaseUrl);
+            const user = await sdk.fetchCurrentUser();
+            await (0, util_1.saveApiToken)(token, superblocksBaseUrl);
+            this.log((0, colorette_1.green)(`Welcome to the Superblocks 🐨 CLI ${user.name}!`));
+        }
+        catch (error) {
+            if (error.name === util_1.ERROR_FILE_ACCESS) {
+                this.log((0, colorette_1.red)("Could not save token, ensure the Superblocks CLI has access to create folders in your home directory."));
+                return;
+            }
+            this.log((0, colorette_1.red)("Invalid token supplied."));
+        }
+    }
+}
+Login.description = "Authenticates with Superblocks cloud";
+Login.flags = {
+    // flag with a value (-t, --token=VALUE)
+    token: core_1.Flags.string({
+        char: "t",
+        description: "Superblocks user access token",
+    }),
+    // flag with a value (-b, --superblocksBaseUrl=VALUE)
+    superblocksBaseUrl: core_1.Flags.string({
+        char: "b",
+        description: "Superblocks base URL",
+    }),
+};
+exports.default = Login;

package/dist/commands/pull.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../common/authenticated-command";
+export default class Pull extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        only: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private createTasks;
+    private getResourceIdsToPull;
+}

package/dist/commands/pull.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 fs = tslib_1.__importStar(require("fs-extra"));
+const listr2_1 = require("listr2");
+const authenticated_command_1 = require("../common/authenticated-command");
+const version_control_1 = require("../common/version-control");
+class Pull extends authenticated_command_1.AuthenticatedCommand {
+    async run() {
+        const { flags, args } = await this.parse(Pull);
+        const tasks = this.createTasks(args.only, flags.mode);
+        await tasks.run();
+    }
+    createTasks(only, mode) {
+        const tasks = new listr2_1.Listr([
+            {
+                title: "Checking for existing Superblocks project...",
+                task: async (ctx) => {
+                    ctx.writtenResources = {};
+                    ctx.now = Date.now();
+                    try {
+                        [
+                            ctx.existingSuperblocksRootConfig,
+                            ctx.superblocksRootConfigPath,
+                        ] = await (0, util_1.getSuperblocksMonorepoConfigJson)(true);
+                        ctx.existingSuperblocksResourceConfig =
+                            await (0, util_1.getSuperblocksResourceConfigIfExists)();
+                    }
+                    catch {
+                        // no existing superblocks config
+                        this.error("No Superblocks project found in the current folder hierarchy. Run 'superblocks init' to initialize a new project.");
+                    }
+                },
+            },
+            {
+                title: "Pulling resources...",
+                task: async (ctx, task) => {
+                    var _a;
+                    const viewMode = await (0, version_control_1.getMode)(task, mode);
+                    const resourceIdsToPull = await this.getResourceIdsToPull(ctx, task, only);
+                    const subtasks = [];
+                    const now = Date.now();
+                    const superblocksRootPath = node_path_1.default.resolve(node_path_1.default.dirname(ctx.superblocksRootConfigPath), "..");
+                    for (const resourceId of resourceIdsToPull) {
+                        const resource = (_a = ctx.existingSuperblocksRootConfig) === null || _a === void 0 ? void 0 : _a.resources[resourceId];
+                        switch (resource === null || resource === void 0 ? void 0 : resource.resourceType) {
+                            case "APPLICATION": {
+                                subtasks.push({
+                                    title: `Pulling application ${resource.location}...`,
+                                    task: async (_ctx, task) => {
+                                        const application = await this.getSdk().fetchApplication(resourceId, viewMode);
+                                        task.title += `: fetched`;
+                                        ctx.writtenResources[resourceId] =
+                                            await (0, version_control_1.writeResourceToDisk)("APPLICATION", resourceId, application, now, superblocksRootPath, resource.location);
+                                        task.title += `: done`;
+                                    },
+                                });
+                                break;
+                            }
+                            case "BACKEND": {
+                                subtasks.push({
+                                    title: `Fetching backend ${resource.location}...`,
+                                    task: async (_ctx, task) => {
+                                        const backend = await this.getSdk().fetchApi(resourceId, viewMode);
+                                        task.title += `: fetched`;
+                                        ctx.writtenResources[resourceId] =
+                                            await (0, version_control_1.writeResourceToDisk)("BACKEND", resourceId, backend, now, superblocksRootPath, resource.location);
+                                        task.title += `: done`;
+                                    },
+                                });
+                                break;
+                            }
+                            default: {
+                                this.error(`Unsupported resource type, resource: ${JSON.stringify(resource)}
+                    `);
+                            }
+                        }
+                    }
+                    return task.newListr(subtasks, {
+                        concurrent: true,
+                    });
+                },
+            },
+            {
+                title: "Updating Superblocks project file...",
+                task: async (ctx) => {
+                    var _a;
+                    const superblocksRootConfig = {
+                        configType: "ROOT",
+                        resources: ctx.existingSuperblocksRootConfig.resources,
+                        metadata: {
+                            ...(_a = ctx.existingSuperblocksRootConfig) === null || _a === void 0 ? void 0 : _a.metadata,
+                            lastUpdated: ctx.now,
+                        },
+                    };
+                    for (const [resourceId, resource] of Object.entries(ctx.writtenResources)) {
+                        superblocksRootConfig.resources[resourceId] = resource;
+                    }
+                    // update superblocks.json file
+                    await fs.writeFile(ctx.superblocksRootConfigPath, JSON.stringify((0, version_control_1.sortByKey)(superblocksRootConfig), null, 2));
+                },
+            },
+        ], {
+            concurrent: false,
+        });
+        return tasks;
+    }
+    async getResourceIdsToPull(ctx, task, only) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (only) {
+            for (const [resourceId, resource] of Object.entries((_b = (_a = ctx.existingSuperblocksRootConfig) === null || _a === void 0 ? void 0 : _a.resources) !== null && _b !== void 0 ? _b : {})) {
+                if (resource.location === only) {
+                    return [resourceId];
+                }
+            }
+            const resource = Object.entries((_d = (_c = ctx.existingSuperblocksRootConfig) === null || _c === void 0 ? void 0 : _c.resources) !== null && _d !== void 0 ? _d : {}).find(([, resource]) => resource.location === only);
+            if (resource) {
+                return [resource[0]];
+            }
+            throw new Error(`No resource found with the given location: ${only}`);
+        }
+        const choices = [];
+        const initialSelections = [];
+        let counter = 0;
+        for (const [resourceId, resource] of Object.entries((_f = (_e = ctx.existingSuperblocksRootConfig) === null || _e === void 0 ? void 0 : _e.resources) !== null && _f !== void 0 ? _f : {})) {
+            choices.push({
+                name: resourceId,
+                message: `${resource.location} (Last updated at ${new Date(resource.lastUpdated).toLocaleTimeString()})`,
+            });
+            if (((_g = ctx.existingSuperblocksResourceConfig) === null || _g === void 0 ? void 0 : _g.id) === resourceId) {
+                initialSelections.push(counter);
+            }
+            counter++;
+        }
+        const resourceIdsToPull = await task.prompt([
+            {
+                type: "MultiSelect",
+                name: "resourceIdsToPull",
+                message: `Select resources to pull (${version_control_1.MULTI_SELECT_PROMPT_HELP})`,
+                choices: choices,
+                initial: initialSelections,
+                validate: version_control_1.atLeastOneSelection,
+                prefix: "▸",
+                indicator: "◉",
+            },
+        ]);
+        return resourceIdsToPull;
+    }
+}
+Pull.description = "Download objects from Superblocks and save them locally";
+Pull.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",
+];
+Pull.flags = version_control_1.commonFlags;
+Pull.args = {
+    only: core_1.Args.string({
+        description: "Superblocks resource location to pull (i.e. apps/my-app or backends/my-workflow)",
+        required: false,
+    }),
+};
+exports.default = Pull;

package/dist/common/authenticated-command.d.ts

@@ -0,0 +1,14 @@
+import { Command } from "@oclif/core";
+import { SuperblocksSdk } from "@superblocksteam/sdk";
+import { SuperblocksApplicationConfig } from "@superblocksteam/util";
+export declare abstract class AuthenticatedCommand extends Command {
+    private sdk;
+    protected init(): Promise<void>;
+    protected getBaseUrl(): Promise<string>;
+    protected getSdk(): SuperblocksSdk;
+}
+export declare abstract class AuthenticatedApplicationCommand extends AuthenticatedCommand {
+    applicationConfig: SuperblocksApplicationConfig;
+    protected getEditModeUrl(): Promise<string>;
+    protected init(): Promise<void>;
+}