Skip to content

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

Ask where telemetry should go with a three-way picker; purple question titles

shukieshah596e428005a9
diff --git a/CLAUDE.md b/CLAUDE.md
index b26a6121..64f626c2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -20,7 +20,7 @@ Do not recreate or depend on removed `asymptote` mirror trees. Keep new work foc
- Beacon is visibility-first endpoint telemetry for local AI agent runtimes, not a hosted policy service or general endpoint protection product.
- Preserve the local-only default. The public Beacon build must not require a hosted account, remote policy fetch, hosted dashboard, or external network dependency during normal hook execution, and hooks themselves never touch the network.
- Asymptote Managed forwarding (`cli/beacon/internal/endpoint/asymptote`, `beacon endpoint asymptote`) is the one destination that sends telemetry to an Asymptote-run service, and it is an explicit, opt-in, revocable Vector destination shaped like every other pack: Beacon stays the local JSONL producer, Vector does the network, and the per-device key lives in a `0600` secrets file read through Vector's secret backend, never in `config.json`, `vector.toml`, or the process environment. Nothing is forwarded until a member of the organization approves the specific device in the browser; only lines written after that are shipped (`read_from = "end"`); revocation from the dashboard takes effect at the ingest service within a minute. The wire contract (gzip NDJSON to `/v1/ingest/{runtime,inventory}`, bearer `bcn_device_*` key, `/v1/ingest/health` credential check) is owned by the `beacon-ingest` service in beacon-mdr; change both sides together. Do not add a second network channel, and do not let the ingest URL be anything but `https://`.
-- Two bounded network channels exist, both explicit. The first: `beacon endpoint install` asks for an email and work/personal intent once per machine and POSTs that plus install context (OS, arch, version, install method, detected runtime names, a random install ID) to an Asymptote-run signup endpoint. The same first-run prompt, when Vector is present, also offers to connect the machine to Asymptote Managed (default no; `BEACON_MANAGED_INGEST=0` silences it; `install --connect` forces it and skips the question; a no is recorded in the profile and never asked again; a yes runs `connect` after the install, is recorded only once that connect succeeds so a failed install or connect is asked again rather than remembered as done, and is the only way onboarding ever forwards telemetry). The second channel is that forwarder, described below. This is intentional product behavior for open-source attribution, not an oversight — do not remove it. It is strictly bounded: interactive TTY only, once per machine, never during hook execution, never on `--system`/root/CI/piped-stdin/`--dry-run` installs, and always skippable with `--no-onboarding` or `BEACON_ONBOARDING=0`. A failed submission never fails an install. No prompt text, telemetry event, file content, or command ever leaves the machine through it. Implementation lives in `cli/beacon/internal/onboarding` and `cli/beacon/cmd/endpoint_onboarding.go`; the README documents the payload field-by-field, so changing the fields means changing that table too.
+- Two bounded network channels exist, both explicit. The first: `beacon endpoint install` asks for an email and work/personal intent once per machine and POSTs that plus install context (OS, arch, version, install method, detected runtime names, a random install ID) to an Asymptote-run signup endpoint. The same first-run prompt ends with a telemetry destination question (arrow-key picker, local first so Enter forwards nothing): keep it local, forward to the user's own infrastructure (prints the log-forwarding docs URL, nothing else changes), or forward to Asymptote Managed. `BEACON_MANAGED_INGEST=0` hides the Asymptote row; `install --connect` skips the question and connects. Local and own-infrastructure answers are recorded in the profile and never asked again; the Asymptote answer runs `connect` after the install, is recorded only once that connect succeeds so a failed install or connect is asked again rather than remembered as done, and is the only way onboarding ever forwards telemetry. The answer is never sent. The second channel is that forwarder, described below. This is intentional product behavior for open-source attribution, not an oversight — do not remove it. It is strictly bounded: interactive TTY only, once per machine, never during hook execution, never on `--system`/root/CI/piped-stdin/`--dry-run` installs, and always skippable with `--no-onboarding` or `BEACON_ONBOARDING=0`. A failed submission never fails an install. No prompt text, telemetry event, file content, or command ever leaves the machine through it. Implementation lives in `cli/beacon/internal/onboarding` and `cli/beacon/cmd/endpoint_onboarding.go`; the README documents the payload field-by-field, so changing the fields means changing that table too.
- Do not add dependency vulnerability scanning, OSV/GHSA lookups, package remediation, or other vulnerability-enforcement flows to the public hook path.
- Do not add broad runtime enforcement unless explicitly requested. Current control behavior is limited to hook-native approvals/denials exposed by supported agent runtimes.
- Keep direct destination support scoped to local JSONL/Wazuh unless explicitly requested. Elastic support is a file-tailing pack over local JSONL; Beacon itself must not store Elastic credentials or require a hosted Elastic dependency.
diff --git a/README.md b/README.md
index 874286ef..b9e1270c 100644
--- a/README.md
+++ b/README.md
@@ -254,17 +254,27 @@ or anything else Beacon captures. The endpoint agent itself stays local-only; th
one HTTP request at install time, not an ongoing channel, unless you connect the
machine to Asymptote Managed.
-When Vector is available, the same first-run prompt also asks whether to
-**forward this machine's agent telemetry to Asymptote Managed now** (default no).
-Answering yes runs `beacon endpoint connect` after the install: your browser opens the
-Asymptote dashboard, a member of your organization approves this specific device, and a
-Vector forwarder starts shipping the runtime and inventory JSONL with a per-device key.
-Nothing recorded before the approval is sent, and the device can be revoked from the
-dashboard at any time. `beacon endpoint install --connect` forces the same flow without asking,
-`BEACON_MANAGED_INGEST=0` silences the question. A no is recorded and never asked again;
-a yes is recorded once the machine is connected, so a failed install or connection is
-asked again on the next interactive install. See [`beacon endpoint connect`](https://docs.asymptotelabs.ai/cli/endpoint-connect)
-and [Asymptote Managed forwarding](https://docs.asymptotelabs.ai/log-forwarding/asymptote).
+The same first-run prompt ends with one more question, **where should this machine's
+agent telemetry go?**, answered with the arrow keys:
+
+- **Keep it on this machine** (the default, so Enter never forwards anything). Local
+ JSONL and local dashboard.
+- **Forward to your own infrastructure**: a SIEM, observability platform, or an S3/GCS
+ bucket you own. Beacon points you at the [log forwarding docs](https://docs.asymptotelabs.ai/log-forwarding)
+ and the install stays local until you set up a pack.
+- **Forward to Asymptote Managed**: runs `beacon endpoint connect` after the install. Your
+ browser opens the Asymptote dashboard, a member of your organization approves this
+ specific device, and a Vector forwarder starts shipping the runtime and inventory JSONL
+ with a per-device key. Nothing recorded before the approval is sent, and the device can
+ be revoked from the dashboard at any time.
+
+The answer stays on the machine and is never sent. Local and own-infrastructure answers
+are recorded at once and the question is not asked again; the Asymptote answer is
+recorded once the machine is connected, so a failed install or connection is asked again
+on the next interactive install. `beacon endpoint install --connect` skips the question
+and connects; `BEACON_MANAGED_INGEST=0` hides the Asymptote option. See
+[`beacon endpoint connect`](https://docs.asymptotelabs.ai/cli/endpoint-connect) and
+[Asymptote Managed forwarding](https://docs.asymptotelabs.ai/log-forwarding/asymptote).
See the [first-run onboarding docs](https://docs.asymptotelabs.ai/cli/endpoint-onboarding#first-run-onboarding)
for fleet attribution without a terminal, inspecting or clearing the record, and
diff --git a/cli/beacon/cmd/endpoint_install.go b/cli/beacon/cmd/endpoint_install.go
index a43b5804..e9025f2a 100644
--- a/cli/beacon/cmd/endpoint_install.go
+++ b/cli/beacon/cmd/endpoint_install.go
@@ -104,13 +104,13 @@ func runEndpointInstall(cmd *cobra.Command, args []string) error {
}
// Asked once, on an interactive install, before anything is written to disk. Every
// non-interactive path (package postinstall, MDM, CI) is gated out inside.
- acceptedOffer, err := maybeRunOnboarding(cmd)
+ chooseAsymptote, err := maybeRunOnboarding(cmd)
if err != nil {
return err
}
- // --connect skips the question inside maybeRunOnboarding; either source of yes is
- // recorded in the profile only after the connect below succeeds.
- connectAfterInstall := acceptedOffer || endpointOpts.connect
+ // --connect skips the destination question inside maybeRunOnboarding; either way the
+ // Asymptote answer is recorded in the profile only after the connect below succeeds.
+ connectAfterInstall := chooseAsymptote || endpointOpts.connect
result, err := lifecycle.Install(lifecycle.InstallOptions{
UserMode: endpointUserMode(),
LogPath: endpointOpts.logPath,
@@ -144,7 +144,7 @@ func runEndpointInstall(cmd *cobra.Command, args []string) error {
if err := connectEndpoint(cmd, endpointUserMode(), result.LogPath); err != nil {
fmt.Fprintf(cmd.ErrOrStderr(), "beacon: managed ingest was not connected (%v). Run `beacon endpoint connect` to try again.\n", err)
} else {
- recordManagedIngestAccepted(cmd)
+ recordDestinationAsymptote(cmd)
}
}
return nil
diff --git a/cli/beacon/cmd/endpoint_onboarding.go b/cli/beacon/cmd/endpoint_onboarding.go
index 0555deb3..2cbe5f97 100644
--- a/cli/beacon/cmd/endpoint_onboarding.go
+++ b/cli/beacon/cmd/endpoint_onboarding.go
@@ -26,9 +26,10 @@ const (
// they just have no terminal to type it into.
onboardingEnvEmail = "BEACON_ONBOARDING_EMAIL"
onboardingEnvUsage = "BEACON_ONBOARDING_USAGE"
- // managedIngestEnvEnabled set to a false-ish value suppresses the offer to connect
- // this machine to Asymptote managed ingest. The explicit --connect flag is unaffected:
- // the variable silences a question, it does not override an operator's request.
+ // managedIngestEnvEnabled set to a false-ish value hides the Asymptote Managed row
+ // from the telemetry destination question; the question itself (local or your own
+ // infrastructure) is still asked. The explicit --connect flag is unaffected: the
+ // variable hides an offer, it does not override an operator's request.
managedIngestEnvEnabled = "BEACON_MANAGED_INGEST"
)
@@ -45,20 +46,19 @@ const (
// Indirection points so the gate and the flow can be tested without a terminal, a
// network, or a real home directory.
var (
- onboardingLoad = onboarding.Load
- onboardingSave = onboarding.Save
- onboardingAsk = onboarding.Prompt
- onboardingSend = onboarding.Submit
- onboardingStdin io.Reader = os.Stdin
- onboardingIsTTY = defaultOnboardingIsTTY
- onboardingIsRoot = func() bool { return os.Geteuid() == 0 }
- onboardingProbeFn = onboarding.StartRuntimeProbe
- onboardingAskWith = onboarding.PromptWith
- onboardingAskManagedIngest = onboarding.AskManagedIngest
- // managedIngestOfferable reports whether connect could succeed here: Vector is present
- // and this endpoint is not already connected. Offering a question whose "yes" would
- // fail is worse than not asking.
- managedIngestOfferable = defaultManagedIngestOfferable
+ onboardingLoad = onboarding.Load
+ onboardingSave = onboarding.Save
+ onboardingAsk = onboarding.Prompt
+ onboardingSend = onboarding.Submit
+ onboardingStdin io.Reader = os.Stdin
+ onboardingIsTTY = defaultOnboardingIsTTY
+ onboardingIsRoot = func() bool { return os.Geteuid() == 0 }
+ onboardingProbeFn = onboarding.StartRuntimeProbe
+ onboardingAskWith = onboarding.PromptWith
+ onboardingAskDestination = onboarding.AskDestination
+ // destinationAskable reports whether the destination question makes sense here: an
+ // endpoint already connected to Asymptote has answered it by doing.
+ destinationAskable = defaultDestinationAskable
)
// runtimeProbeBudget bounds how long submission waits on background runtime
@@ -75,8 +75,8 @@ func defaultOnboardingIsTTY() bool {
}
// maybeRunOnboarding runs the one-time signup prompt if this install should ask, and
-// reports whether the user asked to connect this machine to Asymptote managed ingest
-// once the install has finished.
+// reports whether the user chose Asymptote Managed as the telemetry destination, which
+// the install carries out with a connect once it has finished.
//
// It is called from `endpoint install` after the --dry-run early return, so a dry run
// never prompts. An error returned here does stop the install: the prompt is a
@@ -85,11 +85,11 @@ func maybeRunOnboarding(cmd *cobra.Command) (connect bool, err error) {
profile := onboardingLoad()
// Someone who already answered is never asked again, but a submission that failed
- // on a flaky network still deserves a quiet retry. The forwarding question is newer
+ // on a flaky network still deserves a quiet retry. The destination question is newer
// than the signup prompt, so a machine onboarded before it existed gets it once.
if profile.Prompted() {
resendPendingOnboarding(&profile)
- return maybeOfferManagedIngest(cmd, &profile)
+ return maybeAskDestination(cmd, &profile)
}
// A headless rollout that supplied answers is recorded without a terminal.
@@ -102,100 +102,94 @@ func maybeRunOnboarding(cmd *cobra.Command) (connect bool, err error) {
return false, nil
}
- // `install --connect` is already the answer to the forwarding question, so the prompt
- // does not ask it; the install records the yes once the connect succeeds.
- offer := !endpointOpts.connect && managedIngestOfferableNow()
+ // `install --connect` is already the answer to the destination question, so the
+ // prompt does not ask it; the install records asymptote once the connect succeeds.
+ ask := !endpointOpts.connect && destinationAskable()
// Discovery shells out to every installed runtime, so start it now and collect it
// after the questions. The latency disappears behind the user reading and typing.
probe := onboardingProbeFn()
- answers, err := onboardingAskWith(onboardingStdin, cmd.OutOrStdout(), onboarding.PromptOptions{OfferManagedIngest: offer})
+ answers, err := onboardingAskWith(onboardingStdin, cmd.OutOrStdout(), onboarding.PromptOptions{AskDestination: ask, OfferAsymptote: managedIngestEnabledByEnv()})
if err != nil {
return false, err
}
- // A no is final and recorded now. A yes is recorded by the install once the machine
- // is actually connected (recordManagedIngestAccepted): if the install or the connect
- // fails first, the record stays empty and the next interactive install asks again,
- // instead of a stored "accepted" silencing the question on a machine that never
- // forwarded anything.
- record := ""
- if answers.ManagedIngestOffered && !answers.ManagedIngest {
- record = onboarding.ManagedIngestDeclined
+ // Local and own-infrastructure answers are final and recorded now. Asymptote is
+ // recorded by the install once the machine is actually connected
+ // (recordDestinationAsymptote): if the install or the connect fails first, the record
+ // stays empty and the next interactive install asks again, instead of a stored
+ // answer silencing the question on a machine that never forwarded anything.
+ chooseAsymptote := answers.DestinationAsked && answers.Destination == onboarding.DestinationAsymptote
+ record := answers.Destination
+ if chooseAsymptote {
+ record = ""
}
completeOnboarding(cmd, &profile, answers.Email, answers.Usage, probe, record)
- return answers.ManagedIngestOffered && answers.ManagedIngest, nil
+ return chooseAsymptote, nil
}
-// maybeOfferManagedIngest asks the forwarding question alone, once, on an interactive
+// maybeAskDestination asks the destination question alone, once, on an interactive
// install of a machine that was onboarded before the question existed.
-func maybeOfferManagedIngest(cmd *cobra.Command, profile *onboarding.Profile) (bool, error) {
- if profile.Onboarding.ManagedIngest != "" || endpointOpts.connect {
+func maybeAskDestination(cmd *cobra.Command, profile *onboarding.Profile) (bool, error) {
+ if profile.Onboarding.Destination != "" || endpointOpts.connect {
return false, nil
}
- if reason, skipped := managedIngestSkipReason(*profile); skipped {
- _ = reason
+ if _, skipped := destinationSkipReason(*profile); skipped {
return false, nil
}
- connect, err := onboardingAskManagedIngest(onboardingStdin, cmd.OutOrStdout())
+ destination, err := onboardingAskDestination(onboardingStdin, cmd.OutOrStdout(), managedIngestEnabledByEnv())
if err != nil {
return false, err
}
- if connect {
- // Recorded by recordManagedIngestAccepted once the connect has succeeded.
+ if destination == onboarding.DestinationAsymptote {
+ // Recorded by recordDestinationAsymptote once the connect has succeeded.
return true, nil
}
- profile.Onboarding.ManagedIngest = onboarding.ManagedIngestDeclined
+ profile.Onboarding.Destination = destination
if err := onboardingSave(*profile); err != nil {
fmt.Fprintf(cmd.ErrOrStderr(), "beacon: could not record onboarding: %v\n", err)
}
return false, nil
}
-// recordManagedIngestAccepted stores the yes after `endpoint install` has connected the
-// machine, whether the yes came from the question or from --connect. Until then the offer
-// is unrecorded on purpose, so a failed install or connect is retried by asking again
-// rather than remembered as done. A recorded no is not overwritten: --connect on a machine
-// whose owner declined is an operator's action, not a change of the owner's answer.
-func recordManagedIngestAccepted(cmd *cobra.Command) {
+// recordDestinationAsymptote stores the Asymptote answer after `endpoint install` has
+// connected the machine, whether the answer came from the question or from --connect.
+// Until then it is unrecorded on purpose, so a failed install or connect is retried by
+// asking again rather than remembered as done. A recorded local or own-infrastructure
+// answer is not overwritten: --connect on such a machine is an operator's action, not a
+// change of the owner's answer.
+func recordDestinationAsymptote(cmd *cobra.Command) {
profile := onboardingLoad()
- if !profile.Prompted() || profile.Onboarding.ManagedIngest != "" {
+ if !profile.Prompted() || profile.Onboarding.Destination != "" {
return
}
- profile.Onboarding.ManagedIngest = onboarding.ManagedIngestAccepted
+ profile.Onboarding.Destination = onboarding.DestinationAsymptote
if err := onboardingSave(profile); err != nil {
fmt.Fprintf(cmd.ErrOrStderr(), "beacon: could not record onboarding: %v\n", err)
}
}
-// managedIngestSkipReason mirrors onboardingSkipReason for the forwarding question, with
-// two extra conditions: the variable that silences it and whether connect could succeed.
-func managedIngestSkipReason(profile onboarding.Profile) (string, bool) {
+// destinationSkipReason mirrors onboardingSkipReason for the destination question, plus
+// one condition of its own: an endpoint already connected to Asymptote is not asked.
+func destinationSkipReason(profile onboarding.Profile) (string, bool) {
switch {
- case profile.Onboarding.ManagedIngest != "":
+ case profile.Onboarding.Destination != "":
return onboardingSkipCompleted, true
- case !managedIngestEnabledByEnv():
- return onboardingSkipOptedOut, true
case !endpointUserMode(), onboardingIsRoot():
return onboardingSkipSystemInstall, true
case isCIEnvironment():
return onboardingSkipCI, true
case !onboardingIsTTY():
return onboardingSkipNotAterminal, true
- case !managedIngestOfferable():
- return "not_offerable", true
+ case !destinationAskable():
+ return "already_connected", true
default:
return "", false
}
}
-// managedIngestOfferableNow is the gate for adding the question to a first-run prompt
-// that is already going to be shown.
-func managedIngestOfferableNow() bool {
- return managedIngestEnabledByEnv() && managedIngestOfferable()
-}
-
-// managedIngestEnabledByEnv reports whether BEACON_MANAGED_INGEST permits the offer.
+// managedIngestEnabledByEnv reports whether BEACON_MANAGED_INGEST permits the Asymptote
+// Managed row.
func managedIngestEnabledByEnv() bool {
switch strings.ToLower(strings.TrimSpace(os.Getenv(managedIngestEnvEnabled))) {
case "0", "false", "no", "off":
@@ -205,12 +199,24 @@ func managedIngestEnabledByEnv() bool {
}
}
-func defaultManagedIngestOfferable() bool {
- if asymptote.Connected(endpointUserMode()) {
- return false
+// defaultDestinationAskable is false once this endpoint is connected to Asymptote: the
+// machine has a destination, and the record is written when the connect succeeds.
+func defaultDestinationAskable() bool {
+ return !asymptote.Connected(endpointUserMode())
+}
+
+// destinationLabel is the human wording for a recorded destination value.
+func destinationLabel(value string) string {
+ switch value {
+ case onboarding.DestinationLocal:
+ return "local only (nothing forwarded)"
+ case onboarding.DestinationOwnInfra:
+ return "own infrastructure (forwarding pack)"
+ case onboarding.DestinationAsymptote:
+ return "Asymptote Managed"
+ default:
+ return value
}
- _, err := asymptote.FindVector("")
- return err == nil
}
// onboardingSkipReason reports whether the prompt should stay silent, and why.
@@ -287,10 +293,10 @@ func onboardingAnswersFromEnv(stderr io.Writer) (string, string, bool) {
// It never returns an error. Once the user has answered, the install belongs to them;
// a signup endpoint being unreachable is our problem, not theirs.
//
-// managedIngest is the forwarding record to store alongside the answers: declined, or ""
-// when the question was not asked or was accepted (accepted is stored by the install
-// after the connect succeeds).
-func completeOnboarding(cmd *cobra.Command, profile *onboarding.Profile, email, usage string, probe *onboarding.RuntimeProbe, managedIngest string) {
+// destination is the telemetry destination to record alongside the answers: local or
+// own_infra, or "" when the question was not asked or the answer was Asymptote (stored
+// by the install after the connect succeeds). It is never sent anywhere.
+func completeOnboarding(cmd *cobra.Command, profile *onboarding.Profile, email, usage string, probe *onboarding.RuntimeProbe, destination string) {
installID, err := onboarding.EnsureInstallID(profile)
if err != nil {
// Without an install ID there is no dedupe key, so there is nothing sensible
@@ -322,7 +328,7 @@ func completeOnboarding(cmd *cobra.Command, profile *onboarding.Profile, email,
Usage: usage,
BeaconVersion: version.GetVersion(),
}
- profile.Onboarding.ManagedIngest = managedIngest
+ profile.Onboarding.Destination = destination
// Keep the payload only when resending could still work. A rejected submission is
// terminal, and holding the address on disk past that point serves nobody.
if outcome == onboarding.OutcomePending {
@@ -386,7 +392,7 @@ type endpointOnboardingStatus struct {
Usage string `json:"usage,omitempty"`
InstallID string `json:"install_id,omitempty"`
BeaconVersion string `json:"beacon_version,omitempty"`
- ManagedIngest string `json:"managed_ingest,omitempty"`
+ Destination string `json:"destination,omitempty"`
Pending bool `json:"pending_submission"`
SkipReason string `json:"skip_reason,omitempty"`
ProfilePath string `json:"profile_path"`
@@ -425,7 +431,7 @@ func runEndpointOnboarding(cmd *cobra.Command, args []string) error {
Usage: profile.Onboarding.Usage,
InstallID: profile.InstallID,
BeaconVersion: profile.Onboarding.BeaconVersion,
- ManagedIngest: profile.Onboarding.ManagedIngest,
+ Destination: profile.Onboarding.Destination,
Pending: profile.Pending != nil,
SkipReason: reason,
ProfilePath: onboarding.Path(),
@@ -446,8 +452,8 @@ func runEndpointOnboarding(cmd *cobra.Command, args []string) error {
fmt.Fprintf(out, "Email: %s\n", status.Email)
fmt.Fprintf(out, "Usage: %s\n", status.Usage)
}
- if status.ManagedIngest != "" {
- fmt.Fprintf(out, "Managed ingest offer: %s\n", status.ManagedIngest)
+ if status.Destination != "" {
+ fmt.Fprintf(out, "Telemetry destination: %s\n", destinationLabel(status.Destination))
}
fmt.Fprintf(out, "Install ID: %s\n", status.InstallID)
fmt.Fprintf(out, "Profile: %s\n", status.ProfilePath)
diff --git a/cli/beacon/cmd/endpoint_onboarding_test.go b/cli/beacon/cmd/endpoint_onboarding_test.go
index 494c7c33..8b7a9e9b 100644
--- a/cli/beacon/cmd/endpoint_onboarding_test.go
+++ b/cli/beacon/cmd/endpoint_onboarding_test.go
@@ -29,12 +29,13 @@ type onboardingHarness struct {
outcome string
sendErr error
probeRuns int
- // offered records the PromptOptions the prompt was invoked with; offerable and
- // standaloneAnswer drive the managed-ingest question.
- offered []onboarding.PromptOptions
- offerable bool
- standaloneAsked bool
- standaloneAnswer bool
+ // offered records the PromptOptions the prompt was invoked with; askable and
+ // standaloneAnswer drive the destination question.
+ offered []onboarding.PromptOptions
+ askable bool
+ standaloneAsked bool
+ standaloneOffered bool
+ standaloneAnswer string
}
func newOnboardingHarness(t *testing.T) *onboardingHarness {
@@ -70,7 +71,7 @@ func newOnboardingHarness(t *testing.T) *onboardingHarness {
prevLoad, prevSave, prevAsk, prevSend := onboardingLoad, onboardingSave, onboardingAskWith, onboardingSend
prevTTY, prevRoot, prevProbe := onboardingIsTTY, onboardingIsRoot, onboardingProbeFn
- prevStandalone, prevOfferable := onboardingAskManagedIngest, managedIngestOfferable
+ prevStandalone, prevAskable := onboardingAskDestination, destinationAskable
t.Setenv(managedIngestEnvEnabled, "")
onboardingLoad = func() onboarding.Profile { return h.loaded }
@@ -83,11 +84,12 @@ func newOnboardingHarness(t *testing.T) *onboardingHarness {
h.offered = append(h.offered, opts)
return h.answers, h.askErr
}
- onboardingAskManagedIngest = func(io.Reader, io.Writer) (bool, error) {
+ onboardingAskDestination = func(_ io.Reader, _ io.Writer, offerAsymptote bool) (string, error) {
h.standaloneAsked = true
+ h.standaloneOffered = offerAsymptote
return h.standaloneAnswer, nil
}
- managedIngestOfferable = func() bool { return h.offerable }
+ destinationAskable = func() bool { return h.askable }
onboardingSend = func(_ context.Context, s onboarding.Submission) (string, error) {
h.sent = append(h.sent, s)
return h.outcome, h.sendErr
@@ -103,7 +105,7 @@ func newOnboardingHarness(t *testing.T) *onboardingHarness {
endpointOpts = prevOpts
onboardingLoad, onboardingSave, onboardingAskWith, onboardingSend = prevLoad, prevSave, prevAsk, prevSend
onboardingIsTTY, onboardingIsRoot, onboardingProbeFn = prevTTY, prevRoot, prevProbe
- onboardingAskManagedIngest, managedIngestOfferable = prevStandalone, prevOfferable
+ onboardingAskDestination, destinationAskable = prevStandalone, prevAskable
})
return h
}
@@ -522,63 +524,77 @@ func TestRetryPendingOnboardingIsSilentWithNothingQueued(t *testing.T) {
}
}
-func TestMaybeRunOnboardingOffersManagedIngestOnlyWhenOfferable(t *testing.T) {
+func TestMaybeRunOnboardingAsksDestinationOnlyWhenAskable(t *testing.T) {
h := newOnboardingHarness(t)
- h.offerable = false
+ h.askable = false
if connect, err := maybeRunOnboarding(h.cmd); err != nil || connect {
t.Fatalf("connect=%t err=%v", connect, err)
}
- if len(h.offered) != 1 || h.offered[0].OfferManagedIngest {
- t.Fatalf("offer must not be made when Vector is missing or already connected: %+v", h.offered)
+ if len(h.offered) != 1 || h.offered[0].AskDestination {
+ t.Fatalf("the destination question must not be asked on a connected endpoint: %+v", h.offered)
}
- if h.saved[len(h.saved)-1].Onboarding.ManagedIngest != "" {
- t.Fatal("an offer that was not made must not be recorded as declined")
+ if h.saved[len(h.saved)-1].Onboarding.Destination != "" {
+ t.Fatal("a question that was not asked must not be recorded")
}
h = newOnboardingHarness(t)
- h.offerable = true
- h.answers.ManagedIngestOffered = true
- h.answers.ManagedIngest = true
+ h.askable = true
+ h.answers.DestinationAsked = true
+ h.answers.Destination = onboarding.DestinationAsymptote
connect, err := maybeRunOnboarding(h.cmd)
if err != nil || !connect {
- t.Fatalf("accepted offer should request a connect: connect=%t err=%v", connect, err)
+ t.Fatalf("the Asymptote answer should request a connect: connect=%t err=%v", connect, err)
}
- if !h.offered[0].OfferManagedIngest {
- t.Fatal("prompt should have been asked to offer managed ingest")
+ if !h.offered[0].AskDestination || !h.offered[0].OfferAsymptote {
+ t.Fatalf("prompt should have been asked to offer all three destinations: %+v", h.offered[0])
}
- if got := h.saved[len(h.saved)-1].Onboarding.ManagedIngest; got != "" {
- t.Fatalf("a yes is recorded only once the install has connected the machine, got %q", got)
+ if got := h.saved[len(h.saved)-1].Onboarding.Destination; got != "" {
+ t.Fatalf("asymptote is recorded only once the install has connected the machine, got %q", got)
}
- h = newOnboardingHarness(t)
- h.offerable = true
- h.answers.ManagedIngestOffered = true
- h.answers.ManagedIngest = false
- if connect, _ := maybeRunOnboarding(h.cmd); connect {
- t.Fatal("declined offer must not connect")
- }
- if got := h.saved[len(h.saved)-1].Onboarding.ManagedIngest; got != onboarding.ManagedIngestDeclined {
- t.Fatalf("recorded choice = %q", got)
+ for _, answer := range []string{onboarding.DestinationLocal, onboarding.DestinationOwnInfra} {
+ h = newOnboardingHarness(t)
+ h.askable = true
+ h.answers.DestinationAsked = true
+ h.answers.Destination = answer
+ if connect, _ := maybeRunOnboarding(h.cmd); connect {
+ t.Fatalf("%s must not connect", answer)
+ }
+ if got := h.saved[len(h.saved)-1].Onboarding.Destination; got != answer {
+ t.Fatalf("recorded destination = %q, want %q", got, answer)
+ }
}
}
-func TestManagedIngestOfferRespectsOptOut(t *testing.T) {
+// BEACON_MANAGED_INGEST=0 hides the Asymptote row but the question is still asked.
+func TestDestinationQuestionHidesAsymptoteWhenOptedOut(t *testing.T) {
h := newOnboardingHarness(t)
- h.offerable = true
+ h.askable = true
t.Setenv(managedIngestEnvEnabled, "0")
+ h.answers.DestinationAsked = true
+ h.answers.Destination = onboarding.DestinationLocal
if connect, err := maybeRunOnboarding(h.cmd); err != nil || connect {
t.Fatalf("connect=%t err=%v", connect, err)
}
- if len(h.offered) != 1 || h.offered[0].OfferManagedIngest {
- t.Fatalf("BEACON_MANAGED_INGEST=0 must suppress the offer: %+v", h.offered)
+ if len(h.offered) != 1 || !h.offered[0].AskDestination || h.offered[0].OfferAsymptote {
+ t.Fatalf("BEACON_MANAGED_INGEST=0 must hide only the Asymptote row: %+v", h.offered)
+ }
+
+ h = newOnboardingHarness(t)
+ h.askable = true
+ t.Setenv(managedIngestEnvEnabled, "0")
+ h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
+ h.standaloneAnswer = onboarding.DestinationOwnInfra
+ if _, err := maybeRunOnboarding(h.cmd); err != nil || !h.standaloneAsked || h.standaloneOffered {
+ t.Fatalf("standalone question should be asked without the Asymptote row: err=%v asked=%t offered=%t", err, h.standaloneAsked, h.standaloneOffered)
}
}
-func TestManagedIngestOfferedOnceToPreviouslyOnboardedMachine(t *testing.T) {
+func TestDestinationAskedOnceToPreviouslyOnboardedMachine(t *testing.T) {
h := newOnboardingHarness(t)
- h.offerable = true
+ h.askable = true
h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", Outcome: onboarding.OutcomeSubmitted, Email: "[email protected]", Usage: onboarding.UsageWork}}
- h.standaloneAnswer = true
+ h.standaloneAnswer = onboarding.DestinationAsymptote
connect, err := maybeRunOnboarding(h.cmd)
if err != nil || !connect {
t.Fatalf("connect=%t err=%v", connect, err)
@@ -586,134 +602,143 @@ func TestManagedIngestOfferedOnceToPreviouslyOnboardedMachine(t *testing.T) {
if h.asked {
t.Fatal("the signup questions must not be asked again")
}
- if !h.standaloneAsked {
- t.Fatal("the forwarding question should be asked once on an already-onboarded machine")
+ if !h.standaloneAsked || !h.standaloneOffered {
+ t.Fatalf("the destination question should be asked once, with the Asymptote row: asked=%t offered=%t", h.standaloneAsked, h.standaloneOffered)
}
if len(h.saved) != 0 {
- t.Fatalf("a yes must not be recorded before the connect succeeds: %+v", h.saved)
+ t.Fatalf("asymptote must not be recorded before the connect succeeds: %+v", h.saved)
}
- // A no is recorded at once.
- h = newOnboardingHarness(t)
- h.offerable = true
- h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
- h.standaloneAnswer = false
- if connect, _ := maybeRunOnboarding(h.cmd); connect || !h.standaloneAsked {
- t.Fatalf("connect=%t asked=%t", connect, h.standaloneAsked)
- }
- if got := h.saved[len(h.saved)-1].Onboarding.ManagedIngest; got != onboarding.ManagedIngestDeclined {
- t.Fatalf("recorded choice = %q", got)
+ // Local and own infrastructure are recorded at once.
+ for _, answer := range []string{onboarding.DestinationLocal, onboarding.DestinationOwnInfra} {
+ h = newOnboardingHarness(t)
+ h.askable = true
+ h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
+ h.standaloneAnswer = answer
+ if connect, _ := maybeRunOnboarding(h.cmd); connect || !h.standaloneAsked {
+ t.Fatalf("connect=%t asked=%t", connect, h.standaloneAsked)
+ }
+ if got := h.saved[len(h.saved)-1].Onboarding.Destination; got != answer {
+ t.Fatalf("recorded destination = %q, want %q", got, answer)
+ }
}
// Once recorded, it is never asked again.
h = newOnboardingHarness(t)
- h.offerable = true
- h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", ManagedIngest: onboarding.ManagedIngestDeclined}}
+ h.askable = true
+ h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", Destination: onboarding.DestinationLocal}}
if connect, _ := maybeRunOnboarding(h.cmd); connect || h.standaloneAsked {
- t.Fatalf("a recorded choice must not be asked again: connect=%t asked=%t", connect, h.standaloneAsked)
+ t.Fatalf("a recorded destination must not be asked again: connect=%t asked=%t", connect, h.standaloneAsked)
}
// Non-interactive paths never see it either.
h = newOnboardingHarness(t)
- h.offerable = true
+ h.askable = true
h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
onboardingIsTTY = func() bool { return false }
if connect, _ := maybeRunOnboarding(h.cmd); connect || h.standaloneAsked {
t.Fatal("no terminal, no question")
}
h = newOnboardingHarness(t)
- h.offerable = true
+ h.askable = true
h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
t.Setenv("CI", "1")
if connect, _ := maybeRunOnboarding(h.cmd); connect || h.standaloneAsked {
t.Fatal("CI never sees the question")
}
+ // A connected endpoint has answered by doing.
+ h = newOnboardingHarness(t)
+ h.askable = false
+ h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
+ if connect, _ := maybeRunOnboarding(h.cmd); connect || h.standaloneAsked {
+ t.Fatal("a connected endpoint is not asked")
+ }
}
-// A yes whose install or connect failed must be asked again, not remembered as done: the
-// record is written only by recordManagedIngestAccepted, after the machine is connected.
-func TestManagedIngestAcceptedIsRecordedAfterConnect(t *testing.T) {
+// An Asymptote answer whose install or connect failed must be asked again, not remembered
+// as done: the record is written only by recordDestinationAsymptote, after the connect.
+func TestAsymptoteDestinationIsRecordedAfterConnect(t *testing.T) {
h := newOnboardingHarness(t)
- h.offerable = true
- h.answers.ManagedIngestOffered = true
- h.answers.ManagedIngest = true
+ h.askable = true
+ h.answers.DestinationAsked = true
+ h.answers.Destination = onboarding.DestinationAsymptote
if connect, err := maybeRunOnboarding(h.cmd); err != nil || !connect {
t.Fatalf("connect=%t err=%v", connect, err)
}
afterPrompt := h.saved[len(h.saved)-1]
- if afterPrompt.Onboarding.ManagedIngest != "" {
- t.Fatalf("recorded before connect: %q", afterPrompt.Onboarding.ManagedIngest)
+ if afterPrompt.Onboarding.Destination != "" {
+ t.Fatalf("recorded before connect: %q", afterPrompt.Onboarding.Destination)
}
// The install failed before connecting: the next interactive install asks again.
h2 := newOnboardingHarness(t)
- h2.offerable = true
+ h2.askable = true
h2.loaded = afterPrompt
- h2.standaloneAnswer = true
+ h2.standaloneAnswer = onboarding.DestinationAsymptote
if connect, err := maybeRunOnboarding(h2.cmd); err != nil || !connect || !h2.standaloneAsked || h2.asked {
t.Fatalf("connect=%t err=%v standaloneAsked=%t signupAsked=%t", connect, err, h2.standaloneAsked, h2.asked)
}
- // The install connected: the yes is recorded and the question retires.
+ // The install connected: the answer is recorded and the question retires.
h3 := newOnboardingHarness(t)
- h3.offerable = true
+ h3.askable = true
h3.loaded = afterPrompt
- recordManagedIngestAccepted(h3.cmd)
- if got := h3.saved[len(h3.saved)-1].Onboarding.ManagedIngest; got != onboarding.ManagedIngestAccepted {
- t.Fatalf("recorded choice = %q", got)
+ recordDestinationAsymptote(h3.cmd)
+ if got := h3.saved[len(h3.saved)-1].Onboarding.Destination; got != onboarding.DestinationAsymptote {
+ t.Fatalf("recorded destination = %q", got)
}
h4 := newOnboardingHarness(t)
- h4.offerable = true
+ h4.askable = true
h4.loaded = h3.saved[len(h3.saved)-1]
if connect, _ := maybeRunOnboarding(h4.cmd); connect || h4.standaloneAsked {
- t.Fatalf("a recorded yes must not be asked again: connect=%t asked=%t", connect, h4.standaloneAsked)
+ t.Fatalf("a recorded destination must not be asked again: connect=%t asked=%t", connect, h4.standaloneAsked)
}
// Never written for a machine that was not onboarded (root, CI, --connect without a prompt).
h5 := newOnboardingHarness(t)
- recordManagedIngestAccepted(h5.cmd)
+ recordDestinationAsymptote(h5.cmd)
if len(h5.saved) != 0 {
t.Fatalf("no profile should be written without a completed onboarding: %+v", h5.saved)
}
- // A recorded no stays a no even when an operator connects with --connect.
+ // A recorded local answer stays local even when an operator connects with --connect.
h6 := newOnboardingHarness(t)
- h6.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", ManagedIngest: onboarding.ManagedIngestDeclined}}
- recordManagedIngestAccepted(h6.cmd)
+ h6.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", Destination: onboarding.DestinationLocal}}
+ recordDestinationAsymptote(h6.cmd)
if len(h6.saved) != 0 {
- t.Fatalf("a declined answer must not be rewritten: %+v", h6.saved)
+ t.Fatalf("an owner's answer must not be rewritten: %+v", h6.saved)
}
}
// --connect is already the answer: the question is not asked on either the first-run
-// prompt or an already-onboarded machine, so a default Enter can never record "declined"
-// on a machine the same command then connects.
-func TestInstallConnectFlagSkipsManagedIngestQuestion(t *testing.T) {
+// prompt or an already-onboarded machine, so Enter can never record "local" on a machine
+// the same command then connects.
+func TestInstallConnectFlagSkipsDestinationQuestion(t *testing.T) {
h := newOnboardingHarness(t)
- h.offerable = true
+ h.askable = true
endpointOpts.connect = true
t.Cleanup(func() { endpointOpts.connect = false })
if connect, err := maybeRunOnboarding(h.cmd); err != nil || connect {
t.Fatalf("connect=%t err=%v", connect, err)
}
- if len(h.offered) != 1 || h.offered[0].OfferManagedIngest {
+ if len(h.offered) != 1 || h.offered[0].AskDestination {
t.Fatalf("--connect must not add the question to the first-run prompt: %+v", h.offered)
}
- if got := h.saved[len(h.saved)-1].Onboarding.ManagedIngest; got != "" {
+ if got := h.saved[len(h.saved)-1].Onboarding.Destination; got != "" {
t.Fatalf("recorded %q before the connect ran", got)
}
h = newOnboardingHarness(t)
- h.offerable = true
+ h.askable = true
h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z"}}
if connect, err := maybeRunOnboarding(h.cmd); err != nil || connect || h.standaloneAsked {
t.Fatalf("connect=%t err=%v asked=%t", connect, err, h.standaloneAsked)
}
- // After the connect the install records the yes, exactly as for an answered question.
- recordManagedIngestAccepted(h.cmd)
- if got := h.saved[len(h.saved)-1].Onboarding.ManagedIngest; got != onboarding.ManagedIngestAccepted {
- t.Fatalf("recorded choice = %q", got)
+ // After the connect the install records the answer, exactly as for an asked question.
+ recordDestinationAsymptote(h.cmd)
+ if got := h.saved[len(h.saved)-1].Onboarding.Destination; got != onboarding.DestinationAsymptote {
+ t.Fatalf("recorded destination = %q", got)
}
}
@@ -723,13 +748,27 @@ func TestInstallHasConnectFlag(t *testing.T) {
}
}
-func TestEndpointOnboardingShowsManagedIngestChoice(t *testing.T) {
+func TestEndpointOnboardingShowsDestination(t *testing.T) {
+ for value, want := range map[string]string{
+ onboarding.DestinationLocal: "Telemetry destination: local only",
+ onboarding.DestinationOwnInfra: "Telemetry destination: own infrastructure",
+ onboarding.DestinationAsymptote: "Telemetry destination: Asymptote Managed",
+ } {
+ h := newOnboardingHarness(t)
+ h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", Outcome: onboarding.OutcomeSubmitted, Email: "[email protected]", Usage: onboarding.UsageWork, Destination: value}}
+ if err := runEndpointOnboarding(h.cmd, nil); err != nil {
+ t.Fatal(err)
+ }
+ if !strings.Contains(h.stdout.String(), want) {
+ t.Fatalf("output = %s", h.stdout.String())
+ }
+ }
h := newOnboardingHarness(t)
- h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", Outcome: onboarding.OutcomeSubmitted, Email: "[email protected]", Usage: onboarding.UsageWork, ManagedIngest: onboarding.ManagedIngestAccepted}}
+ h.loaded = onboarding.Profile{InstallID: "abc", Onboarding: onboarding.Onboarding{CompletedAt: "2026-08-01T00:00:00Z", Outcome: onboarding.OutcomeSubmitted}}
if err := runEndpointOnboarding(h.cmd, nil); err != nil {
t.Fatal(err)
}
- if !strings.Contains(h.stdout.String(), "Managed ingest offer: accepted") {
- t.Fatalf("output = %s", h.stdout.String())
+ if strings.Contains(h.stdout.String(), "Telemetry destination") {
+ t.Fatalf("no destination line before the question is answered:\n%s", h.stdout.String())
}
}
diff --git a/cli/beacon/internal/onboarding/picker.go b/cli/beacon/internal/onboarding/picker.go
index 60491070..aee6afc1 100644
--- a/cli/beacon/internal/onboarding/picker.go
+++ b/cli/beacon/internal/onboarding/picker.go
@@ -28,10 +28,39 @@ const (
const (
colorReset = "\x1b[0m"
colorDim = "\x1b[2m"
- colorAccnt = "\x1b[38;5;141m" // the Beacon purple used by the root splash
+ colorAccnt = "\x1b[38;5;141m" // the Beacon purple used by the root splash
+ colorTitle = "\x1b[1;38;5;141m" // bold purple: every question title, so the prompt reads as one piece
colorGreen = "\x1b[32m"
)
+// choice is one row of a picker: a label and an optional one-line detail drawn dim
+// beneath it, for questions whose options need a sentence of explanation.
+type choice struct {
+ Label string
+ Detail string
+}
+
+func choices(labels []string) []choice {
+ rows := make([]choice, len(labels))
+ for i, label := range labels {
+ rows[i] = choice{Label: label}
+ }
+ return rows
+}
+
+// renderedLines is how many terminal lines a picker draws: one per option, one per
+// detail, and the key hint.
+func renderedLines(options []choice) int {
+ n := 1
+ for _, option := range options {
+ n++
+ if option.Detail != "" {
+ n++
+ }
+ }
+ return n
+}
+
// keyAction is what a keypress means to the picker.
type keyAction int
@@ -54,7 +83,7 @@ type keyEvent struct {
// The terminal is restored on every exit path, including Ctrl-C: raw mode disables
// the interrupt signal, so leaving without restoring would hand the user back a shell
// with no echo.
-func selectOption(in *os.File, out io.Writer, options []string, color bool) (int, error) {
+func selectOption(in *os.File, out io.Writer, options []choice, color bool) (int, error) {
fd := int(in.Fd())
state, err := term.MakeRaw(fd)
if err != nil {
@@ -74,7 +103,7 @@ func selectOption(in *os.File, out io.Writer, options []string, color bool) (int
for {
n, err := in.Read(buf)
if err != nil || n == 0 {
- clear(out, len(options)+1)
+ clear(out, renderedLines(options))
return 0, ErrPromptAborted
}
moved := false
@@ -87,13 +116,13 @@ func selectOption(in *os.File, out io.Writer, options []string, color bool) (int
selected = (selected + 1) % len(options)
moved = true
case keySelect:
- clear(out, len(options)+1)
+ clear(out, renderedLines(options))
return selected, nil
case keyPick:
- clear(out, len(options)+1)
+ clear(out, renderedLines(options))
return event.index, nil
case keyAbort:
- clear(out, len(options)+1)
+ clear(out, renderedLines(options))
return 0, ErrPromptAborted
}
}
@@ -162,9 +191,9 @@ func decodeByte(c byte, total int) (keyEvent, bool) {
}
// render draws the option list plus its key hint, overwriting the previous draw.
-func render(out io.Writer, options []string, selected int, color bool, first bool) {
+func render(out io.Writer, options []choice, selected int, color bool, first bool) {
if !first {
- fmt.Fprintf(out, ansiUp, len(options)+1)
+ fmt.Fprintf(out, ansiUp, renderedLines(options))
}
accent, dimmed, clear := "", "", ""
if color {
@@ -173,9 +202,13 @@ func render(out io.Writer, options []string, selected int, color bool, first boo
for i, option := range options {
fmt.Fprint(out, ansiClearLine)
if i == selected {
- fmt.Fprintf(out, " %s❯ %s%s\r\n", accent, option, clear)
+ fmt.Fprintf(out, " %s❯ %s%s\r\n", accent, option.Label, clear)
} else {
- fmt.Fprintf(out, " %s\r\n", option)
+ fmt.Fprintf(out, " %s\r\n", option.Label)
+ }
+ if option.Detail != "" {
+ fmt.Fprint(out, ansiClearLine)
+ fmt.Fprintf(out, " %s%s%s\r\n", dimmed, option.Detail, clear)
}
}
fmt.Fprint(out, ansiClearLine)
diff --git a/cli/beacon/internal/onboarding/picker_test.go b/cli/beacon/internal/onboarding/picker_test.go
index d77527b9..5af791ab 100644
--- a/cli/beacon/internal/onboarding/picker_test.go
+++ b/cli/beacon/internal/onboarding/picker_test.go
@@ -83,7 +83,7 @@ func assertEvents(t *testing.T, got, want []keyEvent) {
func TestRenderMarksTheSelectedOption(t *testing.T) {
var out bytes.Buffer
- render(&out, []string{"Alpha", "Beta", "Gamma"}, 1, false, true)
+ render(&out, choices([]string{"Alpha", "Beta", "Gamma"}), 1, false, true)
got := out.String()
if !strings.Contains(got, "❯ Beta") {
@@ -101,8 +101,8 @@ func TestRenderMarksTheSelectedOption(t *testing.T) {
// printed above the menu.
func TestRenderFirstDrawDoesNotMoveTheCursor(t *testing.T) {
var first, redraw bytes.Buffer
- render(&first, []string{"A", "B"}, 0, false, true)
- render(&redraw, []string{"A", "B"}, 0, false, false)
+ render(&first, choices([]string{"A", "B"}), 0, false, true)
+ render(&redraw, choices([]string{"A", "B"}), 0, false, false)
if strings.Contains(first.String(), "\x1b[3A") {
t.Fatalf("first draw moved the cursor up:\n%q", first.String())
@@ -114,13 +114,13 @@ func TestRenderFirstDrawDoesNotMoveTheCursor(t *testing.T) {
func TestRenderHonorsColorOff(t *testing.T) {
var out bytes.Buffer
- render(&out, []string{"Alpha", "Beta"}, 0, false, true)
+ render(&out, choices([]string{"Alpha", "Beta"}), 0, false, true)
if strings.Contains(out.String(), colorAccnt) || strings.Contains(out.String(), colorDim) {
t.Fatalf("colour escapes leaked with colour disabled:\n%q", out.String())
}
out.Reset()
- render(&out, []string{"Alpha", "Beta"}, 0, true, true)
+ render(&out, choices([]string{"Alpha", "Beta"}), 0, true, true)
if !strings.Contains(out.String(), colorAccnt) {
t.Fatalf("colour was requested but not emitted:\n%q", out.String())
}
@@ -136,7 +136,7 @@ func TestSelectOptionFallsBackWithoutATerminal(t *testing.T) {
}
defer file.Close()
- if _, err := selectOption(file, io.Discard, []string{"A", "B"}, false); !errors.Is(err, errRawUnavailable) {
+ if _, err := selectOption(file, io.Discard, choices([]string{"A", "B"}), false); !errors.Is(err, errRawUnavailable) {
t.Fatalf("selectOption error = %v, want errRawUnavailable", err)
}
}
@@ -185,3 +185,26 @@ func TestClearRewindsWhatItWiped(t *testing.T) {
t.Fatalf("clear did not park the cursor at the start of the block:\n%q", got)
}
}
+
+// A detail line is drawn dim under its option and counted when the menu is redrawn or
+// cleared, so a picker with descriptions never eats the lines above it.
+func TestRenderDrawsDetailsAndCountsThem(t *testing.T) {
+ rows := []choice{{Label: "Alpha", Detail: "first thing"}, {Label: "Beta"}, {Label: "Gamma", Detail: "third thing"}}
+ if got := renderedLines(rows); got != 6 {
+ t.Fatalf("renderedLines = %d, want 3 options + 2 details + hint", got)
+ }
+ var out bytes.Buffer
+ render(&out, rows, 0, true, true)
+ got := out.String()
+ if !strings.Contains(got, " "+colorDim+"first thing"+colorReset) || !strings.Contains(got, colorDim+"third thing") {
+ t.Fatalf("details are not drawn dim under their options:\n%q", got)
+ }
+ if strings.Index(got, "Alpha") > strings.Index(got, "first thing") || strings.Index(got, "first thing") > strings.Index(got, "Beta") {
+ t.Fatalf("detail must sit between its option and the next:\n%s", got)
+ }
+ var redraw bytes.Buffer
+ render(&redraw, rows, 1, false, false)
+ if !strings.HasPrefix(redraw.String(), "\x1b[6A") {
+ t.Fatalf("redraw must move up over options, details and hint:\n%q", redraw.String())
+ }
+}
diff --git a/cli/beacon/internal/onboarding/profile.go b/cli/beacon/internal/onboarding/profile.go
index 03479c91..93a89164 100644
--- a/cli/beacon/internal/onboarding/profile.go
+++ b/cli/beacon/internal/onboarding/profile.go
@@ -57,16 +57,18 @@ type Onboarding struct {
Email string `json:"email,omitempty"`
Usage string `json:"usage,omitempty"`
BeaconVersion string `json:"beacon_version,omitempty"`
- // ManagedIngest records the answer to the managed-forwarding offer: accepted or
- // declined. Empty means it has not been offered on this machine yet, so a later
- // interactive install may ask once.
- ManagedIngest string `json:"managed_ingest,omitempty"`
+ // Destination records where the user chose to send this machine's telemetry:
+ // local, own_infra or asymptote. Empty means the question has not been answered on
+ // this machine, so a later interactive install may ask once. asymptote is written
+ // only after the connect succeeds, so a failed connect is asked again.
+ Destination string `json:"destination,omitempty"`
}
-// Answers to the managed-forwarding offer.
+// Answers to the telemetry destination question.
const (
- ManagedIngestAccepted = "accepted"
- ManagedIngestDeclined = "declined"
+ DestinationLocal = "local"
+ DestinationOwnInfra = "own_infra"
+ DestinationAsymptote = "asymptote"
)
// Prompted reports whether this machine has already been through onboarding.
diff --git a/cli/beacon/internal/onboarding/prompt.go b/cli/beacon/internal/onboarding/prompt.go
index ea600303..ca316bf9 100644
--- a/cli/beacon/internal/onboarding/prompt.go
+++ b/cli/beacon/internal/onboarding/prompt.go
@@ -26,19 +26,26 @@ var ErrTooManyAttempts = errors.New("too many invalid answers")
type Answers struct {
Email string
Usage string
- // ManagedIngestOffered is true when the forwarding question was asked;
- // ManagedIngest is the answer.
- ManagedIngestOffered bool
- ManagedIngest bool
+ // DestinationAsked is true when the telemetry destination question was asked;
+ // Destination is the answer (DestinationLocal, DestinationOwnInfra or
+ // DestinationAsymptote).
+ DestinationAsked bool
+ Destination string
}
// PromptOptions tunes the one-time prompt.
type PromptOptions struct {
- // OfferManagedIngest adds the "forward to Asymptote Managed now?" question. The
- // caller decides whether it is offerable (Vector present, not already connected).
- OfferManagedIngest bool
+ // AskDestination adds the "where should this machine's telemetry go?" question. The
+ // caller decides whether to ask (not already connected, not forced by --connect).
+ AskDestination bool
+ // OfferAsymptote includes the Asymptote Managed row; BEACON_MANAGED_INGEST=0 hides it.
+ OfferAsymptote bool
}
+// ForwardingDocsURL is where the own-infrastructure answer points: the pack-by-pack
+// guide for shipping the local JSONL to a SIEM, observability platform or bucket.
+const ForwardingDocsURL = "https://docs.asymptotelabs.ai/log-forwarding"
+
// Prompt runs the one-time onboarding questions.
//
// On a real terminal the usage question is an arrow-key picker. Anywhere else -- a
@@ -54,7 +61,7 @@ func PromptWith(in io.Reader, out io.Writer, opts PromptOptions) (Answers, error
reader := bufio.NewReader(in)
fmt.Fprintln(out)
- fmt.Fprintf(out, " %sBeacon is free and open source.%s Sharing your email helps us\n", bold(color), reset(color))
+ fmt.Fprintf(out, " %sBeacon is free and open source.%s Sharing your email helps us\n", title(color), reset(color))
fmt.Fprintln(out, " prioritize which agent runtimes to support next.")
fmt.Fprintln(out)
@@ -75,60 +82,137 @@ func PromptWith(in io.Reader, out io.Writer, opts PromptOptions) (Answers, error
}
answers := Answers{Email: email, Usage: usage}
- if opts.OfferManagedIngest {
+ if opts.AskDestination {
fmt.Fprintln(out)
- connect, err := askManagedIngest(reader, out, color)
+ destination, err := askDestination(reader, in, out, color, opts.OfferAsymptote)
if err != nil {
return Answers{}, err
}
- answers.ManagedIngestOffered = true
- answers.ManagedIngest = connect
+ answers.DestinationAsked = true
+ answers.Destination = destination
}
fmt.Fprintln(out)
return answers, nil
}
-// AskManagedIngest asks only the forwarding question, for a machine that went through
+// AskDestination asks only the destination question, for a machine that went through
// onboarding before the question existed.
-func AskManagedIngest(in io.Reader, out io.Writer) (bool, error) {
+func AskDestination(in io.Reader, out io.Writer, offerAsymptote bool) (string, error) {
color := supportsColor(out)
fmt.Fprintln(out)
- answer, err := askManagedIngest(bufio.NewReader(in), out, color)
+ answer, err := askDestination(bufio.NewReader(in), in, out, color, offerAsymptote)
fmt.Fprintln(out)
return answer, err
}
-// askManagedIngest offers to connect this machine to Asymptote Managed. Default is no:
-// forwarding telemetry off the machine is a choice, never a side effect of Enter.
-func askManagedIngest(reader *bufio.Reader, out io.Writer, color bool) (bool, error) {
- fmt.Fprintf(out, " %sForward this machine's agent telemetry to Asymptote Managed?%s\n", bold(color), reset(color))
- fmt.Fprintln(out, " This opens your browser to sign in and approve this device; you can revoke it")
- fmt.Fprintln(out, " from the dashboard at any time. Nothing recorded before approval is sent.")
+// destinationChoice is one answer to the destination question.
+type destinationChoice struct {
+ value, label, detail string
+}
+
+// destinationChoices lists the answers in display order. Local is first so that Enter
+// never forwards anything: sending telemetry off the machine is a choice, never a default.
+func destinationChoices(offerAsymptote bool) []destinationChoice {
+ items := []destinationChoice{
+ {DestinationLocal, "Keep it on this machine", "Nothing is sent anywhere. Local JSONL and local dashboard; change it any time."},
+ {DestinationOwnInfra, "Forward to your own infrastructure", "SIEM, observability platform, or an S3/GCS bucket you own."},
+ }
+ if offerAsymptote {
+ items = append(items, destinationChoice{DestinationAsymptote, "Forward to Asymptote Managed", "Opens your browser to approve this device; revoke it from the dashboard any time."})
+ }
+ return items
+}
+
+// askDestination asks where this machine's telemetry should go. On a terminal it is the
+// same arrow-key picker as the usage question, with a line of detail under each row;
+// elsewhere it degrades to the numbered menu, where an empty answer means the first row.
+func askDestination(reader *bufio.Reader, in io.Reader, out io.Writer, color bool, offerAsymptote bool) (string, error) {
+ items := destinationChoices(offerAsymptote)
+ fmt.Fprintf(out, " %sWhere should this machine's agent telemetry go?%s\n\n", title(color), reset(color))
+
+ if tty, ok := terminalFile(in); ok {
+ rows := make([]choice, len(items))
+ for i, item := range items {
+ rows[i] = choice{Label: item.label, Detail: item.detail}
+ }
+ index, err := selectOption(tty, out, rows, color)
+ if err == nil {
+ printDestination(out, items[index], color)
+ return items[index].value, nil
+ }
+ if !errors.Is(err, errRawUnavailable) {
+ return "", ErrPromptAborted
+ }
+ }
+
+ for i, item := range items {
+ fmt.Fprintf(out, " %d) %s\n", i+1, item.label)
+ fmt.Fprintf(out, " %s%s%s\n", dim(color), item.detail, reset(color))
+ }
fmt.Fprintln(out)
for attempt := 0; attempt < maxAttempts; attempt++ {
- line, err := readLine(reader, out, " Connect now? [y/N] ")
+ line, err := readLine(reader, out, fmt.Sprintf(" Choice [1-%d] ", len(items)))
if err != nil {
- return false, err
+ return "", err
}
- switch strings.ToLower(strings.TrimSpace(line)) {
- case "", "n", "no":
- printChoice(out, "Not now. Run `beacon endpoint connect` whenever you are ready.", color)
- return false, nil
- case "y", "yes":
- printChoice(out, "Connecting after install.", color)
- return true, nil
+ if index, ok := parseDestination(line, items); ok {
+ printDestination(out, items[index], color)
+ return items[index].value, nil
}
- fmt.Fprintf(out, " %s✗ answer y or n%s\n", warn(color), reset(color))
+ fmt.Fprintf(out, " %s✗ enter a number from 1 to %d%s\n", warn(color), len(items), reset(color))
}
- return false, ErrTooManyAttempts
+ return "", ErrTooManyAttempts
+}
+
+// parseDestination accepts the row number, the stored value, or a plain word for it.
+// An empty answer is the first row, matching what Enter does in the picker.
+func parseDestination(line string, items []destinationChoice) (int, bool) {
+ answer := strings.ToLower(strings.TrimSpace(line))
+ if answer == "" {
+ return 0, true
+ }
+ for i, item := range items {
+ if answer == fmt.Sprint(i+1) || answer == item.value {
+ return i, true
+ }
+ }
+ aliases := map[string]string{
+ "local": DestinationLocal, "keep": DestinationLocal, "none": DestinationLocal,
+ "own": DestinationOwnInfra, "self": DestinationOwnInfra, "siem": DestinationOwnInfra,
+ "asymptote": DestinationAsymptote, "managed": DestinationAsymptote,
+ }
+ if value, ok := aliases[answer]; ok {
+ for i, item := range items {
+ if item.value == value {
+ return i, true
+ }
+ }
+ }
+ return 0, false
+}
+
+// printDestination confirms the choice and says what happens next.
+func printDestination(out io.Writer, item destinationChoice, color bool) {
+ fmt.Fprintf(out, " %s✓%s %s\n", ok(color), reset(color), item.label)
+ switch item.value {
+ case DestinationLocal:
+ fmt.Fprintf(out, " %sTo forward later: a forwarding pack (%s) or `beacon endpoint connect`.%s\n", dim(color), ForwardingDocsURL, reset(color))
+ case DestinationOwnInfra:
+ fmt.Fprintln(out, " Beacon keeps writing JSONL locally; a Vector pack ships it to your destination.")
+ fmt.Fprintf(out, " Set one up: %s%s%s\n", accent(color), ForwardingDocsURL, reset(color))
+ fmt.Fprintf(out, " %sPacks: beacon endpoint datadog | elastic | falcon | s3 | gcs | wazuh | sentinel … (--help lists them all)%s\n", dim(color), reset(color))
+ case DestinationAsymptote:
+ fmt.Fprintf(out, " %sConnecting after install.%s\n", dim(color), reset(color))
+ }
+ fmt.Fprintln(out)
}
func askUsage(reader *bufio.Reader, in io.Reader, out io.Writer, color bool) (string, error) {
- fmt.Fprintf(out, " %sHow are you using Beacon?%s\n\n", bold(color), reset(color))
+ fmt.Fprintf(out, " %sHow are you using Beacon?%s\n\n", title(color), reset(color))
if tty, ok := terminalFile(in); ok {
- index, err := selectOption(tty, out, UsageLabels, color)
+ index, err := selectOption(tty, out, choices(UsageLabels), color)
if err == nil {
printChoice(out, UsageLabels[index], color)
return ValidUsages[index], nil
@@ -165,7 +249,7 @@ func askUsage(reader *bufio.Reader, in io.Reader, out io.Writer, color bool) (st
func askEmail(reader *bufio.Reader, out io.Writer, color bool) (string, error) {
for attempt := 0; attempt < maxAttempts; attempt++ {
- line, err := readLine(reader, out, fmt.Sprintf(" %sEmail%s › ", bold(color), reset(color)))
+ line, err := readLine(reader, out, fmt.Sprintf(" %sEmail%s › ", title(color), reset(color)))
if err != nil {
return "", err
}
@@ -199,9 +283,16 @@ func readLine(reader *bufio.Reader, out io.Writer, prompt string) (string, error
// Colour helpers return empty strings when colour is off, so every format string can
// use them unconditionally.
-func bold(c bool) string {
+func title(c bool) string {
+ if c {
+ return colorTitle
+ }
+ return ""
+}
+
+func accent(c bool) string {
if c {
- return "\x1b[1m"
+ return colorAccnt
}
return ""
}
diff --git a/cli/beacon/internal/onboarding/prompt_test.go b/cli/beacon/internal/onboarding/prompt_test.go
index 27bdb672..a8080918 100644
--- a/cli/beacon/internal/onboarding/prompt_test.go
+++ b/cli/beacon/internal/onboarding/prompt_test.go
@@ -167,57 +167,97 @@ func TestPromptDoesNotNoteFreeMailboxForPersonalUse(t *testing.T) {
}
}
-func TestPromptOffersManagedIngestOnlyWhenAsked(t *testing.T) {
+func TestPromptAsksDestinationOnlyWhenRequested(t *testing.T) {
answers, out, err := runPrompt(t, "1\[email protected]\n")
if err != nil {
t.Fatalf("Prompt returned error: %v", err)
}
- if answers.ManagedIngestOffered || strings.Contains(out, "Asymptote Managed") {
- t.Fatalf("default prompt must not offer managed ingest: %+v\n%s", answers, out)
+ if answers.DestinationAsked || strings.Contains(out, "Where should") {
+ t.Fatalf("default prompt must not ask the destination question: %+v\n%s", answers, out)
}
var buf bytes.Buffer
- answers, err = PromptWith(strings.NewReader("1\[email protected]\ny\n"), &buf, PromptOptions{OfferManagedIngest: true})
+ answers, err = PromptWith(strings.NewReader("1\[email protected]\n3\n"), &buf, PromptOptions{AskDestination: true, OfferAsymptote: true})
if err != nil {
t.Fatalf("PromptWith returned error: %v", err)
}
- if !answers.ManagedIngestOffered || !answers.ManagedIngest {
- t.Fatalf("expected an accepted offer, got %+v", answers)
+ if !answers.DestinationAsked || answers.Destination != DestinationAsymptote {
+ t.Fatalf("expected the Asymptote answer, got %+v", answers)
}
- for _, want := range []string{"Forward this machine's agent telemetry to Asymptote Managed?", "revoke it", "Nothing recorded before approval is sent", "Connect now? [y/N]", "Connecting after install."} {
+ for _, want := range []string{
+ "Where should this machine's agent telemetry go?",
+ "Keep it on this machine", "Nothing is sent anywhere.",
+ "Forward to your own infrastructure", "SIEM, observability platform, or an S3/GCS bucket you own.",
+ "Forward to Asymptote Managed", "revoke it from the dashboard",
+ "Connecting after install.",
+ } {
if !strings.Contains(buf.String(), want) {
- t.Fatalf("offer output missing %q:\n%s", want, buf.String())
+ t.Fatalf("destination output missing %q:\n%s", want, buf.String())
}
}
}
-func TestManagedIngestOfferDefaultsToNo(t *testing.T) {
- for _, input := range []string{"\n", "n\n", "NO\n"} {
+// Enter (an empty answer in the typed menu) keeps telemetry local: forwarding is a choice.
+func TestDestinationDefaultsToLocal(t *testing.T) {
+ for _, input := range []string{"\n", "1\n", "local\n", "KEEP\n"} {
var buf bytes.Buffer
- answers, err := PromptWith(strings.NewReader("1\[email protected]\n"+input), &buf, PromptOptions{OfferManagedIngest: true})
+ answers, err := PromptWith(strings.NewReader("1\[email protected]\n"+input), &buf, PromptOptions{AskDestination: true, OfferAsymptote: true})
if err != nil {
t.Fatalf("input %q: %v", input, err)
}
- if !answers.ManagedIngestOffered || answers.ManagedIngest {
- t.Fatalf("input %q should decline, got %+v", input, answers)
+ if answers.Destination != DestinationLocal {
+ t.Fatalf("input %q should keep telemetry local, got %+v", input, answers)
}
- if !strings.Contains(buf.String(), "beacon endpoint connect") {
- t.Fatalf("declining should name the command to run later:\n%s", buf.String())
+ if !strings.Contains(buf.String(), "beacon endpoint connect") || !strings.Contains(buf.String(), ForwardingDocsURL) {
+ t.Fatalf("the local answer should say how to forward later:\n%s", buf.String())
}
}
var buf bytes.Buffer
- if _, err := PromptWith(strings.NewReader("1\[email protected]\nmaybe\nwhat\nhuh\n?\n!\n"), &buf, PromptOptions{OfferManagedIngest: true}); !errors.Is(err, ErrTooManyAttempts) {
+ if _, err := PromptWith(strings.NewReader("1\[email protected]\nmaybe\n9\nhuh\n?\n!\n"), &buf, PromptOptions{AskDestination: true, OfferAsymptote: true}); !errors.Is(err, ErrTooManyAttempts) {
t.Fatalf("expected ErrTooManyAttempts after repeated bad answers, got %v", err)
}
}
-func TestAskManagedIngestAlone(t *testing.T) {
+func TestDestinationOwnInfrastructurePointsAtTheDocs(t *testing.T) {
+ for _, input := range []string{"2\n", "own\n", "siem\n", "own_infra\n"} {
+ var buf bytes.Buffer
+ answers, err := PromptWith(strings.NewReader("1\[email protected]\n"+input), &buf, PromptOptions{AskDestination: true, OfferAsymptote: true})
+ if err != nil || answers.Destination != DestinationOwnInfra {
+ t.Fatalf("input %q: destination=%q err=%v", input, answers.Destination, err)
+ }
+ for _, want := range []string{ForwardingDocsURL, "beacon endpoint datadog", "Vector pack"} {
+ if !strings.Contains(buf.String(), want) {
+ t.Fatalf("own-infrastructure answer missing %q:\n%s", want, buf.String())
+ }
+ }
+ }
+}
+
+// BEACON_MANAGED_INGEST=0 hides the Asymptote row; the question is still asked.
+func TestDestinationHidesAsymptoteWhenNotOffered(t *testing.T) {
+ var buf bytes.Buffer
+ answers, err := PromptWith(strings.NewReader("1\[email protected]\n3\nasymptote\n2\n"), &buf, PromptOptions{AskDestination: true, OfferAsymptote: false})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if answers.Destination != DestinationOwnInfra {
+ t.Fatalf("with two rows, 3 and asymptote must be rejected and 2 accepted, got %+v", answers)
+ }
+ if strings.Contains(buf.String(), "Asymptote Managed") {
+ t.Fatalf("Asymptote row must be hidden:\n%s", buf.String())
+ }
+ if strings.Count(buf.String(), "enter a number from 1 to 2") != 2 {
+ t.Fatalf("expected two rejections:\n%s", buf.String())
+ }
+}
+
+func TestAskDestinationAlone(t *testing.T) {
var buf bytes.Buffer
- yes, err := AskManagedIngest(strings.NewReader("yes\n"), &buf)
- if err != nil || !yes {
- t.Fatalf("AskManagedIngest = %t, %v", yes, err)
+ destination, err := AskDestination(strings.NewReader("3\n"), &buf, true)
+ if err != nil || destination != DestinationAsymptote {
+ t.Fatalf("AskDestination = %q, %v", destination, err)
}
- if _, err := AskManagedIngest(strings.NewReader(""), &buf); !errors.Is(err, ErrPromptAborted) {
+ if _, err := AskDestination(strings.NewReader(""), &buf, true); !errors.Is(err, ErrPromptAborted) {
t.Fatalf("EOF should abort, got %v", err)
}
}
diff --git a/docs/changelog/cli.mdx b/docs/changelog/cli.mdx
index 4dd827b5..510ae3ea 100644
--- a/docs/changelog/cli.mdx
+++ b/docs/changelog/cli.mdx
@@ -13,13 +13,17 @@ Stay up to date with the latest changes to the Agent Beacon CLI.
### v1.2.8 · September 4, 2026
-- **Onboarding offers managed forwarding** · When Vector is present, the
- first-run prompt asks one more question, whether to forward this machine's
- telemetry to Asymptote Managed (default no); yes runs `beacon endpoint connect`
- after the install. `beacon endpoint install --connect` forces it,
- `BEACON_MANAGED_INGEST=0` silences it, a no is recorded once per machine and a yes once the machine is connected
- and shown by `beacon endpoint onboarding`. The Homebrew formula now depends on
- `vector` so a Homebrew install can connect without a second step.
+- **Onboarding asks where telemetry should go** · The first-run prompt ends with
+ an arrow-key question: keep telemetry on this machine (default), forward it to
+ your own infrastructure (a SIEM, observability platform, or an S3/GCS bucket you
+ own, with a pointer to the log forwarding docs), or forward it to Asymptote
+ Managed, which runs `beacon endpoint connect` after the install. Question titles
+ and the selected row use the Beacon purple. `beacon endpoint install --connect`
+ skips the question and connects, `BEACON_MANAGED_INGEST=0` hides the Asymptote
+ answer, the answer stays local and is shown by `beacon endpoint onboarding`; the
+ Asymptote answer is recorded only once the machine is connected. The Homebrew
+ formula now depends on `vector` so a Homebrew install can connect without a
+ second step.
- **`beacon endpoint connect` and `disconnect`** · Connect an endpoint to
Asymptote managed ingest from the CLI: it finds Vector (0.56+), opens the
dashboard's device approval page, receives a per-device key through a
diff --git a/docs/cli/endpoint-install.mdx b/docs/cli/endpoint-install.mdx
index 69f9b9a3..4703c3f2 100644
--- a/docs/cli/endpoint-install.mdx
+++ b/docs/cli/endpoint-install.mdx
@@ -45,9 +45,17 @@ By default, Beacon configures Claude Code and Codex CLI telemetry for local or c
| `--falcon-ca-file <path>` | Optional CA certificate path for Falcon LogScale HEC TLS verification |
| `--connect` | After a successful install, connect this endpoint to Asymptote managed ingest: opens the dashboard to approve the device and starts the Vector forwarder. Same as running [`beacon endpoint connect`](/cli/endpoint-connect) afterwards |
-## Managed ingest offer
+## Telemetry destination question
-On a first interactive install where Vector is available, the [onboarding prompt](/cli/endpoint-onboarding) ends with one more question: whether to forward this machine's agent telemetry to Asymptote Managed now. The default is no. Answering yes runs the connect flow after the install completes; a failed connect is reported with the retry command and never fails the install. `--connect` is already the answer, so it skips the question. `BEACON_MANAGED_INGEST=0` suppresses the question and it is never shown non-interactively. A no is recorded at once and the question is not asked again. A yes is recorded only once the machine is connected, so if the install or the connection fails, the next interactive install asks again.
+On a first interactive install the [onboarding prompt](/cli/endpoint-onboarding) ends with one more question, where this machine's agent telemetry should go, as an arrow-key menu with three answers:
+
+| Answer | What happens |
+|--------|--------------|
+| Keep it on this machine (default) | Nothing is forwarded. Enter picks this, so forwarding is never a side effect. |
+| Forward to your own infrastructure | A SIEM, observability platform, or an S3/GCS bucket you own. The prompt prints the [log forwarding docs](/log-forwarding) and the pack commands; the install stays local until you set one up. |
+| Forward to Asymptote Managed | Runs the [connect flow](/cli/endpoint-connect) after the install completes. A failed connect is reported with the retry command and never fails the install. |
+
+`--connect` is already the answer, so it skips the question. `BEACON_MANAGED_INGEST=0` hides the Asymptote answer; the question is never shown non-interactively. The answer is stored in the local onboarding profile and never sent. Local and own-infrastructure answers are recorded at once and the question is not asked again. The Asymptote answer is recorded only once the machine is connected, so if the install or the connection fails, the next interactive install asks again.
## Examples
diff --git a/docs/cli/endpoint-onboarding.mdx b/docs/cli/endpoint-onboarding.mdx
index f9a276dd..a45a43f8 100644
--- a/docs/cli/endpoint-onboarding.mdx
+++ b/docs/cli/endpoint-onboarding.mdx
@@ -18,7 +18,7 @@ Beacon does not ask again.
## First-run onboarding
The first interactive `beacon endpoint install` asks two questions, how you are using Beacon and your email, then sends the answers to Asymptote once. This is how we decide
-which agent runtimes and integrations to build next. When Vector is available on the machine it asks a third question, whether to forward this machine's telemetry to Asymptote Managed now; that answer stays local and, if yes, runs [`beacon endpoint connect`](/cli/endpoint-connect) after the install.
+which agent runtimes and integrations to build next. It then asks a third question, where this machine's telemetry should go: keep it on the machine, forward it to your own infrastructure (a SIEM, observability platform, or an S3/GCS bucket you own, with a pointer to the [log forwarding docs](/log-forwarding)), or forward it to Asymptote Managed, which runs [`beacon endpoint connect`](/cli/endpoint-connect) after the install. That answer stays local and is never sent.
What is sent, and nothing else:
@@ -53,8 +53,8 @@ skip it silently.
Set `BEACON_ONBOARDING=0` to suppress the prompt on an install that would otherwise be
interactive. There is no CLI flag for this: it exists for unattended CI and MDM
-workflows. `BEACON_MANAGED_INGEST=0` suppresses only the managed-forwarding question;
-`beacon endpoint install --connect` still connects when asked explicitly.
+workflows. `BEACON_MANAGED_INGEST=0` hides only the Asymptote Managed answer from the
+destination question; `beacon endpoint install --connect` still connects when asked explicitly.
```bash title="Suppress the prompt"
BEACON_ONBOARDING=0 beacon endpoint install
@@ -73,9 +73,10 @@ is reported on stderr and ignored rather than failing the install.
## Examples
-Show what was recorded, including the answer to the managed-forwarding question
-(`Managed ingest offer: accepted` or `declined`; absent when it has not been asked, or when
-a yes has not yet been carried through to a connected machine):
+Show what was recorded, including the answer to the destination question
+(`Telemetry destination: local only …`, `own infrastructure …` or `Asymptote Managed`; absent
+when it has not been asked, or when an Asymptote answer has not yet been carried through to a
+connected machine):
```bash title="Show the onboarding record"
beacon endpoint onboarding