@theholocron/cli 5.0.0-alpha.264 → 5.0.0-alpha.265
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/README.md +11 -10
- package/dist/cli.mjs +241 -16
- package/dist/cli.mjs.map +1 -1
- package/dist/{index-BGZ_6iES.d.mts → index-CwxYoWzS.d.mts} +24 -1
- package/dist/{index-D0d--U7u.d.mts → index-DyTxSSgq.d.mts} +1 -1
- package/dist/index.d.mts +3 -3
- package/dist/index.mjs +2 -2
- package/dist/plugin/capabilities.d.mts +2 -2
- package/dist/plugin/capabilities.mjs +9 -1
- package/dist/presets.d.mts +1 -1
- package/package.json +9 -9
package/README.md
CHANGED
|
@@ -539,15 +539,16 @@ A `notifications` provider can declare a whole server in `holocron.config.ts`
|
|
|
539
539
|
pinned messages, onboarding, the bot application) and the CLI applies and checks it. The
|
|
540
540
|
commands and the config are provider-neutral; Discord is the first provider.
|
|
541
541
|
|
|
542
|
-
| Command | What it does
|
|
543
|
-
| -------------------------------------------------------------- |
|
|
544
|
-
| `holocron notifications setup` | Applies the layout; looks everything up by name first, so a re-run changes nothing that matches
|
|
545
|
-
| `holocron notifications channel add <name>` | Creates one channel (optionally with a webhook whose URL is stored as a secret)
|
|
546
|
-
| `holocron notifications create-server --name <n> --owner <id>` | Creates the server the layout describes, writes its id into the config, applies the layout, invites the owner, waits for them to join and hands the server over (`--resume` finishes an interrupted hand-over; `--force` allows a second server)
|
|
547
|
-
| `holocron notifications link` | Links your account on the provider to your GitHub account by signing in with the provider (OAuth, nothing secret kept)
|
|
548
|
-
| `holocron notifications sync-roles` | Makes who holds a role match a GitHub team, through the links file (`--keep` only adds; `--provider` picks one)
|
|
549
|
-
| `holocron doctor notifications [--built-only] [--deliver]` | Step by step: does the server match the layout, do the secrets exist, and does a person (not the bot) own it. A full run also leaves one `🧪 test:` post in the layout's `testChannel`; `--built-only` posts nothing; `--deliver` posts to every channel and removes each post
|
|
550
|
-
| `holocron
|
|
542
|
+
| Command | What it does |
|
|
543
|
+
| -------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
544
|
+
| `holocron notifications setup` | Applies the layout; looks everything up by name first, so a re-run changes nothing that matches |
|
|
545
|
+
| `holocron notifications channel add <name>` | Creates one channel (optionally with a webhook whose URL is stored as a secret) |
|
|
546
|
+
| `holocron notifications create-server --name <n> --owner <id>` | Creates the server the layout describes, writes its id into the config, applies the layout, invites the owner, waits for them to join and hands the server over (`--resume` finishes an interrupted hand-over; `--force` allows a second server) |
|
|
547
|
+
| `holocron notifications link` | Links your account on the provider to your GitHub account by signing in with the provider (OAuth, nothing secret kept) |
|
|
548
|
+
| `holocron notifications sync-roles` | Makes who holds a role match a GitHub team, through the links file (`--keep` only adds; `--provider` picks one) |
|
|
549
|
+
| `holocron doctor notifications [--built-only] [--deliver]` | Step by step: does the server match the layout, do the secrets exist, and does a person (not the bot) own it. A full run also leaves one `🧪 test:` post in the layout's `testChannel`; `--built-only` posts nothing; `--deliver` posts to every channel and removes each post |
|
|
550
|
+
| `holocron doctor variables` | Do the Actions variables `repo.variables` declares exist, with those values (and, for the organization's, that visibility)? One row for the repository and one for the organization, each only when declared. Read-only. An undeclared variable counts only with `prune`; a scope that cannot be read (no provider, no org token) is a skip, not a failure |
|
|
551
|
+
| `holocron probe [<provider> [<probe>]] [--dry-run] [--yes]` | Poke a live provider on purpose: list the probes, inspect something, or run a proof that cleans up after itself. Plugins offer the probes; nothing secret is printed; one that changes things asks first |
|
|
551
552
|
|
|
552
553
|
Channels fed by another service are declared with `feeds` on the channel: `{ name: "uptime", webhook: true, feeds: { monitoring: true } }` (the object form `{ name?, webhook?, avatar? }` overrides the alert channel's name, default `Message to #<channel>`, the dedicated webhook's name, default the provider's, and gives that webhook a picture, a file path or `https://` URL, or `{ url, image }` (the URL is tried first, the file in the repo is the fallback), else the provider's own icon (`Monitoring.icon`, a URL and an embedded `data:` image; Checkly provides one), else the layout's `webhookAvatar`, else the layout's `webhookAvatar`). `setup` gives the channel a dedicated webhook and hands its URL straight to the `monitoring` provider through `Monitoring.ensureAlertChannel({ name, format: "discord", url? })`, which finds an alert channel of that name or creates one and subscribes every check; the URL is never stored as a secret. It needs a `monitoring` provider that implements `ensureAlertChannel` (Checkly does). Two feeds may not share an alert channel name, and a feed's webhook may not share the channel's own webhook name (compared without regard to case).
|
|
553
554
|
|
|
@@ -768,7 +769,7 @@ the local override exists to exempt.
|
|
|
768
769
|
`package bump-versions`, `sync github`, `repo upgrade node`,
|
|
769
770
|
`repo upgrade deps`, `new plugin`, `auth`, `notifications setup`,
|
|
770
771
|
`notifications channel add`, `notifications link`,
|
|
771
|
-
`notifications sync-roles`, `doctor notifications`
|
|
772
|
+
`notifications sync-roles`, `doctor notifications`, `doctor variables`
|
|
772
773
|
- `src/commands/doctor-checks/` and `src/commands/deep-checks/` — the shared row
|
|
773
774
|
renderer and `declaredVsActual` helper, and `DEEP_CHECKS`, the registry every
|
|
774
775
|
`doctor <capability>` is listed in
|
package/dist/cli.mjs
CHANGED
|
@@ -215,6 +215,7 @@ const COMMAND_CONTEXTS = {
|
|
|
215
215
|
"notifications create-server": "workspace",
|
|
216
216
|
"notifications sync-roles": "workspace",
|
|
217
217
|
"doctor notifications": "workspace",
|
|
218
|
+
"doctor variables": "workspace",
|
|
218
219
|
probe: "workspace",
|
|
219
220
|
deploy: "workspace",
|
|
220
221
|
"deploy cleanup-preview": "workspace",
|
|
@@ -1418,6 +1419,13 @@ const doctorNotificationsEntry = {
|
|
|
1418
1419
|
}],
|
|
1419
1420
|
supportsDryRun: false
|
|
1420
1421
|
};
|
|
1422
|
+
// src/commands/doctor-variables/doctor-variables.entry.ts
|
|
1423
|
+
const doctorVariablesEntry = {
|
|
1424
|
+
name: "doctor variables",
|
|
1425
|
+
description: "Check the Actions variables the config declares against the ones the provider holds (read-only)",
|
|
1426
|
+
positionals: [],
|
|
1427
|
+
supportsDryRun: false
|
|
1428
|
+
};
|
|
1421
1429
|
// src/commands/monitoring-check/monitoring-check.entry.ts
|
|
1422
1430
|
const monitoringCheckEntry = {
|
|
1423
1431
|
name: "monitoring check",
|
|
@@ -1621,6 +1629,7 @@ const COMMAND_REGISTRY = [
|
|
|
1621
1629
|
},
|
|
1622
1630
|
notificationsChannelAddEntry,
|
|
1623
1631
|
doctorNotificationsEntry,
|
|
1632
|
+
doctorVariablesEntry,
|
|
1624
1633
|
notificationsSetupEntry,
|
|
1625
1634
|
notificationsCreateServerEntry,
|
|
1626
1635
|
notificationsLinkEntry,
|
|
@@ -2178,6 +2187,14 @@ var ElevationRequiredError = class extends Error {
|
|
|
2178
2187
|
this.elevation = elevation;
|
|
2179
2188
|
}
|
|
2180
2189
|
};
|
|
2190
|
+
/**
|
|
2191
|
+
* A provider cannot do a read because it has no token for it. A check that meets this skips with the message instead
|
|
2192
|
+
* of failing: the token is missing, not wrong.
|
|
2193
|
+
*/
|
|
2194
|
+
var MissingTokenError = class extends Error {
|
|
2195
|
+
/** Lets a caller tell this error from any other by name, across package copies. */
|
|
2196
|
+
name = "MissingTokenError";
|
|
2197
|
+
};
|
|
2181
2198
|
// src/config/config/config.ts
|
|
2182
2199
|
var ConfigError = class extends Error {
|
|
2183
2200
|
name = "ConfigError";
|
|
@@ -3889,6 +3906,29 @@ function logReason(err) {
|
|
|
3889
3906
|
const root = err instanceof Error && err.cause !== void 0 ? err.cause : err;
|
|
3890
3907
|
return errorMessage(root);
|
|
3891
3908
|
}
|
|
3909
|
+
// src/commands/doctor-checks/declared-vs-actual.ts
|
|
3910
|
+
/**
|
|
3911
|
+
* Compares what the config declares with what exists, both as maps by key, and returns one problem line per
|
|
3912
|
+
* difference: a declared key that is missing, a key found but not declared, a key whose values disagree.
|
|
3913
|
+
* An empty list means they match. A deep check is then a list of these comparisons, not a renderer of its own.
|
|
3914
|
+
*/
|
|
3915
|
+
function declaredVsActual(declared, actual, options) {
|
|
3916
|
+
const equal = options.equal ?? ((a, b) => a === b);
|
|
3917
|
+
const show = options.show ?? ((value) => String(value));
|
|
3918
|
+
const problems = [];
|
|
3919
|
+
for (const [key, want] of declared) {
|
|
3920
|
+
if (!actual.has(key)) {
|
|
3921
|
+
problems.push(`missing ${options.noun} ${key}`);
|
|
3922
|
+
continue;
|
|
3923
|
+
}
|
|
3924
|
+
const found = actual.get(key);
|
|
3925
|
+
if (!equal(want, found)) problems.push(`${options.noun} ${key}: declared ${show(want)}, found ${show(found)}`);
|
|
3926
|
+
}
|
|
3927
|
+
if (options.flagExtra !== false) {
|
|
3928
|
+
for (const key of actual.keys()) if (!declared.has(key)) problems.push(`unexpected ${options.noun} ${key}`);
|
|
3929
|
+
}
|
|
3930
|
+
return problems;
|
|
3931
|
+
}
|
|
3892
3932
|
// src/commands/doctor-checks/print-check-rows.ts
|
|
3893
3933
|
/** One row per step, titles padded to the widest, each problem on its own indented line. */
|
|
3894
3934
|
function printCheckRows(rows, print) {
|
|
@@ -3904,6 +3944,15 @@ function printCheckSummary(summary, print) {
|
|
|
3904
3944
|
print("");
|
|
3905
3945
|
print(style.header(`${summary.ok} ok, ${summary.fail} fail, ${summary.skip} skipped`));
|
|
3906
3946
|
}
|
|
3947
|
+
// src/commands/doctor-checks/summarise-checks.ts
|
|
3948
|
+
/** How many rows ended each way. */
|
|
3949
|
+
function summariseChecks(rows) {
|
|
3950
|
+
return {
|
|
3951
|
+
ok: rows.filter((r) => r.status === "ok").length,
|
|
3952
|
+
fail: rows.filter((r) => r.status === "fail").length,
|
|
3953
|
+
skip: rows.filter((r) => r.status === "skip").length
|
|
3954
|
+
};
|
|
3955
|
+
}
|
|
3907
3956
|
// src/commands/notifications-channel-add/avatar.ts
|
|
3908
3957
|
/**
|
|
3909
3958
|
* Read a webhook avatar named in a layout: a file path (from the directory the CLI runs in) or an
|
|
@@ -5439,6 +5488,175 @@ async function runDoctorNotifications(input) {
|
|
|
5439
5488
|
}, print);
|
|
5440
5489
|
return finish();
|
|
5441
5490
|
}
|
|
5491
|
+
// src/commands/doctor-notifications/doctor-notifications.command.ts
|
|
5492
|
+
const doctorNotificationsCommand = {
|
|
5493
|
+
command: "notifications",
|
|
5494
|
+
describe: "Check the layout against the server and the secrets store, step by step (a full run leaves one test post in the test channel; --built-only posts nothing unless --deliver)",
|
|
5495
|
+
builder: doctorNotificationsArgs,
|
|
5496
|
+
handler: async (argv) => {
|
|
5497
|
+
const tokens = tokenContext(argv.token);
|
|
5498
|
+
if (!tokens) return;
|
|
5499
|
+
const loaded = await loadConfig(argv.cwd);
|
|
5500
|
+
applyResolvedConfig(argv, loaded.resolved);
|
|
5501
|
+
if ((await runDoctorNotifications({
|
|
5502
|
+
loaded,
|
|
5503
|
+
context: {
|
|
5504
|
+
repoRoot: argv.cwd,
|
|
5505
|
+
...tokens,
|
|
5506
|
+
org: resolveOrg(argv, loaded.resolved)
|
|
5507
|
+
},
|
|
5508
|
+
...argv.scope ? { scope: parseScope(argv.scope) } : {},
|
|
5509
|
+
...argv.provider ? { provider: argv.provider } : {},
|
|
5510
|
+
...argv.builtOnly ? { builtOnly: true } : {},
|
|
5511
|
+
...argv.deliver ? { deliver: true } : {}
|
|
5512
|
+
})).status === "fail") process.exitCode = 1;
|
|
5513
|
+
}
|
|
5514
|
+
};
|
|
5515
|
+
// src/commands/doctor-variables/doctor-variables.ts
|
|
5516
|
+
/**
|
|
5517
|
+
* `holocron doctor variables` — do the Actions variables `repo.variables` declares exist, with those values?
|
|
5518
|
+
*
|
|
5519
|
+
* Read-only. One row for the repository's variables and one for the organization's, each only when the config
|
|
5520
|
+
* declares that scope. A variable that exists but is not declared is a problem only with `repo.variables.prune`,
|
|
5521
|
+
* since without it `repo setup` leaves it alone. A scope that cannot be read because there is no provider, the
|
|
5522
|
+
* provider cannot list variables, or the token is missing is a skip with the reason, not a failure.
|
|
5523
|
+
*/
|
|
5524
|
+
const REPO_TITLE = "repository variables match";
|
|
5525
|
+
const ORG_TITLE = "organization variables match";
|
|
5526
|
+
async function runDoctorVariables(input) {
|
|
5527
|
+
const print = input.print ?? ((line) => console.log(line));
|
|
5528
|
+
const logger = input.logger ?? getLogger();
|
|
5529
|
+
const loader = input.loader ?? new PluginLoader(input.loaded.resolved, input.context);
|
|
5530
|
+
await loader.load();
|
|
5531
|
+
assertPluginsResolvable(loader, "doctor variables");
|
|
5532
|
+
const config = input.loaded.resolved;
|
|
5533
|
+
const variables = config.repo?.variables;
|
|
5534
|
+
const prune = variables?.prune === true;
|
|
5535
|
+
const declares = (scope) => scope !== void 0 && (Object.keys(scope).length > 0 || prune);
|
|
5536
|
+
const checks = [];
|
|
5537
|
+
if (declares(variables?.repo)) checks.push({
|
|
5538
|
+
id: "repo-variables",
|
|
5539
|
+
title: REPO_TITLE,
|
|
5540
|
+
async run(source) {
|
|
5541
|
+
if (!source.listVariables) return { skip: "provider does not implement listVariables" };
|
|
5542
|
+
const declared = variables.repo;
|
|
5543
|
+
return {
|
|
5544
|
+
problems: compareRepo(declared, await source.listVariables(), prune),
|
|
5545
|
+
checked: Object.keys(declared).length
|
|
5546
|
+
};
|
|
5547
|
+
}
|
|
5548
|
+
});
|
|
5549
|
+
if (declares(variables?.org)) checks.push({
|
|
5550
|
+
id: "org-variables",
|
|
5551
|
+
title: ORG_TITLE,
|
|
5552
|
+
async run(source) {
|
|
5553
|
+
if (!source.listOrgVariables) return { skip: "provider does not implement listOrgVariables" };
|
|
5554
|
+
const org = input.context.org ?? (input.context.repo ?? config.repo?.name ?? "").split("/")[0];
|
|
5555
|
+
if (!org) return {
|
|
5556
|
+
problems: ["no organization: set `org` in the config or run inside a repository"],
|
|
5557
|
+
checked: 0
|
|
5558
|
+
};
|
|
5559
|
+
const declared = variables.org;
|
|
5560
|
+
return {
|
|
5561
|
+
problems: compareOrg(declared, await source.listOrgVariables(org), prune),
|
|
5562
|
+
checked: Object.keys(declared).length
|
|
5563
|
+
};
|
|
5564
|
+
}
|
|
5565
|
+
});
|
|
5566
|
+
const rows = [];
|
|
5567
|
+
if (checks.length === 0) rows.push({
|
|
5568
|
+
id: "variables",
|
|
5569
|
+
title: "variables",
|
|
5570
|
+
status: "ok",
|
|
5571
|
+
detail: "none declared",
|
|
5572
|
+
problems: []
|
|
5573
|
+
});
|
|
5574
|
+
else if (!loader.has("source")) {
|
|
5575
|
+
const why = whyMissing(loader, "source", "no `source` provider to read them with");
|
|
5576
|
+
for (const check of checks) rows.push(row(check, { skip: why }));
|
|
5577
|
+
} else {
|
|
5578
|
+
const source = loader.get("source");
|
|
5579
|
+
for (const check of checks) try {
|
|
5580
|
+
rows.push(row(check, await check.run(source)));
|
|
5581
|
+
} catch (err) {
|
|
5582
|
+
if (err instanceof MissingTokenError) rows.push(row(check, { skip: err.message }));
|
|
5583
|
+
else rows.push({
|
|
5584
|
+
id: check.id,
|
|
5585
|
+
title: check.title,
|
|
5586
|
+
status: "fail",
|
|
5587
|
+
detail: errorMessage(err),
|
|
5588
|
+
problems: []
|
|
5589
|
+
});
|
|
5590
|
+
}
|
|
5591
|
+
}
|
|
5592
|
+
printCheckRows(rows, print);
|
|
5593
|
+
const summary = summariseChecks(rows);
|
|
5594
|
+
printCheckSummary(summary, print);
|
|
5595
|
+
const status = summary.fail > 0 ? "fail" : summary.ok === 0 ? "skip" : "ok";
|
|
5596
|
+
logger.info({
|
|
5597
|
+
...summary,
|
|
5598
|
+
status
|
|
5599
|
+
}, "doctor variables");
|
|
5600
|
+
return {
|
|
5601
|
+
status,
|
|
5602
|
+
rows,
|
|
5603
|
+
summary,
|
|
5604
|
+
...status === "skip" ? { reason: rows.map((r) => r.detail).join("; ") } : {}
|
|
5605
|
+
};
|
|
5606
|
+
}
|
|
5607
|
+
function row(check, result) {
|
|
5608
|
+
const { id, title } = check;
|
|
5609
|
+
if ("skip" in result) return {
|
|
5610
|
+
id,
|
|
5611
|
+
title,
|
|
5612
|
+
status: "skip",
|
|
5613
|
+
detail: result.skip,
|
|
5614
|
+
problems: []
|
|
5615
|
+
};
|
|
5616
|
+
if (result.problems.length > 0) return {
|
|
5617
|
+
id,
|
|
5618
|
+
title,
|
|
5619
|
+
status: "fail",
|
|
5620
|
+
detail: `${result.problems.length} problem(s)`,
|
|
5621
|
+
problems: result.problems
|
|
5622
|
+
};
|
|
5623
|
+
return {
|
|
5624
|
+
id,
|
|
5625
|
+
title,
|
|
5626
|
+
status: "ok",
|
|
5627
|
+
detail: `${result.checked} of ${result.checked} match`,
|
|
5628
|
+
problems: []
|
|
5629
|
+
};
|
|
5630
|
+
}
|
|
5631
|
+
/** Re-keys what GitHub holds by the spelling the config declares, since GitHub treats names as case-insensitive. */
|
|
5632
|
+
function bySpelling(declared, have) {
|
|
5633
|
+
const spelled = new Map(declared.map((name) => [name.toUpperCase(), name]));
|
|
5634
|
+
return new Map(Object.entries(have).map(([name, value]) => [spelled.get(name.toUpperCase()) ?? name, value]));
|
|
5635
|
+
}
|
|
5636
|
+
function compareRepo(declared, have, prune) {
|
|
5637
|
+
return declaredVsActual(new Map(Object.entries(declared)), bySpelling(Object.keys(declared), have), {
|
|
5638
|
+
noun: "variable",
|
|
5639
|
+
flagExtra: prune,
|
|
5640
|
+
show: (value) => JSON.stringify(value)
|
|
5641
|
+
});
|
|
5642
|
+
}
|
|
5643
|
+
function compareOrg(declared, have, prune) {
|
|
5644
|
+
const wanted = new Map(Object.entries(declared).map(([name, v]) => [name, typeof v === "string" ? {
|
|
5645
|
+
value: v,
|
|
5646
|
+
visibility: "all"
|
|
5647
|
+
} : {
|
|
5648
|
+
value: v.value,
|
|
5649
|
+
visibility: v.visibility ?? "all"
|
|
5650
|
+
}]));
|
|
5651
|
+
const found = bySpelling(Object.keys(declared), have);
|
|
5652
|
+
for (const [name, v] of found) if (!wanted.has(name) && v.visibility === "selected") found.delete(name);
|
|
5653
|
+
return declaredVsActual(wanted, found, {
|
|
5654
|
+
noun: "organization variable",
|
|
5655
|
+
flagExtra: prune,
|
|
5656
|
+
equal: (a, b) => a.value === b.value && a.visibility === b.visibility,
|
|
5657
|
+
show: (v) => `${JSON.stringify(v.value)} (${v.visibility})`
|
|
5658
|
+
});
|
|
5659
|
+
}
|
|
5442
5660
|
// src/commands/deep-checks/deep-checks.ts
|
|
5443
5661
|
/**
|
|
5444
5662
|
* Every `doctor <capability>` deep check, in the order `doctor --all` runs them. Adding one is an entry here
|
|
@@ -5447,39 +5665,46 @@ async function runDoctorNotifications(input) {
|
|
|
5447
5665
|
const DEEP_CHECKS = [{
|
|
5448
5666
|
name: "notifications",
|
|
5449
5667
|
capability: "notifications",
|
|
5668
|
+
command: doctorNotificationsCommand,
|
|
5669
|
+
async run(input) {
|
|
5670
|
+
const report = await runDoctorNotifications(input);
|
|
5671
|
+
return {
|
|
5672
|
+
status: report.status,
|
|
5673
|
+
summary: {
|
|
5674
|
+
ok: report.summary.pass,
|
|
5675
|
+
fail: report.summary.fail,
|
|
5676
|
+
skip: report.summary.skip
|
|
5677
|
+
},
|
|
5678
|
+
...report.message ? { reason: report.message } : {}
|
|
5679
|
+
};
|
|
5680
|
+
}
|
|
5681
|
+
}, {
|
|
5682
|
+
name: "variables",
|
|
5683
|
+
capability: "source",
|
|
5450
5684
|
command: {
|
|
5451
|
-
command: "
|
|
5452
|
-
describe: "Check the
|
|
5453
|
-
builder: doctorNotificationsArgs,
|
|
5685
|
+
command: "variables",
|
|
5686
|
+
describe: "Check the Actions variables the config declares against the ones the provider holds (read-only)",
|
|
5454
5687
|
handler: async (argv) => {
|
|
5455
5688
|
const tokens = tokenContext(argv.token);
|
|
5456
5689
|
if (!tokens) return;
|
|
5457
5690
|
const loaded = await loadConfig(argv.cwd);
|
|
5458
5691
|
applyResolvedConfig(argv, loaded.resolved);
|
|
5459
|
-
if ((await
|
|
5692
|
+
if ((await runDoctorVariables({
|
|
5460
5693
|
loaded,
|
|
5461
5694
|
context: {
|
|
5462
5695
|
repoRoot: argv.cwd,
|
|
5463
5696
|
...tokens,
|
|
5464
5697
|
org: resolveOrg(argv, loaded.resolved)
|
|
5465
|
-
}
|
|
5466
|
-
...argv.scope ? { scope: parseScope(argv.scope) } : {},
|
|
5467
|
-
...argv.provider ? { provider: argv.provider } : {},
|
|
5468
|
-
...argv.builtOnly ? { builtOnly: true } : {},
|
|
5469
|
-
...argv.deliver ? { deliver: true } : {}
|
|
5698
|
+
}
|
|
5470
5699
|
})).status === "fail") process.exitCode = 1;
|
|
5471
5700
|
}
|
|
5472
5701
|
},
|
|
5473
5702
|
async run(input) {
|
|
5474
|
-
const report = await
|
|
5703
|
+
const report = await runDoctorVariables(input);
|
|
5475
5704
|
return {
|
|
5476
5705
|
status: report.status,
|
|
5477
|
-
summary:
|
|
5478
|
-
|
|
5479
|
-
fail: report.summary.fail,
|
|
5480
|
-
skip: report.summary.skip
|
|
5481
|
-
},
|
|
5482
|
-
...report.message ? { reason: report.message } : {}
|
|
5706
|
+
summary: report.summary,
|
|
5707
|
+
...report.reason ? { reason: report.reason } : {}
|
|
5483
5708
|
};
|
|
5484
5709
|
}
|
|
5485
5710
|
}];
|