@oxy.so/core 4.5.0 → 4.8.0

package/src/api/organizations.ts

@@ -0,0 +1,180 @@
+import {
+  organizationSchema,
+  organizationListSchema,
+  organizationBatchSchema,
+  organizationClaimSchema,
+  organizationExternalSchema,
+  organizationExternalResolutionSchema,
+  organizationImportBatchResultSchema,
+  organizationCurationResultSchema,
+  type OrganizationCuration,
+  type OrganizationImportBatch,
+  organizationClaimListSchema,
+  organizationClaimDetailSchema,
+  type OrganizationClaimListQuery,
+  type CreateOrganization,
+  type OrganizationSearch,
+  type UpdateOrganization,
+  type OrganizationClaimInput,
+  type OrganizationClaimReview,
+  type OrganizationExternalInput,
+  type OrganizationMerge,
+} from '@oxy.so/contracts';
+import type { OxyContext } from '../client/context';
+import { evictOxyIdentityCache } from '../utils/identityCacheSweep';
+
+/** The public canonical organization directory. Claiming changes authority, never identity. */
+export class OrganizationsApi {
+  constructor(private readonly ctx: OxyContext) {}
+  async search(input: OrganizationSearch) {
+    return organizationListSchema.parse(
+      await this.ctx.request('GET', '/organizations', input, { cache: false, skipAuth: true }),
+    );
+  }
+  async get(accountId: string) {
+    return organizationSchema.parse(
+      await this.ctx.request('GET', `/organizations/${encodeURIComponent(accountId)}`, undefined, {
+        cache: false,
+        skipAuth: true,
+      }),
+    );
+  }
+  async batch(input: { ids: string[] }) {
+    return organizationBatchSchema.parse(
+      await this.ctx.request('POST', '/organizations/batch', input, {
+        cache: false,
+        skipAuth: true,
+      }),
+    );
+  }
+  async create(input: CreateOrganization) {
+    return organizationSchema.parse(
+      await this.ctx.request('POST', '/organizations', input, { cache: false }),
+    );
+  }
+  async update(accountId: string, input: UpdateOrganization) {
+    const result = organizationSchema.parse(
+      await this.ctx.request('PATCH', `/organizations/${encodeURIComponent(accountId)}`, input, {
+        cache: false,
+      }),
+    );
+
+    evictOxyIdentityCache(this.ctx.http, accountId);
+    return result;
+  }
+  async claim(accountId: string, input: OrganizationClaimInput) {
+    return organizationClaimSchema.parse(
+      await this.ctx.request(
+        'POST',
+        `/organizations/${encodeURIComponent(accountId)}/claims`,
+        input,
+        { cache: false },
+      ),
+    );
+  }
+  async myClaims(input: OrganizationClaimListQuery = {}) {
+    return organizationClaimListSchema.parse(
+      await this.ctx.request('GET', '/organizations/claims/mine', input, { cache: false }),
+    );
+  }
+  async myClaim(claimId: string) {
+    return organizationClaimDetailSchema.parse(
+      await this.ctx.request(
+        'GET',
+        `/organizations/claims/mine/${encodeURIComponent(claimId)}`,
+        undefined,
+        { cache: false },
+      ),
+    );
+  }
+  async reviewClaims(input: OrganizationClaimListQuery = {}) {
+    return organizationClaimListSchema.parse(
+      await this.ctx.request('GET', '/organizations/claims/review', input, { cache: false }),
+    );
+  }
+  async reviewClaimDetail(claimId: string) {
+    return organizationClaimDetailSchema.parse(
+      await this.ctx.request(
+        'GET',
+        `/organizations/claims/review/${encodeURIComponent(claimId)}`,
+        undefined,
+        { cache: false },
+      ),
+    );
+  }
+  async reviewClaim(claimId: string, input: OrganizationClaimReview) {
+    const result = organizationClaimSchema.parse(
+      await this.ctx.request(
+        'POST',
+        `/organizations/claims/${encodeURIComponent(claimId)}/review`,
+        input,
+        { cache: false },
+      ),
+    );
+
+    evictOxyIdentityCache(this.ctx.http, result.accountId);
+    return result;
+  }
+  async importBatch(input: OrganizationImportBatch) {
+    if (!this.ctx.service?.available)
+      throw new Error('Organization batch import requires an OxyServer service identity');
+    return organizationImportBatchResultSchema.parse(
+      await this.ctx.service.request('POST', '/organizations/external/batch', input, {
+        cache: false,
+      }),
+    );
+  }
+  async importExternal(input: OrganizationExternalInput) {
+    return organizationExternalSchema.parse(
+      await this.ctx.request('POST', '/organizations/external', input, { cache: false }),
+    );
+  }
+  async resolveExternal(input: { namespace: string; externalId: string }) {
+    return organizationExternalResolutionSchema.parse(
+      await this.ctx.request(
+        'GET',
+        `/organizations/external/${encodeURIComponent(input.namespace)}/${encodeURIComponent(input.externalId)}`,
+        undefined,
+        { cache: false },
+      ),
+    );
+  }
+  async curate(accountId: string, input: OrganizationCuration) {
+    const result = organizationCurationResultSchema.parse(
+      await this.ctx.request(
+        'POST',
+        `/organizations/${encodeURIComponent(accountId)}/curation`,
+        input,
+        { cache: false },
+      ),
+    );
+
+    evictOxyIdentityCache(this.ctx.http, accountId);
+    return result;
+  }
+  async merge(accountId: string, input: OrganizationMerge) {
+    const result = organizationSchema.parse(
+      await this.ctx.request(
+        'POST',
+        `/organizations/${encodeURIComponent(accountId)}/merge`,
+        input,
+        { cache: false },
+      ),
+    );
+
+    evictOxyIdentityCache(this.ctx.http, accountId);
+    evictOxyIdentityCache(this.ctx.http, result.accountId);
+    return result;
+  }
+  async *iterate(input: OrganizationSearch) {
+    let cursor = input.cursor;
+    const seen = new Set<string>();
+    do {
+      const page = await this.search({ ...input, cursor });
+      yield* page.items;
+      cursor = page.nextCursor ?? undefined;
+      if (cursor && seen.has(cursor)) throw new Error('Organization directory repeated a cursor');
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+  }
+}

package/src/api/safety.ts

@@ -0,0 +1,33 @@
+import {
+  profileAccessInputSchema,
+  profileAccessDecisionSchema,
+  type ProfileAccessInput,
+} from '@oxy.so/contracts';
+import type { OxyContext } from '../client/context';
+
+export class SafetyApi {
+  constructor(private readonly ctx: OxyContext) {}
+  /** Server callers must explicitly supply the incoming user bearer or null for anonymous access. */
+  async profileAccess(input: ProfileAccessInput, options?: { accessToken: string | null }) {
+    if (this.ctx.service && options === undefined)
+      throw new Error('Server profile access requires an explicit requester bearer or null');
+    return profileAccessDecisionSchema.parse(
+      await this.ctx.request(
+        'GET',
+        '/safety/profile-access',
+        profileAccessInputSchema.parse(input),
+        {
+          cache: false,
+          ...(options
+            ? {
+                skipAuth: true,
+                headers: options.accessToken
+                  ? { Authorization: `Bearer ${options.accessToken}` }
+                  : {},
+              }
+            : {}),
+        },
+      ),
+    );
+  }
+}

package/src/i18n/locales/en-US.ts

@@ -1,4 +1,72 @@
 const dict = {
+  organizationDirectory: {
+    invalidName: 'Use a plain-text organization name (up to 300 characters).',
+    review: {
+      title: 'Review organization access requests',
+      forbidden: 'This action requires current staff authorization.',
+      empty: 'No requests are waiting for review.',
+      hint: 'Review the supporting evidence independently. Approval grants management access to the existing organization account.',
+      independent: 'Another reviewer must decide your own request.',
+      evidence: 'Review evidence reference',
+      approved: 'Approve access',
+      rejected: 'Reject request',
+      conflict:
+        'This request or organization changed. Refresh the queue before making another decision.',
+      failed: 'The review could not be saved. Your decision has not been confirmed.',
+    },
+    title: 'Organization directory',
+    search: 'Find your organization',
+    searchHint:
+      'Find an existing organization before creating an account. Its identity is shared across Oxy apps.',
+    empty: 'No organizations found.',
+    retry: 'Try again',
+    loadMore: 'Show more',
+    failed: 'Could not load the organization directory.',
+    unclaimed: 'Unclaimed',
+    claimed: 'Managed organization',
+    inactive: 'Inactive',
+    newAccount: 'Create a new organization account',
+    newAccountHint:
+      'Create and manage a new organization. Choose an existing entry if your organization is already listed.',
+    addDirectory: 'Add to directory',
+    directoryHint:
+      'This creates a shared, unclaimed entry. It does not give you access to manage the organization.',
+    added: 'Organization added to the directory',
+    back: 'Back to search',
+    type: 'Organization type',
+    types: {
+      business: 'Business',
+      nonprofit: 'Nonprofit',
+      public_body: 'Public body',
+      community: 'Community',
+      other: 'Other',
+    },
+    name: 'Organization name',
+    legalName: 'Legal name',
+    website: 'Website',
+    country: 'Country code',
+    save: 'Save organization',
+    saved: 'Organization updated',
+    invalid:
+      'Check the organization details. Use a complete website URL and a two-letter country code.',
+    saveFailed: 'Could not save the organization. Try again.',
+    claim: 'Request management access',
+    claimHint:
+      'Oxy reviews evidence of your authority. A request does not grant access or verify your role.',
+    evidence: 'Supporting evidence reference',
+    evidenceHint:
+      'Provide a reference to your private verification case or supporting records. Only you and reviewers can read it.',
+    claimSent: 'Request submitted for review',
+    claimFailed: 'Could not submit your request. Try again.',
+    claimedHint: 'This organization already has managers. Contact a manager to request access.',
+    requests: 'Organization access requests',
+    pending: 'Pending review',
+    approved: 'Approved',
+    rejected: 'Rejected',
+    requestError: 'Could not load your access requests.',
+    view: 'Organization details',
+    readonly: 'You do not have permission to edit this organization.',
+  },
   signin: {
     title: 'Sign in',
     subtitle: 'Use your Oxy account',

package/src/i18n/locales/es-ES.ts

@@ -1,4 +1,72 @@
 const dict = {
+  organizationDirectory: {
+    invalidName: 'Usa un nombre de organización en texto plano (hasta 300 caracteres).',
+    review: {
+      title: 'Revisar solicitudes de acceso a organizaciones',
+      forbidden: 'Esta acción requiere autorización vigente del personal de Oxy.',
+      empty: 'No hay solicitudes pendientes de revisión.',
+      hint: 'Revisa la documentación de forma independiente. La aprobación concede acceso de administración a la cuenta existente.',
+      independent: 'Otro revisor debe decidir sobre tu propia solicitud.',
+      evidence: 'Referencia de la documentación de revisión',
+      approved: 'Aprobar acceso',
+      rejected: 'Rechazar solicitud',
+      conflict:
+        'La solicitud o la organización ha cambiado. Actualiza la lista antes de tomar otra decisión.',
+      failed: 'No se pudo guardar la revisión. Tu decisión no se ha confirmado.',
+    },
+    title: 'Directorio de organizaciones',
+    search: 'Busca tu organización',
+    searchHint:
+      'Busca una organización existente antes de crear una cuenta. Su identidad se comparte entre las aplicaciones de Oxy.',
+    empty: 'No se encontraron organizaciones.',
+    retry: 'Reintentar',
+    loadMore: 'Mostrar más',
+    failed: 'No se pudo cargar el directorio de organizaciones.',
+    unclaimed: 'Sin reclamar',
+    claimed: 'Organización administrada',
+    inactive: 'Inactiva',
+    newAccount: 'Crear una nueva cuenta de organización',
+    newAccountHint:
+      'Crea y administra una organización nueva. Si ya aparece en el directorio, elige la entrada existente.',
+    addDirectory: 'Añadir al directorio',
+    directoryHint:
+      'Esto crea una entrada compartida sin reclamar. No te da acceso para administrar la organización.',
+    added: 'Organización añadida al directorio',
+    back: 'Volver a la búsqueda',
+    type: 'Tipo de organización',
+    types: {
+      business: 'Empresa',
+      nonprofit: 'Sin ánimo de lucro',
+      public_body: 'Organismo público',
+      community: 'Comunidad',
+      other: 'Otro',
+    },
+    name: 'Nombre de la organización',
+    legalName: 'Nombre legal',
+    website: 'Sitio web',
+    country: 'Código de país',
+    save: 'Guardar organización',
+    saved: 'Organización actualizada',
+    invalid: 'Revisa los datos. Usa una URL completa y un código de país de dos letras.',
+    saveFailed: 'No se pudo guardar la organización. Inténtalo de nuevo.',
+    claim: 'Solicitar acceso de administración',
+    claimHint:
+      'Oxy revisará las pruebas de tu autorización. Una solicitud no concede acceso ni verifica tu cargo.',
+    evidence: 'Referencia de la documentación',
+    evidenceHint:
+      'Indica una referencia a tu expediente privado de verificación o documentación acreditativa. Solo tú y los revisores podéis verla.',
+    claimSent: 'Solicitud enviada para revisión',
+    claimFailed: 'No se pudo enviar la solicitud. Inténtalo de nuevo.',
+    claimedHint:
+      'Esta organización ya tiene administradores. Contacta con uno para solicitar acceso.',
+    requests: 'Solicitudes de acceso a organizaciones',
+    pending: 'Pendiente de revisión',
+    approved: 'Aprobada',
+    rejected: 'Rechazada',
+    requestError: 'No se pudieron cargar tus solicitudes.',
+    view: 'Datos de la organización',
+    readonly: 'No tienes permiso para editar esta organización.',
+  },
   signin: {
     title: 'Iniciar sesión',
     subtitle: 'Usa tu cuenta de Oxy',

package/src/index.ts

@@ -605,3 +605,14 @@ export type { PkcePair, BuildOAuthAuthorizeUrlParams, OxyAuthScreen } from './ut
 // Constants
 // ---------------------------------------------------------------------------
 export { packageInfo } from './constants/version';
+
+export type {
+  Organization,
+  OrganizationType,
+  CreateOrganization,
+  UpdateOrganization,
+  OrganizationSearch,
+  OrganizationClaim,
+} from '@oxy.so/contracts';
+
+export type { ProfileAccessInput, ProfileAccessDecision } from '@oxy.so/contracts';

package/src/models/interfaces.ts

@@ -1,6 +1,7 @@
 import type {
   AccountKind,
   AccountCategoryId,
+  AvatarCharacter,
   UserNameResponse,
   UserRelationship,
   ThemePreference,
@@ -180,7 +181,15 @@ export interface User {
   isFederated?: boolean;
   /** Allow sharing this user's content on the fediverse. Defaults to true. */
   fediverseSharing?: boolean;
+  /**
+   * Derived from `kind === 'bot'` (the SOLE definition), NOT from `type`.
+   */
   isAgent?: boolean;
+  /**
+   * The 3D avatar character of a `kind: 'bot'` account, drawn by Bloom's
+   * `Avatar`. Present ONLY on a bot; absent for every other kind.
+   */
+  character?: AvatarCharacter;
   isAutomated?: boolean;
   instance?: string;
   federation?: {