feat: Phase 1 RPC protocol infrastructure for daemon architecture (bd-111)

Implemented Unix socket RPC foundation to enable daemon-based concurrent access:

New files:
- internal/rpc/protocol.go: Request/Response types with 13 operations
- internal/rpc/server.go: Unix socket server with storage adapter
- internal/rpc/client.go: Client with auto-detection and typed methods
- internal/rpc/rpc_test.go: Integration tests

Features:
- JSON-based protocol over Unix sockets
- Adapter pattern for context/actor propagation to storage API
- Ping/health checks for daemon detection
- All core operations: create, update, close, list, show, ready, stats, deps, labels
- Graceful socket cleanup and signal handling
- Concurrent request support

Tests: 49.3% coverage, all passing

Related issues:
- bd-110: Daemon architecture epic
- bd-111: Phase 1 (completed)
- bd-112: Phase 2 (client auto-detection)
- bd-113: Phase 3 (daemon command)
- bd-114: Phase 4 (atomic operations)

Amp-Thread-ID: https://ampcode.com/threads/T-796c62e6-93b6-41c7-9cb5-8acc4a35ba9a
Co-authored-by: Amp <amp@ampcode.com>

internal/rpc/server.go

@@ -7,259 +7,552 @@ import (
 	"fmt"
 	"net"
 	"os"
+	"os/signal"
+	"path/filepath"
 	"sync"
+	"syscall"
 
 	"github.com/steveyegge/beads/internal/storage"
+	"github.com/steveyegge/beads/internal/types"
 )
 
-// Server is the RPC server that handles requests from bd clients.
+// Server represents the RPC server that runs in the daemon
 type Server struct {
-	storage  storage.Storage
-	listener net.Listener
-	sockPath string
-	ctx      context.Context
-	cancel   context.CancelFunc
-	wg       sync.WaitGroup
-	mu       sync.Mutex // Protects shutdown state
-	shutdown bool
+	socketPath string
+	storage    storage.Storage
+	listener   net.Listener
+	mu         sync.Mutex
+	shutdown   bool
 }
 
-// NewServer creates a new RPC server.
-func NewServer(store storage.Storage, sockPath string) *Server {
-	ctx, cancel := context.WithCancel(context.Background())
+// NewServer creates a new RPC server
+func NewServer(socketPath string, store storage.Storage) *Server {
 	return &Server{
-		storage:  store,
-		sockPath: sockPath,
-		ctx:      ctx,
-		cancel:   cancel,
+		socketPath: socketPath,
+		storage:    store,
 	}
 }
 
-// Start starts the RPC server listening on the Unix socket.
-func (s *Server) Start() error {
-	if err := os.Remove(s.sockPath); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("failed to remove existing socket: %w", err)
+// Start starts the RPC server and listens for connections
+func (s *Server) Start(ctx context.Context) error {
+	if err := s.ensureSocketDir(); err != nil {
+		return fmt.Errorf("failed to ensure socket directory: %w", err)
 	}
 
-	listener, err := net.Listen("unix", s.sockPath)
+	if err := s.removeOldSocket(); err != nil {
+		return fmt.Errorf("failed to remove old socket: %w", err)
+	}
+
+	var err error
+	s.listener, err = net.Listen("unix", s.socketPath)
 	if err != nil {
-		return fmt.Errorf("failed to listen on socket %s: %w", s.sockPath, err)
-	}
-	s.listener = listener
-
-	if err := os.Chmod(s.sockPath, 0600); err != nil {
-		s.listener.Close()
-		return fmt.Errorf("failed to set socket permissions: %w", err)
+		return fmt.Errorf("failed to listen on socket: %w", err)
 	}
 
-	s.wg.Add(1)
-	go s.acceptLoop()
+	go s.handleSignals()
 
-	return nil
+	for {
+		conn, err := s.listener.Accept()
+		if err != nil {
+			s.mu.Lock()
+			shutdown := s.shutdown
+			s.mu.Unlock()
+			if shutdown {
+				return nil
+			}
+			return fmt.Errorf("failed to accept connection: %w", err)
+		}
+
+		go s.handleConnection(conn)
+	}
 }
 
-// Stop gracefully stops the RPC server.
+// Stop stops the RPC server and cleans up resources
 func (s *Server) Stop() error {
 	s.mu.Lock()
-	if s.shutdown {
-		s.mu.Unlock()
-		return nil
-	}
 	s.shutdown = true
 	s.mu.Unlock()
 
-	s.cancel()
-
 	if s.listener != nil {
-		s.listener.Close()
+		if err := s.listener.Close(); err != nil {
+			return fmt.Errorf("failed to close listener: %w", err)
+		}
 	}
 
-	s.wg.Wait()
-
-	if err := os.Remove(s.sockPath); err != nil && !os.IsNotExist(err) {
+	if err := s.removeOldSocket(); err != nil {
 		return fmt.Errorf("failed to remove socket: %w", err)
 	}
 
 	return nil
 }
 
-// acceptLoop accepts incoming connections and handles them.
-func (s *Server) acceptLoop() {
-	defer s.wg.Done()
-
-	for {
-		conn, err := s.listener.Accept()
-		if err != nil {
-			select {
-			case <-s.ctx.Done():
-				return
-			default:
-				fmt.Fprintf(os.Stderr, "Error accepting connection: %v\n", err)
-				continue
-			}
-		}
-
-		s.wg.Add(1)
-		go s.handleConnection(conn)
+func (s *Server) ensureSocketDir() error {
+	dir := filepath.Dir(s.socketPath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
 	}
+	return nil
+}
+
+func (s *Server) removeOldSocket() error {
+	if _, err := os.Stat(s.socketPath); err == nil {
+		if err := os.Remove(s.socketPath); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *Server) handleSignals() {
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	<-sigChan
+	s.Stop()
 }
 
-// handleConnection handles a single client connection.
 func (s *Server) handleConnection(conn net.Conn) {
-	defer s.wg.Done()
 	defer conn.Close()
 
-	scanner := bufio.NewScanner(conn)
+	reader := bufio.NewReader(conn)
 	writer := bufio.NewWriter(conn)
 
-	for scanner.Scan() {
-		select {
-		case <-s.ctx.Done():
+	for {
+		line, err := reader.ReadBytes('\n')
+		if err != nil {
 			return
-		default:
 		}
 
-		line := scanner.Bytes()
 		var req Request
 		if err := json.Unmarshal(line, &req); err != nil {
-			resp := NewErrorResponse(fmt.Errorf("invalid request JSON: %w", err))
-			s.sendResponse(writer, resp)
+			resp := Response{
+				Success: false,
+				Error:   fmt.Sprintf("invalid request: %v", err),
+			}
+			s.writeResponse(writer, resp)
 			continue
 		}
 
 		resp := s.handleRequest(&req)
-		s.sendResponse(writer, resp)
-	}
-
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error reading from connection: %v\n", err)
+		s.writeResponse(writer, resp)
 	}
 }
 
-// sendResponse sends a response to the client.
-func (s *Server) sendResponse(writer *bufio.Writer, resp *Response) {
-	respJSON, err := json.Marshal(resp)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error marshaling response: %v\n", err)
-		return
-	}
-
-	if _, err := writer.Write(respJSON); err != nil {
-		fmt.Fprintf(os.Stderr, "Error writing response: %v\n", err)
-		return
-	}
-	if _, err := writer.Write([]byte("\n")); err != nil {
-		fmt.Fprintf(os.Stderr, "Error writing newline: %v\n", err)
-		return
-	}
-	if err := writer.Flush(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error flushing response: %v\n", err)
-	}
-}
-
-// handleRequest processes an RPC request and returns a response.
-func (s *Server) handleRequest(req *Request) *Response {
-	ctx := context.Background()
-
+func (s *Server) handleRequest(req *Request) Response {
 	switch req.Operation {
-	case OpBatch:
-		return s.handleBatch(ctx, req)
+	case OpPing:
+		return s.handlePing(req)
 	case OpCreate:
-		return s.handleCreate(ctx, req)
+		return s.handleCreate(req)
 	case OpUpdate:
-		return s.handleUpdate(ctx, req)
+		return s.handleUpdate(req)
 	case OpClose:
-		return s.handleClose(ctx, req)
+		return s.handleClose(req)
 	case OpList:
-		return s.handleList(ctx, req)
+		return s.handleList(req)
 	case OpShow:
-		return s.handleShow(ctx, req)
+		return s.handleShow(req)
 	case OpReady:
-		return s.handleReady(ctx, req)
-	case OpBlocked:
-		return s.handleBlocked(ctx, req)
+		return s.handleReady(req)
 	case OpStats:
-		return s.handleStats(ctx, req)
+		return s.handleStats(req)
 	case OpDepAdd:
-		return s.handleDepAdd(ctx, req)
+		return s.handleDepAdd(req)
 	case OpDepRemove:
-		return s.handleDepRemove(ctx, req)
-	case OpDepTree:
-		return s.handleDepTree(ctx, req)
+		return s.handleDepRemove(req)
 	case OpLabelAdd:
-		return s.handleLabelAdd(ctx, req)
+		return s.handleLabelAdd(req)
 	case OpLabelRemove:
-		return s.handleLabelRemove(ctx, req)
-	case OpLabelList:
-		return s.handleLabelList(ctx, req)
-	case OpLabelListAll:
-		return s.handleLabelListAll(ctx, req)
+		return s.handleLabelRemove(req)
 	default:
-		return NewErrorResponse(fmt.Errorf("unknown operation: %s", req.Operation))
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("unknown operation: %s", req.Operation),
+		}
 	}
 }
 
-// Placeholder handlers - will be implemented in future commits
-func (s *Server) handleBatch(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("batch operation not yet implemented"))
+// Adapter helpers
+func (s *Server) reqCtx(_ *Request) context.Context {
+	return context.Background()
 }
 
-func (s *Server) handleCreate(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("create operation not yet implemented"))
+func (s *Server) reqActor(req *Request) string {
+	if req != nil && req.Actor != "" {
+		return req.Actor
+	}
+	return "daemon"
 }
 
-func (s *Server) handleUpdate(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("update operation not yet implemented"))
+func strValue(p *string) string {
+	if p == nil {
+		return ""
+	}
+	return *p
 }
 
-func (s *Server) handleClose(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("close operation not yet implemented"))
+func strPtr(s string) *string {
+	if s == "" {
+		return nil
+	}
+	return &s
 }
 
-func (s *Server) handleList(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("list operation not yet implemented"))
+func updatesFromArgs(a UpdateArgs) map[string]interface{} {
+	u := map[string]interface{}{}
+	if a.Title != nil {
+		u["title"] = *a.Title
+	}
+	if a.Status != nil {
+		u["status"] = *a.Status
+	}
+	if a.Priority != nil {
+		u["priority"] = *a.Priority
+	}
+	if a.Design != nil {
+		u["design"] = a.Design
+	}
+	if a.AcceptanceCriteria != nil {
+		u["acceptance_criteria"] = a.AcceptanceCriteria
+	}
+	if a.Notes != nil {
+		u["notes"] = a.Notes
+	}
+	if a.Assignee != nil {
+		u["assignee"] = a.Assignee
+	}
+	return u
 }
 
-func (s *Server) handleShow(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("show operation not yet implemented"))
+// Handler implementations
+
+func (s *Server) handlePing(_ *Request) Response {
+	data, _ := json.Marshal(PingResponse{
+		Message: "pong",
+		Version: "0.9.8",
+	})
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleReady(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("ready operation not yet implemented"))
+func (s *Server) handleCreate(req *Request) Response {
+	var createArgs CreateArgs
+	if err := json.Unmarshal(req.Args, &createArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid create args: %v", err),
+		}
+	}
+
+	var design, acceptance, assignee *string
+	if createArgs.Design != "" {
+		design = &createArgs.Design
+	}
+	if createArgs.AcceptanceCriteria != "" {
+		acceptance = &createArgs.AcceptanceCriteria
+	}
+	if createArgs.Assignee != "" {
+		assignee = &createArgs.Assignee
+	}
+
+	issue := &types.Issue{
+		ID:                 createArgs.ID,
+		Title:              createArgs.Title,
+		Description:        createArgs.Description,
+		IssueType:          types.IssueType(createArgs.IssueType),
+		Priority:           createArgs.Priority,
+		Design:             strValue(design),
+		AcceptanceCriteria: strValue(acceptance),
+		Assignee:           strValue(assignee),
+		Status:             types.StatusOpen,
+	}
+
+	ctx := s.reqCtx(req)
+	if err := s.storage.CreateIssue(ctx, issue, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to create issue: %v", err),
+		}
+	}
+
+	data, _ := json.Marshal(issue)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleBlocked(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("blocked operation not yet implemented"))
+func (s *Server) handleUpdate(req *Request) Response {
+	var updateArgs UpdateArgs
+	if err := json.Unmarshal(req.Args, &updateArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid update args: %v", err),
+		}
+	}
+
+	ctx := s.reqCtx(req)
+	updates := updatesFromArgs(updateArgs)
+	if len(updates) == 0 {
+		return Response{Success: true}
+	}
+
+	if err := s.storage.UpdateIssue(ctx, updateArgs.ID, updates, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to update issue: %v", err),
+		}
+	}
+
+	issue, err := s.storage.GetIssue(ctx, updateArgs.ID)
+	if err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get updated issue: %v", err),
+		}
+	}
+
+	data, _ := json.Marshal(issue)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleStats(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("stats operation not yet implemented"))
+func (s *Server) handleClose(req *Request) Response {
+	var closeArgs CloseArgs
+	if err := json.Unmarshal(req.Args, &closeArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid close args: %v", err),
+		}
+	}
+
+	ctx := s.reqCtx(req)
+	if err := s.storage.CloseIssue(ctx, closeArgs.ID, closeArgs.Reason, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to close issue: %v", err),
+		}
+	}
+
+	issue, _ := s.storage.GetIssue(ctx, closeArgs.ID)
+	data, _ := json.Marshal(issue)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleDepAdd(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("dep_add operation not yet implemented"))
+func (s *Server) handleList(req *Request) Response {
+	var listArgs ListArgs
+	if err := json.Unmarshal(req.Args, &listArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid list args: %v", err),
+		}
+	}
+
+	filter := types.IssueFilter{
+		Limit: listArgs.Limit,
+	}
+	if listArgs.Status != "" {
+		status := types.Status(listArgs.Status)
+		filter.Status = &status
+	}
+	if listArgs.IssueType != "" {
+		issueType := types.IssueType(listArgs.IssueType)
+		filter.IssueType = &issueType
+	}
+	if listArgs.Assignee != "" {
+		filter.Assignee = &listArgs.Assignee
+	}
+	if listArgs.Priority != nil {
+		filter.Priority = listArgs.Priority
+	}
+
+	ctx := s.reqCtx(req)
+	issues, err := s.storage.SearchIssues(ctx, listArgs.Query, filter)
+	if err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to list issues: %v", err),
+		}
+	}
+
+	data, _ := json.Marshal(issues)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleDepRemove(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("dep_remove operation not yet implemented"))
+func (s *Server) handleShow(req *Request) Response {
+	var showArgs ShowArgs
+	if err := json.Unmarshal(req.Args, &showArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid show args: %v", err),
+		}
+	}
+
+	ctx := s.reqCtx(req)
+	issue, err := s.storage.GetIssue(ctx, showArgs.ID)
+	if err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get issue: %v", err),
+		}
+	}
+
+	data, _ := json.Marshal(issue)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleDepTree(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("dep_tree operation not yet implemented"))
+func (s *Server) handleReady(req *Request) Response {
+	var readyArgs ReadyArgs
+	if err := json.Unmarshal(req.Args, &readyArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid ready args: %v", err),
+		}
+	}
+
+	wf := types.WorkFilter{
+		Status:   types.StatusOpen,
+		Priority: readyArgs.Priority,
+		Limit:    readyArgs.Limit,
+	}
+	if readyArgs.Assignee != "" {
+		wf.Assignee = &readyArgs.Assignee
+	}
+
+	ctx := s.reqCtx(req)
+	issues, err := s.storage.GetReadyWork(ctx, wf)
+	if err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get ready work: %v", err),
+		}
+	}
+
+	data, _ := json.Marshal(issues)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleLabelAdd(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("label_add operation not yet implemented"))
+func (s *Server) handleStats(req *Request) Response {
+	ctx := s.reqCtx(req)
+	stats, err := s.storage.GetStatistics(ctx)
+	if err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to get statistics: %v", err),
+		}
+	}
+
+	data, _ := json.Marshal(stats)
+	return Response{
+		Success: true,
+		Data:    data,
+	}
 }
 
-func (s *Server) handleLabelRemove(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("label_remove operation not yet implemented"))
+func (s *Server) handleDepAdd(req *Request) Response {
+	var depArgs DepAddArgs
+	if err := json.Unmarshal(req.Args, &depArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid dep add args: %v", err),
+		}
+	}
+
+	dep := &types.Dependency{
+		IssueID:     depArgs.FromID,
+		DependsOnID: depArgs.ToID,
+		Type:        types.DependencyType(depArgs.DepType),
+	}
+
+	ctx := s.reqCtx(req)
+	if err := s.storage.AddDependency(ctx, dep, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to add dependency: %v", err),
+		}
+	}
+
+	return Response{Success: true}
 }
 
-func (s *Server) handleLabelList(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("label_list operation not yet implemented"))
+func (s *Server) handleDepRemove(req *Request) Response {
+	var depArgs DepRemoveArgs
+	if err := json.Unmarshal(req.Args, &depArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid dep remove args: %v", err),
+		}
+	}
+
+	ctx := s.reqCtx(req)
+	if err := s.storage.RemoveDependency(ctx, depArgs.FromID, depArgs.ToID, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to remove dependency: %v", err),
+		}
+	}
+
+	return Response{Success: true}
 }
 
-func (s *Server) handleLabelListAll(ctx context.Context, req *Request) *Response {
-	return NewErrorResponse(fmt.Errorf("label_list_all operation not yet implemented"))
+func (s *Server) handleLabelAdd(req *Request) Response {
+	var labelArgs LabelAddArgs
+	if err := json.Unmarshal(req.Args, &labelArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid label add args: %v", err),
+		}
+	}
+
+	ctx := s.reqCtx(req)
+	if err := s.storage.AddLabel(ctx, labelArgs.ID, labelArgs.Label, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to add label: %v", err),
+		}
+	}
+
+	return Response{Success: true}
+}
+
+func (s *Server) handleLabelRemove(req *Request) Response {
+	var labelArgs LabelRemoveArgs
+	if err := json.Unmarshal(req.Args, &labelArgs); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("invalid label remove args: %v", err),
+		}
+	}
+
+	ctx := s.reqCtx(req)
+	if err := s.storage.RemoveLabel(ctx, labelArgs.ID, labelArgs.Label, s.reqActor(req)); err != nil {
+		return Response{
+			Success: false,
+			Error:   fmt.Sprintf("failed to remove label: %v", err),
+		}
+	}
+
+	return Response{Success: true}
+}
+
+func (s *Server) writeResponse(writer *bufio.Writer, resp Response) {
+	data, _ := json.Marshal(resp)
+	writer.Write(data)
+	writer.WriteByte('\n')
+	writer.Flush()
 }