// Check environment variable is loaded
console.log('API Key exists:', !!process.env.Koreshield_API_KEY);

// Verify key format
const apiKey = process.env.Koreshield_API_KEY;
if (!apiKey.startsWith('ks_')) {
  console.error('Invalid API key format');
}

// Test connection
import { Koreshield } from 'Koreshield-sdk';

const Koreshield = new Koreshield({ apiKey });

try {
  await Koreshield.scan({ content: 'test' });
  console.log('Connection successful');
} catch (error) {
  console.error('Connection failed:', error.message);
}

// Enable request caching
const Koreshield = new Koreshield({
  apiKey: process.env.Koreshield_API_KEY,
  cache: {
    enabled: true,
    ttl: 300, // 5 minutes
  },
});

// Use batch scanning
const results = await Koreshield.batchScan({
  items: messages.map((content, i) => ({ id: `${i}`, content })),
});

// Set timeouts
const scan = await Promise.race([
  Koreshield.scan({ content: message }),
  new Promise((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), 5000)
  ),
]);

// Adjust sensitivity
const scan = await Koreshield.scan({
  content: message,
  sensitivity: 'medium', // or 'low'
});

// Use allowlist
const scan = await Koreshield.scan({
  content: message,
  allowlist: ['technical terms', 'product names'],
});

// Custom policy
const scan = await Koreshield.scan({
  content: message,
  policyId: 'custom-policy-id',
});

import pRetry from 'p-retry';

async function scanWithRetry(content: string) {
  return pRetry(
    async () => {
      return await Koreshield.scan({ content });
    },
    {
      retries: 3,
      onFailedAttempt: error => {
        if (error.response?.status === 429) {
          console.log('Rate limited, retrying...');
        }
      },
    }
  );
}

// Implement client-side rate limiting
import Bottleneck from 'bottleneck';

const limiter = new Bottleneck({
  maxConcurrent: 10,
  minTime: 100, // 100ms between requests
});

const scan = limiter.wrap((content: string) =>
  Koreshield.scan({ content })
);

// Properly close connections
process.on('SIGTERM', async () => {
  await Koreshield.close();
  process.exit(0);
});

// Avoid storing large scan histories
const MAX_HISTORY = 1000;
let scanHistory: any[] = [];

function addToHistory(scan: any) {
  scanHistory.push(scan);
  if (scanHistory.length > MAX_HISTORY) {
    scanHistory = scanHistory.slice(-MAX_HISTORY);
  }
}

// Use streaming for large responses
for await (const chunk of streamResponse()) {
  // Process chunk immediately, don't accumulate
  await handleChunk(chunk);
}

const Koreshield = new Koreshield({
  apiKey: process.env.Koreshield_API_KEY,
  debug: true,
  logLevel: 'debug',
});

// Console will show:
// [Koreshield] Request: POST /v1/scan
// [Koreshield] Response: 200 OK (123ms)

const scan = await Koreshield.scan({ content: message });

console.log('Scan Results:', {
  threatDetected: scan.threat_detected,
  threatType: scan.threat_type,
  confidence: scan.confidence,
  patterns: scan.patterns_matched,
  metadata: scan.metadata,
});

# Check connectivity
curl -I https://api.Koreshield.com/health

# Test API key
curl -X POST https://api.Koreshield.com/v1/scan \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "test"}'

# Monitor requests
export DEBUG=axios
npm start

async function profileScan(content: string) {
  const start = performance.now();

  const scan = await Koreshield.scan({ content });

  const duration = performance.now() - start;

  console.log(`Scan completed in ${duration.toFixed(2)}ms`);

  return { scan, duration };
}