@anyshift/mcp-proxy 0.3.5 → 0.4.0

package/dist/timeseries/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Time Series Anomaly Detection Types
+ */
+/**
+ * A single data point in the time series
+ */
+export interface DataPoint {
+    /** Index in the original array */
+    index: number;
+    /** Timestamp value (if available) */
+    timestamp?: string | number;
+    /** The numeric value */
+    value: number;
+}
+/**
+ * Threshold direction for threshold-based detection
+ */
+export type ThresholdDirection = 'upper' | 'lower';
+/**
+ * A named threshold with direction
+ */
+export interface NamedThreshold {
+    /** Name/label for this threshold */
+    name: string;
+    /** The threshold value */
+    value: number;
+    /** Whether this is an upper or lower bound */
+    direction: ThresholdDirection;
+}
+/**
+ * Detection types supported by the tool
+ */
+export type DetectionType = 'rolling_quantile' | 'mad' | 'moving_average' | 'threshold';
+/**
+ * Parameters for Rolling Quantile detection (similar to Datadog Basic)
+ */
+export interface RollingQuantileParams {
+    /** Window size for the rolling quantile calculation */
+    window_size: number;
+    /** Lower quantile for the expected range (default: 0.05 = 5th percentile) */
+    lower_quantile?: number;
+    /** Upper quantile for the expected range (default: 0.95 = 95th percentile) */
+    upper_quantile?: number;
+}
+/**
+ * Parameters for MAD (Median Absolute Deviation) detection
+ */
+export interface MadParams {
+    /** Multiplier for MAD threshold (default: 3) */
+    threshold?: number;
+}
+/**
+ * Parameters for Moving Average detection
+ */
+export interface MovingAverageParams {
+    /** Window size for the moving average */
+    window_size: number;
+    /** Number of standard deviations from moving average (default: 2) */
+    threshold?: number;
+}
+/**
+ * Parameters for Threshold detection
+ */
+export interface ThresholdParams {
+    /** Named thresholds with direction */
+    thresholds: NamedThreshold[];
+}
+/**
+ * Union type for all detection parameters
+ */
+export type DetectionParams = RollingQuantileParams | MadParams | MovingAverageParams | ThresholdParams;
+/**
+ * A detected anomaly (individual point)
+ */
+export interface Anomaly {
+    /** Index in the original data */
+    index: number;
+    /** Timestamp if available (raw value from data) */
+    timestamp?: string | number;
+    /** UTC time string if timestamp was a Unix timestamp */
+    utc_time?: string;
+    /** The anomalous value */
+    value: number;
+    /** Reason/description of why this is an anomaly */
+    reason: string;
+    /** For threshold detection: which thresholds were crossed */
+    crossed_thresholds?: string[];
+    /** Additional metadata (e.g., z-score value, percent change) */
+    metadata?: Record<string, number>;
+}
+/**
+ * A pooled anomaly (consecutive anomalies grouped together)
+ */
+export interface PooledAnomaly {
+    /** Start index in the original data */
+    start_index: number;
+    /** End index in the original data (inclusive) */
+    end_index: number;
+    /** Number of anomalous points in this pool */
+    count: number;
+    /** Start timestamp if available */
+    start_timestamp?: string | number;
+    /** End timestamp if available */
+    end_timestamp?: string | number;
+    /** Start UTC time string */
+    start_utc?: string;
+    /** End UTC time string */
+    end_utc?: string;
+    /** Minimum value in the pool */
+    min_value: number;
+    /** Maximum value in the pool */
+    max_value: number;
+    /** Average value in the pool */
+    avg_value: number;
+    /** Summary reason for the pool */
+    reason: string;
+    /** For threshold detection: union of all crossed thresholds */
+    crossed_thresholds?: string[];
+}
+/**
+ * Result of anomaly detection
+ */
+export interface AnomalyDetectionResult {
+    /** Total number of data points analyzed */
+    total_points: number;
+    /** Number of anomalous points detected */
+    anomaly_count: number;
+    /** Percentage of points that are anomalies */
+    anomaly_percentage: number;
+    /** Number of anomaly pools (consecutive anomalies grouped) */
+    pool_count: number;
+    /** List of pooled anomalies (consecutive anomalies grouped together) */
+    anomalies: PooledAnomaly[];
+    /** Detection method used */
+    detection_type: DetectionType;
+    /** Parameters used for detection */
+    parameters: DetectionParams;
+}
+/**
+ * Configuration for the timeseries anomaly detection tool
+ */
+export interface TimeseriesConfig {
+    /** Paths where the tool is allowed to read files */
+    allowedPaths: string[];
+    /** Timeout for jq query execution in milliseconds (default: 30000) */
+    timeoutMs?: number;
+}

package/dist/timeseries/types.js

@@ -0,0 +1,4 @@
+/**
+ * Time Series Anomaly Detection Types
+ */
+export {};

package/dist/types/index.d.ts

@@ -53,27 +53,6 @@ export interface FileWriterResult {
         text: string;
     }>;
 }
-/**
- * Schema analysis result for a JSON structure
- */
-export interface JsonSchema {
-    type: string;
-    properties?: Record<string, unknown>;
-    items?: unknown;
-    length?: number;
-    _hasNulls?: boolean;
-    _keysAreNumeric?: boolean;
-    _accessPattern?: string;
-}
-/**
- * Nullable fields extracted from schema
- */
-export interface NullableFields {
-    /** Fields that are always null */
-    alwaysNull: string[];
-    /** Fields that can be null (mixed types) */
-    nullable: string[];
-}
 /**
  * Unified response format for all tool calls
  * Provides a consistent structure for LLM consumption

package/dist/utils/filename.d.ts

@@ -6,11 +6,3 @@
  * @returns Tool ID like "1697834567123_met_qry_a3b4c5"
  */
 export declare const generateToolId: (toolName: string, args: Record<string, unknown>, toolAbbreviations?: Record<string, string>) => string;
-/**
- * Generate LLM-friendly compact filename
- * @param toolName - Name of the tool that generated the data
- * @param args - Arguments passed to the tool
- * @param toolAbbreviations - Optional custom abbreviations for tool names
- * @returns Compact filename like "1697834567123_met_qry_a3b4c5.json"
- */
-export declare const generateCompactFilename: (toolName: string, args: Record<string, unknown>, toolAbbreviations?: Record<string, string>) => string;

package/dist/utils/filename.js

@@ -40,13 +40,3 @@ export const generateToolId = (toolName, args, toolAbbreviations) => {
     const argsHash = hashArgs(args);
     return `${timestamp}_${toolAbbrev}_${argsHash}`;
 };
-/**
- * Generate LLM-friendly compact filename
- * @param toolName - Name of the tool that generated the data
- * @param args - Arguments passed to the tool
- * @param toolAbbreviations - Optional custom abbreviations for tool names
- * @returns Compact filename like "1697834567123_met_qry_a3b4c5.json"
- */
-export const generateCompactFilename = (toolName, args, toolAbbreviations) => {
-    return `${generateToolId(toolName, args, toolAbbreviations)}.json`;
-};

package/dist/utils/jq.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Dangerous patterns that could access environment variables or system info in jq queries
+ */
+export declare const DANGEROUS_JQ_PATTERNS: RegExp[];
+/**
+ * Validate a jq query for dangerous patterns
+ * @throws Error if the query contains dangerous patterns
+ */
+export declare function validateJqQuery(jqQuery: string): void;
+/**
+ * Execute a jq query and return the raw stdout string
+ * @param jqQuery - The jq query to execute
+ * @param filePath - Path to the JSON file
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns Raw stdout string from jq
+ */
+export declare function runJq(jqQuery: string, filePath: string, timeoutMs: number): Promise<string>;
+/**
+ * Execute a jq query and return the parsed JSON result
+ * @param jqQuery - The jq query to execute
+ * @param filePath - Path to the JSON file
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns Parsed JSON result
+ */
+export declare function runJqParsed(jqQuery: string, filePath: string, timeoutMs: number): Promise<unknown>;

package/dist/utils/jq.js

@@ -0,0 +1,90 @@
+import { spawn } from 'child_process';
+/**
+ * Dangerous patterns that could access environment variables or system info in jq queries
+ */
+export const DANGEROUS_JQ_PATTERNS = [
+    /\$ENV/i, // $ENV variable access
+    /env\./i, // env.VARIABLE access
+    /@env/i, // @env function
+    /\.env\[/i, // .env["VARIABLE"] access
+    /getenv/i, // getenv function
+    /\$__loc__/i, // location info that might leak paths
+    /input_filename/i, // input filename access
+];
+/**
+ * Validate a jq query for dangerous patterns
+ * @throws Error if the query contains dangerous patterns
+ */
+export function validateJqQuery(jqQuery) {
+    const isDangerous = DANGEROUS_JQ_PATTERNS.some((pattern) => pattern.test(jqQuery));
+    if (isDangerous) {
+        throw new Error('The jq query contains patterns that could access environment variables or system information. Please use a different query.');
+    }
+}
+/**
+ * Execute a jq query and return the raw stdout string
+ * @param jqQuery - The jq query to execute
+ * @param filePath - Path to the JSON file
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns Raw stdout string from jq
+ */
+export async function runJq(jqQuery, filePath, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const jqProcess = spawn('jq', [jqQuery, filePath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+        });
+        let stdout = '';
+        let stderr = '';
+        jqProcess.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        jqProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        // Handle timeout
+        const timeoutId = setTimeout(() => {
+            if (!settled && !jqProcess.killed) {
+                settled = true;
+                jqProcess.kill('SIGTERM');
+                reject(new Error(`jq command timed out after ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+        jqProcess.on('close', (code) => {
+            clearTimeout(timeoutId);
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`jq command failed with exit code ${code}: ${stderr.trim()}`));
+            }
+        });
+        jqProcess.on('error', (error) => {
+            clearTimeout(timeoutId);
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`Failed to execute jq command: ${error.message}`));
+        });
+    });
+}
+/**
+ * Execute a jq query and return the parsed JSON result
+ * @param jqQuery - The jq query to execute
+ * @param filePath - Path to the JSON file
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns Parsed JSON result
+ */
+export async function runJqParsed(jqQuery, filePath, timeoutMs) {
+    const stdout = await runJq(jqQuery, filePath, timeoutMs);
+    try {
+        return JSON.parse(stdout);
+    }
+    catch (parseError) {
+        throw new Error(`Failed to parse jq output as JSON: ${stdout.slice(0, 200)}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyshift/mcp-proxy",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "Generic MCP proxy that adds truncation, file writing, and JQ capabilities to any MCP server",
   "type": "module",
   "main": "dist/index.js",