Add docker like aliases

Author: sjmiller609

README.md

@@ -33,18 +33,35 @@ go run cmd/hypeman/main.go
 
 ## Usage
 
-The CLI follows a resource-based command structure:
-
 ```sh
-hypeman [resource] [command] [flags]
-```
+# Pull an image
+hypeman pull nginx:alpine
 
-```sh
-hypeman health check
+# Run an instance (auto-pulls image if needed)
+hypeman run nginx:alpine
+hypeman run --name my-app -e PORT=3000 nginx:alpine
+
+# List running instances
+hypeman ps
+hypeman ps -a    # show all instances
+
+# View logs
+hypeman logs <instance-id>
+hypeman logs -f <instance-id>   # follow logs
+
+# Execute a command in a running instance
+hypeman exec <instance-id> -- /bin/sh
+hypeman exec -it <instance-id>  # interactive shell
 ```
 
 For details about specific commands, use the `--help` flag.
 
+The CLI also provides resource-based commands for more advanced usage:
+
+```sh
+hypeman [resource] [command] [flags]
+```
+
 ## Global Flags
 
 - `--debug` - Enable debug logging (includes HTTP request/response details)

pkg/cmd/cmd.go

@@ -68,6 +68,10 @@ func init() {
 		},
 		Commands: []*cli.Command{
 			&execCmd,
+			&pullCmd,
+			&runCmd,
+			&psCmd,
+			&logsCmd,
 			{
 				Name:     "health",
 				Category: "API RESOURCE",

pkg/cmd/exec.go

@@ -131,7 +131,7 @@ func handleExec(ctx context.Context, cmd *cli.Command) error {
 		baseURL = os.Getenv("HYPEMAN_BASE_URL")
 	}
 	if baseURL == "" {
-		baseURL = "https://api.onkernel.com"
+		baseURL = "http://localhost:8080"
 	}
 
 	apiKey := os.Getenv("HYPEMAN_API_KEY")

pkg/cmd/format.go

@@ -0,0 +1,148 @@
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"time"
+)
+
+// TableWriter provides simple table formatting for CLI output
+type TableWriter struct {
+	w       io.Writer
+	headers []string
+	widths  []int
+	rows    [][]string
+}
+
+// NewTableWriter creates a new table writer
+func NewTableWriter(w io.Writer, headers ...string) *TableWriter {
+	widths := make([]int, len(headers))
+	for i, h := range headers {
+		widths[i] = len(h)
+	}
+	return &TableWriter{
+		w:       w,
+		headers: headers,
+		widths:  widths,
+	}
+}
+
+// AddRow adds a row to the table
+func (t *TableWriter) AddRow(cells ...string) {
+	// Pad or truncate to match header count
+	row := make([]string, len(t.headers))
+	for i := range row {
+		if i < len(cells) {
+			row[i] = cells[i]
+		}
+		if len(row[i]) > t.widths[i] {
+			t.widths[i] = len(row[i])
+		}
+	}
+	t.rows = append(t.rows, row)
+}
+
+// Render outputs the table
+func (t *TableWriter) Render() {
+	// Print headers
+	for i, h := range t.headers {
+		fmt.Fprintf(t.w, "%-*s", t.widths[i]+2, h)
+	}
+	fmt.Fprintln(t.w)
+
+	// Print rows
+	for _, row := range t.rows {
+		for i, cell := range row {
+			fmt.Fprintf(t.w, "%-*s", t.widths[i]+2, cell)
+		}
+		fmt.Fprintln(t.w)
+	}
+}
+
+// FormatTimeAgo formats a time as "X ago" string
+func FormatTimeAgo(t time.Time) string {
+	if t.IsZero() {
+		return "N/A"
+	}
+
+	d := time.Since(t)
+
+	switch {
+	case d < time.Minute:
+		return fmt.Sprintf("%d seconds ago", int(d.Seconds()))
+	case d < time.Hour:
+		mins := int(d.Minutes())
+		if mins == 1 {
+			return "1 minute ago"
+		}
+		return fmt.Sprintf("%d minutes ago", mins)
+	case d < 24*time.Hour:
+		hours := int(d.Hours())
+		if hours == 1 {
+			return "1 hour ago"
+		}
+		return fmt.Sprintf("%d hours ago", hours)
+	default:
+		days := int(d.Hours() / 24)
+		if days == 1 {
+			return "1 day ago"
+		}
+		return fmt.Sprintf("%d days ago", days)
+	}
+}
+
+// TruncateID truncates an ID to 12 characters (like Docker)
+func TruncateID(id string) string {
+	if len(id) > 12 {
+		return id[:12]
+	}
+	return id
+}
+
+// TruncateString truncates a string to max length with ellipsis
+func TruncateString(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	if max <= 3 {
+		return s[:max]
+	}
+	return s[:max-3] + "..."
+}
+
+// GenerateInstanceName generates a name from image reference
+func GenerateInstanceName(image string) string {
+	// Extract image name without registry/tag
+	name := image
+
+	// Remove registry prefix
+	if idx := strings.LastIndex(name, "/"); idx != -1 {
+		name = name[idx+1:]
+	}
+
+	// Remove tag/digest
+	if idx := strings.Index(name, ":"); idx != -1 {
+		name = name[:idx]
+	}
+	if idx := strings.Index(name, "@"); idx != -1 {
+		name = name[:idx]
+	}
+
+	// Add random suffix
+	suffix := randomSuffix(4)
+	return fmt.Sprintf("%s-%s", name, suffix)
+}
+
+// randomSuffix generates a random alphanumeric suffix
+func randomSuffix(n int) string {
+	const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
+	b := make([]byte, n)
+	for i := range b {
+		// Simple pseudo-random using time
+		b[i] = chars[(time.Now().UnixNano()+int64(i))%int64(len(chars))]
+	}
+	return string(b)
+}
+
+

pkg/cmd/logs.go

@@ -0,0 +1,65 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/onkernel/hypeman-go"
+	"github.com/onkernel/hypeman-go/option"
+	"github.com/urfave/cli/v3"
+)
+
+var logsCmd = cli.Command{
+	Name:      "logs",
+	Usage:     "Fetch the logs of an instance",
+	ArgsUsage: "<instance>",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "follow",
+			Aliases: []string{"f"},
+			Usage:   "Follow log output",
+		},
+		&cli.IntFlag{
+			Name:  "tail",
+			Usage: "Number of lines to show from the end of the logs",
+			Value: 100,
+		},
+	},
+	Action:          handleLogs,
+	HideHelpCommand: true,
+}
+
+func handleLogs(ctx context.Context, cmd *cli.Command) error {
+	args := cmd.Args().Slice()
+	if len(args) < 1 {
+		return fmt.Errorf("instance ID required\nUsage: hypeman logs [flags] <instance>")
+	}
+
+	instanceID := args[0]
+
+	client := hypeman.NewClient(getDefaultRequestOptions(cmd)...)
+
+	params := hypeman.InstanceStreamLogsParams{}
+	if cmd.IsSet("follow") {
+		params.Follow = hypeman.Opt(cmd.Bool("follow"))
+	}
+	if cmd.IsSet("tail") {
+		params.Tail = hypeman.Opt(int64(cmd.Int("tail")))
+	}
+
+	stream := client.Instances.StreamLogsStreaming(
+		ctx,
+		instanceID,
+		params,
+		option.WithMiddleware(debugMiddleware(cmd.Root().Bool("debug"))),
+	)
+	defer stream.Close()
+
+	for stream.Next() {
+		fmt.Printf("%s\n", stream.Current())
+	}
+
+	return stream.Err()
+}
+
+

pkg/cmd/ps.go

@@ -0,0 +1,84 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/onkernel/hypeman-go"
+	"github.com/onkernel/hypeman-go/option"
+	"github.com/urfave/cli/v3"
+)
+
+var psCmd = cli.Command{
+	Name:  "ps",
+	Usage: "List instances",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "all",
+			Aliases: []string{"a"},
+			Usage:   "Show all instances (default: running only)",
+		},
+		&cli.BoolFlag{
+			Name:    "quiet",
+			Aliases: []string{"q"},
+			Usage:   "Only display instance IDs",
+		},
+	},
+	Action:          handlePs,
+	HideHelpCommand: true,
+}
+
+func handlePs(ctx context.Context, cmd *cli.Command) error {
+	client := hypeman.NewClient(getDefaultRequestOptions(cmd)...)
+
+	instances, err := client.Instances.List(
+		ctx,
+		option.WithMiddleware(debugMiddleware(cmd.Root().Bool("debug"))),
+	)
+	if err != nil {
+		return err
+	}
+
+	showAll := cmd.Bool("all")
+	quietMode := cmd.Bool("quiet")
+
+	// Filter instances
+	var filtered []hypeman.Instance
+	for _, inst := range *instances {
+		if showAll || inst.State == "Running" {
+			filtered = append(filtered, inst)
+		}
+	}
+
+	// Quiet mode - just IDs
+	if quietMode {
+		for _, inst := range filtered {
+			fmt.Println(inst.ID)
+		}
+		return nil
+	}
+
+	// Table output
+	if len(filtered) == 0 {
+		if !showAll {
+			fmt.Fprintln(os.Stderr, "No running instances. Use -a to show all.")
+		}
+		return nil
+	}
+
+	table := NewTableWriter(os.Stdout, "INSTANCE ID", "NAME", "IMAGE", "STATE", "CREATED")
+	for _, inst := range filtered {
+		table.AddRow(
+			TruncateID(inst.ID),
+			TruncateString(inst.Name, 20),
+			TruncateString(inst.Image, 25),
+			string(inst.State),
+			FormatTimeAgo(inst.CreatedAt),
+		)
+	}
+	table.Render()
+
+	return nil
+}
+