Add exec_client CLI for exec_service

Author: afq984

exec_service/cmd/exec_client/BUILD.bazel

@@ -0,0 +1,44 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+load("@rules_go//go:def.bzl", "go_binary", "go_library", "go_test")
+
+go_library(
+    name = "exec_client_lib",
+    srcs = ["main.go"],
+    importpath = "github.com/google/agent-shell-tools/exec_service/cmd/exec_client",
+    deps = [
+        "//exec_service:exec_service_go_proto",
+        "@org_golang_google_grpc//:grpc",
+        "@org_golang_google_grpc//credentials/insecure",
+    ],
+)
+
+go_binary(
+    name = "exec_client",
+    embed = [":exec_client_lib"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "exec_client_test",
+    srcs = ["exec_client_test.go"],
+    embed = [":exec_client_lib"],
+    tags = ["local"],
+    deps = [
+        "//exec_service:exec_service_go_proto",
+        "//exec_service/server",
+        "@org_golang_google_grpc//:grpc",
+    ],
+)

exec_service/cmd/exec_client/exec_client_test.go

@@ -0,0 +1,158 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"bytes"
+	"net"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	pb "github.com/google/agent-shell-tools/exec_service/execservicepb"
+	"github.com/google/agent-shell-tools/exec_service/server"
+	"google.golang.org/grpc"
+)
+
+// startTestServer starts an ExecService gRPC server on a temporary Unix socket
+// and returns the socket path. The server is stopped on test cleanup.
+func startTestServer(t *testing.T) string {
+	t.Helper()
+	sock := filepath.Join(t.TempDir(), "test.sock")
+
+	lis, err := net.Listen("unix", sock)
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+
+	srv := grpc.NewServer()
+	pb.RegisterExecServiceServer(srv, &server.ExecServer{})
+	go srv.Serve(lis)
+	t.Cleanup(srv.GracefulStop)
+
+	return sock
+}
+
+func TestBasicCommand(t *testing.T) {
+	sock := startTestServer(t)
+
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", sock, "echo", "hello"}, &stdout, &stderr)
+
+	if code != 0 {
+		t.Errorf("exit code = %d, want 0; stderr: %s", code, stderr.String())
+	}
+	if got := strings.TrimSpace(stdout.String()); got != "hello" {
+		t.Errorf("stdout = %q, want %q", got, "hello")
+	}
+}
+
+func TestExitCode(t *testing.T) {
+	sock := startTestServer(t)
+
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", sock, "exit 42"}, &stdout, &stderr)
+
+	if code != 42 {
+		t.Errorf("exit code = %d, want 42", code)
+	}
+}
+
+func TestWorkingDir(t *testing.T) {
+	sock := startTestServer(t)
+	dir := t.TempDir()
+
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", sock, "-dir", dir, "pwd"}, &stdout, &stderr)
+
+	if code != 0 {
+		t.Errorf("exit code = %d, want 0; stderr: %s", code, stderr.String())
+	}
+	if got := strings.TrimSpace(stdout.String()); got != dir {
+		t.Errorf("pwd = %q, want %q", got, dir)
+	}
+}
+
+func TestMissingAddr(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"echo", "hello"}, &stdout, &stderr)
+
+	if code != 2 {
+		t.Errorf("exit code = %d, want 2", code)
+	}
+	if !strings.Contains(stderr.String(), "-addr is required") {
+		t.Errorf("stderr = %q, want it to contain %q", stderr.String(), "-addr is required")
+	}
+}
+
+func TestMissingCommand(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", "/tmp/fake.sock"}, &stdout, &stderr)
+
+	if code != 2 {
+		t.Errorf("exit code = %d, want 2", code)
+	}
+	if !strings.Contains(stderr.String(), "command is required") {
+		t.Errorf("stderr = %q, want it to contain %q", stderr.String(), "command is required")
+	}
+}
+
+func TestStderrOutput(t *testing.T) {
+	sock := startTestServer(t)
+
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", sock, "echo error >&2"}, &stdout, &stderr)
+
+	if code != 0 {
+		t.Errorf("exit code = %d, want 0", code)
+	}
+	// Server merges stderr into stdout stream.
+	if got := strings.TrimSpace(stdout.String()); got != "error" {
+		t.Errorf("stdout = %q, want %q", got, "error")
+	}
+}
+
+func TestArgQuoting(t *testing.T) {
+	sock := startTestServer(t)
+	dir := t.TempDir()
+
+	// "touch" with a filename containing a space should create one file, not two.
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", sock, "-dir", dir, "touch", "a b"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("exit code = %d, want 0; stderr: %s", code, stderr.String())
+	}
+
+	// Verify exactly one file named "a b" was created.
+	var check bytes.Buffer
+	code = run([]string{"-addr", sock, "-dir", dir, "ls"}, &check, &stderr)
+	if code != 0 {
+		t.Fatalf("ls exit code = %d; stderr: %s", code, stderr.String())
+	}
+	if got := strings.TrimSpace(check.String()); got != "a b" {
+		t.Errorf("ls = %q, want %q", got, "a b")
+	}
+}
+
+func TestCommandNotFound(t *testing.T) {
+	sock := startTestServer(t)
+
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"-addr", sock, "nonexistent_command_xyz"}, &stdout, &stderr)
+
+	if code == 0 {
+		t.Error("exit code = 0, want non-zero for command not found")
+	}
+}

exec_service/cmd/exec_client/main.go

@@ -0,0 +1,133 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Binary exec_client is a command line client for the ExecService gRPC server.
+// It connects to the server over a Unix socket, sends a command, streams
+// output to stdout, and exits with the command's exit code.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	pb "github.com/google/agent-shell-tools/exec_service/execservicepb"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func run(args []string, stdout, stderr io.Writer) int {
+	fs := flag.NewFlagSet("exec_client", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	addr := fs.String("addr", "", "Unix socket path to connect to (required)")
+	dir := fs.String("dir", "", "Working directory for the command")
+
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+
+	if *addr == "" {
+		fmt.Fprintln(stderr, "-addr is required")
+		return 2
+	}
+
+	cmdArgs := fs.Args()
+	if len(cmdArgs) == 0 {
+		fmt.Fprintln(stderr, "command is required")
+		return 2
+	}
+
+	// When the caller passes a single argument it is treated as a raw shell
+	// command (e.g. exec_client -addr s "echo hello && ls"). Multiple
+	// arguments are shell-quoted so that spaces and metacharacters in
+	// individual args are preserved (e.g. exec_client -addr s touch "a b").
+	var cmdLine string
+	if len(cmdArgs) == 1 {
+		cmdLine = cmdArgs[0]
+	} else {
+		cmdLine = shellJoin(cmdArgs)
+	}
+
+	sockPath, err := filepath.Abs(*addr)
+	if err != nil {
+		fmt.Fprintf(stderr, "resolve socket path: %v\n", err)
+		return 1
+	}
+
+	conn, err := grpc.NewClient("unix://"+sockPath,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	)
+	if err != nil {
+		fmt.Fprintf(stderr, "dial: %v\n", err)
+		return 1
+	}
+	defer conn.Close()
+
+	client := pb.NewExecServiceClient(conn)
+	stream, err := client.RunCommand(context.Background(), &pb.StartCommandRequest{
+		CommandLine: cmdLine,
+		WorkingDir:  *dir,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "RunCommand: %v\n", err)
+		return 1
+	}
+
+	for {
+		ev, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			fmt.Fprintf(stderr, "recv: %v\n", err)
+			return 1
+		}
+		switch e := ev.Event.(type) {
+		case *pb.ServerEvent_Output:
+			stdout.Write(e.Output)
+		case *pb.ServerEvent_Exited:
+			if msg := e.Exited.GetErrorMessage(); msg != "" {
+				fmt.Fprintf(stderr, "error: %s\n", msg)
+			}
+			return int(e.Exited.GetExitCode())
+		}
+	}
+	return 0
+}
+
+// shellQuote wraps s in single quotes, escaping any embedded single quotes.
+func shellQuote(s string) string {
+	if s == "" {
+		return "''"
+	}
+	return "'" + strings.ReplaceAll(s, "'", "'\"'\"'") + "'"
+}
+
+// shellJoin quotes each argument and joins them with spaces, producing a
+// string safe for interpretation by sh -c.
+func shellJoin(args []string) string {
+	quoted := make([]string, len(args))
+	for i, a := range args {
+		quoted[i] = shellQuote(a)
+	}
+	return strings.Join(quoted, " ")
+}
+
+func main() {
+	os.Exit(run(os.Args[1:], os.Stdout, os.Stderr))
+}