sverka 0.2.24 → 0.2.26

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/main.ts","../src/output.ts"],"mappings":";;iBAGiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;iBAIe;EACf,MAAM;EACN,UAAU;EACV,MAAM;EACN,UAAU;;EAEV,MAAM;;;qBAIK;;;;;;YAOD,mBAAmB,uBAAuB;;YAG1C;;qBAWC,iBAAiB;WACnB,MAAM;WACN,UAAU;WACD;EAEhB,YAAA,iBACA,MAAM,cACN,UAAU,UACV;;;;;UC9Ba;EACf,SAAS;;;;;;;wBA6cW,KAAK,gBAAgB,OAAO,WAAW;;;;KCrejD,aAAa;;;;;;qBAOZ,+BAA+B;;EAM9B,YAAA,KAAK,WAAW,KAAK,WAAW,iBAAe;EAO3D,MAAM;EAKN,UAAU;EAKV,MAAM;EAIN,UAAU;;EAKV,MAAM;;;;;;wBAwDQ,mBACd,QAAQ,aACR,KAAK,WACL,KAAK,YACJ;;;;;wBAYa,iBACd,QAAQ,aACR,MAAM,eACL"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/main.ts","../src/output.ts"],"mappings":";;iBAGiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;iBAIe;EACf,MAAM;EACN,UAAU;EACV,MAAM;EACN,UAAU;;EAEV,MAAM;;;qBAIK;;;;;;YAOD,mBAAmB,uBAAuB;;YAG1C;;qBAWC,iBAAiB;WACnB,MAAM;WACN,UAAU;WACD;EAEhB,YAAA,iBACA,MAAM,cACN,UAAU,UACV;;;;;UC3Ba;EACf,SAAS;;;;;;;wBAwjBW,KAAK,gBAAgB,OAAO,WAAW;;;;KCnlBjD,aAAa;;;;;;qBAOZ,+BAA+B;;EAM9B,YAAA,KAAK,WAAW,KAAK,WAAW,iBAAe;EAO3D,MAAM;EAKN,UAAU;EAKV,MAAM;EAIN,UAAU;;EAKV,MAAM;;;;;;wBAwDQ,mBACd,QAAQ,aACR,KAAK,WACL,KAAK,YACJ;;;;;wBAYa,iBACd,QAAQ,aACR,MAAM,eACL"}

package/dist/index.mjs

@@ -3,18 +3,21 @@ import * as nodeModule from "node:module";
 import { register } from "node:module";
 import process$1 from "node:process";
 import yargs from "yargs";
-import { constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { mkdir, open, readFile, realpath, writeFile } from "node:fs/promises";
 import { Entry, Pipeline, Project, ShellStep, collectConstructWarnings, manual, synthesize, validateGraph } from "@sverka/workflow";
 import { bindRunPlan, createPlanner } from "@sverka/sdk";
 import { DEFAULT_POLICY, createBuiltinResolver, evaluatePolicy, loadBaseline, normalizeSarif, serializeSarif, synthesizeCheckSteps } from "@sverka/verification";
-import { AGENT_ENV, collectAgentWrites, createDockerDriver, createEngine, createHostDriver, noAgentDriverError, resolveAgentDrivers, resolveAgentEngine } from "@sverka/runtime";
-import { spawnSync } from "node:child_process";
+import { AGENT_ENV, collectAgentWrites, createDockerDriver, createEngine, createFileCacheStore, createHostDriver, noAgentDriverError, resolveAgentDrivers, resolveAgentEngine } from "@sverka/runtime";
+import { execFileSync, spawnSync } from "node:child_process";
 import { watch } from "chokidar";
+import { homedir } from "node:os";
+import { createRemoteCacheStore, createRemoteCircuit, createRemoteSnapshotStore, createTieredCacheStore } from "@sverka/storage";
 import { compileGithub, compileGitlab } from "@sverka/compiler";
 import { z } from "zod";
+import { startHubServer } from "@sverka/hub";
 //#region src/types.ts
 /** Exit codes used by the CLI. */
 const ExitCode = {
@@ -967,6 +970,119 @@ function watchLoop(opts) {
 	};
 }
 //#endregion
+//#region src/internal/hub.ts
+function configHome() {
+	const xdg = process.env["XDG_CONFIG_HOME"];
+	return typeof xdg === "string" && xdg !== "" ? xdg : join(homedir(), ".config");
+}
+function credentialsPath() {
+	return join(configHome(), "sverka", "credentials");
+}
+function readCredentials() {
+	try {
+		const text = readFileSync(credentialsPath(), "utf8");
+		const parsed = JSON.parse(text);
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+	} catch {}
+	return {};
+}
+/**
+* Store a hub token at `~/.config/sverka/credentials` with mode 0600.
+* The file is a JSON map keyed by hub URL so multiple hubs coexist.
+*/
+function storeCredentials(url, token) {
+	const path = credentialsPath();
+	const hubs = {
+		...readCredentials().hubs ?? {},
+		[url]: token
+	};
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	writeFileSync(path, `${JSON.stringify({ hubs }, null, 2)}\n`, { mode: 384 });
+	chmodSync(path, 384);
+	return path;
+}
+function storedTokenFor(url) {
+	return readCredentials().hubs?.[url];
+}
+/** Read `.sverka/hub.json` when present. Malformed JSON is ignored. */
+function readHubFileConfig(root) {
+	const path = join(root, ".sverka", "hub.json");
+	if (!existsSync(path)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		if (typeof parsed !== "object" || parsed === null) return {};
+		const outer = parsed;
+		const inner = typeof outer.remote === "object" && outer.remote !== null ? outer.remote : outer;
+		return {
+			url: typeof inner.url === "string" ? inner.url : void 0,
+			project: typeof inner.project === "string" ? inner.project : void 0,
+			enabled: inner.enabled === true,
+			cache: typeof inner.cache === "boolean" ? inner.cache : void 0,
+			upload: typeof inner.upload === "boolean" ? inner.upload : void 0
+		};
+	} catch {
+		return {};
+	}
+}
+/** Derive "owner/repo" from `git remote.origin.url`; falls back to the
+*  directory basename when there is no usable remote. */
+function projectSlug(root) {
+	try {
+		const url = execFileSync("git", [
+			"config",
+			"--get",
+			"remote.origin.url"
+		], {
+			cwd: root,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		const slug = (/^[^@]+@[^:]+:(.+)$/.exec(url)?.[1] ?? new URL(url).pathname).replace(/\.git$/, "").replace(/^\/+/, "");
+		if (slug !== "") return slug;
+	} catch {}
+	return basename(resolve(root));
+}
+function envString(name) {
+	const value = process.env[name];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/** Canonical credential key — `sverka login` stores tokens under the URL
+*  with trailing slashes stripped; lookups must normalize identically. */
+function normalizeHubUrl(url) {
+	let end = url.length;
+	while (end > 0 && url.charCodeAt(end - 1) === 47) end--;
+	return url.slice(0, end);
+}
+/**
+* Resolve the effective hub connection for a root. Returns null when no
+* hub is configured at all (no url, no token anywhere) — the caller then
+* treats `--remote` as a usage error and a bare `run` stays local.
+*/
+function resolveHub(root) {
+	const file = readHubFileConfig(root);
+	const rawUrl = envString("SVERKA_HUB_URL") ?? file.url;
+	const url = rawUrl !== void 0 ? normalizeHubUrl(rawUrl) : void 0;
+	const token = envString("SVERKA_HUB_TOKEN") ?? (url !== void 0 ? storedTokenFor(url) : void 0);
+	if (url === void 0 || token === void 0) return null;
+	return {
+		config: {
+			url,
+			token,
+			project: file.project ?? projectSlug(root)
+		},
+		cache: file.cache ?? true,
+		upload: file.upload ?? true,
+		enabled: file.enabled === true
+	};
+}
+//#endregion
 //#region src/commands/run.ts
 /** Pure-argument guards — an invalid flag fails fast instead of surfacing
 *  as a recurring run failure inside the watch supervisor. */
@@ -988,6 +1104,7 @@ async function runCommand(args, global, output, start) {
 	if (detected !== void 0) output.errorLine(`no sverka.config — running ${detected.length} detected checks (${detected.join(", ")})`);
 	for (const warning of warnings) output.errorLine(`warning: ${warning}`);
 	const entryId = resolveEntryId(graph, args.entryId);
+	const remote = resolveRemote(args, global, output);
 	const plan = bindRunPlan({
 		graph,
 		entryId
@@ -999,7 +1116,9 @@ async function runCommand(args, global, output, start) {
 		maxConcurrent: args.jobs ?? 4
 	}), plan, {
 		workspace: global.root,
-		artifactDir
+		artifactDir,
+		cache: remote?.stores.cache,
+		snapshotStore: remote?.stores.snapshotStore
 	}, global, output, graph, args);
 	const durationMs = Date.now() - start;
 	const evaluation = await evaluateRun(fmt.evaluate, artifactDir, global, output, events, renderer, args, start);
@@ -1015,6 +1134,7 @@ async function runCommand(args, global, output, start) {
 		...detected !== void 0 ? { detected } : {},
 		...args.report !== void 0 ? { report: args.report } : {}
 	}, events, output);
+	if (remote !== void 0 && remote.upload && report !== void 0) await uploadReportSafe(remote, report, entryId, findRunId(events), output);
 	await finalizeRenderer(fmt, renderer, args, global, output);
 	if (evaluation.collectionFailed) return evaluation.exitCode;
 	writeRunOutput({
@@ -1032,6 +1152,52 @@ async function runCommand(args, global, output, start) {
 	if (evaluation.exitCode !== 0) return evaluation.exitCode;
 	return exitCodeForStatus(runStatus);
 }
+/** Build the remote wiring for a run. `--remote` with no hub configured
+*  is a usage error naming `sverka login`; a hub.json-enabled run whose
+*  credentials are missing warns and runs local-only (degrade, don't
+*  fail). */
+function resolveRemote(args, global, output) {
+	const hub = resolveHub(global.root);
+	const requested = args.remote === true;
+	if (hub === null) {
+		if (requested) throw new CliError("--remote needs a hub: set SVERKA_HUB_URL + SVERKA_HUB_TOKEN, run `sverka login --hub <url> --token <t>`, or add .sverka/hub.json", "MISSING_ARG", ExitCode.UsageError);
+		if (readHubFileConfig(global.root).enabled === true) output.errorLine("warning: .sverka/hub.json enables remote runs but no hub credentials resolved — running local-only (see `sverka login`)");
+		return;
+	}
+	if (!requested && !hub.enabled) return void 0;
+	const circuit = createRemoteCircuit();
+	const remoteConfig = {
+		...hub.config,
+		circuit
+	};
+	const cache = hub.cache ? createTieredCacheStore({
+		local: createFileCacheStore({ cacheDir: join(global.root, ".sverka", "cache") }),
+		remote: createRemoteCacheStore(remoteConfig),
+		onWarn: (msg) => output.errorLine(`warning: ${msg}`)
+	}) : void 0;
+	return {
+		config: remoteConfig,
+		upload: hub.upload,
+		stores: {
+			...cache !== void 0 ? { cache } : {},
+			snapshotStore: createRemoteSnapshotStore(remoteConfig)
+		}
+	};
+}
+/** Upload the run report — warns `remote.upload-failed` and swallows the
+*  error per Spec 55 ("remote failures degrade to local + warn"). */
+async function uploadReportSafe(remote, report, entryId, runId, output) {
+	try {
+		const { uploadRunReport } = await import("@sverka/storage");
+		const result = await uploadRunReport(remote.config, report.payload, report.findingsList, {
+			entry: entryId,
+			...runId !== void 0 ? { runId } : {}
+		});
+		output.debug(`remote: uploaded run report as ${result.runId}`);
+	} catch (e) {
+		output.errorLine(`warning: remote.upload-failed: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
 /** Post-run: announce the HTML report path (sarif/web print their own),
 *  then keep interactive renderers mounted until the user quits. */
 async function finalizeRenderer(fmt, renderer, args, global, output) {
@@ -1111,7 +1277,9 @@ async function writeReportSafe(ctx, events, output) {
 		return {
 			html: artifacts.htmlPath,
 			json: join(artifacts.dir, "report.json"),
-			findings: artifacts.findingsCount
+			findings: artifacts.findingsCount,
+			payload: artifacts.payload,
+			findingsList: artifacts.findings
 		};
 	} catch (err) {
 		if (err instanceof CliError) throw err;
@@ -1219,7 +1387,9 @@ async function consumeEvents(engine, plan, ctx, global, output, graph, args) {
 	for await (const event of engine.run({
 		plan,
 		workspace: ctx.workspace,
-		artifactDir: ctx.artifactDir
+		artifactDir: ctx.artifactDir,
+		...ctx.cache !== void 0 ? { cache: ctx.cache } : {},
+		...ctx.snapshotStore !== void 0 ? { snapshotStore: ctx.snapshotStore } : {}
 	})) {
 		events.push(event);
 		renderer?.onEvent(event);
@@ -1485,11 +1655,14 @@ async function writeRunArtifacts(opts) {
 	const warnings = [];
 	const findings = await collectRunFindings(opts, warnings);
 	const htmlPath = await writeReportHtml(opts.reportPath !== void 0 ? resolveUnderRoot(opts.root, opts.reportPath) : join(dir, "report.html"), findings, warnings);
-	writeFileSync(join(dir, "report.json"), JSON.stringify(runReportPayload(opts, findings.length, warnings), null, 2), "utf-8");
+	const payload = runReportPayload(opts, findings.length, warnings);
+	writeFileSync(join(dir, "report.json"), JSON.stringify(payload, null, 2), "utf-8");
 	return {
 		dir,
 		htmlPath,
-		findingsCount: findings.length
+		findingsCount: findings.length,
+		payload,
+		findings
 	};
 }
 function exitCodeForStatus(runStatus) {
@@ -2498,6 +2671,124 @@ async function postJson(url, token, body, auth) {
 	}
 }
 //#endregion
+//#region src/commands/login.ts
+async function loginCommand(args, _global, output, _start) {
+	const url = args.hub ?? process.env["SVERKA_HUB_URL"];
+	const token = args.token ?? process.env["SVERKA_HUB_TOKEN"];
+	if (url === void 0) throw new CliError("missing --hub <url> (or set SVERKA_HUB_URL)", "MISSING_ARG", ExitCode.UsageError);
+	if (!token) throw new CliError("missing --token <t> (or set SVERKA_HUB_TOKEN)", "MISSING_ARG", ExitCode.UsageError);
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new CliError(`--hub must be a URL, got "${url}"`, "INVALID_FLAG", ExitCode.UsageError);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new CliError(`--hub must be http(s), got "${parsed.protocol}"`, "INVALID_FLAG", ExitCode.UsageError);
+	const normalized = normalizeHubUrl(url);
+	const path = storeCredentials(normalized, token);
+	output.writeLine(`stored credentials for ${normalized} in ${path}`);
+	return ExitCode.Success;
+}
+//#endregion
+//#region src/commands/hub.ts
+async function hubCommand(args, global, output, _start) {
+	if (args.action !== "serve") throw new CliError(`unknown hub action "${args.action ?? ""}" (supported: serve)`, "UNKNOWN_COMMAND", ExitCode.UsageError);
+	if (args.port !== void 0 && (!Number.isInteger(args.port) || args.port < 0 || args.port > 65535)) throw new CliError("--port must be an integer in [0, 65535]", "INVALID_FLAG", ExitCode.UsageError);
+	const dataDir = args.data ?? `${global.root}/.sverka-hub`;
+	const server = await startHubServer({
+		dataDir,
+		...args.port !== void 0 ? { port: args.port } : {},
+		...args.host !== void 0 ? { host: args.host } : {}
+	});
+	output.writeLine(`sverka hub listening on ${server.url}`);
+	output.writeLine(`  data: ${server.dataDir}`);
+	output.writeLine(`  dashboard: ${server.url}/`);
+	output.writeLine("  (Ctrl+C to stop)");
+	await new Promise((done) => {
+		const stop = () => {
+			process.removeListener("SIGINT", stop);
+			process.removeListener("SIGTERM", stop);
+			done();
+		};
+		process.on("SIGINT", stop);
+		process.on("SIGTERM", stop);
+	});
+	await server.close();
+	return ExitCode.Success;
+}
+//#endregion
+//#region src/commands/runs.ts
+function listLocalRuns(root) {
+	const dir = join(root, ".sverka", "runs");
+	if (!existsSync(dir)) return [];
+	const rows = [];
+	for (const entry of readdirSync(dir)) {
+		const reportPath = join(dir, entry, "report.json");
+		if (!existsSync(reportPath)) continue;
+		let status = "unknown";
+		let findings = null;
+		try {
+			const data = JSON.parse(readFileSync(reportPath, "utf8")).data ?? {};
+			if (typeof data.status === "string") status = data.status;
+			if (typeof data.findings === "number") findings = data.findings;
+		} catch {}
+		rows.push({
+			runId: entry,
+			status,
+			findings,
+			mtimeMs: statSync(reportPath).mtimeMs
+		});
+	}
+	return rows.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+async function runsCommand(args, global, output, _start) {
+	if (args.remote === true) return remoteRuns(args, global, output);
+	return localRuns(args, global, output);
+}
+async function remoteRuns(args, global, output) {
+	const hub = resolveHub(global.root);
+	if (hub === null) throw new CliError("no hub configured — set SVERKA_HUB_URL + SVERKA_HUB_TOKEN, run `sverka login`, or add .sverka/hub.json", "MISSING_ARG", ExitCode.UsageError);
+	const { listRuns } = await import("@sverka/storage");
+	const runs = await listRuns(hub.config, { ...args.limit !== void 0 ? { limit: args.limit } : {} });
+	if (global.format === "json") {
+		output.writeLine(JSON.stringify({
+			command: "runs",
+			data: runs
+		}));
+		return ExitCode.Success;
+	}
+	if (runs.length === 0) {
+		output.writeLine(`no remote runs for ${hub.config.project} — run \`sverka run --remote\` to upload one`);
+		return ExitCode.Success;
+	}
+	output.writeLine(`remote runs for ${hub.config.project} (${hub.config.url})`);
+	for (const run of runs) {
+		const when = run.startedAt === null ? "—" : new Date(run.startedAt).toISOString().slice(0, 19) + "Z";
+		const duration = run.durationMs === null ? "—" : `${(run.durationMs / 1e3).toFixed(1)}s`;
+		output.writeLine(`  ${run.runId}  ${run.status.padEnd(9)} ${run.entry.padEnd(20)} ${when}  ${duration}  findings:${run.findingCounts.total}`);
+	}
+	return ExitCode.Success;
+}
+function localRuns(args, global, output) {
+	const shown = listLocalRuns(global.root).slice(0, args.limit ?? 20);
+	if (global.format === "json") {
+		output.writeLine(JSON.stringify({
+			command: "runs",
+			data: shown
+		}));
+		return ExitCode.Success;
+	}
+	if (shown.length === 0) {
+		output.writeLine("no runs recorded — run `sverka run` first");
+		return ExitCode.Success;
+	}
+	for (const run of shown) {
+		const when = new Date(run.mtimeMs).toISOString().slice(0, 19) + "Z";
+		output.writeLine(`  ${run.runId}  ${run.status.padEnd(9)} ${when}  findings:${run.findings ?? "—"}`);
+	}
+	return ExitCode.Success;
+}
+//#endregion
 //#region src/main.ts
 /** Build GlobalFlags from parsed yargs options. */
 function buildGlobalFlags(parsed) {
@@ -2567,6 +2858,10 @@ function addRunCommand(y) {
 		type: "boolean",
 		alias: "w",
 		describe: "Re-run on file changes (debounced 300ms)"
+	}).option("remote", {
+		type: "boolean",
+		default: false,
+		describe: "Remote hub run: remote cache + snapshot store + report upload"
 	});
 }
 /** Configure the plan subcommand options. */
@@ -2636,6 +2931,45 @@ function addUiCommand(y) {
 		describe: "Host to bind"
 	});
 }
+/** Configure the login subcommand options. */
+function addLoginCommand(y) {
+	return y.option("hub", {
+		type: "string",
+		describe: "Hub base URL (or SVERKA_HUB_URL)"
+	}).option("token", {
+		type: "string",
+		describe: "Hub bearer token (or SVERKA_HUB_TOKEN)"
+	});
+}
+/** Configure the hub subcommand options. */
+function addHubCommand(y) {
+	return y.positional("action", {
+		type: "string",
+		choices: ["serve"],
+		describe: "hub action (serve)"
+	}).option("port", {
+		type: "number",
+		default: 7357,
+		describe: "Port to listen on"
+	}).option("host", {
+		type: "string",
+		describe: "Host to bind"
+	}).option("data", {
+		type: "string",
+		describe: "Data directory (default: .sverka-hub under --root)"
+	});
+}
+/** Configure the runs subcommand options. */
+function addRunsCommand(y) {
+	return y.option("remote", {
+		type: "boolean",
+		default: false,
+		describe: "List runs stored on the configured hub"
+	}).option("limit", {
+		type: "number",
+		describe: "Max runs to list"
+	});
+}
 function buildParser() {
 	return yargs([]).scriptName("sverka").version(cliVersion()).option("format", {
 		type: "string",
@@ -2672,7 +3006,7 @@ function buildParser() {
 	}).option("file", {
 		type: "string",
 		describe: "Path to sverka-writes.json (default: <root>/sverka-writes.json)"
-	})).demandCommand(1, "No command given").strict().fail((msg, err) => {
+	})).command("login", "Store hub credentials (~/.config/sverka/credentials)", addLoginCommand).command("hub <action>", "Self-hosted run hub (serve: cache + history + findings)", addHubCommand).command("runs", "List run history (local, or --remote)", addRunsCommand).demandCommand(1, "No command given").strict().fail((msg, err) => {
 		if (err) throw err;
 		throw new CliError(msg, "UNKNOWN_COMMAND", ExitCode.UsageError);
 	});
@@ -2696,6 +3030,9 @@ async function dispatch(command, parsed, global, output, start) {
 		case "ui": return dispatchUi(parsed, global, output, start);
 		case "agent": return dispatchAgent(parsed, global, output, start);
 		case "apply": return dispatchApply(parsed, global, output, start);
+		case "login": return dispatchLogin(parsed, global, output, start);
+		case "hub": return dispatchHub(parsed, global, output, start);
+		case "runs": return dispatchRuns(parsed, global, output, start);
 		default: throw new CliError(`unknown command: ${command}`, "UNKNOWN_COMMAND", ExitCode.UsageError);
 	}
 }
@@ -2732,6 +3069,7 @@ function dispatchRun(parsed, global, output, start) {
 	if (parsed.tui === true) args.tui = true;
 	if (parsed.tui === false) args.tui = false;
 	if (parsed.watch === true) args.watch = true;
+	if (parsed.remote === true) args.remote = true;
 	return runCommand(args, global, output, start);
 }
 function dispatchPolicy(parsed, global, output, start) {
@@ -2776,6 +3114,25 @@ function dispatchApply(parsed, global, output, start) {
 	if (typeof parsed.file === "string") args.file = parsed.file;
 	return applyCommand(args, global, output, start);
 }
+function dispatchLogin(parsed, global, output, start) {
+	const args = {};
+	if (typeof parsed.hub === "string") args.hub = parsed.hub;
+	if (typeof parsed.token === "string") args.token = parsed.token;
+	return loginCommand(args, global, output, start);
+}
+function dispatchHub(parsed, global, output, start) {
+	const args = {};
+	if (typeof parsed.action === "string") args.action = parsed.action;
+	if (typeof parsed.port === "number") args.port = parsed.port;
+	if (typeof parsed.data === "string") args.data = parsed.data;
+	if (typeof parsed.host === "string") args.host = parsed.host;
+	return hubCommand(args, global, output, start);
+}
+function dispatchRuns(parsed, global, output, start) {
+	const args = { remote: parsed.remote === true };
+	if (typeof parsed.limit === "number") args.limit = parsed.limit;
+	return runsCommand(args, global, output, start);
+}
 /**
 * The main CLI entry point.
 * @param argv Command-line arguments (excluding node and script path).