@topolo/sdk 0.2.12 → 0.4.0

package/src/client.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { TopoloClient } from './client.js';
 import { TopoloAuthError, TopoloHttpError, TopoloPermissionError } from './errors.js';
 
@@ -16,6 +16,15 @@ function stubFetch(responses: Array<{ status?: number; body?: unknown; contentTy
 }
 
 const AGENT = { clientName: 'topolo-test', clientVersion: '0.0.0' };
+const SERVICE_LOOKUP = { body: { success: true, data: { service_id: 'service_test' } } };
+
+function requestCalls(calls: Array<{ url: string; init: RequestInit }>) {
+  return calls.filter((call) => !call.url.includes('/api/services/by-slug/'));
+}
+
+beforeEach(() => {
+  TopoloClient.clearServiceIdCache();
+});
 
 describe('TopoloClient.request', () => {
   it('injects Bearer auth + audit headers for access_token credentials', async () => {
@@ -24,10 +33,12 @@ describe('TopoloClient.request', () => {
       credential: { kind: 'access_token', accessToken: 'tok_abc' },
       agent: AGENT,
       fetch: impl,
+      serviceIds: { auth: 'service_auth' },
     });
     await client.request({ service: 'auth', path: '/api/me' });
-    const headers = new Headers(calls[0]!.init.headers);
+    const headers = new Headers(requestCalls(calls)[0]!.init.headers);
     expect(headers.get('Authorization')).toBe('Bearer tok_abc');
+    expect(headers.get('X-Service-ID')).toBe('service_auth');
     expect(headers.get('X-Topolo-Client')).toBe('topolo-test/0.0.0');
     expect(headers.get('X-Topolo-Request-Id')).toMatch(/.+/);
   });
@@ -40,7 +51,7 @@ describe('TopoloClient.request', () => {
       fetch: impl,
     });
     await client.request({ service: 'crm', path: '/api/contacts' });
-    const headers = new Headers(calls[0]!.init.headers);
+    const headers = new Headers(requestCalls(calls)[0]!.init.headers);
     expect(headers.get('X-Api-Key')).toBe('dak_xyz');
     expect(headers.get('Authorization')).toBeNull();
   });
@@ -71,7 +82,7 @@ describe('TopoloClient.request', () => {
       body: { email: 'a@b.co' },
       confirm: true,
     });
-    expect(calls[0]!.init.method).toBe('POST');
+    expect(requestCalls(calls)[0]!.init.method).toBe('POST');
   });
 
   it('maps 401 → TopoloAuthError with unwrapped message', async () => {
@@ -144,7 +155,7 @@ describe('TopoloClient.request', () => {
       fetch: impl,
     });
     await client.request({ service: 'crm', path: '/api/contacts', query: { q: 'acme', page: 2 } });
-    const u = new URL(calls[0]!.url);
+    const u = new URL(requestCalls(calls)[0]!.url);
     expect(u.searchParams.get('q')).toBe('acme');
     expect(u.searchParams.get('page')).toBe('2');
   });
@@ -169,7 +180,7 @@ describe('TopoloClient.request', () => {
 
 describe('TopoloClient.debug hook', () => {
   it('fires request → response on a successful call with stable requestId + duration', async () => {
-    const { impl } = stubFetch([{ body: { ok: true } }]);
+    const { impl } = stubFetch([SERVICE_LOOKUP, { body: { ok: true } }]);
     const events: unknown[] = [];
     const client = new TopoloClient({
       credential: { kind: 'api_key', apiKey: 'x' },
@@ -251,5 +262,160 @@ describe('TopoloClient.debug hook', () => {
   });
 });
 
+describe('TopoloClient.getServiceIdBySlug', () => {
+  function freshClient(impl: typeof fetch, serviceUrls?: Record<string, string>) {
+    TopoloClient.clearServiceIdCache();
+    return new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'x' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: serviceUrls as never,
+    });
+  }
+
+  it('uses configured service ids without calling Auth', async () => {
+    const { impl, calls } = stubFetch([]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'x' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' } as never,
+      serviceIds: { notify: 'service_notify' },
+    });
+    const id = await client.getServiceIdBySlug('topolo-notify');
+    expect(id).toBe('service_notify');
+    expect(calls).toEqual([]);
+  });
+
+  it('falls back to /api/services/by-slug/:slug for unknown slugs', async () => {
+    const { impl, calls } = stubFetch([
+      { body: { success: true, data: { service_id: 'service_abc123', base_url: 'https://x' } } },
+    ]);
+    const client = freshClient(impl, { auth: 'https://auth.example.com' });
+    const id = await client.getServiceIdBySlug('external-service');
+    expect(id).toBe('service_abc123');
+    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/external-service');
+    // No auth header — endpoint is public.
+    const headers = new Headers(calls[0]!.init.headers);
+    expect(headers.get('Authorization')).toBeNull();
+    expect(headers.get('X-Api-Key')).toBeNull();
+  });
+
+  it('returns null on 404 and caches the negative result', async () => {
+    const { impl, calls } = stubFetch([{ status: 404, body: { success: false } }]);
+    const client = freshClient(impl, { auth: 'https://auth.example.com' });
+    expect(await client.getServiceIdBySlug('nope')).toBeNull();
+    expect(await client.getServiceIdBySlug('nope')).toBeNull();
+    expect(calls.length).toBe(1);
+  });
+
+  it('caches positive results across calls', async () => {
+    const { impl, calls } = stubFetch([
+      { body: { success: true, data: { service_id: 'service_external' } } },
+    ]);
+    const client = freshClient(impl, { auth: 'https://auth.example.com' });
+    expect(await client.getServiceIdBySlug('external-service')).toBe('service_external');
+    expect(await client.getServiceIdBySlug('external-service')).toBe('service_external');
+    expect(calls.length).toBe(1);
+  });
+
+  it('normalizes slug case + whitespace before hitting the network', async () => {
+    const { impl, calls } = stubFetch([
+      { body: { success: true, data: { service_id: 'service_x' } } },
+    ]);
+    const client = freshClient(impl, { auth: 'https://auth.example.com' });
+    await client.getServiceIdBySlug('  EXTERNAL-SERVICE  ');
+    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/external-service');
+  });
+
+  it('returns null on network failure without poisoning cache', async () => {
+    let throws = true;
+    const impl = vi.fn(async (url: string) => {
+      if (throws) {
+        throws = false;
+        throw new Error('ECONNREFUSED');
+      }
+      return new Response(JSON.stringify({ success: true, data: { service_id: 'service_y' } }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }) as unknown as typeof fetch;
+    TopoloClient.clearServiceIdCache();
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'x' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' } as never,
+    });
+    expect(await client.getServiceIdBySlug('flaky')).toBeNull();
+    // Second call retries — earlier null was not cached.
+    expect(await client.getServiceIdBySlug('flaky')).toBe('service_y');
+  });
+});
+
+describe('TopoloClient.listServices', () => {
+  it('normalizes the live catalog and attaches the credential', async () => {
+    const { impl, calls } = stubFetch([
+      {
+        body: {
+          data: {
+            services: [
+              {
+                service_id: 'srv_wRCnLLbtvmVT',
+                app_slug: 'topolo-director',
+                name: 'Topolo Director',
+                description: 'Demo control plane',
+                base_url: 'https://director.topolo.app',
+                status: 'active',
+                surface_kind: 'application',
+                launchable: true,
+              },
+            ],
+          },
+        },
+      },
+    ]);
+    const client = new TopoloClient({
+      credential: { kind: 'access_token', accessToken: 'tok_abc' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+    const out = await client.listServices();
+    expect(out).toEqual([
+      {
+        serviceId: 'srv_wRCnLLbtvmVT',
+        slug: 'topolo-director',
+        name: 'Topolo Director',
+        description: 'Demo control plane',
+        baseUrl: 'https://director.topolo.app',
+        status: 'active',
+        surfaceKind: 'application',
+        launchable: true,
+      },
+    ]);
+    expect(calls[0]!.url).toBe(
+      'https://auth.example.com/api/services/catalog',
+    );
+    expect(new Headers(calls[0]!.init.headers).get('Authorization')).toBe(
+      'Bearer tok_abc',
+    );
+  });
+
+  it('falls back to the generated snapshot on HTTP failure', async () => {
+    const { impl } = stubFetch([{ status: 503, body: { error: 'down' } }]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'dak_xyz' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+    const out = await client.listServices();
+    expect(out.length).toBeGreaterThan(10);
+    expect(out.some((e) => e.serviceId === 'admin')).toBe(true);
+    expect(out.every((e) => typeof e.serviceId === 'string')).toBe(true);
+  });
+});
+
 // Silence unused-import warning if the bundler later tree-shakes these
 void TopoloHttpError;

package/src/client.ts

@@ -7,7 +7,7 @@ import {
 } from './auth.js';
 import { TopoloAuthError, TopoloHttpError, TopoloPermissionError } from './errors.js';
 import {
-  PLATFORM_SERVICE_IDS,
+  APPLICATIONS,
   resolveServiceUrl,
   type ServiceId,
 } from './services.js';
@@ -17,6 +17,8 @@ export interface TopoloClientOptions {
   agent: AgentIdentity;
   /** Per-service URL overrides. Useful for staging/dev. */
   serviceUrls?: Partial<Record<ServiceId, string>>;
+  /** Per-service TopoloAuth service id overrides from the owning app/deployment. */
+  serviceIds?: Partial<Record<ServiceId, string>>;
   /**
    * When true, mutating helpers (POST/PUT/PATCH/DELETE) require callers to pass
    * `{ confirm: true }`. Defaults to true. Set false only for trusted surfaces.
@@ -81,21 +83,63 @@ export interface RequestOptions {
 
 const WRITE_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 
+const POSITIVE_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const NEGATIVE_CACHE_TTL_MS = 60 * 1000; // 1 minute
+
+interface ServiceIdCacheEntry {
+  value: string | null;
+  expiresAt: number;
+}
+
+/**
+ * A single entry from the live platform service catalog. Returned by
+ * {@link TopoloClient.listServices}. Shape mirrors the public-safe projection
+ * from TopoloAuth `GET /api/services/catalog`.
+ */
+export interface TopoloServiceCatalogEntry {
+  serviceId: string;
+  slug: string | null;
+  name: string | null;
+  description: string | null;
+  baseUrl: string | null;
+  status: string | null;
+  surfaceKind: string | null;
+  launchable: boolean;
+}
+
 export class TopoloClient {
   private readonly credential: TopoloCredential;
   private readonly agent: AgentIdentity;
   private readonly serviceUrls?: Partial<Record<ServiceId, string>>;
+  private readonly serviceIds?: Partial<Record<ServiceId, string>>;
   private readonly requireConfirmForWrites: boolean;
   private readonly timeoutMs: number;
   private readonly fetchImpl: typeof fetch;
   private readonly debug?: (event: TopoloDebugEvent) => void;
 
+  /**
+   * Process-wide cache for slug → service-id lookups. Keyed by
+   * `${authBaseUrl}|${slug}` so multiple `TopoloClient` instances pointing at
+   * the same Auth share, but staging vs prod don't poison each other.
+   * Cleared via `TopoloClient.clearServiceIdCache()` if a test needs it.
+   */
+  private static readonly serviceIdCache = new Map<string, ServiceIdCacheEntry>();
+
+  /**
+   * Drop the slug→service-id cache. Test-only — production callers should
+   * let the 5-minute TTL expire naturally.
+   */
+  static clearServiceIdCache(): void {
+    TopoloClient.serviceIdCache.clear();
+  }
+
   constructor(options: TopoloClientOptions) {
     if (!options.credential) throw new TopoloAuthError('credential is required');
     if (!options.agent?.clientName) throw new TopoloAuthError('agent.clientName is required');
     this.credential = options.credential;
     this.agent = options.agent;
     this.serviceUrls = options.serviceUrls;
+    this.serviceIds = options.serviceIds;
     this.requireConfirmForWrites = options.requireConfirmForWrites !== false;
     this.timeoutMs = options.timeoutMs ?? 30_000;
     this.fetchImpl = options.fetch ?? fetch;
@@ -136,7 +180,7 @@ export class TopoloClient {
     const headers = new Headers();
     headers.set('Accept', 'application/json');
     if (opts.body !== undefined) headers.set('Content-Type', 'application/json');
-    const platformServiceId = PLATFORM_SERVICE_IDS[opts.service];
+    const platformServiceId = resolveConfiguredServiceId(opts.service, this.serviceIds);
     if (platformServiceId) headers.set('X-Service-ID', platformServiceId);
 
     applyAuthHeaders(headers, this.credential);
@@ -224,6 +268,145 @@ export class TopoloClient {
     return parsed as T;
   }
 
+  /**
+   * Resolve a service-slug → opaque service-id via caller config or TopoloAuth.
+   *
+   * Cache: 5 minutes per process per `(slug, auth_base_url)`. Negative
+   * results (404) are cached for 60s so a typo doesn't hot-loop the
+   * resolver. Returns null when the slug isn't registered — callers decide
+   * whether to throw.
+   *
+   * No credential is sent: the endpoint is public (slugs aren't secret).
+   * This keeps the resolver usable during early bootstrap before a caller
+   * has acquired an access token.
+   */
+  async getServiceIdBySlug(slug: string): Promise<string | null> {
+    if (typeof slug !== 'string') return null;
+    const normalized = slug.trim().toLowerCase();
+    if (!normalized) return null;
+
+    const configuredServiceId = resolveConfiguredServiceId(normalized, this.serviceIds);
+    if (configuredServiceId) return configuredServiceId;
+
+    const authBase = resolveServiceUrl('auth', this.serviceUrls);
+    const cacheKey = `${authBase}|${normalized}`;
+    const now = Date.now();
+    const cached = TopoloClient.serviceIdCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cached.value;
+    }
+
+    const url = new URL(
+      `/api/services/by-slug/${encodeURIComponent(normalized)}`,
+      authBase.endsWith('/') ? authBase : `${authBase}/`,
+    ).toString();
+
+    let res: Response;
+    try {
+      res = await this.fetchImpl(url, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+      });
+    } catch {
+      // Network-level failure — don't poison cache; let the caller retry.
+      return null;
+    }
+
+    if (res.status === 404) {
+      TopoloClient.serviceIdCache.set(cacheKey, {
+        value: null,
+        expiresAt: now + NEGATIVE_CACHE_TTL_MS,
+      });
+      return null;
+    }
+
+    if (!res.ok) {
+      return null;
+    }
+
+    const body = (await res.json().catch(() => null)) as
+      | { success?: boolean; data?: { service_id?: unknown } }
+      | null;
+    const serviceId = body?.data?.service_id;
+    const value = typeof serviceId === 'string' && serviceId ? serviceId : null;
+    TopoloClient.serviceIdCache.set(cacheKey, {
+      value,
+      expiresAt: now + POSITIVE_CACHE_TTL_MS,
+    });
+    return value;
+  }
+
+  /**
+   * List the platform service catalog from the live registry
+   * (`GET /api/services/catalog` on TopoloAuth). Credential-aware: the
+   * caller's credential is attached, so an authenticated caller in an
+   * entitled org also receives the `developer_only` services its role
+   * permits; an unauthenticated/agent caller receives `active` only.
+   *
+   * Resilient: on any network/HTTP failure this falls back to the
+   * build-time generated `APPLICATIONS` snapshot so offline/degraded
+   * callers still get a usable (if static) catalog. The live result is
+   * authoritative; the snapshot is a floor, not a cap.
+   */
+  async listServices(): Promise<TopoloServiceCatalogEntry[]> {
+    try {
+      const res = await this.request<
+        | { data?: { services?: unknown[] } }
+        | { services?: unknown[] }
+      >({ service: 'auth', method: 'GET', path: '/api/services/catalog' });
+      const raw =
+        (res as { data?: { services?: unknown[] } }).data?.services ??
+        (res as { services?: unknown[] }).services;
+      if (Array.isArray(raw) && raw.length > 0) {
+        const entries: TopoloServiceCatalogEntry[] = [];
+        for (const item of raw) {
+          const s = item as Record<string, unknown>;
+          const serviceId =
+            typeof s.service_id === 'string'
+              ? s.service_id
+              : typeof s.id === 'string'
+                ? s.id
+                : null;
+          if (!serviceId) continue;
+          entries.push({
+            serviceId,
+            slug: typeof s.app_slug === 'string' ? s.app_slug : null,
+            name: typeof s.name === 'string' ? s.name : null,
+            description:
+              typeof s.description === 'string' ? s.description : null,
+            baseUrl: typeof s.base_url === 'string' ? s.base_url : null,
+            status: typeof s.status === 'string' ? s.status : null,
+            surfaceKind:
+              typeof s.surface_kind === 'string' ? s.surface_kind : null,
+            launchable: s.launchable === true,
+          });
+        }
+        if (entries.length > 0) return entries;
+      }
+    } catch {
+      // Fall through to the generated snapshot.
+    }
+    return this.generatedCatalogFallback();
+  }
+
+  private generatedCatalogFallback(): TopoloServiceCatalogEntry[] {
+    const apps = Object.values(APPLICATIONS) as ReadonlyArray<{
+      id: string;
+      name?: string;
+      productionUrl?: string | null;
+    }>;
+    return apps.map((app) => ({
+      serviceId: app.id,
+      slug: app.id,
+      name: app.name ?? app.id,
+      description: null,
+      baseUrl: app.productionUrl ?? null,
+      status: 'active',
+      surfaceKind: 'application',
+      launchable: Boolean(app.productionUrl),
+    }));
+  }
+
   /**
    * Introspect the current credential. Returns the caller's resolved identity,
    * organization, and permission set. Used by CLI `whoami` and by MCP to gate
@@ -268,6 +451,35 @@ export class TopoloClient {
   }
 }
 
+function resolveConfiguredServiceId(
+  slug: string,
+  serviceIds?: Partial<Record<ServiceId, string>>,
+): string | null {
+  for (const serviceKey of serviceKeyCandidates(slug)) {
+    const configured = serviceIds?.[serviceKey as ServiceId];
+    if (typeof configured === 'string' && configured.trim()) return configured.trim();
+
+    const envKey = `TOPOLO_SERVICE_ID_${serviceKey.replace(/\./g, '_').toUpperCase()}`;
+    const envValue = typeof process !== 'undefined' ? process.env?.[envKey] : undefined;
+    if (typeof envValue === 'string' && envValue.trim()) return envValue.trim();
+  }
+
+  return null;
+}
+
+function serviceKeyCandidates(slug: string): string[] {
+  const normalized = slug.trim().toLowerCase();
+  const withoutTopolo = normalized.startsWith('topolo-')
+    ? normalized.slice('topolo-'.length)
+    : normalized;
+  return [...new Set([
+    normalized,
+    normalized.replace(/-/g, '_'),
+    withoutTopolo,
+    withoutTopolo.replace(/-/g, '_'),
+  ])];
+}
+
 interface AuthMePayload {
   credentialType?: 'access_token' | 'api_key';
   user: RawUser;

package/src/index.ts

@@ -4,6 +4,7 @@ export {
   type RequestOptions,
   type CredentialIntrospection,
   type TopoloDebugEvent,
+  type TopoloServiceCatalogEntry,
 } from "./client.js";
 export type { TopoloCredential, AgentIdentity } from "./auth.js";
 export {
@@ -11,7 +12,6 @@ export {
   APPLICATIONS,
   APPLICATION_REQUIREMENTS,
   APPLICATION_REQUIREMENTS_VERSION,
-  PLATFORM_SERVICE_IDS,
   auditAllApplicationRequirements,
   auditApplicationRequirements,
   applicationRequirementScopes,

package/src/modules/p2p.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { TopoloClient } from '../client.js';
 import { P2PModule } from './p2p.js';
 
@@ -8,6 +8,12 @@ function stubFetch(responses: Array<{ status?: number; body?: unknown }>) {
   const calls: Array<{ url: string; init: RequestInit }> = [];
   const impl = vi.fn(async (url: string, init: RequestInit) => {
     calls.push({ url, init });
+    if (String(url).includes('/api/services/by-slug/')) {
+      return new Response(JSON.stringify({ success: true, data: { service_id: 'service_p2p' } }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
     const next = responses.shift() ?? { status: 200, body: { success: true, data: {} } };
     return new Response(JSON.stringify(next.body ?? { success: true, data: {} }), {
       status: next.status ?? 200,
@@ -17,6 +23,10 @@ function stubFetch(responses: Array<{ status?: number; body?: unknown }>) {
   return { impl: impl as unknown as typeof fetch, calls };
 }
 
+function requestCalls(calls: Array<{ url: string; init: RequestInit }>) {
+  return calls.filter((call) => !call.url.includes('/api/services/by-slug/'));
+}
+
 function clientWith(impl: typeof fetch) {
   return new TopoloClient({
     credential: { kind: 'access_token', accessToken: 'tok_test' },
@@ -26,6 +36,10 @@ function clientWith(impl: typeof fetch) {
 }
 
 describe('P2PModule.listDirectory', () => {
+  beforeEach(() => {
+    TopoloClient.clearServiceIdCache();
+  });
+
   it('GETs /api/directory/capabilities and unwraps the envelope', async () => {
     const { impl, calls } = stubFetch([
       {
@@ -37,7 +51,7 @@ describe('P2PModule.listDirectory', () => {
                 capability_id: 'cap_1',
                 publisher_org_id: 'org_a',
                 app_id: 'app_x',
-                service_id: 'srv_x',
+                service_id: 'service_x',
                 name: 'Demo',
                 description: 'A capability',
                 category: 'other',
@@ -60,10 +74,11 @@ describe('P2PModule.listDirectory', () => {
     const capabilities = await p2p.listDirectory({ limit: 10 });
     expect(capabilities).toHaveLength(1);
     expect(capabilities[0]!.capability_id).toBe('cap_1');
-    const url = new URL(calls[0]!.url);
+    const call = requestCalls(calls)[0]!;
+    const url = new URL(call.url);
     expect(url.pathname).toBe('/api/directory/capabilities');
     expect(url.searchParams.get('limit')).toBe('10');
-    expect((calls[0]!.init.method ?? 'GET').toUpperCase()).toBe('GET');
+    expect((call.init.method ?? 'GET').toUpperCase()).toBe('GET');
   });
 });
 
@@ -78,7 +93,7 @@ describe('P2PModule.publishCapability', () => {
               capability_id: 'cap_z',
               publisher_org_id: 'org_p',
               app_id: 'app_x',
-              service_id: 'srv_x',
+              service_id: 'service_x',
               name: 'Demo',
               description: 'A capability',
               category: 'other',
@@ -101,7 +116,7 @@ describe('P2PModule.publishCapability', () => {
       capability_id: 'cap_z',
       publisher_org_id: 'org_p',
       app_id: 'app_x',
-      service_id: 'srv_x',
+      service_id: 'service_x',
       name: 'Demo',
       description: 'A capability',
       category: 'other',
@@ -114,13 +129,14 @@ describe('P2PModule.publishCapability', () => {
     });
     expect(capability.capability_id).toBe('cap_z');
 
-    const sent = JSON.parse(String(calls[0]!.init.body));
+    const call = requestCalls(calls)[0]!;
+    const sent = JSON.parse(String(call.init.body));
     expect(sent.publisher_org_id).toBe('org_p');
     expect(sent.acting_for_org_id).toBe('org_p');
     expect(sent.public_directory_visible).toBe(true);
     expect(sent.requires_human_approval).toBe(false);
     expect(sent.trust_level).toBe('standard');
-    const url = new URL(calls[0]!.url);
+    const url = new URL(call.url);
     expect(url.pathname).toBe('/api/p2p/internal/capabilities/sync');
     expect((calls[0]!.init.method ?? '').toUpperCase()).toBe('POST');
   });
@@ -134,7 +150,7 @@ describe('P2PModule.publishCapability', () => {
       capability_id: 'cap_other',
       publisher_org_id: 'org_target',
       app_id: 'app_x',
-      service_id: 'srv_x',
+      service_id: 'service_x',
       name: 'Demo',
       description: '...',
       category: 'other',
@@ -144,7 +160,7 @@ describe('P2PModule.publishCapability', () => {
       source_revision: 'rev_1',
       acting_for_org_id: 'org_target',
     });
-    const sent = JSON.parse(String(calls[0]!.init.body));
+    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
     expect(sent.acting_for_org_id).toBe('org_target');
   });
 });
@@ -211,7 +227,7 @@ describe('P2PModule.releaseHold', () => {
     const result = await p2p.releaseHold('hold_1', 'seller', { reason: 'arbitration' });
     expect(result.resolution).toBe('seller');
     expect(result.cancel_entries[0]!.entry_id).toBe('led_1');
-    const sent = JSON.parse(String(calls[0]!.init.body));
+    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
     expect(sent.resolution).toBe('seller');
     expect(sent.reason).toBe('arbitration');
   });

package/src/services.generated.ts

@@ -36,12 +36,14 @@ export const SERVICES = {
   p2p: "https://p2p.topolo.app",
   pay: "https://pay.topolo.app",
   people: "https://people.topolo.app",
+  pulse: "https://pulse.topolo.app",
   "quro.api": "https://api.ol0.me",
   "quro.redirect": "https://ol0.me",
   roadmapper: "https://roadmapper-api.topolo.app",
   sign: "https://sign.topolo.app",
   social_studio: "https://studio-api.topolo.app",
   socialize: "https://socialize-api.topolo.app",
+  spaces: "https://spaces.topolo.app",
   status: "https://status.topolo.app",
   support: "https://support.topolo.app",
   survey: "https://survey.topolo.app",
@@ -50,27 +52,3 @@ export const SERVICES = {
 } as const;
 
 export type ServiceId = keyof typeof SERVICES;
-
-export const PLATFORM_SERVICE_IDS: Partial<Record<ServiceId, string>> = {
-  books: "srv_0g260hbN8oqv",
-  bugfix: "srv_kQ1t8qUSDgNs",
-  compose: "srv_aR3ETYmgygmd",
-  consent: "srv_8FIGR7Q7zP9r",
-  crm: "srv_iCwM4jGXcwlj",
-  customer_success: "srv_RWpOxkgZdZbH",
-  developers: "srv_NjDq9G9qyyjr",
-  director: "srv_wRCnLLbtvmVT",
-  flow: "srv_GBCuKkHhnRXv",
-  forms: "srv_UE7IcGe80J5o",
-  home: "srv_hE6HBldVzjth",
-  insights: "srv_DgbBMwWSIhmC",
-  inventory: "srv_hmvjbv3ZxDnh",
-  localize: "srv_Ze1g9OmXuZjF",
-  notify: "srv_9pRdkIjYyKX0",
-  p2p: "srv_4BzeLqH0wCve",
-  people: "srv_VDMBAonA5fKb",
-  sign: "srv_Bd8pRw5ZqRBT",
-  status: "srv_topolo_status",
-  survey: "srv_RCOi7CJkwf7R",
-  voice: "srv_BZANHkshGAK5",
-};