diff --git a/internal/mail/mailbox.go b/internal/mail/mailbox.go index 8e240575..ceb3a774 100644 --- a/internal/mail/mailbox.go +++ b/internal/mail/mailbox.go @@ -22,6 +22,7 @@ var ( type Mailbox struct { identity string // beads identity (e.g., "gastown-Toast") workDir string // directory to run bd commands in + beadsDir string // explicit .beads directory path (set via BEADS_DIR) path string // for legacy JSONL mode (crew workers) legacy bool // true = use JSONL files, false = use beads } @@ -45,12 +46,22 @@ func NewMailboxBeads(identity, workDir string) *Mailbox { } // NewMailboxFromAddress creates a beads-backed mailbox from a GGT address. -// The address is stored as-is (not converted to identity) to match how -// messages are stored with their assignee field. func NewMailboxFromAddress(address, workDir string) *Mailbox { + beadsDir := filepath.Join(workDir, ".beads") return &Mailbox{ - identity: address, // Use address directly, not identity format + identity: addressToIdentity(address), workDir: workDir, + beadsDir: beadsDir, + legacy: false, + } +} + +// NewMailboxWithBeadsDir creates a mailbox with an explicit beads directory. +func NewMailboxWithBeadsDir(address, workDir, beadsDir string) *Mailbox { + return &Mailbox{ + identity: addressToIdentity(address), + workDir: workDir, + beadsDir: beadsDir, legacy: false, } } @@ -74,13 +85,13 @@ func (m *Mailbox) List() ([]*Message, error) { } func (m *Mailbox) listBeads() ([]*Message, error) { - // bd list --type=message --assignee= --status=open --json - cmd := exec.Command("bd", "list", - "--type", "message", - "--assignee", m.identity, - "--status", "open", - "--json") + // bd mail inbox --json + cmd := exec.Command("bd", "mail", "inbox", "--json") cmd.Dir = m.workDir + cmd.Env = append(cmd.Environ(), + "BD_IDENTITY="+m.identity, + "BEADS_DIR="+m.beadsDir, + ) var stdout, stderr bytes.Buffer cmd.Stdout = &stdout @@ -104,14 +115,6 @@ func (m *Mailbox) listBeads() ([]*Message, error) { return nil, err } - // Sort pinned messages first, then by timestamp (newest first) - sort.Slice(beadsMsgs, func(i, j int) bool { - if beadsMsgs[i].Pinned != beadsMsgs[j].Pinned { - return beadsMsgs[i].Pinned // pinned comes first - } - return beadsMsgs[i].CreatedAt.After(beadsMsgs[j].CreatedAt) - }) - // Convert to GGT messages var messages []*Message for _, bm := range beadsMsgs { @@ -186,9 +189,9 @@ func (m *Mailbox) Get(id string) (*Message, error) { } func (m *Mailbox) getBeads(id string) (*Message, error) { - // bd show --json returns an array with one element - cmd := exec.Command("bd", "show", id, "--json") + cmd := exec.Command("bd", "mail", "read", id, "--json") cmd.Dir = m.workDir + cmd.Env = append(cmd.Environ(), "BEADS_DIR="+m.beadsDir) var stdout, stderr bytes.Buffer cmd.Stdout = &stdout @@ -205,16 +208,12 @@ func (m *Mailbox) getBeads(id string) (*Message, error) { return nil, err } - // bd show returns an array with one element - var beadsMsgs []BeadsMessage - if err := json.Unmarshal(stdout.Bytes(), &beadsMsgs); err != nil { + var bm BeadsMessage + if err := json.Unmarshal(stdout.Bytes(), &bm); err != nil { return nil, err } - if len(beadsMsgs) == 0 { - return nil, ErrMessageNotFound - } - return beadsMsgs[0].ToMessage(), nil + return bm.ToMessage(), nil } func (m *Mailbox) getLegacy(id string) (*Message, error) { @@ -239,9 +238,9 @@ func (m *Mailbox) MarkRead(id string) error { } func (m *Mailbox) markReadBeads(id string) error { - // bd close marks the message as read - cmd := exec.Command("bd", "close", id, "--reason", "Message read") + cmd := exec.Command("bd", "mail", "ack", id) cmd.Dir = m.workDir + cmd.Env = append(cmd.Environ(), "BEADS_DIR="+m.beadsDir) var stderr bytes.Buffer cmd.Stderr = &stderr @@ -408,12 +407,13 @@ func (m *Mailbox) ListByThread(threadID string) ([]*Message, error) { } func (m *Mailbox) listByThreadBeads(threadID string) ([]*Message, error) { - // bd list --type=message --label=thread: --json - cmd := exec.Command("bd", "list", - "--type", "message", - "--label", "thread:"+threadID, - "--json") + // bd message thread --json + cmd := exec.Command("bd", "message", "thread", threadID, "--json") cmd.Dir = m.workDir + cmd.Env = append(cmd.Environ(), + "BD_IDENTITY="+m.identity, + "BEADS_DIR="+m.beadsDir, + ) var stdout, stderr bytes.Buffer cmd.Stdout = &stdout diff --git a/internal/mail/router.go b/internal/mail/router.go index d0910164..37646ef4 100644 --- a/internal/mail/router.go +++ b/internal/mail/router.go @@ -4,72 +4,143 @@ import ( "bytes" "errors" "fmt" + "os" "os/exec" + "path/filepath" "strings" "github.com/steveyegge/gastown/internal/tmux" ) // Router handles message delivery via beads. +// It routes messages to the correct beads database based on address: +// - Town-level (mayor/, deacon/) -> {townRoot}/.beads +// - Rig-level (rig/polecat) -> {townRoot}/{rig}/.beads type Router struct { - workDir string // directory to run bd commands in - tmux *tmux.Tmux + workDir string // fallback directory to run bd commands in + townRoot string // town root directory (e.g., ~/gt) + tmux *tmux.Tmux } // NewRouter creates a new mail router. // workDir should be a directory containing a .beads database. +// The town root is auto-detected from workDir if possible. func NewRouter(workDir string) *Router { + // Try to detect town root from workDir + townRoot := detectTownRoot(workDir) + return &Router{ - workDir: workDir, - tmux: tmux.NewTmux(), + workDir: workDir, + townRoot: townRoot, + tmux: tmux.NewTmux(), } } -// Send delivers a message via beads issue creation. -// Messages are stored as beads issues with type=message. -func (r *Router) Send(msg *Message) error { - // Use address directly for assignee (maintains compatibility with old messages) - // The from address is converted to identity format for the labels - fromIdentity := addressToIdentity(msg.From) +// NewRouterWithTownRoot creates a router with an explicit town root. +func NewRouterWithTownRoot(workDir, townRoot string) *Router { + return &Router{ + workDir: workDir, + townRoot: townRoot, + tmux: tmux.NewTmux(), + } +} - // Build command: bd create --type=message --title="subject" --assignee=recipient - // Assignee uses the original address format to match how bd mail stored them - args := []string{"create", - "--type", "message", - "--title", msg.Subject, - "--assignee", msg.To, +// detectTownRoot finds the town root by looking for mayor/town.json. +func detectTownRoot(startDir string) string { + dir := startDir + for { + // Check for primary marker (mayor/town.json) + markerPath := filepath.Join(dir, "mayor", "town.json") + if _, err := os.Stat(markerPath); err == nil { + return dir + } + + // Move up + parent := filepath.Dir(dir) + if parent == dir { + break + } + dir = parent + } + return "" +} + +// resolveBeadsDir returns the correct .beads directory for the given address. +// Town-level addresses (mayor/, deacon/) use {townRoot}/.beads. +// Rig-level addresses (rig/polecat) use {townRoot}/{rig}/.beads. +func (r *Router) resolveBeadsDir(address string) string { + // If no town root, fall back to workDir's .beads + if r.townRoot == "" { + return filepath.Join(r.workDir, ".beads") } - // Add body if present - if msg.Body != "" { - args = append(args, "--description", msg.Body) + // Town-level agents: mayor/, deacon/ + if isTownLevelAddress(address) { + return filepath.Join(r.townRoot, ".beads") + } + + // Rig-level addresses: rig/polecat, rig/refinery + parts := strings.SplitN(address, "/", 2) + if len(parts) >= 1 && parts[0] != "" { + rig := parts[0] + rigBeadsDir := filepath.Join(r.townRoot, rig, ".beads") + // Check if rig beads exists + if _, err := os.Stat(rigBeadsDir); err == nil { + return rigBeadsDir + } + } + + // Fall back to town-level beads + return filepath.Join(r.townRoot, ".beads") +} + +// isTownLevelAddress returns true if the address is for a town-level agent. +func isTownLevelAddress(address string) bool { + addr := strings.TrimSuffix(address, "/") + return addr == "mayor" || addr == "deacon" +} + +// Send delivers a message via beads message. +// Routes the message to the correct beads database based on recipient address. +func (r *Router) Send(msg *Message) error { + // Convert addresses to beads identities + toIdentity := addressToIdentity(msg.To) + fromIdentity := addressToIdentity(msg.From) + + // Build command: bd mail send -s -m + args := []string{"mail", "send", toIdentity, + "-s", msg.Subject, + "-m", msg.Body, } // Add priority flag beadsPriority := PriorityToBeads(msg.Priority) args = append(args, "--priority", fmt.Sprintf("%d", beadsPriority)) - // Build labels for metadata (from, thread-id, reply-to, message-type) - var labels []string - labels = append(labels, "from:"+fromIdentity) - - if msg.ThreadID != "" { - labels = append(labels, "thread:"+msg.ThreadID) - } - if msg.ReplyTo != "" { - labels = append(labels, "reply-to:"+msg.ReplyTo) - } + // Add message type if set if msg.Type != "" && msg.Type != TypeNotification { - labels = append(labels, "msg-type:"+string(msg.Type)) + args = append(args, "--type", string(msg.Type)) } - if len(labels) > 0 { - args = append(args, "--labels", strings.Join(labels, ",")) + // Add thread ID if set + if msg.ThreadID != "" { + args = append(args, "--thread-id", msg.ThreadID) } + // Add reply-to if set + if msg.ReplyTo != "" { + args = append(args, "--reply-to", msg.ReplyTo) + } + + // Resolve the correct beads directory for the recipient + beadsDir := r.resolveBeadsDir(msg.To) + cmd := exec.Command("bd", args...) - cmd.Env = append(cmd.Environ(), "BEADS_AGENT_NAME="+fromIdentity) - cmd.Dir = r.workDir + cmd.Env = append(cmd.Environ(), + "BEADS_AGENT_NAME="+fromIdentity, + "BEADS_DIR="+beadsDir, + ) + cmd.Dir = filepath.Dir(beadsDir) // Run in parent of .beads var stderr bytes.Buffer cmd.Stderr = &stderr @@ -89,8 +160,11 @@ func (r *Router) Send(msg *Message) error { } // GetMailbox returns a Mailbox for the given address. +// Routes to the correct beads database based on the address. func (r *Router) GetMailbox(address string) (*Mailbox, error) { - return NewMailboxFromAddress(address, r.workDir), nil + beadsDir := r.resolveBeadsDir(address) + workDir := filepath.Dir(beadsDir) // Parent of .beads + return NewMailboxFromAddress(address, workDir), nil } // notifyRecipient sends a notification to a recipient's tmux session. diff --git a/internal/polecat/manager.go b/internal/polecat/manager.go index 07f92e0a..dd022862 100644 --- a/internal/polecat/manager.go +++ b/internal/polecat/manager.go @@ -139,12 +139,12 @@ func (m *Manager) Add(name string) (*Polecat, error) { } } - // Create beads redirect to share rig-level beads database - // This eliminates git sync overhead - all polecats use same daemon - if err := m.createBeadsRedirect(polecatPath); err != nil { - // Non-fatal - polecat can still work with its own .beads/ if needed + // Set up shared beads: polecat uses rig's .beads via redirect file. + // This eliminates git sync overhead - all polecats share one database. + if err := m.setupSharedBeads(polecatPath); err != nil { + // Non-fatal - polecat can still work with local beads // Log warning but don't fail the spawn - fmt.Fprintf(os.Stderr, "Warning: could not create beads redirect: %v\n", err) + fmt.Printf("Warning: could not set up shared beads: %v\n", err) } // Return polecat with derived state (no issue assigned yet = idle) @@ -522,47 +522,37 @@ func (m *Manager) loadFromBeads(name string) (*Polecat, error) { }, nil } -// createBeadsRedirect creates a .beads/redirect file in the polecat directory -// that points to the rig-level shared beads database. This eliminates the need -// for git sync between polecats - they all share the same daemon and database. +// setupSharedBeads creates a redirect file so the polecat uses the rig's shared .beads database. +// This eliminates the need for git sync between polecat clones - all polecats share one database. // -// Directory structure: -// gastown/ -// .beads/ <- Shared database (created if missing) -// polecats/ -// nux/ -// .beads/ -// redirect <- Contains "../../.beads" -func (m *Manager) createBeadsRedirect(polecatPath string) error { - // Rig-level beads path - rigBeadsPath := filepath.Join(m.rig.Path, ".beads") - - // Ensure rig-level .beads/ exists - if _, err := os.Stat(rigBeadsPath); os.IsNotExist(err) { - // Initialize rig-level beads if it doesn't exist - // This creates the database and config - if err := os.MkdirAll(rigBeadsPath, 0755); err != nil { - return fmt.Errorf("creating rig beads dir: %w", err) - } - // Note: bd will auto-initialize when first used +// Structure: +// +// rig/ +// .beads/ <- Shared database (ensured to exist) +// polecats/ +// / +// .beads/ +// redirect <- Contains "../../.beads" +func (m *Manager) setupSharedBeads(polecatPath string) error { + // Ensure rig root has .beads/ directory + rigBeadsDir := filepath.Join(m.rig.Path, ".beads") + if err := os.MkdirAll(rigBeadsDir, 0755); err != nil { + return fmt.Errorf("creating rig .beads dir: %w", err) } - // Create polecat .beads directory - polecatBeadsPath := filepath.Join(polecatPath, ".beads") - if err := os.MkdirAll(polecatBeadsPath, 0755); err != nil { - return fmt.Errorf("creating polecat beads dir: %w", err) + // Create polecat's .beads directory + polecatBeadsDir := filepath.Join(polecatPath, ".beads") + if err := os.MkdirAll(polecatBeadsDir, 0755); err != nil { + return fmt.Errorf("creating polecat .beads dir: %w", err) } - // Calculate relative path from polecat to rig beads - // polecatPath is like: /polecats/ - // rigBeadsPath is like: /.beads - // So relative path is: ../../.beads - redirectPath := filepath.Join(polecatBeadsPath, "redirect") - relativePath := "../../.beads" + // Create redirect file pointing to rig's .beads + // Path is relative from polecats//.beads/ to rig/.beads/ + redirectPath := filepath.Join(polecatBeadsDir, "redirect") + redirectContent := "../../.beads\n" - // Write redirect file - if err := os.WriteFile(redirectPath, []byte(relativePath+"\n"), 0644); err != nil { - return fmt.Errorf("writing redirect file: %w", err) + if err := os.WriteFile(redirectPath, []byte(redirectContent), 0644); err != nil { + return fmt.Errorf("creating redirect file: %w", err) } return nil