fix handling of cron jobs

cmd/crons.go

···
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
-	"log"
+	"log/slog"
 	"os"
 	"path/filepath"
 	"strings"
···
 func NewCmdCrons() *cobra.Command {
 	var flags struct {
 		json bool
+		app  string
 		all  bool
 	}
 
 	cmd := &cobra.Command{
-		Use:               "crons [app]",
-		Aliases:           []string{"cron"},
-		Args:              cobra.MaximumNArgs(1),
-		ValidArgsFunction: completeApp,
-		PreRunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) > 0 && flags.all {
-				return fmt.Errorf("cannot set both --all and specify an app")
-			}
-
-			return nil
-		},
-		Short: "List cron jobs",
+		Use:     "crons",
+		Aliases: []string{"cron"},
+		Args:    cobra.NoArgs,
+		Short:   "List cron jobs",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			var crons []CronItem
 			apps, err := app.ListApps(k.String("dir"))
···
 
 	cmd.Flags().BoolVar(&flags.json, "json", false, "output as json")
 	cmd.Flags().BoolVar(&flags.all, "all", false, "show all cron jobs")
+	cmd.Flags().StringVarP(&flags.app, "app", "a", "", "the app to show cron jobs for")
+	cmd.RegisterFlagCompletionFunc("app", completeApp)
+	cmd.MarkFlagsMutuallyExclusive("app", "all")
 
 	return cmd
 }
 
-func CronRunner(stdout, stderr io.Writer) *cron.Cron {
+func CronRunner(logger *slog.Logger) *cron.Cron {
 	parser := cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
 	c := cron.New(cron.WithParser(parser))
 	_, _ = c.AddFunc("* * * * *", func() {
-		rounded := time.Now().Truncate(time.Minute)
-		for _, appname := range k.MapKeys("apps") {
-			for _, job := range k.Slices(fmt.Sprintf("apps.%s.crons", appname)) {
-				sched, err := parser.Parse(job.String("schedule"))
+		apps, err := app.ListApps(k.String("dir"))
+		if err != nil {
+			logger.Error("failed to list apps", "error", err)
+			return
+		}
+
+		for _, appname := range apps {
+			a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"))
+			if err != nil {
+				logger.Error("failed to load app", "app", appname, "error", err)
+				continue
+			}
+
+			current := time.Now().Truncate(time.Minute)
+			for _, job := range a.Config.Crons {
+				sched, err := parser.Parse(job.Schedule)
 				if err != nil {
-					fmt.Println(err)
+					logger.Error("failed to parse cron schedule", "app", appname, "schedule", job.Schedule, "error", err)
 					continue
 				}
 
-				if sched.Next(rounded.Add(-1*time.Second)) != rounded {
+				if sched.Next(current.Add(-1*time.Second)) != current {
 					continue
 				}
 
-				a, err := app.LoadApp(appname, k.String("rootDir"), k.String("domain"))
+				a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"))
 				if err != nil {
-					fmt.Println(err)
+					logger.Error("failed to load app", "app", appname, "error", err)
 					continue
 				}
 				wk := worker.NewWorker(a, k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)), nil)
 
-				command, err := wk.Command(context.Background(), job.Strings("args"), nil)
+				command, err := wk.Command(context.Background(), job.Args, nil)
 				if err != nil {
-					fmt.Println(err)
+					logger.Error("failed to create command", "app", appname, "args", job.Args, "error", err)
 					continue
 				}
-				command.Stdout = stdout
-				command.Stderr = stderr
 
-				if err := command.Run(); err != nil {
-					log.Printf("failed to run command: %v", err)
-				}
+				logger.Info("running cron job", "app", appname, "args", job.Args, "schedule", job.Schedule)
+				go func() {
+					if err := command.Run(); err != nil {
+						logger.Error("failed to run command", "app", appname, "args", job.Args, "error", err)
+					}
+				}()
 			}
 		}
 	})

cmd/open.go

···
 )
 
 func NewCmdOpen() *cobra.Command {
+	var flags struct {
+		app string
+	}
+
 	cmd := &cobra.Command{
-		Use:               "open [app]",
-		Short:             "Open an app in the browser",
-		Args:              cobra.MaximumNArgs(1),
-		ValidArgsFunction: completeApp,
+		Use:   "open [app]",
+		Short: "Open an app in the browser",
+		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) == 0 {
+			if flags.app == "" {
 				cwd, err := os.Getwd()
 				if err != nil {
 					return fmt.Errorf("failed to get current directory: %w", err)
···
 				return nil
 			}
 
-			a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"))
+			a, err := app.LoadApp(flags.app, k.String("dir"), k.String("domain"))
 			if err != nil {
 				return fmt.Errorf("failed to load app: %w", err)
 			}
···
 			return nil
 		},
 	}
+
+	cmd.Flags().StringVarP(&flags.app, "app", "a", "", "The app to open")
+	cmd.RegisterFlagCompletionFunc("app", completeApp)
 
 	return cmd
 }

cmd/secrets.go

···
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/cli/go-gh/v2/pkg/tableprinter"
 	"github.com/getsops/sops/v3/decrypt"
···
 func NewCmdSecrets() *cobra.Command {
 	var flags struct {
 		json   bool
+		app    string
 		dotenv bool
 	}
 
 	cmd := &cobra.Command{
-		Use:               "secrets [app]",
-		Short:             "Print app secrets",
-		ValidArgsFunction: completeApp,
-		Args:              cobra.MaximumNArgs(1),
+		Use:   "secrets [app]",
+		Short: "Print app secrets",
+		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) == 0 {
-				return fmt.Errorf("app name is required")
+			appName := flags.app
+			if appName == "" {
+				cwd, err := os.Getwd()
+				if err != nil {
+					return fmt.Errorf("failed to get current directory: %w", err)
+				}
+
+				if !strings.HasPrefix(cwd, k.String("dir")) {
+					return fmt.Errorf("not in an app directory")
+				}
+
+				appDir := cwd
+				for filepath.Dir(appDir) != k.String("dir") {
+					appDir = filepath.Dir(appDir)
+				}
+
+				appName = filepath.Base(appDir)
 			}
 
-			secretPath := filepath.Join(k.String("dir"), args[0], "secrets.enc.env")
+			secretPath := filepath.Join(k.String("dir"), appName, "secrets.enc.env")
 
 			rawBytes, err := os.ReadFile(secretPath)
 			if err != nil {
···
 
 	cmd.Flags().BoolVar(&flags.json, "json", false, "Output as JSON")
 	cmd.Flags().BoolVar(&flags.dotenv, "dotenv", false, "Output as dotenv")
+	cmd.Flags().StringVar(&flags.app, "app", "", "App name")
+	cmd.RegisterFlagCompletionFunc("app", completeApp)
 
 	return cmd
 

cmd/up.go

···
 	"github.com/spf13/cobra"
 )
 
-var ErrSilent = errors.New("exit error")
-
 func NewCmdUp() *cobra.Command {
 	var flags struct {
 		enableCrons   bool
···
 	}
 
 	cmd := &cobra.Command{
-		Use:           "up",
-		Short:         "Start the smallweb evaluation server",
-		Aliases:       []string{"serve"},
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
+		Use:     "up",
+		Short:   "Start the smallweb evaluation server",
+		Aliases: []string{"serve"},
+		Args:    cobra.NoArgs,
 		PreRunE: func(cmd *cobra.Command, args []string) error {
 			if _, err := checkDenoVersion(); err != nil {
 				return err
···
 
 			if k.String("dir") == "" {
 				logger.Error("dir cannot be empty")
-				return ErrSilent
+				return fmt.Errorf("dir cannot be empty")
 			}
 
 			if k.String("domain") == "" {
-				logger.Error("domain cannot be empty")
-				return ErrSilent
+				return fmt.Errorf("domain cannot be empty")
 			}
 
 			handler := &Handler{
···
 				}
 			})
 			if err != nil {
-				logger.Error("failed to create watcher")
-				return ErrSilent
+				return fmt.Errorf("failed to create watcher: %w", err)
 			}
 
 			handler.watcher = watcher
···
 			if flags.tlsCert != "" && flags.tlsKey != "" {
 				cert, err := tls.LoadX509KeyPair(flags.tlsCert, flags.tlsKey)
 				if err != nil {
-					logger.Error("failed to load tls certificate", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to load tls certificate: %w", err)
 				}
 
 				tlsConfig := &tls.Config{Certificates: []tls.Certificate{cert}}
···
 
 				ln, err := getListener(addr, tlsConfig)
 				if err != nil {
-					logger.Error("failed to get listener", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to get listener: %w", err)
 				}
 
 				logger.Info("serving https", "domain", k.String("domain"), "dir", k.String("dir"), "addr", addr)
···
 
 				ln, err := getListener(addr, nil)
 				if err != nil {
-					logger.Error("failed to get listener", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to get listener: %w", err)
 				}
 
 				logger.Info("serving http", "domain", k.String("domain"), "dir", k.String("dir"), "addr", addr)
···
 
 			if flags.enableCrons {
 				logger.Info("starting cron jobs")
-				crons := CronRunner(cmd.OutOrStdout(), cmd.ErrOrStderr())
+				crons := CronRunner(logger.With("logger", "cron"))
 				crons.Start()
 				defer crons.Stop()
 			}
···
 				if flags.sshPrivateKey == "" {
 					homeDir, err := os.UserHomeDir()
 					if err != nil {
-						logger.Error("failed to get home directory", "error", err)
-						return ErrSilent
+						return fmt.Errorf("failed to get home directory: %w", err)
 					}
 
 					for _, keyType := range []string{"id_rsa", "id_ed25519"} {
···
 				}
 
 				if sshPrivateKeyPath == "" {
-					logger.Error("ssh private key not found")
-					return ErrSilent
+					return fmt.Errorf("ssh private key not found")
 				}
 
 				privateKeyBytes, err := os.ReadFile(sshPrivateKeyPath)
 				if err != nil {
-					logger.Error("failed to read private key", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to read private key: %w", err)
 				}
 
 				privateKey, err := gossh.ParseRawPrivateKey(privateKeyBytes)
 				if err != nil {
-					logger.Error("failed to parse private key", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to parse private key: %w", err)
 				}
 
 				signer, err := gossh.NewSignerFromKey(privateKey)
 				if err != nil {
-					logger.Error("failed to create signer", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to create signer: %w", err)
 				}
 
 				authorizedKey := string(gossh.MarshalAuthorizedKey(signer.PublicKey()))
···
 
 				if err != nil {
 					logger.Error("failed to create ssh server", "error", err)
-					return ErrSilent
+					return fmt.Errorf("failed to create ssh server: %w", err)
 				}
 
 				logger.Info("serving ssh", "addr", flags.sshAddr)
···
 	cmd.Flags().BoolVar(&flags.onDemandTLS, "on-demand-tls", false, "enable on-demand tls")
 	cmd.Flags().StringVar(&flags.logFormat, "log-format", "pretty", "log format (json or text)")
 	cmd.Flags().BoolVar(&flags.enableCrons, "enable-crons", false, "enable cron jobs")
-	cmd.Flags().Bool("cron", false, "enable cron jobs")
 
-	cmd.Flags().MarkDeprecated("cron", "use --enable-crons instead")
-	cmd.Flags().MarkDeprecated("ssh-host-key", "use --ssh-private-key instead")
 	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "tls-cert")
 	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "tls-key")
 	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "addr")

example/cron/main.ts

···
+export default {
+    run() {
+        console.log('Cron job running...');
+    }
+}

example/cron/smallweb.json

···
+{
+    "crons": [
+        {
+            "schedule": "* * * * *",
+            "args": []
+        }
+    ]
+}

main.go

···
 
 import (
 	_ "embed"
-	"errors"
-	"fmt"
 	"os"
 
 	"github.com/pomdtr/smallweb/cmd"
···
 	root.SetErr(os.Stderr)
 
 	if err := root.Execute(); err != nil {
-		if !errors.Is(err, cmd.ErrSilent) {
-			fmt.Fprintln(os.Stderr, err)
-		}
-
 		os.Exit(1)
 	}
 }

schemas/manifest.schema.json

···
                         "description": "Cron schedule",
                         "type": "string"
                     },
-                    "description": {
-                        "type": "string",
-                        "description": "An optional description for the task"
-                    },
                     "args": {
                         "description": "Cron arguments",
                         "type": "array",