refactor: rename project uatu -> sanderling (#24)

* refactor: rename Go module path uatu -> sanderling

Module path github.com/priyanshujain/uatu -> github.com/priyanshujain/sanderling,
including all imports and the proto go_package option. Generated .pb.go files
rewritten in-place; safe to regenerate with protoc later.

* chore(proto): regenerate driverpb after module path rename

The previous sed-based module rename corrupted the embedded descriptor
byte lengths. buf generate rewrites them cleanly.

* refactor: rename CLI binary uatu -> sanderling

Updates Makefile target + UATU_BIN var, .goreleaser project/build IDs,
.gitignore comment, and all user-facing strings in the CLI help text,
error messages, and tests. Binary is now bin/sanderling.

* refactor(sdk): rename Kotlin package dev.uatu.sdk -> dev.sanderling.sdk

Moves sdk/android/src/{main,test}/kotlin/dev/uatu -> dev/sanderling and
rewrites package declarations, imports, and the Gradle namespace. Class
names (Uatu, UatuRuntime) are renamed in a follow-up commit.

* refactor(sidecar): rename Kotlin package dev.uatu.sidecar -> dev.sanderling.sidecar

Moves sidecar/src/{main,test}/kotlin/dev/uatu -> dev/sanderling and
rewrites package declarations, imports, and the application mainClass.

* refactor: rename Uatu API surface -> Sanderling

- Kotlin: Uatu -> Sanderling, UatuRuntime -> SanderlingRuntime (+ files).
- JS host binding: globalThis.__uatu__ -> __sanderling__ (Go verifier,
  spec-api, tests).
- TS interface: UatuRuntime -> SanderlingRuntime; internal tags
  __uatuFormula / __uatuActionGenerator -> __sanderling* variants.
- Go trace: UatuVersion field + uatu_version JSON tag renamed.
- Socket naming: uatu-agent / uatu-agent-reader -> sanderling-agent*.
- Sample app, docs, inline-JS test strings updated to match.

* refactor(examples): rename examples/folio/uatu -> examples/folio/sanderling

Renames the example spec directory; updates justfile paths + gitignore
entries accordingly. Package.json name/description and @uatu/spec
dependency are renamed in the npm + docs commits.

* chore(build): rename gradle property + rootProject.name uatu -> sanderling

- Renames the uatu.version gradle property and all its -P references in
  Makefile, build.gradle.kts files, and .github/workflows/release.yml.
- settings.gradle.kts rootProject.name = "sanderling".
- Renames .env.local.example header + release-cli workflow job name.

* refactor(proto): rename proto package uatu.driver.v1 -> sanderling.driver.v1

Updates the proto package and java_package, regenerates driver.pb.go +
driver_grpc.pb.go, rewrites Kotlin imports and the gRPC ServiceName
assertion in driver_test.go.

* refactor: rename npm package @uatu/spec -> @sanderling/spec

Renames package name in pkg/spec-api/package.json + lockfile, all
consumer imports (examples/folio spec, testdata, verifier tests), the
esbuild alias in cmd/sanderling/test_run.go, and related doc references.

* docs: rename uatu -> sanderling in README, docs, and URLs

- README + docs/{manual,development}/*: narrative + GitHub + Pages URLs.
- POM + npm package.json repo/homepage/bugs URLs.
- .gitignore + embed_stub + Makefile-comment references updated to
  'make sanderling'.
- Minor narrative comments in cmd/sanderling/test_run.go and
  internal/inspect/server.go.

* refactor: rename remaining internal uatu strings -> sanderling

- SANDERLING_TEST_PHONE/OTP env vars (cmd + bundler tests).
- sanderling-sidecar runtime tmp dir + extracted JAR filename.
- Inspect web UI: @sanderling/inspect-web package, title, theme
  localStorage key, RunList empty-state copy, uatu_version TS field.
- Sample app storage key sanderling.ledger.v1.
- Test data: sanderling_test AVD name + com.example.sanderling_test.
- Release docs tarball name template.

cmd/sanderling/inspect.go

@@ -0,0 +1,119 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"time"
+
+	"github.com/priyanshujain/sanderling/internal/inspect"
+)
+
+type inspectOptions struct {
+	port      int
+	noOpen    bool
+	dev       bool
+	directory string
+}
+
+func parseInspectArgs(args []string, stderr io.Writer) (inspectOptions, error) {
+	flagSet := flag.NewFlagSet("inspect", flag.ContinueOnError)
+	flagSet.SetOutput(stderr)
+	var options inspectOptions
+	flagSet.IntVar(&options.port, "port", 0, "TCP port to listen on (0 = ephemeral)")
+	flagSet.BoolVar(&options.noOpen, "no-open", false, "do not open the default browser on startup")
+	flagSet.BoolVar(&options.dev, "dev", false, "reverse-proxy non-API requests to "+inspect.DevTarget)
+	if err := flagSet.Parse(args); err != nil {
+		return inspectOptions{}, err
+	}
+	rest := flagSet.Args()
+	if len(rest) > 1 {
+		return inspectOptions{}, errors.New("inspect takes at most one positional argument (run or runs directory)")
+	}
+	if len(rest) == 1 {
+		options.directory = rest[0]
+	}
+	return options, nil
+}
+
+func runInspect(options inspectOptions, stdout io.Writer) error {
+	runsDirectory, deepLinkID, err := inspect.ResolveRunsDirectory(options.directory)
+	if err != nil {
+		return err
+	}
+	devTarget := ""
+	if options.dev {
+		devTarget = inspect.DevTarget
+	}
+	server, err := inspect.NewServer(inspect.ServerOptions{
+		RunsDirectory: runsDirectory,
+		DevTarget:     devTarget,
+	})
+	if err != nil {
+		return err
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:"+strconv.Itoa(options.port))
+	if err != nil {
+		return fmt.Errorf("listen: %w", err)
+	}
+	address := listener.Addr().(*net.TCPAddr)
+	browseURL := buildBrowseURL(address, deepLinkID)
+	fmt.Fprintf(stdout, "sanderling inspect listening on %s (runs=%s)\n", browseURL, runsDirectory)
+
+	context, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	watcherDone := make(chan struct{})
+	go func() {
+		_ = server.Watcher().Run(context)
+		close(watcherDone)
+	}()
+
+	httpServer := &http.Server{Handler: server.Handler(), ReadHeaderTimeout: 10 * time.Second}
+	serverDone := make(chan error, 1)
+	go func() { serverDone <- httpServer.Serve(listener) }()
+
+	if !options.noOpen {
+		if err := openBrowser(browseURL); err != nil {
+			fmt.Fprintf(stdout, "warning: could not open browser: %v\n", err)
+		}
+	}
+
+	err = <-serverDone
+	cancel()
+	<-watcherDone
+	if errors.Is(err, http.ErrServerClosed) {
+		return nil
+	}
+	return err
+}
+
+func buildBrowseURL(address *net.TCPAddr, deepLinkID string) string {
+	target := url.URL{Scheme: "http", Host: address.String(), Path: "/"}
+	if deepLinkID != "" {
+		target.Path = "/runs/" + deepLinkID
+	}
+	return target.String()
+}
+
+func openBrowser(target string) error {
+	var command *exec.Cmd
+	switch runtime.GOOS {
+	case "darwin":
+		command = exec.Command("open", target)
+	case "windows":
+		command = exec.Command("cmd", "/c", "start", target)
+	default:
+		command = exec.Command("xdg-open", target)
+	}
+	return command.Start()
+}