@agentspan/agentspan 0.0.3

package/cmd/server.go

@@ -0,0 +1,446 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/agentspan/agentspan/cli/config"
+	"github.com/agentspan/agentspan/cli/internal/progress"
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+const (
+	s3Bucket = "https://agentspan.s3.us-east-2.amazonaws.com"
+	jarName  = "agentspan-runtime.jar"
+)
+
+var (
+	serverPort    string
+	serverModel   string
+	serverVersion string
+	serverJar     string
+	serverLocal   bool
+	followLogs    bool
+)
+
+var serverCmd = &cobra.Command{
+	Use:   "server",
+	Short: "Manage the agent runtime server",
+}
+
+var serverStartCmd = &cobra.Command{
+	Use:   "start",
+	Short: "Download (if needed) and start the agent runtime server",
+	RunE:  runServerStart,
+}
+
+var serverStopCmd = &cobra.Command{
+	Use:   "stop",
+	Short: "Stop the running agent runtime server",
+	RunE:  runServerStop,
+}
+
+var serverLogsCmd = &cobra.Command{
+	Use:   "logs",
+	Short: "Show server logs",
+	RunE:  runServerLogs,
+}
+
+func init() {
+	serverStartCmd.Flags().StringVarP(&serverPort, "port", "p", "8080", "Server port")
+	serverStartCmd.Flags().StringVarP(&serverModel, "model", "m", "", "Default LLM model (e.g. openai/gpt-4o)")
+	serverStartCmd.Flags().StringVar(&serverVersion, "version", "", "Specific server version to download (e.g. 0.1.0)")
+	serverStartCmd.Flags().StringVar(&serverJar, "jar", "", "Path to a local JAR file to use directly")
+	serverStartCmd.Flags().BoolVar(&serverLocal, "local", false, "Use locally built JAR from server/build/libs/")
+
+	serverLogsCmd.Flags().BoolVarP(&followLogs, "follow", "f", false, "Follow log output")
+
+	serverCmd.AddCommand(serverStartCmd, serverStopCmd, serverLogsCmd)
+	rootCmd.AddCommand(serverCmd)
+}
+
+func serverDir() string {
+	return filepath.Join(config.ConfigDir(), "server")
+}
+
+func pidFile() string {
+	return filepath.Join(serverDir(), "server.pid")
+}
+
+func logFile() string {
+	return filepath.Join(serverDir(), "server.log")
+}
+
+func runServerStart(cmd *cobra.Command, args []string) error {
+	dir := serverDir()
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return fmt.Errorf("create server dir: %w", err)
+	}
+
+	var jarPath string
+	switch {
+	case serverJar != "":
+		// Use explicit JAR path
+		abs, err := filepath.Abs(serverJar)
+		if err != nil {
+			return fmt.Errorf("resolve JAR path: %w", err)
+		}
+		if _, err := os.Stat(abs); err != nil {
+			return fmt.Errorf("JAR not found: %s", abs)
+		}
+		jarPath = abs
+		color.Green("Using JAR: %s", jarPath)
+
+	case serverLocal:
+		// Find locally built JAR by walking up from executable or CWD
+		localJar, err := findLocalJAR()
+		if err != nil {
+			return err
+		}
+		jarPath = localJar
+		color.Green("Using local JAR: %s", jarPath)
+
+	case serverVersion != "":
+		jarPath = filepath.Join(dir, fmt.Sprintf("agentspan-runtime-%s.jar", serverVersion))
+		if err := ensureVersionedJAR(jarPath, serverVersion); err != nil {
+			return err
+		}
+
+	default:
+		jarPath = filepath.Join(dir, jarName)
+		if err := ensureLatestJAR(jarPath); err != nil {
+			return err
+		}
+	}
+
+	// Check if already running
+	if pid, err := readPID(); err == nil {
+		if processRunning(pid) {
+			color.Yellow("Server already running (PID %d). Stop it first with: agentspan server stop", pid)
+			return nil
+		}
+		// Stale PID file
+		os.Remove(pidFile())
+	}
+
+	checkAIProviderKeys()
+
+	bold := color.New(color.Bold)
+	bold.Printf("Starting agent runtime on port %s...\n", serverPort)
+
+	// Build java args
+	javaArgs := []string{"-jar", jarPath}
+
+	env := os.Environ()
+	if serverPort != "8080" {
+		env = append(env, "SERVER_PORT="+serverPort)
+	}
+	if serverModel != "" {
+		env = append(env, "AGENT_DEFAULT_MODEL="+serverModel)
+	}
+
+	// Open log file
+	logF, err := os.OpenFile(logFile(), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
+	if err != nil {
+		return fmt.Errorf("open log file: %w", err)
+	}
+
+	proc := exec.Command("java", javaArgs...)
+	proc.Env = env
+	proc.Stdout = logF
+	proc.Stderr = logF
+	proc.SysProcAttr = sysProcAttr()
+
+	if err := proc.Start(); err != nil {
+		logF.Close()
+		return fmt.Errorf("failed to start server: %w", err)
+	}
+
+	// Write PID
+	pid := proc.Process.Pid
+	if err := os.WriteFile(pidFile(), []byte(strconv.Itoa(pid)), 0o644); err != nil {
+		logF.Close()
+		return fmt.Errorf("write PID file: %w", err)
+	}
+
+	// Detach - release the process so CLI can exit
+	proc.Process.Release()
+	logF.Close()
+
+	color.Green("Server started (PID %d)", pid)
+	fmt.Printf("  Logs: %s\n", logFile())
+	fmt.Printf("  URL:  http://localhost:%s\n", serverPort)
+	fmt.Println("\nUse 'agentspan server logs -f' to follow output.")
+	return nil
+}
+
+func runServerStop(cmd *cobra.Command, args []string) error {
+	pid, err := readPID()
+	if err != nil {
+		color.Yellow("No server PID file found. Server may not be running.")
+		return nil
+	}
+
+	if !processRunning(pid) {
+		os.Remove(pidFile())
+		color.Yellow("Server process (PID %d) is not running. Cleaned up stale PID file.", pid)
+		return nil
+	}
+
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return fmt.Errorf("find process %d: %w", pid, err)
+	}
+
+	if err := killProcess(process); err != nil {
+		return fmt.Errorf("stop process %d: %w", pid, err)
+	}
+
+	os.Remove(pidFile())
+	color.Green("Server stopped (PID %d)", pid)
+	return nil
+}
+
+func runServerLogs(cmd *cobra.Command, args []string) error {
+	path := logFile()
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return fmt.Errorf("no log file found at %s", path)
+	}
+
+	if !followLogs {
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		fmt.Print(string(data))
+		return nil
+	}
+
+	// Follow mode: tail -f style
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	// Seek to end
+	f.Seek(0, io.SeekEnd)
+
+	buf := make([]byte, 4096)
+	for {
+		n, err := f.Read(buf)
+		if n > 0 {
+			fmt.Print(string(buf[:n]))
+		}
+		if err == io.EOF {
+			time.Sleep(200 * time.Millisecond)
+			continue
+		}
+		if err != nil {
+			return err
+		}
+	}
+}
+
+// --- Local JAR helpers ---
+
+func findLocalJAR() (string, error) {
+	// Try CWD first, then walk up to find 'server/build/libs/agentspan-runtime.jar'
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("get working directory: %w", err)
+	}
+
+	// Check common relative paths from likely CWD locations
+	candidates := []string{
+		filepath.Join(cwd, "server", "build", "libs", jarName),
+		filepath.Join(cwd, "build", "libs", jarName),
+		filepath.Join(cwd, "..", "server", "build", "libs", jarName),
+	}
+
+	// Also walk up from CWD looking for server/build/libs/
+	dir := cwd
+	for i := 0; i < 5; i++ {
+		candidate := filepath.Join(dir, "server", "build", "libs", jarName)
+		candidates = append(candidates, candidate)
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break
+		}
+		dir = parent
+	}
+
+	for _, c := range candidates {
+		if _, err := os.Stat(c); err == nil {
+			return filepath.Abs(c)
+		}
+	}
+
+	return "", fmt.Errorf("local JAR not found. Build it first with: cd server && ./gradlew build")
+}
+
+// --- JAR download helpers ---
+
+func ensureVersionedJAR(jarPath, version string) error {
+	if _, err := os.Stat(jarPath); err == nil {
+		color.Green("Using cached JAR for version %s", version)
+		return nil
+	}
+
+	downloadURL := fmt.Sprintf("%s/agentspan-server-%s.jar", s3Bucket, version)
+	return downloadJAR(downloadURL, jarPath)
+}
+
+func ensureLatestJAR(jarPath string) error {
+	downloadURL := fmt.Sprintf("%s/agentspan-server-latest.jar", s3Bucket)
+
+	// If we already have a cached JAR, do a HEAD request to check if remote has changed
+	if info, err := os.Stat(jarPath); err == nil {
+		httpClient := &http.Client{Timeout: 15 * time.Second}
+		resp, err := httpClient.Head(downloadURL)
+		if err != nil {
+			color.Yellow("Could not check for updates (%v), using cached JAR", err)
+			return nil
+		}
+		resp.Body.Close()
+
+		if resp.StatusCode == http.StatusOK {
+			// Compare content-length as a simple freshness check
+			remoteSize := resp.ContentLength
+			if remoteSize > 0 && remoteSize == info.Size() {
+				color.Green("Server JAR is up to date")
+				return nil
+			}
+		} else if resp.StatusCode == http.StatusNotFound {
+			color.Yellow("No remote release found, using cached JAR")
+			return nil
+		}
+	}
+
+	return downloadJAR(downloadURL, jarPath)
+}
+
+func downloadJAR(downloadURL, destPath string) error {
+	color.Yellow("Downloading server JAR...")
+	fmt.Printf("  URL: %s\n", downloadURL)
+
+	httpClient := &http.Client{
+		Timeout: 10 * time.Minute,
+	}
+
+	resp, err := httpClient.Get(downloadURL)
+	if err != nil {
+		return fmt.Errorf("download: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
+	}
+
+	// Write to temp file first, then rename
+	tmpPath := destPath + ".tmp"
+	f, err := os.Create(tmpPath)
+	if err != nil {
+		return fmt.Errorf("create temp file: %w", err)
+	}
+
+	pr, bar := progress.NewReader(resp.Body, resp.ContentLength, "Downloading")
+	_, err = io.Copy(f, pr)
+	f.Close()
+	bar.Finish()
+	if err != nil {
+		os.Remove(tmpPath)
+		return fmt.Errorf("write JAR: %w", err)
+	}
+
+	if err := os.Rename(tmpPath, destPath); err != nil {
+		os.Remove(tmpPath)
+		return fmt.Errorf("rename JAR: %w", err)
+	}
+
+	color.Green("Download complete!")
+	return nil
+}
+
+// --- AI provider check ---
+
+const aiModelsDocURL = "https://github.com/agentspan/agentspan/blob/main/docs/ai-models.md"
+
+func checkAIProviderKeys() {
+	hasAny := false
+	for _, p := range aiProviders {
+		allSet := true
+		for _, env := range p.envVars {
+			if os.Getenv(env) == "" {
+				allSet = false
+				break
+			}
+		}
+		if allSet {
+			hasAny = true
+			break
+		}
+	}
+
+	// Check provider-specific warnings
+	for _, p := range aiProviders {
+		for _, w := range p.warns {
+			if w.condition() {
+				warn := color.New(color.FgYellow, color.Bold)
+				warn.Printf("WARNING: %s — %s\n", p.name, w.message)
+				fmt.Println()
+				fmt.Printf("    %s\n", w.fix)
+				fmt.Println()
+			}
+		}
+	}
+
+	if hasAny {
+		return
+	}
+
+	warn := color.New(color.FgYellow, color.Bold)
+	warn.Println("WARNING: No AI provider API keys detected!")
+	fmt.Println()
+	fmt.Println("  The server will start, but agents won't be able to call any LLM")
+	fmt.Println("  until you set at least one provider's API key.")
+	fmt.Println()
+	fmt.Println("  Set one or more of these before starting the server:")
+	fmt.Println()
+	fmt.Println("    # OpenAI")
+	fmt.Println("    export OPENAI_API_KEY=sk-...")
+	fmt.Println()
+	fmt.Println("    # Anthropic (Claude)")
+	fmt.Println("    export ANTHROPIC_API_KEY=sk-ant-...")
+	fmt.Println()
+	fmt.Println("    # Google Gemini")
+	fmt.Println("    export GEMINI_API_KEY=AI...")
+	fmt.Println("    export GOOGLE_CLOUD_PROJECT=your-gcp-project-id")
+	fmt.Println()
+	fmt.Println("  Run 'agentspan doctor' for a full diagnostic.")
+	fmt.Printf("  Docs: %s\n", aiModelsDocURL)
+	fmt.Println()
+}
+
+// --- PID helpers ---
+
+func readPID() (int, error) {
+	data, err := os.ReadFile(pidFile())
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(strings.TrimSpace(string(data)))
+}
+

package/cmd/server_unix.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+//go:build !windows
+
+package cmd
+
+import (
+	"os"
+	"syscall"
+)
+
+func sysProcAttr() *syscall.SysProcAttr {
+	return &syscall.SysProcAttr{Setpgid: true}
+}
+
+func killProcess(process *os.Process) error {
+	return process.Signal(syscall.SIGTERM)
+}
+
+func processRunning(pid int) bool {
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	err = process.Signal(syscall.Signal(0))
+	return err == nil
+}
+
+func getFreeDiskMB(path string) int64 {
+	var stat syscall.Statfs_t
+	if err := syscall.Statfs(path, &stat); err != nil {
+		return -1
+	}
+	return int64(stat.Bavail) * int64(stat.Bsize) / (1024 * 1024)
+}

package/cmd/server_windows.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+//go:build windows
+
+package cmd
+
+import (
+	"os"
+	"syscall"
+)
+
+func sysProcAttr() *syscall.SysProcAttr {
+	return &syscall.SysProcAttr{}
+}
+
+func killProcess(process *os.Process) error {
+	return process.Kill()
+}
+
+func processRunning(pid int) bool {
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	// On Windows, FindProcess always succeeds; try to open the process
+	err = process.Signal(os.Kill)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+func getFreeDiskMB(path string) int64 {
+	// Not easily available on Windows without unsafe; skip check
+	return -1
+}

package/cmd/status.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var statusCmd = &cobra.Command{
+	Use:   "status <execution-id>",
+	Short: "Get the detailed status of an agent execution",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cfg := getConfig()
+		c := newClient(cfg)
+
+		detail, err := c.GetExecutionDetail(args[0])
+		if err != nil {
+			return fmt.Errorf("failed to get status: %w", err)
+		}
+
+		bold := color.New(color.Bold)
+		bold.Printf("Execution: %s\n", detail.WorkflowID)
+		fmt.Printf("  Agent:   %s (v%d)\n", detail.AgentName, detail.Version)
+
+		statusColor := color.FgWhite
+		switch detail.Status {
+		case "RUNNING":
+			statusColor = color.FgYellow
+		case "COMPLETED":
+			statusColor = color.FgGreen
+		case "FAILED", "TERMINATED", "TIMED_OUT":
+			statusColor = color.FgRed
+		}
+		color.New(statusColor, color.Bold).Printf("  Status:  %s\n", detail.Status)
+
+		if detail.Input != nil {
+			fmt.Printf("\nInput:\n")
+			printJSON(detail.Input)
+		}
+
+		if detail.Output != nil {
+			fmt.Printf("\nOutput:\n")
+			printJSON(detail.Output)
+		}
+
+		if detail.CurrentTask != nil {
+			fmt.Printf("\nCurrent Task:\n")
+			fmt.Printf("  Name:   %s\n", detail.CurrentTask.TaskRefName)
+			fmt.Printf("  Type:   %s\n", detail.CurrentTask.TaskType)
+			fmt.Printf("  Status: %s\n", detail.CurrentTask.Status)
+			if detail.CurrentTask.InputData != nil {
+				fmt.Printf("  Input:\n")
+				printJSON(detail.CurrentTask.InputData)
+			}
+			if detail.CurrentTask.OutputData != nil {
+				fmt.Printf("  Output:\n")
+				printJSON(detail.CurrentTask.OutputData)
+			}
+		}
+
+		return nil
+	},
+}
+
+func init() {
+	agentCmd.AddCommand(statusCmd)
+}

package/cmd/stream.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+var streamLastEventID string
+
+var streamCmd = &cobra.Command{
+	Use:   "stream <workflow-id>",
+	Short: "Stream events from a running agent",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cfg := getConfig()
+		c := newClient(cfg)
+
+		workflowID := args[0]
+		fmt.Printf("Streaming events for %s...\n\n", workflowID)
+
+		return streamWorkflow(c, workflowID)
+	},
+}
+
+func init() {
+	streamCmd.Flags().StringVar(&streamLastEventID, "last-event-id", "", "Resume from a specific event ID")
+	agentCmd.AddCommand(streamCmd)
+}

package/cmd/update.go

@@ -0,0 +1,91 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/agentspan/agentspan/cli/internal/progress"
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+const cliS3Bucket = "https://agentspan.s3.us-east-2.amazonaws.com"
+
+var updateCmd = &cobra.Command{
+	Use:   "update",
+	Short: "Update the CLI to the latest version",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		goos := runtime.GOOS
+		goarch := runtime.GOARCH
+
+		binaryName := fmt.Sprintf("agentspan_%s_%s", goos, goarch)
+		if goos == "windows" {
+			binaryName += ".exe"
+		}
+
+		downloadURL := fmt.Sprintf("%s/cli/latest/%s", cliS3Bucket, binaryName)
+
+		color.Yellow("Downloading latest CLI...")
+		fmt.Printf("  URL: %s\n", downloadURL)
+
+		httpClient := &http.Client{Timeout: 5 * time.Minute}
+		resp, err := httpClient.Get(downloadURL)
+		if err != nil {
+			return fmt.Errorf("download failed: %w", err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
+		}
+
+		// Find current executable path
+		execPath, err := os.Executable()
+		if err != nil {
+			return fmt.Errorf("find executable path: %w", err)
+		}
+
+		// Write to temp file with progress bar
+		tmpPath := execPath + ".new"
+		f, err := os.Create(tmpPath)
+		if err != nil {
+			return fmt.Errorf("create temp file: %w", err)
+		}
+
+		pr, bar := progress.NewReader(resp.Body, resp.ContentLength, "Downloading")
+		_, err = io.Copy(f, pr)
+		f.Close()
+		bar.Finish()
+		if err != nil {
+			os.Remove(tmpPath)
+			return fmt.Errorf("write binary: %w", err)
+		}
+
+		// Make executable
+		if err := os.Chmod(tmpPath, 0o755); err != nil {
+			os.Remove(tmpPath)
+			return fmt.Errorf("chmod: %w", err)
+		}
+
+		// Replace current executable
+		if err := os.Rename(tmpPath, execPath); err != nil {
+			os.Remove(tmpPath)
+			return fmt.Errorf("replace binary: %w", err)
+		}
+
+		color.Green("Updated successfully!")
+		fmt.Println("Run 'agentspan version' to see the new version.")
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(updateCmd)
+}