@alpic-ai/api 0.0.0-staging.gd09342b → 0.0.0-staging.gd0d3ad5
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/dist/index.d.mts +6723 -97
- package/dist/index.mjs +2383 -226
- package/package.json +9 -9
package/dist/index.mjs
CHANGED
|
@@ -2,7 +2,10 @@ import { z } from "zod";
|
|
|
2
2
|
import * as z$1 from "zod/v4";
|
|
3
3
|
import { oc } from "@orpc/contract";
|
|
4
4
|
import ms from "ms";
|
|
5
|
-
//#region
|
|
5
|
+
//#region \0rolldown/runtime.js
|
|
6
|
+
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
|
|
7
|
+
//#endregion
|
|
8
|
+
//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.32.1_supports-color@8.1.1_zod@4.6.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
|
|
6
9
|
/**
|
|
7
10
|
* Reusable URL validation that disallows javascript: scheme
|
|
8
11
|
*/
|
|
@@ -119,7 +122,12 @@ z$1.object({
|
|
|
119
122
|
token_type: z$1.string(),
|
|
120
123
|
expires_in: z$1.coerce.number().optional(),
|
|
121
124
|
scope: z$1.string().optional(),
|
|
122
|
-
refresh_token: z$1.string().optional()
|
|
125
|
+
refresh_token: z$1.string().optional(),
|
|
126
|
+
/**
|
|
127
|
+
* Not part of the wire format: the authorization server this value was obtained from, added by
|
|
128
|
+
* the client's `auth()` before it is stored and compared when it is read back.
|
|
129
|
+
*/
|
|
130
|
+
issuer: z$1.string().optional().catch(void 0)
|
|
123
131
|
}).strip();
|
|
124
132
|
z$1.object({
|
|
125
133
|
error: z$1.string(),
|
|
@@ -158,7 +166,12 @@ const OAuthClientInformationSchema = z$1.object({
|
|
|
158
166
|
client_id: z$1.string(),
|
|
159
167
|
client_secret: z$1.string().optional(),
|
|
160
168
|
client_id_issued_at: z$1.number().optional(),
|
|
161
|
-
client_secret_expires_at: z$1.number().optional()
|
|
169
|
+
client_secret_expires_at: z$1.number().optional(),
|
|
170
|
+
/**
|
|
171
|
+
* Not part of the wire format: the authorization server this value was obtained from, added by
|
|
172
|
+
* the client's `auth()` before it is stored and compared when it is read back.
|
|
173
|
+
*/
|
|
174
|
+
issuer: z$1.string().optional().catch(void 0)
|
|
162
175
|
}).strip();
|
|
163
176
|
OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
|
|
164
177
|
z$1.object({
|
|
@@ -169,11 +182,1420 @@ z$1.object({
|
|
|
169
182
|
token: z$1.string(),
|
|
170
183
|
token_type_hint: z$1.string().optional()
|
|
171
184
|
}).strip();
|
|
172
|
-
|
|
185
|
+
//#endregion
|
|
186
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
|
|
187
|
+
var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
188
|
+
module.exports = {
|
|
189
|
+
MAX_LENGTH: 256,
|
|
190
|
+
MAX_SAFE_COMPONENT_LENGTH: 16,
|
|
191
|
+
MAX_SAFE_BUILD_LENGTH: 250,
|
|
192
|
+
MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER ||
|
|
193
|
+
/* istanbul ignore next */ 9007199254740991,
|
|
194
|
+
RELEASE_TYPES: [
|
|
195
|
+
"major",
|
|
196
|
+
"premajor",
|
|
197
|
+
"minor",
|
|
198
|
+
"preminor",
|
|
199
|
+
"patch",
|
|
200
|
+
"prepatch",
|
|
201
|
+
"prerelease"
|
|
202
|
+
],
|
|
203
|
+
SEMVER_SPEC_VERSION: "2.0.0",
|
|
204
|
+
FLAG_INCLUDE_PRERELEASE: 1,
|
|
205
|
+
FLAG_LOOSE: 2
|
|
206
|
+
};
|
|
207
|
+
}));
|
|
208
|
+
//#endregion
|
|
209
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
|
|
210
|
+
var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
211
|
+
module.exports = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
|
|
212
|
+
}));
|
|
213
|
+
//#endregion
|
|
214
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
|
|
215
|
+
var require_re = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
216
|
+
const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
|
|
217
|
+
const debug = require_debug();
|
|
218
|
+
exports = module.exports = {};
|
|
219
|
+
const re = exports.re = [];
|
|
220
|
+
const safeRe = exports.safeRe = [];
|
|
221
|
+
const src = exports.src = [];
|
|
222
|
+
const safeSrc = exports.safeSrc = [];
|
|
223
|
+
const t = exports.t = {};
|
|
224
|
+
let R = 0;
|
|
225
|
+
const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
|
|
226
|
+
const safeRegexReplacements = [
|
|
227
|
+
["\\s", 1],
|
|
228
|
+
["\\d", MAX_LENGTH],
|
|
229
|
+
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
|
|
230
|
+
];
|
|
231
|
+
const makeSafeRegex = (value) => {
|
|
232
|
+
for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
|
|
233
|
+
return value;
|
|
234
|
+
};
|
|
235
|
+
const createToken = (name, value, isGlobal) => {
|
|
236
|
+
const safe = makeSafeRegex(value);
|
|
237
|
+
const index = R++;
|
|
238
|
+
debug(name, index, value);
|
|
239
|
+
t[name] = index;
|
|
240
|
+
src[index] = value;
|
|
241
|
+
safeSrc[index] = safe;
|
|
242
|
+
re[index] = new RegExp(value, isGlobal ? "g" : void 0);
|
|
243
|
+
safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
|
|
244
|
+
};
|
|
245
|
+
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
|
|
246
|
+
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
|
|
247
|
+
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
|
|
248
|
+
createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
|
|
249
|
+
createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
|
|
250
|
+
createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
|
|
251
|
+
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
|
|
252
|
+
createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
|
|
253
|
+
createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
|
|
254
|
+
createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
|
|
255
|
+
createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
|
|
256
|
+
createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
|
|
257
|
+
createToken("FULL", `^${src[t.FULLPLAIN]}$`);
|
|
258
|
+
createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
|
|
259
|
+
createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
|
|
260
|
+
createToken("GTLT", "((?:<|>)?=?)");
|
|
261
|
+
createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
|
|
262
|
+
createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
|
|
263
|
+
createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
|
|
264
|
+
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
|
|
265
|
+
createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
|
|
266
|
+
createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
|
|
267
|
+
createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
|
|
268
|
+
createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
|
|
269
|
+
createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
|
|
270
|
+
createToken("COERCERTL", src[t.COERCE], true);
|
|
271
|
+
createToken("COERCERTLFULL", src[t.COERCEFULL], true);
|
|
272
|
+
createToken("LONETILDE", "(?:~>?)");
|
|
273
|
+
createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
|
|
274
|
+
exports.tildeTrimReplace = "$1~";
|
|
275
|
+
createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
|
|
276
|
+
createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
|
|
277
|
+
createToken("LONECARET", "(?:\\^)");
|
|
278
|
+
createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
|
|
279
|
+
exports.caretTrimReplace = "$1^";
|
|
280
|
+
createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
|
|
281
|
+
createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
|
|
282
|
+
createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
|
|
283
|
+
createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
|
|
284
|
+
createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
|
|
285
|
+
exports.comparatorTrimReplace = "$1$2$3";
|
|
286
|
+
createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
|
|
287
|
+
createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
|
|
288
|
+
createToken("STAR", "(<|>)?=?\\s*\\*");
|
|
289
|
+
createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
|
|
290
|
+
createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
|
|
291
|
+
}));
|
|
292
|
+
//#endregion
|
|
293
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
|
|
294
|
+
var require_parse_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
295
|
+
const looseOption = Object.freeze({ loose: true });
|
|
296
|
+
const emptyOpts = Object.freeze({});
|
|
297
|
+
const parseOptions = (options) => {
|
|
298
|
+
if (!options) return emptyOpts;
|
|
299
|
+
if (typeof options !== "object") return looseOption;
|
|
300
|
+
return options;
|
|
301
|
+
};
|
|
302
|
+
module.exports = parseOptions;
|
|
303
|
+
}));
|
|
304
|
+
//#endregion
|
|
305
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
|
|
306
|
+
var require_identifiers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
307
|
+
const numeric = /^[0-9]+$/;
|
|
308
|
+
const compareIdentifiers = (a, b) => {
|
|
309
|
+
if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
|
|
310
|
+
const anum = numeric.test(a);
|
|
311
|
+
const bnum = numeric.test(b);
|
|
312
|
+
if (anum && bnum) {
|
|
313
|
+
a = +a;
|
|
314
|
+
b = +b;
|
|
315
|
+
}
|
|
316
|
+
return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
|
|
317
|
+
};
|
|
318
|
+
const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
|
|
319
|
+
module.exports = {
|
|
320
|
+
compareIdentifiers,
|
|
321
|
+
rcompareIdentifiers
|
|
322
|
+
};
|
|
323
|
+
}));
|
|
324
|
+
//#endregion
|
|
325
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
|
|
326
|
+
var require_semver$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
327
|
+
const debug = require_debug();
|
|
328
|
+
const { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
|
|
329
|
+
const { safeRe: re, t } = require_re();
|
|
330
|
+
const parseOptions = require_parse_options();
|
|
331
|
+
const { compareIdentifiers } = require_identifiers();
|
|
332
|
+
const isPrereleaseIdentifier = (prerelease, identifier) => {
|
|
333
|
+
const identifiers = identifier.split(".");
|
|
334
|
+
if (identifiers.length > prerelease.length) return false;
|
|
335
|
+
for (let i = 0; i < identifiers.length; i++) if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) return false;
|
|
336
|
+
return true;
|
|
337
|
+
};
|
|
338
|
+
module.exports = class SemVer {
|
|
339
|
+
constructor(version, options) {
|
|
340
|
+
options = parseOptions(options);
|
|
341
|
+
if (version instanceof SemVer) {
|
|
342
|
+
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
|
|
343
|
+
else version = version.version;
|
|
344
|
+
} else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
|
|
345
|
+
if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
|
|
346
|
+
debug("SemVer", version, options);
|
|
347
|
+
this.options = options;
|
|
348
|
+
this.loose = !!options.loose;
|
|
349
|
+
this.includePrerelease = !!options.includePrerelease;
|
|
350
|
+
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
|
|
351
|
+
if (!m) throw new TypeError(`Invalid Version: ${version}`);
|
|
352
|
+
this.raw = version;
|
|
353
|
+
this.major = +m[1];
|
|
354
|
+
this.minor = +m[2];
|
|
355
|
+
this.patch = +m[3];
|
|
356
|
+
if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
|
|
357
|
+
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
|
|
358
|
+
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
|
|
359
|
+
if (!m[4]) this.prerelease = [];
|
|
360
|
+
else this.prerelease = m[4].split(".").map((id) => {
|
|
361
|
+
if (/^[0-9]+$/.test(id)) {
|
|
362
|
+
const num = +id;
|
|
363
|
+
if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
|
|
364
|
+
}
|
|
365
|
+
return id;
|
|
366
|
+
});
|
|
367
|
+
this.build = m[5] ? m[5].split(".") : [];
|
|
368
|
+
this.format();
|
|
369
|
+
}
|
|
370
|
+
format() {
|
|
371
|
+
this.version = `${this.major}.${this.minor}.${this.patch}`;
|
|
372
|
+
if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
|
|
373
|
+
return this.version;
|
|
374
|
+
}
|
|
375
|
+
toString() {
|
|
376
|
+
return this.version;
|
|
377
|
+
}
|
|
378
|
+
compare(other) {
|
|
379
|
+
debug("SemVer.compare", this.version, this.options, other);
|
|
380
|
+
if (!(other instanceof SemVer)) {
|
|
381
|
+
if (typeof other === "string" && other === this.version) return 0;
|
|
382
|
+
other = new SemVer(other, this.options);
|
|
383
|
+
}
|
|
384
|
+
if (other.version === this.version) return 0;
|
|
385
|
+
return this.compareMain(other) || this.comparePre(other);
|
|
386
|
+
}
|
|
387
|
+
compareMain(other) {
|
|
388
|
+
if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
|
|
389
|
+
if (this.major < other.major) return -1;
|
|
390
|
+
if (this.major > other.major) return 1;
|
|
391
|
+
if (this.minor < other.minor) return -1;
|
|
392
|
+
if (this.minor > other.minor) return 1;
|
|
393
|
+
if (this.patch < other.patch) return -1;
|
|
394
|
+
if (this.patch > other.patch) return 1;
|
|
395
|
+
return 0;
|
|
396
|
+
}
|
|
397
|
+
comparePre(other) {
|
|
398
|
+
if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
|
|
399
|
+
if (this.prerelease.length && !other.prerelease.length) return -1;
|
|
400
|
+
else if (!this.prerelease.length && other.prerelease.length) return 1;
|
|
401
|
+
else if (!this.prerelease.length && !other.prerelease.length) return 0;
|
|
402
|
+
let i = 0;
|
|
403
|
+
do {
|
|
404
|
+
const a = this.prerelease[i];
|
|
405
|
+
const b = other.prerelease[i];
|
|
406
|
+
debug("prerelease compare", i, a, b);
|
|
407
|
+
if (a === void 0 && b === void 0) return 0;
|
|
408
|
+
else if (b === void 0) return 1;
|
|
409
|
+
else if (a === void 0) return -1;
|
|
410
|
+
else if (a === b) continue;
|
|
411
|
+
else return compareIdentifiers(a, b);
|
|
412
|
+
} while (++i);
|
|
413
|
+
}
|
|
414
|
+
compareBuild(other) {
|
|
415
|
+
if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
|
|
416
|
+
let i = 0;
|
|
417
|
+
do {
|
|
418
|
+
const a = this.build[i];
|
|
419
|
+
const b = other.build[i];
|
|
420
|
+
debug("build compare", i, a, b);
|
|
421
|
+
if (a === void 0 && b === void 0) return 0;
|
|
422
|
+
else if (b === void 0) return 1;
|
|
423
|
+
else if (a === void 0) return -1;
|
|
424
|
+
else if (a === b) continue;
|
|
425
|
+
else return compareIdentifiers(a, b);
|
|
426
|
+
} while (++i);
|
|
427
|
+
}
|
|
428
|
+
inc(release, identifier, identifierBase) {
|
|
429
|
+
if (release.startsWith("pre")) {
|
|
430
|
+
if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
|
|
431
|
+
if (identifier) {
|
|
432
|
+
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
|
|
433
|
+
if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
|
|
434
|
+
}
|
|
435
|
+
}
|
|
436
|
+
switch (release) {
|
|
437
|
+
case "premajor":
|
|
438
|
+
this.prerelease.length = 0;
|
|
439
|
+
this.patch = 0;
|
|
440
|
+
this.minor = 0;
|
|
441
|
+
this.major++;
|
|
442
|
+
this.inc("pre", identifier, identifierBase);
|
|
443
|
+
break;
|
|
444
|
+
case "preminor":
|
|
445
|
+
this.prerelease.length = 0;
|
|
446
|
+
this.patch = 0;
|
|
447
|
+
this.minor++;
|
|
448
|
+
this.inc("pre", identifier, identifierBase);
|
|
449
|
+
break;
|
|
450
|
+
case "prepatch":
|
|
451
|
+
this.prerelease.length = 0;
|
|
452
|
+
this.inc("patch", identifier, identifierBase);
|
|
453
|
+
this.inc("pre", identifier, identifierBase);
|
|
454
|
+
break;
|
|
455
|
+
case "prerelease":
|
|
456
|
+
if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
|
|
457
|
+
this.inc("pre", identifier, identifierBase);
|
|
458
|
+
break;
|
|
459
|
+
case "release":
|
|
460
|
+
if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
|
|
461
|
+
this.prerelease.length = 0;
|
|
462
|
+
break;
|
|
463
|
+
case "major":
|
|
464
|
+
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
|
|
465
|
+
this.minor = 0;
|
|
466
|
+
this.patch = 0;
|
|
467
|
+
this.prerelease = [];
|
|
468
|
+
break;
|
|
469
|
+
case "minor":
|
|
470
|
+
if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
|
|
471
|
+
this.patch = 0;
|
|
472
|
+
this.prerelease = [];
|
|
473
|
+
break;
|
|
474
|
+
case "patch":
|
|
475
|
+
if (this.prerelease.length === 0) this.patch++;
|
|
476
|
+
this.prerelease = [];
|
|
477
|
+
break;
|
|
478
|
+
case "pre": {
|
|
479
|
+
const base = Number(identifierBase) ? 1 : 0;
|
|
480
|
+
if (this.prerelease.length === 0) this.prerelease = [base];
|
|
481
|
+
else {
|
|
482
|
+
let i = this.prerelease.length;
|
|
483
|
+
while (--i >= 0) if (typeof this.prerelease[i] === "number") {
|
|
484
|
+
this.prerelease[i]++;
|
|
485
|
+
i = -2;
|
|
486
|
+
}
|
|
487
|
+
if (i === -1) {
|
|
488
|
+
if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
|
|
489
|
+
this.prerelease.push(base);
|
|
490
|
+
}
|
|
491
|
+
}
|
|
492
|
+
if (identifier) {
|
|
493
|
+
let prerelease = [identifier, base];
|
|
494
|
+
if (identifierBase === false) prerelease = [identifier];
|
|
495
|
+
if (isPrereleaseIdentifier(this.prerelease, identifier)) {
|
|
496
|
+
const prereleaseBase = this.prerelease[identifier.split(".").length];
|
|
497
|
+
if (isNaN(prereleaseBase)) this.prerelease = prerelease;
|
|
498
|
+
} else this.prerelease = prerelease;
|
|
499
|
+
}
|
|
500
|
+
break;
|
|
501
|
+
}
|
|
502
|
+
default: throw new Error(`invalid increment argument: ${release}`);
|
|
503
|
+
}
|
|
504
|
+
this.raw = this.format();
|
|
505
|
+
if (this.build.length) this.raw += `+${this.build.join(".")}`;
|
|
506
|
+
return this;
|
|
507
|
+
}
|
|
508
|
+
};
|
|
509
|
+
}));
|
|
510
|
+
//#endregion
|
|
511
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
|
|
512
|
+
var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
513
|
+
const SemVer = require_semver$1();
|
|
514
|
+
const parse = (version, options, throwErrors = false) => {
|
|
515
|
+
if (version instanceof SemVer) return version;
|
|
516
|
+
try {
|
|
517
|
+
return new SemVer(version, options);
|
|
518
|
+
} catch (er) {
|
|
519
|
+
if (!throwErrors) return null;
|
|
520
|
+
throw er;
|
|
521
|
+
}
|
|
522
|
+
};
|
|
523
|
+
module.exports = parse;
|
|
524
|
+
}));
|
|
525
|
+
//#endregion
|
|
526
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
|
|
527
|
+
var require_valid$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
528
|
+
const parse = require_parse();
|
|
529
|
+
const valid = (version, options) => {
|
|
530
|
+
const v = parse(version, options);
|
|
531
|
+
return v ? v.version : null;
|
|
532
|
+
};
|
|
533
|
+
module.exports = valid;
|
|
534
|
+
}));
|
|
535
|
+
//#endregion
|
|
536
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/clean.js
|
|
537
|
+
var require_clean = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
538
|
+
const parse = require_parse();
|
|
539
|
+
const clean = (version, options) => {
|
|
540
|
+
const s = parse(version.trim().replace(/^[=v]+/, ""), options);
|
|
541
|
+
return s ? s.version : null;
|
|
542
|
+
};
|
|
543
|
+
module.exports = clean;
|
|
544
|
+
}));
|
|
545
|
+
//#endregion
|
|
546
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/inc.js
|
|
547
|
+
var require_inc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
548
|
+
const SemVer = require_semver$1();
|
|
549
|
+
const inc = (version, release, options, identifier, identifierBase) => {
|
|
550
|
+
if (typeof options === "string") {
|
|
551
|
+
identifierBase = identifier;
|
|
552
|
+
identifier = options;
|
|
553
|
+
options = void 0;
|
|
554
|
+
}
|
|
555
|
+
try {
|
|
556
|
+
return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
|
|
557
|
+
} catch (er) {
|
|
558
|
+
return null;
|
|
559
|
+
}
|
|
560
|
+
};
|
|
561
|
+
module.exports = inc;
|
|
562
|
+
}));
|
|
563
|
+
//#endregion
|
|
564
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/diff.js
|
|
565
|
+
var require_diff = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
566
|
+
const parse = require_parse();
|
|
567
|
+
const diff = (version1, version2) => {
|
|
568
|
+
const v1 = parse(version1, null, true);
|
|
569
|
+
const v2 = parse(version2, null, true);
|
|
570
|
+
const comparison = v1.compare(v2);
|
|
571
|
+
if (comparison === 0) return null;
|
|
572
|
+
const v1Higher = comparison > 0;
|
|
573
|
+
const highVersion = v1Higher ? v1 : v2;
|
|
574
|
+
const lowVersion = v1Higher ? v2 : v1;
|
|
575
|
+
const highHasPre = !!highVersion.prerelease.length;
|
|
576
|
+
if (!!lowVersion.prerelease.length && !highHasPre) {
|
|
577
|
+
if (!lowVersion.patch && !lowVersion.minor) return "major";
|
|
578
|
+
if (lowVersion.compareMain(highVersion) === 0) {
|
|
579
|
+
if (lowVersion.minor && !lowVersion.patch) return "minor";
|
|
580
|
+
return "patch";
|
|
581
|
+
}
|
|
582
|
+
}
|
|
583
|
+
const prefix = highHasPre ? "pre" : "";
|
|
584
|
+
if (v1.major !== v2.major) return prefix + "major";
|
|
585
|
+
if (v1.minor !== v2.minor) return prefix + "minor";
|
|
586
|
+
if (v1.patch !== v2.patch) return prefix + "patch";
|
|
587
|
+
return "prerelease";
|
|
588
|
+
};
|
|
589
|
+
module.exports = diff;
|
|
590
|
+
}));
|
|
591
|
+
//#endregion
|
|
592
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/major.js
|
|
593
|
+
var require_major = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
594
|
+
const SemVer = require_semver$1();
|
|
595
|
+
const major = (a, loose) => new SemVer(a, loose).major;
|
|
596
|
+
module.exports = major;
|
|
597
|
+
}));
|
|
598
|
+
//#endregion
|
|
599
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/minor.js
|
|
600
|
+
var require_minor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
601
|
+
const SemVer = require_semver$1();
|
|
602
|
+
const minor = (a, loose) => new SemVer(a, loose).minor;
|
|
603
|
+
module.exports = minor;
|
|
604
|
+
}));
|
|
605
|
+
//#endregion
|
|
606
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/patch.js
|
|
607
|
+
var require_patch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
608
|
+
const SemVer = require_semver$1();
|
|
609
|
+
const patch = (a, loose) => new SemVer(a, loose).patch;
|
|
610
|
+
module.exports = patch;
|
|
611
|
+
}));
|
|
612
|
+
//#endregion
|
|
613
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js
|
|
614
|
+
var require_prerelease = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
615
|
+
const parse = require_parse();
|
|
616
|
+
const prerelease = (version, options) => {
|
|
617
|
+
const parsed = parse(version, options);
|
|
618
|
+
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
|
|
619
|
+
};
|
|
620
|
+
module.exports = prerelease;
|
|
621
|
+
}));
|
|
622
|
+
//#endregion
|
|
623
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
|
|
624
|
+
var require_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
625
|
+
const SemVer = require_semver$1();
|
|
626
|
+
const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
|
|
627
|
+
module.exports = compare;
|
|
628
|
+
}));
|
|
629
|
+
//#endregion
|
|
630
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js
|
|
631
|
+
var require_rcompare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
632
|
+
const compare = require_compare();
|
|
633
|
+
const rcompare = (a, b, loose) => compare(b, a, loose);
|
|
634
|
+
module.exports = rcompare;
|
|
635
|
+
}));
|
|
636
|
+
//#endregion
|
|
637
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-loose.js
|
|
638
|
+
var require_compare_loose = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
639
|
+
const compare = require_compare();
|
|
640
|
+
const compareLoose = (a, b) => compare(a, b, true);
|
|
641
|
+
module.exports = compareLoose;
|
|
642
|
+
}));
|
|
643
|
+
//#endregion
|
|
644
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-build.js
|
|
645
|
+
var require_compare_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
646
|
+
const SemVer = require_semver$1();
|
|
647
|
+
const compareBuild = (a, b, loose) => {
|
|
648
|
+
const versionA = new SemVer(a, loose);
|
|
649
|
+
const versionB = new SemVer(b, loose);
|
|
650
|
+
return versionA.compare(versionB) || versionA.compareBuild(versionB);
|
|
651
|
+
};
|
|
652
|
+
module.exports = compareBuild;
|
|
653
|
+
}));
|
|
654
|
+
//#endregion
|
|
655
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/sort.js
|
|
656
|
+
var require_sort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
657
|
+
const compareBuild = require_compare_build();
|
|
658
|
+
const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
|
|
659
|
+
module.exports = sort;
|
|
660
|
+
}));
|
|
661
|
+
//#endregion
|
|
662
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rsort.js
|
|
663
|
+
var require_rsort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
664
|
+
const compareBuild = require_compare_build();
|
|
665
|
+
const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
|
|
666
|
+
module.exports = rsort;
|
|
667
|
+
}));
|
|
668
|
+
//#endregion
|
|
669
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js
|
|
670
|
+
var require_gt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
671
|
+
const compare = require_compare();
|
|
672
|
+
const gt = (a, b, loose) => compare(a, b, loose) > 0;
|
|
673
|
+
module.exports = gt;
|
|
674
|
+
}));
|
|
675
|
+
//#endregion
|
|
676
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js
|
|
677
|
+
var require_lt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
678
|
+
const compare = require_compare();
|
|
679
|
+
const lt = (a, b, loose) => compare(a, b, loose) < 0;
|
|
680
|
+
module.exports = lt;
|
|
681
|
+
}));
|
|
682
|
+
//#endregion
|
|
683
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js
|
|
684
|
+
var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
685
|
+
const compare = require_compare();
|
|
686
|
+
const eq = (a, b, loose) => compare(a, b, loose) === 0;
|
|
687
|
+
module.exports = eq;
|
|
688
|
+
}));
|
|
689
|
+
//#endregion
|
|
690
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js
|
|
691
|
+
var require_neq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
692
|
+
const compare = require_compare();
|
|
693
|
+
const neq = (a, b, loose) => compare(a, b, loose) !== 0;
|
|
694
|
+
module.exports = neq;
|
|
695
|
+
}));
|
|
696
|
+
//#endregion
|
|
697
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js
|
|
698
|
+
var require_gte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
699
|
+
const compare = require_compare();
|
|
700
|
+
const gte = (a, b, loose) => compare(a, b, loose) >= 0;
|
|
701
|
+
module.exports = gte;
|
|
702
|
+
}));
|
|
703
|
+
//#endregion
|
|
704
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js
|
|
705
|
+
var require_lte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
706
|
+
const compare = require_compare();
|
|
707
|
+
const lte = (a, b, loose) => compare(a, b, loose) <= 0;
|
|
708
|
+
module.exports = lte;
|
|
709
|
+
}));
|
|
710
|
+
//#endregion
|
|
711
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js
|
|
712
|
+
var require_cmp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
713
|
+
const eq = require_eq();
|
|
714
|
+
const neq = require_neq();
|
|
715
|
+
const gt = require_gt();
|
|
716
|
+
const gte = require_gte();
|
|
717
|
+
const lt = require_lt();
|
|
718
|
+
const lte = require_lte();
|
|
719
|
+
const cmp = (a, op, b, loose) => {
|
|
720
|
+
switch (op) {
|
|
721
|
+
case "===":
|
|
722
|
+
if (typeof a === "object") a = a.version;
|
|
723
|
+
if (typeof b === "object") b = b.version;
|
|
724
|
+
return a === b;
|
|
725
|
+
case "!==":
|
|
726
|
+
if (typeof a === "object") a = a.version;
|
|
727
|
+
if (typeof b === "object") b = b.version;
|
|
728
|
+
return a !== b;
|
|
729
|
+
case "":
|
|
730
|
+
case "=":
|
|
731
|
+
case "==": return eq(a, b, loose);
|
|
732
|
+
case "!=": return neq(a, b, loose);
|
|
733
|
+
case ">": return gt(a, b, loose);
|
|
734
|
+
case ">=": return gte(a, b, loose);
|
|
735
|
+
case "<": return lt(a, b, loose);
|
|
736
|
+
case "<=": return lte(a, b, loose);
|
|
737
|
+
default: throw new TypeError(`Invalid operator: ${op}`);
|
|
738
|
+
}
|
|
739
|
+
};
|
|
740
|
+
module.exports = cmp;
|
|
741
|
+
}));
|
|
742
|
+
//#endregion
|
|
743
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/coerce.js
|
|
744
|
+
var require_coerce = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
745
|
+
const SemVer = require_semver$1();
|
|
746
|
+
const parse = require_parse();
|
|
747
|
+
const { safeRe: re, t } = require_re();
|
|
748
|
+
const coerce = (version, options) => {
|
|
749
|
+
if (version instanceof SemVer) return version;
|
|
750
|
+
if (typeof version === "number") version = String(version);
|
|
751
|
+
if (typeof version !== "string") return null;
|
|
752
|
+
options = options || {};
|
|
753
|
+
let match = null;
|
|
754
|
+
if (!options.rtl) match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
|
|
755
|
+
else {
|
|
756
|
+
const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
|
|
757
|
+
let next;
|
|
758
|
+
while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
|
|
759
|
+
if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
|
|
760
|
+
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
|
|
761
|
+
}
|
|
762
|
+
coerceRtlRegex.lastIndex = -1;
|
|
763
|
+
}
|
|
764
|
+
if (match === null) return null;
|
|
765
|
+
const major = match[2];
|
|
766
|
+
const minor = match[3] || "0";
|
|
767
|
+
const patch = match[4] || "0";
|
|
768
|
+
const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
|
|
769
|
+
const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
|
|
770
|
+
return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
|
|
771
|
+
};
|
|
772
|
+
module.exports = coerce;
|
|
773
|
+
}));
|
|
774
|
+
//#endregion
|
|
775
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/truncate.js
|
|
776
|
+
var require_truncate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
777
|
+
const parse = require_parse();
|
|
778
|
+
const constants = require_constants();
|
|
779
|
+
const SemVer = require_semver$1();
|
|
780
|
+
const truncate = (version, truncation, options) => {
|
|
781
|
+
if (!constants.RELEASE_TYPES.includes(truncation)) return null;
|
|
782
|
+
const clonedVersion = cloneInputVersion(version, options);
|
|
783
|
+
return clonedVersion && doTruncation(clonedVersion, truncation);
|
|
784
|
+
};
|
|
785
|
+
const cloneInputVersion = (version, options) => {
|
|
786
|
+
const versionStringToParse = version instanceof SemVer ? version.version : version;
|
|
787
|
+
return parse(versionStringToParse, options);
|
|
788
|
+
};
|
|
789
|
+
const doTruncation = (version, truncation) => {
|
|
790
|
+
if (isPrerelease(truncation)) return version.version;
|
|
791
|
+
version.prerelease = [];
|
|
792
|
+
switch (truncation) {
|
|
793
|
+
case "major":
|
|
794
|
+
version.minor = 0;
|
|
795
|
+
version.patch = 0;
|
|
796
|
+
break;
|
|
797
|
+
case "minor": version.patch = 0;
|
|
798
|
+
}
|
|
799
|
+
return version.format();
|
|
800
|
+
};
|
|
801
|
+
const isPrerelease = (type) => {
|
|
802
|
+
return type.startsWith("pre");
|
|
803
|
+
};
|
|
804
|
+
module.exports = truncate;
|
|
805
|
+
}));
|
|
806
|
+
//#endregion
|
|
807
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js
|
|
808
|
+
var require_lrucache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
809
|
+
var LRUCache = class {
|
|
810
|
+
constructor() {
|
|
811
|
+
this.max = 1e3;
|
|
812
|
+
this.map = /* @__PURE__ */ new Map();
|
|
813
|
+
}
|
|
814
|
+
get(key) {
|
|
815
|
+
const value = this.map.get(key);
|
|
816
|
+
if (value === void 0) return;
|
|
817
|
+
else {
|
|
818
|
+
this.map.delete(key);
|
|
819
|
+
this.map.set(key, value);
|
|
820
|
+
return value;
|
|
821
|
+
}
|
|
822
|
+
}
|
|
823
|
+
delete(key) {
|
|
824
|
+
return this.map.delete(key);
|
|
825
|
+
}
|
|
826
|
+
set(key, value) {
|
|
827
|
+
if (!this.delete(key) && value !== void 0) {
|
|
828
|
+
if (this.map.size >= this.max) {
|
|
829
|
+
const firstKey = this.map.keys().next().value;
|
|
830
|
+
this.delete(firstKey);
|
|
831
|
+
}
|
|
832
|
+
this.map.set(key, value);
|
|
833
|
+
}
|
|
834
|
+
return this;
|
|
835
|
+
}
|
|
836
|
+
};
|
|
837
|
+
module.exports = LRUCache;
|
|
838
|
+
}));
|
|
839
|
+
//#endregion
|
|
840
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js
|
|
841
|
+
var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
842
|
+
const SPACE_CHARACTERS = /\s+/g;
|
|
843
|
+
module.exports = class Range {
|
|
844
|
+
constructor(range, options) {
|
|
845
|
+
options = parseOptions(options);
|
|
846
|
+
if (range instanceof Range) {
|
|
847
|
+
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
|
|
848
|
+
else return new Range(range.raw, options);
|
|
849
|
+
}
|
|
850
|
+
if (range instanceof Comparator) {
|
|
851
|
+
this.raw = range.value;
|
|
852
|
+
this.set = [[range]];
|
|
853
|
+
this.formatted = void 0;
|
|
854
|
+
return this;
|
|
855
|
+
}
|
|
856
|
+
this.options = options;
|
|
857
|
+
this.loose = !!options.loose;
|
|
858
|
+
this.includePrerelease = !!options.includePrerelease;
|
|
859
|
+
this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
|
|
860
|
+
this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
|
|
861
|
+
if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
|
|
862
|
+
if (this.set.length > 1) {
|
|
863
|
+
const first = this.set[0];
|
|
864
|
+
this.set = this.set.filter((c) => !isNullSet(c[0]));
|
|
865
|
+
if (this.set.length === 0) this.set = [first];
|
|
866
|
+
else if (this.set.length > 1) {
|
|
867
|
+
for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
|
|
868
|
+
this.set = [c];
|
|
869
|
+
break;
|
|
870
|
+
}
|
|
871
|
+
}
|
|
872
|
+
}
|
|
873
|
+
this.formatted = void 0;
|
|
874
|
+
}
|
|
875
|
+
get range() {
|
|
876
|
+
if (this.formatted === void 0) {
|
|
877
|
+
this.formatted = "";
|
|
878
|
+
for (let i = 0; i < this.set.length; i++) {
|
|
879
|
+
if (i > 0) this.formatted += "||";
|
|
880
|
+
const comps = this.set[i];
|
|
881
|
+
for (let k = 0; k < comps.length; k++) {
|
|
882
|
+
if (k > 0) this.formatted += " ";
|
|
883
|
+
this.formatted += comps[k].toString().trim();
|
|
884
|
+
}
|
|
885
|
+
}
|
|
886
|
+
}
|
|
887
|
+
return this.formatted;
|
|
888
|
+
}
|
|
889
|
+
format() {
|
|
890
|
+
return this.range;
|
|
891
|
+
}
|
|
892
|
+
toString() {
|
|
893
|
+
return this.range;
|
|
894
|
+
}
|
|
895
|
+
parseRange(range) {
|
|
896
|
+
range = range.replace(BUILDSTRIPRE, "");
|
|
897
|
+
const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
|
|
898
|
+
const cached = cache.get(memoKey);
|
|
899
|
+
if (cached) return cached;
|
|
900
|
+
const loose = this.options.loose;
|
|
901
|
+
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
|
|
902
|
+
range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
|
|
903
|
+
debug("hyphen replace", range);
|
|
904
|
+
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
|
|
905
|
+
debug("comparator trim", range);
|
|
906
|
+
range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
|
|
907
|
+
debug("tilde trim", range);
|
|
908
|
+
range = range.replace(re[t.CARETTRIM], caretTrimReplace);
|
|
909
|
+
debug("caret trim", range);
|
|
910
|
+
let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
|
|
911
|
+
if (loose) rangeList = rangeList.filter((comp) => {
|
|
912
|
+
debug("loose invalid filter", comp, this.options);
|
|
913
|
+
return !!comp.match(re[t.COMPARATORLOOSE]);
|
|
914
|
+
});
|
|
915
|
+
debug("range list", rangeList);
|
|
916
|
+
const rangeMap = /* @__PURE__ */ new Map();
|
|
917
|
+
const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
|
|
918
|
+
for (const comp of comparators) {
|
|
919
|
+
if (isNullSet(comp)) return [comp];
|
|
920
|
+
rangeMap.set(comp.value, comp);
|
|
921
|
+
}
|
|
922
|
+
if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
|
|
923
|
+
const result = [...rangeMap.values()];
|
|
924
|
+
cache.set(memoKey, result);
|
|
925
|
+
return result;
|
|
926
|
+
}
|
|
927
|
+
intersects(range, options) {
|
|
928
|
+
if (!(range instanceof Range)) throw new TypeError("a Range is required");
|
|
929
|
+
return this.set.some((thisComparators) => {
|
|
930
|
+
return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
|
|
931
|
+
return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
|
|
932
|
+
return rangeComparators.every((rangeComparator) => {
|
|
933
|
+
return thisComparator.intersects(rangeComparator, options);
|
|
934
|
+
});
|
|
935
|
+
});
|
|
936
|
+
});
|
|
937
|
+
});
|
|
938
|
+
}
|
|
939
|
+
test(version) {
|
|
940
|
+
if (!version) return false;
|
|
941
|
+
if (typeof version === "string") try {
|
|
942
|
+
version = new SemVer(version, this.options);
|
|
943
|
+
} catch (er) {
|
|
944
|
+
return false;
|
|
945
|
+
}
|
|
946
|
+
for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
|
|
947
|
+
return false;
|
|
948
|
+
}
|
|
949
|
+
};
|
|
950
|
+
const cache = new (require_lrucache())();
|
|
951
|
+
const parseOptions = require_parse_options();
|
|
952
|
+
const Comparator = require_comparator();
|
|
953
|
+
const debug = require_debug();
|
|
954
|
+
const SemVer = require_semver$1();
|
|
955
|
+
const { safeRe: re, src, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
|
|
956
|
+
const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
|
|
957
|
+
const BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
|
|
958
|
+
const isNullSet = (c) => c.value === "<0.0.0-0";
|
|
959
|
+
const isAny = (c) => c.value === "";
|
|
960
|
+
const isSatisfiable = (comparators, options) => {
|
|
961
|
+
let result = true;
|
|
962
|
+
const remainingComparators = comparators.slice();
|
|
963
|
+
let testComparator = remainingComparators.pop();
|
|
964
|
+
while (result && remainingComparators.length) {
|
|
965
|
+
result = remainingComparators.every((otherComparator) => {
|
|
966
|
+
return testComparator.intersects(otherComparator, options);
|
|
967
|
+
});
|
|
968
|
+
testComparator = remainingComparators.pop();
|
|
969
|
+
}
|
|
970
|
+
return result;
|
|
971
|
+
};
|
|
972
|
+
const parseComparator = (comp, options) => {
|
|
973
|
+
comp = comp.replace(re[t.BUILD], "");
|
|
974
|
+
debug("comp", comp, options);
|
|
975
|
+
comp = replaceCarets(comp, options);
|
|
976
|
+
debug("caret", comp);
|
|
977
|
+
comp = replaceTildes(comp, options);
|
|
978
|
+
debug("tildes", comp);
|
|
979
|
+
comp = replaceXRanges(comp, options);
|
|
980
|
+
debug("xrange", comp);
|
|
981
|
+
comp = replaceStars(comp, options);
|
|
982
|
+
debug("stars", comp);
|
|
983
|
+
return comp;
|
|
984
|
+
};
|
|
985
|
+
const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
|
|
986
|
+
const invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
|
|
987
|
+
const replaceTildes = (comp, options) => {
|
|
988
|
+
return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
|
|
989
|
+
};
|
|
990
|
+
const replaceTilde = (comp, options) => {
|
|
991
|
+
const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
|
|
992
|
+
const z = options.includePrerelease ? "-0" : "";
|
|
993
|
+
return comp.replace(r, (_, M, m, p, pr) => {
|
|
994
|
+
debug("tilde", comp, _, M, m, p, pr);
|
|
995
|
+
let ret;
|
|
996
|
+
if (isX(M)) ret = "";
|
|
997
|
+
else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
|
|
998
|
+
else if (isX(p)) ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
|
|
999
|
+
else if (pr) {
|
|
1000
|
+
debug("replaceTilde pr", pr);
|
|
1001
|
+
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
|
|
1002
|
+
} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
|
|
1003
|
+
debug("tilde return", ret);
|
|
1004
|
+
return ret;
|
|
1005
|
+
});
|
|
1006
|
+
};
|
|
1007
|
+
const replaceCarets = (comp, options) => {
|
|
1008
|
+
return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
|
|
1009
|
+
};
|
|
1010
|
+
const replaceCaret = (comp, options) => {
|
|
1011
|
+
debug("caret", comp, options);
|
|
1012
|
+
const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
|
|
1013
|
+
const z = options.includePrerelease ? "-0" : "";
|
|
1014
|
+
return comp.replace(r, (_, M, m, p, pr) => {
|
|
1015
|
+
debug("caret", comp, _, M, m, p, pr);
|
|
1016
|
+
let ret;
|
|
1017
|
+
if (isX(M)) ret = "";
|
|
1018
|
+
else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
|
|
1019
|
+
else if (isX(p)) {
|
|
1020
|
+
if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
|
|
1021
|
+
else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
|
|
1022
|
+
} else if (pr) {
|
|
1023
|
+
debug("replaceCaret pr", pr);
|
|
1024
|
+
if (M === "0") {
|
|
1025
|
+
if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
|
|
1026
|
+
else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
|
|
1027
|
+
} else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
|
|
1028
|
+
} else {
|
|
1029
|
+
debug("no pr");
|
|
1030
|
+
if (M === "0") {
|
|
1031
|
+
if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
|
|
1032
|
+
else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
|
|
1033
|
+
} else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
|
|
1034
|
+
}
|
|
1035
|
+
debug("caret return", ret);
|
|
1036
|
+
return ret;
|
|
1037
|
+
});
|
|
1038
|
+
};
|
|
1039
|
+
const replaceXRanges = (comp, options) => {
|
|
1040
|
+
debug("replaceXRanges", comp, options);
|
|
1041
|
+
return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
|
|
1042
|
+
};
|
|
1043
|
+
const replaceXRange = (comp, options) => {
|
|
1044
|
+
comp = comp.trim();
|
|
1045
|
+
const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
|
|
1046
|
+
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
|
|
1047
|
+
debug("xRange", comp, ret, gtlt, M, m, p, pr);
|
|
1048
|
+
if (invalidXRangeOrder(M, m, p)) return comp;
|
|
1049
|
+
const xM = isX(M);
|
|
1050
|
+
const xm = xM || isX(m);
|
|
1051
|
+
const xp = xm || isX(p);
|
|
1052
|
+
const anyX = xp;
|
|
1053
|
+
if (gtlt === "=" && anyX) gtlt = "";
|
|
1054
|
+
pr = options.includePrerelease ? "-0" : "";
|
|
1055
|
+
if (xM) {
|
|
1056
|
+
if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
|
|
1057
|
+
else ret = "*";
|
|
1058
|
+
} else if (gtlt && anyX) {
|
|
1059
|
+
if (xm) m = 0;
|
|
1060
|
+
p = 0;
|
|
1061
|
+
if (gtlt === ">") {
|
|
1062
|
+
gtlt = ">=";
|
|
1063
|
+
if (xm) {
|
|
1064
|
+
M = +M + 1;
|
|
1065
|
+
m = 0;
|
|
1066
|
+
p = 0;
|
|
1067
|
+
} else {
|
|
1068
|
+
m = +m + 1;
|
|
1069
|
+
p = 0;
|
|
1070
|
+
}
|
|
1071
|
+
} else if (gtlt === "<=") {
|
|
1072
|
+
gtlt = "<";
|
|
1073
|
+
if (xm) M = +M + 1;
|
|
1074
|
+
else m = +m + 1;
|
|
1075
|
+
}
|
|
1076
|
+
if (gtlt === "<") pr = "-0";
|
|
1077
|
+
ret = `${gtlt + M}.${m}.${p}${pr}`;
|
|
1078
|
+
} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
|
|
1079
|
+
else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
|
|
1080
|
+
debug("xRange return", ret);
|
|
1081
|
+
return ret;
|
|
1082
|
+
});
|
|
1083
|
+
};
|
|
1084
|
+
const replaceStars = (comp, options) => {
|
|
1085
|
+
debug("replaceStars", comp, options);
|
|
1086
|
+
return comp.trim().replace(re[t.STAR], "");
|
|
1087
|
+
};
|
|
1088
|
+
const replaceGTE0 = (comp, options) => {
|
|
1089
|
+
debug("replaceGTE0", comp, options);
|
|
1090
|
+
return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
|
|
1091
|
+
};
|
|
1092
|
+
const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
|
|
1093
|
+
if (isX(fM)) from = "";
|
|
1094
|
+
else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
|
|
1095
|
+
else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
|
|
1096
|
+
else if (fpr) from = `>=${from}`;
|
|
1097
|
+
else from = `>=${from}${incPr ? "-0" : ""}`;
|
|
1098
|
+
if (isX(tM)) to = "";
|
|
1099
|
+
else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
|
|
1100
|
+
else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
|
|
1101
|
+
else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
|
|
1102
|
+
else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
|
|
1103
|
+
else to = `<=${to}`;
|
|
1104
|
+
return `${from} ${to}`.trim();
|
|
1105
|
+
};
|
|
1106
|
+
const testSet = (set, version, options) => {
|
|
1107
|
+
for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
|
|
1108
|
+
if (version.prerelease.length && !options.includePrerelease) {
|
|
1109
|
+
for (let i = 0; i < set.length; i++) {
|
|
1110
|
+
debug(set[i].semver);
|
|
1111
|
+
if (set[i].semver === Comparator.ANY) continue;
|
|
1112
|
+
if (set[i].semver.prerelease.length > 0) {
|
|
1113
|
+
const allowed = set[i].semver;
|
|
1114
|
+
if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
|
|
1115
|
+
}
|
|
1116
|
+
}
|
|
1117
|
+
return false;
|
|
1118
|
+
}
|
|
1119
|
+
return true;
|
|
1120
|
+
};
|
|
1121
|
+
}));
|
|
1122
|
+
//#endregion
|
|
1123
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js
|
|
1124
|
+
var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1125
|
+
const ANY = Symbol("SemVer ANY");
|
|
1126
|
+
module.exports = class Comparator {
|
|
1127
|
+
static get ANY() {
|
|
1128
|
+
return ANY;
|
|
1129
|
+
}
|
|
1130
|
+
constructor(comp, options) {
|
|
1131
|
+
options = parseOptions(options);
|
|
1132
|
+
if (comp instanceof Comparator) {
|
|
1133
|
+
if (comp.loose === !!options.loose) return comp;
|
|
1134
|
+
else comp = comp.value;
|
|
1135
|
+
}
|
|
1136
|
+
comp = comp.trim().split(/\s+/).join(" ");
|
|
1137
|
+
debug("comparator", comp, options);
|
|
1138
|
+
this.options = options;
|
|
1139
|
+
this.loose = !!options.loose;
|
|
1140
|
+
this.parse(comp);
|
|
1141
|
+
if (this.semver === ANY) this.value = "";
|
|
1142
|
+
else this.value = this.operator + this.semver.version;
|
|
1143
|
+
debug("comp", this);
|
|
1144
|
+
}
|
|
1145
|
+
parse(comp) {
|
|
1146
|
+
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
|
|
1147
|
+
const m = comp.match(r);
|
|
1148
|
+
if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
|
|
1149
|
+
this.operator = m[1] !== void 0 ? m[1] : "";
|
|
1150
|
+
if (this.operator === "=") this.operator = "";
|
|
1151
|
+
if (!m[2]) this.semver = ANY;
|
|
1152
|
+
else this.semver = new SemVer(m[2], this.options.loose);
|
|
1153
|
+
}
|
|
1154
|
+
toString() {
|
|
1155
|
+
return this.value;
|
|
1156
|
+
}
|
|
1157
|
+
test(version) {
|
|
1158
|
+
debug("Comparator.test", version, this.options.loose);
|
|
1159
|
+
if (this.semver === ANY || version === ANY) return true;
|
|
1160
|
+
if (typeof version === "string") try {
|
|
1161
|
+
version = new SemVer(version, this.options);
|
|
1162
|
+
} catch (er) {
|
|
1163
|
+
return false;
|
|
1164
|
+
}
|
|
1165
|
+
return cmp(version, this.operator, this.semver, this.options);
|
|
1166
|
+
}
|
|
1167
|
+
intersects(comp, options) {
|
|
1168
|
+
if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
|
|
1169
|
+
if (this.operator === "") {
|
|
1170
|
+
if (this.value === "") return true;
|
|
1171
|
+
return new Range(comp.value, options).test(this.value);
|
|
1172
|
+
} else if (comp.operator === "") {
|
|
1173
|
+
if (comp.value === "") return true;
|
|
1174
|
+
return new Range(this.value, options).test(comp.semver);
|
|
1175
|
+
}
|
|
1176
|
+
options = parseOptions(options);
|
|
1177
|
+
if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
|
|
1178
|
+
if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
|
|
1179
|
+
if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
|
|
1180
|
+
if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
|
|
1181
|
+
if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
|
|
1182
|
+
if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
|
|
1183
|
+
if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
|
|
1184
|
+
return false;
|
|
1185
|
+
}
|
|
1186
|
+
};
|
|
1187
|
+
const parseOptions = require_parse_options();
|
|
1188
|
+
const { safeRe: re, t } = require_re();
|
|
1189
|
+
const cmp = require_cmp();
|
|
1190
|
+
const debug = require_debug();
|
|
1191
|
+
const SemVer = require_semver$1();
|
|
1192
|
+
const Range = require_range();
|
|
1193
|
+
}));
|
|
1194
|
+
//#endregion
|
|
1195
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js
|
|
1196
|
+
var require_satisfies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1197
|
+
const Range = require_range();
|
|
1198
|
+
const satisfies = (version, range, options) => {
|
|
1199
|
+
try {
|
|
1200
|
+
range = new Range(range, options);
|
|
1201
|
+
} catch (er) {
|
|
1202
|
+
return false;
|
|
1203
|
+
}
|
|
1204
|
+
return range.test(version);
|
|
1205
|
+
};
|
|
1206
|
+
module.exports = satisfies;
|
|
1207
|
+
}));
|
|
1208
|
+
//#endregion
|
|
1209
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/to-comparators.js
|
|
1210
|
+
var require_to_comparators = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1211
|
+
const Range = require_range();
|
|
1212
|
+
const toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
|
|
1213
|
+
module.exports = toComparators;
|
|
1214
|
+
}));
|
|
1215
|
+
//#endregion
|
|
1216
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/max-satisfying.js
|
|
1217
|
+
var require_max_satisfying = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1218
|
+
const SemVer = require_semver$1();
|
|
1219
|
+
const Range = require_range();
|
|
1220
|
+
const maxSatisfying = (versions, range, options) => {
|
|
1221
|
+
let max = null;
|
|
1222
|
+
let maxSV = null;
|
|
1223
|
+
let rangeObj = null;
|
|
1224
|
+
try {
|
|
1225
|
+
rangeObj = new Range(range, options);
|
|
1226
|
+
} catch (er) {
|
|
1227
|
+
return null;
|
|
1228
|
+
}
|
|
1229
|
+
versions.forEach((v) => {
|
|
1230
|
+
if (rangeObj.test(v)) {
|
|
1231
|
+
if (!max || maxSV.compare(v) === -1) {
|
|
1232
|
+
max = v;
|
|
1233
|
+
maxSV = new SemVer(max, options);
|
|
1234
|
+
}
|
|
1235
|
+
}
|
|
1236
|
+
});
|
|
1237
|
+
return max;
|
|
1238
|
+
};
|
|
1239
|
+
module.exports = maxSatisfying;
|
|
1240
|
+
}));
|
|
1241
|
+
//#endregion
|
|
1242
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-satisfying.js
|
|
1243
|
+
var require_min_satisfying = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1244
|
+
const SemVer = require_semver$1();
|
|
1245
|
+
const Range = require_range();
|
|
1246
|
+
const minSatisfying = (versions, range, options) => {
|
|
1247
|
+
let min = null;
|
|
1248
|
+
let minSV = null;
|
|
1249
|
+
let rangeObj = null;
|
|
1250
|
+
try {
|
|
1251
|
+
rangeObj = new Range(range, options);
|
|
1252
|
+
} catch (er) {
|
|
1253
|
+
return null;
|
|
1254
|
+
}
|
|
1255
|
+
versions.forEach((v) => {
|
|
1256
|
+
if (rangeObj.test(v)) {
|
|
1257
|
+
if (!min || minSV.compare(v) === 1) {
|
|
1258
|
+
min = v;
|
|
1259
|
+
minSV = new SemVer(min, options);
|
|
1260
|
+
}
|
|
1261
|
+
}
|
|
1262
|
+
});
|
|
1263
|
+
return min;
|
|
1264
|
+
};
|
|
1265
|
+
module.exports = minSatisfying;
|
|
1266
|
+
}));
|
|
1267
|
+
//#endregion
|
|
1268
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-version.js
|
|
1269
|
+
var require_min_version = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1270
|
+
const SemVer = require_semver$1();
|
|
1271
|
+
const Range = require_range();
|
|
1272
|
+
const gt = require_gt();
|
|
1273
|
+
const minVersion = (range, loose) => {
|
|
1274
|
+
range = new Range(range, loose);
|
|
1275
|
+
let minver = new SemVer("0.0.0");
|
|
1276
|
+
if (range.test(minver)) return minver;
|
|
1277
|
+
minver = new SemVer("0.0.0-0");
|
|
1278
|
+
if (range.test(minver)) return minver;
|
|
1279
|
+
minver = null;
|
|
1280
|
+
for (let i = 0; i < range.set.length; ++i) {
|
|
1281
|
+
const comparators = range.set[i];
|
|
1282
|
+
let setMin = null;
|
|
1283
|
+
comparators.forEach((comparator) => {
|
|
1284
|
+
const compver = new SemVer(comparator.semver.version);
|
|
1285
|
+
switch (comparator.operator) {
|
|
1286
|
+
case ">":
|
|
1287
|
+
if (compver.prerelease.length === 0) compver.patch++;
|
|
1288
|
+
else compver.prerelease.push(0);
|
|
1289
|
+
compver.raw = compver.format();
|
|
1290
|
+
case "":
|
|
1291
|
+
case ">=":
|
|
1292
|
+
if (!setMin || gt(compver, setMin)) setMin = compver;
|
|
1293
|
+
break;
|
|
1294
|
+
case "<":
|
|
1295
|
+
case "<=": break;
|
|
1296
|
+
/* istanbul ignore next */
|
|
1297
|
+
default: throw new Error(`Unexpected operation: ${comparator.operator}`);
|
|
1298
|
+
}
|
|
1299
|
+
});
|
|
1300
|
+
if (setMin && (!minver || gt(minver, setMin))) minver = setMin;
|
|
1301
|
+
}
|
|
1302
|
+
if (minver && range.test(minver)) return minver;
|
|
1303
|
+
return null;
|
|
1304
|
+
};
|
|
1305
|
+
module.exports = minVersion;
|
|
1306
|
+
}));
|
|
1307
|
+
//#endregion
|
|
1308
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js
|
|
1309
|
+
var require_valid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1310
|
+
const Range = require_range();
|
|
1311
|
+
const validRange = (range, options) => {
|
|
1312
|
+
try {
|
|
1313
|
+
return new Range(range, options).range || "*";
|
|
1314
|
+
} catch (er) {
|
|
1315
|
+
return null;
|
|
1316
|
+
}
|
|
1317
|
+
};
|
|
1318
|
+
module.exports = validRange;
|
|
1319
|
+
}));
|
|
1320
|
+
//#endregion
|
|
1321
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/outside.js
|
|
1322
|
+
var require_outside = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1323
|
+
const SemVer = require_semver$1();
|
|
1324
|
+
const Comparator = require_comparator();
|
|
1325
|
+
const { ANY } = Comparator;
|
|
1326
|
+
const Range = require_range();
|
|
1327
|
+
const satisfies = require_satisfies();
|
|
1328
|
+
const gt = require_gt();
|
|
1329
|
+
const lt = require_lt();
|
|
1330
|
+
const lte = require_lte();
|
|
1331
|
+
const gte = require_gte();
|
|
1332
|
+
const outside = (version, range, hilo, options) => {
|
|
1333
|
+
version = new SemVer(version, options);
|
|
1334
|
+
range = new Range(range, options);
|
|
1335
|
+
let gtfn, ltefn, ltfn, comp, ecomp;
|
|
1336
|
+
switch (hilo) {
|
|
1337
|
+
case ">":
|
|
1338
|
+
gtfn = gt;
|
|
1339
|
+
ltefn = lte;
|
|
1340
|
+
ltfn = lt;
|
|
1341
|
+
comp = ">";
|
|
1342
|
+
ecomp = ">=";
|
|
1343
|
+
break;
|
|
1344
|
+
case "<":
|
|
1345
|
+
gtfn = lt;
|
|
1346
|
+
ltefn = gte;
|
|
1347
|
+
ltfn = gt;
|
|
1348
|
+
comp = "<";
|
|
1349
|
+
ecomp = "<=";
|
|
1350
|
+
break;
|
|
1351
|
+
default: throw new TypeError("Must provide a hilo val of \"<\" or \">\"");
|
|
1352
|
+
}
|
|
1353
|
+
if (satisfies(version, range, options)) return false;
|
|
1354
|
+
for (let i = 0; i < range.set.length; ++i) {
|
|
1355
|
+
const comparators = range.set[i];
|
|
1356
|
+
let high = null;
|
|
1357
|
+
let low = null;
|
|
1358
|
+
comparators.forEach((comparator) => {
|
|
1359
|
+
if (comparator.semver === ANY) comparator = new Comparator(">=0.0.0");
|
|
1360
|
+
high = high || comparator;
|
|
1361
|
+
low = low || comparator;
|
|
1362
|
+
if (gtfn(comparator.semver, high.semver, options)) high = comparator;
|
|
1363
|
+
else if (ltfn(comparator.semver, low.semver, options)) low = comparator;
|
|
1364
|
+
});
|
|
1365
|
+
if (high.operator === comp || high.operator === ecomp) return false;
|
|
1366
|
+
if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;
|
|
1367
|
+
else if (low.operator === ecomp && ltfn(version, low.semver)) return false;
|
|
1368
|
+
}
|
|
1369
|
+
return true;
|
|
1370
|
+
};
|
|
1371
|
+
module.exports = outside;
|
|
1372
|
+
}));
|
|
1373
|
+
//#endregion
|
|
1374
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/gtr.js
|
|
1375
|
+
var require_gtr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1376
|
+
const outside = require_outside();
|
|
1377
|
+
const gtr = (version, range, options) => outside(version, range, ">", options);
|
|
1378
|
+
module.exports = gtr;
|
|
1379
|
+
}));
|
|
1380
|
+
//#endregion
|
|
1381
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/ltr.js
|
|
1382
|
+
var require_ltr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1383
|
+
const outside = require_outside();
|
|
1384
|
+
const ltr = (version, range, options) => outside(version, range, "<", options);
|
|
1385
|
+
module.exports = ltr;
|
|
1386
|
+
}));
|
|
1387
|
+
//#endregion
|
|
1388
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/intersects.js
|
|
1389
|
+
var require_intersects = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1390
|
+
const Range = require_range();
|
|
1391
|
+
const intersects = (r1, r2, options) => {
|
|
1392
|
+
r1 = new Range(r1, options);
|
|
1393
|
+
r2 = new Range(r2, options);
|
|
1394
|
+
return r1.intersects(r2, options);
|
|
1395
|
+
};
|
|
1396
|
+
module.exports = intersects;
|
|
1397
|
+
}));
|
|
1398
|
+
//#endregion
|
|
1399
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/simplify.js
|
|
1400
|
+
var require_simplify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1401
|
+
const satisfies = require_satisfies();
|
|
1402
|
+
const compare = require_compare();
|
|
1403
|
+
module.exports = (versions, range, options) => {
|
|
1404
|
+
const set = [];
|
|
1405
|
+
let first = null;
|
|
1406
|
+
let prev = null;
|
|
1407
|
+
const v = versions.sort((a, b) => compare(a, b, options));
|
|
1408
|
+
for (const version of v) if (satisfies(version, range, options)) {
|
|
1409
|
+
prev = version;
|
|
1410
|
+
if (!first) first = version;
|
|
1411
|
+
} else {
|
|
1412
|
+
if (prev) set.push([first, prev]);
|
|
1413
|
+
prev = null;
|
|
1414
|
+
first = null;
|
|
1415
|
+
}
|
|
1416
|
+
if (first) set.push([first, null]);
|
|
1417
|
+
const ranges = [];
|
|
1418
|
+
for (const [min, max] of set) if (min === max) ranges.push(min);
|
|
1419
|
+
else if (!max && min === v[0]) ranges.push("*");
|
|
1420
|
+
else if (!max) ranges.push(`>=${min}`);
|
|
1421
|
+
else if (min === v[0]) ranges.push(`<=${max}`);
|
|
1422
|
+
else ranges.push(`${min} - ${max}`);
|
|
1423
|
+
const simplified = ranges.join(" || ");
|
|
1424
|
+
const original = typeof range.raw === "string" ? range.raw : String(range);
|
|
1425
|
+
return simplified.length < original.length ? simplified : range;
|
|
1426
|
+
};
|
|
1427
|
+
}));
|
|
1428
|
+
//#endregion
|
|
1429
|
+
//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/subset.js
|
|
1430
|
+
var require_subset = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1431
|
+
const Range = require_range();
|
|
1432
|
+
const Comparator = require_comparator();
|
|
1433
|
+
const { ANY } = Comparator;
|
|
1434
|
+
const satisfies = require_satisfies();
|
|
1435
|
+
const compare = require_compare();
|
|
1436
|
+
const subset = (sub, dom, options = {}) => {
|
|
1437
|
+
if (sub === dom) return true;
|
|
1438
|
+
sub = new Range(sub, options);
|
|
1439
|
+
dom = new Range(dom, options);
|
|
1440
|
+
let sawNonNull = false;
|
|
1441
|
+
OUTER: for (const simpleSub of sub.set) {
|
|
1442
|
+
for (const simpleDom of dom.set) {
|
|
1443
|
+
const isSub = simpleSubset(simpleSub, simpleDom, options);
|
|
1444
|
+
sawNonNull = sawNonNull || isSub !== null;
|
|
1445
|
+
if (isSub) continue OUTER;
|
|
1446
|
+
}
|
|
1447
|
+
if (sawNonNull) return false;
|
|
1448
|
+
}
|
|
1449
|
+
return true;
|
|
1450
|
+
};
|
|
1451
|
+
const minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
|
|
1452
|
+
const minimumVersion = [new Comparator(">=0.0.0")];
|
|
1453
|
+
const simpleSubset = (sub, dom, options) => {
|
|
1454
|
+
if (sub === dom) return true;
|
|
1455
|
+
if (sub.length === 1 && sub[0].semver === ANY) {
|
|
1456
|
+
if (dom.length === 1 && dom[0].semver === ANY) return true;
|
|
1457
|
+
else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
|
|
1458
|
+
else sub = minimumVersion;
|
|
1459
|
+
}
|
|
1460
|
+
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
1461
|
+
if (options.includePrerelease) return true;
|
|
1462
|
+
else dom = minimumVersion;
|
|
1463
|
+
}
|
|
1464
|
+
const eqSet = /* @__PURE__ */ new Set();
|
|
1465
|
+
let gt, lt;
|
|
1466
|
+
for (const c of sub) if (c.operator === ">" || c.operator === ">=") gt = higherGT(gt, c, options);
|
|
1467
|
+
else if (c.operator === "<" || c.operator === "<=") lt = lowerLT(lt, c, options);
|
|
1468
|
+
else eqSet.add(c.semver);
|
|
1469
|
+
if (eqSet.size > 1) return null;
|
|
1470
|
+
let gtltComp;
|
|
1471
|
+
if (gt && lt) {
|
|
1472
|
+
gtltComp = compare(gt.semver, lt.semver, options);
|
|
1473
|
+
if (gtltComp > 0) return null;
|
|
1474
|
+
else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) return null;
|
|
1475
|
+
}
|
|
1476
|
+
for (const eq of eqSet) {
|
|
1477
|
+
if (gt && !satisfies(eq, String(gt), options)) return null;
|
|
1478
|
+
if (lt && !satisfies(eq, String(lt), options)) return null;
|
|
1479
|
+
for (const c of dom) if (!satisfies(eq, String(c), options)) return false;
|
|
1480
|
+
return true;
|
|
1481
|
+
}
|
|
1482
|
+
let higher, lower;
|
|
1483
|
+
let hasDomLT, hasDomGT;
|
|
1484
|
+
let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
|
|
1485
|
+
let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
|
|
1486
|
+
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) needDomLTPre = false;
|
|
1487
|
+
for (const c of dom) {
|
|
1488
|
+
hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
|
|
1489
|
+
hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
|
|
1490
|
+
if (gt) {
|
|
1491
|
+
if (needDomGTPre) {
|
|
1492
|
+
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;
|
|
1493
|
+
}
|
|
1494
|
+
if (c.operator === ">" || c.operator === ">=") {
|
|
1495
|
+
higher = higherGT(gt, c, options);
|
|
1496
|
+
if (higher === c && higher !== gt) return false;
|
|
1497
|
+
} else if (gt.operator === ">=" && !c.test(gt.semver)) return false;
|
|
1498
|
+
}
|
|
1499
|
+
if (lt) {
|
|
1500
|
+
if (needDomLTPre) {
|
|
1501
|
+
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;
|
|
1502
|
+
}
|
|
1503
|
+
if (c.operator === "<" || c.operator === "<=") {
|
|
1504
|
+
lower = lowerLT(lt, c, options);
|
|
1505
|
+
if (lower === c && lower !== lt) return false;
|
|
1506
|
+
} else if (lt.operator === "<=" && !c.test(lt.semver)) return false;
|
|
1507
|
+
}
|
|
1508
|
+
if (!c.operator && (lt || gt) && gtltComp !== 0) return false;
|
|
1509
|
+
}
|
|
1510
|
+
if (gt && hasDomLT && !lt && gtltComp !== 0) return false;
|
|
1511
|
+
if (lt && hasDomGT && !gt && gtltComp !== 0) return false;
|
|
1512
|
+
if (needDomGTPre || needDomLTPre) return false;
|
|
1513
|
+
return true;
|
|
1514
|
+
};
|
|
1515
|
+
const higherGT = (a, b, options) => {
|
|
1516
|
+
if (!a) return b;
|
|
1517
|
+
const comp = compare(a.semver, b.semver, options);
|
|
1518
|
+
return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
|
|
1519
|
+
};
|
|
1520
|
+
const lowerLT = (a, b, options) => {
|
|
1521
|
+
if (!a) return b;
|
|
1522
|
+
const comp = compare(a.semver, b.semver, options);
|
|
1523
|
+
return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
|
|
1524
|
+
};
|
|
1525
|
+
module.exports = subset;
|
|
1526
|
+
}));
|
|
1527
|
+
(/* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
1528
|
+
const internalRe = require_re();
|
|
1529
|
+
const constants = require_constants();
|
|
1530
|
+
const SemVer = require_semver$1();
|
|
1531
|
+
const identifiers = require_identifiers();
|
|
1532
|
+
module.exports = {
|
|
1533
|
+
parse: require_parse(),
|
|
1534
|
+
valid: require_valid$1(),
|
|
1535
|
+
clean: require_clean(),
|
|
1536
|
+
inc: require_inc(),
|
|
1537
|
+
diff: require_diff(),
|
|
1538
|
+
major: require_major(),
|
|
1539
|
+
minor: require_minor(),
|
|
1540
|
+
patch: require_patch(),
|
|
1541
|
+
prerelease: require_prerelease(),
|
|
1542
|
+
compare: require_compare(),
|
|
1543
|
+
rcompare: require_rcompare(),
|
|
1544
|
+
compareLoose: require_compare_loose(),
|
|
1545
|
+
compareBuild: require_compare_build(),
|
|
1546
|
+
sort: require_sort(),
|
|
1547
|
+
rsort: require_rsort(),
|
|
1548
|
+
gt: require_gt(),
|
|
1549
|
+
lt: require_lt(),
|
|
1550
|
+
eq: require_eq(),
|
|
1551
|
+
neq: require_neq(),
|
|
1552
|
+
gte: require_gte(),
|
|
1553
|
+
lte: require_lte(),
|
|
1554
|
+
cmp: require_cmp(),
|
|
1555
|
+
coerce: require_coerce(),
|
|
1556
|
+
truncate: require_truncate(),
|
|
1557
|
+
Comparator: require_comparator(),
|
|
1558
|
+
Range: require_range(),
|
|
1559
|
+
satisfies: require_satisfies(),
|
|
1560
|
+
toComparators: require_to_comparators(),
|
|
1561
|
+
maxSatisfying: require_max_satisfying(),
|
|
1562
|
+
minSatisfying: require_min_satisfying(),
|
|
1563
|
+
minVersion: require_min_version(),
|
|
1564
|
+
validRange: require_valid(),
|
|
1565
|
+
outside: require_outside(),
|
|
1566
|
+
gtr: require_gtr(),
|
|
1567
|
+
ltr: require_ltr(),
|
|
1568
|
+
intersects: require_intersects(),
|
|
1569
|
+
simplifyRange: require_simplify(),
|
|
1570
|
+
subset: require_subset(),
|
|
1571
|
+
SemVer,
|
|
1572
|
+
re: internalRe.re,
|
|
1573
|
+
src: internalRe.src,
|
|
1574
|
+
tokens: internalRe.t,
|
|
1575
|
+
SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
|
|
1576
|
+
RELEASE_TYPES: constants.RELEASE_TYPES,
|
|
1577
|
+
compareIdentifiers: identifiers.compareIdentifiers,
|
|
1578
|
+
rcompareIdentifiers: identifiers.rcompareIdentifiers
|
|
1579
|
+
};
|
|
1580
|
+
})))();
|
|
1581
|
+
const AI_PLATFORMS = ["chatgpt", "claudeai"];
|
|
1582
|
+
const platformSchema = z.enum(AI_PLATFORMS);
|
|
173
1583
|
const PLATFORM_LABELS = {
|
|
174
1584
|
chatgpt: "ChatGPT",
|
|
175
1585
|
claudeai: "Claude.ai"
|
|
176
1586
|
};
|
|
1587
|
+
const WAF_PLATFORMS = [
|
|
1588
|
+
"akamai",
|
|
1589
|
+
"cato",
|
|
1590
|
+
"cloudflare",
|
|
1591
|
+
"fastly"
|
|
1592
|
+
];
|
|
1593
|
+
const ALLOWED_PLATFORMS = [...[
|
|
1594
|
+
...AI_PLATFORMS,
|
|
1595
|
+
"meta",
|
|
1596
|
+
"google"
|
|
1597
|
+
], ...WAF_PLATFORMS];
|
|
1598
|
+
const allowedPlatformSchema = z.enum(ALLOWED_PLATFORMS);
|
|
177
1599
|
const auditStatusSchema = z.enum([
|
|
178
1600
|
"pending",
|
|
179
1601
|
"partial",
|
|
@@ -246,6 +1668,25 @@ z.object({
|
|
|
246
1668
|
clientSecret: z.string(),
|
|
247
1669
|
clientScopes: z.array(z.string())
|
|
248
1670
|
});
|
|
1671
|
+
const creditEntryReasonSchema = z.enum([
|
|
1672
|
+
"free_seed",
|
|
1673
|
+
"paid_conversion_floor",
|
|
1674
|
+
"top_up",
|
|
1675
|
+
"usage",
|
|
1676
|
+
"admin_adjustment"
|
|
1677
|
+
]);
|
|
1678
|
+
z.enum(["playground"]);
|
|
1679
|
+
z.number().int().min(500);
|
|
1680
|
+
const creditActivityEntrySchema = z.object({
|
|
1681
|
+
reason: creditEntryReasonSchema,
|
|
1682
|
+
day: z.number(),
|
|
1683
|
+
amountInNanoUSD: z.number(),
|
|
1684
|
+
messageCount: z.number().nullable()
|
|
1685
|
+
});
|
|
1686
|
+
z.object({
|
|
1687
|
+
balanceInNanoUSD: z.number(),
|
|
1688
|
+
recentActivity: z.array(creditActivityEntrySchema)
|
|
1689
|
+
});
|
|
249
1690
|
const deploymentStatusSchema$1 = z.enum([
|
|
250
1691
|
"ongoing",
|
|
251
1692
|
"deployed",
|
|
@@ -273,34 +1714,52 @@ const deploymentSummarySchema = z.object({
|
|
|
273
1714
|
createdAt: z.coerce.date(),
|
|
274
1715
|
updatedAt: z.coerce.date()
|
|
275
1716
|
});
|
|
276
|
-
/**
|
|
277
|
-
* Public environment
|
|
278
|
-
*
|
|
279
|
-
* No OAuth metadata exposed.
|
|
280
|
-
*/
|
|
1717
|
+
/** Public environment: answers anonymously and exposes no OAuth metadata. */
|
|
281
1718
|
const publicEnvironmentSchema = z.object({
|
|
1719
|
+
allowsAnonymous: z.literal(true),
|
|
1720
|
+
oAuthMetadata: z.strictObject({})
|
|
1721
|
+
});
|
|
1722
|
+
/** Protected environment whose external resource metadata URL is returned in the WWW-Authenticate header on the first 401; everything after is handled outside the MCP server scope. */
|
|
1723
|
+
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
1724
|
+
allowsAnonymous: z.boolean(),
|
|
1725
|
+
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
1726
|
+
scope: z.string().optional()
|
|
1727
|
+
});
|
|
1728
|
+
/** Protected environment whose own /.well-known/oauth-protected-resource endpoint points at an external authorization server; everything after is handled outside the MCP server scope. */
|
|
1729
|
+
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
1730
|
+
allowsAnonymous: z.boolean(),
|
|
1731
|
+
oAuthMetadata: z.object({
|
|
1732
|
+
externalAuthorizationServerUrl: z.url(),
|
|
1733
|
+
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
|
|
1734
|
+
}),
|
|
1735
|
+
scope: z.string().optional()
|
|
1736
|
+
});
|
|
1737
|
+
/** Standalone protected environment: the server itself exposes both the /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server endpoints. */
|
|
1738
|
+
const standaloneEnvironmentSchema = z.object({
|
|
1739
|
+
allowsAnonymous: z.boolean(),
|
|
1740
|
+
oAuthMetadata: z.object({
|
|
1741
|
+
authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
|
|
1742
|
+
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
|
|
1743
|
+
}),
|
|
1744
|
+
scope: z.string().optional()
|
|
1745
|
+
});
|
|
1746
|
+
/** Protected environment that enforces authentication but advertises no OAuth discovery metadata; clients must obtain credentials out-of-band. */
|
|
1747
|
+
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
1748
|
+
allowsAnonymous: z.literal(false),
|
|
1749
|
+
oAuthMetadata: z.strictObject({}),
|
|
1750
|
+
scope: z.string().optional(),
|
|
1751
|
+
wwwAuthenticate: z.string().optional()
|
|
1752
|
+
});
|
|
1753
|
+
const legacyPublicEnvironmentSchema = z.object({
|
|
282
1754
|
isPublic: z.literal(true),
|
|
283
1755
|
oAuthMetadata: z.undefined().optional()
|
|
284
1756
|
});
|
|
285
|
-
|
|
286
|
-
* Protected environment with an external resource metadata URL
|
|
287
|
-
*
|
|
288
|
-
* An external resource metadata URL is returned in the WWW-Authenticate header during the first 401 response.
|
|
289
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
290
|
-
*/
|
|
291
|
-
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
1757
|
+
const legacyExternalResourceMetadataEnvironmentSchema = z.object({
|
|
292
1758
|
isPublic: z.literal(false),
|
|
293
1759
|
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
294
1760
|
scope: z.string().optional()
|
|
295
1761
|
});
|
|
296
|
-
|
|
297
|
-
* Protected environment with an external authorization server URL
|
|
298
|
-
*
|
|
299
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
300
|
-
* An external authorization server URL is returned when requesting the endpoint.
|
|
301
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
302
|
-
*/
|
|
303
|
-
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
1762
|
+
const legacyExternalAuthorizationServerEnvironmentSchema = z.object({
|
|
304
1763
|
isPublic: z.literal(false),
|
|
305
1764
|
oAuthMetadata: z.object({
|
|
306
1765
|
externalAuthorizationServerUrl: z.url(),
|
|
@@ -308,13 +1767,7 @@ const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
|
308
1767
|
}),
|
|
309
1768
|
scope: z.string().optional()
|
|
310
1769
|
});
|
|
311
|
-
|
|
312
|
-
* Standalone protected environment
|
|
313
|
-
*
|
|
314
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
315
|
-
* The server itself exposes the /.well-known/oauth-authorization-server endpoint.
|
|
316
|
-
*/
|
|
317
|
-
const standaloneEnvironmentSchema = z.object({
|
|
1770
|
+
const legacyStandaloneEnvironmentSchema = z.object({
|
|
318
1771
|
isPublic: z.literal(false),
|
|
319
1772
|
oAuthMetadata: z.object({
|
|
320
1773
|
authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
|
|
@@ -322,14 +1775,7 @@ const standaloneEnvironmentSchema = z.object({
|
|
|
322
1775
|
}),
|
|
323
1776
|
scope: z.string().optional()
|
|
324
1777
|
});
|
|
325
|
-
|
|
326
|
-
* Protected environment without OAuth discovery
|
|
327
|
-
*
|
|
328
|
-
* The server enforces authentication but exposes no OAuth discovery metadata.
|
|
329
|
-
* Neither /.well-known/oauth-protected-resource nor /.well-known/oauth-authorization-server
|
|
330
|
-
* are advertised. Clients must obtain credentials out-of-band.
|
|
331
|
-
*/
|
|
332
|
-
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
1778
|
+
const legacyProtectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
333
1779
|
isPublic: z.literal(false),
|
|
334
1780
|
oAuthMetadata: z.strictObject({}),
|
|
335
1781
|
scope: z.string().optional()
|
|
@@ -339,14 +1785,21 @@ z.union([
|
|
|
339
1785
|
externalResourceMetadataEnvironmentSchema,
|
|
340
1786
|
externalAuthorizationServerEnvironmentSchema,
|
|
341
1787
|
standaloneEnvironmentSchema,
|
|
342
|
-
protectedWithoutDiscoveryEnvironmentSchema
|
|
1788
|
+
protectedWithoutDiscoveryEnvironmentSchema,
|
|
1789
|
+
legacyPublicEnvironmentSchema,
|
|
1790
|
+
legacyExternalResourceMetadataEnvironmentSchema,
|
|
1791
|
+
legacyExternalAuthorizationServerEnvironmentSchema,
|
|
1792
|
+
legacyStandaloneEnvironmentSchema,
|
|
1793
|
+
legacyProtectedWithoutDiscoveryEnvironmentSchema
|
|
343
1794
|
]);
|
|
344
|
-
const allowedPlatformSchema = platformSchema;
|
|
345
1795
|
const playgroundModelSchema = z.enum([
|
|
1796
|
+
"global.anthropic.claude-haiku-5-5",
|
|
346
1797
|
"global.anthropic.claude-haiku-4-5-20251001-v1:0",
|
|
347
|
-
"global.anthropic.claude-sonnet-
|
|
1798
|
+
"global.anthropic.claude-sonnet-5-5",
|
|
348
1799
|
"openai.gpt-5.4",
|
|
349
|
-
"openai.gpt-5.5"
|
|
1800
|
+
"openai.gpt-5.5",
|
|
1801
|
+
"openai.gpt-6-luna",
|
|
1802
|
+
"openai.gpt-6.1-sol"
|
|
350
1803
|
]);
|
|
351
1804
|
const environmentDomainSchema = z.object({
|
|
352
1805
|
name: z.string(),
|
|
@@ -381,14 +1834,17 @@ z.object({
|
|
|
381
1834
|
collectRequestPayload: z.boolean(),
|
|
382
1835
|
collectResponsePayload: z.boolean(),
|
|
383
1836
|
collectErrorMessage: z.boolean(),
|
|
384
|
-
collectUserData: z.boolean()
|
|
1837
|
+
collectUserData: z.boolean(),
|
|
1838
|
+
identityTraitKey: z.string().min(1).max(200).nullable(),
|
|
1839
|
+
leadEventName: z.string().min(1).max(200).nullable()
|
|
385
1840
|
});
|
|
386
|
-
z.object({
|
|
1841
|
+
const feedbackSchema = z.object({
|
|
387
1842
|
id: z.string(),
|
|
388
1843
|
createdAt: z.coerce.date(),
|
|
389
1844
|
environmentId: z.string(),
|
|
390
1845
|
content: z.string(),
|
|
391
|
-
source: z.enum(["model", "user"])
|
|
1846
|
+
source: z.enum(["model", "user"]),
|
|
1847
|
+
clientName: z.string().nullable()
|
|
392
1848
|
});
|
|
393
1849
|
z.object({
|
|
394
1850
|
content: z.string(),
|
|
@@ -404,7 +1860,7 @@ const intentCategoryColorSchema = z.enum([
|
|
|
404
1860
|
"pink",
|
|
405
1861
|
"gray"
|
|
406
1862
|
]);
|
|
407
|
-
intentCategoryColorSchema.options;
|
|
1863
|
+
const INTENT_CATEGORY_COLORS = intentCategoryColorSchema.options;
|
|
408
1864
|
const intentCategorySchema = z.object({
|
|
409
1865
|
id: z.string(),
|
|
410
1866
|
createdAt: z.coerce.date(),
|
|
@@ -412,7 +1868,7 @@ const intentCategorySchema = z.object({
|
|
|
412
1868
|
name: z.string(),
|
|
413
1869
|
color: intentCategoryColorSchema
|
|
414
1870
|
});
|
|
415
|
-
z.object({
|
|
1871
|
+
const intentCategorySummarySchema = z.object({
|
|
416
1872
|
id: z.string(),
|
|
417
1873
|
name: z.string(),
|
|
418
1874
|
color: intentCategoryColorSchema,
|
|
@@ -424,6 +1880,7 @@ z.object({
|
|
|
424
1880
|
environmentId: z.string(),
|
|
425
1881
|
toolName: z.string(),
|
|
426
1882
|
message: z.string(),
|
|
1883
|
+
clientName: z.string().nullable(),
|
|
427
1884
|
categories: z.array(intentCategorySchema)
|
|
428
1885
|
});
|
|
429
1886
|
const signalCategorySchema = z.object({
|
|
@@ -482,17 +1939,277 @@ z.object({
|
|
|
482
1939
|
createdAt: z.coerce.date(),
|
|
483
1940
|
updatedAt: z.coerce.date()
|
|
484
1941
|
});
|
|
1942
|
+
const alpicMcpRequestLogSchema = z.object({
|
|
1943
|
+
type: z.literal("mcp_request"),
|
|
1944
|
+
method: z.string()
|
|
1945
|
+
});
|
|
1946
|
+
const alpicMcpErrorLogSchema = z.object({
|
|
1947
|
+
type: z.literal("mcp_error"),
|
|
1948
|
+
method: z.string(),
|
|
1949
|
+
error: z.string()
|
|
1950
|
+
});
|
|
1951
|
+
z.union([alpicMcpRequestLogSchema, alpicMcpErrorLogSchema]);
|
|
485
1952
|
z.enum([
|
|
486
1953
|
"INFO",
|
|
487
1954
|
"WARNING",
|
|
488
1955
|
"DEBUG",
|
|
489
1956
|
"ERROR"
|
|
490
1957
|
]);
|
|
1958
|
+
const LOG_SEARCH_MAX_ESCAPED_LENGTH = 960;
|
|
1959
|
+
function escapeLogSearchTerm(search) {
|
|
1960
|
+
return [...search].flatMap((character) => [...new TextEncoder().encode(character)]).map((byte) => {
|
|
1961
|
+
const character = String.fromCharCode(byte);
|
|
1962
|
+
return /^[a-zA-Z0-9]$/.test(character) ? character : `\\x${byte.toString(16).toUpperCase().padStart(2, "0")}`;
|
|
1963
|
+
}).join("");
|
|
1964
|
+
}
|
|
1965
|
+
const logSearchSchema = z.string().max(240, `Search must be 240 characters or fewer`).refine((search) => escapeLogSearchTerm(search).length <= LOG_SEARCH_MAX_ESCAPED_LENGTH, "Search is too complex; shorten it or use fewer special characters");
|
|
1966
|
+
/** Only names a vendor actually ships belong here: lookalikes like `claude-code-test` are customers' own scripts. */
|
|
1967
|
+
const MCP_CLIENT_GROUPS = [
|
|
1968
|
+
{
|
|
1969
|
+
id: "claude_code",
|
|
1970
|
+
label: "Claude Code",
|
|
1971
|
+
vendor: "anthropic",
|
|
1972
|
+
rawNames: ["claude-code", "Anthropic/ClaudeCodeDesktop"]
|
|
1973
|
+
},
|
|
1974
|
+
{
|
|
1975
|
+
id: "claude",
|
|
1976
|
+
label: "Claude",
|
|
1977
|
+
vendor: "anthropic",
|
|
1978
|
+
rawNames: [
|
|
1979
|
+
"Anthropic/ClaudeAI",
|
|
1980
|
+
"claude-ai",
|
|
1981
|
+
"claude",
|
|
1982
|
+
"Claude",
|
|
1983
|
+
"claude-desktop",
|
|
1984
|
+
"claude-desktop-3p"
|
|
1985
|
+
]
|
|
1986
|
+
},
|
|
1987
|
+
{
|
|
1988
|
+
id: "claude_mobile",
|
|
1989
|
+
label: "Claude mobile",
|
|
1990
|
+
vendor: "anthropic",
|
|
1991
|
+
rawNames: ["claude-ios", "ClaudeAndroid"]
|
|
1992
|
+
},
|
|
1993
|
+
{
|
|
1994
|
+
id: "claude_cowork",
|
|
1995
|
+
label: "Claude Cowork",
|
|
1996
|
+
vendor: "anthropic",
|
|
1997
|
+
rawNames: ["Anthropic/Cowork"]
|
|
1998
|
+
},
|
|
1999
|
+
{
|
|
2000
|
+
id: "claude_sheet_add_in",
|
|
2001
|
+
label: "Claude (Sheet Add-In)",
|
|
2002
|
+
vendor: "anthropic",
|
|
2003
|
+
rawNames: ["sheet-add-in"]
|
|
2004
|
+
},
|
|
2005
|
+
{
|
|
2006
|
+
id: "claude_toolbox",
|
|
2007
|
+
label: "Claude Toolbox",
|
|
2008
|
+
vendor: "anthropic",
|
|
2009
|
+
rawNames: ["Anthropic/Toolbox", "Anthropic/toolbox-bootstrap"]
|
|
2010
|
+
},
|
|
2011
|
+
{
|
|
2012
|
+
id: "anthropic_api",
|
|
2013
|
+
label: "Anthropic API",
|
|
2014
|
+
vendor: "anthropic",
|
|
2015
|
+
rawNames: ["Anthropic/API"]
|
|
2016
|
+
},
|
|
2017
|
+
{
|
|
2018
|
+
id: "anthropic_connector_refresh",
|
|
2019
|
+
label: "Anthropic (connector refresh)",
|
|
2020
|
+
vendor: "anthropic",
|
|
2021
|
+
rawNames: ["Anthropic"]
|
|
2022
|
+
},
|
|
2023
|
+
{
|
|
2024
|
+
id: "codex",
|
|
2025
|
+
label: "Codex",
|
|
2026
|
+
vendor: "openai",
|
|
2027
|
+
rawNames: [
|
|
2028
|
+
"codex-mcp-client",
|
|
2029
|
+
"codex",
|
|
2030
|
+
"Codex",
|
|
2031
|
+
"codex-cli",
|
|
2032
|
+
"openai-mcp (Codex)"
|
|
2033
|
+
]
|
|
2034
|
+
},
|
|
2035
|
+
{
|
|
2036
|
+
id: "chatgpt",
|
|
2037
|
+
label: "ChatGPT",
|
|
2038
|
+
vendor: "openai",
|
|
2039
|
+
rawNames: ["openai-mcp", "openai-mcp (ChatGPT)"]
|
|
2040
|
+
},
|
|
2041
|
+
{
|
|
2042
|
+
id: "openai_responses_api",
|
|
2043
|
+
label: "OpenAI Responses API",
|
|
2044
|
+
vendor: "openai",
|
|
2045
|
+
rawNames: ["openai-mcp (Responses API)"]
|
|
2046
|
+
},
|
|
2047
|
+
{
|
|
2048
|
+
id: "openai_agent_builder",
|
|
2049
|
+
label: "OpenAI Agent Builder",
|
|
2050
|
+
vendor: "openai",
|
|
2051
|
+
rawNames: ["openai-mcp (Agent Builder)"]
|
|
2052
|
+
},
|
|
2053
|
+
{
|
|
2054
|
+
id: "cursor",
|
|
2055
|
+
label: "Cursor",
|
|
2056
|
+
vendor: "cursor",
|
|
2057
|
+
rawNames: [
|
|
2058
|
+
"cursor-vscode",
|
|
2059
|
+
"Cursor",
|
|
2060
|
+
"cursor"
|
|
2061
|
+
]
|
|
2062
|
+
},
|
|
2063
|
+
{
|
|
2064
|
+
id: "cline",
|
|
2065
|
+
label: "Cline",
|
|
2066
|
+
vendor: "cline",
|
|
2067
|
+
rawNames: [
|
|
2068
|
+
"Cline",
|
|
2069
|
+
"cline",
|
|
2070
|
+
"@cline/core"
|
|
2071
|
+
]
|
|
2072
|
+
},
|
|
2073
|
+
{
|
|
2074
|
+
id: "github_copilot",
|
|
2075
|
+
label: "GitHub Copilot",
|
|
2076
|
+
vendor: "githubCopilot",
|
|
2077
|
+
rawNames: [
|
|
2078
|
+
"Copilot",
|
|
2079
|
+
"github-copilot-developer",
|
|
2080
|
+
"Copilot MCP Gateway",
|
|
2081
|
+
"Xcode/copilot-xcode"
|
|
2082
|
+
]
|
|
2083
|
+
},
|
|
2084
|
+
{
|
|
2085
|
+
id: "gemini_cli",
|
|
2086
|
+
label: "Gemini CLI",
|
|
2087
|
+
vendor: "google",
|
|
2088
|
+
rawNames: ["gemini-cli-mcp-client", "gemini-cli"]
|
|
2089
|
+
},
|
|
2090
|
+
{
|
|
2091
|
+
id: "antigravity",
|
|
2092
|
+
label: "Antigravity",
|
|
2093
|
+
vendor: "google",
|
|
2094
|
+
rawNames: ["antigravity-client"]
|
|
2095
|
+
},
|
|
2096
|
+
{
|
|
2097
|
+
id: "gemini",
|
|
2098
|
+
label: "Gemini",
|
|
2099
|
+
vendor: "google",
|
|
2100
|
+
rawNames: ["Gemini", "google-ai-edge-gallery"]
|
|
2101
|
+
},
|
|
2102
|
+
{
|
|
2103
|
+
id: "windsurf",
|
|
2104
|
+
label: "Windsurf",
|
|
2105
|
+
vendor: "windsurf",
|
|
2106
|
+
rawNames: ["Windsurf", "windsurf-client"]
|
|
2107
|
+
},
|
|
2108
|
+
{
|
|
2109
|
+
id: "mistral",
|
|
2110
|
+
label: "Mistral / Le Chat",
|
|
2111
|
+
vendor: "mistral",
|
|
2112
|
+
rawNames: ["Mistral"],
|
|
2113
|
+
rawNamePrefixes: ["connector:custom-mcp:"]
|
|
2114
|
+
},
|
|
2115
|
+
{
|
|
2116
|
+
id: "n8n",
|
|
2117
|
+
label: "n8n",
|
|
2118
|
+
vendor: "n8n",
|
|
2119
|
+
rawNames: [
|
|
2120
|
+
"@n8n/n8n-nodes-langchain.mcpClient",
|
|
2121
|
+
"@n8n/n8n-nodes-langchain.mcpClientTool",
|
|
2122
|
+
"n8n"
|
|
2123
|
+
]
|
|
2124
|
+
},
|
|
2125
|
+
{
|
|
2126
|
+
id: "alpic_playground",
|
|
2127
|
+
label: "Alpic Playground",
|
|
2128
|
+
vendor: "alpic",
|
|
2129
|
+
rawNames: ["alpic-playground", "playground"]
|
|
2130
|
+
},
|
|
2131
|
+
{
|
|
2132
|
+
id: "opencode",
|
|
2133
|
+
label: "opencode",
|
|
2134
|
+
vendor: "opencode",
|
|
2135
|
+
rawNames: ["opencode"]
|
|
2136
|
+
},
|
|
2137
|
+
{
|
|
2138
|
+
id: "zed",
|
|
2139
|
+
label: "Zed",
|
|
2140
|
+
vendor: "zed",
|
|
2141
|
+
rawNames: ["Zed", "zed"]
|
|
2142
|
+
},
|
|
2143
|
+
{
|
|
2144
|
+
id: "zapier",
|
|
2145
|
+
label: "Zapier",
|
|
2146
|
+
vendor: "zapier",
|
|
2147
|
+
rawNames: ["Zapier", "zapier"]
|
|
2148
|
+
},
|
|
2149
|
+
{
|
|
2150
|
+
id: "make",
|
|
2151
|
+
label: "Make",
|
|
2152
|
+
vendor: "make",
|
|
2153
|
+
rawNames: ["Make", "make"]
|
|
2154
|
+
},
|
|
2155
|
+
{
|
|
2156
|
+
id: "librechat",
|
|
2157
|
+
label: "LibreChat",
|
|
2158
|
+
vendor: "mcp",
|
|
2159
|
+
rawNames: ["LibreChat", "librechat"]
|
|
2160
|
+
},
|
|
2161
|
+
{
|
|
2162
|
+
id: "jan",
|
|
2163
|
+
label: "Jan",
|
|
2164
|
+
vendor: "mcp",
|
|
2165
|
+
rawNames: ["Jan", "jan"]
|
|
2166
|
+
},
|
|
2167
|
+
{
|
|
2168
|
+
id: "goose",
|
|
2169
|
+
label: "goose",
|
|
2170
|
+
vendor: "mcp",
|
|
2171
|
+
rawNames: ["goose", "Goose"]
|
|
2172
|
+
},
|
|
2173
|
+
{
|
|
2174
|
+
id: "mcphost",
|
|
2175
|
+
label: "mcphost",
|
|
2176
|
+
vendor: "mcp",
|
|
2177
|
+
rawNames: ["mcphost"]
|
|
2178
|
+
},
|
|
2179
|
+
{
|
|
2180
|
+
id: "mcporter",
|
|
2181
|
+
label: "mcporter",
|
|
2182
|
+
vendor: "mcp",
|
|
2183
|
+
rawNames: ["mcporter"]
|
|
2184
|
+
},
|
|
2185
|
+
{
|
|
2186
|
+
id: "rmcp",
|
|
2187
|
+
label: "rmcp",
|
|
2188
|
+
vendor: "mcp",
|
|
2189
|
+
rawNames: ["rmcp"]
|
|
2190
|
+
},
|
|
2191
|
+
{
|
|
2192
|
+
id: "unnamed_client",
|
|
2193
|
+
label: "Unnamed client",
|
|
2194
|
+
vendor: "mcp",
|
|
2195
|
+
rawNames: [
|
|
2196
|
+
"mcp",
|
|
2197
|
+
"unknown",
|
|
2198
|
+
""
|
|
2199
|
+
]
|
|
2200
|
+
}
|
|
2201
|
+
];
|
|
2202
|
+
/** A source pattern, not a RegExp, because analytics renders the same rule into ClickHouse RE2, which shares this syntax. */
|
|
2203
|
+
const MCP_REMOTE_WRAPPER_SUFFIX = String.raw` \(via mcp-remote [^\n]+?\)$`;
|
|
2204
|
+
new RegExp(MCP_REMOTE_WRAPPER_SUFFIX);
|
|
2205
|
+
new Map(MCP_CLIENT_GROUPS.map((group) => [group.id, group]));
|
|
491
2206
|
const runtimeSchema = z.enum([
|
|
492
2207
|
"python3.13",
|
|
493
2208
|
"python3.14",
|
|
2209
|
+
"python3.15",
|
|
494
2210
|
"node22",
|
|
495
|
-
"node24"
|
|
2211
|
+
"node24",
|
|
2212
|
+
"node26"
|
|
496
2213
|
]);
|
|
497
2214
|
const transportSchema = z.enum([
|
|
498
2215
|
"stdio",
|
|
@@ -565,15 +2282,7 @@ z.object({
|
|
|
565
2282
|
serverFields: serverFieldsSchema$1,
|
|
566
2283
|
source: z.enum(["registry", "defaults"])
|
|
567
2284
|
});
|
|
568
|
-
/**
|
|
569
|
-
* Returns a variant of a `maxLength`-constrained string that clamps (truncates) instead of
|
|
570
|
-
* rejecting on overflow — used for AI-generated copy where the model routinely overshoots.
|
|
571
|
-
*
|
|
572
|
-
* NOTE: this rebuilds the schema from scratch, carrying over only `maxLength` (as a clamp),
|
|
573
|
-
* `minLength`, and the description. Any other validators on the source field (`.regex()`,
|
|
574
|
-
* `.email()`, custom refinements) are intentionally dropped — this helper is meant for plain
|
|
575
|
-
* free-text length caps only. A field with `null` `maxLength` is returned unchanged.
|
|
576
|
-
*/
|
|
2285
|
+
/** Clamps instead of rejecting on max-length overflow (for AI-generated copy that overshoots); intentionally carries over only maxLength, minLength, and description, dropping any other validators. */
|
|
577
2286
|
const clampStringField = (field) => {
|
|
578
2287
|
const max = field.maxLength;
|
|
579
2288
|
if (max === null) return field;
|
|
@@ -581,6 +2290,10 @@ const clampStringField = (field) => {
|
|
|
581
2290
|
const withMin = field.minLength === null ? clamped : clamped.min(field.minLength);
|
|
582
2291
|
return field.description ? withMin.describe(field.description) : withMin;
|
|
583
2292
|
};
|
|
2293
|
+
const unboundedArrayField = (field) => {
|
|
2294
|
+
const unbounded = z.array(field.element);
|
|
2295
|
+
return field.description ? unbounded.describe(field.description) : unbounded;
|
|
2296
|
+
};
|
|
584
2297
|
const toolDefinitionSchema = z.object({
|
|
585
2298
|
name: z.string(),
|
|
586
2299
|
title: z.string().optional().describe("Human-friendly name for the tool, used in the UI. If not provided, `name` will be used."),
|
|
@@ -593,11 +2306,22 @@ const toolDefinitionSchema = z.object({
|
|
|
593
2306
|
}).optional()
|
|
594
2307
|
});
|
|
595
2308
|
const positiveTestCaseSchema = z.object({
|
|
596
|
-
scenario: z.string().describe("Short label for what this case demonstrates."),
|
|
597
|
-
userPrompt: z.string().describe("A realistic, standalone user message a reviewer can paste and run with no prior state or multi-turn setup. Vary phrasing and tone across cases."),
|
|
2309
|
+
scenario: z.string().min(1).describe("Short label for what this case demonstrates."),
|
|
2310
|
+
userPrompt: z.string().min(1).describe("A realistic, standalone user message a reviewer can paste and run with no prior state or multi-turn setup. Vary phrasing and tone across cases."),
|
|
598
2311
|
toolTriggered: z.string().optional().describe("The tool this prompt should invoke."),
|
|
599
2312
|
expectedOutput: z.string().optional().describe("What the user should see, including post-interaction behaviour where relevant.")
|
|
600
|
-
}).
|
|
2313
|
+
}).describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
|
|
2314
|
+
const positiveTestCaseDraftSchema = positiveTestCaseSchema.partial().extend({
|
|
2315
|
+
scenario: z.string().optional(),
|
|
2316
|
+
userPrompt: z.string().optional()
|
|
2317
|
+
});
|
|
2318
|
+
const blankPositiveTestCase = () => ({
|
|
2319
|
+
scenario: "",
|
|
2320
|
+
userPrompt: "",
|
|
2321
|
+
toolTriggered: "",
|
|
2322
|
+
expectedOutput: ""
|
|
2323
|
+
});
|
|
2324
|
+
const toFixedLength = (entries, length, blank) => Array.from({ length }, (_, index) => entries[index] ?? blank());
|
|
601
2325
|
const screenshotEntrySchema = z.object({
|
|
602
2326
|
prompt: z.string(),
|
|
603
2327
|
url: z.url()
|
|
@@ -910,20 +2634,25 @@ const chatgptTranslationLocaleSchema = z.enum([
|
|
|
910
2634
|
"zh-TW"
|
|
911
2635
|
]);
|
|
912
2636
|
const negativeTestCaseSchema = z.object({
|
|
913
|
-
scenario: z.string(),
|
|
914
|
-
userPrompt: z.string()
|
|
915
|
-
}).
|
|
2637
|
+
scenario: z.string().min(1),
|
|
2638
|
+
userPrompt: z.string().min(1)
|
|
2639
|
+
}).describe("Each case: Scenario + User prompt (the plugin should NOT trigger).");
|
|
2640
|
+
const negativeTestCaseDraftSchema = negativeTestCaseSchema.partial().extend({
|
|
2641
|
+
scenario: z.string().optional(),
|
|
2642
|
+
userPrompt: z.string().optional()
|
|
2643
|
+
});
|
|
2644
|
+
const blankNegativeTestCase = () => ({
|
|
2645
|
+
scenario: "",
|
|
2646
|
+
userPrompt: ""
|
|
2647
|
+
});
|
|
2648
|
+
const chatgptSkillSchema = z.object({ name: z.string() }).describe("A skill discovered on the MCP server, by name.");
|
|
916
2649
|
const chatgptToolJustificationSchema = z.object({
|
|
917
2650
|
toolName: z.string(),
|
|
918
2651
|
readOnlyJustification: z.string().describe("One sentence on what the tool reads and returns."),
|
|
919
2652
|
openWorldJustification: z.string().describe("One sentence on whether the tool reaches external systems beyond your own service."),
|
|
920
2653
|
destructiveJustification: z.string().describe("One sentence on whether the tool changes data. For a read-only tool, state the full triad: \"No data is created, modified, or deleted.\"")
|
|
921
2654
|
}).describe("Per-tool justification of each MCP annotation value (one specific sentence per hint).");
|
|
922
|
-
/**
|
|
923
|
-
* Base copy fields, defined once and reused by both the submission form and per-locale
|
|
924
|
-
* translations so the constraints (tagline ≤ 30 chars) never drift. The translation generation
|
|
925
|
-
* path wraps these in {@link clampStringField} since the LLM tends to overshoot the limit.
|
|
926
|
-
*/
|
|
2655
|
+
/** Defined once and reused by both the submission form and per-locale translations so the tagline ≤ 30 chars constraint never drifts. */
|
|
927
2656
|
const chatgptTaglineSchema = z.string().max(30);
|
|
928
2657
|
const chatgptDescriptionSchema = z.string();
|
|
929
2658
|
const chatgptTranslationSchema = z.object({
|
|
@@ -932,34 +2661,32 @@ const chatgptTranslationSchema = z.object({
|
|
|
932
2661
|
description: chatgptDescriptionSchema
|
|
933
2662
|
}).describe("Locale-scoped override for tagline + description. English (US) is the default.");
|
|
934
2663
|
chatgptTranslationSchema.extend({ tagline: clampStringField(chatgptTaglineSchema) });
|
|
935
|
-
/**
|
|
936
|
-
* Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section.
|
|
937
|
-
* When adding/removing/reordering fields, keep this in sync with the sheet.
|
|
938
|
-
*/
|
|
2664
|
+
/** Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section; keep it in sync with the sheet. */
|
|
939
2665
|
const chatgptSubmissionFormDataSchema = z.object({
|
|
940
2666
|
logoLight: z.string().describe("Logo icon for light mode. Square PNG, no borders or rounded corners (clients apply circular cropping)."),
|
|
941
2667
|
logoDark: z.string().optional().describe("Optional dark-mode logo icon. Square PNG, same specs as the light icon. Leave empty if the light icon also works on dark backgrounds."),
|
|
942
|
-
appName: z.string().describe("The name users will see in ChatGPT and in the
|
|
2668
|
+
appName: z.string().describe("The name users will see in ChatGPT and in the Plugin Directory."),
|
|
943
2669
|
tagline: chatgptTaglineSchema.describe("Plain-language phrase focused on function and user value, 30 chars max. Avoid generic superlatives like \"the best …\"."),
|
|
944
|
-
description: chatgptDescriptionSchema.describe("Clear, engaging description highlighting what the
|
|
2670
|
+
description: chatgptDescriptionSchema.describe("Clear, engaging description highlighting what the plugin does and why people will love it. Appears publicly on the directory page. End it by naming the product categories or intents the plugin does NOT cover, so ChatGPT learns when not to route to it (define exclusions by absent categories or wrong intents, never by naming other brands)."),
|
|
945
2671
|
category: chatgptCategorySchema.describe("Category from the OpenAI taxonomy."),
|
|
946
|
-
developerName: z.string().describe("Developer name shown publicly on the
|
|
2672
|
+
developerName: z.string().describe("Developer name shown publicly on the plugin's directory page."),
|
|
947
2673
|
companyUrl: urlField.describe("Your company's main website URL."),
|
|
948
2674
|
supportChannel: supportChannelSchema.describe("Customer support URL or email address."),
|
|
949
2675
|
privacyPolicyUrl: urlField.describe("URL to your privacy policy."),
|
|
950
|
-
termsOfServiceUrl: urlField.describe("URL to the
|
|
951
|
-
demoRecordingUrl: urlField.describe("URL to a video demonstrating the
|
|
952
|
-
appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My
|
|
2676
|
+
termsOfServiceUrl: urlField.describe("URL to the plugin's terms of service."),
|
|
2677
|
+
demoRecordingUrl: urlField.describe("URL to a video demonstrating the plugin, recorded via OpenAI Developer Mode. Cover all main use cases on web, iOS, and Android."),
|
|
2678
|
+
appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My plugin links or directs users out of ChatGPT to make purchases.' Defaults to false. Verify the plugin does not offer digital goods."),
|
|
953
2679
|
serverUrl: urlField.describe("URL of the MCP server."),
|
|
954
2680
|
authentication: chatgptAuthenticationSchema.describe("OAuth 2.0 or No auth. OAuth configuration is auto-discovered from the MCP server's metadata."),
|
|
955
2681
|
tools: z.array(toolDefinitionSchema).describe("List of tools exposed by the MCP server (auto-populated from the production server's manifest)."),
|
|
956
2682
|
toolJustifications: z.array(chatgptToolJustificationSchema).describe("Per-tool justification of `readOnlyHint`, `openWorldHint`, and `destructiveHint` annotation values. One short, specific sentence per hint describing what the tool actually does."),
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
2683
|
+
skills: z.array(chatgptSkillSchema).optional().describe("Skills the server exposes over MCP (auto-populated from the production server's manifest). Left unset when the server does not advertise the skills extension, which is a different state from advertising it and exposing none."),
|
|
2684
|
+
testCases: z.array(positiveTestCaseSchema).length(5).describe("Exactly 5 positive test cases. Each: Scenario, User prompt, Tool triggered, Expected output. Collectively cover the full capability across different flow stages (initial search or browse, market or locale handling, post-interaction detail, an action ChatGPT performs on the user's behalf, and a conversion or secondary tool) rather than five variations of the same first step."),
|
|
2685
|
+
negativeTestCases: z.array(negativeTestCaseSchema).length(3).describe("Exactly 3 negative test cases: prompts where the plugin should NOT trigger but the model might think it is relevant. These become production routing metadata that teaches ChatGPT when to stay silent, so pick tight near-misses: a product category the plugin does not carry, the right brand or domain but an intent the plugin does not serve, or a boundary with a sibling plugin."),
|
|
2686
|
+
screenshots: z.array(screenshotEntrySchema.extend({ prompt: z.string().max(75, { error: "Screenshot prompts are limited to 75 characters." }) })).max(3).describe("In-plugin screenshots paired with the user prompt that produced them (each prompt is 75 characters max). Widget plugins must show the widget UI; non-widget plugins show the model response. Min 1, max 3 entries, all public. Images: 706px wide, 400–860px tall, PNG."),
|
|
960
2687
|
translations: z.array(chatgptTranslationSchema).describe("Per-locale translation of tagline + description. English (US) is the default."),
|
|
961
2688
|
allowedCountries: chatgptAllowedCountriesSchema.describe("Availability: all supported countries, or an allow-list / block-list of specific ones (ISO alpha-2)."),
|
|
962
|
-
releaseNotes: z.string().describe("Publicly displayed on the
|
|
2689
|
+
releaseNotes: z.string().describe("Publicly displayed on the plugin details page.")
|
|
963
2690
|
});
|
|
964
2691
|
const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().extend({
|
|
965
2692
|
tagline: z.string().optional(),
|
|
@@ -970,23 +2697,35 @@ const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().e
|
|
|
970
2697
|
demoRecordingUrl: z.string().optional(),
|
|
971
2698
|
serverUrl: z.string().optional(),
|
|
972
2699
|
screenshots: z.array(screenshotDraftEntrySchema).optional(),
|
|
2700
|
+
testCases: z.array(positiveTestCaseDraftSchema).optional(),
|
|
2701
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).optional(),
|
|
973
2702
|
translations: z.array(chatgptTranslationSchema.extend({ tagline: z.string() })).optional()
|
|
974
2703
|
});
|
|
975
|
-
|
|
2704
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "chatgpt" })` can populate. */
|
|
2705
|
+
const chatgptPrefillFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
976
2706
|
appName: true,
|
|
977
2707
|
developerName: true,
|
|
978
2708
|
serverUrl: true,
|
|
979
2709
|
tools: true,
|
|
2710
|
+
skills: true,
|
|
980
2711
|
authentication: true
|
|
981
2712
|
});
|
|
982
|
-
|
|
2713
|
+
/** Source of truth for `SubmissionPrefillService.generate({ platform: "chatgpt" })`. */
|
|
2714
|
+
const chatgptAiGeneratedFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
983
2715
|
tagline: true,
|
|
984
2716
|
description: true,
|
|
985
2717
|
category: true,
|
|
986
2718
|
testCases: true,
|
|
987
2719
|
negativeTestCases: true,
|
|
988
2720
|
toolJustifications: true
|
|
989
|
-
}).extend({
|
|
2721
|
+
}).extend({
|
|
2722
|
+
testCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.testCases),
|
|
2723
|
+
negativeTestCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.negativeTestCases)
|
|
2724
|
+
}).extend({
|
|
2725
|
+
tagline: clampStringField(chatgptSubmissionFormDataSchema.shape.tagline),
|
|
2726
|
+
testCases: z.array(positiveTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 5, blankPositiveTestCase)),
|
|
2727
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 3, blankNegativeTestCase))
|
|
2728
|
+
});
|
|
990
2729
|
const claudeCategorySchema = z.enum([
|
|
991
2730
|
"Productivity",
|
|
992
2731
|
"Communication",
|
|
@@ -1032,11 +2771,7 @@ const claudePolicyAcknowledgementSchema = z.enum([
|
|
|
1032
2771
|
"My connector does not collect conversation data beyond what is needed for its function.",
|
|
1033
2772
|
"Public documentation for this connector will be live by the publish date."
|
|
1034
2773
|
]);
|
|
1035
|
-
/**
|
|
1036
|
-
* Field order mirrors the claude.ai directory submission wizard
|
|
1037
|
-
* (`claude.ai/admin-settings/directory/submissions/new`), grouped by step.
|
|
1038
|
-
* When adding/removing/reordering fields, keep this in sync with the wizard.
|
|
1039
|
-
*/
|
|
2774
|
+
/** Field order mirrors the claude.ai directory submission wizard (`claude.ai/admin-settings/directory/submissions/new`), grouped by step; keep it in sync with the wizard. */
|
|
1040
2775
|
const claudeSubmissionFormDataSchema = z.object({
|
|
1041
2776
|
serverUrl: z.url().describe(`The full https:// URL where your MCP server is hosted and reachable. In the claude.ai wizard this is read live
|
|
1042
2777
|
from the custom connector you select — the connection is used to verify the URL and the tool list at submission time.
|
|
@@ -1113,7 +2848,8 @@ const claudeSubmissionDraftSchema = claudeSubmissionFormDataSchema.partial().ext
|
|
|
1113
2848
|
categories: z.array(claudeCategorySchema).optional(),
|
|
1114
2849
|
screenshots: z.array(screenshotDraftEntrySchema).optional()
|
|
1115
2850
|
});
|
|
1116
|
-
|
|
2851
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "claudeai" })` can populate. */
|
|
2852
|
+
const claudePrefillFormDataSchema = claudeSubmissionFormDataSchema.pick({
|
|
1117
2853
|
serverUrl: true,
|
|
1118
2854
|
name: true,
|
|
1119
2855
|
slug: true,
|
|
@@ -1128,39 +2864,93 @@ claudeSubmissionFormDataSchema.pick({
|
|
|
1128
2864
|
connectionRequirements: claudeSubmissionFormDataSchema.shape.connectionRequirements.optional(),
|
|
1129
2865
|
testInstructions: claudeSubmissionFormDataSchema.shape.testInstructions.optional()
|
|
1130
2866
|
});
|
|
1131
|
-
/**
|
|
1132
|
-
* Narrative fields the LLM-backed generation step produces for Claude submissions.
|
|
1133
|
-
* This schema accepts the slightly loose shape returned by AI generation, then normalizes it into
|
|
1134
|
-
* the strict form shape. Keep transforms here rather than in callers so generation leniency is
|
|
1135
|
-
* colocated with the Claude contract.
|
|
1136
|
-
*/
|
|
2867
|
+
/** Loose shape returned by AI generation for Claude narrative fields; transforms live here so generation leniency stays colocated with the Claude contract. */
|
|
1137
2868
|
const claudeAiGeneratedFormDataRawSchema = z.object({
|
|
1138
2869
|
oneLiner: claudeSubmissionFormDataSchema.shape.oneLiner,
|
|
1139
2870
|
description: claudeSubmissionFormDataSchema.shape.description,
|
|
1140
2871
|
categories: z.array(claudeCategorySchema).describe(claudeCategoryDescription),
|
|
1141
2872
|
primaryUseCases: claudeSubmissionFormDataSchema.shape.primaryUseCases
|
|
1142
2873
|
});
|
|
1143
|
-
claudeAiGeneratedFormDataRawSchema.extend({
|
|
2874
|
+
const claudeAiGeneratedFormDataSchema = claudeAiGeneratedFormDataRawSchema.extend({
|
|
1144
2875
|
oneLiner: clampStringField(claudeSubmissionFormDataSchema.shape.oneLiner),
|
|
1145
2876
|
categories: claudeAiGeneratedFormDataRawSchema.shape.categories.transform((categories) => categories.slice(0, 5))
|
|
1146
2877
|
});
|
|
2878
|
+
function provenanceByField(prefillShape, aiGeneratedShape) {
|
|
2879
|
+
const byField = {};
|
|
2880
|
+
for (const field of Object.keys(prefillShape)) byField[field] = "prefilled";
|
|
2881
|
+
for (const field of Object.keys(aiGeneratedShape)) byField[field] = "ai-generated";
|
|
2882
|
+
return byField;
|
|
2883
|
+
}
|
|
2884
|
+
provenanceByField(claudePrefillFormDataSchema.shape, claudeAiGeneratedFormDataSchema.shape), provenanceByField(chatgptPrefillFormDataSchema.shape, chatgptAiGeneratedFormDataSchema.shape);
|
|
2885
|
+
const urlVerificationOutcomeSchema = z.enum([
|
|
2886
|
+
"pass",
|
|
2887
|
+
"fail",
|
|
2888
|
+
"unverified"
|
|
2889
|
+
]);
|
|
2890
|
+
const VERIFIABLE_URL_FIELDS = {
|
|
2891
|
+
chatgpt: ["privacyPolicyUrl", "termsOfServiceUrl"],
|
|
2892
|
+
claudeai: ["privacyPolicy"]
|
|
2893
|
+
};
|
|
2894
|
+
const verifiableUrlFieldSchema = z.enum([...VERIFIABLE_URL_FIELDS.chatgpt, ...VERIFIABLE_URL_FIELDS.claudeai]);
|
|
2895
|
+
const policyDisclosureSchema = z.enum([
|
|
2896
|
+
"dataCategories",
|
|
2897
|
+
"purposesOfUse",
|
|
2898
|
+
"recipients",
|
|
2899
|
+
"retention"
|
|
2900
|
+
]);
|
|
2901
|
+
const urlVerificationFieldResultSchema = z.object({
|
|
2902
|
+
field: verifiableUrlFieldSchema,
|
|
2903
|
+
url: z.string(),
|
|
2904
|
+
outcome: urlVerificationOutcomeSchema,
|
|
2905
|
+
reason: z.string(),
|
|
2906
|
+
concerns: z.array(z.string()).optional(),
|
|
2907
|
+
scrapedWith: z.enum(["fetch", "firecrawl"]).optional()
|
|
2908
|
+
});
|
|
2909
|
+
const urlVerificationSchema = z.object({
|
|
2910
|
+
verifiedAt: z.coerce.date(),
|
|
2911
|
+
results: z.array(urlVerificationFieldResultSchema)
|
|
2912
|
+
});
|
|
2913
|
+
const pageKindSchema = z.enum([
|
|
2914
|
+
"expectedDocument",
|
|
2915
|
+
"errorPage",
|
|
2916
|
+
"loginWall",
|
|
2917
|
+
"parkedDomain",
|
|
2918
|
+
"comingSoon",
|
|
2919
|
+
"marketingPage",
|
|
2920
|
+
"unrelatedDocument"
|
|
2921
|
+
]);
|
|
2922
|
+
z.object({
|
|
2923
|
+
pageKind: pageKindSchema.describe("What the page actually is. Use 'expectedDocument' only when it is genuinely the document the field claims."),
|
|
2924
|
+
reason: z.string().max(200).describe("One sentence naming what the page is, addressed to the developer who entered the URL."),
|
|
2925
|
+
missingDisclosures: z.array(policyDisclosureSchema).describe("For a privacy policy only: which of the four required disclosures the text does not cover. Empty for every other page kind.")
|
|
2926
|
+
});
|
|
1147
2927
|
const submissionMetaFieldsSchema = z.object({
|
|
1148
2928
|
id: z.string(),
|
|
1149
2929
|
environmentId: z.string(),
|
|
1150
2930
|
auditId: z.string().nullable(),
|
|
2931
|
+
urlVerification: urlVerificationSchema.nullable().default(null),
|
|
1151
2932
|
createdAt: z.coerce.date(),
|
|
1152
2933
|
updatedAt: z.coerce.date()
|
|
1153
2934
|
});
|
|
1154
2935
|
const claudeSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1155
2936
|
platform: z.literal("claudeai"),
|
|
1156
|
-
formData: claudeSubmissionDraftSchema
|
|
2937
|
+
formData: claudeSubmissionDraftSchema,
|
|
2938
|
+
prefillSnapshot: claudeSubmissionDraftSchema.nullable().default(null)
|
|
1157
2939
|
});
|
|
1158
2940
|
const chatgptSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1159
2941
|
platform: z.literal("chatgpt"),
|
|
1160
|
-
formData: chatgptSubmissionDraftSchema
|
|
2942
|
+
formData: chatgptSubmissionDraftSchema,
|
|
2943
|
+
prefillSnapshot: chatgptSubmissionDraftSchema.nullable().default(null)
|
|
1161
2944
|
});
|
|
1162
|
-
z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
2945
|
+
const submissionSchemaInternal = z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
1163
2946
|
z.union([claudeSubmissionDraftSchema, chatgptSubmissionDraftSchema]);
|
|
2947
|
+
/** Discriminated on `platform`, which pins the shape of `formData`: a Claude submission cannot carry chatgpt-only fields, and vice-versa. */
|
|
2948
|
+
const submissionSchema = submissionSchemaInternal;
|
|
2949
|
+
z.literal([
|
|
2950
|
+
100,
|
|
2951
|
+
75,
|
|
2952
|
+
50
|
|
2953
|
+
]);
|
|
1164
2954
|
const subscriptionPlanSchema = z.enum([
|
|
1165
2955
|
"pro",
|
|
1166
2956
|
"business",
|
|
@@ -1172,17 +2962,78 @@ const customerCreditsSchema = z.object({
|
|
|
1172
2962
|
expiresAt: z.number().nullable(),
|
|
1173
2963
|
currency: z.string()
|
|
1174
2964
|
});
|
|
1175
|
-
const customerUsageSchema = z.object({
|
|
1176
|
-
amountInCents: z.number(),
|
|
1177
|
-
currency: z.string(),
|
|
1178
|
-
periodEnd: z.number()
|
|
1179
|
-
});
|
|
1180
2965
|
const partnerDiscountSchema = z.object({ endsAt: z.number() });
|
|
1181
2966
|
z.object({
|
|
1182
2967
|
customerCredits: customerCreditsSchema.nullable(),
|
|
1183
|
-
customerUsage: customerUsageSchema.nullable(),
|
|
1184
2968
|
partnerDiscount: partnerDiscountSchema.nullable()
|
|
1185
2969
|
});
|
|
2970
|
+
const metricsQueueEventSchema = z.object({
|
|
2971
|
+
ts: z.number().int(),
|
|
2972
|
+
method: z.string(),
|
|
2973
|
+
tool: z.string().nullable(),
|
|
2974
|
+
client: z.string(),
|
|
2975
|
+
sessionId: z.string().nullable(),
|
|
2976
|
+
conversationId: z.string().nullable().optional(),
|
|
2977
|
+
durationMs: z.number().int(),
|
|
2978
|
+
outputTokens: z.number().int().nullable(),
|
|
2979
|
+
errorType: z.enum([
|
|
2980
|
+
"mcp_error",
|
|
2981
|
+
"tool_error",
|
|
2982
|
+
"timeout"
|
|
2983
|
+
]).nullable(),
|
|
2984
|
+
errorCode: z.number().int().nullable()
|
|
2985
|
+
});
|
|
2986
|
+
z.object({
|
|
2987
|
+
v: z.literal(1),
|
|
2988
|
+
envId: z.string(),
|
|
2989
|
+
events: z.array(metricsQueueEventSchema)
|
|
2990
|
+
});
|
|
2991
|
+
z.object({ v: z.number() });
|
|
2992
|
+
const TELEMETRY_SIGNALS = [
|
|
2993
|
+
"logs",
|
|
2994
|
+
"metrics",
|
|
2995
|
+
"traces"
|
|
2996
|
+
];
|
|
2997
|
+
const telemetrySignalSchema = z.enum(TELEMETRY_SIGNALS);
|
|
2998
|
+
const OTLP_PROTOCOLS = ["http/protobuf", "http/json"];
|
|
2999
|
+
const otlpProtocolSchema = z.enum(OTLP_PROTOCOLS);
|
|
3000
|
+
const otlpEndpointSchema = z.string().trim().min(1).max(2048);
|
|
3001
|
+
const OTLP_HEADER_VALUE_MAX_LENGTH = 2048;
|
|
3002
|
+
const otlpHeaderNameSchema = z.string().trim().min(1, "Enter a header name").max(128).regex(/^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/, "Use letters, digits and !#$%&'*+-.^_`|~ only");
|
|
3003
|
+
const otlpHeaderValueSchema = z.string().trim().max(OTLP_HEADER_VALUE_MAX_LENGTH).refine((value) => !/[\r\n]/.test(value), "Line breaks are not allowed in a header value");
|
|
3004
|
+
const telemetryDestinationHeaderSchema = z.object({
|
|
3005
|
+
id: z.string(),
|
|
3006
|
+
name: otlpHeaderNameSchema,
|
|
3007
|
+
value: otlpHeaderValueSchema,
|
|
3008
|
+
isSecret: z.boolean()
|
|
3009
|
+
});
|
|
3010
|
+
const otlpPushFailureReasonSchema = z.enum([
|
|
3011
|
+
"credentials",
|
|
3012
|
+
"wrong-path",
|
|
3013
|
+
"wrong-protocol",
|
|
3014
|
+
"invalid-payload",
|
|
3015
|
+
"partial-rejection",
|
|
3016
|
+
"blocked-target",
|
|
3017
|
+
"timeout",
|
|
3018
|
+
"unreachable",
|
|
3019
|
+
"receiver-error",
|
|
3020
|
+
"unexpected-status"
|
|
3021
|
+
]);
|
|
3022
|
+
const telemetryDestinationStatusSchema = z.enum(["active", "suspended"]);
|
|
3023
|
+
z.object({
|
|
3024
|
+
id: z.string(),
|
|
3025
|
+
signal: telemetrySignalSchema,
|
|
3026
|
+
endpoint: otlpEndpointSchema,
|
|
3027
|
+
protocol: otlpProtocolSchema,
|
|
3028
|
+
headers: z.array(telemetryDestinationHeaderSchema),
|
|
3029
|
+
status: telemetryDestinationStatusSchema,
|
|
3030
|
+
lastFailureReason: otlpPushFailureReasonSchema.nullable(),
|
|
3031
|
+
isScopedToIntentionalRequestsOnly: z.boolean()
|
|
3032
|
+
});
|
|
3033
|
+
const hasDuplicateHeaderNames = (headers) => {
|
|
3034
|
+
const names = headers.map(({ name }) => name.trim().toLowerCase());
|
|
3035
|
+
return new Set(names).size !== names.length;
|
|
3036
|
+
};
|
|
1186
3037
|
//#endregion
|
|
1187
3038
|
//#region src/auth-scope.ts
|
|
1188
3039
|
/** Accepts an API key or OAuth access token (default for most routes). */
|
|
@@ -1225,7 +3076,10 @@ const RESERVED_KEYS = [
|
|
|
1225
3076
|
"BUILD_ARG_START_COMMAND",
|
|
1226
3077
|
"ALPIC_HOST",
|
|
1227
3078
|
"ALPIC_CUSTOM_DOMAINS",
|
|
1228
|
-
"ALPIC_INTENT_META_KEY"
|
|
3079
|
+
"ALPIC_INTENT_META_KEY",
|
|
3080
|
+
"ALPIC_FEEDBACK_META_KEY",
|
|
3081
|
+
"ALPIC_EVENTS_META_KEY",
|
|
3082
|
+
"ALPIC_IDENTIFY_META_KEY"
|
|
1229
3083
|
];
|
|
1230
3084
|
const environmentVariableSchema = z.object({
|
|
1231
3085
|
key: z.string().min(2, "Key must be at least 2 characters").regex(/^[a-zA-Z]([a-zA-Z0-9_])+$/, "Key must start with a letter and contain only letters, numbers, and underscores").refine((key) => !RESERVED_KEYS.includes(key), "This key is reserved and cannot be used as an environment variable key"),
|
|
@@ -1278,6 +3132,14 @@ const serverFieldsSchema = z.object({
|
|
|
1278
3132
|
});
|
|
1279
3133
|
//#endregion
|
|
1280
3134
|
//#region src/api.contract.ts
|
|
3135
|
+
const isValidIanaTimeZone = (timeZone) => {
|
|
3136
|
+
try {
|
|
3137
|
+
new Intl.DateTimeFormat("en-US", { timeZone });
|
|
3138
|
+
return true;
|
|
3139
|
+
} catch {
|
|
3140
|
+
return false;
|
|
3141
|
+
}
|
|
3142
|
+
};
|
|
1281
3143
|
const deploymentStatusSchema = z.enum([
|
|
1282
3144
|
"ongoing",
|
|
1283
3145
|
"deployed",
|
|
@@ -1306,21 +3168,20 @@ const deploymentSchema = z.object({
|
|
|
1306
3168
|
isCurrent: z.boolean(),
|
|
1307
3169
|
deploymentPageUrl: z.url().nullable()
|
|
1308
3170
|
});
|
|
1309
|
-
const
|
|
3171
|
+
const isValidTimeInput = (value) => {
|
|
1310
3172
|
if (ms(value) !== void 0) return true;
|
|
1311
3173
|
return !Number.isNaN(new Date(value).getTime());
|
|
1312
3174
|
};
|
|
1313
|
-
const
|
|
3175
|
+
const timeInputSchema = z.string().refine(isValidTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." });
|
|
3176
|
+
const base = oc.errors({ BAD_REQUEST: {} });
|
|
3177
|
+
const createEnvironmentContractV1 = base.route({
|
|
1314
3178
|
path: "/v1/environments",
|
|
1315
3179
|
method: "POST",
|
|
1316
3180
|
summary: "Create an environment",
|
|
1317
3181
|
description: "Create an environment for a project",
|
|
1318
3182
|
tags: ["environments"],
|
|
1319
3183
|
successDescription: "The environment has been created successfully"
|
|
1320
|
-
}).errors({
|
|
1321
|
-
NOT_FOUND: {},
|
|
1322
|
-
BAD_REQUEST: {}
|
|
1323
|
-
}).input(z.object({
|
|
3184
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1324
3185
|
projectId: z.string().describe("The ID of the project to create the environment for"),
|
|
1325
3186
|
name: z.string().min(1).describe("The name of the environment"),
|
|
1326
3187
|
sourceBranch: z.string().min(1).describe("The branch used to build the environment"),
|
|
@@ -1333,7 +3194,7 @@ const createEnvironmentContractV1 = oc.route({
|
|
|
1333
3194
|
createdAt: z.coerce.date(),
|
|
1334
3195
|
projectId: z.string().describe("The ID of the project the environment belongs to")
|
|
1335
3196
|
}));
|
|
1336
|
-
const getEnvironmentContractV1 =
|
|
3197
|
+
const getEnvironmentContractV1 = base.route({
|
|
1337
3198
|
path: "/v1/environments/{environmentId}",
|
|
1338
3199
|
method: "GET",
|
|
1339
3200
|
summary: "Get an environment",
|
|
@@ -1349,6 +3210,14 @@ const getEnvironmentContractV1 = oc.route({
|
|
|
1349
3210
|
createdAt: z.coerce.date(),
|
|
1350
3211
|
projectId: z.string()
|
|
1351
3212
|
}));
|
|
3213
|
+
const deleteEnvironmentContractV1 = base.route({
|
|
3214
|
+
path: "/v1/environments/{environmentId}",
|
|
3215
|
+
method: "DELETE",
|
|
3216
|
+
summary: "Delete an environment",
|
|
3217
|
+
description: "All environments can be deleted except the production environment. This operation is not reversible: associated logs, analytics, and metrics are deleted as well.",
|
|
3218
|
+
tags: ["environments"],
|
|
3219
|
+
successDescription: "The environment has been deleted successfully"
|
|
3220
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.object({ success: z.literal(true) }));
|
|
1352
3221
|
const domainSchema = z.object({
|
|
1353
3222
|
domain: z.string(),
|
|
1354
3223
|
status: z.enum([
|
|
@@ -1390,7 +3259,7 @@ const projectOutputSchema = z.object({
|
|
|
1390
3259
|
productionEnvironment: productionEnvironmentSchema.nullable(),
|
|
1391
3260
|
environments: z.array(environmentSchema)
|
|
1392
3261
|
});
|
|
1393
|
-
const getProjectContractV1 =
|
|
3262
|
+
const getProjectContractV1 = base.route({
|
|
1394
3263
|
path: "/v1/projects/{projectId}",
|
|
1395
3264
|
method: "GET",
|
|
1396
3265
|
summary: "Get a project",
|
|
@@ -1398,18 +3267,15 @@ const getProjectContractV1 = oc.route({
|
|
|
1398
3267
|
tags: ["projects"],
|
|
1399
3268
|
successDescription: "The project details"
|
|
1400
3269
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(projectOutputSchema);
|
|
1401
|
-
const listProjectsContractV1 =
|
|
3270
|
+
const listProjectsContractV1 = base.route({
|
|
1402
3271
|
path: "/v1/projects",
|
|
1403
3272
|
method: "GET",
|
|
1404
3273
|
summary: "List projects",
|
|
1405
3274
|
description: "List all projects for a team",
|
|
1406
3275
|
tags: ["projects"],
|
|
1407
3276
|
successDescription: "The list of projects"
|
|
1408
|
-
}).errors({
|
|
1409
|
-
|
|
1410
|
-
BAD_REQUEST: {}
|
|
1411
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1412
|
-
const createProjectContractV1 = oc.route({
|
|
3277
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
3278
|
+
const createProjectContractV1 = base.route({
|
|
1413
3279
|
path: "/v1/projects",
|
|
1414
3280
|
method: "POST",
|
|
1415
3281
|
summary: "Create a project",
|
|
@@ -1418,7 +3284,6 @@ const createProjectContractV1 = oc.route({
|
|
|
1418
3284
|
successDescription: "The project has been created successfully"
|
|
1419
3285
|
}).errors({
|
|
1420
3286
|
NOT_FOUND: {},
|
|
1421
|
-
BAD_REQUEST: {},
|
|
1422
3287
|
FORBIDDEN: {}
|
|
1423
3288
|
}).input(z.object({
|
|
1424
3289
|
teamId: z.string().optional(),
|
|
@@ -1459,7 +3324,101 @@ const environmentVariableOutputSchema = z.object({
|
|
|
1459
3324
|
isSecret: z.boolean(),
|
|
1460
3325
|
createdAt: z.coerce.date()
|
|
1461
3326
|
});
|
|
1462
|
-
const
|
|
3327
|
+
const telemetryDestinationHeaderOutputSchema = z.discriminatedUnion("isSecret", [z.object({
|
|
3328
|
+
id: z.string(),
|
|
3329
|
+
name: otlpHeaderNameSchema,
|
|
3330
|
+
value: z.null(),
|
|
3331
|
+
isSecret: z.literal(true)
|
|
3332
|
+
}), z.object({
|
|
3333
|
+
id: z.string(),
|
|
3334
|
+
name: otlpHeaderNameSchema,
|
|
3335
|
+
value: otlpHeaderValueSchema,
|
|
3336
|
+
isSecret: z.literal(false)
|
|
3337
|
+
})]);
|
|
3338
|
+
const telemetryDestinationOutputSchema = z.object({
|
|
3339
|
+
id: z.string(),
|
|
3340
|
+
signal: telemetrySignalSchema,
|
|
3341
|
+
endpoint: otlpEndpointSchema,
|
|
3342
|
+
protocol: otlpProtocolSchema,
|
|
3343
|
+
headers: z.array(telemetryDestinationHeaderOutputSchema),
|
|
3344
|
+
status: telemetryDestinationStatusSchema,
|
|
3345
|
+
lastFailureReason: otlpPushFailureReasonSchema.nullable(),
|
|
3346
|
+
isScopedToIntentionalRequestsOnly: z.boolean()
|
|
3347
|
+
});
|
|
3348
|
+
const createTelemetryDestinationHeaderInputSchema = z.object({
|
|
3349
|
+
name: otlpHeaderNameSchema,
|
|
3350
|
+
value: otlpHeaderValueSchema.min(1, "Enter a header value"),
|
|
3351
|
+
isSecret: z.boolean()
|
|
3352
|
+
});
|
|
3353
|
+
const updateTelemetryDestinationHeaderInputSchema = z.object({
|
|
3354
|
+
id: z.string().optional(),
|
|
3355
|
+
name: otlpHeaderNameSchema,
|
|
3356
|
+
value: otlpHeaderValueSchema.optional(),
|
|
3357
|
+
isSecret: z.boolean()
|
|
3358
|
+
});
|
|
3359
|
+
const uniqueTelemetryHeaders = (headers) => !hasDuplicateHeaderNames(headers);
|
|
3360
|
+
const listTelemetryDestinationsContractV1 = base.route({
|
|
3361
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations",
|
|
3362
|
+
method: "GET",
|
|
3363
|
+
summary: "List telemetry destinations",
|
|
3364
|
+
description: "List the OTLP destinations configured for an environment. Secret header values are never returned.",
|
|
3365
|
+
tags: ["telemetry"],
|
|
3366
|
+
successDescription: "The list of telemetry destinations"
|
|
3367
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(telemetryDestinationOutputSchema));
|
|
3368
|
+
const createTelemetryDestinationContractV1 = base.route({
|
|
3369
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations",
|
|
3370
|
+
method: "POST",
|
|
3371
|
+
summary: "Create a telemetry destination",
|
|
3372
|
+
description: "Verify and save an OTLP destination for logs, metrics, or traces.",
|
|
3373
|
+
tags: ["telemetry"],
|
|
3374
|
+
successDescription: "The telemetry destination has been created"
|
|
3375
|
+
}).errors({
|
|
3376
|
+
NOT_FOUND: {},
|
|
3377
|
+
FORBIDDEN: {},
|
|
3378
|
+
OTLP_DESTINATION_UNVERIFIED: { status: 400 },
|
|
3379
|
+
INTERNAL_SERVER_ERROR: {}
|
|
3380
|
+
}).input(z.object({
|
|
3381
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3382
|
+
signal: telemetrySignalSchema,
|
|
3383
|
+
endpoint: otlpEndpointSchema,
|
|
3384
|
+
protocol: otlpProtocolSchema.default("http/protobuf"),
|
|
3385
|
+
isScopedToIntentionalRequestsOnly: z.boolean().default(false),
|
|
3386
|
+
headers: z.array(createTelemetryDestinationHeaderInputSchema).default([]).refine(uniqueTelemetryHeaders, "Header names must be unique")
|
|
3387
|
+
})).output(telemetryDestinationOutputSchema);
|
|
3388
|
+
const updateTelemetryDestinationContractV1 = base.route({
|
|
3389
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations/{destinationId}",
|
|
3390
|
+
method: "PATCH",
|
|
3391
|
+
summary: "Update a telemetry destination",
|
|
3392
|
+
description: "Verify and save changes to an OTLP destination. Omit headers to keep them unchanged; omit the value of an existing header to preserve it. A secret header value must be re-entered when the endpoint changes.",
|
|
3393
|
+
tags: ["telemetry"],
|
|
3394
|
+
successDescription: "The telemetry destination has been updated"
|
|
3395
|
+
}).errors({
|
|
3396
|
+
NOT_FOUND: {},
|
|
3397
|
+
FORBIDDEN: {},
|
|
3398
|
+
OTLP_DESTINATION_UNVERIFIED: { status: 400 }
|
|
3399
|
+
}).input(z.object({
|
|
3400
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3401
|
+
destinationId: z.string().describe("The ID of the telemetry destination"),
|
|
3402
|
+
endpoint: otlpEndpointSchema.optional(),
|
|
3403
|
+
protocol: otlpProtocolSchema.optional(),
|
|
3404
|
+
isScopedToIntentionalRequestsOnly: z.boolean().optional(),
|
|
3405
|
+
headers: z.array(updateTelemetryDestinationHeaderInputSchema).refine(uniqueTelemetryHeaders, "Header names must be unique").optional()
|
|
3406
|
+
})).output(telemetryDestinationOutputSchema);
|
|
3407
|
+
const deleteTelemetryDestinationContractV1 = base.route({
|
|
3408
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations/{destinationId}",
|
|
3409
|
+
method: "DELETE",
|
|
3410
|
+
summary: "Delete a telemetry destination",
|
|
3411
|
+
description: "Delete an OTLP destination from an environment.",
|
|
3412
|
+
tags: ["telemetry"],
|
|
3413
|
+
successDescription: "The telemetry destination has been deleted"
|
|
3414
|
+
}).errors({
|
|
3415
|
+
NOT_FOUND: {},
|
|
3416
|
+
INTERNAL_SERVER_ERROR: {}
|
|
3417
|
+
}).input(z.object({
|
|
3418
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3419
|
+
destinationId: z.string().describe("The ID of the telemetry destination")
|
|
3420
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
3421
|
+
const listEnvironmentVariablesContractV1 = base.route({
|
|
1463
3422
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1464
3423
|
method: "GET",
|
|
1465
3424
|
summary: "List environment variables",
|
|
@@ -1467,48 +3426,39 @@ const listEnvironmentVariablesContractV1 = oc.route({
|
|
|
1467
3426
|
tags: ["environments"],
|
|
1468
3427
|
successDescription: "The list of environment variables"
|
|
1469
3428
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(environmentVariableOutputSchema));
|
|
1470
|
-
const createEnvironmentVariablesContractV1 =
|
|
3429
|
+
const createEnvironmentVariablesContractV1 = base.route({
|
|
1471
3430
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1472
3431
|
method: "POST",
|
|
1473
3432
|
summary: "Add environment variables",
|
|
1474
3433
|
description: "Add one or more environment variables to an environment",
|
|
1475
3434
|
tags: ["environments"],
|
|
1476
3435
|
successDescription: "The environment variables have been added successfully"
|
|
1477
|
-
}).errors({
|
|
1478
|
-
NOT_FOUND: {},
|
|
1479
|
-
BAD_REQUEST: {}
|
|
1480
|
-
}).input(z.object({
|
|
3436
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1481
3437
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1482
3438
|
environmentVariables: environmentVariablesSchema
|
|
1483
3439
|
})).output(z.object({ success: z.literal(true) }));
|
|
1484
|
-
const updateEnvironmentVariableContractV1 =
|
|
3440
|
+
const updateEnvironmentVariableContractV1 = base.route({
|
|
1485
3441
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1486
3442
|
method: "PATCH",
|
|
1487
3443
|
summary: "Update an environment variable",
|
|
1488
3444
|
description: "Update an environment variable by ID",
|
|
1489
3445
|
tags: ["environments"],
|
|
1490
3446
|
successDescription: "The environment variable has been updated successfully"
|
|
1491
|
-
}).errors({
|
|
1492
|
-
NOT_FOUND: {},
|
|
1493
|
-
BAD_REQUEST: {}
|
|
1494
|
-
}).input(z.object({
|
|
3447
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1495
3448
|
environmentVariableId: z.string().describe("The ID of the environment variable"),
|
|
1496
3449
|
key: environmentVariableSchema.shape.key,
|
|
1497
3450
|
value: environmentVariableSchema.shape.value.optional(),
|
|
1498
3451
|
isSecret: environmentVariableSchema.shape.isSecret.optional()
|
|
1499
3452
|
})).output(z.object({ success: z.literal(true) }));
|
|
1500
|
-
const deleteEnvironmentVariableContractV1 =
|
|
3453
|
+
const deleteEnvironmentVariableContractV1 = base.route({
|
|
1501
3454
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1502
3455
|
method: "DELETE",
|
|
1503
3456
|
summary: "Delete an environment variable",
|
|
1504
3457
|
description: "Delete an environment variable by ID",
|
|
1505
3458
|
tags: ["environments"],
|
|
1506
3459
|
successDescription: "The environment variable has been deleted successfully"
|
|
1507
|
-
}).errors({
|
|
1508
|
-
|
|
1509
|
-
BAD_REQUEST: {}
|
|
1510
|
-
}).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
1511
|
-
const deleteProjectContractV1 = oc.route({
|
|
3460
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
3461
|
+
const deleteProjectContractV1 = base.route({
|
|
1512
3462
|
path: "/v1/projects/{projectId}",
|
|
1513
3463
|
method: "DELETE",
|
|
1514
3464
|
summary: "Delete a project",
|
|
@@ -1516,7 +3466,7 @@ const deleteProjectContractV1 = oc.route({
|
|
|
1516
3466
|
tags: ["projects"],
|
|
1517
3467
|
successDescription: "The project has been deleted successfully"
|
|
1518
3468
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.object({ success: z.literal(true) }));
|
|
1519
|
-
const updateProjectContractV1 =
|
|
3469
|
+
const updateProjectContractV1 = base.route({
|
|
1520
3470
|
path: "/v1/projects/{projectId}",
|
|
1521
3471
|
method: "PATCH",
|
|
1522
3472
|
summary: "Update a project",
|
|
@@ -1525,14 +3475,13 @@ const updateProjectContractV1 = oc.route({
|
|
|
1525
3475
|
successDescription: "The project has been updated successfully"
|
|
1526
3476
|
}).errors({
|
|
1527
3477
|
NOT_FOUND: {},
|
|
1528
|
-
BAD_REQUEST: {},
|
|
1529
3478
|
FORBIDDEN: {}
|
|
1530
3479
|
}).input(z.object({
|
|
1531
3480
|
projectId: z.string().describe("The ID of the project"),
|
|
1532
3481
|
name: z.string().min(1).max(100).optional().describe("The new name for the project"),
|
|
1533
3482
|
sourceRepository: z.string().nullable().optional().describe("The source repository to connect to the project")
|
|
1534
3483
|
})).output(projectOutputSchema);
|
|
1535
|
-
const deployEnvironmentContractV1 =
|
|
3484
|
+
const deployEnvironmentContractV1 = base.route({
|
|
1536
3485
|
path: "/v1/environments/{environmentId}/deploy",
|
|
1537
3486
|
method: "POST",
|
|
1538
3487
|
summary: "Deploy an environment",
|
|
@@ -1541,28 +3490,25 @@ const deployEnvironmentContractV1 = oc.route({
|
|
|
1541
3490
|
successDescription: "The environment has been deployed successfully"
|
|
1542
3491
|
}).errors({
|
|
1543
3492
|
NOT_FOUND: {},
|
|
1544
|
-
|
|
3493
|
+
CONFLICT: {}
|
|
1545
3494
|
}).input(z.object({
|
|
1546
3495
|
environmentId: z.string().describe("The ID of the environment to deploy"),
|
|
1547
3496
|
token: z.string().describe("The token to identify the source archive").optional(),
|
|
1548
3497
|
settings: buildSettingsSchema.extend({ transport: transportSchema }).optional().describe("Project settings detected by the client from the source. When provided, the server skips downloading and extracting the source archive to detect them.")
|
|
1549
3498
|
})).output(deploymentSchema);
|
|
1550
|
-
const uploadDeploymentArtifactContractV1 =
|
|
3499
|
+
const uploadDeploymentArtifactContractV1 = base.route({
|
|
1551
3500
|
path: "/v1/deployments/upload",
|
|
1552
3501
|
method: "POST",
|
|
1553
3502
|
summary: "Upload deployment artifacts",
|
|
1554
3503
|
description: "Return a presigned S3 URL to upload a deployment artifact",
|
|
1555
3504
|
tags: ["deployments"],
|
|
1556
3505
|
successDescription: "The presigned upload URL has been generated successfully"
|
|
1557
|
-
}).errors({
|
|
1558
|
-
NOT_FOUND: {},
|
|
1559
|
-
BAD_REQUEST: {}
|
|
1560
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
3506
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
1561
3507
|
uploadUrl: z.url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
|
|
1562
3508
|
token: z.string().describe("Token to identify the source archive"),
|
|
1563
3509
|
expiresAt: z.coerce.date().describe("Expiration date of the presigned URL")
|
|
1564
3510
|
}));
|
|
1565
|
-
const listDeploymentsContractV1 =
|
|
3511
|
+
const listDeploymentsContractV1 = base.route({
|
|
1566
3512
|
path: "/v1/projects/{projectId}/deployments",
|
|
1567
3513
|
method: "GET",
|
|
1568
3514
|
summary: "List project deployments",
|
|
@@ -1574,7 +3520,7 @@ const listDeploymentsContractV1 = oc.route({
|
|
|
1574
3520
|
status: z.array(deploymentStatusSchema).optional().describe("Filter by one or more statuses"),
|
|
1575
3521
|
environmentId: z.string().optional().describe("Filter by environment ID")
|
|
1576
3522
|
})).output(z.array(deploymentSchema));
|
|
1577
|
-
const getDeploymentContractV1 =
|
|
3523
|
+
const getDeploymentContractV1 = base.route({
|
|
1578
3524
|
path: "/v1/deployments/{deploymentId}",
|
|
1579
3525
|
method: "GET",
|
|
1580
3526
|
summary: "Get a deployment",
|
|
@@ -1582,20 +3528,32 @@ const getDeploymentContractV1 = oc.route({
|
|
|
1582
3528
|
tags: ["deployments"],
|
|
1583
3529
|
successDescription: "The deployment details"
|
|
1584
3530
|
}).errors({ NOT_FOUND: {} }).input(z.object({ deploymentId: z.string().describe("The ID of the deployment") })).output(deploymentSchema);
|
|
1585
|
-
const
|
|
3531
|
+
const logEntrySchema = z.object({
|
|
3532
|
+
timestamp: z.coerce.date(),
|
|
3533
|
+
type: z.enum([
|
|
3534
|
+
"START",
|
|
3535
|
+
"END",
|
|
3536
|
+
"INFO",
|
|
3537
|
+
"ERROR",
|
|
3538
|
+
"WARNING",
|
|
3539
|
+
"DEBUG"
|
|
3540
|
+
]),
|
|
3541
|
+
requestId: z.string(),
|
|
3542
|
+
content: z.string().optional(),
|
|
3543
|
+
method: z.string().optional(),
|
|
3544
|
+
durationInMs: z.number().optional()
|
|
3545
|
+
});
|
|
3546
|
+
const getLogsContractV1 = base.route({
|
|
1586
3547
|
path: "/v1/environments/{environmentId}/logs",
|
|
1587
3548
|
method: "GET",
|
|
1588
3549
|
summary: "Get logs",
|
|
1589
3550
|
description: "Get logs for an environment",
|
|
1590
3551
|
tags: ["environments"],
|
|
1591
3552
|
successDescription: "The logs"
|
|
1592
|
-
}).errors({
|
|
1593
|
-
NOT_FOUND: {},
|
|
1594
|
-
BAD_REQUEST: {}
|
|
1595
|
-
}).input(z.object({
|
|
3553
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1596
3554
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1597
|
-
since:
|
|
1598
|
-
until:
|
|
3555
|
+
since: timeInputSchema.optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
3556
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
1599
3557
|
limit: z.coerce.number().int().min(1).max(1e3).default(1e3).describe("Maximum number of log entries to return."),
|
|
1600
3558
|
level: z.array(z.enum([
|
|
1601
3559
|
"INFO",
|
|
@@ -1603,37 +3561,20 @@ const getLogsContractV1 = oc.route({
|
|
|
1603
3561
|
"WARNING",
|
|
1604
3562
|
"DEBUG"
|
|
1605
3563
|
])).optional().describe("Filter by log level"),
|
|
1606
|
-
search:
|
|
3564
|
+
search: logSearchSchema.optional().describe("Term to search for in log content"),
|
|
1607
3565
|
nextToken: z.string().optional().describe("Pagination token from a previous response")
|
|
1608
3566
|
})).output(z.object({
|
|
1609
|
-
logs: z.array(
|
|
1610
|
-
timestamp: z.coerce.date(),
|
|
1611
|
-
type: z.enum([
|
|
1612
|
-
"START",
|
|
1613
|
-
"END",
|
|
1614
|
-
"INFO",
|
|
1615
|
-
"ERROR",
|
|
1616
|
-
"WARNING",
|
|
1617
|
-
"DEBUG"
|
|
1618
|
-
]),
|
|
1619
|
-
requestId: z.string(),
|
|
1620
|
-
content: z.string().optional(),
|
|
1621
|
-
method: z.string().optional(),
|
|
1622
|
-
durationInMs: z.number().optional()
|
|
1623
|
-
})),
|
|
3567
|
+
logs: z.array(logEntrySchema),
|
|
1624
3568
|
nextToken: z.string().nullable()
|
|
1625
3569
|
}));
|
|
1626
|
-
const getLatestLogsContractV1 =
|
|
3570
|
+
const getLatestLogsContractV1 = base.route({
|
|
1627
3571
|
path: "/v1/environments/{environmentId}/latest-logs",
|
|
1628
3572
|
method: "GET",
|
|
1629
3573
|
summary: "Get latest logs",
|
|
1630
3574
|
description: "Get the N most recent logs for an environment",
|
|
1631
3575
|
tags: ["environments"],
|
|
1632
3576
|
successDescription: "The latest logs"
|
|
1633
|
-
}).errors({
|
|
1634
|
-
NOT_FOUND: {},
|
|
1635
|
-
BAD_REQUEST: {}
|
|
1636
|
-
}).input(z.object({
|
|
3577
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1637
3578
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1638
3579
|
limit: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of most recent log entries to return"),
|
|
1639
3580
|
level: z.array(z.enum([
|
|
@@ -1642,23 +3583,9 @@ const getLatestLogsContractV1 = oc.route({
|
|
|
1642
3583
|
"WARNING",
|
|
1643
3584
|
"DEBUG"
|
|
1644
3585
|
])).optional().describe("Filter by log level"),
|
|
1645
|
-
search:
|
|
1646
|
-
})).output(z.object({ logs: z.array(
|
|
1647
|
-
|
|
1648
|
-
type: z.enum([
|
|
1649
|
-
"START",
|
|
1650
|
-
"END",
|
|
1651
|
-
"INFO",
|
|
1652
|
-
"ERROR",
|
|
1653
|
-
"WARNING",
|
|
1654
|
-
"DEBUG"
|
|
1655
|
-
]),
|
|
1656
|
-
requestId: z.string(),
|
|
1657
|
-
content: z.string().optional(),
|
|
1658
|
-
method: z.string().optional(),
|
|
1659
|
-
durationInMs: z.number().optional()
|
|
1660
|
-
})) }));
|
|
1661
|
-
const getDeploymentLogsContractV1 = oc.route({
|
|
3586
|
+
search: logSearchSchema.optional().describe("Term to search for in log content")
|
|
3587
|
+
})).output(z.object({ logs: z.array(logEntrySchema) }));
|
|
3588
|
+
const getDeploymentLogsContractV1 = base.route({
|
|
1662
3589
|
path: "/v1/deployments/{deploymentId}/logs",
|
|
1663
3590
|
method: "GET",
|
|
1664
3591
|
summary: "Get deployment logs",
|
|
@@ -1685,22 +3612,19 @@ const analyticsTimeSeriesSchema = z.object({
|
|
|
1685
3612
|
output_token_mean: z.array(analyticsDataPointSchema),
|
|
1686
3613
|
task_count: z.array(analyticsDataPointSchema)
|
|
1687
3614
|
});
|
|
1688
|
-
const getProjectAnalyticsContractV1 =
|
|
3615
|
+
const getProjectAnalyticsContractV1 = base.route({
|
|
1689
3616
|
path: "/v1/analytics/{projectId}",
|
|
1690
3617
|
method: "GET",
|
|
1691
3618
|
summary: "Get project analytics",
|
|
1692
3619
|
description: "Get analytics data for a project over a time range",
|
|
1693
3620
|
tags: ["analytics"],
|
|
1694
3621
|
successDescription: "The project analytics data"
|
|
1695
|
-
}).errors({
|
|
1696
|
-
NOT_FOUND: {},
|
|
1697
|
-
BAD_REQUEST: {}
|
|
1698
|
-
}).input(z.object({
|
|
3622
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1699
3623
|
projectId: z.string().describe("The ID of the project"),
|
|
1700
3624
|
startTimestamp: z.coerce.number().describe("Start timestamp in milliseconds"),
|
|
1701
3625
|
endTimestamp: z.coerce.number().describe("End timestamp in milliseconds"),
|
|
1702
3626
|
timeZone: z.string().describe("IANA timezone (e.g. Europe/Paris)")
|
|
1703
|
-
}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <=
|
|
3627
|
+
}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <= 26784e5, { message: "Date range must be less than 1 month" }).refine(({ timeZone }) => isValidIanaTimeZone(timeZone), { message: "Time zone must be a valid IANA timezone" })).output(z.object({
|
|
1704
3628
|
metadata: z.object({
|
|
1705
3629
|
startTimestamp: z.number(),
|
|
1706
3630
|
endTimestamp: z.number(),
|
|
@@ -1710,7 +3634,132 @@ const getProjectAnalyticsContractV1 = oc.route({
|
|
|
1710
3634
|
}),
|
|
1711
3635
|
timeSeries: analyticsTimeSeriesSchema
|
|
1712
3636
|
}));
|
|
1713
|
-
const
|
|
3637
|
+
const paginatedInsightsInputShape = {
|
|
3638
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3639
|
+
since: timeInputSchema.default("7d").describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
3640
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
3641
|
+
limit: z.coerce.number().int().min(1).max(200).default(50),
|
|
3642
|
+
offset: z.coerce.number().int().min(0).default(0),
|
|
3643
|
+
search: z.string().trim().min(1).max(200).optional()
|
|
3644
|
+
};
|
|
3645
|
+
const listIntentsContractV1 = base.route({
|
|
3646
|
+
path: "/v1/environments/{environmentId}/intents",
|
|
3647
|
+
method: "GET",
|
|
3648
|
+
summary: "List intents",
|
|
3649
|
+
description: "List grouped user intents for an environment over a time range",
|
|
3650
|
+
tags: ["insights"],
|
|
3651
|
+
successDescription: "The grouped user intents"
|
|
3652
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3653
|
+
...paginatedInsightsInputShape,
|
|
3654
|
+
tools: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
3655
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional(),
|
|
3656
|
+
categoryIds: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
3657
|
+
sortDir: z.enum(["asc", "desc"]).default("desc")
|
|
3658
|
+
})).output(z.object({
|
|
3659
|
+
intents: z.array(z.object({
|
|
3660
|
+
id: z.string(),
|
|
3661
|
+
intentIds: z.array(z.string()).min(1),
|
|
3662
|
+
environmentId: z.string(),
|
|
3663
|
+
message: z.string(),
|
|
3664
|
+
toolName: z.string(),
|
|
3665
|
+
createdAt: z.coerce.date(),
|
|
3666
|
+
occurrenceCount: z.number().int().positive(),
|
|
3667
|
+
clientName: z.string().nullable(),
|
|
3668
|
+
clientId: z.string().nullable(),
|
|
3669
|
+
categories: z.array(z.object({
|
|
3670
|
+
id: z.string(),
|
|
3671
|
+
name: z.string(),
|
|
3672
|
+
color: intentCategoryColorSchema
|
|
3673
|
+
}))
|
|
3674
|
+
})),
|
|
3675
|
+
totalCount: z.number().int().nonnegative()
|
|
3676
|
+
}));
|
|
3677
|
+
const listFeedbacksContractV1 = base.route({
|
|
3678
|
+
path: "/v1/environments/{environmentId}/feedbacks",
|
|
3679
|
+
method: "GET",
|
|
3680
|
+
summary: "List feedbacks",
|
|
3681
|
+
description: "List user feedback for an environment over a time range",
|
|
3682
|
+
tags: ["insights"],
|
|
3683
|
+
successDescription: "The user feedback"
|
|
3684
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3685
|
+
...paginatedInsightsInputShape,
|
|
3686
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional()
|
|
3687
|
+
})).output(z.object({
|
|
3688
|
+
feedbacks: z.array(feedbackSchema.extend({ clientId: z.string().nullable() })),
|
|
3689
|
+
totalCount: z.number().int().nonnegative()
|
|
3690
|
+
}));
|
|
3691
|
+
const intentCategoryNameSchema = z.string().trim().min(1).max(100).describe("The category name");
|
|
3692
|
+
const categorizableIntentIdsSchema = z.array(z.string().trim().min(1)).min(1).max(100).describe("IDs of the intents to categorize");
|
|
3693
|
+
const listIntentCategoriesContractV1 = base.route({
|
|
3694
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
3695
|
+
method: "GET",
|
|
3696
|
+
summary: "List intent categories",
|
|
3697
|
+
description: "List intent categories for an environment, including how many intents each category is linked to",
|
|
3698
|
+
tags: ["insights"],
|
|
3699
|
+
successDescription: "The intent categories"
|
|
3700
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(intentCategorySummarySchema));
|
|
3701
|
+
const createIntentCategoryContractV1 = base.route({
|
|
3702
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
3703
|
+
method: "POST",
|
|
3704
|
+
summary: "Create an intent category",
|
|
3705
|
+
description: "Create an intent category, optionally linking it to existing intents",
|
|
3706
|
+
tags: ["insights"],
|
|
3707
|
+
successDescription: "The created intent category"
|
|
3708
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3709
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3710
|
+
name: intentCategoryNameSchema,
|
|
3711
|
+
color: intentCategoryColorSchema.optional().describe("The category color; derived from the name when omitted"),
|
|
3712
|
+
intentIds: categorizableIntentIdsSchema.optional().describe("IDs of intents to link to the new category")
|
|
3713
|
+
})).output(intentCategorySchema);
|
|
3714
|
+
const updateIntentCategoryContractV1 = base.route({
|
|
3715
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
3716
|
+
method: "PATCH",
|
|
3717
|
+
summary: "Update an intent category",
|
|
3718
|
+
description: "Rename or recolor an intent category",
|
|
3719
|
+
tags: ["insights"],
|
|
3720
|
+
successDescription: "The updated intent category"
|
|
3721
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3722
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3723
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
3724
|
+
name: intentCategoryNameSchema.optional(),
|
|
3725
|
+
color: intentCategoryColorSchema.optional().describe("The category color")
|
|
3726
|
+
}).refine(({ name, color }) => name !== void 0 || color !== void 0, { message: "At least one of name or color must be provided" })).output(intentCategorySchema);
|
|
3727
|
+
const deleteIntentCategoryContractV1 = base.route({
|
|
3728
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
3729
|
+
method: "DELETE",
|
|
3730
|
+
summary: "Delete an intent category",
|
|
3731
|
+
description: "Delete an intent category; its intents are unlinked but not deleted",
|
|
3732
|
+
tags: ["insights"],
|
|
3733
|
+
successDescription: "The intent category has been deleted successfully"
|
|
3734
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3735
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3736
|
+
categoryId: z.string().describe("The ID of the category")
|
|
3737
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
3738
|
+
const linkIntentCategoryContractV1 = base.route({
|
|
3739
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/link",
|
|
3740
|
+
method: "POST",
|
|
3741
|
+
summary: "Link an intent category",
|
|
3742
|
+
description: "Link an intent category to intents; already linked intents are ignored",
|
|
3743
|
+
tags: ["insights"],
|
|
3744
|
+
successDescription: "The intents have been linked successfully"
|
|
3745
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3746
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3747
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
3748
|
+
intentIds: categorizableIntentIdsSchema
|
|
3749
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
3750
|
+
const unlinkIntentCategoryContractV1 = base.route({
|
|
3751
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/unlink",
|
|
3752
|
+
method: "POST",
|
|
3753
|
+
summary: "Unlink an intent category",
|
|
3754
|
+
description: "Unlink an intent category from intents; intents without the category are ignored",
|
|
3755
|
+
tags: ["insights"],
|
|
3756
|
+
successDescription: "The intents have been unlinked successfully"
|
|
3757
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3758
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
3759
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
3760
|
+
intentIds: categorizableIntentIdsSchema
|
|
3761
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
3762
|
+
const listTeamsContractV1 = base.route({
|
|
1714
3763
|
path: "/v1/teams",
|
|
1715
3764
|
method: "GET",
|
|
1716
3765
|
summary: "List teams",
|
|
@@ -1723,7 +3772,22 @@ const listTeamsContractV1 = oc.route({
|
|
|
1723
3772
|
createdAt: z.coerce.date(),
|
|
1724
3773
|
hasStripeAccount: z.boolean()
|
|
1725
3774
|
})));
|
|
1726
|
-
const
|
|
3775
|
+
const getTeamUsageContractV1 = base.route({
|
|
3776
|
+
path: "/v1/teams/{teamId}/usage",
|
|
3777
|
+
method: "GET",
|
|
3778
|
+
summary: "Get team usage",
|
|
3779
|
+
description: "Get the MCP request usage of a team for its current billing window. A team that has made no request in the window reports zero.",
|
|
3780
|
+
tags: ["teams"],
|
|
3781
|
+
successDescription: "The current billing window usage"
|
|
3782
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().describe("The ID of the team") })).output(z.object({
|
|
3783
|
+
teamId: z.string(),
|
|
3784
|
+
plan: subscriptionPlanSchema.nullable().describe("The plan in force for the window, null on the Free plan"),
|
|
3785
|
+
periodStart: z.coerce.date().describe("Start of the current billing window"),
|
|
3786
|
+
periodEnd: z.coerce.date().describe("End of the current billing window"),
|
|
3787
|
+
requestCount: z.number().int().describe("MCP requests settled during the current billing window"),
|
|
3788
|
+
includedRequests: z.number().int().nullable().describe("Requests included in the plan for one window, null when the allowance is contract-specific")
|
|
3789
|
+
}));
|
|
3790
|
+
const getTunnelTicketContractV1 = base.route({
|
|
1727
3791
|
path: "/v1/tunnels/ticket",
|
|
1728
3792
|
method: "GET",
|
|
1729
3793
|
summary: "Get a tunnel ticket",
|
|
@@ -1735,16 +3799,13 @@ const getTunnelTicketContractV1 = oc.route({
|
|
|
1735
3799
|
ticket: z.string().describe("The signed tunnel ticket"),
|
|
1736
3800
|
tunnelHost: z.string().describe("The tunnel host to connect to")
|
|
1737
3801
|
}));
|
|
1738
|
-
const publishServerContractV1 =
|
|
3802
|
+
const publishServerContractV1 = base.route({
|
|
1739
3803
|
path: "/v1/distribution/publish",
|
|
1740
3804
|
method: "POST",
|
|
1741
3805
|
summary: "Publish a server to the MCP registry",
|
|
1742
3806
|
tags: ["distribution"],
|
|
1743
3807
|
successDescription: "The server has been published successfully"
|
|
1744
|
-
}).errors({
|
|
1745
|
-
NOT_FOUND: {},
|
|
1746
|
-
BAD_REQUEST: {}
|
|
1747
|
-
}).input(z.object({
|
|
3808
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1748
3809
|
projectId: z.string(),
|
|
1749
3810
|
domain: z.string(),
|
|
1750
3811
|
title: z.string().min(1).max(100),
|
|
@@ -1753,17 +3814,14 @@ const publishServerContractV1 = oc.route({
|
|
|
1753
3814
|
iconSrc: z.url().max(255).optional(),
|
|
1754
3815
|
dryRun: z.boolean().optional()
|
|
1755
3816
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
1756
|
-
const getServerInfoContractV1 =
|
|
3817
|
+
const getServerInfoContractV1 = base.route({
|
|
1757
3818
|
path: "/v1/distribution/get",
|
|
1758
3819
|
method: "GET",
|
|
1759
3820
|
summary: "Get server info",
|
|
1760
3821
|
description: "Get info about a server",
|
|
1761
3822
|
tags: ["distribution"],
|
|
1762
3823
|
successDescription: "The server info"
|
|
1763
|
-
}).errors({
|
|
1764
|
-
NOT_FOUND: {},
|
|
1765
|
-
BAD_REQUEST: {}
|
|
1766
|
-
}).input(z.object({
|
|
3824
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1767
3825
|
projectId: z.string(),
|
|
1768
3826
|
domain: z.string()
|
|
1769
3827
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
@@ -1782,7 +3840,7 @@ const playgroundOutputSchema = z.object({
|
|
|
1782
3840
|
isPlaygroundEnabled: z.boolean(),
|
|
1783
3841
|
serverMetadata: playgroundServerMetadataOutputSchema.nullable()
|
|
1784
3842
|
});
|
|
1785
|
-
const getPlaygroundContractV1 =
|
|
3843
|
+
const getPlaygroundContractV1 = base.route({
|
|
1786
3844
|
path: "/v1/environments/{environmentId}/playground",
|
|
1787
3845
|
method: "GET",
|
|
1788
3846
|
summary: "Get playground configuration",
|
|
@@ -1790,17 +3848,14 @@ const getPlaygroundContractV1 = oc.route({
|
|
|
1790
3848
|
tags: ["environments"],
|
|
1791
3849
|
successDescription: "The playground configuration"
|
|
1792
3850
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(playgroundOutputSchema);
|
|
1793
|
-
const upsertPlaygroundContractV1 =
|
|
3851
|
+
const upsertPlaygroundContractV1 = base.route({
|
|
1794
3852
|
path: "/v1/environments/{environmentId}/playground",
|
|
1795
3853
|
method: "PUT",
|
|
1796
3854
|
summary: "Update playground configuration",
|
|
1797
3855
|
description: "Update the playground configuration for an environment. All fields are optional — only provided fields are updated.",
|
|
1798
3856
|
tags: ["environments"],
|
|
1799
3857
|
successDescription: "The updated playground configuration"
|
|
1800
|
-
}).errors({
|
|
1801
|
-
NOT_FOUND: {},
|
|
1802
|
-
BAD_REQUEST: {}
|
|
1803
|
-
}).input(z.object({
|
|
3858
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1804
3859
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1805
3860
|
isPlaygroundEnabled: z.boolean().optional(),
|
|
1806
3861
|
name: z.string().min(1).max(100).optional(),
|
|
@@ -1808,7 +3863,7 @@ const upsertPlaygroundContractV1 = oc.route({
|
|
|
1808
3863
|
headers: z.array(playgroundHeaderSchema).optional(),
|
|
1809
3864
|
examplePrompts: z.array(playgroundExamplePromptSchema).max(5).optional()
|
|
1810
3865
|
})).output(playgroundOutputSchema);
|
|
1811
|
-
const createBeaconContractV1 =
|
|
3866
|
+
const createBeaconContractV1 = base.route({
|
|
1812
3867
|
path: "/v1/beacon/audits",
|
|
1813
3868
|
method: "POST",
|
|
1814
3869
|
summary: "Create a beacon audit",
|
|
@@ -1817,7 +3872,6 @@ const createBeaconContractV1 = oc.route({
|
|
|
1817
3872
|
successDescription: "The audit has been created"
|
|
1818
3873
|
}).errors({
|
|
1819
3874
|
NOT_FOUND: {},
|
|
1820
|
-
BAD_REQUEST: {},
|
|
1821
3875
|
DNS_RESOLUTION_FAILED: { status: 400 }
|
|
1822
3876
|
}).input(z.object({
|
|
1823
3877
|
targetUrl: z.url().describe("The HTTPS URL of the MCP server to audit"),
|
|
@@ -1825,7 +3879,7 @@ const createBeaconContractV1 = oc.route({
|
|
|
1825
3879
|
projectId: z.string().optional().describe("The project ID to associate the audit with"),
|
|
1826
3880
|
excludeCategories: z.array(checkCategorySchema).optional().describe("Check categories to exclude from the audit")
|
|
1827
3881
|
})).output(z.object({ id: z.string() }));
|
|
1828
|
-
const getBeaconContractV1 =
|
|
3882
|
+
const getBeaconContractV1 = base.route({
|
|
1829
3883
|
path: "/v1/beacon/audits/{auditId}",
|
|
1830
3884
|
method: "GET",
|
|
1831
3885
|
summary: "Get a beacon audit",
|
|
@@ -1840,9 +3894,73 @@ const getBeaconContractV1 = oc.route({
|
|
|
1840
3894
|
createdAt: z.coerce.date(),
|
|
1841
3895
|
report: auditReportWithScreenshotsSchema.nullable()
|
|
1842
3896
|
}));
|
|
3897
|
+
const PLATFORM_DESCRIPTION = "The directory the package targets: `chatgpt` for the OpenAI App Directory, `claudeai` for the Anthropic MCP Directory";
|
|
3898
|
+
const submissionIdSchema = z.string().describe("The ID of the submission package");
|
|
3899
|
+
const claudeSubmissionUpdateSchema = claudeSubmissionDraftSchema.strict();
|
|
3900
|
+
const chatgptSubmissionUpdateSchema = chatgptSubmissionDraftSchema.strict();
|
|
3901
|
+
const createSubmissionContractV1 = base.route({
|
|
3902
|
+
path: "/v1/submissions",
|
|
3903
|
+
method: "POST",
|
|
3904
|
+
summary: "Create a submission package",
|
|
3905
|
+
description: "Create a submission package for an environment. Alpic reads the environment's live MCP server and prefills every field it can infer, so the response already carries the populated package. The environment must have a successful deployment and must not require authentication.",
|
|
3906
|
+
tags: ["submissions"],
|
|
3907
|
+
successDescription: "The created submission package, with its prefilled fields"
|
|
3908
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3909
|
+
environmentId: z.string().describe("The ID of the environment to build the package from"),
|
|
3910
|
+
platform: platformSchema.describe(PLATFORM_DESCRIPTION)
|
|
3911
|
+
})).output(submissionSchema);
|
|
3912
|
+
const listSubmissionsContractV1 = base.route({
|
|
3913
|
+
path: "/v1/projects/{projectId}/submissions",
|
|
3914
|
+
method: "GET",
|
|
3915
|
+
summary: "List submission packages",
|
|
3916
|
+
description: "List the submission packages of a project, grouped by directory and most recently updated first, optionally narrowed to one environment or one directory",
|
|
3917
|
+
tags: ["submissions"],
|
|
3918
|
+
successDescription: "The list of submission packages"
|
|
3919
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
3920
|
+
projectId: z.string().describe("The ID of the project"),
|
|
3921
|
+
environmentId: z.string().optional().describe("Filter by environment ID"),
|
|
3922
|
+
platform: platformSchema.optional().describe(PLATFORM_DESCRIPTION)
|
|
3923
|
+
})).output(z.array(submissionSchema));
|
|
3924
|
+
const getSubmissionContractV1 = base.route({
|
|
3925
|
+
path: "/v1/submissions/{submissionId}",
|
|
3926
|
+
method: "GET",
|
|
3927
|
+
summary: "Get a submission package",
|
|
3928
|
+
description: "Get a submission package by ID, including its form data and the prefill it started from",
|
|
3929
|
+
tags: ["submissions"],
|
|
3930
|
+
successDescription: "The submission package"
|
|
3931
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ submissionId: submissionIdSchema })).output(submissionSchema);
|
|
3932
|
+
const updateSubmissionContractV1 = base.route({
|
|
3933
|
+
path: "/v1/submissions/{submissionId}",
|
|
3934
|
+
method: "PUT",
|
|
3935
|
+
summary: "Update a submission package",
|
|
3936
|
+
description: "Update the form data of a submission package. Only the fields you send are changed; the rest are left as they are. Unknown field names are rejected rather than ignored, so a typo fails the call. `platform` must match the package's own platform.",
|
|
3937
|
+
tags: ["submissions"],
|
|
3938
|
+
successDescription: "The updated submission package"
|
|
3939
|
+
}).errors({ NOT_FOUND: {} }).input(z.discriminatedUnion("platform", [z.object({
|
|
3940
|
+
submissionId: submissionIdSchema,
|
|
3941
|
+
platform: z.literal("claudeai").describe(PLATFORM_DESCRIPTION),
|
|
3942
|
+
formData: claudeSubmissionUpdateSchema
|
|
3943
|
+
}), z.object({
|
|
3944
|
+
submissionId: submissionIdSchema,
|
|
3945
|
+
platform: z.literal("chatgpt").describe(PLATFORM_DESCRIPTION),
|
|
3946
|
+
formData: chatgptSubmissionUpdateSchema
|
|
3947
|
+
})])).output(submissionSchema);
|
|
1843
3948
|
const contract = {
|
|
1844
|
-
teams: {
|
|
3949
|
+
teams: {
|
|
3950
|
+
list: { v1: listTeamsContractV1 },
|
|
3951
|
+
getUsage: { v1: getTeamUsageContractV1 }
|
|
3952
|
+
},
|
|
1845
3953
|
analytics: { get: { v1: getProjectAnalyticsContractV1 } },
|
|
3954
|
+
intents: { list: { v1: listIntentsContractV1 } },
|
|
3955
|
+
intentCategories: {
|
|
3956
|
+
list: { v1: listIntentCategoriesContractV1 },
|
|
3957
|
+
create: { v1: createIntentCategoryContractV1 },
|
|
3958
|
+
update: { v1: updateIntentCategoryContractV1 },
|
|
3959
|
+
delete: { v1: deleteIntentCategoryContractV1 },
|
|
3960
|
+
link: { v1: linkIntentCategoryContractV1 },
|
|
3961
|
+
unlink: { v1: unlinkIntentCategoryContractV1 }
|
|
3962
|
+
},
|
|
3963
|
+
feedbacks: { list: { v1: listFeedbacksContractV1 } },
|
|
1846
3964
|
deployments: {
|
|
1847
3965
|
list: { v1: listDeploymentsContractV1 },
|
|
1848
3966
|
get: { v1: getDeploymentContractV1 },
|
|
@@ -1852,6 +3970,7 @@ const contract = {
|
|
|
1852
3970
|
environments: {
|
|
1853
3971
|
create: { v1: createEnvironmentContractV1 },
|
|
1854
3972
|
get: { v1: getEnvironmentContractV1 },
|
|
3973
|
+
delete: { v1: deleteEnvironmentContractV1 },
|
|
1855
3974
|
deploy: { v1: deployEnvironmentContractV1 },
|
|
1856
3975
|
getLogs: { v1: getLogsContractV1 },
|
|
1857
3976
|
getLatestLogs: { v1: getLatestLogsContractV1 }
|
|
@@ -1862,6 +3981,12 @@ const contract = {
|
|
|
1862
3981
|
update: { v1: updateEnvironmentVariableContractV1 },
|
|
1863
3982
|
delete: { v1: deleteEnvironmentVariableContractV1 }
|
|
1864
3983
|
},
|
|
3984
|
+
telemetryDestinations: {
|
|
3985
|
+
list: { v1: listTelemetryDestinationsContractV1 },
|
|
3986
|
+
create: { v1: createTelemetryDestinationContractV1 },
|
|
3987
|
+
update: { v1: updateTelemetryDestinationContractV1 },
|
|
3988
|
+
delete: { v1: deleteTelemetryDestinationContractV1 }
|
|
3989
|
+
},
|
|
1865
3990
|
projects: {
|
|
1866
3991
|
update: { v1: updateProjectContractV1 },
|
|
1867
3992
|
get: { v1: getProjectContractV1 },
|
|
@@ -1881,7 +4006,39 @@ const contract = {
|
|
|
1881
4006
|
beacon: {
|
|
1882
4007
|
create: { v1: createBeaconContractV1 },
|
|
1883
4008
|
get: { v1: getBeaconContractV1 }
|
|
4009
|
+
},
|
|
4010
|
+
submissions: {
|
|
4011
|
+
create: { v1: createSubmissionContractV1 },
|
|
4012
|
+
list: { v1: listSubmissionsContractV1 },
|
|
4013
|
+
get: { v1: getSubmissionContractV1 },
|
|
4014
|
+
update: { v1: updateSubmissionContractV1 }
|
|
4015
|
+
}
|
|
4016
|
+
};
|
|
4017
|
+
const { uploadArtifact: _discard, ...deploymentsForDocs } = contract.deployments;
|
|
4018
|
+
const contractForDocs = {
|
|
4019
|
+
...contract,
|
|
4020
|
+
deployments: deploymentsForDocs
|
|
4021
|
+
};
|
|
4022
|
+
/** Shared by the served `openapi.json` and the snapshot test that guards it, so the two cannot drift. */
|
|
4023
|
+
const OPENAPI_DOC_OPTIONS = {
|
|
4024
|
+
info: {
|
|
4025
|
+
title: "Alpic API",
|
|
4026
|
+
version: "1.0.0"
|
|
4027
|
+
},
|
|
4028
|
+
servers: [{ url: "https://api.alpic.ai" }],
|
|
4029
|
+
security: [{ bearerAuth: [] }],
|
|
4030
|
+
components: { securitySchemes: { bearerAuth: {
|
|
4031
|
+
type: "http",
|
|
4032
|
+
description: "Bearer token for authentication. Use an API key from the API Keys page in team settings, or an OAuth access token.",
|
|
4033
|
+
scheme: "bearer"
|
|
4034
|
+
} } },
|
|
4035
|
+
commonSchemas: {
|
|
4036
|
+
Submission: { schema: submissionSchema },
|
|
4037
|
+
ClaudeSubmissionFormData: { schema: claudeSubmissionDraftSchema },
|
|
4038
|
+
ChatgptSubmissionFormData: { schema: chatgptSubmissionDraftSchema },
|
|
4039
|
+
ClaudeSubmissionFormDataUpdate: { schema: claudeSubmissionUpdateSchema },
|
|
4040
|
+
ChatgptSubmissionFormDataUpdate: { schema: chatgptSubmissionUpdateSchema }
|
|
1884
4041
|
}
|
|
1885
4042
|
};
|
|
1886
4043
|
//#endregion
|
|
1887
|
-
export { AUTH_SCOPE_ANY, AUTH_SCOPE_USER, PLATFORM_LABELS, buildSettingsSchema, contract, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
|
|
4044
|
+
export { AI_PLATFORMS, AUTH_SCOPE_ANY, AUTH_SCOPE_USER, INTENT_CATEGORY_COLORS, OPENAPI_DOC_OPTIONS, OTLP_PROTOCOLS, PLATFORM_LABELS, TELEMETRY_SIGNALS, buildSettingsSchema, chatgptSubmissionUpdateSchema, claudeSubmissionUpdateSchema, contract, contractForDocs, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, intentCategoryColorSchema, otlpProtocolSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, telemetrySignalSchema, transportSchema, updateEnvironmentVariableSchema };
|