axios+telemetry cleanup

services/policyLimits/index.ts

@@ -12,7 +12,7 @@
  * - API returns empty restrictions for users without policy limits
  */
 
-import axios from 'axios'
+import { isHttpError, nativeRequest, classifyHttpError } from '../../utils/http.js'
 import { createHash } from 'crypto'
 import { readFileSync as fsReadFileSync } from 'fs'
 import { unlink, writeFile } from 'fs/promises'
@@ -30,7 +30,7 @@ import {
 import { registerCleanup } from '../../utils/cleanupRegistry.js'
 import { logForDebugging } from '../../utils/debug.js'
 import { getClaudeConfigHomeDir } from '../../utils/envUtils.js'
-import { classifyAxiosError } from '../../utils/errors.js'
+// Removed classifyAxiosError import - using classifyHttpError from utils/http.js instead
 import { safeParseJSON } from '../../utils/json.js'
 import {
   getAPIProvider,
@@ -312,22 +312,90 @@ async function fetchPolicyLimits(
       }
     }
 
-    const endpoint = getPolicyLimitsEndpoint()
-    const headers: Record<string, string> = {
-      ...authHeaders.headers,
-      'User-Agent': getClaudeCodeUserAgent(),
-    }
+     const endpoint = getPolicyLimitsEndpoint()
+     const headers: Record<string, string> = {
+       ...authHeaders.headers,
+       'User-Agent': getClaudeCodeUserAgent(),
+     }
+
+     if (cachedChecksum) {
+       headers['If-None-Match'] = `"${cachedChecksum}"`
+     }
+
+     try {
+       const response = await nativeRequest(endpoint, {
+         method: 'GET',
+         headers,
+         timeout: FETCH_TIMEOUT_MS,
+         responseType: 'json',
+       })
+
+       // Handle 304 Not Modified - cached version is still valid
+       if (response.status === 304) {
+         logForDebugging('Policy limits: Using cached restrictions (304)')
+         return {
+           success: true,
+           restrictions: null, // Signal that cache is valid
+           etag: cachedChecksum,
+         }
+       }
+
+       // Handle 404 Not Found - no policy limits exist or feature not enabled
+       if (response.status === 404) {
+         logForDebugging('Policy limits: No restrictions found (404)')
+         return {
+           success: true,
+           restrictions: {},
+           etag: undefined,
+         }
+       }
+
+       const parsed = PolicyLimitsResponseSchema().safeParse(response.data)
+       if (!parsed.success) {
+         logForDebugging(
+           `Policy limits: Invalid response format - ${parsed.error.message}`,
+         )
+         return {
+           success: false,
+           error: 'Invalid policy limits format',
+         }
+       }
+
+       logForDebugging('Policy limits: Fetched successfully')
+       return {
+         success: true,
+         restrictions: parsed.data.restrictions,
+       }
+     } catch (error) {
+       // 404 is handled above via validateStatus, so it won't reach here
+       const { kind, message } = classifyHttpError(error)
+       switch (kind) {
+         case 'auth':
+           return {
+             success: false,
+             error: 'Not authorized for policy limits',
+             skipRetry: true,
+           }
+         case 'timeout':
+           return { success: false, error: 'Policy limits request timeout' }
+         case 'network':
+           return { success: false, error: 'Cannot connect to server' }
+         default:
+           return { success: false, error: message }
+       }
+     }
 
     if (cachedChecksum) {
       headers['If-None-Match'] = `"${cachedChecksum}"`
     }
 
-    const response = await axios.get(endpoint, {
-      headers,
-      timeout: FETCH_TIMEOUT_MS,
-      validateStatus: status =>
-        status === 200 || status === 304 || status === 404,
-    })
+     try {
+       const response = await nativeRequest(endpoint, {
+         method: 'GET',
+         headers,
+         timeout: FETCH_TIMEOUT_MS,
+         responseType: 'json',
+       })
 
     // Handle 304 Not Modified - cached version is still valid
     if (response.status === 304) {
@@ -365,24 +433,24 @@ async function fetchPolicyLimits(
       success: true,
       restrictions: parsed.data.restrictions,
     }
-  } catch (error) {
-    // 404 is handled above via validateStatus, so it won't reach here
-    const { kind, message } = classifyAxiosError(error)
-    switch (kind) {
-      case 'auth':
-        return {
-          success: false,
-          error: 'Not authorized for policy limits',
-          skipRetry: true,
-        }
-      case 'timeout':
-        return { success: false, error: 'Policy limits request timeout' }
-      case 'network':
-        return { success: false, error: 'Cannot connect to server' }
-      default:
-        return { success: false, error: message }
-    }
-  }
+     } catch (error) {
+     // 404 is handled above via validateStatus, so it won't reach here
+     const { kind, message } = classifyHttpError(error)
+     switch (kind) {
+       case 'auth':
+         return {
+           success: false,
+           error: 'Not authorized for policy limits',
+           skipRetry: true,
+         }
+       case 'timeout':
+         return { success: false, error: 'Policy limits request timeout' }
+       case 'network':
+         return { success: false, error: 'Cannot connect to server' }
+       default:
+         return { success: false, error: message }
+     }
+   }
 }
 
 /**