flake.nix

{
  description = "Nix dev shell for the Emdash Electron workspace";

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

  outputs = { self, nixpkgs, flake-utils, ... }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
        lib = pkgs.lib;
        nodejs = pkgs.nodejs_22;
        pnpm = pkgs.pnpm_10 or pkgs.pnpm;

        # Electron version must match package.json
        electronVersion = "30.5.1";

        # Pre-fetch Electron binary for Linux x64
        # electron-builder expects zips named: electron-v${version}-linux-x64.zip
        electronLinuxZip = pkgs.fetchurl {
          url = "https://github.com/electron/electron/releases/download/v${electronVersion}/electron-v${electronVersion}-linux-x64.zip";
          sha256 = "sha256-7EcHeD056GAF9CiZ4wrlnlDdXZx/KFMe1JTrQ/I2FAM=";
        };

        # Create a directory with the electron zip for electronDist
        electronDistDir = pkgs.runCommand "electron-dist" {} ''
          mkdir -p $out
          cp ${electronLinuxZip} $out/electron-v${electronVersion}-linux-x64.zip
        '';

        sharedEnv =
          [
            nodejs
            pkgs.git
            pkgs.python3
            pkgs.pkg-config
            pkgs.openssl
            pkgs.libtool
            pkgs.autoconf
            pkgs.automake
            pkgs.coreutils
          ]
          ++ lib.optionals pkgs.stdenv.isDarwin [
            pkgs.libiconv
          ]
          ++ lib.optionals pkgs.stdenv.isLinux [
            pkgs.libsecret
            pkgs.sqlite
            pkgs.zlib
            pkgs.libutempter
            pkgs.patchelf
          ];
        cleanSrc = lib.cleanSource ./.;
        emdashPackage =
          if pkgs.stdenv.isLinux then
            pkgs.stdenv.mkDerivation rec {
              pname = "emdash";
              version = "0.3.34";
              src = cleanSrc;
              pnpmDeps = pnpm.fetchDeps {
                inherit pname version src;
                hash = "sha256-9NDjQ8L1thkaoSvWm6s9Q9ubT9+oPpWfLDPAnvKsq7A=";
              };
              dontConfigure = true;

              nativeBuildInputs =
                sharedEnv
                ++ [
                  pnpm.configHook
                  pkgs.dpkg
                  pkgs.rpm
                ];
              buildInputs = [
                pkgs.libsecret
                pkgs.sqlite
                pkgs.zlib
                pkgs.libutempter
              ];
              env = {
                HOME = "$TMPDIR/emdash-home";
                npm_config_build_from_source = "true";
                # Skip Electron binary download during pnpm install
                ELECTRON_SKIP_BINARY_DOWNLOAD = "1";
              };

              buildPhase = ''
                runHook preBuild

                mkdir -p "$TMPDIR/emdash-home"

                # Build the app (renderer + main)
                pnpm run build

                # Run electron-builder with electronDist override to avoid download
                # Use --dir to only produce unpacked output (no AppImage/deb which require network)
                pnpm exec electron-builder --linux --dir \
                  -c.electronDist=${electronDistDir} \
                  -c.electronVersion=${electronVersion}

                runHook postBuild
              '';

              installPhase = ''
                runHook preInstall

                # electron-builder outputs to "release" directory (configured in package.json build.directories.output)
                distDir="$PWD/release"
                unpackedDir="$distDir/linux-unpacked"

                if [ ! -d "$unpackedDir" ]; then
                  echo "Expected linux-unpacked output from electron-builder, got nothing at $unpackedDir" >&2
                  exit 1
                fi

                install -d $out/share/emdash
                cp -R "$unpackedDir" $out/share/emdash/

                if ls "$distDir"/*.AppImage >/dev/null 2>&1; then
                  for image in "$distDir"/*.AppImage; do
                    install -Dm755 "$image" "$out/share/emdash/$(basename "$image")"
                  done
                fi

                install -d $out/bin
                cat <<EOF > $out/bin/emdash
#!${pkgs.bash}/bin/bash
set -euo pipefail

APP_ROOT="$out/share/emdash/linux-unpacked"
exec "\$APP_ROOT/emdash" "\$@"
EOF
                chmod +x $out/bin/emdash

                runHook postInstall
              '';

              meta = {
                description = "Emdash – multi-agent orchestration desktop app";
                homepage = "https://emdash.sh";
                license = lib.licenses.mit;
                platforms = [ "x86_64-linux" ];
              };
            }
          else
            pkgs.writeShellScriptBin "emdash" ''
              echo "The packaged Emdash app is currently only available for Linux when using Nix." >&2
              exit 1
            '';
      in {
        devShells.default = pkgs.mkShell {
          packages = sharedEnv;

          shellHook = ''
            echo "Emdash dev shell ready"
            echo "Node: $(node --version)"
            echo "Run 'pnpm run d' for the full dev loop."
          '';
        };

        packages.emdash = emdashPackage;
        packages.default = emdashPackage;

        apps.default = {
          type = "app";
          program = "${emdashPackage}/bin/emdash";
        };
      });
}