Fix desktop packaging and backend restart handling

Author: zortos293

apps/desktop/src/backendRestartPolicy.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  BACKEND_MAX_CONSECUTIVE_FAILURES,
+  BACKEND_STABLE_RUN_MS,
+  decideBackendRestart,
+  INITIAL_BACKEND_RESTART_STATE,
+  noteBackendLaunch,
+} from "./backendRestartPolicy";
+
+describe("backendRestartPolicy", () => {
+  it("backs off for consecutive fast crashes", () => {
+    const firstLaunch = noteBackendLaunch(INITIAL_BACKEND_RESTART_STATE, 1_000);
+    const firstFailure = decideBackendRestart(firstLaunch, 1_100);
+    expect(firstFailure.type).toBe("restart");
+    expect(firstFailure.delayMs).toBe(500);
+
+    const secondLaunch = noteBackendLaunch(firstFailure.nextState, 2_000);
+    const secondFailure = decideBackendRestart(secondLaunch, 2_100);
+    expect(secondFailure.type).toBe("restart");
+    expect(secondFailure.delayMs).toBe(1_000);
+  });
+
+  it("treats a stable run as a fresh failure streak", () => {
+    const priorFailures = {
+      consecutiveFailures: 4,
+      lastLaunchAtMs: 10_000,
+    };
+
+    const decision = decideBackendRestart(priorFailures, 10_000 + BACKEND_STABLE_RUN_MS);
+
+    expect(decision.type).toBe("restart");
+    expect(decision.delayMs).toBe(500);
+    expect(decision.nextState.consecutiveFailures).toBe(1);
+  });
+
+  it("stops restarting after too many rapid failures", () => {
+    let state = INITIAL_BACKEND_RESTART_STATE;
+
+    for (let index = 0; index < BACKEND_MAX_CONSECUTIVE_FAILURES - 1; index += 1) {
+      state = noteBackendLaunch(state, 1_000 + index * 100);
+      const decision = decideBackendRestart(state, 1_050 + index * 100);
+      expect(decision.type).toBe("restart");
+      state = decision.nextState;
+    }
+
+    state = noteBackendLaunch(state, 5_000);
+    const fatalDecision = decideBackendRestart(state, 5_050);
+
+    expect(fatalDecision.type).toBe("fatal");
+    expect(fatalDecision.nextState.consecutiveFailures).toBe(BACKEND_MAX_CONSECUTIVE_FAILURES);
+  });
+});

apps/desktop/src/backendRestartPolicy.ts

@@ -0,0 +1,54 @@
+export interface BackendRestartState {
+  readonly consecutiveFailures: number;
+  readonly lastLaunchAtMs: number | null;
+}
+
+export interface BackendRestartDecision {
+  readonly type: "restart" | "fatal";
+  readonly delayMs: number;
+  readonly nextState: BackendRestartState;
+  readonly uptimeMs: number;
+}
+
+export const BACKEND_STABLE_RUN_MS = 5_000;
+export const BACKEND_MAX_CONSECUTIVE_FAILURES = 5;
+const BACKEND_RESTART_BASE_DELAY_MS = 500;
+const BACKEND_RESTART_MAX_DELAY_MS = 10_000;
+
+export const INITIAL_BACKEND_RESTART_STATE: BackendRestartState = {
+  consecutiveFailures: 0,
+  lastLaunchAtMs: null,
+};
+
+export function noteBackendLaunch(
+  state: BackendRestartState,
+  launchedAtMs: number,
+): BackendRestartState {
+  return {
+    ...state,
+    lastLaunchAtMs: launchedAtMs,
+  };
+}
+
+export function decideBackendRestart(
+  state: BackendRestartState,
+  nowMs: number,
+): BackendRestartDecision {
+  const uptimeMs = state.lastLaunchAtMs === null ? 0 : Math.max(0, nowMs - state.lastLaunchAtMs);
+  const stableRun = uptimeMs >= BACKEND_STABLE_RUN_MS;
+  const consecutiveFailures = stableRun ? 1 : state.consecutiveFailures + 1;
+  const delayMs = Math.min(
+    BACKEND_RESTART_BASE_DELAY_MS * 2 ** Math.max(consecutiveFailures - 1, 0),
+    BACKEND_RESTART_MAX_DELAY_MS,
+  );
+
+  return {
+    type: consecutiveFailures >= BACKEND_MAX_CONSECUTIVE_FAILURES ? "fatal" : "restart",
+    delayMs,
+    nextState: {
+      consecutiveFailures,
+      lastLaunchAtMs: null,
+    },
+    uptimeMs,
+  };
+}

apps/desktop/src/main.ts

@@ -49,6 +49,11 @@ import {
   reduceDesktopUpdateStateOnUpdateAvailable,
 } from "./updateMachine";
 import { isArm64HostRunningIntelBuild, resolveDesktopRuntimeInfo } from "./runtimeArch";
+import {
+  decideBackendRestart,
+  INITIAL_BACKEND_RESTART_STATE,
+  noteBackendLaunch,
+} from "./backendRestartPolicy";
 
 syncShellEnvironment();
 
@@ -89,14 +94,14 @@ let backendProcess: ChildProcess.ChildProcess | null = null;
 let backendPort = 0;
 let backendAuthToken = "";
 let backendWsUrl = "";
-let restartAttempt = 0;
 let restartTimer: ReturnType<typeof setTimeout> | null = null;
 let isQuitting = false;
 let desktopProtocolRegistered = false;
 let aboutCommitHashCache: string | null | undefined;
 let desktopLogSink: RotatingFileSink | null = null;
 let backendLogSink: RotatingFileSink | null = null;
 let restoreStdIoCapture: (() => void) | null = null;
+let backendRestartState = INITIAL_BACKEND_RESTART_STATE;
 
 let destructiveMenuIconCache: Electron.NativeImage | null | undefined;
 let macDeveloperIdSigned: boolean | null = null;
@@ -1041,8 +1046,19 @@ function backendEnv(): NodeJS.ProcessEnv {
 function scheduleBackendRestart(reason: string): void {
   if (isQuitting || restartTimer) return;
 
-  const delayMs = Math.min(500 * 2 ** restartAttempt, 10_000);
-  restartAttempt += 1;
+  const decision = decideBackendRestart(backendRestartState, Date.now());
+  backendRestartState = decision.nextState;
+  if (decision.type === "fatal") {
+    handleFatalStartupError(
+      "backend",
+      new Error(
+        `The background server crashed ${decision.nextState.consecutiveFailures} times in a row within ${decision.uptimeMs}ms. Check ${Path.join(LOG_DIR, "server-child.log")} for details.`,
+      ),
+    );
+    return;
+  }
+
+  const delayMs = decision.delayMs;
   console.error(`[desktop] backend exited unexpectedly (${reason}); restarting in ${delayMs}ms`);
 
   restartTimer = setTimeout(() => {
@@ -1061,6 +1077,7 @@ function startBackend(): void {
   }
 
   const captureBackendLogs = app.isPackaged && backendLogSink !== null;
+  backendRestartState = noteBackendLaunch(backendRestartState, Date.now());
   const child = ChildProcess.spawn(process.execPath, [backendEntry], {
     cwd: resolveBackendCwd(),
     // In Electron main, process.execPath points to the Electron binary.
@@ -1084,10 +1101,6 @@ function startBackend(): void {
   );
   captureBackendOutput(child);
 
-  child.once("spawn", () => {
-    restartAttempt = 0;
-  });
-
   child.on("error", (error) => {
     if (backendProcess === child) {
       backendProcess = null;
@@ -1115,6 +1128,8 @@ function stopBackend(): void {
     restartTimer = null;
   }
 
+  backendRestartState = INITIAL_BACKEND_RESTART_STATE;
+
   const child = backendProcess;
   backendProcess = null;
   if (!child) return;
@@ -1135,6 +1150,8 @@ async function stopBackendAndWaitForExit(timeoutMs = 5_000): Promise<void> {
     restartTimer = null;
   }
 
+  backendRestartState = INITIAL_BACKEND_RESTART_STATE;
+
   const child = backendProcess;
   backendProcess = null;
   if (!child) return;

scripts/build-desktop-artifact.ts

@@ -188,12 +188,14 @@ interface StagePackageJson {
   readonly version: string;
   readonly buildVersion: string;
   readonly t3codeCommitHash: string;
+  readonly packageManager?: string;
   readonly private: true;
   readonly description: string;
   readonly author: string;
   readonly main: string;
   readonly build: Record<string, unknown>;
   readonly dependencies: Record<string, unknown>;
+  readonly patchedDependencies?: Record<string, string>;
   readonly devDependencies: {
     readonly electron: string;
   };
@@ -647,11 +649,22 @@ const buildDesktopArtifact = Effect.fn("buildDesktopArtifact")(function* (
   // electron-builder is filtering out stageResourcesDir directory in the AppImage for production
   yield* fs.copy(stageResourcesDir, path.join(stageAppDir, "apps/desktop/prod-resources"));
 
+  const rootPatchedDependencies = rootPackageJson.patchedDependencies;
+  if (rootPatchedDependencies) {
+    for (const relativePatchPath of Object.values(rootPatchedDependencies)) {
+      const sourcePatchPath = path.join(repoRoot, relativePatchPath);
+      const targetPatchPath = path.join(stageAppDir, relativePatchPath);
+      yield* fs.makeDirectory(path.dirname(targetPatchPath), { recursive: true });
+      yield* fs.copyFile(sourcePatchPath, targetPatchPath);
+    }
+  }
+
   const stagePackageJson: StagePackageJson = {
     name: "t3-code-desktop",
     version: appVersion,
     buildVersion: appVersion,
     t3codeCommitHash: commitHash,
+    packageManager: rootPackageJson.packageManager,
     private: true,
     description: "T3 Code desktop build",
     author: "T3 Tools",
@@ -667,6 +680,7 @@ const buildDesktopArtifact = Effect.fn("buildDesktopArtifact")(function* (
       ...bundledCopilotPlatformDependencies,
       ...resolvedDesktopRuntimeDependencies,
     },
+    patchedDependencies: rootPatchedDependencies,
     devDependencies: {
       electron: electronVersion,
     },