@pi-in-go/pigpen-acp 0.1.0

package/extensions/acp/cmd/pig-acp/main_test.go

@@ -0,0 +1,213 @@
+package main
+
+// Twins of the src/index.ts behavior (terminal login entrypoint, stdio wiring, shutdown) and of
+// test/unit/stdout-destroyed-does-not-crash.test.ts at the process level.
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestMain doubles as the fake pig: with PIGACP_FAKE_PIG set it prints its arguments and exits
+// with the requested code.
+func TestMain(m *testing.M) {
+	if code := os.Getenv("PIGACP_FAKE_PIG"); code != "" {
+		fmt.Printf("fake-pig args=%q\n", os.Args[1:])
+		var n int
+		fmt.Sscanf(code, "%d", &n)
+		os.Exit(n)
+	}
+	root, _ := os.MkdirTemp("", "pigacp-main-*")
+	for _, k := range []string{"HOME", "PIG_HOME", "PIG_CODING_AGENT_DIR", "PI_CODING_AGENT_DIR", "XDG_CONFIG_HOME"} {
+		os.Setenv(k, filepath.Join(root, k))
+	}
+	for _, k := range []string{"PIG_ACP_PIG_COMMAND", "PI_ACP_PI_COMMAND", "PIG_USE_PI_DIRS"} {
+		os.Unsetenv(k)
+	}
+	code := m.Run()
+	os.RemoveAll(root)
+	os.Exit(code)
+}
+
+func fakePig(t *testing.T, exit int) string {
+	t.Helper()
+	exe, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	script := filepath.Join(t.TempDir(), "pig")
+	body := fmt.Sprintf("#!/bin/sh\nPIGACP_FAKE_PIG=%d exec %q \"$@\"\n", exit, exe)
+	if err := os.WriteFile(script, []byte(body), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return script
+}
+
+func TestVersionAndUsage(t *testing.T) {
+	t.Run("--version names the tool and the pinned ACP protocol version", func(t *testing.T) {
+		var out, errw bytes.Buffer
+		if code := run([]string{"--version"}, strings.NewReader(""), &out, &errw); code != 0 {
+			t.Fatalf("exit %d: %s", code, errw.String())
+		}
+		if !strings.HasPrefix(out.String(), "pig-acp ") || !strings.Contains(out.String(), "ACP protocol version 1") {
+			t.Errorf("out = %q", out.String())
+		}
+	})
+	t.Run("--help lists the flags and the environment variables", func(t *testing.T) {
+		var out bytes.Buffer
+		if code := run([]string{"--help"}, strings.NewReader(""), &out, io.Discard); code != 0 {
+			t.Fatalf("exit %d", code)
+		}
+		for _, want := range []string{"--pig", "--piglet", "--pig-arg", "--terminal-login", "PIG_ACP_PIG_COMMAND", "PIG_ACP_ENABLE_EMBEDDED_CONTEXT"} {
+			if !strings.Contains(out.String(), want) {
+				t.Errorf("help lacks %q:\n%s", want, out.String())
+			}
+		}
+	})
+	t.Run("an unknown flag exits 2 with a message on stderr and nothing on stdout", func(t *testing.T) {
+		var out, errw bytes.Buffer
+		if code := run([]string{"--bogus"}, strings.NewReader(""), &out, &errw); code != 2 || out.Len() != 0 || !strings.Contains(errw.String(), "--bogus") {
+			t.Errorf("code=%d out=%q err=%q", code, out.String(), errw.String())
+		}
+	})
+}
+
+func TestTerminalLogin(t *testing.T) {
+	t.Run("--terminal-login starts pig interactively and returns its exit status", func(t *testing.T) {
+		var out, errw bytes.Buffer
+		code := run([]string{"--pig", fakePig(t, 3), "--terminal-login"}, strings.NewReader(""), &out, &errw)
+		if code != 3 {
+			t.Fatalf("exit %d, stderr %s", code, errw.String())
+		}
+		if !strings.Contains(out.String(), "fake-pig args=[]") {
+			t.Errorf("pig was not started without arguments: %q", out.String())
+		}
+	})
+	t.Run("--terminal-login with a missing pig explains how to install it and exits 1", func(t *testing.T) {
+		var errw bytes.Buffer
+		code := run([]string{"--pig", "pig-does-not-exist-12345", "--terminal-login"}, strings.NewReader(""), io.Discard, &errw)
+		if code != 1 || !strings.Contains(errw.String(), "pig-acp: could not start pig (command not found: pig-does-not-exist-12345)") {
+			t.Errorf("code=%d stderr=%q", code, errw.String())
+		}
+	})
+}
+
+func TestPigCommandSelection(t *testing.T) {
+	t.Run("--pig beats PIG_ACP_PIG_COMMAND beats PI_ACP_PI_COMMAND", func(t *testing.T) {
+		a, b, c := fakePig(t, 11), fakePig(t, 12), fakePig(t, 13)
+		var out bytes.Buffer
+		t.Setenv("PI_ACP_PI_COMMAND", c)
+		t.Setenv("PIG_ACP_PIG_COMMAND", b)
+		if code := run([]string{"--pig", a, "--terminal-login"}, strings.NewReader(""), &out, io.Discard); code != 11 {
+			t.Errorf("flag: exit %d", code)
+		}
+		if code := run([]string{"--terminal-login"}, strings.NewReader(""), &out, io.Discard); code != 12 {
+			t.Errorf("PIG_ACP_PIG_COMMAND: exit %d", code)
+		}
+		t.Setenv("PIG_ACP_PIG_COMMAND", "")
+		if code := run([]string{"--terminal-login"}, strings.NewReader(""), &out, io.Discard); code != 13 {
+			t.Errorf("PI_ACP_PI_COMMAND: exit %d", code)
+		}
+	})
+	t.Run("--piglet and --pig-arg are forwarded to the pig child after the RPC flags", func(t *testing.T) {
+		// Checked through the launch arguments the terminal login does not use; see pirpc.BuildArgs.
+		got := buildPigArgs([]string{"--piglet", "acp"}, "")
+		want := []string{"--mode", "rpc", "--no-themes", "--piglet", "acp"}
+		if strings.Join(got, "|") != strings.Join(want, "|") {
+			t.Errorf("args = %v, want %v", got, want)
+		}
+	})
+}
+
+func TestServing(t *testing.T) {
+	t.Run("serves ACP on stdin and stdout and exits 0 when stdin closes", func(t *testing.T) {
+		req, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": map[string]any{"protocolVersion": 1}})
+		var out bytes.Buffer
+		code := run(nil, strings.NewReader(string(req)+"\n"), &out, io.Discard)
+		if code != 0 {
+			t.Fatalf("exit %d", code)
+		}
+		var resp map[string]any
+		if err := json.Unmarshal(bytes.TrimSpace(out.Bytes()), &resp); err != nil {
+			t.Fatalf("stdout %q is not one JSON line: %v", out.String(), err)
+		}
+		if resp["id"] != float64(1) || resp["result"].(map[string]any)["protocolVersion"] != float64(1) {
+			t.Errorf("response = %v", resp)
+		}
+	})
+	t.Run("writes nothing but protocol messages to stdout", func(t *testing.T) {
+		var out, errw bytes.Buffer
+		run(nil, strings.NewReader("garbage\n"), &out, &errw)
+		if out.Len() != 0 {
+			t.Errorf("stdout has %q", out.String())
+		}
+	})
+	t.Run("stdout writer: a destroyed stdout ends the run with exit 0 and no crash", func(t *testing.T) {
+		req, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": map[string]any{"protocolVersion": 1}})
+		pr, pw := io.Pipe()
+		pr.Close()
+		done := make(chan int, 1)
+		go func() { done <- run(nil, strings.NewReader(string(req)+"\n"), pw, io.Discard) }()
+		select {
+		case code := <-done:
+			if code != 0 {
+				t.Errorf("exit %d", code)
+			}
+		case <-time.After(5 * time.Second):
+			t.Fatal("run blocked on a destroyed stdout")
+		}
+	})
+}
+
+func TestPigletAndPigArgReachPig(t *testing.T) {
+	t.Run("--piglet and --pig-arg are the arguments pig is started with", func(t *testing.T) {
+		var out bytes.Buffer
+		code := run([]string{"--pig", fakePig(t, 0), "--piglet", "acp", "--pig-arg", "-e", "--pig-arg", "/x y", "--terminal-login"}, strings.NewReader(""), &out, io.Discard)
+		if code != 0 || !strings.Contains(out.String(), `args=["--piglet" "acp" "-e" "/x y"]`) {
+			t.Errorf("code=%d out=%q", code, out.String())
+		}
+	})
+}
+
+// The auth method the editor runs for "sign in" must start the same agent the sessions use: a
+// session started with --piglet and --pig-arg must not get a plain-pig login. (Found by review: the
+// advertised arguments kept only --pig.)
+func TestTerminalAuthMethodKeepsTheAgentSelection(t *testing.T) {
+	req, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": map[string]any{
+		"protocolVersion": 1, "clientCapabilities": map[string]any{"_meta": map[string]any{"terminal-auth": true}}}})
+	var out bytes.Buffer
+	args := []string{"--pig", "/opt/pig", "--piglet", "acp", "--pig-arg", "-e", "--pig-arg", "/x y"}
+	if code := run(args, strings.NewReader(string(req)+"\n"), &out, io.Discard); code != 0 {
+		t.Fatalf("exit %d", code)
+	}
+	var resp struct {
+		Result struct {
+			AuthMethods []struct {
+				Args []string `json:"args"`
+				Meta struct {
+					TerminalAuth struct {
+						Args []string `json:"args"`
+					} `json:"terminal-auth"`
+				} `json:"_meta"`
+			} `json:"authMethods"`
+		} `json:"result"`
+	}
+	if err := json.Unmarshal(bytes.TrimSpace(out.Bytes()), &resp); err != nil || len(resp.Result.AuthMethods) != 1 {
+		t.Fatalf("response %q: %v", out.String(), err)
+	}
+	want := `["--pig" "/opt/pig" "--piglet" "acp" "--pig-arg" "-e" "--pig-arg" "/x y" "--terminal-login"]`
+	m := resp.Result.AuthMethods[0]
+	if got := fmt.Sprintf("%q", m.Args); got != want {
+		t.Errorf("args = %s, want %s", got, want)
+	}
+	if got := fmt.Sprintf("%q", m.Meta.TerminalAuth.Args); got != want {
+		t.Errorf("_meta terminal-auth args = %s, want %s", got, want)
+	}
+}

package/extensions/acp/cmd/pig-acp/sigpipe_unix.go

@@ -0,0 +1,10 @@
+//go:build !windows
+
+package main
+
+import (
+	"os/signal"
+	"syscall"
+)
+
+func ignoreSIGPIPE() { signal.Ignore(syscall.SIGPIPE) }

package/extensions/acp/cmd/pig-acp/sigpipe_windows.go

@@ -0,0 +1,5 @@
+//go:build windows
+
+package main
+
+func ignoreSIGPIPE() {}

package/extensions/acp/cmd/pig-acp/testdata/ask/extension.go

@@ -0,0 +1,28 @@
+// Package ask is an end-to-end test fixture: the ask tool opens a select dialog and reports the choice.
+package ask
+
+import (
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// Extension registers the ask tool.
+func Extension() *sdk.Extension {
+	e := sdk.New("ask")
+	e.RegisterTool(sdk.ToolDefinition{
+		Name: "ask", Label: "Ask", Description: "Ask the user where to deploy",
+		Parameters: sdk.Schema{"type": "object", "properties": map[string]any{}},
+		Execute: func(ctx sdk.Context, _ map[string]any) (any, error) {
+			choice, ok, err := ctx.Select("Deploy where?", []string{"staging", "production"})
+			if err != nil {
+				return nil, err
+			}
+			if !ok {
+				ctx.Notify("no choice", "warning")
+				return "the user made no choice", nil
+			}
+			ctx.Notify("chose "+choice, "info")
+			return "the user chose " + choice, nil
+		},
+	})
+	return e
+}

package/extensions/acp/cmd/pig-acp/testdata/ask/go.mod

@@ -0,0 +1,7 @@
+module askfixture
+
+go 1.26
+
+// Test fixture only (not part of the Package): a Go extension whose ask tool opens a
+// select dialog, so the end-to-end test can exercise ACP permission requests.
+require github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1

package/extensions/acp/cmd/pig-acp/testdata/ask/go.sum

@@ -0,0 +1,2 @@
+github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1/go.mod h1:4j0XhCW0EPOBWvqYE7XKjTvIAahI7K1VyyW3KpjTKj8=
+github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1 h1:Ql9sTkc6dvAXaYQLq5nxqmSZgqu8S0L53ZTs8MkOuxw=

package/extensions/acp/cmd/pig-acp/testdata/gate/extension.go

@@ -0,0 +1,37 @@
+// Package gate is an end-to-end test fixture: pig runs its tool_call hook after it has announced
+// the tool (tool_execution_start) and before it runs the tool, so a hook that blocks holds the tool
+// while the adapter reacts to the announcement.
+package gate
+
+import (
+	"net"
+	"os"
+	"path/filepath"
+	"strings"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// Extension holds every write until the test closes the connection it opened to the address in
+// <cwd>/gate.addr.
+func Extension() *sdk.Extension {
+	e := sdk.New("gate")
+	e.OnEvent(sdk.EventToolCall, func(ctx sdk.Context, data map[string]any) (any, error) {
+		if data["toolName"] != "write" {
+			return nil, nil
+		}
+		addr, err := os.ReadFile(filepath.Join(ctx.Cwd(), "gate.addr"))
+		if err != nil {
+			return nil, err
+		}
+		conn, err := net.Dial("tcp", strings.TrimSpace(string(addr)))
+		if err != nil {
+			return nil, err
+		}
+		defer conn.Close()
+		// The test closes its end to release the write; Read returns then.
+		_, _ = conn.Read(make([]byte, 1))
+		return nil, nil
+	})
+	return e
+}

package/extensions/acp/cmd/pig-acp/testdata/gate/go.mod

@@ -0,0 +1,7 @@
+module gatefixture
+
+go 1.26
+
+// Test fixture only (not part of the Package): a Go extension that holds the write tool until the
+// end-to-end test lets it run, so the test decides whether the adapter or the write comes first.
+require github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1

package/extensions/acp/cmd/pig-acp/testdata/gate/go.sum

@@ -0,0 +1,2 @@
+github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1/go.mod h1:4j0XhCW0EPOBWvqYE7XKjTvIAahI7K1VyyW3KpjTKj8=
+github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1 h1:Ql9sTkc6dvAXaYQLq5nxqmSZgqu8S0L53ZTs8MkOuxw=

package/extensions/acp/cmd/pig-acp/twin_test.go

@@ -0,0 +1,28 @@
+package main
+
+// Twin helpers for a port whose original has tests. Every upstream test case gets one
+// tw(...) call carrying the upstream title unchanged, or one tskip(...) with the reason it
+// cannot be ported. `pigeq twins check` reads these calls and fails on a missing title, an
+// unknown one (a misspelling) or one reason shared by many skips.
+//
+//	pigeq twins list --tests <upstream>/test > port/upstream-tests.json
+//	pigeq twins check --ledger port/upstream-tests.json --go extensions/<name> [--files a,b]
+//
+// Copy this file into the port as twin_test.go and replace main with the package name (in
+// an external test package use `main_test`). A parametrized upstream title (it contains
+// `${`) is twinned once, with the template text unchanged.
+
+import "testing"
+
+// tw runs one exact twin: file is the upstream test file (its name without .test.mjs), title
+// the upstream test title, unchanged.
+func tw(t *testing.T, file, title string, fn func(t *testing.T)) {
+	t.Helper()
+	t.Run(title, fn)
+}
+
+// tskip records a named gap: the upstream case has no Go twin, with its own reason.
+func tskip(t *testing.T, file, title, reason string) {
+	t.Helper()
+	t.Run(title, func(t *testing.T) { t.Skip(reason) })
+}

package/extensions/acp/extension.go

@@ -0,0 +1,63 @@
+// Package acp is the PiG-side extension of the ACP Package. The editor entrypoint itself is the
+// companion executable in cmd/pig-acp: an extension may not write protocol bytes to the host's
+// stdout, so it cannot speak ACP. This extension is the in-session part: `/acp` reports how to
+// point an editor at this agent, and what the adapter does and does not support.
+package acp
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// Extension returns the extension.
+func Extension() *sdk.Extension {
+	e := sdk.New("acp")
+	e.Command("acp", "show how to use this agent from an ACP editor such as Zed", func(ctx sdk.Context, args string) error {
+		switch strings.TrimSpace(args) {
+		case "":
+			ctx.Notify(zedSnippet()+"\n\n"+limits(), "info")
+		case "zed":
+			ctx.Notify(zedSnippet(), "info")
+		default:
+			ctx.Notify("Usage: /acp [zed]", "warning")
+		}
+		return nil
+	})
+	return e
+}
+
+// Executable is the path the editor configuration names for --pig: the running agent. Fused into a
+// Piglet Binary the extension runs inside the agent, so that is this process. Installed as a Package it
+// runs in its own extension process (a cell runner, not an agent); PiG then names the agent that
+// started it in PIG_HARNESS_BINARY, the variable its extension processes use to re-launch the harness.
+// That variable is not part of the public SDK: if a PiG release drops it, /acp names the runner again.
+func Executable() string {
+	if host := os.Getenv("PIG_HARNESS_BINARY"); host != "" {
+		return host
+	}
+	if exe, err := os.Executable(); err == nil && exe != "" {
+		return exe
+	}
+	return "pig"
+}
+
+func zedSnippet() string {
+	cfg := map[string]any{"agent_servers": map[string]any{"PiG": map[string]any{
+		"type": "custom", "command": "pig-acp", "args": []string{"--pig", Executable()}, "env": map[string]any{},
+	}}}
+	b, _ := json.MarshalIndent(cfg, "", "  ")
+	return "Agent Client Protocol (ACP): use this agent from an editor.\n" +
+		"Install pig-acp (the companion executable of the acp Package), then add this to Zed's settings.json:\n\n" +
+		string(b) +
+		"\n\nOther ACP clients run: pig-acp --pig " + Executable()
+}
+
+func limits() string {
+	return "Supported: sessions (new, load, list, delete), streaming text and thinking, tool calls with diffs and terminal output, " +
+		"cancel, model and thinking-level selection, context usage, permission requests for extension select and confirm dialogs.\n" +
+		"Not supported: file system and terminal delegation to the editor, MCP servers passed by the editor " +
+		"(accepted, never started), extension slash commands, input and editor dialogs (cancelled with a notice)."
+}

package/extensions/acp/extension_test.go

@@ -0,0 +1,111 @@
+package acp_test
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	acpext "github.com/MichaelKinsy/pigpen/acp"
+)
+
+// The extension is the in-session half of the ACP Package (the protocol entrypoint is the
+// companion executable, see cmd/pig-acp). Layer-1 cases through the fake host.
+
+// runCommand runs a slash command through the fake host (the template's Host.Command).
+func runCommand(h *Host, name, args string) string {
+	h.t.Helper()
+	return h.Command(name, args)
+}
+
+func notifications(h *Host) []HostCall { return h.CallsTo("ui.notify") }
+
+func TestRegistersOnlyTheAcpCommand(t *testing.T) {
+	h := StartHost(t, acpext.Extension(), HostOptions{})
+	if h.Registered("session_start") || h.Registered("session_shutdown") || h.Registered("tool_call") {
+		t.Error("registered an event handler: the extension must not touch the session")
+	}
+	if code := runCommand(h, "acp", ""); code != "" {
+		t.Fatalf("/acp failed: %s", code)
+	}
+}
+
+func TestAcpCommandExplainsSetup(t *testing.T) {
+	h := StartHost(t, acpext.Extension(), HostOptions{})
+	if code := runCommand(h, "acp", ""); code != "" {
+		t.Fatalf("/acp failed: %s", code)
+	}
+	notes := notifications(h)
+	if len(notes) != 1 {
+		t.Fatalf("%d notifications, want 1", len(notes))
+	}
+	msg, _ := notes[0].Args["message"].(string)
+	for _, want := range []string{
+		"pig-acp", "--pig", `"agent_servers"`, "Agent Client Protocol",
+		"Supported:", "Not supported:", "file system and terminal delegation", "MCP",
+	} {
+		if !strings.Contains(msg, want) {
+			t.Errorf("message lacks %q:\n%s", want, msg)
+		}
+	}
+	if notes[0].Args["level"] != "info" {
+		t.Errorf("level = %v", notes[0].Args["level"])
+	}
+}
+
+func TestAcpCommandNamesThisExecutable(t *testing.T) {
+	h := StartHost(t, acpext.Extension(), HostOptions{})
+	runCommand(h, "acp", "")
+	msg, _ := notifications(h)[0].Args["message"].(string)
+	exe := acpext.Executable()
+	if exe == "" || !strings.Contains(msg, exe) {
+		t.Errorf("message does not name the running executable %q:\n%s", exe, msg)
+	}
+}
+
+// Installed as a Package (not fused into a Piglet Binary), the extension runs in its own process: an
+// extension cell under PiG's cache, which is not an agent and cannot be pig-acp's --pig target. PiG hands
+// every extension process the executable of the agent that started it in PIG_HARNESS_BINARY; /acp must
+// name that one. (Found by review: `pig -e components/acp/extensions/acp` printed the cell runner.)
+func TestAcpCommandNamesTheHostAgentWhenItRunsAsASubprocess(t *testing.T) {
+	t.Setenv("PIG_HARNESS_BINARY", "/opt/pig/bin/pig")
+	if got := acpext.Executable(); got != "/opt/pig/bin/pig" {
+		t.Errorf("Executable() = %q, want the host agent /opt/pig/bin/pig", got)
+	}
+	h := StartHost(t, acpext.Extension(), HostOptions{})
+	runCommand(h, "acp", "zed")
+	msg, _ := notifications(h)[0].Args["message"].(string)
+	if !strings.Contains(msg, `"/opt/pig/bin/pig"`) || !strings.Contains(msg, "pig-acp --pig /opt/pig/bin/pig") {
+		t.Errorf("the snippet does not name the host agent:\n%s", msg)
+	}
+}
+
+func TestAcpCommandRejectsUnknownArguments(t *testing.T) {
+	h := StartHost(t, acpext.Extension(), HostOptions{})
+	runCommand(h, "acp", "bogus")
+	notes := notifications(h)
+	if len(notes) != 1 || notes[0].Args["level"] != "warning" || !strings.Contains(notes[0].Args["message"].(string), "Usage: /acp") {
+		t.Errorf("notifications = %+v", notes)
+	}
+}
+
+func TestAcpCommandZedSnippetOnly(t *testing.T) {
+	h := StartHost(t, acpext.Extension(), HostOptions{})
+	runCommand(h, "acp", "zed")
+	msg, _ := notifications(h)[0].Args["message"].(string)
+	if !strings.Contains(msg, `"agent_servers"`) || strings.Contains(msg, "Not supported:") {
+		t.Errorf("message:\n%s", msg)
+	}
+	// The snippet names this executable as the --pig target (a JSON string, so escaped as JSON).
+	quoted, _ := json.Marshal(acpext.Executable())
+	if !strings.Contains(msg, string(quoted)) {
+		t.Errorf("the snippet does not name the executable %s:\n%s", quoted, msg)
+	}
+}
+
+func TestAcpCommandStaysQuietWithoutUI(t *testing.T) {
+	no := false
+	h := StartHost(t, acpext.Extension(), HostOptions{Mode: "print", HasUI: &no})
+	if code := runCommand(h, "acp", ""); code != "" {
+		t.Fatalf("/acp failed headless: %s", code)
+	}
+}