Security Overview

import fetch from 'node-fetch';

const apiKey = process.env.PROMPTGUARD_API_KEY;
const baseUrl = 'https://api.promptguard.co/api/v1/presets';

const headers = {
  'X-API-Key': apiKey,
  'Content-Type': 'application/json'
};

// Complete configuration workflow
async function configureSecurityPreset(
  projectId: string,
  useCase: string,
  strictnessLevel: string = 'moderate'
) {
  /**
   * Configure security preset for a project.
   * @param projectId - Project ID to configure
   * @param useCase - Use case template (e.g., 'support_bot', 'code_assistant')
   * @param strictnessLevel - Strictness level ('strict', 'moderate', 'permissive')
   */
  try {
    // Step 1: List available use cases
    console.log('Fetching available use cases...');
    const useCasesResponse = await fetch(`${baseUrl}/use-cases`, { headers });

    if (useCasesResponse.status !== 200) {
      console.error(`Error fetching use cases: HTTP ${useCasesResponse.status}`);
      return false;
    }

    const useCases = await useCasesResponse.json();
    const availableKeys = useCases.use_cases?.map((uc: any) => uc.key) || [];

    // Step 2: Validate use case
    if (!availableKeys.includes(useCase)) {
      console.error(`Error: Use case '${useCase}' not found`);
      console.error(`Available use cases: ${availableKeys.join(', ')}`);
      return false;
    }

    // Step 3: Validate strictness level
    const validStrictness = ['strict', 'moderate', 'permissive'];
    if (!validStrictness.includes(strictnessLevel)) {
      console.error(`Error: Invalid strictness level '${strictnessLevel}'`);
      console.error(`Valid levels: ${validStrictness.join(', ')}`);
      return false;
    }

    // Step 4: Get current configuration
    console.log(`\nGetting current configuration for project ${projectId}...`);
    const currentResponse = await fetch(
      `${baseUrl}/projects/${projectId}/preset`,
      { headers }
    );

    if (currentResponse.status === 200) {
      const current = await currentResponse.json();
      console.log(`Current: ${current.use_case}:${current.strictness_level}`);
    } else if (currentResponse.status === 404) {
      console.error(`Error: Project ${projectId} not found`);
      return false;
    }

    // Step 5: Update preset
    const presetName = `${useCase}:${strictnessLevel}`;
    console.log(`\nUpdating preset to: ${presetName}`);

    const updateResponse = await fetch(
      `${baseUrl}/projects/${projectId}/preset`,
      {
        method: 'PUT',
        headers,
        body: JSON.stringify({ preset_name: presetName })
      }
    );

    if (updateResponse.status === 200) {
      const result = await updateResponse.json();
      console.log(`OK: Successfully updated to ${presetName}`);

      // Step 6: Verify configuration
      console.log('\nVerifying configuration...');
      const verifyResponse = await fetch(
        `${baseUrl}/projects/${projectId}/preset`,
        { headers }
      );

      if (verifyResponse.status === 200) {
        const verified = await verifyResponse.json();
        if (verified.use_case === useCase &&
            verified.strictness_level === strictnessLevel) {
          console.log('OK: Configuration verified successfully!');
          return true;
        } else {
          console.log('Warning: Configuration may not have updated correctly');
          return false;
        }
      }

      return true;
    } else if (updateResponse.status === 400) {
      const error = await updateResponse.json();
      console.error(`Error: ${error.detail || 'Invalid request'}`);
    } else if (updateResponse.status === 404) {
      console.error(`Error: Project ${projectId} not found`);
    } else if (updateResponse.status === 401) {
      console.error('Error: Invalid API key');
    } else {
      console.error(`Error: HTTP ${updateResponse.status}`);
    }

    return false;
  } catch (error) {
    console.error(`Unexpected error: ${error}`);
    return false;
  }
}

// Quick preset update
async function quickUpdatePreset(projectId: string, presetName: string) {
  /**
   * Quick update using preset name string.
   * Format: 'use_case:strictness' or 'use_case' (defaults to moderate)
   */
  const response = await fetch(
    `${baseUrl}/projects/${projectId}/preset`,
    {
      method: 'PUT',
      headers,
      body: JSON.stringify({ preset_name: presetName })
    }
  );

  if (response.status === 200) {
    console.log(`OK: Preset updated to: ${presetName}`);
    return await response.json();
  } else {
    const error = await response.json().catch(() => ({}));
    console.error(`Error: ${error.detail || `HTTP ${response.status}`}`);
    return null;
  }
}

// Example usage
async function main() {
  const projectId = 'proj_abc123';

  // Complete workflow
  await configureSecurityPreset(projectId, 'support_bot', 'strict');

  // Quick update
  await quickUpdatePreset(projectId, 'code_assistant:moderate');

  // Update with default strictness (moderate)
  await quickUpdatePreset(projectId, 'rag_system');
}

main();

# List available use cases (developer API - requires API key)
curl https://api.promptguard.co/api/v1/presets/use-cases \
  -H "X-API-Key: $PROMPTGUARD_API_KEY"

# Get current project preset
curl https://api.promptguard.co/api/v1/presets/projects/{project_id}/preset \
  -H "X-API-Key: $PROMPTGUARD_API_KEY"

# Update project preset using composed format (use_case:strictness)
curl -X PUT https://api.promptguard.co/api/v1/presets/projects/{project_id}/preset \
  -H "X-API-Key: $PROMPTGUARD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "preset_name": "support_bot:strict"
  }'

# Or use just use case name (defaults to moderate strictness)
curl -X PUT https://api.promptguard.co/api/v1/presets/projects/{project_id}/preset \
  -H "X-API-Key: $PROMPTGUARD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "preset_name": "support_bot"
  }'