@oxy.so/core 1.18.0 → 3.0.0

package/src/mixins/index.ts

@@ -1,203 +0,0 @@
-/**
- * Centralized mixin exports and composition helper
- *
- * This module provides a clean way to compose all mixins
- * and ensures consistent ordering for better maintainability
- */
-
-import { OxyServicesBase } from '../OxyServices.base';
-import { OxyServicesAuthMixin } from './OxyServices.auth';
-import { OxyServicesUserMixin } from './OxyServices.user';
-import { OxyServicesIdentityMixin } from './OxyServices.identity';
-import { OxyServicesIdentityBackupMixin } from './OxyServices.identityBackup';
-import { OxyServicesPrivacyMixin } from './OxyServices.privacy';
-import { OxyServicesLanguageMixin } from './OxyServices.language';
-import { OxyServicesPaymentMixin } from './OxyServices.payment';
-import { OxyServicesReputationMixin } from './OxyServices.reputation';
-import { OxyServicesAssetsMixin } from './OxyServices.assets';
-import { OxyServicesAccountsMixin } from './OxyServices.accounts';
-import { OxyServicesConnectedAppsMixin } from './OxyServices.connectedApps';
-import { OxyServicesAgencyMixin } from './OxyServices.agency';
-import { OxyServicesStoreMixin } from './OxyServices.store';
-import { OxyServicesLocationMixin } from './OxyServices.location';
-import { OxyServicesAnalyticsMixin } from './OxyServices.analytics';
-import { OxyServicesDevicesMixin } from './OxyServices.devices';
-import { OxyServicesSecurityMixin } from './OxyServices.security';
-import { OxyServicesUtilityMixin } from './OxyServices.utility';
-import { OxyServicesFeaturesMixin } from './OxyServices.features';
-import { OxyServicesTopicsMixin } from './OxyServices.topics';
-import { OxyServicesContactsMixin } from './OxyServices.contacts';
-import { OxyServicesNotificationsMixin } from './OxyServices.notifications';
-import { OxyServicesAppDataMixin } from './OxyServices.appData';
-import { OxyServicesCivicMixin } from './OxyServices.civic';
-import { OxyServicesChainsMixin } from './OxyServices.chains';
-import { OxyServicesNodesMixin } from './OxyServices.nodes';
-import { OxyServicesFollowGraphMixin } from './OxyServices.followGraph';
-import { OxyServicesInferenceMixin } from './OxyServices.inference';
-import { OxyServicesDeviceBootMixin } from './OxyServices.deviceBoot';
-import { OxyServicesLinkedAccountsMixin } from './OxyServices.linkedAccounts';
-
-/**
- * Instance shape of every mixin in the pipeline, intersected. The runtime
- * `composeOxyServices()` produces a class whose instances expose all of
- * these methods; we surface that to TypeScript via this intersection so the
- * `extends` site in `OxyServices.ts` can avoid an `as any` cast.
- *
- * If you add a new mixin to `MIXIN_PIPELINE`, add it here too so its methods
- * are visible without a cast.
- */
-type AllMixinInstances =
-  & InstanceType<ReturnType<typeof OxyServicesAuthMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesUserMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesIdentityMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesIdentityBackupMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesPrivacyMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesLanguageMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesPaymentMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesReputationMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesAssetsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesAccountsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesConnectedAppsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesAgencyMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesStoreMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesLocationMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesAnalyticsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesDevicesMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesSecurityMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesFeaturesMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesTopicsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesContactsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesNotificationsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesAppDataMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesCivicMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesChainsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesNodesMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesFollowGraphMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesInferenceMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesDeviceBootMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesLinkedAccountsMixin<typeof OxyServicesBase>>>
-  & InstanceType<ReturnType<typeof OxyServicesUtilityMixin<typeof OxyServicesBase>>>;
-
-/**
- * Constructor type for the fully composed mixin pipeline. Each mixin returns
- * a new constructor that augments its input; reducing across the pipeline
- * yields an instance with every mixin's methods.
- */
-export type ComposedOxyServicesConstructor = new (config: import('../OxyServices.base').OxyConfig) => AllMixinInstances;
-
-/**
- * A mixin function: takes a constructor and returns an augmented constructor.
- * Each individual mixin uses a `<T extends typeof OxyServicesBase>` generic
- * to preserve its specific augmentations, but those refinements are
- * intentionally collapsed across the `reduce` call below.
- */
-type MixinFunction = (Base: new (...args: unknown[]) => OxyServicesBase) => new (...args: unknown[]) => OxyServicesBase;
-
-/**
- * Mixin pipeline - applied in order from first to last.
- *
- * Order matters for dependencies:
- * 1. Base auth mixin first (required by all others)
- * 2. User mixin (requires auth)
- * 3. Feature mixins (can depend on user)
- * 4. Utility mixin last (augments all)
- *
- * To add a new mixin: insert it at the appropriate position in this array.
- */
-const MIXIN_PIPELINE: MixinFunction[] = [
-    // Base authentication
-    OxyServicesAuthMixin,
-
-    // User management (requires auth)
-    OxyServicesUserMixin,
-    // Self-sovereign identity (DID, signed records, auth-method ↔ VM mapping)
-    OxyServicesIdentityMixin,
-    // Encrypted off-device identity backup (b3 Feature 1): store/restore an
-    // encrypted copy of the self-custody key, keyed off the recovery phrase.
-    OxyServicesIdentityBackupMixin,
-    OxyServicesPrivacyMixin,
-
-    // Feature mixins
-    OxyServicesLanguageMixin,
-    OxyServicesPaymentMixin,
-    OxyServicesReputationMixin,
-    OxyServicesAssetsMixin,
-    // Unified account graph + the applications owned within it. The clean-cut
-    // replacement for the former managedAccounts + workspaces + applications
-    // (account-management) mixins.
-    OxyServicesAccountsMixin,
-    // OAuth-consent surface (public app identity + connected-app grants). Kept
-    // separate from account ownership.
-    OxyServicesConnectedAppsMixin,
-    // Oxy-owned delegated authority for Alia and digital-agent accounts.
-    OxyServicesAgencyMixin,
-    // The app store: the public storefront, the reviews on it, and the listing a
-    // publisher edits. A module OVER the platform — turn it off and OAuth still
-    // works — so it is its own surface rather than more of `accounts`.
-    OxyServicesStoreMixin,
-    OxyServicesLocationMixin,
-    OxyServicesAnalyticsMixin,
-    OxyServicesDevicesMixin,
-    OxyServicesSecurityMixin,
-    OxyServicesFeaturesMixin,
-    OxyServicesTopicsMixin,
-    OxyServicesContactsMixin,
-    // Push-token registration: the one SDK-owned register/unregister pair every
-    // Oxy app uses, and what lets a "Sign in with Oxy" request be delivered to a
-    // known Commons installation instead of falling back to a QR.
-    OxyServicesNotificationsMixin,
-    OxyServicesAppDataMixin,
-    // Civic / Commons "Oxy ID" (public signed cards, Oxy ID QR payload)
-    OxyServicesCivicMixin,
-    OxyServicesChainsMixin,
-    // User nodes / decentralization (Fase 5): register/read/revoke/manage the
-    // caller's personal data node + ingest hint.
-    OxyServicesNodesMixin,
-    // The user-owned follow graph (#809). One relationship per user and target,
-    // shared across applications, with per-application context on top.
-    OxyServicesFollowGraphMixin,
-
-    // The inference model catalogue (#972). Reads only, and deliberately no
-    // request/stream/receipt methods — the public inference edge those would
-    // call is workstream 4 and does not exist yet. See
-    // `docs/inference/README.md` for what is and is not built.
-    OxyServicesInferenceMixin,
-
-    // Device-first token mint: the client half of the zero-cookie transport
-    // (`mintFromDeviceSecret` → `POST /session/device/token`).
-    OxyServicesDeviceBootMixin,
-
-    // Linked external accounts (Mastodon-API, Bluesky) proven by OAuth; the
-    // service read uses the auth mixin's `makeServiceRequest`.
-    OxyServicesLinkedAccountsMixin,
-
-    // Device-to-device identity transfer ("add a device"): E2E-encrypted key
-    // clone over a short-lived relay (b3 Feature 2).
-
-    // Utility (last, can use all above)
-    OxyServicesUtilityMixin,
-];
-
-/**
- * Composes all OxyServices mixins using a pipeline pattern.
- *
- * This is equivalent to the nested calls but more readable and maintainable.
- * Adding a new mixin: add it to MIXIN_PIPELINE at the appropriate position
- * AND extend `AllMixinInstances` so its methods are visible to consumers.
- *
- * The cast through `unknown` carries the runtime augmentation chain into the
- * static type system. `Array.reduce` cannot track each mixin's generic
- * refinement, so we assert the final shape exposed by all mixins together.
- *
- * @returns The fully composed OxyServices constructor with all mixins applied
- */
-export function composeOxyServices(): ComposedOxyServicesConstructor {
-    const composed = MIXIN_PIPELINE.reduce(
-        (Base, mixin) => mixin(Base),
-        OxyServicesBase as unknown as new (...args: unknown[]) => OxyServicesBase
-    );
-    return composed as unknown as ComposedOxyServicesConstructor;
-}
-
-// Export the pipeline for testing/debugging
-export { MIXIN_PIPELINE };

package/src/mixins/mixinHelpers.ts

@@ -1,69 +0,0 @@
-/**
- * Helper utilities for mixin classes
- * Provides common patterns to reduce code duplication
- */
-
-import type { OxyServicesBase } from '../OxyServices.base';
-
-/**
- * Wraps an async method with standard error handling
- * Reduces boilerplate in mixin methods
- */
-export async function withErrorHandling<T>(
-  operation: () => Promise<T>,
-  handleError: (error: any) => Error
-): Promise<T> {
-  try {
-    return await operation();
-  } catch (error) {
-    throw handleError(error);
-  }
-}
-
-/**
- * Creates a standard API request method with error handling
- * Reduces duplication across mixin methods
- */
-export function createApiMethod<T>(
-  makeRequest: OxyServicesBase['makeRequest'],
-  handleError: OxyServicesBase['handleError'],
-  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
-  url: string | ((...args: any[]) => string),
-  options: {
-    cache?: boolean;
-    cacheTTL?: number;
-    retry?: boolean;
-    transformData?: (data: any) => any;
-    transformResponse?: (response: any) => T;
-  } = {}
-) {
-  return async (...args: any[]): Promise<T> => {
-    const urlString = typeof url === 'function' ? url(...args) : url;
-    const requestData = options.transformData ? options.transformData(args) : args[0];
-    
-    const requestOptions = {
-      cache: options.cache ?? true,
-      cacheTTL: options.cacheTTL,
-      retry: options.retry ?? true,
-    };
-
-    try {
-      const response = await makeRequest<T>(method, urlString, requestData, requestOptions);
-      return options.transformResponse ? options.transformResponse(response) : response;
-    } catch (error) {
-      throw handleError(error);
-    }
-  };
-}
-
-/**
- * Cache time constants (in milliseconds)
- */
-export const CACHE_TIMES = {
-  SHORT: 1 * 60 * 1000,      // 1 minute
-  MEDIUM: 2 * 60 * 1000,     // 2 minutes
-  LONG: 5 * 60 * 1000,       // 5 minutes
-  VERY_LONG: 10 * 60 * 1000, // 10 minutes
-  EXTRA_LONG: 30 * 60 * 1000, // 30 minutes
-} as const;
-

package/src/server/__tests__/auth.test.ts

@@ -1,78 +0,0 @@
-import type { NextFunction, Request, Response } from 'express';
-import type { OxyServices } from '../../OxyServices';
-import {
-  createOxyAuthMiddleware,
-  getOxyUserId,
-  getRequiredOxyUserId,
-  requireOxyAuth,
-  type OxyAuthRequest,
-} from '../auth';
-
-function makeResponse(): Response {
-  return {
-    status: jest.fn().mockReturnThis(),
-    json: jest.fn().mockReturnThis(),
-  } as unknown as Response;
-}
-
-function makeNext(): NextFunction {
-  return jest.fn() as unknown as NextFunction;
-}
-
-describe('@oxy.so/core/server auth helpers', () => {
-  it('reads the current user id from userId, user.id, or user._id', () => {
-    expect(getOxyUserId({ userId: 'user-from-request' } as OxyAuthRequest)).toBe('user-from-request');
-    expect(getOxyUserId({ user: { id: 'user-from-id' } } as OxyAuthRequest)).toBe('user-from-id');
-    expect(getOxyUserId({ user: { id: '', _id: 'user-from-mongo-id' } } as OxyAuthRequest)).toBe('user-from-mongo-id');
-    expect(getOxyUserId({ user: { id: '' } } as OxyAuthRequest)).toBeNull();
-  });
-
-  it('throws when a required user id is missing', () => {
-    expect(() => getRequiredOxyUserId({} as Request)).toThrow('User not authenticated');
-  });
-
-  it('returns a consistent 401 when auth is missing', () => {
-    const req = {} as Request;
-    const res = makeResponse();
-    const next = makeNext();
-
-    requireOxyAuth(req, res, next);
-
-    expect(res.status).toHaveBeenCalledWith(401);
-    expect(res.json).toHaveBeenCalledWith({
-      error: 'Unauthorized',
-      message: 'Authentication required',
-    });
-    expect(next).not.toHaveBeenCalled();
-  });
-
-  it('normalizes an authenticated request before continuing', () => {
-    const req = { user: { id: '', _id: 'mongo-user-id' } } as OxyAuthRequest;
-    const res = makeResponse();
-    const next = makeNext();
-
-    requireOxyAuth(req, res, next);
-
-    expect(req.userId).toBe('mongo-user-id');
-    expect(req.user?.id).toBe('mongo-user-id');
-    expect(next).toHaveBeenCalledTimes(1);
-  });
-
-  it('can resolve and require auth as one middleware', () => {
-    const oxy = {
-      auth: jest.fn(() => (req: OxyAuthRequest, _res: Response, next: NextFunction) => {
-        req.user = { id: 'resolved-user' };
-        next();
-      }),
-    } as unknown as OxyServices;
-    const req = {} as OxyAuthRequest;
-    const res = makeResponse();
-    const next = makeNext();
-
-    createOxyAuthMiddleware(oxy)(req, res, next);
-
-    expect(oxy.auth).toHaveBeenCalledWith({ optional: true });
-    expect(req.userId).toBe('resolved-user');
-    expect(next).toHaveBeenCalledTimes(1);
-  });
-});

package/src/server/__tests__/capabilityTicket.test.ts

@@ -1,111 +0,0 @@
-import type { CapabilityTicketClaims } from '@oxy.so/contracts';
-import { generateKeyPairSync } from 'node:crypto';
-import type { CapabilityTicketError } from '../capabilityTicket';
-import {
-  inputSatisfiesCapabilityLimits,
-  issueCapabilityTicket,
-  readCapabilityAuthorization,
-  verifyCapabilityTicket,
-} from '../capabilityTicket';
-
-const NOW = new Date('2026-09-01T10:00:00.000Z');
-const KEY_PAIR = generateKeyPairSync('ed25519');
-const KEY_ID = 'capability-test-1';
-
-const claims: Omit<CapabilityTicketClaims, 'iss' | 'iat' | 'exp' | 'jti'> = {
-  aud: 'inbox-api',
-  sub: 'agent-1',
-  runId: 'run-1',
-  executionAuthorization: { kind: 'direct_request', id: 'authorization-1' },
-  coordinator: { applicationId: 'alia-app', credentialId: 'alia-credential' },
-  requesterAccountId: 'owner-1',
-  ownerAccountId: 'owner-1',
-  actor: { type: 'agent', accountId: 'agent-1' },
-  resource: {
-    appId: 'inbox',
-    effectiveAccountId: 'business-1',
-    resourceType: 'mailbox',
-    resourceId: 'mailbox-1',
-  },
-  tool: 'sendEmail',
-  capabilities: ['email.send'],
-  limits: [],
-  autonomy: 'execute_on_request',
-};
-
-describe('capability tickets', () => {
-  it('parses the Capability HTTP authentication scheme case-insensitively', () => {
-    expect(readCapabilityAuthorization('Capability signed-ticket')).toBe('signed-ticket');
-    expect(readCapabilityAuthorization('capability signed-ticket')).toBe('signed-ticket');
-    expect(readCapabilityAuthorization('Bearer signed-ticket')).toBeNull();
-    expect(readCapabilityAuthorization('Capability signed-ticket extra')).toBeNull();
-  });
-
-  it('round-trips exact actor, effective account, resource and run claims', () => {
-    const token = issueCapabilityTicket(claims, {
-      issuer: 'https://api.oxy.so',
-      privateKey: KEY_PAIR.privateKey,
-      keyId: KEY_ID,
-      now: NOW,
-      jti: 'ticket-1',
-      ttlSeconds: 60,
-    });
-    const verified = verifyCapabilityTicket(token, {
-      audience: 'inbox-api',
-      issuer: 'https://api.oxy.so',
-      resolvePublicKey: (keyId) => keyId === KEY_ID ? KEY_PAIR.publicKey : undefined,
-      now: new Date('2026-09-01T10:00:30.000Z'),
-    });
-
-    expect(verified.actor).toEqual({ type: 'agent', accountId: 'agent-1' });
-    expect(verified.resource.effectiveAccountId).toBe('business-1');
-    expect(verified.resource.resourceId).toBe('mailbox-1');
-    expect(verified.runId).toBe('run-1');
-  });
-
-  it('rejects cross-app replay even when the signature is valid', () => {
-    const token = issueCapabilityTicket(claims, {
-      issuer: 'https://api.oxy.so', privateKey: KEY_PAIR.privateKey, keyId: KEY_ID, now: NOW,
-    });
-
-    expect(() => verifyCapabilityTicket(token, {
-      audience: 'mention-api', resolvePublicKey: () => KEY_PAIR.publicKey, now: NOW,
-    })).toThrow(expect.objectContaining<Partial<CapabilityTicketError>>({ code: 'wrong_audience' }));
-    expect(() => verifyCapabilityTicket(token, {
-      audience: 'inbox-api', resolvePublicKey: () => undefined, now: NOW,
-    })).toThrow(expect.objectContaining<Partial<CapabilityTicketError>>({ code: 'unknown_key' }));
-  });
-
-  it('rejects expired, tampered and overlong tickets', () => {
-    const token = issueCapabilityTicket(claims, {
-      issuer: 'https://api.oxy.so', privateKey: KEY_PAIR.privateKey, keyId: KEY_ID, now: NOW, ttlSeconds: 60,
-    });
-    expect(() => verifyCapabilityTicket(token, {
-      audience: 'inbox-api', resolvePublicKey: () => KEY_PAIR.publicKey, now: new Date('2026-09-01T10:01:00.000Z'),
-    })).toThrow(expect.objectContaining<Partial<CapabilityTicketError>>({ code: 'expired' }));
-
-    const [header, payload, signature] = token.split('.');
-    expect(() => verifyCapabilityTicket(`${header}.${payload}x.${signature}`, {
-      audience: 'inbox-api', resolvePublicKey: () => KEY_PAIR.publicKey, now: NOW,
-    })).toThrow(expect.objectContaining<Partial<CapabilityTicketError>>({ code: 'invalid_signature' }));
-
-    expect(() => issueCapabilityTicket(claims, {
-      issuer: 'https://api.oxy.so', privateKey: KEY_PAIR.privateKey, keyId: KEY_ID, now: NOW, ttlSeconds: 301,
-    })).toThrow(expect.objectContaining<Partial<CapabilityTicketError>>({ code: 'ttl_exceeded' }));
-  });
-
-  it('enforces numeric and boolean limits carried by a ticket', () => {
-    const limits = [
-      { tool: 'sendPayment', key: 'amount', value: 100 },
-      { tool: 'sendPayment', key: 'confirmed', value: true },
-    ];
-    expect(inputSatisfiesCapabilityLimits('sendPayment', { amount: 75, confirmed: true }, limits)).toBe(true);
-    expect(inputSatisfiesCapabilityLimits('sendPayment', { amount: 101, confirmed: true }, limits)).toBe(false);
-    expect(inputSatisfiesCapabilityLimits('sendPayment', { amount: 75, confirmed: false }, limits)).toBe(false);
-    expect(inputSatisfiesCapabilityLimits('sendPayment', { amount: 75 }, limits)).toBe(false);
-    expect(inputSatisfiesCapabilityLimits('otherTool', { amount: 75, confirmed: true }, limits)).toBe(false);
-    expect(inputSatisfiesCapabilityLimits('updateFlags', {
-      flags: { seen: true },
-    }, [{ tool: 'updateFlags', key: 'flags.seen', value: true }])).toBe(true);
-  });
-});