AmirulAndalib · pull · May 19, 2025 · May 19, 2025 · May 19, 2025 · May 19, 2025
diff --git a/.cursorrules b/.cursorrules
@@ -4,25 +4,25 @@ This project is called "Coder" - an application for managing remote development
 
 Coder provides a platform for creating, managing, and using remote development environments (also known as Cloud Development Environments or CDEs). It leverages Terraform to define and provision these environments, which are referred to as "workspaces" within the project. The system is designed to be extensible, secure, and provide developers with a seamless remote development experience.
 
-# Core Architecture
+## Core Architecture
 
 The heart of Coder is a control plane that orchestrates the creation and management of workspaces. This control plane interacts with separate Provisioner processes over gRPC to handle workspace builds. The Provisioners consume workspace definitions and use Terraform to create the actual infrastructure.
 
 The CLI package serves dual purposes - it can be used to launch the control plane itself and also provides client functionality for users to interact with an existing control plane instance. All user-facing frontend code is developed in TypeScript using React and lives in the `site/` directory.
 
 The database layer uses PostgreSQL with SQLC for generating type-safe database code. Database migrations are carefully managed to ensure both forward and backward compatibility through paired `.up.sql` and `.down.sql` files.
 
-# API Design
+## API Design
 
 Coder's API architecture combines REST and gRPC approaches. The REST API is defined in `coderd/coderd.go` and uses Chi for HTTP routing. This provides the primary interface for the frontend and external integrations.
 
 Internal communication with Provisioners occurs over gRPC, with service definitions maintained in `.proto` files. This separation allows for efficient binary communication with the components responsible for infrastructure management while providing a standard REST interface for human-facing applications.
 
-# Network Architecture
+## Network Architecture
 
 Coder implements a secure networking layer based on Tailscale's Wireguard implementation. The `tailnet` package provides connectivity between workspace agents and clients through DERP (Designated Encrypted Relay for Packets) servers when direct connections aren't possible. This creates a secure overlay network allowing access to workspaces regardless of network topology, firewalls, or NAT configurations.
 
-## Tailnet and DERP System
+### Tailnet and DERP System
 
 The networking system has three key components:
 
@@ -35,7 +35,7 @@ The networking system has three key components:
 
 3. **Direct Connections**: When possible, the system establishes peer-to-peer connections between clients and workspaces using STUN for NAT traversal. This requires both endpoints to send UDP traffic on ephemeral ports.
 
-## Workspace Proxies
+### Workspace Proxies
 
 Workspace proxies (in the Enterprise edition) provide regional relay points for browser-based connections, reducing latency for geo-distributed teams. Key characteristics:
 
@@ -45,9 +45,10 @@ Workspace proxies (in the Enterprise edition) provide regional relay points for
 - Managed through the `coder wsproxy` commands
 - Implemented primarily in the `enterprise/wsproxy/` package
 
-# Agent System
+## Agent System
 
 The workspace agent runs within each provisioned workspace and provides core functionality including:
+
 - SSH access to workspaces via the `agentssh` package
 - Port forwarding
 - Terminal connectivity via the `pty` package for pseudo-terminal support
@@ -57,7 +58,7 @@ The workspace agent runs within each provisioned workspace and provides core fun
 
 Agents communicate with the control plane using the tailnet system and authenticate using secure tokens.
 
-# Workspace Applications
+## Workspace Applications
 
 Workspace applications (or "apps") provide browser-based access to services running within workspaces. The system supports:
 
@@ -69,17 +70,17 @@ Workspace applications (or "apps") provide browser-based access to services runn
 
 The implementation is primarily in the `coderd/workspaceapps/` directory with components for URL generation, proxying connections, and managing application state.
 
-# Implementation Details
+## Implementation Details
 
 The project structure separates frontend and backend concerns. React components and pages are organized in the `site/src/` directory, with Jest used for testing. The backend is primarily written in Go, with a strong emphasis on error handling patterns and test coverage.
 
 Database interactions are carefully managed through migrations in `coderd/database/migrations/` and queries in `coderd/database/queries/`. All new queries require proper database authorization (dbauthz) implementation to ensure that only users with appropriate permissions can access specific resources.
 
-# Authorization System
+## Authorization System
 
 The database authorization (dbauthz) system enforces fine-grained access control across all database operations. It uses role-based access control (RBAC) to validate user permissions before executing database operations. The `dbauthz` package wraps the database store and performs authorization checks before returning data. All database operations must pass through this layer to ensure security.
 
-# Testing Framework
+## Testing Framework
 
 The codebase has a comprehensive testing approach with several key components:
 
@@ -91,7 +92,7 @@ The codebase has a comprehensive testing approach with several key components:
 
 4. **Enterprise Testing**: Enterprise features have dedicated test utilities in the `coderdenttest` package.
 
-# Open Source and Enterprise Components
+## Open Source and Enterprise Components
 
 The repository contains both open source and enterprise components:
 
@@ -100,9 +101,10 @@ The repository contains both open source and enterprise components:
 - The boundary between open source and enterprise is managed through a licensing system
 - The same core codebase supports both editions, with enterprise features conditionally enabled
 
-# Development Philosophy
+## Development Philosophy
 
 Coder emphasizes clear error handling, with specific patterns required:
+
 - Concise error messages that avoid phrases like "failed to"
 - Wrapping errors with `%w` to maintain error chains
 - Using sentinel errors with the "err" prefix (e.g., `errNotFound`)
@@ -111,7 +113,7 @@ All tests should run in parallel using `t.Parallel()` to ensure efficient testin
 
 Git contributions follow a standard format with commit messages structured as `type: <message>`, where type is one of `feat`, `fix`, or `chore`.
 
-# Development Workflow
+## Development Workflow
 
 Development can be initiated using `scripts/develop.sh` to start the application after making changes. Database schema updates should be performed through the migration system using `create_migration.sh <name>` to generate migration files, with each `.up.sql` migration paired with a corresponding `.down.sql` that properly reverts all changes.
 

diff --git a/.github/actions/setup-go-paths/action.yml b/.github/actions/setup-go-paths/action.yml
@@ -0,0 +1,57 @@
+name: "Setup Go Paths"
+description: Overrides Go paths like GOCACHE and GOMODCACHE to use temporary directories.
+outputs:
+  gocache:
+    description: "Value of GOCACHE"
+    value: ${{ steps.paths.outputs.gocache }}
+  gomodcache:
+    description: "Value of GOMODCACHE"
+    value: ${{ steps.paths.outputs.gomodcache }}
+  gopath:
+    description: "Value of GOPATH"
+    value: ${{ steps.paths.outputs.gopath }}
+  gotmp:
+    description: "Value of GOTMPDIR"
+    value: ${{ steps.paths.outputs.gotmp }}
+  cached-dirs:
+    description: "Go directories that should be cached between CI runs"
+    value: ${{ steps.paths.outputs.cached-dirs }}
+runs:
+  using: "composite"
+  steps:
+    - name: Override Go paths
+      id: paths
+      uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
+      with:
+        script: |
+          const path = require('path');
+
+          // RUNNER_TEMP should be backed by a RAM disk on Windows if
+          // coder/setup-ramdisk-action was used
+          const runnerTemp = process.env.RUNNER_TEMP;
+          const gocacheDir = path.join(runnerTemp, 'go-cache');
+          const gomodcacheDir = path.join(runnerTemp, 'go-mod-cache');
+          const gopathDir = path.join(runnerTemp, 'go-path');
+          const gotmpDir = path.join(runnerTemp, 'go-tmp');
+
+          core.exportVariable('GOCACHE', gocacheDir);
+          core.exportVariable('GOMODCACHE', gomodcacheDir);
+          core.exportVariable('GOPATH', gopathDir);
+          core.exportVariable('GOTMPDIR', gotmpDir);
+
+          core.setOutput('gocache', gocacheDir);
+          core.setOutput('gomodcache', gomodcacheDir);
+          core.setOutput('gopath', gopathDir);
+          core.setOutput('gotmp', gotmpDir);
+
+          const cachedDirs = `${gocacheDir}\n${gomodcacheDir}`;
+          core.setOutput('cached-dirs', cachedDirs);
+
+    - name: Create directories
+      shell: bash
+      run: |
+        set -e
+        mkdir -p "$GOCACHE"
+        mkdir -p "$GOMODCACHE"
+        mkdir -p "$GOPATH"
+        mkdir -p "$GOTMPDIR"
diff --git a/.github/actions/setup-go/action.yaml b/.github/actions/setup-go/action.yaml
@@ -8,42 +8,26 @@ inputs:
   use-preinstalled-go:
     description: "Whether to use preinstalled Go."
     default: "false"
-  use-temp-cache-dirs:
-    description: "Whether to use temporary GOCACHE and GOMODCACHE directories."
-    default: "false"
+  use-cache:
+    description: "Whether to use the cache."
+    default: "true"
 runs:
   using: "composite"
   steps:
-    - name: Override GOCACHE and GOMODCACHE
-      shell: bash
-      if: inputs.use-temp-cache-dirs == 'true'
-      run: |
-        # cd to another directory to ensure we're not inside a Go project.
-        # That'd trigger Go to download the toolchain for that project.
-        cd "$RUNNER_TEMP"
-        # RUNNER_TEMP should be backed by a RAM disk on Windows if
-        # coder/setup-ramdisk-action was used
-        export GOCACHE_DIR="$RUNNER_TEMP""\go-cache"
-        export GOMODCACHE_DIR="$RUNNER_TEMP""\go-mod-cache"
-        export GOPATH_DIR="$RUNNER_TEMP""\go-path"
-        export GOTMP_DIR="$RUNNER_TEMP""\go-tmp"
-        mkdir -p "$GOCACHE_DIR"
-        mkdir -p "$GOMODCACHE_DIR"
-        mkdir -p "$GOPATH_DIR"
-        mkdir -p "$GOTMP_DIR"
-        go env -w GOCACHE="$GOCACHE_DIR"
-        go env -w GOMODCACHE="$GOMODCACHE_DIR"
-        go env -w GOPATH="$GOPATH_DIR"
-        go env -w GOTMPDIR="$GOTMP_DIR"
     - name: Setup Go
       uses: actions/setup-go@0a12ed9d6a96ab950c8f026ed9f722fe0da7ef32 # v5.0.2
       with:
         go-version: ${{ inputs.use-preinstalled-go == 'false' && inputs.version || '' }}
+        cache: ${{ inputs.use-cache }}
 
     - name: Install gotestsum
       shell: bash
       run: go install gotest.tools/gotestsum@0d9599e513d70e5792bb9334869f82f6e8b53d4d # main as of 2025-05-15
 
+    - name: Install mtimehash
+      shell: bash
+      run: go install github.com/slsyy/mtimehash/cmd/mtimehash@a6b5da4ed2c4a40e7b805534b004e9fde7b53ce0 # v1.0.0
+
     # It isn't necessary that we ever do this, but it helps
     # separate the "setup" from the "run" times.
     - name: go mod download

diff --git a/.github/actions/setup-imdisk/action.yaml b/.github/actions/setup-imdisk/action.yaml