@carrierllc/mcp 0.13.92 → 0.13.94

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.
@@ -806,8 +806,277 @@ async function deploySite(target, brand, opts = {}) {
806
806
  }
807
807
  }
808
808
 
809
+ // src/cli/lib/clerk-instance-lock.ts
810
+ import { createHash, randomUUID } from "crypto";
811
+ import { lstat, mkdir, open, readdir, rm as rm2, stat, writeFile as writeFile2 } from "fs/promises";
812
+ import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
813
+ import { basename, dirname, join as join4 } from "path";
814
+ var CLERK_LOCK_STALE_MS = 12e4;
815
+ var CLERK_LOCK_WAIT_MS = 3e4;
816
+ var CLERK_LOCK_HEARTBEAT_MS = 5e3;
817
+ var MISSED_HEARTBEATS = 3;
818
+ function heartbeatMs(staleMs) {
819
+ return Math.max(1e3, Math.min(CLERK_LOCK_HEARTBEAT_MS, Math.floor(staleMs / 4)));
820
+ }
821
+ var ANNOUNCE_GARBAGE_MS = 10 * 6e4;
822
+ var POLL_MS = 150;
823
+ function pollMs() {
824
+ return POLL_MS / 2 + Math.random() * POLL_MS;
825
+ }
826
+ function fallbackClerkLockDir() {
827
+ const uid = typeof process.getuid === "function" ? String(process.getuid()) : "user";
828
+ return join4(tmpdir2(), `carrier-locks-${uid}`);
829
+ }
830
+ async function lockDirProblem(dir) {
831
+ let st;
832
+ try {
833
+ st = await lstat(dir);
834
+ } catch (err) {
835
+ return err.message;
836
+ }
837
+ if (!st.isDirectory()) return "it is not a directory";
838
+ if (typeof process.getuid === "function" && st.uid !== process.getuid()) {
839
+ return "it belongs to another user";
840
+ }
841
+ return void 0;
842
+ }
843
+ function defaultClerkLockDir() {
844
+ try {
845
+ const home = homedir2();
846
+ if (home) return join4(home, ".carrier", "locks");
847
+ } catch {
848
+ }
849
+ return fallbackClerkLockDir();
850
+ }
851
+ function clerkInstanceLockPath(dir, secretKey) {
852
+ const digest = createHash("sha256").update(secretKey).digest("hex").slice(0, 32);
853
+ return join4(dir, `clerk-instance-${digest}.lock`);
854
+ }
855
+ function sleep(ms) {
856
+ return new Promise((resolve) => setTimeout(resolve, ms));
857
+ }
858
+ async function readLockFile(path) {
859
+ let handle;
860
+ try {
861
+ handle = await open(path, "r");
862
+ } catch (err) {
863
+ if (err.code !== "ENOENT") return "unreadable";
864
+ try {
865
+ await lstat(path);
866
+ return "unreadable";
867
+ } catch {
868
+ return void 0;
869
+ }
870
+ }
871
+ try {
872
+ const st = await handle.stat();
873
+ let pid;
874
+ try {
875
+ const parsed = JSON.parse(await handle.readFile("utf8"));
876
+ const value = typeof parsed === "object" && parsed !== null ? parsed.pid : void 0;
877
+ if (typeof value === "number" && Number.isInteger(value) && value > 0) pid = value;
878
+ } catch {
879
+ pid = void 0;
880
+ }
881
+ return { ino: st.ino, mtimeMs: st.mtimeMs, pid };
882
+ } catch {
883
+ return "unreadable";
884
+ } finally {
885
+ await handle.close().catch(() => {
886
+ });
887
+ }
888
+ }
889
+ function processExists(pid) {
890
+ try {
891
+ process.kill(pid, 0);
892
+ return true;
893
+ } catch (err) {
894
+ return err.code !== "ESRCH";
895
+ }
896
+ }
897
+ function isAbandoned(file, staleMs, deadGraceMs) {
898
+ const age = Date.now() - file.mtimeMs;
899
+ if (file.pid === void 0) return age > staleMs;
900
+ return age > Math.min(staleMs, deadGraceMs) && !processExists(file.pid);
901
+ }
902
+ async function removeIfSame(path, ino) {
903
+ try {
904
+ if ((await stat(path)).ino !== ino) return;
905
+ } catch {
906
+ return;
907
+ }
908
+ await rm2(path, { force: true }).catch(() => {
909
+ });
910
+ }
911
+ async function takeBreaker(path) {
912
+ const dir = dirname(path);
913
+ const prefix = `${basename(path)}.breaking.`;
914
+ const mine = `${prefix}${process.pid}.${randomUUID()}`;
915
+ const minePath = join4(dir, mine);
916
+ try {
917
+ await writeFile2(minePath, "", { flag: "wx" });
918
+ } catch {
919
+ return void 0;
920
+ }
921
+ const release = async () => {
922
+ await rm2(minePath, { force: true }).catch(() => {
923
+ });
924
+ };
925
+ try {
926
+ for (const name of await readdir(dir)) {
927
+ if (name === mine || !name.startsWith(prefix)) continue;
928
+ const otherPath = join4(dir, name);
929
+ let touchedMs;
930
+ try {
931
+ touchedMs = (await stat(otherPath)).mtimeMs;
932
+ } catch {
933
+ continue;
934
+ }
935
+ const pid = Number(name.slice(prefix.length).split(".")[0]);
936
+ const live = Number.isInteger(pid) && pid > 0 && processExists(pid) && Date.now() - touchedMs <= ANNOUNCE_GARBAGE_MS;
937
+ if (live) {
938
+ await release();
939
+ return void 0;
940
+ }
941
+ await rm2(otherPath, { force: true }).catch(() => {
942
+ });
943
+ }
944
+ } catch {
945
+ await release();
946
+ return void 0;
947
+ }
948
+ return { release };
949
+ }
950
+ async function breakAbandonedLock(path, staleMs, deadGraceMs) {
951
+ const seen = await readLockFile(path);
952
+ if (!seen) return "gone";
953
+ if (seen === "unreadable") return "held";
954
+ if (!isAbandoned(seen, staleMs, deadGraceMs)) return "held";
955
+ const breaker = await takeBreaker(path);
956
+ if (!breaker) return "held";
957
+ try {
958
+ const now = await readLockFile(path);
959
+ if (!now) return "gone";
960
+ if (now === "unreadable") return "held";
961
+ if (now.ino !== seen.ino || !isAbandoned(now, staleMs, deadGraceMs)) return "held";
962
+ await rm2(path, { force: true });
963
+ return "broken";
964
+ } catch {
965
+ return "held";
966
+ } finally {
967
+ await breaker.release();
968
+ }
969
+ }
970
+ async function acquireClerkInstanceLock(dir, secretKey, opts = {}) {
971
+ const waitMs = opts.waitMs ?? CLERK_LOCK_WAIT_MS;
972
+ const staleMs = opts.staleMs ?? CLERK_LOCK_STALE_MS;
973
+ const path = clerkInstanceLockPath(dir, secretKey);
974
+ try {
975
+ await mkdir(dir, { recursive: true, mode: 448 });
976
+ } catch (err) {
977
+ return {
978
+ ok: false,
979
+ reason: `could not create the Clerk instance lock directory ${dir}: ${err.message}`,
980
+ cause: "directory"
981
+ };
982
+ }
983
+ const problem = await lockDirProblem(dir);
984
+ if (problem) {
985
+ return {
986
+ ok: false,
987
+ reason: `the Clerk instance lock directory ${dir} cannot be used: ${problem}`,
988
+ cause: "directory"
989
+ };
990
+ }
991
+ const deadline = Date.now() + waitMs;
992
+ const beatMs = heartbeatMs(staleMs);
993
+ let lastTry = false;
994
+ let freeRetries = 0;
995
+ for (; ; ) {
996
+ let handle;
997
+ try {
998
+ handle = await open(path, "wx");
999
+ } catch (err) {
1000
+ if (err.code !== "EEXIST") {
1001
+ return {
1002
+ ok: false,
1003
+ reason: `could not take the Clerk instance lock: ${err.message}`,
1004
+ // The directory would not take a new file.
1005
+ cause: "directory"
1006
+ };
1007
+ }
1008
+ }
1009
+ if (handle) {
1010
+ const held = handle;
1011
+ let ino;
1012
+ try {
1013
+ await held.writeFile(JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }));
1014
+ ino = (await held.stat()).ino;
1015
+ } catch (err) {
1016
+ await held.close().catch(() => {
1017
+ });
1018
+ await rm2(path, { force: true }).catch(() => {
1019
+ });
1020
+ return {
1021
+ ok: false,
1022
+ reason: `could not write the Clerk instance lock: ${err.message}`,
1023
+ cause: "io"
1024
+ };
1025
+ }
1026
+ const beat = setInterval(() => {
1027
+ const now = /* @__PURE__ */ new Date();
1028
+ void held.utimes(now, now).catch(() => {
1029
+ });
1030
+ }, beatMs);
1031
+ beat.unref?.();
1032
+ let released = false;
1033
+ return {
1034
+ ok: true,
1035
+ lock: {
1036
+ release: async () => {
1037
+ if (released) return;
1038
+ released = true;
1039
+ clearInterval(beat);
1040
+ await held.close().catch(() => {
1041
+ });
1042
+ await removeIfSame(path, ino);
1043
+ }
1044
+ }
1045
+ };
1046
+ }
1047
+ const timedOut = {
1048
+ ok: false,
1049
+ reason: `another deploy is configuring this Clerk instance; waited ${Math.round(waitMs / 1e3)}s for it to finish (lock file ${path})`,
1050
+ cause: "busy"
1051
+ };
1052
+ if (lastTry) return timedOut;
1053
+ const state = await breakAbandonedLock(path, staleMs, MISSED_HEARTBEATS * beatMs);
1054
+ const expired = Date.now() >= deadline;
1055
+ if (state === "held") {
1056
+ if (expired) return timedOut;
1057
+ freeRetries = 0;
1058
+ await sleep(pollMs());
1059
+ continue;
1060
+ }
1061
+ lastTry = expired;
1062
+ if (freeRetries > 0) await sleep(pollMs());
1063
+ freeRetries += 1;
1064
+ }
1065
+ }
1066
+ async function acquireDefaultClerkInstanceLock(secretKey, opts = {}) {
1067
+ const dir = defaultClerkLockDir();
1068
+ const first = await acquireClerkInstanceLock(dir, secretKey, opts);
1069
+ if (first.ok || first.cause !== "directory") return first;
1070
+ const fallback = fallbackClerkLockDir();
1071
+ if (fallback === dir) return first;
1072
+ const second = await acquireClerkInstanceLock(fallback, secretKey, opts);
1073
+ if (second.ok || second.cause !== "directory") return second;
1074
+ return { ok: false, cause: "directory", reason: `${first.reason}; ${second.reason}` };
1075
+ }
1076
+
809
1077
  // src/cli/lib/clerk.ts
810
1078
  var CLERK_API_BASE = "https://api.clerk.com/v1";
1079
+ var CLERK_REQUEST_TIMEOUT_MS = 2e4;
811
1080
  var PUBLISHABLE_KEYS = [
812
1081
  "CLERK_PUBLISHABLE_KEY",
813
1082
  "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY"
@@ -834,7 +1103,11 @@ async function clerkFetch(path, token, init = {}) {
834
1103
  Authorization: `Bearer ${token}`,
835
1104
  "Content-Type": "application/json"
836
1105
  },
837
- body: init.body === void 0 ? void 0 : JSON.stringify(init.body)
1106
+ body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
1107
+ // Opt-in: a request that is cut off may still have been carried out,
1108
+ // which is harmless for the instance calls below and not for a call
1109
+ // that creates something.
1110
+ signal: init.timeoutMs === void 0 ? void 0 : AbortSignal.timeout(init.timeoutMs)
838
1111
  });
839
1112
  const text = await res.text();
840
1113
  let json;
@@ -848,15 +1121,28 @@ async function clerkFetch(path, token, init = {}) {
848
1121
  }
849
1122
  return { ok: true, status: res.status, json };
850
1123
  } catch (e) {
1124
+ if (e instanceof Error && e.name === "TimeoutError") {
1125
+ return {
1126
+ ok: false,
1127
+ status: 0,
1128
+ error: `Clerk did not answer within ${Math.round((init.timeoutMs ?? 0) / 1e3)}s`
1129
+ };
1130
+ }
851
1131
  return { ok: false, status: 0, error: e instanceof Error ? e.message : String(e) };
852
1132
  }
853
1133
  }
1134
+ function instanceFetch(path, secretKey, init = {}) {
1135
+ return clerkFetch(path, secretKey, { ...init, timeoutMs: CLERK_REQUEST_TIMEOUT_MS });
1136
+ }
854
1137
  function clerkError(json) {
855
1138
  if (typeof json !== "object" || json === null) return void 0;
856
1139
  const errors = json.errors;
857
1140
  if (!Array.isArray(errors) || errors.length === 0) return void 0;
858
1141
  const first = errors[0];
859
- return first.long_message ?? first.message;
1142
+ if (typeof first !== "object" || first === null) return void 0;
1143
+ const { long_message: long, message } = first;
1144
+ if (typeof long === "string") return long;
1145
+ return typeof message === "string" ? message : void 0;
860
1146
  }
861
1147
  async function createClerkApplication(platformToken, opts) {
862
1148
  const body = {
@@ -1003,21 +1289,147 @@ async function provisionClerk(opts) {
1003
1289
  async function configureClerkInstance(secretKey, opts) {
1004
1290
  const applied = [];
1005
1291
  const failed = [];
1006
- const origins = dedupe(opts.allowedOrigins ?? []);
1007
- if (origins.length > 0) {
1008
- const res = await clerkFetch("/instance", secretKey, {
1009
- method: "PATCH",
1010
- body: { allowed_origins: origins }
1011
- });
1012
- if (res.ok) applied.push(`allowed_origins (${origins.length})`);
1013
- else failed.push({ step: "allowed_origins", reason: res.error ?? `HTTP ${res.status}` });
1292
+ const warnings = [];
1293
+ const wanted = dedupe(opts.allowedOrigins ?? []);
1294
+ const redirectUrls = dedupe(opts.redirectUrls ?? []);
1295
+ const registerRedirectUrls = async () => {
1296
+ for (const url of redirectUrls) {
1297
+ const res = await instanceFetch("/redirect_urls", secretKey, { method: "POST", body: { url } });
1298
+ if (res.ok) applied.push(`redirect_url ${url}`);
1299
+ else if (isDuplicateRedirectUrl(res)) applied.push(`redirect_url ${url}`);
1300
+ else failed.push({ step: `redirect_url ${url}`, reason: res.error ?? `HTTP ${res.status}` });
1301
+ }
1302
+ };
1303
+ if (wanted.length === 0) {
1304
+ await registerRedirectUrls();
1305
+ return { ok: failed.length === 0, applied, failed, warnings };
1306
+ }
1307
+ const lock = opts.lockDir ? await acquireClerkInstanceLock(opts.lockDir, secretKey) : await acquireDefaultClerkInstanceLock(secretKey);
1308
+ if (!lock.ok) {
1309
+ failed.push({ step: "allowed_origins", reason: lock.reason });
1310
+ await registerRedirectUrls();
1311
+ return { ok: false, applied, failed, warnings };
1312
+ }
1313
+ try {
1314
+ const merged = await mergeAllowedOrigins(secretKey, wanted);
1315
+ if (!merged.ok) failed.push({ step: "allowed_origins", reason: merged.reason });
1316
+ await registerRedirectUrls();
1317
+ if (merged.ok) {
1318
+ const settled = merged.wrote ? await settleAllowedOrigins(secretKey, wanted, merged) : { ok: true, note: originsNote(merged), restored: [] };
1319
+ if (settled.ok) applied.unshift(settled.note);
1320
+ else failed.unshift({ step: "allowed_origins", reason: settled.reason });
1321
+ if (settled.restored.length > 0) warnings.push(`allowed_origins: ${restoredNote(settled.restored)}`);
1322
+ }
1323
+ } finally {
1324
+ await lock.lock.release();
1325
+ }
1326
+ return { ok: failed.length === 0, applied, failed, warnings };
1327
+ }
1328
+ var ORIGIN_MERGE_ATTEMPTS = 3;
1329
+ function originsNote(m, restored = []) {
1330
+ const base = `allowed_origins (${m.added} added, ${m.kept} kept)`;
1331
+ if (restored.length === 0) return base;
1332
+ return `${base}; ${restoredNote(restored)}`;
1333
+ }
1334
+ function restoredNote(restored) {
1335
+ return `put back after another write removed them during this deploy: ${restored.join(", ")}. If one was removed on purpose, remove it again.`;
1336
+ }
1337
+ function missingOrigins(list, wanted) {
1338
+ const have = new Set(list.map(originKey));
1339
+ return wanted.filter((origin) => !have.has(originKey(origin)));
1340
+ }
1341
+ function originKey(origin) {
1342
+ return origin.trim().replace(/\/+$/, "").toLowerCase();
1343
+ }
1344
+ function dedupeOrigins(origins) {
1345
+ const seen = /* @__PURE__ */ new Set();
1346
+ const out = [];
1347
+ for (const origin of origins) {
1348
+ const key = originKey(origin);
1349
+ if (!key || seen.has(key)) continue;
1350
+ seen.add(key);
1351
+ out.push(origin.trim());
1014
1352
  }
1015
- for (const url of dedupe(opts.redirectUrls ?? [])) {
1016
- const res = await clerkFetch("/redirect_urls", secretKey, { method: "POST", body: { url } });
1017
- if (res.ok) applied.push(`redirect_url ${url}`);
1018
- else failed.push({ step: `redirect_url ${url}`, reason: res.error ?? `HTTP ${res.status}` });
1353
+ return out;
1354
+ }
1355
+ var UNREADABLE_INSTANCE = "Clerk returned an instance that could not be read; allowed_origins was left unchanged.";
1356
+ function originsOf(json) {
1357
+ if (typeof json !== "object" || json === null || Array.isArray(json)) return void 0;
1358
+ const existing = json.allowed_origins;
1359
+ if (existing === void 0 || existing === null) return [];
1360
+ if (!Array.isArray(existing) || !existing.every((o) => typeof o === "string")) return void 0;
1361
+ return existing;
1362
+ }
1363
+ async function mergeAllowedOrigins(secretKey, wanted, carry = []) {
1364
+ const current = await instanceFetch("/instance", secretKey);
1365
+ if (!current.ok) return { ok: false, reason: current.error ?? `HTTP ${current.status}` };
1366
+ const kept = originsOf(current.json);
1367
+ if (!kept) return { ok: false, reason: UNREADABLE_INSTANCE };
1368
+ const missing = missingOrigins(kept, wanted);
1369
+ const lost = missingOrigins(kept, carry);
1370
+ if (missing.length === 0 && lost.length === 0) {
1371
+ return { ok: true, added: 0, kept: kept.length, wrote: false, seen: kept, restored: [] };
1372
+ }
1373
+ const write = [...kept, ...dedupeOrigins([...missing, ...lost])];
1374
+ const res = await clerkFetch("/instance", secretKey, {
1375
+ method: "PATCH",
1376
+ body: { allowed_origins: write }
1377
+ });
1378
+ if (!res.ok) return { ok: false, reason: res.error ?? `HTTP ${res.status}` };
1379
+ return {
1380
+ ok: true,
1381
+ added: write.length - kept.length,
1382
+ kept: kept.length,
1383
+ wrote: true,
1384
+ seen: write,
1385
+ // What was put back and is not one of this deploy's own origins.
1386
+ restored: missingOrigins(wanted, lost)
1387
+ };
1388
+ }
1389
+ async function settleAllowedOrigins(secretKey, wanted, first) {
1390
+ let last = first;
1391
+ let expected = dedupe([...first.seen, ...wanted]);
1392
+ let restored = [];
1393
+ for (let attempt = 1; ; attempt++) {
1394
+ const after = await instanceFetch("/instance", secretKey);
1395
+ const now = after.ok ? originsOf(after.json) : void 0;
1396
+ if (!now) {
1397
+ const why = after.ok ? "the instance could not be read" : after.error ?? `HTTP ${after.status}`;
1398
+ return {
1399
+ ok: false,
1400
+ reason: `allowed_origins was written but could not be confirmed (${why}). Run the deploy again to confirm.`,
1401
+ restored
1402
+ };
1403
+ }
1404
+ const lost = missingOrigins(now, expected);
1405
+ if (lost.length === 0) return { ok: true, note: originsNote(last, restored), restored };
1406
+ if (attempt >= ORIGIN_MERGE_ATTEMPTS) {
1407
+ return {
1408
+ ok: false,
1409
+ reason: `allowed_origins did not keep every origin it had after ${ORIGIN_MERGE_ATTEMPTS} writes; these are not in the list: ${lost.join(", ")}. Run the deploy again.`,
1410
+ restored
1411
+ };
1412
+ }
1413
+ const again = await mergeAllowedOrigins(secretKey, wanted, expected);
1414
+ if (!again.ok) return { ...again, restored };
1415
+ if (!again.wrote) return { ok: true, note: originsNote(last, restored), restored };
1416
+ expected = dedupe([...expected, ...again.seen]);
1417
+ restored = dedupeOrigins([...restored, ...again.restored]);
1418
+ last = again;
1419
+ }
1420
+ }
1421
+ function isDuplicateRedirectUrl(res) {
1422
+ if (res.status < 400 || res.status > 499) return false;
1423
+ const errors = res.json?.errors;
1424
+ if (Array.isArray(errors)) {
1425
+ for (const entry of errors) {
1426
+ if (typeof entry !== "object" || entry === null) continue;
1427
+ const code = entry.code;
1428
+ if (typeof code === "string" && /duplicate|already_exists/i.test(code)) return true;
1429
+ }
1019
1430
  }
1020
- return { ok: failed.length === 0, applied, failed };
1431
+ const text = (res.error ?? "").toLowerCase();
1432
+ return text.includes("already exists") || text.includes("already_exists") || text.includes("resource_already_exists");
1021
1433
  }
1022
1434
  function dedupe(values) {
1023
1435
  return [...new Set(values.map((v) => v.trim()).filter(Boolean))];
@@ -1035,9 +1447,9 @@ function storefrontClerkUrls(deployedUrl, domain) {
1035
1447
  }
1036
1448
 
1037
1449
  // src/cli/lib/clerk-cli.ts
1038
- import { join as join4 } from "path";
1039
- import { cp, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
1040
- import { tmpdir as tmpdir2 } from "os";
1450
+ import { join as join5 } from "path";
1451
+ import { cp, mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
1452
+ import { tmpdir as tmpdir3 } from "os";
1041
1453
  var SNAPSHOT_PATHS = ["src", "package.json", "next.config.mjs", "middleware.ts"];
1042
1454
  function clerkCliDeps() {
1043
1455
  return {
@@ -1055,23 +1467,23 @@ function clerkCliDeps() {
1055
1467
  }
1056
1468
  },
1057
1469
  snapshot: async (storefront) => {
1058
- const backup = await mkdtemp2(join4(tmpdir2(), "carrier-clerk-snap-"));
1470
+ const backup = await mkdtemp2(join5(tmpdir3(), "carrier-clerk-snap-"));
1059
1471
  const saved = [];
1060
1472
  for (const rel of SNAPSHOT_PATHS) {
1061
- const src = join4(storefront, rel);
1473
+ const src = join5(storefront, rel);
1062
1474
  if (!await exists(src)) continue;
1063
- await cp(src, join4(backup, rel), { recursive: true });
1475
+ await cp(src, join5(backup, rel), { recursive: true });
1064
1476
  saved.push(rel);
1065
1477
  }
1066
1478
  return async () => {
1067
1479
  try {
1068
1480
  for (const rel of saved) {
1069
- const target = join4(storefront, rel);
1070
- await rm2(target, { recursive: true, force: true });
1071
- await cp(join4(backup, rel), target, { recursive: true });
1481
+ const target = join5(storefront, rel);
1482
+ await rm3(target, { recursive: true, force: true });
1483
+ await cp(join5(backup, rel), target, { recursive: true });
1072
1484
  }
1073
1485
  } finally {
1074
- await rm2(backup, { recursive: true, force: true });
1486
+ await rm3(backup, { recursive: true, force: true });
1075
1487
  }
1076
1488
  };
1077
1489
  }
@@ -1137,7 +1549,7 @@ var REPAIRABLE = /* @__PURE__ */ new Set([
1137
1549
  "clerk-keys-missing",
1138
1550
  "clerk-not-configured"
1139
1551
  ]);
1140
- var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
1552
+ var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
1141
1553
  async function verifyStorefront(url, storefront, env = process.env, opts = {}) {
1142
1554
  const attempts = Math.max(1, opts.attempts ?? 4);
1143
1555
  const delayMs = opts.delayMs ?? 5e3;
@@ -1151,7 +1563,7 @@ async function verifyStorefront(url, storefront, env = process.env, opts = {}) {
1151
1563
  }
1152
1564
  diagnosis = diagnose(probes, secrets);
1153
1565
  if (diagnosis !== "not-deployed" || attempt === attempts) break;
1154
- await sleep(delayMs);
1566
+ await sleep2(delayMs);
1155
1567
  }
1156
1568
  const ok = diagnosis === "healthy";
1157
1569
  return {
@@ -1915,7 +2327,7 @@ function storefrontScreen(input) {
1915
2327
  // package.json
1916
2328
  var package_default = {
1917
2329
  name: "@carrierllc/mcp",
1918
- version: "0.13.92",
2330
+ version: "0.13.94",
1919
2331
  description: "Carrier MCP \u2014 natural-language control of MVNO/eSIM fleets via the network OCS. Stdio mode for direct integration with Claude Desktop, Cursor, Windsurf, and MCP-compatible clients. Ships the `carrier` CLI (plugin install + white-label eSIM storefront scaffold).",
1920
2332
  license: "MIT",
1921
2333
  mcpName: "llc.carrier/mcp",
@@ -3122,7 +3534,7 @@ function ocsBudgetFor(method) {
3122
3534
  const totalMs = Math.max(envInt("OCS_TOTAL_TIMEOUT_MS") ?? base.totalMs, attemptMs);
3123
3535
  return { attemptMs, maxAttempts: base.maxAttempts, totalMs };
3124
3536
  }
3125
- function sleep2(ms, signal) {
3537
+ function sleep3(ms, signal) {
3126
3538
  return new Promise((resolve) => {
3127
3539
  const timer = setTimeout(finish, ms);
3128
3540
  function finish() {
@@ -3180,7 +3592,7 @@ async function runWithBudget(method, attempt, budget = ocsBudgetFor(method)) {
3180
3592
  if (i === budget.maxAttempts - 1) break;
3181
3593
  const backoff = Math.random() * BACKOFF_BASE_MS * 2 ** i;
3182
3594
  if (Date.now() + backoff + MIN_ATTEMPT_BUDGET_MS > deadlineAt) break;
3183
- await sleep2(backoff, budgetController.signal);
3595
+ await sleep3(backoff, budgetController.signal);
3184
3596
  }
3185
3597
  } finally {
3186
3598
  clearTimeout(budgetTimer);
@@ -3920,15 +4332,15 @@ function periodFrom(entry) {
3920
4332
  const name = rec.status;
3921
4333
  if (typeof name !== "string" || name.length === 0) return null;
3922
4334
  const endDate = rec.endDate;
3923
- const open = endDate === void 0 || endDate === null || endDate === "";
3924
- return { name, start: typeof rec.startDate === "string" ? rec.startDate : "", open };
4335
+ const open2 = endDate === void 0 || endDate === null || endDate === "";
4336
+ return { name, start: typeof rec.startDate === "string" ? rec.startDate : "", open: open2 };
3925
4337
  }
3926
4338
  function currentSubscriberStatus(raw) {
3927
4339
  if (typeof raw === "string" && raw.length > 0) return raw;
3928
4340
  if (!Array.isArray(raw)) return void 0;
3929
4341
  const periods = raw.map(periodFrom).filter((period) => period !== null);
3930
- const open = periods.find((period) => period.open);
3931
- if (open) return open.name;
4342
+ const open2 = periods.find((period) => period.open);
4343
+ if (open2) return open2.name;
3932
4344
  const latest = [...periods].sort((a, b) => b.start.localeCompare(a.start))[0];
3933
4345
  return latest?.name;
3934
4346
  }
@@ -6165,4 +6577,4 @@ export {
6165
6577
  package_default,
6166
6578
  CARRIER_VERSION
6167
6579
  };
6168
- //# sourceMappingURL=chunk-KL4YT2Q5.js.map
6580
+ //# sourceMappingURL=chunk-NL3OMNXC.js.map