auramaxx 0.0.17 → 0.0.19

package/src/server/cron/index.ts

@@ -1,6 +1,6 @@
 /**
  * Cron Server Entry Point
- * Runs background jobs: balance sync, native price sync.
+ * Runs background jobs: native price sync, social sync.
  * Connects to the same DB as the wallet server.
  */
 
@@ -9,11 +9,9 @@ import pino from 'pino';
 import { getDbUrl } from '../lib/config';
 import { preloadCache, getDefaultSync } from '../lib/defaults';
 import { Scheduler } from './scheduler';
-import { balanceSyncJob } from './jobs/balance-sync';
 import { nativePriceJob } from './jobs/native-price';
-import { incomingScanJob } from './jobs/incoming-scan';
-import { orphanCleanupJob } from './jobs/orphan-cleanup';
-import { strategyRunnerJob } from './jobs/strategy-runner';
+import { socialInboundJob } from './jobs/social-inbound';
+import { socialOutboundJob } from './jobs/social-outbound';
 import type { CronContext } from './job';
 
 // Set DATABASE_URL before creating PrismaClient
@@ -108,10 +106,8 @@ async function main(): Promise<void> {
   // Build scheduler
   const scheduler = new Scheduler();
   scheduler.register(nativePriceJob);
-  scheduler.register(balanceSyncJob);
-  scheduler.register(incomingScanJob);
-  scheduler.register(orphanCleanupJob);
-  scheduler.register(strategyRunnerJob);
+  scheduler.register(socialInboundJob);
+  scheduler.register(socialOutboundJob);
 
   // Start all jobs
   await scheduler.startAll(ctx);

package/src/server/cron/jobs/social-inbound.ts

@@ -0,0 +1,596 @@
+/**
+ * Social Inbound Sync Job
+ * =======================
+ * Pulls messages from the hub into local InboundMessage cache.
+ * Two modes:
+ *   - snapshot: cold start or stale cursor (> 1 hour behind)
+ *   - incremental: normal operation, pulls from global event log
+ */
+
+import type { CronJob, CronContext } from '../job';
+import { isEnabled } from '../../lib/feature-flags';
+import { getHubUrl } from '../../lib/defaults';
+import { createNotification } from '../../lib/notifications';
+import { getAgentMnemonic } from '../../lib/cold';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { tryCallHubWithSessionAuth } from '../../lib/hub-auth';
+import { normalizeHubPublicKey } from '../../lib/social/public-key';
+const EVENT_BATCH_LIMIT = 500;
+const STALENESS_THRESHOLD = 10_000; // If agent is this many events behind, fall back to snapshot
+const RELEVANT_STREAMS = ['feed', 'followers', 'notifications'] as const;
+
+// ─── Hub response types ──────────────────────────────────────────────
+
+interface HubEvent {
+  seq: number;
+  hash: string;
+  authorAuraId: number;
+  authorPublicKey: string;
+  type: string;
+  body: string; // JSON-encoded
+  timestamp: number;
+}
+
+interface EventsResponse {
+  events: HubEvent[];
+  latestSeq: number;
+}
+
+interface SnapshotMessage {
+  hash: string;
+  authorAuraId: number;
+  authorPublicKey?: string;
+  type: string;
+  body: string;
+  timestamp: number;
+}
+
+interface SnapshotFollowEntry {
+  auraId: number;
+  publicKey: string;
+  timestamp: number;
+}
+
+interface SnapshotResponse {
+  followers: SnapshotFollowEntry[];
+  following: SnapshotFollowEntry[];
+  feed: SnapshotMessage[];
+  notifications: SnapshotMessage[];
+  latestSeq: number;
+}
+
+interface SnapshotCursorResponse {
+  since: number;
+  seq: number;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+/** Check if an authorPublicKey is someone this agent follows. */
+async function isFollowing(
+  agentId: string,
+  authorPublicKey: string,
+  ctx: CronContext,
+): Promise<boolean> {
+  if (!authorPublicKey) return false;
+
+  // Fast path: check inbound cache (populated by snapshot sync)
+  const inbound = await ctx.prisma.inboundMessage.findFirst({
+    where: {
+      agentId,
+      type: 'link_add',
+      body: { contains: `"followeePublicKey":"${authorPublicKey}"` },
+    },
+    select: { id: true },
+  });
+  if (inbound) return true;
+
+  // Fallback: check our own outbound follows in SocialMessage
+  const outboundFollow = await ctx.prisma.socialMessage.findFirst({
+    where: {
+      agentId,
+      type: 'link_add',
+      body: { contains: `"followeePublicKey":"${authorPublicKey}"` },
+    },
+    orderBy: { createdAt: 'desc' },
+    select: { createdAt: true },
+  });
+  if (!outboundFollow) return false;
+
+  // Ensure no subsequent unfollow
+  const outboundUnfollow = await ctx.prisma.socialMessage.findFirst({
+    where: {
+      agentId,
+      type: 'link_remove',
+      body: { contains: `"followeePublicKey":"${authorPublicKey}"` },
+    },
+    orderBy: { createdAt: 'desc' },
+    select: { createdAt: true },
+  });
+  if (outboundUnfollow && outboundUnfollow.createdAt > outboundFollow.createdAt) return false;
+
+  return true;
+}
+
+/** Check if a message references one of this agent's outbound post hashes. */
+async function referencesMyPost(
+  agentId: string,
+  body: string,
+  ctx: CronContext,
+): Promise<boolean> {
+  // Look for postHash or targetPostHash in the body
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return false;
+  }
+  const refHash = (parsed.postHash ?? parsed.targetPostHash ?? parsed.parentPostHash) as string | undefined;
+  if (!refHash) return false;
+
+  const myMsg = await ctx.prisma.socialMessage.findFirst({
+    where: { agentId, hash: refHash },
+    select: { id: true },
+  });
+  return myMsg !== null;
+}
+
+/** Check if this is a credential_add for me (by publicKey). */
+function isCredentialForMe(body: string, myPublicKeyHex: string): boolean {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.ownerPublicKey === myPublicKeyHex;
+  } catch {
+    return false;
+  }
+}
+
+/** Check if this is a link_add targeting us (by publicKey). */
+function isFollowingMe(body: string, myPublicKeyHex: string): boolean {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.followeePublicKey === myPublicKeyHex;
+  } catch {
+    return false;
+  }
+}
+
+/** Handle remove types: delete matching InboundMessage by target hash. */
+async function handleRemove(
+  agentId: string,
+  type: string,
+  body: string,
+  ctx: CronContext,
+): Promise<void> {
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return;
+  }
+
+  let targetHash: string | undefined;
+  let targetType: string | undefined;
+
+  if (type === 'post_remove') {
+    targetHash = parsed.targetPostHash as string;
+    targetType = 'post_add';
+  } else if (type === 'reaction_remove') {
+    targetHash = parsed.postHash as string;
+    targetType = 'reaction_add';
+  } else if (type === 'link_remove') {
+    // For link_remove, find the matching link_add by followeePublicKey in body
+    const followeePublicKey = parsed.followeePublicKey as string;
+    if (followeePublicKey) {
+      await ctx.prisma.inboundMessage.deleteMany({
+        where: {
+          agentId,
+          type: 'link_add',
+          body: { contains: `"followeePublicKey":"${followeePublicKey}"` },
+        },
+      });
+    }
+    return;
+  }
+
+  if (targetHash && targetType) {
+    await ctx.prisma.inboundMessage.deleteMany({
+      where: { agentId, type: targetType, hash: targetHash },
+    });
+  }
+}
+
+// ─── Notification generation ─────────────────────────────────────────
+
+async function createSocialNotification(
+  agentId: string,
+  publicKeyHex: string,
+  event: HubEvent,
+  ctx: CronContext,
+): Promise<void> {
+  let title: string | undefined;
+  let message: string | undefined;
+  let socialType: string | undefined;
+
+  // Reaction on my post
+  if (event.type === 'reaction_add' && await referencesMyPost(agentId, event.body, ctx)) {
+    socialType = 'reaction';
+    const actorLabel = event.authorAuraId ? `#${event.authorAuraId}` : 'Someone';
+    title = 'Reaction on your post';
+    message = `${actorLabel} reacted to your post`;
+  }
+  // Reply to my post
+  else if (event.type === 'post_add') {
+    let parsed: Record<string, unknown> | undefined;
+    try { parsed = JSON.parse(event.body); } catch { /* skip */ }
+    if (parsed?.parentPostHash && await referencesMyPost(agentId, event.body, ctx)) {
+      socialType = 'reply';
+      const actorLabel = event.authorAuraId ? `#${event.authorAuraId}` : 'Someone';
+      title = 'Reply to your post';
+      message = `${actorLabel} replied to your post`;
+    }
+  }
+  // New follower
+  else if (event.type === 'link_add' && isFollowingMe(event.body, publicKeyHex)) {
+    socialType = 'follow';
+    const actorLabel = event.authorAuraId ? `#${event.authorAuraId}` : 'Someone';
+    title = 'New follower';
+    message = `${actorLabel} started following you`;
+  }
+
+  if (!title || !message || !socialType) return;
+
+  const notification = await createNotification({
+    type: 'info',
+    category: 'social',
+    title,
+    message,
+    hash: event.hash,
+    source: 'system',
+    agentId,
+    metadata: {
+      socialType,
+      actorAuraId: event.authorAuraId,
+      actorPublicKey: event.authorPublicKey,
+      eventHash: event.hash,
+    },
+  });
+
+  if (notification) {
+    await ctx.emit('notification:created', {
+      agentId,
+      notificationId: notification.id,
+      category: 'social',
+      title,
+    });
+    ctx.log.debug({ agentId, socialType, hash: event.hash }, 'Social notification created');
+  }
+}
+
+// ─── Snapshot mode ───────────────────────────────────────────────────
+
+/** Generate a deterministic hash for synthetic follow/follower messages. */
+function syntheticHash(prefix: string, agentId: string, publicKey: string): string {
+  const input = `${prefix}:${agentId}:${publicKey}`;
+  return Buffer.from(blake3(new TextEncoder().encode(input))).toString('hex');
+}
+
+async function runSnapshot(
+  agentId: string,
+  hubUrl: string,
+  mnemonic: string,
+  subscriptionId: string,
+  ctx: CronContext,
+): Promise<void> {
+  const cursor = await tryCallHubWithSessionAuth<SnapshotCursorResponse>(
+    hubUrl,
+    'sync.snapshotCursor',
+    {},
+    mnemonic,
+    { log: ctx.log },
+  );
+
+  // Get personalized snapshot by publicKey
+  const identity = await ctx.prisma.agentProfile.findUnique({ where: { agentId } });
+  const pubKey = identity?.publicKeyHex ? normalizeHubPublicKey(identity.publicKeyHex) : '';
+  const snapshot = await tryCallHubWithSessionAuth<SnapshotResponse>(
+    hubUrl,
+    'sync.snapshot',
+    { publicKey: pubKey },
+    mnemonic,
+    { log: ctx.log },
+  );
+
+  if (!snapshot) {
+    ctx.log.warn({ agentId, hubUrl }, 'Snapshot fetch failed, will retry');
+    return;
+  }
+
+  let upsertCount = 0;
+
+  const upsert = async (hash: string, authorAuraId: number, authorPublicKey: string, type: string, body: string, timestamp: number) => {
+    await ctx.prisma.inboundMessage.upsert({
+      where: { hash_hubUrl: { hash, hubUrl } },
+      create: { agentId, hash, hubUrl, authorAuraId, authorPublicKey, type, body, timestamp },
+      update: {},
+    }).catch((err: unknown) => {
+      ctx.log.debug({ err, hash }, 'Snapshot upsert failed (likely race)');
+    });
+    upsertCount++;
+  };
+
+  // following → synthetic link_add (we follow them)
+  for (const entry of snapshot.following ?? []) {
+    const hash = syntheticHash('following', agentId, entry.publicKey);
+    const body = JSON.stringify({ followeePublicKey: entry.publicKey, followeeAuraId: entry.auraId });
+    await upsert(hash, entry.auraId, pubKey, 'link_add', body, entry.timestamp);
+  }
+
+  // followers → synthetic link_add with followeePublicKey = our key
+  for (const entry of snapshot.followers ?? []) {
+    const hash = syntheticHash('follower', agentId, entry.publicKey);
+    const body = JSON.stringify({ followeePublicKey: pubKey, followerPublicKey: entry.publicKey });
+    await upsert(hash, entry.auraId, entry.publicKey, 'link_add', body, entry.timestamp);
+  }
+
+  // feed → direct upsert
+  for (const msg of snapshot.feed ?? []) {
+    await upsert(msg.hash, msg.authorAuraId, msg.authorPublicKey ?? '', msg.type, msg.body, msg.timestamp);
+  }
+
+  // notifications → direct upsert
+  for (const msg of snapshot.notifications ?? []) {
+    await upsert(msg.hash, msg.authorAuraId, msg.authorPublicKey ?? '', msg.type, msg.body, msg.timestamp);
+  }
+
+  // Set cursor to latest global seq and switch to incremental
+  const latestSeq = snapshot.latestSeq ?? cursor?.seq ?? 0;
+  await ctx.prisma.hubSubscription.update({
+    where: { id: subscriptionId },
+    data: {
+      inboundSeq: latestSeq,
+      inboundMode: 'incremental',
+    },
+  });
+
+  ctx.log.info(
+    { agentId, hubUrl, upsertCount, seq: latestSeq },
+    'Snapshot sync complete, switching to incremental',
+  );
+}
+
+// ─── Incremental mode ────────────────────────────────────────────────
+
+/** Pull events once from the hub starting at the lowest agent cursor. */
+async function fetchEventBatch(
+  sinceSeq: number,
+  hubUrl: string,
+  publicKey: string,
+  mnemonic: string,
+  ctx: CronContext,
+): Promise<{ events: HubEvent[]; latestSeq: number } | null> {
+  const params: Record<string, unknown> = {
+    sinceSeq,
+    limit: EVENT_BATCH_LIMIT,
+    publicKey: normalizeHubPublicKey(publicKey),
+    streams: RELEVANT_STREAMS,
+  };
+  return tryCallHubWithSessionAuth<EventsResponse>(
+    hubUrl,
+    'sync.events.relevant',
+    params,
+    mnemonic,
+    { log: ctx.log },
+  );
+}
+
+/** Fan-out: filter a batch of events for a single agent and persist relevant ones. */
+async function processEventsForAgent(
+  agentId: string,
+  publicKeyHex: string,
+  events: HubEvent[],
+  hubUrl: string,
+  ctx: CronContext,
+): Promise<number> {
+  let maxSeq = 0;
+
+  for (const event of events) {
+    const isRemove = event.type.endsWith('_remove');
+
+    if (isRemove) {
+      await handleRemove(agentId, event.type, event.body, ctx);
+    } else {
+      // Filter: should we cache this message?
+      let shouldCache = false;
+
+      // Is this a credential_add for my publicKey?
+      if (event.type === 'credential_add' && isCredentialForMe(event.body, publicKeyHex)) {
+        shouldCache = true;
+      }
+      // Is this a link_add targeting my publicKey? (new follower)
+      else if (event.type === 'link_add' && isFollowingMe(event.body, publicKeyHex)) {
+        shouldCache = true;
+      }
+      // Is authorPublicKey someone I follow? (feed content)
+      else if (await isFollowing(agentId, event.authorPublicKey, ctx)) {
+        shouldCache = true;
+      }
+      // Is this a reaction/reply to one of my posts? (notification)
+      else if (await referencesMyPost(agentId, event.body, ctx)) {
+        shouldCache = true;
+      }
+
+      if (shouldCache) {
+        await ctx.prisma.inboundMessage.upsert({
+          where: { hash_hubUrl: { hash: event.hash, hubUrl } },
+          create: {
+            agentId,
+            hash: event.hash,
+            hubUrl,
+            authorAuraId: event.authorAuraId,
+            authorPublicKey: event.authorPublicKey ?? '',
+            type: event.type,
+            body: event.body,
+            timestamp: event.timestamp,
+          },
+          update: {},
+        }).catch((err: unknown) => {
+          ctx.log.debug({ err, hash: event.hash }, 'Incremental upsert failed (likely race)');
+        });
+
+        // Generate social notifications for notification-worthy events
+        await createSocialNotification(agentId, publicKeyHex, event, ctx);
+      }
+    }
+
+    if (event.seq > maxSeq) maxSeq = event.seq;
+  }
+
+  return maxSeq;
+}
+
+/**
+ * Incremental sync for a single agent against a single hub.
+ * Pull events from the hub and filter/cache locally.
+ */
+async function runIncremental(
+  agentId: string,
+  publicKeyHex: string,
+  currentSeq: number,
+  hubUrl: string,
+  mnemonic: string,
+  subscriptionId: string,
+  ctx: CronContext,
+): Promise<void> {
+  let seq = currentSeq;
+  let batchCount = 0;
+
+  do {
+    const data = await fetchEventBatch(seq, hubUrl, publicKeyHex, mnemonic, ctx);
+    if (!data) break;
+    if (!data.events || data.events.length === 0) {
+      if (data.latestSeq > seq) {
+        seq = data.latestSeq;
+      }
+      break;
+    }
+
+    batchCount = data.events.length;
+
+    const maxSeq = await processEventsForAgent(agentId, publicKeyHex, data.events, hubUrl, ctx);
+    if (maxSeq > seq) seq = maxSeq;
+    if (batchCount < EVENT_BATCH_LIMIT && data.latestSeq > seq) {
+      seq = data.latestSeq;
+    }
+  } while (batchCount === EVENT_BATCH_LIMIT);
+
+  if (seq > currentSeq) {
+    await ctx.prisma.hubSubscription.update({
+      where: { id: subscriptionId },
+      data: { inboundSeq: seq },
+    });
+    ctx.log.debug({ agentId, hubUrl, oldSeq: currentSeq, newSeq: seq }, 'Incremental sync advanced cursor');
+  }
+}
+
+// ─── Job Definition ──────────────────────────────────────────────────
+
+export const socialInboundJob: CronJob = {
+  id: 'social-inbound',
+  name: 'Social Inbound Sync',
+  intervalKey: 'social_inbound_interval',
+  defaultInterval: 5_000,
+
+  async run(ctx: CronContext): Promise<void> {
+    if (!isEnabled('SOCIAL')) return;
+
+    // Sync inbound cache for every local agent with a social identity.
+    const agents = await ctx.prisma.agentProfile.findMany({
+      where: { publicKeyHex: { not: null } },
+      orderBy: { createdAt: 'asc' },
+    });
+
+    if (agents.length === 0) return;
+
+    for (const agent of agents) {
+      const agentId = agent.agentId;
+      const publicKeyHex = agent.publicKeyHex;
+      if (!publicKeyHex) continue;
+
+      const mnemonic = getAgentMnemonic(agentId);
+      if (!mnemonic) {
+        ctx.log.warn({ agentId }, 'Skipping social inbound sync because agent is locked');
+        continue;
+      }
+
+      // Iterate over all subscribed hubs for this agent.
+      const subscriptions = await ctx.prisma.hubSubscription.findMany({
+        where: { agentId },
+      });
+
+      // Fallback: if no subscriptions exist yet (pre-migration), create one
+      // from the legacy single-hub config so existing users aren't broken.
+      if (subscriptions.length === 0) {
+        const defaultHubUrl = getHubUrl();
+        const sub = await ctx.prisma.hubSubscription.upsert({
+          where: { agentId_hubUrl: { agentId, hubUrl: defaultHubUrl } },
+          create: {
+            agentId,
+            hubUrl: defaultHubUrl,
+            label: 'AuraMaxx',
+            auraId: null,
+            inboundSeq: agent.inboundSeq,
+            inboundMode: agent.inboundMode,
+          },
+          update: {},
+        });
+        subscriptions.push(sub);
+      }
+
+      for (const sub of subscriptions) {
+        const hubUrl = sub.hubUrl;
+        const currentSeq = sub.inboundSeq ?? 0;
+        const mode = sub.inboundMode;
+
+        // Fetch snapshot-cursor for this (agent, hub) pair.
+        // Do not share cursor responses across agents because auth/whitelist
+        // can differ by caller key.
+        const snapshotCursor = await tryCallHubWithSessionAuth<SnapshotCursorResponse>(
+          hubUrl,
+          'sync.snapshotCursor',
+          {},
+          mnemonic,
+          { log: ctx.log },
+        );
+
+        const isStale =
+          snapshotCursor !== null &&
+          currentSeq > 0 &&
+          mode === 'incremental' &&
+          (snapshotCursor.seq - currentSeq) > STALENESS_THRESHOLD;
+
+        const needsSnapshot =
+          mode !== 'incremental' ||
+          currentSeq === 0 ||
+          isStale;
+
+        if (isStale) {
+          ctx.log.info(
+            { agentId, hubUrl, currentSeq, hubSeq: snapshotCursor!.seq, threshold: STALENESS_THRESHOLD },
+            'Stale cursor, falling back to snapshot mode',
+          );
+        }
+
+        try {
+          if (needsSnapshot) {
+            await runSnapshot(agentId, hubUrl, mnemonic, sub.id, ctx);
+          } else {
+            await runIncremental(agentId, publicKeyHex, currentSeq, hubUrl, mnemonic, sub.id, ctx);
+          }
+        } catch (err) {
+          ctx.log.error({ err, agentId, hubUrl }, 'Inbound sync failed for hub');
+        }
+      }
+    }
+  },
+};

package/src/server/cron/jobs/social-outbound.ts

@@ -0,0 +1,70 @@
+/**
+ * Social Outbound Sync Job
+ * ========================
+ * Batches pending SocialMessages and POSTs them to the hub.
+ * Handles 207 multi-status response: accepted, duplicate, rejected, error.
+ * Exponential backoff on failures (max 5 minutes).
+ */
+
+import type { CronJob, CronContext } from '../job';
+import type { SocialMessage } from '@prisma/client';
+import { isEnabled } from '../../lib/feature-flags';
+import { syncSocialMessagesNow } from '../../lib/social/sync';
+import { getHubUrl } from '../../lib/defaults';
+const BATCH_LIMIT = 200;
+
+// --- Job Definition ---
+
+export const socialOutboundJob: CronJob = {
+  id: 'social-outbound',
+  name: 'Social Outbound Sync',
+  intervalKey: 'social_outbound_interval',
+  defaultInterval: 2_000,
+
+  async run(ctx: CronContext): Promise<void> {
+    if (!isEnabled('SOCIAL')) return;
+
+    // Query pending messages ready to sync
+    const pending = await ctx.prisma.socialMessage.findMany({
+      where: {
+        syncStatus: 'pending',
+        OR: [
+          { nextRetryAt: null },
+          { nextRetryAt: { lte: new Date() } },
+        ],
+      },
+      orderBy: { createdAt: 'asc' },
+      take: BATCH_LIMIT,
+    });
+
+    if (pending.length === 0) return;
+
+    // Group by (agentId, hubUrl) — each group syncs to its respective hub
+    const groups = new Map<string, SocialMessage[]>();
+    for (const msg of pending) {
+      const key = `${msg.agentId}\0${msg.hubUrl}`;
+      const list = groups.get(key) ?? [];
+      list.push(msg);
+      groups.set(key, list);
+    }
+
+    for (const [key, messages] of groups) {
+      const sepIdx = key.indexOf('\0');
+      const agentId = key.slice(0, sepIdx);
+      const msgHubUrl = key.slice(sepIdx + 1);
+      const hubUrl = msgHubUrl || getHubUrl(); // "" = default hub
+
+      try {
+        await syncSocialMessagesNow({
+          messages,
+          transientErrorMode: 'retry',
+          prismaClient: ctx.prisma,
+          hubUrl,
+          log: ctx.log,
+        });
+      } catch (err) {
+        ctx.log.error({ err, agentId, hubUrl }, 'Outbound sync failed for agent/hub');
+      }
+    }
+  },
+};