@thinkhive/sdk 3.1.0 → 3.3.0

package/dist/api/apiKeys.d.ts

@@ -0,0 +1,252 @@
+/**
+ * ThinkHive SDK - API Keys Management
+ *
+ * Create and manage scoped API keys with:
+ * - Permission control (read/write/delete)
+ * - Agent-level scoping (allowedAgentIds)
+ * - Environment separation (production/staging/development)
+ * - IP whitelisting (allowedIps)
+ *
+ * @example
+ * ```typescript
+ * import { apiKeys } from 'thinkhive-js';
+ *
+ * // Create a read-only key for monitoring
+ * const readOnlyKey = await apiKeys.create({
+ *   name: 'Monitoring Key',
+ *   scopeType: 'readonly'
+ * });
+ *
+ * // Create a key scoped to specific agents
+ * const agentKey = await apiKeys.create({
+ *   name: 'Agent A Key',
+ *   allowedAgentIds: ['agent-a-id', 'agent-b-id'],
+ *   permissions: { read: true, write: true, delete: false }
+ * });
+ *
+ * // Create a staging environment key
+ * const stagingKey = await apiKeys.create({
+ *   name: 'Staging Key',
+ *   environment: 'staging',
+ *   allowedIps: ['10.0.0.1', '10.0.0.2']
+ * });
+ * ```
+ */
+/**
+ * API key permission configuration
+ */
+export interface ApiKeyPermissions {
+    /** Allow read operations (GET requests, listing, etc.) */
+    read: boolean;
+    /** Allow write operations (POST, PUT requests) */
+    write: boolean;
+    /** Allow delete operations (DELETE requests) */
+    delete: boolean;
+}
+/**
+ * API key scope type
+ * - `company`: Full access to all company data
+ * - `agent`: Limited to specific agents (requires allowedAgentIds)
+ * - `readonly`: Read-only access regardless of other settings
+ */
+export type ScopeType = 'company' | 'agent' | 'readonly';
+/**
+ * API key environment
+ * - `production`: For production systems
+ * - `staging`: For staging/pre-production
+ * - `development`: For local development
+ */
+export type Environment = 'production' | 'staging' | 'development';
+/**
+ * Options for creating an API key
+ */
+export interface CreateApiKeyOptions {
+    /** Display name for the key */
+    name: string;
+    /** Permission configuration (defaults to read+write) */
+    permissions?: Partial<ApiKeyPermissions>;
+    /**
+     * Restrict key to specific agent IDs
+     * When set, key can only access traces for these agents
+     */
+    allowedAgentIds?: string[];
+    /**
+     * Scope type for the key
+     * @default 'company' or 'agent' if allowedAgentIds is set
+     */
+    scopeType?: ScopeType;
+    /**
+     * Environment for the key
+     * @default 'production'
+     */
+    environment?: Environment;
+    /**
+     * Restrict key to specific IP addresses
+     * When set, only requests from these IPs can use this key
+     */
+    allowedIps?: string[];
+    /** Expiration date for the key */
+    expiresAt?: Date;
+}
+/**
+ * API key metadata (returned from server)
+ */
+export interface ApiKey {
+    /** Unique key ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Key prefix (first 8 chars for identification) */
+    keyPrefix: string;
+    /** Permission configuration */
+    permissions: ApiKeyPermissions | string[];
+    /** Scope type */
+    scopeType: ScopeType;
+    /** Environment */
+    environment: Environment;
+    /** Allowed agent IDs (null = all agents) */
+    allowedAgentIds: string[] | null;
+    /** Allowed IP addresses (null = all IPs) */
+    allowedIps: string[] | null;
+    /** Whether key is active */
+    isActive: boolean;
+    /** Last usage timestamp */
+    lastUsedAt: string | null;
+    /** Total usage count */
+    usageCount: number;
+    /** Expiration date */
+    expiresAt: string | null;
+    /** Creation timestamp */
+    createdAt: string;
+}
+/**
+ * Result of creating an API key (includes secret)
+ */
+export interface CreateApiKeyResult extends ApiKey {
+    /**
+     * The full API key value
+     * IMPORTANT: This is only returned once and cannot be retrieved later!
+     * Store it securely.
+     */
+    key: string;
+}
+/**
+ * Create a new API key with specified permissions and scoping
+ *
+ * @param options - API key configuration
+ * @returns Created key with secret (only returned once!)
+ *
+ * @example
+ * ```typescript
+ * // Create a production write key
+ * const result = await apiKeys.create({
+ *   name: 'Production SDK Key',
+ *   permissions: { read: true, write: true, delete: false }
+ * });
+ *
+ * // Save the key securely - it won't be shown again!
+ * console.log('Save this key:', result.key);
+ * ```
+ */
+export declare function create(options: CreateApiKeyOptions): Promise<CreateApiKeyResult>;
+/**
+ * List all API keys for the authenticated company
+ *
+ * @returns Array of API keys (without secrets)
+ *
+ * @example
+ * ```typescript
+ * const keys = await apiKeys.list();
+ * console.log(`Found ${keys.length} API keys`);
+ *
+ * // Filter by environment
+ * const prodKeys = keys.filter(k => k.environment === 'production');
+ * ```
+ */
+export declare function list(): Promise<ApiKey[]>;
+/**
+ * Revoke (deactivate) an API key
+ *
+ * @param keyId - ID of the key to revoke
+ *
+ * @example
+ * ```typescript
+ * // Revoke a compromised key
+ * await apiKeys.revoke('key-id-to-revoke');
+ * ```
+ */
+export declare function revoke(keyId: string): Promise<void>;
+/**
+ * Rotate an API key (revoke old, create new with same config)
+ *
+ * @param keyId - ID of the key to rotate
+ * @param options - Optional overrides for the new key
+ * @returns New key with secret
+ *
+ * @example
+ * ```typescript
+ * // Rotate a key periodically
+ * const existingKeys = await apiKeys.list();
+ * const oldKey = existingKeys.find(k => k.name === 'Production Key');
+ *
+ * if (oldKey) {
+ *   const newKey = await apiKeys.rotate(oldKey.id);
+ *   // Update your systems with newKey.key
+ *   console.log('New key:', newKey.key);
+ * }
+ * ```
+ */
+export declare function rotate(keyId: string, options?: Partial<CreateApiKeyOptions>): Promise<CreateApiKeyResult>;
+/**
+ * Test an API key connection
+ *
+ * @param apiKey - The full API key value to test
+ * @param agentId - Optional agent ID to test with
+ * @returns Test result
+ *
+ * @example
+ * ```typescript
+ * const result = await apiKeys.test('thk_...', 'my-agent-id');
+ * if (result.success) {
+ *   console.log('Key is valid!');
+ * }
+ * ```
+ */
+export declare function test(apiKey: string, agentId?: string): Promise<{
+    success: boolean;
+    error?: string;
+    testTraceId?: string;
+}>;
+/**
+ * Check if an API key has a specific permission
+ */
+export declare function hasPermission(key: ApiKey, permission: 'read' | 'write' | 'delete'): boolean;
+/**
+ * Check if an API key is expired
+ */
+export declare function isExpired(key: ApiKey): boolean;
+/**
+ * Check if an API key is valid (active and not expired)
+ */
+export declare function isValid(key: ApiKey): boolean;
+/**
+ * Get time until key expires (in milliseconds)
+ * Returns null if key doesn't expire
+ */
+export declare function getTimeUntilExpiry(key: ApiKey): number | null;
+/**
+ * Check if a key can access a specific agent
+ */
+export declare function canAccessAgent(key: ApiKey, agentId: string): boolean;
+export declare const apiKeys: {
+    create: typeof create;
+    list: typeof list;
+    revoke: typeof revoke;
+    rotate: typeof rotate;
+    test: typeof test;
+    hasPermission: typeof hasPermission;
+    isExpired: typeof isExpired;
+    isValid: typeof isValid;
+    getTimeUntilExpiry: typeof getTimeUntilExpiry;
+    canAccessAgent: typeof canAccessAgent;
+};

package/dist/api/apiKeys.js

@@ -0,0 +1,298 @@
+"use strict";
+/**
+ * ThinkHive SDK - API Keys Management
+ *
+ * Create and manage scoped API keys with:
+ * - Permission control (read/write/delete)
+ * - Agent-level scoping (allowedAgentIds)
+ * - Environment separation (production/staging/development)
+ * - IP whitelisting (allowedIps)
+ *
+ * @example
+ * ```typescript
+ * import { apiKeys } from 'thinkhive-js';
+ *
+ * // Create a read-only key for monitoring
+ * const readOnlyKey = await apiKeys.create({
+ *   name: 'Monitoring Key',
+ *   scopeType: 'readonly'
+ * });
+ *
+ * // Create a key scoped to specific agents
+ * const agentKey = await apiKeys.create({
+ *   name: 'Agent A Key',
+ *   allowedAgentIds: ['agent-a-id', 'agent-b-id'],
+ *   permissions: { read: true, write: true, delete: false }
+ * });
+ *
+ * // Create a staging environment key
+ * const stagingKey = await apiKeys.create({
+ *   name: 'Staging Key',
+ *   environment: 'staging',
+ *   allowedIps: ['10.0.0.1', '10.0.0.2']
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeys = void 0;
+exports.create = create;
+exports.list = list;
+exports.revoke = revoke;
+exports.rotate = rotate;
+exports.test = test;
+exports.hasPermission = hasPermission;
+exports.isExpired = isExpired;
+exports.isValid = isValid;
+exports.getTimeUntilExpiry = getTimeUntilExpiry;
+exports.canAccessAgent = canAccessAgent;
+const client_1 = require("../core/client");
+// ============================================================================
+// API Key Management Functions
+// ============================================================================
+/**
+ * Create a new API key with specified permissions and scoping
+ *
+ * @param options - API key configuration
+ * @returns Created key with secret (only returned once!)
+ *
+ * @example
+ * ```typescript
+ * // Create a production write key
+ * const result = await apiKeys.create({
+ *   name: 'Production SDK Key',
+ *   permissions: { read: true, write: true, delete: false }
+ * });
+ *
+ * // Save the key securely - it won't be shown again!
+ * console.log('Save this key:', result.key);
+ * ```
+ */
+async function create(options) {
+    if (!options.name || options.name.trim().length === 0) {
+        throw new client_1.ThinkHiveValidationError('API key name is required', 'name');
+    }
+    // Validate IP addresses if provided
+    if (options.allowedIps) {
+        // IPv4 pattern
+        const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        // IPv6 pattern (supports full and compressed notation like ::1, 2001:db8::1)
+        const ipv6Regex = /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?::[0-9a-fA-F]{1,4}){1,6}|:(?::[0-9a-fA-F]{1,4}){1,7}|::)$/;
+        for (const ip of options.allowedIps) {
+            if (!ipv4Regex.test(ip) && !ipv6Regex.test(ip) && ip !== 'localhost') {
+                throw new client_1.ThinkHiveValidationError(`Invalid IP address: ${ip}`, 'allowedIps');
+            }
+        }
+    }
+    const body = {
+        name: options.name.trim(),
+    };
+    if (options.permissions) {
+        body.permissions = {
+            read: options.permissions.read !== false,
+            write: options.permissions.write === true,
+            delete: options.permissions.delete === true,
+        };
+    }
+    if (options.scopeType) {
+        body.scopeType = options.scopeType;
+    }
+    if (options.environment) {
+        body.environment = options.environment;
+    }
+    if (options.allowedAgentIds && options.allowedAgentIds.length > 0) {
+        body.allowedAgentIds = options.allowedAgentIds;
+    }
+    if (options.allowedIps && options.allowedIps.length > 0) {
+        body.allowedIps = options.allowedIps;
+    }
+    if (options.expiresAt) {
+        body.expiresAt = options.expiresAt.toISOString();
+    }
+    return (0, client_1.apiRequest)('/api-keys', {
+        method: 'POST',
+        body,
+        apiVersion: 'v1',
+    });
+}
+/**
+ * List all API keys for the authenticated company
+ *
+ * @returns Array of API keys (without secrets)
+ *
+ * @example
+ * ```typescript
+ * const keys = await apiKeys.list();
+ * console.log(`Found ${keys.length} API keys`);
+ *
+ * // Filter by environment
+ * const prodKeys = keys.filter(k => k.environment === 'production');
+ * ```
+ */
+async function list() {
+    return (0, client_1.apiRequest)('/api-keys', {
+        method: 'GET',
+        apiVersion: 'v1',
+    });
+}
+/**
+ * Revoke (deactivate) an API key
+ *
+ * @param keyId - ID of the key to revoke
+ *
+ * @example
+ * ```typescript
+ * // Revoke a compromised key
+ * await apiKeys.revoke('key-id-to-revoke');
+ * ```
+ */
+async function revoke(keyId) {
+    if (!keyId) {
+        throw new client_1.ThinkHiveValidationError('Key ID is required', 'keyId');
+    }
+    await (0, client_1.apiRequest)(`/api-keys/${keyId}`, {
+        method: 'DELETE',
+        apiVersion: 'v1',
+    });
+}
+/**
+ * Rotate an API key (revoke old, create new with same config)
+ *
+ * @param keyId - ID of the key to rotate
+ * @param options - Optional overrides for the new key
+ * @returns New key with secret
+ *
+ * @example
+ * ```typescript
+ * // Rotate a key periodically
+ * const existingKeys = await apiKeys.list();
+ * const oldKey = existingKeys.find(k => k.name === 'Production Key');
+ *
+ * if (oldKey) {
+ *   const newKey = await apiKeys.rotate(oldKey.id);
+ *   // Update your systems with newKey.key
+ *   console.log('New key:', newKey.key);
+ * }
+ * ```
+ */
+async function rotate(keyId, options) {
+    // Get existing key metadata
+    const keys = await list();
+    const existingKey = keys.find(k => k.id === keyId);
+    if (!existingKey) {
+        throw new client_1.ThinkHiveValidationError('API key not found', 'keyId');
+    }
+    // Create new key with same (or overridden) config
+    const newKeyOptions = {
+        name: options?.name || existingKey.name,
+        scopeType: options?.scopeType || existingKey.scopeType,
+        environment: options?.environment || existingKey.environment,
+        allowedAgentIds: options?.allowedAgentIds || existingKey.allowedAgentIds || undefined,
+        allowedIps: options?.allowedIps || existingKey.allowedIps || undefined,
+    };
+    // Handle permissions conversion
+    if (options?.permissions) {
+        newKeyOptions.permissions = options.permissions;
+    }
+    else if (existingKey.permissions && typeof existingKey.permissions === 'object' && !Array.isArray(existingKey.permissions)) {
+        newKeyOptions.permissions = existingKey.permissions;
+    }
+    // Create new key first (so we don't lose access if creation fails)
+    const newKey = await create(newKeyOptions);
+    // Revoke old key
+    await revoke(keyId);
+    return newKey;
+}
+/**
+ * Test an API key connection
+ *
+ * @param apiKey - The full API key value to test
+ * @param agentId - Optional agent ID to test with
+ * @returns Test result
+ *
+ * @example
+ * ```typescript
+ * const result = await apiKeys.test('thk_...', 'my-agent-id');
+ * if (result.success) {
+ *   console.log('Key is valid!');
+ * }
+ * ```
+ */
+async function test(apiKey, agentId) {
+    if (!apiKey) {
+        throw new client_1.ThinkHiveValidationError('API key is required', 'apiKey');
+    }
+    return (0, client_1.apiRequest)('/api-keys/test', {
+        method: 'POST',
+        body: { apiKey, agentId, createTestTrace: !!agentId },
+        apiVersion: 'v1',
+    });
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Check if an API key has a specific permission
+ */
+function hasPermission(key, permission) {
+    // Handle object format
+    if (typeof key.permissions === 'object' && !Array.isArray(key.permissions)) {
+        return key.permissions[permission] === true;
+    }
+    // Handle legacy array format
+    if (Array.isArray(key.permissions)) {
+        return key.permissions.some(p => p.endsWith(`:${permission}`));
+    }
+    // Default: read allowed, write/delete denied
+    return permission === 'read';
+}
+/**
+ * Check if an API key is expired
+ */
+function isExpired(key) {
+    if (!key.expiresAt)
+        return false;
+    return new Date(key.expiresAt) < new Date();
+}
+/**
+ * Check if an API key is valid (active and not expired)
+ */
+function isValid(key) {
+    return key.isActive && !isExpired(key);
+}
+/**
+ * Get time until key expires (in milliseconds)
+ * Returns null if key doesn't expire
+ */
+function getTimeUntilExpiry(key) {
+    if (!key.expiresAt)
+        return null;
+    const expiry = new Date(key.expiresAt).getTime();
+    const now = Date.now();
+    return Math.max(0, expiry - now);
+}
+/**
+ * Check if a key can access a specific agent
+ */
+function canAccessAgent(key, agentId) {
+    // If no agent restrictions, allow all
+    if (!key.allowedAgentIds || key.allowedAgentIds.length === 0) {
+        return true;
+    }
+    return key.allowedAgentIds.includes(agentId);
+}
+// ============================================================================
+// Export namespace
+// ============================================================================
+exports.apiKeys = {
+    create,
+    list,
+    revoke,
+    rotate,
+    test,
+    hasPermission,
+    isExpired,
+    isValid,
+    getTimeUntilExpiry,
+    canAccessAgent,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apiKeys.js","sourceRoot":"","sources":["../../src/api/apiKeys.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK - API Keys Management\n *\n * Create and manage scoped API keys with:\n * - Permission control (read/write/delete)\n * - Agent-level scoping (allowedAgentIds)\n * - Environment separation (production/staging/development)\n * - IP whitelisting (allowedIps)\n *\n * @example\n * ```typescript\n * import { apiKeys } from 'thinkhive-js';\n *\n * // Create a read-only key for monitoring\n * const readOnlyKey = await apiKeys.create({\n *   name: 'Monitoring Key',\n *   scopeType: 'readonly'\n * });\n *\n * // Create a key scoped to specific agents\n * const agentKey = await apiKeys.create({\n *   name: 'Agent A Key',\n *   allowedAgentIds: ['agent-a-id', 'agent-b-id'],\n *   permissions: { read: true, write: true, delete: false }\n * });\n *\n * // Create a staging environment key\n * const stagingKey = await apiKeys.create({\n *   name: 'Staging Key',\n *   environment: 'staging',\n *   allowedIps: ['10.0.0.1', '10.0.0.2']\n * });\n * ```\n */\n\nimport { apiRequest, ThinkHiveValidationError } from '../core/client';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * API key permission configuration\n */\nexport interface ApiKeyPermissions {\n  /** Allow read operations (GET requests, listing, etc.) */\n  read: boolean;\n  /** Allow write operations (POST, PUT requests) */\n  write: boolean;\n  /** Allow delete operations (DELETE requests) */\n  delete: boolean;\n}\n\n/**\n * API key scope type\n * - `company`: Full access to all company data\n * - `agent`: Limited to specific agents (requires allowedAgentIds)\n * - `readonly`: Read-only access regardless of other settings\n */\nexport type ScopeType = 'company' | 'agent' | 'readonly';\n\n/**\n * API key environment\n * - `production`: For production systems\n * - `staging`: For staging/pre-production\n * - `development`: For local development\n */\nexport type Environment = 'production' | 'staging' | 'development';\n\n/**\n * Options for creating an API key\n */\nexport interface CreateApiKeyOptions {\n  /** Display name for the key */\n  name: string;\n\n  /** Permission configuration (defaults to read+write) */\n  permissions?: Partial<ApiKeyPermissions>;\n\n  /**\n   * Restrict key to specific agent IDs\n   * When set, key can only access traces for these agents\n   */\n  allowedAgentIds?: string[];\n\n  /**\n   * Scope type for the key\n   * @default 'company' or 'agent' if allowedAgentIds is set\n   */\n  scopeType?: ScopeType;\n\n  /**\n   * Environment for the key\n   * @default 'production'\n   */\n  environment?: Environment;\n\n  /**\n   * Restrict key to specific IP addresses\n   * When set, only requests from these IPs can use this key\n   */\n  allowedIps?: string[];\n\n  /** Expiration date for the key */\n  expiresAt?: Date;\n}\n\n/**\n * API key metadata (returned from server)\n */\nexport interface ApiKey {\n  /** Unique key ID */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Key prefix (first 8 chars for identification) */\n  keyPrefix: string;\n  /** Permission configuration */\n  permissions: ApiKeyPermissions | string[];\n  /** Scope type */\n  scopeType: ScopeType;\n  /** Environment */\n  environment: Environment;\n  /** Allowed agent IDs (null = all agents) */\n  allowedAgentIds: string[] | null;\n  /** Allowed IP addresses (null = all IPs) */\n  allowedIps: string[] | null;\n  /** Whether key is active */\n  isActive: boolean;\n  /** Last usage timestamp */\n  lastUsedAt: string | null;\n  /** Total usage count */\n  usageCount: number;\n  /** Expiration date */\n  expiresAt: string | null;\n  /** Creation timestamp */\n  createdAt: string;\n}\n\n/**\n * Result of creating an API key (includes secret)\n */\nexport interface CreateApiKeyResult extends ApiKey {\n  /**\n   * The full API key value\n   * IMPORTANT: This is only returned once and cannot be retrieved later!\n   * Store it securely.\n   */\n  key: string;\n}\n\n// ============================================================================\n// API Key Management Functions\n// ============================================================================\n\n/**\n * Create a new API key with specified permissions and scoping\n *\n * @param options - API key configuration\n * @returns Created key with secret (only returned once!)\n *\n * @example\n * ```typescript\n * // Create a production write key\n * const result = await apiKeys.create({\n *   name: 'Production SDK Key',\n *   permissions: { read: true, write: true, delete: false }\n * });\n *\n * // Save the key securely - it won't be shown again!\n * console.log('Save this key:', result.key);\n * ```\n */\nexport async function create(options: CreateApiKeyOptions): Promise<CreateApiKeyResult> {\n  if (!options.name || options.name.trim().length === 0) {\n    throw new ThinkHiveValidationError('API key name is required', 'name');\n  }\n\n  // Validate IP addresses if provided\n  if (options.allowedIps) {\n    // IPv4 pattern\n    const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;\n    // IPv6 pattern (supports full and compressed notation like ::1, 2001:db8::1)\n    const ipv6Regex = /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?::[0-9a-fA-F]{1,4}){1,6}|:(?::[0-9a-fA-F]{1,4}){1,7}|::)$/;\n    for (const ip of options.allowedIps) {\n      if (!ipv4Regex.test(ip) && !ipv6Regex.test(ip) && ip !== 'localhost') {\n        throw new ThinkHiveValidationError(`Invalid IP address: ${ip}`, 'allowedIps');\n      }\n    }\n  }\n\n  const body: Record<string, unknown> = {\n    name: options.name.trim(),\n  };\n\n  if (options.permissions) {\n    body.permissions = {\n      read: options.permissions.read !== false,\n      write: options.permissions.write === true,\n      delete: options.permissions.delete === true,\n    };\n  }\n\n  if (options.scopeType) {\n    body.scopeType = options.scopeType;\n  }\n\n  if (options.environment) {\n    body.environment = options.environment;\n  }\n\n  if (options.allowedAgentIds && options.allowedAgentIds.length > 0) {\n    body.allowedAgentIds = options.allowedAgentIds;\n  }\n\n  if (options.allowedIps && options.allowedIps.length > 0) {\n    body.allowedIps = options.allowedIps;\n  }\n\n  if (options.expiresAt) {\n    body.expiresAt = options.expiresAt.toISOString();\n  }\n\n  return apiRequest<CreateApiKeyResult>('/api-keys', {\n    method: 'POST',\n    body,\n    apiVersion: 'v1',\n  });\n}\n\n/**\n * List all API keys for the authenticated company\n *\n * @returns Array of API keys (without secrets)\n *\n * @example\n * ```typescript\n * const keys = await apiKeys.list();\n * console.log(`Found ${keys.length} API keys`);\n *\n * // Filter by environment\n * const prodKeys = keys.filter(k => k.environment === 'production');\n * ```\n */\nexport async function list(): Promise<ApiKey[]> {\n  return apiRequest<ApiKey[]>('/api-keys', {\n    method: 'GET',\n    apiVersion: 'v1',\n  });\n}\n\n/**\n * Revoke (deactivate) an API key\n *\n * @param keyId - ID of the key to revoke\n *\n * @example\n * ```typescript\n * // Revoke a compromised key\n * await apiKeys.revoke('key-id-to-revoke');\n * ```\n */\nexport async function revoke(keyId: string): Promise<void> {\n  if (!keyId) {\n    throw new ThinkHiveValidationError('Key ID is required', 'keyId');\n  }\n\n  await apiRequest(`/api-keys/${keyId}`, {\n    method: 'DELETE',\n    apiVersion: 'v1',\n  });\n}\n\n/**\n * Rotate an API key (revoke old, create new with same config)\n *\n * @param keyId - ID of the key to rotate\n * @param options - Optional overrides for the new key\n * @returns New key with secret\n *\n * @example\n * ```typescript\n * // Rotate a key periodically\n * const existingKeys = await apiKeys.list();\n * const oldKey = existingKeys.find(k => k.name === 'Production Key');\n *\n * if (oldKey) {\n *   const newKey = await apiKeys.rotate(oldKey.id);\n *   // Update your systems with newKey.key\n *   console.log('New key:', newKey.key);\n * }\n * ```\n */\nexport async function rotate(\n  keyId: string,\n  options?: Partial<CreateApiKeyOptions>\n): Promise<CreateApiKeyResult> {\n  // Get existing key metadata\n  const keys = await list();\n  const existingKey = keys.find(k => k.id === keyId);\n\n  if (!existingKey) {\n    throw new ThinkHiveValidationError('API key not found', 'keyId');\n  }\n\n  // Create new key with same (or overridden) config\n  const newKeyOptions: CreateApiKeyOptions = {\n    name: options?.name || existingKey.name,\n    scopeType: options?.scopeType || existingKey.scopeType,\n    environment: options?.environment || existingKey.environment,\n    allowedAgentIds: options?.allowedAgentIds || existingKey.allowedAgentIds || undefined,\n    allowedIps: options?.allowedIps || existingKey.allowedIps || undefined,\n  };\n\n  // Handle permissions conversion\n  if (options?.permissions) {\n    newKeyOptions.permissions = options.permissions;\n  } else if (existingKey.permissions && typeof existingKey.permissions === 'object' && !Array.isArray(existingKey.permissions)) {\n    newKeyOptions.permissions = existingKey.permissions as ApiKeyPermissions;\n  }\n\n  // Create new key first (so we don't lose access if creation fails)\n  const newKey = await create(newKeyOptions);\n\n  // Revoke old key\n  await revoke(keyId);\n\n  return newKey;\n}\n\n/**\n * Test an API key connection\n *\n * @param apiKey - The full API key value to test\n * @param agentId - Optional agent ID to test with\n * @returns Test result\n *\n * @example\n * ```typescript\n * const result = await apiKeys.test('thk_...', 'my-agent-id');\n * if (result.success) {\n *   console.log('Key is valid!');\n * }\n * ```\n */\nexport async function test(\n  apiKey: string,\n  agentId?: string\n): Promise<{ success: boolean; error?: string; testTraceId?: string }> {\n  if (!apiKey) {\n    throw new ThinkHiveValidationError('API key is required', 'apiKey');\n  }\n\n  return apiRequest<{ success: boolean; error?: string; testTraceId?: string }>('/api-keys/test', {\n    method: 'POST',\n    body: { apiKey, agentId, createTestTrace: !!agentId },\n    apiVersion: 'v1',\n  });\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/**\n * Check if an API key has a specific permission\n */\nexport function hasPermission(\n  key: ApiKey,\n  permission: 'read' | 'write' | 'delete'\n): boolean {\n  // Handle object format\n  if (typeof key.permissions === 'object' && !Array.isArray(key.permissions)) {\n    return key.permissions[permission] === true;\n  }\n\n  // Handle legacy array format\n  if (Array.isArray(key.permissions)) {\n    return key.permissions.some(p => p.endsWith(`:${permission}`));\n  }\n\n  // Default: read allowed, write/delete denied\n  return permission === 'read';\n}\n\n/**\n * Check if an API key is expired\n */\nexport function isExpired(key: ApiKey): boolean {\n  if (!key.expiresAt) return false;\n  return new Date(key.expiresAt) < new Date();\n}\n\n/**\n * Check if an API key is valid (active and not expired)\n */\nexport function isValid(key: ApiKey): boolean {\n  return key.isActive && !isExpired(key);\n}\n\n/**\n * Get time until key expires (in milliseconds)\n * Returns null if key doesn't expire\n */\nexport function getTimeUntilExpiry(key: ApiKey): number | null {\n  if (!key.expiresAt) return null;\n  const expiry = new Date(key.expiresAt).getTime();\n  const now = Date.now();\n  return Math.max(0, expiry - now);\n}\n\n/**\n * Check if a key can access a specific agent\n */\nexport function canAccessAgent(key: ApiKey, agentId: string): boolean {\n  // If no agent restrictions, allow all\n  if (!key.allowedAgentIds || key.allowedAgentIds.length === 0) {\n    return true;\n  }\n  return key.allowedAgentIds.includes(agentId);\n}\n\n// ============================================================================\n// Export namespace\n// ============================================================================\n\nexport const apiKeys = {\n  create,\n  list,\n  revoke,\n  rotate,\n  test,\n  hasPermission,\n  isExpired,\n  isValid,\n  getTimeUntilExpiry,\n  canAccessAgent,\n};\n"]}