@plasmicapp/cli 0.1.304 → 0.1.305

package/dist/lib.js

@@ -731539,7 +731539,7 @@ var handleError = (p) => {
   return p.catch((e) => {
     if (e.message) {
       logger.error(
-        import_chalk.default.bold(import_chalk.default.redBright("\nPlasmic error: ")) + e.message
+        import_chalk.default.bold(import_chalk.default.redBright("\nPlasmic error: ")) + e.message + e.stack
       );
     }
     if (checkEngineStrict()) {
@@ -731557,7 +731557,6 @@ var DEFAULT_HOST = process.env.PLASMIC_DEFAULT_HOST || "https://studio.plasmic.a
 var AUTH_FILE_NAME = ".plasmic.auth";
 var CONFIG_FILE_NAME = "plasmic.json";
 var LOCK_FILE_NAME = "plasmic.lock";
-var LOADER_CONFIG_FILE_NAME = "plasmic-loader.json";
 var ENV_AUTH_HOST = "PLASMIC_AUTH_HOST";
 var ENV_AUTH_USER = "PLASMIC_AUTH_USER";
 var ENV_AUTH_TOKEN = "PLASMIC_AUTH_TOKEN";
@@ -731782,6 +731781,20 @@ var PlasmicApi = class {
     );
     return result.data;
   }
+  /**
+   * Code-gen endpoint.
+   * This will fetch components from a given branch at an exact specified version
+   * using the "plain" scheme
+   */
+  async exportProject(projectId, branchName, opts) {
+    const result = await this.post(
+      `${this.codegenHost}/api/v1/projects/${projectId}/code/components?branchName=${branchName}&export=true`,
+      {
+        ...opts
+      }
+    );
+    return result.data;
+  }
   async projectMeta(projectId) {
     const result = await this.post(
       `${this.codegenHost}/api/v1/projects/${projectId}/code/meta`
@@ -733060,7 +733073,8 @@ async function resolveMissingFilesInConfig(context, config) {
 }
 async function getContext(args, {
   enableSkipAuth = false,
-  skipMissingFiles = false
+  skipMissingFiles = false,
+  skipInit = false
 } = {}) {
   if (!args.baseDir)
     args.baseDir = process.cwd();
@@ -734149,25 +734163,7 @@ async function ensureRequiredPackages(context, baseDir, yes) {
     }
   }
 }
-function getLoaderConfigPath(opts) {
-  return opts.loaderConfig || LOADER_CONFIG_FILE_NAME;
-}
-function maybeReadLoaderConfig(opts) {
-  const path14 = getLoaderConfigPath(opts);
-  if (!existsBuffered(path14)) {
-    return {};
-  }
-  return JSON.parse(readFileText(path14));
-}
-function writeLoaderConfig(opts, config) {
-  const loaderConfigPath = getLoaderConfigPath(opts);
-  writeFileText(
-    loaderConfigPath,
-    formatAsLocal(JSON.stringify(config), loaderConfigPath, opts.baseDir)
-  );
-}
 async function sync(opts, metadataDefaults) {
-  var _a;
   if (!opts.baseDir)
     opts.baseDir = process.cwd();
   const baseDir = opts.baseDir;
@@ -734181,18 +734177,17 @@ async function sync(opts, metadataDefaults) {
   }
   fixFileExtension(context);
   assertAllPathsInRootDir(context);
-  const loaderConfig = process.env.PLASMIC_LOADER ? maybeReadLoaderConfig(opts) : {};
   const projectIdToToken = new Map(
-    [...context.config.projects, ...(_a = loaderConfig == null ? void 0 : loaderConfig.projects) != null ? _a : []].filter((p) => p.projectApiToken).map((p) => tuple(p.projectId, p.projectApiToken))
+    [...context.config.projects].filter((p) => p.projectApiToken).map((p) => tuple(p.projectId, p.projectApiToken))
   );
   const projectConfigMap = import_lodash17.default.keyBy(context.config.projects, (p) => p.projectId);
   const projectWithVersion = opts.projects.map((p) => {
-    var _a2, _b, _c;
+    var _a, _b, _c;
     const [projectIdToken, versionRange] = p.split("@");
     const [projectId, projectApiToken] = projectIdToken.split(":");
     return {
       projectId,
-      branchName: (_b = (_a2 = projectConfigMap[projectId]) == null ? void 0 : _a2.projectBranchName) != null ? _b : "main",
+      branchName: (_b = (_a = projectConfigMap[projectId]) == null ? void 0 : _a.projectBranchName) != null ? _b : "main",
       versionRange: versionRange || ((_c = projectConfigMap[projectId]) == null ? void 0 : _c.version) || "latest",
       componentIdOrNames: void 0,
       // Get all components!
@@ -734201,10 +734196,10 @@ async function sync(opts, metadataDefaults) {
     };
   });
   const projectSyncParams = projectWithVersion.length ? projectWithVersion : context.config.projects.map((p) => {
-    var _a2;
+    var _a;
     return {
       projectId: p.projectId,
-      branchName: (_a2 = p.projectBranchName) != null ? _a2 : "main",
+      branchName: (_a = p.projectBranchName) != null ? _a : "main",
       versionRange: p.version,
       componentIdOrNames: void 0,
       // Get all components!
@@ -734222,7 +734217,7 @@ async function sync(opts, metadataDefaults) {
       context = await getContext(opts);
     } catch (e) {
       if (e.message.includes("Unable to authenticate Plasmic")) {
-        const configFileName = process.env.PLASMIC_LOADER ? LOADER_CONFIG_FILE_NAME : CONFIG_FILE_NAME;
+        const configFileName = CONFIG_FILE_NAME;
         throw new HandledError(
           `Unable to authenticate Plasmic. Please run 'plasmic auth' or check the projectApiTokens in your ${configFileName}, and try again.`
         );
@@ -734259,7 +734254,6 @@ async function sync(opts, metadataDefaults) {
   const externalNpmPackages = /* @__PURE__ */ new Set();
   const externalCssImports = /* @__PURE__ */ new Set();
   const doSync = async () => {
-    var _a2;
     for (const projectMeta of projectsToSync) {
       await syncProject(
         context,
@@ -734303,21 +734297,6 @@ async function sync(opts, metadataDefaults) {
       });
     }
     await fixAllImportStatements(context, opts.baseDir, summary);
-    if (process.env.PLASMIC_LOADER) {
-      const rootProjectIds = new Set(projectSyncParams.map((p) => p.projectId));
-      const freshIdsAndTokens = projectIdsAndTokens.filter((p) => rootProjectIds.has(p.projectId)).map((p) => import_lodash17.default.pick(p, "projectId", "projectApiToken"));
-      const config = {
-        ...loaderConfig,
-        projects: import_lodash17.default.sortBy(
-          import_lodash17.default.uniqBy(
-            [...freshIdsAndTokens, ...(_a2 = loaderConfig == null ? void 0 : loaderConfig.projects) != null ? _a2 : []],
-            (p) => p.projectId
-          ),
-          (p) => p.projectId
-        )
-      };
-      writeLoaderConfig(opts, config);
-    }
     const codegenVersion = await context.api.latestCodegenVersion();
     context.lock.projects.forEach((p) => {
       if (projectsToSync.some(

package/dist/utils/config-utils.d.ts

@@ -1,23 +1,13 @@
 import { DeepPartial } from "utility-types";
-import { PlasmicApi, ProjectIdAndToken } from "../api";
+import { PlasmicApi } from "../api";
 export declare const DEFAULT_HOST: string;
 export declare const AUTH_FILE_NAME = ".plasmic.auth";
 export declare const CONFIG_FILE_NAME = "plasmic.json";
 export declare const LOCK_FILE_NAME = "plasmic.lock";
-export declare const LOADER_CONFIG_FILE_NAME = "plasmic-loader.json";
 export declare const CONFIG_SCHEMA_FILE_NAME = "plasmic.schema.json";
 export declare const ENV_AUTH_HOST = "PLASMIC_AUTH_HOST";
 export declare const ENV_AUTH_USER = "PLASMIC_AUTH_USER";
 export declare const ENV_AUTH_TOKEN = "PLASMIC_AUTH_TOKEN";
-export interface PlasmicLoaderConfig {
-    projects: ProjectIdAndToken[];
-    aboutThisFile: string;
-    dir: string;
-    plasmicDir: string;
-    pageDir: string;
-    initArgs: Record<string, string>;
-    substitutions?: Record<string, any>;
-}
 export interface PlasmicConfig {
     /** Target platform to generate code for */
     platform: "react" | "nextjs" | "gatsby";

package/dist/utils/get-context.d.ts

@@ -1,10 +1,15 @@
 import { CommonArgs } from "../index";
 import { PlasmicContext, PlasmicLock } from "./config-utils";
 export declare function readLock(lockFile: string): PlasmicLock;
-export declare function getContext(args: CommonArgs, { enableSkipAuth, skipMissingFiles, }?: {
+export declare function getContext(args: CommonArgs, { enableSkipAuth, skipMissingFiles, skipInit, }?: {
     enableSkipAuth?: boolean;
     skipMissingFiles?: boolean;
+    skipInit?: boolean;
 }): Promise<PlasmicContext>;
+/**
+ * Use empty user/token to signify no auth (only returning to provide a default host).
+ */
+export declare function getCurrentOrDefaultAuth(args: CommonArgs): Promise<import("./config-utils").AuthConfig>;
 /**
  * Table of where this metadata will be set
  *

package/dist/utils/test-utils.d.ts

@@ -1,5 +1,5 @@
 import * as tmp from "tmp";
-import { AuthConfig, PlasmicConfig, PlasmicLoaderConfig } from "../utils/config-utils";
+import { AuthConfig, PlasmicConfig } from "../utils/config-utils";
 export declare class TempRepo {
     tmpDir: tmp.DirResult;
     constructor();
@@ -17,6 +17,4 @@ export declare class TempRepo {
     readPlasmicJson(): PlasmicConfig;
     writePlasmicJson(json: PlasmicConfig): void;
     deletePlasmicJson(): void;
-    plasmicLoaderJsonPath(): string;
-    readPlasmicLoaderJson(): PlasmicLoaderConfig;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasmicapp/cli",
-  "version": "0.1.304",
+  "version": "0.1.305",
   "description": "plasmic cli for syncing local code with Plasmic designs",
   "engines": {
     "node": ">=12"
@@ -78,5 +78,5 @@
     "wrap-ansi": "^7.0.0",
     "yargs": "^15.4.1"
   },
-  "gitHead": "7569dd15624b746deaea9cf9631a43961a30f52f"
+  "gitHead": "f1d5f4fddc0f8d528cffb91a803501e51c877b42"
 }

package/src/__tests__/project-api-token-spec.ts

@@ -158,55 +158,4 @@ describe("Project API tokens", () => {
     });
     await expect(sync(opts)).rejects.toThrow("Unable to authenticate");
   });
-
-  test("should use plasmic-loader.json for API tokens in loader mode", async () => {
-    process.env.PLASMIC_LOADER = "1";
-
-    opts.projects = ["projectId1"];
-    await expect(sync(opts)).resolves.toBeUndefined();
-
-    const loaderConfig = tmpRepo.readPlasmicLoaderJson();
-    expect(loaderConfig).toEqual({
-      projects: [
-        {
-          projectId: "projectId1",
-          projectApiToken: "abc",
-        },
-      ],
-    });
-
-    // Re-run, this time with no auth and no tokens in plasmic.json, only in plasmic-loader.json.
-    removeAuth();
-    tmpRepo.writePlasmicJson(defaultPlasmicJson);
-    await expect(sync(opts)).resolves.toBeUndefined();
-
-    delete process.env["PLASMIC_LOADER"];
-  });
-
-  test("works in PlasmicLoader mode even if root project was determined to not need an update", async () => {
-    process.env.PLASMIC_LOADER = "1";
-
-    // Make project1 have a dependency.
-    standardTestSetup();
-
-    // Explicitly sync both - we had a bug writing back the plasmic-loader.json in this case.
-    opts.projects = ["projectId1", "dependencyId1"];
-    await expect(sync(opts)).resolves.toBeUndefined();
-
-    // We sync project1 which got updated, but the dependency is still same version.
-    opts.force = false;
-    removeAuth();
-    mockApi.getMockProject("projectId1", "main", "1.2.3").version = "1.2.4";
-    await expect(sync(opts)).resolves.toBeUndefined();
-  });
-
-  test("should fail in loader mode if not available", async () => {
-    process.env.PLASMIC_LOADER = "1";
-
-    opts.projects = ["projectId1"];
-    removeAuth();
-    await expect(sync(opts)).rejects.toThrow();
-
-    delete process.env["PLASMIC_LOADER"];
-  });
 });

package/src/actions/export.ts

@@ -0,0 +1,326 @@
+import { keyBy, snakeCase } from "lodash";
+import { CommonArgs } from "..";
+import { ComponentBundle, PlasmicApi, ProjectBundle } from "../api";
+import {
+  CodeConfig,
+  I18NConfig,
+  ImagesConfig,
+  PlasmicConfig,
+  StyleConfig,
+  findConfigFile,
+} from "../utils/config-utils";
+import { getContext, getCurrentOrDefaultAuth } from "../utils/get-context";
+import { tuple } from "../utils/lang-utils";
+import {
+  fixAllImportStatements,
+  formatAsLocal,
+  maybeConvertTsxToJsx,
+} from "../utils/code-utils";
+import { promises as fs, write } from "fs";
+import path from "path";
+import { DEFAULT_GLOBAL_CONTEXTS_NAME } from "./sync-global-contexts";
+import { ensureImageAssetContents } from "./sync-images";
+import { logger } from "../deps";
+
+export interface ExportArgs extends CommonArgs {
+  projects: readonly string[];
+  platform: "" | "react" | "nextjs" | "gatsby";
+  codeLang: "" | "ts" | "js";
+  styleScheme: "" | "css" | "css-modules";
+  imagesScheme: "" | "inlined" | "files" | "public-files";
+  imagesPublicDir: string;
+  imagesPublicUrlPrefix: string;
+  i18nKeyScheme: "" | I18NConfig["keyScheme"];
+  i18nTagPrefix: "" | I18NConfig["tagPrefix"];
+
+  skipFormatting?: boolean;
+
+  outDir: string;
+}
+
+export async function exportProjectsCli(opts: ExportArgs): Promise<void> {
+  if (!opts.baseDir) opts.baseDir = process.cwd();
+  let configFile =
+    opts.config || findConfigFile(opts.baseDir, { traverseParents: true });
+  let context = configFile
+    ? await getContext(opts, { enableSkipAuth: true })
+    : undefined;
+  const projectConfigMap = keyBy(
+    context?.config.projects ?? [],
+    (p) => p.projectId
+  );
+  const projectIdToToken = new Map(
+    [...(context?.config.projects ?? [])]
+      .filter((p) => p.projectApiToken)
+      .map((p) => tuple(p.projectId, p.projectApiToken))
+  );
+  const projectWithVersion = opts.projects.map((p) => {
+    const [projectIdToken, versionRange] = p.split("@");
+    const [projectId, projectApiToken] = projectIdToken.split(":");
+    return {
+      projectId,
+      branchName: projectConfigMap[projectId]?.projectBranchName ?? "main",
+      versionRange:
+        versionRange || projectConfigMap[projectId]?.version || "latest",
+      componentIdOrNames: undefined, // Get all components!
+      projectApiToken: projectApiToken || projectIdToToken.get(projectId),
+      indirect: false,
+    };
+  });
+
+  const auth = await getCurrentOrDefaultAuth(opts);
+  const api = new PlasmicApi(auth);
+  const result = await exportProjects(api, {
+    projects: projectWithVersion.map((p) => ({
+      id: p.projectId,
+      token: p.projectApiToken,
+      branchName: p.branchName,
+      version: p.versionRange,
+    })),
+    platform: opts.platform || "react",
+    codeOpts: { lang: opts.codeLang || "ts" },
+    stylesOpts: { scheme: opts.styleScheme || "css-modules" },
+    imageOpts: { scheme: opts.imagesScheme || "files" },
+    i18nOpts: opts.i18nKeyScheme
+      ? { keyScheme: opts.i18nKeyScheme, tagPrefix: opts.i18nTagPrefix }
+      : undefined,
+  });
+
+  const extx = opts.codeLang === "js" ? "jsx" : "tsx";
+
+  const writeProj = async (bundle: ProjectBundle) => {
+    await ensureImageAssetContents(bundle.imageAssets);
+    const outPath = path.resolve(opts.outDir);
+    const promises: Promise<void>[] = [];
+    const writeFile = (fileName: string, content: string | Buffer) => {
+      if (typeof content === "string" && !opts.skipFormatting) {
+        content = formatAsLocal(content, fileName, opts.outDir);
+      }
+      const projectName = snakeCase(bundle.projectConfig.projectName);
+      promises.push(
+        (async () => {
+          await fs.mkdir(path.join(outPath, projectName), { recursive: true });
+          await fs.writeFile(
+            path.join(outPath, projectName, fileName),
+            content
+          );
+        })()
+      );
+    };
+    for (const comp of bundle.components) {
+      writeFile(comp.skeletonModuleFileName, comp.skeletonModule);
+      writeFile(comp.cssFileName, comp.cssRules);
+    }
+    for (const icon of bundle.iconAssets) {
+      writeFile(icon.fileName, icon.module);
+    }
+    for (const gv of bundle.globalVariants) {
+      writeFile(gv.contextFileName, gv.contextModule);
+    }
+
+    for (const img of bundle.imageAssets) {
+      writeFile(img.fileName, Buffer.from(img.blob, "base64"));
+    }
+
+    writeFile(bundle.projectConfig.cssFileName, bundle.projectConfig.cssRules);
+    if (bundle.projectConfig.globalContextBundle) {
+      writeFile(
+        `${DEFAULT_GLOBAL_CONTEXTS_NAME}.${extx}`,
+        bundle.projectConfig.globalContextBundle.contextModule
+      );
+    }
+
+    await Promise.all(promises);
+  };
+
+  await Promise.all(result.map((res) => writeProj(res)));
+
+  await fixAllImportStatements(
+    {
+      configFile: "",
+      lockFile: "",
+      rootDir: path.resolve(opts.outDir),
+      absoluteSrcDir: path.resolve(opts.outDir),
+      config: {
+        platform: opts.platform || "react",
+        srcDir: "./",
+        defaultPlasmicDir: "./",
+        code: {
+          lang: opts.codeLang || "ts",
+          scheme: "blackbox",
+          reactRuntime: "classic",
+        },
+        images: {
+          scheme: opts.imagesScheme || "files",
+          publicDir: opts.imagesPublicDir,
+          publicUrlPrefix: opts.imagesPublicUrlPrefix,
+        },
+        style: {
+          scheme: opts.styleScheme || "css-modules",
+          defaultStyleCssFilePath: "",
+        },
+        tokens: {} as any,
+        globalVariants: {
+          variantGroups: result.flatMap((bundle) => {
+            const projectName = snakeCase(bundle.projectConfig.projectName);
+            return bundle.globalVariants.map((gv) => ({
+              id: gv.id,
+              name: gv.name,
+              projectId: bundle.projectConfig.projectId,
+              contextFilePath: `./${projectName}/${gv.contextFileName}`,
+            }));
+          }),
+        },
+        projects: result.map((bundle) => {
+          const projectName = snakeCase(bundle.projectConfig.projectName);
+          return {
+            projectId: bundle.projectConfig.projectId,
+            projectName: bundle.projectConfig.projectName,
+            version: "latest",
+            cssFilePath: `${projectName}/${bundle.projectConfig.cssFileName}`,
+            globalContextsFilePath: bundle.projectConfig.globalContextBundle
+              ? `${projectName}/${DEFAULT_GLOBAL_CONTEXTS_NAME}.${extx}`
+              : "",
+            components: bundle.components.map((comp) => ({
+              id: comp.id,
+              name: comp.componentName,
+              projectId: bundle.projectConfig.projectId,
+              type: "managed",
+              importSpec: {
+                modulePath: `${projectName}/${comp.skeletonModuleFileName}`,
+              },
+              renderModuleFilePath: `${projectName}/${comp.skeletonModuleFileName}`,
+              cssFilePath: `${projectName}/${comp.cssFileName}`,
+              scheme: "blackbox",
+              componentType: `${comp.isPage ? "page" : "component"}`,
+              plumeType: comp.plumeType,
+            })),
+            codeComponents: bundle.codeComponentMetas.map((comp) => ({
+              id: comp.id,
+              name: comp.name,
+              displayName: comp.displayName,
+              componentImportPath: comp.importPath,
+              helper: comp.helper,
+            })),
+            icons: bundle.iconAssets.map((icon) => ({
+              id: icon.id,
+              name: icon.name,
+              moduleFilePath: `${projectName}/${icon.fileName}`,
+            })),
+            images: bundle.imageAssets.map((image) => ({
+              id: image.id,
+              name: image.name,
+              filePath: `${projectName}/${image.fileName}`,
+            })),
+            indirect: false,
+          };
+        }),
+        wrapPagesWithGlobalContexts: true,
+      },
+      lock: {} as any,
+      auth: {} as any,
+      api: api,
+      cliArgs: {} as any,
+    },
+    opts.outDir
+  );
+}
+
+interface ExportOpts {
+  projects: {
+    id: string;
+    token?: string;
+    branchName?: string;
+    version?: string;
+  }[];
+  platform?: PlasmicConfig["platform"];
+  imageOpts?: ImagesConfig;
+  stylesOpts?: Omit<StyleConfig, "defaultStyleCssFilePath">;
+  i18nOpts?: I18NConfig;
+  codeOpts?: Omit<CodeConfig, "scheme" | "reactRuntime">;
+}
+
+async function exportProjects(api: PlasmicApi, opts: ExportOpts) {
+  api.attachProjectIdsAndTokens(
+    opts.projects.map((proj) => ({
+      projectId: proj.id,
+      projectApiToken: proj.token,
+    }))
+  );
+
+  const versionResolution = await api.resolveSync(
+    opts.projects.map((p) => ({
+      projectId: p.id,
+      branchName: p.branchName ?? "main",
+      versionRange: p.version,
+      componentIdOrNames: undefined,
+      projectApiToken: p.token,
+      indirect: false,
+    })),
+    true
+  );
+
+  const versionsToSync = [
+    ...versionResolution.dependencies,
+    ...versionResolution.projects,
+  ];
+
+  const result = await Promise.all(
+    versionsToSync.map(async (v) => {
+      return api.exportProject(v.projectId, v.branchName, {
+        platform: opts.platform ?? "react",
+        platformOptions: {},
+        version: v.version,
+        imageOpts: opts.imageOpts ?? {
+          scheme: "files",
+        },
+        stylesOpts: {
+          defaultStyleCssFilePath: "",
+          scheme: "css-modules",
+          ...opts.stylesOpts,
+        },
+        i18nOpts: opts.i18nOpts,
+        codeOpts: opts.codeOpts ?? { lang: "ts" },
+        indirect: v.indirect,
+        wrapPagesWithGlobalContexts: true,
+      });
+    })
+  );
+
+  if (opts.codeOpts?.lang === "js") {
+    for (const proj of result) {
+      for (const comp of proj.components) {
+        [comp.skeletonModuleFileName, comp.skeletonModule] =
+          maybeConvertTsxToJsx(
+            comp.skeletonModuleFileName,
+            comp.skeletonModule,
+            "."
+          );
+      }
+      for (const icon of proj.iconAssets) {
+        [icon.fileName, icon.module] = maybeConvertTsxToJsx(
+          icon.fileName,
+          icon.module,
+          "."
+        );
+      }
+      for (const gv of proj.globalVariants) {
+        [gv.contextFileName, gv.contextModule] = maybeConvertTsxToJsx(
+          gv.contextFileName,
+          gv.contextModule,
+          "."
+        );
+      }
+      if (proj.projectConfig.globalContextBundle) {
+        const res = maybeConvertTsxToJsx(
+          `${DEFAULT_GLOBAL_CONTEXTS_NAME}.tsx`,
+          proj.projectConfig.globalContextBundle.contextModule,
+          "."
+        );
+        proj.projectConfig.globalContextBundle.contextModule = res[1];
+      }
+    }
+  }
+
+  return result;
+}

package/src/actions/localization-strings.ts

@@ -22,6 +22,25 @@ export interface LocalizationStringsArgs extends CommonArgs {
   excludeDeps: boolean | undefined;
 }
 
+export function getLocalizationYargs(key: "key-scheme" | "tag-prefix") {
+  if (key === "key-scheme") {
+    return {
+      describe:
+        "What value to use as message keys; `content` uses the message content itself, `hash` uses a hash of the content, and `path` uses a a hierarchical string containing the project id, component name, element name, and related variants, and does not encode the text content in the key.  Defaults to whatever is specified in plasmic.json, or `content`",
+      type: "string" as const,
+      choices: ["content", "hash", "path"],
+    };
+  } else if (key === "tag-prefix") {
+    return {
+      describe:
+        "By default, rich text with markup tags look like '<0>hello</0>'. If your localization framework requires num-numeric tags, then specify a prefix; for example a prefix of 'n' turns it into '<n0>hello</n0>'.",
+      type: "string" as const,
+    };
+  } else {
+    throw new Error(`Unexpected localization option ${key}`);
+  }
+}
+
 export async function localizationStrings(
   opts: LocalizationStringsArgs
 ): Promise<void> {

package/src/actions/sync-components.ts

@@ -233,7 +233,7 @@ export async function syncProjectComponents(
 
       compConfig.plumeType = plumeType;
 
-      if (scheme === "direct") {
+      if ((scheme as any) === "direct") {
         throw new Error(`Direct update codegen scheme is no longer supported`);
       } else if (/\/\/\s*plasmic-managed-jsx\/\d+/.test(editedFile)) {
         if (forceOverwrite) {

package/src/actions/sync-global-contexts.ts

@@ -15,6 +15,7 @@ import {
 } from "../utils/file-utils";
 
 const COMPONENT_NAME = "PlasmicGlobalContextsProvider";
+export const DEFAULT_GLOBAL_CONTEXTS_NAME = COMPONENT_NAME;
 
 export async function syncGlobalContexts(
   context: PlasmicContext,

package/src/actions/sync-images.ts

@@ -130,7 +130,7 @@ export async function syncProjectImageAssets(
   );
 }
 
-async function ensureImageAssetContents(bundles: ImageBundle[]) {
+export async function ensureImageAssetContents(bundles: ImageBundle[]) {
   // The server may send images as a url instead of a base64 blob. In that
   // case, we fetch the images here in the cli, instead of on the server.
   // If you have a lot of images, this moves the expensive / long fetch