@carrierllc/mcp 0.13.93 → 0.13.95
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/{chunk-2RCR7NYX.js → chunk-GBCVDJGG.js} +447 -35
- package/dist/chunk-GBCVDJGG.js.map +1 -0
- package/dist/cli.js +4 -1
- package/dist/cli.js.map +1 -1
- package/dist/index.js +6 -2
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
- package/plugin/carrier/agents/carrier-storefront-builder.md +4 -4
- package/plugin/carrier/skills/onboard/SKILL.md +1 -1
- package/dist/chunk-2RCR7NYX.js.map +0 -1
|
@@ -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
|
-
|
|
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
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
1012
|
-
|
|
1013
|
-
|
|
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
|
-
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
|
|
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
|
-
|
|
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
|
|
1039
|
-
import { cp, mkdtemp as mkdtemp2, rm as
|
|
1040
|
-
import { tmpdir as
|
|
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(
|
|
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 =
|
|
1473
|
+
const src = join5(storefront, rel);
|
|
1062
1474
|
if (!await exists(src)) continue;
|
|
1063
|
-
await cp(src,
|
|
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 =
|
|
1070
|
-
await
|
|
1071
|
-
await cp(
|
|
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
|
|
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
|
|
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
|
|
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.
|
|
2330
|
+
version: "0.13.95",
|
|
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
|
|
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
|
|
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
|
|
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
|
|
3931
|
-
if (
|
|
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-
|
|
6580
|
+
//# sourceMappingURL=chunk-GBCVDJGG.js.map
|