Merge origin/main into feat/automation-schedule-timezone

Point go-flashduty at 26910a1 so --timezone and the incident custom-field map both compile.

Author: debidong

go.mod

@@ -3,7 +3,7 @@ module github.com/flashcatcloud/flashduty-cli
 go 1.26.0
 
 require (
-	github.com/flashcatcloud/go-flashduty v0.15.12-0.20261009031927-7a88b4a32908
+	github.com/flashcatcloud/go-flashduty v0.15.13-0.20261009050530-26910a16529d
 	github.com/mattn/go-runewidth v0.0.30
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/pflag v1.0.10

go.sum

@@ -1,10 +1,8 @@
 github.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=
 github.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
-github.com/flashcatcloud/go-flashduty v0.15.10 h1:OfCx6EpF5tv+qSXGPZcEwEjXbo0KvQBOaw3ggWj+6Hs=
-github.com/flashcatcloud/go-flashduty v0.15.10/go.mod h1:YpHiTYXR5NXBI/rGRZfUy537XMkhdCkwA8NW1QoRHwk=
-github.com/flashcatcloud/go-flashduty v0.15.12-0.20261009031927-7a88b4a32908 h1:6gjBhoBX5PoY0bgFP5EnZw5lV+284HVwHylu3fDN2EI=
-github.com/flashcatcloud/go-flashduty v0.15.12-0.20261009031927-7a88b4a32908/go.mod h1:YpHiTYXR5NXBI/rGRZfUy537XMkhdCkwA8NW1QoRHwk=
+github.com/flashcatcloud/go-flashduty v0.15.13-0.20261009050530-26910a16529d h1:LU8KL6c3fSBVtevbAyLkzNcEltvtWH3wuqeQcNvKMjI=
+github.com/flashcatcloud/go-flashduty v0.15.13-0.20261009050530-26910a16529d/go.mod h1:YpHiTYXR5NXBI/rGRZfUy537XMkhdCkwA8NW1QoRHwk=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/mattn/go-runewidth v0.0.30 h1:+KUuiDA4fF0R1p5FeueHefjDm+GIM+kWfFnDjybOPgk=

internal/cli/alert.go

@@ -24,14 +24,14 @@ func newAlertCmd() *cobra.Command {
 }
 
 func newAlertListCmd() *cobra.Command {
-	var severity, channel, integration, since, until, fields string
-	var active, recovered, muted bool
+	var severity, channel, integration, since, until, fields, alertIDs, alertKeys string
+	var active, recovered, muted, asc, byUpdatedAt bool
 	var limit, page int
 
 	cmd := &cobra.Command{
 		Use:   "list",
 		Short: "List alerts",
-		Long:  curatedLong("List alerts within a time window, optionally filtered by severity, channel, active/recovered/muted state. No server-side title/text filter — to search by title, pipe --json to jq: 'select(.title|test(\"pat\";\"i\"))'. In json/toon mode, --fields projects each row to just the named fields (e.g. --fields alert_id,title,alert_severity,created_at) so you get a compact record without piping to jq. --limit max 100; --since/--until window must be < 31 days.", "Alerts", "ReadList"),
+		Long:  curatedLong("List alerts within a time window, optionally filtered by severity, channel, integration, alert ID/key, active/recovered/muted state. --asc sorts oldest first; --by-updated-at applies the window to last-updated time. No server-side title/text filter — to search by title, pipe --json to jq: 'select(.title|test(\"pat\";\"i\"))'. In json/toon mode, --fields projects each row to just the named fields (e.g. --fields alert_id,title,alert_severity,created_at) so you get a compact record without piping to jq. --limit max 100; --since/--until window must be < 31 days.", "Alerts", "ReadList"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return runCommand(cmd, args, func(ctx *RunContext) error {
 				if active && recovered {
@@ -54,6 +54,10 @@ func newAlertListCmd() *cobra.Command {
 				}
 				req.Limit = limit
 				req.Page = page
+				req.Asc = asc
+				req.ByUpdatedAt = byUpdatedAt
+				req.AlertIDs = parseStringSlice(alertIDs)
+				req.AlertKeys = parseStringSlice(alertKeys)
 
 				// Preserve legacy semantics: --active sends is_active=true,
 				// --recovered sends is_active=false, neither omits the filter.
@@ -118,6 +122,10 @@ func newAlertListCmd() *cobra.Command {
 	cmd.Flags().StringVar(&channel, "channel", "", "Comma-separated channel IDs")
 	cmd.Flags().StringVar(&integration, "integration", "", "Comma-separated integration IDs")
 	cmd.Flags().BoolVar(&muted, "muted", false, "Show ever-muted only")
+	cmd.Flags().StringVar(&alertIDs, "alert-ids", "", "Comma-separated alert IDs to return")
+	cmd.Flags().StringVar(&alertKeys, "alert-keys", "", "Comma-separated alert deduplication keys")
+	cmd.Flags().BoolVar(&asc, "asc", false, "Sort oldest first by start time (default newest first)")
+	cmd.Flags().BoolVar(&byUpdatedAt, "by-updated-at", false, "Apply --since/--until to the last-updated time instead of the start time")
 	cmd.Flags().StringVar(&since, "since", "24h", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
 	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 100)")

internal/cli/alert_event.go

@@ -20,6 +20,7 @@ func newAlertEventCmd() *cobra.Command {
 func newAlertEventListCmd() *cobra.Command {
 	var severity, channel, integration, integrationType, since, until, fields string
 	var limit, page int
+	var asc bool
 
 	cmd := &cobra.Command{
 		Use:   "list",
@@ -46,6 +47,7 @@ func newAlertEventListCmd() *cobra.Command {
 				}
 				input.Limit = limit
 				input.Page = page
+				input.Asc = asc
 
 				if severity != "" {
 					// go-flashduty takes severities as a comma-separated string.
@@ -120,6 +122,7 @@ func newAlertEventListCmd() *cobra.Command {
 	registerEnumFlag(cmd, "severity", severityEnum...)
 	cmd.Flags().StringVar(&integration, "integration", "", "Comma-separated integration IDs")
 	cmd.Flags().StringVar(&integrationType, "integration-type", "", "Comma-separated integration types (plugin keys, e.g. AliCloud,Prometheus) — not integration IDs; use --integration for that")
+	cmd.Flags().BoolVar(&asc, "asc", false, "Sort oldest first (default newest first)")
 	cmd.Flags().StringVar(&since, "since", "1h", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
 	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 100)")

internal/cli/alert_test.go

@@ -2,6 +2,8 @@ package cli
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 )
@@ -214,3 +216,86 @@ func TestCommandAlertMergeDataAndCommentFileBothStdinErrors(t *testing.T) {
 		t.Fatalf("[alert-merge-double-stdin] expected the double-stdin-read error naming both flags, got: %v", err)
 	}
 }
+
+func TestCommandAlertListFilterFlagsReachWire(t *testing.T) {
+	saveAndResetGlobals(t)
+	stub := newGFStub(t)
+
+	if _, err := execCommand("alert", "list", "--alert-ids", "a1,a2", "--alert-keys", "k1, k2", "--asc", "--by-updated-at"); err != nil {
+		t.Fatalf("[alert-list-filters] unexpected error: %v", err)
+	}
+	if stub.lastPath != "/alert/list" {
+		t.Fatalf("[alert-list-filters] expected /alert/list, got %q", stub.lastPath)
+	}
+	for _, f := range []string{"asc", "by_updated_at"} {
+		if got := stub.lastBody[f]; got != true {
+			t.Errorf("[alert-list-filters] %s: want true, got %#v", f, got)
+		}
+	}
+	for field, want := range map[string]string{"alert_ids": "a1,a2", "alert_keys": "k1,k2"} {
+		got, _ := stub.lastBody[field].([]any)
+		var parts []string
+		for _, v := range got {
+			parts = append(parts, fmt.Sprint(v))
+		}
+		if strings.Join(parts, ",") != want {
+			t.Errorf("[alert-list-filters] %s: want %q, got %#v", field, want, stub.lastBody[field])
+		}
+	}
+}
+
+func TestCommandAlertListFilterFlagsDefaultOmitted(t *testing.T) {
+	saveAndResetGlobals(t)
+	stub := newGFStub(t)
+
+	if _, err := execCommand("alert", "list"); err != nil {
+		t.Fatalf("[alert-list-filters-default] unexpected error: %v", err)
+	}
+	for _, f := range []string{"alert_ids", "alert_keys", "asc", "by_updated_at"} {
+		if _, ok := stub.lastBody[f]; ok {
+			t.Errorf("[alert-list-filters-default] %s should be omitted by default, got %#v", f, stub.lastBody[f])
+		}
+	}
+}
+
+func TestCommandAlertEventListAsc(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		extra []string
+		want  any
+	}{
+		{name: "default omits asc", want: nil},
+		{name: "flag sends asc", extra: []string{"--asc"}, want: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			saveAndResetGlobals(t)
+			stub := newGFStub(t)
+
+			if _, err := execCommand(append([]string{"alert-event", "list"}, tc.extra...)...); err != nil {
+				t.Fatalf("[alert-event-list-asc] unexpected error: %v", err)
+			}
+			if stub.lastPath != "/alert-event/list" {
+				t.Fatalf("[alert-event-list-asc] expected /alert-event/list, got %q", stub.lastPath)
+			}
+			if got := stub.lastBody["asc"]; got != tc.want {
+				t.Fatalf("[alert-event-list-asc] asc: want %#v, got %#v", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestCommandAlertMergeCommentFileReachesWire(t *testing.T) {
+	saveAndResetGlobals(t)
+	stub := newGFStub(t)
+
+	path := filepath.Join(t.TempDir(), "comment.txt")
+	if err := os.WriteFile(path, []byte("merge `reason` $(x)"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := execCommand("alert", "merge", "a1", "--incident-id", "i1", "--comment-file", path); err != nil {
+		t.Fatalf("[alert-merge-comment] unexpected error: %v", err)
+	}
+	if got := stub.lastBody["comment"]; got != "merge `reason` $(x)" {
+		t.Fatalf("[alert-merge-comment] comment: got %#v", got)
+	}
+}

internal/cli/audit.go

@@ -17,14 +17,15 @@ func newAuditCmd() *cobra.Command {
 }
 
 func newAuditSearchCmd() *cobra.Command {
-	var since, until, operation string
+	var since, until, operation, requestID string
+	var isWrite, isDangerous bool
 	var person int64
 	var limit, page int
 
 	cmd := &cobra.Command{
 		Use:   "search",
 		Short: "Search audit logs",
-		Long:  curatedLong("Search audit logs within a time window, optionally filtered by person and operation type. The --since/--until window must be < 90 days; --limit max is 99.", "AuditLogs", "Search"),
+		Long:  curatedLong("Search audit logs within a time window, optionally filtered by person, operation type, write/read, risk level and request ID. The --since/--until window must be < 90 days; --limit max is 99.", "AuditLogs", "Search"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return runCommand(cmd, args, func(ctx *RunContext) error {
 				startTime, err := timeutil.Parse(since)
@@ -41,6 +42,13 @@ func newAuditSearchCmd() *cobra.Command {
 					EndTime:   endTime,
 					Limit:     int64(limit),
 					PersonID:  uint64(person),
+					RequestID: requestID,
+				}
+				if cmd.Flags().Changed("is-write") {
+					input.IsWrite = &isWrite
+				}
+				if cmd.Flags().Changed("is-dangerous") {
+					input.IsDangerous = &isDangerous
 				}
 				if operation != "" {
 					input.Operations = parseStringSlice(operation)
@@ -105,6 +113,9 @@ func newAuditSearchCmd() *cobra.Command {
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
 	cmd.Flags().Int64Var(&person, "person", 0, "Filter by person ID")
 	cmd.Flags().StringVar(&operation, "operation", "", "Filter by exact operation name(s) from 'flashduty audit operation-list' (e.g. monitRule:write:update); comma-separate to match several in one call. Prefixes do NOT match (\"monitRule\" returns nothing).")
+	cmd.Flags().StringVar(&requestID, "request-id", "", "Filter to a single request by its request ID")
+	cmd.Flags().BoolVar(&isWrite, "is-write", false, "Only write operations; --is-write=false returns only read operations")
+	cmd.Flags().BoolVar(&isDangerous, "is-dangerous", false, "Only high-risk (dangerous) operations")
 	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 99)")
 	cmd.Flags().IntVar(&page, "page", 1, "Page number")
 

internal/cli/broker_dial_other.go

@@ -7,7 +7,7 @@ import (
 	"net/http"
 )
 
-func newBrokerHTTPClient(int) *http.Client { return nil }
+func newBrokerHTTPClient(int) (*http.Client, error) { return nil, errBrokerUnsupported }
 
 var errBrokerUnsupported = errors.New("flashduty: broker mode is not supported on this platform")
 

internal/cli/broker_dial_unix.go

@@ -14,11 +14,6 @@ import (
 	"time"
 )
 
-// errBrokerUnsupported is returned when broker mode is requested on a build that
-// cannot provide it. On unix this is effectively unreachable (newBrokerHTTPClient
-// never returns nil), but defaultNewClient references it on every platform.
-var errBrokerUnsupported = errors.New("flashduty: broker mode is not supported on this platform")
-
 // errBrokerClosed is returned (wrapped) when the runner-side broker control
 // channel is gone: the runner exited, or reclaimed the channel once the
 // command that started this process finished, so fduty calls from a
@@ -110,7 +105,21 @@ func (d *brokerDialer) dial(_ context.Context, _, _ string) (net.Conn, error) {
 // every connection over the inherited control fd. Timeout matches the SDK's
 // historical default (30s) so behavior is unchanged for non-streaming calls;
 // streaming export relies on request context like before.
-func newBrokerHTTPClient(credFD int) *http.Client {
+//
+// It first checks that credFD is an open socket in this process. The runner
+// hands the control end to bash, and only processes that inherit fd credFD
+// reach fduty with it intact: Python's subprocess (close_fds=True by default),
+// Node's child_process and sudo all close it. Without the check that surfaces
+// as a handshake EBADF/ENOTSOCK at the first request, after the SDK's URL
+// prefix, with nothing saying how to fix it.
+func newBrokerHTTPClient(credFD int) (*http.Client, error) {
+	if _, err := syscall.GetsockoptInt(credFD, syscall.SOL_SOCKET, syscall.SO_TYPE); err != nil {
+		return nil, fmt.Errorf("FLASHDUTY_CRED_FD=%d is not an open socket in this process (%v): "+
+			"the program that started fduty did not pass the credential channel down. "+
+			"Run fduty from the shell, or keep fd %d open when spawning it: "+
+			"Python subprocess.run(cmd, pass_fds=(%d,)); Node: set entry %d of spawn's stdio array to %d",
+			credFD, err, credFD, credFD, credFD, credFD)
+	}
 	d := &brokerDialer{credFD: credFD}
 	return &http.Client{
 		Timeout: 30 * time.Second,
@@ -125,5 +134,5 @@ func newBrokerHTTPClient(credFD int) *http.Client {
 			IdleConnTimeout:       90 * time.Second,
 			ResponseHeaderTimeout: 0,
 		},
-	}
+	}, nil
 }

internal/cli/broker_dial_unix_test.go

@@ -106,9 +106,9 @@ func TestBrokerHTTPClient_DialAndRewrite(t *testing.T) {
 	defer func() { _ = syscall.Close(childFD) }()
 	defer stop()
 
-	client := newBrokerHTTPClient(childFD)
-	if client == nil {
-		t.Fatal("newBrokerHTTPClient returned nil")
+	client, err := newBrokerHTTPClient(childFD)
+	if err != nil {
+		t.Fatalf("newBrokerHTTPClient: %v", err)
 	}
 	defer client.CloseIdleConnections() // release dispatched keep-alive conns
 	// The CLI's base URL is an http placeholder; broker rewrites host.
@@ -208,6 +208,41 @@ func TestDefaultNewClient_RejectsStdioFD(t *testing.T) {
 	}
 }
 
+// TestDefaultNewClient_CredFDNotInherited covers a caller that drops the
+// inherited control fd before exec (Python's subprocess closes fds >= 3 by
+// default): the fd number is then closed, or reused by an unrelated file.
+// Either way defaultNewClient must fail up front with an error that names the
+// fd and the fix, instead of a handshake errno at the first request.
+func TestDefaultNewClient_CredFDNotInherited(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("FLASHDUTY_APP_KEY", "")
+
+	f, err := os.CreateTemp(t.TempDir(), "not-a-socket")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = f.Close() }()
+	pair, err := syscall.Socketpair(syscall.AF_UNIX, controlSockType, 0)
+	if err != nil {
+		t.Fatalf("socketpair: %v", err)
+	}
+	closedFD := pair[0]
+	_ = syscall.Close(pair[0])
+	_ = syscall.Close(pair[1])
+
+	for name, fd := range map[string]int{"closed fd": closedFD, "regular file": int(f.Fd())} {
+		t.Setenv("FLASHDUTY_CRED_FD", strconv.Itoa(fd))
+		_, err := defaultNewClient()
+		if err == nil {
+			t.Fatalf("%s: defaultNewClient must fail", name)
+		}
+		want := "FLASHDUTY_CRED_FD=" + strconv.Itoa(fd) + " is not an open socket"
+		if msg := err.Error(); !strings.HasPrefix(msg, want) || !strings.Contains(msg, "pass_fds=("+strconv.Itoa(fd)+",)") {
+			t.Fatalf("%s: error must start with %q and name pass_fds, got: %v", name, want, msg)
+		}
+	}
+}
+
 // TestBrokerHTTPClient_RefusedReturnsError verifies the dialer surfaces the
 // broker's 0xFF refusal (e.g. the runner failed to mint a connection) as a real
 // error instead of hanging or wrapping a nil conn.
@@ -232,7 +267,10 @@ func TestBrokerHTTPClient_RefusedReturnsError(t *testing.T) {
 		}
 	}()
 
-	client := newBrokerHTTPClient(childFD)
+	client, err := newBrokerHTTPClient(childFD)
+	if err != nil {
+		t.Fatalf("newBrokerHTTPClient: %v", err)
+	}
 	req, _ := http.NewRequestWithContext(context.Background(), "GET",
 		"http://flashduty.broker.local/x?app_key=SENTINEL", nil)
 	if _, err := client.Do(req); err == nil {

internal/cli/change.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"encoding/json"
 	"fmt"
 
 	"github.com/flashcatcloud/go-flashduty"
@@ -20,7 +21,9 @@ func newChangeListCmd() *cobra.Command {
 	var channel string
 	var since, until string
 	var limit, page int
-	var query, integration string
+	var query, integration, filters string
+	var orderby string
+	var asc, includeEvents bool
 
 	cmd := &cobra.Command{
 		Use:   "list",
@@ -72,6 +75,14 @@ func newChangeListCmd() *cobra.Command {
 					input.IntegrationIDs = integrationIDs
 				}
 				input.Query = query
+				input.Orderby = orderby
+				input.Asc = asc
+				input.IncludeEvents = includeEvents
+				if filters != "" {
+					if err := json.Unmarshal([]byte(filters), &input.Filters); err != nil {
+						return fmt.Errorf("invalid --filters: %w", err)
+					}
+				}
 
 				result, _, err := ctx.Client.Changes.List(cmdContext(ctx.Cmd), input)
 				if err != nil {
@@ -94,6 +105,10 @@ func newChangeListCmd() *cobra.Command {
 	cmd.Flags().StringVar(&channel, "channel", "", "Comma-separated channel IDs")
 	cmd.Flags().StringVar(&query, "query", "", "Free-text/regex search over change fields")
 	cmd.Flags().StringVar(&integration, "integration", "", "Comma-separated reporting integration IDs")
+	cmd.Flags().StringVar(&filters, "filters", "", `Structured filters ANDed onto the query, as a JSON array of {"key","oper","vals"} (oper IN or NOTIN; key like labels.env). Keys starting with "incident" are ignored`)
+	cmd.Flags().StringVar(&orderby, "orderby", "", "Sort field: start_time (default) or last_time")
+	cmd.Flags().BoolVar(&asc, "asc", false, "Sort in ascending order")
+	cmd.Flags().BoolVar(&includeEvents, "include-events", false, "Include the underlying change events for each change")
 	cmd.Flags().StringVar(&since, "since", "24h", "Start time (accepts 7d/24h/now, RFC3339, or Unix epoch; window must be < 31 days)")
 	cmd.Flags().StringVar(&until, "until", "now", "End time (accepts 7d/24h/now, RFC3339, or Unix epoch)")
 	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 100)")