Skip to content

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

Add the Asymptote managed forwarding pack (beacon endpoint asymptote)

shukieshah024e43af390b
diff --git a/CLAUDE.md b/CLAUDE.md
index d99cc8ce..8b16966f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,7 +18,8 @@ Do not recreate or depend on removed `asymptote` mirror trees. Keep new work foc
## Product Posture
- 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 product posture. The public Beacon build should not require a hosted account, remote policy fetch, hosted dashboard, or external network dependency during normal hook execution.
+- 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://`.
- One narrow, deliberate exception to the no-network posture: `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. 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.
@@ -49,7 +50,7 @@ Supported runtime surfaces today:
Current non-goals unless explicitly requested:
- Kernel/process monitoring, EDR replacement, shell history scraping, cloud audit ingestion, general browser or SaaS activity monitoring beyond the supported chat surfaces, credential-use attribution, and MCP configuration inventory.
-- Direct hosted integrations for Datadog, Snowflake, Chronicle, Panther, or other SIEM destinations beyond explicitly supported local/customer-managed forwarding patterns.
+- Direct hosted integrations for Datadog, Snowflake, Chronicle, Panther, or other SIEM destinations beyond explicitly supported local/customer-managed forwarding patterns and the opt-in Asymptote Managed path.
- Dependency vulnerability scanning or package security remediation.
## Common Commands
@@ -145,6 +146,17 @@ go run . endpoint fx status # sessions fx has written and how much Beacon
go run . endpoint fx sync --print # map records to events without writing anything
```
+Run the Asymptote Managed forwarder by hand during manual testing (needs a device key from
+enrollment and Vector on the machine; `/opt/beacon/bin/vector` from the signed package works):
+
+```bash
+cd cli/beacon
+go run . endpoint asymptote install-pack --output /tmp/beacon-asymptote-pack --log-path "$HOME/.beacon/endpoint/logs/runtime.jsonl"
+BEACON_ASYMPTOTE_INGEST_URL=https://<ingest> BEACON_ASYMPTOTE_SECRETS_FILE=/path/to/secrets.json BEACON_ASYMPTOTE_DATA_DIR=/tmp/beacon-asymptote-data \
+ vector validate --skip-healthchecks /tmp/beacon-asymptote-pack/vector.toml
+go run . endpoint asymptote validate # writes a validation event the forwarder ships
+```
+
Run the local dashboard during manual testing:
```bash
diff --git a/README.md b/README.md
index 4c9812dd..51271318 100644
--- a/README.md
+++ b/README.md
@@ -137,7 +137,13 @@ to compare it with the managed path.
Beacon writes endpoint telemetry to local JSONL by default and supports
customer-controlled forwarding into SIEM, log aggregation, and object storage
-destinations.
+destinations, plus an opt-in managed path to the Asymptote dashboard.
+
+#### Asymptote Managed
+
+| Destination | Support path |
+| --- | --- |
+| [Asymptote Managed](https://docs.asymptotelabs.ai/log-forwarding/asymptote) | Vector `http` forwarder over endpoint JSONL with a per-device key approved in the browser; revocable from the dashboard |
#### Security Information and Event Management (SIEM)
diff --git a/SECURITY.md b/SECURITY.md
index 6281ddc8..7cd4cfd4 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -68,6 +68,14 @@ active log rotates at 10 MiB and Beacon keeps up to five numbered local
archives. Normal endpoint collection does not require a hosted account, remote
policy fetch, MDM API credentials, or external network connection.
+The one opt-in network channel for telemetry is Asymptote Managed forwarding:
+a Vector forwarder on the endpoint posts the local runtime and inventory JSONL
+over HTTPS with a per-device key that a member of the organization approved in
+the browser. The key lives in a `0600` secrets file outside Beacon
+configuration, hooks never touch the network, and revoking the device from the
+Asymptote dashboard stops ingestion within about a minute. See
+[Asymptote Managed](https://docs.asymptotelabs.ai/log-forwarding/asymptote).
+
See paths, permissions, network behavior, and uninstall guarantees in
[endpoint operations](https://docs.asymptotelabs.ai/cli/security-review-endpoint-operations).
diff --git a/cli/beacon/cmd/endpoint_destinations.go b/cli/beacon/cmd/endpoint_destinations.go
index 2c28caf5..876db54f 100644
--- a/cli/beacon/cmd/endpoint_destinations.go
+++ b/cli/beacon/cmd/endpoint_destinations.go
@@ -5,6 +5,7 @@ import (
"github.com/spf13/cobra"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/asymptote"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/cloudwatch"
endpointconfig "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/config"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/datadog"
@@ -309,6 +310,31 @@ var siemDestinations = []siemDestination{
},
},
},
+ {
+ name: "asymptote",
+ short: "Manage Asymptote managed forwarding content",
+ printConfig: &destPrintConfig{
+ short: "Print the Vector config that forwards Beacon endpoint events to Asymptote",
+ render: func(cfg endpointconfig.Config) (string, error) { return asymptote.VectorConfig(cfg.LogPath) },
+ },
+ installPack: &destInstallPack{
+ short: "Write Asymptote managed forwarding content to a directory",
+ defaultOutputDir: asymptote.DefaultOutputDir,
+ successLabel: "Asymptote managed forwarding content pack written to ",
+ outputFlagHelp: "Output directory for Asymptote managed forwarding content pack",
+ install: asymptote.InstallPack,
+ },
+ validate: &destValidate{
+ short: "Write and describe an Asymptote validation event",
+ mode: "asymptote_managed_http",
+ message: "Beacon endpoint Asymptote validation event",
+ print: func(cfg endpointconfig.Config) {
+ fmt.Println("Expected Asymptote fields: vendor=beacon product=endpoint-agent destination.type=asymptote destination.mode=asymptote_managed_http")
+ fmt.Println(`Check the device key: curl -sS -o /dev/null -w '%{http_code}\n' "$BEACON_ASYMPTOTE_INGEST_URL/v1/ingest/health" -H "Authorization: Bearer $(sed -n 's/.*\"device_key\": *\"\([^\"]*\)\".*/\1/p' "$BEACON_ASYMPTOTE_SECRETS_FILE")" # 200 valid, 401 revoked`)
+ fmt.Println("Confirm delivery on the Asymptote dashboard telemetry page by searching for \"Beacon endpoint Asymptote validation event\"; forwarded events appear within a minute or two.")
+ },
+ },
+ },
{
name: "sentinel",
short: "Manage Microsoft Sentinel integration content",
diff --git a/cli/beacon/cmd/endpoint_destinations_characterization_test.go b/cli/beacon/cmd/endpoint_destinations_characterization_test.go
index e465b0c5..9a22f1dc 100644
--- a/cli/beacon/cmd/endpoint_destinations_characterization_test.go
+++ b/cli/beacon/cmd/endpoint_destinations_characterization_test.go
@@ -111,6 +111,16 @@ func destinationCharCases() []destinationCharCase {
"Beacon endpoint GCS validation event",
},
},
+ {
+ group: "asymptote",
+ installLabel: "Asymptote managed forwarding content pack written to ",
+ validateWant: []string{
+ "Expected Asymptote fields: vendor=beacon product=endpoint-agent destination.type=asymptote destination.mode=asymptote_managed_http",
+ "/v1/ingest/health",
+ "200 valid, 401 revoked",
+ "Beacon endpoint Asymptote validation event",
+ },
+ },
{
group: "sentinel",
installLabel: "Microsoft Sentinel content pack written to ",
diff --git a/cli/beacon/cmd/endpoint_test.go b/cli/beacon/cmd/endpoint_test.go
index d87931ae..d5c9e081 100644
--- a/cli/beacon/cmd/endpoint_test.go
+++ b/cli/beacon/cmd/endpoint_test.go
@@ -694,6 +694,30 @@ func TestEndpointGCSCommandsRegistered(t *testing.T) {
}
}
+func TestEndpointAsymptoteCommandsRegistered(t *testing.T) {
+ for _, path := range [][]string{
+ {"asymptote", "print-config"},
+ {"asymptote", "install-pack"},
+ {"asymptote", "validate"},
+ } {
+ cmd, _, err := endpointCmd.Find(path)
+ if err != nil {
+ t.Fatalf("Find %v returned error: %v", path, err)
+ }
+ if cmd == nil || cmd.Use != path[len(path)-1] {
+ t.Fatalf("asymptote command %v not registered: %#v", path, cmd)
+ }
+ for _, name := range []string{"user", "system", "log-path"} {
+ if cmd.Flags().Lookup(name) == nil {
+ t.Fatalf("asymptote command %v missing --%s flag", path, name)
+ }
+ }
+ }
+ if findEndpointLeaf("asymptote", "install-pack").Flags().Lookup("output") == nil {
+ t.Fatal("asymptote install-pack command missing --output flag")
+ }
+}
+
func TestEndpointSentinelCommandsRegistered(t *testing.T) {
for _, path := range [][]string{
{"sentinel", "print-config"},
@@ -1930,6 +1954,14 @@ func TestSyntheticEventDestinations(t *testing.T) {
if gcsEvent.Message != "Beacon endpoint GCS validation event" {
t.Fatalf("gcs message = %q", gcsEvent.Message)
}
+
+ asymptoteEvent := syntheticEvent("asymptote")
+ if asymptoteEvent.Destination.Type != "asymptote" || asymptoteEvent.Destination.Mode != "asymptote_managed_http" {
+ t.Fatalf("asymptote destination = %#v", asymptoteEvent.Destination)
+ }
+ if asymptoteEvent.Message != "Beacon endpoint Asymptote validation event" {
+ t.Fatalf("asymptote message = %q", asymptoteEvent.Message)
+ }
}
func TestEndpointS3ValidatePrintsAWSCLIInspectionGuidance(t *testing.T) {
@@ -2060,6 +2092,44 @@ func TestEndpointGCSValidatePrintsGoogleCloudCLIInspectionGuidance(t *testing.T)
}
}
+func TestEndpointAsymptoteValidatePrintsCredentialAndDashboardGuidance(t *testing.T) {
+ home := t.TempDir()
+ t.Setenv("HOME", home)
+ logPath := filepath.Join(home, "runtime.jsonl")
+ oldLogPath := endpointOpts.logPath
+ oldUserMode := endpointOpts.userMode
+ oldSystemMode := endpointOpts.systemMode
+ endpointOpts.logPath = logPath
+ endpointOpts.userMode = true
+ endpointOpts.systemMode = false
+ t.Cleanup(func() {
+ endpointOpts.logPath = oldLogPath
+ endpointOpts.userMode = oldUserMode
+ endpointOpts.systemMode = oldSystemMode
+ })
+
+ output, err := runEndpointLeaf(t, "asymptote", "validate")
+ if err != nil {
+ t.Fatalf("asymptote validate returned error: %v", err)
+ }
+ for _, want := range []string{
+ "Validation event written to",
+ "destination.type=asymptote destination.mode=asymptote_managed_http",
+ "/v1/ingest/health",
+ "Beacon endpoint Asymptote validation event",
+ } {
+ if !strings.Contains(output, want) {
+ t.Fatalf("Asymptote validation output missing %q: %s", want, output)
+ }
+ }
+ if strings.Contains(output, "verified delivery") {
+ t.Fatalf("Asymptote validation output should not claim remote delivery verification: %s", output)
+ }
+ if strings.Contains(output, "bcn_device_") {
+ t.Fatalf("Asymptote validation output must not print a device key: %s", output)
+ }
+}
+
func captureStdout(t *testing.T, fn func() error) (string, error) {
t.Helper()
oldStdout := os.Stdout
diff --git a/cli/beacon/internal/endpoint/asymptote/asymptote.go b/cli/beacon/internal/endpoint/asymptote/asymptote.go
new file mode 100644
index 00000000..80d1b9f8
--- /dev/null
+++ b/cli/beacon/internal/endpoint/asymptote/asymptote.go
@@ -0,0 +1,160 @@
+// Package asymptote is the content pack for forwarding Beacon endpoint JSONL to
+// Asymptote's managed ingest service.
+//
+// It is the one destination that sends telemetry to an Asymptote-run endpoint,
+// so it is deliberately shaped like every other Vector pack: Beacon stays the
+// local JSONL producer, Vector does the network, and the device key lives in a
+// separate 0600 secrets file read through Vector's secret backend. The rendered
+// files are valid for running Vector by hand; `beacon endpoint connect` fills
+// the same template in for the managed forwarder service.
+package asymptote
+
+import (
+ "io/fs"
+ "strings"
+
+ "embed"
+
+ endpointconfig "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/config"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/siempack"
+)
+
+//go:embed pack/*
+var packFS embed.FS
+
+const (
+ // DefaultOutputDir is where install-pack writes when --output is omitted.
+ DefaultOutputDir = "beacon-asymptote-pack"
+
+ // EnvIngestURL, EnvSecretsFile and EnvDataDir are the environment variables the
+ // rendered vector.toml reads. connect writes them into the forwarder unit; a
+ // hand-run Vector exports them.
+ EnvIngestURL = "BEACON_ASYMPTOTE_INGEST_URL"
+ EnvSecretsFile = "BEACON_ASYMPTOTE_SECRETS_FILE"
+ EnvDataDir = "BEACON_ASYMPTOTE_DATA_DIR"
+
+ // SecretsKey is the JSON key inside the secrets file; the template references it
+ // as SECRET[beacon.device_key].
+ SecretsKey = "device_key"
+
+ // RuntimeIngestPath and InventoryIngestPath are appended to the ingest URL.
+ RuntimeIngestPath = "/v1/ingest/runtime"
+ InventoryIngestPath = "/v1/ingest/inventory"
+ // CredentialCheckPath answers 200 or 401 for a bearer device key. Vector's
+ // sink healthcheck sends its auth header, so pointing it here makes a revoked
+ // key visible at startup. HealthPath is the unauthenticated liveness probe.
+ CredentialCheckPath = "/v1/ingest/health"
+ HealthPath = "/health"
+)
+
+// DefaultLogPath is resolved per platform like the other packs.
+var DefaultLogPath = endpointconfig.SystemLogPath()
+
+const (
+ vectorAsset = "pack/vector.toml.tmpl"
+ smokeTestAsset = "pack/asymptote-ingest-smoke-test.sh.tmpl"
+)
+
+// File is the installable pack-file type, shared with siempack.
+type File = siempack.File
+
+var pack = siempack.Pack{
+ Label: "asymptote",
+ FS: packFS,
+ DefaultLogPath: DefaultLogPath,
+ DefaultOutputDir: DefaultOutputDir,
+ Assets: []siempack.Asset{
+ {Source: "pack/README.md", Name: "README.md"},
+ {Source: smokeTestAsset, Name: "asymptote-ingest-smoke-test.sh", TemplateLogPath: true},
+ {Source: "pack/sample-event.jsonl", Name: "sample-event.jsonl"},
+ {Source: vectorAsset, Name: "vector.toml", TemplateLogPath: true},
+ },
+}
+
+// mustRead returns the embedded asset at path or panics. Retained for test use.
+func mustRead(path string) string { return pack.MustRead(path) }
+
+// filesFromFS builds the file list from the supplied FS; tests use it to inject
+// read-error conditions.
+func filesFromFS(fsys fs.FS) ([]File, error) { return pack.WithFS(fsys).Files() }
+
+// Files returns all pack files, propagating any embedded asset read error.
+func Files() ([]File, error) { return pack.Files() }
+
+// VectorConfig returns the Vector forwarder config with logPath substituted. The
+// ingest URL, secrets file and data directory stay as environment references.
+func VectorConfig(logPath string) (string, error) { return pack.Render(vectorAsset, logPath) }
+
+// IngestSmokeTest returns the one-shot credential and upload check script with
+// logPath substituted.
+func IngestSmokeTest(logPath string) (string, error) { return pack.Render(smokeTestAsset, logPath) }
+
+// InstallPack writes the pack files to outputDir with logPath substituted.
+func InstallPack(outputDir, logPath string) error { return pack.Install(outputDir, logPath) }
+
+// RenderOptions are the concrete values a managed forwarder needs in place of the
+// template's environment references.
+type RenderOptions struct {
+ LogPath string
+ IngestURL string
+ SecretsFile string
+ DataDir string
+}
+
+// RenderVectorConfig returns vector.toml with every environment reference replaced
+// by a literal value, for a forwarder unit that must not depend on its
+// environment. It refuses non-https ingest URLs so a downgraded endpoint can never
+// receive a device key.
+func RenderVectorConfig(opts RenderOptions) (string, error) {
+ if !strings.HasPrefix(strings.ToLower(opts.IngestURL), "https://") {
+ return "", ErrInsecureIngestURL
+ }
+ if opts.SecretsFile == "" || opts.DataDir == "" {
+ return "", ErrIncompleteRender
+ }
+ content, err := VectorConfig(opts.LogPath)
+ if err != nil {
+ return "", err
+ }
+ ingest := strings.TrimRight(opts.IngestURL, "/")
+ replacements := []struct{ from, to string }{
+ {`"${` + EnvDataDir + `:-/var/lib/vector/beacon-asymptote}"`, tomlString(opts.DataDir)},
+ {`"${` + EnvSecretsFile + `}"`, tomlString(opts.SecretsFile)},
+ {`"${` + EnvIngestURL + `}` + RuntimeIngestPath + `"`, tomlString(ingest + RuntimeIngestPath)},
+ {`"${` + EnvIngestURL + `}` + InventoryIngestPath + `"`, tomlString(ingest + InventoryIngestPath)},
+ {`"${` + EnvIngestURL + `}` + CredentialCheckPath + `"`, tomlString(ingest + CredentialCheckPath)},
+ }
+ for _, r := range replacements {
+ content = strings.ReplaceAll(content, r.from, r.to)
+ }
+ if strings.Contains(content, "${"+EnvIngestURL) || strings.Contains(content, "${"+EnvSecretsFile) || strings.Contains(content, "${"+EnvDataDir) {
+ return "", ErrIncompleteRender
+ }
+ return content, nil
+}
+
+// tomlString quotes s as a TOML basic string.
+func tomlString(s string) string {
+ replacer := strings.NewReplacer(`\`, `\\`, `"`, `\"`, "\n", `\n`, "\t", `\t`)
+ return `"` + replacer.Replace(s) + `"`
+}
+
+// SecretsFileContent returns the JSON document the secrets file must hold for the
+// template's SECRET[beacon.device_key] reference.
+func SecretsFileContent(deviceKey string) string {
+ return `{"` + SecretsKey + `": ` + jsonString(deviceKey) + "}\n"
+}
+
+func jsonString(s string) string {
+ return `"` + siempack.JSONEscapeForString(s) + `"`
+}
+
+// Sentinel errors returned by RenderVectorConfig.
+type renderError string
+
+func (e renderError) Error() string { return string(e) }
+
+const (
+ ErrInsecureIngestURL renderError = "asymptote ingest URL must use https://"
+ ErrIncompleteRender renderError = "asymptote forwarder render needs ingest URL, secrets file and data dir"
+)
diff --git a/cli/beacon/internal/endpoint/asymptote/asymptote_test.go b/cli/beacon/internal/endpoint/asymptote/asymptote_test.go
new file mode 100644
index 00000000..7da534cd
--- /dev/null
+++ b/cli/beacon/internal/endpoint/asymptote/asymptote_test.go
@@ -0,0 +1,220 @@
+package asymptote
+
+import (
+ "bufio"
+ "encoding/json"
+ "errors"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "testing/fstest"
+)
+
+func TestVectorConfigForwardsBothStreamsOverHTTPWithABearerSecret(t *testing.T) {
+ got, err := VectorConfig("/tmp/beacon/runtime.jsonl")
+ if err != nil {
+ t.Fatalf("VectorConfig returned error: %v", err)
+ }
+ for _, want := range []string{
+ `include = ["/tmp/beacon/runtime.jsonl"]`,
+ `include = ["/tmp/beacon/inventory_state.jsonl"]`,
+ `read_from = "end"`,
+ `read_from = "beginning"`,
+ `[secret.beacon]`,
+ `type = "file"`,
+ `path = "${BEACON_ASYMPTOTE_SECRETS_FILE}"`,
+ `data_dir = "${BEACON_ASYMPTOTE_DATA_DIR:-/var/lib/vector/beacon-asymptote}"`,
+ `type = "http"`,
+ `uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/runtime"`,
+ `uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/inventory"`,
+ `uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/health"`,
+ `strategy = "bearer"`,
+ `token = "SECRET[beacon.device_key]"`,
+ `compression = "gzip"`,
+ `codec = "text"`,
+ `method = "newline_delimited"`,
+ `Content-Type = "application/x-ndjson"`,
+ `max_bytes = 5000000`,
+ `max_events = 5000`,
+ `type = "disk"`,
+ `when_full = "block"`,
+ `retry_max_duration_secs = 300`,
+ } {
+ if !strings.Contains(got, want) {
+ t.Fatalf("vector config missing %q:\n%s", want, got)
+ }
+ }
+ for _, forbidden := range []string{"{{LOG_PATH}}", "{{INVENTORY_LOG_PATH}}", "bcn_device", "parse_json"} {
+ if strings.Contains(got, forbidden) {
+ t.Fatalf("vector config must not contain %q:\n%s", forbidden, got)
+ }
+ }
+ // Only the secret reference may carry the key; a literal token would defeat the
+ // secrets file.
+ if strings.Count(got, "SECRET[beacon.device_key]") != 2 {
+ t.Fatalf("expected the two sinks to reference the secret exactly once each:\n%s", got)
+ }
+}
+
+func TestIngestSmokeTestChecksCredentialBeforePosting(t *testing.T) {
+ got, err := IngestSmokeTest("/tmp/beacon/runtime.jsonl")
+ if err != nil {
+ t.Fatalf("IngestSmokeTest returned error: %v", err)
+ }
+ for _, want := range []string{
+ `BEACON_LOG="${BEACON_LOG:-/tmp/beacon/runtime.jsonl}"`,
+ `BEACON_INVENTORY_LOG="${BEACON_INVENTORY_LOG:-/tmp/beacon/inventory_state.jsonl}"`,
+ "BEACON_ASYMPTOTE_INGEST_URL",
+ "BEACON_ASYMPTOTE_SECRETS_FILE",
+ "https://*)",
+ "/v1/ingest/health",
+ "/v1/ingest/runtime",
+ "/v1/ingest/inventory",
+ "Content-Encoding: gzip",
+ "Content-Type: application/x-ndjson",
+ "-H @",
+ "validation only",
+ } {
+ if !strings.Contains(got, want) {
+ t.Fatalf("smoke test missing %q:\n%s", want, got)
+ }
+ }
+ if strings.Contains(got, "{{LOG_PATH}}") {
+ t.Fatalf("smoke test still contains template token:\n%s", got)
+ }
+ if strings.Contains(got, `-H "Authorization: Bearer $`) {
+ t.Fatalf("smoke test must not pass the device key on the curl command line:\n%s", got)
+ }
+}
+
+func TestInstallPackWritesExpectedFilesWithSafeModes(t *testing.T) {
+ dir := t.TempDir()
+ if err := InstallPack(dir, "/tmp/beacon/runtime.jsonl"); err != nil {
+ t.Fatalf("InstallPack returned error: %v", err)
+ }
+ for _, name := range []string{"README.md", "asymptote-ingest-smoke-test.sh", "sample-event.jsonl", "vector.toml"} {
+ if _, err := os.Stat(filepath.Join(dir, name)); err != nil {
+ t.Fatalf("expected %s: %v", name, err)
+ }
+ }
+ script, err := os.Stat(filepath.Join(dir, "asymptote-ingest-smoke-test.sh"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if script.Mode().Perm()&0111 == 0 {
+ t.Fatalf("smoke test should be executable, mode=%s", script.Mode())
+ }
+ vectorPath := filepath.Join(dir, "vector.toml")
+ vectorConfig, err := os.ReadFile(vectorPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !strings.Contains(string(vectorConfig), "/tmp/beacon/runtime.jsonl") {
+ t.Fatalf("generated vector config missing configured log path: %s", vectorConfig)
+ }
+ if strings.Contains(string(vectorConfig), "bcn_device") {
+ t.Fatalf("generated vector config must never contain a device key: %s", vectorConfig)
+ }
+ info, err := os.Stat(vectorPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if info.Mode().Perm() != 0644 {
+ t.Fatalf("generated vector config should be 0644, mode=%s", info.Mode().Perm())
+ }
+}
+
+func TestSampleEventsAreValidBeaconEventsForThisDestination(t *testing.T) {
+ sample := mustRead("pack/sample-event.jsonl")
+ scanner := bufio.NewScanner(strings.NewReader(sample))
+ lines := 0
+ sawDestination := false
+ for scanner.Scan() {
+ line := strings.TrimSpace(scanner.Text())
+ if line == "" {
+ continue
+ }
+ lines++
+ var event map[string]any
+ if err := json.Unmarshal([]byte(line), &event); err != nil {
+ t.Fatalf("sample line %d is not JSON: %v", lines, err)
+ }
+ for _, key := range []string{"timestamp", "vendor", "product", "schema_version", "event"} {
+ if _, ok := event[key]; !ok {
+ t.Fatalf("sample line %d missing %q", lines, key)
+ }
+ }
+ if event["vendor"] != "beacon" || event["product"] != "endpoint-agent" {
+ t.Fatalf("sample line %d has wrong vendor/product: %v", lines, event)
+ }
+ if dest, ok := event["destination"].(map[string]any); ok {
+ sawDestination = true
+ if dest["type"] != "asymptote" || dest["mode"] != "asymptote_managed_http" {
+ t.Fatalf("sample destination = %v", dest)
+ }
+ }
+ }
+ if lines < 2 || !sawDestination {
+ t.Fatalf("expected several sample events including a validation event, got %d lines (destination seen: %t)", lines, sawDestination)
+ }
+}
+
+func TestRenderVectorConfigReplacesEveryEnvironmentReference(t *testing.T) {
+ got, err := RenderVectorConfig(RenderOptions{
+ LogPath: "/Users/me/.beacon/endpoint/logs/runtime.jsonl",
+ IngestURL: "https://ingest.example.test/",
+ SecretsFile: "/Users/me/.beacon/endpoint/asymptote/vector-secrets.json",
+ DataDir: "/Users/me/.beacon/endpoint/asymptote/vector-data",
+ })
+ if err != nil {
+ t.Fatalf("RenderVectorConfig returned error: %v", err)
+ }
+ for _, want := range []string{
+ `data_dir = "/Users/me/.beacon/endpoint/asymptote/vector-data"`,
+ `path = "/Users/me/.beacon/endpoint/asymptote/vector-secrets.json"`,
+ `uri = "https://ingest.example.test/v1/ingest/runtime"`,
+ `uri = "https://ingest.example.test/v1/ingest/inventory"`,
+ `uri = "https://ingest.example.test/v1/ingest/health"`,
+ `include = ["/Users/me/.beacon/endpoint/logs/runtime.jsonl"]`,
+ `token = "SECRET[beacon.device_key]"`,
+ } {
+ if !strings.Contains(got, want) {
+ t.Fatalf("rendered config missing %q:\n%s", want, got)
+ }
+ }
+ if strings.Contains(got, "${") {
+ t.Fatalf("rendered config still has environment references:\n%s", got)
+ }
+}
+
+func TestRenderVectorConfigRefusesInsecureOrIncompleteInput(t *testing.T) {
+ if _, err := RenderVectorConfig(RenderOptions{LogPath: "/tmp/r.jsonl", IngestURL: "http://ingest.example.test", SecretsFile: "/s", DataDir: "/d"}); !errors.Is(err, ErrInsecureIngestURL) {
+ t.Fatalf("expected ErrInsecureIngestURL, got %v", err)
+ }
+ if _, err := RenderVectorConfig(RenderOptions{LogPath: "/tmp/r.jsonl", IngestURL: "https://ingest.example.test"}); !errors.Is(err, ErrIncompleteRender) {
+ t.Fatalf("expected ErrIncompleteRender, got %v", err)
+ }
+}
+
+func TestSecretsFileContentIsTheShapeTheTemplateReads(t *testing.T) {
+ content := SecretsFileContent(`bcn_device_abcdefgh_` + strings.Repeat("x", 43))
+ var parsed map[string]string
+ if err := json.Unmarshal([]byte(content), &parsed); err != nil {
+ t.Fatalf("secrets content is not JSON: %v", err)
+ }
+ if !strings.HasPrefix(parsed[SecretsKey], "bcn_device_abcdefgh_") {
+ t.Fatalf("secrets content = %q", content)
+ }
+ quoted := SecretsFileContent(`a"b\c`)
+ if err := json.Unmarshal([]byte(quoted), &parsed); err != nil || parsed[SecretsKey] != `a"b\c` {
+ t.Fatalf("secrets content must escape the key: %q (%v)", quoted, err)
+ }
+}
+
+func TestFilesFromFSPropagatesReadErrors(t *testing.T) {
+ fsys := fstest.MapFS{"pack/README.md": &fstest.MapFile{Data: []byte("readme")}}
+ if _, err := filesFromFS(fsys); err == nil || !strings.Contains(err.Error(), "asymptote pack asset") {
+ t.Fatalf("expected a labelled asset read error, got %v", err)
+ }
+}
diff --git a/cli/beacon/internal/endpoint/asymptote/pack/README.md b/cli/beacon/internal/endpoint/asymptote/pack/README.md
new file mode 100644
index 00000000..559bc1d1
--- /dev/null
+++ b/cli/beacon/internal/endpoint/asymptote/pack/README.md
@@ -0,0 +1,102 @@
+# Beacon Endpoint Agent Asymptote Managed Forwarding Pack
+
+This pack forwards Beacon endpoint JSONL events to Asymptote's managed ingest
+service so they appear on the Asymptote dashboard. Beacon writes runtime
+activity to `runtime.jsonl` and configuration inventory to
+`inventory_state.jsonl`; Vector tails both files and POSTs gzip-compressed
+NDJSON batches over HTTPS with a per-device key.
+
+Forwarding is opt-in and revocable. Beacon's default posture is local-only;
+nothing in this pack runs until a device has been approved by a member of your
+Asymptote organization and Vector has been started with the resulting key.
+
+## What leaves the machine
+
+Every line of `runtime.jsonl` written after the forwarder starts, and every
+line of `inventory_state.jsonl`, exactly as Beacon wrote them locally. Local
+redaction, retention and size limits apply before a line is written, so they
+apply to what is forwarded. The ingest service adds a `tenant` block
+(organization, device, approving user, receive time) server-side and ignores
+any tenant fields sent by the client. Nothing else is sent: no prompts or files
+beyond what the events already contain, no environment variables, no shell
+history.
+
+## Prerequisites
+
+- Beacon endpoint installed and writing local JSONL.
+- Vector 0.56 or newer (`/opt/beacon/bin/vector` from the signed macOS
+ package, Homebrew's `vector`, or the Linux `vector` packages).
+- A device key and ingest URL from enrollment. `beacon endpoint connect`
+ performs enrollment and writes this configuration for you; use this pack when
+ you want to run or inspect the forwarder by hand.
+
+## Files
+
+- `vector.toml`: the forwarder. Reads the device key from a JSON secrets file
+ through Vector's `file` secret backend, so the key is in neither the config
+ nor the environment. Its startup healthcheck calls the authenticated
+ `/v1/ingest/health`, so a revoked key is reported when Vector starts.
+- `asymptote-ingest-smoke-test.sh`: one-shot credential check plus a manual
+ POST of the log tail, to prove the key works before starting Vector.
+- `sample-event.jsonl`: example Beacon events in the shape the service accepts.
+
+## Install
+
+```bash
+beacon endpoint asymptote install-pack --output ./beacon-asymptote-pack
+```
+
+The generated files point at the Beacon log path selected by the CLI:
+
+- User mode: `~/.beacon/endpoint/logs/runtime.jsonl`
+- System mode: `/var/log/beacon-agent/runtime.jsonl`
+- Custom mode: the value passed with `--log-path`
+
+The inventory log is the sibling `inventory_state.jsonl` in the same directory.
+
+## Run Vector by hand
+
+1. Put the device key in a file only the forwarder's user can read:
+
+ ```bash
+ umask 077
+ printf '{"device_key": "%s"}\n' "$DEVICE_KEY" > ~/.beacon/endpoint/asymptote/vector-secrets.json
+ ```
+
+2. Export the values the template reads and validate the config:
+
+ ```bash
+ export BEACON_ASYMPTOTE_INGEST_URL=https://<ingest host returned by enrollment>
+ export BEACON_ASYMPTOTE_SECRETS_FILE=~/.beacon/endpoint/asymptote/vector-secrets.json
+ export BEACON_ASYMPTOTE_DATA_DIR=~/.beacon/endpoint/asymptote/vector-data
+ mkdir -p "$BEACON_ASYMPTOTE_DATA_DIR"
+ vector validate ./beacon-asymptote-pack/vector.toml
+ vector --config ./beacon-asymptote-pack/vector.toml
+ ```
+
+3. Confirm delivery. `sh ./beacon-asymptote-pack/asymptote-ingest-smoke-test.sh`
+ checks the key against `GET /v1/ingest/health` (200 means valid, 401 means
+ revoked) and posts the log tail once. Events reach the dashboard's telemetry
+ page within a minute or two.
+
+## Wire contract
+
+- `POST <ingest url>/v1/ingest/runtime` and `/v1/ingest/inventory`,
+ `Authorization: Bearer bcn_device_…`, `Content-Type: application/x-ndjson`,
+ `Content-Encoding: gzip`. HTTPS only.
+- Limits: 8 MiB compressed, 10,000 lines and 1 MiB per line per request. The
+ template batches well below that.
+- `200` returns accepted and rejected line counts; `401` means the key is
+ unknown, revoked or expired, or the approving user is no longer a member of
+ the organization; `403` means the organization is not enabled for managed
+ ingest; `429` and `5xx` are retried by Vector; other `4xx` are dropped.
+- Revoking a device from the dashboard's Beacon Endpoints page takes effect at
+ the ingest service within about a minute. Vector then logs 401s and drops the
+ batches; re-run enrollment to issue a new key.
+
+## Offline behavior
+
+Vector keeps reading into a disk buffer (512 MiB for runtime, 256 MiB for
+inventory) while the network is unavailable and drains it on reconnect. The
+service accepts events with old timestamps; nothing is lost across a laptop
+sleeping or a flight, up to the buffer size.
diff --git a/cli/beacon/internal/endpoint/asymptote/pack/asymptote-ingest-smoke-test.sh.tmpl b/cli/beacon/internal/endpoint/asymptote/pack/asymptote-ingest-smoke-test.sh.tmpl
new file mode 100644
index 00000000..6f59dce9
--- /dev/null
+++ b/cli/beacon/internal/endpoint/asymptote/pack/asymptote-ingest-smoke-test.sh.tmpl
@@ -0,0 +1,74 @@
+#!/bin/sh
+# One-shot check that a device key can reach the Asymptote ingest service.
+# Posts the tail of the Beacon runtime log the way Vector does (gzip NDJSON,
+# bearer device key) and prints the service's response. Validation only; use
+# vector.toml for continuous forwarding.
+set -eu
+
+BEACON_LOG="${BEACON_LOG:-{{LOG_PATH}}}"
+BEACON_INVENTORY_LOG="${BEACON_INVENTORY_LOG:-{{INVENTORY_LOG_PATH}}}"
+BEACON_SMOKE_LINES="${BEACON_SMOKE_LINES:-100}"
+
+if [ -z "${BEACON_ASYMPTOTE_INGEST_URL:-}" ]; then
+ echo "BEACON_ASYMPTOTE_INGEST_URL is required (the https URL returned by enrollment)." >&2
+ exit 2
+fi
+case "$BEACON_ASYMPTOTE_INGEST_URL" in
+ https://*) ;;
+ *) echo "BEACON_ASYMPTOTE_INGEST_URL must be an https:// URL." >&2; exit 2 ;;
+esac
+if [ -z "${BEACON_ASYMPTOTE_SECRETS_FILE:-}" ] || [ ! -r "$BEACON_ASYMPTOTE_SECRETS_FILE" ]; then
+ echo "BEACON_ASYMPTOTE_SECRETS_FILE must point at a readable {\"device_key\": \"...\"} file." >&2
+ exit 2
+fi
+if [ ! -r "$BEACON_LOG" ]; then
+ echo "Beacon runtime log is not readable: $BEACON_LOG" >&2
+ exit 2
+fi
+for tool in curl gzip; do
+ command -v "$tool" >/dev/null 2>&1 || { echo "$tool is required for this smoke test." >&2; exit 2; }
+done
+
+# The key never touches the command line or the environment of a child process
+# other than curl, which reads it from a header file.
+header_file="$(mktemp)"
+trap 'rm -f "$header_file" "${body_file:-}"' EXIT
+device_key="$(sed -n 's/.*"device_key"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$BEACON_ASYMPTOTE_SECRETS_FILE" | head -n 1)"
+if [ -z "$device_key" ]; then
+ echo "No device_key found in $BEACON_ASYMPTOTE_SECRETS_FILE" >&2
+ exit 2
+fi
+printf 'Authorization: Bearer %s\n' "$device_key" > "$header_file"
+unset device_key
+
+echo "Credential check: GET ${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/health"
+health="$(curl -sS -o /dev/null -w '%{http_code}' -H @"$header_file" "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/health")"
+case "$health" in
+ 200) echo "Device key accepted (HTTP 200)." ;;
+ 401) echo "Device key rejected (HTTP 401): it was revoked, expired, or the approving user left the organization." >&2; exit 1 ;;
+ *) echo "Unexpected health response HTTP $health" >&2; exit 1 ;;
+esac
+
+body_file="$(mktemp)"
+tail -n "$BEACON_SMOKE_LINES" "$BEACON_LOG" | gzip -c > "$body_file"
+echo "Posting the last $BEACON_SMOKE_LINES runtime lines to ${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/runtime"
+curl -sS -w '\nHTTP %{http_code}\n' -X POST "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/runtime" \
+ -H @"$header_file" \
+ -H 'Content-Type: application/x-ndjson' \
+ -H 'Content-Encoding: gzip' \
+ --data-binary @"$body_file"
+
+if [ -r "$BEACON_INVENTORY_LOG" ]; then
+ tail -n 5 "$BEACON_INVENTORY_LOG" | gzip -c > "$body_file"
+ echo "Posting the last 5 inventory lines to ${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/inventory"
+ curl -sS -w '\nHTTP %{http_code}\n' -X POST "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/inventory" \
+ -H @"$header_file" \
+ -H 'Content-Type: application/x-ndjson' \
+ -H 'Content-Encoding: gzip' \
+ --data-binary @"$body_file"
+else
+ echo "Beacon inventory log is not readable yet, skipping optional upload: $BEACON_INVENTORY_LOG"
+fi
+
+echo "A 200 response lists accepted and rejected line counts and the object written. Events appear on the dashboard within a minute or two."
+echo "This script is for validation only; use vector.toml for production forwarding."
diff --git a/cli/beacon/internal/endpoint/asymptote/pack/vector.toml.tmpl b/cli/beacon/internal/endpoint/asymptote/pack/vector.toml.tmpl
new file mode 100644
index 00000000..56e9dbb1
--- /dev/null
+++ b/cli/beacon/internal/endpoint/asymptote/pack/vector.toml.tmpl
@@ -0,0 +1,116 @@
+# Beacon Endpoint Agent -> Asymptote managed ingest
+#
+# Vector tails Beacon's local JSONL streams and POSTs them, gzip-compressed and
+# newline-delimited, to the Asymptote ingest service with a per-device key.
+# The key is read from a 0600 JSON file through Vector's secret backend so it
+# appears in neither this config nor the process environment.
+#
+# Required environment:
+# BEACON_ASYMPTOTE_INGEST_URL https URL returned by device enrollment
+# BEACON_ASYMPTOTE_SECRETS_FILE path to a {"device_key": "<device key>"} file (mode 0600)
+# Optional:
+# BEACON_ASYMPTOTE_DATA_DIR Vector data_dir for checkpoints and the disk buffer
+#
+# `beacon endpoint connect` writes this file with the values filled in and runs
+# Vector as a service; this template is for running the same forwarder by hand.
+
+data_dir = "${BEACON_ASYMPTOTE_DATA_DIR:-/var/lib/vector/beacon-asymptote}"
+
+[secret.beacon]
+type = "file"
+path = "${BEACON_ASYMPTOTE_SECRETS_FILE}"
+
+[sources.beacon_runtime]
+type = "file"
+include = ["{{LOG_PATH}}"]
+# Nothing recorded before the device was approved is shipped.
+read_from = "end"
+
+[sources.beacon_inventory]
+type = "file"
+include = ["{{INVENTORY_LOG_PATH}}"]
+read_from = "beginning"
+
+# Each JSONL line is forwarded byte-for-byte as one NDJSON record (codec "text"
+# sends the file source's message field); the ingest service validates and
+# stamps tenant identity server-side, so no remap runs here.
+
+[sinks.asymptote_runtime]
+type = "http"
+inputs = ["beacon_runtime"]
+uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/runtime"
+method = "post"
+compression = "gzip"
+
+[sinks.asymptote_runtime.auth]
+strategy = "bearer"
+token = "SECRET[beacon.device_key]"
+
+[sinks.asymptote_runtime.encoding]
+codec = "text"
+
+[sinks.asymptote_runtime.framing]
+method = "newline_delimited"
+
+[sinks.asymptote_runtime.request.headers]
+Content-Type = "application/x-ndjson"
+
+[sinks.asymptote_runtime.batch]
+# Stays under the ingest service's 8 MiB compressed / 10,000 line limits.
+max_bytes = 5000000
+max_events = 5000
+timeout_secs = 60
+
+[sinks.asymptote_runtime.buffer]
+# Survives offline periods and forwarder restarts; drains on reconnect.
+type = "disk"
+max_size = 536870912
+when_full = "block"
+
+[sinks.asymptote_runtime.request]
+timeout_secs = 30
+retry_initial_backoff_secs = 2
+retry_max_duration_secs = 300
+
+# The healthcheck carries the bearer key, so a revoked or expired device shows up
+# as an unhealthy sink at startup (401) instead of silently dropping batches.
+[sinks.asymptote_runtime.healthcheck]
+uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/health"
+
+[sinks.asymptote_inventory]
+type = "http"
+inputs = ["beacon_inventory"]
+uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/inventory"
+method = "post"
+compression = "gzip"
+
+[sinks.asymptote_inventory.auth]
+strategy = "bearer"
+token = "SECRET[beacon.device_key]"
+
+[sinks.asymptote_inventory.encoding]
+codec = "text"
+
+[sinks.asymptote_inventory.framing]
+method = "newline_delimited"
+
+[sinks.asymptote_inventory.request.headers]
+Content-Type = "application/x-ndjson"
+
+[sinks.asymptote_inventory.batch]
+max_bytes = 5000000
+max_events = 5000
+timeout_secs = 60
+
+[sinks.asymptote_inventory.buffer]
+type = "disk"
+max_size = 268435488
+when_full = "block"
+
+[sinks.asymptote_inventory.request]
+timeout_secs = 30
+retry_initial_backoff_secs = 2
+retry_max_duration_secs = 300
+
+[sinks.asymptote_inventory.healthcheck]
+uri = "${BEACON_ASYMPTOTE_INGEST_URL}/v1/ingest/health"
diff --git a/docs/changelog/cli.mdx b/docs/changelog/cli.mdx
index 6f7aa499..348d9b0a 100644
--- a/docs/changelog/cli.mdx
+++ b/docs/changelog/cli.mdx
@@ -13,6 +13,14 @@ Stay up to date with the latest changes to the Agent Beacon CLI.
### Unreleased
+- **Asymptote Managed forwarding pack** · `beacon endpoint asymptote` generates a
+ Vector `http` forwarder that posts the runtime and inventory JSONL to
+ Asymptote's ingest service with a per-device key read from a `0600` secrets
+ file, plus a credential smoke test and sample events. It is the first Beacon
+ destination that sends events to an Asymptote-run service; forwarding is
+ opt-in per device, starts only after browser approval, and is revocable from
+ the dashboard. `beacon endpoint connect` (coming next) runs enrollment and the
+ forwarder as a service using the same template.
- **Removed `beacon login` and `beacon ingest`** · Neither command was ever
connected to a server: `beacon ingest endpoint upload` had nothing to upload
to and `beacon login` saved credentials nothing consumed. `beacon endpoint
diff --git a/docs/cli/asymptote.mdx b/docs/cli/asymptote.mdx
new file mode 100644
index 00000000..a2cd25bd
--- /dev/null
+++ b/docs/cli/asymptote.mdx
@@ -0,0 +1,156 @@
+---
+title: "beacon endpoint asymptote"
+description: "Generate the Vector forwarding pack that sends Beacon endpoint events to Asymptote's managed ingest service, and write validation events."
+---
+
+## Forwarding command
+
+Use `beacon endpoint asymptote` to generate the content pack that forwards Beacon endpoint events to Asymptote's managed ingest service. The pack keeps Beacon as a local JSONL producer: Vector tails the runtime and inventory logs and POSTs gzip-compressed NDJSON batches over HTTPS with a per-device key.
+
+This is the one destination that sends telemetry to an Asymptote-run endpoint. It is opt-in and revocable: nothing is forwarded until a member of your Asymptote organization has approved the device in the browser and Vector has been started with the resulting key. `beacon endpoint connect` performs that enrollment and runs the forwarder as a service; the commands on this page generate the same files for running or inspecting the forwarder by hand.
+
+Beacon does not store the device key in its own configuration. The key lives in a `0600` JSON secrets file that Vector reads through its secret backend, so it appears in neither `vector.toml` nor the process environment.
+
+```bash title="Command syntax"
+beacon endpoint asymptote [command]
+```
+
+## Commands
+
+<Columns cols={2}>
+ <Card title="beacon endpoint asymptote print-config" icon="file-lines" href="#beacon-endpoint-asymptote-print-config">
+ Print the Vector forwarding config for the configured runtime log.
+ </Card>
+ <Card title="beacon endpoint asymptote install-pack" icon="box-archive" href="#beacon-endpoint-asymptote-install-pack">
+ Write the forwarding pack to a directory.
+ </Card>
+ <Card title="beacon endpoint asymptote validate" icon="check" href="#beacon-endpoint-asymptote-validate">
+ Write and describe a Beacon Asymptote validation event.
+ </Card>
+</Columns>
+
+## Runtime log paths
+
+| Mode | Path |
+|------|------|
+| User mode | `~/.beacon/endpoint/logs/runtime.jsonl` |
+| System mode | `/var/log/beacon-agent/runtime.jsonl` |
+
+The inventory log is the sibling `inventory_state.jsonl` in the same directory.
+
+## beacon endpoint asymptote print-config
+
+`beacon endpoint asymptote print-config` prints the Vector configuration that tails the selected Beacon runtime and inventory logs and posts them to the ingest service.
+
+```bash title="Print the configuration"
+beacon endpoint asymptote print-config
+```
+
+The printed config reads three environment variables:
+
+| Variable | Purpose |
+|----------|---------|
+| `BEACON_ASYMPTOTE_INGEST_URL` | The `https://` ingest URL returned by enrollment. Required. |
+| `BEACON_ASYMPTOTE_SECRETS_FILE` | Path to a `{"device_key": "..."}` file with mode `0600`. Required. |
+| `BEACON_ASYMPTOTE_DATA_DIR` | Vector `data_dir` for checkpoints and the disk buffer. Defaults to `/var/lib/vector/beacon-asymptote`. |
+
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `--user` | Use per-user endpoint paths. Enabled by default |
+| `--system` | Use system endpoint paths and launch daemon |
+| `--log-path <path>` | Runtime JSONL log path |
+
+## beacon endpoint asymptote install-pack
+
+`beacon endpoint asymptote install-pack` writes the forwarding pack to a directory.
+
+```bash title="Generate the pack"
+beacon endpoint asymptote install-pack --output ./beacon-asymptote-pack
+```
+
+The pack includes:
+
+- `README.md` with the wire contract, what leaves the machine, and how to run Vector by hand.
+- `vector.toml`, the forwarder. Its startup healthcheck calls the authenticated `/v1/ingest/health`, so a revoked key is reported when Vector starts.
+- `asymptote-ingest-smoke-test.sh`, a one-shot credential check plus a manual POST of the log tail.
+- `sample-event.jsonl` with Beacon endpoint events in the shape the service accepts.
+
+### Examples
+
+```bash title="Generate a pack for a system-mode deployment"
+sudo /opt/beacon/bin/beacon endpoint asymptote install-pack \
+ --system \
+ --output ./beacon-asymptote-pack
+```
+
+```bash title="Run the forwarder by hand"
+umask 077
+printf '{"device_key": "%s"}\n' "$DEVICE_KEY" > ~/.beacon/endpoint/asymptote/vector-secrets.json
+export BEACON_ASYMPTOTE_INGEST_URL=https://<ingest host returned by enrollment>
+export BEACON_ASYMPTOTE_SECRETS_FILE=~/.beacon/endpoint/asymptote/vector-secrets.json
+export BEACON_ASYMPTOTE_DATA_DIR=~/.beacon/endpoint/asymptote/vector-data
+mkdir -p "$BEACON_ASYMPTOTE_DATA_DIR"
+vector validate ./beacon-asymptote-pack/vector.toml
+vector --config ./beacon-asymptote-pack/vector.toml
+```
+
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `--output <dir>` | Output directory for the pack. Defaults to `beacon-asymptote-pack` |
+| `--user` | Use per-user endpoint paths. Enabled by default |
+| `--system` | Use system endpoint paths and launch daemon |
+| `--log-path <path>` | Runtime JSONL log path |
+
+## beacon endpoint asymptote validate
+
+`beacon endpoint asymptote validate` writes a Beacon validation event to the runtime JSONL log and prints the expected fields plus the credential check to run.
+
+```bash title="Run the validation check"
+beacon endpoint asymptote validate
+```
+
+The command writes the local event only. If the forwarder is running, the event reaches the ingest service within its batch window (60 seconds) and appears on the dashboard telemetry page a minute or so later. Search for the message `Beacon endpoint Asymptote validation event`.
+
+Expected validation fields:
+
+```text
+vendor=beacon product=endpoint-agent destination.type=asymptote destination.mode=asymptote_managed_http
+```
+
+Check the device key without sending events:
+
+```bash
+curl -sS -o /dev/null -w '%{http_code}\n' "$BEACON_ASYMPTOTE_INGEST_URL/v1/ingest/health" \
+ -H "Authorization: Bearer $(sed -n 's/.*"device_key": *"\([^"]*\)".*/\1/p' "$BEACON_ASYMPTOTE_SECRETS_FILE")"
+```
+
+`200` means the key is valid; `401` means it was revoked, expired, or the approving user is no longer a member of the organization.
+
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `--user` | Use per-user endpoint paths. Enabled by default |
+| `--system` | Use system endpoint paths and launch daemon |
+| `--log-path <path>` | Runtime JSONL log path |
+
+## Related
+
+<Columns cols={2}>
+ <Card title="Asymptote managed forwarding" icon="tower-broadcast" href="/log-forwarding/asymptote">
+ Wire contract, what leaves the machine, revocation, and offline behavior.
+ </Card>
+ <Card title="Log forwarding" icon="tower-broadcast" href="/log-forwarding">
+ Review forwarding patterns and validation steps.
+ </Card>
+ <Card title="Endpoint agent" icon="desktop" href="/cli/endpoint">
+ Install and inspect the local endpoint agent.
+ </Card>
+ <Card title="Endpoint event schema" icon="code" href="/telemetry-schema/event-schema">
+ Review normalized Beacon JSONL fields and example events.
+ </Card>
+</Columns>
diff --git a/docs/docs.json b/docs/docs.json
index b99ac222..de262001 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -251,6 +251,12 @@
"root": "log-forwarding/index",
"pages": [
"log-forwarding/ci-telemetry-exports",
+ {
+ "group": "Asymptote Managed",
+ "pages": [
+ "log-forwarding/asymptote"
+ ]
+ },
{
"group": "Security Information and Event Management (SIEM)",
"pages": [
@@ -387,6 +393,7 @@
"cli/cloudwatch",
"cli/s3",
"cli/gcs",
+ "cli/asymptote",
"cli/hooks",
{
"group": "integrations",
diff --git a/docs/log-forwarding/asymptote.mdx b/docs/log-forwarding/asymptote.mdx
new file mode 100644
index 00000000..4056d98a
--- /dev/null
+++ b/docs/log-forwarding/asymptote.mdx
@@ -0,0 +1,73 @@
+---
+title: "Asymptote Managed"
+description: "Forward Beacon endpoint events to Asymptote's managed ingest service and see them on the Asymptote dashboard."
+---
+
+## Forwarding overview
+
+Asymptote Managed is the forwarding path that lands Beacon endpoint events on the Asymptote dashboard without any customer-run infrastructure. Beacon stays the local JSONL producer. A Vector forwarder on the endpoint tails the [runtime JSONL log](/concepts/core-concepts#runtime-jsonl-log) and the inventory log and POSTs gzip-compressed NDJSON batches over HTTPS to Asymptote's ingest service, authenticated with a key issued to that one device.
+
+This is the only Beacon destination that sends telemetry to an Asymptote-run endpoint, and it is opt-in. Beacon's default remains local-only; nothing is forwarded until a member of your Asymptote organization approves the device in the browser and the forwarder is started with the resulting key. Revoking the device from the dashboard's Beacon Endpoints page stops ingestion within about a minute.
+
+Generate the pack with [`beacon endpoint asymptote`](/cli/asymptote). `beacon endpoint connect` performs enrollment and runs the forwarder as a service; the pack is for running or inspecting the same forwarder by hand.
+
+## What leaves the machine
+
+Every line written to `runtime.jsonl` after the forwarder starts, and every line of `inventory_state.jsonl`, exactly as Beacon wrote them locally. Beacon's [retention and redaction](/security/retention-redaction) settings apply before a line is written, so they apply to what is forwarded. The ingest service adds a `tenant` block (organization, device, approving user, receive time) to every event server-side and ignores any tenant fields sent by the client.
+
+Nothing else is sent. The forwarder does not read prompts, files, environment variables, or shell history beyond what the events already contain.
+
+## How identity works
+
+Each enrolled machine gets its own key. Enrollment is a browser flow: the CLI registers the machine's hostname, operating system, and Beacon version, opens the dashboard, and a signed-in member of the organization chooses the organization and clicks Approve. The key is minted only after that click and is shown to the CLI once. It is stored in a `0600` secrets file that Vector reads through its secret backend, so the key is in neither `vector.toml` nor the environment of the Vector process.
+
+The ingest service checks three things on every request: the key is known and not revoked or expired, the user who approved the device is still a member of the organization, and the organization is enabled for managed ingest. Those checks are cached for one minute, which is the longest a revoked device can keep sending.
+
+## Wire contract
+
+- `POST <ingest url>/v1/ingest/runtime` and `POST <ingest url>/v1/ingest/inventory` with `Authorization: Bearer <device key>`, `Content-Type: application/x-ndjson`, and `Content-Encoding: gzip`. HTTPS only; the CLI and pack refuse other schemes.
+- Each line must be a Beacon endpoint event: `vendor=beacon`, `product=endpoint-agent`, `schema_version`, a parseable `timestamp`, and `event.kind` and `event.action`. Malformed lines are counted and reported; a batch fails only if every line is bad.
+- Limits per request: 8 MiB compressed, 10,000 lines, 1 MiB per line. The pack batches at 5 MB or 5,000 events or 60 seconds, whichever comes first.
+- Responses: `200` with accepted and rejected counts and the object written; `401` for an unknown, revoked, or expired key, or an approver who left the organization; `403` when the organization is not enabled; `413` when a limit is exceeded; `429` and `5xx` are retried by Vector with backoff. Other `4xx` responses are dropped, which is the intended behavior for a revoked key.
+- `GET /v1/ingest/health` (or `HEAD`) with the bearer key returns `200` or `401` and is the credential check the forwarder's startup healthcheck and the smoke-test script use.
+
+## Offline behavior
+
+Vector keeps reading into a disk buffer (512 MiB for runtime, 256 MiB for inventory) while the network is unavailable and drains it when connectivity returns. The service accepts events with old timestamps, so a laptop that was asleep or on a flight catches up without loss, up to the buffer size. A batch whose acknowledgement was lost is re-sent; the dashboard's storage collapses duplicates on Beacon's deterministic event id.
+
+## Install the pack
+
+```bash title="Generate the Asymptote pack for a system-mode deployment"
+sudo /opt/beacon/bin/beacon endpoint asymptote install-pack \
+ --system \
+ --output ./beacon-asymptote-pack
+```
+
+The pack includes `README.md`, `vector.toml`, `asymptote-ingest-smoke-test.sh`, and `sample-event.jsonl`. Run Vector by hand with the environment described in [`beacon endpoint asymptote print-config`](/cli/asymptote#beacon-endpoint-asymptote-print-config).
+
+## Validation
+
+1. Run `sh ./beacon-asymptote-pack/asymptote-ingest-smoke-test.sh` with `BEACON_ASYMPTOTE_INGEST_URL` and `BEACON_ASYMPTOTE_SECRETS_FILE` set. It checks the key (`200` valid, `401` revoked) and posts the log tail once.
+2. With Vector running, write a validation event: `beacon endpoint asymptote validate`.
+3. Within a minute or two, search the dashboard telemetry page for `Beacon endpoint Asymptote validation event`.
+
+## Revocation
+
+Revoke a device, or every device a person approved, from the dashboard's Beacon Endpoints page. The ingest service rejects the key within about a minute, Vector logs `401` responses and drops those batches, and the forwarder needs a new enrollment to resume. Removing a user from the organization has the same effect on every device they approved.
+
+## Related
+
+<Columns cols={2}>
+ <Card title="beacon endpoint asymptote" icon="terminal" href="/cli/asymptote">
+ Generate the pack, print the config, and write validation events.
+ </Card>
+ <Card title="Data flow and threat model" icon="shield" href="/security/data-flow-threat-model">
+ Where this channel sits among Beacon's trust boundaries.
+ </Card>
+ <Card title="Retention and redaction" icon="eye-slash" href="/security/retention-redaction">
+ Controls applied before events are written or forwarded.
+ </Card>
+ <Card title="Log forwarding" icon="tower-broadcast" href="/log-forwarding">
+ Every other destination Beacon supports.
+ </Card>
+</Columns>
diff --git a/docs/log-forwarding/index.mdx b/docs/log-forwarding/index.mdx
index e6e710d0..f7969bc0 100644
--- a/docs/log-forwarding/index.mdx
+++ b/docs/log-forwarding/index.mdx
@@ -7,7 +7,7 @@ description: "Forward Beacon endpoint events from local JSONL into SIEMs, log ag
Beacon writes normalized [endpoint events](/concepts/core-concepts#endpoint-event) as JSONL. The active [runtime log](/concepts/core-concepts#runtime-jsonl-log) is the handoff point for local review, [customer-managed log pipelines](/concepts/core-concepts#customer-managed-forwarding), log aggregators, object storage exporters, and most SIEM content packs. Beacon can also enable optional collector exporters for [Splunk HTTP Event Collector (HEC)](/concepts/core-concepts#splunk-hec) and [CrowdStrike Falcon LogScale HEC](/concepts/core-concepts#falcon-logscale-hec) during endpoint install or repair.
-Use the subpages below by destination category. SIEM pages are for destinations that become investigation or detection systems. Log aggregation pages are for customer-owned pipelines and observability stores that tail local JSONL. Object storage pages are for archival or data lake export. Local pages cover the default runtime log and dashboard source.
+Use the subpages below by destination category. Asymptote Managed is the one path that sends events to an Asymptote-run service; it is opt-in per device and revocable from the Asymptote dashboard. SIEM pages are for destinations that become investigation or detection systems. Log aggregation pages are for customer-owned pipelines and observability stores that tail local JSONL. Object storage pages are for archival or data lake export. Local pages cover the default runtime log and dashboard source.
For [ephemeral CI jobs](/concepts/core-concepts#ci-telemetry), see [CI Telemetry Exports](/log-forwarding/ci-telemetry-exports) for workflow artifacts, S3/GCS upload, and downstream handoff patterns over the completed CI `runtime.jsonl` file.
@@ -29,6 +29,19 @@ Use system mode for MDM deployments so endpoint events land in the shared system
## Destination categories
+### Asymptote Managed
+
+Use this path when Beacon events should appear on the Asymptote dashboard. A device key is issued only after a member of your organization approves the machine in the browser, and revoking it stops ingestion within a minute.
+
+<Columns cols={2}>
+ <Card title="Asymptote Managed" icon="tower-broadcast" href="/log-forwarding/asymptote">
+ Vector `http` forwarder over local JSONL with a per-device key; what leaves the machine, the wire contract, and revocation.
+ </Card>
+ <Card title="beacon endpoint asymptote" icon="terminal" href="/cli/asymptote">
+ Generate the pack, print the config, and write validation events.
+ </Card>
+</Columns>
+
### Security information and event management (SIEM)
Use these paths when the destination is the security investigation or detection system.
@@ -250,6 +263,18 @@ See [macOS System-Mode Object Storage Forwarding](/guides/macos-object-storage-s
for bucket creation, IAM, Vector `0.56` authentication limits, safe credential
delivery and rotation, and validation.
+### Asymptote Managed
+
+For the Asymptote dashboard, generate the Asymptote pack and run Vector with the device key and ingest URL issued by enrollment. `beacon endpoint connect` does this for you as a managed service.
+
+```bash title="Generate the integration pack"
+beacon endpoint asymptote install-pack --system --output ./beacon-asymptote-pack
+```
+
+The generated pack includes setup guidance, a Vector `http` sink template that reads the device key from a `0600` secrets file through Vector's secret backend, a one-shot credential and upload smoke-test script, and sample events. Only the runtime and inventory JSONL lines leave the machine; the ingest service stamps organization and device identity server-side.
+
+See [Asymptote Managed](/log-forwarding/asymptote) for the wire contract, revocation, and offline behavior.
+
### Vector log forwarding
Beacon `v0.0.26` added generated Vector configs to the Sumo Logic and Rapid7 content packs, Beacon `v0.0.37` added a Vector [AWS S3 content pack](/concepts/core-concepts#aws-s3-content-pack), Beacon `v0.0.38` added a Vector [Google Cloud Storage content pack](/concepts/core-concepts#google-cloud-storage-content-pack), Beacon `v0.0.42` added a Vector [AWS CloudWatch Logs content pack](/concepts/core-concepts#aws-cloudwatch-logs-content-pack), and Beacon `v0.0.49` added a CrowdStrike Falcon Vector path. Use these templates when you want [Vector forwarding](/concepts/core-concepts#vector-forwarding) to tail Beacon's local JSONL streams and forward events without storing destination secrets in Beacon endpoint configuration.
diff --git a/docs/security/data-flow-threat-model.mdx b/docs/security/data-flow-threat-model.mdx
index a9e716e9..05533993 100644
--- a/docs/security/data-flow-threat-model.mdx
+++ b/docs/security/data-flow-threat-model.mdx
@@ -28,16 +28,17 @@ flowchart LR
| Local storage | Beacon writes one JSON object per line to `runtime.jsonl` | Filesystem permissions and log ownership |
| Local inspection | The dashboard reads the runtime log over a loopback-only service | Local browser to local dashboard service |
| Optional forwarding | Wazuh, Elastic/Filebeat, Datadog Agent, Sumo Logic, Rapid7, Microsoft Sentinel, AWS S3, Google Cloud Storage, Splunk HEC, Falcon LogScale HEC, or customer-managed shippers read or receive events | Customer-managed network and SIEM boundary |
+| Asymptote Managed forwarding (opt-in) | A Vector forwarder posts runtime and inventory JSONL over HTTPS to Asymptote's ingest service with a per-device key issued after browser approval | Endpoint to Asymptote-run service; identity derived from the key, revocable from the dashboard |
## Threat model
| Risk | Design response |
|------|-----------------|
-| Unintended hosted telemetry | Normal endpoint collection writes local JSONL and does not require a Beacon-hosted account, remote policy fetch, or external network dependency |
+| Unintended hosted telemetry | Normal endpoint collection writes local JSONL and does not require a Beacon-hosted account, remote policy fetch, or external network dependency. Asymptote Managed forwarding starts only after a member of the organization approves the specific device in the browser, forwards only lines written after that approval, and stops within a minute of revocation |
| Network exposure of collectors | Default OTLP receivers bind to `127.0.0.1` rather than an externally reachable interface |
| Over-collection of prompt or diff content | Scope supported runtimes and hook deployment deliberately before rollout, and review destination access for retained local telemetry |
| Secret leakage in retained content | Beacon applies redaction, sanitization, truncation, and event-size limits before writing supported content fields |
-| Destination credential exposure | Persistent endpoint file-based destinations tail local JSONL, so Beacon endpoint configuration does not store Elastic, Datadog, Sumo Logic, Rapid7, Microsoft Sentinel, AWS, or Google Cloud credentials. Optional Splunk and Falcon tokens live in collector configuration. Self-serve cloud-agent uploads are a separate proof-of-concept path: scoped GCS or AWS credentials are injected into the provider-managed sandbox as runtime secrets and must be rotated and access-reviewed. |
+| Destination credential exposure | Persistent endpoint file-based destinations tail local JSONL, so Beacon endpoint configuration does not store Elastic, Datadog, Sumo Logic, Rapid7, Microsoft Sentinel, AWS, or Google Cloud credentials. Optional Splunk and Falcon tokens live in collector configuration. The Asymptote Managed device key is a per-machine credential stored in a `0600` secrets file read through Vector's secret backend, never in `config.json`, `vector.toml`, or the process environment; it grants only the right to post events for one device and is revocable from the dashboard. Self-serve cloud-agent uploads are a separate proof-of-concept path: scoped GCS or AWS credentials are injected into the provider-managed sandbox as runtime secrets and must be rotated and access-reviewed. |
| Removal uncertainty | Endpoint uninstall removes managed service and configuration state, with explicit `--keep-logs` and `--keep-config` exceptions |
## Current boundaries
diff --git a/docs/security/data-inventory.mdx b/docs/security/data-inventory.mdx
index c1381c82..830e23fe 100644
--- a/docs/security/data-inventory.mdx
+++ b/docs/security/data-inventory.mdx
@@ -93,6 +93,7 @@ By default, snapshots include config-file metadata, MCP server metadata, skill m
| `prompt` | Prompt text when retention allows it | `text` |
| `content` | Content handling state | `retention`, `included`, `redacted`, `truncated` |
| `destination` | Output or validation destination state | `type`, `mode`, `status` |
+| `tenant` | Added by Asymptote's ingest service to forwarded events only; never written locally | `organization_id`, `device_id`, `user_id`, `key_id`, `received_at` |
| `health` | Endpoint or component health state | `component`, `status`, `reason` |
Top-level `model`, `repository`, `branch`, `message`, `raw`, and `field_truncated` fields can add shared context across entities. Content-bearing fields follow the configured retention mode.