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

package/ui/login.go

@@ -0,0 +1,106 @@
+package ui
+
+import (
+	"context"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+	pitypesafe "github.com/MichaelKinsy/pigpen/components/pi-typesafe-api"
+	"github.com/MichaelKinsy/pigpen/components/typesafe/libraries/typesafe"
+)
+
+// LoginResult is a completed login.
+type LoginResult struct {
+	// Path is where the verified key was saved.
+	Path string
+	// Models is the number of models the key can access; it proves the API accepted the key.
+	Models int
+}
+
+// LoginOptions configure the login helpers.
+type LoginOptions struct {
+	// HTTPClient is a transport injection for offline tests.
+	HTTPClient typesafe.HTTPDoer
+}
+
+// LoginWithPrompt asks for a TypeSafe key (hidden input), verifies it against api.typesafe.ai with a model
+// listing, and stores it for every consumer of this package. It returns nil when the user cancels and a
+// *pitypesafe.IntegrationError for an invalid or unverifiable key. It refuses when TYPESAFE_API_KEY is set,
+// because the environment would shadow the stored key. Other backends have no login: their key is an
+// environment variable only.
+func LoginWithPrompt(ctx sdk.Context, opts LoginOptions) (*LoginResult, error) {
+	if pitypesafe.EnvKeySet() {
+		return nil, &pitypesafe.IntegrationError{Code: pitypesafe.CodeConfiguration, Message: "TYPESAFE_API_KEY is set in the environment and takes precedence over a stored key. Unset it before logging in interactively."}
+	}
+	if !ctx.HasUI() {
+		return nil, &pitypesafe.IntegrationError{Code: pitypesafe.CodeConfiguration, Message: "Logging in needs an interactive session. Set TYPESAFE_API_KEY in the environment instead."}
+	}
+	entered, ok, err := PromptForAPIKey(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		return nil, nil
+	}
+	key, err := pitypesafe.NormalizeAPIKey(entered)
+	if err != nil {
+		return nil, err
+	}
+	// Verify before saving so a bad paste fails here, not on first use.
+	client, err := pitypesafe.New(pitypesafe.Options{APIKey: key, HTTPClient: opts.HTTPClient})
+	if err != nil {
+		return nil, err
+	}
+	models, err := client.ListModels(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	path, err := pitypesafe.StoreAPIKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return &LoginResult{Path: path, Models: len(models)}, nil
+}
+
+// EnsureResult is the outcome of EnsureAPIKey: the source of the key in use, and the login when one ran.
+type EnsureResult struct {
+	Source pitypesafe.KeySource
+	Login  *LoginResult
+}
+
+// EnsureAPIKey uses the configured key for the backend if there is one; otherwise it runs the login prompt. A
+// nil result means the user cancelled. A store that must not be read returns a configuration error with the
+// reason instead of prompting, so a permissions problem stays visible. A backend without a login store (every
+// backend except TypeSafe) returns a configuration error naming its environment variable instead of
+// prompting, because the prompt would verify the key against the wrong service and store it where the
+// TypeSafe key lives. backend nil means the default.
+func EnsureAPIKey(ctx sdk.Context, backend any, opts LoginOptions) (*EnsureResult, error) {
+	if backend == nil {
+		backend = pitypesafe.DefaultBackend
+	}
+	situation, err := pitypesafe.KeySituationFor(backend)
+	if err != nil {
+		return nil, err
+	}
+	switch situation.Kind {
+	case pitypesafe.KeyEnvironment:
+		return &EnsureResult{Source: pitypesafe.SourceEnvironment}, nil
+	case pitypesafe.KeyStored:
+		return &EnsureResult{Source: pitypesafe.SourceStored}, nil
+	case pitypesafe.KeyNotRequired:
+		return &EnsureResult{}, nil
+	case pitypesafe.KeyUnusable:
+		return nil, &pitypesafe.IntegrationError{Code: pitypesafe.CodeConfiguration, Message: situation.Reason}
+	}
+	config, err := pitypesafe.ResolveBackend(backend)
+	if err != nil {
+		return nil, err
+	}
+	if !pitypesafe.UsesTypeSafeKey(config.BackendConfig) {
+		return nil, &pitypesafe.IntegrationError{Code: pitypesafe.CodeConfiguration, Message: "No " + config.Label + " key. Set " + config.KeyEnv + " in the environment; /typesafe login stores a TypeSafe key only."}
+	}
+	login, err := LoginWithPrompt(ctx, opts)
+	if err != nil || login == nil {
+		return nil, err
+	}
+	return &EnsureResult{Source: pitypesafe.SourceStored, Login: login}, nil
+}

package/ui/twin_test.go

@@ -0,0 +1,28 @@
+package ui_test
+
+// 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 ui_test with the package name (in
+// an external test package use `ui_test_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/ui/ui_test.go

@@ -0,0 +1,285 @@
+package ui_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"unicode/utf8"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+	pitypesafe "github.com/MichaelKinsy/pigpen/components/pi-typesafe-api"
+	"github.com/MichaelKinsy/pigpen/components/pi-typesafe-api/ui"
+)
+
+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("PIG_USE_PI_DIRS", "")
+	for _, name := range []string{"TYPESAFE_API_KEY", "OPENROUTER_API_KEY"} {
+		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) }
+
+// loginRig runs a test extension whose /login command calls the helpers under test.
+type loginRig struct {
+	t          *testing.T
+	host       *Host
+	custom     any // nil: cancelled; string: typed key; "unsupported": no custom components
+	inputText  string
+	modelCalls atomic.Int32
+	result     *ui.LoginResult
+	ensured    *ui.EnsureResult
+	err        error
+	backend    any
+	ensure     bool
+}
+
+func newLoginRig(t *testing.T, hasUI bool) *loginRig {
+	t.Helper()
+	r := &loginRig{t: t}
+	opts := ui.LoginOptions{HTTPClient: doerFunc(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasSuffix(req.URL.Path, "/v1/models") {
+			t.Errorf("unexpected request to %s", req.URL)
+			return nil, io.ErrUnexpectedEOF
+		}
+		r.modelCalls.Add(1)
+		body, _ := json.Marshal(map[string]any{"models": []any{map[string]any{"name": "jev-latest", "description": "", "release_date": "2026-01-01"}, map[string]any{"name": "jev-preview", "description": "", "release_date": "2026-01-01"}}})
+		return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": {"application/json"}}, Body: io.NopCloser(bytes.NewReader(body))}, nil
+	})}
+	ext := sdk.New("ui-test")
+	ext.Command("run", "runs the helper under test", func(ctx sdk.Context, _ string) error {
+		if r.ensure {
+			r.ensured, r.err = ui.EnsureAPIKey(ctx, r.backend, opts)
+		} else {
+			r.result, r.err = ui.LoginWithPrompt(ctx, opts)
+		}
+		return nil
+	})
+	r.host = StartHost(t, ext, HostOptions{HasUI: &hasUI, OnCall: func(method string, args map[string]any) (map[string]any, string) {
+		switch method {
+		case "ui.custom":
+			switch v := r.custom.(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}, ""
+			}
+		case "ui.input":
+			if r.custom != "unsupported" {
+				return nil, "plain input must not be used when custom UI exists"
+			}
+			return map[string]any{"text": r.inputText, "ok": true}, ""
+		}
+		return nil, ""
+	}})
+	return r
+}
+
+func (r *loginRig) run() {
+	r.t.Helper()
+	r.result, r.ensured, r.err = nil, nil, nil
+	if failure := r.host.Command("run", ""); failure != "" {
+		r.t.Fatalf("command failed: %s", failure)
+	}
+}
+
+func isCode(err error, code pitypesafe.ErrorCode) bool {
+	ie, ok := err.(*pitypesafe.IntegrationError)
+	return ok && ie.Code == code
+}
+
+func TestLogin(t *testing.T) {
+	tw(t, "login", "loginWithPrompt cancels cleanly, rejects bad keys, and stores a verified key with owner-only permissions", func(t *testing.T) {
+		agent := isolate(t)
+		stored := filepath.Join(agent, "pi-typesafe", "auth.json")
+		r := newLoginRig(t, true)
+		r.run()
+		if r.result != nil || r.err != nil {
+			t.Fatalf("cancel: %v %v", r.result, r.err)
+		}
+		if _, err := os.Stat(stored); err == nil {
+			t.Fatal("nothing may be saved on cancel")
+		}
+		r.custom = "nope"
+		r.run()
+		if !isCode(r.err, pitypesafe.CodeValidation) || strings.Contains(r.err.Error(), "nope") || r.modelCalls.Load() != 0 {
+			t.Fatalf("bad key: %v", r.err)
+		}
+		r.custom = "ts_live_key_0123456789abcdef"
+		r.run()
+		if r.err != nil || r.result == nil || *r.result != (ui.LoginResult{Path: stored, Models: 2}) || r.modelCalls.Load() != 1 {
+			t.Fatalf("login: %+v %v", r.result, r.err)
+		}
+		if info, _ := os.Stat(stored); runtime.GOOS != "windows" && info.Mode().Perm() != 0o600 {
+			t.Errorf("mode = %v", info.Mode().Perm())
+		}
+	})
+	tw(t, "login", "loginWithPrompt refuses when the environment key would shadow the store, or without a UI", func(t *testing.T) {
+		agent := isolate(t)
+		r := newLoginRig(t, true)
+		t.Setenv("TYPESAFE_API_KEY", "env-key-0123456789")
+		r.custom = "ts_live_key_0123456789abcdef"
+		r.run()
+		if !isCode(r.err, pitypesafe.CodeConfiguration) || !strings.Contains(r.err.Error(), "TYPESAFE_API_KEY") {
+			t.Fatalf("env: %v", r.err)
+		}
+		t.Setenv("TYPESAFE_API_KEY", "")
+		headless := newLoginRig(t, false)
+		headless.run()
+		if headless.err == nil || !regexp.MustCompile(`interactive`).MatchString(headless.err.Error()) {
+			t.Fatalf("headless: %v", headless.err)
+		}
+		if _, err := os.Stat(filepath.Join(agent, "pi-typesafe", "auth.json")); err == nil {
+			t.Fatal("nothing may be saved")
+		}
+	})
+	tw(t, "login", "ensureApiKey reports an existing key without prompting, otherwise logs in", func(t *testing.T) {
+		agent := isolate(t)
+		stored := filepath.Join(agent, "pi-typesafe", "auth.json")
+		r := newLoginRig(t, true)
+		r.ensure = true
+		t.Setenv("TYPESAFE_API_KEY", "env-key-0123456789")
+		r.custom = "must-not-be-used-0123456789"
+		r.run()
+		if r.err != nil || r.ensured == nil || r.ensured.Source != pitypesafe.SourceEnvironment || r.ensured.Login != nil {
+			t.Fatalf("env: %+v %v", r.ensured, r.err)
+		}
+		if _, err := os.Stat(stored); err == nil {
+			t.Fatal("an existing key must not prompt or store")
+		}
+		t.Setenv("TYPESAFE_API_KEY", "")
+		r.custom = nil
+		r.run()
+		if r.ensured != nil || r.err != nil {
+			t.Fatalf("cancelled prompt: %+v %v", r.ensured, r.err)
+		}
+		r.custom = "ts_live_key_0123456789abcdef"
+		r.run()
+		want := ui.EnsureResult{Source: pitypesafe.SourceStored, Login: &ui.LoginResult{Path: stored, Models: 2}}
+		if r.err != nil || r.ensured == nil || r.ensured.Source != want.Source || *r.ensured.Login != *want.Login {
+			t.Fatalf("login: %+v %v", r.ensured, r.err)
+		}
+		r.custom = "another-key-that-must-not-replace-it"
+		r.run()
+		if r.err != nil || r.ensured == nil || r.ensured.Source != pitypesafe.SourceStored || r.ensured.Login != nil || r.modelCalls.Load() != 1 {
+			t.Fatalf("second call reuses the stored key: %+v %v", r.ensured, r.err)
+		}
+	})
+	tw(t, "login", "ensureApiKey for another backend uses its environment variable and never opens the TypeSafe login", func(t *testing.T) {
+		agent := isolate(t)
+		r := newLoginRig(t, true)
+		r.ensure = true
+		// A stored TypeSafe key does not satisfy OpenRouter, and the prompt must not run: it would verify against api.typesafe.ai.
+		r.custom = "ts_live_key_0123456789abcdef"
+		r.run()
+		if r.err != nil || r.ensured == nil || r.ensured.Login == nil || r.ensured.Login.Path != filepath.Join(agent, "pi-typesafe", "auth.json") {
+			t.Fatalf("typesafe login: %+v %v", r.ensured, r.err)
+		}
+		r.backend = "openrouter"
+		r.run()
+		if !isCode(r.err, pitypesafe.CodeConfiguration) || !strings.Contains(r.err.Error(), "OPENROUTER_API_KEY") || r.modelCalls.Load() != 1 {
+			t.Fatalf("openrouter: %v models=%d", r.err, r.modelCalls.Load())
+		}
+		t.Setenv("OPENROUTER_API_KEY", "sk-or-0123456789abcdef")
+		r.run()
+		if r.err != nil || r.ensured == nil || r.ensured.Source != pitypesafe.SourceEnvironment || r.modelCalls.Load() != 1 {
+			t.Fatalf("openrouter env: %+v %v", r.ensured, r.err)
+		}
+	})
+}
+
+func stripANSI(s string) string { return regexp.MustCompile(`\x1b\[[0-9;]*m`).ReplaceAllString(s, "") }
+
+func TestKeyPrompt(t *testing.T) {
+	tw(t, "key-prompt", "typed key is masked on screen and returned on Enter", func(t *testing.T) {
+		p := ui.NewKeyPrompt()
+		for _, c := range "ts_secret_key_0123456789" {
+			if res, err := p.HandleInput(string(c)); err != nil || res.Done {
+				t.Fatalf("typing ended early: %+v %v", res, err)
+			}
+		}
+		frame := p.Render(60)
+		res, err := p.HandleInput("\r")
+		if err != nil || !res.Done || res.Value != "ts_secret_key_0123456789" {
+			t.Fatalf("enter: %+v %v", res, err)
+		}
+		screen := strings.Join(frame, "\n")
+		if strings.Contains(screen, "ts_secret") || !strings.Contains(screen, strings.Repeat("•", 24)) || !strings.Contains(screen, "TypeSafe API key") {
+			t.Fatalf("screen = %q", screen)
+		}
+		for _, line := range frame {
+			if utf8.RuneCountInString(stripANSI(line)) > 60+8 {
+				t.Errorf("line too wide: %q", line)
+			}
+		}
+	})
+	tw(t, "key-prompt", "Escape cancels without a value", func(t *testing.T) {
+		p := ui.NewKeyPrompt()
+		_, _ = p.HandleInput("a")
+		res, err := p.HandleInput("\x1b")
+		if err != nil || !res.Done || res.Value != nil {
+			t.Fatalf("escape: %+v %v", res, err)
+		}
+	})
+	tw(t, "key-prompt", "falls back to Pi's plain input when custom UI is unavailable", func(t *testing.T) {
+		isolate(t)
+		r := newLoginRig(t, true)
+		r.custom = "unsupported"
+		r.inputText = "  ts_plain_key_0123456789  "
+		var got string
+		var ok bool
+		ext := sdk.New("prompt-test")
+		ext.Command("prompt", "", func(ctx sdk.Context, _ string) error {
+			var err error
+			got, ok, err = ui.PromptForAPIKey(ctx)
+			return err
+		})
+		host := StartHost(t, ext, HostOptions{OnCall: func(method string, _ map[string]any) (map[string]any, string) {
+			switch method {
+			case "ui.custom":
+				return nil, "custom components are unavailable"
+			case "ui.input":
+				return map[string]any{"text": r.inputText, "ok": true}, ""
+			}
+			return nil, ""
+		}})
+		if failure := host.Command("prompt", ""); failure != "" || !ok || got != r.inputText {
+			t.Fatalf("fallback: %q %v %q", got, ok, failure)
+		}
+	})
+}
+
+func TestKeyPromptEditing(t *testing.T) {
+	p := ui.NewKeyPrompt()
+	_, _ = p.HandleInput("\x1b[200~ts_pasted_0123456789\x1b[201~")
+	_, _ = p.HandleInput("X")
+	_, _ = p.HandleInput("\x7f")
+	_, _ = p.HandleInput("\x1b[A") // an arrow key is ignored
+	res, _ := p.HandleInput("\r")
+	if res.Value != "ts_pasted_0123456789" {
+		t.Fatalf("value = %q", res.Value)
+	}
+	if got := ui.NewKeyPrompt().Render(4); len(got) < 3 {
+		t.Fatalf("a narrow render still draws every line: %v", got)
+	}
+}