API Key Management

curl -X POST https://api.docintell.com/v1/keys \
  -H "Authorization: Bearer dk_live_YOUR_ADMIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production Server",
    "environment": "live"
  }'

import requests

headers = {
    "Authorization": "Bearer dk_live_YOUR_ADMIN_KEY",
    "Content-Type": "application/json"
}

data = {
    "name": "Production Server",
    "environment": "live"
}

response = requests.post(
    "https://api.docintell.com/v1/keys",
    headers=headers,
    json=data
)

api_key = response.json()["api_key"]
print(f"New API key: {api_key}")

const response = await fetch('https://api.docintell.com/v1/keys', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer dk_live_YOUR_ADMIN_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Production Server',
    environment: 'live',
  }),
});

const { api_key } = await response.json();
console.log(`New API key: ${api_key}`);

import (
    "bytes"
    "encoding/json"
    "net/http"
)

payload := map[string]string{
    "name":        "Production Server",
    "environment": "live",
}

body, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", "https://api.docintell.com/v1/keys", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer dk_live_YOUR_ADMIN_KEY")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)

curl -X GET https://api.docintell.com/v1/keys \
  -H "Authorization: Bearer dk_live_YOUR_API_KEY"

import requests

headers = {
    "Authorization": "Bearer dk_live_YOUR_API_KEY"
}

response = requests.get(
    "https://api.docintell.com/v1/keys",
    headers=headers
)

keys = response.json()["keys"]
for key in keys:
    print(f"{key['name']}: {key['status']} (last used: {key['last_used_at']})")

const response = await fetch('https://api.docintell.com/v1/keys', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer dk_live_YOUR_API_KEY',
  },
});

const { keys } = await response.json();
keys.forEach((key: any) => {
  console.log(`${key.name}: ${key.status} (last used: ${key.last_used_at})`);
});

import (
    "encoding/json"
    "net/http"
)

req, _ := http.NewRequest("GET", "https://api.docintell.com/v1/keys", nil)
req.Header.Set("Authorization", "Bearer dk_live_YOUR_API_KEY")

client := &http.Client{}
resp, _ := client.Do(req)

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

keys := result["keys"].([]interface{})
for _, k := range keys {
    key := k.(map[string]interface{})
    fmt.Printf("%s: %s (last used: %s)\n",
        key["name"], key["status"], key["last_used_at"])
}

curl -X GET "https://api.docintell.com/v1/keys?include_deprecated=false" \
  -H "Authorization: Bearer dk_live_YOUR_API_KEY"

response = requests.get(
    "https://api.docintell.com/v1/keys",
    headers=headers,
    params={"include_deprecated": False}
)

const response = await fetch(
  'https://api.docintell.com/v1/keys?include_deprecated=false',
  {
    headers: { 'Authorization': 'Bearer dk_live_YOUR_API_KEY' },
  }
);

req, _ := http.NewRequest(
    "GET",
    "https://api.docintell.com/v1/keys?include_deprecated=false",
    nil,
)
req.Header.Set("Authorization", "Bearer dk_live_YOUR_API_KEY")

#!/usr/bin/env python3
"""API Key Health Check - Run daily to monitor key status."""
import os
import sys
from datetime import datetime, timedelta

import requests

API_KEY = os.environ["DOCINTELL_API_KEY"]
BASE_URL = "https://api.docintell.com"

def check_api_keys():
    """Check API key health and report issues."""
    response = requests.get(
        f"{BASE_URL}/v1/keys",
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    response.raise_for_status()

    keys = response.json()["keys"]
    issues = []

    # Check 1: Unused keys (never used or >30 days)
    cutoff = datetime.utcnow() - timedelta(days=30)
    for key in keys:
        if key["last_used_at"] is None:
            issues.append(f"⚠️ UNUSED: '{key['name']}' has never been used")
        else:
            last_used = datetime.fromisoformat(
                key["last_used_at"].replace("Z", "+00:00")
            )
            if last_used < cutoff:
                days_ago = (datetime.utcnow().replace(tzinfo=last_used.tzinfo) - last_used).days
                issues.append(
                    f"⚠️ STALE: '{key['name']}' not used in {days_ago} days"
                )

    # Check 2: Keys in grace period
    for key in keys:
        if key["status"] == "deprecated":
            days = key["grace_period_days_remaining"]
            if days <= 2:
                issues.append(
                    f"🚨 URGENT: '{key['name']}' expires in {days} days!"
                )
            else:
                issues.append(
                    f"⏳ GRACE PERIOD: '{key['name']}' expires in {days} days"
                )

    # Check 3: Multiple active keys (should only have 1 per environment)
    active_live = [k for k in keys if k["status"] == "active" and k["environment"] == "live"]
    active_test = [k for k in keys if k["status"] == "active" and k["environment"] == "test"]

    if len(active_live) > 1:
        issues.append(
            f"⚠️ MULTIPLE LIVE KEYS: {len(active_live)} active live keys found"
        )
    if len(active_test) > 3:
        issues.append(
            f"⚠️ MANY TEST KEYS: {len(active_test)} active test keys found"
        )

    # Report results
    if issues:
        print("API Key Health Check - Issues Found:")
        for issue in issues:
            print(f"  {issue}")
        return 1
    else:
        print("✅ API Key Health Check - All keys healthy")
        return 0

if __name__ == "__main__":
    sys.exit(check_api_keys())

#!/usr/bin/env node
/**
 * API Key Health Check - Run daily to monitor key status.
 */
const API_KEY = process.env.DOCINTELL_API_KEY!;
const BASE_URL = 'https://api.docintell.com';

async function checkApiKeys(): Promise<number> {
  const response = await fetch(`${BASE_URL}/v1/keys`, {
    headers: { Authorization: `Bearer ${API_KEY}` },
  });

  if (!response.ok) throw new Error(`HTTP ${response.status}`);

  const { keys } = await response.json();
  const issues: string[] = [];

  // Check 1: Unused keys (never used or >30 days)
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
  for (const key of keys) {
    if (!key.last_used_at) {
      issues.push(`⚠️ UNUSED: '${key.name}' has never been used`);
    } else {
      const lastUsed = new Date(key.last_used_at);
      if (lastUsed < cutoff) {
        const daysAgo = Math.floor((Date.now() - lastUsed.getTime()) / (24 * 60 * 60 * 1000));
        issues.push(`⚠️ STALE: '${key.name}' not used in ${daysAgo} days`);
      }
    }
  }

  // Check 2: Keys in grace period
  for (const key of keys) {
    if (key.status === 'deprecated') {
      const days = key.grace_period_days_remaining;
      if (days <= 2) {
        issues.push(`🚨 URGENT: '${key.name}' expires in ${days} days!`);
      } else {
        issues.push(`⏳ GRACE PERIOD: '${key.name}' expires in ${days} days`);
      }
    }
  }

  // Check 3: Multiple active keys
  const activeLive = keys.filter(
    (k: any) => k.status === 'active' && k.environment === 'live'
  );
  const activeTest = keys.filter(
    (k: any) => k.status === 'active' && k.environment === 'test'
  );

  if (activeLive.length > 1) {
    issues.push(`⚠️ MULTIPLE LIVE KEYS: ${activeLive.length} active live keys found`);
  }
  if (activeTest.length > 3) {
    issues.push(`⚠️ MANY TEST KEYS: ${activeTest.length} active test keys found`);
  }

  // Report results
  if (issues.length > 0) {
    console.log('API Key Health Check - Issues Found:');
    issues.forEach((issue) => console.log(`  ${issue}`));
    return 1;
  } else {
    console.log('✅ API Key Health Check - All keys healthy');
    return 0;
  }
}

checkApiKeys().then((exitCode) => process.exit(exitCode));

#!/bin/bash
# API Key Health Check - Run daily to monitor key status

API_KEY="${DOCINTELL_API_KEY}"
BASE_URL="https://api.docintell.com"

# Fetch all keys
response=$(curl -s -X GET "${BASE_URL}/v1/keys" \
  -H "Authorization: Bearer ${API_KEY}")

# Parse and check for issues
issues=0

# Check for deprecated keys
deprecated_count=$(echo "$response" | jq '[.keys[] | select(.status == "deprecated")] | length')
if [ "$deprecated_count" -gt 0 ]; then
  echo "⏳ GRACE PERIOD: $deprecated_count keys in rotation"

  # Check if any are expiring soon (< 3 days)
  urgent=$(echo "$response" | jq '[.keys[] | select(.status == "deprecated" and .grace_period_days_remaining < 3)] | length')
  if [ "$urgent" -gt 0 ]; then
    echo "🚨 URGENT: $urgent keys expire in < 3 days!"
    issues=1
  fi
fi

# Check for unused keys (last_used_at is null)
unused=$(echo "$response" | jq '[.keys[] | select(.last_used_at == null)] | length')
if [ "$unused" -gt 0 ]; then
  echo "⚠️ UNUSED: $unused keys have never been used"
  issues=1
fi

# Exit with appropriate code
if [ $issues -eq 0 ]; then
  echo "✅ API Key Health Check - All keys healthy"
  exit 0
else
  exit 1
fi