@superblocksteam/sdk 2.0.59-next.0 → 2.0.59-next.10

package/src/cli-replacement/dev.mts

@@ -1,9 +1,10 @@
 import * as child_process from "node:child_process";
 import path from "node:path";
+import * as readline from "node:readline";
 import { promisify } from "node:util";
 import { SpanStatusCode } from "@opentelemetry/api";
 
-import { NotFoundError } from "@superblocksteam/shared";
+import { ConflictError, NotFoundError } from "@superblocksteam/shared";
 import { maskUnixSignals } from "@superblocksteam/util";
 import { AiService } from "@superblocksteam/vite-plugin-file-sync/ai-service";
 import {
@@ -40,12 +41,132 @@ import type { DraftInterface } from "@superblocksteam/vite-plugin-file-sync/draf
 const exec = promisify(child_process.exec);
 
 const passErrorToVSCode = (message: string | undefined, logger: Logger) => {
-  if (message) {
+  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.
     logger.error(`clierr: ${JSON.stringify({ message })}`);
   }
 };
 
+const promptUser = (question: string): Promise<string> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+};
+
+const getBooleanUserResponse = async (question: string): Promise<boolean> => {
+  const answer = await promptUser(question);
+  return answer === "y" || answer === "yes";
+};
+
+async function handleInactiveLockTakeover(
+  lockInfo: { ownerName: string; timeSinceLastActivityMs: number | null },
+  lockSvc: LockService,
+  span: any,
+  logger: Logger,
+): Promise<void> {
+  const inactiveMinutes = Math.floor(
+    (lockInfo.timeSinceLastActivityMs ?? 0) / 1000 / 60,
+  );
+  const warningMessage = `⚠️  This branch is locked by ${lockInfo.ownerName}, but they've been inactive for more than ${inactiveMinutes} minutes.`;
+  const prompt = "Take over editing? (y/N)";
+
+  // If running in VSCode, send prompt to extension
+  if (process.env.SUPERBLOCKS_VSCODE === "true") {
+    logger.error(
+      `cliprompt: ${JSON.stringify({
+        type: "force-takeover",
+        message: `${warningMessage} ${prompt}`,
+        lockInfo: {
+          ownerName: lockInfo.ownerName,
+          inactiveMinutes,
+        },
+      })}`,
+    );
+    logger.warn("Waiting for user response in VSCode...");
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: "Lock takeover prompt shown in VSCode",
+    });
+    throw new Error("Lock takeover prompt shown");
+  }
+
+  // Prompt user to force takeover (CLI only)
+  logger.warn(warningMessage);
+  const shouldTakeover = await getBooleanUserResponse(prompt);
+  if (shouldTakeover) {
+    logger.warn("Taking over lock...");
+    await lockSvc.forceTakeover();
+    logger.info(
+      "Lock acquired successfully. Continuing with dev server startup...",
+    );
+    return;
+  }
+
+  logger.warn("Lock takeover declined. Exiting...");
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: "Lock takeover declined",
+  });
+  throw new Error("Lock takeover declined");
+}
+
+function handleActiveLock(
+  lockInfo: { ownerName: string; lockLifetimeMs: number },
+  error: Error,
+  span: any,
+  logger: Logger,
+): never {
+  const activeMinutes = Math.floor(lockInfo.lockLifetimeMs / 1000 / 60);
+  const activeTime =
+    activeMinutes === 0 ? "less than a minute" : `${activeMinutes} minutes`;
+  const message = `🔒 This branch is currently locked by ${lockInfo.ownerName} (active for ${activeTime}).\nYou cannot run the dev server on this branch. Wait for them to finish editing and try again.`;
+
+  passErrorToVSCode(message, logger);
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: JSON.stringify(error),
+  });
+  throw new Error(message);
+}
+
+async function handleLockConflict(
+  error: ConflictError,
+  lockSvc: LockService,
+  span: any,
+  logger: Logger,
+): Promise<void> {
+  let lockInfo;
+  try {
+    lockInfo = await lockSvc.inspectLock();
+  } catch (inspectError) {
+    logger.error("Failed to inspect lock", getErrorMeta(inspectError));
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: JSON.stringify(error),
+    });
+    passErrorToVSCode(
+      (error as { context?: { message: string } }).context?.message,
+      logger,
+    );
+    throw new Error(`Failed to acquire lock on application: ${error}`);
+  }
+
+  // Successfully inspected the lock
+  if (lockInfo.canForceTakeover) {
+    await handleInactiveLockTakeover(lockInfo, lockSvc, span, logger);
+  } else {
+    handleActiveLock(lockInfo, error, span, logger);
+  }
+}
+
 async function readPkgJson(cwd: string) {
   try {
     const { readPackage } = await import("read-pkg");
@@ -116,6 +237,7 @@ export async function dev(options: {
   /* user control of sync operations */
   uploadFirst?: boolean;
   downloadFirst?: boolean;
+  forceTakeover?: boolean;
   /* only used for testing purposes */
   skipSync?: boolean;
 
@@ -222,10 +344,24 @@ export async function dev(options: {
     try {
       await maskUnixSignals(async () => {
         if (lockService) {
+          const lockSvc = lockService;
           await tracer.startActiveSpan("acquiringInitialLock", async (span) => {
             try {
-              await lockService!.acquireLock();
+              // If --force-takeover flag is set, immediately force takeover instead of acquiring
+              if (options.forceTakeover) {
+                logger.info("Force takeover requested, taking over lock...");
+                await lockSvc.forceTakeover();
+                logger.info("Lock acquired successfully via force takeover.");
+              } else {
+                await lockSvc.acquireLock();
+              }
             } catch (error) {
+              // If we got a conflict error (409), inspect the lock for more information
+              if (error instanceof ConflictError) {
+                await handleLockConflict(error, lockSvc, span, logger);
+                return;
+              }
+
               logger.error(
                 "Failed to acquire lock on application",
                 getErrorMeta(error),

package/src/dev-utils/dev-server.mts

@@ -184,7 +184,8 @@ export async function createDevServer({
       req.url === "/_sb_connect" ||
       req.url === "/_sb_disconnect" ||
       req.url === "/_sb_health" ||
-      req.url === "/_sb_status"
+      req.url === "/_sb_status" ||
+      req.url === "/_sb_activity"
     ) {
       return next();
     }
@@ -431,6 +432,21 @@ export async function createDevServer({
     }
   });
 
+  app.get("/_sb_activity", async (_req, res) => {
+    res.setHeader("Content-Type", "application/json");
+
+    if (lockService) {
+      res.send({
+        isUserActive: lockService.wasRecentlyActive,
+        connectedUsers: lockService.connectedUsers,
+        timeSinceLastActivityMs: lockService.timeSinceLastActivity,
+      });
+    } else {
+      logger.error("Lock service not found, rejecting request");
+      viteReject(new Error("Lock service not found, rejecting request"));
+    }
+  });
+
   process.on("SIGINT", async () => {
     logger.info("SIGINT received");
     await gracefulShutdown({ logger, serverInitiated: false });

package/src/telemetry/logging.ts

@@ -19,7 +19,6 @@ if (process.env.SUPERBLOCKS_IS_CSB === "true") {
 activeTransports.push(
   new transports.Console({
     format: format.combine(
-      format.colorize(),
       format.timestamp({
         format: "HH:mm:ss.SSS",
       }),
@@ -29,11 +28,12 @@ activeTransports.push(
           process.env.SUPERBLOCKS_IS_CSB === "true"
             ? `${timestamp} (${process.pid}) ${message}`
             : `${message}`;
-        if (level === "error") {
+        if (level === "error" && error !== undefined) {
           return `${base} ${(error as ErrorMeta["error"]).message} ${(error as ErrorMeta["error"]).stack}`;
         }
         return base;
       }),
+      format.colorize(),
     ),
   }),
 );
@@ -95,9 +95,13 @@ const logger: Logger = Object.freeze({
       severityNumber: SeverityNumber.ERROR,
       severityText: "ERROR",
       body: message,
-      attributes: meta as unknown as AnyValueMap,
+      attributes: meta as unknown as AnyValueMap | undefined,
     });
-    winstonLogger.error(message, meta);
+    if (meta) {
+      winstonLogger.error(message, { error: meta.error });
+    } else {
+      winstonLogger.error(message);
+    }
   },
 });
 

package/src/vite-plugin-generate-api-build-manifest.mts

@@ -1,12 +1,14 @@
 import path from "node:path";
 import { resolveLanguageSpecificStepContentFromBlocks } from "@superblocksteam/util";
-import { getPageName } from "@superblocksteam/vite-plugin-file-sync";
+import {
+  getPageName,
+  getScopeIdFromName,
+} from "@superblocksteam/vite-plugin-file-sync";
 import { yellow, red } from "colorette";
 import fg from "fast-glob";
 import fs from "fs-extra";
 import { createLogger } from "vite";
 import yaml from "yaml";
-import { getScopeIdFromName } from "../../../../vite-plugin-file-sync/dist/util.js";
 import { getLogger } from "./telemetry/logging.js";
 import type { DeleteMeLibraryApi } from "@superblocksteam/library-shared/types";
 import type { Plugin } from "vite";