add --quiet flag to suppress silo log output

Author: leighmcculloch

backend/fly/fly.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net"
 	"net/http"
 	"os"
@@ -24,10 +25,11 @@ import (
 type Client struct {
 	app    string
 	region string
+	logw   io.Writer
 }
 
 // NewClient creates a new Fly.io backend client.
-func NewClient(app, region string) (*Client, error) {
+func NewClient(app, region string, logw io.Writer) (*Client, error) {
 	if _, err := exec.LookPath("fly"); err != nil {
 		return nil, fmt.Errorf("fly CLI not found (install from https://fly.io/docs/flyctl/install/): %w", err)
 	}
@@ -43,7 +45,16 @@ func NewClient(app, region string) (*Client, error) {
 	if region == "" {
 		region = "syd"
 	}
-	return &Client{app: app, region: region}, nil
+	if logw == nil {
+		logw = os.Stderr
+	}
+	return &Client{app: app, region: region, logw: logw}, nil
+}
+
+func (c *Client) logf(format string, args ...any) {
+	if c.logw != nil {
+		fmt.Fprintf(c.logw, format, args...)
+	}
 }
 
 // Close is a no-op.
@@ -204,40 +215,40 @@ func (c *Client) Run(ctx context.Context, opts backend.RunOptions) error {
 	imageRef := fmt.Sprintf("registry.fly.io/%s:%s", c.app, opts.Image)
 
 	// 1. Create machine with sleep infinity (keeps it running for sync + reconnect)
-	fmt.Fprintf(os.Stderr, "  → Creating machine...\n")
+	c.logf("  → Creating machine...\n")
 	machineID, err := c.createMachine(ctx, imageRef, opts)
 	if err != nil {
 		return err
 	}
-	fmt.Fprintf(os.Stderr, "  → Machine created: %s\n", machineID)
+	c.logf("  → Machine created: %s\n", machineID)
 
 	// 2. Wait for machine to start
-	fmt.Fprintf(os.Stderr, "  → Waiting for machine to start...\n")
+	c.logf("  → Waiting for machine to start...\n")
 	if err := c.waitForState(ctx, machineID, "started", 5*time.Minute); err != nil {
 		c.destroyMachine(ctx, machineID)
 		return err
 	}
 
 	// 3. Wait for SSH to be ready
-	fmt.Fprintf(os.Stderr, "  → Waiting for SSH...\n")
+	c.logf("  → Waiting for SSH...\n")
 	if err := c.waitForSSH(ctx, machineID, 60*time.Second); err != nil {
 		c.destroyMachine(ctx, machineID)
 		return err
 	}
 
 	// 4. Start file sync (mutagen: initial sync + continuous bidirectional)
-	fmt.Fprintf(os.Stderr, "  → Syncing files...\n")
+	c.logf("  → Syncing files...\n")
 	stopSync, err := c.startMutagenSync(ctx, machineID, opts.MountsRO, opts.MountsRW, opts.CleanMountPaths)
 	if err != nil {
 		c.destroyMachine(ctx, machineID)
 		return fmt.Errorf("file sync failed: %w", err)
 	}
-	fmt.Fprintf(os.Stderr, "  → Files synced\n")
+	c.logf("  → Files synced\n")
 
 	// 5. Run pre-run hooks (skip mount wait since files are already synced)
 	hooks := filterMountWait(opts.PreRunHooks)
 	if len(hooks) > 0 {
-		fmt.Fprintf(os.Stderr, "  → Running pre-run hooks...\n")
+		c.logf("  → Running pre-run hooks...\n")
 		hookScript := strings.Join(hooks, " && ")
 		if err := c.sshExec(ctx, machineID, hookScript); err != nil {
 			stopSync()
@@ -247,7 +258,7 @@ func (c *Client) Run(ctx context.Context, opts backend.RunOptions) error {
 	}
 
 	// 6. Connect interactively with the tool command (via tmux)
-	fmt.Fprintf(os.Stderr, "  → Connecting...\n")
+	c.logf("  → Connecting...\n")
 	connectErr := c.connectInteractive(ctx, machineID, opts)
 
 	// 7. Check if the tmux session is still running (user detached vs tool exited).
@@ -256,16 +267,16 @@ func (c *Client) Run(ctx context.Context, opts backend.RunOptions) error {
 	tmuxAlive := c.isTmuxSessionAlive(ctx, machineID)
 
 	// 8. Stop continuous sync (flushes final changes)
-	fmt.Fprintf(os.Stderr, "  → Syncing final changes...\n")
+	c.logf("  → Syncing final changes...\n")
 	stopSync()
 
 	if tmuxAlive {
-		fmt.Fprintf(os.Stderr, "  → Detached. Machine %s still running — use 'silo reconnect %s --backend fly' to reattach.\n", machineID, opts.Name)
+		c.logf("  → Detached. Machine %s still running — use 'silo reconnect %s --backend fly' to reattach.\n", machineID, opts.Name)
 		return nil
 	}
 
 	// Tool exited, destroy the machine
-	fmt.Fprintf(os.Stderr, "  → Destroying machine...\n")
+	c.logf("  → Destroying machine...\n")
 	destroyCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 	c.destroyMachine(destroyCtx, machineID)
@@ -297,15 +308,15 @@ func (c *Client) Reconnect(ctx context.Context, name string, opts backend.RunOpt
 	}
 
 	// Re-sync files (don't clean mount paths — tool is already running)
-	fmt.Fprintf(os.Stderr, "  → Syncing files...\n")
+	c.logf("  → Syncing files...\n")
 	stopSync, err := c.startMutagenSync(ctx, machineID, opts.MountsRO, opts.MountsRW, nil)
 	if err != nil {
 		return fmt.Errorf("file sync failed: %w", err)
 	}
-	fmt.Fprintf(os.Stderr, "  → Files synced\n")
+	c.logf("  → Files synced\n")
 
 	// Reattach to the tmux session
-	fmt.Fprintf(os.Stderr, "  → Reconnecting...\n")
+	c.logf("  → Reconnecting...\n")
 	user := currentUsername()
 	if user == "" {
 		user = "root"
@@ -317,16 +328,16 @@ func (c *Client) Reconnect(ctx context.Context, name string, opts backend.RunOpt
 	tmuxAlive := c.isTmuxSessionAlive(ctx, machineID)
 
 	// Stop sync (flush final changes)
-	fmt.Fprintf(os.Stderr, "  → Syncing final changes...\n")
+	c.logf("  → Syncing final changes...\n")
 	stopSync()
 
 	if tmuxAlive {
-		fmt.Fprintf(os.Stderr, "  → Detached. Machine %s still running — use 'silo reconnect %s --backend fly' to reattach.\n", machineID, name)
+		c.logf("  → Detached. Machine %s still running — use 'silo reconnect %s --backend fly' to reattach.\n", machineID, name)
 		return nil
 	}
 
 	// Tool exited, destroy the machine
-	fmt.Fprintf(os.Stderr, "  → Destroying machine...\n")
+	c.logf("  → Destroying machine...\n")
 	destroyCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 	c.destroyMachine(destroyCtx, machineID)
@@ -759,7 +770,7 @@ func (c *Client) startMutagenSync(ctx context.Context, machineID string, mountsR
 		return nil, fmt.Errorf("mutagen is required for the fly backend (install from https://mutagen.io): %w", err)
 	}
 
-	progress := newSyncProgress(os.Stderr)
+	progress := newSyncProgress(c.logw)
 
 	// Create SSH tunnel for mutagen (fly proxy + issued certs + ControlMaster)
 	progress.setPhase("Establishing SSH tunnel...")
@@ -896,7 +907,7 @@ func (c *Client) startMutagenSync(ctx context.Context, machineID string, mountsR
 				}
 				localPath = target
 			} else {
-				fmt.Fprintf(os.Stderr, "    mutagen: warning: cannot resolve %s: %v\n", m.path, err)
+				c.logf("    mutagen: warning: cannot resolve %s: %v\n", m.path, err)
 			}
 		}
 

main.go

@@ -79,12 +79,48 @@ func runMain(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	rootCmd.SetErr(stderr)
 
 	if err := rootCmd.Execute(); err != nil {
-		cli.LogErrorTo(stderr, "%v", err)
+		if !hasQuietArg(args) {
+			cli.LogErrorTo(stderr, "%v", err)
+		}
 		return 1
 	}
 	return 0
 }
 
+func hasQuietArg(args []string) bool {
+	for _, arg := range args {
+		if arg == "--" {
+			break
+		}
+		if arg == "--quiet" || arg == "-q" {
+			return true
+		}
+		if strings.HasPrefix(arg, "-") && !strings.HasPrefix(arg, "--") && strings.Contains(arg[1:], "q") {
+			return true
+		}
+	}
+	return false
+}
+
+func quietFlag(cmd *cobra.Command) bool {
+	if cmd == nil {
+		return false
+	}
+	if f := cmd.Flags().Lookup("quiet"); f != nil {
+		if q, err := cmd.Flags().GetBool("quiet"); err == nil && q {
+			return true
+		}
+	}
+	if root := cmd.Root(); root != nil && root != cmd {
+		if f := root.Flags().Lookup("quiet"); f != nil {
+			if q, err := root.Flags().GetBool("quiet"); err == nil && q {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func newRootCmd(stdout, stderr io.Writer) *cobra.Command {
 	rootCmd := &cobra.Command{
 		Use:   "silo",
@@ -135,6 +171,7 @@ Configuration is loaded from (in order, merged):
 	rootCmd.Flags().Bool("force-build", false, "Force rebuild of container image")
 	rootCmd.Flags().Bool("no-cache", false, "Disable build cache (implies --force-build)")
 	rootCmd.Flags().BoolP("verbose", "v", false, "Show detailed output instead of progress bar")
+	rootCmd.Flags().BoolP("quiet", "q", false, "Suppress silo logs and render only tool output")
 	rootCmd.Flags().String("tool-version", "", "Pin a specific tool version (forces synchronous build)")
 	addMountFlags(rootCmd)
 
@@ -161,6 +198,7 @@ Configuration is loaded from (in order, merged):
 		toolCmd.Flags().Bool("force-build", false, "Force rebuild of container image")
 		toolCmd.Flags().Bool("no-cache", false, "Disable build cache (implies --force-build)")
 		toolCmd.Flags().BoolP("verbose", "v", false, "Show detailed output instead of progress bar")
+		toolCmd.Flags().BoolP("quiet", "q", false, "Suppress silo logs and render only tool output")
 		toolCmd.Flags().String("entrypoint", "", "Run a custom command instead of the tool (e.g. /bin/bash)")
 		toolCmd.Flags().String("tool-version", "", "Pin a specific tool version (forces synchronous build)")
 		addMountFlags(toolCmd)
@@ -399,6 +437,9 @@ func runSilo(cmd *cobra.Command, args []string, stdout, stderr io.Writer) error
 	// Get verbose flag
 	verbose, _ := cmd.Flags().GetBool("verbose")
 
+	// Get quiet flag
+	quiet := quietFlag(cmd)
+
 	// Get tool-version flag
 	toolVersion, _ := cmd.Flags().GetString("tool-version")
 
@@ -416,6 +457,7 @@ func runSilo(cmd *cobra.Command, args []string, stdout, stderr io.Writer) error
 		ForceBuild:    forceBuild,
 		NoCache:       noCache,
 		Verbose:       verbose,
+		Quiet:         quiet,
 		ToolVersion:   toolVersion,
 		ExtraMountsRW: extraMountsRW,
 		ExtraMountsRO: extraMountsRO,
@@ -451,6 +493,9 @@ func runTool(cmd *cobra.Command, toolDef tools.Tool, args []string, stdout, stde
 	// Get verbose flag
 	verbose, _ := cmd.Flags().GetBool("verbose")
 
+	// Get quiet flag
+	quiet := quietFlag(cmd)
+
 	// Get entrypoint flag
 	entrypoint, _ := cmd.Flags().GetString("entrypoint")
 
@@ -472,6 +517,7 @@ func runTool(cmd *cobra.Command, toolDef tools.Tool, args []string, stdout, stde
 		ForceBuild:    forceBuild,
 		NoCache:       noCache,
 		Verbose:       verbose,
+		Quiet:         quiet,
 		Entrypoint:    entrypoint,
 		ToolVersion:   toolVersion,
 		ExtraMountsRW: extraMountsRW,
@@ -1073,7 +1119,7 @@ func createBackendByType(backendType string, cfg config.Config) (backend.Backend
 	case "container":
 		return applecontainer.NewClient()
 	case "fly":
-		return flybackend.NewClient(cfg.Backends.Fly.App, cfg.Backends.Fly.Region)
+		return flybackend.NewClient(cfg.Backends.Fly.App, cfg.Backends.Fly.Region, os.Stderr)
 	default:
 		return nil, fmt.Errorf("unknown backend: %s", backendType)
 	}

main_test.go

@@ -116,6 +116,31 @@ func TestToolMountFlags(t *testing.T) {
 	}
 }
 
+func TestQuietFlags(t *testing.T) {
+	rootCmd := newRootCmd(io.Discard, io.Discard)
+
+	rootQuiet := rootCmd.Flags().Lookup("quiet")
+	if rootQuiet == nil {
+		t.Fatal("expected --quiet flag on root command")
+	}
+	if rootQuiet.Shorthand != "q" {
+		t.Fatalf("expected root --quiet shorthand to be -q, got %q", rootQuiet.Shorthand)
+	}
+
+	claudeCmd, _, err := rootCmd.Find([]string{"claude"})
+	if err != nil {
+		t.Fatalf("failed to find claude command: %v", err)
+	}
+
+	toolQuiet := claudeCmd.Flags().Lookup("quiet")
+	if toolQuiet == nil {
+		t.Fatal("expected --quiet flag on claude command")
+	}
+	if toolQuiet.Shorthand != "q" {
+		t.Fatalf("expected claude --quiet shorthand to be -q, got %q", toolQuiet.Shorthand)
+	}
+}
+
 func TestConfigShowCommand(t *testing.T) {
 	exitCode, stdout, _ := testcli.Main(t, []string{"config", "show"}, nil, mainFunc)
 
@@ -325,6 +350,19 @@ func TestInvalidTool(t *testing.T) {
 	}
 }
 
+func TestQuietSuppressesTopLevelErrors(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+
+	exitCode := runMain([]string{"--quiet", "invalid-tool"}, nil, &stdout, &stderr)
+
+	if exitCode == 0 {
+		t.Fatal("expected failure for invalid tool")
+	}
+	if stderr.Len() != 0 {
+		t.Fatalf("expected no stderr output with --quiet, got: %s", stderr.String())
+	}
+}
+
 func TestCompletionCommand(t *testing.T) {
 	shells := []string{"bash", "zsh", "fish", "powershell"}