webctx 0.1.0 → 0.1.1

package/internal/app/app_test.go

@@ -2,6 +2,9 @@ package app
 
 import (
 	"bytes"
+	"os"
+	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 )
@@ -75,3 +78,111 @@ func TestParseGitHubURL(t *testing.T) {
 		t.Fatalf("unexpected parse result: %#v", info)
 	}
 }
+
+func TestSearchMissingCredentialsErrorIsHelpful(t *testing.T) {
+	t.Setenv("BRAVE_API_KEY", "")
+	t.Setenv("TAVILY_API_KEY", "")
+	t.Setenv("EXA_API_KEY", "")
+
+	text, err := Search(SearchParams{Query: "openai api"})
+	if err == nil {
+		t.Fatalf("expected error, got text %q", text)
+	}
+	if !strings.Contains(err.Error(), "missing BRAVE_API_KEY, EXA_API_KEY, TAVILY_API_KEY") {
+		t.Fatalf("unexpected error: %q", err.Error())
+	}
+	if !strings.Contains(err.Error(), "macOS Keychain") {
+		t.Fatalf("expected keychain guidance, got %q", err.Error())
+	}
+}
+
+func TestMapSiteMissingCredentialErrorIsHelpful(t *testing.T) {
+	t.Setenv("FIRECRAWL_API_KEY", "")
+
+	text, err := MapSite("https://example.com")
+	if err == nil {
+		t.Fatalf("expected error, got text %q", text)
+	}
+	if !strings.Contains(err.Error(), "missing FIRECRAWL_API_KEY") {
+		t.Fatalf("unexpected error: %q", err.Error())
+	}
+	if !strings.Contains(err.Error(), ".env.local next to the binary") {
+		t.Fatalf("expected .env.local guidance, got %q", err.Error())
+	}
+}
+
+func TestLoadDotEnvFileDoesNotOverrideExistingEnv(t *testing.T) {
+	tmpDir := t.TempDir()
+	envPath := filepath.Join(tmpDir, ".env.local")
+	if err := os.WriteFile(envPath, []byte("BRAVE_API_KEY=from-file\nEXA_API_KEY=from-file\n"), 0o644); err != nil {
+		t.Fatalf("write env file: %v", err)
+	}
+
+	t.Setenv("BRAVE_API_KEY", "from-env")
+	t.Setenv("EXA_API_KEY", "")
+
+	loadDotEnvFile(envPath)
+
+	if got := os.Getenv("BRAVE_API_KEY"); got != "from-env" {
+		t.Fatalf("expected existing env to win, got %q", got)
+	}
+	if got := os.Getenv("EXA_API_KEY"); got != "" {
+		t.Fatalf("expected explicitly empty env to remain untouched, got %q", got)
+	}
+}
+
+func TestEnvLocalCandidatesPreferExecutableDir(t *testing.T) {
+	originalGetwd := getwdFunc
+	originalExecutable := executableFunc
+	t.Cleanup(func() {
+		getwdFunc = originalGetwd
+		executableFunc = originalExecutable
+	})
+
+	getwdFunc = func() (string, error) { return "/tmp/project", nil }
+	executableFunc = func() (string, error) { return "/opt/webctx/bin/webctx", nil }
+
+	got := envLocalCandidates()
+	want := []string{
+		filepath.Join("/opt/webctx/bin", ".env.local"),
+		filepath.Join("/opt/webctx", ".env.local"),
+		filepath.Join("/tmp/project", ".env.local"),
+	}
+	if runtime.GOOS == "windows" {
+		for i := range want {
+			want[i] = filepath.Clean(want[i])
+		}
+	}
+
+	if len(got) != len(want) {
+		t.Fatalf("unexpected candidate count: got %v want %v", got, want)
+	}
+	for i := range want {
+		if filepath.Clean(got[i]) != filepath.Clean(want[i]) {
+			t.Fatalf("candidate %d mismatch: got %q want %q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestLoadKeychainEnvLoadsMissingOnly(t *testing.T) {
+	originalLookup := keychainLookup
+	t.Cleanup(func() { keychainLookup = originalLookup })
+
+	keychainLookup = func(key string) (string, error) {
+		return "from-keychain-" + key, nil
+	}
+
+	t.Setenv("BRAVE_API_KEY", "already-set")
+	t.Setenv("TAVILY_API_KEY", "")
+	t.Setenv("EXA_API_KEY", "")
+	t.Setenv("FIRECRAWL_API_KEY", "")
+
+	loadKeychainEnv()
+
+	if got := os.Getenv("BRAVE_API_KEY"); got != "already-set" {
+		t.Fatalf("expected existing env to remain, got %q", got)
+	}
+	if got := os.Getenv("TAVILY_API_KEY"); got != "" {
+		t.Fatalf("expected explicitly empty env to remain untouched, got %q", got)
+	}
+}

package/internal/app/scrape.go

@@ -7,7 +7,9 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"sync"
 	"time"
@@ -19,6 +21,15 @@ type MarkdownResult struct {
 	Markdown string
 }
 
+const keychainServiceName = "webctx"
+
+var (
+	credentialEnvKeys = []string{"BRAVE_API_KEY", "TAVILY_API_KEY", "EXA_API_KEY", "FIRECRAWL_API_KEY"}
+	getwdFunc         = os.Getwd
+	executableFunc    = os.Executable
+	keychainLookup    = lookupKeychainSecret
+)
+
 type githubURLInfo struct {
 	Owner  string
 	Repo   string
@@ -263,17 +274,18 @@ func loadEnvLocal() {
 	for _, candidate := range envLocalCandidates() {
 		loadDotEnvFile(candidate)
 	}
+	loadKeychainEnv()
 }
 
 func envLocalCandidates() []string {
 	candidates := []string{}
-	if cwd, err := os.Getwd(); err == nil {
-		candidates = append(candidates, filepath.Join(cwd, ".env.local"))
-	}
-	if exe, err := os.Executable(); err == nil {
+	if exe, err := executableFunc(); err == nil {
 		exeDir := filepath.Dir(exe)
 		candidates = append(candidates, filepath.Join(exeDir, ".env.local"), filepath.Join(filepath.Dir(exeDir), ".env.local"))
 	}
+	if cwd, err := getwdFunc(); err == nil {
+		candidates = append(candidates, filepath.Join(cwd, ".env.local"))
+	}
 	seen := map[string]struct{}{}
 	unique := []string{}
 	for _, c := range candidates {
@@ -304,7 +316,38 @@ func loadDotEnvFile(path string) {
 		key = strings.TrimSpace(key)
 		value = strings.Trim(strings.TrimSpace(value), `"'`)
 		if key != "" {
+			if _, exists := os.LookupEnv(key); exists {
+				continue
+			}
 			_ = os.Setenv(key, value)
 		}
 	}
 }
+
+func loadKeychainEnv() {
+	for _, key := range credentialEnvKeys {
+		if _, exists := os.LookupEnv(key); exists {
+			continue
+		}
+		value, err := keychainLookup(key)
+		if err != nil || strings.TrimSpace(value) == "" {
+			continue
+		}
+		_ = os.Setenv(key, value)
+	}
+}
+
+func lookupKeychainSecret(account string) (string, error) {
+	if runtime.GOOS != "darwin" || strings.TrimSpace(account) == "" {
+		return "", nil
+	}
+
+	out, err := exec.Command("security", "find-generic-password", "-s", keychainServiceName, "-a", account, "-w").Output()
+	if err != nil {
+		if _, ok := err.(*exec.ExitError); ok {
+			return "", nil
+		}
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
+}

package/internal/app/tools.go

@@ -34,6 +34,7 @@ type SearchResult struct {
 type providerDocs struct {
 	Docs     []SearchDoc
 	Provider string
+	Err      error
 }
 
 type scoredURL struct {
@@ -77,7 +78,7 @@ func Search(params SearchParams) (string, error) {
 			defer cancel()
 			res, err := s.fn(ctx)
 			if err != nil {
-				results[i] = providerDocs{Provider: s.name, Docs: []SearchDoc{}}
+				results[i] = providerDocs{Provider: s.name, Docs: []SearchDoc{}, Err: err}
 				return
 			}
 			results[i] = providerDocs{Provider: s.name, Docs: res.Docs}
@@ -90,7 +91,23 @@ func Search(params SearchParams) (string, error) {
 		total += len(r.Docs)
 	}
 	if total == 0 {
-		return "", errors.New("Error searching the web: All search providers failed to return results")
+		missingKeys := uniqueMissingCredentialKeys(results)
+		if len(missingKeys) > 0 {
+			return "", missingCredentialsError("Error searching the web", missingKeys, "")
+		}
+
+		failures := make([]string, 0, len(results))
+		for _, r := range results {
+			if r.Err == nil {
+				continue
+			}
+			failures = append(failures, fmt.Sprintf("%s: %v", r.Provider, r.Err))
+		}
+		if len(failures) > 0 {
+			return "", fmt.Errorf("Error searching the web: all search providers failed (%s)", strings.Join(failures, "; "))
+		}
+
+		return "", errors.New("Error searching the web: all search providers failed to return results")
 	}
 
 	filtered := filterExcludedDomains(results, allExcludedDomains)
@@ -126,7 +143,7 @@ func ReadLink(rawURL string) (string, error) {
 
 	apiKey := strings.TrimSpace(os.Getenv("FIRECRAWL_API_KEY"))
 	if apiKey == "" {
-		return "", errors.New("Error reading web page: FIRECRAWL_API_KEY environment variable is required for non-.md URLs")
+		return "", missingCredentialsError("Error reading web page", []string{"FIRECRAWL_API_KEY"}, "for non-.md URLs")
 	}
 
 	requestBody := map[string]any{
@@ -179,7 +196,7 @@ func ReadLink(rawURL string) (string, error) {
 func MapSite(rawURL string) (string, error) {
 	apiKey := strings.TrimSpace(os.Getenv("FIRECRAWL_API_KEY"))
 	if apiKey == "" {
-		return "", errors.New("Error mapping website: FIRECRAWL_API_KEY environment variable is required")
+		return "", missingCredentialsError("Error mapping website", []string{"FIRECRAWL_API_KEY"}, "")
 	}
 
 	requestBody := map[string]any{
@@ -237,6 +254,47 @@ func formatReadLink(title, rawURL, markdown string) string {
 	return strings.Join(parts, "\n")
 }
 
+func uniqueMissingCredentialKeys(results []providerDocs) []string {
+	keys := map[string]struct{}{}
+	for _, r := range results {
+		if r.Err == nil {
+			continue
+		}
+		msg := r.Err.Error()
+		if !strings.HasPrefix(msg, "missing ") {
+			continue
+		}
+		key := strings.TrimSpace(strings.TrimPrefix(msg, "missing "))
+		if key != "" {
+			keys[key] = struct{}{}
+		}
+	}
+
+	out := make([]string, 0, len(keys))
+	for key := range keys {
+		out = append(out, key)
+	}
+	sort.Strings(out)
+	return out
+}
+
+func missingCredentialsError(prefix string, keys []string, detail string) error {
+	sort.Strings(keys)
+	keysText := strings.Join(keys, ", ")
+	suffix := ""
+	if strings.TrimSpace(detail) != "" {
+		suffix = " " + strings.TrimSpace(detail)
+	}
+
+	return fmt.Errorf(
+		"%s: missing %s%s. Set them as environment variables, place them in a .env.local next to the binary, or store them in macOS Keychain with service %q and account names matching the env vars",
+		prefix,
+		keysText,
+		suffix,
+		keychainServiceName,
+	)
+}
+
 func searchWithBrave(ctx context.Context, query string) (SearchResult, error) {
 	apiKey := strings.TrimSpace(os.Getenv("BRAVE_API_KEY"))
 	if apiKey == "" {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webctx",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Pure Go web search and browsing CLI using Brave, Tavily, Exa, and Firecrawl",
   "license": "MIT",
   "author": "amxv",