1 files changed, 71 insertions, 52 deletions

diff --git a/cmd/ship/deploy_impl_v2.go b/cmd/ship/deploy_impl_v2.go
index e2989b2..5b68dc3 100644
--- a/cmd/ship/deploy_impl_v2.go
+++ b/cmd/ship/deploy_impl_v2.go
@@ -46,20 +46,22 @@ func deployStaticV2(ctx *deployContext) *output.ErrorResponse {
                 // Non-fatal, continue
         }
 
-        // Generate Caddyfile
-        caddyfile, err := templates.StaticCaddy(map[string]string{
-                "Domain":  ctx.URL[8:], // Strip https://
-                "RootDir": remotePath,
-                "Name":    name,
-        })
-        if err != nil {
-                return output.Err(output.ErrCaddyFailed, "failed to generate Caddyfile: "+err.Error())
-        }
-
-        // Upload Caddyfile
+        // Generate Caddyfile only if it doesn't exist (preserve manual edits)
         caddyPath := fmt.Sprintf("/etc/caddy/sites-enabled/%s.caddy", name)
-        if err := client.WriteSudoFile(caddyPath, caddyfile); err != nil {
-                return output.Err(output.ErrCaddyFailed, "failed to write Caddyfile: "+err.Error())
+        caddyExists, _ := client.Run(fmt.Sprintf("test -f %s && echo exists", caddyPath))
+        if strings.TrimSpace(caddyExists) != "exists" {
+                caddyfile, err := templates.StaticCaddy(map[string]string{
+                        "Domain":  ctx.URL[8:], // Strip https://
+                        "RootDir": remotePath,
+                        "Name":    name,
+                })
+                if err != nil {
+                        return output.Err(output.ErrCaddyFailed, "failed to generate Caddyfile: "+err.Error())
+                }
+
+                if err := client.WriteSudoFile(caddyPath, caddyfile); err != nil {
+                        return output.Err(output.ErrCaddyFailed, "failed to write Caddyfile: "+err.Error())
+                }
         }
 
         // Reload Caddy
@@ -132,9 +134,14 @@ func deployDockerV2(ctx *deployContext) *output.ErrorResponse {
         }
 
         // Generate systemd unit
+        containerPort := ctx.Opts.ContainerPort
+        if containerPort == 0 {
+                containerPort = 80
+        }
         service, err := templates.DockerService(map[string]string{
-                "Name": name,
-                "Port": strconv.Itoa(port),
+                "Name":          name,
+                "Port":          strconv.Itoa(port),
+                "ContainerPort": strconv.Itoa(containerPort),
         })
         if err != nil {
                 return output.Err(output.ErrServiceFailed, "failed to generate systemd unit: "+err.Error())
@@ -145,18 +152,21 @@ func deployDockerV2(ctx *deployContext) *output.ErrorResponse {
                 return output.Err(output.ErrServiceFailed, "failed to write systemd unit: "+err.Error())
         }
 
-        // Generate Caddyfile
-        caddyfile, err := templates.AppCaddy(map[string]string{
-                "Domain": ctx.URL[8:], // Strip https://
-                "Port":   strconv.Itoa(port),
-        })
-        if err != nil {
-                return output.Err(output.ErrCaddyFailed, "failed to generate Caddyfile: "+err.Error())
-        }
-
+        // Generate Caddyfile only if it doesn't exist (preserve manual edits)
         caddyPath := fmt.Sprintf("/etc/caddy/sites-enabled/%s.caddy", name)
-        if err := client.WriteSudoFile(caddyPath, caddyfile); err != nil {
-                return output.Err(output.ErrCaddyFailed, "failed to write Caddyfile: "+err.Error())
+        caddyExists, _ := client.Run(fmt.Sprintf("test -f %s && echo exists", caddyPath))
+        if strings.TrimSpace(caddyExists) != "exists" {
+                caddyfile, err := templates.AppCaddy(map[string]string{
+                        "Domain": ctx.URL[8:], // Strip https://
+                        "Port":   strconv.Itoa(port),
+                })
+                if err != nil {
+                        return output.Err(output.ErrCaddyFailed, "failed to generate Caddyfile: "+err.Error())
+                }
+
+                if err := client.WriteSudoFile(caddyPath, caddyfile); err != nil {
+                        return output.Err(output.ErrCaddyFailed, "failed to write Caddyfile: "+err.Error())
+                }
         }
 
         // Reload systemd and start service
@@ -250,18 +260,21 @@ func deployBinaryV2(ctx *deployContext) *output.ErrorResponse {
                 return output.Err(output.ErrServiceFailed, "failed to write systemd unit: "+err.Error())
         }
 
-        // Generate Caddyfile
-        caddyfile, err := templates.AppCaddy(map[string]string{
-                "Domain": ctx.URL[8:], // Strip https://
-                "Port":   strconv.Itoa(port),
-        })
-        if err != nil {
-                return output.Err(output.ErrCaddyFailed, "failed to generate Caddyfile: "+err.Error())
-        }
-
+        // Generate Caddyfile only if it doesn't exist (preserve manual edits)
         caddyPath := fmt.Sprintf("/etc/caddy/sites-enabled/%s.caddy", name)
-        if err := client.WriteSudoFile(caddyPath, caddyfile); err != nil {
-                return output.Err(output.ErrCaddyFailed, "failed to write Caddyfile: "+err.Error())
+        caddyExists, _ := client.Run(fmt.Sprintf("test -f %s && echo exists", caddyPath))
+        if strings.TrimSpace(caddyExists) != "exists" {
+                caddyfile, err := templates.AppCaddy(map[string]string{
+                        "Domain": ctx.URL[8:], // Strip https://
+                        "Port":   strconv.Itoa(port),
+                })
+                if err != nil {
+                        return output.Err(output.ErrCaddyFailed, "failed to generate Caddyfile: "+err.Error())
+                }
+
+                if err := client.WriteSudoFile(caddyPath, caddyfile); err != nil {
+                        return output.Err(output.ErrCaddyFailed, "failed to write Caddyfile: "+err.Error())
+                }
         }
 
         // Reload systemd and start service
@@ -281,38 +294,44 @@ func deployBinaryV2(ctx *deployContext) *output.ErrorResponse {
 }
 
 // allocatePort allocates or retrieves a port for a service
+// Uses atomic increment on /etc/ship/next_port to avoid collisions
 func allocatePort(client *ssh.Client, name string) (int, error) {
         portFile := fmt.Sprintf("/etc/ship/ports/%s", name)
 
-        // Try to read existing port
+        // Try to read existing port for this app
         out, err := client.Run(fmt.Sprintf("cat %s 2>/dev/null || echo ''", portFile))
         if err == nil && out != "" {
-                port, err := strconv.Atoi(out[:len(out)-1]) // Strip newline
-                if err == nil && port > 0 {
+                out = strings.TrimSpace(out)
+                if port, err := strconv.Atoi(out); err == nil && port > 0 {
                         return port, nil
                 }
         }
 
-        // Allocate new port
-        // Find highest used port and increment
-        out, err = client.RunSudo("mkdir -p /etc/ship/ports && ls /etc/ship/ports/ 2>/dev/null | xargs -I{} cat /etc/ship/ports/{} 2>/dev/null | sort -n | tail -1")
+        // Allocate new port atomically using flock
+        // This reads next_port, increments it, and writes back while holding a lock
+        allocScript := `
+flock -x /etc/ship/.port.lock sh -c '
+  mkdir -p /etc/ship/ports
+  PORT=$(cat /etc/ship/next_port 2>/dev/null || echo 9000)
+  echo $((PORT + 1)) > /etc/ship/next_port
+  echo $PORT
+'`
+        out, err = client.RunSudo(allocScript)
         if err != nil {
-                out = ""
+                return 0, fmt.Errorf("failed to allocate port: %w", err)
         }
 
-        nextPort := 9000
-        if out != "" {
-                if lastPort, err := strconv.Atoi(out[:len(out)-1]); err == nil {
-                        nextPort = lastPort + 1
-                }
+        port, err := strconv.Atoi(strings.TrimSpace(out))
+        if err != nil {
+                return 0, fmt.Errorf("invalid port allocated: %s", out)
         }
 
-        // Write port allocation
-        if err := client.WriteSudoFile(portFile, strconv.Itoa(nextPort)); err != nil {
+        // Write port allocation for this app
+        if err := client.WriteSudoFile(portFile, strconv.Itoa(port)); err != nil {
                 return 0, err
         }
 
-        return nextPort, nil
+        return port, nil
 }
 
 // setTTLV2 sets auto-expiry for a deploy