chore(deps): bump Electron to 44.1.1

apps/desktop/package.json

@@ -21,7 +21,7 @@
     "@t3tools/ssh": "workspace:*",
     "@t3tools/tailscale": "workspace:*",
     "effect": "catalog:",
-    "electron": "43.4.1",
+    "electron": "44.1.1",
     "electron-store": "^8.2.0",
     "electron-updater": "^6.6.2",
     "playwright-core": "1.60.0",

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

@@ -36,6 +36,29 @@ describe("ElectronShell", () => {
     }).pipe(Effect.provide(ElectronShell.layer)),
   );
 
+  it.effect("copies text to the system clipboard", () =>
+    Effect.gen(function* () {
+      writeTextMock.mockResolvedValue(undefined);
+
+      const electronShell = yield* ElectronShell.ElectronShell;
+      const result = yield* electronShell.copyText("https://example.com/path");
+
+      assert.equal(result, true);
+      assert.deepEqual(writeTextMock.mock.calls, [["https://example.com/path"]]);
+    }).pipe(Effect.provide(ElectronShell.layer)),
+  );
+
+  it.effect("reports a refused clipboard write instead of failing", () =>
+    Effect.gen(function* () {
+      writeTextMock.mockRejectedValue(new Error("clipboard unavailable"));
+
+      const electronShell = yield* ElectronShell.ElectronShell;
+      const result = yield* electronShell.copyText("https://example.com/path");
+
+      assert.equal(result, false);
+    }).pipe(Effect.provide(ElectronShell.layer)),
+  );
+
   it.effect("opens remote SSH editor URLs", () =>
     Effect.gen(function* () {
       openExternalMock.mockResolvedValue(undefined);

apps/desktop/src/electron/ElectronShell.ts

@@ -43,7 +43,8 @@ export class ElectronShell extends Context.Service<
   ElectronShell,
   {
     readonly openExternal: (rawUrl: unknown) => Effect.Effect<boolean>;
-    readonly copyText: (text: string) => Effect.Effect<void>;
+    /** Writes to the system clipboard. Resolves false when the platform refuses the write. */
+    readonly copyText: (text: string) => Effect.Effect<boolean>;
   }
 >()("@t3tools/desktop/electron/ElectronShell") {}
 
@@ -60,9 +61,12 @@ export const make = ElectronShell.of({
         ),
     }),
   copyText: (text) =>
-    Effect.sync(() => {
-      Electron.clipboard.writeText(text);
-    }),
+    Effect.promise(() =>
+      Electron.clipboard.writeText(text).then(
+        () => true,
+        () => false,
+      ),
+    ),
 });
 
 export const layer = Layer.succeed(ElectronShell, make);

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

@@ -113,30 +113,36 @@ describe("previewWindowOpenAction", () => {
 
 const {
   browserWindowConstructor,
+  clipboardItemConstructor,
   createFromPath,
   fromId,
   getFocusedWebContents,
   mkdir,
   showItemInFolder,
   webviewSend,
   writeFile,
-  writeImage,
+  writeClipboard,
 } = vi.hoisted(() => ({
   browserWindowConstructor: vi.fn(),
-  createFromPath: vi.fn((): { readonly isEmpty: () => boolean } => ({ isEmpty: () => false })),
+  clipboardItemConstructor: vi.fn<(data: Record<string, unknown>) => void>(),
+  createFromPath: vi.fn(() => ({
+    isEmpty: (): boolean => false,
+    toPNG: () => Buffer.from("png"),
+  })),
   fromId: vi.fn<(_id?: number) => Electron.WebContents | null>((_id?: number) => null),
   getFocusedWebContents: vi.fn(() => null),
   mkdir: vi.fn((_path: string) => undefined),
   showItemInFolder: vi.fn(),
   webviewSend: vi.fn(),
   writeFile: vi.fn((_path: string, _data: Uint8Array) => undefined),
-  writeImage: vi.fn(),
+  writeClipboard: vi.fn(async () => undefined),
 }));
 
 vi.mock("electron", () => ({
   BrowserWindow: browserWindowConstructor,
+  ClipboardItem: clipboardItemConstructor,
   clipboard: {
-    writeImage,
+    write: writeClipboard,
   },
   nativeImage: {
     createFromPath,
@@ -469,7 +475,8 @@ describe("PreviewManager", () => {
     mkdir.mockClear();
     writeFile.mockClear();
     showItemInFolder.mockClear();
-    writeImage.mockClear();
+    clipboardItemConstructor.mockClear();
+    writeClipboard.mockClear();
     createFromPath.mockClear();
     webviewSend.mockClear();
   });
@@ -3232,7 +3239,15 @@ describe("PreviewManager", () => {
         yield* manager.copyArtifactToClipboard(artifactPath);
 
         expect(createFromPath).toHaveBeenCalledWith(artifactPath);
-        expect(writeImage).toHaveBeenCalledOnce();
+        const pngBlob = clipboardItemConstructor.mock.calls[0]?.[0]["image/png"];
+        if (!(pngBlob instanceof Blob)) {
+          throw new Error("expected a PNG Blob in the ClipboardItem");
+        }
+        expect(pngBlob.type).toBe("image/png");
+        expect(Buffer.from(yield* Effect.promise(() => pngBlob.arrayBuffer())).toString()).toBe(
+          "png",
+        );
+        expect(writeClipboard).toHaveBeenCalledOnce();
         const exit = yield* Effect.exit(
           manager.copyArtifactToClipboard("/tmp/t3/dev/settings.json"),
         );
@@ -3246,14 +3261,29 @@ describe("PreviewManager", () => {
         });
         expect("cause" in error).toBe(false);
 
-        createFromPath.mockReturnValueOnce({ isEmpty: () => true });
+        createFromPath.mockReturnValueOnce({
+          isEmpty: () => true,
+          toPNG: () => Buffer.from("invalid"),
+        });
         const invalidImageExit = yield* Effect.exit(manager.copyArtifactToClipboard(artifactPath));
         expect(Exit.isFailure(invalidImageExit)).toBe(true);
         if (Exit.isSuccess(invalidImageExit)) return;
         expect(Option.getOrThrow(Cause.findErrorOption(invalidImageExit.cause))).toMatchObject({
           _tag: "PreviewArtifactImageLoadError",
           artifactPath,
         });
+
+        const writeCause = new Error("clipboard write failed");
+        writeClipboard.mockRejectedValueOnce(writeCause);
+        const writeExit = yield* Effect.exit(manager.copyArtifactToClipboard(artifactPath));
+        expect(Exit.isFailure(writeExit)).toBe(true);
+        if (Exit.isSuccess(writeExit)) return;
+        expect(Option.getOrThrow(Cause.findErrorOption(writeExit.cause))).toMatchObject({
+          _tag: "PreviewOperationError",
+          operation: "copyArtifactToClipboard.write",
+          artifactPath,
+          cause: writeCause,
+        });
       }),
     ),
   );

apps/desktop/src/preview/Manager.ts

@@ -32,7 +32,15 @@ import type {
 } from "@t3tools/contracts";
 import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
 import { normalizePreviewUrl } from "@t3tools/shared/preview";
-import { BrowserWindow, type Session, clipboard, nativeImage, shell, webContents } from "electron";
+import {
+  BrowserWindow,
+  ClipboardItem,
+  type Session,
+  clipboard,
+  nativeImage,
+  shell,
+  webContents,
+} from "electron";
 import * as Cause from "effect/Cause";
 import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
@@ -4031,8 +4039,14 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
     if (image.isEmpty()) {
       return yield* new PreviewArtifactImageLoadError({ artifactPath: resolvedPath });
     }
-    yield* attempt({ operation: "copyArtifactToClipboard.write", artifactPath: resolvedPath }, () =>
-      clipboard.writeImage(image),
+    yield* attemptPromise(
+      { operation: "copyArtifactToClipboard.write", artifactPath: resolvedPath },
+      () =>
+        clipboard.write([
+          new ClipboardItem({
+            "image/png": new Blob([Uint8Array.from(image.toPNG())], { type: "image/png" }),
+          }),
+        ]),
     );
   });
 

apps/desktop/src/window/DesktopWindow.test.ts

@@ -280,7 +280,7 @@ function makeTestLayer(input: {
               input.openedExternalUrls?.push(url);
               return true;
             }),
-          copyText: () => Effect.void,
+          copyText: () => Effect.succeed(true),
         } satisfies ElectronShell.ElectronShell["Service"]),
         electronThemeLayer,
         electronWindowLayer,
@@ -380,7 +380,7 @@ const makeSplashScenario = (createOutcomes: readonly (Electron.BrowserWindow | n
           electronMenuLayer,
           Layer.succeed(ElectronShell.ElectronShell, {
             openExternal: () => Effect.succeed(true),
-            copyText: () => Effect.void,
+            copyText: () => Effect.succeed(true),
           } satisfies ElectronShell.ElectronShell["Service"]),
           electronThemeLayer,
           Layer.succeed(ElectronWindow.ElectronWindow, electronWindowShape),

docs/operations/release.md

@@ -215,6 +215,7 @@ available.
 - macOS metadata note:
   - `electron-updater` reads `latest-mac.yml` on stable and `nightly-mac.yml` on nightly, for both Intel and Apple Silicon.
   - The workflow merges the per-arch mac manifests into one channel-specific mac manifest before publishing the GitHub Release.
+  - The desktop artifact build stamps `minimumSystemVersion: '22.0.0'` (Darwin 22, macOS 13 Ventura) into every mac manifest. `electron-updater` compares that field against `os.release()`, which reports the Darwin kernel version rather than the macOS product version, and skips the update on older systems instead of installing an app that cannot launch there.
 
 ### Windows payload topology and update validation
 

docs/user/install.md

@@ -8,6 +8,8 @@ Node.js `^22.16 || ^23.11 || >=24.10` on the machine that runs the T3 Code serve
 
 At least one provider CLI, installed and authenticated. See [Providers](#providers) below.
 
+The desktop app needs macOS 13 (Ventura) or newer on Mac.
+
 ## Run Without Installing
 
 ```bash

scripts/build-desktop-artifact.test.ts

@@ -21,6 +21,8 @@ import {
   createStageWorkspaceConfig,
   createStagePatchedDependencies,
   createBuildConfig,
+  isMacUpdateManifestName,
+  stampMacUpdateManifest,
   DESKTOP_ELECTRON_LANGUAGES,
   DESKTOP_FILE_EXCLUSIONS,
   DESKTOP_EXTRA_RESOURCES,
@@ -563,6 +565,43 @@ it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
     ]);
   });
 
+  it("stamps the macOS floor into updater manifests", () => {
+    const stamped = stampMacUpdateManifest(
+      `version: 1.2.3
+files:
+  - url: T3-Code-1.2.3-arm64.zip
+    sha512: zipsha
+    size: 1
+  - url: T3-Code-1.2.3-arm64.dmg
+    sha512: dmgsha
+    size: 2
+path: T3-Code-1.2.3-arm64.zip
+sha512: zipsha
+releaseDate: '2026-09-03T10:00:00.000Z'
+`,
+      "latest-mac.yml",
+    );
+
+    assert.equal(
+      stamped,
+      `version: '1.2.3'
+files:
+  - url: T3-Code-1.2.3-arm64.zip
+    sha512: zipsha
+    size: 1
+  - url: T3-Code-1.2.3-arm64.dmg
+    sha512: dmgsha
+    size: 2
+minimumSystemVersion: '22.0.0'
+releaseDate: '2026-09-03T10:00:00.000Z'
+`,
+    );
+    assert.isTrue(isMacUpdateManifestName("latest-mac.yml"));
+    assert.isTrue(isMacUpdateManifestName("nightly-mac.yml"));
+    assert.isFalse(isMacUpdateManifestName("builder-debug.yml"));
+    assert.isFalse(isMacUpdateManifestName("latest.yml"));
+  });
+
   it.effect("applies platform-specific packaging to the build config", () =>
     Effect.gen(function* () {
       const mac = yield* createBuildConfig(
@@ -610,6 +649,7 @@ it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
       assert.notProperty(mac, "asarUnpack");
       assert.notProperty(linux, "asarUnpack");
       assert.notProperty(win, "asarUnpack");
+      assert.nestedPropertyVal(mac, "mac.minimumSystemVersion", "13.0");
       assert.deepStrictEqual(win.extraResources, [
         {
           from: "apps/desktop/prod-resources/resource-monitor",