@hraness/slopcamera 3.2.7 → 3.2.8

package/apps/desktop/html-overlay/audio-reactivity.ts

@@ -0,0 +1,127 @@
+import { z } from "zod";
+
+import type { AudioReactivityBands } from "../core/music-analysis";
+
+export const HTML_AUDIO_REACTIVITY_RESOURCE_NAME = "audio-reactivity";
+export const HTML_AUDIO_REACTIVITY_RESOURCE_URL_PATH = "slopcamera/audio-reactivity.json";
+export const HTML_AUDIO_REACTIVITY_MAX_BYTES = 4 * 1024 * 1024;
+
+export type HtmlOverlayAudioReactivity = Readonly<{
+  kind: "slopcamera.audio-reactivity";
+  schemaVersion: 1;
+  profile: "bands-v1";
+  source: Readonly<{ bytes: number; sha256: string }>;
+  pcm: Readonly<{ sampleCount: number; sha256: string }>;
+  durationUs: number;
+  rateHz: 60;
+  bands: AudioReactivityBands;
+}>;
+
+export type HtmlOverlayAudioSample = Readonly<{
+  bass: number; mid: number; treble: number; energy: number;
+}>;
+export type PreparedHtmlOverlayAudioReactivity = Readonly<{
+  durationUs: number;
+  sample: (timeUs: number) => HtmlOverlayAudioSample;
+}>;
+
+const LIMITS = Object.freeze({ maxSamples: 14_400_000, maxSourceBytes: 512 * 1024 * 1024,
+  sampleRateHz: 24_000, hopSize: 400, rateHz: 60, maxTimeUs: 3_600_000_000 });
+
+/** One implementation validates the SDK and browser resource, before frame sampling. */
+function createAudioReactivityRuntime(limits: typeof LIMITS) {
+  const object = (value: unknown, keys: readonly string[]): Record<string, unknown> => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      throw new TypeError("Audio reactivity requires a strict JSON object.");
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(value).length !== keys.length
+      || keys.some(key => descriptors[key] === undefined || !("value" in descriptors[key]!))) {
+      throw new TypeError("Audio reactivity contains missing, unknown, or accessor fields.");
+    }
+    return value as Record<string, unknown>;
+  };
+  const integer = (value: unknown, minimum: number, maximum: number): number => {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) {
+      throw new RangeError("Audio reactivity integer is outside its bound.");
+    }
+    return value;
+  };
+  const digest = (value: unknown): string => {
+    if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)) {
+      throw new TypeError("Audio reactivity requires a SHA-256 digest.");
+    }
+    return value;
+  };
+  const parse = (value: unknown): HtmlOverlayAudioReactivity => {
+    const input = object(value, ["kind", "schemaVersion", "profile", "source", "pcm", "durationUs", "rateHz", "bands"]);
+    if (input.kind !== "slopcamera.audio-reactivity" || input.schemaVersion !== 1
+      || input.profile !== "bands-v1" || input.rateHz !== limits.rateHz) {
+      throw new TypeError("Unsupported audio reactivity profile or version.");
+    }
+    const source = object(input.source, ["bytes", "sha256"]);
+    const pcm = object(input.pcm, ["sampleCount", "sha256"]);
+    const sampleCount = integer(pcm.sampleCount, 1, limits.maxSamples);
+    const durationUs = Math.round(sampleCount * 1_000_000 / limits.sampleRateHz);
+    if (input.durationUs !== durationUs) throw new RangeError("Audio reactivity duration differs from its PCM sample count.");
+    const length = Math.ceil(sampleCount / limits.hopSize) + 1;
+    const bands = object(input.bands, ["bass", "mid", "treble", "energy"]);
+    const channel = (value: unknown): readonly number[] => {
+      const keys = value !== null && typeof value === "object" ? Reflect.ownKeys(value) : [];
+      if (!Array.isArray(value) || value.length !== length || keys.length !== length + 1
+        || keys.some(key => key !== "length" && (typeof key !== "string" || !/^(?:0|[1-9][0-9]*)$/u.test(key)))) {
+        throw new RangeError("Audio reactivity bands must be dense arrays covering the declared duration.");
+      }
+      const copy: number[] = [];
+      for (let index = 0; index < length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        const sample: unknown = descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+        if (typeof sample !== "number" || !Number.isFinite(sample) || sample < 0 || sample > 1) {
+          throw new RangeError("Audio reactivity band values must be finite numbers in [0, 1].");
+        }
+        copy.push(sample === 0 ? 0 : sample);
+      }
+      if (copy.at(-1) !== 0) throw new RangeError("Audio reactivity requires a zero endpoint at the exact duration.");
+      return Object.freeze(copy);
+    };
+    return Object.freeze({
+      kind: "slopcamera.audio-reactivity", schemaVersion: 1, profile: "bands-v1", rateHz: 60, durationUs,
+      source: Object.freeze({ bytes: integer(source.bytes, 1, limits.maxSourceBytes), sha256: digest(source.sha256) }),
+      pcm: Object.freeze({ sampleCount, sha256: digest(pcm.sha256) }),
+      bands: Object.freeze({ bass: channel(bands.bass), mid: channel(bands.mid), treble: channel(bands.treble), energy: channel(bands.energy) }),
+    });
+  };
+  const prepareAudioReactivity = (input: unknown): PreparedHtmlOverlayAudioReactivity => {
+    const data = parse(input);
+    const zero = Object.freeze({ bass: 0, mid: 0, treble: 0, energy: 0 });
+    return Object.freeze({ durationUs: data.durationUs, sample(timeUs: number): HtmlOverlayAudioSample {
+      integer(timeUs, -limits.maxTimeUs, limits.maxTimeUs);
+      if (timeUs < 0 || timeUs >= data.durationUs) return zero;
+      const index = Math.min(data.bands.bass.length - 2, Math.floor(timeUs * limits.rateHz / 1_000_000));
+      const startUs = index * 1_000_000 / limits.rateHz;
+      const endUs = Math.min(data.durationUs, (index + 1) * 1_000_000 / limits.rateHz);
+      const mix = Math.max(0, Math.min(1, (timeUs - startUs) / (endUs - startUs)));
+      const interpolate = (band: readonly number[]) => band[index]! * (1 - mix) + band[index + 1]! * mix;
+      return Object.freeze({ bass: interpolate(data.bands.bass), mid: interpolate(data.bands.mid),
+        treble: interpolate(data.bands.treble), energy: interpolate(data.bands.energy) });
+    } });
+  };
+  return { parse, prepareAudioReactivity };
+}
+
+const runtime = createAudioReactivityRuntime(LIMITS);
+export const HtmlOverlayAudioReactivitySchema = z.unknown().transform((input, context): HtmlOverlayAudioReactivity => {
+  try { return runtime.parse(input); } catch (error) {
+    context.addIssue({ code: "custom", message: error instanceof Error ? error.message : "Invalid audio reactivity." });
+    return z.NEVER;
+  }
+});
+
+/** Validate and copy once. Samples depend only on absolute source time, in integer microseconds. */
+export function prepareHtmlOverlayAudioReactivity(input: unknown): PreparedHtmlOverlayAudioReactivity {
+  return runtime.prepareAudioReactivity(input);
+}
+
+export function createHtmlOverlayAudioReactivityRuntimeSource(): string {
+  return `(() => { const runtime = (${createAudioReactivityRuntime.toString()})(${JSON.stringify(LIMITS)}); return { prepareAudioReactivity: runtime.prepareAudioReactivity }; })()`;
+}

package/apps/desktop/html-overlay/index.ts

@@ -33,6 +33,15 @@ export {
   type HtmlOverlayTiming,
 } from "./contracts";
 export { HtmlSceneInputSchema, type HtmlSceneInput } from "./scene";
+export {
+  HTML_AUDIO_REACTIVITY_RESOURCE_NAME,
+  HTML_AUDIO_REACTIVITY_RESOURCE_URL_PATH,
+  HtmlOverlayAudioReactivitySchema,
+  prepareHtmlOverlayAudioReactivity,
+  type HtmlOverlayAudioReactivity,
+  type HtmlOverlayAudioSample,
+  type PreparedHtmlOverlayAudioReactivity,
+} from "./audio-reactivity";
 export {
   HTML_OVERLAY_SCAFFOLD_CLOCK_INTEGRATIONS,
   HTML_OVERLAY_SCAFFOLD_KINDS,

package/apps/desktop/html-overlay/runtime.ts

@@ -11,6 +11,7 @@ import {
 import { htmlOverlayAssetLocalUrl } from "./libraries";
 import { HTML_OVERLAY_RANDOM_ALGORITHM } from "./random";
 import { createHtmlOverlayMusicClockRuntimeSource } from "./music-clock";
+import { createHtmlOverlayAudioReactivityRuntimeSource } from "./audio-reactivity";
 
 const Uint32Schema = z.number().int().safe().min(0).max(0xffff_ffff);
 
@@ -713,6 +714,7 @@ export function createHtmlOverlayBrowserRuntimeSource(
       };
     },
     ...${createHtmlOverlayMusicClockRuntimeSource()},
+    ...${createHtmlOverlayAudioReactivityRuntimeSource()},
     parameters: deepFreeze(config.parameters),
     random,
     randomFor,

package/apps/desktop/html-overlay/scene.ts

@@ -6,6 +6,8 @@ import {
 } from "./contracts";
 import { HtmlOverlayExecutionProfileSchema } from "./execution-profile";
 import { HtmlOverlayLibrarySelectionSchema } from "./libraries";
+import { AUDIO_REACTIVITY_MAX_DURATION_US } from "../core/music-analysis";
+import { HTML_AUDIO_REACTIVITY_RESOURCE_NAME, HTML_AUDIO_REACTIVITY_RESOURCE_URL_PATH } from "./audio-reactivity";
 
 const ResourceSchema = HtmlOverlayDeclaredResourceSchema.omit({ bytes: true, sha256: true }).extend({
   path: RepositoryRelativePathSchema,
@@ -27,8 +29,35 @@ export const HtmlSceneInputSchema = z.strictObject({
   executionProfile: HtmlOverlayExecutionProfileSchema.optional(),
   audio: z.strictObject({
     path: z.string().min(1).max(4096).refine(path => !/[\0\r\n]/u.test(path), "Audio path contains a control character."),
+    reactivity: z.strictObject({
+      profile: z.literal("bands-v1"),
+      resource: z.literal(HTML_AUDIO_REACTIVITY_RESOURCE_NAME).optional(),
+      sha256: z.string().regex(/^[a-f0-9]{64}$/u).optional(),
+    }).optional(),
   }).optional(),
 }).superRefine((input, context) => {
+  if (input.audio?.reactivity !== undefined && input.timing.durationUs > AUDIO_REACTIVITY_MAX_DURATION_US) {
+    context.addIssue({ code: "custom", message: "Audio reactivity is limited to ten minutes per scene." });
+  }
+  if (input.audio?.reactivity?.resource === undefined && input.audio?.reactivity !== undefined && (
+    input.resources.length >= 64
+    || input.resources.some(resource => resource.name === HTML_AUDIO_REACTIVITY_RESOURCE_NAME
+      || resource.urlPath === HTML_AUDIO_REACTIVITY_RESOURCE_URL_PATH)
+  )) {
+    context.addIssue({ code: "custom", message: "Audio reactivity requires one free resource slot and an unused audio-reactivity name and slopcamera/audio-reactivity.json URL path." });
+  }
+  if (input.audio?.reactivity?.resource === undefined && input.audio?.reactivity?.sha256 !== undefined) {
+    context.addIssue({ code: "custom", message: "An audio-reactivity sidecar digest requires its retained resource name." });
+  }
+  if (input.audio?.reactivity?.resource !== undefined && !input.resources.some(resource => (
+    resource.name === HTML_AUDIO_REACTIVITY_RESOURCE_NAME && resource.urlPath === HTML_AUDIO_REACTIVITY_RESOURCE_URL_PATH
+      && resource.mediaType === "application/json" && resource.transport === "fetch"
+  ))) {
+    context.addIssue({ code: "custom", message: "A retained audio-reactivity source must declare its fixed fetched JSON resource." });
+  }
+  if (input.audio?.reactivity?.resource !== undefined && input.audio.reactivity.sha256 === undefined) {
+    context.addIssue({ code: "custom", message: "A retained audio-reactivity source must record its sidecar SHA-256 digest." });
+  }
   const authoring = HtmlOverlayAuthoringInputSchema.safeParse({
     kind: "slopcamera.html-overlay", schemaVersion: 1, canvas: input.canvas, timing: input.timing,
     libraries: input.libraries, parameters: input.parameters, seed: input.seed,

package/dist/cli.js

@@ -4,30 +4,25 @@ import {
   SLOPCAMERA_VERSION,
   artifactSummary,
   checkDiagramFile,
-  desktopStatus,
-  getLatestDesktopRelease,
-  installDesktop,
-  openInDesktop,
   renderDiagramFile,
-  runMcpServer,
-  selectDesktopAsset
-} from "./index-rvghzt7b.js";
+  runMcpServer
+} from "./index-7131pg1c.js";
 import {
   installSkill,
   pathExists
 } from "./index-7308egqr.js";
 import"./index-8txs6fkn.js";
-import"./index-mcy8z0br.js";
+import"./index-fava6pge.js";
 import {
   executeSlopcameraOperation,
   isSlopcameraOperationCode,
   searchSlopcameraOperations,
   slopcameraOperationCodes,
   withSlopcameraOperationHostAdmission
-} from "./index-z7239b4h.js";
+} from "./index-h1k0fnjq.js";
 import {
   vectorizeImage
-} from "./index-p63wavx0.js";
+} from "./index-zfnddgay.js";
 import {
   generateSlopcameraImageFile,
   slopcameraGatewayCredentialStatus,
@@ -41,7 +36,58 @@ import {
 // src/cli.ts
 import { writeFile } from "fs/promises";
 import { resolve } from "path";
-import { createInterface } from "readline/promises";
+
+// src/support-completion.ts
+function reportUsefulResult(observer) {
+  try {
+    if (observer !== undefined)
+      Promise.resolve(observer()).catch(() => {
+        return;
+      });
+  } catch {}
+}
+
+// src/support.ts
+import {
+  maybeShowSupportInvitation,
+  runSupportCommand
+} from "@hraness/support-foundation/node";
+var supportProfile = {
+  id: "slopcamera",
+  name: "Slopcamera",
+  valueProposition: "Support ongoing development of local visual tools for agents.",
+  updates: false
+};
+function standaloneSupportEnvironment() {
+  const env = { ...process.env };
+  process.env.HRANESS_SUPPORT_AUDIENCE = "off";
+  process.env.HRANESS_SUPPORT_EMAIL = "off";
+  return env;
+}
+async function runProductSupportCommand(args, options = {}) {
+  const result = await runSupportCommand(supportProfile, args, {
+    command: ["slopcamera"],
+    ...options,
+    gitEmail: false
+  });
+  if (result.stdout !== "")
+    process.stdout.write(result.stdout);
+  if (result.stderr !== "")
+    process.stderr.write(result.stderr);
+  return result.exitCode;
+}
+async function showProductSupportInvitation(options = {}) {
+  try {
+    await maybeShowSupportInvitation(supportProfile, {
+      usefulResult: true,
+      command: ["slopcamera"],
+      ...options,
+      gitEmail: false
+    });
+  } catch {}
+}
+
+// src/cli.ts
 var slopcameraCliVersion = SLOPCAMERA_VERSION;
 var help = `slopcamera ${slopcameraCliVersion}
 
@@ -56,11 +102,8 @@ Usage:
   slopcamera code search [query] [--limit <number>]
   slopcamera code execute <operation> --input <JSON>
   slopcamera mcp --root <workspace>
-  slopcamera canvas open <file.tldr|file.tldraw>
-  slopcamera canvas status
-  slopcamera canvas url
-  slopcamera canvas install [--yes] [--download-only]
   slopcamera doctor
+  slopcamera support [--json|protocol --json|offer --json|shown <id>|release <id>|dismiss|snooze|enable|status --json]
   slopcamera skill path
   slopcamera skill install [--target codex|claude|agents] [--scope user|project] [--force]
 
@@ -71,9 +114,8 @@ Render writes the same five replaceable artifacts on every run:
   <name>.light.png
   <name>.dark.png
 
-The .tldr file is editable tldraw interchange. It imports into tldraw Offline,
-which can save the newer app-owned .tldraw bundle. Rendering does not require
-tldraw Offline or the tldraw SDK.
+  The .tldr file is editable interchange for browser-based canvas tooling.
+  Rendering does not require a desktop application or a bundled UI runtime.
 
 Vectorize adaptively traces a raster with a checksum-pinned VTracer binary.
 It enforces bounded input, decode, time, path, and output budgets and emits a
@@ -85,6 +127,10 @@ Set AI_GATEWAY_API_KEY, or run through \`vercel env run -- \u2026\` so
 VERCEL_OIDC_TOKEN is available. Slopcamera never stores or prints the token.
 PNG, JPEG, and WebP responses are signature-checked and published atomically.
 
+Optional support: after useful work, agents can read slopcamera support protocol --json.
+Discovery uses stderr without claiming an invitation; HRANESS_SUPPORT_AUDIENCE=off disables it.
+No feature requires payment. Imported CLI/SDK calls and probes stay quiet.
+
 Code mode searches and executes a fixed semantic registry. Execute accepts
 typed JSON for one exact owned operation code; it never evaluates source text.
 
@@ -187,18 +233,6 @@ var starter = {
   ],
   edges: [{ id: "source-result", from: "source", to: "result" }]
 };
-async function confirmInstall() {
-  if (!process.stdin.isTTY) {
-    throw new Error("Pass --yes to download the 100\u2013230 MB official tldraw Offline installer");
-  }
-  const prompt = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await prompt.question("Download, verify, and launch the official tldraw Offline installer? [y/N] ");
-    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
-  } finally {
-    prompt.close();
-  }
-}
 function hostAdmissionOptions(dependencies) {
   return dependencies.hostResourceCoordinator === undefined ? {} : { hostResourceCoordinator: dependencies.hostResourceCoordinator };
 }
@@ -216,15 +250,7 @@ function canonicalArguments(args) {
     }
     throw new Error("Use slopcamera image vectorize or generate");
   }
-  if (surface === "canvas") {
-    if (subcommand === "open")
-      return ["open", ...rest];
-    if (subcommand === "status" || subcommand === "url" || subcommand === "install") {
-      return ["desktop", subcommand, ...rest];
-    }
-    throw new Error("Use slopcamera canvas open, status, url, or install");
-  }
-  if (surface === "init" || surface === "check" || surface === "render" || surface === "vectorize" || surface === "generate" || surface === "open" || surface === "desktop") {
+  if (surface === "init" || surface === "check" || surface === "render" || surface === "vectorize" || surface === "generate") {
     throw new Error(`The flat \`${surface}\` command moved to a namespaced Slopcamera surface.
 
 ${help}`);
@@ -232,6 +258,10 @@ ${help}`);
   return args;
 }
 async function main(args, dependencies = {}) {
+  if (args[0] === "support") {
+    process.exitCode = await runProductSupportCommand(args.slice(1), dependencies.supportEnvironment === undefined ? {} : { env: dependencies.supportEnvironment });
+    return;
+  }
   const [command, ...rest] = canonicalArguments(args);
   if (command === undefined || command === "help" || command === "--help" || command === "-h") {
     console.log(help);
@@ -249,6 +279,7 @@ async function main(args, dependencies = {}) {
     await writeFile(filePath, `${JSON.stringify(starter, null, 2)}
 `);
     console.log(`Created ${filePath}`);
+    reportUsefulResult(dependencies.onUsefulResult);
     return;
   }
   if (command === "check") {
@@ -274,6 +305,7 @@ async function main(args, dependencies = {}) {
     }), hostAdmissionOptions(dependencies));
     console.log(artifactSummary(result.artifacts));
     printFindings(result.findings);
+    reportUsefulResult(dependencies.onUsefulResult);
     return;
   }
   if (command === "vectorize") {
@@ -304,6 +336,7 @@ async function main(args, dependencies = {}) {
     } else {
       (dependencies.log ?? console.log)(`Vectorized ${result.receipt.width}\xD7${result.receipt.height} with ` + `${result.receipt.profile}/${result.receipt.representation}: ${result.outputPath}`);
     }
+    reportUsefulResult(dependencies.onUsefulResult);
     return;
   }
   if (command === "generate") {
@@ -329,6 +362,7 @@ async function main(args, dependencies = {}) {
     } else {
       (dependencies.log ?? console.log)(`Generated ${result.mediaType} with ${result.model}: ${result.outputPath} (${result.bytes} bytes, request ${result.requestId})`);
     }
+    reportUsefulResult(dependencies.onUsefulResult);
     return;
   }
   if (command === "code") {
@@ -367,6 +401,9 @@ async function main(args, dependencies = {}) {
         ...hostAdmissionOptions(dependencies)
       });
       (dependencies.log ?? console.log)(JSON.stringify({ operation, result }, null, 2));
+      if (operation === "slopcamera.diagram.render" || operation === "slopcamera.image.vectorize" || operation === "slopcamera.image.generate") {
+        reportUsefulResult(dependencies.onUsefulResult);
+      }
       return;
     }
     throw new Error("Use slopcamera code search [query] or slopcamera code execute <operation> --input <JSON>");
@@ -382,14 +419,7 @@ async function main(args, dependencies = {}) {
     });
     return;
   }
-  if (command === "open") {
-    const parsed = parseArguments(rest, new Set);
-    await openInDesktop(requiredPositional(parsed, 0, "tldraw file"));
-    console.log("Opened in tldraw Offline.");
-    return;
-  }
   if (command === "doctor") {
-    const status = await desktopStatus();
     console.log(`slopcamera ${slopcameraCliVersion}`);
     console.log(`Bun ${process.versions.bun ?? "not detected"}`);
     console.log("Headless diagram SVG/PNG/tldraw renderer ready");
@@ -397,42 +427,8 @@ async function main(args, dependencies = {}) {
     console.log("Root-relative MCP check/render server ready (trusted local workspace)");
     const gateway = slopcameraGatewayCredentialStatus();
     console.log(gateway.available ? `Vercel AI Gateway ready via ${gateway.source}` : "Vercel AI Gateway requires AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN");
-    console.log(status.installedPath === null ? "tldraw Offline not installed (optional)" : `tldraw Offline: ${status.installedPath}`);
-    console.log(status.server === null ? "tldraw Offline agent server not running (optional)" : `tldraw Offline agent server: localhost:${status.server.port}`);
     return;
   }
-  if (command === "desktop") {
-    const [subcommand, ...subcommandArgs] = rest;
-    if (subcommand === "status") {
-      const status = await desktopStatus();
-      console.log(JSON.stringify(status, null, 2));
-      return;
-    }
-    if (subcommand === "url") {
-      const release = await getLatestDesktopRelease();
-      const asset = selectDesktopAsset(release);
-      console.log(JSON.stringify({
-        release: release.tag_name,
-        releaseUrl: release.html_url,
-        asset: asset.name,
-        url: asset.browser_download_url,
-        bytes: asset.size,
-        sha256: asset.digest
-      }, null, 2));
-      return;
-    }
-    if (subcommand === "install") {
-      const parsed = parseArguments(subcommandArgs, new Set);
-      if (!parsed.flags.has("yes") && !await confirmInstall()) {
-        console.log("Cancelled.");
-        return;
-      }
-      const result = await installDesktop({ downloadOnly: parsed.flags.has("download-only") });
-      console.log(`${parsed.flags.has("download-only") ? "Downloaded" : "Prepared"} tldraw Offline ${result.release}: ${result.filePath}`);
-      return;
-    }
-    throw new Error("Use slopcamera canvas status, url, or install");
-  }
   if (command === "skill") {
     const [subcommand, ...subcommandArgs] = rest;
     if (subcommand === "path") {
@@ -467,7 +463,13 @@ ${help}`);
 }
 if (import.meta.main) {
   try {
-    await main(process.argv.slice(2));
+    const env = standaloneSupportEnvironment();
+    let usefulResult = false;
+    await main(process.argv.slice(2), { supportEnvironment: env, onUsefulResult: () => {
+      usefulResult = true;
+    } });
+    if (usefulResult && (process.exitCode ?? 0) === 0)
+      await showProductSupportInvitation({ env });
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;