auramaxx 0.0.17 → 0.0.19

package/src/hooks/useSocialNotifications.ts

@@ -0,0 +1,123 @@
+'use client';
+
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { useWebSocket } from '@/context/WebSocketContext';
+import { WALLET_EVENTS, type WalletEvent, type NotificationCreatedData } from '@/lib/events';
+import { api, Api } from '@/lib/api';
+
+export interface SocialNotification {
+  id: string;
+  type: string;
+  category: string;
+  title: string;
+  message: string;
+  read: boolean;
+  dismissed: boolean;
+  metadata: string | null;
+  hash: string | null;
+  createdAt: string;
+  agentId: string | null;
+}
+
+interface SocialNotificationMeta {
+  socialType?: 'reaction' | 'reply' | 'follow';
+  actorAuraId?: number;
+  actorPublicKey?: string;
+  eventHash?: string;
+}
+
+interface FetchResponse {
+  success: boolean;
+  notifications: SocialNotification[];
+  total: number;
+}
+
+interface UpdateResponse {
+  success: boolean;
+  updated: number;
+}
+
+export function parseSocialMeta(raw: string | null): SocialNotificationMeta {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw) as SocialNotificationMeta;
+  } catch {
+    return {};
+  }
+}
+
+export function useSocialNotifications(agentId: string | null) {
+  const [notifications, setNotifications] = useState<SocialNotification[]>([]);
+  const [loading, setLoading] = useState(false);
+  const mountedRef = useRef(true);
+  const { subscribe, connected } = useWebSocket();
+
+  const fetchNotifications = useCallback(async () => {
+    setLoading(true);
+    try {
+      const qs = agentId ? `agentId=${encodeURIComponent(agentId)}&limit=50` : 'limit=50';
+      const data = await api.get<FetchResponse>(Api.Wallet, `/social/notifications?${qs}`);
+      if (mountedRef.current && data.success) {
+        setNotifications(data.notifications);
+      }
+    } catch {
+      // Silently ignore - social may not be enabled
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, [agentId]);
+
+  // Initial fetch
+  useEffect(() => {
+    mountedRef.current = true;
+    fetchNotifications();
+    return () => { mountedRef.current = false; };
+  }, [agentId, fetchNotifications]);
+
+  // Refetch on reconnect
+  useEffect(() => {
+    if (connected) fetchNotifications();
+  }, [connected, agentId, fetchNotifications]);
+
+  // Listen for real-time notification:created events
+  useEffect(() => {
+    const unsub = subscribe(WALLET_EVENTS.NOTIFICATION_CREATED, (event) => {
+      const data = (event as WalletEvent).data as NotificationCreatedData;
+      if (data.category !== 'social') return;
+      if (agentId && data.agentId !== agentId) return;
+      // Refetch to get full notification data
+      fetchNotifications();
+    });
+    return unsub;
+  }, [subscribe, agentId, fetchNotifications]);
+
+  const unreadCount = useMemo(
+    () => notifications.filter((n) => !n.read && !n.dismissed).length,
+    [notifications],
+  );
+
+  const markRead = useCallback(async (ids: string[]) => {
+    if (ids.length === 0) return;
+    setNotifications((prev) => prev.map((n) => ids.includes(n.id) ? { ...n, read: true } : n));
+    try {
+      await api.post<UpdateResponse>(Api.Wallet, '/social/notifications/read', { ids });
+    } catch { /* best-effort */ }
+  }, []);
+
+  const dismiss = useCallback(async (ids: string[]) => {
+    if (ids.length === 0) return;
+    setNotifications((prev) => prev.map((n) => ids.includes(n.id) ? { ...n, dismissed: true, read: true } : n));
+    try {
+      await api.post<UpdateResponse>(Api.Wallet, '/social/notifications/dismiss', { ids });
+    } catch { /* best-effort */ }
+  }, []);
+
+  return {
+    notifications,
+    unreadCount,
+    loading,
+    markRead,
+    dismiss,
+    refresh: fetchNotifications,
+  };
+}

package/src/lib/events.ts

@@ -216,6 +216,13 @@ export interface CredentialAccessedData {
   tokenHash?: string;
 }
 
+export interface NotificationCreatedData {
+  agentId: string;
+  notificationId: string;
+  category: string;
+  title: string;
+}
+
 export interface BalanceUpdatedData {
   chain: string;
   type: 'native' | 'token';
@@ -234,7 +241,8 @@ export type WalletEventData =
   | ActionCreatedData
   | ActionResolvedData
   | CredentialChangedData
-  | CredentialAccessedData;
+  | CredentialAccessedData
+  | NotificationCreatedData;
 
 // Event types as const for type safety
 export const WALLET_EVENTS = {
@@ -251,6 +259,7 @@ export const WALLET_EVENTS = {
   CREDENTIAL_CHANGED: 'credential:changed',
   CREDENTIAL_ACCESSED: 'credential:accessed',
   SECRET_ACCESSED: 'secret:accessed',
+  NOTIFICATION_CREATED: 'notification:created',
 } as const;
 
 export type WalletEventType = (typeof WALLET_EVENTS)[keyof typeof WALLET_EVENTS];

package/src/lib/social-client.ts

@@ -0,0 +1,319 @@
+import { api, Api } from './api';
+
+export interface SocialAgentInfo {
+  id: string;
+  name?: string;
+  isPrimary: boolean;
+  parentAgentId?: string;
+}
+
+export interface SocialMessageItem {
+  id: string;
+  agentId: string;
+  hash: string;
+  type: string;
+  body: string;
+  timestamp: number;
+  syncStatus?: string;
+  createdAt?: string;
+}
+
+export interface InboundMessageItem {
+  id: string;
+  agentId: string;
+  hash: string;
+  authorAuraId: number;
+  type: string;
+  body: string;
+  timestamp: number;
+}
+
+export interface FollowerItem {
+  id: string;
+  authorAuraId: number;
+  timestamp: number;
+  body: string;
+}
+
+export interface FollowingItem {
+  auraId: number;
+  timestamp: number;
+}
+
+export interface SyncStatus {
+  pending: number;
+  accepted: number;
+  rejected: number;
+  failed: number;
+  total: number;
+}
+
+export interface AgentProfile {
+  pfp: string;
+  handle: string;
+  displayName: string;
+  pfpIsSprite?: boolean;
+}
+
+export interface HubSubscriptionInfo {
+  id: string;
+  agentId: string;
+  hubUrl: string;
+  frontendUrl: string | null;
+  label: string | null;
+  auraId: number | null;
+  inboundSeq: number | null;
+  inboundMode: string | null;
+  joinedAt: string;
+}
+
+interface ProfileMessageItem {
+  body: string;
+  createdAt?: string;
+  timestamp?: number;
+}
+
+const DEFAULT_AGENT_AVATAR = 'https://auramaxx.sh/agent7.png';
+
+function parseLatestProfile(messages: ProfileMessageItem[]): AgentProfile {
+  const latest: Record<string, { value: string; rank: number }> = {};
+  for (const msg of messages) {
+    try {
+      const parsed = JSON.parse(msg.body) as { type?: string; value?: string };
+      if (!parsed.type) continue;
+      const rank = msg.createdAt
+        ? Date.parse(msg.createdAt)
+        : typeof msg.timestamp === 'number'
+          ? msg.timestamp * 1000
+          : 0;
+      const existing = latest[parsed.type];
+      if (!existing || rank >= existing.rank) {
+        latest[parsed.type] = { value: parsed.value ?? '', rank };
+      }
+    } catch {
+      // ignore malformed profile rows
+    }
+  }
+
+  const pfpVal = latest.pfp?.value || DEFAULT_AGENT_AVATAR;
+  return {
+    pfp: pfpVal,
+    handle: latest.handle?.value || '',
+    displayName: latest.display_name?.value || '',
+    pfpIsSprite: latest.pfp_is_sprite?.value === 'true'
+      || (!latest.pfp_is_sprite && /\/agent\d+\.png$/.test(pfpVal)),
+  };
+}
+
+function tryParseBody(body: string): Record<string, unknown> {
+  try {
+    return JSON.parse(body) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+function shouldApplyPostRemove(syncStatus?: string): boolean {
+  return syncStatus !== 'failed' && syncStatus !== 'rejected';
+}
+
+function extractRemovedPostHash(message: SocialMessageItem): string | null {
+  const parsed = tryParseBody(message.body);
+  const raw = parsed.targetPostHash ?? parsed.postHash ?? parsed.targetHash;
+  if (typeof raw !== 'string') return null;
+  const trimmed = raw.trim();
+  return trimmed ? trimmed : null;
+}
+
+export async function fetchSocialAgents(): Promise<SocialAgentInfo[]> {
+  const res = await api.get<{ agents: SocialAgentInfo[] }>(Api.Wallet, '/agents/credential');
+  return res.agents || [];
+}
+
+export interface GlobalFeedAuthorProfile {
+  handle: string | null;
+  displayName: string | null;
+  pfp: string | null;
+  pfpIsSprite: boolean;
+}
+
+export interface GlobalFeedItem {
+  postHash: string;
+  authorAuraId: number;
+  text: string;
+  updatedTs: number;
+  authorScore: number;
+  authorProfile: GlobalFeedAuthorProfile | null;
+}
+
+export async function fetchGlobalFeed(cursor?: string, hubUrl?: string): Promise<{ items: GlobalFeedItem[]; nextCursor: string | null }> {
+  const params: Record<string, string | number> = { limit: 50 };
+  if (cursor) params.cursor = cursor;
+  if (hubUrl) params.hubUrl = hubUrl;
+  const res = await api.get<{ ok: boolean; items: GlobalFeedItem[]; nextCursor: string | null }>(
+    Api.Wallet,
+    '/social/global-feed',
+    params,
+  );
+  return { items: res.items || [], nextCursor: res.nextCursor ?? null };
+}
+
+export async function fetchSocialFeed(agentId: string, hubUrl?: string): Promise<InboundMessageItem[]> {
+  const params: Record<string, string | number> = { agentId, type: 'post_add', limit: 50 };
+  if (hubUrl) params.hubUrl = hubUrl;
+
+  const [feedRes, ownPosts] = await Promise.all([
+    api.get<{ messages: InboundMessageItem[] }>(
+      Api.Wallet,
+      '/social/feed',
+      params,
+    ),
+    fetchSocialPosts(agentId, hubUrl),
+  ]);
+
+  const byHash = new Map<string, InboundMessageItem>();
+  for (const message of feedRes.messages || []) {
+    byHash.set(message.hash, message);
+  }
+  for (const post of ownPosts) {
+    if (byHash.has(post.hash)) continue;
+    byHash.set(post.hash, {
+      id: post.id,
+      agentId: post.agentId,
+      hash: post.hash,
+      authorAuraId: 0,
+      type: post.type,
+      body: post.body,
+      timestamp: post.timestamp,
+    });
+  }
+
+  return Array.from(byHash.values()).sort((a, b) => b.timestamp - a.timestamp);
+}
+
+export async function fetchSocialPosts(agentId: string, hubUrl?: string): Promise<SocialMessageItem[]> {
+  const params: Record<string, string | number> = { agentId, type: 'post_add', limit: 200 };
+  if (hubUrl) params.hubUrl = hubUrl;
+  const removeParams: Record<string, string | number> = { agentId, type: 'post_remove', limit: 200 };
+  if (hubUrl) removeParams.hubUrl = hubUrl;
+
+  const [addsRes, removesRes] = await Promise.all([
+    api.get<{ messages: SocialMessageItem[] }>(Api.Wallet, '/social/messages', params),
+    api.get<{ messages: SocialMessageItem[] }>(Api.Wallet, '/social/messages', removeParams),
+  ]);
+
+  const posts = addsRes.messages || [];
+  const removals = removesRes.messages || [];
+  if (removals.length === 0) return posts;
+
+  const removedHashes = new Set<string>();
+  for (const removeMessage of removals) {
+    if (!shouldApplyPostRemove(removeMessage.syncStatus)) continue;
+    const targetHash = extractRemovedPostHash(removeMessage);
+    if (targetHash) removedHashes.add(targetHash);
+  }
+
+  if (removedHashes.size === 0) return posts;
+  return posts.filter((post) => !removedHashes.has(post.hash));
+}
+
+export async function fetchSocialFollowers(agentId: string, hubUrl?: string): Promise<FollowerItem[]> {
+  const params: Record<string, string> = { agentId };
+  if (hubUrl) params.hubUrl = hubUrl;
+  const res = await api.get<{ followers: FollowerItem[] }>(Api.Wallet, '/social/followers', params);
+  return res.followers || [];
+}
+
+export async function fetchSocialFollowing(agentId: string, hubUrl?: string): Promise<FollowingItem[]> {
+  const params: Record<string, string> = { agentId };
+  if (hubUrl) params.hubUrl = hubUrl;
+  const res = await api.get<{ following: FollowingItem[] }>(Api.Wallet, '/social/following', params);
+  return res.following || [];
+}
+
+export async function fetchSocialStatus(agentId: string, hubUrl?: string): Promise<SyncStatus | null> {
+  const params: Record<string, string> = { agentId };
+  if (hubUrl) params.hubUrl = hubUrl;
+  const res = await api.get<{ status: SyncStatus | null }>(Api.Wallet, '/social/status', params);
+  return res.status || null;
+}
+
+export async function fetchSocialProfile(agentId: string): Promise<AgentProfile> {
+  const res = await api.get<{ messages: ProfileMessageItem[] }>(
+    Api.Wallet,
+    '/social/messages',
+    { agentId, type: 'user_data_add', limit: 200 },
+  );
+  return parseLatestProfile(res.messages || []);
+}
+
+export function buildLocalPendingPost(agentId: string, text: string): SocialMessageItem {
+  const nowMs = Date.now();
+  const nowIso = new Date(nowMs).toISOString();
+  const localId = `local:${agentId}:${nowMs}:${Math.random().toString(16).slice(2, 8)}`;
+  return {
+    id: localId,
+    agentId,
+    hash: localId,
+    type: 'post_add',
+    body: JSON.stringify({ text }),
+    timestamp: Math.floor(nowMs / 1000),
+    syncStatus: 'pending',
+    createdAt: nowIso,
+  };
+}
+
+export function submitPostLocalFirst(agentId: string, text: string, hubUrl?: string): {
+  localMessage: SocialMessageItem;
+  submit: Promise<SocialMessageItem>;
+} {
+  const normalizedText = text.trim();
+  if (!normalizedText) {
+    throw new Error('text is required and must be a non-empty string');
+  }
+  const localMessage = buildLocalPendingPost(agentId, normalizedText);
+  const postBody: Record<string, string> = { agentId, text: normalizedText };
+  if (hubUrl) postBody.hubUrl = hubUrl;
+
+  const submit = api
+    .post<{ success: boolean; message: SocialMessageItem }>(Api.Wallet, '/social/post', postBody)
+    .then((res) => res.message);
+
+  return { localMessage, submit };
+}
+
+export async function removeSocialPost(agentId: string, targetPostHash: string, hubUrl?: string): Promise<void> {
+  const body: Record<string, string> = { agentId, targetPostHash };
+  if (hubUrl) body.hubUrl = hubUrl;
+  await api.post(Api.Wallet, '/social/post/remove', body);
+}
+
+export async function likeSocialPost(agentId: string, postHash: string, hubUrl?: string): Promise<void> {
+  const body: Record<string, string> = { agentId, postHash, reactionType: 'like' };
+  if (hubUrl) body.hubUrl = hubUrl;
+  await api.post(Api.Wallet, '/social/react', body);
+}
+
+// ─── Hub management ──────────────────────────────────────────────────
+
+export async function fetchPrimaryHubUrl(): Promise<string> {
+  const res = await api.get<{ hubUrl?: string }>(Api.Wallet, '/agent-hub/default');
+  const hubUrl = typeof res.hubUrl === 'string' ? res.hubUrl.trim() : '';
+  return hubUrl;
+}
+
+export async function fetchHubSubscriptions(agentId: string): Promise<HubSubscriptionInfo[]> {
+  const res = await api.get<{ hubs: HubSubscriptionInfo[] }>(Api.Wallet, `/agent-hub/${agentId}/hubs`);
+  return res.hubs || [];
+}
+
+export async function joinHub(agentId: string, hubUrl: string, label?: string): Promise<HubSubscriptionInfo> {
+  const body: Record<string, string> = { hubUrl };
+  if (label) body.label = label;
+  const res = await api.post<{ hub: HubSubscriptionInfo }>(Api.Wallet, `/agent-hub/${agentId}/join`, body);
+  return res.hub;
+}
+
+export async function leaveHub(agentId: string, hubUrl: string): Promise<void> {
+  await api.post(Api.Wallet, `/agent-hub/${agentId}/leave`, { hubUrl });
+}

package/src/lib/view-registry.ts

@@ -22,14 +22,32 @@ export const DEFAULT_VIEWS: ViewDefinition[] = [
     pinned: true,
   },
   {
-    id: 'wallet',
-    label: 'Wallet',
-    icon: 'Flame',
-    description: 'Wallet balances, send, swap, and fund',
+    id: 'agents',
+    label: 'Verify',
+    icon: 'ShieldCheck',
+    description: 'Verified credentials and identity attestations',
     pinned: true,
   },
 ];
 
+/** Social view — only shown when SOCIAL feature flag is enabled */
+export const SOCIAL_VIEW: ViewDefinition = {
+  id: 'social',
+  label: 'Social',
+  icon: 'MessageCircle',
+  description: 'Social feed, posts, reactions, and follows',
+  pinned: true,
+};
+
+/** Hub view — renders a hub's frontend in an iframe */
+export const HUB_VIEW: ViewDefinition = {
+  id: 'hub',
+  label: 'Hub',
+  icon: 'Globe',
+  description: 'Browse hub frontends',
+  pinned: true,
+};
+
 /** Views that can be created from the + button */
 export const CREATABLE_VIEWS: ViewDefinition[] = [
   {

package/src/server/cli/commands/agent.ts

@@ -29,6 +29,8 @@ import {
   normalizeCredentialFieldsForType,
   getCredentialFieldValue,
   NOTE_CONTENT_KEY,
+  CREDENTIAL_FIELD_SCHEMA,
+  type CredentialType,
 } from '../../../../shared/credential-field-schema';
 import {
   createSecretGist,
@@ -718,8 +720,7 @@ export function parseArgs(args: string[]): {
   const flagTotp = parseableArgs.includes('--totp');
   const flagOneTime = parseableArgs.includes('--one-time');
   const flagDangerPlaintext = parseableArgs.includes('--danger-plaintext');
-  const fieldIdx = parseableArgs.indexOf('--field');
-  const fieldName = fieldIdx !== -1 ? parseableArgs[fieldIdx + 1] : undefined;
+  let fieldName: string | undefined;
   const secretEnvIdx = parseableArgs.indexOf('--env');
   const legacySecretEnvIdx = parseableArgs.indexOf('--name');
   const secretEnvName = secretEnvIdx !== -1
@@ -752,7 +753,7 @@ export function parseArgs(args: string[]): {
     : undefined;
 
   const knownValueFlags = new Set([
-    '--field', '--name', '--env', '--agent', '--expires-after', '--password', '--location', '--reqId', '--req-id', '--requestId', '--request-id', '--profile', '--profile-version', '--profile-overrides', '--type', '--tags',
+    '--name', '--env', '--agent', '--expires-after', '--password', '--location', '--reqId', '--req-id', '--requestId', '--request-id', '--profile', '--profile-version', '--profile-overrides', '--type', '--tags',
   ]);
   const knownBooleanFlags = new Set(['--json', '--first', '--totp', '--one-time', '--danger-plaintext']);
 
@@ -766,6 +767,21 @@ export function parseArgs(args: string[]): {
       continue;
     }
 
+    // Handle --field specially: supports --field key=value and --field key
+    if (arg === '--field') {
+      const nextArg = parseableArgs[i + 1];
+      if (nextArg && !nextArg.startsWith('--')) {
+        const eqIdx = nextArg.indexOf('=');
+        if (eqIdx > 0) {
+          extraFields.push({ key: nextArg.slice(0, eqIdx), value: nextArg.slice(eqIdx + 1) });
+        } else {
+          fieldName = fieldName || nextArg;
+        }
+        i++;
+      }
+      continue;
+    }
+
     if (knownValueFlags.has(arg)) {
       i++;
       continue;
@@ -1050,6 +1066,14 @@ function resolveSetType(typeName: string | undefined): { requestType: string; no
   return { requestType, normalizedType, defaultFieldKey };
 }
 
+function resolveFieldSensitivity(credentialType: string, fieldKey: string): boolean {
+  const schema = CREDENTIAL_FIELD_SCHEMA[credentialType as CredentialType];
+  if (!schema) return false;
+  const spec = schema.find((f) => f.key.toLowerCase() === fieldKey.toLowerCase()
+    || (f.aliases || []).some((a) => a.toLowerCase() === fieldKey.toLowerCase()));
+  return spec ? spec.sensitive : false;
+}
+
 // ── Output formatting ──────────────────────────────────────────────────
 
 export function formatCredential(
@@ -1456,7 +1480,7 @@ export async function runAgentCli(args: string[]): Promise<number> {
 
       const setFields: Array<{ key: string; value: string; sensitive?: boolean }> = [
         { key: fieldKey, value, sensitive: true },
-        ...extraFields.map((f) => ({ key: f.key, value: f.value, sensitive: true })),
+        ...extraFields.map((f) => ({ key: f.key, value: f.value, sensitive: resolveFieldSensitivity(resolvedType.requestType, f.key) })),
       ];
       const nextMeta = tags ? { tags } : undefined;
 
@@ -1487,13 +1511,15 @@ export async function runAgentCli(args: string[]): Promise<number> {
               retryCommandTemplate,
               originalCommand,
             });
+            const effectiveType = decrypted.type || resolvedType.requestType;
             const existing = [...decrypted.fields];
             for (const next of setFields) {
               const index = existing.findIndex((f) => f.key.toLowerCase() === next.key.toLowerCase());
+              const sensitive = next.sensitive ?? resolveFieldSensitivity(effectiveType, next.key);
               if (index >= 0) {
-                existing[index] = { ...existing[index], key: next.key, value: next.value, sensitive: true };
+                existing[index] = { ...existing[index], key: next.key, value: next.value, sensitive };
               } else {
-                existing.push({ key: next.key, value: next.value, sensitive: true });
+                existing.push({ key: next.key, value: next.value, sensitive });
               }
             }
             nextFields = existing;
@@ -1505,7 +1531,7 @@ export async function runAgentCli(args: string[]): Promise<number> {
         }
 
         const updated = await updateCredential(token, target.id, {
-          sensitiveFields: nextFields.map((f) => ({ key: f.key, value: f.value, sensitive: true })),
+          sensitiveFields: nextFields.map((f) => ({ key: f.key, value: f.value, sensitive: f.sensitive ?? false })),
           ...(nextMeta ? { meta: nextMeta } : {}),
         });