@mcpspec/shared 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MCPSpec Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,1062 @@
+import { Writable, Readable } from 'node:stream';
+import { z } from 'zod';
+
+declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly TEST_FAILURE: 1;
+    readonly ERROR: 2;
+    readonly CONFIG_ERROR: 3;
+    readonly CONNECTION_ERROR: 4;
+    readonly TIMEOUT: 5;
+    readonly SECURITY_FINDINGS: 6;
+    readonly VALIDATION_ERROR: 7;
+    readonly INTERRUPTED: 130;
+};
+type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
+
+type MessageDirection = 'outgoing' | 'incoming';
+interface ProtocolLogEntry {
+    id: string;
+    timestamp: number;
+    direction: MessageDirection;
+    message: Record<string, unknown>;
+    jsonrpcId?: string | number | null;
+    method?: string;
+    isError?: boolean;
+    roundTripMs?: number;
+}
+
+interface SavedServerConnection {
+    id: string;
+    name: string;
+    transport: TransportType;
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SavedCollection {
+    id: string;
+    name: string;
+    description?: string;
+    yaml: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TestRunRecord {
+    id: string;
+    collectionId?: string;
+    collectionName: string;
+    serverId?: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    summary?: TestSummary;
+    results?: TestResult[];
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+}
+interface ApiResponse<T> {
+    data: T;
+}
+interface ApiListResponse<T> {
+    data: T[];
+    total: number;
+}
+interface ApiError {
+    error: string;
+    message: string;
+    details?: unknown;
+}
+
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'disconnecting' | 'error';
+interface ConnectionConfig {
+    maxReconnectAttempts: number;
+    reconnectBackoff: 'exponential';
+    initialReconnectDelay: number;
+    maxReconnectDelay: number;
+}
+interface ProcessConfig {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+}
+interface ManagedProcess {
+    id: string;
+    pid: number;
+    command: string;
+    args: string[];
+    startedAt: Date;
+    stdin: Writable;
+    stdout: Readable;
+    stderr: Readable;
+}
+interface TimeoutConfig {
+    test: number;
+    mcpCall: number;
+    transport: number;
+    assertion: number;
+    cleanup: number;
+}
+declare const DEFAULT_TIMEOUTS: TimeoutConfig;
+interface RateLimitConfig {
+    maxCallsPerSecond: number;
+    maxConcurrent: number;
+    backoff: {
+        initial: number;
+        multiplier: number;
+        max: number;
+    };
+}
+declare const DEFAULT_RATE_LIMIT: RateLimitConfig;
+type TransportType = 'stdio' | 'sse' | 'streamable-http';
+interface ServerConfig {
+    name?: string;
+    transport: TransportType;
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    timeouts?: Partial<TimeoutConfig>;
+}
+interface CollectionDefinition {
+    schemaVersion?: string;
+    name: string;
+    description?: string;
+    server: string | ServerConfig;
+    environments?: Record<string, EnvironmentDefinition>;
+    defaultEnvironment?: string;
+    tests: TestDefinition[];
+}
+interface EnvironmentDefinition {
+    variables: Record<string, string>;
+}
+interface TestDefinition {
+    id?: string;
+    name: string;
+    tags?: string[];
+    timeout?: number;
+    retries?: number;
+    type?: 'tool' | 'resource';
+    tool?: string;
+    call?: string;
+    input?: Record<string, unknown>;
+    with?: Record<string, unknown>;
+    assertions?: AssertionDefinition[];
+    expect?: SimpleExpectation[];
+    expectError?: boolean;
+    extract?: ExtractionDefinition[];
+}
+type SimpleExpectation = {
+    exists: string;
+} | {
+    equals: [string, unknown];
+} | {
+    contains: [string, unknown];
+} | {
+    matches: [string, string];
+};
+interface AssertionDefinition {
+    type: AssertionType;
+    path?: string;
+    value?: unknown;
+    expected?: unknown;
+    pattern?: string;
+    maxMs?: number;
+    operator?: string;
+    expr?: string;
+}
+type AssertionType = 'schema' | 'equals' | 'contains' | 'exists' | 'matches' | 'type' | 'length' | 'latency' | 'mimeType' | 'expression';
+interface ExtractionDefinition {
+    name: string;
+    path: string;
+}
+interface TestRunResult {
+    id: string;
+    collectionName: string;
+    startedAt: Date;
+    completedAt: Date;
+    duration: number;
+    results: TestResult[];
+    summary: TestSummary;
+}
+interface TestResult {
+    testId: string;
+    testName: string;
+    status: 'passed' | 'failed' | 'skipped' | 'error';
+    duration: number;
+    assertions: AssertionResult[];
+    error?: string;
+    extractedVariables?: Record<string, unknown>;
+}
+interface AssertionResult {
+    type: AssertionType;
+    passed: boolean;
+    message: string;
+    expected?: unknown;
+    actual?: unknown;
+}
+interface TestSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    errors: number;
+    duration: number;
+}
+type ReporterType = 'console' | 'json' | 'junit' | 'html' | 'tap';
+type SecurityScanMode = 'passive' | 'active' | 'aggressive';
+type SeverityLevel = 'info' | 'low' | 'medium' | 'high' | 'critical';
+interface SecurityFinding {
+    id: string;
+    rule: string;
+    severity: SeverityLevel;
+    title: string;
+    description: string;
+    evidence?: string;
+    remediation?: string;
+}
+interface SecurityScanConfig {
+    mode: SecurityScanMode;
+    rules?: string[];
+    severityThreshold?: SeverityLevel;
+    acknowledgeRisk?: boolean;
+    timeout?: number;
+    maxProbesPerTool?: number;
+}
+interface SecurityScanResult {
+    id: string;
+    serverName: string;
+    mode: SecurityScanMode;
+    startedAt: Date;
+    completedAt: Date;
+    findings: SecurityFinding[];
+    summary: SecurityScanSummary;
+}
+interface SecurityScanSummary {
+    totalFindings: number;
+    bySeverity: Record<SeverityLevel, number>;
+    byRule: Record<string, number>;
+}
+interface BenchmarkConfig {
+    iterations: number;
+    warmupIterations: number;
+    concurrency: number;
+    timeout: number;
+}
+interface BenchmarkResult {
+    toolName: string;
+    iterations: number;
+    stats: BenchmarkStats;
+    errors: number;
+    startedAt: Date;
+    completedAt: Date;
+}
+interface BenchmarkStats {
+    min: number;
+    max: number;
+    mean: number;
+    median: number;
+    p95: number;
+    p99: number;
+    stddev: number;
+}
+interface ProfileEntry {
+    toolName: string;
+    startMs: number;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+}
+interface WaterfallEntry {
+    label: string;
+    startMs: number;
+    durationMs: number;
+}
+interface MCPScore {
+    overall: number;
+    categories: {
+        documentation: number;
+        errorHandling: number;
+        schemaQuality: number;
+        performance: number;
+        security: number;
+    };
+}
+type WSClientMessage = {
+    type: 'subscribe';
+    channel: string;
+} | {
+    type: 'unsubscribe';
+    channel: string;
+} | {
+    type: 'ping';
+};
+type WSServerMessage = {
+    type: 'subscribed';
+    channel: string;
+} | {
+    type: 'event';
+    channel: string;
+    event: string;
+    data: unknown;
+} | {
+    type: 'pong';
+};
+interface ErrorTemplate {
+    title: string;
+    description: string;
+    suggestions: string[];
+    docs?: string;
+}
+
+declare const createServerSchema: z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    name: string;
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+declare const updateServerSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    transport: z.ZodOptional<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
+    command: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    args: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    url: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    env: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    name?: string | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+declare const createCollectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    yaml: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    yaml: string;
+    description?: string | undefined;
+}, {
+    name: string;
+    yaml: string;
+    description?: string | undefined;
+}>;
+declare const updateCollectionSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    yaml: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    yaml?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    yaml?: string | undefined;
+}>;
+declare const triggerRunSchema: z.ZodObject<{
+    collectionId: z.ZodString;
+    serverId: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    parallelism: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    collectionId: string;
+    serverId?: string | undefined;
+    environment?: string | undefined;
+    tags?: string[] | undefined;
+    parallelism?: number | undefined;
+}, {
+    collectionId: string;
+    serverId?: string | undefined;
+    environment?: string | undefined;
+    tags?: string[] | undefined;
+    parallelism?: number | undefined;
+}>;
+declare const inspectConnectSchema: z.ZodObject<{
+    transport: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+declare const inspectCallSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    tool: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    tool: string;
+    sessionId: string;
+    input?: Record<string, unknown> | undefined;
+}, {
+    tool: string;
+    sessionId: string;
+    input?: Record<string, unknown> | undefined;
+}>;
+declare const auditStartSchema: z.ZodObject<{
+    transport: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mode: z.ZodDefault<z.ZodEnum<["passive", "active", "aggressive"]>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse" | "streamable-http";
+    mode: "passive" | "active" | "aggressive";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    rules?: string[] | undefined;
+}, {
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    mode?: "passive" | "active" | "aggressive" | undefined;
+    rules?: string[] | undefined;
+}>;
+declare const benchmarkStartSchema: z.ZodObject<{
+    transport: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    tool: z.ZodString;
+    toolArgs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    iterations: z.ZodDefault<z.ZodNumber>;
+    warmup: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    tool: string;
+    transport: "stdio" | "sse" | "streamable-http";
+    toolArgs: Record<string, unknown>;
+    iterations: number;
+    warmup: number;
+    timeout: number;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    tool: string;
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    toolArgs?: Record<string, unknown> | undefined;
+    iterations?: number | undefined;
+    warmup?: number | undefined;
+    timeout?: number | undefined;
+}>;
+declare const docsGenerateSchema: z.ZodObject<{
+    transport: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<["markdown", "html"]>>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse" | "streamable-http";
+    format: "html" | "markdown";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    format?: "html" | "markdown" | undefined;
+}>;
+declare const scoreCalculateSchema: z.ZodObject<{
+    transport: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    transport: "stdio" | "sse" | "streamable-http";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+
+declare const serverConfigSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeouts: z.ZodOptional<z.ZodObject<{
+        connect: z.ZodOptional<z.ZodNumber>;
+        call: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        connect?: number | undefined;
+        call?: number | undefined;
+    }, {
+        connect?: number | undefined;
+        call?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse" | "streamable-http";
+    name?: string | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    timeouts?: {
+        connect?: number | undefined;
+        call?: number | undefined;
+    } | undefined;
+}, {
+    name?: string | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    env?: Record<string, string> | undefined;
+    timeouts?: {
+        connect?: number | undefined;
+        call?: number | undefined;
+    } | undefined;
+}>]>;
+declare const simpleExpectationSchema: z.ZodUnion<[z.ZodObject<{
+    exists: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    exists: string;
+}, {
+    exists: string;
+}>, z.ZodObject<{
+    equals: z.ZodTuple<[z.ZodString, z.ZodUnknown], null>;
+}, "strip", z.ZodTypeAny, {
+    equals: [string, unknown];
+}, {
+    equals: [string, unknown];
+}>, z.ZodObject<{
+    contains: z.ZodTuple<[z.ZodString, z.ZodUnknown], null>;
+}, "strip", z.ZodTypeAny, {
+    contains: [string, unknown];
+}, {
+    contains: [string, unknown];
+}>, z.ZodObject<{
+    matches: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, "strip", z.ZodTypeAny, {
+    matches: [string, string];
+}, {
+    matches: [string, string];
+}>]>;
+declare const assertionDefinitionSchema: z.ZodObject<{
+    type: z.ZodEnum<["schema", "equals", "contains", "exists", "matches", "type", "length", "latency", "mimeType", "expression"]>;
+    path: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    expected: z.ZodOptional<z.ZodUnknown>;
+    pattern: z.ZodOptional<z.ZodString>;
+    maxMs: z.ZodOptional<z.ZodNumber>;
+    operator: z.ZodOptional<z.ZodString>;
+    expr: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+    value?: unknown;
+    path?: string | undefined;
+    expected?: unknown;
+    pattern?: string | undefined;
+    maxMs?: number | undefined;
+    operator?: string | undefined;
+    expr?: string | undefined;
+}, {
+    type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+    value?: unknown;
+    path?: string | undefined;
+    expected?: unknown;
+    pattern?: string | undefined;
+    maxMs?: number | undefined;
+    operator?: string | undefined;
+    expr?: string | undefined;
+}>;
+declare const extractionSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    path: string;
+}, {
+    name: string;
+    path: string;
+}>;
+declare const testDefinitionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<["tool", "resource"]>>;
+    tool: z.ZodOptional<z.ZodString>;
+    call: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["schema", "equals", "contains", "exists", "matches", "type", "length", "latency", "mimeType", "expression"]>;
+        path: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodUnknown>;
+        expected: z.ZodOptional<z.ZodUnknown>;
+        pattern: z.ZodOptional<z.ZodString>;
+        maxMs: z.ZodOptional<z.ZodNumber>;
+        operator: z.ZodOptional<z.ZodString>;
+        expr: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+        value?: unknown;
+        path?: string | undefined;
+        expected?: unknown;
+        pattern?: string | undefined;
+        maxMs?: number | undefined;
+        operator?: string | undefined;
+        expr?: string | undefined;
+    }, {
+        type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+        value?: unknown;
+        path?: string | undefined;
+        expected?: unknown;
+        pattern?: string | undefined;
+        maxMs?: number | undefined;
+        operator?: string | undefined;
+        expr?: string | undefined;
+    }>, "many">>;
+    expect: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    expectError: z.ZodOptional<z.ZodBoolean>;
+    extract: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        path: string;
+    }, {
+        name: string;
+        path: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    tool?: string | undefined;
+    type?: "tool" | "resource" | undefined;
+    tags?: string[] | undefined;
+    input?: Record<string, unknown> | undefined;
+    timeout?: number | undefined;
+    call?: string | undefined;
+    id?: string | undefined;
+    retries?: number | undefined;
+    with?: Record<string, unknown> | undefined;
+    assertions?: {
+        type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+        value?: unknown;
+        path?: string | undefined;
+        expected?: unknown;
+        pattern?: string | undefined;
+        maxMs?: number | undefined;
+        operator?: string | undefined;
+        expr?: string | undefined;
+    }[] | undefined;
+    expect?: Record<string, unknown>[] | undefined;
+    expectError?: boolean | undefined;
+    extract?: {
+        name: string;
+        path: string;
+    }[] | undefined;
+}, {
+    name: string;
+    tool?: string | undefined;
+    type?: "tool" | "resource" | undefined;
+    tags?: string[] | undefined;
+    input?: Record<string, unknown> | undefined;
+    timeout?: number | undefined;
+    call?: string | undefined;
+    id?: string | undefined;
+    retries?: number | undefined;
+    with?: Record<string, unknown> | undefined;
+    assertions?: {
+        type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+        value?: unknown;
+        path?: string | undefined;
+        expected?: unknown;
+        pattern?: string | undefined;
+        maxMs?: number | undefined;
+        operator?: string | undefined;
+        expr?: string | undefined;
+    }[] | undefined;
+    expect?: Record<string, unknown>[] | undefined;
+    expectError?: boolean | undefined;
+    extract?: {
+        name: string;
+        path: string;
+    }[] | undefined;
+}>;
+declare const environmentSchema: z.ZodObject<{
+    variables: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    variables: Record<string, string>;
+}, {
+    variables: Record<string, string>;
+}>;
+declare const collectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    server: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        transport: z.ZodDefault<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        url: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        timeouts: z.ZodOptional<z.ZodObject<{
+            connect: z.ZodOptional<z.ZodNumber>;
+            call: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            connect?: number | undefined;
+            call?: number | undefined;
+        }, {
+            connect?: number | undefined;
+            call?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        transport: "stdio" | "sse" | "streamable-http";
+        name?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+        timeouts?: {
+            connect?: number | undefined;
+            call?: number | undefined;
+        } | undefined;
+    }, {
+        name?: string | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+        timeouts?: {
+            connect?: number | undefined;
+            call?: number | undefined;
+        } | undefined;
+    }>]>;
+    environments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        variables: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        variables: Record<string, string>;
+    }, {
+        variables: Record<string, string>;
+    }>>>;
+    defaultEnvironment: z.ZodOptional<z.ZodString>;
+    tests: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodOptional<z.ZodEnum<["tool", "resource"]>>;
+        tool: z.ZodOptional<z.ZodString>;
+        call: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["schema", "equals", "contains", "exists", "matches", "type", "length", "latency", "mimeType", "expression"]>;
+            path: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodUnknown>;
+            expected: z.ZodOptional<z.ZodUnknown>;
+            pattern: z.ZodOptional<z.ZodString>;
+            maxMs: z.ZodOptional<z.ZodNumber>;
+            operator: z.ZodOptional<z.ZodString>;
+            expr: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+            value?: unknown;
+            path?: string | undefined;
+            expected?: unknown;
+            pattern?: string | undefined;
+            maxMs?: number | undefined;
+            operator?: string | undefined;
+            expr?: string | undefined;
+        }, {
+            type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+            value?: unknown;
+            path?: string | undefined;
+            expected?: unknown;
+            pattern?: string | undefined;
+            maxMs?: number | undefined;
+            operator?: string | undefined;
+            expr?: string | undefined;
+        }>, "many">>;
+        expect: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        expectError: z.ZodOptional<z.ZodBoolean>;
+        extract: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            path: string;
+        }, {
+            name: string;
+            path: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        tool?: string | undefined;
+        type?: "tool" | "resource" | undefined;
+        tags?: string[] | undefined;
+        input?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        call?: string | undefined;
+        id?: string | undefined;
+        retries?: number | undefined;
+        with?: Record<string, unknown> | undefined;
+        assertions?: {
+            type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+            value?: unknown;
+            path?: string | undefined;
+            expected?: unknown;
+            pattern?: string | undefined;
+            maxMs?: number | undefined;
+            operator?: string | undefined;
+            expr?: string | undefined;
+        }[] | undefined;
+        expect?: Record<string, unknown>[] | undefined;
+        expectError?: boolean | undefined;
+        extract?: {
+            name: string;
+            path: string;
+        }[] | undefined;
+    }, {
+        name: string;
+        tool?: string | undefined;
+        type?: "tool" | "resource" | undefined;
+        tags?: string[] | undefined;
+        input?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        call?: string | undefined;
+        id?: string | undefined;
+        retries?: number | undefined;
+        with?: Record<string, unknown> | undefined;
+        assertions?: {
+            type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+            value?: unknown;
+            path?: string | undefined;
+            expected?: unknown;
+            pattern?: string | undefined;
+            maxMs?: number | undefined;
+            operator?: string | undefined;
+            expr?: string | undefined;
+        }[] | undefined;
+        expect?: Record<string, unknown>[] | undefined;
+        expectError?: boolean | undefined;
+        extract?: {
+            name: string;
+            path: string;
+        }[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    server: string | {
+        transport: "stdio" | "sse" | "streamable-http";
+        name?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+        timeouts?: {
+            connect?: number | undefined;
+            call?: number | undefined;
+        } | undefined;
+    };
+    tests: {
+        name: string;
+        tool?: string | undefined;
+        type?: "tool" | "resource" | undefined;
+        tags?: string[] | undefined;
+        input?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        call?: string | undefined;
+        id?: string | undefined;
+        retries?: number | undefined;
+        with?: Record<string, unknown> | undefined;
+        assertions?: {
+            type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+            value?: unknown;
+            path?: string | undefined;
+            expected?: unknown;
+            pattern?: string | undefined;
+            maxMs?: number | undefined;
+            operator?: string | undefined;
+            expr?: string | undefined;
+        }[] | undefined;
+        expect?: Record<string, unknown>[] | undefined;
+        expectError?: boolean | undefined;
+        extract?: {
+            name: string;
+            path: string;
+        }[] | undefined;
+    }[];
+    description?: string | undefined;
+    schemaVersion?: string | undefined;
+    environments?: Record<string, {
+        variables: Record<string, string>;
+    }> | undefined;
+    defaultEnvironment?: string | undefined;
+}, {
+    name: string;
+    server: string | {
+        name?: string | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+        env?: Record<string, string> | undefined;
+        timeouts?: {
+            connect?: number | undefined;
+            call?: number | undefined;
+        } | undefined;
+    };
+    tests: {
+        name: string;
+        tool?: string | undefined;
+        type?: "tool" | "resource" | undefined;
+        tags?: string[] | undefined;
+        input?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        call?: string | undefined;
+        id?: string | undefined;
+        retries?: number | undefined;
+        with?: Record<string, unknown> | undefined;
+        assertions?: {
+            type: "schema" | "equals" | "contains" | "exists" | "matches" | "type" | "length" | "latency" | "mimeType" | "expression";
+            value?: unknown;
+            path?: string | undefined;
+            expected?: unknown;
+            pattern?: string | undefined;
+            maxMs?: number | undefined;
+            operator?: string | undefined;
+            expr?: string | undefined;
+        }[] | undefined;
+        expect?: Record<string, unknown>[] | undefined;
+        expectError?: boolean | undefined;
+        extract?: {
+            name: string;
+            path: string;
+        }[] | undefined;
+    }[];
+    description?: string | undefined;
+    schemaVersion?: string | undefined;
+    environments?: Record<string, {
+        variables: Record<string, string>;
+    }> | undefined;
+    defaultEnvironment?: string | undefined;
+}>;
+declare const timeoutConfigSchema: z.ZodObject<{
+    test: z.ZodDefault<z.ZodNumber>;
+    mcpCall: z.ZodDefault<z.ZodNumber>;
+    transport: z.ZodDefault<z.ZodNumber>;
+    assertion: z.ZodDefault<z.ZodNumber>;
+    cleanup: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    transport: number;
+    test: number;
+    mcpCall: number;
+    assertion: number;
+    cleanup: number;
+}, {
+    transport?: number | undefined;
+    test?: number | undefined;
+    mcpCall?: number | undefined;
+    assertion?: number | undefined;
+    cleanup?: number | undefined;
+}>;
+declare const rateLimitConfigSchema: z.ZodObject<{
+    maxCallsPerSecond: z.ZodDefault<z.ZodNumber>;
+    maxConcurrent: z.ZodDefault<z.ZodNumber>;
+    backoff: z.ZodObject<{
+        initial: z.ZodDefault<z.ZodNumber>;
+        multiplier: z.ZodDefault<z.ZodNumber>;
+        max: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        initial: number;
+        multiplier: number;
+        max: number;
+    }, {
+        initial?: number | undefined;
+        multiplier?: number | undefined;
+        max?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    maxCallsPerSecond: number;
+    maxConcurrent: number;
+    backoff: {
+        initial: number;
+        multiplier: number;
+        max: number;
+    };
+}, {
+    backoff: {
+        initial?: number | undefined;
+        multiplier?: number | undefined;
+        max?: number | undefined;
+    };
+    maxCallsPerSecond?: number | undefined;
+    maxConcurrent?: number | undefined;
+}>;
+
+export { type ApiError, type ApiListResponse, type ApiResponse, type AssertionDefinition, type AssertionResult, type AssertionType, type BenchmarkConfig, type BenchmarkResult, type BenchmarkStats, type CollectionDefinition, type ConnectionConfig, type ConnectionState, DEFAULT_RATE_LIMIT, DEFAULT_TIMEOUTS, EXIT_CODES, type EnvironmentDefinition, type ErrorTemplate, type ExitCode, type ExtractionDefinition, type MCPScore, type ManagedProcess, type MessageDirection, type ProcessConfig, type ProfileEntry, type ProtocolLogEntry, type RateLimitConfig, type ReporterType, type SavedCollection, type SavedServerConnection, type SecurityFinding, type SecurityScanConfig, type SecurityScanMode, type SecurityScanResult, type SecurityScanSummary, type ServerConfig, type SeverityLevel, type SimpleExpectation, type TestDefinition, type TestResult, type TestRunRecord, type TestRunResult, type TestSummary, type TimeoutConfig, type TransportType, type WSClientMessage, type WSServerMessage, type WaterfallEntry, assertionDefinitionSchema, auditStartSchema, benchmarkStartSchema, collectionSchema, createCollectionSchema, createServerSchema, docsGenerateSchema, environmentSchema, extractionSchema, inspectCallSchema, inspectConnectSchema, rateLimitConfigSchema, scoreCalculateSchema, serverConfigSchema, simpleExpectationSchema, testDefinitionSchema, timeoutConfigSchema, triggerRunSchema, updateCollectionSchema, updateServerSchema };

package/dist/index.js

@@ -0,0 +1,223 @@
+// src/constants/exit-codes.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  TEST_FAILURE: 1,
+  ERROR: 2,
+  CONFIG_ERROR: 3,
+  CONNECTION_ERROR: 4,
+  TIMEOUT: 5,
+  SECURITY_FINDINGS: 6,
+  VALIDATION_ERROR: 7,
+  INTERRUPTED: 130
+};
+
+// src/types/index.ts
+var DEFAULT_TIMEOUTS = {
+  test: 3e4,
+  mcpCall: 25e3,
+  transport: 2e4,
+  assertion: 5e3,
+  cleanup: 5e3
+};
+var DEFAULT_RATE_LIMIT = {
+  maxCallsPerSecond: 10,
+  maxConcurrent: 5,
+  backoff: {
+    initial: 1e3,
+    multiplier: 2,
+    max: 3e4
+  }
+};
+
+// src/schemas/index.ts
+import { z as z2 } from "zod";
+
+// src/schemas/api.ts
+import { z } from "zod";
+var createServerSchema = z.object({
+  name: z.string().min(1),
+  transport: z.enum(["stdio", "sse", "streamable-http"]),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional()
+});
+var updateServerSchema = createServerSchema.partial();
+var createCollectionSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  yaml: z.string().min(1)
+});
+var updateCollectionSchema = createCollectionSchema.partial();
+var triggerRunSchema = z.object({
+  collectionId: z.string().min(1),
+  serverId: z.string().optional(),
+  environment: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  parallelism: z.number().int().min(1).optional()
+});
+var inspectConnectSchema = z.object({
+  transport: z.enum(["stdio", "sse", "streamable-http"]),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional()
+});
+var inspectCallSchema = z.object({
+  sessionId: z.string().min(1),
+  tool: z.string().min(1),
+  input: z.record(z.unknown()).optional()
+});
+var auditStartSchema = z.object({
+  transport: z.enum(["stdio", "sse", "streamable-http"]),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  mode: z.enum(["passive", "active", "aggressive"]).default("passive"),
+  rules: z.array(z.string()).optional()
+});
+var benchmarkStartSchema = z.object({
+  transport: z.enum(["stdio", "sse", "streamable-http"]),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  tool: z.string().min(1),
+  toolArgs: z.record(z.unknown()).default({}),
+  iterations: z.number().int().min(1).default(100),
+  warmup: z.number().int().min(0).default(5),
+  timeout: z.number().int().min(1e3).default(3e4)
+});
+var docsGenerateSchema = z.object({
+  transport: z.enum(["stdio", "sse", "streamable-http"]),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  format: z.enum(["markdown", "html"]).default("markdown")
+});
+var scoreCalculateSchema = z.object({
+  transport: z.enum(["stdio", "sse", "streamable-http"]),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional()
+});
+
+// src/schemas/index.ts
+var serverConfigSchema = z2.union([
+  z2.string(),
+  z2.object({
+    name: z2.string().optional(),
+    transport: z2.enum(["stdio", "sse", "streamable-http"]).default("stdio"),
+    command: z2.string().optional(),
+    args: z2.array(z2.string()).optional(),
+    url: z2.string().optional(),
+    env: z2.record(z2.string()).optional(),
+    timeouts: z2.object({
+      connect: z2.number().optional(),
+      call: z2.number().optional()
+    }).optional()
+  })
+]);
+var simpleExpectationSchema = z2.union([
+  z2.object({ exists: z2.string() }),
+  z2.object({ equals: z2.tuple([z2.string(), z2.unknown()]) }),
+  z2.object({ contains: z2.tuple([z2.string(), z2.unknown()]) }),
+  z2.object({ matches: z2.tuple([z2.string(), z2.string()]) })
+]);
+var assertionDefinitionSchema = z2.object({
+  type: z2.enum([
+    "schema",
+    "equals",
+    "contains",
+    "exists",
+    "matches",
+    "type",
+    "length",
+    "latency",
+    "mimeType",
+    "expression"
+  ]),
+  path: z2.string().optional(),
+  value: z2.unknown().optional(),
+  expected: z2.unknown().optional(),
+  pattern: z2.string().optional(),
+  maxMs: z2.number().optional(),
+  operator: z2.string().optional(),
+  expr: z2.string().optional()
+});
+var extractionSchema = z2.object({
+  name: z2.string(),
+  path: z2.string()
+});
+var testDefinitionSchema = z2.object({
+  id: z2.string().optional(),
+  name: z2.string(),
+  tags: z2.array(z2.string()).optional(),
+  timeout: z2.number().optional(),
+  retries: z2.number().optional(),
+  type: z2.enum(["tool", "resource"]).optional(),
+  tool: z2.string().optional(),
+  call: z2.string().optional(),
+  input: z2.record(z2.unknown()).optional(),
+  with: z2.record(z2.unknown()).optional(),
+  assertions: z2.array(assertionDefinitionSchema).optional(),
+  expect: z2.array(z2.record(z2.unknown())).optional(),
+  expectError: z2.boolean().optional(),
+  extract: z2.array(extractionSchema).optional()
+});
+var environmentSchema = z2.object({
+  variables: z2.record(z2.string())
+});
+var collectionSchema = z2.object({
+  schemaVersion: z2.string().optional(),
+  name: z2.string(),
+  description: z2.string().optional(),
+  server: serverConfigSchema,
+  environments: z2.record(environmentSchema).optional(),
+  defaultEnvironment: z2.string().optional(),
+  tests: z2.array(testDefinitionSchema).min(1)
+});
+var timeoutConfigSchema = z2.object({
+  test: z2.number().default(3e4),
+  mcpCall: z2.number().default(25e3),
+  transport: z2.number().default(2e4),
+  assertion: z2.number().default(5e3),
+  cleanup: z2.number().default(5e3)
+});
+var rateLimitConfigSchema = z2.object({
+  maxCallsPerSecond: z2.number().default(10),
+  maxConcurrent: z2.number().default(5),
+  backoff: z2.object({
+    initial: z2.number().default(1e3),
+    multiplier: z2.number().default(2),
+    max: z2.number().default(3e4)
+  })
+});
+export {
+  DEFAULT_RATE_LIMIT,
+  DEFAULT_TIMEOUTS,
+  EXIT_CODES,
+  assertionDefinitionSchema,
+  auditStartSchema,
+  benchmarkStartSchema,
+  collectionSchema,
+  createCollectionSchema,
+  createServerSchema,
+  docsGenerateSchema,
+  environmentSchema,
+  extractionSchema,
+  inspectCallSchema,
+  inspectConnectSchema,
+  rateLimitConfigSchema,
+  scoreCalculateSchema,
+  serverConfigSchema,
+  simpleExpectationSchema,
+  testDefinitionSchema,
+  timeoutConfigSchema,
+  triggerRunSchema,
+  updateCollectionSchema,
+  updateServerSchema
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mcpspec/shared",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/mcpspec.git",
+    "directory": "packages/shared"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.1.0"
+  },
+  "dependencies": {
+    "zod": "^3.22.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist .turbo"
+  }
+}