@superblocksteam/sdk 2.0.115-next.1 → 2.0.115

package/src/cli-replacement/dev-s3-restore.test.mts

@@ -0,0 +1,599 @@
+import * as fs from "node:fs/promises";
+import * as http from "node:http";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { beforeEach, describe, expect, it, vi, type Mock } from "vitest";
+
+import { packageJsonSnapshot } from "./package-json-snapshot.mjs";
+
+const execMock = vi.fn();
+vi.mock("node:child_process", () => ({
+  default: { exec: execMock },
+  exec: execMock,
+}));
+
+vi.mock("node:readline", () => ({
+  default: {
+    createInterface: vi.fn(() => ({ question: vi.fn(), close: vi.fn() })),
+  },
+  createInterface: vi.fn(() => ({ question: vi.fn(), close: vi.fn() })),
+}));
+
+vi.mock("fs-extra", () => ({
+  default: {
+    existsSync: vi.fn(() => true),
+    readFileSync: vi.fn(() => "{}"),
+  },
+}));
+
+vi.mock("package-manager-detector/detect", () => ({
+  detect: vi.fn(async () => ({
+    name: "npm",
+    agent: "npm",
+    version: "10.0.0",
+  })),
+}));
+
+vi.mock("package-manager-detector", () => ({
+  resolveCommand: vi.fn(() => ({
+    command: "npm",
+    args: ["install", "--fund=false", "--audit=false"],
+  })),
+}));
+
+vi.mock("read-pkg", () => ({
+  readPackage: vi.fn(async () => ({
+    name: "test-app",
+    dependencies: { "@superblocksteam/library": "1.0.0" },
+  })),
+}));
+
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+vi.mock("../telemetry/logging.js", () => ({
+  getLogger: () => mockLogger,
+  getErrorMeta: vi.fn(() => ({})),
+}));
+
+vi.mock("../telemetry/index.js", () => ({
+  getTracer: () => ({
+    startActiveSpan: vi.fn(
+      async (
+        _name: string,
+        fn: (span: {
+          end: () => void;
+          setStatus: () => void;
+        }) => Promise<unknown>,
+      ) => fn({ end: vi.fn(), setStatus: vi.fn() }),
+    ),
+  }),
+}));
+
+vi.mock("@opentelemetry/api", () => ({
+  SpanStatusCode: { ERROR: 2 },
+}));
+
+vi.mock("colorette", () => ({
+  green: (s: string) => s,
+}));
+
+vi.mock("@superblocksteam/shared", () => ({
+  buildGithubSuperblocksSyncWorkflow: vi.fn(),
+  buildGithubSuperblocksSyncWorkflowFromBaseUrl: vi.fn(),
+  ConflictError: class ConflictError extends Error {},
+  DEFAULT_NON_GIT_BRANCH: "__non_git__",
+  isGitHubRemoteUrl: vi.fn(() => false),
+  NotFoundError: class NotFoundError extends Error {},
+  SUPERBLOCKS_LIVE_GIT_BRANCH: "__live__",
+}));
+
+vi.mock("@superblocksteam/util", () => ({
+  maskUnixSignals: async function maskUnixSignals(fn: () => Promise<void>) {
+    return fn();
+  },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/ai-service", () => ({
+  AiService: class {
+    initialize = vi.fn(async () => undefined);
+    removeIntegrationCache = vi.fn(async () => undefined);
+    chatSessionStore = { invalidateCache: vi.fn() };
+  },
+  AiServiceFeatureFlags: class {
+    static create = vi.fn(() => ({}));
+  },
+  SnapshotManager: class {
+    executePendingRestore = vi.fn(async () => false);
+  },
+  isSdkApiTemplate: vi.fn(() => false),
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/git-service", () => ({
+  createGitService: vi.fn(async () => undefined),
+}));
+
+const mockLockService = {
+  acquireLock: vi.fn(async () => undefined),
+  shutdown: vi.fn(async () => undefined),
+  shutdownAndExit: vi.fn(async () => undefined),
+  setIsRestarting: vi.fn(),
+  isLocked: false,
+  connectedUsers: [],
+  wasRecentlyActive: false,
+  timeSinceLastActivity: 0,
+};
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/lock-service", () => ({
+  LockService: class {
+    acquireLock = mockLockService.acquireLock;
+    shutdown = mockLockService.shutdown;
+    shutdownAndExit = mockLockService.shutdownAndExit;
+    setIsRestarting = mockLockService.setIsRestarting;
+    isLocked = mockLockService.isLocked;
+    connectedUsers = mockLockService.connectedUsers;
+    wasRecentlyActive = mockLockService.wasRecentlyActive;
+    timeSinceLastActivity = mockLockService.timeSinceLastActivity;
+  },
+  LockType: { CSB: "CSB", LOCAL: "LOCAL" },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/operation-queue", () => ({
+  OperationQueue: class {
+    enqueue = vi.fn(async (fn: () => Promise<unknown>) => fn());
+  },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/server-rpc", () => ({
+  AutoConnectingRpcClient: class {},
+}));
+
+const mockSyncService = {
+  downloadDirectory: vi.fn(async () => undefined),
+  uploadDirectory: vi.fn(async () => undefined),
+  uploadDirectoryNowIfNeeded: vi.fn(async () => undefined),
+  cancelPendingSync: vi.fn(),
+};
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/sync-service", () => ({
+  SyncService: class {
+    downloadDirectory = mockSyncService.downloadDirectory;
+    uploadDirectory = mockSyncService.uploadDirectory;
+    uploadDirectoryNowIfNeeded = mockSyncService.uploadDirectoryNowIfNeeded;
+    cancelPendingSync = mockSyncService.cancelPendingSync;
+  },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/draft-interface", () => ({}));
+
+vi.mock("./version-detection.js", () => ({
+  getCurrentCliVersion: vi.fn(async () => ({
+    version: "2.0.0",
+    alias: undefined,
+  })),
+}));
+
+const mockCheckVersions = vi.fn(async () => ({
+  cliUpdated: false,
+  upgradePromises: [] as Promise<void>[],
+}));
+vi.mock("./automatic-upgrades.js", () => ({
+  checkVersionsAndWritePackageJson: (
+    ...args: Parameters<typeof mockCheckVersions>
+  ) => mockCheckVersions(...args),
+}));
+
+vi.mock("./git-repo-setup.mjs", () => ({
+  ensureRemoteHasDefaultBranch: vi.fn(async () => undefined),
+  getGitErrorFields: vi.fn(() => ({})),
+}));
+
+const mockCreateDevServer = vi.fn(async () => http.createServer());
+vi.mock("../dev-utils/dev-server.mjs", () => ({
+  createDevServer: (...args: Parameters<typeof mockCreateDevServer>) =>
+    mockCreateDevServer(...args),
+}));
+
+vi.mock("../index.js", () => ({
+  AUTO_UPGRADE_EXIT_CODE: 99,
+}));
+
+function buildMockSdk() {
+  return {
+    hashLocalDirectory: vi.fn(async () => ({ hash: "same" })),
+    dbfsGetApplicationDirectoryHash: vi.fn(async () => "same"),
+    getApplicationGitConfig: vi.fn(async () => null),
+    fetchCurrentUser: vi.fn(async () => ({
+      user: {
+        id: "user-1",
+        name: "Test User",
+        email: "test@example.com",
+        currentOrganizationId: "org-1",
+      },
+      organizations: [{ id: "org-1", pluginExecutionVersions: {} }],
+      flagBootstrap: {},
+    })),
+    getFeatureFlagsForCurrentUser: vi.fn(async () => ({
+      devServerCloudInactivityTimeoutMinutes: () => 30,
+      devServerLocalInactivityTimeoutMinutes: () => 30,
+      enableSessionRecording: () => false,
+    })),
+    getFeatureFlagsForUser: vi.fn(() => ({
+      devServerCloudInactivityTimeoutMinutes: () => 30,
+      devServerLocalInactivityTimeoutMinutes: () => 30,
+    })),
+  };
+}
+
+function buildDevOptions(overrides: Record<string, unknown> = {}) {
+  return {
+    cwd: "/tmp/test-app",
+    downloadFirst: true,
+    applicationConfig: {
+      id: "app-test",
+      branchName: "main",
+    },
+    tokenConfig: {
+      superblocksBaseUrl: "https://example.test",
+      token: "test-token",
+    },
+    tokenManager: {
+      getToken: vi.fn(() => "test-token"),
+      onTokenRefresh: vi.fn(),
+    },
+    getCurrentToken: vi.fn(() => "test-token"),
+    sdk: buildMockSdk(),
+    ...overrides,
+  };
+}
+
+function setupExecMock() {
+  execMock.mockImplementation(
+    (
+      _cmd: string,
+      _opts: unknown,
+      cb?: (err: null, result: { stdout: string }) => void,
+    ) => {
+      if (typeof _opts === "function") {
+        (_opts as (err: null, result: { stdout: string }) => void)(null, {
+          stdout: "installed",
+        });
+      } else if (cb) {
+        cb(null, { stdout: "installed" });
+      }
+    },
+  );
+}
+
+function expectInstallToHaveRun() {
+  const installCall = execMock.mock.calls.find(
+    (call: unknown[]) =>
+      typeof call[0] === "string" && (call[0] as string).includes("install"),
+  );
+  expect(installCall).toBeDefined();
+}
+
+describe("dev startup after S3 workspace restore", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    setupExecMock();
+    mockCheckVersions.mockResolvedValue({
+      cliUpdated: false,
+      upgradePromises: [],
+    });
+
+    const { readPackage } = await import("read-pkg");
+    (readPackage as Mock).mockResolvedValue({
+      name: "test-app",
+      dependencies: { "@superblocksteam/library": "1.0.0" },
+    });
+  });
+
+  it("keeps the existing no-op path when package.json is unchanged", async () => {
+    const { dev } = await import("./dev.mjs");
+
+    await dev(buildDevOptions() as any);
+
+    expect(execMock).not.toHaveBeenCalled();
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      "Package install decision",
+      expect.objectContaining({
+        packageJsonRequiresInstall: false,
+        forcePackageInstall: false,
+        upgradePromiseCount: 0,
+      }),
+    );
+  });
+
+  it("runs npm install when auto-upgrade only rewrites @superblocksteam/library", async () => {
+    const { readPackage } = await import("read-pkg");
+    (readPackage as Mock)
+      .mockResolvedValueOnce({
+        name: "test-app",
+        dependencies: { "@superblocksteam/library": "1.0.0" },
+      })
+      .mockResolvedValueOnce({
+        name: "test-app",
+        dependencies: { "@superblocksteam/library": "2.0.0" },
+      });
+    const { dev } = await import("./dev.mjs");
+
+    await dev(buildDevOptions() as any);
+
+    expectInstallToHaveRun();
+  });
+
+  it("normalizes library drift introduced by warm DBFS download before package comparison", async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-dbfs-"));
+    const warmPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        react: "19.0.0",
+      },
+    };
+    const staleLibraryPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "1.0.0",
+        react: "19.0.0",
+      },
+    };
+
+    try {
+      await fs.writeFile(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify(warmPackageJson, null, 2),
+      );
+      const { readPackage } = await import("read-pkg");
+      (readPackage as Mock).mockImplementation(async ({ cwd }) =>
+        JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")),
+      );
+      mockSyncService.downloadDirectory.mockImplementationOnce(async () => {
+        await fs.writeFile(
+          path.join(tmpDir, "package.json"),
+          JSON.stringify(staleLibraryPackageJson, null, 2),
+        );
+      });
+      const sdk = buildMockSdk();
+      sdk.hashLocalDirectory = vi.fn(async () => ({ hash: "local" }));
+      sdk.dbfsGetApplicationDirectoryHash = vi.fn(async () => "server");
+      const { dev } = await import("./dev.mjs");
+
+      await dev(
+        buildDevOptions({
+          cwd: tmpDir,
+          sdk,
+          normalizeManagedPackageDependencies: true,
+        }) as any,
+      );
+
+      const finalPackageJson = JSON.parse(
+        await fs.readFile(path.join(tmpDir, "package.json"), "utf-8"),
+      );
+      expect(finalPackageJson.dependencies["@superblocksteam/library"]).toBe(
+        "2.0.0",
+      );
+      expect(execMock).not.toHaveBeenCalled();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("normalizes managed template dependency drift introduced by warm DBFS download before package comparison", async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-dbfs-"));
+    const warmPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        "@superblocksteam/sdk-api": "2.0.0",
+        react: "19.0.0",
+      },
+    };
+    const staleManagedPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        "@superblocksteam/sdk-api": "1.0.0",
+        react: "19.0.0",
+      },
+    };
+
+    try {
+      await fs.writeFile(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify(warmPackageJson, null, 2),
+      );
+      const { readPackage } = await import("read-pkg");
+      (readPackage as Mock).mockImplementation(async ({ cwd }) =>
+        JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")),
+      );
+      mockSyncService.downloadDirectory.mockImplementationOnce(async () => {
+        await fs.writeFile(
+          path.join(tmpDir, "package.json"),
+          JSON.stringify(staleManagedPackageJson, null, 2),
+        );
+      });
+      const sdk = buildMockSdk();
+      sdk.hashLocalDirectory = vi.fn(async () => ({ hash: "local" }));
+      sdk.dbfsGetApplicationDirectoryHash = vi.fn(async () => "server");
+      const { dev } = await import("./dev.mjs");
+
+      await dev(
+        buildDevOptions({
+          cwd: tmpDir,
+          sdk,
+          normalizeManagedPackageDependencies: true,
+        }) as any,
+      );
+
+      const finalPackageJson = JSON.parse(
+        await fs.readFile(path.join(tmpDir, "package.json"), "utf-8"),
+      );
+      expect(finalPackageJson.dependencies["@superblocksteam/sdk-api"]).toBe(
+        "2.0.0",
+      );
+      expect(execMock).not.toHaveBeenCalled();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("does not normalize library drift for normal DBFS download-first startup", async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-dbfs-"));
+    const localPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        react: "19.0.0",
+      },
+    };
+    const serverPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "1.0.0",
+        react: "19.0.0",
+      },
+    };
+
+    try {
+      await fs.writeFile(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify(localPackageJson, null, 2),
+      );
+      const { readPackage } = await import("read-pkg");
+      (readPackage as Mock).mockImplementation(async ({ cwd }) =>
+        JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")),
+      );
+      mockSyncService.downloadDirectory.mockImplementationOnce(async () => {
+        await fs.writeFile(
+          path.join(tmpDir, "package.json"),
+          JSON.stringify(serverPackageJson, null, 2),
+        );
+      });
+      const sdk = buildMockSdk();
+      sdk.hashLocalDirectory = vi.fn(async () => ({ hash: "local" }));
+      sdk.dbfsGetApplicationDirectoryHash = vi.fn(async () => "server");
+      const { dev } = await import("./dev.mjs");
+
+      await dev(
+        buildDevOptions({
+          cwd: tmpDir,
+          sdk,
+        }) as any,
+      );
+
+      const finalPackageJson = JSON.parse(
+        await fs.readFile(path.join(tmpDir, "package.json"), "utf-8"),
+      );
+      expect(finalPackageJson.dependencies["@superblocksteam/library"]).toBe(
+        "1.0.0",
+      );
+      expectInstallToHaveRun();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("runs npm install when S3 restore changes package.json install inputs", async () => {
+    const { dev } = await import("./dev.mjs");
+
+    await dev(
+      buildDevOptions({
+        forcePackageInstall: true,
+      }) as any,
+    );
+
+    expectInstallToHaveRun();
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      "Package install decision",
+      expect.objectContaining({
+        packageJsonRequiresInstall: false,
+        forcePackageInstall: true,
+        upgradePromiseCount: 0,
+      }),
+    );
+  });
+
+  it("uploads local package state when S3 restore forces package installation", async () => {
+    const { dev } = await import("./dev.mjs");
+
+    await dev(
+      buildDevOptions({
+        forcePackageInstall: true,
+      }) as any,
+    );
+
+    expect(mockSyncService.uploadDirectory).toHaveBeenCalledWith("cli:sdk");
+    expect(mockSyncService.uploadDirectoryNowIfNeeded).toHaveBeenCalledWith(
+      "cli:sdk",
+    );
+  });
+
+  it("clears forced npm install when DBFS restores package.json to the pre-restore install inputs", async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-dbfs-"));
+    const warmPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        react: "19.0.0",
+      },
+    };
+    const restoredPackageJson = {
+      name: "test-app",
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        random: "1.0.0",
+        react: "19.0.0",
+      },
+    };
+
+    try {
+      await fs.writeFile(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify(restoredPackageJson, null, 2),
+      );
+      const { readPackage } = await import("read-pkg");
+      (readPackage as Mock).mockImplementation(async ({ cwd }) =>
+        JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")),
+      );
+      mockSyncService.downloadDirectory.mockImplementationOnce(async () => {
+        await fs.writeFile(
+          path.join(tmpDir, "package.json"),
+          JSON.stringify(warmPackageJson, null, 2),
+        );
+      });
+      const sdk = buildMockSdk();
+      sdk.hashLocalDirectory = vi.fn(async () => ({ hash: "local" }));
+      sdk.dbfsGetApplicationDirectoryHash = vi.fn(async () => "server");
+      const { dev } = await import("./dev.mjs");
+
+      await dev(
+        buildDevOptions({
+          cwd: tmpDir,
+          forcePackageInstall: true,
+          packageJsonSnapshotBeforeRestore:
+            packageJsonSnapshot(warmPackageJson),
+          sdk,
+        }) as any,
+      );
+
+      expect(execMock).not.toHaveBeenCalled();
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        "Package install decision",
+        expect.objectContaining({
+          forcePackageInstall: false,
+          forcePackageInstallRequested: true,
+          packageJsonRequiresInstall: false,
+        }),
+      );
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+});