cordisx 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/extensions.mjs

@@ -0,0 +1,427 @@
+// src/service/extension-registry.ts
+import { createHash } from "node:crypto";
+var CLI_PROXY_GATEWAY_ADAPTER_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-adapter.v1.schema.json";
+var CLI_PROXY_GATEWAY_CONNECTION_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-connection.v1.schema.json";
+var CLI_PROXY_GATEWAY_ADAPTER_CONTRACT_V1 = "cordisx.cli-proxy-gateway-adapter/v1";
+var CLI_PROXY_GATEWAY_CONNECTION_CONTRACT_V1 = "cordisx.cli-proxy-gateway-connection/v1";
+var CLI_PROXY_GATEWAY_EXTENSION_PLAN_CONTRACT_V1 = "cordisx.cli-proxy-gateway-extension-plan/v1";
+var CLI_PROXY_GATEWAY_EXTENSION_REGISTRY_SERVICE_V1 = "cliProxyGatewayExtensions";
+var ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,95}$/;
+var HEADER_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,128}$/;
+var POINTER_PATTERN = /^(?:\/(?:[^~/]|~0|~1)*)+$/;
+var MAX_ADAPTERS = 64;
+var MAX_CONNECTIONS = 128;
+var MAX_MODELS = 256;
+function isText(value, maximum) {
+  return value.length > 0 && value.length <= maximum && value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(
+      ([key, item]) => [key, stableValue(item)]
+    )
+  );
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value));
+}
+function digest(value) {
+  return `sha256:${createHash("sha256").update(stableStringify(value)).digest("hex")}`;
+}
+function rejection(failure) {
+  return { status: "rejected", diagnostic: failure };
+}
+function validRevision(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+function validTemplate(value, depth = 0) {
+  if (depth > 12) return false;
+  if (value === null || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return value.length <= 8192 && !value.includes("\0");
+  if (Array.isArray(value)) return value.length <= 128 && value.every((item) => validTemplate(item, depth + 1));
+  const entries = Object.entries(value);
+  return entries.length <= 128 && entries.every(([key, item]) => isText(key, 256) && validTemplate(item, depth + 1));
+}
+function validateAdapter(adapter) {
+  if (adapter.$schema !== CLI_PROXY_GATEWAY_ADAPTER_SCHEMA_V1 || adapter.contract !== CLI_PROXY_GATEWAY_ADAPTER_CONTRACT_V1 || adapter.schemaVersion !== 1) return { code: "invalid-registration", field: "contract", message: "Unsupported gateway adapter contract" };
+  if (!ID_PATTERN.test(adapter.adapterId)) {
+    return { code: "invalid-registration", field: "adapterId", message: "Invalid adapter id" };
+  }
+  if (!validRevision(adapter.revision)) {
+    return { code: "invalid-registration", field: "revision", message: "Revision must be a positive safe integer" };
+  }
+  if (adapter.sessionSources.length > 16) {
+    return { code: "invalid-registration", field: "sessionSources", message: "Too many session sources" };
+  }
+  for (const source of adapter.sessionSources) {
+    if (source.kind === "header" ? !HEADER_PATTERN.test(source.name) : !POINTER_PATTERN.test(source.pointer) || source.pointer.length > 512) return { code: "invalid-registration", field: "sessionSources", message: "Invalid session source" };
+  }
+  for (const name of adapter.request.clearHeaders ?? []) {
+    if (!HEADER_PATTERN.test(name)) {
+      return { code: "invalid-registration", field: "request.clearHeaders", message: "Invalid header name" };
+    }
+  }
+  for (const [name, value] of Object.entries(adapter.request.setHeaders ?? {})) {
+    if (!HEADER_PATTERN.test(name) || !validTemplate(value)) {
+      return { code: "invalid-registration", field: "request.setHeaders", message: "Invalid header transform" };
+    }
+  }
+  for (const [pointer, value] of Object.entries(adapter.request.setBody ?? {})) {
+    if (!POINTER_PATTERN.test(pointer) || pointer.length > 512 || !validTemplate(value)) {
+      return { code: "invalid-registration", field: "request.setBody", message: "Invalid body transform" };
+    }
+  }
+  if (stableStringify(adapter).length > 64 * 1024) {
+    return { code: "invalid-registration", message: "Adapter exceeds the supported size" };
+  }
+  return void 0;
+}
+function validateConnection(connection) {
+  if (connection.$schema !== CLI_PROXY_GATEWAY_CONNECTION_SCHEMA_V1 || connection.contract !== CLI_PROXY_GATEWAY_CONNECTION_CONTRACT_V1 || connection.schemaVersion !== 1) return { code: "invalid-registration", field: "contract", message: "Unsupported gateway connection contract" };
+  if (!ID_PATTERN.test(connection.connectionId)) {
+    return { code: "invalid-registration", field: "connectionId", message: "Invalid connection id" };
+  }
+  if (!validRevision(connection.revision)) {
+    return { code: "invalid-registration", field: "revision", message: "Revision must be a positive safe integer" };
+  }
+  if (connection.wireApi !== "responses" && connection.wireApi !== "chat-completions") {
+    return { code: "invalid-registration", field: "wireApi", message: "Unsupported wire API" };
+  }
+  if (!connection.endpointPath.startsWith("/") || connection.endpointPath.startsWith("//") || connection.endpointPath.length > 512 || /[?#\u0000-\u001f\u007f]/.test(connection.endpointPath)) return { code: "invalid-registration", field: "endpointPath", message: "Invalid endpoint path" };
+  if (!ID_PATTERN.test(connection.adapter.adapterId) || !validRevision(connection.adapter.revision)) {
+    return { code: "invalid-registration", field: "adapter", message: "Invalid adapter reference" };
+  }
+  if (connection.models.length === 0 || connection.models.length > MAX_MODELS) {
+    return { code: "invalid-registration", field: "models", message: "Model routes are outside the supported range" };
+  }
+  const gatewayModels = /* @__PURE__ */ new Set();
+  const sourceModels = /* @__PURE__ */ new Set();
+  let defaults = 0;
+  for (const model of connection.models) {
+    if (!isText(model.sourceModelId, 256) || !isText(model.modelId, 256) || model.modelId.includes("/")) {
+      return { code: "invalid-registration", field: "models", message: "Invalid model identity" };
+    }
+    if (model.displayName !== void 0 && !isText(model.displayName, 200)) {
+      return { code: "invalid-registration", field: "models.displayName", message: "Invalid model display name" };
+    }
+    if (gatewayModels.has(model.modelId) || sourceModels.has(model.sourceModelId)) {
+      return { code: "conflicting-model", field: "models", message: "Duplicate connection model route" };
+    }
+    gatewayModels.add(model.modelId);
+    sourceModels.add(model.sourceModelId);
+    if (model.enabled && model.isDefault) defaults += 1;
+  }
+  if (!connection.models.some((model) => model.enabled)) {
+    return { code: "invalid-registration", field: "models", message: "At least one enabled model route is required" };
+  }
+  if (defaults > 1) {
+    return { code: "conflicting-model", field: "models.isDefault", message: "Only one default model is allowed" };
+  }
+  return void 0;
+}
+var CliProxyGatewayExtensionRegistryV1 = class {
+  constructor(pluginGeneration, sourceKey) {
+    this.pluginGeneration = pluginGeneration;
+    this.sourceKey = sourceKey;
+    if (!isText(pluginGeneration, 256)) throw new Error("Invalid plugin generation");
+  }
+  pluginGeneration;
+  sourceKey;
+  adapters = /* @__PURE__ */ new Map();
+  connections = /* @__PURE__ */ new Map();
+  producerGenerations = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  disposed = false;
+  activateProducer(producer, registryGeneration) {
+    if (this.disposed || registryGeneration !== this.pluginGeneration) {
+      throw new Error("Gateway extension registry generation is stale");
+    }
+    if (!ID_PATTERN.test(producer.pluginId) || !isText(producer.pluginGeneration, 256)) {
+      throw new Error("Invalid gateway extension producer authority");
+    }
+    if (this.producerGenerations.get(producer.pluginId) === producer.pluginGeneration) return;
+    this.producerGenerations.set(producer.pluginId, producer.pluginGeneration);
+    if (this.removeProducerEntries(producer.pluginId)) this.changed();
+  }
+  registerAdapter(adapter, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const validation = validateAdapter(adapter);
+    if (validation !== void 0) return rejection(validation);
+    const current = this.adapters.get(adapter.adapterId);
+    const ownership = this.ownershipFailure(current?.producer, producer);
+    if (ownership !== void 0) return ownership;
+    if (current !== void 0) {
+      const revision = this.revisionResult(current.adapter.revision, adapter.revision, current.adapter, adapter);
+      if (revision !== void 0) return revision;
+    } else if (this.adapters.size >= MAX_ADAPTERS) {
+      return rejection({ code: "capacity-exceeded", message: "Gateway adapter capacity was reached" });
+    }
+    this.adapters.set(adapter.adapterId, { producer, adapter: structuredClone(adapter) });
+    this.changed();
+    return { status: current === void 0 ? "registered" : "updated", registryRevision: this.revision };
+  }
+  registerConnection(connection, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const validation = validateConnection(connection);
+    if (validation !== void 0) return rejection(validation);
+    const current = this.connections.get(connection.connectionId);
+    const ownership = this.ownershipFailure(current?.producer, producer);
+    if (ownership !== void 0) return ownership;
+    const sourceKey = this.sourceKey(connection.source);
+    if (!isText(sourceKey, 512)) {
+      return rejection({
+        code: "invalid-registration",
+        field: "source",
+        message: "Invalid connection source reference"
+      });
+    }
+    if (current !== void 0) {
+      const revision = this.revisionResult(
+        current.connection.revision,
+        connection.revision,
+        { ...current.connection, source: current.sourceKey },
+        { ...connection, source: sourceKey }
+      );
+      if (revision !== void 0) return revision;
+    } else if (this.connections.size >= MAX_CONNECTIONS) {
+      return rejection({ code: "capacity-exceeded", message: "Gateway connection capacity was reached" });
+    }
+    for (const [connectionId, entry] of this.connections) {
+      if (connectionId === connection.connectionId) continue;
+      if (entry.sourceKey === sourceKey) {
+        return rejection({
+          code: "conflicting-source",
+          field: "source",
+          message: "Connection source is already registered"
+        });
+      }
+      const existingModels = new Set(
+        entry.connection.models.filter((model) => entry.connection.enabled && model.enabled).map(
+          (model) => `${entry.connection.connectionId}/${model.modelId}`
+        )
+      );
+      if (connection.models.some(
+        (model) => connection.enabled && model.enabled && existingModels.has(
+          `${connection.connectionId}/${model.modelId}`
+        )
+      )) return rejection({ code: "conflicting-model", field: "models", message: "Gateway model is already registered" });
+    }
+    this.connections.set(connection.connectionId, {
+      producer,
+      sourceKey,
+      connection: structuredClone(connection)
+    });
+    this.changed();
+    return { status: current === void 0 ? "registered" : "updated", registryRevision: this.revision };
+  }
+  revokeAdapter(input, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const current = this.adapters.get(input.adapterId);
+    if (current === void 0) {
+      return rejection({ code: "not-found", field: "adapterId", message: "Adapter is not registered" });
+    }
+    const ownership = this.ownershipFailure(current.producer, producer);
+    if (ownership !== void 0) return ownership;
+    if (current.adapter.revision !== input.expectedRevision) {
+      return rejection({ code: "stale-revision", field: "expectedRevision", message: "Adapter revision is stale" });
+    }
+    this.adapters.delete(input.adapterId);
+    this.changed();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  revokeConnection(input, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const current = this.connections.get(input.connectionId);
+    if (current === void 0) {
+      return rejection({ code: "not-found", field: "connectionId", message: "Connection is not registered" });
+    }
+    const ownership = this.ownershipFailure(current.producer, producer);
+    if (ownership !== void 0) return ownership;
+    if (current.connection.revision !== input.expectedRevision) {
+      return rejection({ code: "stale-revision", field: "expectedRevision", message: "Connection revision is stale" });
+    }
+    this.connections.delete(input.connectionId);
+    this.changed();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  disposeProducer(producer, registryGeneration) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    this.producerGenerations.delete(producer.pluginId);
+    if (!this.removeProducerEntries(producer.pluginId, producer.pluginGeneration)) {
+      return { status: "unchanged", registryRevision: this.revision };
+    }
+    this.changed();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  subscribe(listener) {
+    if (this.disposed) throw new Error("Gateway extension registry generation is stale");
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  plan(pluginGeneration) {
+    if (this.disposed || pluginGeneration !== this.pluginGeneration) {
+      return { code: "stale-generation", message: "Gateway extension plan generation is stale" };
+    }
+    const adapters = [...this.adapters.values()].map((entry) => structuredClone(entry.adapter)).sort(
+      (left, right) => left.adapterId.localeCompare(right.adapterId)
+    );
+    const connections = [];
+    const composition = [];
+    for (const entry of [...this.connections.values()].sort(
+      (left, right) => left.connection.connectionId.localeCompare(right.connection.connectionId)
+    )) {
+      const connection = entry.connection;
+      const adapter = this.adapters.get(connection.adapter.adapterId)?.adapter;
+      const adapterAvailable = adapter?.enabled === true && adapter.revision === connection.adapter.revision;
+      const enabled = connection.enabled && (!connection.adapter.required || adapterAvailable);
+      const index = connections.length;
+      connections.push({
+        connectionId: connection.connectionId,
+        revision: connection.revision,
+        enabled,
+        adapterId: connection.adapter.adapterId,
+        adapterRevision: connection.adapter.revision,
+        adapterRequired: connection.adapter.required,
+        adapterAvailable,
+        wireApi: connection.wireApi,
+        endpointPath: connection.endpointPath,
+        endpoint: null,
+        authorization: connection.authorization,
+        credential: null,
+        models: connection.models.filter((model) => model.enabled).sort(
+          (left, right) => left.modelId.localeCompare(right.modelId)
+        ).map((model) => ({
+          sourceModelId: model.sourceModelId,
+          gatewayModelId: `${connection.connectionId}/${model.modelId}`,
+          displayName: model.displayName ?? model.modelId,
+          isDefault: model.isDefault
+        }))
+      });
+      if (!enabled) continue;
+      const sourceAlias = `extension-${index}`;
+      composition.push({
+        connectionId: connection.connectionId,
+        sourceAlias,
+        source: connection.source,
+        originPointer: `/connections/${index}/endpoint`,
+        ...connection.authorization === "bearer" ? { authorizationPointer: `/connections/${index}/credential` } : {}
+      });
+    }
+    const base = {
+      contract: CLI_PROXY_GATEWAY_EXTENSION_PLAN_CONTRACT_V1,
+      schemaVersion: 1,
+      pluginGeneration: this.pluginGeneration,
+      registryRevision: this.revision,
+      configuration: { adapters, connections },
+      composition
+    };
+    return { ...base, planDigest: digest({ ...base, composition: composition.map(({ source: _, ...item }) => item) }) };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.adapters.clear();
+    this.connections.clear();
+    this.producerGenerations.clear();
+    this.listeners.clear();
+    this.revision += 1;
+  }
+  revisionResult(currentRevision, nextRevision, current, next) {
+    if (nextRevision < currentRevision) {
+      return rejection({ code: "stale-revision", field: "revision", message: "Extension revision is stale" });
+    }
+    if (nextRevision !== currentRevision) return void 0;
+    return stableStringify(current) === stableStringify(next) ? { status: "unchanged", registryRevision: this.revision } : rejection({ code: "stale-revision", field: "revision", message: "Revision was reused with different content" });
+  }
+  ownershipFailure(current, producer) {
+    if (current === void 0) return void 0;
+    if (current.pluginId !== producer.pluginId) {
+      return rejection({ code: "conflicting-producer", message: "Extension is owned by another producer" });
+    }
+    if (current.pluginGeneration !== producer.pluginGeneration) {
+      return {
+        status: "stale-generation",
+        diagnostic: { code: "stale-generation", message: "Extension producer generation is stale" }
+      };
+    }
+    return void 0;
+  }
+  generationFailure(registryGeneration, producer) {
+    if (this.disposed || registryGeneration !== this.pluginGeneration || this.producerGenerations.get(producer.pluginId) !== producer.pluginGeneration) {
+      return {
+        status: "stale-generation",
+        diagnostic: { code: "stale-generation", message: "Gateway extension registry generation is stale" }
+      };
+    }
+    return void 0;
+  }
+  removeProducerEntries(pluginId, pluginGeneration) {
+    let removed = false;
+    for (const [adapterId, entry] of this.adapters) {
+      if (entry.producer.pluginId !== pluginId || pluginGeneration !== void 0 && entry.producer.pluginGeneration !== pluginGeneration) continue;
+      this.adapters.delete(adapterId);
+      removed = true;
+    }
+    for (const [connectionId, entry] of this.connections) {
+      if (entry.producer.pluginId !== pluginId || pluginGeneration !== void 0 && entry.producer.pluginGeneration !== pluginGeneration) continue;
+      this.connections.delete(connectionId);
+      removed = true;
+    }
+    return removed;
+  }
+  changed() {
+    this.revision += 1;
+    for (const listener of this.listeners) listener(this.revision);
+  }
+};
+function createCliProxyGatewayExtensionRegistrarV1(registry, producer) {
+  registry.activateProducer(producer, registry.pluginGeneration);
+  let disposed = false;
+  const currentRevision = () => {
+    const plan = registry.plan(registry.pluginGeneration);
+    return "code" in plan ? 0 : plan.registryRevision;
+  };
+  return Object.freeze({
+    producer,
+    registerAdapter: (adapter) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.registerAdapter(adapter, registry.pluginGeneration, producer),
+    revokeAdapter: (input) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.revokeAdapter(input, registry.pluginGeneration, producer),
+    registerConnection: (connection) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.registerConnection(connection, registry.pluginGeneration, producer),
+    revokeConnection: (input) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.revokeConnection(input, registry.pluginGeneration, producer),
+    dispose: () => {
+      if (disposed) return { status: "unchanged", registryRevision: currentRevision() };
+      disposed = true;
+      return registry.disposeProducer(producer, registry.pluginGeneration);
+    }
+  });
+}
+export {
+  CLI_PROXY_GATEWAY_ADAPTER_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_ADAPTER_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_CONNECTION_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_CONNECTION_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_EXTENSION_PLAN_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_EXTENSION_REGISTRY_SERVICE_V1,
+  CliProxyGatewayExtensionRegistryV1,
+  createCliProxyGatewayExtensionRegistrarV1
+};