@knitli/openapi-mcp 0.0.0

package/dist/stdio/config.js

@@ -0,0 +1,144 @@
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import { parseJsonStrict } from "../runtime/strict-json.js";
+import { DEFAULT_RUNTIME_LIMITS, resolveRuntimeLimits, } from "../runtime/versions.js";
+import { validateLocalAuthProfile } from "../sqlite/auth.js";
+import { isOAuthResource } from "../sqlite/oauth-resource.js";
+const id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/);
+const path = z.string().min(1).refine(isAbsolute);
+const https = z.string().refine((value) => {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "https:" && !url.username && !url.password && !url.hash);
+    }
+    catch {
+        return false;
+    }
+});
+const origin = https.refine((value) => new URL(value).origin === value);
+const scopes = z.array(z.string().min(1).max(256)).max(256);
+const auth = z.discriminatedUnion("type", [
+    z.strictObject({
+        type: z.literal("bearer-env"),
+        env: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
+    }),
+    z.strictObject({
+        type: z.literal("api-key-env"),
+        env: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
+        placement: z.enum(["header", "query"]),
+        name: z.string().min(1).max(256),
+    }),
+    z.strictObject({
+        type: z.literal("oauth2-pkce"),
+        authorizationEndpoint: https,
+        tokenEndpoint: https,
+        clientId: z.string().min(1).max(1024),
+        scopes,
+        resource: z.string().refine(isOAuthResource).optional(),
+    }),
+]);
+const profile = z.strictObject({
+    profileId: id,
+    revision: z.number().int().positive(),
+    allowedOrigins: z.array(origin).min(1).max(256),
+    auth,
+    audience: z.string().min(1).max(2048).optional(),
+    scopes: scopes.optional(),
+});
+const key = z.strictObject({
+    issuer: z
+        .string()
+        .min(1)
+        .max(256)
+        .regex(/^[\x21-\x7e]+$/),
+    keyId: id,
+    publicKey: z
+        .string()
+        .regex(/^[A-Za-z0-9_-]+$/)
+        .max(4096),
+});
+const digest = z.string().regex(/^[0-9a-f]{64}$/);
+const constraint = z.lazy(() => z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("exact"), value: z.json() }),
+    z.strictObject({
+        kind: z.literal("string-set"),
+        values: z.array(z.string()).min(1).max(256),
+    }),
+    z.strictObject({
+        kind: z.literal("number"),
+        min: z.number(),
+        max: z.number(),
+    }),
+    z.strictObject({
+        kind: z.literal("object"),
+        properties: z.record(z.string(), constraint),
+    }),
+    z.strictObject({
+        kind: z.literal("array"),
+        maxItems: z.number().int().nonnegative(),
+        items: constraint,
+    }),
+]));
+const exactPolicy = z.strictObject({
+    version: z.literal(1),
+    catalogId: id,
+    releaseId: id,
+    manifestDigest: digest,
+    operationId: z.string().startsWith("operation:"),
+    operationDigest: digest,
+    credentialProfileDigest: digest,
+    actionKind: z.enum(["create", "update"]),
+    cardinality: z.enum(["single", "bounded"]),
+    maxAffected: z.number().int().positive(),
+    expiresAt: z.number().int().positive(),
+    arguments: constraint,
+});
+const limits = z.strictObject(Object.fromEntries(Object.entries(DEFAULT_RUNTIME_LIMITS).map(([name, maximum]) => [
+    name,
+    z.number().int().min(1).max(maximum).optional(),
+])));
+const schema = z.strictObject({
+    version: z.literal(1),
+    generationStatePath: path,
+    catalogs: z
+        .array(z.strictObject({ catalogId: id, releaseId: id, path, profileId: id }))
+        .min(1)
+        .max(256),
+    trust: z.strictObject({
+        releaseKeys: z.array(key).min(1).max(256),
+        rollbackKeys: z.array(key).max(256),
+    }),
+    allowedOrigins: z.array(origin).min(1).max(256),
+    profiles: z.array(profile).min(1).max(256),
+    limits: limits.optional(),
+    exactPolicies: z.array(exactPolicy).max(256).optional(),
+});
+/** Operator-only input. Error text never contains submitted values or keys. */
+export function parseOpenApiStdioConfig(input) {
+    try {
+        const value = typeof input === "string"
+            ? parseJsonStrict(input, {
+                maxBytes: 1024 * 1024,
+                maxDepth: 40,
+                maxKeys: 30_000,
+            })
+            : input;
+        const config = schema.parse(value);
+        for (const entry of config.profiles)
+            validateLocalAuthProfile(entry);
+        const profileIds = new Set(config.profiles.map((entry) => entry.profileId));
+        if (profileIds.size !== config.profiles.length ||
+            new Set(config.catalogs.map((entry) => entry.catalogId)).size !==
+                config.catalogs.length)
+            throw new Error();
+        if (config.catalogs.some((entry) => !profileIds.has(entry.profileId)))
+            throw new Error();
+        if (config.profiles.some((entry) => entry.allowedOrigins.some((allowed) => !config.allowedOrigins.includes(allowed))))
+            throw new Error();
+        resolveRuntimeLimits(config.limits);
+        return config;
+    }
+    catch {
+        throw new Error("Invalid OpenAPI stdio configuration");
+    }
+}

package/dist/stdio/exact-policy.d.ts

@@ -0,0 +1,41 @@
+import type { CatalogId, JsonValue, PreparedCall, ReleaseId, Sha256, TypedOperationId } from "../runtime/types.ts";
+export type ArgumentConstraint = {
+    readonly kind: "exact";
+    readonly value: JsonValue;
+} | {
+    readonly kind: "string-set";
+    readonly values: readonly string[];
+} | {
+    readonly kind: "number";
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly kind: "object";
+    readonly properties: Readonly<Record<string, ArgumentConstraint>>;
+} | {
+    readonly kind: "array";
+    readonly maxItems: number;
+    readonly items: ArgumentConstraint;
+};
+export interface ExactPolicyTemplate {
+    readonly version: 1;
+    readonly catalogId: CatalogId;
+    readonly releaseId: ReleaseId;
+    readonly manifestDigest: Sha256;
+    readonly operationId: TypedOperationId;
+    readonly operationDigest: Sha256;
+    readonly credentialProfileDigest: Sha256;
+    readonly actionKind: "create" | "update";
+    readonly cardinality: "single" | "bounded";
+    readonly maxAffected: number;
+    readonly expiresAt: number;
+    readonly arguments: ArgumentConstraint;
+}
+export interface CompiledExactPolicy {
+    readonly template: Readonly<ExactPolicyTemplate>;
+    readonly policyDigest: Sha256;
+}
+/** Validate and normalize an untrusted startup template before hashing it. */
+export declare function compileExactPolicy(input: unknown): Promise<CompiledExactPolicy>;
+/** Return true only when every policy identity and closed constraint matches. */
+export declare function matchesExactPolicy(policy: CompiledExactPolicy, call: PreparedCall, nowMs: number): boolean;

package/dist/stdio/exact-policy.js

@@ -0,0 +1,361 @@
+import { sha256 } from "../runtime/digest.js";
+import { OpenApiMcpError } from "../runtime/errors.js";
+import { parseTypedRecordId } from "../runtime/references.js";
+import { canonicalJsonBounded, parseJsonStrict, } from "../runtime/strict-json.js";
+const POLICY_DOMAIN = "knitli.openapi-mcp.exact-policy.v1";
+const MAX_POLICY_BYTES = 64 * 1024;
+const MAX_POLICY_DEPTH = 32;
+const MAX_POLICY_NODES = 4_096;
+const MAX_STRING_SET_VALUES = 256;
+const MAX_AFFECTED = 10_000;
+const digestPattern = /^[0-9a-f]{64}$/;
+const shortIdPattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const templateKeys = [
+    "actionKind",
+    "arguments",
+    "cardinality",
+    "catalogId",
+    "credentialProfileDigest",
+    "expiresAt",
+    "manifestDigest",
+    "maxAffected",
+    "operationDigest",
+    "operationId",
+    "releaseId",
+    "version",
+];
+function invalid() {
+    return new OpenApiMcpError("INPUT_INVALID", "Exact policy template is invalid");
+}
+function objectWithExactKeys(value, keys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw invalid();
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        throw invalid();
+    const ownKeys = Reflect.ownKeys(value);
+    if (ownKeys.some((key) => typeof key !== "string"))
+        throw invalid();
+    const stringKeys = ownKeys;
+    if (keys !== null &&
+        (stringKeys.length !== keys.length ||
+            stringKeys.some((key) => !keys.includes(key)))) {
+        throw invalid();
+    }
+    for (const key of stringKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined ||
+            !("value" in descriptor) ||
+            !descriptor.enumerable) {
+            throw invalid();
+        }
+    }
+    return value;
+}
+function ownValue(object, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (descriptor === undefined || !("value" in descriptor))
+        throw invalid();
+    return descriptor.value;
+}
+function shortId(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > 128 ||
+        value === "." ||
+        value === ".." ||
+        !shortIdPattern.test(value)) {
+        throw invalid();
+    }
+    return value;
+}
+function digest(value) {
+    if (typeof value !== "string" || !digestPattern.test(value))
+        throw invalid();
+    return value;
+}
+function operationId(value) {
+    if (typeof value !== "string")
+        throw invalid();
+    try {
+        const parsed = parseTypedRecordId(value);
+        if (!parsed.startsWith("operation:"))
+            throw invalid();
+        return parsed;
+    }
+    catch {
+        throw invalid();
+    }
+}
+function boundedInteger(value, minimum, maximum) {
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < minimum ||
+        value > maximum) {
+        throw invalid();
+    }
+    return value;
+}
+function freezeJson(value) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            freezeJson(item);
+        return Object.freeze(value);
+    }
+    if (typeof value === "object" && value !== null) {
+        for (const child of Object.values(value))
+            freezeJson(child);
+        return Object.freeze(value);
+    }
+    return value;
+}
+function parseConstraint(value) {
+    const source = objectWithExactKeys(value, null);
+    const kind = ownValue(source, "kind");
+    if (kind === "exact") {
+        objectWithExactKeys(source, ["kind", "value"]);
+        return Object.freeze({
+            kind,
+            value: freezeJson(ownValue(source, "value")),
+        });
+    }
+    if (kind === "string-set") {
+        objectWithExactKeys(source, ["kind", "values"]);
+        const rawValues = ownValue(source, "values");
+        if (!Array.isArray(rawValues) ||
+            rawValues.length > MAX_STRING_SET_VALUES ||
+            rawValues.some((item) => typeof item !== "string")) {
+            throw invalid();
+        }
+        const values = [...rawValues];
+        if (new Set(values).size !== values.length)
+            throw invalid();
+        values.sort();
+        return Object.freeze({ kind, values: Object.freeze(values) });
+    }
+    if (kind === "number") {
+        objectWithExactKeys(source, ["kind", "max", "min"]);
+        const min = ownValue(source, "min");
+        const max = ownValue(source, "max");
+        if (typeof min !== "number" ||
+            typeof max !== "number" ||
+            !Number.isFinite(min) ||
+            !Number.isFinite(max) ||
+            min > max) {
+            throw invalid();
+        }
+        return Object.freeze({ kind, min, max });
+    }
+    if (kind === "object") {
+        objectWithExactKeys(source, ["kind", "properties"]);
+        const rawProperties = objectWithExactKeys(ownValue(source, "properties"), null);
+        const properties = Object.create(null);
+        for (const key of Object.keys(rawProperties).sort()) {
+            properties[key] = parseConstraint(ownValue(rawProperties, key));
+        }
+        return Object.freeze({ kind, properties: Object.freeze(properties) });
+    }
+    if (kind === "array") {
+        objectWithExactKeys(source, ["items", "kind", "maxItems"]);
+        return Object.freeze({
+            kind,
+            maxItems: boundedInteger(ownValue(source, "maxItems"), 0, MAX_AFFECTED),
+            items: parseConstraint(ownValue(source, "items")),
+        });
+    }
+    throw invalid();
+}
+function parseTemplate(value) {
+    const source = objectWithExactKeys(value, templateKeys);
+    const version = ownValue(source, "version");
+    const actionKind = ownValue(source, "actionKind");
+    const cardinality = ownValue(source, "cardinality");
+    const maxAffected = boundedInteger(ownValue(source, "maxAffected"), 1, MAX_AFFECTED);
+    const expiresAt = ownValue(source, "expiresAt");
+    if (version !== 1 ||
+        (actionKind !== "create" && actionKind !== "update") ||
+        (cardinality !== "single" && cardinality !== "bounded") ||
+        (cardinality === "single" && maxAffected !== 1) ||
+        typeof expiresAt !== "number" ||
+        !Number.isSafeInteger(expiresAt)) {
+        throw invalid();
+    }
+    return Object.freeze({
+        version,
+        catalogId: shortId(ownValue(source, "catalogId")),
+        releaseId: shortId(ownValue(source, "releaseId")),
+        manifestDigest: digest(ownValue(source, "manifestDigest")),
+        operationId: operationId(ownValue(source, "operationId")),
+        operationDigest: digest(ownValue(source, "operationDigest")),
+        credentialProfileDigest: digest(ownValue(source, "credentialProfileDigest")),
+        actionKind,
+        cardinality,
+        maxAffected,
+        expiresAt,
+        arguments: parseConstraint(ownValue(source, "arguments")),
+    });
+}
+/** Validate and normalize an untrusted startup template before hashing it. */
+export async function compileExactPolicy(input) {
+    try {
+        // Both operations are synchronous: no caller-owned data survives to the
+        // first await, including through proxies, accessors, or later mutation.
+        const snapshotJson = canonicalJsonBounded(input, {
+            maxBytes: MAX_POLICY_BYTES,
+            maxDepth: MAX_POLICY_DEPTH,
+            maxNodes: MAX_POLICY_NODES,
+        });
+        const snapshot = parseJsonStrict(snapshotJson, {
+            maxBytes: MAX_POLICY_BYTES,
+            maxDepth: MAX_POLICY_DEPTH,
+            maxKeys: MAX_POLICY_NODES,
+        });
+        const template = parseTemplate(snapshot);
+        const policyDigest = await sha256(POLICY_DOMAIN, template);
+        return Object.freeze({ template, policyDigest });
+    }
+    catch {
+        throw invalid();
+    }
+}
+function ownJsonObject(value) {
+    try {
+        return objectWithExactKeys(value, null);
+    }
+    catch {
+        return null;
+    }
+}
+function isCanonicalArray(value) {
+    if (Object.getPrototypeOf(value) !== Array.prototype)
+        return false;
+    const keys = Reflect.ownKeys(value);
+    if (keys.length !== value.length + 1)
+        return false;
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    if (lengthDescriptor === undefined ||
+        !("value" in lengthDescriptor) ||
+        lengthDescriptor.enumerable ||
+        lengthDescriptor.value !== value.length) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor === undefined ||
+            !("value" in descriptor) ||
+            !descriptor.enumerable) {
+            return false;
+        }
+    }
+    return true;
+}
+function exactJson(left, right) {
+    if (left === null ||
+        typeof left === "boolean" ||
+        typeof left === "number" ||
+        typeof left === "string") {
+        return Object.is(left, right) || (left === 0 && right === 0);
+    }
+    if (Array.isArray(left)) {
+        if (!Array.isArray(right) ||
+            right.length !== left.length ||
+            !isCanonicalArray(right)) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(right, String(index));
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !exactJson(left[index], descriptor.value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const rightObject = ownJsonObject(right);
+    if (rightObject === null)
+        return false;
+    const keys = Object.keys(left).sort();
+    const rightKeys = Object.keys(rightObject).sort();
+    if (keys.length !== rightKeys.length ||
+        keys.some((key, index) => key !== rightKeys[index])) {
+        return false;
+    }
+    return keys.every((key) => exactJson(left[key], ownValue(rightObject, key)));
+}
+function matchesConstraint(constraint, value) {
+    if (constraint.kind === "exact") {
+        return exactJson(constraint.value, value);
+    }
+    if (constraint.kind === "string-set") {
+        return typeof value === "string" && constraint.values.includes(value);
+    }
+    if (constraint.kind === "number") {
+        return (typeof value === "number" &&
+            Number.isFinite(value) &&
+            value >= constraint.min &&
+            value <= constraint.max);
+    }
+    if (constraint.kind === "array") {
+        if (!Array.isArray(value) ||
+            value.length > constraint.maxItems ||
+            !isCanonicalArray(value)) {
+            return false;
+        }
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !matchesConstraint(constraint.items, descriptor.value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const object = ownJsonObject(value);
+    if (object === null)
+        return false;
+    const expectedKeys = Object.keys(constraint.properties).sort();
+    const actualKeys = Object.keys(object).sort();
+    if (expectedKeys.length !== actualKeys.length ||
+        expectedKeys.some((key, index) => key !== actualKeys[index])) {
+        return false;
+    }
+    return expectedKeys.every((key) => matchesConstraint(constraint.properties[key], ownValue(object, key)));
+}
+/** Return true only when every policy identity and closed constraint matches. */
+export function matchesExactPolicy(policy, call, nowMs) {
+    try {
+        const template = policy.template;
+        if (!Number.isSafeInteger(nowMs) ||
+            nowMs >= template.expiresAt ||
+            call.safety !== "action" ||
+            (call.actionKind !== "create" && call.actionKind !== "update") ||
+            call.actionKind !== template.actionKind ||
+            call.catalogId !== template.catalogId ||
+            call.releaseId !== template.releaseId ||
+            call.manifestDigest !== template.manifestDigest ||
+            call.operationId !== template.operationId ||
+            call.operationDigest !== template.operationDigest ||
+            call.credentialProfileDigest !== template.credentialProfileDigest) {
+            return false;
+        }
+        if (template.cardinality === "single") {
+            if (call.cardinality?.kind !== "single" || template.maxAffected !== 1) {
+                return false;
+            }
+        }
+        else if (call.cardinality?.kind !== "bounded" ||
+            !Number.isSafeInteger(call.cardinality.maxAffected) ||
+            call.cardinality.maxAffected > MAX_AFFECTED ||
+            call.cardinality.maxAffected > template.maxAffected ||
+            call.cardinality.maxAffected < 1) {
+            return false;
+        }
+        return matchesConstraint(template.arguments, call.normalizedArguments);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/stdio/index.d.ts

@@ -0,0 +1,6 @@
+import { type StdioServerHandle } from "@modelcontextprotocol/server/stdio";
+import { type OpenApiStdioConfig } from "./config.ts";
+export { type OpenApiStdioConfig, parseOpenApiStdioConfig } from "./config.ts";
+export { createOpenApiMcpServer, type OpenApiMcpServerOptions, } from "./server.ts";
+/** Owns process-local credentials/catalogs independently of disposable SDK probes. */
+export declare function serveOpenApiStdio(input: OpenApiStdioConfig): Promise<StdioServerHandle>;