Merge origin/main into proxies branch

Author: sjmiller609

DEVELOPMENT.md

@@ -13,7 +13,7 @@ brew install onkernel/tap/kernel
 Install the following tools:
 
 - Go 1.22+ ( https://go.dev/doc/install )
-- [Goreleaser](https://goreleaser.com/install/)
+- [Goreleaser Pro](https://goreleaser.com/install/#pro) - **IMPORTANT: You must install goreleaser-pro, not the standard version, as this is required for our release process**
 - [chglog](https://github.com/goreleaser/chglog)
 
 Compile the CLI:
@@ -60,7 +60,7 @@ A typical workflow we encounter is updating the API and integrating those change
 
 Prerequisites:
 
-- Make sure you have `goreleaser` _pro_ installed via `brew install --cask goreleaser/tap/goreleaser-pro`. You will need a license key (in 1pw), and then `export GORELEASER_KEY=<the key>`.
+- Make sure you have **goreleaser-pro** installed via `brew install --cask goreleaser/tap/goreleaser-pro`. You will need a license key (in 1pw), and then `export GORELEASER_KEY=<the key>`. **Note: goreleaser-pro is required, not the standard goreleaser version.**
 
 - Grab the NPM token for our org (in 1pw) and run `npm config set '//registry.npmjs.org/:_authToken'=<the token>`
 

cmd/invoke.go

@@ -12,6 +12,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/onkernel/cli/pkg/util"
 	"github.com/onkernel/kernel-go-sdk"
 	"github.com/onkernel/kernel-go-sdk/option"
 	"github.com/pterm/pterm"
@@ -21,17 +22,31 @@ import (
 var invokeCmd = &cobra.Command{
 	Use:   "invoke <app_name> <action_name> [flags]",
 	Short: "Invoke a deployed Kernel application",
-	Args:  cobra.ExactArgs(2),
 	RunE:  runInvoke,
 }
 
+var invocationHistoryCmd = &cobra.Command{
+	Use:   "history",
+	Short: "Show invocation history",
+	Args:  cobra.NoArgs,
+	RunE:  runInvocationHistory,
+}
+
 func init() {
 	invokeCmd.Flags().StringP("version", "v", "latest", "Specify a version of the app to invoke (optional, defaults to 'latest')")
 	invokeCmd.Flags().StringP("payload", "p", "", "JSON payload for the invocation (optional)")
 	invokeCmd.Flags().BoolP("sync", "s", false, "Invoke synchronously (default false). A synchronous invocation will open a long-lived HTTP POST to the Kernel API to wait for the invocation to complete. This will time out after 60 seconds, so only use this option if you expect your invocation to complete in less than 60 seconds. The default is to invoke asynchronously, in which case the CLI will open an SSE connection to the Kernel API after submitting the invocation and wait for the invocation to complete.")
+
+	invocationHistoryCmd.Flags().Int("limit", 100, "Max invocations to return (default 100)")
+	invocationHistoryCmd.Flags().StringP("app", "a", "", "Filter by app name")
+	invocationHistoryCmd.Flags().String("version", "", "Filter by invocation version")
+	invokeCmd.AddCommand(invocationHistoryCmd)
 }
 
 func runInvoke(cmd *cobra.Command, args []string) error {
+	if len(args) != 2 {
+		return fmt.Errorf("requires exactly 2 arguments: <app_name> <action_name>")
+	}
 	startTime := time.Now()
 	client := getKernelClient(cmd)
 	appName := args[0]
@@ -70,6 +85,8 @@ func runInvoke(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return handleSdkError(err)
 	}
+	// Log the invocation ID for user reference
+	pterm.Info.Printfln("Invocation ID: %s", resp.ID)
 	// coordinate the cleanup with the polling loop to ensure this is given enough time to run
 	// before this function returns
 	cleanupDone := make(chan struct{})
@@ -187,3 +204,90 @@ func printResult(success bool, output string) {
 		pterm.Error.Printf("Result:\n%s\n", output)
 	}
 }
+
+func runInvocationHistory(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+
+	lim, _ := cmd.Flags().GetInt("limit")
+	appFilter, _ := cmd.Flags().GetString("app")
+	versionFilter, _ := cmd.Flags().GetString("version")
+
+	// Build parameters for the API call
+	params := kernel.InvocationListParams{
+		Limit: kernel.Opt(int64(lim)),
+	}
+
+	// Only add app filter if specified
+	if appFilter != "" {
+		params.AppName = kernel.Opt(appFilter)
+	}
+
+	// Only add version filter if specified
+	if versionFilter != "" {
+		params.Version = kernel.Opt(versionFilter)
+	}
+
+	// Build debug message based on filters
+	if appFilter != "" && versionFilter != "" {
+		pterm.Debug.Printf("Listing invocations for app '%s' version '%s'...\n", appFilter, versionFilter)
+	} else if appFilter != "" {
+		pterm.Debug.Printf("Listing invocations for app '%s'...\n", appFilter)
+	} else if versionFilter != "" {
+		pterm.Debug.Printf("Listing invocations for version '%s'...\n", versionFilter)
+	} else {
+		pterm.Debug.Printf("Listing all invocations...\n")
+	}
+
+	// Make a single API call to get invocations
+	invocations, err := client.Invocations.List(cmd.Context(), params)
+	if err != nil {
+		pterm.Error.Printf("Failed to list invocations: %v\n", err)
+		return nil
+	}
+
+	table := pterm.TableData{{"Invocation ID", "App Name", "Action", "Version", "Status", "Started At", "Duration", "Output"}}
+
+	for _, inv := range invocations.Items {
+		started := util.FormatLocal(inv.StartedAt)
+		status := string(inv.Status)
+
+		// Calculate duration
+		var duration string
+		if !inv.FinishedAt.IsZero() {
+			dur := inv.FinishedAt.Sub(inv.StartedAt)
+			duration = dur.Round(time.Millisecond).String()
+		} else if status == "running" {
+			dur := time.Since(inv.StartedAt)
+			duration = dur.Round(time.Second).String() + " (running)"
+		} else {
+			duration = "-"
+		}
+
+		// Truncate output for display
+		output := inv.Output
+		if len(output) > 50 {
+			output = output[:47] + "..."
+		}
+		if output == "" {
+			output = "-"
+		}
+
+		table = append(table, []string{
+			inv.ID,
+			inv.AppName,
+			inv.ActionName,
+			inv.Version,
+			status,
+			started,
+			duration,
+			output,
+		})
+	}
+
+	if len(table) == 1 {
+		pterm.Info.Println("No invocations found.")
+	} else {
+		pterm.DefaultTable.WithHasHeader().WithData(table).Render()
+	}
+	return nil
+}

cmd/logs.go

@@ -23,6 +23,7 @@ func init() {
 	logsCmd.Flags().BoolP("follow", "f", false, "Follow logs in real-time (stream continuously)")
 	logsCmd.Flags().String("since", "s", "How far back to retrieve logs. Supports duration formats: ns, us, ms, s, m, h (e.g., 5m, 2h, 1h30m). Note: 'd' for days is NOT supported - use hours instead. Can also specify timestamps: 2006-01-02 (day), 2006-01-02T15:04 (minute), 2006-01-02T15:04:05 (second), 2006-01-02T15:04:05.000 (ms). Maximum lookback is 167h (just under 7 days). Defaults to 5m if not following, 5s if following.")
 	logsCmd.Flags().Bool("with-timestamps", false, "Include timestamps in each log line")
+	logsCmd.Flags().StringP("invocation", "i", "", "Show logs for a specific invocation/run of the app. Accepts full ID or unambiguous prefix. If the invocation is still running, streaming respects --follow.")
 	rootCmd.AddCommand(logsCmd)
 }
 
@@ -34,6 +35,7 @@ func runLogs(cmd *cobra.Command, args []string) error {
 	follow, _ := cmd.Flags().GetBool("follow")
 	since, _ := cmd.Flags().GetString("since")
 	timestamps, _ := cmd.Flags().GetBool("with-timestamps")
+	invocationRef, _ := cmd.Flags().GetString("invocation")
 	if version == "" {
 		version = "latest"
 	}
@@ -45,6 +47,90 @@ func runLogs(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	// If an invocation is specified, stream invocation-specific logs and return
+	if invocationRef != "" {
+		inv, err := client.Invocations.Get(cmd.Context(), invocationRef)
+		if err != nil {
+			return fmt.Errorf("failed to get invocation: %w", err)
+		}
+		if inv.AppName != appName {
+			return fmt.Errorf("invocation %s does not belong to app \"%s\" (found app: %s)", inv.ID, appName, inv.AppName)
+		}
+
+		pterm.Info.Printf("Streaming logs for invocation \"%s\" of app \"%s\" (action: %s, status: %s)...\n", inv.ID, inv.AppName, inv.ActionName, inv.Status)
+		if follow {
+			pterm.Info.Println("Press Ctrl+C to exit")
+		} else {
+			pterm.Info.Println("Showing recent logs (timeout after 3s with no events)")
+		}
+
+		stream := client.Invocations.FollowStreaming(cmd.Context(), inv.ID, kernel.InvocationFollowParams{}, option.WithMaxRetries(0))
+		if stream.Err() != nil {
+			return fmt.Errorf("failed to follow streaming: %w", stream.Err())
+		}
+
+		if follow {
+			for stream.Next() {
+				data := stream.Current()
+				switch data.Event {
+				case "log":
+					logEntry := data.AsLog()
+					if timestamps {
+						fmt.Printf("%s %s\n", util.FormatLocal(logEntry.Timestamp), logEntry.Message)
+					} else {
+						fmt.Println(logEntry.Message)
+					}
+				case "error":
+					errEv := data.AsError()
+					pterm.Error.Printfln("%s: %s", errEv.Error.Code, errEv.Error.Message)
+				}
+			}
+		} else {
+			timeout := time.NewTimer(3 * time.Second)
+			defer timeout.Stop()
+
+			done := false
+			for !done {
+				nextCh := make(chan bool, 1)
+				go func() {
+					hasNext := stream.Next()
+					nextCh <- hasNext
+				}()
+
+				select {
+				case hasNext := <-nextCh:
+					if !hasNext {
+						done = true
+					} else {
+						data := stream.Current()
+						switch data.Event {
+						case "log":
+							logEntry := data.AsLog()
+							if timestamps {
+								fmt.Printf("%s %s\n", util.FormatLocal(logEntry.Timestamp), logEntry.Message)
+							} else {
+								fmt.Println(logEntry.Message)
+							}
+						case "error":
+							errEv := data.AsError()
+							pterm.Error.Printfln("%s: %s", errEv.Error.Code, errEv.Error.Message)
+						}
+						timeout.Reset(3 * time.Second)
+					}
+				case <-timeout.C:
+					done = true
+					stream.Close()
+					return nil
+				}
+			}
+		}
+
+		if stream.Err() != nil {
+			return fmt.Errorf("failed to follow streaming: %w", stream.Err())
+		}
+		return nil
+	}
+
 	params := kernel.AppListParams{
 		AppName: kernel.Opt(appName),
 		Version: kernel.Opt(version),
@@ -88,6 +174,9 @@ func runLogs(cmd *cobra.Command, args []string) error {
 				} else {
 					fmt.Println(logEntry.Message)
 				}
+			case "error":
+				errEv := data.AsErrorEvent()
+				pterm.Error.Printfln("%s: %s", errEv.Error.Code, errEv.Error.Message)
 			}
 		}
 	} else {
@@ -122,6 +211,9 @@ func runLogs(cmd *cobra.Command, args []string) error {
 						} else {
 							fmt.Println(logEntry.Message)
 						}
+					case "error":
+						errEv := data.AsErrorEvent()
+						pterm.Error.Printfln("%s: %s", errEv.Error.Code, errEv.Error.Message)
 					}
 					timeout.Reset(3 * time.Second)
 				}

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/charmbracelet/fang v0.2.0
 	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/joho/godotenv v1.5.1
-	github.com/onkernel/kernel-go-sdk v0.11.4
+	github.com/onkernel/kernel-go-sdk v0.11.5
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
 	github.com/pterm/pterm v0.12.80
 	github.com/samber/lo v1.51.0

go.sum

@@ -91,8 +91,8 @@ github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe
 github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
-github.com/onkernel/kernel-go-sdk v0.11.4 h1:vgDcPtldfEcRh+a1wlOSOY2bBWjxLFUwHqeXHHQ4OjM=
-github.com/onkernel/kernel-go-sdk v0.11.4/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
+github.com/onkernel/kernel-go-sdk v0.11.5 h1:LApX5A/Ful62LwNTW+srhi/3cx3W04pzgZ361PlDEAc=
+github.com/onkernel/kernel-go-sdk v0.11.5/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=