@superblocksteam/sdk 1.14.2 → 1.99.99-next.2

package/src/cli-replacement/dev.mts

@@ -0,0 +1,276 @@
+import "../dev-utils/dev-tracer.js";
+
+import * as child_process from "node:child_process";
+import * as fsp from "node:fs/promises";
+import { promisify } from "node:util";
+import { maskUnixSignals } from "@superblocksteam/util";
+import { AiService } from "@superblocksteam/vite-plugin-file-sync/ai-service";
+import {
+  LockService,
+  LockType,
+} from "@superblocksteam/vite-plugin-file-sync/lock-service";
+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 { diffJson } from "diff";
+import { resolveCommand } from "package-manager-detector";
+import { detect } from "package-manager-detector/detect";
+
+import { getLogger } from "../dev-utils/dev-logger.mjs";
+import { createDevServer } from "../dev-utils/dev-server.mjs";
+import tracer from "../dev-utils/dev-tracer.js";
+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";
+
+const exec = promisify(child_process.exec);
+
+const passErrorToVSCode = (message: string | undefined, logger: DevLogger) => {
+  if (message) {
+    // Prefixing with `clierr:` will make the VS code extension capture this message and show it to the user.
+    logger.error(`clierr: ${JSON.stringify({ message })}`);
+  }
+};
+
+async function readPkgJson(cwd: string) {
+  try {
+    const { readPackage } = await import("read-pkg");
+    return await readPackage({ cwd });
+  } catch {
+    return null;
+  }
+}
+
+async function installPackages(cwd: string, logger: DevLogger) {
+  try {
+    const pm = await detect({
+      strategies: [
+        "packageManager-field",
+        "lockfile",
+        "install-metadata",
+        "devEngines-field",
+      ],
+      cwd,
+    });
+
+    if (!pm) {
+      logger.warn(
+        "Could not detect package manager, skipping package installation",
+      );
+      return;
+    }
+
+    const installCommand = resolveCommand(pm.agent, "install", []);
+
+    if (!installCommand) {
+      logger.warn(
+        `Could not determine install command for ${pm.agent}, skipping package installation`,
+      );
+      return;
+    }
+
+    const { command, args } = installCommand;
+    logger.info(
+      `Running ${command} ${args.join(" ")} to install dependencies…`,
+    );
+
+    await exec(`${command} ${args.join(" ")}`, { cwd });
+    logger.info("Package installation completed successfully");
+  } catch (error) {
+    logger.error(`Error during package installation: ${error}`);
+    throw error;
+  }
+}
+
+export async function dev(options: {
+  /* cwd is required */
+  cwd: string;
+  pidfilePath?: string;
+  devServerPort?: number;
+
+  /* user control of sync operations */
+  uploadFirst?: boolean;
+  downloadFirst?: boolean;
+  /* only used for testing purposes */
+  skipSync?: boolean;
+
+  applicationConfig?: ApplicationConfig;
+  /* For redirecting output, like when running outside of the CLI */
+  logger?: (message: string) => void;
+
+  /* To cancel the dev server */
+  signal?: AbortSignal;
+}) {
+  const logger = getLogger(options.logger);
+
+  const {
+    cwd,
+    pidfilePath,
+    devServerPort,
+    downloadFirst,
+    uploadFirst,
+    skipSync,
+    applicationConfig,
+  } = options;
+
+  if (pidfilePath) {
+    await fsp.writeFile(pidfilePath, `${process.pid}\n`);
+  }
+
+  const port = devServerPort ?? 5173;
+
+  const fsOperationQueue = new OperationQueue();
+  let syncService: SyncService | undefined;
+  let lockService: LockService | undefined;
+  let aiService: AiService | undefined;
+
+  if (applicationConfig && !skipSync) {
+    lockService = new LockService({
+      authToken: applicationConfig.token,
+      superblocksBaseUrl: applicationConfig.superblocksBaseUrl,
+      applicationId: applicationConfig.id,
+      branchName: applicationConfig.branchName,
+      lockType:
+        process.env.SUPERBLOCKS_IS_CSB === "true"
+          ? LockType.CSB
+          : LockType.LOCAL,
+      tracer,
+    });
+    syncService = new SyncService({
+      authToken: applicationConfig.token,
+      superblocksBaseUrl: applicationConfig.superblocksBaseUrl,
+      appRootDirPath: cwd,
+      applicationId: applicationConfig.id,
+      branchName: applicationConfig.branchName,
+      fsOperationQueue,
+      lockService,
+      tracer,
+    });
+
+    logger.info("Checking if local files are synced with the server");
+
+    try {
+      await maskUnixSignals(async () => {
+        const sdk = new SuperblocksSdk(
+          applicationConfig.token,
+          applicationConfig.superblocksBaseUrl,
+          "",
+        );
+
+        if (lockService) {
+          try {
+            await lockService!.acquireLock();
+
+            // TODO(code-mode): package naming is preventing upgrade in ephemeral environments
+            if (
+              !process.env.PACKAGE_SUFFIX ||
+              process.env.PACKAGE_SUFFIX === ""
+            ) {
+              await checkVersionsAndUpgrade(lockService, applicationConfig);
+            }
+          } catch (error) {
+            logger.error("Failed to acquire lock on application", error);
+            passErrorToVSCode(
+              (error as { context?: { message: string } }).context?.message,
+              logger,
+            );
+            throw new Error(`Failed to acquire lock on application: ${error}`);
+          }
+        }
+
+        const [localContents, serverHash, currentUser] = await Promise.all([
+          sdk.hashLocalDirectory(cwd),
+          sdk.dbfsGetApplicationDirectoryHash({
+            applicationId: applicationConfig.id,
+            branch: applicationConfig.branchName,
+          }),
+          sdk.fetchCurrentUser(),
+        ]);
+
+        aiService = new AiService({
+          authToken: applicationConfig.token,
+          superblocksBaseUrl: applicationConfig.superblocksBaseUrl,
+          appRootDirPath: options.cwd,
+          applicationId: applicationConfig.id,
+          organizationId: currentUser.organizations[0].id,
+          anthropicApiKey: process.env.ANTHROPIC_API_KEY || "",
+          fsOperationQueue,
+          draftInterface: syncService! as DraftInterface,
+        });
+
+        const isSynced = localContents.hash === serverHash;
+
+        if (isSynced) {
+          logger.info("Local files are in sync with the server");
+          return;
+        }
+
+        logger.info("Local files are out of sync with the server");
+
+        if (!(downloadFirst || uploadFirst)) {
+          throw new Error(
+            "You must choose --download-first or --upload-first to use the dev command",
+          );
+        }
+        if (downloadFirst && uploadFirst) {
+          throw new Error("Choose either --download-first or --upload-first");
+        }
+
+        if (downloadFirst) {
+          logger.info(
+            "Starting directory sync from server before starting the local server",
+          );
+
+          // Read package.json before download
+          const packageJsonBefore = await readPkgJson(cwd);
+
+          await syncService!.downloadDirectory();
+
+          // Read package.json after download and compare
+          const packageJsonAfter = await readPkgJson(cwd);
+
+          // Check if package.json changed
+          if (packageJsonBefore && packageJsonAfter) {
+            const diff = diffJson(packageJsonBefore, packageJsonAfter);
+            const hasChanges = diff.some((part) => part.added || part.removed);
+
+            if (hasChanges) {
+              logger.info("package.json has changed, installing packages…");
+              await installPackages(cwd, logger);
+            }
+          }
+        } else if (uploadFirst) {
+          logger.info("Uploading local files to server before starting");
+          await syncService!.uploadDirectory();
+        }
+      });
+    } catch (error: any) {
+      logger.error(error.message);
+      process.exit(1);
+    }
+  } else {
+    logger.info("Skipping directory sync");
+  }
+
+  const httpServer = await createDevServer({
+    root: options.cwd,
+    mode: "development",
+    port: port,
+    fsOperationQueue,
+    syncService,
+    lockService,
+    aiService,
+    logger: options.logger,
+  });
+
+  options.signal?.addEventListener("abort", () => {
+    logger.info("Server closed");
+    httpServer.close();
+  });
+
+  logger.debug(green(`Local server started at port ${port}`));
+  logger.debug(green(`Visit your application at:`));
+  logger.debug(green(`http://localhost:${port}`));
+}

package/src/cli-replacement/init.ts

@@ -0,0 +1,47 @@
+import { ComponentEvent } from "@superblocksteam/shared";
+import { COMPONENT_EVENT_HEADER } from "@superblocksteam/util";
+import { writeApplicationToDisk } from "../version-control.mjs";
+import { DEFAULT_BRANCH } from "../version-control.mjs";
+import type { FeatureFlags } from "../flag.js";
+import type { SuperblocksSdk } from "../sdk.js";
+import type { ExportViewMode } from "@superblocksteam/shared";
+import type { VersionedResourceConfig } from "@superblocksteam/util";
+
+export async function fetchAndWriteApplication({
+  resourceId,
+  viewMode,
+  featureFlags,
+  projectRootFolder,
+  appRelativePath,
+  sdk,
+  skipSigningVerification,
+}: {
+  resourceId: string;
+  viewMode: ExportViewMode;
+  featureFlags: FeatureFlags;
+  projectRootFolder: string;
+  appRelativePath?: string;
+  sdk: SuperblocksSdk;
+  skipSigningVerification: boolean;
+}): Promise<VersionedResourceConfig | undefined> {
+  const headers: Record<string, string> = {
+    [COMPONENT_EVENT_HEADER]: ComponentEvent.INIT,
+  };
+
+  const application = await sdk.fetchApplicationWithComponents({
+    applicationId: resourceId,
+    branch: DEFAULT_BRANCH,
+    viewMode: viewMode,
+    headers,
+    skipSigningVerification,
+  });
+  if (application) {
+    return await writeApplicationToDisk({
+      sdk,
+      resource: application,
+      projectRootFolder,
+      appRelativePath,
+      featureFlags,
+    });
+  }
+}

package/src/client.ts

@@ -1,38 +1,42 @@
 import * as fs from "fs";
+import { Bucketeer, FileDescriptor } from "@superblocksteam/bucketeer-sdk";
+import { ExportViewMode } from "@superblocksteam/shared";
 import {
   COMPONENT_EVENT_HEADER,
   ComponentEvent,
   ForbiddenError,
   getBucketeerUrlFromSuperblocksUrl,
   getContentType,
-  LocalGitRepoState,
   NotFoundError,
-  SuperblocksResourceType,
   BadRequestError,
   unreachable,
-  ValidateGitSetupRequestBody,
 } from "@superblocksteam/util";
-import axios, { AxiosError, AxiosRequestConfig } from "axios";
+import axios, { AxiosError } from "axios";
 import FormData from "form-data";
-import { isEqual, isEmpty } from "lodash";
+import { isEqual, isEmpty } from "lodash-es";
 import {
   BranchNotCheckedOutError,
   CommitAlreadyExistsError,
   ValidateGitSetupError,
-} from "./errors";
-import { signingEnabled } from "./flag";
-import { connectToISocketRPCServer, StdISocketRPCClient } from "./socket";
-import {
-  AgentType,
-  Api,
+} from "./errors.js";
+import { signingEnabled } from "./flag.js";
+import { connectToISocketRPCServer } from "./socket/index.js";
+import { AgentType } from "./types/index.js";
+import { getAgentUrl } from "./utils.js";
+import type { StdISocketRPCClient } from "./socket/index.js";
+import type {
   ApiWithPb,
   Page,
   RemoteCommitDto,
-  UserMeDto,
-  ViewMode,
   DeploymentDto,
-} from "./types";
-import { getAgentUrl } from "./utils";
+  UserMeDto,
+} from "./types/index.js";
+import type {
+  LocalGitRepoState,
+  SuperblocksResourceType,
+  ValidateGitSetupRequestBody,
+} from "@superblocksteam/util";
+import type { AxiosRequestConfig } from "axios";
 
 const BASE_BUCKETEER_URL = "api";
 const BASE_SERVER_PUBLIC_API_URL_V1 = "api/v1/public";
@@ -63,23 +67,31 @@ export interface MultiPageApplicationWrapper {
   apis: Record<string, any>[];
 }
 
+export interface MultiPageApplicationWrapperWithComponents {
+  type: "multi-page";
+  application: Record<string, any>;
+  pages: Page[];
+  apis: Record<string, any>[];
+  componentFiles: any;
+}
+
+export interface CodeModeApplicationWrapper {
+  type: "code-mode";
+  application: Record<string, any>;
+}
+
 export type PushMultiPageApplicationWithCommitConfig =
   MultiPageApplicationWrapper & {
-    commitId?: string;
-    commitMessage?: string;
+    commitId: string;
+    commitMessage: string;
     gitState: LocalGitRepoState;
     skipCommit: boolean;
   };
 
-export interface ApiWrapper {
-  apiPb: Api;
-  name?: string; //@deprecated this attribute is used for getting a name for backends(jobs and workflows) that were never migrated to the new API version.
-}
-
 export type PushApiWithCommitConfig = {
   apiPb: Record<string, any>;
-  commitId?: string;
-  commitMessage?: string;
+  commitId: string;
+  commitMessage: string;
   gitState: LocalGitRepoState;
   skipCommit: boolean;
 };
@@ -136,12 +148,12 @@ export async function fetchApplication({
   branch?: string;
   token: string;
   superblocksBaseUrl: string;
-  viewMode: ViewMode;
+  viewMode: ExportViewMode;
   commitId?: string;
   skipSigningVerification?: boolean;
   injectedHeaders: Record<string, string>;
 }): Promise<MultiPageApplicationWrapper | undefined> {
-  if (commitId && viewMode !== "export-commit") {
+  if (commitId && viewMode !== ExportViewMode.EXPORT_COMMIT) {
     throw new Error(
       `If commitId ${commitId} is provided, viewMode cannot be ${viewMode}`,
     );
@@ -177,7 +189,7 @@ export async function fetchApplication({
           branchName: branch,
           commitId,
         });
-        return resp.data;
+        return resp.data as unknown as MultiPageApplicationWrapper;
       } finally {
         socket.close();
       }
@@ -263,14 +275,13 @@ export async function fetchApplicationWithComponents({
   branch: string;
   token: string;
   superblocksBaseUrl: string;
-  viewMode: ViewMode;
+  viewMode: ExportViewMode;
   commitId?: string;
   skipSigningVerification?: boolean;
   injectedHeaders: Record<string, string>;
 }): Promise<
-  | (MultiPageApplicationWrapper & {
-      componentFiles: any;
-    })
+  | MultiPageApplicationWrapperWithComponents
+  | CodeModeApplicationWrapper
   | undefined
 > {
   const applicationWrapper = await fetchApplication({
@@ -289,9 +300,48 @@ export async function fetchApplicationWithComponents({
     return;
   }
 
+  if (applicationWrapper.application.devEnvEnabled) {
+    return {
+      type: "code-mode",
+      ...applicationWrapper,
+    } satisfies CodeModeApplicationWrapper;
+  }
+
+  return await fetchApplicationWithComponentsFromBucketeer({
+    applicationWrapper,
+    superblocksBaseUrl,
+    applicationId,
+    branch,
+    commitId,
+    viewMode,
+    token,
+    injectedHeaders,
+  });
+}
+
+async function fetchApplicationWithComponentsFromBucketeer({
+  applicationWrapper,
+  superblocksBaseUrl,
+  applicationId,
+  branch,
+  commitId,
+  viewMode,
+  token,
+  injectedHeaders,
+}: {
+  applicationWrapper: MultiPageApplicationWrapper;
+  superblocksBaseUrl: string;
+  applicationId: string;
+  branch: string;
+  commitId?: string;
+  viewMode: ExportViewMode;
+  token: string;
+  injectedHeaders: Record<string, string>;
+}): Promise<MultiPageApplicationWrapperWithComponents> {
   // if there are no custom components, just return here without trying to initialize them using bucketeer
   if (isEmpty(applicationWrapper.application?.settings?.registeredComponents)) {
     return {
+      type: "multi-page",
       ...applicationWrapper,
       componentFiles: null,
     };
@@ -318,9 +368,7 @@ export async function fetchApplicationWithComponents({
       },
     };
     const bucketeerApp = (await axios(config))
-      .data as MultiPageApplicationWrapper & {
-      componentFiles: any;
-    };
+      .data as MultiPageApplicationWrapperWithComponents;
 
     if (
       !isEqual(
@@ -383,7 +431,7 @@ export async function fetchApi(
   apiId: string,
   token: string,
   superblocksBaseUrl: string,
-  viewMode: ViewMode,
+  viewMode: ExportViewMode,
   branch?: string,
   commitId?: string,
   skipSigningVerification = false,
@@ -716,7 +764,7 @@ You can reduce your component bundle size by uploading static assets to a separa
         branchName: branch ?? undefined,
         srcFiles: srcFiles.map((file) => file.filename),
         buildFiles: buildFiles.map((file) => file.filename),
-        registeredComponents: componentConfigs,
+        registeredComponents: componentConfigs as Record<string, never>,
         cliVersion,
         componentBaseUrl: uploadResponse.data.componentBaseUrl,
         signingRequired: !isEmpty(initialSocket),
@@ -858,7 +906,7 @@ export async function pushApplication({
       if (resp.responseMeta.status !== 200) {
         // Get the raw error message from the server and throw it. The outer try-catch block will wrap it in a nicer error message
         const message: string =
-          (resp?.responseMeta?.message as string) ?? JSON.stringify(resp?.data);
+          resp?.responseMeta?.message ?? JSON.stringify(resp?.data);
         throw new Error(message);
       }
       return resp.data;
@@ -968,7 +1016,7 @@ export async function pushApi({
       if (resp.responseMeta.status !== 200) {
         // Get the raw error message from the server and throw it. The outer try-catch block will wrap it in a nicer error message
         const message: string =
-          (resp?.responseMeta?.message as string) ?? JSON.stringify(resp?.data);
+          resp?.responseMeta?.message ?? JSON.stringify(resp?.data);
         throw new Error(message);
       }
       return resp.data;
@@ -1215,3 +1263,31 @@ async function deployResource(
     throw new Error(`${e.message}`);
   }
 }
+
+export async function uploadApplication({
+  files,
+  scopedJwt,
+  url,
+  cliVersion,
+}: {
+  files: string[];
+  scopedJwt: string;
+  url: string;
+  cliVersion: string;
+}) {
+  const fds = filesToFileDescriptors(files);
+  const bucketeer = new Bucketeer({
+    token: scopedJwt,
+    baseUrl: url,
+    cliVersion,
+    maxTotalFileSizeMB: SUPERBLOCKS_MAX_FILE_SIZE_MB,
+  });
+  await bucketeer.uploadApplication(fds);
+}
+
+function filesToFileDescriptors(files: string[]) {
+  const fds = files.map((file) => {
+    return new FileDescriptor(file, fs.createReadStream(file));
+  });
+  return fds;
+}