@oxyhq/core 21.0.0 → 21.0.2

package/src/mixins/__tests__/accounts.test.ts

@@ -17,9 +17,6 @@ import type { User } from '../../models/interfaces';
 import type {
   AccountNode,
   AccountMember,
-  AccountCredential,
-  AccountCredentialWithSecret,
-  RotateAccountCredentialResult,
   Application,
   ApplicationCredential,
   ApplicationCredentialWithSecret,
@@ -62,20 +59,6 @@ const accountNodeFixture: AccountNode = {
   childCount: 2,
 };
 
-const credentialFixture: AccountCredential = {
-  _id: 'cred1',
-  accountId: 'acc1',
-  name: 'bot-prod',
-  publicKey: 'oxy_dk_abc',
-  type: 'service',
-  environment: 'production',
-  scopes: ['user:read'],
-  status: 'active',
-  createdByUserId: 'u1',
-  createdAt: '2026-06-29T00:00:00.000Z',
-  updatedAt: '2026-06-29T00:00:00.000Z',
-};
-
 const appFixture: Application = {
   _id: 'app1',
   name: 'Mention',
@@ -476,91 +459,6 @@ describe('OxyServices.accounts', () => {
     });
   });
 
-  describe('listAccountCredentials', () => {
-    it('unwraps the `credentials` array and caches the read', async () => {
-      makeRequestSpy.mockResolvedValue({ credentials: [credentialFixture] });
-
-      const result = await oxy.listAccountCredentials('acc1');
-
-      expect(result).toEqual([credentialFixture]);
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'GET',
-        '/accounts/acc1/credentials',
-        undefined,
-        expect.objectContaining({ cache: true }),
-      );
-    });
-
-    it('returns an empty array when `credentials` is absent', async () => {
-      makeRequestSpy.mockResolvedValue({});
-      expect(await oxy.listAccountCredentials('acc1')).toEqual([]);
-    });
-  });
-
-  describe('createAccountCredential', () => {
-    it('posts the config, returns the secret result, and busts the credentials cache', async () => {
-      const created: AccountCredentialWithSecret = {
-        credential: credentialFixture,
-        secret: 'sk_once',
-      };
-      makeRequestSpy.mockResolvedValue(created);
-
-      const result = await oxy.createAccountCredential('acc1', {
-        name: 'bot-prod',
-        environment: 'production',
-      });
-
-      expect(result).toEqual(created);
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'POST',
-        '/accounts/acc1/credentials',
-        { name: 'bot-prod', environment: 'production' },
-        expect.objectContaining({ cache: false }),
-      );
-      expect(clearEntrySpy).toHaveBeenCalledWith('GET:/accounts/acc1/credentials');
-    });
-  });
-
-  describe('rotateAccountCredential', () => {
-    it('posts to /rotate, encodes ids, returns the audit result, and busts credentials', async () => {
-      const rotated: RotateAccountCredentialResult = {
-        credential: { ...credentialFixture, _id: 'cred2' },
-        secret: 'sk_new',
-        rotatedFrom: 'cred1',
-        graceExpiresAt: '2026-07-06T00:00:00.000Z',
-      };
-      makeRequestSpy.mockResolvedValue(rotated);
-
-      const result = await oxy.rotateAccountCredential('acc1', 'cred 1');
-
-      expect(result).toEqual(rotated);
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'POST',
-        '/accounts/acc1/credentials/cred%201/rotate',
-        undefined,
-        expect.objectContaining({ cache: false }),
-      );
-      expect(clearEntrySpy).toHaveBeenCalledWith('GET:/accounts/acc1/credentials');
-    });
-  });
-
-  describe('revokeAccountCredential', () => {
-    it('deletes the credential and busts the credentials cache', async () => {
-      makeRequestSpy.mockResolvedValue({ success: true });
-
-      const result = await oxy.revokeAccountCredential('acc1', 'cred1');
-
-      expect(result).toEqual({ success: true });
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'DELETE',
-        '/accounts/acc1/credentials/cred1',
-        undefined,
-        expect.objectContaining({ cache: false }),
-      );
-      expect(clearEntrySpy).toHaveBeenCalledWith('GET:/accounts/acc1/credentials');
-    });
-  });
-
   describe('createApp', () => {
     it('posts the payload, unwraps `application`, and busts every app list', async () => {
       makeRequestSpy.mockResolvedValue({ application: appFixture });
@@ -678,6 +576,39 @@ describe('OxyServices.accounts', () => {
       );
       expect(clearEntrySpy).toHaveBeenCalledWith('GET:/applications/app1/credentials');
     });
+
+    it("forwards a machine credential's expiresInSeconds and its one-time token", async () => {
+      // A `machine` credential's material arrives in `token`, never `secret` —
+      // a surface rendering "the secret" must not silently print an API key.
+      const created: ApplicationCredentialWithSecret = {
+        credential: { ...appCredentialFixture, type: 'machine', tokenPrefix: 'oxy_sk_0123456789abcdef' },
+        secret: null,
+        token: 'oxy_sk_0123456789abcdef_' + 'a'.repeat(64),
+      };
+      makeRequestSpy.mockResolvedValue(created);
+
+      const result = await oxy.createAppCredential('app1', {
+        name: 'ci-runner',
+        type: 'machine',
+        environment: 'production',
+        scopes: ['inference:invoke'],
+        expiresInSeconds: 86_400,
+      });
+
+      expect(result.token).toBe(created.token);
+      expect(makeRequestSpy).toHaveBeenCalledWith(
+        'POST',
+        '/applications/app1/credentials',
+        {
+          name: 'ci-runner',
+          type: 'machine',
+          environment: 'production',
+          scopes: ['inference:invoke'],
+          expiresInSeconds: 86_400,
+        },
+        expect.objectContaining({ cache: false }),
+      );
+    });
   });
 
   describe('rotateAppCredential', () => {
@@ -701,6 +632,30 @@ describe('OxyServices.accounts', () => {
       );
       expect(clearEntrySpy).toHaveBeenCalledWith('GET:/applications/app1/credentials');
     });
+
+    it('forwards an opt-in rotation grace window', async () => {
+      // Omitting it (the case above) sends `undefined`, and the server then
+      // revokes the superseded machine token immediately. Sending it must reach
+      // the body, or a caller asking for zero-downtime rotation would silently
+      // get the instant-revoke behaviour instead.
+      const rotated: RotateApplicationCredentialResult = {
+        credential: { ...appCredentialFixture, _id: 'appcred2', type: 'machine' },
+        secret: null,
+        token: 'oxy_sk_fedcba9876543210_' + 'b'.repeat(64),
+        rotatedFrom: 'appcred1',
+        graceExpiresAt: '2026-08-17T00:00:00.000Z',
+      };
+      makeRequestSpy.mockResolvedValue(rotated);
+
+      await oxy.rotateAppCredential('app1', 'appcred1', { graceSeconds: 3600 });
+
+      expect(makeRequestSpy).toHaveBeenCalledWith(
+        'POST',
+        '/applications/app1/credentials/appcred1/rotate',
+        { graceSeconds: 3600 },
+        expect.objectContaining({ cache: false }),
+      );
+    });
   });
 
   describe('revokeAppCredential', () => {

package/src/mixins/__tests__/inferenceFactory.test.ts

@@ -0,0 +1,58 @@
+/**
+ * `oxyServices.inference()` — the binding, which is the only thing this mixin
+ * does.
+ *
+ * Two properties matter and neither is visible from the client's own suite: the
+ * client must inherit THIS instance's base URL, and it must read the bearer
+ * LATE, so a token planted after construction is the one that gets sent. A
+ * factory that captured `getAccessToken()` eagerly would pass every test that
+ * signs in first and fail on the cold-boot ordering every app actually has.
+ *
+ * Driven through the real global `fetch`, spied — the factory takes no
+ * transport, so a test that built its own client would be asserting against a
+ * re-implementation of the thing under test rather than against it.
+ */
+
+import { OxyServices } from '../../OxyServices';
+import { OxyInferenceClient } from '../../inference/OxyInferenceClient';
+
+describe('OxyServices.inference()', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        fetchSpy = jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+            new Response(JSON.stringify({ data: [], count: 0 }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }),
+        );
+    });
+
+    afterEach(() => {
+        fetchSpy.mockRestore();
+    });
+
+    it('returns one memoized client, so a consumer can hold it', () => {
+        const oxy = new OxyServices({ baseURL: 'http://test.invalid' });
+
+        const first = oxy.inference();
+        expect(first).toBeInstanceOf(OxyInferenceClient);
+        expect(oxy.inference()).toBe(first);
+    });
+
+    it('binds this instance base URL and reads the bearer at request time', async () => {
+        const oxy = new OxyServices({ baseURL: 'http://test.invalid' });
+        const client = oxy.inference();
+
+        // The token is planted AFTER the client exists — the cold-boot order.
+        oxy.setTokens('planted-later');
+        await client.listModels();
+
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        const [url, init] = fetchSpy.mock.calls[0] as [string, RequestInit];
+        expect(String(url)).toBe('http://test.invalid/v1/models');
+        expect((init.headers as Record<string, string>)['Authorization']).toBe(
+            'Bearer planted-later',
+        );
+    });
+});

package/src/mixins/__tests__/serviceAuth.test.ts

@@ -50,6 +50,7 @@ const signServiceToken = (claims: ServiceTokenClaims, secret: string): string =>
     aud: 'oxy-api',
     iss: 'oxy-auth',
     credentialId: 'cred-1',
+    ownerAccountId: 'owner-account-1',
     environment: 'production',
     ...claims,
   };
@@ -184,6 +185,7 @@ describe('C3: service-token acting-as enforcement', () => {
       appId: 'app-1',
       appName: 'trusted-service',
       credentialId: 'cred-1',
+      ownerAccountId: 'owner-account-1',
       scopes: ['user:read'],
       environment: 'production',
     });

package/src/mixins/index.ts

@@ -33,6 +33,7 @@ import { OxyServicesChainsMixin } from './OxyServices.chains';
 import { OxyServicesNodesMixin } from './OxyServices.nodes';
 import { OxyServicesLinksMixin } from './OxyServices.links';
 import { OxyServicesFollowGraphMixin } from './OxyServices.followGraph';
+import { OxyServicesInferenceMixin } from './OxyServices.inference';
 import { OxyServicesDeviceBootMixin } from './OxyServices.deviceBoot';
 import { OxyServicesDeviceTransferMixin } from './OxyServices.deviceTransfer';
 
@@ -72,6 +73,7 @@ type AllMixinInstances =
   & InstanceType<ReturnType<typeof OxyServicesNodesMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesLinksMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesFollowGraphMixin<typeof OxyServicesBase>>>
+  & InstanceType<ReturnType<typeof OxyServicesInferenceMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesDeviceBootMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesDeviceTransferMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesUtilityMixin<typeof OxyServicesBase>>>;
@@ -156,6 +158,12 @@ const MIXIN_PIPELINE: MixinFunction[] = [
     // 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,

package/src/server/__tests__/cors.socket.test.ts

@@ -0,0 +1,225 @@
+/**
+ * `createOxyCors` over a REAL socket, plus the two halves of the opaque-origin
+ * guard.
+ *
+ * `cors.test.ts` drives the middleware with a fake `Request`/`Response` pair,
+ * which is fine for header bookkeeping but cannot answer the question this
+ * suite exists for: what a client actually receives. These tests start an
+ * Express app on an ephemeral port and read the response headers off the wire.
+ *
+ * `node:http` rather than `fetch`: `Origin` is a forbidden header name for
+ * `fetch`, so the request under test has to be built by hand.
+ */
+
+import http from 'node:http';
+import type { AddressInfo } from 'node:net';
+import express from 'express';
+import { configureLogger, resetLoggerConfig } from '../../logger';
+import type { LogEntry } from '../../logger';
+import { createOxyCors, matchesAllowedOrigin, normalizeAppOrigins } from '../cors';
+import type { OxyCorsOptions } from '../cors';
+
+interface CorsResponse {
+  status: number;
+  allowOrigin: string | undefined;
+  allowCredentials: string | undefined;
+}
+
+/** Start an Express app carrying `createOxyCors(options)` on an ephemeral port. */
+async function startServer(options: OxyCorsOptions): Promise<http.Server> {
+  const app = express();
+  app.use(createOxyCors(options));
+  app.get('/catalogue', (_req, res) => {
+    res.json({ ok: true });
+  });
+  const server = http.createServer(app);
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  return server;
+}
+
+async function stopServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+}
+
+/** Issue a real request carrying `Origin` and read the CORS headers back. */
+function requestWithOrigin(
+  server: http.Server,
+  method: 'GET' | 'OPTIONS',
+  origin: string,
+): Promise<CorsResponse> {
+  const { port } = server.address() as AddressInfo;
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port,
+        method,
+        path: '/catalogue',
+        headers: { Origin: origin, 'Access-Control-Request-Method': 'GET' },
+      },
+      (res) => {
+        res.resume();
+        res.on('end', () => {
+          resolve({
+            status: res.statusCode ?? 0,
+            allowOrigin: res.headers['access-control-allow-origin'],
+            allowCredentials: res.headers['access-control-allow-credentials'],
+          });
+        });
+        res.on('error', reject);
+      },
+    );
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+/**
+ * The exact shape that was live: one custom-scheme entry alongside ordinary
+ * ones. Every origin below normalizes to the opaque origin, so before the fix
+ * the `exp://` entry admitted all of them.
+ */
+const CONFIGURED_WITH_OPAQUE_ENTRY = ['https://app.example.com', 'exp://localhost:8150'];
+const OTHER_OPAQUE_SCHEME_ORIGINS = [
+  'vscode-webview://abc123',
+  'capacitor://localhost',
+  'chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+  'file://',
+];
+
+describe('createOxyCors over a real socket', () => {
+  let server: http.Server;
+
+  beforeAll(async () => {
+    // The dropped entry logs at error level by design; that log is asserted in
+    // the configure-side suite below. Swallow it here so this suite's output
+    // carries only its own failures.
+    configureLogger({ sink: () => undefined });
+    server = await startServer({ appOrigins: CONFIGURED_WITH_OPAQUE_ENTRY });
+    resetLoggerConfig();
+  });
+
+  afterAll(async () => {
+    await stopServer(server);
+  });
+
+  it('POSITIVE CONTROL: a configured https origin gets its headers over the wire', async () => {
+    for (const method of ['GET', 'OPTIONS'] as const) {
+      const res = await requestWithOrigin(server, method, 'https://app.example.com');
+      expect(res.allowOrigin).toBe('https://app.example.com');
+      expect(res.allowCredentials).toBe('true');
+    }
+  });
+
+  it('POSITIVE CONTROL: the built-in Oxy apex family still gets its headers', async () => {
+    const res = await requestWithOrigin(server, 'GET', 'https://auth.oxy.so');
+    expect(res.allowOrigin).toBe('https://auth.oxy.so');
+    expect(res.allowCredentials).toBe('true');
+  });
+
+  it('a custom-scheme origin is NOT admitted by a custom-scheme allowlist entry', async () => {
+    for (const origin of OTHER_OPAQUE_SCHEME_ORIGINS) {
+      for (const method of ['GET', 'OPTIONS'] as const) {
+        const res = await requestWithOrigin(server, method, origin);
+        expect(res.allowOrigin).toBeUndefined();
+        expect(res.allowCredentials).toBeUndefined();
+      }
+    }
+  });
+
+  it('the opaque-origin entry does not admit even ITSELF', async () => {
+    const res = await requestWithOrigin(server, 'GET', 'exp://localhost:8150');
+    expect(res.allowOrigin).toBeUndefined();
+    expect(res.allowCredentials).toBeUndefined();
+  });
+
+  it('NEGATIVE CONTROL: a literal `Origin: null` is refused, as it always was', async () => {
+    const res = await requestWithOrigin(server, 'GET', 'null');
+    expect(res.allowOrigin).toBeUndefined();
+    expect(res.allowCredentials).toBeUndefined();
+  });
+
+  it('NEGATIVE CONTROL: an unrelated https origin is refused', async () => {
+    const res = await requestWithOrigin(server, 'GET', 'https://evil.example.com');
+    expect(res.allowOrigin).toBeUndefined();
+    expect(res.allowCredentials).toBeUndefined();
+  });
+});
+
+/**
+ * The CONFIGURE-SIDE half. Its behavioural effect is masked by the match-side
+ * half — with both in place, deleting this one changes no response — so what
+ * this suite asserts is the observable the drop-rather-than-throw decision
+ * rests on: the entry is named in an error log, and nothing else stops.
+ */
+describe('normalizeAppOrigins (configure side)', () => {
+  let entries: LogEntry[];
+
+  beforeEach(() => {
+    entries = [];
+    configureLogger({ sink: (entry) => entries.push(entry) });
+  });
+
+  afterEach(() => {
+    resetLoggerConfig();
+  });
+
+  it('drops an opaque-origin entry from the set and names it in an error log', () => {
+    const explicit = normalizeAppOrigins(CONFIGURED_WITH_OPAQUE_ENTRY);
+
+    expect([...explicit]).toEqual(['https://app.example.com']);
+    expect(explicit.has('null')).toBe(false);
+
+    const dropped = entries.filter((entry) => entry.level === 'error');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0]?.context?.entry).toBe('exp://localhost:8150');
+    expect(dropped[0]?.message).toContain('no origin to match against');
+  });
+
+  it('drops an entry that is not a URL at all, separately named', () => {
+    const explicit = normalizeAppOrigins(['not a url', 'https://app.example.com']);
+
+    expect([...explicit]).toEqual(['https://app.example.com']);
+    const dropped = entries.filter((entry) => entry.level === 'error');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0]?.context?.entry).toBe('not a url');
+    expect(dropped[0]?.message).toContain('not a URL');
+  });
+
+  it('VACUITY FLOOR: a wholly valid list is dropped from silently', () => {
+    const explicit = normalizeAppOrigins(['https://app.example.com', 'http://localhost:3000']);
+
+    expect([...explicit].sort()).toEqual(['http://localhost:3000', 'https://app.example.com']);
+    expect(entries.filter((entry) => entry.level === 'error')).toHaveLength(0);
+  });
+});
+
+/**
+ * The MATCH-SIDE half, driven with the hostile precondition the configure side
+ * prevents: a set that already contains the opaque origin. This is the only
+ * way to observe this half — through `createOxyCors` it is unreachable, so a
+ * test there would measure `normalizeAppOrigins` and report on this.
+ */
+describe('matchesAllowedOrigin (match side)', () => {
+  const poisoned: ReadonlySet<string> = new Set(['null', 'https://app.example.com']);
+
+  it('refuses every opaque-scheme origin even against a set containing "null"', () => {
+    for (const origin of [...OTHER_OPAQUE_SCHEME_ORIGINS, 'exp://localhost:8150']) {
+      expect(matchesAllowedOrigin(poisoned, origin)).toBe(false);
+    }
+  });
+
+  it('POSITIVE CONTROL: the same poisoned set still matches its real entry', () => {
+    expect(matchesAllowedOrigin(poisoned, 'https://app.example.com')).toBe(true);
+    expect(matchesAllowedOrigin(poisoned, 'https://auth.oxy.so')).toBe(true);
+    expect(matchesAllowedOrigin(poisoned, 'https://evil.example.com')).toBe(false);
+  });
+
+  it('NEGATIVE CONTROL: a literal `null` never reaches the set lookup either', () => {
+    expect(matchesAllowedOrigin(poisoned, 'null')).toBe(false);
+  });
+});