@pellux/goodvibes-tui 0.18.8 → 0.18.9

package/src/control-plane/method-catalog-shared.ts

@@ -1,223 +1 @@
-import type { RuntimeEventDomain } from '../runtime/events/index.ts';
-
-export type GatewayMethodTransport = 'http' | 'ws' | 'internal';
-export type GatewayMethodSource = 'builtin' | 'plugin';
-export type GatewayMethodAccess = 'public' | 'authenticated' | 'admin' | 'remote-peer';
-export type GatewayEventTransport = 'sse' | 'ws' | 'internal';
-
-export interface GatewayHttpBinding {
-  readonly method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
-  readonly path: string;
-}
-
-export interface GatewayMethodDescriptor {
-  readonly id: string;
-  readonly title: string;
-  readonly description: string;
-  readonly category: string;
-  readonly source: GatewayMethodSource;
-  readonly access: GatewayMethodAccess;
-  readonly transport: readonly GatewayMethodTransport[];
-  readonly scopes: readonly string[];
-  readonly http?: GatewayHttpBinding;
-  readonly events?: readonly string[];
-  readonly inputSchema?: Record<string, unknown>;
-  readonly outputSchema?: Record<string, unknown>;
-  readonly pluginId?: string;
-  readonly dangerous?: boolean;
-  readonly invokable?: boolean;
-  readonly metadata?: Record<string, unknown>;
-}
-
-export interface GatewayEventDescriptor {
-  readonly id: string;
-  readonly title: string;
-  readonly description: string;
-  readonly category: string;
-  readonly source: GatewayMethodSource;
-  readonly transport: readonly GatewayEventTransport[];
-  readonly scopes: readonly string[];
-  readonly domains?: readonly RuntimeEventDomain[];
-  readonly wireEvents?: readonly string[];
-  readonly outputSchema?: Record<string, unknown>;
-  readonly pluginId?: string;
-  readonly metadata?: Record<string, unknown>;
-}
-
-export interface GatewayMethodInvocationContext {
-  readonly principalId?: string;
-  readonly principalKind?: 'user' | 'bot' | 'service' | 'token' | 'remote-peer';
-  readonly admin?: boolean;
-  readonly scopes?: readonly string[];
-  readonly clientKind?: string;
-  readonly authToken?: string;
-  readonly metadata?: Record<string, unknown>;
-}
-
-export interface GatewayMethodInvocation {
-  readonly body?: unknown;
-  readonly query?: Record<string, unknown>;
-  readonly context: GatewayMethodInvocationContext;
-}
-
-export type GatewayMethodHandler = (input: GatewayMethodInvocation) => unknown | Promise<unknown>;
-export interface GatewayMethodListOptions {
-  readonly category?: string;
-  readonly source?: GatewayMethodSource;
-  readonly pluginId?: string;
-}
-
-export interface GatewayEventListOptions {
-  readonly category?: string;
-  readonly source?: GatewayMethodSource;
-  readonly pluginId?: string;
-  readonly domain?: RuntimeEventDomain;
-}
-
-export const EMPTY_OBJECT_SCHEMA = { type: 'object', properties: {}, additionalProperties: false } as const;
-export const STRING_SCHEMA = { type: 'string' } as const;
-export const BOOLEAN_SCHEMA = { type: 'boolean' } as const;
-export const NUMBER_SCHEMA = { type: 'number' } as const;
-const NULL_SCHEMA = { type: 'null' } as const;
-export const JSON_VALUE_SCHEMA: Record<string, unknown> = {};
-export const JSON_OBJECT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  additionalProperties: JSON_VALUE_SCHEMA,
-};
-export const JSON_ARRAY_SCHEMA: Record<string, unknown> = {
-  type: 'array',
-  items: JSON_VALUE_SCHEMA,
-};
-
-Object.assign(JSON_VALUE_SCHEMA, {
-  anyOf: [
-    STRING_SCHEMA,
-    NUMBER_SCHEMA,
-    BOOLEAN_SCHEMA,
-    NULL_SCHEMA,
-    JSON_OBJECT_SCHEMA,
-    JSON_ARRAY_SCHEMA,
-  ],
-});
-
-export function arraySchema(itemSchema: Record<string, unknown>): Record<string, unknown> {
-  return { type: 'array', items: itemSchema };
-}
-
-export function objectSchema(
-  properties: Record<string, Record<string, unknown>>,
-  required: readonly string[] = [],
-  options: { readonly additionalProperties?: boolean } = {},
-): Record<string, unknown> {
-  return {
-    type: 'object',
-    properties,
-    ...(required.length > 0 ? { required: [...required] } : {}),
-    additionalProperties: options.additionalProperties ?? false,
-  };
-}
-
-export const GATEWAY_HTTP_BINDING_SCHEMA = objectSchema({
-  method: STRING_SCHEMA,
-  path: STRING_SCHEMA,
-}, ['method', 'path']);
-
-export const METHOD_DESCRIPTOR_SCHEMA = objectSchema({
-  id: STRING_SCHEMA,
-  title: STRING_SCHEMA,
-  description: STRING_SCHEMA,
-  category: STRING_SCHEMA,
-  source: STRING_SCHEMA,
-  access: STRING_SCHEMA,
-  transport: arraySchema(STRING_SCHEMA),
-  scopes: arraySchema(STRING_SCHEMA),
-  http: GATEWAY_HTTP_BINDING_SCHEMA,
-  events: arraySchema(STRING_SCHEMA),
-  inputSchema: JSON_OBJECT_SCHEMA,
-  outputSchema: JSON_OBJECT_SCHEMA,
-  pluginId: STRING_SCHEMA,
-  dangerous: BOOLEAN_SCHEMA,
-  invokable: BOOLEAN_SCHEMA,
-  metadata: JSON_OBJECT_SCHEMA,
-}, ['id', 'title', 'description', 'category', 'source', 'access', 'transport', 'scopes']);
-
-export const EVENT_DESCRIPTOR_SCHEMA = objectSchema({
-  id: STRING_SCHEMA,
-  title: STRING_SCHEMA,
-  description: STRING_SCHEMA,
-  category: STRING_SCHEMA,
-  source: STRING_SCHEMA,
-  transport: arraySchema(STRING_SCHEMA),
-  scopes: arraySchema(STRING_SCHEMA),
-  domains: arraySchema(STRING_SCHEMA),
-  wireEvents: arraySchema(STRING_SCHEMA),
-  outputSchema: JSON_OBJECT_SCHEMA,
-  pluginId: STRING_SCHEMA,
-  metadata: JSON_OBJECT_SCHEMA,
-}, ['id', 'title', 'description', 'category', 'source', 'transport', 'scopes']);
-
-export function listOutputSchema(
-  key: string,
-  itemSchema: Record<string, unknown>,
-): Record<string, unknown> {
-  return objectSchema({ [key]: arraySchema(itemSchema) }, [key], { additionalProperties: false });
-}
-
-export function entityOutputSchema(
-  key: string,
-  entitySchema: Record<string, unknown>,
-): Record<string, unknown> {
-  return objectSchema({ [key]: entitySchema }, [key], { additionalProperties: false });
-}
-
-export function actionResultOutputSchema(
-  key: string,
-  entitySchema: Record<string, unknown>,
-): Record<string, unknown> {
-  return objectSchema({
-    [key]: entitySchema,
-  }, [key], { additionalProperties: true });
-}
-
-export function bodyEnvelopeSchema(
-  properties: Record<string, Record<string, unknown>> = {},
-  required: readonly string[] = [],
-): Record<string, unknown> {
-  return objectSchema({
-    ...properties,
-  }, required, { additionalProperties: true });
-}
-
-export function methodDescriptor(input: Omit<GatewayMethodDescriptor, 'source' | 'transport' | 'access'> & Partial<Pick<GatewayMethodDescriptor, 'source' | 'transport' | 'access'>>): GatewayMethodDescriptor {
-  return {
-    source: input.source ?? 'builtin',
-    transport: input.transport ?? ['http', 'ws'],
-    access: input.access ?? 'authenticated',
-    ...input,
-  };
-}
-
-export function eventDescriptor(input: Omit<GatewayEventDescriptor, 'source'> & Partial<Pick<GatewayEventDescriptor, 'source'>>): GatewayEventDescriptor {
-  return {
-    source: input.source ?? 'builtin',
-    ...input,
-  };
-}
-
-export function runtimeEventId(domain: RuntimeEventDomain): string {
-  return `runtime.${domain}`;
-}
-
-export function runtimeDomainEvent(domain: RuntimeEventDomain, description: string): GatewayEventDescriptor {
-  return eventDescriptor({
-    id: runtimeEventId(domain),
-    title: `${domain} Domain Events`,
-    description,
-    category: 'runtime-domain',
-    transport: ['sse', 'ws'],
-    scopes: ['read:events'],
-    domains: [domain],
-    wireEvents: [domain],
-    outputSchema: JSON_OBJECT_SCHEMA,
-  });
-}
+export * from '@pellux/goodvibes-sdk/platform/control-plane/method-catalog-shared';

package/src/control-plane/method-catalog.ts

@@ -1,242 +1 @@
-import {
-  builtinGatewayAdminMethodDescriptors,
-} from './method-catalog-admin.ts';
-import {
-  builtinGatewayChannelMethodDescriptors,
-} from './method-catalog-channels.ts';
-import {
-  builtinGatewayControlMethodDescriptors,
-} from './method-catalog-control.ts';
-import {
-  builtinGatewayEventDescriptors,
-} from './method-catalog-events.ts';
-import {
-  builtinGatewayKnowledgeMethodDescriptors,
-} from './method-catalog-knowledge.ts';
-import {
-  builtinGatewayMediaMethodDescriptors,
-} from './method-catalog-media.ts';
-import type {
-  GatewayEventDescriptor,
-  GatewayEventListOptions,
-  GatewayMethodDescriptor,
-  GatewayMethodHandler,
-  GatewayMethodInvocation,
-  GatewayMethodListOptions,
-} from './method-catalog-shared.ts';
-import {
-  builtinGatewayRuntimeMethodDescriptors,
-} from './method-catalog-runtime.ts';
-
-export type {
-  GatewayEventDescriptor,
-  GatewayEventListOptions,
-  GatewayEventTransport,
-  GatewayHttpBinding,
-  GatewayMethodAccess,
-  GatewayMethodDescriptor,
-  GatewayMethodHandler,
-  GatewayMethodInvocation,
-  GatewayMethodInvocationContext,
-  GatewayMethodListOptions,
-  GatewayMethodSource,
-  GatewayMethodTransport,
-} from './method-catalog-shared.ts';
-
-interface RegisteredGatewayMethod {
-  readonly descriptor: GatewayMethodDescriptor;
-  readonly handler?: GatewayMethodHandler;
-}
-
-interface RegisteredGatewayEvent {
-  readonly descriptor: GatewayEventDescriptor;
-}
-
-const BUILTIN_GATEWAY_EVENTS: readonly GatewayEventDescriptor[] = builtinGatewayEventDescriptors;
-
-const BUILTIN_GATEWAY_METHODS: readonly GatewayMethodDescriptor[] = [
-  ...builtinGatewayControlMethodDescriptors,
-  ...builtinGatewayChannelMethodDescriptors,
-  ...builtinGatewayRuntimeMethodDescriptors,
-  ...builtinGatewayKnowledgeMethodDescriptors,
-  ...builtinGatewayMediaMethodDescriptors,
-  ...builtinGatewayAdminMethodDescriptors,
-];
-
-function normalizeDescriptor(descriptor: GatewayMethodDescriptor): GatewayMethodDescriptor {
-  const id = descriptor.id.trim();
-  if (!id) throw new Error('Gateway method id is required');
-  return {
-    ...descriptor,
-    id,
-    transport: [...new Set(descriptor.transport)],
-    scopes: [...new Set(descriptor.scopes)],
-    events: descriptor.events ? [...new Set(descriptor.events)] : undefined,
-    invokable: descriptor.invokable ?? true,
-  };
-}
-
-function normalizeEventDescriptor(descriptor: GatewayEventDescriptor): GatewayEventDescriptor {
-  const id = descriptor.id.trim();
-  if (!id) throw new Error('Gateway event id is required');
-  return {
-    ...descriptor,
-    id,
-    transport: [...new Set(descriptor.transport)],
-    scopes: [...new Set(descriptor.scopes)],
-    domains: descriptor.domains ? [...new Set(descriptor.domains)] : undefined,
-    wireEvents: descriptor.wireEvents ? [...new Set(descriptor.wireEvents)] : undefined,
-  };
-}
-
-function pathMatchesTemplate(template: string, pathname: string): boolean {
-  const normalize = (value: string) => value.replace(/\/+$/, '') || '/';
-  const templateParts = normalize(template).split('/');
-  const pathParts = normalize(pathname).split('/');
-  if (templateParts.length !== pathParts.length) return false;
-  return templateParts.every((segment, index) => {
-    if (segment.startsWith('{') && segment.endsWith('}')) return pathParts[index]!.length > 0;
-    return segment === pathParts[index];
-  });
-}
-
-export class GatewayMethodCatalog {
-  private readonly methods = new Map<string, RegisteredGatewayMethod>();
-  private readonly events = new Map<string, RegisteredGatewayEvent>();
-
-  constructor(options: { readonly includeBuiltins?: boolean } = {}) {
-    if (options.includeBuiltins !== false) {
-      for (const descriptor of BUILTIN_GATEWAY_METHODS) {
-        this.register(descriptor, undefined, { replace: true });
-      }
-      for (const descriptor of BUILTIN_GATEWAY_EVENTS) {
-        this.registerEvent(descriptor, { replace: true });
-      }
-    }
-  }
-
-  register(
-    descriptor: GatewayMethodDescriptor,
-    handler?: GatewayMethodHandler,
-    options: { readonly replace?: boolean } = {},
-  ): () => void {
-    const normalized = normalizeDescriptor(descriptor);
-    if (this.methods.has(normalized.id) && !options.replace) {
-      throw new Error(`Gateway method already registered: ${normalized.id}`);
-    }
-    this.methods.set(normalized.id, { descriptor: normalized, handler });
-    return () => {
-      const current = this.methods.get(normalized.id);
-      if (current && current.descriptor.pluginId === normalized.pluginId && current.descriptor.source === normalized.source) {
-        this.unregister(normalized.id);
-      }
-    };
-  }
-
-  registerEvent(
-    descriptor: GatewayEventDescriptor,
-    options: { readonly replace?: boolean } = {},
-  ): () => void {
-    const normalized = normalizeEventDescriptor(descriptor);
-    if (this.events.has(normalized.id) && !options.replace) {
-      throw new Error(`Gateway event already registered: ${normalized.id}`);
-    }
-    this.events.set(normalized.id, { descriptor: normalized });
-    return () => {
-      const current = this.events.get(normalized.id);
-      if (current && current.descriptor.pluginId === normalized.pluginId && current.descriptor.source === normalized.source) {
-        this.unregisterEvent(normalized.id);
-      }
-    };
-  }
-
-  unregister(id: string): boolean {
-    return this.methods.delete(id);
-  }
-
-  unregisterEvent(id: string): boolean {
-    return this.events.delete(id);
-  }
-
-  clearPluginMethods(pluginId: string): void {
-    for (const [id, entry] of this.methods.entries()) {
-      if (entry.descriptor.pluginId === pluginId) {
-        this.methods.delete(id);
-      }
-    }
-    for (const [id, entry] of this.events.entries()) {
-      if (entry.descriptor.pluginId === pluginId) {
-        this.events.delete(id);
-      }
-    }
-  }
-
-  list(options: GatewayMethodListOptions = {}): GatewayMethodDescriptor[] {
-    return [...this.methods.values()]
-      .map((entry) => entry.descriptor)
-      .filter((descriptor) => !options.category || descriptor.category === options.category)
-      .filter((descriptor) => !options.source || descriptor.source === options.source)
-      .filter((descriptor) => !options.pluginId || descriptor.pluginId === options.pluginId)
-      .sort((a, b) => a.category.localeCompare(b.category) || a.id.localeCompare(b.id));
-  }
-
-  listEvents(options: GatewayEventListOptions = {}): GatewayEventDescriptor[] {
-    return [...this.events.values()]
-      .map((entry) => entry.descriptor)
-      .filter((descriptor) => !options.category || descriptor.category === options.category)
-      .filter((descriptor) => !options.source || descriptor.source === options.source)
-      .filter((descriptor) => !options.pluginId || descriptor.pluginId === options.pluginId)
-      .filter((descriptor) => !options.domain || descriptor.domains?.includes(options.domain))
-      .sort((a, b) => a.category.localeCompare(b.category) || a.id.localeCompare(b.id));
-  }
-
-  get(id: string): GatewayMethodDescriptor | null {
-    return this.methods.get(id)?.descriptor ?? null;
-  }
-
-  getEvent(id: string): GatewayEventDescriptor | null {
-    return this.events.get(id)?.descriptor ?? null;
-  }
-
-  hasHandler(id: string): boolean {
-    return typeof this.methods.get(id)?.handler === 'function';
-  }
-
-  findByHttpBinding(method: string, pathname: string): GatewayMethodDescriptor | null {
-    const normalizedMethod = method.toUpperCase();
-    for (const entry of this.methods.values()) {
-      const binding = entry.descriptor.http;
-      if (!binding || binding.method !== normalizedMethod) continue;
-      if (pathMatchesTemplate(binding.path, pathname)) return entry.descriptor;
-      const aliasPaths = Array.isArray(entry.descriptor.metadata?.aliasPaths)
-        ? entry.descriptor.metadata.aliasPaths.filter((value): value is string => typeof value === 'string')
-        : [];
-      if (aliasPaths.some((candidate) => pathMatchesTemplate(candidate, pathname))) return entry.descriptor;
-    }
-    return null;
-  }
-
-  getAllScopes(options: { readonly includeWrite?: boolean } = {}): string[] {
-    const scopes = new Set<string>();
-    for (const descriptor of this.methods.values()) {
-      for (const scope of descriptor.descriptor.scopes) {
-        if (!options.includeWrite && !scope.startsWith('read:')) continue;
-        scopes.add(scope);
-      }
-    }
-    for (const descriptor of this.events.values()) {
-      for (const scope of descriptor.descriptor.scopes) {
-        if (!options.includeWrite && !scope.startsWith('read:')) continue;
-        scopes.add(scope);
-      }
-    }
-    return [...scopes].sort();
-  }
-
-  async invoke(id: string, invocation: GatewayMethodInvocation): Promise<unknown> {
-    const entry = this.methods.get(id);
-    if (!entry) throw new Error(`Unknown gateway method: ${id}`);
-    if (!entry.handler) throw new Error(`Gateway method has no internal handler: ${id}`);
-    return entry.handler(invocation);
-  }
-}
+export * from '@pellux/goodvibes-sdk/platform/control-plane/method-catalog';