// mesh-build-node: the Node and TypeScript build module (novox/hq ADR 0405, ADR 0466 §1, ADR 0469, ADR 0470; design // 47 R4c-3, issue 1488). A Go tools bundle the node's runtime launches as the module's own account (runs-as). It names // the one Node version it builds with, installs the TypeScript toolchain its own lock names, writes the Node version // it finds to .typescript of its `toolchains` state at start and before every step, and refuses every step on // a node that has another: its health is then unhealthy, so the controller raises the node's condition. What it // says, it says on stderr; stdout is the MCP channel. package main import ( "context" "fmt" "os" "os/user" "path/filepath" "strings" "time" seat "git.novox.be/novox/mesh-delivery/contracts/go/seats/nodebuildnode" sdkstep "git.novox.be/novox/mesh-delivery/sdk/buildstep" dforgekey "git.novox.be/novox/mesh-delivery/sdk/forgekey" stdio "git.novox.be/novox/mesh-sdk/go" ) // CacheDir is the cache directory, outside the account's home (ADR 0466 §1; module.json resource `cache`). const CacheDir = "/var/lib/mesh-build-node-cache" // WorkDir is the work directory, outside the home (module.json resource `work`). const WorkDir = "/var/lib/mesh-build-node-work" func logf(format string, a ...any) { fmt.Fprintf(os.Stderr, "[mesh-build-node] "+format+"\n", a...) } func main() { ctx := context.Background() home := "" if u, err := user.Current(); err == nil { home = u.HomeDir } paths := Paths{Home: home, Cache: CacheDir} registry := func() (Registry, error) { return ReadRegistry(filepath.Join(home, "package-registry.json")) } m := &Module{ Node: strings.TrimSpace(os.Getenv("MESH_NODE")), Reload: func() (Recipe, error) { return ReadRecipe(paths.LockPath()) }, Probe: ProbeNode, Toolchain: &Toolchain{Paths: paths, Run: dforgekey.ExecRunnerClean(0), Registry: registry}, Toolchains: stdio.State(seat.StateToolchains).Put, Emit: func(t string, b any) error { return stdio.Emit(t, b) }, Steps: stdio.State(seat.StateSteps).Put, ReadSteps: readOf(stdio.State(seat.StateSteps)), Detected: stdio.State(seat.StateDetectedSteps).Put, ReadDetected: readOf(stdio.State(seat.StateDetectedSteps)).Get, Pauses: stdio.State(sdkstep.PausesState).Put, ReadPauses: readOf(stdio.State(sdkstep.PausesState)), ForgetPause: stdio.State(sdkstep.PausesState).Delete, WatchPauses: stdio.State(sdkstep.PausesState).Watch, ReadToolchainsState: readOf(stdio.State(seat.StateToolchains)), Work: WorkDir, Run: dforgekey.ExecRunnerClean(0), Ctx: ctx, Say: logf, Bubblewrap: ProbeBubblewrap, } m.Floor = floorOf(m.Node) m.Settings = filepath.Join(home, "settings.json") // Outside a launch by the runtime — a build, a check — there is no node and no state to write. if m.Node != "" { go m.Start(ctx) } go startKeeper(ctx) // Every state it keeps, said on the bus before it serves (ADR 0495 §2; issue 1790). if err := keepStates(); err != nil { logf("announcing the states it keeps: %v", err) os.Exit(1) } steps := m.StepTools() booted := time.Now() puller := m.Puller(steps, nil) m.Held = puller if m.Node != "" { // A step a previous process left running is ended (issue 1890): one that names another owner, or none and // started before booted. go m.endLeftRunning(ctx, m.stepScan(), booted, logf) } if m.Node != "" { // The seat's asks, pulled once Serve has the runtime's channel; a pull before it is said and tried again. go func() { _ = puller.Pull(ctx) }() } if err := stdio.Serve("", append(m.Tools(steps), m.SeatTools(puller)...)); err != nil { logf("%v", err) os.Exit(1) } }