@plasmicapp/cli 0.1.162

package/dist/api.d.ts

@@ -0,0 +1,182 @@
+/// <reference types="socket.io-client" />
+import { ProjectSyncMetadataModel } from "@plasmicapp/code-merger";
+import { AuthConfig, CodeConfig, ImagesConfig, StyleConfig } from "./utils/config-utils";
+import { Metadata } from "./utils/get-context";
+export declare class AppServerError extends Error {
+    constructor(message: string);
+}
+export interface ComponentBundle {
+    renderModule: string;
+    skeletonModule: string;
+    cssRules: string;
+    renderModuleFileName: string;
+    skeletonModuleFileName: string;
+    cssFileName: string;
+    componentName: string;
+    id: string;
+    scheme: string;
+    nameInIdToUuid: Array<[string, string]>;
+    isPage: boolean;
+    plumeType?: string;
+}
+export interface GlobalVariantBundle {
+    id: string;
+    name: string;
+    contextModule: string;
+    contextFileName: string;
+}
+export interface JsBundleTheme {
+    themeFileName: string;
+    themeModule: string;
+    bundleName: string;
+}
+export interface ProjectMetaBundle {
+    projectId: string;
+    projectName: string;
+    cssFileName: string;
+    cssRules: string;
+    jsBundleThemes?: JsBundleTheme[];
+}
+export interface IconBundle {
+    id: string;
+    name: string;
+    module: string;
+    fileName: string;
+}
+export interface ImageBundle {
+    id: string;
+    name: string;
+    blob: string;
+    fileName: string;
+}
+export interface ProjectVersionMeta {
+    projectId: string;
+    projectApiToken: string;
+    version: string;
+    projectName: string;
+    componentIds: string[];
+    dependencies: {
+        [projectId: string]: string;
+    };
+}
+export interface VersionResolution {
+    projects: ProjectVersionMeta[];
+    dependencies: ProjectVersionMeta[];
+    conflicts: ProjectVersionMeta[];
+}
+export interface RequiredPackages {
+    "@plasmicapp/loader": string;
+    "@plasmicapp/cli": string;
+    "@plasmicapp/react-web": string;
+    "@plasmicapp/react-web-runtime": string;
+}
+export interface ProjectBundle {
+    components: ComponentBundle[];
+    codeComponentMetas: CodeComponentMeta[];
+    projectConfig: ProjectMetaBundle;
+    globalVariants: GlobalVariantBundle[];
+    usedTokens: StyleTokensMap;
+    iconAssets: IconBundle[];
+    imageAssets: ImageBundle[];
+    checksums: ChecksumBundle;
+}
+export declare type ProjectMeta = Omit<ProjectBundle, "projectConfig">;
+export interface StyleConfigResponse {
+    defaultStyleCssFileName: string;
+    defaultStyleCssRules: string;
+}
+export interface StyleTokensMap {
+    props: {
+        name: string;
+        type: string;
+        value: string | number;
+        meta: {
+            projectId: string;
+            id: string;
+        };
+    }[];
+    global: {
+        meta: {
+            source: "plasmic.app";
+        };
+    };
+}
+export interface ChecksumBundle {
+    renderModuleChecksums: Array<[string, string]>;
+    cssRulesChecksums: Array<[string, string]>;
+    imageChecksums: Array<[string, string]>;
+    iconChecksums: Array<[string, string]>;
+    globalVariantChecksums: Array<[string, string]>;
+    projectCssChecksum: string;
+}
+export interface CodeComponentMeta {
+    id: string;
+    name: string;
+    importPath: string;
+}
+export interface ProjectIconsResponse {
+    version: string;
+    icons: IconBundle[];
+}
+export interface ProjectIdAndToken {
+    projectId: string;
+    projectApiToken?: string;
+}
+export declare class PlasmicApi {
+    private auth;
+    constructor(auth: AuthConfig);
+    genStyleConfig(styleOpts?: StyleConfig): Promise<StyleConfigResponse>;
+    /**
+     * Sync resolution - Given a fuzzy idea of what the user wants,
+     * (i.e. a versionRange and component names),
+     * ask the server for the exact references for a later call to `projectComponents`
+     * - For components specified in the parameters - the server will return the latest version that satisfies the versionRange
+     * - Any conflicting versions will be returned in `conflicts`, and should cause the client's sync to abort
+     * @param projects
+     * @param recursive
+     */
+    resolveSync(projects: {
+        projectId: string;
+        versionRange?: string;
+        componentIdOrNames: readonly string[] | undefined;
+        projectApiToken?: string;
+    }[], recursive?: boolean): Promise<VersionResolution>;
+    getCurrentUser(): Promise<import("axios").AxiosResponse<any>>;
+    requiredPackages(): Promise<RequiredPackages>;
+    /**
+     * Code-gen endpoint.
+     * This will fetch components at an exact specified version.
+     * If you don't know what version should be used, call `resolveSync` first.
+     * @param projectId
+     * @param cliVersion
+     * @param reactWebVersion
+     * @param newCompScheme
+     * @param existingCompScheme
+     * @param componentIdOrNames
+     * @param version
+     */
+    projectComponents(projectId: string, opts: {
+        platform: string;
+        newCompScheme: "blackbox" | "direct";
+        existingCompScheme: Array<[string, "blackbox" | "direct"]>;
+        componentIdOrNames: readonly string[] | undefined;
+        version: string;
+        imageOpts: ImagesConfig;
+        stylesOpts: StyleConfig;
+        codeOpts: CodeConfig;
+        checksums: ChecksumBundle;
+        metadata?: Metadata;
+    }): Promise<ProjectBundle>;
+    uploadBundle(projectId: string, bundleName: string, bundleJs: string, css: string[], metaJson: string, genModulePath: string | undefined, genCssPaths: string[], pkgVersion: string | undefined, extraPropMetaJson: string | undefined, themeProviderWrapper: string | undefined, themeModule: string | undefined): Promise<StyleTokensMap>;
+    projectStyleTokens(projectId: string, versionRange?: string): Promise<StyleTokensMap>;
+    projectIcons(projectId: string, versionRange?: string, iconIds?: string[]): Promise<ProjectIconsResponse>;
+    projectSyncMetadata(projectId: string, revision: number, rethrowAppError: boolean): Promise<ProjectSyncMetadataModel>;
+    connectSocket(): SocketIOClient.Socket;
+    private post;
+    private makeErrorMessage;
+    private makeHeaders;
+    private projectIdsAndTokens?;
+    attachProjectIdsAndTokens(idsAndTokens: ProjectIdAndToken[]): void;
+    private get studioHost();
+    private get codegenHost();
+}

package/dist/api.js

@@ -0,0 +1,202 @@
+"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.PlasmicApi = exports.AppServerError = void 0;
+const code_merger_1 = require("@plasmicapp/code-merger");
+const axios_1 = __importDefault(require("axios"));
+const socket_io_client_1 = __importDefault(require("socket.io-client"));
+const config_utils_1 = require("./utils/config-utils");
+const error_1 = require("./utils/error");
+class AppServerError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.AppServerError = AppServerError;
+class PlasmicApi {
+    constructor(auth) {
+        this.auth = auth;
+    }
+    genStyleConfig(styleOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.post(`${this.codegenHost}/api/v1/code/style-config`, styleOpts);
+            return result.data;
+        });
+    }
+    /**
+     * Sync resolution - Given a fuzzy idea of what the user wants,
+     * (i.e. a versionRange and component names),
+     * ask the server for the exact references for a later call to `projectComponents`
+     * - For components specified in the parameters - the server will return the latest version that satisfies the versionRange
+     * - Any conflicting versions will be returned in `conflicts`, and should cause the client's sync to abort
+     * @param projects
+     * @param recursive
+     */
+    resolveSync(projects, recursive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.post(`${this.codegenHost}/api/v1/code/resolve-sync`, {
+                projects,
+                recursive,
+            });
+            const versionResolution = resp.data;
+            return Object.assign({}, versionResolution);
+        });
+    }
+    getCurrentUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield axios_1.default.get(`${this.studioHost}/api/v1/auth/self`, {
+                headers: this.makeHeaders(),
+            });
+        });
+    }
+    requiredPackages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.post(`${this.codegenHost}/api/v1/code/required-packages`);
+            return Object.assign({}, resp.data);
+        });
+    }
+    /**
+     * Code-gen endpoint.
+     * This will fetch components at an exact specified version.
+     * If you don't know what version should be used, call `resolveSync` first.
+     * @param projectId
+     * @param cliVersion
+     * @param reactWebVersion
+     * @param newCompScheme
+     * @param existingCompScheme
+     * @param componentIdOrNames
+     * @param version
+     */
+    projectComponents(projectId, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.post(`${this.codegenHost}/api/v1/projects/${projectId}/code/components`, Object.assign({}, opts));
+            return result.data;
+        });
+    }
+    uploadBundle(projectId, bundleName, bundleJs, css, metaJson, genModulePath, genCssPaths, pkgVersion, extraPropMetaJson, themeProviderWrapper, themeModule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.post(`${this.codegenHost}/api/v1/projects/${projectId}/jsbundle/upload`, {
+                projectId,
+                bundleName,
+                bundleJs,
+                css,
+                metaJson,
+                genModulePath,
+                genCssPaths,
+                pkgVersion,
+                extraPropMetaJson,
+                themeProviderWrapper,
+                themeModule,
+            });
+            return result.data;
+        });
+    }
+    projectStyleTokens(projectId, versionRange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.post(`${this.codegenHost}/api/v1/projects/${projectId}/code/tokens`, { versionRange });
+            return result.data;
+        });
+    }
+    projectIcons(projectId, versionRange, iconIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.post(`${this.codegenHost}/api/v1/projects/${projectId}/code/icons`, { versionRange, iconIds });
+            return result.data;
+        });
+    }
+    projectSyncMetadata(projectId, revision, rethrowAppError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.post(`${this.codegenHost}/api/v1/projects/${projectId}/code/project-sync-metadata`, { revision }, rethrowAppError);
+            return code_merger_1.ProjectSyncMetadataModel.fromJson(result.data);
+        });
+    }
+    connectSocket() {
+        const socket = socket_io_client_1.default.connect(this.studioHost, {
+            path: `/api/v1/socket`,
+            transportOptions: {
+                polling: {
+                    extraHeaders: this.makeHeaders(),
+                },
+            },
+        });
+        return socket;
+    }
+    // If rethrowAppError is true, we will throw an exception with the error
+    // message
+    post(url, data, rethrowAppError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield axios_1.default.post(url, Object.assign({ projectIdsAndTokens: this.projectIdsAndTokens }, data), {
+                    headers: this.makeHeaders(),
+                });
+            }
+            catch (e) {
+                const error = e;
+                const errorMsg = this.makeErrorMessage(error);
+                if (rethrowAppError) {
+                    throw new AppServerError(errorMsg);
+                }
+                if (!errorMsg) {
+                    throw e;
+                }
+                throw new error_1.HandledError(errorMsg);
+            }
+        });
+    }
+    makeErrorMessage(error) {
+        var _a, _b;
+        const response = error.response;
+        if (!response) {
+            return undefined;
+        }
+        if (response.status === 403) {
+            return `Incorrect Plasmic credentials; please check your .plasmic.auth file or your project API tokens.`;
+        }
+        if ((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.message) {
+            return response.data.error.message;
+        }
+        else if (response.data) {
+            return `Error: request failed with status code ${response.status}. The response is
+  ${response.data}`;
+        }
+        else {
+            return undefined;
+        }
+    }
+    makeHeaders() {
+        const headers = {
+            "x-plasmic-api-user": this.auth.user,
+            "x-plasmic-api-token": this.auth.token,
+        };
+        if (this.auth.basicAuthUser && this.auth.basicAuthPassword) {
+            const authString = Buffer.from(`${this.auth.basicAuthUser}:${this.auth.basicAuthPassword}`).toString("base64");
+            headers["Authorization"] = `Basic ${authString}`;
+        }
+        return headers;
+    }
+    attachProjectIdsAndTokens(idsAndTokens) {
+        this.projectIdsAndTokens = idsAndTokens;
+    }
+    get studioHost() {
+        return this.auth.host;
+    }
+    get codegenHost() {
+        if (!this.auth.host || this.auth.host === config_utils_1.DEFAULT_HOST) {
+            return "https://codegen.plasmic.app";
+        }
+        else {
+            return this.auth.host;
+        }
+    }
+}
+exports.PlasmicApi = PlasmicApi;

package/dist/deps.d.ts

@@ -0,0 +1,2 @@
+import winston from "winston";
+export declare const logger: winston.Logger;

package/dist/deps.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const winston_1 = __importDefault(require("winston"));
+exports.logger = winston_1.default.createLogger({
+    level: "info",
+    format: winston_1.default.format.json(),
+    defaultMeta: {},
+    transports: [
+        new winston_1.default.transports.Console({
+            format: winston_1.default.format.printf((info) => `${info.message}`
+            //info => `${moment().format("HH:mm:ss")}:${info.level}\t${info.message}`
+            ),
+            stderrLevels: ["error"],
+        }),
+    ],
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export interface CommonArgs {
+    baseDir: string;
+    auth?: string;
+    config?: string;
+    yes?: boolean;
+}

package/dist/index.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = __importDefault(require("semver"));
+const update_notifier_1 = __importDefault(require("update-notifier"));
+const yargs_1 = __importDefault(require("yargs"));
+const auth = __importStar(require("./actions/auth"));
+const fix_imports_1 = require("./actions/fix-imports");
+const init_1 = require("./actions/init");
+const projectToken = __importStar(require("./actions/project-token"));
+const sync_1 = require("./actions/sync");
+const upload_bundle_1 = require("./actions/upload-bundle");
+const watch_1 = require("./actions/watch");
+const config_utils_1 = require("./utils/config-utils");
+const error_1 = require("./utils/error");
+if (process.env.DEBUG_CHDIR) {
+    process.chdir(process.env.DEBUG_CHDIR);
+}
+// Check once an hour
+const pkg = require("../package.json");
+const notifier = update_notifier_1.default({ pkg, updateCheckInterval: 1000 * 60 * 60 });
+// Workaround for this bug
+// https://github.com/yeoman/update-notifier/issues/181
+if (!!notifier.update &&
+    semver_1.default.gt(notifier.update.latest, notifier.update.current)) {
+    notifier.notify();
+}
+yargs_1.default
+    .usage("Usage: $0 <command> [options]")
+    .option("auth", {
+    describe: "Plasmic auth file to use; by default, uses ~/.plasmic.auth, or the first .plasmic.auth file found in current and parent directories",
+})
+    .option("config", {
+    describe: "Plasmic config file to use; by default, uses the first plasmic.json file found in the current or parent directories",
+})
+    .option("yes", {
+    type: "boolean",
+    describe: "Automatic yes to prompts.",
+    default: false,
+})
+    .command("init", "Initializes Plasmic for a project.", (yags) => {
+    yags
+        .option("enable-skip-auth", {
+        describe: "Enable skipping auth, just initialize a plasmic.json",
+        type: "boolean",
+        default: false,
+    })
+        .option("host", init_1.getYargsOption("host", "https://studio.plasmic.app"))
+        .option("platform", init_1.getYargsOption("platform"))
+        .option("code-lang", init_1.getYargsOption("codeLang"))
+        .option("code-scheme", init_1.getYargsOption("codeScheme"))
+        .option("react-runtime", {
+        describe: "React runtime to use; either classic or automatic",
+        choices: ["classic", "automatic"],
+        default: "classic",
+    })
+        .option("src-dir", init_1.getYargsOption("srcDir"))
+        .option("plasmic-dir", init_1.getYargsOption("plasmicDir"))
+        .option("pages-dir", init_1.getYargsOption("pagesDir"))
+        .option("style-scheme", init_1.getYargsOption("styleScheme"))
+        .option("images-scheme", init_1.getYargsOption("imagesScheme"))
+        .option("images-public-dir", init_1.getYargsOption("imagesPublicDir"))
+        .option("images-public-url-prefix", init_1.getYargsOption("imagesPublicUrlPrefix"));
+}, (argv) => error_1.handleError(init_1.initPlasmic(argv)))
+    .command("auth", "Authenticates you to plasmic.", (yags) => {
+    yags
+        .option("host", {
+        describe: "Plasmic host to use",
+        type: "string",
+        default: "https://studio.plasmic.app",
+    })
+        .option("check", {
+        alias: "c",
+        describe: "Just verifies if the current credentials are valid.",
+        type: "boolean",
+    })
+        .option("email", {
+        describe: "Print the email of the currently authenticated user and exit.",
+        type: "boolean",
+    });
+}, (argv) => {
+    error_1.handleError(auth.auth(argv));
+})
+    .command("sync", "Syncs designs from Plasmic to local files.", (yags) => configureSyncArgs(yags), (argv) => {
+    error_1.handleError(sync_1.sync(argv, {
+        source: "cli",
+        scheme: "codegen",
+        command: "sync",
+    }));
+})
+    .command("watch", "Watches for updates to projects, and syncs them automatically to local files.", (yags) => configureSyncArgs(yags, false), (argv) => {
+    error_1.handleError(watch_1.watchProjects(argv, {
+        source: "cli",
+        scheme: "codegen",
+        command: "watch",
+    }));
+})
+    .command("fix-imports", "Fixes import paths after you've moved around Plasmic blackbox files", (yags) => 0, (argv) => error_1.handleError(fix_imports_1.fixImports(argv)))
+    .command("upload-bundle", false, (yargs) => yargs
+    .option("project", {
+    alias: "p",
+    describe: "ID of Plasmic project to upload the bundle to.",
+    type: "string",
+})
+    .option("bundleName", {
+    describe: "Name of the bundle",
+    type: "string",
+})
+    .option("bundleJsFile", {
+    describe: "Path of the bundled Javascript file in AMD format",
+    type: "string",
+})
+    .option("cssFiles", {
+    describe: "Path of the bundled css files to load",
+    type: "array",
+    default: [],
+})
+    .option("metaJsonFile", {
+    describe: "Path of the meta data file (in JSON format) describing the component",
+    type: "string",
+})
+    .option("extraPropMetaJsonFile", {
+    describe: "Path of the extra meta data file (in JSON format) describing the component's additional controlled properties and initial properties",
+    type: "string",
+})
+    .option("pkgVersion", {
+    describe: "version of the package to include in the generated package.json",
+    type: "string",
+    default: "latest",
+})
+    .option("genModulePath", {
+    describe: "the path of include when generating import statement and generate package.json for. Default to bundleName.",
+    type: "string",
+})
+    .option("themeProviderWrapper", {
+    describe: "the wrapper that inject theme to the bundle.",
+    type: "string",
+})
+    .option("themeModuleFile", {
+    describe: "the typescript file that contains and exports the implementation of themeProviderWrapper. Used for code generation. It must be specified together with themeProviderWrapper.",
+    type: "string",
+})
+    .option("genCssPaths", {
+    describe: "the list of css paths to import in generate code whenever a component in this bundle is used",
+    type: "array",
+    default: [],
+}), (argv) => error_1.handleError(upload_bundle_1.uploadJsBundle(argv)))
+    .command("project-token <projectId>", "Get projectApiToken for a given project", (yargs) => yargs
+    .positional("projectId", {
+    describe: "projectId",
+    type: "string",
+})
+    .option("host", {
+    describe: "Plasmic host to use",
+    type: "string",
+    default: "https://studio.plasmic.app",
+}), (argv) => error_1.handleError(projectToken.projectToken(argv)))
+    .demandCommand()
+    .strict()
+    .help("h")
+    .alias("h", "help").argv;
+function configureSyncArgs(yags, includeQuietOption = true) {
+    let args = yags
+        .option("projects", {
+        alias: "p",
+        describe: "One or more projects to sync, separated by comma. Version constraints can be specified using @. Example: projectid, projectid@>=version",
+        type: "array",
+        default: [],
+    })
+        .option("force", {
+        type: "boolean",
+        describe: "Force sync to bypass specified version ranges.",
+        default: false,
+    })
+        .option("loader-config", {
+        type: "string",
+        describe: "Path to loader config file, and causes CLI to run in PlasmicLoader mode.",
+        hidden: true,
+        default: config_utils_1.LOADER_CONFIG_FILE_NAME,
+    })
+        .option("non-recursive", {
+        type: "boolean",
+        describe: "Do not recursively sync dependencies, only sync the specified projects",
+        default: false,
+    })
+        .option("force-overwrite", {
+        type: "boolean",
+        describe: "Overwrite the skeleton file with newly generated version. Useful when switching between codegen schemes.",
+        default: false,
+    })
+        .option("append-jsx-on-missing-base", {
+        type: "boolean",
+        describe: "When the base metadata is missing to perform the three-way merge for direct edit component, append the jsx of the new version so that user can perform manual merge.",
+        default: false,
+    })
+        .option("new-component-scheme", {
+        type: "string",
+        choices: ["blackbox", "direct"],
+        describe: "Sync the new components using this code scheme rather than the default code scheme.",
+    })
+        .option("ignore-post-sync", {
+        type: "boolean",
+        describe: "Ignore post-sync commands in plasmic.json",
+        default: false,
+    })
+        .option("metadata", {
+        type: "string",
+        describe: "Pass metadata through to the server. Use querystring format (e.g. command=sync&source=cli&cli_version=1.0.0",
+        default: "source=cli",
+        hidden: true,
+    })
+        .option("all-files", {
+        type: "boolean",
+        describe: "Sync all files, including those that haven't changed since last sync",
+        default: "",
+    });
+    if (includeQuietOption) {
+        args = args.option("quiet", {
+            type: "boolean",
+            describe: "Do not inform each asset to be synced",
+            default: false,
+        });
+    }
+    return args;
+}

package/dist/lib.d.ts

@@ -0,0 +1,10 @@
+export { auth, AuthArgs } from "./actions/auth";
+export { fixImports, FixImportsArgs } from "./actions/fix-imports";
+export { InitArgs, initPlasmic } from "./actions/init";
+export { getProjectApiToken } from "./actions/project-token";
+export { sync, SyncArgs } from "./actions/sync";
+export { UploadBundleArgs, uploadJsBundle } from "./actions/upload-bundle";
+export { WatchArgs, watchProjects } from "./actions/watch";
+export { logger } from "./deps";
+export { HandledError, handleError } from "./utils/error";
+export { Metadata, setMetadataEnv } from "./utils/get-context";