feat: split bindercli commands into 323 independent Go packages

The 691K-line commands_gen.go in package main was killing CI build
times (>31min timeout). Restructured into 323 auto-generated
subpackages under cmd/bindercli/gen/ that compile independently:

- cmd/bindercli/cliutil/ — shared Conn, Formatter, service discovery
- cmd/bindercli/gen/<aidl_pkg>/commands.go — per-package Register()
- cmd/bindercli/register_gen.go — imports and registers all packages

Package main: 22.5K lines (down from 691K). Largest subpackage:
android_app at 46K lines. Incremental builds <1s (Go build cache
caches each package independently).

Author: xaionaro@dx.center

.github/workflows/ci.yml

@@ -52,6 +52,7 @@ jobs:
     needs: test
     if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     permissions:
       contents: write
       packages: write

Makefile

@@ -156,3 +156,5 @@ clean:
 	find specs -name spec.yaml -delete 2>/dev/null; find specs -type d -empty -delete 2>/dev/null; true
 	find . -maxdepth 1 -name '*.go' -exec grep -l 'Code generated' {} \; | xargs -r rm -f
 	rm -f servicemanager/service_names_gen.go
+	rm -f cmd/bindercli/commands_gen.go cmd/bindercli/commands_gen_*.go cmd/bindercli/registry_gen.go cmd/bindercli/register_gen.go
+	rm -rf cmd/bindercli/gen/

cmd/bindercli/cliutil/conn.go

@@ -0,0 +1,102 @@
+//go:build linux
+
+package cliutil
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/facebookincubator/go-belt/tool/logger"
+	"github.com/spf13/cobra"
+
+	"github.com/AndroidGoLab/binder/binder"
+	"github.com/AndroidGoLab/binder/binder/versionaware"
+	"github.com/AndroidGoLab/binder/kernelbinder"
+	"github.com/AndroidGoLab/binder/servicemanager"
+)
+
+// Conn wraps the binder driver and service manager into a single
+// connection handle for CLI subcommands.
+type Conn struct {
+	Driver    *kernelbinder.Driver
+	Transport binder.Transport
+	SM        *servicemanager.ServiceManager
+}
+
+// OpenConn opens a binder driver connection and creates a service manager client.
+func OpenConn(
+	ctx context.Context,
+	cmd *cobra.Command,
+) (_conn *Conn, _err error) {
+	logger.Tracef(ctx, "OpenConn")
+	defer func() { logger.Tracef(ctx, "/OpenConn: %v", _err) }()
+
+	mapSize, err := cmd.Root().PersistentFlags().GetInt("map-size")
+	if err != nil {
+		return nil, fmt.Errorf("reading --map-size flag: %w", err)
+	}
+
+	targetAPI, err := cmd.Root().PersistentFlags().GetInt("target-api")
+	if err != nil {
+		return nil, fmt.Errorf("reading --target-api flag: %w", err)
+	}
+
+	// Detect API level BEFORE opening /dev/binder. Detection may fork
+	// a child process (getprop), and forking after mmap-ing the binder
+	// driver corrupts its state.
+	if targetAPI <= 0 {
+		targetAPI = versionaware.DetectAPILevel()
+	}
+
+	driver, err := kernelbinder.Open(ctx, binder.WithMapSize(uint32(mapSize)))
+	if err != nil {
+		return nil, fmt.Errorf("opening binder driver: %w", err)
+	}
+
+	// Wrap with version-aware transport so that ResolveCode returns
+	// the correct transaction codes for the target device's API level.
+	transport, err := versionaware.NewTransport(ctx, driver, targetAPI)
+	if err != nil {
+		driver.Close(ctx)
+		return nil, fmt.Errorf("initializing version-aware transport: %w", err)
+	}
+
+	sm := servicemanager.New(transport)
+
+	return &Conn{
+		Driver:    driver,
+		Transport: transport,
+		SM:        sm,
+	}, nil
+}
+
+// Close releases the binder driver resources.
+func (c *Conn) Close(
+	ctx context.Context,
+) (_err error) {
+	logger.Tracef(ctx, "Conn.Close")
+	defer func() { logger.Tracef(ctx, "/Conn.Close: %v", _err) }()
+
+	return c.Driver.Close(ctx)
+}
+
+// GetService looks up a registered binder service by name.
+// Returns an error if the service is not found.
+func (c *Conn) GetService(
+	ctx context.Context,
+	name string,
+) (_binder binder.IBinder, _err error) {
+	logger.Tracef(ctx, "GetService(%q)", name)
+	defer func() { logger.Tracef(ctx, "/GetService(%q): %v", name, _err) }()
+
+	svc, err := c.SM.CheckService(ctx, servicemanager.ServiceName(name))
+	if err != nil {
+		return nil, fmt.Errorf("checking service %q: %w", name, err)
+	}
+
+	if svc == nil {
+		return nil, fmt.Errorf("service %q not found", name)
+	}
+
+	return svc, nil
+}

cmd/bindercli/cliutil/formatter.go

@@ -0,0 +1,150 @@
+package cliutil
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"sort"
+	"text/tabwriter"
+
+	"golang.org/x/term"
+)
+
+// Formatter handles text and JSON output with auto-detection of terminal vs pipe.
+type Formatter struct {
+	Mode string
+	W    io.Writer
+}
+
+// NewFormatter creates a Formatter that resolves "auto" mode by checking
+// whether the writer is a terminal.
+func NewFormatter(
+	mode string,
+	w io.Writer,
+) *Formatter {
+	var isTTY bool
+	if f, ok := w.(interface{ Fd() uintptr }); ok {
+		isTTY = term.IsTerminal(int(f.Fd()))
+	} else {
+		isTTY = term.IsTerminal(int(os.Stdout.Fd()))
+	}
+	return &Formatter{
+		Mode: ResolveMode(mode, isTTY),
+		W:    w,
+	}
+}
+
+// ResolveMode maps the mode string to a concrete output format.
+// When mode is "auto", it returns "text" for terminals and "json" for pipes.
+func ResolveMode(
+	mode string,
+	isTTY bool,
+) string {
+	switch mode {
+	case "text", "json":
+		return mode
+	default:
+		if isTTY {
+			return "text"
+		}
+		return "json"
+	}
+}
+
+// Value writes a single key-value pair.
+// Text: "key: val\n". JSON: {"key": val}.
+func (f *Formatter) Value(
+	key string,
+	val any,
+) {
+	switch f.Mode {
+	case "json":
+		f.WriteJSON(map[string]any{key: val})
+	default:
+		fmt.Fprintf(f.W, "%s: %v\n", key, val)
+	}
+}
+
+// Result writes a map of key-value pairs.
+// Text: sorted k/v lines. JSON: object.
+func (f *Formatter) Result(
+	m map[string]any,
+) {
+	switch f.Mode {
+	case "json":
+		f.WriteJSON(m)
+	default:
+		keys := make([]string, 0, len(m))
+		for k := range m {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		for _, k := range keys {
+			fmt.Fprintf(f.W, "%s: %v\n", k, m[k])
+		}
+	}
+}
+
+// Table writes tabular data.
+// Text: aligned columns via tabwriter. JSON: array of objects keyed by headers.
+func (f *Formatter) Table(
+	headers []string,
+	rows [][]string,
+) {
+	switch f.Mode {
+	case "json":
+		objects := make([]map[string]string, 0, len(rows))
+		for _, row := range rows {
+			obj := make(map[string]string, len(headers))
+			for i, h := range headers {
+				if i < len(row) {
+					obj[h] = row[i]
+				}
+			}
+			objects = append(objects, obj)
+		}
+		f.WriteJSON(objects)
+	default:
+		tw := tabwriter.NewWriter(f.W, 0, 4, 2, ' ', 0)
+		for i, h := range headers {
+			if i > 0 {
+				fmt.Fprint(tw, "\t")
+			}
+			fmt.Fprint(tw, h)
+		}
+		fmt.Fprintln(tw)
+		for _, row := range rows {
+			for i, cell := range row {
+				if i > 0 {
+					fmt.Fprint(tw, "\t")
+				}
+				fmt.Fprint(tw, cell)
+			}
+			fmt.Fprintln(tw)
+		}
+		tw.Flush()
+	}
+}
+
+// Error writes an error message.
+// Text: "error: msg\n". JSON: {"error": "msg"}.
+func (f *Formatter) Error(
+	err error,
+) {
+	switch f.Mode {
+	case "json":
+		f.WriteJSON(map[string]string{"error": err.Error()})
+	default:
+		fmt.Fprintf(f.W, "error: %s\n", err.Error())
+	}
+}
+
+// WriteJSON encodes v as JSON to the formatter's writer.
+func (f *Formatter) WriteJSON(
+	v any,
+) {
+	enc := json.NewEncoder(f.W)
+	enc.SetEscapeHTML(false)
+	_ = enc.Encode(v)
+}

cmd/bindercli/cliutil/service_discovery.go

@@ -0,0 +1,74 @@
+//go:build linux
+
+package cliutil
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/AndroidGoLab/binder/binder"
+	"github.com/AndroidGoLab/binder/parcel"
+	"github.com/AndroidGoLab/binder/servicemanager"
+)
+
+// KnownServiceNames maps AIDL descriptors to well-known Android
+// ServiceManager names, allowing fast lookup without enumeration.
+// Populated by generated code via SetKnownServiceNames.
+var KnownServiceNames map[string]string
+
+// FindServiceByDescriptor locates a binder service by its AIDL descriptor.
+// It first tries the static map of well-known service names to avoid
+// slow enumeration, then falls back to listing all services.
+func FindServiceByDescriptor(
+	ctx context.Context,
+	conn *Conn,
+	descriptor string,
+) (binder.IBinder, error) {
+	// Try the static map of well-known service names first to avoid
+	// slow enumeration of all registered services.
+	if name, ok := KnownServiceNames[descriptor]; ok {
+		svc, err := conn.SM.CheckService(ctx, servicemanager.ServiceName(name))
+		if err == nil && svc != nil {
+			return svc, nil
+		}
+	}
+
+	// Fall back to enumeration.
+	services, err := conn.SM.ListServices(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("listing services: %w", err)
+	}
+
+	for _, name := range services {
+		svc, err := conn.SM.CheckService(ctx, name)
+		if err != nil || svc == nil {
+			continue
+		}
+		desc := QueryDescriptor(ctx, svc)
+		if desc == descriptor {
+			return svc, nil
+		}
+	}
+
+	return nil, fmt.Errorf("no service with descriptor %q found", descriptor)
+}
+
+// QueryDescriptor sends an InterfaceTransaction to the binder service
+// and reads back the interface descriptor string.
+// Returns "(unknown)" if the query fails.
+func QueryDescriptor(
+	ctx context.Context,
+	svc binder.IBinder,
+) string {
+	reply, err := svc.Transact(ctx, binder.InterfaceTransaction, 0, parcel.New())
+	if err != nil {
+		return "(unknown)"
+	}
+
+	desc, err := reply.ReadString16()
+	if err != nil {
+		return "(unknown)"
+	}
+
+	return desc
+}