@pi-in-go/pigpen-pi-typesafe 0.1.0

package/extensions/pi-typesafe/format.go

@@ -0,0 +1,191 @@
+package pi_typesafe
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"math/big"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+// jsonString is JSON.stringify for a string.
+func jsonString(s string) string {
+	var b strings.Builder
+	enc := json.NewEncoder(&b)
+	enc.SetEscapeHTML(false)
+	_ = enc.Encode(s)
+	return strings.TrimSuffix(b.String(), "\n")
+}
+
+func number(v any) float64 {
+	f, _ := v.(float64)
+	return f
+}
+
+// toFixed3 is Number.prototype.toFixed(3): the exact value rounded half up in magnitude (Go's own
+// formatting rounds an exact tie to even).
+func toFixed3(f float64) string {
+	if math.IsNaN(f) || math.IsInf(f, 0) {
+		return strconv.FormatFloat(f, 'f', -1, 64)
+	}
+	neg := f < 0
+	r := new(big.Rat).SetFloat64(math.Abs(f))
+	r.Mul(r, big.NewRat(1000, 1))
+	n := new(big.Int).Quo(r.Num(), r.Denom())
+	rem := new(big.Rat).Sub(r, new(big.Rat).SetInt(n))
+	if rem.Cmp(big.NewRat(1, 2)) >= 0 {
+		n.Add(n, big.NewInt(1))
+	}
+	digits := n.String()
+	for len(digits) < 4 {
+		digits = "0" + digits
+	}
+	out := digits[:len(digits)-3] + "." + digits[len(digits)-3:]
+	if neg && strings.Trim(out, "0.") != "" {
+		out = "-" + out
+	}
+	return out
+}
+
+// orderedIDs lists answer ids in question order when the details carry it, else sorted.
+func orderedIDs(details map[string]any, answers map[string]any) []string {
+	var ids []string
+	seen := map[string]bool{}
+	if order, ok := details["order"].([]any); ok {
+		for _, o := range order {
+			if id, ok := o.(string); ok {
+				if _, present := answers[id]; present && !seen[id] {
+					ids = append(ids, id)
+					seen[id] = true
+				}
+			}
+		}
+	}
+	var rest []string
+	for id := range answers {
+		if !seen[id] {
+			rest = append(rest, id)
+		}
+	}
+	sort.Strings(rest)
+	return append(ids, rest...)
+}
+
+// probabilitiesText is JSON.stringify of a probabilities object: numeric keys ascending (a Score's levels), else sorted.
+func probabilitiesText(v any) string {
+	probs, _ := v.(map[string]any)
+	keys := make([]string, 0, len(probs))
+	for k := range probs {
+		keys = append(keys, k)
+	}
+	sort.Slice(keys, func(i, j int) bool {
+		a, errA := strconv.Atoi(keys[i])
+		b, errB := strconv.Atoi(keys[j])
+		if errA == nil && errB == nil {
+			return a < b
+		}
+		return keys[i] < keys[j]
+	})
+	parts := make([]string, len(keys))
+	for i, k := range keys {
+		parts[i] = jsonString(k) + ":" + strconv.FormatFloat(number(probs[k]), 'f', -1, 64)
+	}
+	return "{" + strings.Join(parts, ",") + "}"
+}
+
+// format renders an evaluation (the tool's details) as the original's text block.
+func format(details map[string]any, expanded bool) string {
+	model, _ := details["model"].(string)
+	lines := []string{fmt.Sprintf("TypeSafe · %s · %s ms", jsonString(model), strconv.FormatFloat(number(details["elapsedMs"]), 'f', -1, 64))}
+	answers, _ := details["answers"].(map[string]any)
+	for _, id := range orderedIDs(details, answers) {
+		answer, _ := answers[id].(map[string]any)
+		label := jsonString(id)
+		switch answer["type"] {
+		case "noul":
+			lines = append(lines, fmt.Sprintf("%s: P(yes) = %s", label, toFixed3(number(answer["noul"]))))
+		case "choice":
+			choice, _ := answer["choice"].(string)
+			lines = append(lines, fmt.Sprintf("%s: %s · confidence %s", label, jsonString(choice), toFixed3(number(answer["confidence"]))))
+		default:
+			lines = append(lines, fmt.Sprintf("%s: %s · confidence %s", label, toFixed3(number(answer["score"])), toFixed3(number(answer["confidence"]))))
+		}
+		if expanded && answer["type"] != "noul" {
+			lines = append(lines, "  "+probabilitiesText(answer["probabilities"]))
+		}
+	}
+	usage, _ := details["usage"].(map[string]any)
+	lines = append(lines, fmt.Sprintf("%s input / %s output tokens", strconv.FormatFloat(number(usage["input_tokens"]), 'f', -1, 64), strconv.FormatFloat(number(usage["output_tokens"]), 'f', -1, 64)))
+	lines = append(lines, "Confidence is distribution concentration, not proof of correctness.")
+	return strings.Join(lines, "\n")
+}
+
+// cellWidth is the terminal width of a rune: 2 for East Asian wide and emoji ranges, 0 for combining marks.
+func cellWidth(r rune) int {
+	switch {
+	case r >= 0x300 && r <= 0x36f, r == 0x200d, r >= 0xfe00 && r <= 0xfe0f:
+		return 0
+	case r >= 0x1100 && r <= 0x115f, r >= 0x2e80 && r <= 0xa4cf, r >= 0xac00 && r <= 0xd7a3, r >= 0xf900 && r <= 0xfaff,
+		r >= 0xfe30 && r <= 0xfe6f, r >= 0xff00 && r <= 0xff60, r >= 0xffe0 && r <= 0xffe6, r >= 0x1f300 && r <= 0x1faff, r >= 0x20000 && r <= 0x3fffd:
+		return 2
+	}
+	return 1
+}
+
+func visibleWidth(s string) int {
+	w := 0
+	for _, r := range s {
+		w += cellWidth(r)
+	}
+	return w
+}
+
+// wrapText breaks text into lines of at most width cells, at spaces where it can, mid-word where it must.
+func wrapText(text string, width int) []string {
+	if width < 1 {
+		width = 1
+	}
+	var out []string
+	for _, paragraph := range strings.Split(text, "\n") {
+		if paragraph == "" {
+			out = append(out, "")
+			continue
+		}
+		line, lineW := "", 0
+		flush := func() {
+			out = append(out, strings.TrimRight(line, " "))
+			line, lineW = "", 0
+		}
+		for _, word := range strings.SplitAfter(paragraph, " ") {
+			w := visibleWidth(word)
+			if lineW+w > width && line != "" {
+				flush()
+			}
+			for w > width { // a word longer than a line
+				var head strings.Builder
+				hw := 0
+				for len(word) > 0 {
+					r, n := utf8.DecodeRuneInString(word)
+					if hw+cellWidth(r) > width {
+						break
+					}
+					head.WriteString(word[:n])
+					hw += cellWidth(r)
+					word = word[n:]
+				}
+				line, lineW = head.String(), hw
+				flush()
+				w = visibleWidth(word)
+			}
+			line += word
+			lineW += w
+		}
+		if line != "" {
+			flush()
+		}
+	}
+	return out
+}

package/extensions/pi-typesafe/format_test.go

@@ -0,0 +1,75 @@
+package pi_typesafe
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestToFixed3IsJavaScriptsToFixed(t *testing.T) {
+	// 0.0625 is exactly representable: JavaScript rounds the tie up, Go's formatting rounds it to even.
+	cases := map[float64]string{0.9: "0.900", 0.0625: "0.063", 1: "1.000", 0.0005: "0.001", 2.5: "2.500", -0.0625: "-0.063", 0: "0.000", 12.3456: "12.346"}
+	for in, want := range cases {
+		if got := toFixed3(in); got != want {
+			t.Errorf("toFixed3(%v) = %s, want %s", in, got, want)
+		}
+	}
+}
+
+func TestFormatFollowsTheOriginalLayoutAndQuestionOrder(t *testing.T) {
+	details := map[string]any{
+		"model": "jev-test", "elapsedMs": 12.0, "usage": map[string]any{"input_tokens": 42.0, "output_tokens": 0.0},
+		"order": []any{"z", "a", "s"},
+		"answers": map[string]any{
+			"a": map[string]any{"type": "choice", "choice": "billing", "confidence": 1.0, "probabilities": map[string]any{"billing": 1.0, "other": 0.0}},
+			"z": map[string]any{"type": "noul", "noul": 0.9},
+			"s": map[string]any{"type": "score", "score": 1.5, "confidence": 0.5, "probabilities": map[string]any{"0": 0.25, "1": 0.5, "10": 0.25}},
+		},
+	}
+	want := strings.Join([]string{
+		`TypeSafe · "jev-test" · 12 ms`,
+		`"z": P(yes) = 0.900`,
+		`"a": "billing" · confidence 1.000`,
+		`  {"billing":1,"other":0}`,
+		`"s": 1.500 · confidence 0.500`,
+		`  {"0":0.25,"1":0.5,"10":0.25}`,
+		`42 input / 0 output tokens`,
+		`Confidence is distribution concentration, not proof of correctness.`,
+	}, "\n")
+	if got := format(details, true); got != want {
+		t.Fatalf("got:\n%s\nwant:\n%s", got, want)
+	}
+	if got := format(details, false); strings.Contains(got, `{"billing"`) {
+		t.Error("collapsed output must not list probabilities")
+	}
+	delete(details, "order")
+	if got := format(details, false); !strings.HasPrefix(strings.Split(got, "\n")[1], `"a"`) {
+		t.Errorf("without order the ids are sorted: %s", got)
+	}
+}
+
+func TestWrapTextKeepsEveryLineWithinWidth(t *testing.T) {
+	text := "TypeSafe · a fairly long line with unbreakable_" + strings.Repeat("x", 60) + " and 🙂 wide cells\n\nnext"
+	for _, width := range []int{10, 40, 80} {
+		for _, line := range wrapText(text, width) {
+			if visibleWidth(line) > width {
+				t.Errorf("width %d: %q is %d cells", width, line, visibleWidth(line))
+			}
+		}
+	}
+	if got := wrapText("a b", 80); len(got) != 1 || got[0] != "a b" {
+		t.Errorf("short text = %v", got)
+	}
+}
+
+func TestDisclosureNamesTheDestination(t *testing.T) {
+	if !strings.Contains(Disclosure("typesafe"), "api.typesafe.ai") {
+		t.Error("the TypeSafe disclosure must name api.typesafe.ai")
+	}
+	own := Disclosure("ownmodel")
+	if !strings.Contains(own, "Nothing is sent to api.typesafe.ai") || !strings.Contains(own, "model PiG is configured with") {
+		t.Errorf("own-model disclosure = %s", own)
+	}
+	if !strings.Contains(ToolDescription("ownmodel"), own) || !strings.Contains(ToolDescription("typesafe"), Disclosure("typesafe")) {
+		t.Error("the tool description carries the disclosure of its backend")
+	}
+}

package/extensions/pi-typesafe/go.mod

@@ -0,0 +1,10 @@
+module github.com/MichaelKinsy/pigpen/components/pi-typesafe/extensions/pi-typesafe
+
+go 1.26
+
+// PiG resolves this requirement to the version-matched staged SDK at build time.
+require github.com/MichaelKinsy/PiG/extensions/sdk v0.4.1
+
+// The typed API (components/pi-typesafe-api) and, through it, the shared client (components/typesafe),
+// found through go.work in this directory.
+require github.com/MichaelKinsy/pigpen/components/pi-typesafe-api v0.0.0

package/extensions/pi-typesafe/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/pi-typesafe/go.work

@@ -0,0 +1,11 @@
+go 1.26
+
+// PiG's extension resolver reads this file (extension/source: goWorkspaceModuleRoots) to
+// find the shared library modules, and adds the require and replace itself when it fuses
+// or builds. The relative paths are the same in the repository and in a staged Piglet
+// (packages/<package>/extensions/<name> -> packages/pi-typesafe-api, packages/typesafe).
+use (
+	.
+	../../libs/pi-typesafe-api
+	../../libs/typesafe
+)

package/extensions/pi-typesafe/harness_test.go

@@ -0,0 +1,200 @@
+package pi_typesafe_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	pi_typesafe "github.com/MichaelKinsy/pigpen/components/pi-typesafe/extensions/pi-typesafe"
+)
+
+// rig is one fake PiG host running the extension, with a fake TypeSafe server behind its HTTP client and
+// scripted answers for the dialogs the extension opens. No test here reaches the network or the real agent
+// directory (rule 17).
+type rig struct {
+	t             *testing.T
+	host          *Host
+	agentDir      string
+	mu            sync.Mutex
+	notices       []string
+	messages      []string
+	confirmResult bool
+	confirmations int
+	confirmTitles []string
+	confirmBodies []string
+	editorText    string
+	editorOK      bool
+	inputText     string
+	customResult  any // nil: cancelled; string: the typed key; "unsupported": the host has no custom components
+	network       atomic.Int32
+	modelList     atomic.Int32
+	respond       func(r *http.Request) *http.Response
+	entries       []json.RawMessage
+	entryTypes    []string
+	levels        []string
+	customTypes   []string
+	// onConfirm runs when a confirm dialog opens, before it is answered (outside the rig's lock).
+	onConfirm func()
+	// modelInfo answers getModelInfo (the model PiG is configured with); nil answers {} (none selected).
+	modelInfo map[string]any
+}
+
+func isolate(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	agent := filepath.Join(dir, "agent")
+	t.Setenv("HOME", dir)
+	t.Setenv("PIG_HOME", filepath.Join(dir, "pighome"))
+	t.Setenv("PIG_CODING_AGENT_DIR", agent)
+	t.Setenv("PI_CODING_AGENT_DIR", filepath.Join(dir, "pi-agent"))
+	t.Setenv("PIG_USE_PI_DIRS", "")
+	for _, name := range []string{"TYPESAFE_API_KEY", "OPENROUTER_API_KEY", "PI_TYPESAFE_ENABLED", "PI_TYPESAFE_BACKEND",
+		"PI_TYPESAFE_MAX_REQUESTS_PER_DAY", "PI_TYPESAFE_MAX_INPUT_TOKENS_PER_DAY", "PI_TYPESAFE_MAX_USD_PER_DAY", "TYPESAFE_BASE_URL", "TYPESAFE_LOG_LEVEL"} {
+		t.Setenv(name, "")
+	}
+	return agent
+}
+
+type doerFunc func(*http.Request) (*http.Response, error)
+
+func (f doerFunc) Do(r *http.Request) (*http.Response, error) { return f(r) }
+
+func jsonResponse(status int, body any) *http.Response {
+	data, _ := json.Marshal(body)
+	return &http.Response{StatusCode: status, Header: http.Header{"Content-Type": {"application/json"}}, Body: io.NopCloser(bytes.NewReader(data))}
+}
+
+func newRig(t *testing.T, opts ...func(*pi_typesafe.Options)) *rig {
+	t.Helper()
+	r := &rig{t: t, agentDir: isolate(t), confirmResult: true}
+	options := pi_typesafe.Options{HTTPClient: doerFunc(func(req *http.Request) (*http.Response, error) {
+		if strings.HasSuffix(req.URL.Path, "/v1/models") {
+			r.modelList.Add(1)
+			return jsonResponse(200, map[string]any{"models": []any{map[string]any{"name": "jev-latest", "description": "", "release_date": "2026-01-01"}}}), nil
+		}
+		r.network.Add(1)
+		if r.respond != nil {
+			return r.respond(req), nil
+		}
+		return jsonResponse(200, map[string]any{"model": "jev-test", "answers": map[string]any{"yes": map[string]any{"type": "noul", "noul": 0.9}}, "usage": map[string]any{"input_tokens": 12, "output_tokens": 0}}), nil
+	})}
+	for _, o := range opts {
+		o(&options)
+	}
+	r.host = StartHost(t, pi_typesafe.New(options), HostOptions{OnCall: r.onCall})
+	return r
+}
+
+func (r *rig) onCall(method string, args map[string]any) (map[string]any, string) {
+	if method == "ui.confirm" && r.onConfirm != nil {
+		r.onConfirm()
+	}
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	switch method {
+	case "getModelInfo":
+		return r.modelInfo, ""
+	case "ui.notify":
+		r.notices = append(r.notices, args["message"].(string))
+		r.levels = append(r.levels, args["level"].(string))
+	case "sendMessage":
+		if m, ok := args["message"].(map[string]any); ok {
+			r.messages = append(r.messages, m["content"].(string))
+			r.customTypes = append(r.customTypes, m["customType"].(string))
+		}
+	case "appendEntry":
+		r.entryTypes = append(r.entryTypes, args["customType"].(string))
+		data, _ := json.Marshal(args["data"])
+		r.entries = append(r.entries, data)
+	case "ui.confirm":
+		r.confirmations++
+		r.confirmTitles = append(r.confirmTitles, args["title"].(string))
+		r.confirmBodies = append(r.confirmBodies, args["message"].(string))
+		return map[string]any{"confirmed": r.confirmResult}, ""
+	case "ui.editor":
+		return map[string]any{"text": r.editorText, "ok": r.editorOK}, ""
+	case "ui.input":
+		if r.customResult != "unsupported" {
+			return nil, "plain input must not be used when custom UI exists"
+		}
+		return map[string]any{"text": r.inputText, "ok": true}, ""
+	case "ui.custom":
+		switch v := r.customResult.(type) {
+		case nil:
+			return map[string]any{"ok": false}, ""
+		case string:
+			if v == "unsupported" {
+				return nil, "custom components are unavailable"
+			}
+			return map[string]any{"ok": true, "result": v}, ""
+		}
+	}
+	return nil, ""
+}
+
+func (r *rig) lastNotice() string {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if len(r.notices) == 0 {
+		return ""
+	}
+	return r.notices[len(r.notices)-1]
+}
+
+func (r *rig) noticeCount() int { r.mu.Lock(); defer r.mu.Unlock(); return len(r.notices) }
+
+func (r *rig) noticesSince(n int) []string {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return append([]string(nil), r.notices[n:]...)
+}
+
+func (r *rig) command(args string) {
+	r.t.Helper()
+	if failure := r.host.Command("typesafe", args); failure != "" {
+		r.t.Fatalf("/typesafe %s failed: %s", args, failure)
+	}
+}
+
+var defaultParams = map[string]any{"state": "synthetic", "questions": map[string]any{"yes": map[string]any{"type": "noul", "instructions": "Is this synthetic?"}}}
+
+// tool runs typesafe_evaluate and returns its details (nil on failure) and the failure text.
+func (r *rig) tool(params map[string]any) (map[string]any, string) {
+	r.t.Helper()
+	if params == nil {
+		params = defaultParams
+	}
+	raw, failure := r.host.Tool("typesafe_evaluate", params)
+	if failure != "" {
+		return nil, failure
+	}
+	var result struct {
+		Content string         `json:"content"`
+		Details map[string]any `json:"details"`
+	}
+	if err := json.Unmarshal(raw, &result); err != nil {
+		r.t.Fatalf("tool result %s: %v", raw, err)
+	}
+	return result.Details, ""
+}
+
+func (r *rig) startSession(reason string) {
+	r.t.Helper()
+	r.host.Fire("session_start", map[string]any{"reason": reason})
+}
+
+func yes(details map[string]any) float64 {
+	answers, _ := details["answers"].(map[string]any)
+	answer, _ := answers["yes"].(map[string]any)
+	f, _ := answer["noul"].(float64)
+	return f
+}
+
+func fileExists(path string) bool { _, err := os.Stat(path); return err == nil }

package/extensions/pi-typesafe/ownmodel_test.go

@@ -0,0 +1,100 @@
+package pi_typesafe_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	pi_typesafe "github.com/MichaelKinsy/pigpen/components/pi-typesafe/extensions/pi-typesafe"
+	"github.com/MichaelKinsy/pigpen/components/typesafe/libraries/typesafe"
+)
+
+// fakeOwn is an own-model evaluator: it answers every question and records that it was used.
+type fakeOwn struct{ calls int }
+
+func (f *fakeOwn) SystemOne(_ context.Context, req typesafe.SystemOneRequest, _ *typesafe.RequestOptions) (*typesafe.SystemOneResult, error) {
+	f.calls++
+	answers := map[string]typesafe.Answer{}
+	for _, q := range req.Questions {
+		answers[q.Name] = typesafe.NoulAnswer{Noul: 0.25}
+	}
+	return &typesafe.SystemOneResult{Model: "own-test", Answers: answers, Usage: typesafe.Usage{InputTokens: 5}}, nil
+}
+
+func TestOwnModelBackendSendsNothingToTypeSafe(t *testing.T) {
+	own := &fakeOwn{}
+	r := newRig(t, func(o *pi_typesafe.Options) { o.Evaluator = own })
+	r.command("backend ownmodel")
+	if !strings.Contains(r.lastNotice(), "consent to sending content to the provider of the model PiG is configured with") {
+		t.Fatalf("switch notice = %s", r.lastNotice())
+	}
+	// Consent is per destination: the switch leaves the tool disabled.
+	if _, failure := r.tool(nil); !strings.Contains(failure, "disabled") {
+		t.Fatalf("failure = %q", failure)
+	}
+	r.confirmResult = true
+	r.command("enable")
+	if !strings.Contains(r.confirmBodies[len(r.confirmBodies)-1], "Nothing is sent to api.typesafe.ai") {
+		t.Fatalf("the consent dialog must name the own-model destination: %v", r.confirmBodies)
+	}
+	details, failure := r.tool(nil)
+	if failure != "" || details["model"] != "own-test" || own.calls != 1 {
+		t.Fatalf("details=%v failure=%q calls=%d", details, failure, own.calls)
+	}
+	if r.network.Load() != 0 || r.modelList.Load() != 0 {
+		t.Fatalf("the own-model backend must not call the TypeSafe API (network=%d)", r.network.Load())
+	}
+	r.command("status")
+	if !strings.Contains(r.lastNotice(), "no key needed") || !strings.Contains(r.lastNotice(), "Nothing is sent to api.typesafe.ai") {
+		t.Fatalf("status = %s", r.lastNotice())
+	}
+	r.command("login")
+	if !strings.Contains(r.lastNotice(), "needs no key") {
+		t.Fatalf("login = %s", r.lastNotice())
+	}
+	r.command("backend typesafe")
+	if _, failure := r.tool(nil); !strings.Contains(failure, "disabled") {
+		t.Fatalf("switching back must disable again: %q", failure)
+	}
+	r.command("backend nonsense")
+	if !strings.Contains(r.lastNotice(), "Unknown backend") {
+		t.Fatalf("notice = %s", r.lastNotice())
+	}
+}
+
+func TestStartupBackendFromEnvironment(t *testing.T) {
+	t.Setenv("PI_TYPESAFE_BACKEND", "ownmodel")
+	r := newRig(t, func(o *pi_typesafe.Options) { o.Evaluator = &fakeOwn{} })
+	t.Setenv("PI_TYPESAFE_BACKEND", "ownmodel")
+	r.startSession("startup")
+	r.command("backend")
+	if !strings.Contains(r.lastNotice(), "Judgment backend: ownmodel") {
+		t.Fatalf("notice = %s", r.lastNotice())
+	}
+}
+
+func TestHeadlessCommandsReportThroughMessages(t *testing.T) {
+	agent := isolate(t)
+	_ = agent
+	no := false
+	ext := pi_typesafe.New(pi_typesafe.Options{})
+	var messages []string
+	host := StartHost(t, ext, HostOptions{HasUI: &no, Mode: "print", OnCall: func(method string, args map[string]any) (map[string]any, string) {
+		if method == "sendMessage" {
+			messages = append(messages, args["message"].(map[string]any)["content"].(string))
+		}
+		return nil, ""
+	}})
+	if failure := host.Command("typesafe", "enable"); failure != "" {
+		t.Fatal(failure)
+	}
+	if len(messages) != 1 || !strings.Contains(messages[0], "needs interactive Pi") {
+		t.Fatalf("messages = %v", messages)
+	}
+	if failure := host.Command("typesafe", "status"); failure != "" || len(messages) != 2 || !strings.Contains(messages[1], "TypeSafe: disabled.") {
+		t.Fatalf("status: %q %v", failure, messages)
+	}
+	if failure := host.Command("typesafe", "bogus"); failure != "" || !strings.Contains(messages[2], "Usage: /typesafe login | logout | setup | status | enable | disable | test | playground") {
+		t.Fatalf("usage: %q %v", failure, messages)
+	}
+}