@kya-os/checkpoint-shared 1.3.0 → 1.3.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +19 -0
- package/dist/beacon-types/index.d.mts +3 -1
- package/dist/beacon-types/index.d.ts +3 -1
- package/dist/beacon-types/index.js +15 -2
- package/dist/beacon-types/index.mjs +15 -2
- package/dist/browser-posture-report.d.mts +85 -0
- package/dist/browser-posture-report.d.ts +85 -0
- package/dist/browser-posture-report.js +1 -0
- package/dist/browser-posture-report.mjs +1 -0
- package/dist/browser-posture.d.mts +114 -0
- package/dist/browser-posture.d.ts +114 -0
- package/dist/browser-posture.js +4204 -0
- package/dist/browser-posture.mjs +4187 -0
- package/dist/browser.d.mts +30 -1
- package/dist/browser.d.ts +30 -1
- package/dist/browser.js +1 -1
- package/dist/browser.mjs +1 -1
- package/dist/errors/index.d.mts +104 -0
- package/dist/errors/index.d.ts +104 -0
- package/dist/errors/index.js +338 -0
- package/dist/errors/index.mjs +333 -0
- package/dist/gateway/index.d.mts +6 -1
- package/dist/gateway/index.d.ts +6 -1
- package/dist/gateway/index.js +4 -0
- package/dist/gateway/index.mjs +4 -1
- package/dist/index.d.mts +769 -146
- package/dist/index.d.ts +769 -146
- package/dist/index.js +926 -282
- package/dist/index.mjs +903 -283
- package/dist/signals/index.d.mts +1 -1
- package/dist/signals/index.d.ts +1 -1
- package/dist/signals/index.js +95 -2
- package/dist/signals/index.mjs +95 -2
- package/fixtures/client-ip-resolution.json +103 -0
- package/fixtures/detection/reason-codes.json +35 -0
- package/fixtures/detection/signal-exposure-example.json +62 -0
- package/fixtures/kya-http/README.md +112 -0
- package/fixtures/kya-http/challenge-proof.canonical.json +25 -0
- package/fixtures/kya-http/challenge.approval-quorum.json +37 -0
- package/fixtures/kya-http/challenge.delegation.fetcher-200.json +55 -0
- package/fixtures/kya-http/challenge.delegation.full.json +81 -0
- package/fixtures/kya-http/challenge.delegation.minimal.json +57 -0
- package/fixtures/kya-http/error-codes.json +35 -0
- package/fixtures/kya-http/fetcher-200-predicate.vectors.json +72 -0
- package/fixtures/kya-http/negative.challenges.json +54 -0
- package/fixtures/kya-http/pickup.transcript.json +96 -0
- package/fixtures/kya-http/pickup.transcript.quorum.json +156 -0
- package/fixtures/kya-http/protected-resource-metadata.full.json +30 -0
- package/fixtures/kya-http/protected-resource-metadata.global.json +28 -0
- package/fixtures/kya-http/registration.request.json +33 -0
- package/fixtures/kya-http/registration.response.json +32 -0
- package/package.json +20 -2
|
@@ -0,0 +1,338 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
// src/constants/errors.ts
|
|
4
|
+
var AUTH_ERRORS = {
|
|
5
|
+
INVALID_API_KEY: "AUTH_INVALID_API_KEY",
|
|
6
|
+
EXPIRED_API_KEY: "AUTH_EXPIRED_API_KEY",
|
|
7
|
+
INVALID_TOKEN: "AUTH_INVALID_TOKEN",
|
|
8
|
+
EXPIRED_TOKEN: "AUTH_EXPIRED_TOKEN",
|
|
9
|
+
MISSING_CREDENTIALS: "AUTH_MISSING_CREDENTIALS",
|
|
10
|
+
UNAUTHORIZED: "AUTH_UNAUTHORIZED",
|
|
11
|
+
INVALID_PIXEL_ID: "AUTH_INVALID_PIXEL_ID",
|
|
12
|
+
INVALID_SECRET_KEY: "AUTH_INVALID_SECRET_KEY"
|
|
13
|
+
};
|
|
14
|
+
var VALIDATION_ERRORS = {
|
|
15
|
+
INVALID_REQUEST: "VALIDATION_INVALID_REQUEST",
|
|
16
|
+
MISSING_REQUIRED_FIELD: "VALIDATION_MISSING_REQUIRED_FIELD",
|
|
17
|
+
INVALID_FIELD_TYPE: "VALIDATION_INVALID_FIELD_TYPE",
|
|
18
|
+
INVALID_FIELD_VALUE: "VALIDATION_INVALID_FIELD_VALUE",
|
|
19
|
+
FIELD_TOO_LONG: "VALIDATION_FIELD_TOO_LONG",
|
|
20
|
+
FIELD_TOO_SHORT: "VALIDATION_FIELD_TOO_SHORT",
|
|
21
|
+
INVALID_EMAIL: "VALIDATION_INVALID_EMAIL",
|
|
22
|
+
INVALID_URL: "VALIDATION_INVALID_URL",
|
|
23
|
+
INVALID_UUID: "VALIDATION_INVALID_UUID",
|
|
24
|
+
INVALID_IP_ADDRESS: "VALIDATION_INVALID_IP_ADDRESS",
|
|
25
|
+
INVALID_USER_AGENT: "VALIDATION_INVALID_USER_AGENT",
|
|
26
|
+
BAD_REQUEST: "VALIDATION_BAD_REQUEST",
|
|
27
|
+
INVALID_START_DATE: "VALIDATION_INVALID_START_DATE",
|
|
28
|
+
INVALID_END_DATE: "VALIDATION_INVALID_END_DATE",
|
|
29
|
+
INVALID_DATE_RANGE: "VALIDATION_INVALID_DATE_RANGE"
|
|
30
|
+
};
|
|
31
|
+
var DETECTION_ERRORS = {
|
|
32
|
+
DETECTION_FAILED: "DETECTION_FAILED",
|
|
33
|
+
INSUFFICIENT_DATA: "DETECTION_INSUFFICIENT_DATA",
|
|
34
|
+
PATTERN_MATCH_FAILED: "DETECTION_PATTERN_MATCH_FAILED",
|
|
35
|
+
WASM_NOT_LOADED: "DETECTION_WASM_NOT_LOADED",
|
|
36
|
+
WASM_EXECUTION_FAILED: "DETECTION_WASM_EXECUTION_FAILED",
|
|
37
|
+
CONFIDENCE_BELOW_THRESHOLD: "DETECTION_CONFIDENCE_BELOW_THRESHOLD",
|
|
38
|
+
SIGNATURE_VERIFICATION_FAILED: "DETECTION_SIGNATURE_VERIFICATION_FAILED"
|
|
39
|
+
};
|
|
40
|
+
var RATE_LIMIT_ERRORS = {
|
|
41
|
+
RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
|
|
42
|
+
BURST_LIMIT_EXCEEDED: "RATE_LIMIT_BURST_EXCEEDED",
|
|
43
|
+
DAILY_LIMIT_EXCEEDED: "RATE_LIMIT_DAILY_EXCEEDED",
|
|
44
|
+
MONTHLY_LIMIT_EXCEEDED: "RATE_LIMIT_MONTHLY_EXCEEDED",
|
|
45
|
+
CONCURRENT_LIMIT_EXCEEDED: "RATE_LIMIT_CONCURRENT_EXCEEDED",
|
|
46
|
+
QUOTA_EXCEEDED: "RATE_LIMIT_QUOTA_EXCEEDED"
|
|
47
|
+
};
|
|
48
|
+
var PERMISSION_ERRORS = {
|
|
49
|
+
INSUFFICIENT_PERMISSIONS: "PERMISSION_INSUFFICIENT",
|
|
50
|
+
RESOURCE_NOT_FOUND: "PERMISSION_RESOURCE_NOT_FOUND",
|
|
51
|
+
RESOURCE_ACCESS_DENIED: "PERMISSION_ACCESS_DENIED",
|
|
52
|
+
OPERATION_NOT_ALLOWED: "PERMISSION_OPERATION_NOT_ALLOWED",
|
|
53
|
+
PROJECT_ACCESS_DENIED: "PERMISSION_PROJECT_ACCESS_DENIED",
|
|
54
|
+
PIXEL_ACCESS_DENIED: "PERMISSION_PIXEL_ACCESS_DENIED",
|
|
55
|
+
FORBIDDEN: "PERMISSION_FORBIDDEN"
|
|
56
|
+
};
|
|
57
|
+
var NETWORK_ERRORS = {
|
|
58
|
+
CONNECTION_FAILED: "NETWORK_CONNECTION_FAILED",
|
|
59
|
+
TIMEOUT: "NETWORK_TIMEOUT",
|
|
60
|
+
DNS_RESOLUTION_FAILED: "NETWORK_DNS_FAILED",
|
|
61
|
+
SSL_ERROR: "NETWORK_SSL_ERROR",
|
|
62
|
+
PROXY_ERROR: "NETWORK_PROXY_ERROR",
|
|
63
|
+
UPSTREAM_ERROR: "NETWORK_UPSTREAM_ERROR"
|
|
64
|
+
};
|
|
65
|
+
var INTERNAL_ERRORS = {
|
|
66
|
+
INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
|
|
67
|
+
DATABASE_ERROR: "INTERNAL_DATABASE_ERROR",
|
|
68
|
+
CACHE_ERROR: "INTERNAL_CACHE_ERROR",
|
|
69
|
+
CONFIGURATION_ERROR: "INTERNAL_CONFIGURATION_ERROR",
|
|
70
|
+
INITIALIZATION_ERROR: "INTERNAL_INITIALIZATION_ERROR",
|
|
71
|
+
PROCESSING_ERROR: "INTERNAL_PROCESSING_ERROR",
|
|
72
|
+
UNKNOWN_ERROR: "INTERNAL_UNKNOWN_ERROR",
|
|
73
|
+
SERVICE_UNAVAILABLE_TRANSIENT: "SERVICE_UNAVAILABLE_TRANSIENT"
|
|
74
|
+
};
|
|
75
|
+
var SESSION_ERRORS = {
|
|
76
|
+
SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
|
|
77
|
+
SESSION_EXPIRED: "SESSION_EXPIRED",
|
|
78
|
+
SESSION_INVALID: "SESSION_INVALID",
|
|
79
|
+
SESSION_CREATION_FAILED: "SESSION_CREATION_FAILED",
|
|
80
|
+
SESSION_UPDATE_FAILED: "SESSION_UPDATE_FAILED",
|
|
81
|
+
SESSION_STORAGE_ERROR: "SESSION_STORAGE_ERROR",
|
|
82
|
+
MAX_SESSIONS_EXCEEDED: "SESSION_MAX_EXCEEDED"
|
|
83
|
+
};
|
|
84
|
+
var PIXEL_ERRORS = {
|
|
85
|
+
PIXEL_NOT_FOUND: "PIXEL_NOT_FOUND",
|
|
86
|
+
PIXEL_DISABLED: "PIXEL_DISABLED",
|
|
87
|
+
PIXEL_CONFIGURATION_ERROR: "PIXEL_CONFIGURATION_ERROR",
|
|
88
|
+
PIXEL_DOMAIN_NOT_ALLOWED: "PIXEL_DOMAIN_NOT_ALLOWED",
|
|
89
|
+
PIXEL_PATH_SKIPPED: "PIXEL_PATH_SKIPPED",
|
|
90
|
+
PIXEL_EVENT_INVALID: "PIXEL_EVENT_INVALID",
|
|
91
|
+
PIXEL_BATCH_TOO_LARGE: "PIXEL_BATCH_TOO_LARGE",
|
|
92
|
+
MISSING_PIXEL_ID: "MISSING_PIXEL_ID",
|
|
93
|
+
INVALID_EDGE_SIGNATURE: "INVALID_EDGE_SIGNATURE",
|
|
94
|
+
DETECTION_STORAGE_FAILED: "DETECTION_STORAGE_FAILED"
|
|
95
|
+
};
|
|
96
|
+
var API_ERRORS = {
|
|
97
|
+
ENDPOINT_NOT_FOUND: "API_ENDPOINT_NOT_FOUND",
|
|
98
|
+
METHOD_NOT_ALLOWED: "API_METHOD_NOT_ALLOWED",
|
|
99
|
+
VERSION_NOT_SUPPORTED: "API_VERSION_NOT_SUPPORTED",
|
|
100
|
+
CONTENT_TYPE_NOT_SUPPORTED: "API_CONTENT_TYPE_NOT_SUPPORTED",
|
|
101
|
+
RESPONSE_TOO_LARGE: "API_RESPONSE_TOO_LARGE",
|
|
102
|
+
REQUEST_TOO_LARGE: "API_REQUEST_TOO_LARGE"
|
|
103
|
+
};
|
|
104
|
+
var BILLING_ERRORS = {
|
|
105
|
+
LIMIT_EXCEEDED: "LIMIT_EXCEEDED",
|
|
106
|
+
BILLING_SUSPENDED: "BILLING_SUSPENDED",
|
|
107
|
+
BILLING_GRACE_PERIOD: "BILLING_GRACE_PERIOD"
|
|
108
|
+
};
|
|
109
|
+
var RESOURCE_ERRORS = {
|
|
110
|
+
CONFLICT: "CONFLICT",
|
|
111
|
+
PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
|
|
112
|
+
REVIEW_REQUIRED: "REVIEW_REQUIRED"
|
|
113
|
+
};
|
|
114
|
+
var POLICY_ERRORS = {
|
|
115
|
+
POLICY_FETCH_FAILED: "POLICY_FETCH_FAILED"
|
|
116
|
+
};
|
|
117
|
+
var BARE_ERRORS = {
|
|
118
|
+
BARE_VALIDATION_ERROR: "VALIDATION_ERROR",
|
|
119
|
+
BARE_INTERNAL_ERROR: "INTERNAL_ERROR"
|
|
120
|
+
};
|
|
121
|
+
var LOWERCASE_ERRORS = {
|
|
122
|
+
LOWERCASE_INVALID_JSON: "invalid_json",
|
|
123
|
+
LOWERCASE_VALIDATION_ERROR: "validation_error"
|
|
124
|
+
};
|
|
125
|
+
var ERROR_CODES = {
|
|
126
|
+
...AUTH_ERRORS,
|
|
127
|
+
...VALIDATION_ERRORS,
|
|
128
|
+
...DETECTION_ERRORS,
|
|
129
|
+
...RATE_LIMIT_ERRORS,
|
|
130
|
+
...PERMISSION_ERRORS,
|
|
131
|
+
...NETWORK_ERRORS,
|
|
132
|
+
...INTERNAL_ERRORS,
|
|
133
|
+
...SESSION_ERRORS,
|
|
134
|
+
...PIXEL_ERRORS,
|
|
135
|
+
...API_ERRORS,
|
|
136
|
+
...BILLING_ERRORS,
|
|
137
|
+
...RESOURCE_ERRORS,
|
|
138
|
+
...POLICY_ERRORS,
|
|
139
|
+
...BARE_ERRORS,
|
|
140
|
+
...LOWERCASE_ERRORS
|
|
141
|
+
};
|
|
142
|
+
var ERROR_MESSAGES = {
|
|
143
|
+
// Authentication
|
|
144
|
+
[AUTH_ERRORS.INVALID_API_KEY]: "The provided API key is invalid",
|
|
145
|
+
[AUTH_ERRORS.EXPIRED_API_KEY]: "The API key has expired",
|
|
146
|
+
[AUTH_ERRORS.INVALID_TOKEN]: "The provided token is invalid",
|
|
147
|
+
[AUTH_ERRORS.EXPIRED_TOKEN]: "The token has expired",
|
|
148
|
+
[AUTH_ERRORS.MISSING_CREDENTIALS]: "Authentication credentials are required",
|
|
149
|
+
[AUTH_ERRORS.UNAUTHORIZED]: "You are not authorized to perform this action",
|
|
150
|
+
[AUTH_ERRORS.INVALID_PIXEL_ID]: "The provided pixel ID is invalid",
|
|
151
|
+
[AUTH_ERRORS.INVALID_SECRET_KEY]: "The provided secret key is invalid",
|
|
152
|
+
// Validation
|
|
153
|
+
[VALIDATION_ERRORS.INVALID_REQUEST]: "The request is invalid",
|
|
154
|
+
[VALIDATION_ERRORS.MISSING_REQUIRED_FIELD]: "A required field is missing",
|
|
155
|
+
[VALIDATION_ERRORS.INVALID_FIELD_TYPE]: "Field type is invalid",
|
|
156
|
+
[VALIDATION_ERRORS.INVALID_FIELD_VALUE]: "Field value is invalid",
|
|
157
|
+
[VALIDATION_ERRORS.FIELD_TOO_LONG]: "Field value exceeds maximum length",
|
|
158
|
+
[VALIDATION_ERRORS.FIELD_TOO_SHORT]: "Field value is below minimum length",
|
|
159
|
+
[VALIDATION_ERRORS.INVALID_EMAIL]: "Invalid email address format",
|
|
160
|
+
[VALIDATION_ERRORS.INVALID_URL]: "Invalid URL format",
|
|
161
|
+
[VALIDATION_ERRORS.INVALID_UUID]: "Invalid UUID format",
|
|
162
|
+
[VALIDATION_ERRORS.INVALID_IP_ADDRESS]: "Invalid IP address format",
|
|
163
|
+
[VALIDATION_ERRORS.INVALID_USER_AGENT]: "Invalid or missing user agent",
|
|
164
|
+
[VALIDATION_ERRORS.BAD_REQUEST]: "Bad request",
|
|
165
|
+
[VALIDATION_ERRORS.INVALID_START_DATE]: "Invalid request data",
|
|
166
|
+
[VALIDATION_ERRORS.INVALID_END_DATE]: "Invalid request data",
|
|
167
|
+
[VALIDATION_ERRORS.INVALID_DATE_RANGE]: "Invalid request data",
|
|
168
|
+
// Detection
|
|
169
|
+
[DETECTION_ERRORS.DETECTION_FAILED]: "Agent detection failed",
|
|
170
|
+
[DETECTION_ERRORS.INSUFFICIENT_DATA]: "Insufficient data for detection",
|
|
171
|
+
[DETECTION_ERRORS.PATTERN_MATCH_FAILED]: "Pattern matching failed",
|
|
172
|
+
[DETECTION_ERRORS.WASM_NOT_LOADED]: "WASM module is not loaded",
|
|
173
|
+
[DETECTION_ERRORS.WASM_EXECUTION_FAILED]: "WASM execution failed",
|
|
174
|
+
[DETECTION_ERRORS.CONFIDENCE_BELOW_THRESHOLD]: "Detection confidence below threshold",
|
|
175
|
+
[DETECTION_ERRORS.SIGNATURE_VERIFICATION_FAILED]: "Signature verification failed",
|
|
176
|
+
// Rate Limiting
|
|
177
|
+
[RATE_LIMIT_ERRORS.RATE_LIMIT_EXCEEDED]: "Rate limit exceeded",
|
|
178
|
+
[RATE_LIMIT_ERRORS.BURST_LIMIT_EXCEEDED]: "Burst limit exceeded",
|
|
179
|
+
[RATE_LIMIT_ERRORS.DAILY_LIMIT_EXCEEDED]: "Daily request limit exceeded",
|
|
180
|
+
[RATE_LIMIT_ERRORS.MONTHLY_LIMIT_EXCEEDED]: "Monthly request limit exceeded",
|
|
181
|
+
[RATE_LIMIT_ERRORS.CONCURRENT_LIMIT_EXCEEDED]: "Concurrent request limit exceeded",
|
|
182
|
+
[RATE_LIMIT_ERRORS.QUOTA_EXCEEDED]: "Account quota exceeded",
|
|
183
|
+
// Permissions
|
|
184
|
+
[PERMISSION_ERRORS.INSUFFICIENT_PERMISSIONS]: "Insufficient permissions",
|
|
185
|
+
[PERMISSION_ERRORS.RESOURCE_NOT_FOUND]: "Resource not found",
|
|
186
|
+
[PERMISSION_ERRORS.RESOURCE_ACCESS_DENIED]: "Access to resource denied",
|
|
187
|
+
[PERMISSION_ERRORS.OPERATION_NOT_ALLOWED]: "Operation not allowed",
|
|
188
|
+
[PERMISSION_ERRORS.PROJECT_ACCESS_DENIED]: "Project access denied",
|
|
189
|
+
[PERMISSION_ERRORS.PIXEL_ACCESS_DENIED]: "Pixel access denied",
|
|
190
|
+
[PERMISSION_ERRORS.FORBIDDEN]: "Access denied",
|
|
191
|
+
// Network
|
|
192
|
+
[NETWORK_ERRORS.CONNECTION_FAILED]: "Connection failed",
|
|
193
|
+
[NETWORK_ERRORS.TIMEOUT]: "Request timeout",
|
|
194
|
+
[NETWORK_ERRORS.DNS_RESOLUTION_FAILED]: "DNS resolution failed",
|
|
195
|
+
[NETWORK_ERRORS.SSL_ERROR]: "SSL/TLS error",
|
|
196
|
+
[NETWORK_ERRORS.PROXY_ERROR]: "Proxy error",
|
|
197
|
+
[NETWORK_ERRORS.UPSTREAM_ERROR]: "Upstream service error",
|
|
198
|
+
// Internal
|
|
199
|
+
[INTERNAL_ERRORS.INTERNAL_SERVER_ERROR]: "Internal server error",
|
|
200
|
+
[INTERNAL_ERRORS.DATABASE_ERROR]: "Database error",
|
|
201
|
+
[INTERNAL_ERRORS.CACHE_ERROR]: "Cache error",
|
|
202
|
+
[INTERNAL_ERRORS.CONFIGURATION_ERROR]: "Configuration error",
|
|
203
|
+
[INTERNAL_ERRORS.INITIALIZATION_ERROR]: "Initialization error",
|
|
204
|
+
[INTERNAL_ERRORS.PROCESSING_ERROR]: "Processing error",
|
|
205
|
+
[INTERNAL_ERRORS.UNKNOWN_ERROR]: "An unknown error occurred",
|
|
206
|
+
[INTERNAL_ERRORS.SERVICE_UNAVAILABLE_TRANSIENT]: "A dependency is temporarily unavailable. Retry shortly.",
|
|
207
|
+
// Session
|
|
208
|
+
[SESSION_ERRORS.SESSION_NOT_FOUND]: "Session not found",
|
|
209
|
+
[SESSION_ERRORS.SESSION_EXPIRED]: "Session has expired",
|
|
210
|
+
[SESSION_ERRORS.SESSION_INVALID]: "Session is invalid",
|
|
211
|
+
[SESSION_ERRORS.SESSION_CREATION_FAILED]: "Failed to create session",
|
|
212
|
+
[SESSION_ERRORS.SESSION_UPDATE_FAILED]: "Failed to update session",
|
|
213
|
+
[SESSION_ERRORS.SESSION_STORAGE_ERROR]: "Session storage error",
|
|
214
|
+
[SESSION_ERRORS.MAX_SESSIONS_EXCEEDED]: "Maximum sessions exceeded",
|
|
215
|
+
// Pixel
|
|
216
|
+
[PIXEL_ERRORS.PIXEL_NOT_FOUND]: "Pixel not found",
|
|
217
|
+
[PIXEL_ERRORS.PIXEL_DISABLED]: "Pixel is disabled",
|
|
218
|
+
[PIXEL_ERRORS.PIXEL_CONFIGURATION_ERROR]: "Pixel configuration error",
|
|
219
|
+
[PIXEL_ERRORS.PIXEL_DOMAIN_NOT_ALLOWED]: "Domain not allowed for this pixel",
|
|
220
|
+
[PIXEL_ERRORS.PIXEL_PATH_SKIPPED]: "Path is configured to be skipped",
|
|
221
|
+
[PIXEL_ERRORS.PIXEL_EVENT_INVALID]: "Invalid pixel event",
|
|
222
|
+
[PIXEL_ERRORS.PIXEL_BATCH_TOO_LARGE]: "Event batch exceeds maximum size",
|
|
223
|
+
[PIXEL_ERRORS.MISSING_PIXEL_ID]: "Project ID is required",
|
|
224
|
+
[PIXEL_ERRORS.INVALID_EDGE_SIGNATURE]: "Invalid request signature",
|
|
225
|
+
[PIXEL_ERRORS.DETECTION_STORAGE_FAILED]: "Failed to store detection data",
|
|
226
|
+
// API
|
|
227
|
+
[API_ERRORS.ENDPOINT_NOT_FOUND]: "API endpoint not found",
|
|
228
|
+
[API_ERRORS.METHOD_NOT_ALLOWED]: "HTTP method not allowed",
|
|
229
|
+
[API_ERRORS.VERSION_NOT_SUPPORTED]: "API version not supported",
|
|
230
|
+
[API_ERRORS.CONTENT_TYPE_NOT_SUPPORTED]: "Content type not supported",
|
|
231
|
+
[API_ERRORS.RESPONSE_TOO_LARGE]: "Response exceeds maximum size",
|
|
232
|
+
[API_ERRORS.REQUEST_TOO_LARGE]: "Request exceeds maximum size",
|
|
233
|
+
// Billing
|
|
234
|
+
[BILLING_ERRORS.LIMIT_EXCEEDED]: "Billing limit exceeded",
|
|
235
|
+
[BILLING_ERRORS.BILLING_SUSPENDED]: "Account billing suspended",
|
|
236
|
+
[BILLING_ERRORS.BILLING_GRACE_PERIOD]: "Account in billing grace period",
|
|
237
|
+
// Resources
|
|
238
|
+
[RESOURCE_ERRORS.CONFLICT]: "Resource conflict",
|
|
239
|
+
[RESOURCE_ERRORS.PROJECT_NOT_FOUND]: "Project not found",
|
|
240
|
+
[RESOURCE_ERRORS.REVIEW_REQUIRED]: "Deploy requires explicit confirmation of the consequential writes it will perform.",
|
|
241
|
+
// Policy
|
|
242
|
+
[POLICY_ERRORS.POLICY_FETCH_FAILED]: "Failed to fetch policy",
|
|
243
|
+
// Bare (un-prefixed, shared across pixel/openclaw/deploy/shopify/bouncer)
|
|
244
|
+
[BARE_ERRORS.BARE_VALIDATION_ERROR]: "Invalid request data",
|
|
245
|
+
[BARE_ERRORS.BARE_INTERNAL_ERROR]: "Internal server error",
|
|
246
|
+
// Lowercase (kya-os events wire format)
|
|
247
|
+
[LOWERCASE_ERRORS.LOWERCASE_INVALID_JSON]: "Request body must be valid JSON",
|
|
248
|
+
[LOWERCASE_ERRORS.LOWERCASE_VALIDATION_ERROR]: "Invalid request body"
|
|
249
|
+
};
|
|
250
|
+
var ERROR_STATUS_CODES = {
|
|
251
|
+
// 200 OK (billing grace period is a soft warning, not a failure)
|
|
252
|
+
[BILLING_ERRORS.BILLING_GRACE_PERIOD]: 200,
|
|
253
|
+
// 400 Bad Request
|
|
254
|
+
[VALIDATION_ERRORS.INVALID_REQUEST]: 400,
|
|
255
|
+
[VALIDATION_ERRORS.MISSING_REQUIRED_FIELD]: 400,
|
|
256
|
+
[VALIDATION_ERRORS.INVALID_FIELD_TYPE]: 400,
|
|
257
|
+
[VALIDATION_ERRORS.INVALID_FIELD_VALUE]: 400,
|
|
258
|
+
[VALIDATION_ERRORS.BAD_REQUEST]: 400,
|
|
259
|
+
[VALIDATION_ERRORS.INVALID_START_DATE]: 400,
|
|
260
|
+
[VALIDATION_ERRORS.INVALID_END_DATE]: 400,
|
|
261
|
+
[VALIDATION_ERRORS.INVALID_DATE_RANGE]: 400,
|
|
262
|
+
[PIXEL_ERRORS.MISSING_PIXEL_ID]: 400,
|
|
263
|
+
[BARE_ERRORS.BARE_VALIDATION_ERROR]: 400,
|
|
264
|
+
[LOWERCASE_ERRORS.LOWERCASE_INVALID_JSON]: 400,
|
|
265
|
+
[LOWERCASE_ERRORS.LOWERCASE_VALIDATION_ERROR]: 400,
|
|
266
|
+
// 401 Unauthorized
|
|
267
|
+
[AUTH_ERRORS.INVALID_API_KEY]: 401,
|
|
268
|
+
[AUTH_ERRORS.EXPIRED_API_KEY]: 401,
|
|
269
|
+
[AUTH_ERRORS.INVALID_TOKEN]: 401,
|
|
270
|
+
[AUTH_ERRORS.EXPIRED_TOKEN]: 401,
|
|
271
|
+
[AUTH_ERRORS.MISSING_CREDENTIALS]: 401,
|
|
272
|
+
[AUTH_ERRORS.UNAUTHORIZED]: 401,
|
|
273
|
+
// 402 Payment Required
|
|
274
|
+
[BILLING_ERRORS.LIMIT_EXCEEDED]: 402,
|
|
275
|
+
[BILLING_ERRORS.BILLING_SUSPENDED]: 402,
|
|
276
|
+
// 403 Forbidden
|
|
277
|
+
[PERMISSION_ERRORS.INSUFFICIENT_PERMISSIONS]: 403,
|
|
278
|
+
[PERMISSION_ERRORS.RESOURCE_ACCESS_DENIED]: 403,
|
|
279
|
+
[PERMISSION_ERRORS.OPERATION_NOT_ALLOWED]: 403,
|
|
280
|
+
[PERMISSION_ERRORS.FORBIDDEN]: 403,
|
|
281
|
+
[PIXEL_ERRORS.INVALID_EDGE_SIGNATURE]: 403,
|
|
282
|
+
// 404 Not Found
|
|
283
|
+
[PERMISSION_ERRORS.RESOURCE_NOT_FOUND]: 404,
|
|
284
|
+
[API_ERRORS.ENDPOINT_NOT_FOUND]: 404,
|
|
285
|
+
[PIXEL_ERRORS.PIXEL_NOT_FOUND]: 404,
|
|
286
|
+
[SESSION_ERRORS.SESSION_NOT_FOUND]: 404,
|
|
287
|
+
// 405 Method Not Allowed
|
|
288
|
+
[API_ERRORS.METHOD_NOT_ALLOWED]: 405,
|
|
289
|
+
// 409 Conflict
|
|
290
|
+
[RESOURCE_ERRORS.CONFLICT]: 409,
|
|
291
|
+
// NOTE: RESOURCE_ERRORS.PROJECT_NOT_FOUND deliberately has no entry here.
|
|
292
|
+
// The pixel API emits it with 400, while enforce and the policy
|
|
293
|
+
// middleware emit it with 404. There is no single correct status, so it
|
|
294
|
+
// stays unpinned and callers set their own status per surface. Locked by
|
|
295
|
+
// a test in __tests__/errors.test.ts.
|
|
296
|
+
// 413 Payload Too Large
|
|
297
|
+
[API_ERRORS.REQUEST_TOO_LARGE]: 413,
|
|
298
|
+
[PIXEL_ERRORS.PIXEL_BATCH_TOO_LARGE]: 413,
|
|
299
|
+
// 415 Unsupported Media Type
|
|
300
|
+
[API_ERRORS.CONTENT_TYPE_NOT_SUPPORTED]: 415,
|
|
301
|
+
// 422 Unprocessable Entity
|
|
302
|
+
[RESOURCE_ERRORS.REVIEW_REQUIRED]: 422,
|
|
303
|
+
// 429 Too Many Requests
|
|
304
|
+
[RATE_LIMIT_ERRORS.RATE_LIMIT_EXCEEDED]: 429,
|
|
305
|
+
[RATE_LIMIT_ERRORS.BURST_LIMIT_EXCEEDED]: 429,
|
|
306
|
+
[RATE_LIMIT_ERRORS.DAILY_LIMIT_EXCEEDED]: 429,
|
|
307
|
+
// 500 Internal Server Error
|
|
308
|
+
[INTERNAL_ERRORS.INTERNAL_SERVER_ERROR]: 500,
|
|
309
|
+
[INTERNAL_ERRORS.DATABASE_ERROR]: 500,
|
|
310
|
+
[INTERNAL_ERRORS.PROCESSING_ERROR]: 500,
|
|
311
|
+
[PIXEL_ERRORS.DETECTION_STORAGE_FAILED]: 500,
|
|
312
|
+
[POLICY_ERRORS.POLICY_FETCH_FAILED]: 500,
|
|
313
|
+
[BARE_ERRORS.BARE_INTERNAL_ERROR]: 500,
|
|
314
|
+
// 502 Bad Gateway
|
|
315
|
+
[NETWORK_ERRORS.UPSTREAM_ERROR]: 502,
|
|
316
|
+
// 503 Service Unavailable
|
|
317
|
+
[INTERNAL_ERRORS.INITIALIZATION_ERROR]: 503,
|
|
318
|
+
[INTERNAL_ERRORS.SERVICE_UNAVAILABLE_TRANSIENT]: 503,
|
|
319
|
+
// 504 Gateway Timeout
|
|
320
|
+
[NETWORK_ERRORS.TIMEOUT]: 504
|
|
321
|
+
};
|
|
322
|
+
|
|
323
|
+
// src/constants/pick-error-codes.ts
|
|
324
|
+
function pickErrorCodes(keys) {
|
|
325
|
+
const picked = {};
|
|
326
|
+
for (const key of keys) {
|
|
327
|
+
if (!(key in ERROR_CODES)) {
|
|
328
|
+
throw new Error(`pickErrorCodes: unknown error code key "${String(key)}"`);
|
|
329
|
+
}
|
|
330
|
+
picked[key] = ERROR_CODES[key];
|
|
331
|
+
}
|
|
332
|
+
return Object.freeze(picked);
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
exports.ERROR_CODES = ERROR_CODES;
|
|
336
|
+
exports.ERROR_MESSAGES = ERROR_MESSAGES;
|
|
337
|
+
exports.ERROR_STATUS_CODES = ERROR_STATUS_CODES;
|
|
338
|
+
exports.pickErrorCodes = pickErrorCodes;
|
|
@@ -0,0 +1,333 @@
|
|
|
1
|
+
// src/constants/errors.ts
|
|
2
|
+
var AUTH_ERRORS = {
|
|
3
|
+
INVALID_API_KEY: "AUTH_INVALID_API_KEY",
|
|
4
|
+
EXPIRED_API_KEY: "AUTH_EXPIRED_API_KEY",
|
|
5
|
+
INVALID_TOKEN: "AUTH_INVALID_TOKEN",
|
|
6
|
+
EXPIRED_TOKEN: "AUTH_EXPIRED_TOKEN",
|
|
7
|
+
MISSING_CREDENTIALS: "AUTH_MISSING_CREDENTIALS",
|
|
8
|
+
UNAUTHORIZED: "AUTH_UNAUTHORIZED",
|
|
9
|
+
INVALID_PIXEL_ID: "AUTH_INVALID_PIXEL_ID",
|
|
10
|
+
INVALID_SECRET_KEY: "AUTH_INVALID_SECRET_KEY"
|
|
11
|
+
};
|
|
12
|
+
var VALIDATION_ERRORS = {
|
|
13
|
+
INVALID_REQUEST: "VALIDATION_INVALID_REQUEST",
|
|
14
|
+
MISSING_REQUIRED_FIELD: "VALIDATION_MISSING_REQUIRED_FIELD",
|
|
15
|
+
INVALID_FIELD_TYPE: "VALIDATION_INVALID_FIELD_TYPE",
|
|
16
|
+
INVALID_FIELD_VALUE: "VALIDATION_INVALID_FIELD_VALUE",
|
|
17
|
+
FIELD_TOO_LONG: "VALIDATION_FIELD_TOO_LONG",
|
|
18
|
+
FIELD_TOO_SHORT: "VALIDATION_FIELD_TOO_SHORT",
|
|
19
|
+
INVALID_EMAIL: "VALIDATION_INVALID_EMAIL",
|
|
20
|
+
INVALID_URL: "VALIDATION_INVALID_URL",
|
|
21
|
+
INVALID_UUID: "VALIDATION_INVALID_UUID",
|
|
22
|
+
INVALID_IP_ADDRESS: "VALIDATION_INVALID_IP_ADDRESS",
|
|
23
|
+
INVALID_USER_AGENT: "VALIDATION_INVALID_USER_AGENT",
|
|
24
|
+
BAD_REQUEST: "VALIDATION_BAD_REQUEST",
|
|
25
|
+
INVALID_START_DATE: "VALIDATION_INVALID_START_DATE",
|
|
26
|
+
INVALID_END_DATE: "VALIDATION_INVALID_END_DATE",
|
|
27
|
+
INVALID_DATE_RANGE: "VALIDATION_INVALID_DATE_RANGE"
|
|
28
|
+
};
|
|
29
|
+
var DETECTION_ERRORS = {
|
|
30
|
+
DETECTION_FAILED: "DETECTION_FAILED",
|
|
31
|
+
INSUFFICIENT_DATA: "DETECTION_INSUFFICIENT_DATA",
|
|
32
|
+
PATTERN_MATCH_FAILED: "DETECTION_PATTERN_MATCH_FAILED",
|
|
33
|
+
WASM_NOT_LOADED: "DETECTION_WASM_NOT_LOADED",
|
|
34
|
+
WASM_EXECUTION_FAILED: "DETECTION_WASM_EXECUTION_FAILED",
|
|
35
|
+
CONFIDENCE_BELOW_THRESHOLD: "DETECTION_CONFIDENCE_BELOW_THRESHOLD",
|
|
36
|
+
SIGNATURE_VERIFICATION_FAILED: "DETECTION_SIGNATURE_VERIFICATION_FAILED"
|
|
37
|
+
};
|
|
38
|
+
var RATE_LIMIT_ERRORS = {
|
|
39
|
+
RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
|
|
40
|
+
BURST_LIMIT_EXCEEDED: "RATE_LIMIT_BURST_EXCEEDED",
|
|
41
|
+
DAILY_LIMIT_EXCEEDED: "RATE_LIMIT_DAILY_EXCEEDED",
|
|
42
|
+
MONTHLY_LIMIT_EXCEEDED: "RATE_LIMIT_MONTHLY_EXCEEDED",
|
|
43
|
+
CONCURRENT_LIMIT_EXCEEDED: "RATE_LIMIT_CONCURRENT_EXCEEDED",
|
|
44
|
+
QUOTA_EXCEEDED: "RATE_LIMIT_QUOTA_EXCEEDED"
|
|
45
|
+
};
|
|
46
|
+
var PERMISSION_ERRORS = {
|
|
47
|
+
INSUFFICIENT_PERMISSIONS: "PERMISSION_INSUFFICIENT",
|
|
48
|
+
RESOURCE_NOT_FOUND: "PERMISSION_RESOURCE_NOT_FOUND",
|
|
49
|
+
RESOURCE_ACCESS_DENIED: "PERMISSION_ACCESS_DENIED",
|
|
50
|
+
OPERATION_NOT_ALLOWED: "PERMISSION_OPERATION_NOT_ALLOWED",
|
|
51
|
+
PROJECT_ACCESS_DENIED: "PERMISSION_PROJECT_ACCESS_DENIED",
|
|
52
|
+
PIXEL_ACCESS_DENIED: "PERMISSION_PIXEL_ACCESS_DENIED",
|
|
53
|
+
FORBIDDEN: "PERMISSION_FORBIDDEN"
|
|
54
|
+
};
|
|
55
|
+
var NETWORK_ERRORS = {
|
|
56
|
+
CONNECTION_FAILED: "NETWORK_CONNECTION_FAILED",
|
|
57
|
+
TIMEOUT: "NETWORK_TIMEOUT",
|
|
58
|
+
DNS_RESOLUTION_FAILED: "NETWORK_DNS_FAILED",
|
|
59
|
+
SSL_ERROR: "NETWORK_SSL_ERROR",
|
|
60
|
+
PROXY_ERROR: "NETWORK_PROXY_ERROR",
|
|
61
|
+
UPSTREAM_ERROR: "NETWORK_UPSTREAM_ERROR"
|
|
62
|
+
};
|
|
63
|
+
var INTERNAL_ERRORS = {
|
|
64
|
+
INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
|
|
65
|
+
DATABASE_ERROR: "INTERNAL_DATABASE_ERROR",
|
|
66
|
+
CACHE_ERROR: "INTERNAL_CACHE_ERROR",
|
|
67
|
+
CONFIGURATION_ERROR: "INTERNAL_CONFIGURATION_ERROR",
|
|
68
|
+
INITIALIZATION_ERROR: "INTERNAL_INITIALIZATION_ERROR",
|
|
69
|
+
PROCESSING_ERROR: "INTERNAL_PROCESSING_ERROR",
|
|
70
|
+
UNKNOWN_ERROR: "INTERNAL_UNKNOWN_ERROR",
|
|
71
|
+
SERVICE_UNAVAILABLE_TRANSIENT: "SERVICE_UNAVAILABLE_TRANSIENT"
|
|
72
|
+
};
|
|
73
|
+
var SESSION_ERRORS = {
|
|
74
|
+
SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
|
|
75
|
+
SESSION_EXPIRED: "SESSION_EXPIRED",
|
|
76
|
+
SESSION_INVALID: "SESSION_INVALID",
|
|
77
|
+
SESSION_CREATION_FAILED: "SESSION_CREATION_FAILED",
|
|
78
|
+
SESSION_UPDATE_FAILED: "SESSION_UPDATE_FAILED",
|
|
79
|
+
SESSION_STORAGE_ERROR: "SESSION_STORAGE_ERROR",
|
|
80
|
+
MAX_SESSIONS_EXCEEDED: "SESSION_MAX_EXCEEDED"
|
|
81
|
+
};
|
|
82
|
+
var PIXEL_ERRORS = {
|
|
83
|
+
PIXEL_NOT_FOUND: "PIXEL_NOT_FOUND",
|
|
84
|
+
PIXEL_DISABLED: "PIXEL_DISABLED",
|
|
85
|
+
PIXEL_CONFIGURATION_ERROR: "PIXEL_CONFIGURATION_ERROR",
|
|
86
|
+
PIXEL_DOMAIN_NOT_ALLOWED: "PIXEL_DOMAIN_NOT_ALLOWED",
|
|
87
|
+
PIXEL_PATH_SKIPPED: "PIXEL_PATH_SKIPPED",
|
|
88
|
+
PIXEL_EVENT_INVALID: "PIXEL_EVENT_INVALID",
|
|
89
|
+
PIXEL_BATCH_TOO_LARGE: "PIXEL_BATCH_TOO_LARGE",
|
|
90
|
+
MISSING_PIXEL_ID: "MISSING_PIXEL_ID",
|
|
91
|
+
INVALID_EDGE_SIGNATURE: "INVALID_EDGE_SIGNATURE",
|
|
92
|
+
DETECTION_STORAGE_FAILED: "DETECTION_STORAGE_FAILED"
|
|
93
|
+
};
|
|
94
|
+
var API_ERRORS = {
|
|
95
|
+
ENDPOINT_NOT_FOUND: "API_ENDPOINT_NOT_FOUND",
|
|
96
|
+
METHOD_NOT_ALLOWED: "API_METHOD_NOT_ALLOWED",
|
|
97
|
+
VERSION_NOT_SUPPORTED: "API_VERSION_NOT_SUPPORTED",
|
|
98
|
+
CONTENT_TYPE_NOT_SUPPORTED: "API_CONTENT_TYPE_NOT_SUPPORTED",
|
|
99
|
+
RESPONSE_TOO_LARGE: "API_RESPONSE_TOO_LARGE",
|
|
100
|
+
REQUEST_TOO_LARGE: "API_REQUEST_TOO_LARGE"
|
|
101
|
+
};
|
|
102
|
+
var BILLING_ERRORS = {
|
|
103
|
+
LIMIT_EXCEEDED: "LIMIT_EXCEEDED",
|
|
104
|
+
BILLING_SUSPENDED: "BILLING_SUSPENDED",
|
|
105
|
+
BILLING_GRACE_PERIOD: "BILLING_GRACE_PERIOD"
|
|
106
|
+
};
|
|
107
|
+
var RESOURCE_ERRORS = {
|
|
108
|
+
CONFLICT: "CONFLICT",
|
|
109
|
+
PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
|
|
110
|
+
REVIEW_REQUIRED: "REVIEW_REQUIRED"
|
|
111
|
+
};
|
|
112
|
+
var POLICY_ERRORS = {
|
|
113
|
+
POLICY_FETCH_FAILED: "POLICY_FETCH_FAILED"
|
|
114
|
+
};
|
|
115
|
+
var BARE_ERRORS = {
|
|
116
|
+
BARE_VALIDATION_ERROR: "VALIDATION_ERROR",
|
|
117
|
+
BARE_INTERNAL_ERROR: "INTERNAL_ERROR"
|
|
118
|
+
};
|
|
119
|
+
var LOWERCASE_ERRORS = {
|
|
120
|
+
LOWERCASE_INVALID_JSON: "invalid_json",
|
|
121
|
+
LOWERCASE_VALIDATION_ERROR: "validation_error"
|
|
122
|
+
};
|
|
123
|
+
var ERROR_CODES = {
|
|
124
|
+
...AUTH_ERRORS,
|
|
125
|
+
...VALIDATION_ERRORS,
|
|
126
|
+
...DETECTION_ERRORS,
|
|
127
|
+
...RATE_LIMIT_ERRORS,
|
|
128
|
+
...PERMISSION_ERRORS,
|
|
129
|
+
...NETWORK_ERRORS,
|
|
130
|
+
...INTERNAL_ERRORS,
|
|
131
|
+
...SESSION_ERRORS,
|
|
132
|
+
...PIXEL_ERRORS,
|
|
133
|
+
...API_ERRORS,
|
|
134
|
+
...BILLING_ERRORS,
|
|
135
|
+
...RESOURCE_ERRORS,
|
|
136
|
+
...POLICY_ERRORS,
|
|
137
|
+
...BARE_ERRORS,
|
|
138
|
+
...LOWERCASE_ERRORS
|
|
139
|
+
};
|
|
140
|
+
var ERROR_MESSAGES = {
|
|
141
|
+
// Authentication
|
|
142
|
+
[AUTH_ERRORS.INVALID_API_KEY]: "The provided API key is invalid",
|
|
143
|
+
[AUTH_ERRORS.EXPIRED_API_KEY]: "The API key has expired",
|
|
144
|
+
[AUTH_ERRORS.INVALID_TOKEN]: "The provided token is invalid",
|
|
145
|
+
[AUTH_ERRORS.EXPIRED_TOKEN]: "The token has expired",
|
|
146
|
+
[AUTH_ERRORS.MISSING_CREDENTIALS]: "Authentication credentials are required",
|
|
147
|
+
[AUTH_ERRORS.UNAUTHORIZED]: "You are not authorized to perform this action",
|
|
148
|
+
[AUTH_ERRORS.INVALID_PIXEL_ID]: "The provided pixel ID is invalid",
|
|
149
|
+
[AUTH_ERRORS.INVALID_SECRET_KEY]: "The provided secret key is invalid",
|
|
150
|
+
// Validation
|
|
151
|
+
[VALIDATION_ERRORS.INVALID_REQUEST]: "The request is invalid",
|
|
152
|
+
[VALIDATION_ERRORS.MISSING_REQUIRED_FIELD]: "A required field is missing",
|
|
153
|
+
[VALIDATION_ERRORS.INVALID_FIELD_TYPE]: "Field type is invalid",
|
|
154
|
+
[VALIDATION_ERRORS.INVALID_FIELD_VALUE]: "Field value is invalid",
|
|
155
|
+
[VALIDATION_ERRORS.FIELD_TOO_LONG]: "Field value exceeds maximum length",
|
|
156
|
+
[VALIDATION_ERRORS.FIELD_TOO_SHORT]: "Field value is below minimum length",
|
|
157
|
+
[VALIDATION_ERRORS.INVALID_EMAIL]: "Invalid email address format",
|
|
158
|
+
[VALIDATION_ERRORS.INVALID_URL]: "Invalid URL format",
|
|
159
|
+
[VALIDATION_ERRORS.INVALID_UUID]: "Invalid UUID format",
|
|
160
|
+
[VALIDATION_ERRORS.INVALID_IP_ADDRESS]: "Invalid IP address format",
|
|
161
|
+
[VALIDATION_ERRORS.INVALID_USER_AGENT]: "Invalid or missing user agent",
|
|
162
|
+
[VALIDATION_ERRORS.BAD_REQUEST]: "Bad request",
|
|
163
|
+
[VALIDATION_ERRORS.INVALID_START_DATE]: "Invalid request data",
|
|
164
|
+
[VALIDATION_ERRORS.INVALID_END_DATE]: "Invalid request data",
|
|
165
|
+
[VALIDATION_ERRORS.INVALID_DATE_RANGE]: "Invalid request data",
|
|
166
|
+
// Detection
|
|
167
|
+
[DETECTION_ERRORS.DETECTION_FAILED]: "Agent detection failed",
|
|
168
|
+
[DETECTION_ERRORS.INSUFFICIENT_DATA]: "Insufficient data for detection",
|
|
169
|
+
[DETECTION_ERRORS.PATTERN_MATCH_FAILED]: "Pattern matching failed",
|
|
170
|
+
[DETECTION_ERRORS.WASM_NOT_LOADED]: "WASM module is not loaded",
|
|
171
|
+
[DETECTION_ERRORS.WASM_EXECUTION_FAILED]: "WASM execution failed",
|
|
172
|
+
[DETECTION_ERRORS.CONFIDENCE_BELOW_THRESHOLD]: "Detection confidence below threshold",
|
|
173
|
+
[DETECTION_ERRORS.SIGNATURE_VERIFICATION_FAILED]: "Signature verification failed",
|
|
174
|
+
// Rate Limiting
|
|
175
|
+
[RATE_LIMIT_ERRORS.RATE_LIMIT_EXCEEDED]: "Rate limit exceeded",
|
|
176
|
+
[RATE_LIMIT_ERRORS.BURST_LIMIT_EXCEEDED]: "Burst limit exceeded",
|
|
177
|
+
[RATE_LIMIT_ERRORS.DAILY_LIMIT_EXCEEDED]: "Daily request limit exceeded",
|
|
178
|
+
[RATE_LIMIT_ERRORS.MONTHLY_LIMIT_EXCEEDED]: "Monthly request limit exceeded",
|
|
179
|
+
[RATE_LIMIT_ERRORS.CONCURRENT_LIMIT_EXCEEDED]: "Concurrent request limit exceeded",
|
|
180
|
+
[RATE_LIMIT_ERRORS.QUOTA_EXCEEDED]: "Account quota exceeded",
|
|
181
|
+
// Permissions
|
|
182
|
+
[PERMISSION_ERRORS.INSUFFICIENT_PERMISSIONS]: "Insufficient permissions",
|
|
183
|
+
[PERMISSION_ERRORS.RESOURCE_NOT_FOUND]: "Resource not found",
|
|
184
|
+
[PERMISSION_ERRORS.RESOURCE_ACCESS_DENIED]: "Access to resource denied",
|
|
185
|
+
[PERMISSION_ERRORS.OPERATION_NOT_ALLOWED]: "Operation not allowed",
|
|
186
|
+
[PERMISSION_ERRORS.PROJECT_ACCESS_DENIED]: "Project access denied",
|
|
187
|
+
[PERMISSION_ERRORS.PIXEL_ACCESS_DENIED]: "Pixel access denied",
|
|
188
|
+
[PERMISSION_ERRORS.FORBIDDEN]: "Access denied",
|
|
189
|
+
// Network
|
|
190
|
+
[NETWORK_ERRORS.CONNECTION_FAILED]: "Connection failed",
|
|
191
|
+
[NETWORK_ERRORS.TIMEOUT]: "Request timeout",
|
|
192
|
+
[NETWORK_ERRORS.DNS_RESOLUTION_FAILED]: "DNS resolution failed",
|
|
193
|
+
[NETWORK_ERRORS.SSL_ERROR]: "SSL/TLS error",
|
|
194
|
+
[NETWORK_ERRORS.PROXY_ERROR]: "Proxy error",
|
|
195
|
+
[NETWORK_ERRORS.UPSTREAM_ERROR]: "Upstream service error",
|
|
196
|
+
// Internal
|
|
197
|
+
[INTERNAL_ERRORS.INTERNAL_SERVER_ERROR]: "Internal server error",
|
|
198
|
+
[INTERNAL_ERRORS.DATABASE_ERROR]: "Database error",
|
|
199
|
+
[INTERNAL_ERRORS.CACHE_ERROR]: "Cache error",
|
|
200
|
+
[INTERNAL_ERRORS.CONFIGURATION_ERROR]: "Configuration error",
|
|
201
|
+
[INTERNAL_ERRORS.INITIALIZATION_ERROR]: "Initialization error",
|
|
202
|
+
[INTERNAL_ERRORS.PROCESSING_ERROR]: "Processing error",
|
|
203
|
+
[INTERNAL_ERRORS.UNKNOWN_ERROR]: "An unknown error occurred",
|
|
204
|
+
[INTERNAL_ERRORS.SERVICE_UNAVAILABLE_TRANSIENT]: "A dependency is temporarily unavailable. Retry shortly.",
|
|
205
|
+
// Session
|
|
206
|
+
[SESSION_ERRORS.SESSION_NOT_FOUND]: "Session not found",
|
|
207
|
+
[SESSION_ERRORS.SESSION_EXPIRED]: "Session has expired",
|
|
208
|
+
[SESSION_ERRORS.SESSION_INVALID]: "Session is invalid",
|
|
209
|
+
[SESSION_ERRORS.SESSION_CREATION_FAILED]: "Failed to create session",
|
|
210
|
+
[SESSION_ERRORS.SESSION_UPDATE_FAILED]: "Failed to update session",
|
|
211
|
+
[SESSION_ERRORS.SESSION_STORAGE_ERROR]: "Session storage error",
|
|
212
|
+
[SESSION_ERRORS.MAX_SESSIONS_EXCEEDED]: "Maximum sessions exceeded",
|
|
213
|
+
// Pixel
|
|
214
|
+
[PIXEL_ERRORS.PIXEL_NOT_FOUND]: "Pixel not found",
|
|
215
|
+
[PIXEL_ERRORS.PIXEL_DISABLED]: "Pixel is disabled",
|
|
216
|
+
[PIXEL_ERRORS.PIXEL_CONFIGURATION_ERROR]: "Pixel configuration error",
|
|
217
|
+
[PIXEL_ERRORS.PIXEL_DOMAIN_NOT_ALLOWED]: "Domain not allowed for this pixel",
|
|
218
|
+
[PIXEL_ERRORS.PIXEL_PATH_SKIPPED]: "Path is configured to be skipped",
|
|
219
|
+
[PIXEL_ERRORS.PIXEL_EVENT_INVALID]: "Invalid pixel event",
|
|
220
|
+
[PIXEL_ERRORS.PIXEL_BATCH_TOO_LARGE]: "Event batch exceeds maximum size",
|
|
221
|
+
[PIXEL_ERRORS.MISSING_PIXEL_ID]: "Project ID is required",
|
|
222
|
+
[PIXEL_ERRORS.INVALID_EDGE_SIGNATURE]: "Invalid request signature",
|
|
223
|
+
[PIXEL_ERRORS.DETECTION_STORAGE_FAILED]: "Failed to store detection data",
|
|
224
|
+
// API
|
|
225
|
+
[API_ERRORS.ENDPOINT_NOT_FOUND]: "API endpoint not found",
|
|
226
|
+
[API_ERRORS.METHOD_NOT_ALLOWED]: "HTTP method not allowed",
|
|
227
|
+
[API_ERRORS.VERSION_NOT_SUPPORTED]: "API version not supported",
|
|
228
|
+
[API_ERRORS.CONTENT_TYPE_NOT_SUPPORTED]: "Content type not supported",
|
|
229
|
+
[API_ERRORS.RESPONSE_TOO_LARGE]: "Response exceeds maximum size",
|
|
230
|
+
[API_ERRORS.REQUEST_TOO_LARGE]: "Request exceeds maximum size",
|
|
231
|
+
// Billing
|
|
232
|
+
[BILLING_ERRORS.LIMIT_EXCEEDED]: "Billing limit exceeded",
|
|
233
|
+
[BILLING_ERRORS.BILLING_SUSPENDED]: "Account billing suspended",
|
|
234
|
+
[BILLING_ERRORS.BILLING_GRACE_PERIOD]: "Account in billing grace period",
|
|
235
|
+
// Resources
|
|
236
|
+
[RESOURCE_ERRORS.CONFLICT]: "Resource conflict",
|
|
237
|
+
[RESOURCE_ERRORS.PROJECT_NOT_FOUND]: "Project not found",
|
|
238
|
+
[RESOURCE_ERRORS.REVIEW_REQUIRED]: "Deploy requires explicit confirmation of the consequential writes it will perform.",
|
|
239
|
+
// Policy
|
|
240
|
+
[POLICY_ERRORS.POLICY_FETCH_FAILED]: "Failed to fetch policy",
|
|
241
|
+
// Bare (un-prefixed, shared across pixel/openclaw/deploy/shopify/bouncer)
|
|
242
|
+
[BARE_ERRORS.BARE_VALIDATION_ERROR]: "Invalid request data",
|
|
243
|
+
[BARE_ERRORS.BARE_INTERNAL_ERROR]: "Internal server error",
|
|
244
|
+
// Lowercase (kya-os events wire format)
|
|
245
|
+
[LOWERCASE_ERRORS.LOWERCASE_INVALID_JSON]: "Request body must be valid JSON",
|
|
246
|
+
[LOWERCASE_ERRORS.LOWERCASE_VALIDATION_ERROR]: "Invalid request body"
|
|
247
|
+
};
|
|
248
|
+
var ERROR_STATUS_CODES = {
|
|
249
|
+
// 200 OK (billing grace period is a soft warning, not a failure)
|
|
250
|
+
[BILLING_ERRORS.BILLING_GRACE_PERIOD]: 200,
|
|
251
|
+
// 400 Bad Request
|
|
252
|
+
[VALIDATION_ERRORS.INVALID_REQUEST]: 400,
|
|
253
|
+
[VALIDATION_ERRORS.MISSING_REQUIRED_FIELD]: 400,
|
|
254
|
+
[VALIDATION_ERRORS.INVALID_FIELD_TYPE]: 400,
|
|
255
|
+
[VALIDATION_ERRORS.INVALID_FIELD_VALUE]: 400,
|
|
256
|
+
[VALIDATION_ERRORS.BAD_REQUEST]: 400,
|
|
257
|
+
[VALIDATION_ERRORS.INVALID_START_DATE]: 400,
|
|
258
|
+
[VALIDATION_ERRORS.INVALID_END_DATE]: 400,
|
|
259
|
+
[VALIDATION_ERRORS.INVALID_DATE_RANGE]: 400,
|
|
260
|
+
[PIXEL_ERRORS.MISSING_PIXEL_ID]: 400,
|
|
261
|
+
[BARE_ERRORS.BARE_VALIDATION_ERROR]: 400,
|
|
262
|
+
[LOWERCASE_ERRORS.LOWERCASE_INVALID_JSON]: 400,
|
|
263
|
+
[LOWERCASE_ERRORS.LOWERCASE_VALIDATION_ERROR]: 400,
|
|
264
|
+
// 401 Unauthorized
|
|
265
|
+
[AUTH_ERRORS.INVALID_API_KEY]: 401,
|
|
266
|
+
[AUTH_ERRORS.EXPIRED_API_KEY]: 401,
|
|
267
|
+
[AUTH_ERRORS.INVALID_TOKEN]: 401,
|
|
268
|
+
[AUTH_ERRORS.EXPIRED_TOKEN]: 401,
|
|
269
|
+
[AUTH_ERRORS.MISSING_CREDENTIALS]: 401,
|
|
270
|
+
[AUTH_ERRORS.UNAUTHORIZED]: 401,
|
|
271
|
+
// 402 Payment Required
|
|
272
|
+
[BILLING_ERRORS.LIMIT_EXCEEDED]: 402,
|
|
273
|
+
[BILLING_ERRORS.BILLING_SUSPENDED]: 402,
|
|
274
|
+
// 403 Forbidden
|
|
275
|
+
[PERMISSION_ERRORS.INSUFFICIENT_PERMISSIONS]: 403,
|
|
276
|
+
[PERMISSION_ERRORS.RESOURCE_ACCESS_DENIED]: 403,
|
|
277
|
+
[PERMISSION_ERRORS.OPERATION_NOT_ALLOWED]: 403,
|
|
278
|
+
[PERMISSION_ERRORS.FORBIDDEN]: 403,
|
|
279
|
+
[PIXEL_ERRORS.INVALID_EDGE_SIGNATURE]: 403,
|
|
280
|
+
// 404 Not Found
|
|
281
|
+
[PERMISSION_ERRORS.RESOURCE_NOT_FOUND]: 404,
|
|
282
|
+
[API_ERRORS.ENDPOINT_NOT_FOUND]: 404,
|
|
283
|
+
[PIXEL_ERRORS.PIXEL_NOT_FOUND]: 404,
|
|
284
|
+
[SESSION_ERRORS.SESSION_NOT_FOUND]: 404,
|
|
285
|
+
// 405 Method Not Allowed
|
|
286
|
+
[API_ERRORS.METHOD_NOT_ALLOWED]: 405,
|
|
287
|
+
// 409 Conflict
|
|
288
|
+
[RESOURCE_ERRORS.CONFLICT]: 409,
|
|
289
|
+
// NOTE: RESOURCE_ERRORS.PROJECT_NOT_FOUND deliberately has no entry here.
|
|
290
|
+
// The pixel API emits it with 400, while enforce and the policy
|
|
291
|
+
// middleware emit it with 404. There is no single correct status, so it
|
|
292
|
+
// stays unpinned and callers set their own status per surface. Locked by
|
|
293
|
+
// a test in __tests__/errors.test.ts.
|
|
294
|
+
// 413 Payload Too Large
|
|
295
|
+
[API_ERRORS.REQUEST_TOO_LARGE]: 413,
|
|
296
|
+
[PIXEL_ERRORS.PIXEL_BATCH_TOO_LARGE]: 413,
|
|
297
|
+
// 415 Unsupported Media Type
|
|
298
|
+
[API_ERRORS.CONTENT_TYPE_NOT_SUPPORTED]: 415,
|
|
299
|
+
// 422 Unprocessable Entity
|
|
300
|
+
[RESOURCE_ERRORS.REVIEW_REQUIRED]: 422,
|
|
301
|
+
// 429 Too Many Requests
|
|
302
|
+
[RATE_LIMIT_ERRORS.RATE_LIMIT_EXCEEDED]: 429,
|
|
303
|
+
[RATE_LIMIT_ERRORS.BURST_LIMIT_EXCEEDED]: 429,
|
|
304
|
+
[RATE_LIMIT_ERRORS.DAILY_LIMIT_EXCEEDED]: 429,
|
|
305
|
+
// 500 Internal Server Error
|
|
306
|
+
[INTERNAL_ERRORS.INTERNAL_SERVER_ERROR]: 500,
|
|
307
|
+
[INTERNAL_ERRORS.DATABASE_ERROR]: 500,
|
|
308
|
+
[INTERNAL_ERRORS.PROCESSING_ERROR]: 500,
|
|
309
|
+
[PIXEL_ERRORS.DETECTION_STORAGE_FAILED]: 500,
|
|
310
|
+
[POLICY_ERRORS.POLICY_FETCH_FAILED]: 500,
|
|
311
|
+
[BARE_ERRORS.BARE_INTERNAL_ERROR]: 500,
|
|
312
|
+
// 502 Bad Gateway
|
|
313
|
+
[NETWORK_ERRORS.UPSTREAM_ERROR]: 502,
|
|
314
|
+
// 503 Service Unavailable
|
|
315
|
+
[INTERNAL_ERRORS.INITIALIZATION_ERROR]: 503,
|
|
316
|
+
[INTERNAL_ERRORS.SERVICE_UNAVAILABLE_TRANSIENT]: 503,
|
|
317
|
+
// 504 Gateway Timeout
|
|
318
|
+
[NETWORK_ERRORS.TIMEOUT]: 504
|
|
319
|
+
};
|
|
320
|
+
|
|
321
|
+
// src/constants/pick-error-codes.ts
|
|
322
|
+
function pickErrorCodes(keys) {
|
|
323
|
+
const picked = {};
|
|
324
|
+
for (const key of keys) {
|
|
325
|
+
if (!(key in ERROR_CODES)) {
|
|
326
|
+
throw new Error(`pickErrorCodes: unknown error code key "${String(key)}"`);
|
|
327
|
+
}
|
|
328
|
+
picked[key] = ERROR_CODES[key];
|
|
329
|
+
}
|
|
330
|
+
return Object.freeze(picked);
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
export { ERROR_CODES, ERROR_MESSAGES, ERROR_STATUS_CODES, pickErrorCodes };
|
package/dist/gateway/index.d.mts
CHANGED
|
@@ -572,4 +572,9 @@ declare const usageCostSchema: z.ZodObject<{
|
|
|
572
572
|
}>;
|
|
573
573
|
type UsageCost = z.infer<typeof usageCostSchema>;
|
|
574
574
|
|
|
575
|
-
|
|
575
|
+
declare const OPENCLAW_PROTOCOL_RANGE: {
|
|
576
|
+
readonly minProtocol: 3;
|
|
577
|
+
readonly maxProtocol: 4;
|
|
578
|
+
};
|
|
579
|
+
|
|
580
|
+
export { type AgentEntry, type CronJob, OPENCLAW_PROTOCOL_RANGE, type SessionEntry, type SkillConfigCheck, type SkillInstallOption, type SkillRequirements, type SkillStatusEntry, type SkillStatusReport, type UsageCost, agentEntrySchema, cronJobSchema, sessionEntrySchema, skillConfigCheckSchema, skillInstallOptionSchema, skillRequirementsSchema, skillStatusEntrySchema, skillStatusReportSchema, usageCostSchema };
|