export deviceId

Author: SSharma-10

doit.go

@@ -31,6 +31,7 @@ import (
 	"time"
 
 	"github.com/blang/semver"
+	"github.com/digitalocean/doctl/internal/deviceid"
 	"github.com/digitalocean/doctl/pkg/listen"
 	"github.com/digitalocean/doctl/pkg/runner"
 	"github.com/digitalocean/doctl/pkg/ssh"
@@ -299,6 +300,10 @@ func (c *LiveConfig) GetGodoClient(trace, allowRetries bool, accessToken string)
 		client.HTTPClient.Transport = r
 	}
 
+	// Stamp the host UUID on hosted-agents requests. Wrapped after the trace
+	// recorder so --trace surfaces the header; no-op when Get() is empty.
+	client.HTTPClient.Transport = deviceid.NewTransport(client.HTTPClient.Transport, deviceid.Get())
+
 	return client, nil
 }
 

internal/deviceid/deviceid.go

@@ -0,0 +1,43 @@
+// Package deviceid resolves the hardware UUID of the host running doctl for
+// the hosted-agents API. Get returns "" on any failure; doctl never fails on
+// a missing UUID. The lookup is cached per process.
+package deviceid
+
+import (
+	"os"
+	"strings"
+	"sync"
+)
+
+// EnvDisable disables the lookup when set to "1", "true", or "yes".
+const EnvDisable = "DOCTL_DISABLE_DEVICE_ID"
+
+var (
+	once   sync.Once
+	cached string
+)
+
+// Get returns the host hardware UUID, or "" if unavailable / opted out.
+func Get() string {
+	once.Do(func() {
+		if isDisabled() {
+			return
+		}
+		cached = strings.TrimSpace(read())
+	})
+	return cached
+}
+
+// reset clears the cache. Test hook only.
+func reset() {
+	once = sync.Once{}
+	cached = ""
+}
+
+func isDisabled() bool {
+	switch strings.ToLower(strings.TrimSpace(os.Getenv(EnvDisable))) {
+	case "1", "true", "yes":
+		return true
+	}
+	return false
+}

internal/deviceid/deviceid_darwin.go

@@ -0,0 +1,30 @@
+//go:build darwin
+
+package deviceid
+
+import (
+	"context"
+	"os/exec"
+	"regexp"
+	"time"
+)
+
+var ioregPath = "/usr/sbin/ioreg"
+
+// ioreg output line: `"IOPlatformUUID" = "<uuid>"`
+var ioPlatformUUID = regexp.MustCompile(`"IOPlatformUUID"\s*=\s*"([^"]+)"`)
+
+func read() string {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	out, err := exec.CommandContext(ctx, ioregPath, "-d2", "-c", "IOPlatformExpertDevice").Output()
+	if err != nil {
+		return ""
+	}
+	m := ioPlatformUUID.FindSubmatch(out)
+	if len(m) < 2 {
+		return ""
+	}
+	return string(m[1])
+}

internal/deviceid/deviceid_linux.go

@@ -0,0 +1,25 @@
+//go:build linux
+
+package deviceid
+
+import "os"
+
+// Note: this is the systemd install UUID, not the SMBIOS hardware UUID
+// (which is root-only on Linux at /sys/class/dmi/id/product_uuid).
+var machineIDPaths = []string{
+	"/etc/machine-id",
+	"/var/lib/dbus/machine-id",
+}
+
+func read() string {
+	for _, p := range machineIDPaths {
+		b, err := os.ReadFile(p)
+		if err != nil {
+			continue
+		}
+		if len(b) > 0 {
+			return string(b)
+		}
+	}
+	return ""
+}

internal/deviceid/deviceid_other.go

@@ -0,0 +1,5 @@
+//go:build !darwin && !linux && !windows
+
+package deviceid
+
+func read() string { return "" }

internal/deviceid/deviceid_test.go

@@ -0,0 +1,46 @@
+package deviceid
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGet_DisabledByEnv(t *testing.T) {
+	t.Setenv(EnvDisable, "1")
+	reset()
+	assert.Equal(t, "", Get(), "Get must return empty when DOCTL_DISABLE_DEVICE_ID is set")
+}
+
+func TestGet_DisabledByEnv_VariantsAreCaseInsensitive(t *testing.T) {
+	for _, v := range []string{"1", "true", "TRUE", "Yes", "  yes  "} {
+		t.Run(v, func(t *testing.T) {
+			t.Setenv(EnvDisable, v)
+			reset()
+			assert.Equal(t, "", Get())
+		})
+	}
+}
+
+func TestGet_NotDisabledByEnv_FalsyValuesIgnored(t *testing.T) {
+	// "0", "false", "" must not be treated as opt-out. We can't assert what
+	// Get returns (it depends on the host), but we can assert isDisabled
+	// behavior directly, which is the only env-driven branch in Get.
+	for _, v := range []string{"", "0", "false", "no", "off", "anything-else"} {
+		t.Run(v, func(t *testing.T) {
+			t.Setenv(EnvDisable, v)
+			assert.False(t, isDisabled(), "value %q must not trip opt-out", v)
+		})
+	}
+}
+
+func TestGet_Cached(t *testing.T) {
+	// Two calls must yield the same value; sync.Once guarantees read() is
+	// invoked at most once. We rely on Get being deterministic for the
+	// lifetime of the process.
+	t.Setenv(EnvDisable, "")
+	reset()
+	first := Get()
+	second := Get()
+	assert.Equal(t, first, second)
+}

internal/deviceid/deviceid_windows.go

@@ -0,0 +1,49 @@
+//go:build windows
+
+package deviceid
+
+import (
+	"context"
+	"os/exec"
+	"regexp"
+	"time"
+)
+
+var uuidLine = regexp.MustCompile(`[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}`)
+
+// read tries wmic (deprecated, removed from Win 11 24H2 fresh installs)
+// then falls back to PowerShell's Get-CimInstance.
+func read() string {
+	if id := readViaWmic(); id != "" {
+		return id
+	}
+	return readViaPowerShell()
+}
+
+func readViaWmic() string {
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	out, err := exec.CommandContext(ctx, "wmic", "csproduct", "get", "UUID").Output()
+	if err != nil {
+		return ""
+	}
+	return string(uuidLine.Find(out))
+}
+
+// 5 s ceiling to absorb powershell.exe cold-start (~1–2 s).
+func readViaPowerShell() string {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	out, err := exec.CommandContext(ctx, "powershell",
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		"(Get-CimInstance -ClassName Win32_ComputerSystemProduct).UUID",
+	).Output()
+	if err != nil {
+		return ""
+	}
+	return string(uuidLine.Find(out))
+}

internal/deviceid/transport.go

@@ -0,0 +1,53 @@
+package deviceid
+
+import (
+	"net/http"
+	"strings"
+)
+
+// HeaderName is coordinated with the harness-api server. Rename in lockstep.
+const HeaderName = "X-Device-UUID"
+
+// agentsSessionsBase mirrors godo's hostedAgentsSessionsBasePath.
+const agentsSessionsBase = "/v2/agents/sessions"
+
+// Transport stamps HeaderName on requests under agentsSessionsBase.
+type Transport struct {
+	Base http.RoundTripper
+	ID   string
+}
+
+// NewTransport returns base unchanged when id is empty so callers can chain
+// unconditionally.
+func NewTransport(base http.RoundTripper, id string) http.RoundTripper {
+	if base == nil {
+		base = http.DefaultTransport
+	}
+	if id == "" {
+		return base
+	}
+	return &Transport{Base: base, ID: id}
+}
+
+func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+	if t.ID == "" || !inAgentsScope(req) {
+		return t.Base.RoundTrip(req)
+	}
+	// RoundTripper contract: don't mutate the caller's request.
+	r := req.Clone(req.Context())
+	if r.Header == nil {
+		r.Header = make(http.Header)
+	}
+	r.Header.Set(HeaderName, t.ID)
+	return t.Base.RoundTrip(r)
+}
+
+// inAgentsScope matches the base path exactly or any sub-resource, but not
+// look-alikes like "/v2/agents/sessionsfoo".
+func inAgentsScope(req *http.Request) bool {
+	if req == nil || req.URL == nil {
+		return false
+	}
+	p := req.URL.Path
+	return p == agentsSessionsBase || strings.HasPrefix(p, agentsSessionsBase+"/")
+}