@awiki/cli 0.0.1-beta.2

package/internal/runtime/listener/server_test.go

@@ -0,0 +1,319 @@
+package listener
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/identity"
+	"github.com/agentconnect/awiki-cli/internal/store"
+	"github.com/coder/websocket"
+)
+
+func TestMessageRecordFromDirectIncomingUsesProtocolFieldsOnly(t *testing.T) {
+	t.Parallel()
+
+	notification := map[string]any{
+		"jsonrpc": "2.0",
+		"method":  "direct.incoming",
+		"params": map[string]any{
+			"meta": map[string]any{
+				"sender_did":   "did:wba:example.com:user:bob:e1_yyy",
+				"message_id":   "msg-001",
+				"created_at":   "2026-04-07T00:00:00Z",
+				"content_type": "text/plain",
+				"target": map[string]any{
+					"kind": "agent",
+					"did":  "did:wba:example.com:user:alice:e1_xxx",
+				},
+			},
+			"auth": map[string]any{
+				"scheme": "anp-rfc9421-origin-proof-v1",
+				"sender_proof": map[string]any{
+					"contentDigest":  "sha-256=:digest:",
+					"signatureInput": "sig1=(\"@method\");created=1;keyid=\"did:wba:example.com:user:bob:e1_yyy#key-1\"",
+					"signature":      "sig1=:signature:",
+				},
+			},
+			"body": map[string]any{
+				"text": "hello back",
+			},
+		},
+	}
+
+	record, ok := messageRecordFromDirectIncoming(notification, "alice")
+	if !ok {
+		t.Fatalf("messageRecordFromDirectIncoming() ok = false, want true")
+	}
+	if record.OwnerDID != "did:wba:example.com:user:alice:e1_xxx" {
+		t.Fatalf("record.OwnerDID = %q", record.OwnerDID)
+	}
+	if record.SenderDID != "did:wba:example.com:user:bob:e1_yyy" {
+		t.Fatalf("record.SenderDID = %q", record.SenderDID)
+	}
+	if record.SentAt != "2026-04-07T00:00:00Z" {
+		t.Fatalf("record.SentAt = %q", record.SentAt)
+	}
+	if !strings.Contains(record.Metadata, "anp-rfc9421-origin-proof-v1") {
+		t.Fatalf("record.Metadata = %q, want auth payload", record.Metadata)
+	}
+	if strings.Contains(record.Metadata, "\"server\"") {
+		t.Fatalf("record.Metadata = %q, should not depend on server wrapper", record.Metadata)
+	}
+}
+
+func TestMessageRecordFromDirectIncomingRejectsNonDirectNotification(t *testing.T) {
+	t.Parallel()
+
+	_, ok := messageRecordFromDirectIncoming(map[string]any{"method": "group.incoming"}, "alice")
+	if ok {
+		t.Fatalf("messageRecordFromDirectIncoming() ok = true, want false")
+	}
+}
+
+func TestMessageRecordFromGroupIncomingUsesProtocolFieldsOnly(t *testing.T) {
+	t.Parallel()
+
+	notification := map[string]any{
+		"jsonrpc": "2.0",
+		"method":  "group.incoming",
+		"params": map[string]any{
+			"meta": map[string]any{
+				"sender_did":   "did:wba:example.com:user:bob:e1_bob",
+				"message_id":   "msg-group-001",
+				"content_type": "text/plain",
+				"target": map[string]any{
+					"kind": "agent",
+					"did":  "did:wba:example.com:user:alice:e1_alice",
+				},
+			},
+			"body": map[string]any{
+				"text":            "hello group",
+				"group_did":       "did:wba:example.com:groups:demo:e1_group",
+				"group_event_seq": "5",
+				"accepted_at":     "2026-04-07T09:11:01Z",
+			},
+		},
+	}
+
+	record, ok := messageRecordFromGroupIncoming(notification, "alice")
+	if !ok {
+		t.Fatalf("messageRecordFromGroupIncoming() ok = false, want true")
+	}
+	if record.GroupDID != "did:wba:example.com:groups:demo:e1_group" {
+		t.Fatalf("record.GroupDID = %q", record.GroupDID)
+	}
+	if record.ThreadID != "group:did:wba:example.com:groups:demo:e1_group" {
+		t.Fatalf("record.ThreadID = %q", record.ThreadID)
+	}
+	if record.Content != "hello group" {
+		t.Fatalf("record.Content = %q", record.Content)
+	}
+}
+
+func TestRecordsFromGroupStateChangedBuildsMemberAndSystemMessage(t *testing.T) {
+	t.Parallel()
+
+	notification := map[string]any{
+		"jsonrpc": "2.0",
+		"method":  "group.state_changed",
+		"params": map[string]any{
+			"meta": map[string]any{
+				"target": map[string]any{
+					"kind": "agent",
+					"did":  "did:wba:example.com:user:alice:e1_alice",
+				},
+			},
+			"body": map[string]any{
+				"event_id":          "evt-3",
+				"group_did":         "did:wba:example.com:groups:demo:e1_group",
+				"group_event_seq":   "3",
+				"subject_method":    "group.remove",
+				"subject_did":       "did:wba:example.com:user:carol:e1_carol",
+				"actor_did":         "did:wba:example.com:user:alice:e1_alice",
+				"membership_status": "removed",
+				"changed_at":        "2026-04-07T09:06:01Z",
+			},
+		},
+	}
+
+	groupRecord, memberRecord, messageRecord, ok := recordsFromGroupStateChanged(notification, "alice")
+	if !ok {
+		t.Fatalf("recordsFromGroupStateChanged() ok = false, want true")
+	}
+	if groupRecord == nil || groupRecord.GroupDID != "did:wba:example.com:groups:demo:e1_group" {
+		t.Fatalf("groupRecord = %#v", groupRecord)
+	}
+	if memberRecord == nil || memberRecord.Status != "removed" {
+		t.Fatalf("memberRecord = %#v", memberRecord)
+	}
+	if messageRecord == nil || messageRecord.ContentType != "group_system_member_kicked" {
+		t.Fatalf("messageRecord = %#v", messageRecord)
+	}
+}
+
+func TestSessionLoopReconnectsAndStoresNotifications(t *testing.T) {
+	t.Parallel()
+
+	var connectionCount atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/ws" {
+			http.NotFound(w, r)
+			return
+		}
+		conn, err := websocket.Accept(w, r, nil)
+		if err != nil {
+			t.Errorf("websocket.Accept() error = %v", err)
+			return
+		}
+		defer conn.Close(websocket.StatusNormalClosure, "done")
+
+		index := connectionCount.Add(1)
+		payload := map[string]any{
+			"jsonrpc": "2.0",
+			"method":  "direct.incoming",
+			"params": map[string]any{
+				"meta": map[string]any{
+					"sender_did":   "did:wba:example.com:user:bob:e1_bob",
+					"message_id":   "msg-" + string(rune('0'+index)),
+					"created_at":   "2026-04-07T00:00:00Z",
+					"content_type": "text/plain",
+					"target": map[string]any{
+						"kind": "agent",
+						"did":  "did:wba:awiki.ai:user:alice:e1_alice",
+					},
+				},
+				"body": map[string]any{
+					"text": "hello-" + string(rune('0'+index)),
+				},
+			},
+		}
+		raw, err := json.Marshal(payload)
+		if err != nil {
+			t.Errorf("json.Marshal() error = %v", err)
+			return
+		}
+		writeCtx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
+		defer cancel()
+		if err := conn.Write(writeCtx, websocket.MessageText, raw); err != nil {
+			t.Errorf("conn.Write() error = %v", err)
+			return
+		}
+		if index == 1 {
+			return
+		}
+		<-r.Context().Done()
+	}))
+	defer server.Close()
+
+	resolved := testResolvedConfig(t, server.URL)
+	supervisor, err := NewSupervisor(resolved)
+	if err != nil {
+		t.Fatalf("NewSupervisor() error = %v", err)
+	}
+	defer supervisor.Close()
+
+	session, err := supervisor.ensureSession("alice")
+	if err != nil {
+		t.Fatalf("ensureSession() error = %v", err)
+	}
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		if connectionCount.Load() >= 2 {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("connectionCount = %d, want at least 2", connectionCount.Load())
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	if session.currentClient() == nil {
+		t.Fatalf("session.currentClient() = nil, want active client after reconnect")
+	}
+
+	db, err := store.Open(resolved.Paths)
+	if err != nil {
+		t.Fatalf("store.Open() error = %v", err)
+	}
+	defer db.Close()
+	deadline = time.Now().Add(10 * time.Second)
+	for {
+		var count int
+		row := db.QueryRow(`SELECT COUNT(*) FROM messages WHERE owner_did = ?`, "did:wba:awiki.ai:user:alice:e1_alice")
+		if scanErr := row.Scan(&count); scanErr != nil {
+			t.Fatalf("Scan() error = %v", scanErr)
+		}
+		if count >= 2 {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("stored message count = %d, want at least 2", count)
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+func testResolvedConfig(t *testing.T, messageServiceURL string) *appconfig.Resolved {
+	t.Helper()
+
+	root := t.TempDir()
+	manager := identity.NewManager(appconfig.Paths{
+		IdentityDir:          filepath.Join(root, "identities"),
+		LegacyCredentialsDir: filepath.Join(root, "legacy"),
+		DataDir:              filepath.Join(root, "data"),
+		StateDir:             filepath.Join(root, "state"),
+		DatabaseFile:         filepath.Join(root, "data", "awiki-cli.db"),
+	})
+	createTestIdentity(t, manager, identity.SaveInput{
+		IdentityName: "alice",
+		DisplayName:  "Alice",
+		Handle:       "alice",
+		UserID:       "user-alice-123",
+		JWTToken:     "token-123",
+	})
+	return &appconfig.Resolved{
+		Paths: appconfig.Paths{
+			IdentityDir:          filepath.Join(root, "identities"),
+			LegacyCredentialsDir: filepath.Join(root, "legacy"),
+			DataDir:              filepath.Join(root, "data"),
+			StateDir:             filepath.Join(root, "state"),
+			DatabaseFile:         filepath.Join(root, "data", "awiki-cli.db"),
+		},
+		UserServiceURL:      messageServiceURL,
+		MessageServiceURL:   messageServiceURL,
+		MessageServiceWSURL: messageServiceURL,
+		DIDDomain:           "awiki.ai",
+		RuntimeMode:         "websocket",
+		ActiveIdentity:      "alice",
+	}
+}
+
+func createTestIdentity(t *testing.T, manager *identity.Manager, input identity.SaveInput) {
+	t.Helper()
+
+	generated, err := identity.GenerateIdentity(identity.GenerateOptions{
+		Hostname:    "awiki.ai",
+		PathPrefix:  []string{"user"},
+		ProofDomain: "awiki.ai",
+	})
+	if err != nil {
+		t.Fatalf("GenerateIdentity() error = %v", err)
+	}
+	input.DID = "did:wba:awiki.ai:user:alice:e1_alice"
+	input.UniqueID = generated.UniqueID
+	input.DIDDocument = generated.DIDDocument
+	input.Key1PrivatePEM = generated.Key1PrivatePEM
+	input.Key1PublicPEM = generated.Key1PublicPEM
+	input.E2EESigningPrivatePEM = generated.E2EESigningPrivatePEM
+	input.E2EEAgreementPrivatePEM = generated.E2EEAgreementPrivatePEM
+	if _, err := manager.Save(input); err != nil {
+		t.Fatalf("Save() error = %v", err)
+	}
+}

package/internal/runtime/listener/sysproc_unix.go

@@ -0,0 +1,17 @@
+//go:build !windows
+// +build !windows
+
+package listener
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+// setSysProcAttr configures the child process attributes for Unix-like systems.
+// It is a no-op on Windows (see sysproc_windows.go).
+func setSysProcAttr(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true,
+	}
+}

package/internal/runtime/listener/sysproc_windows.go

@@ -0,0 +1,13 @@
+//go:build windows
+// +build windows
+
+package listener
+
+import "os/exec"
+
+// setSysProcAttr is a no-op on Windows. The listener supervisor is not yet
+// supported as a background service on this platform.
+func setSysProcAttr(cmd *exec.Cmd) {
+	// Intentionally empty.
+	_ = cmd
+}

package/internal/runtime/listener/types.go

@@ -0,0 +1,21 @@
+package listener
+
+type SessionStatus struct {
+	IdentityName string `json:"identity_name"`
+	DID          string `json:"did,omitempty"`
+	Connected    bool   `json:"connected"`
+	LastError    string `json:"last_error,omitempty"`
+}
+
+type Status struct {
+	Mode       string          `json:"mode"`
+	Running    bool            `json:"running"`
+	PID        int             `json:"pid,omitempty"`
+	PIDFile    string          `json:"pid_file,omitempty"`
+	SocketPath string          `json:"socket_path,omitempty"`
+	LogFile    string          `json:"log_file,omitempty"`
+	StatusFile string          `json:"status_file,omitempty"`
+	StartedAt  string          `json:"started_at,omitempty"`
+	Sessions   []SessionStatus `json:"sessions,omitempty"`
+	Warnings   []string        `json:"warnings,omitempty"`
+}

package/internal/runtime/listener/wsclient.go

@@ -0,0 +1,299 @@
+package listener
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/agentconnect/awiki-cli/internal/authsdk"
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/message"
+	"github.com/coder/websocket"
+)
+
+type WSClient struct {
+	requestURL    string
+	websocketURL  string
+	httpClient    *http.Client
+	auth          *authsdk.Session
+	conn          *websocket.Conn
+	nextID        int64
+	pendingMu     sync.Mutex
+	pending       map[string]chan map[string]any
+	notifications chan map[string]any
+	readerErr     atomic.Value
+	writeMu       sync.Mutex
+}
+
+func (c *WSClient) ReaderError() error {
+	if c == nil {
+		return nil
+	}
+	raw := c.readerErr.Load()
+	if raw == nil {
+		return nil
+	}
+	err, _ := raw.(error)
+	return err
+}
+
+func NewWSClient(resolved *appconfig.Resolved, auth *authsdk.Session) (*WSClient, error) {
+	if auth == nil {
+		return nil, fmt.Errorf("auth session is required for websocket mode")
+	}
+	targetHTTPURL := strings.TrimSpace(resolved.MessageServiceURL)
+	if targetHTTPURL == "" {
+		return nil, fmt.Errorf("message service url is required for websocket mode")
+	}
+	targetWSURL := strings.TrimSpace(resolved.MessageServiceWSURL)
+	if targetWSURL == "" {
+		targetWSURL = strings.Replace(targetHTTPURL, "https://", "wss://", 1)
+		targetWSURL = strings.Replace(targetWSURL, "http://", "ws://", 1)
+	}
+	targetHTTPURL = appendEndpointIfMissing(targetHTTPURL, message.MessageWSEndpoint)
+	targetWSURL = appendEndpointIfMissing(targetWSURL, message.MessageWSEndpoint)
+	return &WSClient{
+		requestURL:    targetHTTPURL,
+		websocketURL:  targetWSURL,
+		httpClient:    &http.Client{},
+		auth:          auth,
+		pending:       map[string]chan map[string]any{},
+		notifications: make(chan map[string]any, 128),
+	}, nil
+}
+
+func (c *WSClient) Connect(ctx context.Context) error {
+	if token := strings.TrimSpace(c.auth.CurrentJWT()); token != "" {
+		conn, response, err := c.dial(ctx, map[string]string{
+			"Authorization": "Bearer " + token,
+		})
+		if err == nil {
+			if response != nil {
+				c.auth.CaptureToken(c.requestURL, response.Header)
+			}
+			c.conn = conn
+			go c.readLoop()
+			return nil
+		}
+		if response == nil || response.StatusCode != http.StatusUnauthorized {
+			return formatDialError(err, response)
+		}
+	}
+	headers, err := c.auth.Headers(c.requestURL, http.MethodGet, nil, false)
+	if err != nil {
+		return err
+	}
+	conn, response, err := c.dial(ctx, headers)
+	if err != nil {
+		if response != nil && response.StatusCode == http.StatusUnauthorized {
+			var retryHeaders map[string]string
+			if c.auth.ShouldRetryAfter401(response.Header) {
+				retryHeaders, err = c.auth.ChallengeHeaders(c.requestURL, response.Header, http.MethodGet, nil)
+			} else {
+				c.auth.ClearToken(c.requestURL)
+				retryHeaders, err = c.auth.Headers(c.requestURL, http.MethodGet, nil, true)
+			}
+			if err != nil {
+				return err
+			}
+			conn, response, err = c.dial(ctx, retryHeaders)
+		}
+		if err != nil {
+			return formatDialError(err, response)
+		}
+	}
+	if response != nil {
+		c.auth.CaptureToken(c.requestURL, response.Header)
+	}
+	c.conn = conn
+	go c.readLoop()
+	return nil
+}
+
+func (c *WSClient) dial(ctx context.Context, headers map[string]string) (*websocket.Conn, *http.Response, error) {
+	httpHeaders := http.Header{}
+	for key, value := range headers {
+		httpHeaders.Set(key, value)
+	}
+	return websocket.Dial(ctx, c.websocketURL, &websocket.DialOptions{
+		HTTPClient:      c.httpClient,
+		HTTPHeader:      httpHeaders,
+		CompressionMode: websocket.CompressionDisabled,
+	})
+}
+
+func formatDialError(err error, response *http.Response) error {
+	if err == nil {
+		return nil
+	}
+	if response == nil || response.Body == nil {
+		return err
+	}
+	defer response.Body.Close()
+	raw, readErr := io.ReadAll(io.LimitReader(response.Body, 4096))
+	if readErr != nil || len(raw) == 0 {
+		return err
+	}
+	return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(raw)))
+}
+
+func appendEndpointIfMissing(base string, endpoint string) string {
+	trimmed := strings.TrimRight(strings.TrimSpace(base), "/")
+	if strings.HasSuffix(trimmed, endpoint) {
+		return trimmed
+	}
+	return trimmed + endpoint
+}
+
+func (c *WSClient) Close() error {
+	if c.conn == nil {
+		return nil
+	}
+	return c.conn.Close(websocket.StatusNormalClosure, "closing")
+}
+
+func (c *WSClient) Notifications() <-chan map[string]any {
+	return c.notifications
+}
+
+func (c *WSClient) SendRPC(ctx context.Context, method string, params map[string]any) (map[string]any, error) {
+	if c.conn == nil {
+		return nil, fmt.Errorf("websocket not connected")
+	}
+	id := atomic.AddInt64(&c.nextID, 1)
+	requestID := fmt.Sprintf("req-%d", id)
+	request := map[string]any{"jsonrpc": "2.0", "id": requestID, "method": method}
+	if params != nil {
+		request["params"] = params
+	}
+	responseCh := make(chan map[string]any, 1)
+	c.pendingMu.Lock()
+	c.pending[requestID] = responseCh
+	c.pendingMu.Unlock()
+	defer func() {
+		c.pendingMu.Lock()
+		delete(c.pending, requestID)
+		c.pendingMu.Unlock()
+	}()
+	c.writeMu.Lock()
+	err := wsjsonWrite(ctx, c.conn, request)
+	c.writeMu.Unlock()
+	if err != nil {
+		return nil, err
+	}
+	select {
+	case response := <-responseCh:
+		if errValue, ok := response["error"].(map[string]any); ok {
+			return nil, fmt.Errorf("json-rpc error %v: %v", errValue["code"], errValue["message"])
+		}
+		if result, ok := response["result"].(map[string]any); ok {
+			return result, nil
+		}
+		return map[string]any{}, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+func (c *WSClient) Ping(ctx context.Context) error {
+	if c.conn == nil {
+		return fmt.Errorf("websocket not connected")
+	}
+	return c.conn.Ping(ctx)
+}
+
+func (c *WSClient) readLoop() {
+	defer close(c.notifications)
+	for {
+		ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
+		var message map[string]any
+		err := wsjsonRead(ctx, c.conn, &message)
+		cancel()
+		if err != nil {
+			c.readerErr.Store(err)
+			c.failPending(err)
+			return
+		}
+		if rawID, ok := message["id"]; ok {
+			id := requestIDFromAny(rawID)
+			c.pendingMu.Lock()
+			responseCh := c.pending[id]
+			c.pendingMu.Unlock()
+			if responseCh != nil {
+				responseCh <- message
+			}
+			continue
+		}
+		select {
+		case c.notifications <- message:
+		default:
+		}
+	}
+}
+
+func (c *WSClient) failPending(err error) {
+	c.pendingMu.Lock()
+	defer c.pendingMu.Unlock()
+	for id, responseCh := range c.pending {
+		responseCh <- map[string]any{"error": map[string]any{"message": err.Error()}, "id": id}
+	}
+}
+
+func wsjsonWrite(ctx context.Context, conn *websocket.Conn, payload any) error {
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	return conn.Write(ctx, websocket.MessageText, raw)
+}
+
+func wsjsonRead(ctx context.Context, conn *websocket.Conn, out any) error {
+	_, raw, err := conn.Read(ctx)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(raw, out)
+}
+
+func requestIDFromAny(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return typed
+	case int64:
+		return fmt.Sprintf("%d", typed)
+	case int:
+		return fmt.Sprintf("%d", typed)
+	case float64:
+		return fmt.Sprintf("%.0f", typed)
+	default:
+		return ""
+	}
+}
+
+func int64FromAny(value any) int64 {
+	switch typed := value.(type) {
+	case int64:
+		return typed
+	case int:
+		return int64(typed)
+	case float64:
+		return int64(typed)
+	default:
+		return 0
+	}
+}
+
+func hostForURL(raw string) string {
+	parsed, err := url.Parse(raw)
+	if err != nil {
+		return raw
+	}
+	return parsed.Host
+}