Add desktop perf trace automation

.github/workflows/ci.yml

@@ -6,6 +6,10 @@ on:
     branches:
       - main
 
+permissions:
+  contents: read
+  pull-requests: write
+
 jobs:
   quality:
     name: Lint, Typecheck, Test, Build
@@ -46,5 +50,84 @@ jobs:
 
       - name: Verify preload bundle output
         run: |
-          test -f apps/desktop/dist-electron/preload.js
-          grep -nE "desktopBridge|getWsUrl|PICK_FOLDER_CHANNEL|wsUrl" apps/desktop/dist-electron/preload.js
+          test -f apps/desktop/dist-electron/preload.cjs
+          grep -nE "desktopBridge|getWsUrl|PICK_FOLDER_CHANNEL|wsUrl" apps/desktop/dist-electron/preload.cjs
+
+      - name: Install desktop runtime deps (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            xvfb \
+            xauth \
+            libgtk-3-0 \
+            libnotify4 \
+            libnss3 \
+            libxss1 \
+            libxtst6 \
+            libatspi2.0-0 \
+            libdrm2 \
+            libgbm1 \
+            libxrandr2 \
+            libxshmfence1 \
+            libxi6 \
+            xdg-utils
+          sudo apt-get install -y libasound2t64 || sudo apt-get install -y libasound2
+
+      - name: Desktop perf trace test
+        if: github.event_name != 'pull_request'
+        env:
+          ELECTRON_DISABLE_SANDBOX: "1"
+          T3CODE_PERF_TIMEOUT_MS: "420000"
+          T3CODE_PERF_MAX_KEYPRESS_AVG_MS: "12"
+          T3CODE_PERF_MAX_KEYPRESS_MAX_MS: "24"
+          T3CODE_PERF_MAX_LONG_DISPATCH_COUNT: "5"
+          # Terminal PTY scripting is flaky in CI VMs; renderer perf checks remain enforced.
+          T3CODE_DESKTOP_PERF_RUN_TERMINAL: "0"
+          # Keep only core renderer interactions in CI perf runs for lower variance.
+          T3CODE_DESKTOP_PERF_RUN_OPTIONAL_RENDERER: "0"
+          # Skip benchmark sweep loops in CI to reduce EventDispatch variance.
+          T3CODE_DESKTOP_PERF_RUN_BENCHMARK_SWEEP: "0"
+          # Keep benchmark follow-up passes disabled in CI by default.
+          T3CODE_DESKTOP_PERF_BENCHMARK_FOLLOW_UP_PASSES: "0"
+          T3CODE_ELECTRON_STARTUP_TIMEOUT_MS: "180000"
+        run: xvfb-run -a bun run test:desktop-perf
+
+      - name: Desktop perf trace test (fork PR)
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository
+        env:
+          ELECTRON_DISABLE_SANDBOX: "1"
+          T3CODE_PERF_TIMEOUT_MS: "420000"
+          T3CODE_PERF_MAX_KEYPRESS_AVG_MS: "12"
+          T3CODE_PERF_MAX_KEYPRESS_MAX_MS: "24"
+          T3CODE_PERF_MAX_LONG_DISPATCH_COUNT: "5"
+          T3CODE_DESKTOP_PERF_RUN_TERMINAL: "0"
+          T3CODE_DESKTOP_PERF_RUN_OPTIONAL_RENDERER: "0"
+          T3CODE_DESKTOP_PERF_RUN_BENCHMARK_SWEEP: "0"
+          T3CODE_DESKTOP_PERF_BENCHMARK_FOLLOW_UP_PASSES: "0"
+          T3CODE_ELECTRON_STARTUP_TIMEOUT_MS: "180000"
+        run: xvfb-run -a bun run test:desktop-perf
+
+      - name: Desktop perf trace test and PR summary
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
+        env:
+          GH_TOKEN: ${{ github.token }}
+          ELECTRON_DISABLE_SANDBOX: "1"
+          T3CODE_PERF_TIMEOUT_MS: "420000"
+          T3CODE_PERF_MAX_KEYPRESS_AVG_MS: "12"
+          T3CODE_PERF_MAX_KEYPRESS_MAX_MS: "24"
+          T3CODE_PERF_MAX_LONG_DISPATCH_COUNT: "5"
+          T3CODE_DESKTOP_PERF_RUN_TERMINAL: "0"
+          T3CODE_DESKTOP_PERF_RUN_OPTIONAL_RENDERER: "0"
+          T3CODE_DESKTOP_PERF_RUN_BENCHMARK_SWEEP: "0"
+          T3CODE_DESKTOP_PERF_BENCHMARK_FOLLOW_UP_PASSES: "0"
+          T3CODE_ELECTRON_STARTUP_TIMEOUT_MS: "180000"
+        run: xvfb-run -a bun run test:desktop-perf:post
+
+      - name: Upload desktop perf artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: desktop-perf-artifacts
+          path: /tmp/t3code-perf-artifacts
+          if-no-files-found: ignore

apps/desktop/package.json

@@ -2,13 +2,14 @@
   "name": "@t3tools/desktop",
   "version": "0.0.0",
   "private": true,
-  "main": "dist-electron/main.js",
+  "type": "module",
+  "main": "dist-electron/main.mjs",
   "scripts": {
     "dev": "bun run --parallel dev:bundle dev:electron",
-    "dev:bundle": "tsdown --watch",
+    "dev:bundle": "tsdown --watch --no-clean",
     "dev:electron": "bun run scripts/dev-electron.mjs",
     "build": "tsdown",
-    "start": "electron dist-electron/main.js",
+    "start": "electron dist-electron/main.mjs",
     "typecheck": "tsc --noEmit",
     "test": "vitest run --passWithNoTests",
     "smoke-test": "node scripts/smoke-test.mjs"

apps/desktop/scripts/dev-electron.mjs

@@ -1,24 +1,184 @@
 import { spawn } from "node:child_process";
-
-import waitOn from "wait-on";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
 
 const port = Number(process.env.ELECTRON_RENDERER_PORT ?? 5173);
-const devServerUrl = `http://localhost:${port}`;
-
-await waitOn({
-  resources: [
-    `tcp:${port}`,
-    "file:dist-electron/main.js",
-    "file:dist-electron/preload.js",
-    "file:../server/dist/index.mjs",
-  ],
-});
+const STARTUP_TIMEOUT_MS = Number(process.env.T3CODE_ELECTRON_STARTUP_TIMEOUT_MS ?? 120_000);
+
+async function canConnect(host, probePort, timeoutMs = 1_000) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let settled = false;
+
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    };
+
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    socket.connect(probePort, host);
+  });
+}
+
+const f = (p) => path.join(import.meta.dirname, "..", p);
+
+function inspectBundleFile(bundleFile) {
+  let stat = null;
+  try {
+    stat = fs.statSync(bundleFile.path);
+  } catch {
+    return {
+      ...bundleFile,
+      status: "missing",
+      mtimeMs: null,
+      reason: "not found",
+    };
+  }
+
+  return {
+    ...bundleFile,
+    status: "ready",
+    mtimeMs: stat.mtimeMs,
+    reason: "ok",
+  };
+}
+
+function describeBundleStates(states) {
+  return states
+    .map((state) => {
+      const mtime =
+        typeof state.mtimeMs === "number" ? new Date(state.mtimeMs).toISOString() : "n/a";
+      return `${state.label}=${state.status} (mtime=${mtime}; reason=${state.reason})`;
+    })
+    .join("; ");
+}
+
+function waitForDesktopBundles(timeoutMs) {
+  const startedAt = Date.now();
+  const bundleFiles = [
+    {
+      path: f("dist-electron/main.mjs"),
+      label: "desktop/main.mjs",
+    },
+    {
+      path: f("dist-electron/preload.cjs"),
+      label: "desktop/preload.cjs",
+    },
+    {
+      path: f("../server/dist/index.mjs"),
+      label: "server/index.mjs",
+    },
+  ];
+  let lastProgressLogAt = 0;
+
+  return new Promise((resolve, reject) => {
+    const tick = () => {
+      const states = bundleFiles.map(inspectBundleFile);
+      const missing = states.filter((state) => state.status === "missing");
+
+      if (missing.length === 0) {
+        resolve();
+        return;
+      }
+
+      const elapsedMs = Date.now() - startedAt;
+      if (elapsedMs >= timeoutMs) {
+        const parts = [];
+        if (missing.length > 0) {
+          parts.push(`missing: ${missing.map((state) => state.label).join(", ")}`);
+        }
+        reject(
+          new Error(
+            `[dev-electron] timed out after ${timeoutMs}ms waiting for bundles (${parts.join("; ")})\n[dev-electron] bundle state: ${describeBundleStates(states)}`,
+          ),
+        );
+        return;
+      }
+
+      if (Date.now() - lastProgressLogAt >= 5_000) {
+        lastProgressLogAt = Date.now();
+        const waitParts = [];
+        if (missing.length > 0) {
+          waitParts.push(`missing=${missing.map((state) => state.label).join(",")}`);
+        }
+        console.log(
+          `[dev-electron] still waiting for bundles after ${elapsedMs}ms (${waitParts.join("; ")})`,
+        );
+      }
+
+      setTimeout(tick, 250);
+    };
+
+    tick();
+  });
+}
+
+function waitForDevServer(probePort, timeoutMs) {
+  const startedAt = Date.now();
+  const candidates = [
+    { host: "127.0.0.1", url: `http://127.0.0.1:${probePort}` },
+    { host: "::1", url: `http://[::1]:${probePort}` },
+    { host: "localhost", url: `http://localhost:${probePort}` },
+  ];
+
+  return new Promise((resolve, reject) => {
+    const tick = () => {
+      void Promise.all(
+        candidates.map(async (candidate) => ({
+          candidate,
+          connected: await canConnect(candidate.host, probePort),
+        })),
+      )
+        .then((results) => {
+          const ready = results.find((entry) => entry.connected);
+          if (ready) {
+            resolve(ready.candidate.url);
+            return;
+          }
+
+          if (Date.now() - startedAt >= timeoutMs) {
+            reject(
+              new Error(
+                `[dev-electron] timed out after ${timeoutMs}ms waiting for renderer dev server on port ${probePort}`,
+              ),
+            );
+            return;
+          }
+
+          setTimeout(tick, 250);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    };
+
+    tick();
+  });
+}
+
+console.log("[dev-electron] waiting for desktop/server bundles");
+await waitForDesktopBundles(STARTUP_TIMEOUT_MS);
+
+console.log(`[dev-electron] waiting for renderer dev server on port ${port}`);
+const devServerUrl = await waitForDevServer(port, STARTUP_TIMEOUT_MS);
+console.log(`[dev-electron] launching electron with renderer url ${devServerUrl}`);
 
 const command = process.platform === "win32" ? "electronmon.cmd" : "electronmon";
 const childEnv = { ...process.env };
 delete childEnv.ELECTRON_RUN_AS_NODE;
 
-const child = spawn(command, ["dist-electron/main.js"], {
+if (process.platform === "linux" && !childEnv.ELECTRON_DISABLE_SANDBOX) {
+  childEnv.ELECTRON_DISABLE_SANDBOX = "1";
+  console.log("[dev-electron] enabling ELECTRON_DISABLE_SANDBOX=1 on Linux");
+}
+
+const child = spawn(command, ["dist-electron/main.mjs"], {
   stdio: "inherit",
   env: {
     ...childEnv,
@@ -29,3 +189,8 @@ const child = spawn(command, ["dist-electron/main.js"], {
 child.on("exit", (code) => {
   process.exit(code ?? 0);
 });
+
+child.on("error", (error) => {
+  console.error("[dev-electron] failed to launch electronmon:", error.message);
+  process.exit(1);
+});