@garthub/gart-npm 0.1.1

package/src/publish-artifacts.js

@@ -0,0 +1,275 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+	parseSkillCoordinates,
+	buildMavenRelativeArtifactPath,
+	buildMavenRelativePomPath,
+	buildMavenArtifactUrl,
+	buildMavenPomUrl,
+	buildRepositoryHeaders,
+} = require('./maven');
+const {buildSkillsArchive, readProjectInfo} = require('./build-resources');
+const {computeFileSha256} = require('./hash');
+const {uploadFile} = require('./http');
+
+async function publishSkillsPackage(
+	config,
+	options = {},
+) {
+	const repository = config.publishing.repository;
+
+	if (!repository) {
+		throw new Error('Publishing repository is not configured.');
+	}
+
+	if (!['maven', 'mavenLocal'].includes(repository.type)) {
+		throw new Error(`Publishing repository type is not supported for skills: ${repository.type}.`);
+	}
+
+	const coordinates = resolvePublishingCoordinates(config);
+	const build = buildSkillsArchive(config, {archiver: options.archiver});
+	const pomContent = renderPom(coordinates, config.resolution.dependencies.exposedSkills);
+	const publishDirectory = path.join(config.buildDir, 'publish');
+	const publishManifestPath = path.join(config.buildDir, 'publish.json');
+	const localPomPath = path.join(publishDirectory, `${coordinates.artifactId}-${coordinates.version}.pom`);
+	const artifactRelativePath = buildMavenRelativeArtifactPath(coordinates);
+	const pomRelativePath = buildMavenRelativePomPath(coordinates);
+
+	fs.mkdirSync(publishDirectory, {recursive: true});
+	fs.writeFileSync(localPomPath, pomContent);
+	const pomSha256 = computeFileSha256(localPomPath);
+
+	let publication;
+
+	if (repository.type === 'mavenLocal') {
+		publication = publishToMavenLocal(
+			repository,
+			build.archivePath,
+			build.archiveSha256,
+			localPomPath,
+			pomSha256,
+			artifactRelativePath,
+			pomRelativePath,
+		);
+	} else {
+		publication = await publishToMavenRepository(
+			repository,
+			coordinates,
+			build.archivePath,
+			build.archiveSha256,
+			localPomPath,
+			pomSha256,
+		);
+	}
+
+	const manifest = {
+		version: 1,
+		generatedAt: new Date().toISOString(),
+		coordinates: coordinates.coordinates,
+		repository: {
+			id: repository.id,
+			type: repository.type,
+			url: repository.url || null,
+			rootDir: repository.rootDir || null,
+		},
+		archivePath: build.archivePath,
+		archiveSha256: build.archiveSha256,
+		localPomPath,
+		pomSha256,
+		publishedArtifact: publication.publishedArtifact,
+		publishedPom: publication.publishedPom,
+		exposedSkills: config.resolution.dependencies.exposedSkills,
+		buildManifestPath: build.manifestPath,
+	};
+
+	fs.writeFileSync(publishManifestPath, JSON.stringify(manifest, null, 2));
+
+	return {
+		coordinates,
+		build,
+		localPomPath,
+		pomSha256,
+		publishManifestPath,
+		...publication,
+	};
+}
+
+function resolvePublishingCoordinates(config) {
+	if (config.publishing.coordinates) {
+		return parseSkillCoordinates(config.publishing.coordinates);
+	}
+
+	const projectInfo = readProjectInfo(config.cwd);
+	const groupId = config.publishing.groupId;
+	const artifactId = config.publishing.artifactId || projectInfo.artifactId;
+	const version = config.publishing.version || projectInfo.version;
+
+	if (!groupId || !artifactId || !version) {
+		throw new Error(
+			'Publishing coordinates are not fully configured. Define publishing.coordinates or publishing.groupId plus artifactId/version.',
+		);
+	}
+
+	return parseSkillCoordinates(`${groupId}:${artifactId}:${version}`);
+}
+
+function renderPom(
+	coordinates,
+	exposedSkills,
+) {
+	const dependencies = exposedSkills.map((dependencyCoordinates) => parseSkillCoordinates(dependencyCoordinates));
+	const dependencyXml = dependencies.length === 0
+		? ''
+		: [
+			'  <dependencies>',
+			...dependencies.flatMap((dependency) => [
+				'    <dependency>',
+				`      <groupId>${escapeXml(dependency.groupId)}</groupId>`,
+				`      <artifactId>${escapeXml(dependency.artifactId)}</artifactId>`,
+				`      <version>${escapeXml(dependency.version)}</version>`,
+				'      <classifier>skills</classifier>',
+				'      <type>zip</type>',
+				'    </dependency>',
+			]),
+			'  </dependencies>',
+		].join('\n');
+
+	return [
+		'<?xml version="1.0" encoding="UTF-8"?>',
+		'<project>',
+		'  <modelVersion>4.0.0</modelVersion>',
+		`  <groupId>${escapeXml(coordinates.groupId)}</groupId>`,
+		`  <artifactId>${escapeXml(coordinates.artifactId)}</artifactId>`,
+		`  <version>${escapeXml(coordinates.version)}</version>`,
+		'  <packaging>zip</packaging>',
+		dependencyXml,
+		'</project>',
+	].filter(Boolean).join('\n');
+}
+
+function publishToMavenLocal(
+	repository,
+	archivePath,
+	archiveSha256,
+	localPomPath,
+	pomSha256,
+	artifactRelativePath,
+	pomRelativePath,
+) {
+	const publishedArtifactPath = path.join(repository.rootDir, ...artifactRelativePath.split('/'));
+	const publishedPomPath = path.join(repository.rootDir, ...pomRelativePath.split('/'));
+
+	fs.mkdirSync(path.dirname(publishedArtifactPath), {recursive: true});
+	fs.mkdirSync(path.dirname(publishedPomPath), {recursive: true});
+	fs.copyFileSync(archivePath, publishedArtifactPath);
+	fs.copyFileSync(localPomPath, publishedPomPath);
+	verifyPublishedFileChecksum(publishedArtifactPath, archiveSha256, 'artifact');
+	verifyPublishedFileChecksum(publishedPomPath, pomSha256, 'pom');
+
+	return {
+		publishedArtifact: {
+			location: publishedArtifactPath,
+			relativePath: artifactRelativePath,
+			sha256: archiveSha256,
+		},
+		publishedPom: {
+			location: publishedPomPath,
+			relativePath: pomRelativePath,
+			sha256: pomSha256,
+		},
+	};
+}
+
+async function publishToMavenRepository(
+	repository,
+	coordinates,
+	archivePath,
+	archiveSha256,
+	localPomPath,
+	pomSha256,
+) {
+	const headers = buildRepositoryHeaders(repository);
+	const artifactUrl = buildMavenArtifactUrl(repository, coordinates);
+	const pomUrl = buildMavenPomUrl(repository, coordinates);
+
+	const artifactUpload = await uploadFile(artifactUrl, archivePath, {
+		headers: {
+			'Content-Type': 'application/zip',
+			...headers,
+		},
+	});
+
+	if (!artifactUpload.ok) {
+		throw new Error(formatUploadFailure('artifact', artifactUrl, artifactUpload));
+	}
+
+	const pomUpload = await uploadFile(pomUrl, localPomPath, {
+		headers: {
+			'Content-Type': 'application/xml',
+			...headers,
+		},
+	});
+
+	if (!pomUpload.ok) {
+		throw new Error(formatUploadFailure('pom', pomUrl, pomUpload));
+	}
+
+	return {
+		publishedArtifact: {
+			location: artifactUrl,
+			relativePath: buildMavenRelativeArtifactPath(coordinates),
+			statusCode: artifactUpload.statusCode,
+			sha256: archiveSha256,
+		},
+		publishedPom: {
+			location: pomUrl,
+			relativePath: buildMavenRelativePomPath(coordinates),
+			statusCode: pomUpload.statusCode,
+			sha256: pomSha256,
+		},
+	};
+}
+
+function verifyPublishedFileChecksum(
+	filePath,
+	expectedSha256,
+	kind,
+) {
+	if (!expectedSha256) {
+		return;
+	}
+
+	const actualSha256 = computeFileSha256(filePath);
+	if (actualSha256 !== expectedSha256) {
+		throw new Error(
+			`Published ${kind} checksum mismatch at ${filePath}. Expected ${expectedSha256} but found ${actualSha256}.`,
+		);
+	}
+}
+
+function formatUploadFailure(
+	phase,
+	location,
+	outcome,
+) {
+	const body = outcome.body ? outcome.body.trim() : '';
+	const detail = body ? ` ${body}` : '';
+	return `Failed to publish ${phase} to ${location}: HTTP ${outcome.statusCode}.${detail}`.trim();
+}
+
+function escapeXml(value) {
+	return String(value)
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&apos;');
+}
+
+module.exports = {
+	publishSkillsPackage,
+	resolvePublishingCoordinates,
+	renderPom,
+	formatUploadFailure,
+	verifyPublishedFileChecksum,
+};

package/src/resolve-artifacts.js

@@ -0,0 +1,417 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+	parseSkillCoordinates,
+	buildMavenRelativeArtifactPath,
+	buildMavenRelativePomPath,
+	buildMavenArtifactUrl,
+	buildMavenPomUrl,
+	buildRepositoryHeaders,
+} = require('./maven');
+const {downloadToFile} = require('./http');
+const {parseTransitiveSkillDependenciesFromPom} = require('./pom');
+
+function collectDependencyEntries(config) {
+	return [
+		...config.resolution.dependencies.skills.map((coordinates) => ({
+			kind: 'skill',
+			coordinates,
+		})),
+		...config.resolution.dependencies.exposedSkills.map((coordinates) => ({
+			kind: 'exposedSkill',
+			coordinates,
+		})),
+	];
+}
+
+async function resolveSkillArtifacts(config) {
+	const directDependencies = collectDependencyEntries(config);
+	const directCoordinates = new Set(directDependencies.map((dependency) => dependency.coordinates));
+	const resolvedArtifacts = [];
+	const unresolved = [];
+	const transitiveDependencies = [];
+	const queue = [...directDependencies];
+	const visited = new Set();
+
+	while (queue.length > 0) {
+		const dependency = queue.shift();
+
+		if (visited.has(dependency.coordinates)) {
+			continue;
+		}
+
+		visited.add(dependency.coordinates);
+		const outcome = await resolveSingleDependency(dependency, config);
+
+		if (outcome.resolvedArtifact) {
+			resolvedArtifacts.push(outcome.resolvedArtifact);
+
+			for (const transitiveDependency of outcome.resolvedArtifact.transitiveDependencies) {
+				const nextDependency = {
+					kind: 'transitiveSkill',
+					coordinates: transitiveDependency.coordinates,
+					parentCoordinates: dependency.coordinates,
+					depth: (dependency.depth || 0) + 1,
+				};
+
+				transitiveDependencies.push(nextDependency);
+				queue.push(nextDependency);
+			}
+		} else {
+			unresolved.push(outcome.unresolved);
+		}
+	}
+
+	return {
+		dependencies: directDependencies,
+		directDependencies,
+		transitiveDependencies: deduplicateDependencies(transitiveDependencies)
+			.filter((dependency) => !directCoordinates.has(dependency.coordinates)),
+		resolvedArtifacts,
+		unresolved,
+	};
+}
+
+async function resolveSingleDependency(
+	dependency,
+	config,
+) {
+	const repositories = config.resolution.repositories;
+	const parsedCoordinates = parseSkillCoordinates(dependency.coordinates);
+	const attempts = [];
+
+	if (repositories.length === 0) {
+		return {
+			unresolved: {
+				dependency,
+				parsedCoordinates,
+				attempts,
+				reason: 'No repositories configured for skill resolution.',
+			},
+		};
+	}
+
+	for (const repository of repositories) {
+		if (repository.type === 'mavenLocal') {
+			const artifactPath = path.join(repository.rootDir, ...buildMavenRelativeArtifactPath(parsedCoordinates).split('/'));
+			const found = fs.existsSync(artifactPath);
+
+			attempts.push({
+				repositoryId: repository.id,
+				repositoryType: repository.type,
+				phase: 'artifact',
+				location: artifactPath,
+				found,
+			});
+
+			if (found) {
+				const pomDescriptor = resolvePomDescriptorForArtifact(
+					config,
+					repository,
+					parsedCoordinates,
+					attempts,
+				);
+
+				if (!pomDescriptor.ok) {
+					return {
+						unresolved: {
+							dependency,
+							parsedCoordinates,
+							attempts,
+							reason: buildUnresolvedReason(attempts),
+						},
+					};
+				}
+
+				return {
+					resolvedArtifact: {
+						dependency,
+						parsedCoordinates,
+						repositoryId: repository.id,
+						repositoryType: repository.type,
+						relativeArtifactPath: buildMavenRelativeArtifactPath(parsedCoordinates),
+						artifactPath,
+						source: 'local',
+						pomPath: pomDescriptor.pomPath,
+						pomSource: pomDescriptor.source,
+						transitiveDependencies: pomDescriptor.dependencies,
+					},
+				};
+			}
+
+			continue;
+		}
+
+		if (repository.type === 'maven') {
+			const artifactUrl = buildMavenArtifactUrl(repository, parsedCoordinates);
+			const cachePath = path.join(config.cacheDir, repository.id, ...buildMavenRelativeArtifactPath(parsedCoordinates).split('/'));
+
+			if (fs.existsSync(cachePath)) {
+				attempts.push({
+					repositoryId: repository.id,
+					repositoryType: repository.type,
+					phase: 'artifact',
+					location: artifactUrl,
+					found: true,
+					source: 'cache',
+				});
+
+				const pomDescriptor = await resolveRemotePomDescriptorForArtifact(
+					config,
+					repository,
+					parsedCoordinates,
+					attempts,
+				);
+
+				if (!pomDescriptor.ok) {
+					return {
+						unresolved: {
+							dependency,
+							parsedCoordinates,
+							attempts,
+							reason: buildUnresolvedReason(attempts),
+						},
+					};
+				}
+
+				return {
+					resolvedArtifact: {
+						dependency,
+						parsedCoordinates,
+						repositoryId: repository.id,
+						repositoryType: repository.type,
+						relativeArtifactPath: buildMavenRelativeArtifactPath(parsedCoordinates),
+						artifactPath: cachePath,
+						source: 'cache',
+						sourceUrl: artifactUrl,
+						pomPath: pomDescriptor.pomPath,
+						pomSource: pomDescriptor.source,
+						transitiveDependencies: pomDescriptor.dependencies,
+					},
+				};
+			}
+
+			try {
+				const download = await downloadToFile(artifactUrl, cachePath, {
+					headers: buildRepositoryHeaders(repository),
+				});
+
+				attempts.push({
+					repositoryId: repository.id,
+					repositoryType: repository.type,
+					phase: 'artifact',
+					location: artifactUrl,
+					found: download.ok,
+					statusCode: download.statusCode,
+					source: download.ok ? 'remote' : 'remote-miss',
+				});
+
+				if (download.ok) {
+					const pomDescriptor = await resolveRemotePomDescriptorForArtifact(
+						config,
+						repository,
+						parsedCoordinates,
+						attempts,
+					);
+
+					if (!pomDescriptor.ok) {
+						return {
+							unresolved: {
+								dependency,
+								parsedCoordinates,
+								attempts,
+								reason: buildUnresolvedReason(attempts),
+							},
+						};
+					}
+
+					return {
+						resolvedArtifact: {
+							dependency,
+							parsedCoordinates,
+							repositoryId: repository.id,
+							repositoryType: repository.type,
+							relativeArtifactPath: buildMavenRelativeArtifactPath(parsedCoordinates),
+							artifactPath: cachePath,
+							source: 'remote',
+							sourceUrl: artifactUrl,
+							pomPath: pomDescriptor.pomPath,
+							pomSource: pomDescriptor.source,
+							transitiveDependencies: pomDescriptor.dependencies,
+						},
+					};
+				}
+			} catch (error) {
+				attempts.push({
+					repositoryId: repository.id,
+					repositoryType: repository.type,
+					phase: 'artifact',
+					location: artifactUrl,
+					found: false,
+					error: error.message,
+				});
+			}
+		}
+	}
+
+	return {
+		unresolved: {
+			dependency,
+			parsedCoordinates,
+			attempts,
+			reason: buildUnresolvedReason(attempts),
+		},
+	};
+}
+
+function buildUnresolvedReason(attempts) {
+	const remoteAttemptsWithStatus = attempts.filter((attempt) => (
+		attempt.repositoryType === 'maven' &&
+		typeof attempt.statusCode === 'number' &&
+		attempt.found === false
+	));
+
+	if (remoteAttemptsWithStatus.length > 0) {
+		const statuses = [...new Set(remoteAttemptsWithStatus.map((attempt) => attempt.statusCode))];
+
+		if (statuses.length === 1) {
+			return `Skill artifact request failed with HTTP ${statuses[0]}.`;
+		}
+
+		return `Skill artifact requests failed with HTTP statuses: ${statuses.join(', ')}.`;
+	}
+
+	const remoteAttemptsWithErrors = attempts.filter((attempt) => (
+		attempt.repositoryType === 'maven' &&
+		attempt.error
+	));
+
+	if (remoteAttemptsWithErrors.length > 0) {
+		return `Skill artifact request failed: ${remoteAttemptsWithErrors[0].error}`;
+	}
+
+	return 'Skill artifact was not found in the configured repositories.';
+}
+
+function resolvePomDescriptorForArtifact(
+	config,
+	repository,
+	parsedCoordinates,
+	attempts,
+) {
+	const pomPath = path.join(repository.rootDir, ...buildMavenRelativePomPath(parsedCoordinates).split('/'));
+	const found = fs.existsSync(pomPath);
+
+	attempts.push({
+		repositoryId: repository.id,
+		repositoryType: repository.type,
+		phase: 'pom',
+		location: pomPath,
+		found,
+	});
+
+	if (!found) {
+		return {ok: false};
+	}
+
+	return {
+		ok: true,
+		pomPath,
+		source: 'local',
+		dependencies: parsePomDependencies(pomPath),
+	};
+}
+
+async function resolveRemotePomDescriptorForArtifact(
+	config,
+	repository,
+	parsedCoordinates,
+	attempts,
+) {
+	const pomUrl = buildMavenPomUrl(repository, parsedCoordinates);
+	const pomCachePath = path.join(config.cacheDir, repository.id, ...buildMavenRelativePomPath(parsedCoordinates).split('/'));
+
+	if (fs.existsSync(pomCachePath)) {
+		attempts.push({
+			repositoryId: repository.id,
+			repositoryType: repository.type,
+			phase: 'pom',
+			location: pomUrl,
+			found: true,
+			source: 'cache',
+		});
+
+		return {
+			ok: true,
+			pomPath: pomCachePath,
+			source: 'cache',
+			dependencies: parsePomDependencies(pomCachePath),
+		};
+	}
+
+	try {
+		const download = await downloadToFile(pomUrl, pomCachePath, {
+			headers: buildRepositoryHeaders(repository),
+		});
+
+		attempts.push({
+			repositoryId: repository.id,
+			repositoryType: repository.type,
+			phase: 'pom',
+			location: pomUrl,
+			found: download.ok,
+			statusCode: download.statusCode,
+			source: download.ok ? 'remote' : 'remote-miss',
+		});
+
+		if (!download.ok) {
+			return {ok: false};
+		}
+
+		return {
+			ok: true,
+			pomPath: pomCachePath,
+			source: 'remote',
+			dependencies: parsePomDependencies(pomCachePath),
+		};
+	} catch (error) {
+		attempts.push({
+			repositoryId: repository.id,
+			repositoryType: repository.type,
+			phase: 'pom',
+			location: pomUrl,
+			found: false,
+			error: error.message,
+		});
+
+		return {ok: false};
+	}
+}
+
+function parsePomDependencies(pomPath) {
+	return parseTransitiveSkillDependenciesFromPom(fs.readFileSync(pomPath, 'utf8'));
+}
+
+function deduplicateDependencies(dependencies) {
+	const seen = new Set();
+	const uniqueDependencies = [];
+
+	for (const dependency of dependencies) {
+		if (seen.has(dependency.coordinates)) {
+			continue;
+		}
+
+		seen.add(dependency.coordinates);
+		uniqueDependencies.push(dependency);
+	}
+
+	return uniqueDependencies;
+}
+
+module.exports = {
+	collectDependencyEntries,
+	resolveSkillArtifacts,
+	buildRepositoryHeaders,
+	buildUnresolvedReason,
+	deduplicateDependencies,
+};

package/src/runtime.js

@@ -0,0 +1,20 @@
+function resolveExecutionCwd(
+	commandName,
+	args,
+	environment,
+	defaultCwd,
+) {
+	if (
+		commandName === 'resolve' &&
+		args.includes('--postinstall') &&
+		environment.INIT_CWD
+	) {
+		return environment.INIT_CWD;
+	}
+
+	return defaultCwd;
+}
+
+module.exports = {
+	resolveExecutionCwd,
+};