docs(install): mise installation (#421 )

feat(compose): support stdin_open and tty (#419 )
* feat: support stdin_open and tty This can be useful to leave a container running without specifying a command like `sleep`, and probably in other situations as well. Signed-off-by: Miek Gieben <miek@miek.nl> * Complete full spec test case Signed-off-by: Miek Gieben <miek@miek.nl> * fix container log streaming for containers with TTY --------- Signed-off-by: Miek Gieben <miek@miek.nl> Co-authored-by: Pasha Sviderski <me@psviderski.name>
2026-08-26 19:13:34 +00:00 · 2026-08-21 15:14:02 +10:00 · 2026-07-30 21:50:54 +10:00 · 2026-07-21 17:01:21 +10:00 · 2026-07-21 14:16:46 +10:00 · 2026-07-14 12:54:44 +10:00
38 changed files with 952 additions and 224 deletions
@@ -24,6 +24,7 @@ import (
 	"github.com/psviderski/uncloud/internal/machine"
 	"github.com/psviderski/uncloud/internal/version"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )

 type globalOptions struct {
@@ -42,6 +43,13 @@ func main() {
 		SilenceUsage:  true,
 		SilenceErrors: true,
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			// Shell completion runs through the hidden __complete command which has flag parsing disabled,
+			// so the global flags from the completed command line are never parsed. Apply them manually to make
+			// completion work with --connect, --context, and --uncloud-config.
+			if cmd.Name() == cobra.ShellCompRequestCmd {
+				applyGlobalFlagsFromCompletionArgs(cmd.Root().PersistentFlags(), os.Args[1:])
+			}
+
 			cli.BindEnvToFlag(cmd, "connect", "UNCLOUD_CONNECT")
 			cli.BindEnvToFlag(cmd, "context", "UNCLOUD_CONTEXT")
 			cli.BindEnvToFlag(cmd, "uncloud-config", "UNCLOUD_CONFIG")
@@ -159,3 +167,27 @@ func main() {
 		cobra.CheckErr(err)
 	}
 }
+
+// applyGlobalFlagsFromCompletionArgs parses the global flags from the raw arguments of a __complete command and applies
+// the ones found to flags. The trailing word being completed, unknown flags, and positional arguments are ignored.
+func applyGlobalFlagsFromCompletionArgs(flags *pflag.FlagSet, args []string) {
+	// The shell always passes the word being completed as the last argument, even if it's empty.
+	// Exclude it from parsing as its value may not be complete yet.
+	if len(args) == 0 {
+		return
+	}
+	args = args[:len(args)-1]
+
+	fset := pflag.NewFlagSet("global", pflag.ContinueOnError)
+	fset.ParseErrorsAllowlist.UnknownFlags = true
+	fset.String("connect", "", "")
+	fset.StringP("context", "c", "", "")
+	fset.String("uncloud-config", "", "")
+	// Parsing an incomplete command line may fail, apply the flags parsed so far anyway.
+	_ = fset.Parse(args)
+
+	fset.Visit(func(f *pflag.Flag) {
+		// Setting the flag marks it as changed so it takes precedence over environment variables.
+		_ = flags.Set(f.Name, f.Value.String())
+	})
+}
@@ -0,0 +1,116 @@
+package main
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestApplyGlobalFlagsFromCompletionArgs(t *testing.T) {
+	defaultConfigPath := "~/.config/uncloud/config.yaml"
+
+	tests := []struct {
+		name           string
+		args           []string
+		wantConnect    string
+		wantContext    string
+		wantConfigPath string
+		// Flag names expected to be marked as changed on the target flag set.
+		wantChanged []string
+	}{
+		{
+			name: "no flags",
+			args: []string{"__complete", "inspect", ""},
+		},
+		{
+			name:        "connect with space",
+			args:        []string{"__complete", "--connect", "ssh://user@host", "inspect", ""},
+			wantConnect: "ssh://user@host",
+			wantChanged: []string{"connect"},
+		},
+		{
+			name:        "connect with equals",
+			args:        []string{"__complete", "--connect=tcp://127.0.0.1:51000", "inspect", ""},
+			wantConnect: "tcp://127.0.0.1:51000",
+			wantChanged: []string{"connect"},
+		},
+		{
+			name:        "context shorthand",
+			args:        []string{"__complete", "-c", "prod", "inspect", ""},
+			wantContext: "prod",
+			wantChanged: []string{"context"},
+		},
+		{
+			name:           "all flags",
+			args:           []string{"__complete", "--connect", "user@host", "-c", "prod", "--uncloud-config", "/tmp/uncloud.yaml", "inspect", ""},
+			wantConnect:    "user@host",
+			wantContext:    "prod",
+			wantConfigPath: "/tmp/uncloud.yaml",
+			wantChanged:    []string{"connect", "context", "uncloud-config"},
+		},
+		{
+			name:        "unknown flags are ignored",
+			args:        []string{"__complete", "--quiet", "-n", "5", "--connect", "user@host", "logs", ""},
+			wantConnect: "user@host",
+			wantChanged: []string{"connect"},
+		},
+		{
+			name: "flags after double dash are ignored",
+			args: []string{"__complete", "exec", "svc", "--", "sh", "--connect", "user@host"},
+		},
+		{
+			name:        "flags before double dash are applied",
+			args:        []string{"__complete", "--connect", "user@host", "exec", "svc", "--", "sh", "-c", "env"},
+			wantConnect: "user@host",
+			wantChanged: []string{"connect"},
+		},
+		{
+			name:        "partial flag name being completed is excluded",
+			args:        []string{"__complete", "--connect", "user@host", "inspect", "--context"},
+			wantConnect: "user@host",
+			wantChanged: []string{"connect"},
+		},
+		{
+			name: "partial flag value being completed is excluded",
+			args: []string{"__complete", "--uncloud-config", "/tmp/"},
+		},
+		{
+			name: "partial connect value being completed is excluded",
+			args: []string{"__complete", "--connect", "tcp://127.0.0.1:5"},
+		},
+		{
+			name:           "completed flag value with partial command word",
+			args:           []string{"__complete", "--uncloud-config", "/tmp/uncloud.yaml", "insp"},
+			wantConfigPath: "/tmp/uncloud.yaml",
+			wantChanged:    []string{"uncloud-config"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Mirror the global persistent flags defined on the root command.
+			var opts globalOptions
+			flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
+			flags.StringVar(&opts.connect, "connect", "", "")
+			flags.StringVarP(&opts.context, "context", "c", "", "")
+			flags.StringVar(&opts.configPath, "uncloud-config", defaultConfigPath, "")
+
+			applyGlobalFlagsFromCompletionArgs(flags, tt.args)
+
+			assert.Equal(t, tt.wantConnect, opts.connect)
+			assert.Equal(t, tt.wantContext, opts.context)
+			wantConfigPath := tt.wantConfigPath
+			if wantConfigPath == "" {
+				wantConfigPath = defaultConfigPath
+			}
+			assert.Equal(t, wantConfigPath, opts.configPath)
+
+			for _, name := range []string{"connect", "context", "uncloud-config"} {
+				assert.Equal(t, slices.Contains(tt.wantChanged, name), flags.Changed(name),
+					"changed status of flag '%s'", name)
+			}
+		})
+	}
+}
@@ -132,35 +132,34 @@ func runProxy(ctx context.Context, uncli *cli.CLI, opts proxyOptions) error {
 	// endpoint and shuffles the data, *it* will actually experience errors.
 	remoteAddr := net.JoinHostPort(ip.String(), strconv.Itoa(opts.remotePort))

-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
 	p := &proxy.Proxy{
 		Listener:    listener,
 		RemoteAddr:  remoteAddr,
 		DialContext: dialer.DialContext,
 		OnError: func(err error) {
-			fmt.Printf("Failed to proxy to '%s': %v\n", remoteAddr, err)
-			cancel()
+			if proxy.IsConnectionClosedError(err) {
+				return
+			}
+			// A more actionable error instead of the cryptic [ssh -W] command error.
+			if strings.Contains(err.Error(), "Session open refused by peer") {
+				fmt.Printf("Could not connect to '%s': connection refused. "+
+					"Check that the service is running and listening on port %d inside the container.\n",
+					remoteAddr, opts.remotePort)
+				return
+			}
+
+			fmt.Printf("Failed to proxy a connection to '%s': %v\n", remoteAddr, err)
 		},
 	}

-	// Run the proxy in the background and signal when it has fully shut down.
-	done := make(chan struct{})
-	go func() {
-		p.Run(ctx)
-		close(done)
-	}()
-
 	// Prefix the local address with the scheme for common HTTP ports so it becomes control-clickable in most
 	// terminals. We assume plain HTTP since TLS is typically terminated by Caddy in front of the service.
 	fmt.Printf("%s%s → %s (%s%s%s)\n", schemeForPort(opts.remotePort), p.Listener.Addr().String(),
 		remoteAddr, opts.service, tui.Faint.Render("/"), containerID)

-	<-ctx.Done()
-	// Wait for the proxy to drain in-flight connections and shut down gracefully.
-	<-done
-
+	if err = p.Run(ctx); err != nil {
+		return fmt.Errorf("run proxy to '%s': %w", remoteAddr, err)
+	}
 	return nil
 }

@@ -11,6 +11,11 @@ import (
 )

 func Contexts(ctx context.Context, uncli *cli.CLI, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+	// There are no contexts to complete when the CLI uses a direct machine connection (--connect) without a config.
+	if uncli.Config == nil {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+
 	contexts := slices.Sorted(maps.Keys(uncli.Config.Contexts))

 	names := []cobra.Completion{}
@@ -21,7 +26,6 @@ func Contexts(ctx context.Context, uncli *cli.CLI, args []string, toComplete str
 		if strings.HasPrefix(context, toComplete) {
 			names = append(names, context)
 		}
-		names = append(names, context)
 	}

 	return names, cobra.ShellCompDirectiveNoFileComp
@@ -10,7 +10,8 @@ import (
 )

 func Machines(ctx context.Context, uncli *cli.CLI, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	client, err := uncli.ConnectCluster(ctx)
+	// Disable the connection progress output to not interfere with the shell completion output.
+	client, err := uncli.ConnectClusterWithOptions(ctx, cli.ConnectOptions{})
 	if err != nil {
 		return nil, cobra.ShellCompDirectiveError
 	}
@@ -11,7 +11,8 @@ import (
 )

 func Services(ctx context.Context, uncli *cli.CLI, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	client, err := uncli.ConnectCluster(ctx)
+	// Disable the connection progress output to not interfere with the shell completion output.
+	client, err := uncli.ConnectClusterWithOptions(ctx, cli.ConnectOptions{})
 	if err != nil {
 		return nil, cobra.ShellCompDirectiveError
 	}
@@ -11,7 +11,8 @@ import (
 )

 func Volumes(ctx context.Context, uncli *cli.CLI, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	client, err := uncli.ConnectCluster(ctx)
+	// Disable the connection progress output to not interfere with the shell completion output.
+	client, err := uncli.ConnectClusterWithOptions(ctx, cli.ConnectOptions{})
 	if err != nil {
 		return nil, cobra.ShellCompDirectiveError
 	}
@@ -9,6 +9,7 @@ import (
 	"time"

 	"github.com/containerd/errdefs"
+	systemd "github.com/coreos/go-systemd/daemon"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/image"
 	"github.com/docker/docker/api/types/mount"
@@ -22,6 +23,13 @@ const (
 	Image = "ghcr.io/unlabs-dev/corrosion:2026.6.15"
 	// ContainerName is the name of the managed Corrosion container.
 	ContainerName = "uncloud-corrosion"
+
+	// systemdStartTimeoutExtension is the duration of each systemd service start timeout extension that prevents
+	// a slow image pull from exceeding the start timeout (TimeoutStartSec). Extensions are a no-op if Corrosion
+	// is not starting during a systemd service startup.
+	systemdStartTimeoutExtension = 30 * time.Second
+	// systemdStartTimeoutExtendMax caps the total duration the start timeout can be extended for.
+	systemdStartTimeoutExtendMax = 5 * time.Minute
 )

 type DockerService struct {
@@ -175,8 +183,14 @@ func (s *DockerService) createAndStart(ctx context.Context) error {
 		}
 		defer respBody.Close()

+		// The pull on the first daemon start may take longer than the systemd service start timeout (TimeoutStartSec)
+		// on a slow connection. Keep extending the timeout while the pull is in progress so systemd doesn't kill
+		// the daemon before it reports readiness. This is a no-op if not running under systemd.
+		stopExtending := extendSystemdStartTimeout(ctx)
 		// Wait for pull to complete.
-		if _, err := io.Copy(io.Discard, respBody); err != nil {
+		_, err = io.Copy(io.Discard, respBody)
+		stopExtending()
+		if err != nil {
 			return fmt.Errorf("read pull response: %w", err)
 		}
 		slog.Info("Docker image pulled.", "image", s.Image, "duration", time.Since(start).String())
@@ -192,3 +206,40 @@ func (s *DockerService) createAndStart(ctx context.Context) error {
 	}
 	return nil
 }
+
+// extendSystemdStartTimeout periodically asks systemd to extend the service start timeout, for up to
+// systemdStartTimeoutExtendMax. The returned function stops the extensions. It is a no-op when the service
+// is not running under systemd (NOTIFY_SOCKET is not set).
+func extendSystemdStartTimeout(ctx context.Context) (stop context.CancelFunc) {
+	ctx, cancel := context.WithCancel(ctx)
+
+	go func() {
+		// Send extensions more frequently than they expire so a single missed tick doesn't time out the start.
+		ticker := time.NewTicker(systemdStartTimeoutExtension / 3)
+		defer ticker.Stop()
+		deadline := time.Now().Add(systemdStartTimeoutExtendMax)
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if time.Now().After(deadline) {
+					slog.Warn("Stopped extending the systemd service start timeout: corrosion service is taking "+
+						"too long to start.", "timeout", systemdStartTimeoutExtendMax)
+					return
+				}
+				msg := fmt.Sprintf("EXTEND_TIMEOUT_USEC=%d", systemdStartTimeoutExtension.Microseconds())
+				if _, err := systemd.SdNotify(false, msg); err != nil {
+					slog.Warn("Failed to extend the systemd service start timeout when starting corrosion service.",
+						"err", err)
+					return
+				}
+				slog.Info("Extended systemd service start timeout while corrosion service is starting.",
+					"duration", systemdStartTimeoutExtension)
+			}
+		}
+	}()
+
+	return cancel
+}
@@ -562,7 +562,9 @@ func (s *Server) CreateServiceContainer(
 			api.LabelServiceMode: spec.Mode,
 			api.LabelManaged:     "",
 		},
-		User: spec.Container.User,
+		User:      spec.Container.User,
+		Tty:       spec.Container.Tty,
+		OpenStdin: spec.Container.OpenStdin,
 	}
 	if spec.Mode == "" {
 		config.Labels[api.LabelServiceMode] = api.ServiceModeReplicated
@@ -1,12 +1,14 @@
 package docker

 import (
+	"bufio"
 	"bytes"
 	"context"
 	"database/sql"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"log/slog"
 	"strconv"
 	"strings"
@@ -233,11 +235,17 @@ func (s *Service) ListImages(ctx context.Context, opts image.ListOptions) (Image
 	return imagesResp, nil
 }

-// ContainerLogs streams logs from a container and returns demultiplexed entries via a channel.
+// ContainerLogs streams logs from a container and returns entries via a channel.
 // The channel is closed when streaming completes or context is cancelled.
 func (s *Service) ContainerLogs(
 	ctx context.Context, containerID string, opts api.ServiceLogsOptions,
 ) (<-chan api.LogEntry, error) {
+	ctr, err := s.Client.ContainerInspect(ctx, containerID)
+	if err != nil {
+		return nil, fmt.Errorf("inspect container '%s': %w", containerID, err)
+	}
+	isTTY := ctr.Config != nil && ctr.Config.Tty
+
 	dockerOpts := container.LogsOptions{
 		ShowStdout: true,
 		ShowStderr: true,
@@ -257,25 +265,31 @@ func (s *Service) ContainerLogs(
 	stdoutWriter := &logsChannelWriter{ctx: ctx, ch: outCh, isStderr: false}
 	stderrWriter := &logsChannelWriter{ctx: ctx, ch: outCh, isStderr: true}

-	// Wrap the context in a cancellable one to unblock the second goroutine below when StdCopy completes.
+	// Wrap the context in a cancellable one to unblock the second goroutine when log copying completes.
 	ctx, cancel := context.WithCancel(ctx)

-	// Run StdCopy in a goroutine to be able to handle context cancellation.
+	// Copy logs in a goroutine to be able to handle context cancellation.
 	go func() {
 		defer close(outCh)
 		defer cancel()

-		// StdCopy is blocking and will return when the reader is closed in another goroutine below or on error.
-		if _, err := stdcopy.StdCopy(stdoutWriter, stderrWriter, reader); err != nil {
+		// Docker returns raw stdout for TTY containers and multiplexed stdout/stderr otherwise.
+		var err error
+		if isTTY {
+			_, err = copyRawContainerLogs(stdoutWriter, reader)
+		} else {
+			_, err = stdcopy.StdCopy(stdoutWriter, stderrWriter, reader)
+		}
+		if err != nil {
 			// Send error as the last entry.
 			select {
-			case outCh <- api.LogEntry{Err: fmt.Errorf("demultiplex container logs: %w", err)}:
+			case outCh <- api.LogEntry{Err: fmt.Errorf("copy container logs: %w", err)}:
 			case <-ctx.Done():
 			}
 		}
 	}()

-	// Close the reader when the context is done to cancel StdCopy if it's still running.
+	// Close the reader when the context is done to cancel log copying if it's still running.
 	go func() {
 		<-ctx.Done()
 		reader.Close()
@@ -284,7 +298,32 @@ func (s *Service) ContainerLogs(
 	return outCh, nil
 }

-// logsChannelWriter is a writer for stdcopy.StdCopy that sends demultiplexed container logs to a channel.
+// copyRawContainerLogs copies a raw TTY log stream one line at a time so each write produces one log entry.
+func copyRawContainerLogs(dst io.Writer, src io.Reader) (written int64, _ error) {
+	reader := bufio.NewReader(src)
+	for {
+		line, readErr := reader.ReadBytes('\n')
+		if len(line) > 0 {
+			n, writeErr := dst.Write(line)
+			written += int64(n)
+			if writeErr != nil {
+				return written, writeErr
+			}
+			if n != len(line) {
+				return written, io.ErrShortWrite
+			}
+		}
+
+		if readErr != nil {
+			if errors.Is(readErr, io.EOF) {
+				return written, nil
+			}
+			return written, readErr
+		}
+	}
+}
+
+// logsChannelWriter sends container log writes to a channel.
 type logsChannelWriter struct {
 	ctx      context.Context
 	ch       chan<- api.LogEntry
@@ -0,0 +1,122 @@
+package docker
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/docker/docker/api/types/container"
+	dockerclient "github.com/docker/docker/client"
+	"github.com/docker/docker/pkg/stdcopy"
+	"github.com/psviderski/uncloud/pkg/api"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestServiceContainerLogs(t *testing.T) {
+	t.Parallel()
+
+	const (
+		containerID = "container-id"
+		firstLog    = "2025-01-01T00:00:00.000000000Z first message\n"
+		secondLog   = "2025-01-01T00:00:01.000000000Z second message\n"
+	)
+
+	var multiplexedLogs bytes.Buffer
+	_, err := stdcopy.NewStdWriter(&multiplexedLogs, stdcopy.Stdout).Write([]byte(firstLog))
+	require.NoError(t, err)
+	_, err = stdcopy.NewStdWriter(&multiplexedLogs, stdcopy.Stderr).Write([]byte(secondLog))
+	require.NoError(t, err)
+
+	tests := []struct {
+		name     string
+		tty      bool
+		logs     []byte
+		streams  []api.LogStreamType
+		messages []string
+	}{
+		{
+			name:     "TTY raw stream",
+			tty:      true,
+			logs:     []byte(firstLog + secondLog),
+			streams:  []api.LogStreamType{api.LogStreamStdout, api.LogStreamStdout},
+			messages: []string{"first message\n", "second message\n"},
+		},
+		{
+			name:     "non-TTY multiplexed stream",
+			logs:     multiplexedLogs.Bytes(),
+			streams:  []api.LogStreamType{api.LogStreamStdout, api.LogStreamStderr},
+			messages: []string{"first message\n", "second message\n"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			dockerClient := newLogsTestClient(t, tt.tty, tt.logs)
+			service := NewService(dockerClient, nil)
+
+			logsCh, err := service.ContainerLogs(context.Background(), containerID, api.ServiceLogsOptions{})
+			require.NoError(t, err)
+
+			var entries []api.LogEntry
+			for entry := range logsCh {
+				require.NoError(t, entry.Err)
+				entries = append(entries, entry)
+			}
+
+			require.Len(t, entries, len(tt.messages))
+			for i := range entries {
+				assert.Equal(t, tt.streams[i], entries[i].Stream)
+				assert.Equal(t, tt.messages[i], string(entries[i].Message))
+				assert.False(t, entries[i].Timestamp.IsZero())
+			}
+		})
+	}
+}
+
+func newLogsTestClient(t *testing.T, tty bool, logs []byte) *dockerclient.Client {
+	t.Helper()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/containers/container-id/json"):
+			w.Header().Set("Content-Type", "application/json")
+			if err := json.NewEncoder(w).Encode(container.InspectResponse{
+				ContainerJSONBase: &container.ContainerJSONBase{ID: "container-id"},
+				Config:            &container.Config{Tty: tty},
+			}); err != nil {
+				t.Errorf("encode inspect response: %v", err)
+			}
+		case strings.HasSuffix(r.URL.Path, "/containers/container-id/logs"):
+			w.Header().Set("Content-Type", "application/vnd.docker.raw-stream")
+			if _, err := w.Write(logs); err != nil {
+				t.Errorf("write logs response: %v", err)
+			}
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	serverURL, err := url.Parse(server.URL)
+	require.NoError(t, err)
+
+	dockerClient, err := dockerclient.NewClientWithOpts(
+		dockerclient.WithHost("tcp://"+serverURL.Host),
+		dockerclient.WithHTTPClient(server.Client()),
+		dockerclient.WithVersion("1.48"),
+	)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, dockerClient.Close())
+	})
+
+	return dockerClient
+}
@@ -2,11 +2,12 @@ package proxy

 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net"
-	"os"
 	"sync"
+	"syscall"
 	"time"
 )

@@ -15,58 +16,53 @@ type Proxy struct {
 	Listener    net.Listener
 	RemoteAddr  string
 	DialContext func(ctx context.Context, network, address string) (net.Conn, error)
+	// OnError is called for errors that occur during proxying individual connections. It may be called concurrently
+	// for different connections.
 	OnError     func(error)
 	activeConns sync.WaitGroup
 }

-// deadliner is an interface for listeners that support setting deadlines.
-type deadliner interface {
-	SetDeadline(t time.Time) error
-}
-
 // halfCloser is an interface for connections that support half-close.
 type halfCloser interface {
 	CloseWrite() error
 }

-// Run starts the proxy and runs until the context is canceled.
-func (p *Proxy) Run(ctx context.Context) {
+// IsConnectionClosedError reports whether err indicates that a connection was closed or aborted by either peer.
+// Callers can use it to ignore routine connection shutdown or broken pipe errors reported to Proxy.OnError.
+func IsConnectionClosedError(err error) bool {
+	return errors.Is(err, net.ErrClosed) || errors.Is(err, io.ErrClosedPipe) ||
+		errors.Is(err, syscall.EPIPE) || errors.Is(err, syscall.ECONNRESET)
+}
+
+// Run starts the proxy and runs until the context is canceled or the listener fails. It returns nil when the context
+// is canceled. Errors handling individual connections are reported to OnError and do not stop the proxy.
+func (p *Proxy) Run(ctx context.Context) error {
 	if p.DialContext == nil {
 		p.DialContext = (&net.Dialer{}).DialContext
 	}

+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
 	defer p.Listener.Close()

-	// Handle incoming connections until context is canceled.
-Loop:
+	// Closing the listener unblocks Accept when the context is canceled. This works for both TCP and Unix listeners
+	// and avoids polling with listener deadlines.
+	stopClose := context.AfterFunc(ctx, func() {
+		p.Listener.Close()
+	})
+	defer stopClose()
+
+	var runErr error
 	for {
-		select {
-		case <-ctx.Done():
-			break Loop
-		default:
-		}
-
-		// Set a deadline on the listener if supported to check context periodically.
-		if dl, ok := p.Listener.(deadliner); ok {
-			dl.SetDeadline(time.Now().Add(1 * time.Second))
-		}
-
 		conn, err := p.Listener.Accept()
 		if err != nil {
-			if os.IsTimeout(err) {
-				// Just a timeout, continue to check context and accept again.
-				continue
+			if ctx.Err() != nil {
+				break
 			}

-			select {
-			case <-ctx.Done():
-				break Loop
-			default:
-				if p.OnError != nil {
-					p.OnError(fmt.Errorf("accept local connection: %w", err))
-				}
-				continue
-			}
+			runErr = fmt.Errorf("accept local connection: %w", err)
+			cancel()
+			break
 		}

 		p.activeConns.Add(1)
@@ -75,6 +71,7 @@ Loop:

 	// Wait for all connections to finish.
 	p.activeConns.Wait()
+	return runErr
 }

 func (p *Proxy) handleConnection(ctx context.Context, localConn net.Conn) {
@@ -87,46 +84,62 @@ func (p *Proxy) handleConnection(ctx context.Context, localConn net.Conn) {

 	remoteConn, err := p.DialContext(dialCtx, "tcp", p.RemoteAddr)
 	if err != nil {
-		if p.OnError != nil {
+		if ctx.Err() == nil && p.OnError != nil {
 			p.OnError(fmt.Errorf("connect remote address '%s': %w", p.RemoteAddr, err))
 		}
 		return
 	}
 	defer remoteConn.Close()

-	// Bidirectional copy with proper half-close handling.
+	// Closing both connections aborts both copies after cancellation or a copy error. A clean EOF still uses
+	// half-close so the other direction can finish sending any remaining data.
+	closeConnections := func() {
+		localConn.Close()
+		remoteConn.Close()
+	}
+	stopClose := context.AfterFunc(ctx, closeConnections)
+	defer stopClose()
+
 	done := make(chan error, 2)

 	go func() {
 		_, err := io.Copy(remoteConn, localConn)
+		if err != nil {
+			done <- err
+			closeConnections()
+			return
+		}
 		// Close write half of remote connection if supported.
 		if hc, ok := remoteConn.(halfCloser); ok {
 			hc.CloseWrite()
 		}
-		done <- err
+		done <- nil
 	}()

 	go func() {
 		_, err := io.Copy(localConn, remoteConn)
+		if err != nil {
+			done <- err
+			closeConnections()
+			return
+		}
 		// Close write half of local connection if supported.
 		if hc, ok := localConn.(halfCloser); ok {
 			hc.CloseWrite()
 		}
-		done <- err
+		done <- nil
 	}()

-	// Wait for both copies to complete or context cancel.
+	// Wait for both copies to complete. The first error is the original failure because a copy reports it before
+	// closing the connections to unblock the other copy.
+	var copyErr error
 	for range 2 {
-		select {
-		case <-ctx.Done():
-			// Close connections to abort ongoing copies.
-			localConn.Close()
-			remoteConn.Close()
-			return
-		case err = <-done:
-			if err != nil && p.OnError != nil {
-				p.OnError(fmt.Errorf("data copy: %w", err))
-			}
+		if err = <-done; err != nil && copyErr == nil {
+			copyErr = err
 		}
 	}
+
+	if copyErr != nil && ctx.Err() == nil && p.OnError != nil {
+		p.OnError(fmt.Errorf("data copy: %w", copyErr))
+	}
 }
@@ -0,0 +1,188 @@
+package proxy
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsConnectionClosedError(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		err  error
+		want bool
+	}{
+		{name: "closed network connection", err: net.ErrClosed, want: true},
+		{name: "closed pipe", err: io.ErrClosedPipe, want: true},
+		{name: "broken pipe", err: syscall.EPIPE, want: true},
+		{name: "connection reset", err: syscall.ECONNRESET, want: true},
+		{name: "wrapped connection error", err: fmt.Errorf("copy data: %w", syscall.EPIPE), want: true},
+		{name: "other error", err: errors.New("copy failed"), want: false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, IsConnectionClosedError(tt.err))
+		})
+	}
+}
+
+func TestRunContinuesAfterClosedConnectionError(t *testing.T) {
+	t.Parallel()
+
+	listener := newTestListener()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	closedErrCh := make(chan error, 1)
+	unexpectedErrCh := make(chan error, 1)
+	var dialCount atomic.Int32
+
+	p := &Proxy{
+		Listener:   listener,
+		RemoteAddr: "remote:80",
+		DialContext: func(context.Context, string, string) (net.Conn, error) {
+			if dialCount.Add(1) == 1 {
+				return readErrorConn{err: syscall.EPIPE}, nil
+			}
+
+			proxyConn, upstreamConn := net.Pipe()
+			go func() {
+				defer upstreamConn.Close()
+				_, _ = upstreamConn.Write([]byte("ok"))
+			}()
+			return proxyConn, nil
+		},
+		OnError: func(err error) {
+			if IsConnectionClosedError(err) {
+				closedErrCh <- err
+				return
+			}
+			unexpectedErrCh <- err
+		},
+	}
+
+	runErrCh := make(chan error, 1)
+	go func() {
+		runErrCh <- p.Run(ctx)
+	}()
+
+	firstConn := listener.connect()
+	defer firstConn.Close()
+
+	select {
+	case connErr := <-closedErrCh:
+		require.ErrorIs(t, connErr, syscall.EPIPE)
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for closed connection error")
+	}
+
+	secondConn := listener.connect()
+	defer secondConn.Close()
+	require.NoError(t, secondConn.SetReadDeadline(time.Now().Add(time.Second)))
+
+	got := make([]byte, 2)
+	_, err := io.ReadFull(secondConn, got)
+	require.NoError(t, err)
+	require.Equal(t, "ok", string(got))
+
+	select {
+	case unexpectedErr := <-unexpectedErrCh:
+		t.Fatalf("unexpected connection error: %v", unexpectedErr)
+	default:
+	}
+
+	cancel()
+	select {
+	case runErr := <-runErrCh:
+		require.NoError(t, runErr)
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for proxy to stop")
+	}
+}
+
+func TestRunReturnsListenerError(t *testing.T) {
+	t.Parallel()
+
+	listenerErr := errors.New("listener failed")
+	listener := errorListener{err: listenerErr}
+
+	p := &Proxy{Listener: listener}
+	err := p.Run(context.Background())
+	require.Error(t, err)
+	require.ErrorContains(t, err, "accept local connection")
+	require.ErrorIs(t, err, listenerErr)
+}
+
+type testListener struct {
+	conns     chan net.Conn
+	closed    chan struct{}
+	closeOnce sync.Once
+}
+
+func newTestListener() *testListener {
+	return &testListener{
+		conns:  make(chan net.Conn),
+		closed: make(chan struct{}),
+	}
+}
+
+func (l *testListener) connect() net.Conn {
+	clientConn, proxyConn := net.Pipe()
+	l.conns <- proxyConn
+	return clientConn
+}
+
+func (l *testListener) Accept() (net.Conn, error) {
+	select {
+	case conn := <-l.conns:
+		return conn, nil
+	case <-l.closed:
+		return nil, net.ErrClosed
+	}
+}
+
+func (l *testListener) Close() error {
+	l.closeOnce.Do(func() {
+		close(l.closed)
+	})
+	return nil
+}
+
+func (l *testListener) Addr() net.Addr {
+	return &net.TCPAddr{}
+}
+
+type errorListener struct {
+	err error
+}
+
+func (l errorListener) Accept() (net.Conn, error) { return nil, l.err }
+func (errorListener) Close() error                { return nil }
+func (errorListener) Addr() net.Addr              { return &net.TCPAddr{} }
+
+// readErrorConn fails reads immediately so tests can deterministically exercise a proxy copy failure.
+type readErrorConn struct {
+	err error
+}
+
+func (c readErrorConn) Read([]byte) (int, error)       { return 0, c.err }
+func (readErrorConn) Write(p []byte) (int, error)      { return len(p), nil }
+func (readErrorConn) Close() error                     { return nil }
+func (readErrorConn) LocalAddr() net.Addr              { return &net.TCPAddr{} }
+func (readErrorConn) RemoteAddr() net.Addr             { return &net.TCPAddr{} }
+func (readErrorConn) SetDeadline(time.Time) error      { return nil }
+func (readErrorConn) SetReadDeadline(time.Time) error  { return nil }
+func (readErrorConn) SetWriteDeadline(time.Time) error { return nil }
@@ -265,6 +265,11 @@ type ContainerSpec struct {
 	LogDriver *LogDriver
 	// PidMode sets the PID namespace mode for the container. Currently only "" or "host" is supported.
 	PidMode string
+	// Tty allocates a pseudo-TTY and connects the container's standard streams to it.
+	// Standard output and standard error share one stream.
+	Tty bool
+	// OpenStdin allocates standard input and keeps it open.
+	OpenStdin bool
 	// Privileged gives extended privileges to the container. This is a security risk and should be used with caution.
 	Privileged bool
 	// PullPolicy determines when to pull the image from the registry or use the image already available in the cluster.
@@ -54,6 +54,8 @@ func ServiceSpecFromCompose(project *types.Project, serviceName string) (api.Ser
 			Image:       service.Image,
 			Init:        service.Init,
 			PidMode:     service.Pid,
+			Tty:         service.Tty,
+			OpenStdin:   service.StdinOpen,
 			Privileged:  service.Privileged,
 			PullPolicy:  pullPolicy,
 			Resources:   resourcesFromCompose(service),
@@ -128,6 +128,8 @@ func TestServiceSpecFromCompose(t *testing.T) {
 							},
 						},
 						PidMode:    "host",
+						Tty:        true,
+						OpenStdin:  true,
 						Privileged: true,
 						PullPolicy: api.PullPolicyAlways,
 						Resources: api.ContainerResources{
@@ -7,6 +7,8 @@ services:
    command: ["nginx", "updated", "command"]
    cpus: 0.5
    pid: host
+    tty: true
+    stdin_open: true
    deploy:
      update_config:
        order: stop-first
@@ -66,6 +66,26 @@ func TestEvalContainerSpecChange_ContainerPidMode(t *testing.T) {
 	assert.Equal(t, ContainerNeedsRecreate, EvalContainerSpecChange(newSpec, currentSpec))
 }

+func TestEvalContainerSpecChange_ContainerTty(t *testing.T) {
+	t.Parallel()
+
+	currentSpec := api.ServiceSpec{
+		Container: api.ContainerSpec{
+			Image: "nginx:latest",
+		},
+	}
+	newSpec := api.ServiceSpec{
+		Container: api.ContainerSpec{
+			Image:     "nginx:latest",
+			Tty:       true,
+			OpenStdin: true,
+		},
+	}
+
+	assert.Equal(t, ContainerNeedsRecreate, EvalContainerSpecChange(currentSpec, newSpec))
+	assert.Equal(t, ContainerNeedsRecreate, EvalContainerSpecChange(newSpec, currentSpec))
+}
+
 func TestEvalContainerSpecChange_ContainerResources(t *testing.T) {
 	t.Parallel()

@@ -252,13 +252,19 @@ func (cli *Client) pushImageToMachine(
 	// The proxy runs in a goroutine. Capture the first error in a channel
 	// so we can surface it alongside the push error if push fails.
 	proxyErrCh := make(chan error, 1)
-	onProxyError := func(err error) {
+	recordProxyError := func(err error) {
 		select {
 		case proxyErrCh <- fmt.Errorf("proxy to unregistry: %w", err):
 		default:
 		}
 		pw.Event(progress.NewEvent(proxyEventID, progress.Error, err.Error()))
 	}
+	onProxyError := func(err error) {
+		if proxy.IsConnectionClosedError(err) {
+			return
+		}
+		recordProxyError(err)
+	}

 	// socketPath is set for plain rootless Docker (not running inside a VM): the Go proxy listens on a unix
 	// socket that is bind-mounted into the socat container, bypassing slirp4netns network routing entirely.
@@ -315,7 +321,11 @@ func (cli *Client) pushImageToMachine(
 	}
 	defer cleanup()

-	go unregProxy.Run(proxyCtx)
+	go func() {
+		if err := unregProxy.Run(proxyCtx); err != nil {
+			recordProxyError(err)
+		}
+	}()

 	if dockerEnv.Virtualised {
 		// VM-based Docker (Docker Desktop, Rancher Desktop, etc.): run a socat container inside the VM
@@ -220,7 +220,7 @@ install_uncloud_binaries() {
                # 0.20.0~nightly-abc < 0.20.0 < 0.21.0~nightly-def.
                # latest_version is always a clean stable tag from releases/latest, so the substitution is one-sided.
                local newest
-                newest=$(printf '%s\n%s\n' "${installed_version//-/~}" "${latest_version}" | sort -V | tail -n1)
+                newest=$(printf '%s\n%s\n' "${installed_version//-/\~}" "${latest_version}" | sort -V | tail -n1)
                if [ "${newest}" = "${latest_version}" ]; then
                    log "⏳ Upgrading uncloudd ${installed_version} → ${latest_version}..."
                    uncloudd_url="${UNCLOUD_GITHUB_URL}/releases/download/v${latest_version}/${uncloudd_archive_name}"
@@ -287,7 +287,7 @@ Wants=network-online.target
 [Service]
 Type=notify
 ExecStart=${INSTALL_BIN_DIR}/uncloudd
-TimeoutStartSec=15
+TimeoutStartSec=20
 Restart=always
 RestartSec=2

@@ -1,5 +1,10 @@
 {
    admin off
+    servers {
+        # Trust the Uncloud ingress Caddy (cluster network) so the X-Forwarded-For chain it forwards
+        # is preserved and the real client IP is logged in the client_ip field.
+        trusted_proxies static 10.210.0.0/16
+    }
 }

 :8000 {
@@ -14,33 +14,41 @@ Uncloud covers all the essentials for operating apps in production without overw
 traditional container orchestrators like Kubernetes or Swarm:

 * Initial machine and network setup
+* Building images and pushing them directly to your machines without a registry
 * Zero-downtime rolling deployments
 * Health checks and automatic restarts
-* Automatic HTTPS and reverse proxy configuration
 * Scaling services across multiple machines
 * Cross-machine service communication without exposing ports to the internet
 * DNS-based service discovery
+* Automatic HTTPS and reverse proxy configuration
 * Load balancing
 * Persistent storage

 ## Use cases

-Some of the common use cases Uncloud is a great fit for:
+Uncloud is a great fit for anything from production workloads to a single-server homelab:

- **Self-hosting and Homelabs**: Run your self-hosted apps on your own hardware. Start with a single machine and add
-  more as your needs grow.
+- **Production web apps and SaaS**: Run your product on VMs from any cloud provider or your own servers with
+  zero-downtime rolling deployments, health checks, and automatic HTTPS. Spread replicas across multiple machines to
+  keep your app available even when a machine goes down.
 - **Outgrowing Docker Compose**: Level up your Docker Compose setup with zero-downtime deployments, replicas across
  multiple machines for improved reliability, cross-machine service communication, automated reverse proxy management,
  and more using the same Compose file.
- **Small to medium web applications**: Deploy your SaaS product, websites, or personal projects with redundancy across
-  multiple machines for better reliability and your peace of mind.
- **Hybrid setups (cloud + on-prem)**: Combine cloud VMs with on-premise for cost savings and data sovereignty — all
-  managed through the same interface.
+- **Moving off a cloud PaaS or Kubernetes**: Get a Heroku-like deployment workflow on your own servers, without the high
+  PaaS costs or the complexity of Kubernetes.
+- **Migrating from Docker Swarm**: Swarm has been in maintenance mode for years. Uncloud offers an actively developed
+  alternative that keeps the familiar Compose format and drops the manager quorum. You also get secure WireGuard
+  networking across machines, image push without a registry, and automatic reverse proxy management out of the box.
+- **Hybrid setups (cloud + on-prem)**: Combine cloud VMs with on-premise servers and distribute workloads for cost
+  savings and data sovereignty. For example, keep your database on your own hardware and scale web replicas out to cloud
+  VMs. Manage everything together through the same interface.
 - **Agencies and freelancers**: Host multiple client projects with proper isolation on shared infrastructure, optimising
  costs and resources.
 - **Edge computing**: Deploy applications closer to your users for lower latency and better performance.
- **Dev/staging environments**: Spin up additional environments for development and testing that mirror production
-  reusing the same Compose configuration.
+- **Self-hosting and homelabs**: Run your self-hosted apps on your own hardware. Start with a single machine and add
+  more as your needs grow.
+- **Dev/staging environments**: Spin up additional environments for development and testing that mirror production,
+  using the same Compose configuration.

 ## What makes Uncloud special

@@ -69,10 +77,10 @@ Talos [KubeSpan](https://www.talos.dev/v1.10/talos-guides/network/kubespan/).

 ### Managed DNS service (optional)

-Uncloud can provide **managed DNS records** like `<service-name>.<cluster-id>.uncld.dev` for your public
-services through free [Uncloud DNS](https://github.com/psviderski/uncloud-dns) service. You can deploy a service and
-instantly access it from anywhere with a proper DNS name and HTTPS without any manual DNS configuration. This makes
-self-hosting much more accessible and simplifies the process of adding your own domain later.
+Uncloud can provide **managed DNS records** like `<service-name>.<cluster-id>.uncld.dev` for your public services
+through free [Uncloud DNS](https://github.com/psviderski/uncloud-dns) service. You can deploy a service and instantly
+access it from anywhere with a proper DNS name and HTTPS without any manual DNS configuration. This makes self-hosting
+much more accessible and simplifies the process of adding your own domain later.

 ### No complex orchestration

@@ -57,6 +57,12 @@ curl -fsS https://get.uncloud.run/install.sh | VERSION=nightly sh

 More information about nightly builds of the CLI and daemon can be found [here](https://github.com/psviderski/uncloud/releases/tag/nightly).

+## mise
+You can install uncloud with [mise](https://mise.jdx.dev/):
+```
+mise use github:psviderski/uncloud[exe=uc]
+```
+
 ## GitHub download (macOS, Linux)

 You can manually download and use a pre-built binary from the
@@ -99,13 +105,15 @@ Follow the same steps to upgrade to the latest version in the future.
 ## Debian

 On a Debian system, you can install Uncloud CLI from an unofficial
-[repository](https://debian.griffo.io/) maintained by
+[repository](https://deb.griffo.io/) maintained by
 [@dariogriffo](https://github.com/dariogriffo):

 ```shell
-curl -sS https://debian.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/trusted.gpg.d/debian.griffo.io.gpg
-echo "deb https://debian.griffo.io/apt $(lsb_release -sc 2>/dev/null) main" | sudo tee /etc/apt/sources.list.d/debian.griffo.io.list
-apt install -y uncloud
+sudo install -d -m 0755 /etc/apt/keyrings
+curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
+echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(lsb_release -sc 2>/dev/null) main" | sudo tee /etc/apt/sources.list.d/deb.griffo.io.list
+sudo apt update
+sudo apt install -y uncloud
 ```

 Alternatively, you can download `.deb` packages directly from the repository
@@ -1,15 +1,19 @@
 # Deploy demo app

-In this guide, we'll deploy [Excalidraw](https://excalidraw.com) — a popular sketching and diagramming tool — to your
+In this guide, we'll deploy [Excalidraw](https://excalidraw.com), a popular sketching and diagramming tool, to your
 Linux server. You'll learn the **basics of Uncloud** and see how simple it is to **run web apps** on your own
 infrastructure with secure internet access.

 :::info NOTE
-To give you a chance to play with Uncloud without even leaving your browser or needing your own servers, we're providing interactive tutorials and playgrounds on the [iximiuz Labs](https://labs.iximiuz.com/) platform.

-You can follow [this tutorial](https://labs.iximiuz.com/tutorials/uncloud-create-cluster-ebebf72b) which walks you through creating a new cluster with two machines and then deploying a simple web service to it.
+To give you a chance to play with Uncloud without even leaving your browser or needing your own servers, we're providing
+interactive tutorials and playgrounds on the [iximiuz Labs](https://labs.iximiuz.com/) platform.

-You can also launch the [Uncloud playground](https://labs.iximiuz.com/playgrounds/uncloud-cluster-64523f7c) where you can play with an already initialized Uncloud cluster.
+You can follow [this tutorial](https://labs.iximiuz.com/tutorials/uncloud-create-cluster-ebebf72b) which walks you
+through creating a new cluster with two machines and then deploying a simple web service to it.
+
+You can also launch the [Uncloud playground](https://labs.iximiuz.com/playgrounds/uncloud-cluster-64523f7c) where you
+can play with an already initialised Uncloud cluster.
 :::

 ## Prerequisites
@@ -53,8 +57,7 @@ This command will:
 - Install the Uncloud daemon on your server
 - Create a Docker network for Uncloud-managed containers
 - Deploy [Caddy](https://caddyserver.com/) as your reverse proxy listening on host ports 80 and 443
- Reserve a free `xxxxxx.uncld.dev` subdomain via the Uncloud managed DNS service and point it to your
-  server's IP
+- Reserve a free `xxxxxx.uncld.dev` subdomain via the Uncloud managed DNS service and point it to your server's IP

 All in about a minute!

@@ -148,17 +151,17 @@ Cluster initialised with machine 'machine-dc3c' and saved as context 'default' i
 Current cluster context is now 'default'.
 Waiting for the machine to be ready...

-Reserved cluster domain: 7za6s7.uncld.dev
-[+] Deploying service caddy 7/2
- ✔ Container caddy-d7uk on machine-dc3c     Started                                            6.1s
-   ✔ Image caddy:2.10.0 on machine-dc3c       Pulled                                           3.7s
+Reserved cluster domain: sh8hsb.uncld.dev
+[+] Deploying service caddy 2/2
+ ✔ Container caddy-d7uk on machine-dc3c     Running                                           11.1s
+   ✔ Image caddy:2.11.4 on machine-dc3c     Pulled                                             3.7s

 Updating cluster domain records in Uncloud DNS to point to machines running caddy service...
 [+] Verifying internet access to caddy service 1/1
 ✔ Machine machine-dc3c (157.180.72.195)  Reachable                                            0.7s

 DNS records updated to use only the internet-reachable machines running caddy service:
-  *.7za6s7.uncld.dev  A → 157.180.72.195
+  *.sh8hsb.uncld.dev  A → 157.180.72.195
 ```

 </details>
@@ -177,11 +180,11 @@ You'll see the progress of the deployment and the public URL where you can acces

 ```
 [+] Running service excalidraw (replicated mode) 2/2
- ✔ Container excalidraw-azpc on machine-dc3c  Started                       8.9s
+ ✔ Container excalidraw-azpc on machine-dc3c  Healthy                      37.1s
   ✔ Image excalidraw/excalidraw on machine-dc3c  Pulled                    4.7s

 excalidraw endpoints:
- • https://excalidraw.7za6s7.uncld.dev → :80
+ • https://excalidraw.sh8hsb.uncld.dev → :80
 ```

 ## Verify your deployment
@@ -193,12 +196,12 @@ uc inspect excalidraw
 ```

 ```
-ID:    4d2de1600b6ada221a03896cd388836c
-Name:  excalidraw
-Mode:  replicated
+Service ID: 4d2de1600b6ada221a03896cd388836c
+Name:       excalidraw
+Mode:       replicated

-CONTAINER ID   IMAGE                   CREATED              STATUS                        MACHINE
-fde7ac7f11ad   excalidraw/excalidraw   About a minute ago   Up About a minute (healthy)   machine-dc3c
+CONTAINER ID   IMAGE                          CREATED              STATUS                        IP ADDRESS   MACHINE
+fde7ac7f11ad   excalidraw/excalidraw:latest   About a minute ago   Up About a minute (healthy)   10.210.0.3   machine-dc3c
 ```

 In this example, the service has one container running on the machine `machine-dc3c` (our server). The container is up
@@ -211,9 +214,9 @@ uc ls
 ```

 ```
-NAME         MODE         REPLICAS   ENDPOINTS
-caddy        global       1
-excalidraw   replicated   1          https://excalidraw.7za6s7.uncld.dev → :80
+NAME         MODE         REPLICAS   IMAGE                          ENDPOINTS
+caddy        global       1          caddy:2.11.4
+excalidraw   replicated   1          excalidraw/excalidraw:latest   https://excalidraw.sh8hsb.uncld.dev → :80
 ```

 You can see `caddy` service listed here. That's your reverse proxy, running as a regular Uncloud service.
@@ -223,7 +226,7 @@ You can see `caddy` service listed here. That's your reverse proxy, running as a
 Open your browser and navigate to the URL shown in the endpoints. It may take a moment for Caddy to obtain a TLS
 certificate from Let's Encrypt. If it doesn't load immediately, wait a few seconds and try again.

-![Excalidraw running on Uncloud](./img/excalidraw-browser.png)
+![Excalidraw running on Uncloud](https://media.uncloud.run/docs/excalidraw-browser.webp)

 You now have:

@@ -231,6 +234,25 @@ You now have:
 - A **public URL** with **automatic HTTPS** you can share with your team and friends
 - **Full control over your data** — no analytics or tracking

+## View service logs
+
+Want to see what's happening inside your service? Use the `uc logs` command to view logs from the service container:
+
+```shell
+uc logs excalidraw
+```
+
+```
+Jul 14 10:53:05.910 machine-dc3c excalidraw/fde7a ::1 - - [14/Jul/2026:00:53:05 +0000] "GET / HTTP/1.1" 200 6843 "-" "Wget" "-"
+Jul 14 10:53:31.456 machine-dc3c excalidraw/fde7a 10.210.0.2 - - [14/Jul/2026:00:53:31 +0000] "GET /sw.js HTTP/1.1" 200 0 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0"
+```
+
+Add the `-f` flag to stream new logs in real-time. Press `Ctrl+C` to stop:
+
+```shell
+uc logs excalidraw -f
+```
+
 ## Convert to Docker Compose format

 Uncloud supports the [Compose file format](https://docs.docker.com/reference/compose-file/) for defining services. This
@@ -249,9 +271,9 @@ services:

 :::info note

-The `x-ports` key is an Uncloud-specific extension to the Compose file format. It allows you to specify ports that
-should be published as HTTP(S) endpoints. Uncloud automatically configures the reverse proxy (Caddy) to route traffic to
-these ports.
+The [`x-ports`](../8-compose-file-reference/2-extensions.md#x-ports) key is an Uncloud-specific extension to the Compose
+file format. It allows you to specify ports that should be published as HTTP(S) endpoints. Uncloud automatically
+configures the reverse proxy (Caddy) to route traffic to these ports.

 :::

@@ -270,27 +292,29 @@ We've successfully converted our deployment created with `uc run` to a Compose f

 ## Use your own domain

-Want to use your own domain, for example, `excalidraw.example.com` instead of `excalidraw.7za6s7.uncld.dev`?
+Want to use your own domain, for example, `excalidraw.example.com` instead of `excalidraw.sh8hsb.uncld.dev`?

 Add a CNAME record `excalidraw.example.com` in your DNS provider (Cloudflare, Namecheap, etc.) pointing to
-`excalidraw.7za6s7.uncld.dev`. Alternatively, you can add an A record pointing to your server's IP.
+`excalidraw.sh8hsb.uncld.dev`. Alternatively, you can add an A record pointing to your server's IP.

 :::info note

 These instructions set up your own domain **in addition to** the Uncloud managed DNS name
-`excalidraw.7za6s7.uncld.dev`.
+`excalidraw.sh8hsb.uncld.dev`.

 If you want to avoid the managed service altogether, add `--no-dns` to your `uc machine init` command, and point an A
-DNS record to your server(s)'s IP(s).
+DNS record to your servers' IPs.

 :::

 Then update the published port `80/https` in `compose.yaml` to use your domain:

 ```yaml title="compose.yaml"
-...
-x-ports:
-  - excalidraw.example.com:80/https
+services:
+  excalidraw:
+    image: excalidraw/excalidraw
+    x-ports:
+      - excalidraw.example.com:80/https
 ```

 Finally, deploy the changes:
@@ -300,25 +324,32 @@ uc deploy
 ```

 ```
-Deployment plan:
- Deploy service [name=excalidraw]
-  - machine-dc3c: Run container [image=excalidraw/excalidraw]
-  - machine-dc3c: Remove container [name=excalidraw-azpc]
+Deployment plan

-Do you want to continue?
+context: default

-Choose [y/N]: y
-Chose: Yes!
+~ update service excalidraw
+  │   image: excalidraw/excalidraw:latest
+  │
+  ╰── +/- replace container excalidraw/fde7ac7f11ad on machine-dc3c

-[+] Deploying services 2/2
- ✔ Container excalidraw-0z12 on machine-dc3c  Started                       3.5s
- ✔ Container excalidraw-azpc on machine-dc3c  Removed                       3.4s
+──────────────────────────────────────────
+1 replace (start-first) · across 1 machine
+
+Proceed with deployment to default? [y/N] y
+
+[+] Deploying to default 2/2
+ ✔ Container excalidraw-0z12 on machine-dc3c          Healthy              30.6s
+ ✔ Container excalidraw/fde7ac7f11ad on machine-dc3c  Removed               0.4s
 ```

-Notice how Uncloud performed a **zero-downtime deployment** — it started the new container with the updated
-configuration before removing the old one. Your service stayed available throughout the update.
+Uncloud prints a deployment plan and asks for confirmation before making any changes. The plan says it will replace the
+running container with a new one using the
+[`start-first` order](../4-guides/1-deployments/4-rolling-deployments.md#update-order). This means Uncloud starts the
+new container with the updated configuration, waits for it to become healthy, and only then removes the old one. Your
+service stays available throughout the update. That's a **zero-downtime deployment**.

-Give it a moment for Caddy to obtain a TLS certificate, then visit https://excalidraw.example.com.
+Give it a moment for Caddy to obtain a TLS certificate, then visit https://excalidraw.example.com (use your own domain).

 ## Clean up

@@ -351,7 +382,7 @@ This command will:
 <summary>💡 Expand to see example output</summary>

 ```
-⚠️This script will uninstall Uncloud and remove ALL Uncloud managed containers on this machine.
+⚠️ This script will uninstall Uncloud and remove ALL Uncloud managed containers on this machine.
 The following actions will be performed:
 - Remove Uncloud systemd services
 - Remove Uncloud binaries and data
@@ -361,20 +392,7 @@ The following actions will be performed:
 - Remove Uncloud WireGuard interface
 Do you want to proceed with uninstallation? [y/N] y
 ⏳ Stopping systemd services...
-Removed "/etc/systemd/system/multi-user.target.wants/uncloud.service".
-The unit files have no installation config (WantedBy=, RequiredBy=, UpheldBy=,
-Also=, or Alias= settings in the [Install] section, and DefaultInstance= for
-template units). This means they are not meant to be enabled or disabled using systemctl.
-
-Possible reasons for having these kinds of units are:
-• A unit may be statically enabled by being symlinked from another unit's
-  .wants/, .requires/, or .upholds/ directory.
-• A unit's purpose may be to act as a helper for some other unit which has
-  a requirement dependency on it.
-• A unit may be started when needed via activation (socket, path, timer,
-  D-Bus, udev, scripted systemctl call, ...).
-• In case of template units, the unit is meant to be enabled with some
-  instance name specified.
+Removed /etc/systemd/system/multi-user.target.wants/uncloud.service.
 ✓ Systemd services stopped.
 ⏳ Removing systemd service files...
 removed '/etc/systemd/system/uncloud.service'
@@ -386,44 +404,61 @@ removed '/usr/local/bin/uncloudd'
 uncloud-corrosion
 ✓ uncloud-corrosion container removed.
 ⏳ Removing data and run directories...
-removed '/var/lib/uncloud/machine.db-wal'
-removed '/var/lib/uncloud/caddy/caddy/autosave.json'
-removed directory '/var/lib/uncloud/caddy/caddy'
-removed '/var/lib/uncloud/caddy/caddy.json'
-removed directory '/var/lib/uncloud/caddy'
-removed '/var/lib/uncloud/machine.json'
 removed '/var/lib/uncloud/machine.db-shm'
-removed '/var/lib/uncloud/corrosion/admin.sock'
-removed '/var/lib/uncloud/corrosion/config.toml'
-removed '/var/lib/uncloud/corrosion/subscriptions/b4e825113f1143e5b27715b62193a9f8/sub.sqlite-wal'
-removed '/var/lib/uncloud/corrosion/subscriptions/b4e825113f1143e5b27715b62193a9f8/sub.sqlite-shm'
-removed '/var/lib/uncloud/corrosion/subscriptions/b4e825113f1143e5b27715b62193a9f8/sub.sqlite'
-removed directory '/var/lib/uncloud/corrosion/subscriptions/b4e825113f1143e5b27715b62193a9f8'
-removed '/var/lib/uncloud/corrosion/subscriptions/5e04cbb20a2743c382cfbd4949922351/sub.sqlite'
-removed directory '/var/lib/uncloud/corrosion/subscriptions/5e04cbb20a2743c382cfbd4949922351'
-removed directory '/var/lib/uncloud/corrosion/subscriptions'
-removed '/var/lib/uncloud/corrosion/schema.sql'
-removed '/var/lib/uncloud/corrosion/store.db'
-removed directory '/var/lib/uncloud/corrosion'
 removed '/var/lib/uncloud/machine.db'
+removed '/var/lib/uncloud/corrosion/store.db'
+removed '/var/lib/uncloud/corrosion/subscriptions/754e24df40f8476389cf6dbfa7b542c8/sub.sqlite'
+removed directory '/var/lib/uncloud/corrosion/subscriptions/754e24df40f8476389cf6dbfa7b542c8'
+removed '/var/lib/uncloud/corrosion/subscriptions/125e6ada8eec4f3cad192e1890db55c2/sub.sqlite'
+removed directory '/var/lib/uncloud/corrosion/subscriptions/125e6ada8eec4f3cad192e1890db55c2'
+removed directory '/var/lib/uncloud/corrosion/subscriptions'
+removed '/var/lib/uncloud/corrosion/config.toml'
+removed '/var/lib/uncloud/corrosion/schema.sql'
+removed directory '/var/lib/uncloud/corrosion'
+removed '/var/lib/uncloud/machine.json'
+removed '/var/lib/uncloud/caddy/caddy.json'
+removed '/var/lib/uncloud/caddy/caddy/autosave.json'
+removed '/var/lib/uncloud/caddy/caddy/last_clean.json'
+removed directory '/var/lib/uncloud/caddy/caddy/locks'
+removed '/var/lib/uncloud/caddy/caddy/instance.uuid'
+removed '/var/lib/uncloud/caddy/caddy/acme/acme-staging-v02.api.letsencrypt.org-directory/users/default/default.json'
+removed '/var/lib/uncloud/caddy/caddy/acme/acme-staging-v02.api.letsencrypt.org-directory/users/default/default.key'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-staging-v02.api.letsencrypt.org-directory/users/default'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-staging-v02.api.letsencrypt.org-directory/users'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-staging-v02.api.letsencrypt.org-directory'
+removed '/var/lib/uncloud/caddy/caddy/acme/acme-v02.api.letsencrypt.org-directory/users/default/default.json'
+removed '/var/lib/uncloud/caddy/caddy/acme/acme-v02.api.letsencrypt.org-directory/users/default/default.key'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-v02.api.letsencrypt.org-directory/users/default'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-v02.api.letsencrypt.org-directory/users'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-v02.api.letsencrypt.org-directory/challenge_tokens'
+removed directory '/var/lib/uncloud/caddy/caddy/acme/acme-v02.api.letsencrypt.org-directory'
+removed directory '/var/lib/uncloud/caddy/caddy/acme'
+removed '/var/lib/uncloud/caddy/caddy/certificates/acme-v02.api.letsencrypt.org-directory/excalidraw.sh8hsb.uncld.dev/excalidraw.sh8hsb.uncld.dev.key'
+removed '/var/lib/uncloud/caddy/caddy/certificates/acme-v02.api.letsencrypt.org-directory/excalidraw.sh8hsb.uncld.dev/excalidraw.sh8hsb.uncld.dev.crt'
+removed '/var/lib/uncloud/caddy/caddy/certificates/acme-v02.api.letsencrypt.org-directory/excalidraw.sh8hsb.uncld.dev/excalidraw.sh8hsb.uncld.dev.json'
+removed directory '/var/lib/uncloud/caddy/caddy/certificates/acme-v02.api.letsencrypt.org-directory/excalidraw.sh8hsb.uncld.dev'
+removed directory '/var/lib/uncloud/caddy/caddy/certificates/acme-v02.api.letsencrypt.org-directory'
+removed directory '/var/lib/uncloud/caddy/caddy/certificates'
+removed directory '/var/lib/uncloud/caddy/caddy'
+removed '/var/lib/uncloud/caddy/Caddyfile'
+removed directory '/var/lib/uncloud/caddy'
+removed '/var/lib/uncloud/machine.db-wal'
 removed directory '/var/lib/uncloud'
+removed '/run/uncloud/caddy/admin.sock'
+removed directory '/run/uncloud/caddy'
+removed '/run/uncloud/corrosion/admin.sock'
+removed directory '/run/uncloud/corrosion'
 removed directory '/run/uncloud'
 ✓ Data and run directories removed.
 ⏳ Removing Linux user and group...
 ✓ Linux user 'uncloud' removed.
 Linux group 'uncloud' does not exist or was already removed.
 ⏳ Looking for Docker containers and network created by Uncloud...
-Found 4 Uncloud managed containers.
+Found 1 Uncloud managed containers.
 ⏳ Stopping Uncloud managed containers...
-20613f6046d0
-1f1a65b78e93
-4300bde4a2b0
-053fdd57ec56
+b2eb9968e468
 ⏳ Removing Uncloud managed containers...
-20613f6046d0
-1f1a65b78e93
-4300bde4a2b0
-053fdd57ec56
+b2eb9968e468
 ✓ Uncloud managed containers stopped and removed.
 ⏳ Removing Docker network uncloud...
 uncloud
@@ -1,6 +1,6 @@
 # Connecting to a cluster

-`uc` only needs to reach one machine to work with the entire cluster. That machine acts as an **entry point** and
+`uc` only needs to reach **one machine** to work with the entire cluster. That machine acts as an **entry point** and
 forwards requests to other machines as needed.

 `uc` stores **cluster contexts** and **connection details** in a [configuration file](../../7-cli-config-reference.md)
@@ -46,6 +46,27 @@ When you run a `uc` command, it determines which cluster to connect to using thi
 Once the context is resolved, `uc` tries each connection in the context's `connections` list in order until one
 succeeds.

+## User permissions on the machine
+
+When `uc` connects to a machine over SSH, it communicates with the Uncloud daemon through the Unix socket
+`/run/uncloud/uncloud.sock` on that machine. The daemon restricts access to the socket to the `root` user and members
+of the `uncloud` Linux group. This means your SSH user must be either `root` or a member of the `uncloud` group.
+
+In most cases you don't need to set this up manually. When you initialise or add a machine with a non-root user,
+`uc machine init` and `uc machine add` automatically add that user to the `uncloud` group during installation.
+
+If you want to connect with a different non-root user later, add them to the group on the machine:
+
+```shell
+sudo usermod -aG uncloud <username>
+```
+
+The group change only applies to new SSH sessions. If `uc` still fails with a permission denied error after adding the
+user, close any long-running SSH connections to the machine (for example, SSH ControlMaster sessions) and try again.
+
+The same requirement applies when running `uc` locally on a cluster machine with a `unix://` connection. The local user
+must be `root` or a member of the `uncloud` group.
+
 ## Global flags and environment variables

 These flags are available on every `uc` command. They can also be set with an environment variable. The flag takes
@@ -17,7 +17,7 @@ uc run -p app.example.com:8000/https app:latest

 ```
 [+] Running service app-mwng (replicated mode) 1/1
- ✔ Container app-mwng-6lub on machine-fnr9  Started
+ ✔ Container app-mwng-6lub on machine-fnr9  Running

 app-mwng endpoints:
 • https://app.example.com → :8000
@@ -45,9 +45,11 @@ If you rely on a specific Compose feature that is not supported by Uncloud, plea
 | `secrets`                        | ⚠️ Limited         | Reference secrets in `environment`, see [Secrets](../3-concepts/8-secrets.md). File mounts not supported                                   |
 | `security_opt`                   | ❌ Not supported    |                                                                                                                                            |
 | `shm_size`                       | ✅ Supported        | Shared memory size                                                                                                                         |
+| `stdin_open`                     | ✅ Supported        | Allocate standard input and keep it open                                                                                                   |
 | `stop_grace_period`              | ✅ Supported        | Time to wait after SIGTERM before SIGKILL                                                                                                  |
 | `storage_opt`                    | ❌ Not supported    |                                                                                                                                            |
 | `sysctls`                        | ✅ Supported        | Namespaced kernel parameters                                                                                                               |
+| `tty`                            | ✅ Supported        | Allocate a pseudo-TTY and connect the container's standard streams to it                                                                   |
 | `ulimits`                        | ✅ Supported        | Resource limits                                                                                                                            |
 | `user`                           | ✅ Supported        | Set container user                                                                                                                         |
 | `volumes`                        | ✅ Supported        | Named volumes, bind mounts, tmpfs                                                                                                          |
@@ -12,7 +12,19 @@ import {themes as prismThemes} from 'prism-react-renderer';
 const config = {
  title: 'Uncloud',
  tagline: 'Self-host and scale web apps without Kubernetes complexity',
-  favicon: 'img/favicon.png',
+  // Use the SVG logo as the primary favicon with a PNG fallback to match the landing pages.
+  favicon: 'img/logo.svg',
+  headTags: [
+    {
+      tagName: 'link',
+      attributes: {
+        rel: 'alternate icon',
+        type: 'image/png',
+        href: '/img/favicon.png',
+        sizes: '96x96',
+      },
+    },
+  ],

  // Set the production url of your site here
  url: 'https://uncloud.run',
@@ -689,7 +689,7 @@
                                    </svg>
                                </summary>
                                <p class="text-zinc-500 leading-relaxed pb-5">
-                                    No. <a class="underline hover:text-zinc-900" href="/">Uncloud</a> is open source
+                                    No, <a class="underline hover:text-zinc-900" href="/">Uncloud</a> is open source
                                    and fully functional on its own without Hub. You can use the CLI to manage your
                                    clusters and deploy your apps across servers from Compose files. You keep full
                                    control over your servers. Hub adds a web UI and an observability stack on top so
@@ -708,9 +708,12 @@
                                    </svg>
                                </summary>
                                <p class="text-zinc-500 leading-relaxed pb-5">
-                                    No, and no point pretending otherwise. Uncloud, the orchestrator, is Apache 2.0. Hub
-                                    is a managed service built on top, and it's how we plan to fund Uncloud's full-time
-                                    development.
+                                    Not at the moment. Hub is a managed service built on top of Uncloud, and it's how
+                                    we plan to fund Uncloud's full-time development. Our principle is that everything
+                                    Uncloud needs on your servers is open source, starting with Uncloud itself under
+                                    Apache 2.0. Your cluster never depends on closed code to keep running. If enough
+                                    people want to run Hub on their own infrastructure, a paid self-hosted license is
+                                    on the table.
                                </p>
                            </details>

@@ -140,7 +140,7 @@
                            <div class="max-w-xs mx-auto sm:max-w-none sm:inline-flex sm:justify-center space-y-4 sm:space-y-0 sm:space-x-4">
                                <div>
                                    <a class="btn text-zinc-100 bg-zinc-900 hover:bg-zinc-800 w-full shadow flex items-center justify-center"
-                                       href="https://github.com/psviderski/uncloud/?tab=readme-ov-file#-quick-start">
+                                       href="/docs/getting-started/deploy-demo-app">
                                        <svg class="w-5 h-5 mr-2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"
                                             fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
                                             stroke-linejoin="round">
@@ -738,10 +738,6 @@ prod-3  201.45.91.123:51820  1m56s ago  11ms   5.12MB    9.34MB
                                <a class="text-sm font-medium text-violet-700 hover:text-violet-900 transition"
                                   href="/hub#early-access">Get early access &rarr;</a>
                            </div>
-                            <p class="mt-5 text-sm text-zinc-500">
-                                Hub is how we plan to fund Uncloud's full-time development.<br>
-                                Uncloud itself stays Apache 2.0 and works fully without Hub.
-                            </p>
                        </div>

                        <div class="lg:col-start-1 lg:row-start-1 rounded-xl overflow-hidden border border-zinc-200 shadow-2xl shadow-zinc-950/10">
@@ -825,6 +821,49 @@ prod-3  201.45.91.123:51820  1m56s ago  11ms   5.12MB    9.34MB
                                    There are no agents to install and no pipelines to migrate.
                                </p>
                            </details>
+
+                            <details class="group">
+                                <summary
+                                        class="flex items-center justify-between gap-4 py-5 cursor-pointer list-none [&::-webkit-details-marker]:hidden font-inter-tight font-semibold text-zinc-900">
+                                    <span>Do I need Hub to use Uncloud?</span>
+                                    <svg class="w-5 h-5 shrink-0 text-zinc-400 transition-transform duration-200 group-open:rotate-45"
+                                         fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"
+                                         aria-hidden="true">
+                                        <path stroke-linecap="round" stroke-linejoin="round" d="M12 5v14m-7-7h14"/>
+                                    </svg>
+                                </summary>
+                                <p class="text-zinc-500 leading-relaxed pb-5">
+                                    No, Uncloud is open source and fully functional on its own without Hub. You can use
+                                    the CLI to manage your clusters and deploy your apps across servers from Compose
+                                    files. You keep full control over your servers. Hub adds a web UI and an
+                                    observability stack on top so you don't have to build and manage one yourself.
+                                </p>
+                            </details>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- Newsletter subscription -->
+        <section class="relative bg-white">
+            <div class="py-12 md:py-20">
+                <div class="max-w-6xl mx-auto px-4 sm:px-6">
+                    <div class="max-w-2xl mx-auto text-center">
+                        <h2 class="font-inter-tight text-3xl md:text-4xl font-bold text-zinc-900 mb-4">
+                            Follow the development journey
+                        </h2>
+                        <p class="text-lg text-zinc-500">
+                            Subscribe to get early insights into new features.
+                            See <a class="font-medium text-zinc-600 underline decoration-zinc-300 underline-offset-2 hover:text-zinc-900 hover:decoration-zinc-400 transition-colors"
+                                   href="https://psviderski.substack.com/" target="_blank" rel="noopener">previous
+                            newsletters</a>.
+                        </p>
+                        <div class="mt-6 md:mt-8 flex justify-center">
+                            <iframe src="https://psviderski.substack.com/embed?transparent=true" width="480"
+                                    height="160" title="Subscribe to the Uncloud newsletter" class="w-full max-w-[480px]"
+                                    style="border:none; background:transparent;" frameborder="0"
+                                    scrolling="no"></iframe>
                        </div>
                    </div>
                </div>
@@ -869,21 +908,6 @@ prod-3  201.45.91.123:51820  1m56s ago  11ms   5.12MB    9.34MB
                        </div>
                    </div>

-                    <!-- Newsletter subscription -->
-                    <div class="mt-12 md:mt-16">
-                        <p class="text-zinc-400 mb-4">
-                            Subscribe to follow the development journey and get early insights into new features.<br>
-                            See <a href="https://psviderski.substack.com/" target="_blank" rel="noopener"
-                                   class="text-zinc-200 underline decoration-zinc-500 underline-offset-2 hover:text-zinc-100 hover:decoration-zinc-300 transition-colors">previous
-                            newsletters</a>.
-                        </p>
-                        <div class="flex justify-center">
-                            <iframe src="https://psviderski.substack.com/embed?transparent=true" width="480"
-                                    height="150" title="Subscribe to the Uncloud newsletter"
-                                    style="border:none; background:transparent;" frameborder="0"
-                                    scrolling="no"></iframe>
-                        </div>
-                    </div>
                </div>
            </div>
        </section>
@@ -1348,6 +1348,10 @@ input[type="search"]::-webkit-search-results-decoration {
  display: inline-flex;
 }

+.table{
+  display: table;
+}
+
 .grid{
  display: grid;
 }
@@ -1468,6 +1472,10 @@ input[type="search"]::-webkit-search-results-decoration {
  max-width: 72rem;
 }

+.max-w-\[480px\]{
+  max-width: 480px;
+}
+
 .max-w-lg{
  max-width: 32rem;
 }
@@ -2376,10 +2384,6 @@ input[type="search"]::-webkit-search-results-decoration {
  text-decoration-color: #a1a1aa;
 }

-.decoration-zinc-500{
-  text-decoration-color: #71717a;
-}
-
 .underline-offset-2{
  text-underline-offset: 2px;
 }
@@ -2735,10 +2739,6 @@ html {
  text-decoration-color: #f4f4f5;
 }

-.hover\:decoration-zinc-300:hover{
-  text-decoration-color: #d4d4d8;
-}
-
 .hover\:decoration-zinc-400:hover{
  text-decoration-color: #a1a1aa;
 }
@@ -2963,8 +2963,8 @@ html {
    margin-top: 3.5rem;
  }

-  .md\:mt-16{
-    margin-top: 4rem;
+  .md\:mt-8{
+    margin-top: 2rem;
  }

  .md\:block{
Author	SHA1	Message	Date
Felix HummelandGitHub	ac56754281	docs(install): mise installation (#421 )	2026-08-21 15:14:02 +10:00
Miek Gieben GitHub Pasha Sviderski	b7e224a1ef	feat(compose): support stdin_open and tty (#419 ) * feat: support stdin_open and tty This can be useful to leave a container running without specifying a command like `sleep`, and probably in other situations as well. Signed-off-by: Miek Gieben <miek@miek.nl> * Complete full spec test case Signed-off-by: Miek Gieben <miek@miek.nl> * fix container log streaming for containers with TTY --------- Signed-off-by: Miek Gieben <miek@miek.nl> Co-authored-by: Pasha Sviderski <me@psviderski.name>	2026-07-30 21:50:54 +10:00
Pasha Sviderski	351698c280	fix(cli): completion with direct connections (--connect, --context, --uncloud-config) (fixes #377 )	2026-07-21 17:01:21 +10:00
Pasha Sviderski	fa77edf53e	fix(proxy): don't shutdown 'uc proxy' when a client connection aborts	2026-07-21 14:16:46 +10:00
Pasha Sviderski	b99abb7c39	website: update docs social card and favicons	2026-07-14 12:54:44 +10:00
Pasha Sviderski	c2ae11a293	docs(cluster): add section about SSH user permissions when connection to the cluster	2026-07-14 12:54:44 +10:00
Pasha Sviderski	f1555259de	chore(docs): update command outputs in Deploy demo app doc, add section to view logs	2026-07-14 12:54:44 +10:00
Pasha Sviderski	50f8fbcfda	fix(install): correctly compare installed nightly daemon version to upgrade to latest	2026-07-14 12:54:44 +10:00
Pasha Sviderski	73f29092ff	docs: update use cases on the Overview page	2026-07-14 12:54:44 +10:00
Pasha Sviderski	08b24af341	website: split newsletter subscription into a separate section	2026-07-14 12:54:43 +10:00
Pasha Sviderski	b9c54f1ff5	chore(website): configure ingress Caddy as trusted proxy to forward client IPs	2026-07-14 12:54:43 +10:00
Pasha Sviderski	4d76dd601c	website: refine faq open source question, update og image	2026-07-14 12:54:43 +10:00
Dario GriffoandGitHub	3af9936d27	docs(install): update Debian repository domain (#413 ) The community repository moved from debian.griffo.io to deb.griffo.io (Debian trademark policy; old domain redirects permanently). Also use the keyring + signed-by layout and add the missing sudo and apt update.	2026-07-14 12:54:29 +10:00
Pasha Sviderski	dc721e511e	fix(daemon): extend systemd service start timeout when pulling Docker image for corrosion service	2026-07-10 20:42:27 +10:00
Pasha Sviderski	054b3b8fd4	website: change CTA link to getting started docs	2026-07-09 19:07:25 +10:00