@oxy.so/core 4.5.0-oxy-one.1 → 4.6.0

package/src/server/aliaMachineCredential.ts

@@ -31,30 +31,53 @@ export interface OxyAliaMachineRequest extends Request {
 }
 
 function id(value: unknown): value is string {
-  return typeof value === 'string' && value.length > 0 && value.length <= 128 && value.trim() === value;
+  return (
+    typeof value === 'string' && value.length > 0 && value.length <= 128 && value.trim() === value
+  );
 }
 
 /** Strict response boundary: extra user/tier fields cannot smuggle authority. */
 export function isOxyAliaMachinePrincipal(value: unknown): value is OxyAliaMachinePrincipal {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
   const p = value as Record<string, unknown>;
-  const keys = ['kind', 'audience', 'applicationId', 'credentialId', 'ownerAccountId', 'environment', 'scopes'];
-  return Object.keys(p).length === keys.length && keys.every(key => Object.prototype.hasOwnProperty.call(p, key))
-    && p.kind === 'machine' && p.audience === OXY_ALIA_RESOURCE_APPLICATION_ID
-    && id(p.applicationId) && id(p.credentialId) && id(p.ownerAccountId)
-    && typeof p.environment === 'string' && ['production', 'staging', 'development'].includes(p.environment)
-    && Array.isArray(p.scopes) && p.scopes.length === 2
-    && OXY_ALIA_MACHINE_SCOPES.every(scope => (p.scopes as unknown[]).includes(scope));
+  const keys = [
+    'kind',
+    'audience',
+    'applicationId',
+    'credentialId',
+    'ownerAccountId',
+    'environment',
+    'scopes',
+  ];
+  return (
+    Object.keys(p).length === keys.length &&
+    keys.every((key) => Object.prototype.hasOwnProperty.call(p, key)) &&
+    p.kind === 'machine' &&
+    p.audience === OXY_ALIA_RESOURCE_APPLICATION_ID &&
+    id(p.applicationId) &&
+    id(p.credentialId) &&
+    id(p.ownerAccountId) &&
+    typeof p.environment === 'string' &&
+    ['production', 'staging', 'development'].includes(p.environment) &&
+    Array.isArray(p.scopes) &&
+    p.scopes.length === 2 &&
+    OXY_ALIA_MACHINE_SCOPES.every((scope) => (p.scopes as unknown[]).includes(scope))
+  );
 }
 
 // Keep the forwarding credential out of enumerable request/principal objects,
 // logs, response serialization and persistent SDK/session state. No cache.
-const forwardingCredentials = new WeakMap<Request, { principal: OxyAliaMachinePrincipal; bearer: string }>();
+const forwardingCredentials = new WeakMap<
+  Request,
+  { principal: OxyAliaMachinePrincipal; bearer: string }
+>();
 
 /** Only for the request-scoped Oxy inference client; never for a user API. */
 export function getOxyAliaMachineCredentialBearer(req: Request): string | null {
   const bound = forwardingCredentials.get(req);
-  return bound && (req as OxyAliaMachineRequest).machineCredential === bound.principal ? bound.bearer : null;
+  return bound && (req as OxyAliaMachineRequest).machineCredential === bound.principal
+    ? bound.bearer
+    : null;
 }
 
 /** Opt into Alia's app-only chat lane on its two chat routes, never globally. */
@@ -69,20 +92,38 @@ export function createOxyAliaMachineCredentialAuth(
       res.status(401).json({ error: 'MACHINE_CREDENTIAL_INVALID' });
       return;
     }
-    const existing = req as Request & { user?: unknown; userId?: unknown; serviceApp?: unknown; oxyRequester?: unknown };
-    if (existing.user || existing.userId || existing.serviceApp || existing.oxyRequester
-      || (req as OxyAliaMachineRequest).machineCredential
-      || req.headers['x-oxy-user-id'] !== undefined || req.headers['x-oxy-requester-assertion'] !== undefined) {
+    const existing = req as Request & {
+      user?: unknown;
+      userId?: unknown;
+      serviceApp?: unknown;
+      oxyRequester?: unknown;
+    };
+    if (
+      existing.user ||
+      existing.userId ||
+      existing.serviceApp ||
+      existing.oxyRequester ||
+      (req as OxyAliaMachineRequest).machineCredential ||
+      req.headers['x-oxy-user-id'] !== undefined ||
+      req.headers['x-oxy-requester-assertion'] !== undefined
+    ) {
       res.status(403).json({ error: 'MACHINE_USER_DELEGATION_UNSUPPORTED' });
       return;
     }
     try {
       const answer = await server.apps.introspectAliaMachineCredential(token);
-      if (!answer.active || !isOxyAliaMachinePrincipal(answer.principal) || answer.principal.environment !== options.environment) {
+      if (
+        !answer.active ||
+        !isOxyAliaMachinePrincipal(answer.principal) ||
+        answer.principal.environment !== options.environment
+      ) {
         res.status(401).json({ error: 'MACHINE_CREDENTIAL_INVALID' });
         return;
       }
-      const principal = Object.freeze({ ...answer.principal, scopes: Object.freeze(['alia:chat', 'inference:invoke'] as const) });
+      const principal = Object.freeze({
+        ...answer.principal,
+        scopes: Object.freeze(['alia:chat', 'inference:invoke'] as const),
+      });
       (req as OxyAliaMachineRequest).machineCredential = principal;
       forwardingCredentials.set(req, { principal, bearer: token });
       next();

package/src/server/auth.ts

@@ -2,7 +2,10 @@ import type { NextFunction, Request, RequestHandler, Response } from 'express';
 import type { AuthMiddlewareOptions, OxyAuthRefusal, OxyMiddleware } from './middleware';
 import type { AccountActorChain } from '@oxy.so/contracts';
 import { logger } from '../logger';
-import { OXY_SERVICE_ENVIRONMENTS, type OxyServiceEnvironment } from '../utils/oxyServiceEnvironment';
+import {
+  OXY_SERVICE_ENVIRONMENTS,
+  type OxyServiceEnvironment,
+} from '../utils/oxyServiceEnvironment';
 
 export { OXY_SERVICE_ENVIRONMENTS };
 export type { OxyServiceEnvironment, OxyAuthRefusal };
@@ -96,9 +99,7 @@ function ensureUser(req: OxyAuthRequest, userId: string): OxyRequestUser {
 export function getOxyUserId(req: Request): string | null {
   const authReq = req as OxyAuthRequest;
   return (
-    normalizeId(authReq.userId) ??
-    normalizeId(authReq.user?.id) ??
-    normalizeId(authReq.user?._id)
+    normalizeId(authReq.userId) ?? normalizeId(authReq.user?.id) ?? normalizeId(authReq.user?._id)
   );
 }
 
@@ -297,7 +298,10 @@ export function createOptionalOxyAuth(
   oxy: OxyAuthHost,
   options: OxyAuthMiddlewareOptions = {},
 ): RequestHandler {
-  const resolveSession = oxy.middleware.auth({ ...options.auth, optional: true }) as unknown as RequestHandler;
+  const resolveSession = oxy.middleware.auth({
+    ...options.auth,
+    optional: true,
+  }) as unknown as RequestHandler;
 
   return (req, res, next) => {
     if (getOxyUserId(req)) {

package/src/server/capabilityTicket.ts

@@ -1,9 +1,4 @@
-import {
-  randomUUID,
-  sign as signBytes,
-  verify as verifyBytes,
-  type KeyObject,
-} from 'node:crypto';
+import { randomUUID, sign as signBytes, verify as verifyBytes, type KeyObject } from 'node:crypto';
 import {
   capabilityTicketClaimsSchema,
   type CapabilityTicketClaims,
@@ -79,7 +74,10 @@ export function issueCapabilityTicket(
 ): string {
   const ttlSeconds = options.ttlSeconds ?? 60;
   if (!Number.isInteger(ttlSeconds) || ttlSeconds < 1 || ttlSeconds > DEFAULT_MAX_TTL_SECONDS) {
-    throw new CapabilityTicketError('ttl_exceeded', `Capability ticket TTL must be between 1 and ${DEFAULT_MAX_TTL_SECONDS} seconds`);
+    throw new CapabilityTicketError(
+      'ttl_exceeded',
+      `Capability ticket TTL must be between 1 and ${DEFAULT_MAX_TTL_SECONDS} seconds`,
+    );
   }
 
   const issuedAt = Math.floor((options.now ?? new Date()).getTime() / 1_000);
@@ -91,7 +89,10 @@ export function issueCapabilityTicket(
     jti: options.jti ?? randomUUID(),
   });
   if (options.privateKey.asymmetricKeyType !== 'ed25519') {
-    throw new CapabilityTicketError('invalid_claims', 'Capability tickets require an Ed25519 private key');
+    throw new CapabilityTicketError(
+      'invalid_claims',
+      'Capability tickets require an Ed25519 private key',
+    );
   }
   const header = { alg: ALGORITHM, typ: TOKEN_TYPE, kid: options.keyId } as const;
   const signingInput = `${base64UrlEncode(JSON.stringify(header))}.${base64UrlEncode(JSON.stringify(payload))}`;
@@ -117,11 +118,11 @@ export function verifyCapabilityTicket(
   }
   const headerRecord = header as Record<string, unknown>;
   if (
-    Object.keys(headerRecord).length !== 3
-    || headerRecord.alg !== ALGORITHM
-    || headerRecord.typ !== TOKEN_TYPE
-    || typeof headerRecord.kid !== 'string'
-    || headerRecord.kid.length === 0
+    Object.keys(headerRecord).length !== 3 ||
+    headerRecord.alg !== ALGORITHM ||
+    headerRecord.typ !== TOKEN_TYPE ||
+    typeof headerRecord.kid !== 'string' ||
+    headerRecord.kid.length === 0
   ) {
     throw new CapabilityTicketError('malformed', 'Capability ticket header is not supported');
   }
@@ -135,12 +136,14 @@ export function verifyCapabilityTicket(
   } catch {
     throw new CapabilityTicketError('malformed', 'Capability ticket signature is malformed');
   }
-  if (!verifyBytes(
-    null,
-    Buffer.from(`${encodedHeader}.${encodedPayload}`),
-    publicKey,
-    providedSignature,
-  )) {
+  if (
+    !verifyBytes(
+      null,
+      Buffer.from(`${encodedHeader}.${encodedPayload}`),
+      publicKey,
+      providedSignature,
+    )
+  ) {
     throw new CapabilityTicketError('invalid_signature', 'Capability ticket signature is invalid');
   }
 
@@ -158,10 +161,16 @@ export function verifyCapabilityTicket(
     throw new CapabilityTicketError('expired', 'Capability ticket has expired');
   }
   if (claims.exp - claims.iat > (options.maximumTtlSeconds ?? DEFAULT_MAX_TTL_SECONDS)) {
-    throw new CapabilityTicketError('ttl_exceeded', 'Capability ticket lifetime exceeds the accepted maximum');
+    throw new CapabilityTicketError(
+      'ttl_exceeded',
+      'Capability ticket lifetime exceeds the accepted maximum',
+    );
   }
   if (claims.aud !== options.audience) {
-    throw new CapabilityTicketError('wrong_audience', 'Capability ticket audience does not match this app');
+    throw new CapabilityTicketError(
+      'wrong_audience',
+      'Capability ticket audience does not match this app',
+    );
   }
   if (options.issuer && claims.iss !== options.issuer) {
     throw new CapabilityTicketError('wrong_issuer', 'Capability ticket issuer is not trusted');

package/src/server/index.ts

@@ -17,7 +17,11 @@
 
 // The backend client: OxyServices plus the service-token lane, middleware,
 // account events and the service-only namespace methods.
-export { OxyServer, ServiceCredentialMismatchError, ANONYMOUS_SERVICE_TOKEN_RETRY_MS } from './OxyServer';
+export {
+  OxyServer,
+  ServiceCredentialMismatchError,
+  ANONYMOUS_SERVICE_TOKEN_RETRY_MS,
+} from './OxyServer';
 export type { OxyServerConfig, ServiceTokenResponse } from './OxyServer';
 export {
   ServerAppsApi,
@@ -200,7 +204,11 @@ export type {
 // The identity-key enumeration itself is platform-neutral (`src/utils/`) so the
 // client namespaces and this Node-only subscriber sweep the SAME list — a second
 // copy is what let `updateAccount` and `updateProfile` drift apart.
-export { evictOxyIdentityCache, oxyUserByIdCacheKey, OXY_IDENTITY_CACHE_PREFIXES } from '../utils/identityCacheSweep';
+export {
+  evictOxyIdentityCache,
+  oxyUserByIdCacheKey,
+  OXY_IDENTITY_CACHE_PREFIXES,
+} from '../utils/identityCacheSweep';
 export type { OxyIdentityCacheEvictor } from '../utils/identityCacheSweep';
 
 // Registrable-apex (eTLD+1) derivation via the Public Suffix List — the SINGLE
@@ -208,7 +216,11 @@ export type { OxyIdentityCacheEvictor } from '../utils/identityCacheSweep';
 // Pure host handling (no browser deps), so it is safe on the server subpath and
 // lets `@oxy.so/api` derive `auth.<apex>` without duplicating PSL logic.
 export { registrableApex } from '../utils/registrableApex';
-export { isLoopbackOrigin, isOfficialWebOrigin, isAllowedDeviceJoinOrigin } from '../utils/officialOrigins';
+export {
+  isLoopbackOrigin,
+  isOfficialWebOrigin,
+  isAllowedDeviceJoinOrigin,
+} from '../utils/officialOrigins';
 
 export { createEcosystemTraffic } from './traffic';
 export type { EcosystemTrafficOptions } from './traffic';
@@ -221,9 +233,20 @@ export { observeNodeHttp, withoutNodeHttpObservation } from './trafficNodeHttp';
  * exported from this subpath rather than the root barrel because it reaches the
  * container credentials endpoint.
  */
-export { canAttestWorkloadIdentity, requestWorkloadServiceToken } from './workloadIdentity';
-export type { WorkloadServiceToken, WorkloadServiceTokenOptions } from './workloadIdentity';
+export {
+  attestWorkloadIdentity,
+  canAttestWorkloadIdentity,
+  requestWorkloadServiceToken,
+} from './workloadIdentity';
+export type {
+  WorkloadAttestation,
+  WorkloadServiceToken,
+  WorkloadServiceTokenOptions,
+} from './workloadIdentity';
 
-export { OXY_SERVICE_TOKEN_MAX_LIFETIME_SECONDS, hasBoundedServiceTokenLifetime } from './serviceTokenLifetime';
+export {
+  OXY_SERVICE_TOKEN_MAX_LIFETIME_SECONDS,
+  hasBoundedServiceTokenLifetime,
+} from './serviceTokenLifetime';
 export { signInAgentAccount } from './agentAccount';
 export type { AgentAccountSigner } from './agentAccount';

package/src/server/liveCapabilityTicket.ts

@@ -1,41 +1,63 @@
-import { canonicalCapabilityJson, capabilityTicketClaimsSchema, type CapabilityTicketClaims } from '@oxy.so/contracts';
-import { verifyCapabilityTicket, type CapabilityTicketVerificationOptions } from './capabilityTicket';
+import {
+  canonicalCapabilityJson,
+  capabilityTicketClaimsSchema,
+  type CapabilityTicketClaims,
+} from '@oxy.so/contracts';
+import {
+  verifyCapabilityTicket,
+  type CapabilityTicketVerificationOptions,
+} from './capabilityTicket';
 import type { CapabilityTicketIntrospection } from './namespaces';
 
 export interface LiveCapabilityTicketVerifierOptions extends CapabilityTicketVerificationOptions {
   issuer: string;
-  introspect: (ticket: string, options: { signal: AbortSignal }) => Promise<CapabilityTicketIntrospection>;
+  introspect: (
+    ticket: string,
+    options: { signal: AbortSignal },
+  ) => Promise<CapabilityTicketIntrospection>;
   /** Network bound only; does not establish an authority freshness policy. */
   timeoutMs?: number;
 }
 
 /** Local signature + live receiving-service introspection; no cache or retry. */
 export function createLiveCapabilityTicketVerifier(options: LiveCapabilityTicketVerifierOptions) {
-  if (typeof options.issuer !== 'string' || options.issuer.trim() === '') throw new Error('A trusted Capability issuer is required');
+  if (typeof options.issuer !== 'string' || options.issuer.trim() === '')
+    throw new Error('A trusted Capability issuer is required');
   const timeoutMs = options.timeoutMs ?? 5000;
   if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60000) {
     throw new Error('Capability introspection timeout must be between 1 and 60000ms');
   }
-  return async (ticket: string, input: { signal?: AbortSignal } = {}): Promise<CapabilityTicketClaims> => {
+  return async (
+    ticket: string,
+    input: { signal?: AbortSignal } = {},
+  ): Promise<CapabilityTicketClaims> => {
     input.signal?.throwIfAborted();
     const signed = verifyCapabilityTicket(ticket, options);
     if (!signed.catalog) throw new Error('Internal MCP requires a signed catalogue binding');
     const controller = new AbortController();
     const abort = () => controller.abort(input.signal?.reason);
     input.signal?.addEventListener('abort', abort, { once: true });
-    const timer = setTimeout(() => controller.abort(new Error('Capability introspection timed out')), timeoutMs);
+    const timer = setTimeout(
+      () => controller.abort(new Error('Capability introspection timed out')),
+      timeoutMs,
+    );
     let rejectAbort: (() => void) | undefined;
     try {
       const interrupted = new Promise<never>((_resolve, reject) => {
-        rejectAbort = () => reject(controller.signal.reason ?? new Error('Capability introspection aborted'));
+        rejectAbort = () =>
+          reject(controller.signal.reason ?? new Error('Capability introspection aborted'));
         controller.signal.addEventListener('abort', rejectAbort, { once: true });
         if (controller.signal.aborted) rejectAbort();
       });
-      const result = await Promise.race([options.introspect(ticket, { signal: controller.signal }), interrupted]);
+      const result = await Promise.race([
+        options.introspect(ticket, { signal: controller.signal }),
+        interrupted,
+      ]);
       controller.signal.throwIfAborted();
       if (result.active !== true) throw new Error('Capability ticket is inactive');
       const live = capabilityTicketClaimsSchema.parse(result.claims);
-      if (canonicalCapabilityJson(live) !== canonicalCapabilityJson(signed)) throw new Error('Capability introspection claims mismatch');
+      if (canonicalCapabilityJson(live) !== canonicalCapabilityJson(signed))
+        throw new Error('Capability introspection claims mismatch');
       // An authority response delayed past expiry cannot extend the signed grant.
       return verifyCapabilityTicket(ticket, options);
     } finally {