@superblocksteam/sdk 2.0.123 → 2.0.124-next.1

package/src/cli-replacement/dev-startup-git-before-dbfs-order.test.mts

@@ -14,9 +14,11 @@ import {
 } from "vitest";
 
 const execMock = vi.fn();
+const execFileMock = vi.fn();
 vi.mock("node:child_process", () => ({
-  default: { exec: execMock },
+  default: { exec: execMock, execFile: execFileMock },
   exec: execMock,
+  execFile: execFileMock,
 }));
 
 vi.mock("node:readline", () => ({
@@ -89,7 +91,12 @@ vi.mock("colorette", () => ({
   green: (s: string) => s,
 }));
 
-vi.mock("@superblocksteam/shared", () => ({
+vi.mock("@superblocksteam/shared", async (importOriginal) => ({
+  // dev.mts now transitively loads @superblocksteam/shared (via the npm-error
+  // classifier re-exported from vite-plugin-file-sync/npm-registry — APPS-4450),
+  // pulling in many named exports (DeploymentTypeEnum, ISocket, …). Spread the
+  // real module so the closed overrides below don't have to enumerate them.
+  ...((await importOriginal()) as Record<string, unknown>),
   buildGithubSuperblocksSyncWorkflow: vi.fn(),
   buildGithubSuperblocksSyncWorkflowFromBaseUrl: vi.fn(),
   ConflictError: class ConflictError extends Error {},
@@ -110,6 +117,7 @@ vi.mock("@superblocksteam/vite-plugin-file-sync/ai-service", () => ({
     initialize = vi.fn(async () => undefined);
     removeIntegrationCache = vi.fn(async () => undefined);
     chatSessionStore = { invalidateCache: vi.fn() };
+    getNpmRegistryClient = vi.fn(() => undefined);
   },
   AiServiceFeatureFlags: class {
     static create = vi.fn(() => ({}));
@@ -121,6 +129,10 @@ vi.mock("@superblocksteam/vite-plugin-file-sync/ai-service", () => ({
   stripResolvedFromLockfile: vi.fn(async () => undefined),
 }));
 
+vi.mock("@superblocksteam/vite-plugin-file-sync/npm-registry", () => ({
+  shouldIgnoreInstallScripts: vi.fn(() => false),
+}));
+
 const { startupOpLog, buildMockGitService } = vi.hoisted(() => {
   const startupOpLog: string[] = [];
   function buildMockGitService(cwd: string) {
@@ -254,6 +266,25 @@ vi.mock("./automatic-upgrades.js", () => ({
   checkVersionsAndWritePackageJson: (
     ...args: Parameters<typeof mockCheckVersions>
   ) => mockCheckVersions(...args),
+  buildInstallEnv: (userconfigPath: string) => ({
+    ...process.env,
+    NPM_CONFIG_USERCONFIG: userconfigPath,
+    PNPM_CONFIG_USERCONFIG: userconfigPath,
+  }),
+}));
+
+// The home `~/.npmrc` writer (APPS-4231) is a best-effort step that runs
+// before auto-upgrade. Mock it out here so this test stays focused on the
+// git-before-DBFS ordering. The `AiService` mock above exposes a minimal
+// `getNpmRegistryClient()` stub so the call site doesn't `TypeError`
+// and silently swallow this mock.
+vi.mock("./home-npmrc.mjs", () => ({
+  syncHomeNpmrc: vi.fn(async () => ({
+    outcome: "skipped-not-configured",
+    path: "/tmp/.superblocks/npmrc",
+  })),
+  superblocksNpmrcPath: vi.fn(() => "/tmp/.superblocks/npmrc"),
+  superblocksLogsPath: vi.fn((appDir: string) => `${appDir}/.superblocks/logs`),
 }));
 
 vi.mock("./git-repo-setup.mjs", () => ({
@@ -330,6 +361,8 @@ function buildDevOptions(cwd: string, overrides: Record<string, unknown> = {}) {
     tokenManager: {
       getToken: vi.fn(() => "test-token"),
       onTokenRefresh: vi.fn(),
+      updateToken: vi.fn(),
+      getCurrentToken: vi.fn(() => "test-token"),
     },
     getCurrentToken: vi.fn(() => "test-token"),
     sdk: buildMockSdk(),

package/src/cli-replacement/dev-token-priming.test.mts

@@ -0,0 +1,103 @@
+/**
+ * Tests for the cold-start `TokenManager` priming step (APPS-4231 follow-up).
+ *
+ * Background
+ * ----------
+ * `NpmRegistryClient.getJwt()` (`packages/vite-plugin-file-sync/src/ai-service/index.ts`)
+ * has two bearer-credential sources:
+ *   1. `tokenManagerJwt`, seeded synchronously at `AiService` construction
+ *      from `tokenManager.getCurrentToken()` and kept current via the
+ *      `tokenUpdated` listener for future refreshes.
+ *   2. `clark?.context?.jwt`, primed lazily by the first socket RPC's
+ *      `peerAuthorization` header (`socket-manager.ts`).
+ *
+ * `TokenManager.updateToken()` has exactly one production writer outside
+ * `dev()` itself: `AuthHotReloadServer` (`auth-hot-reload.mts`). That socket
+ * is explicitly disabled on live-edit pods (SABS sets
+ * `SUPERBLOCKS_AUTH_HOT_RELOAD=false`). So on cold start neither source is
+ * primed until the UI socket lands — which is AFTER `syncHomeNpmrc` and
+ * AFTER the AiService's `TemplateRenderer` prefetch fires.
+ *
+ * The CLI does have a usable token in scope at `dev()` entry
+ * (`tokenConfig.token`, sourced from auth.json or `/_sb_activate`).
+ * `primeTokenManagerWithInitialToken` seeds it. Because `TokenManager`
+ * retains the current token as state and consumers read it synchronously
+ * during construction (see `getCurrentToken()` on `ITokenManager`), the
+ * call-site ordering between the prime and consumer construction is NOT
+ * load-bearing: the seed reaches AiService whether the prime fires before
+ * or after `new AiService(...)`.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+
+import { TokenManager } from "../dev-utils/token-manager.js";
+import { primeTokenManagerWithInitialToken } from "./dev.mjs";
+
+describe("primeTokenManagerWithInitialToken", () => {
+  it("emits a `tokenUpdated` event carrying the supplied token to listeners subscribed before the call", () => {
+    const tokenManager = new TokenManager();
+    const events: string[] = [];
+    tokenManager.on("tokenUpdated", (event) => {
+      events.push(event.token);
+    });
+
+    primeTokenManagerWithInitialToken(tokenManager, "jwt-from-cold-start");
+
+    expect(events).toEqual(["jwt-from-cold-start"]);
+  });
+
+  it("no-ops when the token is empty (no spurious `tokenUpdated` event)", () => {
+    const tokenManager = new TokenManager();
+    const events: string[] = [];
+    tokenManager.on("tokenUpdated", (event) => {
+      events.push(event.token);
+    });
+
+    primeTokenManagerWithInitialToken(tokenManager, "");
+
+    expect(events).toEqual([]);
+  });
+});
+
+describe("TokenManager state retention (cold-start contract)", () => {
+  it("exposes the primed token via getCurrentToken() to consumers constructed AFTER the prime call", () => {
+    // This is what makes the dev.mts call site order-independent. AiService
+    // reads tokenManager.getCurrentToken() synchronously in its constructor
+    // to seed `tokenManagerJwt` — so even if `dev()` primes BEFORE
+    // `new AiService(...)`, the seed survives.
+    const tokenManager = new TokenManager();
+    primeTokenManagerWithInitialToken(tokenManager, "seed-jwt");
+
+    expect(tokenManager.getCurrentToken()).toBe("seed-jwt");
+  });
+
+  it("returns undefined from getCurrentToken() when no token has been set", () => {
+    const tokenManager = new TokenManager();
+
+    expect(tokenManager.getCurrentToken()).toBeUndefined();
+  });
+
+  it("does NOT auto-replay prior emissions to late-attached listeners", () => {
+    // Deliberate: auto-replaying would cause refresh-handling subscribers
+    // (e.g. AutoConnectingRpcClient, which closes and reconnects the socket
+    // on every `tokenUpdated`) to fire on what is conceptually a seed read.
+    // Late-attached subscribers MUST opt in via `getCurrentToken()` if they
+    // need the current value at attach time; the event channel is for
+    // changes only.
+    const tokenManager = new TokenManager();
+    primeTokenManagerWithInitialToken(tokenManager, "abc");
+
+    const lateListener = vi.fn();
+    tokenManager.on("tokenUpdated", lateListener);
+
+    expect(lateListener).not.toHaveBeenCalled();
+  });
+
+  it("overwrites the stored token on each updateToken call so refreshes win", () => {
+    const tokenManager = new TokenManager();
+    primeTokenManagerWithInitialToken(tokenManager, "first");
+    tokenManager.updateToken("second");
+
+    expect(tokenManager.getCurrentToken()).toBe("second");
+  });
+});

package/src/cli-replacement/dev.interception.test.mts

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+import { InitialInstallFailed } from "./dependency-install-classifier.mjs";
+import { handleStartupError } from "./dev.mjs";
+
+// Mock the metrics module so we can assert recordInitialInstallFailure calls.
+// vi.mock is hoisted, so we use vi.hoisted to declare the spy before the factory.
+const { recordInitialInstallFailureMock } = vi.hoisted(() => ({
+  recordInitialInstallFailureMock: vi.fn(),
+}));
+vi.mock("../dev-utils/dev-server-metrics.mjs", () => ({
+  devServerMetrics: {
+    recordInitialInstallFailure: recordInitialInstallFailureMock,
+    flush: vi.fn(),
+    recordEndpoint: vi.fn(),
+    recordSocketUpgrade: vi.fn(),
+    recordViteEagerInit: vi.fn(),
+    recordWarmPrewarm: vi.fn(),
+    recordWarmActivation: vi.fn(),
+    recordWarmHandoff: vi.fn(),
+  },
+}));
+
+const makeLogger = () =>
+  ({ error: () => {}, info: () => {}, warn: () => {} }) as any;
+
+beforeEach(() => {
+  recordInitialInstallFailureMock.mockClear();
+});
+
+describe("handleStartupError", () => {
+  it("records + does NOT exit for InitialInstallFailed", () => {
+    const status = { serverErrors: [] as any[] };
+    const marker = new InitialInstallFailed({
+      type: "dev-server/dependency-install",
+      timestamp: "t",
+      category: "dependency_conflict",
+      rawError: "x",
+    });
+    const decision = handleStartupError(marker, status, makeLogger());
+    expect(decision).toBe("degrade");
+    expect(status.serverErrors).toHaveLength(1);
+  });
+
+  it("emits the install-failure metric with category on the degrade path", () => {
+    const status = { serverErrors: [] as any[] };
+    const marker = new InitialInstallFailed({
+      type: "dev-server/dependency-install",
+      timestamp: "t",
+      category: "registry_auth_failed",
+      npmErrorCode: "E401",
+      hasAnyRegistryConfigured: true,
+      rawError: "x",
+    });
+    handleStartupError(marker, status, makeLogger());
+    expect(recordInitialInstallFailureMock).toHaveBeenCalledOnce();
+    expect(recordInitialInstallFailureMock).toHaveBeenCalledWith({
+      category: "registry_auth_failed",
+      npmErrorCode: "E401",
+      hasAnyRegistryConfigured: true,
+    });
+  });
+
+  it("does NOT emit the install-failure metric on the exit path", () => {
+    const status = { serverErrors: [] as any[] };
+    handleStartupError(new Error("lock failed"), status, makeLogger());
+    expect(recordInitialInstallFailureMock).not.toHaveBeenCalled();
+  });
+
+  it("exits for a non-marker error (upgrade / lock / sync)", () => {
+    const status = { serverErrors: [] as any[] };
+    const decision = handleStartupError(
+      new Error("lock failed"),
+      status,
+      makeLogger(),
+    );
+    expect(decision).toBe("exit");
+    expect(status.serverErrors).toHaveLength(0);
+  });
+});