ryco-cli 0.1.3 → 0.1.4

package/dist/SourceControlProviderDiscoveryCatalog-DoDSpZoa.mjs

@@ -0,0 +1,569 @@
+#!/usr/bin/env node
+
+import { Dn as VcsProcessExitError, En as VcsOutputDecodeError, On as VcsProcessSpawnError, kn as VcsProcessTimeoutError, t as collectUint8StreamText } from "./collectUint8StreamText-Cgz3T1YG.mjs";
+import { Cause, Context, Duration, Effect, Exit, Layer, Option, Result, Schema, SchemaGetter, SchemaIssue, SchemaTransformation, Sink, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+//#region ../../packages/shared/src/schemaJson.ts
+const decodeJsonResult = (schema) => {
+	const decode = Schema.decodeExit(Schema.fromJsonString(schema));
+	return (input) => {
+		const result = decode(input);
+		if (Exit.isFailure(result)) return Result.fail(result.cause);
+		return Result.succeed(result.value);
+	};
+};
+const formatSchemaError = (cause) => {
+	const squashed = Cause.squash(cause);
+	return Schema.isSchemaError(squashed) ? SchemaIssue.makeFormatterDefault()(squashed.issue) : Cause.pretty(cause);
+};
+/**
+* A `Getter` that parses a lenient JSON string (tolerating trailing commas
+* and JS-style comments) into an unknown value.
+*
+* Mirrors `SchemaGetter.parseJson()` but uses `parseLenientJson` instead
+* of `JSON.parse`.
+*/
+const parseLenientJsonGetter = SchemaGetter.onSome((input) => Effect.try({
+	try: () => {
+		let stripped = input.replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\//g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/,(\s*[}\]])/g, "$1");
+		return Option.some(JSON.parse(stripped));
+	},
+	catch: (e) => new SchemaIssue.InvalidValue(Option.some(input), { message: String(e) })
+}));
+/**
+* Schema transformation: lenient JSONC string ↔ unknown.
+*
+* Same API as `SchemaTransformation.fromJsonString`, but the decode side
+* strips trailing commas and JS-style comments before parsing.
+* Encoding produces strict JSON via `JSON.stringify`.
+*/
+const fromLenientJsonString = new SchemaTransformation.Transformation(parseLenientJsonGetter, SchemaGetter.stringifyJson());
+/**
+* Build a schema that decodes a lenient JSON string into `A`.
+*
+* Drop-in replacement for `Schema.fromJsonString(schema)` that tolerates
+* trailing commas and comments in the input.
+*/
+const fromLenientJson = (schema) => Schema.String.pipe(Schema.decodeTo(schema, fromLenientJsonString));
+//#endregion
+//#region src/vcs/VcsProcess.ts
+var VcsProcess = class extends Context.Service()("ryco/vcs/VcsProcess") {};
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_OUTPUT_BYTES = 1e6;
+const OUTPUT_TRUNCATED_MARKER = "\n\n[truncated]";
+function commandLabel(command, args) {
+	return [command, ...args].join(" ");
+}
+function outputDecodeError(input, detail, cause) {
+	return new VcsOutputDecodeError({
+		operation: input.operation,
+		command: commandLabel(input.command, input.args),
+		cwd: input.cwd,
+		detail,
+		cause
+	});
+}
+const collectText = Effect.fn("VcsProcess.collectText")(function* (input) {
+	const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+	return yield* collectUint8StreamText({
+		stream: input.stream,
+		maxBytes: maxOutputBytes,
+		truncatedMarker: input.truncateOutputAtMaxBytes ? OUTPUT_TRUNCATED_MARKER : null
+	});
+});
+const make = Effect.fn("makeVcsProcess")(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const spawn = Effect.fn("VcsProcess.spawn")(function* (input) {
+		const label = commandLabel(input.command, input.args);
+		const child = yield* spawner.spawn(ChildProcess.make(input.command, [...input.args], {
+			cwd: input.cwd,
+			env: {
+				...process.env,
+				...input.env
+			}
+		})).pipe(Effect.mapError((cause) => new VcsProcessSpawnError({
+			operation: input.operation,
+			command: label,
+			cwd: input.cwd,
+			cause
+		})));
+		yield* Effect.addFinalizer(() => child.kill().pipe(Effect.ignore));
+		const mapStreamError = (streamName) => Stream.mapError((cause) => outputDecodeError(input, `failed to read process ${streamName}`, cause));
+		const mapEffectError = (detail) => Effect.mapError((cause) => outputDecodeError(input, detail, cause));
+		const writeStdin = (stdin) => Stream.run(Stream.encodeText(Stream.make(stdin)), child.stdin).pipe(mapEffectError("failed to write process stdin"));
+		return {
+			pid: child.pid,
+			stdin: child.stdin.pipe(Sink.mapError((cause) => outputDecodeError(input, "failed to write process stdin", cause))),
+			stdout: child.stdout.pipe(mapStreamError("stdout")),
+			stderr: child.stderr.pipe(mapStreamError("stderr")),
+			exitCode: child.exitCode.pipe(mapEffectError("failed to read process exit code")),
+			writeStdin
+		};
+	});
+	const withProcess = (input, use) => Effect.scoped(spawn(input).pipe(Effect.flatMap(use)));
+	const run = Effect.fn("VcsProcess.run")(function* (input) {
+		const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+		const label = commandLabel(input.command, input.args);
+		return yield* Effect.gen(function* () {
+			const [stdout, stderr, exitCode] = yield* withProcess(input, (child) => Effect.all([
+				collectText({
+					operation: input.operation,
+					command: label,
+					cwd: input.cwd,
+					stream: child.stdout,
+					maxOutputBytes,
+					truncateOutputAtMaxBytes: input.truncateOutputAtMaxBytes ?? false
+				}),
+				collectText({
+					operation: input.operation,
+					command: label,
+					cwd: input.cwd,
+					stream: child.stderr,
+					maxOutputBytes,
+					truncateOutputAtMaxBytes: input.truncateOutputAtMaxBytes ?? false
+				}),
+				child.exitCode,
+				input.stdin === void 0 ? Effect.void : child.writeStdin(input.stdin)
+			], { concurrency: "unbounded" })).pipe(Effect.map(([stdout, stderr, exitCode]) => [
+				stdout,
+				stderr,
+				exitCode
+			]));
+			if (!input.allowNonZeroExit && exitCode !== 0) return yield* new VcsProcessExitError({
+				operation: input.operation,
+				command: label,
+				cwd: input.cwd,
+				exitCode,
+				detail: stderr.text.trim() || `${label} exited with code ${exitCode}.`
+			});
+			return {
+				exitCode,
+				stdout: stdout.text,
+				stderr: stderr.text,
+				stdoutTruncated: stdout.truncated,
+				stderrTruncated: stderr.truncated
+			};
+		}).pipe(Effect.scoped, Effect.timeoutOption(Duration.millis(timeoutMs)), Effect.flatMap((result) => Option.match(result, {
+			onSome: Effect.succeed,
+			onNone: () => Effect.fail(new VcsProcessTimeoutError({
+				operation: input.operation,
+				command: label,
+				cwd: input.cwd,
+				timeoutMs
+			}))
+		})));
+	});
+	return VcsProcess.of({
+		withProcess,
+		run
+	});
+});
+const layer = Layer.effect(VcsProcess, make());
+//#endregion
+//#region src/sourceControl/SourceControlProvider.ts
+function parseSourceControlOwnerRef(headSelector) {
+	const match = /^([^:/\s]+):(.+)$/u.exec(headSelector.trim());
+	const owner = match?.[1]?.trim();
+	const refName = match?.[2]?.trim();
+	return owner && refName ? {
+		owner,
+		refName
+	} : void 0;
+}
+function normalizeSourceBranch(headSelector) {
+	return parseSourceControlOwnerRef(headSelector)?.refName ?? headSelector.trim();
+}
+function sourceBranch(input) {
+	return input.source?.refName ?? normalizeSourceBranch(input.headSelector);
+}
+function sourceControlRefFromInput(input) {
+	return input.source ?? parseSourceControlOwnerRef(input.headSelector);
+}
+var SourceControlProvider = class extends Context.Service()("ryco/source-control/SourceControlProvider") {};
+//#endregion
+//#region src/sourceControl/gitHubAuthStatus.ts
+const GitHubAuthStatusAccountSchema = Schema.Struct({
+	state: Schema.String,
+	error: Schema.optional(Schema.String),
+	active: Schema.Boolean,
+	host: Schema.String,
+	login: Schema.String
+});
+const GitHubAuthStatusSchema = Schema.Struct({ hosts: Schema.Record(Schema.String, Schema.Array(GitHubAuthStatusAccountSchema)) });
+const decodeGitHubAuthStatusJson = Schema.decodeUnknownOption(Schema.fromJsonString(GitHubAuthStatusSchema));
+function nonEmptyString(value) {
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function parseGitHubAuthStatus(text) {
+	return Option.match(decodeGitHubAuthStatusJson(text), {
+		onNone: () => ({
+			parsed: false,
+			accounts: []
+		}),
+		onSome: (status) => ({
+			parsed: true,
+			accounts: Object.values(status.hosts).flatMap((accounts) => accounts.flatMap((account) => {
+				const host = nonEmptyString(account.host);
+				const login = nonEmptyString(account.login);
+				if (host === null || login === null) return [];
+				return [{
+					host: host.toLowerCase(),
+					account: login,
+					authenticated: account.state === "success",
+					active: account.active,
+					error: account.error?.trim() || null
+				}];
+			}))
+		})
+	});
+}
+function findAuthenticatedGitHubAccount(accounts) {
+	return accounts.find((account) => account.authenticated && account.active) ?? accounts.find((account) => account.authenticated);
+}
+//#endregion
+//#region src/sourceControl/gitLabAuthStatus.ts
+const HOST_LINE_PATTERN = /^(?:[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?|\[[a-f0-9:.]+\])(?::\d+)?$/iu;
+const LOGGED_IN_PATTERN = /Logged in to .+? as\s+([^\s(]+)/iu;
+function parseGitLabAuthStatusHosts(text) {
+	const hosts = [];
+	let currentHost = null;
+	let currentLines = [];
+	const flush = () => {
+		if (currentHost === null) return;
+		const account = LOGGED_IN_PATTERN.exec(currentLines.join("\n"))?.[1]?.trim() || null;
+		hosts.push({
+			host: currentHost,
+			account,
+			authenticated: account !== null
+		});
+		currentHost = null;
+		currentLines = [];
+	};
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		if (rawLine.length === rawLine.trimStart().length && HOST_LINE_PATTERN.test(line)) {
+			flush();
+			currentHost = line.toLowerCase();
+			continue;
+		}
+		if (currentHost !== null) currentLines.push(line);
+	}
+	flush();
+	return hosts;
+}
+function findAuthenticatedGitLabHost(hosts) {
+	return hosts.find((host) => host.authenticated);
+}
+//#endregion
+//#region src/sourceControl/SourceControlProviderDiscovery.ts
+function firstNonEmptyLine(text) {
+	const line = text.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry.length > 0);
+	return line === void 0 ? Option.none() : Option.some(line);
+}
+function detailFromCause(cause) {
+	if (cause instanceof Error && cause.message.trim().length > 0) return Option.some(cause.message.trim());
+	return Option.none();
+}
+function authAccount(account) {
+	const trimmed = account?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? Option.none() : Option.some(trimmed);
+}
+function authHost(host) {
+	const trimmed = host?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? Option.none() : Option.some(trimmed);
+}
+function authDetail(detail) {
+	const trimmed = detail?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? Option.none() : Option.some(trimmed);
+}
+function providerAuth(input) {
+	return {
+		status: input.status,
+		account: authAccount(input.account),
+		host: authHost(input.host),
+		detail: authDetail(input.detail)
+	};
+}
+function unknownAuth(detail) {
+	return providerAuth({
+		status: "unknown",
+		detail
+	});
+}
+function combinedAuthOutput(input) {
+	return [input.stdout, input.stderr].filter((entry) => entry.trim().length > 0).join("\n");
+}
+function sanitizedAuthLines(text) {
+	return text.split(/\r?\n/).map((entry) => entry.trim()).filter((entry) => entry.length > 0).filter((entry) => !/^[-\s]*token(?:\s+scopes?)?:/iu.test(entry));
+}
+function firstSafeAuthLine(text) {
+	return sanitizedAuthLines(text)[0];
+}
+function parseCliHost(text) {
+	return sanitizedAuthLines(text).map((line) => line.replace(/^[^a-z0-9]+/iu, "")).find((line) => /^[a-z0-9][a-z0-9.-]*(?::\d+)?$/iu.test(line));
+}
+function matchFirst(text, patterns) {
+	for (const pattern of patterns) {
+		const value = pattern.exec(text)?.[1]?.trim();
+		if (value && value.length > 0) return value;
+	}
+}
+function isCliRemoteRefinementSpec(spec) {
+	return spec.type === "cli" && spec.refineUnknownRemote !== void 0;
+}
+function probeCli(input) {
+	return input.process.run({
+		operation: "source-control.discovery.probe",
+		command: input.spec.executable,
+		args: input.spec.versionArgs,
+		cwd: input.cwd,
+		timeoutMs: 5e3,
+		maxOutputBytes: 8e3,
+		truncateOutputAtMaxBytes: true
+	}).pipe(Effect.map((result) => ({
+		kind: input.spec.kind,
+		label: input.spec.label,
+		executable: input.spec.executable,
+		status: "available",
+		version: Option.orElse(firstNonEmptyLine(result.stdout), () => firstNonEmptyLine(result.stderr)),
+		installHint: input.spec.installHint,
+		detail: Option.none()
+	})), Effect.catch((cause) => Effect.succeed({
+		kind: input.spec.kind,
+		label: input.spec.label,
+		executable: input.spec.executable,
+		status: "missing",
+		version: Option.none(),
+		installHint: input.spec.installHint,
+		detail: detailFromCause(cause)
+	})));
+}
+function probeSourceControlProvider(input) {
+	if (input.spec.type === "api") return input.spec.probeAuth.pipe(Effect.map((auth) => ({
+		kind: input.spec.kind,
+		label: input.spec.label,
+		status: "available",
+		version: Option.none(),
+		installHint: input.spec.installHint,
+		detail: Option.none(),
+		auth
+	})));
+	const spec = input.spec;
+	return probeCli({
+		spec,
+		process: input.process,
+		cwd: input.cwd
+	}).pipe(Effect.flatMap((item) => {
+		if (item.status !== "available") return Effect.succeed({
+			...item,
+			auth: unknownAuth("Hosting integration command was not found on the server PATH.")
+		});
+		return input.process.run({
+			operation: "source-control.discovery.auth",
+			command: spec.executable,
+			args: spec.authArgs,
+			cwd: input.cwd,
+			allowNonZeroExit: true,
+			timeoutMs: 5e3,
+			maxOutputBytes: 8e3,
+			truncateOutputAtMaxBytes: true
+		}).pipe(Effect.map((result) => ({
+			...item,
+			auth: spec.parseAuth(result)
+		})), Effect.catch((cause) => Effect.succeed({
+			...item,
+			auth: unknownAuth(Option.getOrUndefined(detailFromCause(cause)))
+		})));
+	}));
+}
+const refineUnknownRemoteProvider = Effect.fn("refineUnknownRemoteProvider")(function* (input) {
+	if (input.context === null || input.context.provider.kind !== "unknown") return input.context;
+	const context = input.context;
+	const provider = (yield* Effect.forEach(input.specs.filter(isCliRemoteRefinementSpec), (spec) => input.process.run({
+		operation: "source-control.discovery.refine-unknown-remote",
+		command: spec.executable,
+		args: spec.authArgs,
+		cwd: input.cwd,
+		allowNonZeroExit: true,
+		timeoutMs: 5e3,
+		maxOutputBytes: 8e3,
+		truncateOutputAtMaxBytes: true
+	}).pipe(Effect.map((auth) => spec.refineUnknownRemote({
+		cwd: input.cwd,
+		context,
+		auth
+	})), Effect.catch(() => Effect.succeed(null))))).find((candidate) => candidate !== null);
+	return provider ? {
+		...context,
+		provider
+	} : context;
+});
+//#endregion
+//#region src/sourceControl/SourceControlProviderDiscoveryCatalog.ts
+function parseGitHubAuth(input) {
+	const output = combinedAuthOutput(input);
+	const authStatus = parseGitHubAuthStatus(input.stdout);
+	const authenticatedAccount = findAuthenticatedGitHubAccount(authStatus.accounts);
+	const fallbackHost = parseCliHost(output);
+	if (authenticatedAccount) return providerAuth({
+		status: "authenticated",
+		account: authenticatedAccount.account,
+		host: authenticatedAccount.host
+	});
+	if (authStatus.parsed) {
+		const failedAccount = authStatus.accounts.find((account) => account.active) ?? authStatus.accounts[0];
+		return providerAuth({
+			status: "unauthenticated",
+			host: failedAccount?.host,
+			detail: failedAccount?.error ?? "Run `gh auth login` to authenticate GitHub CLI with an active account."
+		});
+	}
+	if (input.exitCode !== 0) return providerAuth({
+		status: "unauthenticated",
+		host: fallbackHost,
+		detail: firstSafeAuthLine(output) ?? "Run `gh auth login` to authenticate GitHub CLI."
+	});
+	const account = matchFirst(output, [/Logged in to .* account\s+([^\s(]+)/iu, /Logged in to .* as\s+([^\s(]+)/iu]);
+	if (account) return providerAuth({
+		status: "authenticated",
+		account,
+		host: fallbackHost
+	});
+	return providerAuth({
+		status: "unknown",
+		host: fallbackHost,
+		detail: firstSafeAuthLine(output) ?? "GitHub CLI auth status could not be parsed."
+	});
+}
+function parseGitLabAuth(input) {
+	const output = combinedAuthOutput(input);
+	const authenticatedHost = findAuthenticatedGitLabHost(parseGitLabAuthStatusHosts(output));
+	const account = authenticatedHost?.account ?? matchFirst(output, [
+		/Logged in to .* as\s+([^\s(]+)/iu,
+		/Logged in to .* account\s+([^\s(]+)/iu,
+		/account:\s*([^\s(]+)/iu
+	]);
+	const host = authenticatedHost?.host ?? parseCliHost(output);
+	if (account) return providerAuth({
+		status: "authenticated",
+		account,
+		host
+	});
+	if (input.exitCode !== 0) return providerAuth({
+		status: "unauthenticated",
+		host,
+		detail: firstSafeAuthLine(output) ?? "Run `glab auth login` to authenticate GitLab CLI."
+	});
+	return providerAuth({
+		status: "unknown",
+		host,
+		detail: firstSafeAuthLine(output) ?? "GitLab CLI auth status could not be parsed."
+	});
+}
+function normalizeAuthHost(value) {
+	const trimmed = value?.trim().toLowerCase() ?? "";
+	if (trimmed.length === 0) return null;
+	try {
+		return new URL(trimmed).host.toLowerCase();
+	} catch {
+		return trimmed.replace(/^https?:\/\//iu, "").replace(/\/.*$/u, "");
+	}
+}
+function gitLabProviderForHost(host) {
+	return {
+		kind: "gitlab",
+		name: host === "gitlab.com" ? "GitLab" : "GitLab Self-Hosted",
+		baseUrl: `https://${host}`
+	};
+}
+function refineUnknownGitLabRemote(input) {
+	const remoteHost = normalizeAuthHost(input.context.provider.baseUrl) ?? normalizeAuthHost(input.context.provider.name);
+	if (remoteHost === null) return null;
+	const authenticatedHost = parseGitLabAuthStatusHosts(combinedAuthOutput(input.auth)).find((host) => host.authenticated && host.host === remoteHost);
+	return authenticatedHost ? gitLabProviderForHost(authenticatedHost.host) : null;
+}
+function parseAzureAuth(input) {
+	const account = input.stdout.trim().split(/\r?\n/)[0]?.trim();
+	if (input.exitCode !== 0) return providerAuth({
+		status: "unauthenticated",
+		detail: firstSafeAuthLine(combinedAuthOutput(input)) ?? "Run `az login` to authenticate Azure CLI."
+	});
+	if (account && account.length > 0) return providerAuth({
+		status: "authenticated",
+		account,
+		host: "dev.azure.com"
+	});
+	return providerAuth({
+		status: "unknown",
+		host: "dev.azure.com",
+		detail: "Azure CLI account status could not be parsed."
+	});
+}
+const githubDiscovery = {
+	type: "cli",
+	kind: "github",
+	label: "GitHub",
+	executable: "gh",
+	versionArgs: ["--version"],
+	authArgs: [
+		"auth",
+		"status",
+		"--json",
+		"hosts"
+	],
+	parseAuth: parseGitHubAuth,
+	installHint: "Install the GitHub command-line tool (`gh`) via https://cli.github.com/ or your package manager (for example `brew install gh`)."
+};
+const gitlabDiscovery = {
+	type: "cli",
+	kind: "gitlab",
+	label: "GitLab",
+	executable: "glab",
+	versionArgs: ["--version"],
+	authArgs: ["auth", "status"],
+	parseAuth: parseGitLabAuth,
+	refineUnknownRemote: refineUnknownGitLabRemote,
+	installHint: "Install the GitLab command-line tool (`glab`) from https://gitlab.com/gitlab-org/cli or your package manager (for example `brew install glab`)."
+};
+const azureDevOpsDiscovery = {
+	type: "cli",
+	kind: "azure-devops",
+	label: "Azure DevOps",
+	executable: "az",
+	versionArgs: ["--version"],
+	authArgs: [
+		"account",
+		"show",
+		"--query",
+		"user.name",
+		"-o",
+		"tsv"
+	],
+	parseAuth: parseAzureAuth,
+	installHint: "Install the Azure command-line tools (`az`), then enable Azure DevOps support with `az extension add --name azure-devops`."
+};
+function makeBitbucketDiscovery(bitbucket) {
+	return {
+		type: "api",
+		kind: "bitbucket",
+		label: "Bitbucket",
+		installHint: "Set RYCO_BITBUCKET_EMAIL and RYCO_BITBUCKET_API_TOKEN on the server (use a Bitbucket API token with pull request and repository scopes).",
+		probeAuth: bitbucket.probeAuth
+	};
+}
+function makeForgejoDiscovery(forgejo) {
+	return {
+		type: "api",
+		kind: "forgejo",
+		label: "Forgejo",
+		installHint: "Authenticate with `fj auth login` on the server and verify with `fj -H codeberg.org whoami`, or set RYCO_FORGEJO_BASE_URL and RYCO_FORGEJO_TOKEN. For unusual fj installs, point Ryco at the token file with RYCO_FORGEJO_CLI_KEYS_FILE.",
+		probeAuth: forgejo.probeAuth
+	};
+}
+//#endregion
+export { formatSchemaError as _, makeForgejoDiscovery as a, probeSourceControlProvider as c, parseSourceControlOwnerRef as d, sourceBranch as f, decodeJsonResult as g, layer as h, makeBitbucketDiscovery as i, refineUnknownRemoteProvider as l, VcsProcess as m, githubDiscovery as n, detailFromCause as o, sourceControlRefFromInput as p, gitlabDiscovery as r, firstNonEmptyLine as s, azureDevOpsDiscovery as t, SourceControlProvider as u, fromLenientJson as v };