@awiki/cli 0.0.1-beta.2

package/internal/store/query.go

@@ -0,0 +1,151 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+func ListInboxMessages(ctx context.Context, db *sql.DB, ownerDID string, limit int, peerDID string, unreadOnly bool) ([]map[string]any, error) {
+	if limit <= 0 {
+		limit = 20
+	}
+	query := `
+SELECT *
+FROM messages
+WHERE owner_did = ?
+  AND direction = 0`
+	args := []any{normalizeOwnerDID(ownerDID)}
+	if unreadOnly {
+		query += " AND is_read = 0"
+	}
+	if strings.TrimSpace(peerDID) != "" {
+		query += " AND (sender_did = ? OR receiver_did = ?)"
+		args = append(args, peerDID, peerDID)
+	}
+	query += " ORDER BY COALESCE(sent_at, stored_at) DESC LIMIT ?"
+	args = append(args, limit)
+	return queryMaps(ctx, db, query, args...)
+}
+
+func ListThreadMessages(ctx context.Context, db *sql.DB, ownerDID string, threadID string, limit int) ([]map[string]any, error) {
+	if strings.TrimSpace(threadID) == "" {
+		return nil, fmt.Errorf("thread_id is required")
+	}
+	if limit <= 0 {
+		limit = 50
+	}
+	return queryMaps(ctx, db, `
+SELECT *
+FROM messages
+WHERE owner_did = ? AND thread_id = ?
+ORDER BY COALESCE(sent_at, stored_at) DESC
+LIMIT ?`, normalizeOwnerDID(ownerDID), threadID, limit)
+}
+
+func ListGroupInboxMessages(ctx context.Context, db *sql.DB, ownerDID string, limit int, groupID string, unreadOnly bool) ([]map[string]any, error) {
+	if limit <= 0 {
+		limit = 20
+	}
+	query := `
+SELECT *
+FROM messages
+WHERE owner_did = ?
+  AND direction = 0
+  AND COALESCE(group_did, group_id) IS NOT NULL`
+	args := []any{normalizeOwnerDID(ownerDID)}
+	if unreadOnly {
+		query += " AND is_read = 0"
+	}
+	if strings.TrimSpace(groupID) != "" {
+		query += " AND (group_did = ? OR group_id = ?)"
+		args = append(args, groupID, groupID)
+	}
+	query += " ORDER BY COALESCE(sent_at, stored_at) DESC LIMIT ?"
+	args = append(args, limit)
+	return queryMaps(ctx, db, query, args...)
+}
+
+func ListGroupMessages(ctx context.Context, db *sql.DB, ownerDID string, groupID string, limit int, sinceSeq *int64) ([]map[string]any, error) {
+	if strings.TrimSpace(groupID) == "" {
+		return nil, fmt.Errorf("group_id is required")
+	}
+	if limit <= 0 {
+		limit = 50
+	}
+	query := `
+SELECT *
+FROM messages
+WHERE owner_did = ?
+  AND (group_did = ? OR group_id = ?)`
+	args := []any{normalizeOwnerDID(ownerDID), groupID, groupID}
+	if sinceSeq != nil {
+		query += " AND COALESCE(server_seq, 0) > ?"
+		args = append(args, *sinceSeq)
+	}
+	query += " ORDER BY COALESCE(server_seq, 0) DESC, COALESCE(sent_at, stored_at) DESC LIMIT ?"
+	args = append(args, limit)
+	return queryMaps(ctx, db, query, args...)
+}
+
+func GetGroupSnapshot(ctx context.Context, db *sql.DB, ownerDID string, groupID string) (map[string]any, error) {
+	return queryOneMap(ctx, db, `
+SELECT *
+FROM groups
+WHERE owner_did = ? AND (group_id = ? OR group_did = ?)`,
+		normalizeOwnerDID(ownerDID), groupID, groupID,
+	)
+}
+
+func ListCachedGroupMembers(ctx context.Context, db *sql.DB, ownerDID string, groupID string, limit int) ([]map[string]any, error) {
+	if strings.TrimSpace(groupID) == "" {
+		return nil, fmt.Errorf("group_id is required")
+	}
+	if limit <= 0 {
+		limit = 100
+	}
+	return queryMaps(ctx, db, `
+SELECT *
+FROM group_members
+WHERE owner_did = ? AND group_id = ?
+ORDER BY role ASC, member_handle ASC, member_did ASC
+LIMIT ?`, normalizeOwnerDID(ownerDID), groupID, limit)
+}
+
+func ListMessagesByIDs(ctx context.Context, db *sql.DB, ownerDID string, messageIDs []string) ([]map[string]any, error) {
+	if len(messageIDs) == 0 {
+		return nil, nil
+	}
+	placeholders := make([]string, 0, len(messageIDs))
+	args := make([]any, 0, len(messageIDs)+1)
+	args = append(args, normalizeOwnerDID(ownerDID))
+	for _, id := range messageIDs {
+		placeholders = append(placeholders, "?")
+		args = append(args, id)
+	}
+	query := fmt.Sprintf(`SELECT * FROM messages WHERE owner_did = ? AND msg_id IN (%s)`, strings.Join(placeholders, ","))
+	return queryMaps(ctx, db, query, args...)
+}
+
+func MarkMessagesRead(ctx context.Context, db *sql.DB, ownerDID string, messageIDs []string) (int64, error) {
+	if len(messageIDs) == 0 {
+		return 0, nil
+	}
+	placeholders := make([]string, 0, len(messageIDs))
+	args := make([]any, 0, len(messageIDs)+1)
+	args = append(args, normalizeOwnerDID(ownerDID))
+	for _, id := range messageIDs {
+		placeholders = append(placeholders, "?")
+		args = append(args, id)
+	}
+	query := fmt.Sprintf(
+		`UPDATE messages SET is_read = 1 WHERE owner_did = ? AND msg_id IN (%s)`,
+		strings.Join(placeholders, ","),
+	)
+	result, err := db.ExecContext(ctx, query, args...)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}

package/internal/store/schema.go

@@ -0,0 +1,277 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+)
+
+const v6TablesSQL = `
+CREATE TABLE IF NOT EXISTS contacts (
+    owner_did       TEXT NOT NULL DEFAULT '',
+    did             TEXT NOT NULL,
+    name            TEXT,
+    handle          TEXT,
+    nick_name       TEXT,
+    bio             TEXT,
+    profile_md      TEXT,
+    tags            TEXT,
+    relationship    TEXT,
+    source_type     TEXT,
+    source_name     TEXT,
+    source_group_id TEXT,
+    connected_at    TEXT,
+    recommended_reason TEXT,
+    followed        INTEGER NOT NULL DEFAULT 0,
+    messaged        INTEGER NOT NULL DEFAULT 0,
+    note            TEXT,
+    first_seen_at   TEXT,
+    last_seen_at    TEXT,
+    metadata        TEXT,
+    PRIMARY KEY (owner_did, did)
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    msg_id          TEXT NOT NULL,
+    owner_did       TEXT NOT NULL DEFAULT '',
+    thread_id       TEXT NOT NULL,
+    direction       INTEGER NOT NULL DEFAULT 0,
+    sender_did      TEXT,
+    receiver_did    TEXT,
+    group_id        TEXT,
+    group_did       TEXT,
+    content_type    TEXT DEFAULT 'text',
+    content         TEXT,
+    title           TEXT,
+    server_seq      INTEGER,
+    sent_at         TEXT,
+    stored_at       TEXT NOT NULL,
+    is_e2ee         INTEGER DEFAULT 0,
+    is_read         INTEGER DEFAULT 0,
+    sender_name     TEXT,
+    metadata        TEXT,
+    credential_name TEXT NOT NULL DEFAULT '',
+    PRIMARY KEY (msg_id, owner_did)
+);
+
+CREATE TABLE IF NOT EXISTS e2ee_outbox (
+    outbox_id            TEXT PRIMARY KEY,
+    owner_did            TEXT NOT NULL DEFAULT '',
+    peer_did             TEXT NOT NULL,
+    session_id           TEXT,
+    original_type        TEXT NOT NULL DEFAULT 'text',
+    plaintext            TEXT NOT NULL,
+    local_status         TEXT NOT NULL DEFAULT 'queued',
+    attempt_count        INTEGER NOT NULL DEFAULT 0,
+    sent_msg_id          TEXT,
+    sent_server_seq      INTEGER,
+    last_error_code      TEXT,
+    retry_hint           TEXT,
+    failed_msg_id        TEXT,
+    failed_server_seq    INTEGER,
+    metadata             TEXT,
+    last_attempt_at      TEXT,
+    created_at           TEXT NOT NULL,
+    updated_at           TEXT NOT NULL,
+    credential_name      TEXT NOT NULL DEFAULT ''
+);
+`
+
+const v7TablesSQL = `
+CREATE TABLE IF NOT EXISTS groups (
+    owner_did          TEXT NOT NULL DEFAULT '',
+    group_id           TEXT NOT NULL,
+    group_did          TEXT,
+    name               TEXT,
+    group_mode         TEXT NOT NULL DEFAULT 'general',
+    slug               TEXT,
+    description        TEXT,
+    goal               TEXT,
+    rules              TEXT,
+    message_prompt     TEXT,
+    doc_url            TEXT,
+    group_owner_did    TEXT,
+    group_owner_handle TEXT,
+    my_role            TEXT,
+    membership_status  TEXT NOT NULL DEFAULT 'active',
+    join_enabled       INTEGER,
+    join_code          TEXT,
+    join_code_expires_at TEXT,
+    member_count       INTEGER,
+    last_synced_seq    INTEGER,
+    last_read_seq      INTEGER,
+    last_message_at    TEXT,
+    remote_created_at  TEXT,
+    remote_updated_at  TEXT,
+    stored_at          TEXT NOT NULL,
+    metadata           TEXT,
+    credential_name    TEXT NOT NULL DEFAULT '',
+    PRIMARY KEY (owner_did, group_id)
+);
+
+CREATE TABLE IF NOT EXISTS group_members (
+    owner_did         TEXT NOT NULL DEFAULT '',
+    group_id          TEXT NOT NULL,
+    user_id           TEXT NOT NULL,
+    member_did        TEXT,
+    member_handle     TEXT,
+    profile_url       TEXT,
+    role              TEXT,
+    status            TEXT NOT NULL DEFAULT 'active',
+    joined_at         TEXT,
+    sent_message_count INTEGER NOT NULL DEFAULT 0,
+    last_synced_at    TEXT NOT NULL,
+    metadata          TEXT,
+    credential_name   TEXT NOT NULL DEFAULT '',
+    PRIMARY KEY (owner_did, group_id, user_id)
+);
+`
+
+const v8TablesSQL = `
+CREATE TABLE IF NOT EXISTS relationship_events (
+    event_id         TEXT PRIMARY KEY,
+    owner_did        TEXT NOT NULL DEFAULT '',
+    target_did       TEXT NOT NULL,
+    target_handle    TEXT,
+    event_type       TEXT NOT NULL,
+    source_type      TEXT,
+    source_name      TEXT,
+    source_group_id  TEXT,
+    reason           TEXT,
+    score            REAL,
+    status           TEXT NOT NULL DEFAULT 'pending',
+    created_at       TEXT NOT NULL,
+    updated_at       TEXT NOT NULL,
+    metadata         TEXT,
+    credential_name  TEXT NOT NULL DEFAULT ''
+);
+`
+
+const v11TablesSQL = `
+CREATE TABLE IF NOT EXISTS e2ee_sessions (
+    owner_did        TEXT NOT NULL DEFAULT '',
+    peer_did         TEXT NOT NULL,
+    session_id       TEXT NOT NULL,
+    is_initiator     INTEGER NOT NULL DEFAULT 0,
+    send_chain_key   TEXT NOT NULL,
+    recv_chain_key   TEXT NOT NULL,
+    send_seq         INTEGER NOT NULL DEFAULT 0,
+    recv_seq         INTEGER NOT NULL DEFAULT 0,
+    expires_at       REAL,
+    created_at       TEXT NOT NULL,
+    active_at        TEXT,
+    peer_confirmed   INTEGER NOT NULL DEFAULT 0,
+    credential_name  TEXT NOT NULL DEFAULT '',
+    updated_at       TEXT NOT NULL,
+    PRIMARY KEY (owner_did, peer_did),
+    UNIQUE (owner_did, session_id)
+);
+`
+
+var indexStatements = []string{
+	`CREATE INDEX IF NOT EXISTS idx_contacts_owner ON contacts(owner_did, last_seen_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_messages_owner_thread ON messages(owner_did, thread_id, sent_at)`,
+	`CREATE INDEX IF NOT EXISTS idx_messages_owner_thread_seq ON messages(owner_did, thread_id, server_seq)`,
+	`CREATE INDEX IF NOT EXISTS idx_messages_owner_direction ON messages(owner_did, direction)`,
+	`CREATE INDEX IF NOT EXISTS idx_messages_owner_sender ON messages(owner_did, sender_did)`,
+	`CREATE INDEX IF NOT EXISTS idx_messages_owner ON messages(owner_did)`,
+	`CREATE INDEX IF NOT EXISTS idx_messages_credential ON messages(credential_name)`,
+	`CREATE INDEX IF NOT EXISTS idx_e2ee_outbox_owner_status ON e2ee_outbox(owner_did, local_status, updated_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_e2ee_outbox_owner_sent_msg ON e2ee_outbox(owner_did, sent_msg_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_e2ee_outbox_owner_sent_seq ON e2ee_outbox(owner_did, peer_did, sent_server_seq)`,
+	`CREATE INDEX IF NOT EXISTS idx_e2ee_outbox_credential ON e2ee_outbox(credential_name)`,
+	`CREATE INDEX IF NOT EXISTS idx_groups_owner_status_last_message ON groups(owner_did, membership_status, last_message_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_groups_owner_slug ON groups(owner_did, slug)`,
+	`CREATE INDEX IF NOT EXISTS idx_groups_owner_updated ON groups(owner_did, remote_updated_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_group_members_owner_group_role ON group_members(owner_did, group_id, role)`,
+	`CREATE INDEX IF NOT EXISTS idx_group_members_owner_group_status ON group_members(owner_did, group_id, status)`,
+	`CREATE INDEX IF NOT EXISTS idx_contacts_owner_source_group ON contacts(owner_did, source_group_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_relationship_events_owner_target_time ON relationship_events(owner_did, target_did, created_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_relationship_events_owner_status_time ON relationship_events(owner_did, status, created_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_relationship_events_owner_group ON relationship_events(owner_did, source_group_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_e2ee_sessions_owner_updated ON e2ee_sessions(owner_did, updated_at DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_e2ee_sessions_credential ON e2ee_sessions(credential_name)`,
+}
+
+var viewStatements = []string{
+	`CREATE VIEW threads AS
+SELECT
+    owner_did,
+    thread_id,
+    COUNT(*) AS message_count,
+    SUM(CASE WHEN is_read = 0 AND direction = 0 THEN 1 ELSE 0 END) AS unread_count,
+    MAX(COALESCE(sent_at, stored_at)) AS last_message_at,
+    (SELECT m2.content FROM messages m2
+     WHERE m2.owner_did = m.owner_did
+       AND m2.thread_id = m.thread_id
+     ORDER BY COALESCE(m2.sent_at, m2.stored_at) DESC
+     LIMIT 1) AS last_content
+FROM messages m
+GROUP BY owner_did, thread_id`,
+	`CREATE VIEW inbox AS
+SELECT * FROM messages WHERE direction = 0
+ORDER BY owner_did, COALESCE(sent_at, stored_at) DESC`,
+	`CREATE VIEW outbox AS
+SELECT * FROM messages WHERE direction = 1
+ORDER BY owner_did, COALESCE(sent_at, stored_at) DESC`,
+}
+
+func EnsureSchema(ctx context.Context, db *sql.DB) error {
+	version, err := schemaVersion(ctx, db)
+	if err != nil {
+		return fmt.Errorf("read sqlite schema version: %w", err)
+	}
+	if version == 0 {
+		if err := createSchema(ctx, db); err != nil {
+			return err
+		}
+		return setSchemaVersion(ctx, db, SchemaVersion)
+	}
+	if version > SchemaVersion {
+		return fmt.Errorf("sqlite schema version %d is newer than supported %d", version, SchemaVersion)
+	}
+	if version < 6 {
+		return fmt.Errorf("sqlite schema version %d is too old for in-place upgrade", version)
+	}
+	if err := createSchema(ctx, db); err != nil {
+		return err
+	}
+	return setSchemaVersion(ctx, db, SchemaVersion)
+}
+
+func CurrentSchemaVersion(db *sql.DB) (int, error) {
+	return schemaVersion(context.Background(), db)
+}
+
+func createSchema(ctx context.Context, db *sql.DB) error {
+	scripts := []string{v6TablesSQL, v7TablesSQL, v8TablesSQL, v11TablesSQL}
+	for _, script := range scripts {
+		if _, err := db.ExecContext(ctx, script); err != nil {
+			return fmt.Errorf("apply sqlite schema: %w", err)
+		}
+	}
+	for _, statement := range indexStatements {
+		if _, err := db.ExecContext(ctx, statement); err != nil {
+			return fmt.Errorf("apply sqlite index: %w", err)
+		}
+	}
+	for _, view := range []string{"threads", "inbox", "outbox"} {
+		if _, err := db.ExecContext(ctx, fmt.Sprintf("DROP VIEW IF EXISTS %s", view)); err != nil {
+			return fmt.Errorf("drop sqlite view %s: %w", view, err)
+		}
+	}
+	for _, statement := range viewStatements {
+		if _, err := db.ExecContext(ctx, statement); err != nil {
+			return fmt.Errorf("apply sqlite view: %w", err)
+		}
+	}
+	return nil
+}
+
+func setSchemaVersion(ctx context.Context, db *sql.DB, version int) error {
+	_, err := db.ExecContext(ctx, fmt.Sprintf("PRAGMA user_version = %d", version))
+	if err != nil {
+		return fmt.Errorf("set sqlite schema version: %w", err)
+	}
+	return nil
+}

package/internal/store/schema_test.go

@@ -0,0 +1,56 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"path/filepath"
+	"testing"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+)
+
+func openTestDB(t *testing.T) *sql.DB {
+	t.Helper()
+	root := t.TempDir()
+	db, err := Open(appconfig.Paths{DatabaseFile: filepath.Join(root, "awiki-cli.db")})
+	if err != nil {
+		t.Fatalf("Open() error = %v", err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+	return db
+}
+
+func TestEnsureSchemaCreatesVersionAndTables(t *testing.T) {
+	t.Parallel()
+
+	db := openTestDB(t)
+	ctx := context.Background()
+	if err := EnsureSchema(ctx, db); err != nil {
+		t.Fatalf("EnsureSchema() error = %v", err)
+	}
+	version, err := CurrentSchemaVersion(db)
+	if err != nil {
+		t.Fatalf("CurrentSchemaVersion() error = %v", err)
+	}
+	if version != SchemaVersion {
+		t.Fatalf("schema version mismatch: got=%d want=%d", version, SchemaVersion)
+	}
+	for _, table := range []string{"contacts", "messages", "e2ee_outbox", "groups", "group_members", "relationship_events", "e2ee_sessions"} {
+		exists, err := tableExists(ctx, db, table)
+		if err != nil {
+			t.Fatalf("tableExists(%s) error = %v", table, err)
+		}
+		if !exists {
+			t.Fatalf("expected table %s to exist", table)
+		}
+	}
+	for _, view := range []string{"threads", "inbox", "outbox"} {
+		exists, err := viewExists(ctx, db, view)
+		if err != nil {
+			t.Fatalf("viewExists(%s) error = %v", view, err)
+		}
+		if !exists {
+			t.Fatalf("expected view %s to exist", view)
+		}
+	}
+}

package/internal/store/types.go

@@ -0,0 +1,177 @@
+package store
+
+import "errors"
+
+const (
+	SchemaVersion = 11
+)
+
+var (
+	ErrUnsupportedLegacySchema = errors.New("unsupported legacy sqlite schema version")
+	ErrLegacyDatabaseNotFound  = errors.New("legacy sqlite database not found")
+	ErrUnsafeSQL               = errors.New("unsafe sql statement")
+)
+
+type OpenOptions struct {
+	ReadOnly bool
+}
+
+type LegacyScan struct {
+	Path          string   `json:"path"`
+	Exists        bool     `json:"exists"`
+	SchemaVersion int      `json:"schema_version"`
+	Tables        []string `json:"tables,omitempty"`
+}
+
+type ImportReport struct {
+	SourcePath          string         `json:"source_path"`
+	SourceSchemaVersion int            `json:"source_schema_version"`
+	ImportedRows        map[string]int `json:"imported_rows"`
+	SkippedTables       []string       `json:"skipped_tables,omitempty"`
+	Warnings            []string       `json:"warnings,omitempty"`
+}
+
+type MessageRecord struct {
+	MsgID          string
+	OwnerDID       string
+	ThreadID       string
+	Direction      int
+	SenderDID      string
+	ReceiverDID    string
+	GroupID        string
+	GroupDID       string
+	ContentType    string
+	Content        string
+	Title          string
+	ServerSeq      *int64
+	SentAt         string
+	IsE2EE         bool
+	IsRead         bool
+	SenderName     string
+	Metadata       string
+	CredentialName string
+}
+
+type ContactRecord struct {
+	OwnerDID          string
+	DID               string
+	Name              string
+	Handle            string
+	NickName          string
+	Bio               string
+	ProfileMD         string
+	Tags              string
+	Relationship      string
+	SourceType        string
+	SourceName        string
+	SourceGroupID     string
+	ConnectedAt       string
+	RecommendedReason string
+	Followed          *bool
+	Messaged          *bool
+	Note              string
+	FirstSeenAt       string
+	LastSeenAt        string
+	Metadata          string
+}
+
+type RelationshipEventRecord struct {
+	EventID        string
+	OwnerDID       string
+	TargetDID      string
+	TargetHandle   string
+	EventType      string
+	SourceType     string
+	SourceName     string
+	SourceGroupID  string
+	Reason         string
+	Score          *float64
+	Status         string
+	CreatedAt      string
+	UpdatedAt      string
+	Metadata       string
+	CredentialName string
+}
+
+type GroupRecord struct {
+	OwnerDID          string
+	GroupID           string
+	GroupDID          string
+	Name              string
+	GroupMode         string
+	Slug              string
+	Description       string
+	Goal              string
+	Rules             string
+	MessagePrompt     string
+	DocURL            string
+	GroupOwnerDID     string
+	GroupOwnerHandle  string
+	MyRole            string
+	MembershipStatus  string
+	JoinEnabled       *bool
+	JoinCode          string
+	JoinCodeExpiresAt string
+	MemberCount       *int64
+	LastSyncedSeq     *int64
+	LastReadSeq       *int64
+	LastMessageAt     string
+	RemoteCreatedAt   string
+	RemoteUpdatedAt   string
+	Metadata          string
+	CredentialName    string
+}
+
+type GroupMemberRecord struct {
+	OwnerDID         string
+	GroupID          string
+	UserID           string
+	MemberDID        string
+	MemberHandle     string
+	ProfileURL       string
+	Role             string
+	Status           string
+	JoinedAt         string
+	SentMessageCount *int64
+	Metadata         string
+	CredentialName   string
+}
+
+type E2EEOutboxRecord struct {
+	OutboxID        string
+	OwnerDID        string
+	PeerDID         string
+	SessionID       string
+	OriginalType    string
+	Plaintext       string
+	LocalStatus     string
+	AttemptCount    int
+	SentMsgID       string
+	SentServerSeq   *int64
+	LastErrorCode   string
+	RetryHint       string
+	FailedMsgID     string
+	FailedServerSeq *int64
+	Metadata        string
+	LastAttemptAt   string
+	CreatedAt       string
+	UpdatedAt       string
+	CredentialName  string
+}
+
+type E2EESessionRecord struct {
+	OwnerDID       string
+	PeerDID        string
+	SessionID      string
+	IsInitiator    bool
+	SendChainKey   string
+	RecvChainKey   string
+	SendSeq        int
+	RecvSeq        int
+	ExpiresAt      *float64
+	CreatedAt      string
+	ActiveAt       string
+	PeerConfirmed  bool
+	UpdatedAt      string
+	CredentialName string
+}