nix flake: completed modularization refactor

Author: Alb-O

.github/workflows/update-nix-hashes.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Update build output hashes
         run: |
           set -euo pipefail
-          script/nix/update-hashes
+          nix/scripts/update-hashes
 
       - name: Verification build (x86_64-linux)
         run: |
@@ -44,18 +44,18 @@ jobs:
           nix build .#packages.aarch64-linux.default --system aarch64-linux -L
           echo "aarch64-linux build successful."
 
-      - name: Commit flake.nix changes
+      - name: Commit Nix hash changes
         run: |
           set -euo pipefail
 
-          if git diff --quiet flake.nix; then
-            echo "No changes to flake.nix. Hash is already up to date."
+          if git diff --quiet flake.nix nix/node-modules.nix nix/models-dev.nix; then
+            echo "No changes to tracked Nix files. Hashes are already up to date."
             exit 0
           fi
 
           VERSION=$(jq -r '.version' packages/opencode/package.json)
-          git add flake.nix
-          git commit -m "nix: update output hashes for v$VERSION"
+          git add flake.nix nix/node-modules.nix nix/models-dev.nix
+          git commit -m "nix: update hashes for v$VERSION"
 
           git pull --rebase origin dev
           git push origin HEAD:dev

flake.nix

@@ -23,28 +23,13 @@
         "aarch64-linux" = "bun-linux-arm64";
         "x86_64-linux" = "bun-linux-x64";
       };
+      scripts = ./nix/scripts;
       modelsDev = forEachSystem (
         system:
         let
           pkgs = pkgsFor system;
         in
-        pkgs.stdenvNoCC.mkDerivation {
-          pname = "models-dev";
-          version = "unstable";
-
-          src = pkgs.fetchurl {
-            url = "https://models.dev/api.json";
-            hash = "sha256-Dff3OWJ7pD7LfVbZZ0Gf/QA65uw4ft14mdfBun0qDBg=";
-          };
-
-          dontUnpack = true;
-          dontBuild = true;
-
-          installPhase = ''
-            mkdir -p $out/dist
-            cp $src $out/dist/_api.json
-          '';
-        }
+        pkgs.callPackage ./nix/models-dev.nix { }
       );
     in
     {
@@ -70,299 +55,18 @@
         system:
         let
           pkgs = pkgsFor system;
+          mkNodeModules = pkgs.callPackage ./nix/node-modules.nix { };
+          mkPackage = pkgs.callPackage ./nix/opencode.nix { };
         in
         {
-          default = pkgs.callPackage (
-            {
-              lib,
-              stdenv,
-              stdenvNoCC,
-              bun,
-              makeBinaryWrapper,
-            }:
-            stdenvNoCC.mkDerivation (finalAttrs: {
-              pname = "opencode";
-              version = packageJson.version;
-
-              src = ./.;
-
-              node_modules =
-                let
-                  canonicalizeScript = ./script/nix/canonicalize-node-modules.ts;
-                in
-                stdenvNoCC.mkDerivation {
-                pname = "opencode-node_modules";
-                inherit (finalAttrs) version src;
-
-                impureEnvVars =
-                  lib.fetchers.proxyImpureEnvVars
-                  ++ [
-                    "GIT_PROXY_COMMAND"
-                    "SOCKS_SERVER"
-                  ];
-
-                nativeBuildInputs = [ bun pkgs.cacert pkgs.curl pkgs.python3 ];
-
-                dontConfigure = true;
-
-                buildPhase = ''
-                  runHook preBuild
-                  export HOME=$(mktemp -d)
-                  export BUN_INSTALL_CACHE_DIR=$(mktemp -d)
-                  bun install \
-                    --frozen-lockfile \
-                    --ignore-scripts \
-                    --no-progress
-
-                  cat > optional-packages.txt <<'EOF'
-@parcel/watcher-linux-arm64-glibc
-@opentui/core-linux-arm64
-EOF
-
-                  python3 <<'PY' > optional-metadata.txt
-import pathlib
-import re
-import sys
-
-lock = pathlib.Path("bun.lock").read_text()
-targets = [line.strip() for line in pathlib.Path("optional-packages.txt").read_text().splitlines() if line.strip()]
-
-for name in targets:
-    version_pattern = rf'"{re.escape(name)}": "([^"]+)"'
-    version_match = re.search(version_pattern, lock)
-    if not version_match:
-        print(f"missing-version\t{name}")
-        sys.exit(1)
-    version = version_match.group(1)
-    sha_pattern = rf'"{re.escape(name)}@{re.escape(version)}"[^\n]*"(sha512-[^"]+)"'
-    sha_match = re.search(sha_pattern, lock)
-    if not sha_match:
-        print(f"missing-sha\t{name}\t{version}")
-        sys.exit(1)
-    print(f"{name}\t{version}\t{sha_match.group(1)}")
-PY
-
-                  while IFS=$'\t' read -r name version sha; do
-                    [ -z "$name" ] && continue
-                    scope="''${name%%/*}"
-                    remainder="''${name#*/}"
-                    if [ "$scope" = "$name" ]; then
-                      scope=""
-                      remainder="$name"
-                    fi
-
-                    base="''${remainder##*/}"
-                    encoded_scope="''${scope//@/%40}"
-
-                    url="https://registry.npmjs.org/''${remainder}/-/''${base}-''${version}.tgz"
-                    dest="node_modules/''${remainder}"
-                    if [ -n "$scope" ]; then
-                      url="https://registry.npmjs.org/''${encoded_scope}/''${remainder}/-/''${base}-''${version}.tgz"
-                      dest="node_modules/''${scope}/''${remainder}"
-                    fi
-
-                    tmp=$(mktemp)
-                    curl --fail --location --silent --show-error --tlsv1.2 "$url" -o "$tmp"
-                    python3 - "$tmp" "$sha" <<'PY'
-import base64
-import hashlib
-import pathlib
-import sys
-
-path = pathlib.Path(sys.argv[1])
-expected = sys.argv[2]
-data = path.read_bytes()
-digest = base64.b64encode(hashlib.sha512(data).digest()).decode()
-if expected.startswith('sha512-'):
-    expected = expected.split('-', 1)[1]
-if digest != expected:
-    print(f"hash mismatch: expected {expected}, got {digest}", file=sys.stderr)
-    sys.exit(1)
-PY
-
-                    mkdir -p "$dest"
-                    tar -xzf "$tmp" -C "$dest" --strip-components=1 package
-                    rm -f "$tmp"
-                  done < optional-metadata.txt
-
-                  rm -f optional-packages.txt optional-metadata.txt
-
-                  cp ${canonicalizeScript} canonicalize-node-modules.ts
-                  bun --bun canonicalize-node-modules.ts
-                  rm -f canonicalize-node-modules.ts
-
-                  runHook postBuild
-                '';
-
-                installPhase = ''
-                  runHook preInstall
-                  mkdir -p $out
-                  while IFS= read -r dir; do
-                    rel="''${dir#./}"
-                    dest="$out/$rel"
-                    mkdir -p "$(dirname "$dest")"
-                    cp -R "$dir" "$dest"
-                  done < <(find . -type d -name node_modules -prune)
-                  runHook postInstall
-                '';
-
-                dontFixup = true;
-
-                outputHashAlgo = "sha256";
-                outputHashMode = "recursive";
-                outputHash = "sha256-s/UTz8BTYDOZpF9P6nZr0b7fNOS7Nv7hUfpihJgsSqE=";
-              };
-
-              nativeBuildInputs = [
-                bun
-                makeBinaryWrapper
-              ];
-
-              configurePhase = ''
-                runHook preConfigure
-                cp -R ${finalAttrs.node_modules}/. .
-                runHook postConfigure
-              '';
-
-              env.MODELS_DEV_API_JSON = "${modelsDev.${system}}/dist/_api.json";
-
-              buildPhase = ''
-                runHook preBuild
-
-                cat > bun-build.ts <<'EOF'
-                import solidPlugin from "./packages/opencode/node_modules/@opentui/solid/scripts/solid-plugin"
-                import path from "path"
-                import fs from "fs"
-
-                const version = "@VERSION@"
-                const repoRoot = process.cwd()
-                const packageDir = path.join(repoRoot, "packages/opencode")
-
-                const parserWorker = fs.realpathSync(
-                  path.join(packageDir, "./node_modules/@opentui/core/parser.worker.js"),
-                )
-                const dir = packageDir
-                const workerPath = "./src/cli/cmd/tui/worker.ts"
-                const target = process.env["BUN_COMPILE_TARGET"]
-
-                if (!target) {
-                  throw new Error("BUN_COMPILE_TARGET not set")
-                }
-
-                process.chdir(packageDir)
-
-                const result = await Bun.build({
-                  conditions: ["browser"],
-                  tsconfig: "./tsconfig.json",
-                  plugins: [solidPlugin],
-                  sourcemap: "external",
-                  entrypoints: ["./src/index.ts", parserWorker, workerPath],
-                  define: {
-                    OPENCODE_VERSION: `'@VERSION@'`,
-                    OTUI_TREE_SITTER_WORKER_PATH: "/$bunfs/root/" + path.relative(dir, parserWorker).replace(/\\/g, "/"),
-                    OPENCODE_CHANNEL: "'latest'",
-                  },
-                  compile: {
-                    target,
-                    outfile: "opencode",
-                    execArgv: ["--user-agent=opencode/" + version, "--env-file=\"\"", "--"],
-                    windows: {},
-                  },
-                })
-
-                if (!result.success) {
-                  console.error("Build failed!")
-                  for (const log of result.logs) {
-                    console.error(log)
-                  }
-                  throw new Error("Compilation failed")
-                }
-
-                // Nix packaging needs a real file for Worker() lookups, so emit a JS bundle alongside the binary.
-                const workerBundle = await Bun.build({
-                  entrypoints: [workerPath],
-                  tsconfig: "./tsconfig.json",
-                  plugins: [solidPlugin],
-                  target: "bun",
-                  outdir: "./.opencode-worker",
-                  sourcemap: "none",
-                })
-
-                if (!workerBundle.success) {
-                  console.error("Worker build failed!")
-                  for (const log of workerBundle.logs) {
-                    console.error(log)
-                  }
-                  throw new Error("Worker compilation failed")
-                }
-
-                const workerOutput = workerBundle.outputs.find((output) => output.kind === "entry-point")
-                if (!workerOutput) {
-                  throw new Error("Worker build produced no entry-point output")
-                }
-
-                const workerTarget = path.join(packageDir, "opencode-worker.js")
-                const workerSource = workerOutput.path
-                await Bun.write(workerTarget, Bun.file(workerSource))
-                fs.rmSync(path.dirname(workerSource), { recursive: true, force: true })
-
-                console.log("Build successful!")
-                EOF
-
-                substituteInPlace bun-build.ts \
-                  --replace '@VERSION@' "${finalAttrs.version}"
-
-                export BUN_COMPILE_TARGET=${bunTarget.${stdenvNoCC.hostPlatform.system}}
-                bun --bun bun-build.ts
-
-                runHook postBuild
-              '';
-
-              dontStrip = true;
-
-              installPhase = ''
-                runHook preInstall
-
-                # The binary is created in the package directory after chdir
-                cd packages/opencode
-                if [ ! -f opencode ]; then
-                  echo "ERROR: opencode binary not found in $(pwd)"
-                  ls -la
-                  exit 1
-                fi
-                if [ ! -f opencode-worker.js ]; then
-                  echo "ERROR: opencode worker bundle not found in $(pwd)"
-                  ls -la
-                  exit 1
-                fi
-
-                install -Dm755 opencode $out/bin/opencode
-                install -Dm644 opencode-worker.js $out/bin/opencode-worker.js
-                runHook postInstall
-              '';
-
-              postFixup = lib.optionalString stdenvNoCC.hostPlatform.isLinux ''
-                wrapProgram $out/bin/opencode \
-                  --set LD_LIBRARY_PATH "${lib.makeLibraryPath [ stdenv.cc.cc.lib ]}"
-              '';
-
-              meta = {
-                description = "AI coding agent built for the terminal";
-                longDescription = ''
-                  OpenCode is a terminal-based agent that can build anything.
-                  It combines a TypeScript/JavaScript core with a Go-based TUI
-                  to provide an interactive AI coding experience.
-                '';
-                homepage = "https://github.com/sst/opencode";
-                license = lib.licenses.mit;
-                platforms = [
-                  "aarch64-linux"
-                  "x86_64-linux"
-                ];
-                mainProgram = "opencode";
-              };
-            })
-          ) { };
+          default = mkPackage {
+            version = packageJson.version;
+            src = ./.;
+            scripts = scripts;
+            target = bunTarget.${system};
+            modelsDev = "${modelsDev.${system}}/dist/_api.json";
+            mkNodeModules = mkNodeModules;
+          };
         }
       );
 

nix/models-dev.nix

@@ -0,0 +1,18 @@
+{ stdenvNoCC, fetchurl }:
+stdenvNoCC.mkDerivation {
+  pname = "models-dev";
+  version = "unstable";
+
+  src = fetchurl {
+    url = "https://models.dev/api.json";
+    hash = "sha256-Dff3OWJ7pD7LfVbZZ0Gf/QA65uw4ft14mdfBun0qDBg=";
+  };
+
+  dontUnpack = true;
+  dontBuild = true;
+
+  installPhase = ''
+    mkdir -p $out/dist
+    cp $src $out/dist/_api.json
+  '';
+}