Merge agent-mode: v2 rewrite complete

- Removed all v1 code (-2800 lines)
- Simplified state to just default_host + base_domain
- Atomic port allocation via flock
- --container-port flag for Docker
- Custom domains shown in ship list
- Caddyfiles preserved on redeploy
- JSON output by default, --pretty for humans

4 files changed, 338 insertions, 78 deletions

diff --git a/internal/detect/detect.go b/internal/detect/detect.go
new file mode 100644
index 0000000..f3efd22
--- /dev/null
+++ b/internal/detect/detect.go
@@ -0,0 +1,105 @@
+// Package detect provides auto-detection of project types.
+package detect
+
+import (
+        "os"
+        "path/filepath"
+
+        "github.com/bdw/ship/internal/output"
+)
+
+// ProjectType represents the detected deployment type
+type ProjectType string
+
+const (
+        TypeStatic ProjectType = "static"
+        TypeDocker ProjectType = "docker"
+        TypeBinary ProjectType = "binary"
+)
+
+// Result is the detection outcome
+type Result struct {
+        Type    ProjectType
+        Path    string // Absolute path to deploy
+        Error   *output.ErrorResponse
+}
+
+// Detect examines a path and determines how to deploy it.
+// Follows the logic from SPEC.md:
+//   - File: must be executable → binary
+//   - Directory with Dockerfile → docker
+//   - Directory with index.html → static
+//   - Go/Node without Dockerfile → error with guidance
+//   - Empty or unknown → error
+func Detect(path string) Result {
+        absPath, err := filepath.Abs(path)
+        if err != nil {
+                return Result{Error: output.Err(output.ErrInvalidPath, "cannot resolve path: "+err.Error())}
+        }
+
+        info, err := os.Stat(absPath)
+        if err != nil {
+                if os.IsNotExist(err) {
+                        return Result{Error: output.Err(output.ErrInvalidPath, "path does not exist: "+path)}
+                }
+                return Result{Error: output.Err(output.ErrInvalidPath, "cannot access path: "+err.Error())}
+        }
+
+        // File: must be executable binary
+        if !info.IsDir() {
+                return detectFile(absPath, info)
+        }
+
+        // Directory: check contents
+        return detectDirectory(absPath)
+}
+
+func detectFile(path string, info os.FileInfo) Result {
+        // Check if executable
+        if info.Mode()&0111 == 0 {
+                return Result{Error: output.Err(output.ErrUnknownProjectType, "file is not executable")}
+        }
+        return Result{Type: TypeBinary, Path: path}
+}
+
+func detectDirectory(path string) Result {
+        // Check for Dockerfile first (highest priority)
+        if hasFile(path, "Dockerfile") {
+                return Result{Type: TypeDocker, Path: path}
+        }
+
+        // Check for static site
+        if hasFile(path, "index.html") || hasFile(path, "index.htm") {
+                return Result{Type: TypeStatic, Path: path}
+        }
+
+        // Check for Go project without Dockerfile
+        if hasFile(path, "go.mod") {
+                return Result{Error: output.Err(output.ErrUnknownProjectType,
+                        "Go project without Dockerfile. Add a Dockerfile or build a binary first.")}
+        }
+
+        // Check for Node project without Dockerfile
+        if hasFile(path, "package.json") {
+                return Result{Error: output.Err(output.ErrUnknownProjectType,
+                        "Node project without Dockerfile. Add a Dockerfile.")}
+        }
+
+        // Check if empty
+        entries, err := os.ReadDir(path)
+        if err != nil {
+                return Result{Error: output.Err(output.ErrInvalidPath, "cannot read directory: "+err.Error())}
+        }
+        if len(entries) == 0 {
+                return Result{Error: output.Err(output.ErrInvalidPath, "directory is empty")}
+        }
+
+        // Unknown
+        return Result{Error: output.Err(output.ErrUnknownProjectType,
+                "cannot detect project type. Add a Dockerfile or index.html.")}
+}
+
+func hasFile(dir, name string) bool {
+        _, err := os.Stat(filepath.Join(dir, name))
+        return err == nil
+}
diff --git a/internal/output/output.go b/internal/output/output.go
new file mode 100644
index 0000000..a9a1036
--- /dev/null
+++ b/internal/output/output.go
@@ -0,0 +1,226 @@
+// Package output provides JSON response types for ship v2.
+// All commands output JSON by default. Human-readable output is opt-in via --pretty.
+package output
+
+import (
+        "encoding/json"
+        "fmt"
+        "os"
+)
+
+// Response is the base interface for all output types
+type Response interface {
+        IsError() bool
+}
+
+// DeployResponse is returned on successful deploy
+type DeployResponse struct {
+        Status  string          `json:"status"`
+        Name    string          `json:"name"`
+        URL     string          `json:"url"`
+        Type    string          `json:"type"` // "static", "docker", "binary"
+        TookMs  int64           `json:"took_ms"`
+        Health  *HealthResult   `json:"health,omitempty"`
+        Expires string          `json:"expires,omitempty"` // ISO 8601, only if TTL set
+}
+
+func (r DeployResponse) IsError() bool { return false }
+
+// HealthResult is the health check outcome
+type HealthResult struct {
+        Endpoint  string `json:"endpoint"`
+        Status    int    `json:"status"`
+        LatencyMs int64  `json:"latency_ms"`
+}
+
+// ListResponse is returned by ship list
+type ListResponse struct {
+        Status  string       `json:"status"`
+        Deploys []DeployInfo `json:"deploys"`
+}
+
+func (r ListResponse) IsError() bool { return false }
+
+// DeployInfo is a single deploy in a list
+type DeployInfo struct {
+        Name    string `json:"name"`
+        URL     string `json:"url"`
+        Type    string `json:"type"`
+        Running bool   `json:"running"`
+        Expires string `json:"expires,omitempty"`
+}
+
+// StatusResponse is returned by ship status
+type StatusResponse struct {
+        Status    string `json:"status"`
+        Name      string `json:"name"`
+        URL       string `json:"url"`
+        Type      string `json:"type"`
+        Running   bool   `json:"running"`
+        Port      int    `json:"port,omitempty"`
+        Expires   string `json:"expires,omitempty"`
+        Memory    string `json:"memory,omitempty"`
+        CPU       string `json:"cpu,omitempty"`
+}
+
+func (r StatusResponse) IsError() bool { return false }
+
+// LogsResponse is returned by ship logs
+type LogsResponse struct {
+        Status string   `json:"status"`
+        Name   string   `json:"name"`
+        Lines  []string `json:"lines"`
+}
+
+func (r LogsResponse) IsError() bool { return false }
+
+// RemoveResponse is returned by ship remove
+type RemoveResponse struct {
+        Status  string `json:"status"`
+        Name    string `json:"name"`
+        Removed bool   `json:"removed"`
+}
+
+func (r RemoveResponse) IsError() bool { return false }
+
+// HostInitResponse is returned by ship host init
+type HostInitResponse struct {
+        Status    string   `json:"status"`
+        Host      string   `json:"host"`
+        Domain    string   `json:"domain"`
+        Installed []string `json:"installed"`
+}
+
+func (r HostInitResponse) IsError() bool { return false }
+
+// ErrorResponse is returned on any failure
+type ErrorResponse struct {
+        Status  string `json:"status"` // always "error"
+        Code    string `json:"code"`
+        Message string `json:"message"`
+        Name    string `json:"name,omitempty"`
+        URL     string `json:"url,omitempty"`
+}
+
+func (r ErrorResponse) IsError() bool { return true }
+
+// Error implements the error interface for compatibility with v1 code
+func (r *ErrorResponse) Error() string { return r.Message }
+
+// Error codes
+const (
+        ErrInvalidPath         = "INVALID_PATH"
+        ErrInvalidArgs         = "INVALID_ARGS"
+        ErrUnknownProjectType  = "UNKNOWN_PROJECT_TYPE"
+        ErrSSHConnectFailed    = "SSH_CONNECT_FAILED"
+        ErrSSHAuthFailed       = "SSH_AUTH_FAILED"
+        ErrUploadFailed        = "UPLOAD_FAILED"
+        ErrBuildFailed         = "BUILD_FAILED"
+        ErrServiceFailed       = "SERVICE_FAILED"
+        ErrCaddyFailed         = "CADDY_FAILED"
+        ErrHealthCheckFailed   = "HEALTH_CHECK_FAILED"
+        ErrHealthCheckTimeout  = "HEALTH_CHECK_TIMEOUT"
+        ErrNotFound            = "NOT_FOUND"
+        ErrConflict            = "CONFLICT"
+        ErrHostNotConfigured   = "HOST_NOT_CONFIGURED"
+        ErrInvalidTTL          = "INVALID_TTL"
+        ErrInvalidName         = "INVALID_NAME"
+        ErrPortExhausted       = "PORT_EXHAUSTED"
+)
+
+// Exit codes
+const (
+        ExitSuccess       = 0
+        ExitDeployFailed  = 1
+        ExitInvalidArgs   = 2
+        ExitSSHFailed     = 3
+        ExitHealthFailed  = 4
+)
+
+// Pretty controls human-readable output
+var Pretty bool
+
+// Print outputs the response as JSON (or pretty if enabled)
+func Print(r Response) {
+        if Pretty {
+                printPretty(r)
+                return
+        }
+        enc := json.NewEncoder(os.Stdout)
+        enc.Encode(r)
+}
+
+// PrintAndExit outputs the response and exits with appropriate code
+func PrintAndExit(r Response) {
+        Print(r)
+        if r.IsError() {
+                os.Exit(exitCodeForError(r.(*ErrorResponse).Code))
+        }
+        os.Exit(ExitSuccess)
+}
+
+// Err creates an ErrorResponse
+func Err(code, message string) *ErrorResponse {
+        return &ErrorResponse{
+                Status:  "error",
+                Code:    code,
+                Message: message,
+        }
+}
+
+// ErrWithName creates an ErrorResponse with name context
+func ErrWithName(code, message, name string) *ErrorResponse {
+        return &ErrorResponse{
+                Status:  "error",
+                Code:    code,
+                Message: message,
+                Name:    name,
+        }
+}
+
+func exitCodeForError(code string) int {
+        switch code {
+        case ErrSSHConnectFailed, ErrSSHAuthFailed:
+                return ExitSSHFailed
+        case ErrHealthCheckFailed, ErrHealthCheckTimeout:
+                return ExitHealthFailed
+        case ErrInvalidPath, ErrInvalidTTL, ErrInvalidName, ErrHostNotConfigured, ErrInvalidArgs:
+                return ExitInvalidArgs
+        default:
+                return ExitDeployFailed
+        }
+}
+
+func printPretty(r Response) {
+        switch v := r.(type) {
+        case *DeployResponse:
+                fmt.Printf("✓ Deployed to %s (%.1fs)\n", v.URL, float64(v.TookMs)/1000)
+        case *ListResponse:
+                if len(v.Deploys) == 0 {
+                        fmt.Println("No deployments")
+                        return
+                }
+                fmt.Printf("%-20s %-40s %-8s %s\n", "NAME", "URL", "TYPE", "STATUS")
+                for _, d := range v.Deploys {
+                        status := "running"
+                        if !d.Running {
+                                status = "stopped"
+                        }
+                        if d.Expires != "" {
+                                status += " (expires " + d.Expires + ")"
+                        }
+                        fmt.Printf("%-20s %-40s %-8s %s\n", d.Name, d.URL, d.Type, status)
+                }
+        case *RemoveResponse:
+                fmt.Printf("✓ Removed %s\n", v.Name)
+        case *ErrorResponse:
+                fmt.Printf("✗ %s: %s\n", v.Code, v.Message)
+        case *HostInitResponse:
+                fmt.Printf("✓ Initialized %s with domain %s\n", v.Host, v.Domain)
+        default:
+                // Fallback to JSON
+                enc := json.NewEncoder(os.Stdout)
+                enc.SetIndent("", "  ")
+                enc.Encode(r)
+        }
+}
diff --git a/internal/state/state.go b/internal/state/state.go
index c9aa21d..9b06179 100644
--- a/internal/state/state.go
+++ b/internal/state/state.go
@@ -8,38 +8,18 @@ import (
         "regexp"
 )
 
-// State represents the entire local deployment state
+// State represents the local ship configuration
 type State struct {
         DefaultHost string           `json:"default_host,omitempty"`
         Hosts       map[string]*Host `json:"hosts"`
 }
 
-// Host represents deployment state for a single VPS
+// Host represents configuration for a single VPS
 type Host struct {
-        NextPort   int             `json:"next_port"`
-        BaseDomain string          `json:"base_domain,omitempty"`
-        GitSetup   bool            `json:"git_setup,omitempty"`
-        Apps       map[string]*App `json:"apps"`
+        BaseDomain string `json:"base_domain,omitempty"`
+        GitSetup   bool   `json:"git_setup,omitempty"`
 }
 
-// App represents a deployed application or static site
-type App struct {
-        Type   string            `json:"type"`             // "app", "static", "git-app", or "git-static"
-        Domain string            `json:"domain"`
-        Port   int               `json:"port,omitempty"`   // only for type="app" or "git-app"
-        Repo   string            `json:"repo,omitempty"`   // only for git types, e.g. "/srv/git/foo.git"
-        Public bool              `json:"public,omitempty"` // only for git types, enables HTTP clone access
-        Env    map[string]string `json:"env,omitempty"`    // only for type="app" or "git-app"
-        Args   string            `json:"args,omitempty"`   // only for type="app"
-        Files  []string          `json:"files,omitempty"`  // only for type="app"
-        Memory string            `json:"memory,omitempty"` // only for type="app"
-        CPU    string            `json:"cpu,omitempty"`    // only for type="app"
-}
-
-const (
-        startPort = 8001
-)
-
 var validName = regexp.MustCompile(`^[a-z][a-z0-9-]{0,62}$`)
 
 // ValidateName checks that a name is safe for use in shell commands,
@@ -55,7 +35,6 @@ func ValidateName(name string) error {
 func Load() (*State, error) {
         path := statePath()
 
-        // If file doesn't exist, return empty state
         if _, err := os.Stat(path); os.IsNotExist(err) {
                 return &State{
                         Hosts: make(map[string]*Host),
@@ -72,7 +51,6 @@ func Load() (*State, error) {
                 return nil, fmt.Errorf("failed to parse state file: %w", err)
         }
 
-        // Initialize maps if nil
         if state.Hosts == nil {
                 state.Hosts = make(map[string]*Host)
         }
@@ -84,7 +62,6 @@ func Load() (*State, error) {
 func (s *State) Save() error {
         path := statePath()
 
-        // Ensure directory exists
         dir := filepath.Dir(path)
         if err := os.MkdirAll(dir, 0755); err != nil {
                 return fmt.Errorf("failed to create config directory: %w", err)
@@ -102,60 +79,14 @@ func (s *State) Save() error {
         return nil
 }
 
-// GetHost returns the host state, creating it if it doesn't exist
+// GetHost returns the host config, creating it if it doesn't exist
 func (s *State) GetHost(host string) *Host {
         if s.Hosts[host] == nil {
-                s.Hosts[host] = &Host{
-                        NextPort: startPort,
-                        Apps:     make(map[string]*App),
-                }
-        }
-        if s.Hosts[host].Apps == nil {
-                s.Hosts[host].Apps = make(map[string]*App)
+                s.Hosts[host] = &Host{}
         }
         return s.Hosts[host]
 }
 
-// AllocatePort returns the next available port for a host
-func (s *State) AllocatePort(host string) int {
-        h := s.GetHost(host)
-        port := h.NextPort
-        h.NextPort++
-        return port
-}
-
-// AddApp adds or updates an app in the state
-func (s *State) AddApp(host, name string, app *App) {
-        h := s.GetHost(host)
-        h.Apps[name] = app
-}
-
-// RemoveApp removes an app from the state
-func (s *State) RemoveApp(host, name string) error {
-        h := s.GetHost(host)
-        if _, exists := h.Apps[name]; !exists {
-                return fmt.Errorf("app %s not found", name)
-        }
-        delete(h.Apps, name)
-        return nil
-}
-
-// GetApp returns an app from the state
-func (s *State) GetApp(host, name string) (*App, error) {
-        h := s.GetHost(host)
-        app, exists := h.Apps[name]
-        if !exists {
-                return nil, fmt.Errorf("app %s not found", name)
-        }
-        return app, nil
-}
-
-// ListApps returns all apps for a host
-func (s *State) ListApps(host string) map[string]*App {
-        h := s.GetHost(host)
-        return h.Apps
-}
-
 // GetDefaultHost returns the default host, or empty string if not set
 func (s *State) GetDefaultHost() string {
         return s.DefaultHost
@@ -166,11 +97,9 @@ func (s *State) SetDefaultHost(host string) {
         s.DefaultHost = host
 }
 
-// statePath returns the path to the state file
 func statePath() string {
         home, err := os.UserHomeDir()
         if err != nil {
-                // Fallback to current directory (should rarely happen)
                 return ".ship-state.json"
         }
         return filepath.Join(home, ".config", "ship", "state.json")
diff --git a/internal/templates/templates.go b/internal/templates/templates.go
index b68a504..2163f47 100644
--- a/internal/templates/templates.go
+++ b/internal/templates/templates.go
@@ -216,7 +216,7 @@ Requires=docker.service
 Type=simple
 ExecStartPre=-/usr/bin/docker rm -f {{.Name}}
 ExecStart=/usr/bin/docker run --rm --name {{.Name}} \
-  -p 127.0.0.1:{{.Port}}:{{.Port}} \
+  -p 127.0.0.1:{{.Port}}:{{.ContainerPort}} \
   --env-file /etc/ship/env/{{.Name}}.env \
   -v /var/lib/{{.Name}}/data:/data \
   {{.Name}}:latest