Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

7.8 KB
Raw Blame
package cmd

import (
	"bytes"
	"context"
	"errors"
	"runtime"
	"strings"
	"testing"
	"time"

	"github.com/spf13/cobra"

	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/account"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/asymptote"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/lifecycle"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/service"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/managedprivacy"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/onboarding"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/testenv"
)

func TestConnectUsesSignedInAccountAndSelectedPrivacy(t *testing.T) {
	originalLoad, originalConnect := connectAccountLoad, connectManagedEndpoint
	originalConnectOpts, originalEndpointOpts := connectOpts, endpointOpts
	t.Cleanup(func() {
		connectAccountLoad, connectManagedEndpoint = originalLoad, originalConnect
		connectOpts, endpointOpts = originalConnectOpts, originalEndpointOpts
	})
	connectOpts.privacyMode = "metadata-only"
	connectAccountLoad = func() (*account.Session, error) {
		return &account.Session{
			BaseURL:     "https://beacon.sh",
			AccessToken: "bcn_cli_secret",
			ExpiresAt:   time.Now().Add(time.Hour),
			Scopes:      []string{account.ScopeProfileRead, account.ScopeDeviceEnroll},
			User:        account.User{ID: "usr_1", Email: "[email protected]"},
		}, nil
	}
	var captured asymptote.ConnectOptions
	connectManagedEndpoint = func(_ context.Context, options asymptote.ConnectOptions) (*asymptote.ConnectResult, error) {
		captured = options
		return &asymptote.ConnectResult{
			Enrollment: asymptote.Enrollment{
				DeviceID: "dev-1", DashboardURL: "https://beacon.sh", PrivacyMode: options.PrivacyMode,
			},
			Forwarder:      "test",
			ForwarderState: service.Status{Loaded: true, Running: true},
			VectorConfig:   "/tmp/vector.toml",
			SecretsFile:    "/tmp/secrets.json",
		}, nil
	}
	var out bytes.Buffer
	command := &cobra.Command{}
	command.SetOut(&out)
	command.SetErr(&out)
	if err := connectEndpoint(command, true, "/tmp/runtime.jsonl", false); err != nil {
		t.Fatalf("connectEndpoint returned error: %v", err)
	}
	if captured.AccountEnroll == nil || captured.AccountEnroll.AccessToken != "bcn_cli_secret" {
		t.Fatalf("account enrollment = %#v", captured.AccountEnroll)
	}
	if captured.PrivacyMode != managedprivacy.MetadataOnly {
		t.Fatalf("privacy mode = %q", captured.PrivacyMode)
	}
	if strings.Contains(out.String(), "bcn_cli_secret") {
		t.Fatalf("connect output leaks the account token: %q", out.String())
	}
}

// Every URL Beacon prints has to be one a browser can actually open. The dashboard
// is a single page at /dashboard whose views are tabs, so the service root is the
// marketing site and deep links like /dashboard/telemetry have no route at all.
func TestDashboardHomeURL(t *testing.T) {
	for base, want := range map[string]string{
		"https://beacon.sh":           "https://beacon.sh/dashboard",
		"https://beacon.sh/":          "https://beacon.sh/dashboard",
		"  https://beacon.sh  ":       "https://beacon.sh/dashboard",
		"https://beacon.sh/dashboard": "https://beacon.sh/dashboard",
		"http://127.0.0.1:8971":       "http://127.0.0.1:8971/dashboard",
		"":                            "https://beacon.sh/dashboard",
	} {
		if got := dashboardHomeURL(base); got != want {
			t.Fatalf("dashboardHomeURL(%q) = %q, want %q", base, got, want)
		}
	}
}

// A system connect or disconnect from a shell without privileges used to say "rerun with sudo",
// which names a command Windows does not have. The hint has to come from the platform, as it
// already does for install, update and the job commands.
func TestSystemConnectAndDisconnectNameThePlatformElevationHint(t *testing.T) {
	if lifecycle.HasSystemPrivileges() {
		t.Skip("an elevated process can connect a system endpoint")
	}
	originalEndpointOpts := endpointOpts
	originalConnect := connectManagedEndpoint
	t.Cleanup(func() {
		endpointOpts = originalEndpointOpts
		connectManagedEndpoint = originalConnect
	})
	endpointOpts.userMode, endpointOpts.systemMode = false, true
	connectManagedEndpoint = func(context.Context, asymptote.ConnectOptions) (*asymptote.ConnectResult, error) {
		return nil, errors.New("must not run")
	}
	for name, run := range map[string]func(*cobra.Command, []string) error{
		"connect":    runEndpointConnect,
		"disconnect": runEndpointDisconnect,
	} {
		err := run(&cobra.Command{}, nil)
		if err == nil {
			t.Fatalf("%s: a system %s without privileges returned nil", name, name)
		}
		if !strings.Contains(err.Error(), "elevated privileges") {
			t.Fatalf("%s: error = %v, want it to name the elevation requirement", name, err)
		}
		if !strings.Contains(err.Error(), lifecycle.SystemPrivilegeHint()) {
			t.Fatalf("%s: error = %v, want it to carry this platform's hint (%q)", name, err, lifecycle.SystemPrivilegeHint())
		}
		if strings.Contains(err.Error(), "sudo") && runtime.GOOS == "windows" {
			t.Fatalf("%s: error = %v names sudo on Windows", name, err)
		}
	}
}

func TestConnectRequiresSignedInAccountInUserMode(t *testing.T) {
	originalLoad, originalConnect := connectAccountLoad, connectManagedEndpoint
	t.Cleanup(func() {
		connectAccountLoad, connectManagedEndpoint = originalLoad, originalConnect
	})
	connectAccountLoad = func() (*account.Session, error) { return nil, account.ErrNotSignedIn }
	connectManagedEndpoint = func(context.Context, asymptote.ConnectOptions) (*asymptote.ConnectResult, error) {
		return nil, errors.New("must not run")
	}
	command := &cobra.Command{}
	err := connectEndpoint(command, true, "/tmp/runtime.jsonl", false)
	if err == nil || !strings.Contains(err.Error(), "beacon login") {
		t.Fatalf("error = %v", err)
	}
}

func TestSelectedManagedPrivacyModePrefersFlagThenActiveEnrollment(t *testing.T) {
	home := t.TempDir()
	testenv.SetHome(t, home)
	originalOpts := connectOpts
	t.Cleanup(func() { connectOpts = originalOpts })
	if err := onboarding.Save(onboarding.Profile{Onboarding: onboarding.Onboarding{
		CompletedAt: "2026-09-21T08:00:00Z",
		Destination: onboarding.DestinationAsymptote,
		PrivacyMode: managedprivacy.Standard,
	}}); err != nil {
		t.Fatal(err)
	}
	if err := asymptote.SaveEnrollment(true, asymptote.Enrollment{
		InstallID:   "install-1",
		IngestURL:   "https://ingest.beacon.sh",
		DeviceID:    "dev-1",
		PrivacyMode: managedprivacy.MetadataOnly,
	}); err != nil {
		t.Fatal(err)
	}
	got, err := selectedManagedPrivacyMode(true)
	if err != nil || got != managedprivacy.MetadataOnly {
		t.Fatalf("active enrollment mode = %q, %v", got, err)
	}
	connectOpts.privacyMode = managedprivacy.Standard
	got, err = selectedManagedPrivacyMode(true)
	if err != nil || got != managedprivacy.Standard {
		t.Fatalf("flag mode = %q, %v", got, err)
	}
}

func TestCloudStatusLineOnlyWhereBeaconCloudApplies(t *testing.T) {
	notConnected := asymptote.ManagedIngestStatus{}
	if line := cloudStatusLine(notConnected, false, false); line != "" {
		t.Errorf("system install, not connected: line = %q, want none (MDM rollouts should not be told to connect)", line)
	}
	if line := cloudStatusLine(notConnected, true, true); line != "" {
		t.Errorf("own forwarder, not connected: line = %q, want none", line)
	}
	if line := cloudStatusLine(notConnected, true, false); !strings.Contains(line, "beacon endpoint connect") {
		t.Errorf("per-user install, not connected: line = %q, want the connect hint", line)
	}
	connected := asymptote.ManagedIngestStatus{Enabled: true, DeviceID: "dev-1"}
	if line := cloudStatusLine(connected, false, true); !strings.Contains(line, "Beacon Cloud: connected") {
		t.Errorf("system install, connected: line = %q, want the connected line", line)
	}
	pending := asymptote.ManagedIngestStatus{Message: "connect did not finish"}
	if line := cloudStatusLine(pending, false, false); !strings.Contains(line, "connect did not finish") {
		t.Errorf("system install, incomplete connect: line = %q, want its message", line)
	}
}