Fix resize repaint gaps and initial view sizing (#1039)

* Fix resize repaint gaps and initial view sizing

The post-resize invalidate block repainted the title bar, content and
env-select popup but skipped the progress view, even though it gets
re-bounded on every resize. On the platforms that need the explicit
invalidate that left the progress view stale until the next paint, so
it now gets invalidated alongside the others.

The title bar and welcome view were laid out from the compile-time
DEFAULT_WIN_* constants at load time. A session restored at a larger or
maximized size then rendered mis-sized for a frame until the first
resize corrected it. Both now read the live size from getContentBounds,
mirroring what _resizeViews already does.

The update check parsed the release feed body with no status check, so a
5xx or an HTML error page went straight into yaml.load and could be
mistaken for metadata. It now fails fast on a non-ok response and guards
that the parsed version is a valid semver before comparing, which routes
a bad response cleanly to the existing error dialog on the 'always' path
instead of comparing against garbage.

Also leave a note by the dialog toolkit script so nobody extends the
CommonJS interop shim to it: the toolkit is a UMD bundle that branches on
typeof exports and faking exports there takes down every jp-* component.

I wrote and verified these with Claude Code: tsc clean, the full unit
suite green, and a focused test that a non-ok update response never
reaches the body parse (fails before the status check, passes after).

* test: sort the vitest named imports to satisfy eslint

The installer CI runs eslint:check before building and the sort-imports rule
rejected the unsorted import in the new checkForUpdates test, failing the Linux
job (and cancelling the others). Order the members alphabetically.

* fix: share title bar bounds between load and resize

The initial bounds in load() spanned the full content width with no inset,
while _resizeViews() insets by 1px on non-macOS, so the title bar gapped by a
pixel on the first paint until the first resize corrected it. Compute the
bounds once in _titleBarBounds() and use it from both so the first paint
matches every later resize.

Note: AI-assisted (Claude Code). Manually verified: tsc and eslint clean, added a unit test for the macOS and non-macOS rects and confirmed it fails when the inset is removed.

Author: notluquis

src/main/app.ts

@@ -1257,9 +1257,15 @@ export class JupyterApplication implements IApplication, IDisposable {
       )
       .then(async response => {
         try {
+          if (!response.ok) {
+            throw new Error(`Update check failed: ${response.status}`);
+          }
           const data = await response.text();
           const latestReleaseData = yaml.load(data);
           const latestVersion = (latestReleaseData as any).version;
+          if (!latestVersion || !semver.valid(latestVersion)) {
+            throw new Error('No valid version in update metadata');
+          }
           const currentVersion = app.getVersion();
           const newVersionAvailable =
             semver.compare(currentVersion, latestVersion) === -1;

src/main/dialog/themedwindow.ts

@@ -106,6 +106,7 @@ export class ThemedWindow {
             overflow-y: auto;
           }
           </style>
+          <!-- do not prepend the cjsInteropShim here: the toolkit is a UMD bundle that branches on typeof exports, so faking exports breaks every jp-* component -->
           <script type="module">${toolkitJsSrc}</script>
           <script type="module">${cjsInteropShim}${titlebarJsSrc}</script>
           <script>

src/main/sessionwindow/sessionwindow.ts

@@ -170,12 +170,7 @@ export class SessionWindow implements IDisposable {
   load() {
     const titleBarView = new TitleBarView({ isDarkTheme: this._isDarkTheme });
     this._window.contentView.addChildView(titleBarView.view);
-    titleBarView.view.setBounds({
-      x: 0,
-      y: 0,
-      width: DEFAULT_WIN_WIDTH,
-      height: titleBarHeight
-    });
+    titleBarView.view.setBounds(this._titleBarBounds());
 
     this._window.on('focus', () => {
       titleBarView.activate();
@@ -324,11 +319,15 @@ export class SessionWindow implements IDisposable {
       isDarkTheme: this._isDarkTheme
     });
     this._window.contentView.addChildView(welcomeView.view);
+    const {
+      width: contentWidth,
+      height: contentHeight
+    } = this._window.getContentBounds();
     welcomeView.view.setBounds({
       x: 0,
       y: titleBarHeight,
-      width: DEFAULT_WIN_WIDTH,
-      height: DEFAULT_WIN_HEIGHT
+      width: contentWidth,
+      height: contentHeight - titleBarHeight
     });
 
     welcomeView.load();
@@ -1225,16 +1224,23 @@ export class SessionWindow implements IDisposable {
     }, 300);
   }
 
-  private _resizeViews() {
-    const { width, height } = this._window.getContentBounds();
-    // add padding to allow resizing around title bar
+  // Title bar bounds, shared by load() and _resizeViews() so the first paint
+  // matches every later resize. Non-macOS insets by 1px so the frame stays
+  // grabbable for resizing around the title bar.
+  private _titleBarBounds(): Electron.Rectangle {
+    const { width } = this._window.getContentBounds();
     const padding = process.platform === 'darwin' ? 0 : 1;
-    this._titleBarView.view.setBounds({
+    return {
       x: padding,
       y: padding,
       width: width - 2 * padding,
       height: titleBarHeight - padding
-    });
+    };
+  }
+
+  private _resizeViews() {
+    const { width, height } = this._window.getContentBounds();
+    this._titleBarView.view.setBounds(this._titleBarBounds());
     const contentRect: Electron.Rectangle = {
       x: 0,
       y: titleBarHeight,
@@ -1260,6 +1266,7 @@ export class SessionWindow implements IDisposable {
       };
       invalidate(this._titleBarView?.view?.webContents);
       invalidate(this.contentView?.webContents);
+      invalidate(this._progressView?.view?.view?.webContents);
       invalidate(this._envSelectPopup?.view?.view?.webContents);
     }, 200);
   }

test/setup/electron-stub.ts

@@ -55,6 +55,8 @@ export const BrowserWindow = vi.fn().mockImplementation(() => ({
 
 export const shell = { openExternal: vi.fn(), openPath: vi.fn() };
 
+export const net = { fetch: vi.fn() };
+
 export const nativeTheme = { shouldUseDarkColors: false };
 
 export const screen = {

test/unit/app-checkforupdates.test.ts

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { net } from '../setup/electron-stub';
+import { JupyterApplication } from '../../src/main/app';
+
+// checkForUpdates is a method on the large JupyterApplication class whose
+// constructor wires up the whole main process, so we exercise the method on a
+// prototype-only instance and stub the two collaborators it reaches: the
+// electron `net.fetch` boundary and the private _showUpdateDialog sink.
+function makeApp(): {
+  app: JupyterApplication;
+  showUpdateDialog: ReturnType<typeof vi.fn>;
+} {
+  const app = Object.create(JupyterApplication.prototype) as JupyterApplication;
+  const showUpdateDialog = vi.fn();
+  ((app as unknown) as {
+    _showUpdateDialog: unknown;
+  })._showUpdateDialog = showUpdateDialog;
+  return { app, showUpdateDialog };
+}
+
+describe('JupyterApplication.checkForUpdates', () => {
+  beforeEach(() => {
+    (net.fetch as ReturnType<typeof vi.fn>).mockReset();
+  });
+
+  it('does not read the body when the release feed responds non-ok', async () => {
+    const { app, showUpdateDialog } = makeApp();
+    const text = vi.fn(() => Promise.resolve('<html>not yaml</html>'));
+    (net.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: false,
+      status: 503,
+      text
+    });
+
+    app.checkForUpdates('always');
+
+    await vi.waitFor(() => expect(showUpdateDialog).toHaveBeenCalled());
+    expect(text).not.toHaveBeenCalled();
+    expect(showUpdateDialog).toHaveBeenCalledWith('error');
+    expect(showUpdateDialog).not.toHaveBeenCalledWith('updates-available');
+  });
+});

test/unit/sessionwindow-titlebar-bounds.test.ts

@@ -0,0 +1,40 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { SessionWindow } from '../../src/main/sessionwindow/sessionwindow';
+
+// _titleBarBounds is the single source of truth shared by load() and
+// _resizeViews(); if the two ever diverge again the first paint gaps by a pixel
+// on non-macOS. Drive it directly without the heavy constructor.
+const realPlatform = process.platform;
+function setPlatform(p: string): void {
+  Object.defineProperty(process, 'platform', { value: p, configurable: true });
+}
+
+function windowWith(width: number): any {
+  const win = Object.create(SessionWindow.prototype);
+  win._window = { getContentBounds: () => ({ width, height: 600 }) };
+  return win;
+}
+
+describe('SessionWindow._titleBarBounds', () => {
+  afterEach(() => setPlatform(realPlatform));
+
+  it('spans the full content width with no inset on macOS', () => {
+    setPlatform('darwin');
+    expect(windowWith(800)._titleBarBounds()).toEqual({
+      x: 0,
+      y: 0,
+      width: 800,
+      height: 29
+    });
+  });
+
+  it('insets by one pixel on non-macOS so the frame stays grabbable', () => {
+    setPlatform('linux');
+    expect(windowWith(800)._titleBarBounds()).toEqual({
+      x: 1,
+      y: 1,
+      width: 798,
+      height: 28
+    });
+  });
+});