nerdgram1337 1.4.7 → 1.5.0
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-KAKG6DWJ.js → chunk-FIQWTTCY.js} +1 -1
- package/dist/{chunk-ZVKNTVWH.js → chunk-M434Z7CG.js} +1 -1
- package/dist/{chunk-IQ4Z2ZHX.js → chunk-MKB7YAGA.js} +2 -2
- package/dist/{chunk-ECAEFMIC.js → chunk-ORJTKOL4.js} +437 -74
- package/dist/{chunk-GQKUFF4P.js → chunk-WORJPG5T.js} +139 -3
- package/dist/cli.js +11 -5
- package/package.json +1 -1
|
@@ -1469,7 +1469,7 @@ async function writeFile(relativePath, content, options = {}) {
|
|
|
1469
1469
|
await atomicWriteText(abs, content);
|
|
1470
1470
|
await dropThumbnail(relative);
|
|
1471
1471
|
const stat = await fs2.stat(abs);
|
|
1472
|
-
const search = await import("./chunk-
|
|
1472
|
+
const search = await import("./chunk-FIQWTTCY.js");
|
|
1473
1473
|
await search.rememberSearchEntry(relative, content, stat.mtimeMs, stat.size);
|
|
1474
1474
|
await noteDiagramSighting({ path: relative, hash: hashContent(content) });
|
|
1475
1475
|
noteSync({ kind: "content", summary: `Update ${relative}` });
|
|
@@ -1482,7 +1482,7 @@ async function writeFile(relativePath, content, options = {}) {
|
|
|
1482
1482
|
};
|
|
1483
1483
|
}
|
|
1484
1484
|
function noteSync(change) {
|
|
1485
|
-
void import("./chunk-
|
|
1485
|
+
void import("./chunk-ORJTKOL4.js").then((mod) => mod.noteLocalChange(change)).catch(() => {
|
|
1486
1486
|
console.error("GitHub sync could not record a local change");
|
|
1487
1487
|
});
|
|
1488
1488
|
}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import "./chunk-
|
|
1
|
+
import "./chunk-MKB7YAGA.js";
|
|
2
2
|
import {
|
|
3
3
|
ensureDataRoot,
|
|
4
4
|
getMetaPath,
|
|
@@ -188,7 +188,7 @@ async function saveConfig(config) {
|
|
|
188
188
|
await writePrivateFile(configPath(), body);
|
|
189
189
|
}
|
|
190
190
|
function configContainsSecret(body) {
|
|
191
|
-
return /"(token|access_token|device_code|client_secret)"\s*:/i.test(body) || /ghp_[A-Za-z0-9]/.test(body);
|
|
191
|
+
return /"(token|access_token|refresh_token|accessToken|refreshToken|device_code|client_secret)"\s*:/i.test(body) || /ghp_[A-Za-z0-9]/.test(body) || /gho_[A-Za-z0-9]/.test(body) || /ghu_[A-Za-z0-9]/.test(body) || /ghs_[A-Za-z0-9]/.test(body) || /ghr_[A-Za-z0-9]/.test(body) || /github_pat_[A-Za-z0-9_]/.test(body);
|
|
192
192
|
}
|
|
193
193
|
function clientIdOf(config) {
|
|
194
194
|
const fromEnv = process.env.NERDGRAM_GITHUB_CLIENT_ID?.trim();
|
|
@@ -223,7 +223,9 @@ function redactText(input) {
|
|
|
223
223
|
for (const pattern of TOKEN_SHAPES) out = out.replace(pattern, "[redacted]");
|
|
224
224
|
out = out.replace(/Bearer\s+\S+/gi, "Bearer [redacted]");
|
|
225
225
|
out = out.replace(/Basic\s+[A-Za-z0-9+/=]+/gi, "Basic [redacted]");
|
|
226
|
+
out = out.replace(/x-access-token:[^\s"']+/gi, "x-access-token:[redacted]");
|
|
226
227
|
out = out.replace(/access_token["']?\s*[:=]\s*["']?[^"'\s&]+/gi, "access_token=[redacted]");
|
|
228
|
+
out = out.replace(/refresh_token["']?\s*[:=]\s*["']?[^"'\s&]+/gi, "refresh_token=[redacted]");
|
|
227
229
|
out = out.replace(/device_code["']?\s*[:=]\s*["']?[^"'\s&]+/gi, "device_code=[redacted]");
|
|
228
230
|
out = out.replace(/client_secret["']?\s*[:=]\s*["']?[^"'\s&]+/gi, "client_secret=[redacted]");
|
|
229
231
|
return out;
|
|
@@ -237,17 +239,181 @@ function scrubError(err) {
|
|
|
237
239
|
if (code && code !== message) {
|
|
238
240
|
Object.assign(next, { code });
|
|
239
241
|
}
|
|
242
|
+
const status = readErrorStatus(err);
|
|
243
|
+
if (status != null) Object.assign(next, { status, statusCode: status });
|
|
240
244
|
return next;
|
|
241
245
|
}
|
|
246
|
+
function readErrorStatus(err) {
|
|
247
|
+
if (!err || typeof err !== "object") return null;
|
|
248
|
+
const record = err;
|
|
249
|
+
if (typeof record.status === "number" && Number.isFinite(record.status)) return record.status;
|
|
250
|
+
if (typeof record.statusCode === "number" && Number.isFinite(record.statusCode)) return record.statusCode;
|
|
251
|
+
if (record.data && typeof record.data.statusCode === "number" && Number.isFinite(record.data.statusCode)) {
|
|
252
|
+
return record.data.statusCode;
|
|
253
|
+
}
|
|
254
|
+
return null;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
// server/src/sync/secrets.ts
|
|
258
|
+
import fs3 from "node:fs/promises";
|
|
259
|
+
var EMPTY_AUTH = {
|
|
260
|
+
accessToken: null,
|
|
261
|
+
refreshToken: null,
|
|
262
|
+
expiresAt: null,
|
|
263
|
+
refreshExpiresAt: null,
|
|
264
|
+
deviceFlow: false,
|
|
265
|
+
source: null
|
|
266
|
+
};
|
|
267
|
+
async function readToken() {
|
|
268
|
+
const auth = await readStoredAuth();
|
|
269
|
+
return { token: auth.accessToken, source: auth.source };
|
|
270
|
+
}
|
|
271
|
+
async function readStoredAuth() {
|
|
272
|
+
const fromEnv = process.env.NERDGRAM_GITHUB_TOKEN?.trim();
|
|
273
|
+
if (fromEnv) {
|
|
274
|
+
rememberSecret(fromEnv);
|
|
275
|
+
return {
|
|
276
|
+
accessToken: fromEnv,
|
|
277
|
+
refreshToken: null,
|
|
278
|
+
expiresAt: null,
|
|
279
|
+
refreshExpiresAt: null,
|
|
280
|
+
deviceFlow: false,
|
|
281
|
+
source: "env"
|
|
282
|
+
};
|
|
283
|
+
}
|
|
284
|
+
let text = "";
|
|
285
|
+
try {
|
|
286
|
+
text = (await fs3.readFile(tokenPath(), "utf8")).trim();
|
|
287
|
+
} catch (err) {
|
|
288
|
+
const code = err.code;
|
|
289
|
+
if (code === "ENOENT") return { ...EMPTY_AUTH };
|
|
290
|
+
throw err;
|
|
291
|
+
}
|
|
292
|
+
if (!text) return { ...EMPTY_AUTH };
|
|
293
|
+
if (text.startsWith("{")) return parseTokenRecord(text);
|
|
294
|
+
rememberSecret(text);
|
|
295
|
+
return {
|
|
296
|
+
accessToken: text,
|
|
297
|
+
refreshToken: null,
|
|
298
|
+
expiresAt: null,
|
|
299
|
+
refreshExpiresAt: null,
|
|
300
|
+
deviceFlow: false,
|
|
301
|
+
source: "file"
|
|
302
|
+
};
|
|
303
|
+
}
|
|
304
|
+
async function writeToken(token, extras) {
|
|
305
|
+
const trimmed = token.trim();
|
|
306
|
+
if (!trimmed) throw new Error("Refusing to store an empty token");
|
|
307
|
+
rememberSecret(trimmed);
|
|
308
|
+
if (process.env.NERDGRAM_GITHUB_TOKEN?.trim()) {
|
|
309
|
+
return;
|
|
310
|
+
}
|
|
311
|
+
const refresh = extras?.refreshToken?.trim() || "";
|
|
312
|
+
if (refresh) rememberSecret(refresh);
|
|
313
|
+
const expiresIn = finiteOrNull(extras?.expiresIn);
|
|
314
|
+
const refreshExpiresIn = finiteOrNull(extras?.refreshExpiresIn);
|
|
315
|
+
if (!refresh && expiresIn == null && refreshExpiresIn == null) {
|
|
316
|
+
await writePrivateFile(tokenPath(), `${trimmed}
|
|
317
|
+
`);
|
|
318
|
+
return;
|
|
319
|
+
}
|
|
320
|
+
const now = Date.now();
|
|
321
|
+
const record = {
|
|
322
|
+
accessToken: trimmed,
|
|
323
|
+
refreshToken: refresh || null,
|
|
324
|
+
expiresAt: expiresIn == null ? null : now + expiresIn * 1e3,
|
|
325
|
+
refreshExpiresAt: refreshExpiresIn == null ? null : now + refreshExpiresIn * 1e3,
|
|
326
|
+
deviceFlow: extras?.deviceFlow === true
|
|
327
|
+
};
|
|
328
|
+
await writePrivateFile(tokenPath(), `${JSON.stringify(record)}
|
|
329
|
+
`);
|
|
330
|
+
}
|
|
331
|
+
function parseTokenRecord(text) {
|
|
332
|
+
let parsed;
|
|
333
|
+
try {
|
|
334
|
+
parsed = JSON.parse(text);
|
|
335
|
+
} catch {
|
|
336
|
+
console.error("GitHub sync: token_file The saved GitHub token file could not be read.");
|
|
337
|
+
return { ...EMPTY_AUTH };
|
|
338
|
+
}
|
|
339
|
+
if (!parsed || typeof parsed !== "object") return { ...EMPTY_AUTH };
|
|
340
|
+
const record = parsed;
|
|
341
|
+
const accessToken = stringField(record, "accessToken");
|
|
342
|
+
const refreshToken = stringField(record, "refreshToken");
|
|
343
|
+
if (accessToken) rememberSecret(accessToken);
|
|
344
|
+
if (refreshToken) rememberSecret(refreshToken);
|
|
345
|
+
return {
|
|
346
|
+
accessToken,
|
|
347
|
+
refreshToken,
|
|
348
|
+
expiresAt: epochField(record, "expiresAt"),
|
|
349
|
+
refreshExpiresAt: epochField(record, "refreshExpiresAt"),
|
|
350
|
+
deviceFlow: record.deviceFlow === true,
|
|
351
|
+
source: accessToken ? "file" : null
|
|
352
|
+
};
|
|
353
|
+
}
|
|
354
|
+
function stringField(record, key) {
|
|
355
|
+
const value = record[key];
|
|
356
|
+
return typeof value === "string" && value.trim() ? value.trim() : null;
|
|
357
|
+
}
|
|
358
|
+
function epochField(record, key) {
|
|
359
|
+
const value = record[key];
|
|
360
|
+
return typeof value === "number" && Number.isFinite(value) ? value : null;
|
|
361
|
+
}
|
|
362
|
+
function finiteOrNull(value) {
|
|
363
|
+
return typeof value === "number" && Number.isFinite(value) ? value : null;
|
|
364
|
+
}
|
|
242
365
|
|
|
243
366
|
// server/src/sync/github.ts
|
|
367
|
+
var REFRESH_SKEW_MS = 5 * 60 * 1e3;
|
|
368
|
+
var AUTH_REVOKED_MESSAGE = "GitHub rejected the saved authorization. It may have been revoked. Connect again.";
|
|
369
|
+
var AUTH_FORBIDDEN_MESSAGE = "GitHub refused this request. Check that the authorization still includes repository access.";
|
|
370
|
+
var AUTH_EXPIRED_MESSAGE = "GitHub authorization expired. Connect again.";
|
|
371
|
+
var APP_CODES = /* @__PURE__ */ new Set([
|
|
372
|
+
"auth_revoked",
|
|
373
|
+
"auth_expired",
|
|
374
|
+
"not_connected",
|
|
375
|
+
"offline",
|
|
376
|
+
"rate_limit",
|
|
377
|
+
"not_fast_forward",
|
|
378
|
+
"repo_missing",
|
|
379
|
+
"github",
|
|
380
|
+
"invalid",
|
|
381
|
+
"invalid_client",
|
|
382
|
+
"device_flow_disabled",
|
|
383
|
+
"name_taken",
|
|
384
|
+
"repo_not_empty",
|
|
385
|
+
"conflicts",
|
|
386
|
+
"locked"
|
|
387
|
+
]);
|
|
244
388
|
var fetchImpl = globalThis.fetch.bind(globalThis);
|
|
389
|
+
function githubWeb() {
|
|
390
|
+
return (process.env.NERDGRAM_GITHUB_WEB || "https://github.com").replace(/\/$/, "");
|
|
391
|
+
}
|
|
245
392
|
function githubApi() {
|
|
246
393
|
return (process.env.NERDGRAM_GITHUB_API || "https://api.github.com").replace(/\/$/, "");
|
|
247
394
|
}
|
|
395
|
+
async function refreshAccessToken(input) {
|
|
396
|
+
rememberSecret(input.refreshToken);
|
|
397
|
+
const secret = input.clientSecret?.trim() || "";
|
|
398
|
+
if (secret) rememberSecret(secret);
|
|
399
|
+
const payload = {
|
|
400
|
+
client_id: input.clientId,
|
|
401
|
+
grant_type: "refresh_token",
|
|
402
|
+
refresh_token: input.refreshToken
|
|
403
|
+
};
|
|
404
|
+
if (secret) payload.client_secret = secret;
|
|
405
|
+
const response = await githubFetch(`${githubWeb()}/login/oauth/access_token`, {
|
|
406
|
+
method: "POST",
|
|
407
|
+
headers: acceptJson({ "Content-Type": "application/json" }),
|
|
408
|
+
body: JSON.stringify(payload)
|
|
409
|
+
});
|
|
410
|
+
const body = await readBody(response);
|
|
411
|
+
if (typeof body.access_token === "string" && body.access_token) return issuedFrom(body);
|
|
412
|
+
throw httpFail(401, AUTH_EXPIRED_MESSAGE, "auth_expired");
|
|
413
|
+
}
|
|
248
414
|
async function getRepo(token, owner, name) {
|
|
249
415
|
const response = await githubFetch(`${githubApi()}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`, {
|
|
250
|
-
headers: authHeaders(token)
|
|
416
|
+
headers: authHeaders(await liveToken(token))
|
|
251
417
|
});
|
|
252
418
|
if (response.status === 404) {
|
|
253
419
|
await response.arrayBuffer().catch(() => void 0);
|
|
@@ -258,9 +424,9 @@ async function getRepo(token, owner, name) {
|
|
|
258
424
|
return repoFrom(body);
|
|
259
425
|
}
|
|
260
426
|
function repoFrom(body) {
|
|
261
|
-
const name =
|
|
262
|
-
const htmlUrl =
|
|
263
|
-
const cloneUrl =
|
|
427
|
+
const name = stringField2(body, "name");
|
|
428
|
+
const htmlUrl = stringField2(body, "html_url");
|
|
429
|
+
const cloneUrl = stringField2(body, "clone_url");
|
|
264
430
|
const ownerObj = body.owner;
|
|
265
431
|
const owner = ownerObj && typeof ownerObj === "object" && typeof ownerObj.login === "string" ? ownerObj.login : "";
|
|
266
432
|
if (!name || !owner || !cloneUrl) {
|
|
@@ -273,7 +439,7 @@ function repoFrom(body) {
|
|
|
273
439
|
private: body.private !== false,
|
|
274
440
|
htmlUrl: htmlUrl || `https://github.com/${owner}/${name}`,
|
|
275
441
|
cloneUrl,
|
|
276
|
-
defaultBranch:
|
|
442
|
+
defaultBranch: stringField2(body, "default_branch")
|
|
277
443
|
};
|
|
278
444
|
}
|
|
279
445
|
function assertCleanRemoteUrl(remoteUrl) {
|
|
@@ -314,30 +480,27 @@ function classifyResponse(status, body, headers) {
|
|
|
314
480
|
"rate_limit"
|
|
315
481
|
);
|
|
316
482
|
}
|
|
317
|
-
if (status === 401)
|
|
318
|
-
return httpFail(
|
|
319
|
-
401,
|
|
320
|
-
"GitHub rejected the saved authorization. It may have been revoked. Connect again.",
|
|
321
|
-
"auth_revoked"
|
|
322
|
-
);
|
|
323
|
-
}
|
|
483
|
+
if (status === 401) return httpFail(401, AUTH_REVOKED_MESSAGE, "auth_revoked");
|
|
324
484
|
if (status === 404) {
|
|
325
485
|
return httpFail(404, "That GitHub repository was not found.", "repo_missing");
|
|
326
486
|
}
|
|
327
|
-
if (status === 403)
|
|
328
|
-
return httpFail(
|
|
329
|
-
403,
|
|
330
|
-
"GitHub refused this request. Check that the authorization still includes repository access.",
|
|
331
|
-
"auth_revoked"
|
|
332
|
-
);
|
|
333
|
-
}
|
|
487
|
+
if (status === 403) return httpFail(403, AUTH_FORBIDDEN_MESSAGE, "auth_revoked");
|
|
334
488
|
return httpFail(502, "GitHub sync failed.", "github");
|
|
335
489
|
}
|
|
336
490
|
function classifyNetworkError(err) {
|
|
337
|
-
if (err instanceof Error && "status" in err && "code" in err) return err;
|
|
338
491
|
const name = err instanceof Error ? err.name : "";
|
|
339
492
|
const code = err && typeof err === "object" && "code" in err && typeof err.code === "string" ? err.code : "";
|
|
340
493
|
const message = redactText(err instanceof Error ? err.message : "");
|
|
494
|
+
const status = httpStatusOf(err) ?? statusFromMessage(message);
|
|
495
|
+
if (code && APP_CODES.has(code) && err instanceof Error) {
|
|
496
|
+
if ("status" in err && typeof err.status === "number") return err;
|
|
497
|
+
return httpFail(status ?? statusForAppCode(code), err.message || "GitHub sync failed.", code);
|
|
498
|
+
}
|
|
499
|
+
if (status === 401 || code === "HttpError" && status === 401) {
|
|
500
|
+
return httpFail(401, AUTH_REVOKED_MESSAGE, "auth_revoked");
|
|
501
|
+
}
|
|
502
|
+
if (status === 403) return httpFail(403, AUTH_FORBIDDEN_MESSAGE, "auth_revoked");
|
|
503
|
+
if (err instanceof Error && "status" in err && "code" in err && code !== "HttpError") return err;
|
|
341
504
|
if (name === "AbortError" || code === "ABORT_ERR" || code === "ETIMEDOUT" || code === "ENOTFOUND" || code === "ECONNREFUSED" || code === "EAI_AGAIN" || code === "ENETUNREACH" || code === "ECONNRESET" || /timeout|network|fetch failed|getaddrinfo/i.test(message)) {
|
|
342
505
|
return httpFail(
|
|
343
506
|
503,
|
|
@@ -354,6 +517,13 @@ function classifyNetworkError(err) {
|
|
|
354
517
|
}
|
|
355
518
|
return httpFail(502, "GitHub sync failed.", "github");
|
|
356
519
|
}
|
|
520
|
+
function acceptJson(extra = {}) {
|
|
521
|
+
return {
|
|
522
|
+
Accept: "application/json",
|
|
523
|
+
"User-Agent": "NerdGram1337",
|
|
524
|
+
...extra
|
|
525
|
+
};
|
|
526
|
+
}
|
|
357
527
|
function authHeaders(token, extra = {}) {
|
|
358
528
|
rememberSecret(token);
|
|
359
529
|
return {
|
|
@@ -364,15 +534,146 @@ function authHeaders(token, extra = {}) {
|
|
|
364
534
|
...extra
|
|
365
535
|
};
|
|
366
536
|
}
|
|
367
|
-
async function githubFetch(url, init = {}) {
|
|
537
|
+
async function githubFetch(url, init = {}, attempt = 0) {
|
|
368
538
|
assertNoSecretInUrl(url);
|
|
369
539
|
const timeout = AbortSignal.timeout(githubTimeoutMs());
|
|
370
540
|
const signal = init.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
|
|
541
|
+
let response;
|
|
371
542
|
try {
|
|
372
|
-
|
|
543
|
+
response = await fetchImpl(url, { ...init, signal });
|
|
373
544
|
} catch (err) {
|
|
374
545
|
throw classifyNetworkError(err);
|
|
375
546
|
}
|
|
547
|
+
if (attempt === 0 && response.status === 401 && bearerValue(init)) {
|
|
548
|
+
let next;
|
|
549
|
+
try {
|
|
550
|
+
next = await refreshAfterUnauthorized();
|
|
551
|
+
} catch (err) {
|
|
552
|
+
await response.arrayBuffer().catch(() => void 0);
|
|
553
|
+
throw err;
|
|
554
|
+
}
|
|
555
|
+
if (next) {
|
|
556
|
+
await response.arrayBuffer().catch(() => void 0);
|
|
557
|
+
const headers = new Headers(init.headers);
|
|
558
|
+
headers.set("Authorization", `Bearer ${next}`);
|
|
559
|
+
return githubFetch(url, { ...init, headers }, attempt + 1);
|
|
560
|
+
}
|
|
561
|
+
}
|
|
562
|
+
return response;
|
|
563
|
+
}
|
|
564
|
+
function bearerValue(init) {
|
|
565
|
+
const value = new Headers(init.headers).get("authorization") ?? "";
|
|
566
|
+
const match = /^Bearer\s+(\S+)/i.exec(value);
|
|
567
|
+
return match?.[1] ?? null;
|
|
568
|
+
}
|
|
569
|
+
var refreshInflight = null;
|
|
570
|
+
async function ensureAccessToken() {
|
|
571
|
+
const auth = await readStoredAuth();
|
|
572
|
+
if (!auth.accessToken) return null;
|
|
573
|
+
if (auth.source !== "file" || auth.expiresAt == null) return auth.accessToken;
|
|
574
|
+
if (auth.expiresAt - Date.now() > REFRESH_SKEW_MS) return auth.accessToken;
|
|
575
|
+
const next = await refreshCoalesced();
|
|
576
|
+
return next ?? auth.accessToken;
|
|
577
|
+
}
|
|
578
|
+
async function refreshAfterUnauthorized() {
|
|
579
|
+
const auth = await readStoredAuth();
|
|
580
|
+
if (auth.source !== "file" || !auth.refreshToken) return null;
|
|
581
|
+
return refreshCoalesced();
|
|
582
|
+
}
|
|
583
|
+
async function authorizationBlock() {
|
|
584
|
+
const auth = await readStoredAuth();
|
|
585
|
+
if (!auth.accessToken || auth.source !== "file") return null;
|
|
586
|
+
if (auth.expiresAt == null || auth.expiresAt > Date.now()) return null;
|
|
587
|
+
if (await canRefresh(auth)) return null;
|
|
588
|
+
return { code: "auth_expired", message: AUTH_EXPIRED_MESSAGE, status: 401 };
|
|
589
|
+
}
|
|
590
|
+
function refreshCoalesced() {
|
|
591
|
+
if (!refreshInflight) {
|
|
592
|
+
refreshInflight = performRefresh().finally(() => {
|
|
593
|
+
refreshInflight = null;
|
|
594
|
+
});
|
|
595
|
+
}
|
|
596
|
+
return refreshInflight;
|
|
597
|
+
}
|
|
598
|
+
async function performRefresh() {
|
|
599
|
+
const auth = await readStoredAuth();
|
|
600
|
+
if (!auth.accessToken || auth.source !== "file") return null;
|
|
601
|
+
if (!auth.refreshToken) {
|
|
602
|
+
if (auth.expiresAt != null && auth.expiresAt - Date.now() <= REFRESH_SKEW_MS) {
|
|
603
|
+
throw httpFail(401, AUTH_EXPIRED_MESSAGE, "auth_expired");
|
|
604
|
+
}
|
|
605
|
+
return null;
|
|
606
|
+
}
|
|
607
|
+
if (auth.refreshExpiresAt != null && auth.refreshExpiresAt <= Date.now()) {
|
|
608
|
+
throw httpFail(401, AUTH_EXPIRED_MESSAGE, "auth_expired");
|
|
609
|
+
}
|
|
610
|
+
const secret = readClientSecret();
|
|
611
|
+
if (!auth.deviceFlow && !secret) throw httpFail(401, AUTH_EXPIRED_MESSAGE, "auth_expired");
|
|
612
|
+
const clientId = await clientIdForRefresh();
|
|
613
|
+
if (!clientId) throw httpFail(401, AUTH_EXPIRED_MESSAGE, "auth_expired");
|
|
614
|
+
const issued = await refreshAccessToken({
|
|
615
|
+
clientId,
|
|
616
|
+
refreshToken: auth.refreshToken,
|
|
617
|
+
clientSecret: secret
|
|
618
|
+
});
|
|
619
|
+
await writeToken(issued.token, {
|
|
620
|
+
refreshToken: issued.refreshToken ?? auth.refreshToken,
|
|
621
|
+
expiresIn: issued.expiresIn,
|
|
622
|
+
refreshExpiresIn: issued.refreshExpiresIn,
|
|
623
|
+
deviceFlow: auth.deviceFlow
|
|
624
|
+
});
|
|
625
|
+
return issued.token;
|
|
626
|
+
}
|
|
627
|
+
async function canRefresh(auth) {
|
|
628
|
+
if (!auth.refreshToken) return false;
|
|
629
|
+
if (auth.refreshExpiresAt != null && auth.refreshExpiresAt <= Date.now()) return false;
|
|
630
|
+
if (!auth.deviceFlow && !readClientSecret()) return false;
|
|
631
|
+
return Boolean(await clientIdForRefresh());
|
|
632
|
+
}
|
|
633
|
+
async function clientIdForRefresh() {
|
|
634
|
+
const config = await loadConfig();
|
|
635
|
+
return clientIdOf(config).id;
|
|
636
|
+
}
|
|
637
|
+
function readClientSecret() {
|
|
638
|
+
const secret = process.env.NERDGRAM_GITHUB_CLIENT_SECRET?.trim() || "";
|
|
639
|
+
if (!secret) return null;
|
|
640
|
+
rememberSecret(secret);
|
|
641
|
+
return secret;
|
|
642
|
+
}
|
|
643
|
+
function issuedFrom(body) {
|
|
644
|
+
const token = typeof body.access_token === "string" ? body.access_token : "";
|
|
645
|
+
const refreshToken = stringField2(body, "refresh_token");
|
|
646
|
+
rememberSecret(token);
|
|
647
|
+
if (refreshToken) rememberSecret(refreshToken);
|
|
648
|
+
return {
|
|
649
|
+
token,
|
|
650
|
+
refreshToken,
|
|
651
|
+
expiresIn: numberField(body, "expires_in"),
|
|
652
|
+
refreshExpiresIn: numberField(body, "refresh_token_expires_in")
|
|
653
|
+
};
|
|
654
|
+
}
|
|
655
|
+
async function liveToken(fallback) {
|
|
656
|
+
const fresh = await ensureAccessToken();
|
|
657
|
+
return fresh || fallback;
|
|
658
|
+
}
|
|
659
|
+
function httpStatusOf(err) {
|
|
660
|
+
return readErrorStatus(err);
|
|
661
|
+
}
|
|
662
|
+
function statusFromMessage(message) {
|
|
663
|
+
const match = /\bHTTP Error:\s*(401|403)\b/.exec(message);
|
|
664
|
+
return match ? Number(match[1]) : null;
|
|
665
|
+
}
|
|
666
|
+
function statusForAppCode(code) {
|
|
667
|
+
if (code === "auth_revoked" || code === "auth_expired" || code === "not_connected") return 401;
|
|
668
|
+
if (code === "offline") return 503;
|
|
669
|
+
if (code === "rate_limit") return 429;
|
|
670
|
+
if (code === "not_fast_forward" || code === "conflicts" || code === "repo_not_empty") return 409;
|
|
671
|
+
if (code === "repo_missing") return 404;
|
|
672
|
+
if (code === "locked") return 423;
|
|
673
|
+
if (code === "invalid" || code === "invalid_client" || code === "device_flow_disabled" || code === "name_taken") {
|
|
674
|
+
return 400;
|
|
675
|
+
}
|
|
676
|
+
return 502;
|
|
376
677
|
}
|
|
377
678
|
function assertNoSecretInUrl(raw) {
|
|
378
679
|
let url;
|
|
@@ -401,10 +702,14 @@ async function readBody(response) {
|
|
|
401
702
|
return {};
|
|
402
703
|
}
|
|
403
704
|
}
|
|
404
|
-
function
|
|
705
|
+
function stringField2(body, key) {
|
|
405
706
|
const value = body[key];
|
|
406
707
|
return typeof value === "string" && value.trim() ? value.trim() : null;
|
|
407
708
|
}
|
|
709
|
+
function numberField(body, key) {
|
|
710
|
+
const value = body[key];
|
|
711
|
+
return typeof value === "number" && Number.isFinite(value) ? value : null;
|
|
712
|
+
}
|
|
408
713
|
|
|
409
714
|
// server/src/sync/mirror.ts
|
|
410
715
|
import fs4 from "node:fs";
|
|
@@ -412,48 +717,48 @@ import fsp from "node:fs/promises";
|
|
|
412
717
|
import path2 from "node:path";
|
|
413
718
|
import git from "isomorphic-git";
|
|
414
719
|
import http from "isomorphic-git/http/node";
|
|
415
|
-
|
|
416
|
-
// server/src/sync/secrets.ts
|
|
417
|
-
import fs3 from "node:fs/promises";
|
|
418
|
-
async function readToken() {
|
|
419
|
-
const fromEnv = process.env.NERDGRAM_GITHUB_TOKEN?.trim();
|
|
420
|
-
if (fromEnv) {
|
|
421
|
-
rememberSecret(fromEnv);
|
|
422
|
-
return { token: fromEnv, source: "env" };
|
|
423
|
-
}
|
|
424
|
-
try {
|
|
425
|
-
const text = (await fs3.readFile(tokenPath(), "utf8")).trim();
|
|
426
|
-
if (!text) return { token: null, source: null };
|
|
427
|
-
rememberSecret(text);
|
|
428
|
-
return { token: text, source: "file" };
|
|
429
|
-
} catch (err) {
|
|
430
|
-
const code = err.code;
|
|
431
|
-
if (code === "ENOENT") return { token: null, source: null };
|
|
432
|
-
throw err;
|
|
433
|
-
}
|
|
434
|
-
}
|
|
435
|
-
|
|
436
|
-
// server/src/sync/mirror.ts
|
|
437
720
|
var nodeFs = fs4;
|
|
438
721
|
var PERSON = { name: "NerdGram1337", email: "nerdgram@localhost" };
|
|
439
722
|
var gitHttp = {
|
|
440
723
|
async request(request) {
|
|
441
|
-
assertCleanRemoteUrl(request.url);
|
|
442
|
-
const { token } = await readToken();
|
|
443
|
-
const headers = { ...request.headers ?? {} };
|
|
444
|
-
if (token) {
|
|
445
|
-
rememberSecret(token);
|
|
446
|
-
headers.Authorization = `Bearer ${token}`;
|
|
447
|
-
}
|
|
448
|
-
const timeout = AbortSignal.timeout(githubTimeoutMs());
|
|
449
|
-
const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
|
|
450
724
|
try {
|
|
451
|
-
return await
|
|
725
|
+
return await gitRequest(request, true);
|
|
452
726
|
} catch (err) {
|
|
453
|
-
throw scrubError(err);
|
|
727
|
+
throw classifyNetworkError(scrubError(err));
|
|
454
728
|
}
|
|
455
729
|
}
|
|
456
730
|
};
|
|
731
|
+
function gitBasicAuthorization(token) {
|
|
732
|
+
rememberSecret(token);
|
|
733
|
+
return `Basic ${Buffer.from(`x-access-token:${token}`, "utf8").toString("base64")}`;
|
|
734
|
+
}
|
|
735
|
+
async function gitRequest(request, allowRefresh) {
|
|
736
|
+
assertCleanRemoteUrl(request.url);
|
|
737
|
+
const token = await ensureAccessToken();
|
|
738
|
+
const headers = { ...request.headers ?? {} };
|
|
739
|
+
if (token) headers.Authorization = gitBasicAuthorization(token);
|
|
740
|
+
const timeout = AbortSignal.timeout(githubTimeoutMs());
|
|
741
|
+
const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
|
|
742
|
+
const response = await http.request({ ...request, headers, signal });
|
|
743
|
+
if (response.statusCode === 401 && allowRefresh) {
|
|
744
|
+
await drainBody(response.body);
|
|
745
|
+
const next = await refreshAfterUnauthorized();
|
|
746
|
+
if (next) return gitRequest(request, false);
|
|
747
|
+
}
|
|
748
|
+
if (response.statusCode === 401 || response.statusCode === 403) {
|
|
749
|
+
await drainBody(response.body);
|
|
750
|
+
throw response.statusCode === 401 ? httpFail(401, AUTH_REVOKED_MESSAGE, "auth_revoked") : httpFail(403, AUTH_FORBIDDEN_MESSAGE, "auth_revoked");
|
|
751
|
+
}
|
|
752
|
+
return response;
|
|
753
|
+
}
|
|
754
|
+
async function drainBody(body) {
|
|
755
|
+
if (!body) return;
|
|
756
|
+
try {
|
|
757
|
+
for await (const _chunk of body) {
|
|
758
|
+
}
|
|
759
|
+
} catch {
|
|
760
|
+
}
|
|
761
|
+
}
|
|
457
762
|
var README = `# NerdGram diagrams
|
|
458
763
|
|
|
459
764
|
This repository is a copy of diagrams from NerdGram1337.
|
|
@@ -494,24 +799,66 @@ async function copyDataToMirror(dataRoot, dir) {
|
|
|
494
799
|
async function commitMirror(dir, message, parents) {
|
|
495
800
|
const matrix = await git.statusMatrix({ fs: nodeFs, dir });
|
|
496
801
|
let dirty = false;
|
|
497
|
-
for (const [filepath,
|
|
498
|
-
if (
|
|
499
|
-
if (
|
|
802
|
+
for (const [filepath, head2, workdir, stage] of matrix) {
|
|
803
|
+
if (head2 === 1 && workdir === 1 && stage === 1) continue;
|
|
804
|
+
if (head2 === 0 && workdir === 0) continue;
|
|
500
805
|
dirty = true;
|
|
501
806
|
if (workdir === 0) await git.remove({ fs: nodeFs, dir, filepath });
|
|
502
807
|
else await git.add({ fs: nodeFs, dir, filepath });
|
|
503
808
|
}
|
|
504
809
|
if (!dirty && !parents) return null;
|
|
810
|
+
const head = await headOid(dir);
|
|
811
|
+
const parentOids = parents && parents.length > 0 ? parents : head ? [head] : [];
|
|
812
|
+
const text = message.trim() || "Update diagrams";
|
|
813
|
+
const onlyParentIsHead = parentOids.length === 1 && parentOids[0] === head;
|
|
814
|
+
if (!parents || onlyParentIsHead) {
|
|
815
|
+
try {
|
|
816
|
+
return await git.commit({
|
|
817
|
+
fs: nodeFs,
|
|
818
|
+
dir,
|
|
819
|
+
message: text,
|
|
820
|
+
author: PERSON,
|
|
821
|
+
committer: PERSON,
|
|
822
|
+
parent: parents,
|
|
823
|
+
disallowEmpty: parentOids.length === 1
|
|
824
|
+
});
|
|
825
|
+
} catch (err) {
|
|
826
|
+
if (isEmptyCommit(err)) return null;
|
|
827
|
+
throw err;
|
|
828
|
+
}
|
|
829
|
+
}
|
|
505
830
|
const oid = await git.commit({
|
|
506
831
|
fs: nodeFs,
|
|
507
832
|
dir,
|
|
508
|
-
message:
|
|
833
|
+
message: text,
|
|
509
834
|
author: PERSON,
|
|
510
835
|
committer: PERSON,
|
|
511
|
-
parent: parents
|
|
836
|
+
parent: parents,
|
|
837
|
+
noUpdateBranch: true
|
|
838
|
+
});
|
|
839
|
+
if (parentOids.length === 1) {
|
|
840
|
+
const [created, parentCommit] = await Promise.all([
|
|
841
|
+
git.readCommit({ fs: nodeFs, dir, oid }),
|
|
842
|
+
git.readCommit({ fs: nodeFs, dir, oid: parentOids[0] })
|
|
843
|
+
]);
|
|
844
|
+
if (created.commit.tree === parentCommit.commit.tree) return null;
|
|
845
|
+
}
|
|
846
|
+
const branch = await git.currentBranch({ fs: nodeFs, dir, fullname: true });
|
|
847
|
+
await git.writeRef({
|
|
848
|
+
fs: nodeFs,
|
|
849
|
+
dir,
|
|
850
|
+
ref: typeof branch === "string" ? branch : "HEAD",
|
|
851
|
+
value: oid,
|
|
852
|
+
force: true
|
|
512
853
|
});
|
|
513
854
|
return oid;
|
|
514
855
|
}
|
|
856
|
+
function isEmptyCommit(err) {
|
|
857
|
+
if (!err || typeof err !== "object") return false;
|
|
858
|
+
const code = "code" in err ? String(err.code) : "";
|
|
859
|
+
const name = "name" in err ? String(err.name) : "";
|
|
860
|
+
return code === "EmptyCommitError" || name === "EmptyCommitError";
|
|
861
|
+
}
|
|
515
862
|
async function fetchRemote(dir) {
|
|
516
863
|
try {
|
|
517
864
|
await git.fetch({
|
|
@@ -594,10 +941,9 @@ async function readUserFilesAt(dir, ref) {
|
|
|
594
941
|
return out;
|
|
595
942
|
}
|
|
596
943
|
async function authHeaders2() {
|
|
597
|
-
const
|
|
944
|
+
const token = await ensureAccessToken();
|
|
598
945
|
if (!token) return {};
|
|
599
|
-
|
|
600
|
-
return { Authorization: `Bearer ${token}` };
|
|
946
|
+
return { Authorization: gitBasicAuthorization(token) };
|
|
601
947
|
}
|
|
602
948
|
function mirrorFile(dir, relativePath) {
|
|
603
949
|
if (!isSyncedFile(relativePath)) {
|
|
@@ -652,6 +998,7 @@ async function deleteExtra(mirror, dir, desired) {
|
|
|
652
998
|
|
|
653
999
|
// server/src/sync/engine.ts
|
|
654
1000
|
var suppress = 0;
|
|
1001
|
+
var noteGeneration = 0;
|
|
655
1002
|
var timer = null;
|
|
656
1003
|
var summaries = [];
|
|
657
1004
|
var structuralPending = false;
|
|
@@ -667,8 +1014,12 @@ function noteLocalChange(change) {
|
|
|
667
1014
|
}
|
|
668
1015
|
async function recordChange(change) {
|
|
669
1016
|
if (suppress > 0) return;
|
|
1017
|
+
const generation = noteGeneration;
|
|
670
1018
|
const config = await loadConfig();
|
|
671
1019
|
if (!config.enabled || suppress > 0) return;
|
|
1020
|
+
if (!await workspaceDiffersFromHead()) return;
|
|
1021
|
+
if (suppress > 0) return;
|
|
1022
|
+
if (generation !== noteGeneration && !await workspaceDiffersFromHead()) return;
|
|
672
1023
|
if (change.summary && !summaries.includes(change.summary)) summaries.push(change.summary);
|
|
673
1024
|
if (change.kind === "structural") {
|
|
674
1025
|
structuralPending = true;
|
|
@@ -677,6 +1028,13 @@ async function recordChange(change) {
|
|
|
677
1028
|
}
|
|
678
1029
|
if (!structuralPending) schedule(idleMs());
|
|
679
1030
|
}
|
|
1031
|
+
async function workspaceDiffersFromHead() {
|
|
1032
|
+
try {
|
|
1033
|
+
return await copyWouldChange();
|
|
1034
|
+
} catch {
|
|
1035
|
+
return true;
|
|
1036
|
+
}
|
|
1037
|
+
}
|
|
680
1038
|
async function syncNow() {
|
|
681
1039
|
return exclusive(async () => {
|
|
682
1040
|
const config = await loadConfig();
|
|
@@ -704,7 +1062,7 @@ async function pushLocal(config, push) {
|
|
|
704
1062
|
const head = await headOid(mirror);
|
|
705
1063
|
config.ahead = head && head !== config.lastPushedOid ? 1 : 0;
|
|
706
1064
|
await saveConfig(config);
|
|
707
|
-
|
|
1065
|
+
logSyncFailure(failure);
|
|
708
1066
|
return;
|
|
709
1067
|
}
|
|
710
1068
|
const compared = await compare(mirror);
|
|
@@ -719,7 +1077,7 @@ async function pushLocal(config, push) {
|
|
|
719
1077
|
"not_fast_forward"
|
|
720
1078
|
)
|
|
721
1079
|
);
|
|
722
|
-
|
|
1080
|
+
logSyncFailure(memoryError);
|
|
723
1081
|
return;
|
|
724
1082
|
}
|
|
725
1083
|
await pushIfForward(config);
|
|
@@ -733,7 +1091,7 @@ async function pushIfForward(config) {
|
|
|
733
1091
|
compared = await compare(mirror);
|
|
734
1092
|
} catch (err) {
|
|
735
1093
|
memoryError = asFailure(err);
|
|
736
|
-
|
|
1094
|
+
logSyncFailure(memoryError);
|
|
737
1095
|
await saveConfig(config);
|
|
738
1096
|
return;
|
|
739
1097
|
}
|
|
@@ -748,7 +1106,7 @@ async function pushIfForward(config) {
|
|
|
748
1106
|
)
|
|
749
1107
|
);
|
|
750
1108
|
await saveConfig(config);
|
|
751
|
-
|
|
1109
|
+
logSyncFailure(memoryError);
|
|
752
1110
|
return;
|
|
753
1111
|
}
|
|
754
1112
|
const head = await headOid(mirror);
|
|
@@ -766,7 +1124,7 @@ async function pushIfForward(config) {
|
|
|
766
1124
|
} catch (err) {
|
|
767
1125
|
memoryError = asFailure(err);
|
|
768
1126
|
await saveConfig(config);
|
|
769
|
-
|
|
1127
|
+
logSyncFailure(memoryError);
|
|
770
1128
|
return;
|
|
771
1129
|
}
|
|
772
1130
|
const pushed = await headOid(mirror);
|
|
@@ -813,11 +1171,12 @@ async function publicStatus() {
|
|
|
813
1171
|
verificationUri: device.verificationUri,
|
|
814
1172
|
expiresAt: new Date(device.expiresAt).toISOString()
|
|
815
1173
|
} : null;
|
|
1174
|
+
const blocked = memoryError || device?.phase === "error" && device.error ? null : await authorizationBlock();
|
|
816
1175
|
const error = device?.phase === "error" && device.error ? {
|
|
817
1176
|
code: device.error.code,
|
|
818
1177
|
message: device.error.message,
|
|
819
1178
|
docsUrl: device.error.code === "invalid_client" || device.error.code === "device_flow_disabled" ? SYNC_DOCS_URL : void 0
|
|
820
|
-
} : memoryError ? { code: memoryError.code, message: memoryError.message, docsUrl: memoryError.docsUrl } : null;
|
|
1179
|
+
} : memoryError ? { code: memoryError.code, message: memoryError.message, docsUrl: memoryError.docsUrl } : blocked ? { code: blocked.code, message: blocked.message, docsUrl: SYNC_DOCS_URL } : null;
|
|
821
1180
|
return {
|
|
822
1181
|
enabled: config.enabled,
|
|
823
1182
|
login: config.login,
|
|
@@ -890,10 +1249,14 @@ async function probeIfHttp(config) {
|
|
|
890
1249
|
const repo = await getRepo(auth.token, config.owner, config.repo);
|
|
891
1250
|
if (!repo) throw httpFail(404, "That GitHub repository was not found.", "repo_missing");
|
|
892
1251
|
}
|
|
1252
|
+
function logSyncFailure(failure) {
|
|
1253
|
+
const message = redactText(failure.message).replace(/\s+/g, " ").trim();
|
|
1254
|
+
console.error(`GitHub sync: ${failure.code} ${message}`);
|
|
1255
|
+
}
|
|
893
1256
|
function asFailure(err) {
|
|
894
1257
|
if (err && typeof err === "object" && "status" in err && "code" in err && err instanceof Error) {
|
|
895
1258
|
const code = String(err.code);
|
|
896
|
-
const docs = code === "invalid_client" || code === "device_flow_disabled" || code === "repo_not_empty" ? SYNC_DOCS_URL : void 0;
|
|
1259
|
+
const docs = code === "invalid_client" || code === "device_flow_disabled" || code === "repo_not_empty" || code === "auth_expired" ? SYNC_DOCS_URL : void 0;
|
|
897
1260
|
return {
|
|
898
1261
|
code,
|
|
899
1262
|
message: err.message,
|
|
@@ -929,7 +1292,7 @@ function schedule(ms) {
|
|
|
929
1292
|
timer = null;
|
|
930
1293
|
void syncNow().catch((err) => {
|
|
931
1294
|
memoryError = asFailure(err);
|
|
932
|
-
|
|
1295
|
+
logSyncFailure(memoryError);
|
|
933
1296
|
});
|
|
934
1297
|
}, ms);
|
|
935
1298
|
timer.unref?.();
|
|
@@ -12,6 +12,119 @@ import {
|
|
|
12
12
|
// server/src/renderDiagram.ts
|
|
13
13
|
import { createRequire } from "node:module";
|
|
14
14
|
import puppeteer from "puppeteer";
|
|
15
|
+
|
|
16
|
+
// server/src/edgeLabelPadding.ts
|
|
17
|
+
function repairSvgMarkup(svg) {
|
|
18
|
+
let next = svg;
|
|
19
|
+
if (next.includes("xlink:") && !/xmlns:xlink\s*=/.test(next)) {
|
|
20
|
+
next = next.replace(/<svg\b/, '<svg xmlns:xlink="http://www.w3.org/1999/xlink"');
|
|
21
|
+
}
|
|
22
|
+
return next.replace(/<br\b([^>]*?)>/gi, (_full, attrs) => {
|
|
23
|
+
const body = attrs.replace(/\s*\/\s*$/, "");
|
|
24
|
+
return `<br${body}/>`;
|
|
25
|
+
});
|
|
26
|
+
}
|
|
27
|
+
function padEdgeLabelBoxes(root) {
|
|
28
|
+
const pad = 6;
|
|
29
|
+
const mark = "data-nerdgram-pad";
|
|
30
|
+
const readPx = (value) => {
|
|
31
|
+
if (!value) return 0;
|
|
32
|
+
const n = Number.parseFloat(value);
|
|
33
|
+
return Number.isFinite(n) ? n : 0;
|
|
34
|
+
};
|
|
35
|
+
const trimNum = (value) => String(Math.round(value * 100) / 100);
|
|
36
|
+
const writePx = (current, next) => {
|
|
37
|
+
const unit = current?.trim().toLowerCase().endsWith("px") ? "px" : "";
|
|
38
|
+
return `${trimNum(next)}${unit}`;
|
|
39
|
+
};
|
|
40
|
+
const shiftTranslateX = (el, dx) => {
|
|
41
|
+
const raw = el.getAttribute("transform") ?? "";
|
|
42
|
+
const match = /translate\(\s*(-?[\d.]+)(?:[,\s]+(-?[\d.]+))?\s*\)/.exec(raw);
|
|
43
|
+
if (!match || match[1] == null) return;
|
|
44
|
+
const x = Number(match[1]) + dx;
|
|
45
|
+
const y = match[2] ?? "0";
|
|
46
|
+
el.setAttribute("transform", raw.replace(match[0], `translate(${trimNum(x)}, ${y})`));
|
|
47
|
+
};
|
|
48
|
+
const appendStyle = (el, addition) => {
|
|
49
|
+
const style = el.getAttribute("style") ?? "";
|
|
50
|
+
if (/padding\s*:/.test(style)) return;
|
|
51
|
+
el.setAttribute("style", style.trim() ? `${style.replace(/;\s*$/, "")};${addition}` : addition);
|
|
52
|
+
};
|
|
53
|
+
for (const group of root.querySelectorAll("g.edgeLabel")) {
|
|
54
|
+
if (group.getAttribute(mark) === "1") continue;
|
|
55
|
+
const foreign = group.querySelector("foreignObject");
|
|
56
|
+
if (foreign) {
|
|
57
|
+
const widthAttr2 = foreign.getAttribute("width");
|
|
58
|
+
const width2 = readPx(widthAttr2);
|
|
59
|
+
if (!(width2 > 0)) continue;
|
|
60
|
+
foreign.setAttribute("width", writePx(widthAttr2, width2 + pad * 2));
|
|
61
|
+
shiftTranslateX(group.querySelector("g.label") ?? group, -pad);
|
|
62
|
+
const tagged = foreign.getElementsByTagName?.("p");
|
|
63
|
+
const paragraphs = tagged ? [...tagged] : [...foreign.querySelectorAll("*")].filter((el) => (el.localName ?? "").toLowerCase() === "p");
|
|
64
|
+
if (paragraphs.length > 0) {
|
|
65
|
+
for (const paragraph of paragraphs) appendStyle(paragraph, `padding:0 ${pad}px`);
|
|
66
|
+
} else {
|
|
67
|
+
const background = foreign.querySelector(".labelBkg") ?? foreign.querySelector("div");
|
|
68
|
+
if (background) appendStyle(background, `padding:0 ${pad}px`);
|
|
69
|
+
}
|
|
70
|
+
group.setAttribute(mark, "1");
|
|
71
|
+
continue;
|
|
72
|
+
}
|
|
73
|
+
const rect = group.querySelector("rect");
|
|
74
|
+
if (!rect) continue;
|
|
75
|
+
const widthAttr = rect.getAttribute("width");
|
|
76
|
+
const width = readPx(widthAttr);
|
|
77
|
+
if (!(width > 0)) continue;
|
|
78
|
+
const xAttr = rect.getAttribute("x");
|
|
79
|
+
const x = readPx(xAttr);
|
|
80
|
+
const text = group.querySelector("text");
|
|
81
|
+
const box = text && typeof text.getBBox === "function" ? text.getBBox() : null;
|
|
82
|
+
let extra = pad;
|
|
83
|
+
if (box && box.width > 1) {
|
|
84
|
+
extra = pad - (width - box.width) / 2;
|
|
85
|
+
if (extra <= 0.5) {
|
|
86
|
+
group.setAttribute(mark, "1");
|
|
87
|
+
continue;
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
rect.setAttribute("x", writePx(xAttr, x - extra));
|
|
91
|
+
rect.setAttribute("width", writePx(widthAttr, width + extra * 2));
|
|
92
|
+
group.setAttribute(mark, "1");
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
function padEdgeLabelSvg(svg) {
|
|
96
|
+
if (!svg.includes("edgeLabel")) return repairSvgMarkup(svg);
|
|
97
|
+
const prepared = repairSvgMarkup(svg);
|
|
98
|
+
const g = globalThis;
|
|
99
|
+
if (!g.DOMParser || !g.XMLSerializer) return prepared;
|
|
100
|
+
const doc = new g.DOMParser().parseFromString(prepared, "image/svg+xml");
|
|
101
|
+
if (doc.querySelector("parsererror")) return prepared;
|
|
102
|
+
padEdgeLabelBoxes(doc);
|
|
103
|
+
return repairSvgMarkup(new g.XMLSerializer().serializeToString(doc.documentElement));
|
|
104
|
+
}
|
|
105
|
+
function svgXmlError(svg) {
|
|
106
|
+
const text = svg.trim();
|
|
107
|
+
if (!text.includes("<svg") || text.includes("<parsererror")) {
|
|
108
|
+
return "Rendered SVG is not well-formed XML.";
|
|
109
|
+
}
|
|
110
|
+
if (/<br\b(?![^>]*\/>)[^>]*>/i.test(text)) {
|
|
111
|
+
return "Rendered SVG is not well-formed XML. Opening and ending tag mismatch: br and p.";
|
|
112
|
+
}
|
|
113
|
+
const g = globalThis;
|
|
114
|
+
if (!g.DOMParser) return null;
|
|
115
|
+
const doc = new g.DOMParser().parseFromString(text, "image/svg+xml");
|
|
116
|
+
const err = doc.querySelector("parsererror");
|
|
117
|
+
if (err) {
|
|
118
|
+
const message = (err.textContent ?? "").replace(/\s+/g, " ").trim();
|
|
119
|
+
return message.slice(0, 300) || "Rendered SVG is not well-formed XML.";
|
|
120
|
+
}
|
|
121
|
+
if (doc.documentElement?.localName && doc.documentElement.localName !== "svg") {
|
|
122
|
+
return "Rendered SVG is not well-formed XML.";
|
|
123
|
+
}
|
|
124
|
+
return null;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
// server/src/renderDiagram.ts
|
|
15
128
|
var require2 = createRequire(import.meta.url);
|
|
16
129
|
var MAX_RENDER_SOURCE_CHARS = 512 * 1024;
|
|
17
130
|
var MAX_RENDER_SVG_CHARS = 2e6;
|
|
@@ -107,14 +220,20 @@ async function draw(page, source, background) {
|
|
|
107
220
|
);
|
|
108
221
|
await page.addScriptTag({ path: mermaidScript() });
|
|
109
222
|
const drawn = await page.evaluate(
|
|
110
|
-
async (code, mermaidConfig, fill) => {
|
|
223
|
+
async (code, mermaidConfig, fill, padSource) => {
|
|
224
|
+
const padSvg = new Function(
|
|
225
|
+
"svg",
|
|
226
|
+
`var __name = function (target) { return target; };
|
|
227
|
+
${padSource}
|
|
228
|
+
return padEdgeLabelSvg(svg);`
|
|
229
|
+
);
|
|
111
230
|
const api = window.mermaid;
|
|
112
231
|
if (!api) return { ok: false, message: "Mermaid did not load", loc: null, token: void 0 };
|
|
113
232
|
document.body.style.background = fill;
|
|
114
233
|
api.initialize(mermaidConfig);
|
|
115
234
|
try {
|
|
116
235
|
const rendered = await api.render("nerdgram-render", code);
|
|
117
|
-
return { ok: true, svg: rendered.svg };
|
|
236
|
+
return { ok: true, svg: padSvg(rendered.svg) };
|
|
118
237
|
} catch (err) {
|
|
119
238
|
const hash = err && typeof err === "object" && "hash" in err ? err.hash : void 0;
|
|
120
239
|
const loc = hash?.loc;
|
|
@@ -133,7 +252,10 @@ async function draw(page, source, background) {
|
|
|
133
252
|
},
|
|
134
253
|
source,
|
|
135
254
|
config,
|
|
136
|
-
background
|
|
255
|
+
background,
|
|
256
|
+
`${repairSvgMarkup.toString()}
|
|
257
|
+
${padEdgeLabelBoxes.toString()}
|
|
258
|
+
${padEdgeLabelSvg.toString()}`
|
|
137
259
|
);
|
|
138
260
|
if (!drawn.ok) {
|
|
139
261
|
const parsed = drawn.loc != null || /parse error on line/i.test(drawn.message);
|
|
@@ -170,6 +292,18 @@ async function rasterize(page, svg, background) {
|
|
|
170
292
|
const png = await frame.screenshot({ type: "png", omitBackground: false });
|
|
171
293
|
return Buffer.from(png);
|
|
172
294
|
}
|
|
295
|
+
async function xmlErrorOnPage(page, svg) {
|
|
296
|
+
const message = await page.evaluate((markup) => {
|
|
297
|
+
const g = globalThis;
|
|
298
|
+
const doc = new g.DOMParser().parseFromString(markup, "image/svg+xml");
|
|
299
|
+
const err = doc.querySelector("parsererror");
|
|
300
|
+
if (err || doc.documentElement?.localName !== "svg") {
|
|
301
|
+
return (err?.textContent || "Rendered SVG is not well-formed XML.").replace(/\s+/g, " ").trim().slice(0, 300);
|
|
302
|
+
}
|
|
303
|
+
return "";
|
|
304
|
+
}, svg);
|
|
305
|
+
return message || null;
|
|
306
|
+
}
|
|
173
307
|
async function renderOnce(input) {
|
|
174
308
|
const source = assertSource(input.source);
|
|
175
309
|
if (input.format !== "svg" && input.format !== "png") {
|
|
@@ -194,6 +328,8 @@ async function renderOnce(input) {
|
|
|
194
328
|
if (/<script[\s>/]/i.test(cleaned)) {
|
|
195
329
|
throw httpFail(400, "Rendered SVG was rejected.", "invalid");
|
|
196
330
|
}
|
|
331
|
+
const markupError = svgXmlError(cleaned) ?? await xmlErrorOnPage(page, cleaned);
|
|
332
|
+
if (markupError) throw httpFail(500, markupError, "invalid");
|
|
197
333
|
if (input.format === "svg") {
|
|
198
334
|
return { format: "svg", contentType: "image/svg+xml; charset=utf-8", body: Buffer.from(cleaned, "utf8") };
|
|
199
335
|
}
|
package/dist/cli.js
CHANGED
|
@@ -26,6 +26,7 @@ var BOOL_FLAGS = /* @__PURE__ */ new Set([
|
|
|
26
26
|
"with-data",
|
|
27
27
|
"keep-data",
|
|
28
28
|
"include-down",
|
|
29
|
+
"create-only",
|
|
29
30
|
"version"
|
|
30
31
|
]);
|
|
31
32
|
var HELP = `nerdgram \u2014 automation client for NerdGram1337
|
|
@@ -68,11 +69,14 @@ Flags
|
|
|
68
69
|
diagnostics, folders, files, and the rest of the payload).
|
|
69
70
|
Failure is {"ok":false,"error","status"} on stdout.
|
|
70
71
|
--include-down Network data. Draw shutdown and down interfaces. Off by default.
|
|
72
|
+
--create-only Create the diagram and return 409 when the path exists.
|
|
73
|
+
Without this flag, generate creates the diagram or updates
|
|
74
|
+
the generated block and the data file beside it.
|
|
71
75
|
--vlan <1-4094> Layer 2 network view. Keep links that carry this VLAN id.
|
|
72
76
|
--group-by <value>
|
|
73
77
|
cdp and lldp: platform or capability.
|
|
74
78
|
network with --view l3: vrf.
|
|
75
|
-
network with --view l2: site or
|
|
79
|
+
network with --view l2: site, role, or platform.
|
|
76
80
|
--view <l3|l2> generate --format network only. l3 is subnets. l2 is VLANs,
|
|
77
81
|
trunks, and LAGs. refresh rejects --view. The view is stored
|
|
78
82
|
in the diagram.
|
|
@@ -108,7 +112,7 @@ not changed. --undo restores that replace and skips a file edited since.
|
|
|
108
112
|
`;
|
|
109
113
|
var renderModule = null;
|
|
110
114
|
function loadRender() {
|
|
111
|
-
renderModule ??= import("./chunk-
|
|
115
|
+
renderModule ??= import("./chunk-WORJPG5T.js");
|
|
112
116
|
return renderModule;
|
|
113
117
|
}
|
|
114
118
|
async function loadLint() {
|
|
@@ -117,7 +121,7 @@ async function loadLint() {
|
|
|
117
121
|
async function templateCommand(parsed, io) {
|
|
118
122
|
const sub = parsed.positionals[0] ?? "";
|
|
119
123
|
const target = parsed.positionals[1] ?? "";
|
|
120
|
-
const templates = await import("./chunk-
|
|
124
|
+
const templates = await import("./chunk-M434Z7CG.js");
|
|
121
125
|
try {
|
|
122
126
|
if (sub === "save") {
|
|
123
127
|
if (!target) throw new CliError("Usage: nerdgram template save <diagram> [--name name] [--replace]");
|
|
@@ -554,8 +558,9 @@ async function generateCommand(parsed, io) {
|
|
|
554
558
|
const vlanText = flagString(parsed.flags, "vlan");
|
|
555
559
|
if (vlanText != null && !/^\d+$/.test(vlanText)) throw new CliError("vlan must be an integer from 1 to 4094.");
|
|
556
560
|
const text = await fs.readFile(dataFile, "utf8");
|
|
561
|
+
const createOnly = parsed.flags.get("create-only") === true;
|
|
557
562
|
const { base, token } = configOf(parsed.flags, io.env);
|
|
558
|
-
const result = await callApi(base, requireToken(token), "POST", "/api/v1/generate", {
|
|
563
|
+
const result = await callApi(base, requireToken(token), "POST", createOnly ? "/api/v1/generate" : "/api/v1/generate/upsert", {
|
|
559
564
|
path: diagramPath,
|
|
560
565
|
text,
|
|
561
566
|
format,
|
|
@@ -569,7 +574,8 @@ async function generateCommand(parsed, io) {
|
|
|
569
574
|
...vlanText != null ? { vlan: Number(vlanText) } : {}
|
|
570
575
|
});
|
|
571
576
|
const body = result.json;
|
|
572
|
-
|
|
577
|
+
const verb = body.created === false ? "Updated" : "Created";
|
|
578
|
+
writeOut(io, isJson(parsed.flags), body, `${verb} ${body.path}${body.dataPath ? ` from ${body.dataPath}` : ""}`);
|
|
573
579
|
}
|
|
574
580
|
async function diffCommand(parsed, io) {
|
|
575
581
|
const itemPath = parsed.positionals[0];
|