Logs in CLI

Author: andreapollastri

README.md

@@ -84,12 +84,15 @@ cipi-cli apps edit <name> [flags]           Edit an application
 cipi-cli apps delete <name> [-y]            Delete an application
 cipi-cli apps suspend <name>                Suspend an application (HTTP 503)
 cipi-cli apps unsuspend <name>              Bring a suspended application back online
+cipi-cli apps logs <name> [flags]           Read application logs
 ```
 
 **Create flags:** `--user`, `--domain`, `--php`, `--repository`, `--branch`, `--custom`, `--docroot`
 
 **Edit flags:** `--php`, `--repository`, `--branch`, `--domain` (rename primary domain; requires Cipi 4.6.2+ / API 1.9.0+)
 
+**Logs flags:** `--type` (default `all`), `--page` (default `1`), `--per-page` (default `50`, max `1000`; requires API 1.11.9+)
+
 ### Domains
 
 ```
@@ -214,6 +217,7 @@ See the [Cipi API documentation](https://cipi.sh/docs/advanced#cipi-api) for det
 | --- | --- | --- |
 | Suspend / unsuspend | 4.5.8 | 1.8.1 |
 | Rename primary domain (`apps edit --domain`) | 4.6.2 | 1.9.0 |
+| App logs (`apps logs`) | — | 1.11.9 |
 | Global domain map (`domains`) | 4.5.5 | — (built from `/api/apps`) |
 
 New app PHP versions must be **8.3**, **8.4**, or **8.5** (Cipi 4.5.4+).

cmd/apps.go

@@ -2,12 +2,16 @@ package cmd
 
 import (
 	"fmt"
+	"net/url"
+	"strings"
 
 	"github.com/cipi-sh/cli/internal/api"
 	"github.com/cipi-sh/cli/internal/output"
 	"github.com/spf13/cobra"
 )
 
+var appLogTypes = []string{"all", "nginx", "php", "worker", "deploy", "laravel"}
+
 var appsCmd = &cobra.Command{
 	Use:     "apps",
 	Aliases: []string{"app"},
@@ -279,6 +283,62 @@ var appsSuspendCmd = &cobra.Command{
 	},
 }
 
+var appsLogsCmd = &cobra.Command{
+	Use:   "logs [name]",
+	Short: "Read application logs",
+	Long:  "Read paginated log snapshots (nginx, PHP-FPM, Laravel, worker, deploy). Page 1 returns the most recent lines.",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		logType, _ := cmd.Flags().GetString("type")
+		page, _ := cmd.Flags().GetInt("page")
+		perPage, _ := cmd.Flags().GetInt("per-page")
+
+		logType = strings.ToLower(strings.TrimSpace(logType))
+		if !isAppLogType(logType) {
+			output.Error("Invalid log type %q — use one of: %s", logType, strings.Join(appLogTypes, ", "))
+			return fmt.Errorf("invalid log type")
+		}
+		if page < 1 {
+			output.Error("Page must be at least 1")
+			return fmt.Errorf("invalid page")
+		}
+		if perPage < 1 || perPage > 1000 {
+			output.Error("per-page must be between 1 and 1000")
+			return fmt.Errorf("invalid per-page")
+		}
+
+		client, err := api.NewClient()
+		if err != nil {
+			output.Error("%s", err)
+			return err
+		}
+
+		query := url.Values{}
+		query.Set("type", logType)
+		query.Set("page", fmt.Sprintf("%d", page))
+		query.Set("per_page", fmt.Sprintf("%d", perPage))
+
+		path := fmt.Sprintf("/api/apps/%s/logs?%s", url.PathEscape(args[0]), query.Encode())
+
+		var result struct {
+			Data map[string]interface{} `json:"data"`
+		}
+
+		if err := client.Get(path, &result); err != nil {
+			output.Error("Failed to read logs: %s", err)
+			return err
+		}
+
+		if jsonFlag {
+			output.PrintJSON(result)
+			return nil
+		}
+
+		printAppLogs(result.Data)
+		return nil
+	},
+}
+
 var appsUnsuspendCmd = &cobra.Command{
 	Use:   "unsuspend [name]",
 	Short: "Unsuspend an application (bring it back online)",
@@ -302,6 +362,81 @@ var appsUnsuspendCmd = &cobra.Command{
 	},
 }
 
+func isAppLogType(t string) bool {
+	for _, v := range appLogTypes {
+		if t == v {
+			return true
+		}
+	}
+	return false
+}
+
+func printAppLogs(data map[string]interface{}) {
+	if len(data) == 0 {
+		output.Warn("No log data returned")
+		return
+	}
+
+	app := str(data, "app")
+	logType := str(data, "type")
+	page := str(data, "page")
+	perPage := str(data, "per_page")
+
+	output.Header(fmt.Sprintf("App logs: %s", app))
+	output.KeyValue(nil, "Type", logType)
+	output.KeyValue(nil, "Page", page)
+	output.KeyValue(nil, "Per page", perPage)
+
+	if types, ok := data["available_types"].([]interface{}); ok && len(types) > 0 {
+		parts := make([]string, 0, len(types))
+		for _, t := range types {
+			parts = append(parts, fmt.Sprintf("%v", t))
+		}
+		output.KeyValue(nil, "Available", strings.Join(parts, ", "))
+	}
+
+	if warnings, ok := data["warnings"].([]interface{}); ok {
+		for _, w := range warnings {
+			output.Warn("%v", w)
+		}
+	}
+
+	files, _ := data["files"].([]interface{})
+	if len(files) == 0 {
+		output.Warn("No log files matched this filter")
+		fmt.Println()
+		return
+	}
+
+	for _, item := range files {
+		file, ok := item.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		path := str(file, "path")
+		filePage := str(file, "page")
+		totalPages := str(file, "total_pages")
+		totalLines := str(file, "total_lines")
+
+		fmt.Println()
+		output.Dim.Printf("  %s\n", path)
+		output.Dim.Printf("  page %s/%s (%s lines total)\n", filePage, totalPages, totalLines)
+		output.Dim.Println("  " + strings.Repeat("─", 60))
+
+		lines, _ := file["lines"].([]interface{})
+		if len(lines) == 0 {
+			output.Dim.Println("  (empty)")
+			continue
+		}
+		for _, line := range lines {
+			fmt.Printf("  %v\n", line)
+		}
+	}
+
+	fmt.Println()
+}
+
 func str(m map[string]interface{}, key string) string {
 	if v, ok := m[key]; ok && v != nil {
 		switch val := v.(type) {
@@ -347,6 +482,10 @@ func init() {
 
 	appsDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation")
 
-	appsCmd.AddCommand(appsListCmd, appsShowCmd, appsCreateCmd, appsEditCmd, appsDeleteCmd, appsSuspendCmd, appsUnsuspendCmd)
+	appsLogsCmd.Flags().StringP("type", "t", "all", "Log type (all, nginx, php, worker, deploy, laravel)")
+	appsLogsCmd.Flags().IntP("page", "p", 1, "Page number (1 = most recent lines)")
+	appsLogsCmd.Flags().Int("per-page", 50, "Lines per log file per page (max 1000)")
+
+	appsCmd.AddCommand(appsListCmd, appsShowCmd, appsCreateCmd, appsEditCmd, appsDeleteCmd, appsLogsCmd, appsSuspendCmd, appsUnsuspendCmd)
 	rootCmd.AddCommand(appsCmd)
 }