Add service methods subcommand to list interface methods

Adds `aidlcli service methods <name>` which connects to a binder
service, queries its interface descriptor, and looks up the methods
in the generated registry. Supports both text and JSON output formats.

Author: xaionaro@dx.center

tools/cmd/aidlcli/cmd_service.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"os"
 	"strconv"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/xaionaro-go/aidl/binder"
@@ -23,6 +24,7 @@ func newServiceCmd() *cobra.Command {
 	cmd.AddCommand(newServiceListCmd())
 	cmd.AddCommand(newServiceInspectCmd())
 	cmd.AddCommand(newServiceTransactCmd())
+	cmd.AddCommand(newServiceMethodsCmd())
 
 	return cmd
 }
@@ -199,3 +201,111 @@ func queryDescriptor(
 
 	return desc
 }
+
+func newServiceMethodsCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "methods <name>",
+		Short: "List methods of a binder service interface",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			name := args[0]
+
+			conn, err := OpenConn(ctx, cmd)
+			if err != nil {
+				return err
+			}
+			defer conn.Close(ctx)
+
+			svc, err := conn.GetService(ctx, name)
+			if err != nil {
+				return err
+			}
+
+			descriptor := queryDescriptor(ctx, svc)
+
+			mode, err := cmd.Root().PersistentFlags().GetString("format")
+			if err != nil {
+				return fmt.Errorf("reading --format flag: %w", err)
+			}
+
+			if generatedRegistry == nil {
+				fmt.Fprintf(os.Stdout, "unknown interface %s — no methods in registry\n", descriptor)
+				return nil
+			}
+
+			info := generatedRegistry.ByDescriptor(descriptor)
+			if info == nil {
+				fmt.Fprintf(os.Stdout, "unknown interface %s — no methods in registry\n", descriptor)
+				return nil
+			}
+
+			f := NewFormatter(mode, os.Stdout)
+			switch f.Mode {
+			case "json":
+				f.writeJSON(map[string]any{
+					"descriptor": descriptor,
+					"methods":    methodsToJSON(info.Methods),
+				})
+			default:
+				fmt.Fprintf(f.W, "Interface: %s (%d methods)\n\n", descriptor, len(info.Methods))
+				for _, m := range info.Methods {
+					fmt.Fprintf(f.W, "  %s\n", formatMethodSignature(m))
+				}
+			}
+
+			return nil
+		},
+	}
+}
+
+// formatMethodSignature renders a MethodInfo as "kebab-name(params...) -> returnType".
+func formatMethodSignature(m MethodInfo) string {
+	var b strings.Builder
+	b.WriteString(camelToKebab(m.Name))
+	b.WriteByte('(')
+	for i, p := range m.Params {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(p.Name)
+		b.WriteByte(' ')
+		b.WriteString(p.Type)
+	}
+	b.WriteByte(')')
+
+	if m.ReturnType != "" {
+		b.WriteString(" -> ")
+		b.WriteString(m.ReturnType)
+	}
+
+	return b.String()
+}
+
+// methodsToJSON converts a slice of MethodInfo into a JSON-friendly representation.
+func methodsToJSON(methods []MethodInfo) []map[string]any {
+	result := make([]map[string]any, 0, len(methods))
+	for _, m := range methods {
+		entry := map[string]any{
+			"name": camelToKebab(m.Name),
+		}
+
+		if len(m.Params) > 0 {
+			params := make([]map[string]string, 0, len(m.Params))
+			for _, p := range m.Params {
+				params = append(params, map[string]string{
+					"name": p.Name,
+					"type": p.Type,
+				})
+			}
+			entry["params"] = params
+		}
+
+		if m.ReturnType != "" {
+			entry["return_type"] = m.ReturnType
+		}
+
+		result = append(result, entry)
+	}
+	return result
+}

tools/cmd/aidlcli/cmd_service_test.go

@@ -0,0 +1,78 @@
+//go:build linux
+
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatMethodSignature_NoParams_NoReturn(t *testing.T) {
+	m := MethodInfo{Name: "ForceFlushCommands"}
+	assert.Equal(t, "force-flush-commands()", formatMethodSignature(m))
+}
+
+func TestFormatMethodSignature_NoParams_WithReturn(t *testing.T) {
+	m := MethodInfo{Name: "IsUserAMonkey", ReturnType: "bool"}
+	assert.Equal(t, "is-user-a-monkey() -> bool", formatMethodSignature(m))
+}
+
+func TestFormatMethodSignature_WithParams_WithReturn(t *testing.T) {
+	m := MethodInfo{
+		Name: "CheckPermission",
+		Params: []ParamInfo{
+			{Name: "permission", Type: "string"},
+			{Name: "pid", Type: "int32"},
+			{Name: "uid", Type: "int32"},
+		},
+		ReturnType: "int32",
+	}
+	assert.Equal(t,
+		"check-permission(permission string, pid int32, uid int32) -> int32",
+		formatMethodSignature(m),
+	)
+}
+
+func TestFormatMethodSignature_WithParams_NoReturn(t *testing.T) {
+	m := MethodInfo{
+		Name:   "SetByte",
+		Params: []ParamInfo{{Name: "input", Type: "byte"}},
+	}
+	assert.Equal(t, "set-byte(input byte)", formatMethodSignature(m))
+}
+
+func TestMethodsToJSON(t *testing.T) {
+	methods := []MethodInfo{
+		{Name: "IsUserAMonkey", ReturnType: "bool"},
+		{
+			Name: "CheckPermission",
+			Params: []ParamInfo{
+				{Name: "permission", Type: "string"},
+				{Name: "pid", Type: "int32"},
+			},
+			ReturnType: "int32",
+		},
+		{Name: "Restart"},
+	}
+
+	result := methodsToJSON(methods)
+	require.Len(t, result, 3)
+
+	assert.Equal(t, "is-user-a-monkey", result[0]["name"])
+	assert.Equal(t, "bool", result[0]["return_type"])
+	assert.Nil(t, result[0]["params"])
+
+	assert.Equal(t, "check-permission", result[1]["name"])
+	assert.Equal(t, "int32", result[1]["return_type"])
+	params, ok := result[1]["params"].([]map[string]string)
+	require.True(t, ok)
+	require.Len(t, params, 2)
+	assert.Equal(t, "permission", params[0]["name"])
+	assert.Equal(t, "string", params[0]["type"])
+
+	assert.Equal(t, "restart", result[2]["name"])
+	assert.Nil(t, result[2]["return_type"])
+	assert.Nil(t, result[2]["params"])
+}