@superblocksteam/sdk 2.0.93-next.7 → 2.0.94-next.0

package/src/cli-replacement/dev.mts

@@ -1,10 +1,14 @@
 import * as child_process from "node:child_process";
+import * as nodeFs from "node:fs/promises";
 import path from "node:path";
 import * as readline from "node:readline";
 import { promisify } from "node:util";
 import { SpanStatusCode } from "@opentelemetry/api";
-
-import { ConflictError, NotFoundError } from "@superblocksteam/shared";
+import {
+  ConflictError,
+  NotFoundError,
+  SUPERBLOCKS_LIVE_GIT_BRANCH,
+} from "@superblocksteam/shared";
 import { maskUnixSignals } from "@superblocksteam/util";
 import {
   AiService,
@@ -12,6 +16,7 @@ import {
   SnapshotManager,
   isSdkApiTemplate,
 } from "@superblocksteam/vite-plugin-file-sync/ai-service";
+import { createGitService } from "@superblocksteam/vite-plugin-file-sync/git-service";
 import {
   LockService,
   LockType,
@@ -24,9 +29,11 @@ import fs from "fs-extra";
 import { resolveCommand } from "package-manager-detector";
 import { detect } from "package-manager-detector/detect";
 
-import { AUTO_UPGRADE_EXIT_CODE, createDevServer } from "../index.js";
+import { createDevServer } from "../dev-utils/dev-server.mjs";
+import { AUTO_UPGRADE_EXIT_CODE } from "../index.js";
 import { getTracer } from "../telemetry/index.js";
 import { getErrorMeta, getLogger, type Logger } from "../telemetry/logging.js";
+import { buildGithubSuperblocksSyncWorkflow } from "./assets/git-workflows/github-superblocks-sync-workflow.js";
 import { checkVersionsAndWritePackageJson } from "./automatic-upgrades.js";
 import { getCurrentCliVersion } from "./version-detection.js";
 import type {
@@ -41,9 +48,9 @@ import type {
   TokenConfig,
 } from "../types/index.js";
 import type { DraftInterface } from "@superblocksteam/vite-plugin-file-sync/draft-interface";
+import type { GitService } from "@superblocksteam/vite-plugin-file-sync/git-service";
 
 const exec = promisify(child_process.exec);
-
 const passErrorToVSCode = (message: string | undefined, logger: Logger) => {
   if (message && process.env.SUPERBLOCKS_VSCODE === "true") {
     // Prefixing with `clierr:` will make the VS code extension capture this message and show it to the user.
@@ -287,7 +294,10 @@ export async function dev(options: {
   let lockService: LockService | undefined;
   let syncService: SyncService | undefined;
   let aiService: AiService | undefined;
+  let gitService: GitService | undefined;
   let snapshotManager: SnapshotManager | undefined;
+  let gitUserName: string | undefined;
+  let gitUserEmail: string | undefined;
   const tracer = getTracer();
   const logger = getLogger(options.logger);
   const skipAutoUpgrade = autoUpgradeMode === DevServerAutoUpgradeMode.SKIP;
@@ -318,6 +328,7 @@ export async function dev(options: {
       const port = devServerPort ?? 5173;
 
       const fsOperationQueue = new OperationQueue();
+      let activeDbfsBranchName = applicationConfig?.branchName ?? "main";
       if (applicationConfig && !skipSync) {
         const rpcClient = new AutoConnectingRpcClient(
           tokenConfig.superblocksBaseUrl,
@@ -346,11 +357,19 @@ export async function dev(options: {
           lockType === LockType.CSB
             ? featureFlags.devServerCloudInactivityTimeoutMinutes() * 60 * 1000
             : featureFlags.devServerLocalInactivityTimeoutMinutes() * 60 * 1000;
+        activeDbfsBranchName = await resolveDbfsBranchName(
+          sdk,
+          applicationConfig,
+          logger,
+        );
+        logger.info(
+          `Using DBFS branch '${activeDbfsBranchName}' for live edit sync`,
+        );
 
         lockService = new LockService({
           superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
           applicationId: applicationConfig.id,
-          branchName: applicationConfig.branchName,
+          branchName: activeDbfsBranchName,
           lockType: lockType,
           tracer,
           logger,
@@ -361,7 +380,7 @@ export async function dev(options: {
         syncService = new SyncService({
           appRootDirPath: cwd,
           applicationId: applicationConfig.id,
-          branchName: applicationConfig.branchName,
+          branchName: activeDbfsBranchName,
           fsOperationQueue,
           lockService: lockService,
           tracer,
@@ -427,7 +446,12 @@ export async function dev(options: {
                 try {
                   const results = await Promise.all([
                     sdk.hashLocalDirectory(cwd),
-                    getDraftOrLiveEditHash(sdk, applicationConfig, logger),
+                    getDraftOrLiveEditHash(
+                      sdk,
+                      applicationConfig.id,
+                      activeDbfsBranchName,
+                      logger,
+                    ),
                     sdk.fetchCurrentUser(),
                   ]);
                   return results;
@@ -436,6 +460,9 @@ export async function dev(options: {
                 }
               });
 
+            gitUserName = currentUser.user.name;
+            gitUserEmail = currentUser.user.email;
+
             snapshotManager = new SnapshotManager(currentUser.user.id);
             const didSnapshotRestore =
               await snapshotManager.executePendingRestore(cwd);
@@ -457,6 +484,13 @@ export async function dev(options: {
                 | Record<string, unknown>
                 | undefined),
               "clark.sdk-api.enabled": sdkApiEnabled,
+              "superblocks.native-git.enabled":
+                sdkApiEnabled &&
+                !!(
+                  currentUser.flagBootstrap as
+                    | Record<string, unknown>
+                    | undefined
+                )?.["superblocks.native-git.enabled"],
             };
 
             aiService = new AiService({
@@ -490,11 +524,11 @@ export async function dev(options: {
 
             if (isSynced) {
               logger.info(
-                `Local files are in sync with the server on branch '${applicationConfig.branchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
+                `Local files are in sync with the server on branch '${activeDbfsBranchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
               );
             } else {
               logger.info(
-                `Local files are out of sync with the server on branch '${applicationConfig.branchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
+                `Local files are out of sync with the server on branch '${activeDbfsBranchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
               );
             }
 
@@ -516,7 +550,7 @@ export async function dev(options: {
             if (downloadFirst && !isSynced) {
               await tracer.startActiveSpan("downloadFirst", async (span) => {
                 logger.info(
-                  `Starting download of branch '${applicationConfig.branchName}'`,
+                  `Starting download of branch '${activeDbfsBranchName}'`,
                 );
 
                 await syncService!.downloadDirectory();
@@ -524,6 +558,76 @@ export async function dev(options: {
               });
             }
 
+            // Git sync step — runs after DBFS download, before version check.
+            // Best-effort: never blocks startup on failure.
+            await tracer.startActiveSpan("gitSync", async (gitSpan) => {
+              try {
+                const bootstrappedGitService = await bootstrapGitService({
+                  sdk,
+                  applicationId: applicationConfig.id,
+                  cwd,
+                  logger,
+                  userName: gitUserName,
+                  userEmail: gitUserEmail,
+                });
+
+                if (!bootstrappedGitService) {
+                  logger.info("No git remote configured, skipping git sync");
+                  gitSpan.end();
+                  return;
+                }
+
+                gitService = bootstrappedGitService;
+
+                // At this point the local repo is usable for status(),
+                // so gitService stays set even if the remote sync below
+                // fails. The footer will show uncommitted changes and
+                // the user can fix their PAT if push/pull don't work.
+                // Also ensure lock/sync branch context is reconciled now,
+                // so startup does not remain pinned to main if git config
+                // became visible after initial branch resolution.
+                activeDbfsBranchName = await ensureRuntimeDbfsBranchConsistency(
+                  {
+                    sdk,
+                    applicationConfig,
+                    logger,
+                    lockService,
+                    syncService,
+                    currentBranchName: activeDbfsBranchName,
+                  },
+                );
+
+                // 3. Fetch remote — failures are non-fatal.
+                //    We don't auto-merge here; the user pulls from the editor
+                //    when ready, and Clark handles any conflicts.
+                try {
+                  await fetchAndEnsureLiveBranch(
+                    gitService,
+                    "Git remote sync failed (local repo still usable)",
+                  );
+                } catch (syncError) {
+                  logger.warn(
+                    `Git remote sync failed (local repo still usable): ${syncError instanceof Error ? syncError.message : String(syncError)}`,
+                  );
+                }
+              } catch (gitError) {
+                // Init/configure/ensureGitRepo failed — repo is not usable
+                gitService = undefined;
+                logger.warn(
+                  `Git setup failed, continuing without git: ${gitError instanceof Error ? gitError.message : String(gitError)}`,
+                );
+                gitSpan.setStatus({
+                  code: SpanStatusCode.ERROR,
+                  message:
+                    gitError instanceof Error
+                      ? gitError.message
+                      : String(gitError),
+                });
+              } finally {
+                gitSpan.end();
+              }
+            });
+
             let hasCliUpdated = false;
             let upgradePromises: Promise<void>[] = [];
             const forceUpgrade =
@@ -594,7 +698,7 @@ export async function dev(options: {
 
             if (hasPackageChanged || uploadFirst) {
               logger.info(
-                `Uploading local files to branch '${applicationConfig.branchName}' on server before starting`,
+                `Uploading local files to branch '${activeDbfsBranchName}' on server before starting`,
               );
               await tracer.startActiveSpan(
                 "uploadFirstOrPackageChanged",
@@ -635,10 +739,78 @@ export async function dev(options: {
         logger.info("Skipping directory sync");
       }
 
+      const activateRuntimeGitService = async (): Promise<
+        GitService | undefined
+      > => {
+        if (gitService) {
+          const hasGit = await nodeFs.access(path.join(cwd, ".git")).then(
+            () => true,
+            () => false,
+          );
+          if (!hasGit) {
+            logger.warn(
+              "[git] activateRuntimeGitService: .git directory disappeared, clearing cached git service",
+            );
+            gitService = undefined;
+            return undefined;
+          }
+
+          activeDbfsBranchName = await ensureRuntimeDbfsBranchConsistency({
+            sdk,
+            applicationConfig,
+            logger,
+            lockService,
+            syncService,
+            currentBranchName: activeDbfsBranchName,
+          });
+          return gitService;
+        }
+
+        try {
+          const runtimeGitService = await bootstrapGitService({
+            sdk,
+            applicationId: applicationConfig.id,
+            cwd,
+            logger,
+            userName: gitUserName,
+            userEmail: gitUserEmail,
+          });
+          if (!runtimeGitService) {
+            return undefined;
+          }
+
+          try {
+            await fetchAndEnsureLiveBranch(
+              runtimeGitService,
+              "Git runtime bootstrap fetch failed",
+            );
+          } catch {
+            // fetchAndEnsureLiveBranch already logs the failure
+          }
+
+          activeDbfsBranchName = await ensureRuntimeDbfsBranchConsistency({
+            sdk,
+            applicationConfig,
+            logger,
+            lockService,
+            syncService,
+            currentBranchName: activeDbfsBranchName,
+          });
+
+          gitService = runtimeGitService;
+          return gitService;
+        } catch (error) {
+          logger.warn(
+            `Git runtime bootstrap failed: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          return undefined;
+        }
+      };
+
       const httpServer = await tracer.startActiveSpan(
         "createDevServer",
         async (span) => {
-          const result = await createDevServer({
+          const createDevServerOptions = {
             root: options.cwd,
             mode: "development",
             port: port,
@@ -646,10 +818,12 @@ export async function dev(options: {
             syncService: syncService,
             lockService: lockService,
             aiService: aiService,
+            activateGitService: activateRuntimeGitService,
             snapshotManager: snapshotManager,
             logger: options.logger,
             sdk,
-          });
+          } as unknown as Parameters<typeof createDevServer>[0];
+          const result = await createDevServer(createDevServerOptions);
           span.end();
           return result;
         },
@@ -686,22 +860,253 @@ export async function dev(options: {
     }
   });
 }
+// ---------------------------------------------------------------------------
+// Git sync helpers
+// ---------------------------------------------------------------------------
+
+async function bootstrapGitService({
+  sdk,
+  applicationId,
+  cwd,
+  logger,
+  userName,
+  userEmail,
+}: {
+  sdk: SuperblocksSdk;
+  applicationId: string;
+  cwd: string;
+  logger: Logger;
+  userName?: string;
+  userEmail?: string;
+}): Promise<GitService | undefined> {
+  interface GitConfigSdk {
+    getApplicationGitConfig(applicationId: string): Promise<{
+      gitRemoteUrl?: string;
+      hasCredential?: boolean;
+    } | null>;
+    getGitFreshToken(
+      host: string,
+      applicationId: string,
+    ): Promise<{ username: string; token: string }>;
+  }
+  const gitConfigSdk = sdk as unknown as GitConfigSdk;
+  const gitConfig = await gitConfigSdk.getApplicationGitConfig(applicationId);
+  if (!gitConfig?.gitRemoteUrl) {
+    return undefined;
+  }
+
+  const service = createGitService(cwd);
+  let credentials: { username: string; token: string } | undefined;
+
+  if (gitConfig.hasCredential) {
+    try {
+      const host = new URL(gitConfig.gitRemoteUrl).hostname;
+      const freshToken = await gitConfigSdk.getGitFreshToken(
+        host,
+        applicationId,
+      );
+      if (freshToken) {
+        credentials = freshToken;
+      }
+    } catch {
+      logger.warn("Could not fetch git credentials, continuing without auth");
+    }
+  }
+
+  await service.configure({ credentials, userName, userEmail });
+  await ensureGitRepo(service, gitConfig.gitRemoteUrl);
+
+  return service;
+}
+
+async function fetchAndEnsureLiveBranch(
+  git: GitService,
+  errorPrefix: string,
+): Promise<void> {
+  let fetchError: unknown;
+  try {
+    await git.fetch();
+  } catch (error) {
+    fetchError = error;
+    getLogger().warn(
+      `${errorPrefix}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  // Always ensure the local superblocks/live branch exists,
+  // even if fetch failed (remote may not be reachable yet).
+  await ensureLiveBranchCheckedOutAfterFetch(git);
+  if (fetchError) {
+    throw fetchError;
+  }
+}
+
+async function ensureGitRepo(
+  git: GitService,
+  remoteUrl: string,
+): Promise<void> {
+  const hasGit = await nodeFs.access(path.join(git.workDir, ".git")).then(
+    () => true,
+    () => false,
+  );
+
+  if (!hasGit) {
+    await git.init();
+    await git.addRemote("origin", remoteUrl);
+
+    const remoteRefs = await git
+      .raw([
+        "ls-remote",
+        "--heads",
+        "origin",
+        `refs/heads/${SUPERBLOCKS_LIVE_GIT_BRANCH}`,
+      ])
+      .catch((err) => {
+        getLogger().warn(
+          `[git] ensureGitRepo: ls-remote failed (remote may be unreachable): ${err instanceof Error ? err.message : String(err)}`,
+        );
+        return "";
+      });
+
+    if (!remoteRefs.includes(`refs/heads/${SUPERBLOCKS_LIVE_GIT_BRANCH}`)) {
+      // No superblocks/live on remote — keep existing bootstrap flow.
+      await seedGithubWorkflowIfNeeded(git.workDir, remoteUrl);
+      await git.raw(["commit", "--allow-empty", "-m", "Initial commit"]);
+      const currentBranch = (
+        await git.raw(["branch", "--show-current"])
+      ).trim();
+
+      await git.push("origin", currentBranch);
+
+      // Additional alignment step: base live branch off remote default branch tip.
+      const defaultBranch = await git.getDefaultBranch();
+      await git.raw(["fetch", "origin", defaultBranch]).catch(() => "");
+      const preferredStartPoint = `origin/${defaultBranch}`;
+      const fallbackStartPoint = `origin/${currentBranch}`;
+      const liveStartPoint = (await canResolveRef(git, preferredStartPoint))
+        ? preferredStartPoint
+        : fallbackStartPoint;
+
+      await git.checkoutOrCreate(SUPERBLOCKS_LIVE_GIT_BRANCH, liveStartPoint);
+    } else {
+      // Remote already has superblocks/live — fetch and set up local branch.
+      await git.raw(["fetch", "origin"]);
+      await git.raw([
+        "symbolic-ref",
+        "HEAD",
+        `refs/heads/${SUPERBLOCKS_LIVE_GIT_BRANCH}`,
+      ]);
+      await git.raw(["reset", `origin/${SUPERBLOCKS_LIVE_GIT_BRANCH}`]);
+    }
+  } else {
+    // If remote URL changed, update it
+    try {
+      const remotes = await git.getRemotes(true);
+      const origin = remotes.find((r) => r.name === "origin");
+      if (origin && origin.refs.fetch !== remoteUrl) {
+        getLogger().warn(
+          `[git] ensureGitRepo: remote URL changed from "${origin.refs.fetch}" to "${remoteUrl}", updating`,
+        );
+        await git.remote(["set-url", "origin", remoteUrl]);
+      } else if (!origin) {
+        getLogger().warn("[git] ensureGitRepo: no origin remote found, adding");
+        await git.addRemote("origin", remoteUrl);
+      }
+    } catch (remoteErr) {
+      getLogger().warn(
+        `[git] ensureGitRepo: failed to inspect/update remotes, attempting fallback: ${remoteErr instanceof Error ? remoteErr.message : String(remoteErr)}`,
+      );
+      try {
+        await git.addRemote("origin", remoteUrl);
+      } catch {
+        await git.remote(["set-url", "origin", remoteUrl]);
+      }
+    }
+  }
+
+  // Ensure GitHub workflow exists for native git flows even when reusing an
+  // existing local repo (hasGit=true), so users don't miss .github bootstrap.
+  await seedGithubWorkflowIfNeeded(git.workDir, remoteUrl);
+}
+
+function isGithubRemote(remoteUrl: string): boolean {
+  return remoteUrl.includes("github.com");
+}
+
+async function seedGithubWorkflowIfNeeded(
+  workDir: string,
+  remoteUrl: string,
+): Promise<void> {
+  if (!isGithubRemote(remoteUrl)) {
+    return;
+  }
+
+  const workflowDir = path.join(workDir, ".github", "workflows");
+  const workflowFile = path.join(workflowDir, "superblocks-sync.yml");
+  const alreadyExists = await nodeFs
+    .access(workflowFile)
+    .then(() => true)
+    .catch(() => false);
+  if (alreadyExists) {
+    return;
+  }
+
+  await nodeFs.mkdir(workflowDir, { recursive: true });
+  await nodeFs.writeFile(
+    workflowFile,
+    buildGithubSuperblocksSyncWorkflow(),
+    "utf-8",
+  );
+}
+
+async function canResolveRef(git: GitService, ref: string): Promise<boolean> {
+  try {
+    await git.revparse(ref);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureLiveBranchCheckedOutAfterFetch(
+  git: GitService,
+): Promise<void> {
+  // If remote live branch exists, initialize/switch local live branch from it.
+  // This handles fresh repos where HEAD is unborn before first fetch.
+  if (await canResolveRef(git, `origin/${SUPERBLOCKS_LIVE_GIT_BRANCH}`)) {
+    await git.checkoutOrCreate(
+      SUPERBLOCKS_LIVE_GIT_BRANCH,
+      `origin/${SUPERBLOCKS_LIVE_GIT_BRANCH}`,
+    );
+    return;
+  }
+
+  // No remote live branch yet — keep working on local superblocks/live.
+  const branch = await git
+    .raw(["branch", "--show-current"])
+    .then((b) => b.trim())
+    .catch(() => "");
+  if (branch !== SUPERBLOCKS_LIVE_GIT_BRANCH) {
+    await git.checkoutOrCreate(SUPERBLOCKS_LIVE_GIT_BRANCH);
+  }
+}
+
 async function getDraftOrLiveEditHash(
   sdk: SuperblocksSdk,
-  applicationConfig: ApplicationConfig,
+  applicationId: string,
+  branchName: string,
   logger: Logger,
 ): Promise<string> {
   try {
     const draftHash = await sdk.dbfsGetApplicationDirectoryHash({
-      applicationId: applicationConfig.id,
-      branch: applicationConfig.branchName,
+      applicationId,
+      branch: branchName,
     });
     return draftHash;
   } catch (e: unknown) {
     if (e instanceof NotFoundError) {
       const liveEditHash = await sdk.dbfsGetApplicationDirectoryHash({
-        applicationId: applicationConfig.id,
-        branch: applicationConfig.branchName,
+        applicationId,
+        branch: branchName,
       });
       logger.warn(
         "Draft state not found, using live edit hash: " + liveEditHash,
@@ -712,3 +1117,108 @@ async function getDraftOrLiveEditHash(
     }
   }
 }
+
+async function ensureRuntimeDbfsBranchConsistency({
+  sdk,
+  applicationConfig,
+  logger,
+  lockService,
+  syncService,
+  currentBranchName,
+}: {
+  sdk: SuperblocksSdk;
+  applicationConfig: ApplicationConfig;
+  logger: Logger;
+  lockService?: LockService;
+  syncService?: SyncService;
+  currentBranchName: string;
+}): Promise<string> {
+  interface BranchSwitchingLockService {
+    isLocked: boolean;
+    switchBranch(
+      nextBranchName: string,
+      options?: { reacquireLock?: boolean },
+    ): Promise<void>;
+  }
+  interface BranchSwitchingSyncService {
+    setBranchName(nextBranchName: string): void;
+  }
+
+  const targetBranchName = await resolveDbfsBranchName(
+    sdk,
+    applicationConfig,
+    logger,
+  );
+
+  if (targetBranchName === currentBranchName) {
+    return currentBranchName;
+  }
+
+  if (!lockService || !syncService) {
+    logger.warn(
+      `Target DBFS branch changed to '${targetBranchName}', but lock/sync services are unavailable; keeping '${currentBranchName}'`,
+    );
+    return currentBranchName;
+  }
+
+  const lockSvc = lockService as unknown as BranchSwitchingLockService;
+  const syncSvc = syncService as unknown as BranchSwitchingSyncService;
+  const wasLocked = lockSvc.isLocked;
+  logger.info(
+    `Switching runtime DBFS branch context from '${currentBranchName}' to '${targetBranchName}'`,
+  );
+
+  try {
+    syncSvc.setBranchName(targetBranchName);
+    await lockSvc.switchBranch(targetBranchName, { reacquireLock: wasLocked });
+    // Align local workspace with the newly selected DBFS branch.
+    await syncService.downloadDirectory();
+    return targetBranchName;
+  } catch (error) {
+    logger.warn(
+      `Failed to switch runtime DBFS branch to '${targetBranchName}', keeping '${currentBranchName}': ${error instanceof Error ? error.message : String(error)}`,
+    );
+    syncSvc.setBranchName(currentBranchName);
+    try {
+      await lockSvc.switchBranch(currentBranchName, {
+        reacquireLock: lockSvc.isLocked || wasLocked,
+      });
+    } catch (rollbackError) {
+      logger.warn(
+        `Failed to rollback lock service branch context to '${currentBranchName}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`,
+      );
+    }
+    return currentBranchName;
+  }
+}
+
+async function resolveDbfsBranchName(
+  sdk: SuperblocksSdk,
+  applicationConfig: ApplicationConfig,
+  logger: Logger,
+): Promise<string> {
+  interface GitAwareSdk {
+    getApplicationGitConfig(
+      applicationId: string,
+    ): Promise<{ gitRemoteUrl?: string } | null>;
+  }
+
+  const fallbackBranchName = applicationConfig.branchName;
+  const gitAwareSdk = sdk as unknown as GitAwareSdk;
+
+  try {
+    const gitConfig = await gitAwareSdk.getApplicationGitConfig(
+      applicationConfig.id,
+    );
+    // Keep DBFS branch selection independent of server-side branch records.
+    // If Git is connected, always use the live workspace branch.
+    return gitConfig?.gitRemoteUrl
+      ? SUPERBLOCKS_LIVE_GIT_BRANCH
+      : fallbackBranchName;
+  } catch (error) {
+    logger.warn(
+      `Could not resolve DBFS branch selection; falling back to '${fallbackBranchName}': ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return fallbackBranchName;
+  }
+}