chore(rtvision): sync upstream main and prepare 0.0.74

.coderabbit.config.ts

@@ -1,21 +1,7 @@
 import { defineConfig, type CodeRabbitContext } from "@coderabbitai/config";
 
-const approvability = `Fail when a maintainer should read this pull request before CodeRabbit approves it, and name the rule and file. Fail if it:
-
-- Changes a product default: a setting's default value, or what users get without opting in. Making a feature do what it already promises is a bug fix, not a default change.
-- Adds or broadens a directive that disables or suppresses a lint, type-checker, LSP, or other static-analysis diagnostic, including file-level, line-level, and configuration-level overrides.
-- Adds a subsystem or user workflow, or is a large refactor across apps or packages.
-- Changes packages/contracts or persisted data in a way that existing clients or stored data might not accept.
-- Changes authentication, pairing, credentials, secrets, or remote connection trust.
-- Adds or changes an external side effect, such as acting on GitHub, publishing a release, or calling a webhook.
-- Adds, upgrades, or patches a dependency.
-- Changes CI or release configuration, agent or contributor instructions, or any review tool's configuration, including .github/, AGENTS.md, CONTRIBUTING.md, .agents/, and .coderabbit.config.ts.
-
-Otherwise pass. A focused bug fix, copy or layout fix, revert, or docs-only or test-only change passes unless a rule above applies. If you cannot decide, fail rather than report inconclusive. When failing, say that the pull request needs a maintainer's review.
-`;
-
 // Org members and collaborators merge their own pull requests. On anyone else's, CodeRabbit
-// requests changes until its comments are resolved and its checks pass, then approves.
+// requests changes until its comments are resolved, then approves.
 const UNGATED_AUTHORS = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
 const isGated = ({ pr }: CodeRabbitContext) => !UNGATED_AUTHORS.has(pr?.authorAssociation ?? "");
 
@@ -31,13 +17,6 @@ export default defineConfig((ctx) => ({
     pre_merge_checks: {
       docstrings: { mode: "off" },
       override_requested_reviewers_only: isGated(ctx),
-      custom_checks: [
-        {
-          name: "Approvability",
-          mode: isGated(ctx) ? "error" : "off",
-          instructions: approvability,
-        },
-      ],
     },
     path_filters: [
       // Vendored read-only reference checkouts of upstream Effect and Alchemy

apps/desktop/package.json

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

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

@@ -0,0 +1,246 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
+
+import * as DesktopCliCommand from "./DesktopCliCommand.ts";
+import * as DesktopCliShim from "./DesktopCliShim.ts";
+import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+
+const environmentFor = (
+  path: Path.Path,
+  input: { home: string; baseDir: string; platform?: NodeJS.Platform; isPackaged?: boolean },
+) =>
+  DesktopEnvironment.DesktopEnvironment.of({
+    path,
+    platform: input.platform ?? "linux",
+    isPackaged: input.isPackaged ?? true,
+    homeDirectory: input.home,
+    baseDir: input.baseDir,
+    stateDir: path.join(input.baseDir, "userdata"),
+    serverRoot: "/opt/T3 Code/resources/app.asar",
+    appImagePath: Option.none(),
+  } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]);
+
+/** The service for a packaged app; the launcher is written on Install. */
+const commandIn = (
+  input: { home: string; baseDir?: string; platform?: NodeJS.Platform; isPackaged?: boolean },
+  spawner?: ChildProcessSpawner.ChildProcessSpawner["Service"],
+) =>
+  Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const fs = yield* FileSystem.FileSystem;
+    const baseDir = input.baseDir ?? path.join(input.home, ".t3");
+    yield* fs.makeDirectory(path.join(baseDir, "userdata"), { recursive: true });
+    const make = DesktopCliCommand.make.pipe(
+      Effect.provideService(
+        DesktopEnvironment.DesktopEnvironment,
+        environmentFor(path, { ...input, baseDir }),
+      ),
+    );
+    return yield* spawner
+      ? make.pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner))
+      : make;
+  });
+
+/** A PowerShell that keeps the user's PATH in memory and can be told to fail reads. */
+const fakePowerShell = (initial: string) => {
+  const registry = { path: initial, failReads: false, writes: 0 };
+  const spawner = ChildProcessSpawner.make((command) =>
+    Effect.sync(() => {
+      const { options } = command as unknown as {
+        readonly options: { readonly env?: Record<string, string> };
+      };
+      const env = options.env ?? {};
+      let exitCode = 0;
+      let stdout = "";
+      if (env.T3_SET === "1") {
+        registry.path = env.T3_PATH ?? "";
+        registry.writes += 1;
+      } else if (registry.failReads) {
+        exitCode = 1;
+      } else {
+        stdout = Buffer.from(registry.path, "utf8").toString("base64");
+      }
+      return ChildProcessSpawner.makeHandle({
+        pid: ChildProcessSpawner.ProcessId(1),
+        exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(exitCode)),
+        isRunning: Effect.succeed(false),
+        kill: () => Effect.void,
+        unref: Effect.succeed(Effect.void),
+        stdin: Sink.drain,
+        stdout: Stream.make(new TextEncoder().encode(stdout)),
+        stderr: Stream.empty,
+        all: Stream.empty,
+        getInputFd: () => Sink.drain,
+        getOutputFd: () => Stream.empty,
+      });
+    }),
+  );
+  return { registry, spawner };
+};
+
+it.layer(NodeServices.layer)("DesktopCliCommand", (it) => {
+  it.effect("links the launcher onto PATH and removes only that link", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const home = yield* fs.makeTempDirectoryScoped();
+      const command = yield* commandIn({ home });
+      const link = path.join(home, ".local", "bin", "t3");
+
+      expect(yield* command.state).toEqual({ supported: true, installedPath: null, onPath: false });
+      // Install writes the launcher itself, even when no local backend ever did.
+      const installed = yield* command.install;
+      expect(installed.installedPath).toBe(link);
+      expect(yield* fs.readLink(link)).toBe(path.join(home, ".t3", "bin", "t3"));
+      expect((yield* command.install).installedPath).toBe(link);
+
+      expect((yield* command.uninstall).installedPath).toBeNull();
+      expect(yield* fs.exists(link)).toBe(false);
+      // The launcher itself stays for setup commands.
+      expect(yield* fs.exists(path.join(home, ".t3", "bin", "t3"))).toBe(true);
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("never replaces or removes a t3 it did not create", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const home = yield* fs.makeTempDirectoryScoped();
+      const command = yield* commandIn({ home });
+      const theirs = path.join(home, ".local", "bin", "t3");
+      yield* fs.makeDirectory(path.dirname(theirs), { recursive: true });
+      yield* fs.writeFileString(theirs, "npm's t3\n");
+      // Even a broken link in the next folder is someone else's.
+      yield* fs.makeDirectory(path.join(home, "bin"), { recursive: true });
+      yield* fs.symlink(path.join(home, "gone"), path.join(home, "bin", "t3"));
+
+      const error = yield* Effect.flip(command.install);
+      expect(error.message).toContain("Another t3 command is already installed");
+      yield* command.uninstall;
+      expect(yield* fs.readFileString(theirs)).toBe("npm's t3\n");
+      expect(yield* fs.readLink(path.join(home, "bin", "t3"))).toBe(path.join(home, "gone"));
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("finds and removes a link left by a previous T3 home", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const home = yield* fs.makeTempDirectoryScoped();
+      const before = yield* commandIn({ home, baseDir: path.join(home, "old-t3") });
+      const link = (yield* before.install).installedPath;
+
+      const after = yield* commandIn({ home, baseDir: path.join(home, "new-t3") });
+      expect((yield* after.state).installedPath).toBe(link);
+      // Installing again points the link at this home's launcher.
+      expect((yield* after.install).installedPath).toBe(link);
+      expect(yield* fs.readLink(link!)).toBe(path.join(home, "new-t3", "bin", "t3"));
+      yield* after.uninstall;
+      expect(yield* fs.exists(path.join(home, ".local", "bin", "t3"))).toBe(false);
+      expect(yield* fs.exists(path.join(home, "bin", "t3"))).toBe(false);
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("does not read a large binary another t3 links to", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const home = yield* fs.makeTempDirectoryScoped();
+      // A big executable that happens to contain the marker text is still not ours.
+      const binary = path.join(home, "native-t3");
+      yield* fs.writeFileString(binary, `${"\0".repeat(64 * 1024)}${DesktopCliShim.MARKER}`);
+      yield* fs.makeDirectory(path.join(home, ".local", "bin"), { recursive: true });
+      yield* fs.symlink(binary, path.join(home, ".local", "bin", "t3"));
+      const command = yield* commandIn({ home });
+      expect((yield* command.state).installedPath).toBeNull();
+      yield* command.uninstall;
+      expect(yield* fs.readLink(path.join(home, ".local", "bin", "t3"))).toBe(binary);
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("reports when another t3 earlier on PATH would run instead", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const home = yield* fs.makeTempDirectoryScoped();
+      const shadow = path.join(home, "shadow");
+      yield* fs.makeDirectory(shadow);
+      yield* fs.writeFileString(path.join(shadow, "t3"), "#!/bin/sh\n", { mode: 0o755 });
+      const previous = process.env.PATH;
+      process.env.PATH = [shadow, path.join(home, ".local", "bin")].join(":");
+      yield* Effect.addFinalizer(() => Effect.sync(() => (process.env.PATH = previous)));
+
+      const command = yield* commandIn({ home });
+      const installed = yield* command.install;
+      expect(installed.installedPath).toBe(path.join(home, ".local", "bin", "t3"));
+      expect(installed.onPath).toBe(false);
+      yield* fs.remove(path.join(shadow, "t3"));
+      expect((yield* command.state).onPath).toBe(true);
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("leaves the Windows PATH alone when it cannot be read", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const home = yield* fs.makeTempDirectoryScoped();
+      const userPath = "C:\\Users\\Me\\npm;%USERPROFILE%\\tools";
+      const { registry, spawner } = fakePowerShell(userPath);
+      const command = yield* commandIn({ home, platform: "win32" }, spawner);
+
+      registry.failReads = true;
+      const error = yield* Effect.flip(command.install);
+      expect(error.message).toContain("left unchanged");
+      expect(registry).toMatchObject({ path: userPath, writes: 0 });
+
+      registry.failReads = false;
+      const launcherDir = DesktopCliShim.launcherPath(
+        environmentFor(yield* Path.Path, { home, baseDir: `${home}/.t3`, platform: "win32" }),
+      ).replace(/[\\/]t3\.cmd$/, "");
+      const installed = yield* command.install;
+      expect(installed.installedPath).not.toBeNull();
+      // Adding the folder does not prove that npm or a machine command won't shadow it.
+      expect(installed.onPath).toBe(false);
+      expect(registry.path).toBe(`${userPath};${launcherDir}`);
+      yield* command.uninstall;
+      expect(registry.path).toBe(userPath);
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("does not claim or remove a Windows PATH entry the user added", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const home = yield* fs.makeTempDirectoryScoped();
+      const launcherDir = path.dirname(
+        DesktopCliShim.launcherPath(
+          environmentFor(path, { home, baseDir: path.join(home, ".t3"), platform: "win32" }),
+        ),
+      );
+      const userPath = `C:\\Tools;${launcherDir}`;
+      const { registry, spawner } = fakePowerShell(userPath);
+      const command = yield* commandIn({ home, platform: "win32" }, spawner);
+
+      expect((yield* command.state).installedPath).toBeNull();
+      yield* command.uninstall;
+      expect(registry.path).toBe(userPath);
+    }).pipe(Effect.scoped),
+  );
+
+  it.effect("offers nothing for a development build", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const command = yield* commandIn({
+        home: yield* fs.makeTempDirectoryScoped(),
+        isPackaged: false,
+      });
+      expect((yield* command.state).supported).toBe(false);
+    }).pipe(Effect.scoped),
+  );
+});