chore(v2): merge main into the V2 branch (48 commits)

.github/triage/PLAYBOOK.md

@@ -59,8 +59,9 @@ different code depending on it:
 
 Then work from evidence, not assumption. In rough order of value:
 
-- The server log and the trace file (`server.trace.ndjson`) around the time of the
-  problem. Recent failures usually leave a trail here.
+- The trace file (`server.trace.ndjson`) around the time of the problem, plus the
+  service log or desktop backend logs from the context file if they exist. Recent
+  failures usually leave a trail here.
 - The provider event log, for problems with claude/codex/cursor sessions.
 - The SQLite database. Read it freely, but only write when a write is necessary
   to fix the problem the user described, and get their explicit permission

.github/workflows/release-desktop.yml

@@ -510,6 +510,7 @@ jobs:
             "release/*.dmg"
             "release/*.zip"
             "release/*.AppImage"
+            "release/*.deb"
             "release/*.exe"
           )
           # Preview builds have no publish config, so electron-builder writes

.github/workflows/release.yml

@@ -625,7 +625,7 @@ jobs:
       clerk_cli_oauth_client_id: ${{ needs.relay_public_config.outputs.clerk_cli_oauth_client_id }}
       relay_url: ${{ needs.relay_public_config.outputs.relay_url }}
       label: Linux arm64
-      runner: ubuntu-24.04-arm
+      runner: blacksmith-16vcpu-ubuntu-2404-arm
       platform: linux
       target: AppImage
       arch: arm64
@@ -875,6 +875,7 @@ jobs:
             echo 'release-assets/*.dmg'
             echo 'release-assets/*.zip'
             echo 'release-assets/*.AppImage'
+            echo 'release-assets/*.deb'
             echo 'release-assets/*.exe'
             if [[ "${{ needs.preflight.outputs.release_channel }}" != "preview" ]]; then
               echo 'release-assets/*.blockmap'

README.md

@@ -54,6 +54,14 @@ winget install T3Tools.T3Code
 brew install --cask t3-code
 ```
 
+#### Debian, Ubuntu (`.deb`)
+
+Download the `.deb` from [GitHub Releases](https://github.com/pingdotgg/t3code/releases), then:
+
+```bash
+sudo apt install ./T3-Code-*.deb
+```
+
 #### Arch Linux (AUR)
 
 Stable:

apps/desktop/package.json

@@ -3,7 +3,7 @@
   "version": "0.0.42",
   "private": true,
   "type": "module",
-  "main": "dist-electron/main.cjs",
+  "main": "dist-electron/boot.cjs",
   "scripts": {
     "ensure:electron": "node scripts/ensure-electron-runtime.mjs",
     "start": "node scripts/start-electron.mjs",

apps/desktop/scripts/main-process-bundle.test.mjs

@@ -1,3 +1,4 @@
+import * as NodeChildProcess from "node:child_process";
 import * as NodeFSP from "node:fs/promises";
 import * as NodeOS from "node:os";
 import * as NodePath from "node:path";
@@ -108,3 +109,65 @@ void import("./linux.ts").then(({ result }) => process.emit("ready", result));`,
     await NodeFSP.rm(directory, { recursive: true, force: true });
   }
 });
+
+it("loads the emitted packaged boot entry and backend cache preload", async () => {
+  const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-desktop-boot-"));
+  try {
+    const entries = ["src/boot.ts", "src/compileCache.ts"];
+    await NodeFSP.mkdir(NodePath.join(directory, "src"));
+    await Promise.all(
+      entries.map((entry) =>
+        NodeFSP.copyFile(new URL(`../${entry}`, import.meta.url), NodePath.join(directory, entry)),
+      ),
+    );
+    assert.ok(Array.isArray(desktopConfig.pack));
+    for (const packConfig of desktopConfig.pack) {
+      if (!Array.isArray(packConfig.entry)) continue;
+      if (!packConfig.entry.some((entry) => entries.includes(entry))) continue;
+      await build({
+        ...packConfig,
+        config: false,
+        cwd: directory,
+        tsconfig: false,
+        sourcemap: false,
+        onSuccess: undefined,
+        logLevel: "silent",
+      });
+    }
+    const outputDirectory = NodePath.join(directory, "dist-electron");
+    const fixture = `console.log(require('node:module').getCompileCacheDir() ? 'cached' : 'uncached');`;
+    await NodeFSP.writeFile(NodePath.join(outputDirectory, "main.cjs"), fixture);
+    await NodeFSP.writeFile(
+      NodePath.join(outputDirectory, "backend.mjs"),
+      `import { getCompileCacheDir } from 'node:module'; console.log(getCompileCacheDir() ? 'cached' : 'uncached');`,
+    );
+    for (const disabled of [false, true]) {
+      for (const args of [
+        [NodePath.join(outputDirectory, "boot.cjs")],
+        [
+          "--require",
+          NodePath.join(outputDirectory, "compileCache.cjs"),
+          NodePath.join(outputDirectory, "backend.mjs"),
+        ],
+      ]) {
+        const child = NodeChildProcess.spawnSync(process.execPath, args, {
+          encoding: "utf8",
+          env: {
+            ...process.env,
+            APPIMAGE: "",
+            NODE_COMPILE_CACHE: undefined,
+            NODE_DISABLE_COMPILE_CACHE: disabled ? "1" : undefined,
+            XDG_CACHE_HOME: directory,
+            TMPDIR: directory,
+            TEMP: directory,
+            TMP: directory,
+          },
+        });
+        assert.equal(child.status, 0, child.stderr);
+        assert.equal(child.stdout.trim(), disabled ? "uncached" : "cached");
+      }
+    }
+  } finally {
+    await NodeFSP.rm(directory, { recursive: true, force: true });
+  }
+});

apps/desktop/scripts/smoke-test.mjs

@@ -5,7 +5,7 @@ import { resolveElectronLaunchCommand } from "./electron-launcher.mjs";
 
 const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));
 const desktopDir = NodePath.resolve(__dirname, "..");
-const mainJs = NodePath.resolve(desktopDir, "dist-electron/main.cjs");
+const mainJs = NodePath.resolve(desktopDir, "dist-electron/boot.cjs");
 
 console.log("\nLaunching Electron smoke test...");
 

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

@@ -44,6 +44,25 @@ function request(requestId: string, platform: NodeJS.Platform): DesktopAppActiva
   };
 }
 
+function startOkServer(target: ReturnType<typeof makeTarget>, userId: number | undefined) {
+  return startDesktopAppControlServer({
+    ...target,
+    userId,
+    handle: async (input) => ({
+      version: 1,
+      requestId: input.requestId,
+      ok: true,
+      projectId: ProjectId.make("project-1"),
+      threadId: ThreadId.make("thread-1"),
+    }),
+    cancel: () => undefined,
+    onReclaimError: () => undefined,
+  }).then((server) => {
+    openServers.push(server);
+    return server;
+  });
+}
+
 function exchange(address: string, payload: DesktopAppActivationRequest) {
   return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
     const socket = NodeNet.createConnection(address);
@@ -84,6 +103,7 @@ describe("desktop app control server", () => {
             };
           },
           cancel: () => undefined,
+          onReclaimError: () => undefined,
         });
         openServers.push(server);
 
@@ -117,6 +137,7 @@ describe("desktop app control server", () => {
           userId,
           handle: () => new Promise(() => undefined),
           cancel: resolveCanceled,
+          onReclaimError: () => undefined,
         });
         openServers.push(server);
         const socket = NodeNet.createConnection(target.address);
@@ -137,4 +158,50 @@ describe("desktop app control server", () => {
       });
     }),
   );
+
+  // Two desktop apps can share one state dir, such as nightly and a preview build.
+  it.effect("keeps a newer app's socket when an older app on the same state dir quits", () =>
+    Effect.gen(function* () {
+      const platform = yield* HostProcessPlatform;
+      const userId = yield* HostProcessUserId;
+      if (platform === "win32") return;
+      yield* Effect.promise(async () => {
+        const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-takeover-test-"));
+        const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+        const older = await startOkServer(target, userId);
+        await startOkServer(target, userId);
+
+        await older.close();
+
+        await expect(
+          exchange(target.address, request("after-quit", platform)),
+        ).resolves.toMatchObject({ ok: true, requestId: "after-quit" });
+        await NodeFSP.rm(root, { recursive: true, force: true });
+      });
+    }),
+  );
+
+  it.effect("binds its address again after the socket file is removed", () =>
+    Effect.gen(function* () {
+      const platform = yield* HostProcessPlatform;
+      const userId = yield* HostProcessUserId;
+      if (platform === "win32") return;
+      yield* Effect.promise(async () => {
+        const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-reclaim-test-"));
+        const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+        const server = await startOkServer(target, userId);
+
+        await NodeFSP.unlink(target.address);
+        await server.reclaim();
+
+        await expect(
+          exchange(target.address, request("reclaimed", platform)),
+        ).resolves.toMatchObject({
+          ok: true,
+          requestId: "reclaimed",
+        });
+        await NodeFSP.rm(root, { recursive: true, force: true });
+      });
+    }),
+  );
 });