merge: sync upstream through 20a70420a (86 commits)

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -9,6 +9,7 @@ body:
     attributes:
       value: |
         Use this form for broken behavior, regressions, crashes, or reliability problems.
+        Feature requests belong in [Discussions](https://github.com/pingdotgg/t3code/discussions/categories/ideas).
         Search existing issues first and keep the report focused on one problem.
 
   - type: checkboxes

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Feature request
+    url: https://github.com/pingdotgg/t3code/discussions/categories/ideas
+    about: Suggest an improvement or new capability in Discussions.

CONTRIBUTING.md

@@ -4,7 +4,9 @@
 
 We are not actively accepting contributions right now.
 
-You can still open an issue or PR, but please do so knowing there is a high chance we close it, defer it forever, or never look at it.
+You can still report a bug or open a PR, but please do so knowing there is a high chance we close it, defer it forever, or never look at it.
+
+Feature requests and proposals belong in [Ideas discussions](https://github.com/pingdotgg/t3code/discussions/categories/ideas), not issues.
 
 If that sounds annoying, that is because it is. This project is still early and we are trying to keep scope, quality, and direction under control.
 
@@ -50,9 +52,9 @@ If the change depends on motion, timing, transitions, or interaction details, in
 
 If we have to guess what changed, we are much less likely to review it.
 
-## Issues First
+## Discuss Changes First
 
-If you are thinking about a non-trivial change, open an issue first.
+If you are thinking about a non-trivial change, start a discussion first. Issues are reserved for bug reports.
 
 That still does not mean we will want the PR, but it gives you a chance to avoid wasting your time.
 

README.md

@@ -113,6 +113,8 @@ Checkout their getting started guide for more information: https://viteplus.dev/
 vp i
 ```
 
-Read [CONTRIBUTING.md](./CONTRIBUTING.md) before opening an issue or PR.
+Read [CONTRIBUTING.md](./CONTRIBUTING.md) before reporting a bug or opening a PR.
+
+Have a feature request? Start an [Ideas discussion](https://github.com/pingdotgg/t3code/discussions/categories/ideas).
 
 Need support? Join the [Discord](https://discord.gg/jn4EGJjrvv).

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

@@ -40,6 +40,7 @@ const makeElectronAppLayer = (calls: ElectronAppCalls) =>
   Layer.succeed(ElectronApp.ElectronApp, {
     metadata: Effect.die("unexpected metadata read"),
     name: Effect.succeed("T3 Code"),
+    systemLocale: Effect.succeed("en-US"),
     whenReady: Effect.void,
     quit: Effect.void,
     exit: () => Effect.void,

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

@@ -21,6 +21,7 @@ describe("DesktopLifecycle", () => {
       const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, {
         metadata: Effect.die("unexpected metadata read"),
         name: Effect.succeed("T3 Code"),
+        systemLocale: Effect.succeed("en-US"),
         whenReady: Effect.void,
         quit: Effect.void,
         exit: () => Effect.void,

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

@@ -730,6 +730,84 @@ describe("DesktopBackendManager", () => {
     ),
   );
 
+  it.effect(
+    "re-probes readiness after the first budget expires while the backend is still alive",
+    () =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const requestUrls: Array<string> = [];
+          let requestCount = 0;
+          let readyCount = 0;
+          let readinessTimeoutCount = 0;
+          const firstProbe = yield* Deferred.make<void>();
+          const childExit = yield* Deferred.make<void>();
+
+          const spawnerLayer = Layer.succeed(
+            ChildProcessSpawner.ChildProcessSpawner,
+            ChildProcessSpawner.make(() =>
+              Effect.succeed(
+                makeProcess({
+                  exitCode: Deferred.await(childExit).pipe(
+                    Effect.as(ChildProcessSpawner.ExitCode(0)),
+                  ),
+                }),
+              ),
+            ),
+          );
+
+          // The backend stays 503 through the first *two* readiness budgets
+          // and only becomes healthy (200) for the third round, i.e. it comes
+          // up well after the initial 50ms budget has expired.
+          const httpLayer = httpClientLayer((request) =>
+            Effect.gen(function* () {
+              requestCount += 1;
+              requestUrls.push(request.url);
+              yield* Deferred.succeed(firstProbe, void 0);
+              return responseForRequest(request, requestCount <= 2 ? 503 : 200);
+            }),
+          );
+
+          const runFiber = yield* DesktopBackendManager.runBackendProcess({
+            ...baseConfig,
+            desktopTelemetryStream: Stream.empty,
+            readinessTimeout: Duration.millis(50),
+            onReady: () =>
+              Effect.sync(() => {
+                readyCount += 1;
+              }),
+            onReadinessFailure: () =>
+              Effect.sync(() => {
+                readinessTimeoutCount += 1;
+              }),
+          }).pipe(Effect.provide(Layer.merge(spawnerLayer, httpLayer)), Effect.forkChild);
+
+          yield* Deferred.await(firstProbe);
+          assert.equal(readyCount, 0);
+          assert.equal(readinessTimeoutCount, 0);
+
+          // The first 50ms readiness budget expires while the backend still
+          // answers 503. The child is alive and may yet become healthy, so the
+          // probe must start a fresh round instead of stopping permanently —
+          // the pre-fix behavior left the app stuck on "Connecting to WSL…"
+          // forever even though the backend kept running.
+          yield* TestClock.adjust(Duration.millis(50));
+          assert.equal(readinessTimeoutCount, 1);
+          assert.equal(readyCount, 0);
+
+          // The second budget also expires (backend still 503), then the third
+          // round connects. The point is the probe persisted across budgets
+          // while the process was alive instead of giving up after the first.
+          yield* TestClock.adjust(Duration.millis(100));
+          assert.equal(readinessTimeoutCount, 2);
+          assert.equal(readyCount, 1);
+          assert.equal(requestUrls.length, 3);
+
+          yield* Deferred.succeed(childExit, void 0);
+          assert.equal((yield* Fiber.join(runFiber)).code.pipe(Option.getOrUndefined), 0);
+        }).pipe(Effect.provide(TestClock.layer())),
+      ),
+  );
+
   it.effect("starts the configured backend and closes the scoped process on stop", () =>
     Effect.scoped(
       Effect.gen(function* () {

apps/desktop/src/backend/DesktopBackendManager.ts

@@ -592,20 +592,33 @@ export const runBackendProcess = Effect.fn("runBackendProcess")(function* (
       ).pipe(Effect.forkScoped),
     );
   }
-  yield* waitForHttpReady({
-    executablePath: options.executablePath,
-    entryPath: options.entryPath,
-    cwd: options.cwd,
-    httpBaseUrl: options.httpBaseUrl,
-    timeout: options.readinessTimeout ?? DEFAULT_BACKEND_READINESS_TIMEOUT,
-  }).pipe(
-    Effect.tap(() => options.onReady?.() ?? Effect.void),
-    Effect.catchTags({
-      BackendReadinessTimeoutError: (error) => options.onReadinessFailure?.(error) ?? Effect.void,
-    }),
-    Effect.forkScoped,
+  // Probe readiness in a loop while the backend process is still alive
+  // instead of giving up after the first budget. A slow cold boot (the
+  // WSL bundle loading across /mnt/c, or a first launch right after an
+  // update) can exceed the initial readiness budget while the backend is
+  // about to come up moments later; a one-shot probe left the app stuck
+  // on "Connecting to WSL…" forever even though the backend kept running
+  // and became healthy. Each round gets a fresh budget, and the forked
+  // loop is torn down with the run scope once the child exits.
+  const probeReadiness = Effect.fn("desktop.backendProcess.probeReadiness")(() =>
+    waitForHttpReady({
+      executablePath: options.executablePath,
+      entryPath: options.entryPath,
+      cwd: options.cwd,
+      httpBaseUrl: options.httpBaseUrl,
+      timeout: options.readinessTimeout ?? DEFAULT_BACKEND_READINESS_TIMEOUT,
+    }).pipe(
+      Effect.flatMap(() => options.onReady?.() ?? Effect.void),
+      Effect.as(true),
+      Effect.catchTags({
+        BackendReadinessTimeoutError: (error) =>
+          (options.onReadinessFailure?.(error) ?? Effect.void).pipe(Effect.as(false)),
+      }),
+    ),
   );
 
+  yield* probeReadiness().pipe(Effect.repeat({ while: (ready) => !ready }), Effect.forkScoped);
+
   const exit = yield* handle.exitCode.pipe(
     Effect.mapError(
       (cause) =>

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

@@ -8,6 +8,7 @@ const {
   autoUpdaterRemoveListenerMock,
   exitMock,
   getAppPathMock,
+  getSystemLocaleMock,
   getVersionMock,
   isDefaultProtocolClientMock,
   onMock,
@@ -30,6 +31,7 @@ const {
   autoUpdaterRemoveListenerMock: vi.fn(),
   exitMock: vi.fn(),
   getAppPathMock: vi.fn(() => "/app"),
+  getSystemLocaleMock: vi.fn(() => "en-GB"),
   getVersionMock: vi.fn(() => "1.2.3"),
   isDefaultProtocolClientMock: vi.fn(() => false),
   onMock: vi.fn(),
@@ -62,6 +64,7 @@ vi.mock("electron", () => ({
       setIcon: setDockIconMock,
     },
     getAppPath: getAppPathMock,
+    getSystemLocale: getSystemLocaleMock,
     getVersion: getVersionMock,
     isDefaultProtocolClient: isDefaultProtocolClientMock,
     isPackaged: true,
@@ -115,6 +118,23 @@ describe("ElectronApp", () => {
     }).pipe(Effect.provide(ElectronApp.layer)),
   );
 
+  it.effect("reads the OS locale through the service", () =>
+    Effect.gen(function* () {
+      const electronApp = yield* ElectronApp.ElectronApp;
+
+      assert.strictEqual(yield* electronApp.systemLocale, "en-GB");
+    }).pipe(Effect.provide(ElectronApp.layer)),
+  );
+
+  it.effect("normalizes POSIX-style locale identifiers that Intl rejects", () =>
+    Effect.gen(function* () {
+      getSystemLocaleMock.mockImplementationOnce(() => "en_GB");
+      const electronApp = yield* ElectronApp.ElectronApp;
+
+      assert.strictEqual(yield* electronApp.systemLocale, "en-GB");
+    }).pipe(Effect.provide(ElectronApp.layer)),
+  );
+
   it.effect("reports which app metadata property failed", () =>
     Effect.gen(function* () {
       const cause = new Error("version unavailable");

apps/desktop/src/electron/ElectronApp.ts

@@ -43,6 +43,13 @@ export class ElectronApp extends Context.Service<
   {
     readonly metadata: Effect.Effect<ElectronAppMetadata, ElectronAppMetadataReadError>;
     readonly name: Effect.Effect<string>;
+    /**
+     * The OS locale, read from the operating system rather than from Chromium's
+     * resolved application locale — the packaged app ships only the `en-US`
+     * locale pak, so `app.getLocale()` and the renderer's `Intl` default are
+     * pinned to `en-US` however the machine is configured.
+     */
+    readonly systemLocale: Effect.Effect<string>;
     readonly whenReady: Effect.Effect<void, ElectronAppWhenReadyError>;
     readonly quit: Effect.Effect<void>;
     readonly exit: (code: number) => Effect.Effect<void>;
@@ -120,6 +127,10 @@ export const make = ElectronApp.of({
     };
   }),
   name: Effect.sync(() => Electron.app.name),
+  // macOS derives this from NSLocale, which uses POSIX-style identifiers
+  // (`en_GB`). `Intl` rejects those outright rather than normalizing them, so
+  // the tag is normalized here rather than in the renderer that consumes it.
+  systemLocale: Effect.sync(() => Electron.app.getSystemLocale().replace(/_/g, "-")),
   whenReady: Effect.gen(function* () {
     const isPackaged = Electron.app.isPackaged;
     yield* Effect.tryPromise({

apps/desktop/src/ipc/DesktopIpcHandlers.ts

@@ -34,6 +34,7 @@ import {
   getAppBranding,
   getLocalEnvironmentBootstraps,
   getLocalEnvironmentBearerToken,
+  getSystemLocale,
   getWindowFullscreenState,
   openExternal,
   probeRemoteEditors,
@@ -55,6 +56,7 @@ export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers"
   yield* PreviewIpc.installPreviewEventForwarding();
 
   yield* ipc.handleSync(getAppBranding);
+  yield* ipc.handleSync(getSystemLocale);
   yield* ipc.handleSync(getWindowFullscreenState);
   yield* ipc.handleSync(getLocalEnvironmentBootstraps);
   yield* ipc.handle(getLocalEnvironmentBearerToken);