Created a nix flake of t3code

[Sawrz]

As a Nixos user, I wanted this lovely application to work nicely on my system. It was important to me to be able to make it declarative. Hence, I created a flake to make this possible. I'm still ironing things out but I was able to install the desktop version (AppImage) on my system and make it discoverable with launchers. I'm still working on the t3 (local browser) version and I want be able to provide it on arm as well for darwin-nix users.

Here is the link: https://github.com/Sawrz/t3code-nix

@t3dotgg @juliusmarminge If you want to provide the flake by yourself and maintain it, I don't mind and would transfer the repo to you guys. The only thing I care, is to use this lovely application on my system =)

Thank you for making t3code open-source and allowing other developers increasing their productivity. Today is like christmas and I'm five again!

[jakob1379]

I mashed this together and have been using it without issue for about a month. I never noticed there should be a desktop version as I only really care for web-based apps for remote hosting :)

Original snippet

clone repo and add the flake there,

{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  };

  outputs =
    { nixpkgs, ... }:
    let
      lib = nixpkgs.lib;
      systems = [
        "x86_64-linux"
        "aarch64-linux"
        "x86_64-darwin"
        "aarch64-darwin"
      ];
      forAllSystems = lib.genAttrs systems;
      version = "0.0.15";
      mkT3code =
        pkgs:
        let
          src = pkgs.fetchFromGitHub {
            owner = "pingdotgg";
            repo = "t3code";
            rev = "f82bae16680206e4be20baf3d835941aa68611cf";
            hash = "sha256-HOPiA8X/FzswKGmOuYKog3YIn5iq5rJ/7kDoGhN11x0=";
          };
          nodeModules = pkgs.stdenvNoCC.mkDerivation {
            pname = "t3code-node_modules";
            inherit version;
            inherit src;

            strictDeps = true;

            nativeBuildInputs = [
              pkgs.bun
              pkgs.nodejs
              pkgs.writableTmpDirAsHomeHook
            ];

            dontConfigure = true;
            dontFixup = true;

            postPatch = ''
              for packageJson in \
                packages/contracts/package.json \
                packages/shared/package.json
              do
                substituteInPlace "$packageJson" \
                  --replace-fail '"prepare": "effect-language-service patch",' '"prepare": "true",'
              done
            '';

            buildPhase = ''
              runHook preBuild

              bun install \
                --ignore-scripts \
                --no-progress \
                --frozen-lockfile \
                --filter ./apps/server \
                --filter ./apps/web \
                --filter ./packages/contracts \
                --filter ./packages/shared

              runHook postBuild
            '';

            installPhase = ''
              runHook preInstall

              mkdir -p "$out"
              find . -type d -name node_modules -exec cp -R --parents {} "$out" \;

              runHook postInstall
            '';

            outputHash = "sha256-cOI7vID7tqLQMUJ2iUH4fOQI2EBZwu8T3tax6Y3UTkQ=";
            outputHashAlgo = "sha256";
            outputHashMode = "recursive";
          };
        in
        pkgs.stdenv.mkDerivation {
          pname = "t3code";
          inherit version;
          inherit src;

          strictDeps = true;

          nativeBuildInputs = [
            pkgs.bun
            pkgs.makeBinaryWrapper
            pkgs.node-gyp
            pkgs.nodejs
            pkgs.python3
            pkgs.writableTmpDirAsHomeHook
          ];

          configurePhase = ''
            runHook preConfigure

            cp -R ${nodeModules}/. .

            chmod -R u+rwX node_modules
            patchShebangs node_modules

            cd node_modules/.bun/node-pty@*/node_modules/node-pty
            node-gyp rebuild
            node scripts/post-install.js
            cd "$NIX_BUILD_TOP/$sourceRoot"

            runHook postConfigure
          '';

          buildPhase = ''
            runHook preBuild

            bun run --cwd apps/web build
            bun run --cwd apps/server build

            runHook postBuild
          '';

          installPhase = ''
            runHook preInstall

            mkdir -p "$out/libexec/t3code/apps/server"
            cp -R --no-preserve=mode node_modules "$out/libexec/t3code/"
            cp -R --no-preserve=mode apps/server/{node_modules,dist} "$out/libexec/t3code/apps/server/"

            rm -f \
              "$out/libexec/t3code/apps/server/node_modules/@t3tools/contracts" \
              "$out/libexec/t3code/apps/server/node_modules/@t3tools/shared" \
              "$out/libexec/t3code/apps/server/node_modules/@t3tools/web"

            for wsDir in "$out"/libexec/t3code/node_modules/.bun/ws@*/node_modules/ws; do
              ln -s "$wsDir" "$out/libexec/t3code/apps/server/node_modules/ws"
              break
            done

            makeWrapper ${lib.getExe pkgs.nodejs} "$out/bin/t3" \
              --add-flags "$out/libexec/t3code/apps/server/dist/index.mjs"

            runHook postInstall
          '';
        };
    in
    {
      packages = forAllSystems (
        system:
        let
          pkgs = import nixpkgs { inherit system; };
        in
        {
          t3code = mkT3code pkgs;
        }
      );
    };
}

I then made an alternative flake, just to experiment which I try to add options to enable more binaries like gitlab, jujutsu etc. using options:
https://github.com/jakob1379/t3code-flake

t3code.override {
    enableClaude = true;
    enableJujutsu = true;
    enableAzureDevOps = true;
  }

[daef]

bump to 0.23: flake.nix

slight changes required due to updated project structure...:

17c17
<       version = "0.0.15";
---
>       version = "0.0.23";
24,25c24,25
<             rev = "f82bae16680206e4be20baf3d835941aa68611cf";
<             hash = "sha256-HOPiA8X/FzswKGmOuYKog3YIn5iq5rJ/7kDoGhN11x0=";
---
>             rev = "3c32bc8fd1f5970e65988e36937cb8e2921437f9";
>             hash = "sha256-gsDHogGnzKVwypGwK1PzYBXpBYBFQHIbXMpWVUGzKU8=";
44,50c44,45
<               for packageJson in \
<                 packages/contracts/package.json \
<                 packages/shared/package.json
<               do
<                 substituteInPlace "$packageJson" \
<                   --replace-fail '"prepare": "effect-language-service patch",' '"prepare": "true",'
<               done
---
>               substituteInPlace package.json \
>                 --replace-fail '"prepare": "effect-language-service patch",' '"prepare": "true",'
77c72
<             outputHash = "sha256-cOI7vID7tqLQMUJ2iUH4fOQI2EBZwu8T3tax6Y3UTkQ=";
---
>             outputHash = "sha256-svScvB0DghRgueH7PiwF4ML9PBcFRyWQpeNz/odJSZY=";
133c128,131
<               "$out/libexec/t3code/apps/server/node_modules/@t3tools/web"
---
>               "$out/libexec/t3code/apps/server/node_modules/@t3tools/tailscale" \
>               "$out/libexec/t3code/apps/server/node_modules/@t3tools/web" \
>               "$out/libexec/t3code/apps/server/node_modules/effect-acp" \
>               "$out/libexec/t3code/apps/server/node_modules/effect-codex-app-server"
141c139
<               --add-flags "$out/libexec/t3code/apps/server/dist/index.mjs"
---
>               --add-flags "$out/libexec/t3code/apps/server/dist/bin.mjs"

[jakob1379]

@daef its patched in both flake repos :)

[SINGH-RAJVEER]

Following up from #15278, which got pointed here. I went through the release workflow to see what an in-repo flake would actually take. Stable is close to free. Nightly is the part that needs a decision from you.

The approach is the same one the AUR packages use. The flake wraps the AppImages the release already publishes for x86_64 and aarch64 with appimageTools.wrapType2, so nothing gets built from source. Versions and hashes live in one generated file, packaging/nix/sources.json, and the flake exposes packages.default for stable and packages.nightly for nightly. Users add github:pingdotgg/t3code as an input once and pick up new releases with nix flake update. The downstream nixpkgs package stays as it is. This is for people who want a release the day it ships.

It also answers the maintenance concern that closed #4699. Once the release workflow writes the hashes, nobody has to touch the flake by hand, the same as t3code-bin on the AUR today.

Why a flake needs a post-release commit

A flake can only fetch a release asset if its hash is pinned in the repo. The tag is cut before the AppImages exist, so the tagged commit can't contain their hashes. Something has to commit them to main after the release is published.

Stable

The finalize job already does this. After every stable release it mints the release app token and pushes a chore(release): prepare vX commit to main. Writing the stable entry of sources.json in that same commit means no new job, no new secret and no extra commit.

The app already behaves correctly when installed this way. DesktopUpdates.ts turns off auto-update on Linux unless the app runs as an AppImage or .deb. The wrapper can also set T3CODE_DISABLE_AUTO_UPDATE=1 to make that explicit.

Nightly

This is where it gets awkward.

1. Nightlies never push to main. Keeping packages.nightly current means a bot commit to main every day a nightly ships.
2. Stable and nightly run in separate concurrency groups, so both could write sources.json at once. The commit step would need a rebase-and-retry or a concurrency group of its own.
3. SHA256SUMS only covers the CLI archives, so the bot has to download each AppImage to hash it. That works, but adding the desktop artifacts to SHA256SUMS would let it read the hashes instead.

I didn't find anything that deletes old nightly releases, so an old flake.lock keeps building.

Options for nightly

• Commit to main daily. Simplest for users, noisiest for history.
• Have the bot keep the flake and sources.json on a dedicated nix branch, for both channels. Users write github:pingdotgg/t3code/nix, still a single input, and main never sees a bot commit.
• Ship stable only for now and revisit nightly later.

I'd lean toward the nix branch if daily commits to main are a no.

One cheap extra. Releases already ship the headless server as t3-<version>-linux-x64.tar.gz, covered by SHA256SUMS, so a packages.t3 output for NixOS remote hosts costs almost nothing.

If one of these works for you, I can open the PR.