chore: sync upstream pingdotgg/t3code (20260721)

apps/desktop/src/app/DesktopLifecycle.test.ts

@@ -70,6 +70,7 @@ function makeDesktopWindowLayer(input: { readonly activateCount: Ref.Ref<number>
     handleBackendNotReady: Effect.die("unexpected handleBackendNotReady"),
     dispatchMenuAction: () => Effect.die("unexpected dispatchMenuAction"),
     syncAppearance: Effect.void,
+    flushMainWindowBounds: Effect.void,
   } satisfies DesktopWindow.DesktopWindow["Service"]);
 }
 

apps/desktop/src/app/DesktopLifecycle.ts

@@ -73,8 +73,14 @@ function addScopedListener<Args extends ReadonlyArray<unknown>>(
 }
 
 const requestDesktopShutdownAndWait = Effect.fn("desktop.lifecycle.requestShutdownAndWait")(
-  function* (): Effect.fn.Return<void, never, DesktopShutdown.DesktopShutdown> {
+  function* (): Effect.fn.Return<
+    void,
+    never,
+    DesktopShutdown.DesktopShutdown | DesktopWindow.DesktopWindow
+  > {
     const shutdown = yield* DesktopShutdown.DesktopShutdown;
+    const desktopWindow = yield* DesktopWindow.DesktopWindow;
+    yield* desktopWindow.flushMainWindowBounds;
     yield* shutdown.request;
     yield* shutdown.awaitComplete;
   },

apps/desktop/src/backend/DesktopBackendPool.test.ts

@@ -77,6 +77,7 @@ function makePoolLayer(
           showConnectingSplash: Effect.void,
           handleBackendReady: () => Effect.void,
           handleBackendNotReady: Effect.void,
+          flushMainWindowBounds: Effect.void,
           dispatchMenuAction: () => Effect.die("unexpected menu action"),
           syncAppearance: Effect.void,
         } satisfies DesktopWindow.DesktopWindow["Service"]),

apps/desktop/src/backend/DesktopServerExposure.test.ts

@@ -250,6 +250,7 @@ describe("DesktopServerExposure", () => {
     const settingsLayer = Layer.succeed(DesktopAppSettings.DesktopAppSettings, {
       get: Effect.succeed(DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS),
       load: Effect.succeed(DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS),
+      setMainWindowBounds: () => Effect.die("unexpected main window bounds update"),
       setServerExposureMode: () => Effect.fail(settingsFailure),
       setTailscaleServe: () => Effect.fail(settingsFailure),
       setUpdateChannel: () => Effect.die("unexpected update channel change"),

apps/desktop/src/electron/ElectronNotification.test.ts

@@ -171,6 +171,7 @@ function makeLayer(
             handleBackendNotReady: Effect.die("unused"),
             dispatchMenuAction: () => Effect.die("unused"),
             syncAppearance: Effect.die("unused"),
+            flushMainWindowBounds: Effect.die("unused"),
           }),
         ),
         Layer.succeed(

apps/desktop/src/preview/BrowserSession.test.ts

@@ -15,6 +15,7 @@ const { fromPartition, sessions } = vi.hoisted(() => ({
       readonly clearStorageData: ReturnType<typeof vi.fn>;
       readonly getUserAgent: ReturnType<typeof vi.fn>;
       readonly setPermissionRequestHandler: ReturnType<typeof vi.fn>;
+      readonly setPermissionCheckHandler: ReturnType<typeof vi.fn>;
       readonly setUserAgent: ReturnType<typeof vi.fn>;
     }
   >(),
@@ -40,6 +41,7 @@ describe("BrowserSession", () => {
         clearStorageData: vi.fn(() => Promise.resolve()),
         getUserAgent: vi.fn(() => "Mozilla/5.0 Electron/41.5.0 t3code/0.0.27"),
         setPermissionRequestHandler: vi.fn(),
+        setPermissionCheckHandler: vi.fn(),
         setUserAgent: vi.fn(),
       };
       sessions.set(partition, browserSession);
@@ -61,6 +63,55 @@ describe("BrowserSession", () => {
     }).pipe(Effect.provide(layer)),
   );
 
+  it.effect("grants clipboard-sanitized-write through both the request and check handlers", () =>
+    Effect.gen(function* () {
+      const browserSessions = yield* BrowserSession.BrowserSession;
+      const partition = yield* browserSessions.getPartition("scope-a");
+      yield* browserSessions.getSession("scope-a");
+
+      const browserSession = sessions.get(partition);
+      assert.isDefined(browserSession);
+
+      const requestHandler = browserSession.setPermissionRequestHandler.mock.calls[0]?.[0];
+      const checkHandler = browserSession.setPermissionCheckHandler.mock.calls[0]?.[0];
+      assert.isFunction(requestHandler);
+      assert.isFunction(checkHandler);
+
+      const requestAllows = (permission: string): boolean => {
+        let granted: boolean | undefined;
+        requestHandler(null, permission, (value: boolean) => {
+          granted = value;
+        });
+        assert.isDefined(granted);
+        return granted;
+      };
+
+      for (const permission of [
+        "clipboard-read",
+        "clipboard-sanitized-write",
+        "notifications",
+        "geolocation",
+      ]) {
+        assert.isTrue(requestAllows(permission), `request handler should allow ${permission}`);
+        assert.isTrue(
+          checkHandler(null, permission) as boolean,
+          `check handler should allow ${permission}`,
+        );
+      }
+
+      // `clipboard-write` is not a real Electron permission — the async write API
+      // uses `clipboard-sanitized-write` — so the stale name must not be granted,
+      // and unrelated permissions stay denied.
+      for (const permission of ["clipboard-write", "midi"]) {
+        assert.isFalse(requestAllows(permission), `request handler should deny ${permission}`);
+        assert.isFalse(
+          checkHandler(null, permission) as boolean,
+          `check handler should deny ${permission}`,
+        );
+      }
+    }).pipe(Effect.provide(layer)),
+  );
+
   it.effect("preserves partition scope and the platform failure chain", () => {
     const nativeCause = new Error("native digest failed");
     const platformCause = PlatformError.systemError({

apps/desktop/src/preview/BrowserSession.ts

@@ -11,6 +11,20 @@ import * as SynchronizedRef from "effect/SynchronizedRef";
 
 const PREVIEW_PARTITION_PREFIX = "persist:t3code-preview-";
 
+// Permissions granted to preview web content. `clipboard-sanitized-write` is the
+// Electron permission behind `navigator.clipboard.writeText()` — note it is NOT
+// `clipboard-write`, which is not a valid Electron permission name. Async
+// clipboard writes are gated by the permission *check* handler (not only the
+// request handler), so both handlers must allow it; otherwise built-in "Copy"
+// buttons — e.g. the Next.js / Vercel error overlay — fail with
+// `Failed to execute 'writeText' on 'Clipboard': Write permission denied`.
+const ALLOWED_PREVIEW_PERMISSIONS: ReadonlySet<string> = new Set([
+  "clipboard-read",
+  "clipboard-sanitized-write",
+  "notifications",
+  "geolocation",
+]);
+
 export class BrowserSessionPartitionDerivationError extends Schema.TaggedErrorClass<BrowserSessionPartitionDerivationError>()(
   "BrowserSessionPartitionDerivationError",
   {
@@ -120,9 +134,11 @@ export const make = Effect.gen(function* BrowserSessionMake() {
             .replace(/\s*t3code\/[\d.]+/, "");
           browserSession.setUserAgent(userAgent);
           browserSession.setPermissionRequestHandler((_webContents, permission, callback) => {
-            const allowed = ["clipboard-read", "clipboard-write", "notifications", "geolocation"];
-            callback(allowed.includes(permission));
+            callback(ALLOWED_PREVIEW_PERMISSIONS.has(permission));
           });
+          browserSession.setPermissionCheckHandler((_webContents, permission) =>
+            ALLOWED_PREVIEW_PERMISSIONS.has(permission),
+          );
           const next = new Map(sessions);
           next.set(partition, browserSession);
           return [browserSession, next] as const;

apps/desktop/src/settings/DesktopAppSettings.test.ts

@@ -11,6 +11,17 @@ import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
 import * as DesktopAppSettings from "./DesktopAppSettings.ts";
 
 const DesktopSettingsPatch = Schema.Struct({
+  mainWindowBounds: Schema.optionalKey(
+    Schema.NullOr(
+      Schema.Struct({
+        x: Schema.Number,
+        y: Schema.Number,
+        width: Schema.Number,
+        height: Schema.Number,
+      }),
+    ),
+  ),
+  mainWindowMaximized: Schema.optionalKey(Schema.Boolean),
   serverExposureMode: Schema.optionalKey(Schema.Literals(["local-only", "network-accessible"])),
   tailscaleServeEnabled: Schema.optionalKey(Schema.Boolean),
   tailscaleServePort: Schema.optionalKey(Schema.Number),
@@ -91,6 +102,8 @@ describe("DesktopSettings", () => {
     assert.deepEqual(
       DesktopAppSettings.resolveDefaultDesktopSettings("0.0.17-nightly.20260415.1"),
       {
+        mainWindowBounds: null,
+        mainWindowMaximized: false,
         serverExposureMode: "local-only",
         tailscaleServeEnabled: false,
         tailscaleServePort: 443,
@@ -116,6 +129,8 @@ describe("DesktopSettings", () => {
         });
 
         assert.deepEqual(yield* settings.load, {
+          mainWindowBounds: null,
+          mainWindowMaximized: false,
           serverExposureMode: "network-accessible",
           tailscaleServeEnabled: true,
           tailscaleServePort: 8443,
@@ -215,10 +230,13 @@ describe("DesktopSettings", () => {
             "serverExposureMode": "network-accessible",
             "tailscaleServeEnabled": true,
             "tailscaleServePort": 8443,
+            "mainWindowBounds": { "x": 120, "y": 80, "width": 1280, "height": 900 },
           }\n`,
         );
 
         assert.deepEqual(yield* settings.load, {
+          mainWindowBounds: { x: 120, y: 80, width: 1280, height: 900 },
+          mainWindowMaximized: false,
           serverExposureMode: "network-accessible",
           tailscaleServeEnabled: true,
           tailscaleServePort: 8443,
@@ -232,19 +250,40 @@ describe("DesktopSettings", () => {
     ),
   );
 
+  it.effect("rejects window bounds that do not satisfy the domain schema", () =>
+    withSettings(
+      Effect.gen(function* () {
+        const settings = yield* DesktopAppSettings.DesktopAppSettings;
+        yield* writeSettingsPatch({
+          mainWindowBounds: { x: 10.5, y: 20, width: 839, height: 620 },
+          mainWindowMaximized: true,
+          serverExposureMode: "network-accessible",
+        });
+
+        const loaded = yield* settings.load;
+        assert.isNull(loaded.mainWindowBounds);
+        assert.isFalse(loaded.mainWindowMaximized);
+        assert.equal(loaded.serverExposureMode, "network-accessible");
+      }),
+    ),
+  );
+
   it.effect("persists sparse desktop settings documents", () =>
     withSettings(
       Effect.gen(function* () {
         const environment = yield* DesktopEnvironment.DesktopEnvironment;
         const fileSystem = yield* FileSystem.FileSystem;
         const settings = yield* DesktopAppSettings.DesktopAppSettings;
 
+        yield* settings.setMainWindowBounds({ x: -1200, y: 40, width: 1440, height: 960 }, true);
         yield* settings.setServerExposureMode("network-accessible");
 
         const persisted = yield* decodeDesktopSettingsPatch(
           yield* fileSystem.readFileString(environment.desktopSettingsPath),
         );
         assert.deepEqual(persisted, {
+          mainWindowBounds: { x: -1200, y: 40, width: 1440, height: 960 },
+          mainWindowMaximized: true,
           serverExposureMode: "network-accessible",
         } satisfies typeof DesktopSettingsPatch.Type);
       }),
@@ -261,6 +300,8 @@ describe("DesktopSettings", () => {
         });
 
         assert.deepEqual(yield* settings.load, {
+          mainWindowBounds: null,
+          mainWindowMaximized: false,
           serverExposureMode: "local-only",
           tailscaleServeEnabled: false,
           tailscaleServePort: 443,
@@ -286,6 +327,8 @@ describe("DesktopSettings", () => {
         });
 
         assert.deepEqual(yield* settings.load, {
+          mainWindowBounds: null,
+          mainWindowMaximized: false,
           serverExposureMode: "local-only",
           tailscaleServeEnabled: false,
           tailscaleServePort: 443,
@@ -310,6 +353,8 @@ describe("DesktopSettings", () => {
         });
 
         assert.deepEqual(yield* settings.load, {
+          mainWindowBounds: null,
+          mainWindowMaximized: false,
           serverExposureMode: "local-only",
           tailscaleServeEnabled: true,
           tailscaleServePort: 443,