@plasmicapp/cli 0.1.342 → 0.1.343

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasmicapp/cli",
-  "version": "0.1.342",
+  "version": "0.1.343",
   "description": "plasmic cli for syncing local code with Plasmic designs",
   "engines": {
     "node": ">=12"
@@ -83,5 +83,5 @@
     "wrap-ansi": "^7.0.0",
     "yargs": "^15.4.1"
   },
-  "gitHead": "354b30e84489d6a01d96855a04c844aa4fa80f3a"
+  "gitHead": "809dc071d1574484fc1d2da06f6ba9f380a1b19c"
 }

package/src/actions/status.ts

@@ -0,0 +1,173 @@
+import chalk from "chalk";
+import { CommonArgs } from "..";
+import { logger } from "../deps";
+import { getContext, readLock } from "../utils/get-context";
+import * as semver from "../utils/semver";
+
+const PROJECT_ID_WIDTH = 23;
+const PROJECT_NAME_WIDTH = 30;
+const BRANCH_NAME_WIDTH = 15;
+const VERSION_WIDTH = 15;
+const STATUS_WIDTH = 23;
+const TOTAL_WIDTH =
+  PROJECT_ID_WIDTH +
+  PROJECT_NAME_WIDTH +
+  BRANCH_NAME_WIDTH +
+  VERSION_WIDTH * 3 +
+  STATUS_WIDTH;
+
+export interface StatusArgs extends CommonArgs {
+  json?: boolean;
+}
+
+export async function showProjectStatus(opts: StatusArgs): Promise<void> {
+  const context = await getContext(opts, { skipInit: true });
+
+  const projects = context.config.projects;
+  if (projects.length === 0) {
+    logger.info("No projects found in plasmic.json");
+    return;
+  }
+
+  // Read lock file if it exists
+  const lockData = readLock(context.lockFile);
+
+  // Fetch latest versions from the server for all projects at once
+  let serverVersions: Record<string, string | null> = {};
+  try {
+    const resolution = await context.api.resolveSync(
+      projects.map((project) => ({
+        projectId: project.projectId,
+        branchName: project.projectBranchName || "main",
+        // We want to use ">=0.0.0" to get the latest published version.
+        // However, due to PLA-11698, this results in an error if the project
+        // has never been published. This is much more likely if the synced
+        // version is "latest".
+        versionRange: project.version === "latest" ? "latest" : ">=0.0.0",
+        componentIdOrNames: undefined,
+        projectApiToken: project.projectApiToken,
+      }))
+    );
+
+    resolution.projects?.forEach((resolvedProject) => {
+      serverVersions[resolvedProject.projectId] = resolvedProject.version;
+    });
+  } catch (error) {
+    // If we can't reach the server, we'll just show local information
+    logger.debug(`Could not fetch latest versions from server: ${error}`);
+  }
+
+  const projectData = projects.map((project) => {
+    // Find the corresponding lock entry
+    const lockEntry = lockData.projects?.find(
+      (p) => p.projectId === project.projectId
+    );
+
+    return {
+      projectId: project.projectId,
+      projectName: project.projectName,
+      branchName: project.projectBranchName,
+      plasmicJsonVersion: project.version,
+      plasmicLockVersion: lockEntry?.version || null,
+      serverVersion: serverVersions[project.projectId] || "unpublished",
+    };
+  });
+
+  if (opts.json) {
+    // Output as JSON
+    logger.info(JSON.stringify(projectData, null, 2));
+  } else {
+    // Output as formatted table
+    logger.info(chalk.bold("\nPlasmic Project Sync Status\n"));
+    logger.info(chalk.gray("─".repeat(TOTAL_WIDTH)));
+
+    // Header
+    logger.info(
+      chalk.bold(padRight("Project ID", PROJECT_ID_WIDTH)) +
+        chalk.bold(padRight("Project", PROJECT_NAME_WIDTH)) +
+        chalk.bold(padRight("Branch", BRANCH_NAME_WIDTH)) +
+        chalk.bold(padRight("plasmic.json", VERSION_WIDTH)) +
+        chalk.bold(padRight("plasmic.lock", VERSION_WIDTH)) +
+        chalk.bold(padRight("server", VERSION_WIDTH)) +
+        chalk.bold("Status")
+    );
+    logger.info(chalk.gray("─".repeat(TOTAL_WIDTH)));
+
+    let notSynced = 0;
+    let updateAvailable = 0;
+    let updateStatusUnknown = 0;
+    for (const status of projectData) {
+      const projectIdDisplay = padRight(status.projectId, 23);
+      const projectNameDisplay = padRight(
+        status.projectName.substring(0, 29),
+        30
+      );
+      const branchDisplay = padRight(status.branchName || "main", 15);
+      const targetDisplay = padRight(status.plasmicJsonVersion, 15);
+      const syncedDisplay = padRight(
+        status.plasmicLockVersion || "not synced",
+        15
+      );
+      const latestDisplay = padRight(status.serverVersion || "unknown", 15);
+
+      let statusDisplay = "";
+      if (!status.plasmicLockVersion) {
+        statusDisplay = chalk.gray("! Not synced");
+        ++notSynced;
+      } else if (
+        !status.serverVersion ||
+        !semver.valid(status.serverVersion) ||
+        semver.isLatest(status.serverVersion)
+      ) {
+        // Can't compare if the server version is unknown or latest
+        statusDisplay = chalk.yellow("? Update status unknown");
+        ++updateStatusUnknown;
+      } else if (semver.lt(status.plasmicLockVersion, status.serverVersion)) {
+        statusDisplay = chalk.blue("↑ Update available");
+        ++updateAvailable;
+      } else {
+        statusDisplay = chalk.green("✓ Up-to-date");
+      }
+
+      logger.info(
+        projectIdDisplay +
+          projectNameDisplay +
+          branchDisplay +
+          targetDisplay +
+          syncedDisplay +
+          latestDisplay +
+          statusDisplay
+      );
+    }
+
+    logger.info(chalk.gray("─".repeat(TOTAL_WIDTH)));
+    logger.info("");
+
+    if (notSynced > 0) {
+      logger.info(chalk.yellow(`! ${notSynced} project(s) not synced`));
+    }
+    if (updateAvailable > 0) {
+      logger.info(chalk.blue(`↑ ${updateAvailable} project(s) can be updated`));
+    }
+    if (updateStatusUnknown > 0) {
+      logger.info(
+        chalk.yellow(
+          `? ${updateStatusUnknown} project(s) have unknown update status due to "latest" version in plasmic.json`
+        )
+      );
+    }
+    if (notSynced === 0 && updateAvailable === 0 && updateStatusUnknown === 0) {
+      logger.info(chalk.green("✓ All projects are up to date"));
+    }
+
+    logger.info("");
+    logger.info(chalk.gray("Run 'plasmic sync' to sync your projects"));
+  }
+}
+
+function padRight(str: string, length: number): string {
+  if (str.length >= length) {
+    return str.substring(0, length - 1) + " ";
+  }
+  return str + " ".repeat(length - str.length);
+}

package/src/api.ts

@@ -1,5 +1,6 @@
 import axios, { AxiosError } from "axios";
 import socketio from "socket.io-client";
+import { logger } from "./deps";
 import {
   AuthConfig,
   CodeConfig,
@@ -484,6 +485,7 @@ export class PlasmicApi {
   // message
   private async post(url: string, data?: any, rethrowAppError?: boolean) {
     try {
+      logger.debug(`POST ${url}`);
       return await axios.post(
         url,
         { projectIdsAndTokens: this.projectIdsAndTokens, ...data },
@@ -509,6 +511,7 @@ export class PlasmicApi {
 
   private async get(url: string, rethrowAppError?: boolean, extraHeaders?: {}) {
     try {
+      logger.debug(`GET ${url}`);
       return await axios.get(url, {
         headers: { ...this.makeHeaders(), ...(extraHeaders ?? {}) },
       });

package/src/deps.ts

@@ -1,7 +1,7 @@
 import winston from "winston";
 
 export const logger = winston.createLogger({
-  level: "info",
+  level: process.env.LOG_LEVEL ?? "info",
   format: winston.format.json(),
   defaultMeta: {},
   transports: [

package/src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import yargs from "yargs";
 import * as auth from "./actions/auth";
+import { ExportArgs, exportProjectsCli } from "./actions/export";
 import { fixImports, FixImportsArgs } from "./actions/fix-imports";
 import { InfoArgs, printProjectInfo } from "./actions/info";
 import { getYargsOption, InitArgs, initPlasmic } from "./actions/init";
@@ -10,11 +11,11 @@ import {
   LocalizationStringsArgs,
 } from "./actions/localization-strings";
 import * as projectToken from "./actions/project-token";
+import { showProjectStatus, StatusArgs } from "./actions/status";
 import { sync, SyncArgs } from "./actions/sync";
 import { UploadBundleArgs, uploadJsBundle } from "./actions/upload-bundle";
 import { WatchArgs, watchProjects } from "./actions/watch";
 import { handleError } from "./utils/error";
-import { ExportArgs, exportProjectsCli } from "./actions/export";
 
 if (process.env.DEBUG_CHDIR) {
   process.chdir(process.env.DEBUG_CHDIR);
@@ -106,6 +107,17 @@ yargs
       handleError(auth.auth(argv));
     }
   )
+  .command<StatusArgs>(
+    "status",
+    "Shows the status of local Plasmic projects.",
+    (yargs) =>
+      yargs.option("json", {
+        describe: "Output status in JSON format",
+        type: "boolean",
+        default: false,
+      }),
+    (argv) => handleError(showProjectStatus(argv))
+  )
   .command<SyncArgs>(
     "sync",
     "Syncs designs from Plasmic to local files.",

package/src/utils/test-utils.ts

@@ -2,8 +2,8 @@ import fs from "fs";
 import * as path from "path";
 import * as tmp from "tmp";
 import {
-  AuthConfig,
   AUTH_FILE_NAME,
+  AuthConfig,
   CONFIG_FILE_NAME,
   PlasmicConfig,
 } from "../utils/config-utils";