@awiki/cli 0.0.1-beta.2

package/internal/message/service_test.go

@@ -0,0 +1,97 @@
+package message
+
+import (
+	"errors"
+	"path/filepath"
+	"testing"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/identity"
+)
+
+func TestRequireActiveIdentityRejectsLocalOnlyIdentity(t *testing.T) {
+	t.Parallel()
+
+	resolved := testResolvedConfig(t)
+	manager := identity.NewManager(resolved.Paths)
+	createTestIdentity(t, manager, identity.SaveInput{
+		IdentityName: "default",
+		DisplayName:  "Alice",
+	})
+
+	service, err := NewService(resolved)
+	if err != nil {
+		t.Fatalf("NewService() error = %v", err)
+	}
+
+	_, err = service.requireActiveIdentity("")
+	if !errors.Is(err, identity.ErrUserRegistrationRequired) {
+		t.Fatalf("requireActiveIdentity() error = %v, want %v", err, identity.ErrUserRegistrationRequired)
+	}
+}
+
+func TestRequireActiveIdentityAcceptsRegisteredUser(t *testing.T) {
+	t.Parallel()
+
+	resolved := testResolvedConfig(t)
+	manager := identity.NewManager(resolved.Paths)
+	createTestIdentity(t, manager, identity.SaveInput{
+		IdentityName: "alice",
+		UserID:       "user-123",
+		DisplayName:  "Alice",
+		Handle:       "alice",
+	})
+	resolved.ActiveIdentity = "alice"
+
+	service, err := NewService(resolved)
+	if err != nil {
+		t.Fatalf("NewService() error = %v", err)
+	}
+
+	record, err := service.requireActiveIdentity("")
+	if err != nil {
+		t.Fatalf("requireActiveIdentity() error = %v", err)
+	}
+	if record.Handle != "alice" || record.UserID != "user-123" {
+		t.Fatalf("unexpected record = %#v", record)
+	}
+}
+
+func testResolvedConfig(t *testing.T) *appconfig.Resolved {
+	t.Helper()
+	root := t.TempDir()
+	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:    "https://awiki.test",
+		MessageServiceURL: "https://awiki.test",
+		DIDDomain:         "awiki.ai",
+	}
+}
+
+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 = generated.DID
+	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/message/types.go

@@ -0,0 +1,155 @@
+package message
+
+import "errors"
+
+const (
+	MessageRPCEndpoint = "/rpc"
+	MessageWSEndpoint  = "/ws"
+)
+
+var (
+	ErrTargetRequired       = errors.New("direct message target is required")
+	ErrGroupRequired        = errors.New("group target is required")
+	ErrMemberRequired       = errors.New("group member target is required")
+	ErrTextRequired         = errors.New("message text is required")
+	ErrTransportUnavailable = errors.New("message transport is unavailable")
+	ErrSecureNotSupported   = errors.New("direct secure messaging is not implemented yet")
+	ErrMessageNotFound      = errors.New("message not found")
+)
+
+type CommandResult struct {
+	Data     map[string]any
+	Summary  string
+	Warnings []string
+}
+
+type SendRequest struct {
+	IdentityName string
+	Target       string
+	Group        string
+	Text         string
+	MessageType  string
+	SecureMode   string
+}
+
+type InboxRequest struct {
+	IdentityName string
+	Scope        string
+	With         string
+	Group        string
+	Limit        int
+	UnreadOnly   bool
+	MarkRead     bool
+}
+
+type HistoryRequest struct {
+	IdentityName string
+	With         string
+	Limit        int
+	Cursor       string
+}
+
+type MarkReadRequest struct {
+	IdentityName string
+	MessageIDs   []string
+}
+
+type directSendResult struct {
+	Accepted        bool   `json:"accepted"`
+	MessageID       string `json:"message_id"`
+	OperationID     string `json:"operation_id"`
+	TargetDID       string `json:"target_did"`
+	AcceptedAt      string `json:"accepted_at"`
+	FinalAcceptance bool   `json:"final_acceptance"`
+	DeliveryState   string `json:"delivery_state"`
+}
+
+type GroupCreateRequest struct {
+	IdentityName        string
+	Name                string
+	Description         string
+	Discoverability     string
+	AdmissionMode       string
+	Slug                string
+	Goal                string
+	Rules               string
+	MessagePrompt       string
+	DocURL              string
+	AttachmentsAllowed  *bool
+	MaxMembers          string
+	MemberMaxMessages   *int64
+	MemberMaxTotalChars *int64
+}
+
+type GroupGetRequest struct {
+	IdentityName string
+	Group        string
+}
+
+type GroupInfoRequest struct {
+	IdentityName      string
+	Group             string
+	IncludePolicy     bool
+	IncludeMemberList bool
+}
+
+type GroupJoinRequest struct {
+	IdentityName string
+	Group        string
+	ReasonText   string
+}
+
+type GroupMemberRequest struct {
+	IdentityName string
+	Group        string
+	Member       string
+	Role         string
+	ReasonText   string
+}
+
+type GroupLeaveRequest struct {
+	IdentityName string
+	Group        string
+}
+
+type GroupUpdateRequest struct {
+	IdentityName        string
+	Group               string
+	Name                string
+	Description         string
+	Discoverability     string
+	AdmissionMode       string
+	Slug                string
+	Goal                string
+	Rules               string
+	MessagePrompt       string
+	DocURL              string
+	AttachmentsAllowed  *bool
+	MaxMembers          string
+	MemberMaxMessages   *int64
+	MemberMaxTotalChars *int64
+}
+
+type GroupMembersRequest struct {
+	IdentityName string
+	Group        string
+	Limit        int
+}
+
+type GroupMessagesRequest struct {
+	IdentityName string
+	Group        string
+	Limit        int
+	Cursor       string
+}
+
+type groupSendResult struct {
+	Accepted          bool   `json:"accepted"`
+	FinalAcceptance   bool   `json:"final_acceptance"`
+	GroupDID          string `json:"group_did"`
+	MessageID         string `json:"message_id"`
+	OperationID       string `json:"operation_id"`
+	GroupEventSeq     string `json:"group_event_seq"`
+	GroupStateVersion string `json:"group_state_version"`
+	AcceptedAt        string `json:"accepted_at"`
+}

package/internal/message/wire.go

@@ -0,0 +1,100 @@
+package message
+
+import (
+	"fmt"
+
+	"github.com/agentconnect/awiki-cli/internal/identity"
+)
+
+func BuildDirectSendRPCParams(record *identity.StoredIdentity, manager *identity.Manager, targetDID string, text string, messageType string) (map[string]any, error) {
+	auth, err := newAuthContext(record, manager)
+	if err != nil {
+		return nil, err
+	}
+	payload, err := buildDirectTextPayload(record.DID, targetDID, text, contentTypeForMessageType(messageType))
+	if err != nil {
+		return nil, err
+	}
+	senderProof, err := buildSenderProof(auth, payload, targetDID)
+	if err != nil {
+		return nil, err
+	}
+	return map[string]any{
+		"meta": payload.Meta,
+		"auth": map[string]any{
+			"scheme":       OriginProofScheme,
+			"sender_proof": senderProof,
+		},
+		"body": payload.Body,
+	}, nil
+}
+
+func BuildInboxRPCParams(record *identity.StoredIdentity, request InboxRequest) map[string]any {
+	limit := request.Limit
+	if limit <= 0 {
+		limit = 20
+	}
+	return map[string]any{
+		"meta": map[string]any{
+			"anp_version":      "1.0",
+			"profile":          "anp.inbox.local.v1",
+			"security_profile": "transport-protected",
+			"sender_did":       record.DID,
+			"operation_id":     "op-" + generateOperationID(),
+			"created_at":       nowRFC3339(),
+		},
+		"body": map[string]any{
+			"user_did": record.DID,
+			"limit":    limit,
+		},
+	}
+}
+
+func BuildHistoryRPCParams(record *identity.StoredIdentity, request HistoryRequest) (map[string]any, error) {
+	if request.With == "" {
+		return nil, ErrTargetRequired
+	}
+	limit := request.Limit
+	if limit <= 0 {
+		limit = 50
+	}
+	body := map[string]any{
+		"user_did": record.DID,
+		"peer_did": request.With,
+		"limit":    limit,
+	}
+	if request.Cursor != "" {
+		body["since_seq"] = request.Cursor
+	}
+	return map[string]any{
+		"meta": map[string]any{
+			"anp_version":      "1.0",
+			"profile":          "anp.direct.local.v1",
+			"security_profile": "transport-protected",
+			"sender_did":       record.DID,
+			"operation_id":     "op-" + generateOperationID(),
+			"created_at":       nowRFC3339(),
+		},
+		"body": body,
+	}, nil
+}
+
+func BuildMarkReadRPCParams(record *identity.StoredIdentity, request MarkReadRequest) (map[string]any, error) {
+	if len(request.MessageIDs) == 0 {
+		return nil, fmt.Errorf("%w: message_ids are required", ErrMessageNotFound)
+	}
+	return map[string]any{
+		"meta": map[string]any{
+			"anp_version":      "1.0",
+			"profile":          "anp.inbox.local.v1",
+			"security_profile": "transport-protected",
+			"sender_did":       record.DID,
+			"operation_id":     "op-" + generateOperationID(),
+			"created_at":       nowRFC3339(),
+		},
+		"body": map[string]any{
+			"user_did":    record.DID,
+			"message_ids": request.MessageIDs,
+		},
+	}, nil
+}

package/internal/message/wire_test.go

@@ -0,0 +1,49 @@
+package message
+
+import (
+	"testing"
+
+	"github.com/agentconnect/awiki-cli/internal/identity"
+)
+
+func TestBuildDirectSendRPCParamsUsesOriginProofScheme(t *testing.T) {
+	t.Parallel()
+
+	generated, err := identity.GenerateIdentity(identity.GenerateOptions{
+		Hostname:    "awiki.ai",
+		PathPrefix:  []string{"user"},
+		ProofDomain: "awiki.ai",
+	})
+	if err != nil {
+		t.Fatalf("GenerateIdentity() error = %v", err)
+	}
+	record := &identity.StoredIdentity{
+		IdentityName:   "alice",
+		DID:            generated.DID,
+		DIDDocument:    generated.DIDDocument,
+		Key1PrivatePEM: generated.Key1PrivatePEM,
+	}
+
+	params, err := BuildDirectSendRPCParams(record, nil, "did:wba:awiki.ai:user:bob", "hello", "text")
+	if err != nil {
+		t.Fatalf("BuildDirectSendRPCParams() error = %v", err)
+	}
+	auth, ok := params["auth"].(map[string]any)
+	if !ok {
+		t.Fatalf("params[auth] = %#v, want map", params["auth"])
+	}
+	if got := stringFromAny(auth["scheme"]); got != OriginProofScheme {
+		t.Fatalf("auth.scheme = %q, want %q", got, OriginProofScheme)
+	}
+	meta, ok := params["meta"].(map[string]any)
+	if !ok {
+		t.Fatalf("params[meta] = %#v, want map", params["meta"])
+	}
+	target, ok := meta["target"].(map[string]any)
+	if !ok {
+		t.Fatalf("meta[target] = %#v, want map", meta["target"])
+	}
+	if got := stringFromAny(target["kind"]); got != "agent" {
+		t.Fatalf("meta.target.kind = %q, want %q", got, "agent")
+	}
+}

package/internal/message/ws_proxy_client.go

@@ -0,0 +1,151 @@
+package message
+
+import (
+	"context"
+	"fmt"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/runtime"
+)
+
+type WSProxyTransport struct {
+	resolved     *appconfig.Resolved
+	identityName string
+}
+
+func NewWSProxyTransport(resolved *appconfig.Resolved, identityName string) *WSProxyTransport {
+	return &WSProxyTransport{resolved: resolved, identityName: identityName}
+}
+
+func (t *WSProxyTransport) SendDirect(ctx context.Context, request SendRequest) (*directSendResult, error) {
+	result, err := t.call("direct.send", map[string]any{
+		"target": request.Target,
+		"text":   request.Text,
+		"type":   request.MessageType,
+	})
+	if err != nil {
+		return nil, err
+	}
+	sendResult := &directSendResult{}
+	decodeMapInto(result, sendResult)
+	return sendResult, nil
+}
+
+func (t *WSProxyTransport) SendGroup(ctx context.Context, request SendRequest) (*groupSendResult, error) {
+	result, err := t.call("group.send", map[string]any{
+		"group": request.Group,
+		"text":  request.Text,
+		"type":  request.MessageType,
+	})
+	if err != nil {
+		return nil, err
+	}
+	sendResult := &groupSendResult{}
+	decodeMapInto(result, sendResult)
+	return sendResult, nil
+}
+
+func (t *WSProxyTransport) GetInbox(ctx context.Context, request InboxRequest) (map[string]any, error) {
+	return t.call("inbox.get", map[string]any{
+		"with":      request.With,
+		"limit":     request.Limit,
+		"scope":     request.Scope,
+		"mark_read": request.MarkRead,
+		"unread":    request.UnreadOnly,
+	})
+}
+
+func (t *WSProxyTransport) GetHistory(ctx context.Context, request HistoryRequest) (map[string]any, error) {
+	return t.call("direct.get_history", map[string]any{
+		"with":   request.With,
+		"limit":  request.Limit,
+		"cursor": request.Cursor,
+	})
+}
+
+func (t *WSProxyTransport) MarkRead(ctx context.Context, request MarkReadRequest) (map[string]any, error) {
+	return t.call("inbox.mark_read", map[string]any{"message_ids": request.MessageIDs})
+}
+
+func (t *WSProxyTransport) CreateGroup(ctx context.Context, request GroupCreateRequest) (map[string]any, error) {
+	return t.call("group.create", map[string]any{
+		"name":                   request.Name,
+		"description":            request.Description,
+		"discoverability":        request.Discoverability,
+		"admission_mode":         request.AdmissionMode,
+		"slug":                   request.Slug,
+		"goal":                   request.Goal,
+		"rules":                  request.Rules,
+		"message_prompt":         request.MessagePrompt,
+		"doc_url":                request.DocURL,
+		"attachments_allowed":    request.AttachmentsAllowed,
+		"max_members":            request.MaxMembers,
+		"member_max_messages":    request.MemberMaxMessages,
+		"member_max_total_chars": request.MemberMaxTotalChars,
+	})
+}
+
+func (t *WSProxyTransport) GetGroupInfo(ctx context.Context, request GroupInfoRequest) (map[string]any, error) {
+	return t.call("group.get_info", map[string]any{
+		"group":               request.Group,
+		"include_policy":      request.IncludePolicy,
+		"include_member_list": request.IncludeMemberList,
+	})
+}
+
+func (t *WSProxyTransport) JoinGroup(ctx context.Context, request GroupJoinRequest) (map[string]any, error) {
+	return t.call("group.join", map[string]any{"group": request.Group, "reason_text": request.ReasonText})
+}
+
+func (t *WSProxyTransport) AddGroupMember(ctx context.Context, request GroupMemberRequest) (map[string]any, error) {
+	return t.call("group.add", map[string]any{
+		"group":       request.Group,
+		"member":      request.Member,
+		"role":        request.Role,
+		"reason_text": request.ReasonText,
+	})
+}
+
+func (t *WSProxyTransport) RemoveGroupMember(ctx context.Context, request GroupMemberRequest) (map[string]any, error) {
+	return t.call("group.remove", map[string]any{
+		"group":       request.Group,
+		"member":      request.Member,
+		"reason_text": request.ReasonText,
+	})
+}
+
+func (t *WSProxyTransport) LeaveGroup(ctx context.Context, request GroupLeaveRequest) (map[string]any, error) {
+	return t.call("group.leave", map[string]any{"group": request.Group})
+}
+
+func (t *WSProxyTransport) GetGroup(ctx context.Context, request GroupGetRequest) (map[string]any, error) {
+	return t.call("group.get", map[string]any{"group": request.Group})
+}
+
+func (t *WSProxyTransport) ListGroupMembers(ctx context.Context, request GroupMembersRequest) (map[string]any, error) {
+	return t.call("group.list_members", map[string]any{"group": request.Group, "limit": request.Limit})
+}
+
+func (t *WSProxyTransport) ListGroupMessages(ctx context.Context, request GroupMessagesRequest) (map[string]any, error) {
+	return t.call("group.list_messages", map[string]any{"group": request.Group, "limit": request.Limit, "cursor": request.Cursor})
+}
+
+func (t *WSProxyTransport) UpdateGroupProfile(ctx context.Context, request GroupGetRequest, patch map[string]any) (map[string]any, error) {
+	return t.call("group.update_profile", map[string]any{"group": request.Group, "patch": patch})
+}
+
+func (t *WSProxyTransport) UpdateGroupPolicy(ctx context.Context, request GroupGetRequest, patch map[string]any) (map[string]any, error) {
+	return t.call("group.update_policy", map[string]any{"group": request.Group, "patch": patch})
+}
+
+func (t *WSProxyTransport) call(method string, params map[string]any) (map[string]any, error) {
+	result, err := runtime.CallLocalBridge(runtime.BridgeRequest{
+		Method:       method,
+		Params:       params,
+		IdentityName: t.identityName,
+	}, t.resolved)
+	if err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrTransportUnavailable, err)
+	}
+	return result, nil
+}