Merge pull request #2 from zainfathoni/fix/circular-lookup-and-inline-proxy

fix: smart fizzy binary lookup to prevent circular resolution

Author: zainfathoni

main.go

@@ -3,9 +3,11 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/yuin/goldmark"
@@ -36,7 +38,7 @@ func convertMarkdownToHTML(markdown string) (string, error) {
 	if err := md.Convert([]byte(markdown), &buf); err != nil {
 		return "", fmt.Errorf("markdown conversion failed: %w", err)
 	}
-	
+
 	// Trim trailing newline (goldmark adds it)
 	html := strings.TrimSuffix(buf.String(), "\n")
 	return html, nil
@@ -50,17 +52,17 @@ func readAndConvertFile(path string) (string, error) {
 	}
 
 	ext := strings.ToLower(filepath.Ext(path))
-	
+
 	// If .html file, return as-is
 	if ext == ".html" || ext == ".htm" {
 		return string(content), nil
 	}
-	
+
 	// If .md file or no extension, convert Markdown to HTML
 	if ext == ".md" || ext == "" {
 		return convertMarkdownToHTML(string(content))
 	}
-	
+
 	// Unknown extension - assume Markdown for safety (agent-friendly default)
 	return convertMarkdownToHTML(string(content))
 }
@@ -69,75 +71,182 @@ func readAndConvertFile(path string) (string, error) {
 func processArgs(args []string) ([]string, error) {
 	result := make([]string, 0, len(args))
 	i := 0
-	
+
 	for i < len(args) {
 		arg := args[i]
-		
+
 		// Check for flags that need conversion
 		if arg == "--description" || arg == "--body" {
 			if i+1 >= len(args) {
 				return nil, fmt.Errorf("flag %s requires a value", arg)
 			}
-			
+
 			// Convert inline Markdown text to HTML
 			markdown := args[i+1]
 			html, err := convertMarkdownToHTML(markdown)
 			if err != nil {
 				return nil, fmt.Errorf("converting %s: %w", arg, err)
 			}
-			
+
 			result = append(result, arg, html)
 			i += 2
 			continue
 		}
-		
+
 		if arg == "--description_file" || arg == "--body_file" {
 			if i+1 >= len(args) {
 				return nil, fmt.Errorf("flag %s requires a file path", arg)
 			}
-			
+
 			// Read file and convert to HTML
 			filePath := args[i+1]
 			html, err := readAndConvertFile(filePath)
 			if err != nil {
 				return nil, err
 			}
-			
+
 			// Create temp file with HTML content
 			tmpFile, err := os.CreateTemp("", "fizzy-md-*.html")
 			if err != nil {
 				return nil, fmt.Errorf("failed to create temp file: %w", err)
 			}
 			defer tmpFile.Close()
-			
+
 			if _, err := tmpFile.WriteString(html); err != nil {
 				return nil, fmt.Errorf("failed to write temp file: %w", err)
 			}
-			
+
 			// Replace flag with temp file path
 			result = append(result, arg, tmpFile.Name())
 			i += 2
 			continue
 		}
-		
+
 		// Pass through all other arguments unchanged
 		result = append(result, arg)
 		i++
 	}
-	
+
 	return result, nil
 }
 
+// findFizzy locates the real fizzy binary, avoiding circular resolution.
+// Priority: FIZZY_PATH env var → PATH lookup (skipping our own binary).
+func findFizzy() string {
+	// 1. Explicit override via env var
+	if p := os.Getenv("FIZZY_PATH"); p != "" {
+		if _, err := os.Stat(p); err == nil {
+			return p
+		}
+	}
+
+	// 2. Resolve our own executable path so we can skip it
+	self, _ := os.Executable()
+	if self != "" {
+		self, _ = filepath.EvalSymlinks(self)
+	}
+
+	// 3. Walk PATH entries looking for a "fizzy" that isn't us
+	pathEnv := os.Getenv("PATH")
+	for _, dir := range filepath.SplitList(pathEnv) {
+		for _, candidate := range fizzyCandidates(dir) {
+			info, err := os.Stat(candidate)
+			if err != nil || info.IsDir() {
+				continue
+			}
+
+			real, _ := filepath.EvalSymlinks(candidate)
+
+			// Skip if it resolves to ourselves (fizzy-md)
+			if self != "" && real == self {
+				continue
+			}
+
+			// Skip shell scripts that call fizzy-md (wrapper scripts)
+			if isShellWrapperForFizzyMd(candidate) {
+				continue
+			}
+
+			return candidate
+		}
+	}
+
+	return ""
+}
+
+// isShellWrapperForFizzyMd does a quick check if a file is a small shell script
+// that references fizzy-md (i.e. a wrapper that would cause a loop).
+func isShellWrapperForFizzyMd(path string) bool {
+	info, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+	if info.IsDir() {
+		return false
+	}
+	// Only check small files (real fizzy binary is >1MB)
+	if info.Size() > 4096 {
+		return false
+	}
+
+	file, err := os.Open(path)
+	if err != nil {
+		return false
+	}
+	defer file.Close()
+
+	buf := make([]byte, 4096)
+	n, err := file.Read(buf)
+	if err != nil && err != io.EOF {
+		return false
+	}
+	content := string(buf[:n])
+	return strings.Contains(content, "fizzy-md")
+}
+
+func fizzyCandidates(dir string) []string {
+	base := "fizzy"
+	if runtime.GOOS != "windows" {
+		return []string{filepath.Join(dir, base)}
+	}
+	if filepath.Ext(base) != "" {
+		return []string{filepath.Join(dir, base)}
+	}
+
+	pathext := os.Getenv("PATHEXT")
+	var exts []string
+	if pathext == "" {
+		exts = []string{".com", ".exe", ".bat", ".cmd"}
+	} else {
+		for _, ext := range strings.Split(pathext, ";") {
+			clean := strings.TrimSpace(ext)
+			if clean == "" {
+				continue
+			}
+			if !strings.HasPrefix(clean, ".") {
+				clean = "." + clean
+			}
+			exts = append(exts, clean)
+		}
+	}
+
+	paths := make([]string, 0, len(exts))
+	for _, ext := range exts {
+		paths = append(paths, filepath.Join(dir, base+ext))
+	}
+	return paths
+}
+
 func main() {
 	// Get original args (skip program name)
 	args := os.Args[1:]
-	
+
 	// Handle --version flag
 	if len(args) == 1 && (args[0] == "--version" || args[0] == "-v") {
 		fmt.Printf("fizzy-md version %s\n", version)
 		os.Exit(0)
 	}
-	
+
 	// Handle stdin mode: if no args and stdin is piped, convert and output
 	if len(args) == 0 {
 		stat, _ := os.Stdin.Stat()
@@ -148,39 +257,39 @@ func main() {
 				fmt.Fprintf(os.Stderr, "fizzy-md error: failed to read stdin: %v\n", err)
 				os.Exit(1)
 			}
-			
+
 			html, err := convertMarkdownToHTML(buf.String())
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "fizzy-md error: %v\n", err)
 				os.Exit(1)
 			}
-			
+
 			fmt.Print(html)
 			os.Exit(0)
 		}
 	}
-	
+
 	// Process args for Markdown conversion
 	processedArgs, err := processArgs(args)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "fizzy-md error: %v\n", err)
 		os.Exit(1)
 	}
-	
-	// Find fizzy executable
-	fizzyPath, err := exec.LookPath("fizzy")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fizzy-md error: fizzy command not found in PATH\n")
-		fmt.Fprintf(os.Stderr, "Please install fizzy-cli: https://github.com/robzolkos/fizzy-cli\n")
+
+	// Find fizzy executable, avoiding circular resolution back to ourselves
+	fizzyPath := findFizzy()
+	if fizzyPath == "" {
+		fmt.Fprintf(os.Stderr, "fizzy-md error: fizzy command not found\n")
+		fmt.Fprintf(os.Stderr, "Set FIZZY_PATH or install fizzy-cli: https://github.com/robzolkos/fizzy-cli\n")
 		os.Exit(1)
 	}
-	
+
 	// Execute real fizzy with processed args
 	cmd := exec.Command(fizzyPath, processedArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	
+
 	if err := cmd.Run(); err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			os.Exit(exitErr.ExitCode())