auramaxx 0.0.20 → 0.1.1

package/src/server/routes/addressbook.ts

@@ -1,129 +0,0 @@
-import { Router, Request, Response } from 'express';
-import { prisma } from '../lib/db';
-import { requireWalletAuth, optionalWalletAuth } from '../middleware/auth';
-import { isAdmin } from '../lib/permissions';
-import { getErrorMessage } from '../lib/error';
-import { respondPermissionDenied } from '../lib/escalation-responder';
-import { ESCALATION_ROUTE_IDS } from '../lib/escalation-route-registry';
-
-const router = Router();
-
-// GET /address-labels - List all address labels
-router.get('/', optionalWalletAuth, async (req: Request, res: Response) => {
-  try {
-    const q = req.query.q as string | undefined;
-
-    const where: Record<string, unknown> = {};
-    if (q) {
-      where.OR = [
-        { label: { contains: q } },
-        { address: { contains: q.toLowerCase() } },
-      ];
-    }
-
-    const labels = await prisma.addressLabel.findMany({
-      where,
-      orderBy: { updatedAt: 'desc' },
-    });
-
-    res.json({ success: true, labels });
-  } catch (error) {
-    const message = getErrorMessage(error);
-    res.status(400).json({ error: message });
-  }
-});
-
-// POST /address-labels - Create or update an address label (upsert by address)
-router.post('/', requireWalletAuth, async (req: Request, res: Response) => {
-  try {
-    const auth = req.auth!;
-
-    // Check permission
-    if (!isAdmin(auth)) {
-      const perms = auth.token.permissions;
-      if (!perms.includes('addressbook:write') && !perms.includes('admin:*')) {
-        await respondPermissionDenied({
-          req,
-          res,
-          routeId: ESCALATION_ROUTE_IDS.ADDRESSBOOK_WRITE,
-          error: 'Token does not have addressbook:write permission',
-          required: ['addressbook:write'],
-          have: auth.token.permissions,
-        });
-        return;
-      }
-    }
-
-    const { address, label, emoji, color, notes } = req.body;
-
-    if (!address || !label) {
-      res.status(400).json({ error: 'address and label are required' });
-      return;
-    }
-
-    const createdBy = isAdmin(auth) ? 'human' : auth.token.agentId;
-
-    const entry = await prisma.addressLabel.upsert({
-      where: { address: address.toLowerCase() },
-      create: {
-        address: address.toLowerCase(),
-        label,
-        emoji: emoji || undefined,
-        color: color || undefined,
-        notes: notes || undefined,
-        createdBy,
-      },
-      update: {
-        label,
-        ...(emoji !== undefined && { emoji }),
-        ...(color !== undefined && { color }),
-        ...(notes !== undefined && { notes }),
-      },
-    });
-
-    res.json({ success: true, label: entry });
-  } catch (error) {
-    const message = getErrorMessage(error);
-    res.status(400).json({ error: message });
-  }
-});
-
-// DELETE /address-labels/:id - Delete an address label
-router.delete('/:id', requireWalletAuth, async (req: Request<{ id: string }>, res: Response) => {
-  try {
-    const auth = req.auth!;
-
-    // Check permission
-    if (!isAdmin(auth)) {
-      const perms = auth.token.permissions;
-      if (!perms.includes('addressbook:write') && !perms.includes('admin:*')) {
-        await respondPermissionDenied({
-          req,
-          res,
-          routeId: ESCALATION_ROUTE_IDS.ADDRESSBOOK_WRITE,
-          error: 'Token does not have addressbook:write permission',
-          required: ['addressbook:write'],
-          have: auth.token.permissions,
-        });
-        return;
-      }
-    }
-
-    const { id } = req.params;
-
-    const existing = await prisma.addressLabel.findUnique({ where: { id } });
-    if (!existing) {
-      res.status(404).json({ error: 'Address label not found' });
-      return;
-    }
-
-    await prisma.addressLabel.delete({ where: { id } });
-
-    res.json({ success: true });
-  } catch (error) {
-    const message = getErrorMessage(error);
-    res.status(400).json({ error: message });
-  }
-});
-
-export default router;

package/src/server/routes/agent-hub.ts

@@ -1,276 +0,0 @@
-import { Request, Response, Router } from 'express';
-import { requireWalletAuth } from '../middleware/auth';
-import { requireAdmin } from '../lib/permissions';
-import { getAgentMnemonic, isAgentUnlocked, listAgents } from '../lib/cold';
-import { registerOnHub } from '../lib/social/register';
-import { syncGlobalAuraIdForAgent } from '../lib/social/global-aura-id';
-import { prisma } from '../lib/db';
-import { getHubUrl } from '../lib/defaults';
-import { log } from '../lib/pino';
-
-const router = Router();
-
-// GET /agent-hub/default — return the configured primary hub URL
-router.get('/default', requireWalletAuth, requireAdmin, async (_req: Request, res: Response) => {
-  return res.json({ hubUrl: getHubUrl() });
-});
-
-// GET /agent-hub/:agentId/status — hub registration status for an agent
-router.get('/:agentId/status', requireWalletAuth, requireAdmin, async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const { agentId } = req.params;
-    const hubUrl = getHubUrl();
-
-    const agents = listAgents();
-    const agent = agents.find(a => a.id === agentId);
-    if (!agent) {
-      return res.status(404).json({ error: 'Agent not found' });
-    }
-
-    const [profile, subscription] = await Promise.all([
-      prisma.agentProfile.findUnique({ where: { agentId } }),
-      prisma.hubSubscription.findUnique({
-        where: {
-          agentId_hubUrl: {
-            agentId,
-            hubUrl,
-          },
-        },
-      }),
-    ]);
-
-    const auraId = subscription?.auraId ?? null;
-    const publicKeyHex = profile?.publicKeyHex ?? null;
-
-    return res.json({
-      agentId,
-      hubUrl,
-      auraId,
-      publicKeyHex,
-      registered: subscription?.auraId != null,
-      hasPublicKey: publicKeyHex !== null,
-    });
-  } catch (error) {
-    log.error({ error }, 'agent-hub status error');
-    return res.status(500).json({ error: 'Failed to fetch hub status' });
-  }
-});
-
-// POST /agent-hub/:agentId/register — register agent on the default hub
-router.post('/:agentId/register', requireWalletAuth, requireAdmin, async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const { agentId } = req.params;
-
-    const agents = listAgents();
-    const agent = agents.find(a => a.id === agentId);
-    if (!agent) {
-      return res.status(404).json({ error: 'Agent not found' });
-    }
-
-    if (!isAgentUnlocked(agentId)) {
-      return res.status(400).json({ error: 'Agent must be unlocked to register' });
-    }
-
-    const mnemonic = getAgentMnemonic(agentId);
-    if (!mnemonic) {
-      return res.status(400).json({ error: 'Cannot access agent mnemonic' });
-    }
-
-    const hubUrl = getHubUrl();
-    const result = await registerOnHub(agentId, mnemonic, hubUrl, 'Primary Hub');
-    const auraId = result.auraId;
-    await syncGlobalAuraIdForAgent(agentId, mnemonic);
-
-    return res.json({ agentId, auraId, hubUrl });
-  } catch (error) {
-    log.error({ error }, 'agent-hub register error');
-    const message = error instanceof Error ? error.message : 'Registration failed';
-    return res.status(500).json({ error: message });
-  }
-});
-
-// GET /agent-hub/:agentId/hubs — list all subscribed hubs for an agent
-router.get('/:agentId/hubs', requireWalletAuth, requireAdmin, async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const { agentId } = req.params;
-
-    const hubs = await prisma.hubSubscription.findMany({
-      where: { agentId },
-      orderBy: { joinedAt: 'asc' },
-    });
-
-    return res.json({ hubs });
-  } catch (error) {
-    log.error({ error }, 'agent-hub list error');
-    return res.status(500).json({ error: 'Failed to list hubs' });
-  }
-});
-
-// POST /agent-hub/:agentId/join — join a new hub
-router.post('/:agentId/join', requireWalletAuth, requireAdmin, async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const { agentId } = req.params;
-    const { hubUrl, label } = req.body;
-
-    if (typeof hubUrl !== 'string' || !hubUrl.trim()) {
-      return res.status(400).json({ error: 'hubUrl is required' });
-    }
-
-    const normalizedUrl = hubUrl.trim().replace(/\/+$/, ''); // strip trailing slashes
-
-    const agents = listAgents();
-    const agent = agents.find(a => a.id === agentId);
-    if (!agent) {
-      return res.status(404).json({ error: 'Agent not found' });
-    }
-
-    if (!isAgentUnlocked(agentId)) {
-      return res.status(400).json({ error: 'Agent must be unlocked to join a hub' });
-    }
-
-    const mnemonic = getAgentMnemonic(agentId);
-    if (!mnemonic) {
-      return res.status(400).json({ error: 'Cannot access agent mnemonic' });
-    }
-
-    // Discover frontend URL from hub's /info endpoint.
-    // Works whether the user pasted the frontend URL (Next.js proxies /info)
-    // or the backend URL (Express serves /info directly).
-    let frontendUrl: string | null = null;
-    try {
-      const infoRes = await fetch(`${normalizedUrl}/info`);
-      if (infoRes.ok) {
-        const info = await infoRes.json() as { name?: string; frontendUrl?: string };
-        frontendUrl = info.frontendUrl || normalizedUrl;
-      }
-    } catch {
-      // Hub may not expose /info — that's fine
-    }
-
-    const result = await registerOnHub(
-      agentId,
-      mnemonic,
-      normalizedUrl,
-      typeof label === 'string' ? label.trim() || undefined : undefined,
-    );
-
-    // Persist discovered frontend URL
-    if (frontendUrl) {
-      await prisma.hubSubscription.update({
-        where: { id: result.subscriptionId },
-        data: { frontendUrl },
-      });
-    }
-
-    const sub = await prisma.hubSubscription.findUnique({
-      where: { id: result.subscriptionId },
-    });
-
-    return res.json({ hub: sub });
-  } catch (error) {
-    log.error({ error }, 'agent-hub join error');
-    const message = error instanceof Error ? error.message : 'Failed to join hub';
-    return res.status(500).json({ error: message });
-  }
-});
-
-// POST /agent-hub/:agentId/leave — leave a hub (prune all data)
-router.post('/:agentId/leave', requireWalletAuth, requireAdmin, async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const { agentId } = req.params;
-    const { hubUrl } = req.body;
-
-    if (typeof hubUrl !== 'string' || !hubUrl.trim()) {
-      return res.status(400).json({ error: 'hubUrl is required' });
-    }
-
-    const normalizedUrl = hubUrl.trim().replace(/\/+$/, '');
-
-    // Don't allow leaving the default hub
-    const defaultHub = getHubUrl();
-    if (normalizedUrl === defaultHub) {
-      return res.status(400).json({ error: 'Cannot leave the default hub' });
-    }
-
-    // Delete subscription
-    await prisma.hubSubscription.deleteMany({
-      where: { agentId, hubUrl: normalizedUrl },
-    });
-
-    // Prune inbound messages from this hub
-    await prisma.inboundMessage.deleteMany({
-      where: { agentId, hubUrl: normalizedUrl },
-    });
-
-    // Cancel pending outbound messages for this hub
-    await prisma.socialMessage.updateMany({
-      where: { agentId, hubUrl: normalizedUrl, syncStatus: 'pending' },
-      data: { syncStatus: 'failed', syncCode: 'hub_left', syncDetail: 'Left hub' },
-    });
-
-    log.info({ agentId, hubUrl: normalizedUrl }, 'Agent left hub, data pruned');
-    return res.json({ ok: true });
-  } catch (error) {
-    log.error({ error }, 'agent-hub leave error');
-    return res.status(500).json({ error: 'Failed to leave hub' });
-  }
-});
-
-// POST /agent-hub/:agentId/purge — purge all local data for a hub without leaving
-router.post('/:agentId/purge', requireWalletAuth, requireAdmin, async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const { agentId } = req.params;
-    const { hubUrl } = req.body;
-
-    if (typeof hubUrl !== 'string' || !hubUrl.trim()) {
-      return res.status(400).json({ error: 'hubUrl is required' });
-    }
-
-    const normalizedUrl = hubUrl.trim().replace(/\/+$/, '');
-
-    // Resolve effective hubUrl for DB queries.
-    // InboundMessage/SocialMessage use "" for the default hub.
-    const defaultHub = getHubUrl();
-    const dbHubUrl = normalizedUrl === defaultHub ? '' : normalizedUrl;
-
-    // Delete all cached inbound messages from this hub
-    const inbound = await prisma.inboundMessage.deleteMany({
-      where: { agentId, hubUrl: dbHubUrl },
-    });
-
-    // Delete all outbound social messages for this hub
-    const outbound = await prisma.socialMessage.deleteMany({
-      where: { agentId, hubUrl: dbHubUrl },
-    });
-
-    // Reset the subscription cursor so inbound sync re-bootstraps from scratch
-    const sub = await prisma.hubSubscription.findFirst({
-      where: { agentId, hubUrl: normalizedUrl },
-    });
-    if (sub) {
-      await prisma.hubSubscription.update({
-        where: { id: sub.id },
-        data: { inboundSeq: 0, inboundMode: 'snapshot' },
-      });
-    }
-
-    log.info(
-      { agentId, hubUrl: normalizedUrl, inbound: inbound.count, outbound: outbound.count },
-      'Purged all local hub data',
-    );
-
-    return res.json({
-      ok: true,
-      purged: {
-        inboundMessages: inbound.count,
-        socialMessages: outbound.count,
-        cursorReset: !!sub,
-      },
-    });
-  } catch (error) {
-    log.error({ error }, 'agent-hub purge error');
-    return res.status(500).json({ error: 'Failed to purge hub data' });
-  }
-});
-
-export default router;

package/src/server/routes/agent-profiles.ts

@@ -1,208 +0,0 @@
-import { Request, Response, Router } from 'express';
-import { requireWalletAuth } from '../middleware/auth';
-import { requireAdmin } from '../lib/permissions';
-import { getErrorMessage } from '../lib/error';
-import { prisma } from '../lib/db';
-
-const router = Router();
-
-router.use(requireWalletAuth, requireAdmin);
-
-function normalizeAgentIdParam(value: string): string {
-  const decoded = decodeURIComponent(String(value || ''));
-  const agentId = decoded.trim();
-  if (!agentId) {
-    throw new Error('agentId path param is required');
-  }
-  return agentId;
-}
-
-// ---------------------------------------------------------------------------
-// Input normalization (moved from shared/agent-profile-schema.ts)
-// ---------------------------------------------------------------------------
-
-function readOptionalString(input: Record<string, unknown>, key: string, aliases: string[] = []): string | undefined {
-  const candidates = [key, ...aliases];
-  for (const candidate of candidates) {
-    const value = input[candidate];
-    if (value === undefined || value === null) continue;
-    if (typeof value !== 'string') {
-      throw new Error(`agent profile field "${key}" must be a string`);
-    }
-    const trimmed = value.trim();
-    if (!trimmed) return undefined;
-    return trimmed;
-  }
-  return undefined;
-}
-
-function readAttributes(input: Record<string, unknown>): Record<string, string> | undefined {
-  const raw = input.attributes ?? input.custom_attributes ?? input.customAttributes;
-  if (raw === undefined || raw === null) return undefined;
-  if (typeof raw !== 'object' || Array.isArray(raw)) {
-    throw new Error('agent profile field "attributes" must be an object');
-  }
-
-  const attributes: Record<string, string> = {};
-  for (const [rawKey, rawValue] of Object.entries(raw as Record<string, unknown>)) {
-    const key = rawKey.trim();
-    if (!key) {
-      throw new Error('agent profile attribute keys must be non-empty');
-    }
-    if (typeof rawValue !== 'string') {
-      throw new Error(`agent profile attribute "${key}" must be a string`);
-    }
-    attributes[key] = rawValue;
-  }
-
-  return Object.keys(attributes).length > 0 ? attributes : undefined;
-}
-
-interface NormalizedProfileInput {
-  agentId: string;
-  email?: string;
-  phone?: string;
-  address?: string;
-  profileImage?: string;
-  attributes?: Record<string, string>;
-}
-
-function normalizeAgentProfileInput(
-  value: unknown,
-  options: { fallbackAgentId?: string } = {},
-): NormalizedProfileInput {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    throw new Error('agent profile payload must be an object');
-  }
-  const input = value as Record<string, unknown>;
-
-  const rawAgentId = input.agentId ?? input.agent_id ?? options.fallbackAgentId;
-  if (typeof rawAgentId !== 'string' || rawAgentId.trim().length === 0) {
-    throw new Error('agent profile requires non-empty agentId');
-  }
-  const agentId = rawAgentId.trim();
-
-  const email = readOptionalString(input, 'email');
-  const phone = readOptionalString(input, 'phone');
-  const address = readOptionalString(input, 'address');
-  const profileImage = readOptionalString(input, 'profileImage', ['profile_image']);
-  const attributes = readAttributes(input);
-
-  return {
-    agentId,
-    ...(email ? { email } : {}),
-    ...(phone ? { phone } : {}),
-    ...(address ? { address } : {}),
-    ...(profileImage ? { profileImage } : {}),
-    ...(attributes ? { attributes } : {}),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Prisma row → API response shape
-// ---------------------------------------------------------------------------
-
-interface ProfileRow {
-  agentId: string;
-  email: string | null;
-  phone: string | null;
-  address: string | null;
-  profileImage: string | null;
-  attributes: string | null;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-function toApiProfile(row: ProfileRow) {
-  return {
-    agentId: row.agentId,
-    email: row.email ?? undefined,
-    phone: row.phone ?? undefined,
-    address: row.address ?? undefined,
-    profileImage: row.profileImage ?? undefined,
-    attributes: row.attributes ? JSON.parse(row.attributes) : undefined,
-    createdAt: row.createdAt.toISOString(),
-    updatedAt: row.updatedAt.toISOString(),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Routes
-// ---------------------------------------------------------------------------
-
-router.get('/', async (_req: Request, res: Response) => {
-  try {
-    const rows = await prisma.agentProfile.findMany({ orderBy: { agentId: 'asc' } });
-    const profiles = rows.map(toApiProfile);
-    res.json({ success: true, profiles });
-  } catch (error) {
-    res.status(500).json({ success: false, error: getErrorMessage(error) });
-  }
-});
-
-router.get('/:agentId', async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const agentId = normalizeAgentIdParam(req.params.agentId);
-    const row = await prisma.agentProfile.findUnique({ where: { agentId } });
-    if (!row) {
-      res.status(404).json({ success: false, error: 'Agent profile not found' });
-      return;
-    }
-    res.json({ success: true, profile: toApiProfile(row) });
-  } catch (error) {
-    res.status(400).json({ success: false, error: getErrorMessage(error) });
-  }
-});
-
-router.put('/:agentId', async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const agentId = normalizeAgentIdParam(req.params.agentId);
-    const body = req.body && typeof req.body === 'object' && !Array.isArray(req.body)
-      ? req.body as Record<string, unknown>
-      : {};
-    const bodyAgentIdRaw = body.agentId ?? body.agent_id;
-    if (typeof bodyAgentIdRaw === 'string' && bodyAgentIdRaw.trim() && bodyAgentIdRaw.trim() !== agentId) {
-      res.status(400).json({ success: false, error: 'body agentId must match path param' });
-      return;
-    }
-    const normalized = normalizeAgentProfileInput(body, { fallbackAgentId: agentId });
-    const row = await prisma.agentProfile.upsert({
-      where: { agentId },
-      create: {
-        agentId,
-        email: normalized.email ?? null,
-        phone: normalized.phone ?? null,
-        address: normalized.address ?? null,
-        profileImage: normalized.profileImage ?? null,
-        attributes: normalized.attributes ? JSON.stringify(normalized.attributes) : null,
-      },
-      update: {
-        email: normalized.email ?? null,
-        phone: normalized.phone ?? null,
-        address: normalized.address ?? null,
-        profileImage: normalized.profileImage ?? null,
-        attributes: normalized.attributes ? JSON.stringify(normalized.attributes) : null,
-      },
-    });
-    res.json({ success: true, profile: toApiProfile(row) });
-  } catch (error) {
-    res.status(400).json({ success: false, error: getErrorMessage(error) });
-  }
-});
-
-router.delete('/:agentId', async (req: Request<{ agentId: string }>, res: Response) => {
-  try {
-    const agentId = normalizeAgentIdParam(req.params.agentId);
-    const existing = await prisma.agentProfile.findUnique({ where: { agentId } });
-    if (!existing) {
-      res.status(404).json({ success: false, error: 'Agent profile not found' });
-      return;
-    }
-    await prisma.agentProfile.delete({ where: { agentId } });
-    res.json({ success: true, deleted: true, agentId });
-  } catch (error) {
-    res.status(400).json({ success: false, error: getErrorMessage(error) });
-  }
-});
-
-export default router;

package/src/server/routes/ai.ts

@@ -1,34 +0,0 @@
-import { Router, Request, Response } from 'express';
-import { requireWalletAuth } from '../middleware/auth';
-import { requireAdmin } from '../lib/permissions';
-import { getProviderMode, MODEL_TIERS, getProviderStatus, AiProviderMode } from '../lib/ai';
-import { getErrorMessage } from '../lib/error';
-
-const router = Router();
-
-/**
- * GET /ai/status
- * Returns active provider, default model, and availability of all providers.
- * Used by the dashboard UI to populate the AI Engine settings section.
- * Auth: admin only.
- */
-router.get('/status', requireWalletAuth, requireAdmin, async (_req: Request, res: Response) => {
-  try {
-    const [activeProvider, providers] = await Promise.all([
-      getProviderMode(),
-      getProviderStatus(),
-    ]);
-    const tiers = MODEL_TIERS[activeProvider as AiProviderMode];
-
-    res.json({
-      activeProvider,
-      tiers,
-      providers,
-    });
-  } catch (error) {
-    const message = getErrorMessage(error);
-    res.status(500).json({ error: message });
-  }
-});
-
-export default router;