Merge pull request #69 from aaditagrawal/sync/upstream-2026-04-17

sync: merge 35 upstream commits from pingdotgg/t3code

Author: aaditagrawal

.github/workflows/ci.yml

@@ -92,5 +92,8 @@ jobs:
         with:
           node-version-file: package.json
 
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
       - name: Exercise release-only workflow steps
         run: bun run scripts/release-smoke.ts

.oxfmtrc.json

@@ -10,7 +10,8 @@
     "*.tsbuildinfo",
     "**/routeTree.gen.ts",
     "apps/web/public/mockServiceWorker.js",
-    "apps/web/src/lib/vendor/qrcodegen.ts"
+    "apps/web/src/lib/vendor/qrcodegen.ts",
+    "*.icon/**"
   ],
   "sortPackageJson": {}
 }

CLAUDE.md

@@ -1 +1 @@
-AGENTS.md
+AGENTS.md

apps/desktop/scripts/electron-launcher.mjs

@@ -6,6 +6,7 @@ import {
   cpSync,
   existsSync,
   mkdirSync,
+  mkdtempSync,
   readFileSync,
   readdirSync,
   rmSync,
@@ -25,6 +26,8 @@ const LAUNCHER_VERSION = 2;
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export const desktopDir = resolve(__dirname, "..");
+const repoRoot = resolve(desktopDir, "..", "..");
+const developmentMacIconPngPath = join(repoRoot, "assets", "dev", "blueprint-macos-1024.png");
 
 function setPlistString(plistPath, key, value) {
   const replaceResult = spawnSync("plutil", ["-replace", key, "-string", value, plistPath], {
@@ -45,6 +48,68 @@ function setPlistString(plistPath, key, value) {
   throw new Error(`Failed to update plist key "${key}" at ${plistPath}: ${details}`.trim());
 }
 
+function runChecked(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8" });
+  if (result.status === 0) {
+    return;
+  }
+
+  const details = [result.stdout, result.stderr].filter(Boolean).join("\n");
+  throw new Error(`Failed to run ${command} ${args.join(" ")}: ${details}`.trim());
+}
+
+function ensureDevelopmentIconIcns(runtimeDir, fallbackIconPath) {
+  const generatedIconPath = join(runtimeDir, "icon-dev.icns");
+  mkdirSync(runtimeDir, { recursive: true });
+
+  if (!existsSync(developmentMacIconPngPath)) {
+    return fallbackIconPath;
+  }
+
+  const sourceMtimeMs = statSync(developmentMacIconPngPath).mtimeMs;
+  if (existsSync(generatedIconPath) && statSync(generatedIconPath).mtimeMs >= sourceMtimeMs) {
+    return generatedIconPath;
+  }
+
+  const iconsetRoot = mkdtempSync(join(runtimeDir, "dev-iconset-"));
+  const iconsetDir = join(iconsetRoot, "icon.iconset");
+  mkdirSync(iconsetDir, { recursive: true });
+
+  try {
+    for (const size of [16, 32, 128, 256, 512]) {
+      runChecked("sips", [
+        "-z",
+        String(size),
+        String(size),
+        developmentMacIconPngPath,
+        "--out",
+        join(iconsetDir, `icon_${size}x${size}.png`),
+      ]);
+
+      const retinaSize = size * 2;
+      runChecked("sips", [
+        "-z",
+        String(retinaSize),
+        String(retinaSize),
+        developmentMacIconPngPath,
+        "--out",
+        join(iconsetDir, `icon_${size}x${size}@2x.png`),
+      ]);
+    }
+
+    runChecked("iconutil", ["-c", "icns", iconsetDir, "-o", generatedIconPath]);
+    return generatedIconPath;
+  } catch (error) {
+    console.warn(
+      "[desktop-launcher] Failed to generate dev macOS icon, falling back to default icon.",
+      error,
+    );
+    return fallbackIconPath;
+  } finally {
+    rmSync(iconsetRoot, { recursive: true, force: true });
+  }
+}
+
 function patchMainBundleInfoPlist(appBundlePath) {
   const infoPlistPath = join(appBundlePath, "Contents", "Info.plist");
   setPlistString(infoPlistPath, "CFBundleDisplayName", APP_DISPLAY_NAME);
@@ -111,10 +176,10 @@ function resolveIconSourceMetadata(desktopResourcesDir) {
   };
 }
 
-async function stageMainBundleIcons(appBundlePath, desktopResourcesDir) {
+async function stageMainBundleIcons(appBundlePath, desktopResourcesDir, legacyIconOverride) {
   const resourcesDir = join(appBundlePath, "Contents", "Resources");
   const iconComposerPath = join(desktopResourcesDir, "icon.icon");
-  const legacyIconPath = join(desktopResourcesDir, "icon.icns");
+  const legacyIconPath = legacyIconOverride ?? join(desktopResourcesDir, "icon.icns");
 
   if (existsSync(iconComposerPath)) {
     const compiled = await generateAssetCatalogForIcon(iconComposerPath);
@@ -144,10 +209,18 @@ async function buildMacLauncher(electronBinaryPath) {
   const targetAppBundlePath = join(runtimeDir, `${APP_DISPLAY_NAME}.app`);
   const targetBinaryPath = join(targetAppBundlePath, "Contents", "MacOS", "Electron");
   const desktopResourcesDir = join(desktopDir, "resources");
+  const defaultLegacyIconPath = join(desktopResourcesDir, "icon.icns");
   const metadataPath = join(runtimeDir, "metadata.json");
 
   mkdirSync(runtimeDir, { recursive: true });
 
+  // In dev mode, fall back to a generated icon derived from the dev blueprint PNG so dev
+  // builds are visually distinct. If the modern icon.icon composer source is present, the
+  // staging step below takes precedence and this override is ignored.
+  const legacyIconOverride = isDevelopment
+    ? ensureDevelopmentIconIcns(runtimeDir, defaultLegacyIconPath)
+    : undefined;
+
   const iconMetadata = resolveIconSourceMetadata(desktopResourcesDir);
 
   const expectedMetadata = {
@@ -172,6 +245,7 @@ async function buildMacLauncher(electronBinaryPath) {
   const refreshedIconMetadata = await stageMainBundleIcons(
     targetAppBundlePath,
     desktopResourcesDir,
+    legacyIconOverride,
   );
   patchHelperBundleInfoPlists(targetAppBundlePath);
   writeFileSync(

apps/desktop/src/appBranding.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+
+import { resolveDesktopAppBranding, resolveDesktopAppStageLabel } from "./appBranding";
+
+describe("resolveDesktopAppStageLabel", () => {
+  it("uses Dev in desktop development", () => {
+    expect(
+      resolveDesktopAppStageLabel({
+        isDevelopment: true,
+        appVersion: "0.0.17-nightly.20260414.1",
+      }),
+    ).toBe("Dev");
+  });
+
+  it("uses Nightly for packaged nightly builds", () => {
+    expect(
+      resolveDesktopAppStageLabel({
+        isDevelopment: false,
+        appVersion: "0.0.17-nightly.20260414.1",
+      }),
+    ).toBe("Nightly");
+  });
+
+  it("uses Alpha for packaged stable builds", () => {
+    expect(
+      resolveDesktopAppStageLabel({
+        isDevelopment: false,
+        appVersion: "0.0.17",
+      }),
+    ).toBe("Alpha");
+  });
+});
+
+describe("resolveDesktopAppBranding", () => {
+  it("returns a complete desktop branding payload", () => {
+    expect(
+      resolveDesktopAppBranding({
+        isDevelopment: false,
+        appVersion: "0.0.17-nightly.20260414.1",
+      }),
+    ).toEqual({
+      baseName: "T3 Code",
+      stageLabel: "Nightly",
+      displayName: "T3 Code (Nightly)",
+    });
+  });
+});

apps/desktop/src/appBranding.ts

@@ -0,0 +1,28 @@
+import type { DesktopAppBranding, DesktopAppStageLabel } from "@t3tools/contracts";
+
+import { isNightlyDesktopVersion } from "./updateChannels";
+
+const APP_BASE_NAME = "T3 Code";
+
+export function resolveDesktopAppStageLabel(input: {
+  readonly isDevelopment: boolean;
+  readonly appVersion: string;
+}): DesktopAppStageLabel {
+  if (input.isDevelopment) {
+    return "Dev";
+  }
+
+  return isNightlyDesktopVersion(input.appVersion) ? "Nightly" : "Alpha";
+}
+
+export function resolveDesktopAppBranding(input: {
+  readonly isDevelopment: boolean;
+  readonly appVersion: string;
+}): DesktopAppBranding {
+  const stageLabel = resolveDesktopAppStageLabel(input);
+  return {
+    baseName: APP_BASE_NAME,
+    stageLabel,
+    displayName: `${APP_BASE_NAME} (${stageLabel})`,
+  };
+}

apps/desktop/src/backendReadiness.test.ts

@@ -7,7 +7,7 @@ import {
 } from "./backendReadiness";
 
 describe("waitForHttpReady", () => {
-  it("returns once the backend reports a successful session endpoint", async () => {
+  it("returns once the backend serves the requested readiness path", async () => {
     const fetchImpl = vi
       .fn<typeof fetch>()
       .mockResolvedValueOnce(new Response(null, { status: 503 }))
@@ -20,6 +20,11 @@ describe("waitForHttpReady", () => {
     });
 
     expect(fetchImpl).toHaveBeenCalledTimes(2);
+    expect(fetchImpl).toHaveBeenNthCalledWith(
+      1,
+      "http://127.0.0.1:3773/",
+      expect.objectContaining({ redirect: "manual" }),
+    );
   });
 
   it("retries after a readiness request stalls past the per-request timeout", async () => {
@@ -80,4 +85,30 @@ describe("waitForHttpReady", () => {
     expect(isBackendReadinessAborted(new BackendReadinessAbortedError())).toBe(true);
     expect(isBackendReadinessAborted(new Error("nope"))).toBe(false);
   });
+
+  it("supports custom readiness predicates", async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 200 }))
+      .mockResolvedValueOnce(new Response(null, { status: 204 }));
+
+    await waitForHttpReady("http://127.0.0.1:3773", {
+      fetchImpl,
+      timeoutMs: 1_000,
+      intervalMs: 0,
+      path: "/api/healthz",
+      isReady: (response) => response.status === 204,
+    });
+
+    expect(fetchImpl).toHaveBeenNthCalledWith(
+      1,
+      "http://127.0.0.1:3773/api/healthz",
+      expect.objectContaining({ redirect: "manual" }),
+    );
+    expect(fetchImpl).toHaveBeenNthCalledWith(
+      2,
+      "http://127.0.0.1:3773/api/healthz",
+      expect.objectContaining({ redirect: "manual" }),
+    );
+  });
 });

apps/desktop/src/backendReadiness.ts

@@ -4,9 +4,11 @@ export interface WaitForHttpReadyOptions {
   readonly requestTimeoutMs?: number;
   readonly fetchImpl?: typeof fetch;
   readonly signal?: AbortSignal;
+  readonly path?: string;
+  readonly isReady?: (response: Response) => boolean;
 }
 
-const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_INTERVAL_MS = 100;
 const DEFAULT_REQUEST_TIMEOUT_MS = 1_000;
 
@@ -57,6 +59,8 @@ export async function waitForHttpReady(
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const intervalMs = options?.intervalMs ?? DEFAULT_INTERVAL_MS;
   const requestTimeoutMs = options?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const readinessPath = options?.path ?? "/";
+  const isReady = options?.isReady ?? ((response: Response) => response.ok);
   const deadline = Date.now() + timeoutMs;
 
   for (;;) {
@@ -74,11 +78,11 @@ export async function waitForHttpReady(
     signal?.addEventListener("abort", abortRequest, { once: true });
 
     try {
-      const response = await fetchImpl(`${baseUrl}/api/auth/session`, {
+      const response = await fetchImpl(new URL(readinessPath, baseUrl).toString(), {
         redirect: "manual",
         signal: requestController.signal,
       });
-      if (response.ok) {
+      if (isReady(response)) {
         return;
       }
     } catch (error) {