@superblocksteam/sdk 2.0.3-next.103 → 2.0.3-next.105

package/src/cli-replacement/automatic-upgrades.ts

@@ -0,0 +1,315 @@
+import * as child_process from "node:child_process";
+import { promisify } from "node:util";
+import { isNativeError } from "node:util/types";
+import { isEqual, pickBy } from "lodash-es";
+import { resolveCommand, type DetectResult } from "package-manager-detector";
+import { detect } from "package-manager-detector/detect";
+import gt from "semver/functions/gt.js";
+import valid from "semver/functions/valid.js";
+import { getLogger } from "../dev-utils/dev-logger.mjs";
+import type { ResponseMeta } from "../socket/handlers.js";
+import type { ApplicationConfig } from "../types/common.js";
+import type { LockService } from "@superblocksteam/vite-plugin-file-sync/lock-service";
+
+const exec = promisify(child_process.exec);
+const logger = getLogger();
+
+interface Versions {
+  [pkg: string]: string;
+}
+
+interface CheckVersionsErrorResponse {
+  responseMeta: ResponseMeta;
+}
+
+interface CheckVersionsSuccessResponse {
+  data: Versions;
+  responseMeta: ResponseMeta;
+}
+
+async function getRemoteCliLibraryVersions(
+  config: ApplicationConfig,
+): Promise<Versions | undefined> {
+  const { token, superblocksBaseUrl, id } = config;
+
+  try {
+    const response = await fetch(
+      new URL(
+        `api/v3/applications/${id}/cli-library-versions`,
+        superblocksBaseUrl,
+      ),
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      },
+    );
+
+    if (response.ok) {
+      const data = (await response.json()) as CheckVersionsSuccessResponse;
+      return data.data;
+    } else {
+      const error = (await response.json()) as CheckVersionsErrorResponse;
+      console.log(
+        `Could not get latest CLI version: ${error.responseMeta.message}`,
+      );
+    }
+  } catch (error) {
+    if (isNativeError(error)) {
+      logger.error(error.message);
+    } else {
+      logger.error(`${error}`);
+    }
+  }
+}
+
+async function installPackageVersions(pm: DetectResult, versions: Versions) {
+  const installCommand = resolveCommand(
+    pm.agent,
+    "install",
+    Object.entries(versions).map(
+      ([pkg, version]) => `@superblocksteam/${pkg}@${version}`,
+    ),
+  );
+
+  if (!installCommand) {
+    console.error(
+      "We could not determine how to upgrade your Superblocks packages.",
+    );
+    return;
+  }
+
+  const { command, args } = installCommand;
+
+  // upgrade packages
+  return await exec(`${command} ${args.join(" ")}`);
+}
+
+async function findSuperblocksExecutable(): Promise<string | undefined> {
+  try {
+    // Use cross-platform approach to find superblocks executable
+    const command = process.platform === "win32" ? "where" : "which";
+    const { stdout } = await exec(`${command} superblocks`);
+    return stdout.trim();
+  } catch {
+    return undefined;
+  }
+}
+
+async function getLocalCliLibraryVersions(
+  pm: DetectResult,
+): Promise<Partial<Versions>> {
+  return {
+    cli: await getLocalCliVersion(),
+    library: await getLocalPackageVersion(pm, "library"),
+  };
+}
+
+async function getLocalCliVersion(): Promise<string | undefined> {
+  try {
+    const superblocksPath = await findSuperblocksExecutable();
+    if (!superblocksPath) {
+      return undefined;
+    }
+
+    const { stdout } = await exec(`${superblocksPath} version --json`);
+    const json = JSON.parse(stdout) as Record<string, string>;
+    // Extract version from string like "@superblocksteam/cli/2.0.0-next.1"
+    return json.cliVersion?.replace("@superblocksteam/cli/", "");
+  } catch (error) {
+    if (isNativeError(error)) {
+      logger.error(`Error getting CLI version: ${error.message}`);
+    }
+    return undefined;
+  }
+}
+
+async function getLocalPackageVersion(
+  pm: DetectResult,
+  pkg: string,
+  global?: boolean,
+) {
+  try {
+    // Configure commands and parsing logic based on package manager type
+    switch (pm.agent) {
+      case "npm": {
+        const { stdout } = await exec(
+          `npm list ${global ? "--global" : ""} @superblocksteam/${pkg} --json`,
+          {
+            cwd: process.cwd(),
+          },
+        );
+        const parsed = JSON.parse(stdout);
+        return (
+          parsed.dependencies?.[`@superblocksteam/${pkg}`]?.version ??
+          parsed.devDependencies?.[`@superblocksteam/${pkg}`]?.version
+        );
+      }
+      case "pnpm": {
+        const { stdout } = await exec(
+          `pnpm list ${global ? "--global" : ""} @superblocksteam/${pkg} --json`,
+          { cwd: process.cwd() },
+        );
+        const parsed = JSON.parse(stdout);
+        // Check the structure based on actual output
+        return (
+          parsed[0]?.dependencies?.[`@superblocksteam/${pkg}`]?.version ??
+          parsed[0]?.devDependencies?.[`@superblocksteam/${pkg}`]?.version
+        );
+      }
+      default:
+        console.error(
+          `${pm.agent} is currently not supported. Your application will not be upgraded automatically.`,
+        );
+        return;
+    }
+  } catch (e) {
+    console.error(
+      "We couldn't resolve your current Superblocks package versions. Your application will not be upgraded automatically.",
+    );
+    console.error(e);
+    return;
+  }
+}
+
+/**
+ * Check if the CLI is updatable via the oclif update command
+ * This indicates it was installed through a prebuilt installer (and updates the CLI)
+ */
+async function tryCliUpdateCommand(version: string): Promise<boolean> {
+  try {
+    const superblocksPath = await findSuperblocksExecutable();
+    if (!superblocksPath) {
+      return false;
+    }
+
+    // Check if the CLI is installed in a way that allows direct updates
+    // We'll try running the update command with --version to see if it shows an updatable message
+    const { stdout } = await exec(
+      `${superblocksPath} update --version=${version}`,
+    );
+
+    // If it mentions "not updatable" in either stdout or stderr, it's not a prebuilt installer
+    return !stdout.includes("not updatable");
+  } catch (error) {
+    if (isNativeError(error)) {
+      logger.error(`Error checking updatability: ${error.message}`);
+    }
+    return false;
+  }
+}
+
+/**
+ * Restart the CLI
+ */
+async function restartCli() {
+  // Get the args that were used to start the current process
+  const args = process.argv.slice(1);
+
+  // Create a new process with the same arguments
+  const child = child_process.spawn(process.execPath, [...args], {
+    detached: true,
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  // Disconnect the child from the parent
+  child.unref();
+
+  // Exit the current process after the next tick to ensure any logs were written to stdout
+  process.nextTick(() => process.exit(0));
+}
+
+export async function checkVersionsAndUpgrade(
+  lockService: LockService,
+  config?: ApplicationConfig,
+) {
+  const pm = await detect({
+    strategies: [
+      "packageManager-field",
+      "lockfile",
+      "install-metadata",
+      "devEngines-field",
+    ],
+  });
+
+  if (!pm) return;
+  if (!config?.id) return;
+
+  const localVersions = await getLocalCliLibraryVersions(pm);
+
+  if (
+    // don't attempt upgrades in local development
+    Object.values(localVersions).some(
+      (x) => !x || !valid(x) || x.startsWith("file:") || x.startsWith("link:"),
+    )
+  ) {
+    return;
+  }
+
+  const serverVersions = await getRemoteCliLibraryVersions(config);
+
+  // don't attempt upgrades if
+  if (
+    // server versions could not be fetched, or
+    !serverVersions ||
+    // we have a different # of libraries in server/local
+    Object.keys(localVersions).length !== Object.keys(serverVersions).length
+  ) {
+    return;
+  }
+
+  const isUpToDate = isEqual(localVersions, serverVersions);
+
+  if (isUpToDate) return;
+
+  // Determine which packages need to be updated
+  const packagesToUpdate = pickBy(localVersions, (_, key) => {
+    try {
+      return gt(serverVersions[key], (localVersions as Versions)[key]);
+    } catch {
+      return false;
+    }
+  }) as Versions;
+
+  if (Object.keys(packagesToUpdate).length === 0) {
+    return;
+  }
+
+  let cliUpdated = false;
+  let libraryUpdated = false;
+
+  // Handle CLI update separately if it needs updating
+  if (packagesToUpdate.cli) {
+    // Try to update using Oclif's builtin update command
+    const isUpdated = await tryCliUpdateCommand(serverVersions.cli);
+
+    if (!isUpdated) {
+      // try to update using package manager (npm/pnpm/yarn)
+      await installPackageVersions(pm, { cli: serverVersions.cli });
+      cliUpdated = true;
+    }
+  }
+
+  // Always use package manager for library updates
+  if (packagesToUpdate.library) {
+    await installPackageVersions(pm, { library: serverVersions.library });
+    libraryUpdated = true;
+  }
+
+  if (cliUpdated && libraryUpdated) {
+    logger.info(
+      "@superblocksteam/cli and @superblocksteam/library have been updated.",
+    );
+  } else if (cliUpdated) {
+    logger.info("@superblocksteam/cli has been updated.");
+  } else if (libraryUpdated) {
+    logger.info("@superblocksteam/library has been updated.");
+  }
+
+  logger.info("Restarting the CLI…");
+
+  await lockService.releaseLock();
+  await restartCli();
+}

package/src/cli-replacement/dev.mts

@@ -1,4 +1,5 @@
 import "../dev-utils/dev-tracer.js";
+
 import * as fsp from "node:fs/promises";
 import { maskUnixSignals } from "@superblocksteam/util";
 import { AiService } from "@superblocksteam/vite-plugin-file-sync/ai-service";
@@ -9,19 +10,15 @@ import {
 import { OperationQueue } from "@superblocksteam/vite-plugin-file-sync/operation-queue";
 import { SyncService } from "@superblocksteam/vite-plugin-file-sync/sync-service";
 import { green } from "colorette";
+
 import { getLogger } from "../dev-utils/dev-logger.mjs";
 import { createDevServer } from "../dev-utils/dev-server.mjs";
 import { SuperblocksSdk } from "../sdk.js";
+import { checkVersionsAndUpgrade } from "./automatic-upgrades.js";
 import type { DevLogger } from "../dev-utils/dev-logger.mjs";
+import type { ApplicationConfig } from "../types/common.js";
 import type { DraftInterface } from "@superblocksteam/vite-plugin-file-sync/draft-interface";
 
-export interface ApplicationConfig {
-  superblocksBaseUrl: string;
-  token: string;
-  id: string;
-  branchName: string;
-}
-
 const passErrorToVSCode = (message: string, logger: DevLogger) => {
   if (message) {
     // Prefixing with `clierr:` will make the VS code extension capture this message and show it to the user.
@@ -105,6 +102,7 @@ export async function dev(options: {
         if (lockService) {
           try {
             await lockService!.acquireLock();
+            await checkVersionsAndUpgrade(lockService, applicationConfig);
           } catch (error) {
             passErrorToVSCode(
               (error as { context: { message: string } }).context.message,

package/src/index.ts

@@ -53,6 +53,7 @@ export {
   type ApiWithPb,
   type AppToSign,
   type AppToVerify,
+  type ApplicationConfig,
   type ApplicationSettingsHashes,
   type ApplicationSignatureTree,
   type ApplicationSignatureTreeSigned,
@@ -113,7 +114,7 @@ export {
 
 export { createDevServer } from "./dev-utils/dev-server.mjs";
 
-export { dev, type ApplicationConfig } from "./cli-replacement/dev.mjs";
+export { dev } from "./cli-replacement/dev.mjs";
 export { fetchAndWriteApplication } from "./cli-replacement/init.js";
 
 export { ExportViewMode } from "@superblocksteam/shared";

package/src/types/common.ts

@@ -14,6 +14,13 @@ export interface FlagBootstrap {
   "superblocks.git.split.large.step.lines"?: number;
 }
 
+export interface ApplicationConfig {
+  superblocksBaseUrl: string;
+  token: string;
+  id: string;
+  branchName: string;
+}
+
 export type User = {
   id: string;
   email: string;