WIP: Save agent roles integration work before CHORUS rebrand

- Agent roles and coordination features
- Chat API integration testing
- New configuration and workspace management

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

vendor/github.com/koron/go-ssdp/advertise.go

@@ -0,0 +1,185 @@
+package ssdp
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"sync"
+
+	"github.com/koron/go-ssdp/internal/multicast"
+	"github.com/koron/go-ssdp/internal/ssdplog"
+)
+
+type message struct {
+	to   net.Addr
+	data multicast.DataProvider
+}
+
+// Advertiser is a server to advertise a service.
+type Advertiser struct {
+	st      string
+	usn     string
+	locProv LocationProvider
+	server  string
+	maxAge  int
+
+	conn *multicast.Conn
+	ch   chan *message
+	wg   sync.WaitGroup
+	wgS  sync.WaitGroup
+}
+
+// Advertise starts advertisement of service.
+// location should be a string or a ssdp.LocationProvider.
+func Advertise(st, usn string, location interface{}, server string, maxAge int) (*Advertiser, error) {
+	locProv, err := toLocationProvider(location)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := multicast.Listen(multicast.RecvAddrResolver)
+	if err != nil {
+		return nil, err
+	}
+	ssdplog.Printf("SSDP advertise on: %s", conn.LocalAddr().String())
+	a := &Advertiser{
+		st:      st,
+		usn:     usn,
+		locProv: locProv,
+		server:  server,
+		maxAge:  maxAge,
+		conn:    conn,
+		ch:      make(chan *message),
+	}
+	a.wg.Add(2)
+	a.wgS.Add(1)
+	go func() {
+		a.sendMain()
+		a.wgS.Done()
+		a.wg.Done()
+	}()
+	go func() {
+		a.recvMain()
+		a.wg.Done()
+	}()
+	return a, nil
+}
+
+func (a *Advertiser) recvMain() error {
+	// TODO: update listening interfaces of a.conn
+	err := a.conn.ReadPackets(0, func(addr net.Addr, data []byte) error {
+		if err := a.handleRaw(addr, data); err != nil {
+			ssdplog.Printf("failed to handle message: %s", err)
+		}
+		return nil
+	})
+	if err != nil && err != io.EOF {
+		return err
+	}
+	return nil
+}
+
+func (a *Advertiser) sendMain() {
+	for msg := range a.ch {
+		_, err := a.conn.WriteTo(msg.data, msg.to)
+		if err != nil {
+			ssdplog.Printf("failed to send: %s", err)
+		}
+	}
+}
+
+func (a *Advertiser) handleRaw(from net.Addr, raw []byte) error {
+	if !bytes.HasPrefix(raw, []byte("M-SEARCH ")) {
+		// unexpected method.
+		return nil
+	}
+	req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(raw)))
+	if err != nil {
+		return err
+	}
+	var (
+		man = req.Header.Get("MAN")
+		st  = req.Header.Get("ST")
+	)
+	if man != `"ssdp:discover"` {
+		return fmt.Errorf("unexpected MAN: %s", man)
+	}
+	if st != All && st != RootDevice && st != a.st {
+		// skip when ST is not matched/expected.
+		return nil
+	}
+	ssdplog.Printf("received M-SEARCH MAN=%s ST=%s from %s", man, st, from.String())
+	// build and send a response.
+	msg := buildOK(a.st, a.usn, a.locProv.Location(from, nil), a.server, a.maxAge)
+	a.ch <- &message{to: from, data: multicast.BytesDataProvider(msg)}
+	return nil
+}
+
+func buildOK(st, usn, location, server string, maxAge int) []byte {
+	// bytes.Buffer#Write() is never fail, so we can omit error checks.
+	b := new(bytes.Buffer)
+	b.WriteString("HTTP/1.1 200 OK\r\n")
+	fmt.Fprintf(b, "EXT: \r\n")
+	fmt.Fprintf(b, "ST: %s\r\n", st)
+	fmt.Fprintf(b, "USN: %s\r\n", usn)
+	if location != "" {
+		fmt.Fprintf(b, "LOCATION: %s\r\n", location)
+	}
+	if server != "" {
+		fmt.Fprintf(b, "SERVER: %s\r\n", server)
+	}
+	fmt.Fprintf(b, "CACHE-CONTROL: max-age=%d\r\n", maxAge)
+	b.WriteString("\r\n")
+	return b.Bytes()
+}
+
+// Close stops advertisement.
+func (a *Advertiser) Close() error {
+	if a.conn != nil {
+		// closing order is very important. be careful to change:
+		// stop sending loop by closing the channel and wait it.
+		close(a.ch)
+		a.wgS.Wait()
+		// stop receiving loop by closing the connection.
+		a.conn.Close()
+		a.wg.Wait()
+		a.conn = nil
+	}
+	return nil
+}
+
+// Alive announces ssdp:alive message.
+func (a *Advertiser) Alive() error {
+	addr, err := multicast.SendAddr()
+	if err != nil {
+		return err
+	}
+	msg := &aliveDataProvider{
+		host:     addr,
+		nt:       a.st,
+		usn:      a.usn,
+		location: a.locProv,
+		server:   a.server,
+		maxAge:   a.maxAge,
+	}
+	a.ch <- &message{to: addr, data: msg}
+	ssdplog.Printf("sent alive")
+	return nil
+}
+
+// Bye announces ssdp:byebye message.
+func (a *Advertiser) Bye() error {
+	addr, err := multicast.SendAddr()
+	if err != nil {
+		return err
+	}
+	msg, err := buildBye(addr, a.st, a.usn)
+	if err != nil {
+		return err
+	}
+	a.ch <- &message{to: addr, data: multicast.BytesDataProvider(msg)}
+	ssdplog.Printf("sent bye")
+	return nil
+}