sync: absorb upstream v0.0.30 (27 commits)

README.md

@@ -1,24 +1,36 @@
 # T3 Code
 
-T3 Code is a minimal web GUI for coding agents (currently Codex, Claude, Cursor, and OpenCode, more coming soon).
+T3 Code is an "agent harness control surface". It enables control of the agents on your machine with a best-in-class mobile app, [web app](https://app.t3.codes) and [Electron-based desktop app](https://t3.codes).
+
+Works with your subscriptions on Claude Code, Codex, Cursor, Grok Build, and OpenCode. If they're set up on your computer, T3 Code can control them.
+
+## "Wait, what are you selling me?"
+
+Nothing. We built T3 Code because we wanted the best possible development experience with agents. We were inspired by existing solutions like the Codex desktop app, Conductor, Claude Desktop and Cursor Glass, but none met our bar.
+
+We wanted something performant, remote-ready, and truly open. If we ever go the wrong direction, we want you to have everything you need to fork and build the editor that you want.
 
 ## Installation
 
 > [!WARNING]
-> T3 Code currently supports Codex, Claude, Cursor, and OpenCode.
-> Install and authenticate at least one provider before use:
+> T3 Code currently supports Codex, Claude, Cursor, Grok Build and OpenCode. Install and authenticate at least one provider before use:
 >
 > - Codex: install [Codex CLI](https://developers.openai.com/codex/cli) and run `codex login`
 > - Claude: install [Claude Code](https://claude.com/product/claude-code) and run `claude auth login`
 > - Cursor: install [Cursor CLI](https://cursor.com/cli) and run `cursor-agent login`
+> - Grok Build: install [Grok Build CLI](https://x.ai/cli) and run `grok login`
 > - OpenCode: install [OpenCode](https://opencode.ai) and run `opencode auth login`
 
-### Run without installing
+### Try it out (install-free)
+
+The easiest way to test T3 Code is to run the server in your terminal:
 
 ```bash
 npx t3@latest
 ```
 
+This will launch T3 Code's backend on your machine as well as the local web app to control your agents.
+
 Tip: Use `npx t3@latest --help` for the full CLI reference.
 
 ### Desktop app
@@ -47,7 +59,7 @@ yay -S t3code-bin
 
 We are very very early in this project. Expect bugs.
 
-We are not accepting contributions yet.
+We are (mostly) not accepting contributions yet. Small fixes may be considered. Big features will not be.
 
 There's no public docs site yet, checkout the miscellaneous markdown files in [docs](./docs).
 

apps/desktop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t3tools/desktop",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "private": true,
   "type": "module",
   "main": "dist-electron/main.cjs",

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

@@ -63,6 +63,7 @@ const makeElectronAppLayer = (calls: ElectronAppCalls) =>
         calls.setDockIcon.push(iconPath);
       }),
     appendCommandLineSwitch: () => Effect.void,
+    onBeforeQuitForUpdate: () => Effect.void,
     on: () => Effect.void,
   } satisfies ElectronApp.ElectronApp["Service"]);
 

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

@@ -0,0 +1,123 @@
+import { assert, describe, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+
+import type * as Electron from "electron";
+
+import * as ElectronApp from "../electron/ElectronApp.ts";
+import * as ElectronTheme from "../electron/ElectronTheme.ts";
+import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+import * as DesktopLifecycle from "./DesktopLifecycle.ts";
+import * as DesktopShutdown from "./DesktopShutdown.ts";
+import * as DesktopState from "./DesktopState.ts";
+import * as DesktopWindow from "../window/DesktopWindow.ts";
+
+describe("DesktopLifecycle", () => {
+  for (const platform of ["darwin", "win32", "linux"] satisfies ReadonlyArray<NodeJS.Platform>) {
+    it.effect(`lets the updater's quit event proceed on ${platform}`, () => {
+      const appListeners = new Map<string, (...args: readonly unknown[]) => void>();
+
+      const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, {
+        metadata: Effect.die("unexpected metadata read"),
+        name: Effect.succeed("T3 Code"),
+        whenReady: Effect.void,
+        quit: Effect.void,
+        exit: () => Effect.void,
+        relaunch: () => Effect.void,
+        setPath: () => Effect.void,
+        setName: () => Effect.void,
+        setAboutPanelOptions: () => Effect.void,
+        setAppUserModelId: () => Effect.void,
+        requestSingleInstanceLock: Effect.succeed(true),
+        isDefaultProtocolClient: () => Effect.succeed(false),
+        setAsDefaultProtocolClient: () => Effect.succeed(true),
+        setDesktopName: () => Effect.void,
+        setDockIcon: () => Effect.void,
+        appendCommandLineSwitch: () => Effect.void,
+        onBeforeQuitForUpdate: (listener) =>
+          Effect.acquireRelease(
+            Effect.sync(() => {
+              appListeners.set("before-quit-for-update", listener);
+            }),
+            () =>
+              Effect.sync(() => {
+                appListeners.delete("before-quit-for-update");
+              }),
+          ).pipe(Effect.asVoid),
+        on: (eventName, listener) =>
+          Effect.acquireRelease(
+            Effect.sync(() => {
+              appListeners.set(
+                eventName,
+                listener as unknown as (...args: readonly unknown[]) => void,
+              );
+            }),
+            () =>
+              Effect.sync(() => {
+                appListeners.delete(eventName);
+              }),
+          ).pipe(Effect.asVoid),
+      } satisfies ElectronApp.ElectronApp["Service"]);
+
+      const electronThemeLayer = Layer.succeed(ElectronTheme.ElectronTheme, {
+        shouldUseDarkColors: Effect.succeed(false),
+        setSource: () => Effect.void,
+        onUpdated: () => Effect.void,
+      });
+
+      const desktopWindowLayer = Layer.succeed(DesktopWindow.DesktopWindow, {
+        createMain: Effect.die("unexpected window creation"),
+        ensureMain: Effect.die("unexpected window creation"),
+        revealOrCreateMain: Effect.die("unexpected window creation"),
+        activate: Effect.void,
+        createMainIfBackendReady: Effect.void,
+        showConnectingSplash: Effect.void,
+        handleBackendReady: () => Effect.void,
+        handleBackendNotReady: Effect.void,
+        flushMainWindowBounds: Effect.void,
+        dispatchMenuAction: () => Effect.void,
+        syncAppearance: Effect.void,
+      });
+
+      const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
+        platform,
+        isDevelopment: false,
+      } as DesktopEnvironment.DesktopEnvironment["Service"]);
+
+      const layer = DesktopLifecycle.layer.pipe(
+        Layer.provideMerge(electronAppLayer),
+        Layer.provideMerge(electronThemeLayer),
+        Layer.provideMerge(desktopWindowLayer),
+        Layer.provideMerge(environmentLayer),
+        Layer.provideMerge(DesktopShutdown.layer),
+        Layer.provideMerge(DesktopState.layer),
+      );
+
+      return Effect.scoped(
+        Effect.gen(function* () {
+          const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
+          yield* lifecycle.register;
+
+          appListeners.get("before-quit-for-update")?.();
+
+          let prevented = false;
+          const event = {
+            preventDefault: () => {
+              prevented = true;
+            },
+          } as Electron.Event;
+          appListeners.get("before-quit")?.(event);
+
+          assert.isFalse(
+            prevented,
+            "cancelling this event prevents the updater from completing its relaunch",
+          );
+
+          const state = yield* DesktopState.DesktopState;
+          assert.isTrue(yield* Ref.get(state.quitting));
+        }),
+      ).pipe(Effect.provide(layer));
+    });
+  }
+});

apps/desktop/src/app/DesktopLifecycle.ts

@@ -176,16 +176,28 @@ export const make = DesktopLifecycle.of({
     const context = yield* Effect.context<DesktopLifecycleRuntimeServices>();
     const runEffect = Effect.runPromiseWith(context);
     let quitAllowed = false;
+    let updaterQuitAllowed = false;
     yield* electronTheme.onUpdated(() => {
       void runEffect(
         desktopWindow.syncAppearance.pipe(Effect.withSpan("desktop.lifecycle.themeUpdated")),
       );
     });
+    yield* electronApp.onBeforeQuitForUpdate(() => {
+      // Electron's updater owns the remaining quit/install/relaunch sequence.
+      // Cancelling the following app "before-quit" event breaks that sequence,
+      // most visibly on macOS where the native updater performs the relaunch.
+      updaterQuitAllowed = true;
+      void runEffect(
+        logLifecycleInfo("allowing updater-controlled quit").pipe(
+          Effect.withSpan("desktop.lifecycle.beforeQuitForUpdate"),
+        ),
+      );
+    });
     yield* electronApp.on("before-quit", (event: Electron.Event) => {
       handleBeforeQuit(
         event,
         runEffect,
-        () => quitAllowed,
+        () => quitAllowed || updaterQuitAllowed,
         () => {
           quitAllowed = true;
         },

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

@@ -4,6 +4,8 @@ import { beforeEach, vi } from "vite-plus/test";
 
 const {
   appendSwitchMock,
+  autoUpdaterOnMock,
+  autoUpdaterRemoveListenerMock,
   exitMock,
   getAppPathMock,
   getVersionMock,
@@ -23,6 +25,8 @@ const {
   whenReadyMock,
 } = vi.hoisted(() => ({
   appendSwitchMock: vi.fn(),
+  autoUpdaterOnMock: vi.fn(),
+  autoUpdaterRemoveListenerMock: vi.fn(),
   exitMock: vi.fn(),
   getAppPathMock: vi.fn(() => "/app"),
   getVersionMock: vi.fn(() => "1.2.3"),
@@ -43,6 +47,10 @@ const {
 }));
 
 vi.mock("electron", () => ({
+  autoUpdater: {
+    on: autoUpdaterOnMock,
+    removeListener: autoUpdaterRemoveListenerMock,
+  },
   app: {
     commandLine: {
       appendSwitch: appendSwitchMock,
@@ -77,6 +85,8 @@ import * as ElectronApp from "./ElectronApp.ts";
 describe("ElectronApp", () => {
   beforeEach(() => {
     appendSwitchMock.mockClear();
+    autoUpdaterOnMock.mockClear();
+    autoUpdaterRemoveListenerMock.mockClear();
     exitMock.mockClear();
     onMock.mockClear();
     quitMock.mockClear();
@@ -153,4 +163,22 @@ describe("ElectronApp", () => {
       assert.deepEqual(removeListenerMock.mock.calls, [["activate", listener]]);
     }).pipe(Effect.provide(ElectronApp.layer)),
   );
+
+  it.effect("scopes native updater quit listeners", () =>
+    Effect.gen(function* () {
+      const listener = vi.fn();
+
+      yield* Effect.scoped(
+        Effect.gen(function* () {
+          const electronApp = yield* ElectronApp.ElectronApp;
+          yield* electronApp.onBeforeQuitForUpdate(listener);
+        }),
+      );
+
+      assert.deepEqual(autoUpdaterOnMock.mock.calls, [["before-quit-for-update", listener]]);
+      assert.deepEqual(autoUpdaterRemoveListenerMock.mock.calls, [
+        ["before-quit-for-update", listener],
+      ]);
+    }).pipe(Effect.provide(ElectronApp.layer)),
+  );
 });

apps/desktop/src/electron/ElectronApp.ts

@@ -66,6 +66,9 @@ export class ElectronApp extends Context.Service<
     readonly setDesktopName: (desktopName: string) => Effect.Effect<void>;
     readonly setDockIcon: (iconPath: string) => Effect.Effect<void>;
     readonly appendCommandLineSwitch: (switchName: string, value?: string) => Effect.Effect<void>;
+    readonly onBeforeQuitForUpdate: (
+      listener: () => void,
+    ) => Effect.Effect<void, never, Scope.Scope>;
     readonly on: <Args extends ReadonlyArray<unknown>>(
       eventName: string,
       listener: (...args: Args) => void,
@@ -178,6 +181,16 @@ export const make = ElectronApp.of({
       }
       Electron.app.commandLine.appendSwitch(switchName, value);
     }),
+  onBeforeQuitForUpdate: (listener) =>
+    Effect.acquireRelease(
+      Effect.sync(() => {
+        Electron.autoUpdater.on("before-quit-for-update", listener);
+      }),
+      () =>
+        Effect.sync(() => {
+          Electron.autoUpdater.removeListener("before-quit-for-update", listener);
+        }),
+    ).pipe(Effect.asVoid),
   on: addScopedAppListener,
 });
 

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

@@ -18,6 +18,7 @@ const clientSettings: ClientSettings = {
   confirmThreadDelete: false,
   dismissedProviderUpdateNotificationKeys: [],
   diffIgnoreWhitespace: true,
+  environmentIdentificationMode: "artwork",
   favorites: [],
   glassOpacity: 80,
   providerModelPreferences: {},
@@ -30,6 +31,7 @@ const clientSettings: ClientSettings = {
   sidebarThreadSortOrder: "created_at",
   sidebarThreadPreviewCount: 6,
   sidebarV2Enabled: false,
+  sidebarV2ConfiguredByUser: false,
   timestampFormat: "24-hour",
   wordWrap: true,
 };

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

@@ -45,6 +45,7 @@ const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, {
   setDesktopName: () => Effect.void,
   setDockIcon: () => Effect.void,
   appendCommandLineSwitch: () => Effect.void,
+  onBeforeQuitForUpdate: () => Effect.void,
   on: () => Effect.void,
 } satisfies ElectronApp.ElectronApp["Service"]);
 

apps/mobile/src/Stack.tsx

@@ -47,7 +47,6 @@ import { SettingsAuthRouteScreen } from "./features/settings/SettingsAuthRouteSc
 import { SettingsEnvironmentsRouteScreen } from "./features/settings/SettingsEnvironmentsRouteScreen";
 import { SettingsLegalRouteScreen } from "./features/settings/SettingsLegalRouteScreen";
 import { SettingsRouteScreen } from "./features/settings/SettingsRouteScreen";
-import { SettingsWaitlistRouteScreen } from "./features/settings/SettingsWaitlistRouteScreen";
 import { ShowcaseCaptureCoordinator } from "./features/showcase/ShowcaseCaptureCoordinator";
 import {
   SettingsLegalDocumentCloseHeaderButton,
@@ -190,10 +189,11 @@ const SettingsSheetStack = createNativeStackNavigator({
       },
     }),
     SettingsWaitlist: createNativeStackScreen({
-      screen: SettingsWaitlistRouteScreen,
+      // Keep the old deep link working after the Connect GA launch.
+      screen: SettingsAuthRouteScreen,
       linking: "waitlist",
       options: {
-        title: "Join the waitlist",
+        title: "Sign in",
       },
     }),
   },