@superblocksteam/sdk 2.0.129 → 2.0.130-next.0

package/src/dev-utils/dev-server-metrics.boot.test.mts

@@ -0,0 +1,83 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { devServerMetrics as DevServerMetricsSingleton } from "./dev-server-metrics.mjs";
+
+/**
+ * Boot-completion-signal emission tests.
+ *
+ * These exercise the real `DevServerMetrics.recordBoot` / `flush` logic against
+ * a fake meter captured at the `getMeter()` boundary — i.e. we "listen" to
+ * exactly the metric increments and labels that would be flushed to the OTLP
+ * exporter, without standing up a network collector. The only substitutions are
+ * the two telemetry-bootstrap boundaries the module depends on
+ * (`isTelemetryInitialized`, `getMeter`).
+ */
+
+type Add = { name: string; value: number; attrs: Record<string, unknown> };
+
+const h = vi.hoisted(() => ({
+  adds: [] as Add[],
+  telemetryUp: true,
+}));
+
+vi.mock("@superblocksteam/telemetry", () => ({
+  isTelemetryInitialized: () => h.telemetryUp,
+}));
+
+vi.mock("../telemetry/index.js", () => ({
+  getMeter: () => ({
+    createCounter: (name: string) => ({
+      add: (value: number, attrs: Record<string, unknown>) =>
+        h.adds.push({ name, value, attrs }),
+    }),
+    createHistogram: () => ({ record: () => {} }),
+  }),
+}));
+
+const bootAdds = () => h.adds.filter((a) => a.name === "dev_server_boot_total");
+
+describe("devServerMetrics.recordBoot (in-place-restart completion signal)", () => {
+  let devServerMetrics: typeof DevServerMetricsSingleton;
+
+  beforeEach(async () => {
+    h.adds = [];
+    h.telemetryUp = true;
+    // Fresh module (and fresh singleton) per test so the once-per-process
+    // boot guard does not leak across cases.
+    vi.resetModules();
+    ({ devServerMetrics } = await import("./dev-server-metrics.mjs"));
+  });
+
+  it("emits dev_server_boot_total once with the flip_restart boot kind", () => {
+    devServerMetrics.recordBoot("flip_restart");
+
+    const boots = bootAdds();
+    expect(boots).toHaveLength(1);
+    expect(boots[0].value).toBe(1);
+    expect(boots[0].attrs).toEqual({ boot_kind: "flip_restart" });
+  });
+
+  it("emits at most one boot per process even when called from multiple sites", () => {
+    // initializeTelemetry runs on cold boot, token hot-reload, and warm
+    // activation, and createDevServer may also call it — the boot signal must
+    // still increment exactly once for the process.
+    devServerMetrics.recordBoot("flip_restart");
+    devServerMetrics.recordBoot("flip_restart");
+    devServerMetrics.recordBoot(undefined);
+
+    expect(bootAdds()).toHaveLength(1);
+  });
+
+  it("buffers the boot when telemetry is down and replays it once on flush", () => {
+    h.telemetryUp = false;
+    devServerMetrics.recordBoot("flip_restart");
+    expect(bootAdds()).toHaveLength(0);
+
+    h.telemetryUp = true;
+    devServerMetrics.flush();
+
+    const boots = bootAdds();
+    expect(boots).toHaveLength(1);
+    expect(boots[0].attrs).toEqual({ boot_kind: "flip_restart" });
+  });
+});

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

@@ -12,6 +12,7 @@
  * warm-standby observations are not silently dropped into the no-op meter.
  */
 
+import { RESTART_REASON_FLIP_RESTART } from "@superblocksteam/library-shared/restart-contract";
 import { isTelemetryInitialized } from "@superblocksteam/telemetry";
 
 import { getMeter } from "../telemetry/index.js";
@@ -72,6 +73,29 @@ export function normalizeNpmErrorCodeTag(code: string | undefined): string {
   return KNOWN_NPM_ERROR_CODES.has(collapsed) ? collapsed : "other";
 }
 
+/**
+ * Normalize the CLI parent's `SUPERBLOCKS_RESTART_REASON` env into a bounded
+ * `boot_kind` metric label for `dev_server_boot_total`:
+ *   - absent/empty/whitespace -> `"cold_start"` (first boot or a non-restart
+ *     respawn; the parent only stamps the reason on a post-flip respawn)
+ *   - `RESTART_REASON_FLIP_RESTART` -> passes through (the post-flip in-place
+ *     restart we want to prove actually booted)
+ *   - anything else -> `"other"`
+ *
+ * The reason comes from process env, which an operator or a stale value could
+ * set to anything, so the unknown branch collapses to `"other"` to keep the
+ * `boot_kind` series count bounded (cardinality guard).
+ */
+export function normalizeBootKindTag(
+  restartReason: string | undefined,
+): string {
+  const trimmed = restartReason?.trim();
+  if (!trimmed) return "cold_start";
+  return trimmed === RESTART_REASON_FLIP_RESTART
+    ? RESTART_REASON_FLIP_RESTART
+    : "other";
+}
+
 /** Dev-server endpoints that produce per-request metrics. */
 export type DevServerEndpoint =
   | "_sb_health"
@@ -150,6 +174,10 @@ class DevServerMetrics {
    */
   private bufferedRecorders: Array<() => void> = [];
 
+  /** Set once `recordBoot` has been called, so the boot metric is emitted at
+   * most once per process regardless of how many init paths invoke it. */
+  private booted = false;
+
   /**
    * Routes a recorder to the live OTel meter when telemetry is up, or buffers
    * it for replay when telemetry has not yet initialized.
@@ -193,6 +221,43 @@ class DevServerMetrics {
     }
   }
 
+  /**
+   * Records a dev-server process boot, tagged by `boot_kind`.
+   *
+   * Emitted once per process at startup. Pass the raw
+   * `SUPERBLOCKS_RESTART_REASON` env value (the CLI parent stamps
+   * `RESTART_REASON_FLIP_RESTART` on a post-flip in-place respawn and leaves it
+   * unset otherwise); it is normalized to a bounded `boot_kind` label
+   * (`cold_start` | `flip_restart` | `other`).
+   *
+   * This is the completion half of the in-place-restart telemetry: the
+   * server-side decision metric proves we *chose* to self-restart, and a
+   * `dev_server_boot_total{boot_kind="flip_restart"}` increment proves the
+   * child actually booted afterward, so the two can be compared in Datadog.
+   */
+  recordBoot(restartReason: string | undefined): void {
+    // Once per process. `recordBoot` is driven from every telemetry-init path
+    // (cold boot, post-flip respawn, warm activation, and auth hot-reload all
+    // call `initializeTelemetry`, which can run more than once per process), so
+    // the guard keeps `dev_server_boot_total` at exactly one increment per boot
+    // no matter how many call sites or re-inits fire. The first call wins and
+    // captures the boot kind; whether it emits immediately or buffers for
+    // `flush()`, later calls are no-ops.
+    if (this.booted) {
+      return;
+    }
+    this.booted = true;
+    const bootKind = normalizeBootKindTag(restartReason);
+    this.record(() => {
+      getMeter()
+        .createCounter("dev_server_boot_total", {
+          description:
+            "Count of dev-server process boots by boot kind (cold_start | flip_restart | other).",
+        })
+        .add(1, { boot_kind: bootKind });
+    });
+  }
+
   /**
    * Records the outcome of a dev-server HTTP endpoint request.
    */

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

@@ -1,6 +1,29 @@
 import { describe, it, expect } from "vitest";
 
-import { normalizeNpmErrorCodeTag } from "./dev-server-metrics.mjs";
+import {
+  normalizeBootKindTag,
+  normalizeNpmErrorCodeTag,
+} from "./dev-server-metrics.mjs";
+
+describe("normalizeBootKindTag (metric cardinality bound)", () => {
+  it("passes through the known flip-restart reason", () => {
+    expect(normalizeBootKindTag("flip_restart")).toBe("flip_restart");
+  });
+
+  it("maps an absent reason to 'cold_start' (no parent restart marker)", () => {
+    expect(normalizeBootKindTag(undefined)).toBe("cold_start");
+    expect(normalizeBootKindTag("")).toBe("cold_start");
+    expect(normalizeBootKindTag("   ")).toBe("cold_start");
+  });
+
+  it("maps unknown / arbitrary / injected tokens to 'other' (cardinality guard)", () => {
+    // SUPERBLOCKS_RESTART_REASON is process env, so an operator or a stale
+    // value could set anything; it must never mint a new time series.
+    expect(normalizeBootKindTag("auto_upgrade")).toBe("other");
+    expect(normalizeBootKindTag("some-random-token")).toBe("other");
+    expect(normalizeBootKindTag("`;rm -rf /#")).toBe("other");
+  });
+});
 
 describe("normalizeNpmErrorCodeTag (metric cardinality bound)", () => {
   it("passes through known npm codes", () => {

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

@@ -1,4 +1,5 @@
 import * as child_process from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { existsSync, readdirSync } from "node:fs";
 import type http from "node:http";
 import net from "node:net";
@@ -14,6 +15,10 @@ import type { HmrOptions, Plugin, UserConfig } from "vite";
 import type { ViteDevServer } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 
+import {
+  RESTART_EXIT_CODE,
+  RESTART_REASON_ENV,
+} from "@superblocksteam/library-shared/restart-contract";
 import type { ServerError } from "@superblocksteam/library-shared/types";
 import {
   JwtVerifier,
@@ -35,6 +40,7 @@ import type { OperationQueue } from "@superblocksteam/vite-plugin-file-sync/oper
 import type { SyncService } from "@superblocksteam/vite-plugin-file-sync/sync-service";
 
 import pkg from "../../package.json" with { type: "json" };
+import { flagOrEnv } from "../flag.js";
 import type { SuperblocksSdk } from "../sdk.js";
 import { getTracer } from "../telemetry/index.js";
 import { getErrorMeta, getLogger } from "../telemetry/logging.js";
@@ -353,7 +359,10 @@ export function isWorkspacePersistUploadHeaders(
   return true;
 }
 
-export const RESTART_EXIT_CODE = 98;
+// Re-exported so existing consumers (sdk index, dev.mts) keep importing
+// RESTART_EXIT_CODE from the SDK; the canonical definition lives in
+// `@superblocksteam/library-shared/restart-contract`.
+export { RESTART_EXIT_CODE };
 
 function getJwksUriWithBaseUrl(superblocksBaseUrl?: string): string {
   if (process.env.SUPERBLOCKS_JWKS_URI) {
@@ -494,6 +503,43 @@ export function buildStatusPayload<T extends object>(
   return { ...base, serverErrors: devServerStatus?.serverErrors ?? [] };
 }
 
+/**
+ * Stable per-process identity for the dev-server runtime. `bootId` is generated
+ * once at module load, so it changes on every process start (including an
+ * in-place restart). Together with an unchanged sandbox/port, these let an e2e
+ * spec prove "same sandbox, new process" after a post-flip restart without log
+ * scraping (testability hook for the post-flip restart e2e spec).
+ */
+export const DEV_SERVER_BOOT_ID = randomUUID();
+export const DEV_SERVER_STARTED_AT = new Date().toISOString();
+
+/**
+ * Builds the `/_sb_health` payload, including the per-process boot identity.
+ * Extracted as a pure function so the boot-identity contract can be unit
+ * tested without booting the full dev server.
+ */
+export function buildHealthResponse(args: {
+  applicationId: string;
+  branch: string | null | undefined;
+  cliVersion: string;
+}): {
+  status: "healthy";
+  applicationId: string;
+  branch: string | null | undefined;
+  cliVersion: string;
+  bootId: string;
+  startedAt: string;
+} {
+  return {
+    status: "healthy",
+    applicationId: args.applicationId,
+    branch: args.branch,
+    cliVersion: args.cliVersion,
+    bootId: DEV_SERVER_BOOT_ID,
+    startedAt: DEV_SERVER_STARTED_AT,
+  };
+}
+
 // The "Dev Server" is a long-running HTTP server that manages the Vite server
 export async function createDevServer({
   root,
@@ -527,13 +573,47 @@ export async function createDevServer({
   }
   const currentBranch = await getCurrentGitBranchIfGit();
 
-  const healthResponse = {
-    status: "healthy",
+  const healthResponse = buildHealthResponse({
     applicationId: resourceConfig.id,
     branch: currentBranch,
-    // TODO(code-mode): add branch name
     cliVersion: pkg.version,
-  };
+  });
+
+  // Anchor the per-process boot identity in stdout so operators can correlate
+  // log lines from before and after an in-place restart (same sandbox, new
+  // process) without polling the /_sb_health endpoint.
+  logger.info(
+    `Dev server process started (bootId=${healthResponse.bootId}, startedAt=${healthResponse.startedAt})`,
+  );
+
+  // Emit a boot metric tagged with how this process started. The CLI parent
+  // stamps SUPERBLOCKS_RESTART_REASON=flip_restart when it respawns the child
+  // after an in-place v2->v3 template flip, so a
+  // `dev_server_boot_total{boot_kind="flip_restart"}` increment proves the child
+  // actually booted back up after the flip — the completion signal that pairs
+  // with the server-side "decided to self-restart" metric.
+  //
+  // NOTE: this child-side metric is BEST-EFFORT, not durable. recordBoot buffers
+  // when telemetry isn't up yet, but the buffer only flushes if a later
+  // initializeTelemetry() call succeeds; if the child stalls or exits before
+  // telemetry initializes, the buffered increment is lost (the exact gap we saw
+  // in Datadog). The reliable completion signal is the parent-emitted
+  // `dev_server_child_respawn_completed_total`, driven by the devServerStarted
+  // IPC sent just below — keep both so server/parent/child can be cross-checked.
+  devServerMetrics.recordBoot(process.env[RESTART_REASON_ENV]);
+
+  // Tell the supervising CLI parent (dev-parent.mts) we reached dev-server boot.
+  // The parent emits the RELIABLE in-place-restart-completed metric from this
+  // signal, because the child's own `dev_server_boot_total` is buffered through
+  // the telemetry pipeline and is lost if telemetry never initializes (the gap
+  // we saw in Datadog: a respawned child went dark before its boot metric ever
+  // flushed). `process.send` is only defined when spawned with an IPC channel —
+  // i.e. under the lightweight parent supervisor; warm single-process and
+  // shell-supervised pods have no IPC parent and simply skip this. Sent as a
+  // plain object; the parent owns the typed `ChildToParentMessage` contract.
+  if (process.send) {
+    process.send({ type: "devServerStarted" });
+  }
 
   let viteCreationResults: {
     viteServer: ViteDevServer;
@@ -1136,6 +1216,12 @@ export async function createDevServer({
       superblocksBaseUrl: explicitBaseUrl || localToken?.superblocksBaseUrl,
       features: {
         enableSessionRecording: featureFlags?.enableSessionRecording() ?? false,
+        // Gate the in-place restart on the LD flag OR the env escape hatch
+        // (cloud-prem/local), mirroring the memory-metrics pattern below.
+        inPlaceTemplateRestartEnabled: flagOrEnv(
+          featureFlags?.inPlaceTemplateRestartEnabled(),
+          "SUPERBLOCKS_DEV_SERVER_IN_PLACE_TEMPLATE_RESTART_ENABLED",
+        ),
       },
     });
     // Note: vitePromise itself gets a no-op .catch() at its construction site
@@ -1154,8 +1240,10 @@ export async function createDevServer({
         // Start memory metrics only for claimed pods (after Vite init, not warm standby).
         // Gated by either the LD flag (cloud) or the SABS-injected env var (cloud-prem/local).
         if (
-          featureFlags?.devServerMemoryMetricsEnabled() ||
-          process.env.SUPERBLOCKS_DEV_SERVER_MEMORY_METRICS_ENABLED === "true"
+          flagOrEnv(
+            featureFlags?.devServerMemoryMetricsEnabled(),
+            "SUPERBLOCKS_DEV_SERVER_MEMORY_METRICS_ENABLED",
+          )
         ) {
           startMemoryMetrics();
         }
@@ -1205,6 +1293,7 @@ async function startVite({
   checkAuthorization: FileSyncPluginParams["checkAuthorization"];
   features: {
     enableSessionRecording: boolean;
+    inPlaceTemplateRestartEnabled: boolean;
   };
 }): Promise<{
   viteServer: ViteDevServer;

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

@@ -5,7 +5,12 @@ import type { ServerError } from "@superblocksteam/library-shared/types";
 // Static import so the slow `dev-server.mjs` module graph (vite, react plugin,
 // workspace deps) loads during file evaluation rather than inside each test,
 // where the cold-import cost easily exceeds the default 5s test timeout.
-import { buildStatusPayload } from "./dev-server.mjs";
+import {
+  buildHealthResponse,
+  buildStatusPayload,
+  DEV_SERVER_BOOT_ID,
+  DEV_SERVER_STARTED_AT,
+} from "./dev-server.mjs";
 
 describe("buildStatusPayload", () => {
   it("merges serverErrors from devServerStatus onto the base payload", () => {
@@ -56,3 +61,32 @@ describe("buildStatusPayload", () => {
     });
   });
 });
+
+describe("buildHealthResponse", () => {
+  it("includes the per-process boot identity so an e2e can prove 'same sandbox, new process'", () => {
+    const health = buildHealthResponse({
+      applicationId: "app-1",
+      branch: "main",
+      cliVersion: "1.2.3",
+    });
+    expect(health).toEqual({
+      status: "healthy",
+      applicationId: "app-1",
+      branch: "main",
+      cliVersion: "1.2.3",
+      bootId: DEV_SERVER_BOOT_ID,
+      startedAt: DEV_SERVER_STARTED_AT,
+    });
+  });
+
+  it("passes through an undefined branch (non-git checkout)", () => {
+    const health = buildHealthResponse({
+      applicationId: "app-2",
+      branch: undefined,
+      cliVersion: "9.9.9",
+    });
+    expect(health.branch).toBeUndefined();
+    expect(health.bootId).toBe(DEV_SERVER_BOOT_ID);
+    expect(health.startedAt).toBe(DEV_SERVER_STARTED_AT);
+  });
+});

package/src/flag.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { FeatureFlags, flagOrEnv } from "./flag.js";
+
+describe("flagOrEnv", () => {
+  const ENV = "SUPERBLOCKS_TEST_FLAG_OR_ENV";
+  let original: string | undefined;
+
+  beforeEach(() => {
+    original = process.env[ENV];
+    delete process.env[ENV];
+  });
+
+  afterEach(() => {
+    if (original === undefined) {
+      delete process.env[ENV];
+    } else {
+      process.env[ENV] = original;
+    }
+  });
+
+  it("returns false when the flag is undefined and the env is unset", () => {
+    expect(flagOrEnv(undefined, ENV)).toBe(false);
+  });
+
+  it("returns true when the flag value is true", () => {
+    expect(flagOrEnv(true, ENV)).toBe(true);
+  });
+
+  it("returns true when the flag is falsy but the env is exactly 'true'", () => {
+    process.env[ENV] = "true";
+    expect(flagOrEnv(false, ENV)).toBe(true);
+    expect(flagOrEnv(undefined, ENV)).toBe(true);
+  });
+
+  it("returns false when the env is set to anything other than 'true'", () => {
+    process.env[ENV] = "1";
+    expect(flagOrEnv(false, ENV)).toBe(false);
+    process.env[ENV] = "TRUE";
+    expect(flagOrEnv(undefined, ENV)).toBe(false);
+  });
+});
+
+describe("FeatureFlags.inPlaceTemplateRestartEnabled", () => {
+  it("defaults to false when the flag is absent", () => {
+    const flags = new FeatureFlags({});
+    expect(flags.inPlaceTemplateRestartEnabled()).toBe(false);
+  });
+
+  it("returns true when the flag is enabled", () => {
+    const flags = new FeatureFlags({
+      "superblocks.dev-server.in-place-template-restart.enabled": true,
+    });
+    expect(flags.inPlaceTemplateRestartEnabled()).toBe(true);
+  });
+
+  it("returns false when the flag is explicitly disabled", () => {
+    const flags = new FeatureFlags({
+      "superblocks.dev-server.in-place-template-restart.enabled": false,
+    });
+    expect(flags.inPlaceTemplateRestartEnabled()).toBe(false);
+  });
+});

package/src/flag.ts

@@ -2,6 +2,17 @@ import { DEFAULT_LINES_FOR_LARGE_STEPS } from "@superblocksteam/util";
 
 import type { FlagBootstrap } from "./types/index.js";
 
+/**
+ * Resolves a feature gate from its LaunchDarkly flag value OR a process-env
+ * escape hatch (used by cloud-prem/local, where LD is unavailable). Centralizes
+ * the `flag ?? false || env === "true"` shape so each gate names its
+ * flag-getter/env-name pairing in exactly one place at the call site.
+ */
+export const flagOrEnv = (
+  flagValue: boolean | undefined,
+  envName: string,
+): boolean => (flagValue ?? false) || process.env[envName] === "true";
+
 export const signingEnabled = (flags: FlagBootstrap): boolean => {
   return flags["ui.enable-resource-signing"] ?? false;
 };
@@ -47,4 +58,17 @@ export class FeatureFlags {
   devServerMemoryMetricsEnabled(): boolean {
     return this.flags["superblocks.dev-server.memory-metrics.enabled"] ?? false;
   }
+
+  /**
+   * Gates the in-place dev-server process restart after a v2->v3 template
+   * flip. When enabled (and a restart supervisor is present), the
+   * dev server self-restarts its own process so the pod stays alive instead of
+   * being terminated and replaced. Flag off restores today's pod-swap behavior.
+   */
+  inPlaceTemplateRestartEnabled(): boolean {
+    return (
+      this.flags["superblocks.dev-server.in-place-template-restart.enabled"] ??
+      false
+    );
+  }
 }

package/src/index.ts

@@ -8,7 +8,9 @@ export {
   type CreateApplicationResult,
   type CurrentBranch,
   type BillingUsageLimitsResponse,
+  type BillingUsageRecordsResponse,
   type DailyUsageRow,
+  type DollarLedgerRow,
   type GetCommitsResponseBody,
   type IntegrationFilters,
   type IntegrationSummary,
@@ -68,6 +70,13 @@ export {
 
 export { AUTO_UPGRADE_EXIT_CODE } from "./cli-replacement/automatic-upgrades.js";
 export { RESTART_EXIT_CODE } from "./dev-utils/dev-server.mjs";
+// Surfaces the canonical restart-contract markers alongside RESTART_EXIT_CODE so
+// the builtins-only CLI parent copies can be drift-checked against it in tests.
+export {
+  RESTART_REASON_ENV,
+  RESTART_REASON_FLIP_RESTART,
+  RESTART_SUPERVISED_ENV,
+} from "@superblocksteam/library-shared/restart-contract";
 
 export { createDevServer, preWarmViteCache } from "./dev-utils/dev-server.mjs";
 export {

package/src/sdk.ts

@@ -41,6 +41,7 @@ import {
   fetchBillingUsageDaily,
   fetchBillingUsageLimits,
   fetchBillingUsageRecords,
+  fetchBillingUsageRecordsResponse,
   fetchCurrentUser,
   fetchFact,
   fetchFacts,
@@ -76,6 +77,7 @@ import type {
   CreateApplicationResult,
   CreateRbacAssignmentsRequest,
   BillingUsageLimitsResponse,
+  BillingUsageRecordsResponse,
   DailyUsageRow,
   FolderMutationPayload,
   FolderSummary,
@@ -108,6 +110,11 @@ import type { DeploymentHistoryEntryDto, UserMeDto } from "./types/index.js";
 
 // Exporting here instead of index.ts because only sdk.ts is exposed outside in package.json
 export * from "./errors.js";
+export {
+  RESTART_REASON_ENV,
+  RESTART_REASON_FLIP_RESTART,
+  RESTART_SUPERVISED_ENV,
+} from "@superblocksteam/library-shared/restart-contract";
 
 export class SuperblocksSdk {
   token = "";
@@ -891,6 +898,19 @@ export class SuperblocksSdk {
     });
   }
 
+  async fetchBillingUsageRecordsResponse(
+    startDate: string,
+    endDate: string,
+  ): Promise<BillingUsageRecordsResponse> {
+    return fetchBillingUsageRecordsResponse({
+      cliVersion: this.cliVersion,
+      token: this.token,
+      superblocksBaseUrl: this.superblocksBaseUrl,
+      startDate,
+      endDate,
+    });
+  }
+
   async fetchBillingPlanSummary(): Promise<PlanSummary> {
     return fetchBillingPlanSummary({
       cliVersion: this.cliVersion,

package/src/types/common.ts

@@ -18,6 +18,7 @@ export interface FlagBootstrap {
   "superblocks.dev-server.inactivity-timeout.local"?: number;
   "superblocks.dev-server.llmobs.enabled"?: boolean;
   "superblocks.dev-server.memory-metrics.enabled"?: boolean;
+  "superblocks.dev-server.in-place-template-restart.enabled"?: boolean;
   "superblocks.deploy.include-dot-superblocks"?: boolean;
 }