@topolo/sdk 0.3.0 → 0.4.0

package/src/application-requirements.ts

@@ -108,12 +108,12 @@ export const APPLICATION_REQUIREMENTS = [
       'Applications must derive identity, organization, scopes, and service entitlement from TopoloAuth rather than inventing parallel auth state.',
     appliesTo: ['browser', 'api', 'tooling', 'agent_surface'],
     evidence: [
-      '@topolo/auth-client or @topolo/auth-middleware is used where applicable',
+      '@topolo/auth-client or @topolo-io/worker-runtime is used where applicable',
       'No public command, tool, or SDK method accepts orgId',
       'Service slug and Auth service registration are documented for protected services',
     ],
     implementation: [
-      'Use shared auth packages instead of copying token parsing or browser storage flows',
+      'Use shared auth/runtime packages instead of copying token parsing, gateway, or browser storage flows',
       'Derive organization from the credential on every request',
       'Route OAuth, refresh, logout, and SSO paths according to the shared Auth contract',
     ],
@@ -264,6 +264,9 @@ export function applicationRequirementScopes(
   application: ApplicationCatalogEntry,
 ): ApplicationRequirementScope[] {
   const scopes = new Set<ApplicationRequirementScope>(['all']);
+  // id is checked by value: tooling ids (cli/mcp) are intentionally not in
+  // the deploy catalog union, so compare as string rather than assert overlap.
+  const appId: string = application.id;
   const hasBrowserSurface =
     Boolean(application.productionUrl) || application.deployTargets.some((target) => target.kind === 'pages');
   const hasApiSurface =
@@ -272,10 +275,10 @@ export function applicationRequirementScopes(
 
   if (hasBrowserSurface) scopes.add('browser');
   if (hasApiSurface) scopes.add('api');
-  if (application.id === 'cli' || application.id === 'mcp' || application.id === 'cloudcontrol') {
+  if (appId === 'cli' || appId === 'mcp' || appId === 'cloudcontrol') {
     scopes.add('tooling');
   }
-  if (application.id === 'cli' || application.id === 'mcp' || hasApiSurface) {
+  if (appId === 'cli' || appId === 'mcp' || hasApiSurface) {
     scopes.add('agent_surface');
   }
 
@@ -420,12 +423,13 @@ function evaluateRequirement(
       return finding(requirement, 'met', 'CloudControl deploy target metadata is present.', evidence);
     }
     case 'agent-and-operator-surfaces': {
+      const appId: string = application.id;
       if (application.services.length > 0) {
         evidence.push(`services=${application.services.join(',')}`);
         return finding(requirement, 'partial', 'SDK service discovery exists; typed SDK/CLI/MCP workflow coverage should be checked as APIs stabilize.', evidence);
       }
-      if (application.id === 'cli' || application.id === 'mcp' || application.id === 'cloudcontrol') {
-        evidence.push(`tooling=${application.id}`);
+      if (appId === 'cli' || appId === 'mcp' || appId === 'cloudcontrol') {
+        evidence.push(`tooling=${appId}`);
         return finding(requirement, 'met', 'This application is itself an agent/operator surface.', evidence);
       }
       return finding(requirement, 'missing', 'No SDK service or tooling surface is registered.', evidence);

package/src/applications.generated.ts

@@ -79,6 +79,24 @@ export const APPLICATIONS = {
       }
     ]
   },
+  "backup": {
+    "id": "backup",
+    "appDir": "TopoloBackup",
+    "name": "topolo-backup",
+    "packageName": "topolo-backup",
+    "productionUrl": null,
+    "services": [],
+    "deployTargets": [
+      {
+        "name": "topolo-backup",
+        "kind": "worker",
+        "apiUrl": null,
+        "domains": [],
+        "routes": [],
+        "serviceId": null
+      }
+    ]
+  },
   "books": {
     "id": "books",
     "appDir": "TopoloBooks",
@@ -229,15 +247,6 @@ export const APPLICATIONS = {
       }
     ]
   },
-  "cli": {
-    "id": "cli",
-    "appDir": "TopoloCli",
-    "name": "@topolo/cli",
-    "packageName": "@topolo/cli",
-    "productionUrl": null,
-    "services": [],
-    "deployTargets": []
-  },
   "cloudcontrol": {
     "id": "cloudcontrol",
     "appDir": "TopoloCloudControl",
@@ -403,24 +412,6 @@ export const APPLICATIONS = {
       }
     ]
   },
-  "d1_backup": {
-    "id": "d1_backup",
-    "appDir": "TopoloD1Backup",
-    "name": "topolo-d1-backup",
-    "packageName": "topolo-d1-backup",
-    "productionUrl": null,
-    "services": [],
-    "deployTargets": [
-      {
-        "name": "topolo-d1-backup",
-        "kind": "worker",
-        "apiUrl": null,
-        "domains": [],
-        "routes": [],
-        "serviceId": null
-      }
-    ]
-  },
   "developers": {
     "id": "developers",
     "appDir": "TopoloDevelopers",
@@ -763,15 +754,6 @@ export const APPLICATIONS = {
       }
     ]
   },
-  "mcp": {
-    "id": "mcp",
-    "appDir": "TopoloMCP",
-    "name": "@topolo/mcp",
-    "packageName": "@topolo/mcp",
-    "productionUrl": null,
-    "services": [],
-    "deployTargets": []
-  },
   "mdm": {
     "id": "mdm",
     "appDir": "TopoloMDM",
@@ -906,7 +888,7 @@ export const APPLICATIONS = {
   "one": {
     "id": "one",
     "appDir": "TopoloOne",
-    "name": "topolo-oneclick-sso",
+    "name": "TopoloOne",
     "packageName": "topolo-oneclick-sso",
     "productionUrl": "https://one.topolo.app",
     "services": [
@@ -1027,9 +1009,24 @@ export const APPLICATIONS = {
     "appDir": "TopoloPulse",
     "name": "topolo-pulse",
     "packageName": "topolo-pulse",
-    "productionUrl": null,
-    "services": [],
-    "deployTargets": []
+    "productionUrl": "https://pulse.topolo.app",
+    "services": [
+      "pulse"
+    ],
+    "deployTargets": [
+      {
+        "name": "topolo-pulse",
+        "kind": "worker",
+        "apiUrl": "https://pulse.topolo.app",
+        "domains": [
+          "pulse.topolo.app"
+        ],
+        "routes": [
+          "pulse.topolo.app"
+        ],
+        "serviceId": "pulse"
+      }
+    ]
   },
   "quro": {
     "id": "quro",
@@ -1212,6 +1209,30 @@ export const APPLICATIONS = {
       }
     ]
   },
+  "spaces": {
+    "id": "spaces",
+    "appDir": "TopoloSpaces",
+    "name": "topolo-spaces",
+    "packageName": "@topolo/spaces",
+    "productionUrl": "https://spaces.topolo.app",
+    "services": [
+      "spaces"
+    ],
+    "deployTargets": [
+      {
+        "name": "topolo-spaces",
+        "kind": "worker",
+        "apiUrl": "https://spaces.topolo.app",
+        "domains": [
+          "spaces.topolo.app"
+        ],
+        "routes": [
+          "spaces.topolo.app"
+        ],
+        "serviceId": "spaces"
+      }
+    ]
+  },
   "status": {
     "id": "status",
     "appDir": "TopoloStatus",

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' },
@@ -262,14 +273,28 @@ describe('TopoloClient.getServiceIdBySlug', () => {
     });
   }
 
-  it('resolves a known slug via /api/services/by-slug/:slug', async () => {
+  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: 'srv_abc123', base_url: 'https://x' } } },
+      { 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('topolo-notify');
-    expect(id).toBe('srv_abc123');
-    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/topolo-notify');
+    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();
@@ -286,21 +311,21 @@ describe('TopoloClient.getServiceIdBySlug', () => {
 
   it('caches positive results across calls', async () => {
     const { impl, calls } = stubFetch([
-      { body: { success: true, data: { service_id: 'srv_iCwM4jGXcwlj' } } },
+      { body: { success: true, data: { service_id: 'service_external' } } },
     ]);
     const client = freshClient(impl, { auth: 'https://auth.example.com' });
-    expect(await client.getServiceIdBySlug('topolo-crm')).toBe('srv_iCwM4jGXcwlj');
-    expect(await client.getServiceIdBySlug('topolo-crm')).toBe('srv_iCwM4jGXcwlj');
+    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: 'srv_x' } } },
+      { body: { success: true, data: { service_id: 'service_x' } } },
     ]);
     const client = freshClient(impl, { auth: 'https://auth.example.com' });
-    await client.getServiceIdBySlug('  TOPOLO-NOTIFY  ');
-    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/topolo-notify');
+    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 () => {
@@ -310,7 +335,7 @@ describe('TopoloClient.getServiceIdBySlug', () => {
         throws = false;
         throw new Error('ECONNREFUSED');
       }
-      return new Response(JSON.stringify({ success: true, data: { service_id: 'srv_y' } }), {
+      return new Response(JSON.stringify({ success: true, data: { service_id: 'service_y' } }), {
         status: 200,
         headers: { 'Content-Type': 'application/json' },
       });
@@ -324,7 +349,71 @@ describe('TopoloClient.getServiceIdBySlug', () => {
     });
     expect(await client.getServiceIdBySlug('flaky')).toBeNull();
     // Second call retries — earlier null was not cached.
-    expect(await client.getServiceIdBySlug('flaky')).toBe('srv_y');
+    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);
   });
 });
 

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.
@@ -89,10 +91,27 @@ interface ServiceIdCacheEntry {
   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;
@@ -120,6 +139,7 @@ export class TopoloClient {
     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;
@@ -160,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);
@@ -249,12 +269,7 @@ export class TopoloClient {
   }
 
   /**
-   * Resolve a service-slug → opaque service-id via TopoloAuth.
-   *
-   * Replaces the SDK-baked `PLATFORM_SERVICE_IDS` map (deprecated in 0.3.0,
-   * removed in 0.4.0). Slug shape accepted: either the canonical Auth slug
-   * (e.g. `topolo-notify`) or the SDK short id (`notify`) — Auth's resolver
-   * understands both.
+   * 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
@@ -270,6 +285,9 @@ export class TopoloClient {
     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();
@@ -318,6 +336,77 @@ export class TopoloClient {
     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
@@ -362,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,