@ticatec/omniflow-github 1.0.0

package/src/artifacts/GitHubMavenPublisher.ts

@@ -0,0 +1,238 @@
+import { promises as fs } from 'fs'
+import path from 'path'
+import crypto from 'crypto'
+import { BasePublisher, resolveMavenArtifactFilenames, mavenPomPathFor, isMavenArtifactFile } from '@ticatec/omniflow-artifact'
+import type { ArtifactPayload, PublishOptions, RegistryConfig } from '@ticatec/omniflow-artifact'
+import { GitHubClient } from '../client/GitHubClient.js'
+
+/**
+ * GitHub Maven Package Registry Publisher.
+ *
+ * Endpoint format: PUT https://maven.pkg.github.com/<owner>/<repo>/{groupId}/{artifactId}/{version}/{filename}
+ */
+export class GitHubMavenPublisher extends BasePublisher {
+  readonly id = 'github-maven'
+  readonly name = 'GitHub Packages (Maven)'
+  readonly platform = 'github'
+  readonly artifactType = 'maven'
+  override readonly priority = 20
+
+  override detect(registry: RegistryConfig): boolean {
+    if (registry.type !== 'maven' && registry.type !== 'jar') {
+      return false
+    }
+
+    const regName = (registry.name || '').toLowerCase()
+    if (regName === 'github' || regName.startsWith('github-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      return parsed.hostname === 'maven.pkg.github.com' || GitHubClient.isGitHubHost(parsed.hostname)
+    } catch {
+      return false
+    }
+  }
+
+  override buildTargetRef(artifact: ArtifactPayload, _registry: RegistryConfig): string {
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : '1.0.0'
+    const artifactId = (artifact.metadata?.artifactId as string) || artifact.name
+    const groupId = (artifact.metadata?.groupId as string)?.trim()
+    return groupId ? `${groupId}:${artifactId}:${version}` : `${artifactId}:${version}`
+  }
+
+  protected resolveBaseRepoUrl(registry: RegistryConfig): string {
+    let repoPath = registry.namespace || ''
+    let server = registry.server || 'https://maven.pkg.github.com'
+    if (!/^https?:\/\//i.test(server)) {
+      server = `https://${server}`
+    }
+
+    if (server.includes('maven.pkg.github.com') && server.split('/').filter(Boolean).length >= 4) {
+      return server.replace(/\/+$/, '')
+    }
+
+    if (!repoPath) {
+      throw new Error(`GitHub Maven packages require repository namespace (<owner>/<repo>) to be configured.`)
+    }
+    return `https://maven.pkg.github.com/${repoPath.replace(/^\/+/, '').replace(/\/+$/, '')}`
+  }
+
+  override async exists(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    options?: PublishOptions
+  ): Promise<boolean> {
+    const creds = this.resolveCredentials(registry)
+    const token = creds.token || creds.password
+
+    let baseRepoUrl: string
+    try {
+      baseRepoUrl = this.resolveBaseRepoUrl(registry)
+    } catch {
+      return false
+    }
+
+    const client = new GitHubClient({
+      token,
+      timeoutMs: options?.timeoutMs
+    })
+
+    let jarPath = artifact.source
+    if (jarPath) {
+      const stat = await fs.stat(jarPath).catch(() => null)
+      if (stat?.isDirectory()) {
+        const files = await fs.readdir(jarPath).catch(() => [] as string[])
+        const jarFile = files.find(
+          f => isMavenArtifactFile(f)
+        )
+        if (jarFile) {
+          jarPath = path.join(jarPath, jarFile)
+        }
+      }
+    }
+
+    const { groupId, artifactId, version, groupPath, jarFilename } = resolveMavenArtifactFilenames(
+      artifact,
+      jarPath,
+      undefined,
+      'GitHub'
+    )
+
+    const probeUrl = `${baseRepoUrl}/${groupPath}/${artifactId}/${version}/${jarFilename}`
+
+    try {
+      const res = await client.request(probeUrl, { method: 'HEAD' })
+      if (res.ok || res.status === 200 || res.status === 204) {
+        return true
+      }
+      if (res.status === 404) {
+        return false
+      }
+      const errText = await client.extractErrorMessage(res)
+      throw new Error(`Failed to check artifact existence in GitHub Maven registry (${res.status}): ${errText}`)
+    } catch (err: any) {
+      if (err?.message?.includes('Failed to check artifact existence in GitHub')) {
+        throw err
+      }
+      throw new Error(
+        `Failed to check artifact existence in GitHub Maven registry: ${client.maskSecrets(err?.message || String(err))}`
+      )
+    }
+  }
+
+  async login(registry: RegistryConfig, _options?: PublishOptions): Promise<void> {
+    const creds = this.resolveCredentials(registry)
+    if (!creds.token && !creds.password) {
+      this.log(`  ℹ No auth token configured for GitHub Maven repository ${registry.server}`)
+    }
+  }
+
+  protected async doPublish(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    options?: PublishOptions
+  ): Promise<{
+    ref: string
+    digest?: string
+    metadata?: Record<string, unknown>
+  }> {
+    const creds = this.resolveCredentials(registry)
+    const token = creds.token || creds.password
+    const repoBaseUrl = this.resolveBaseRepoUrl(registry)
+
+    const client = new GitHubClient({
+      token,
+      timeoutMs: options?.timeoutMs
+    })
+
+    // Locate jar file
+    let jarPath = artifact.source
+    const stat = await fs.stat(jarPath).catch(() => null)
+    if (stat?.isDirectory()) {
+      const files = await fs.readdir(jarPath)
+      const jarFile = files.find(f => isMavenArtifactFile(f))
+      if (!jarFile) {
+        throw new Error(`No jar/war artifact found in directory: ${jarPath}`)
+      }
+      jarPath = path.join(jarPath, jarFile)
+    }
+
+    const { groupId, artifactId, version, groupPath, jarFilename, pomFilename } = resolveMavenArtifactFilenames(
+      artifact,
+      jarPath,
+      undefined,
+      'GitHub'
+    )
+
+    const jarBuffer = await fs.readFile(jarPath)
+    const digest = `sha256:${crypto.createHash('sha256').update(jarBuffer).digest('hex')}`
+
+    const targetUrl = `${repoBaseUrl}/${groupPath}/${artifactId}/${version}/${jarFilename}`
+    this.log(`  📤 Uploading Maven JAR to GitHub: ${targetUrl}`)
+
+    if (options?.dryRun) {
+      this.log(`  [dryRun] Would PUT ${jarFilename} (${jarBuffer.length} bytes) to ${targetUrl}`)
+      return {
+        ref: `${groupId}:${artifactId}:${version}`,
+        digest,
+        metadata: { targetUrl, size: jarBuffer.length }
+      }
+    }
+
+    // The POM goes up first, deliberately.
+    //
+    // The existence probe checks for the jar/war, so uploading that last is what
+    // makes the probe mean "this artifact is complete". With the artifact first, a
+    // run that uploaded it and then failed on the POM would leave a coordinate that
+    // probes as present: the retry skips it as already published, and the POM never
+    // arrives — a jar in the repository forever, with no dependency information.
+    // Upload pom if exists
+    const pomPath = mavenPomPathFor(jarPath)
+    const pomStat = await fs.stat(pomPath).catch(() => null)
+    if (pomStat?.isFile()) {
+      const pomBuffer = await fs.readFile(pomPath)
+      const targetPomFilename = pomFilename || `${artifactId}-${version}.pom`
+      const pomTargetUrl = `${repoBaseUrl}/${groupPath}/${artifactId}/${version}/${targetPomFilename}`
+      this.log(`  📤 Uploading Maven POM to GitHub: ${pomTargetUrl}`)
+
+      const pomRes = await client.request(pomTargetUrl, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/xml' },
+        body: pomBuffer
+      })
+
+      if (!pomRes.ok && pomRes.status !== 201 && pomRes.status !== 200) {
+        const pomErr = await client.extractErrorMessage(pomRes)
+        throw new Error(`Failed to upload Maven POM to GitHub (${pomRes.status}): ${pomErr}`)
+      }
+    }
+
+    const res = await client.request(targetUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/java-archive'
+      },
+      body: jarBuffer
+    })
+
+    if (!res.ok && res.status !== 201 && res.status !== 200) {
+      const errText = await client.extractErrorMessage(res)
+      throw new Error(`Failed to upload Maven JAR to GitHub (${res.status}): ${errText}`)
+    }
+
+    return {
+      ref: `${groupId}:${artifactId}:${version}`,
+      digest,
+      metadata: {
+        groupId,
+        artifactId,
+        version,
+        targetUrl,
+        size: jarBuffer.length
+      }
+    }
+  }
+}

package/src/artifacts/GitHubNpmPublisher.ts

@@ -0,0 +1,66 @@
+import { BaseNpmPublisher } from '@ticatec/omniflow-artifact'
+import type { ArtifactPayload, PublishOptions, RegistryConfig } from '@ticatec/omniflow-artifact'
+import { GitHubClient } from '../client/GitHubClient.js'
+
+/**
+ * GitHub NPM Package Registry Publisher.
+ *
+ * Endpoint format: https://npm.pkg.github.com/
+ * GitHub requires npm packages to be scoped, e.g. @owner/package-name.
+ */
+export class GitHubNpmPublisher extends BaseNpmPublisher {
+  readonly id = 'github-npm'
+  readonly name = 'GitHub Packages (NPM)'
+  readonly platform = 'github'
+  override readonly priority = 20
+
+  override detect(registry: RegistryConfig): boolean {
+    if (registry.type !== 'npm') {
+      return false
+    }
+
+    const regName = (registry.name || '').toLowerCase()
+    if (regName === 'github' || regName.startsWith('github-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      const host = parsed.hostname.toLowerCase()
+      return host === 'npm.pkg.github.com' || GitHubClient.isGitHubHost(host)
+    } catch {
+      return false
+    }
+  }
+
+  override normalizeRegistryUrl(server: string, _namespace?: string): string {
+    let url = (server || '').trim()
+    if (!url || url === 'github') {
+      return 'https://npm.pkg.github.com/'
+    }
+
+    if (!/^https?:\/\//i.test(url)) {
+      url = `https://${url}`
+    }
+
+    return url.endsWith('/') ? url : `${url}/`
+  }
+
+  protected override async doPublish(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    options?: PublishOptions
+  ): Promise<{
+    ref: string
+    metadata?: Record<string, unknown>
+  }> {
+    if (!artifact.name.startsWith('@')) {
+      this.log(
+        `  ⚠ Notice: Package "${artifact.name}" is not scoped. GitHub Packages requires scoped package names (e.g. @owner/repo).`
+      )
+    }
+
+    return super.doPublish(artifact, registry, options)
+  }
+}

package/src/artifacts/GitHubReleasePublisher.ts

@@ -0,0 +1,238 @@
+import { promises as fs } from 'fs'
+import path from 'path'
+import crypto from 'crypto'
+import { BasePublisher } from '@ticatec/omniflow-artifact'
+import type { ArtifactPayload, DownloadOptions, DownloadResult, PublishOptions, RegistryConfig } from '@ticatec/omniflow-artifact'
+import { GitHubClient } from '../client/GitHubClient.js'
+
+/**
+ * GitHub Releases (Generic Artifact / Asset) Publisher.
+ *
+ * Publishes arbitrary binary artifacts, distribution tarballs (.tar.gz),
+ * or zip files to GitHub Releases under the specified version tag.
+ */
+export class GitHubReleasePublisher extends BasePublisher {
+  readonly id = 'github-release'
+  readonly name = 'GitHub Releases'
+  readonly platform = 'github'
+  readonly artifactType = 'generic'
+  override readonly priority = 20
+
+  override detect(registry: RegistryConfig): boolean {
+    if (registry.type !== 'generic' && registry.type !== 'archive' && registry.type !== 'release') {
+      return false
+    }
+
+    const regName = (registry.name || '').toLowerCase()
+    if (regName === 'github' || regName === 'github-release' || regName.startsWith('github-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      return GitHubClient.isGitHubHost(parsed.hostname)
+    } catch {
+      return false
+    }
+  }
+
+  override buildTargetRef(artifact: ArtifactPayload, registry: RegistryConfig): string {
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : 'v1.0.0'
+    const tagName = version.startsWith('v') || /^\d/.test(version) ? version : `v${version}`
+    const filename = artifact.source ? path.basename(artifact.source) : artifact.name
+
+    try {
+      const { owner, repo } = this.resolveOwnerRepo(registry)
+      return `${owner}/${repo}@${tagName}#${filename}`
+    } catch {
+      return `${artifact.name}@${tagName}#${filename}`
+    }
+  }
+
+  protected resolveOwnerRepo(registry: RegistryConfig): { owner: string; repo: string } {
+    let namespace = registry.namespace || ''
+    let owner = ''
+    let repo = ''
+
+    if (namespace.includes('/')) {
+      const parts = namespace.split('/')
+      owner = parts[0]
+      repo = parts[1]
+    } else if (registry.server && registry.server.includes('/')) {
+      try {
+        const parsed = GitHubClient.parseRepo(registry.server)
+        owner = parsed.owner
+        repo = parsed.repo
+      } catch {
+        // fall through
+      }
+    }
+
+    if (!owner || !repo) {
+      throw new Error(
+        `GitHub Releases publisher requires repository namespace in "owner/repo" format (got "${registry.namespace || registry.server}").`
+      )
+    }
+
+    return { owner, repo }
+  }
+
+  override async exists(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    options?: PublishOptions
+  ): Promise<boolean> {
+    const creds = this.resolveCredentials(registry)
+    const token = creds.token || creds.password
+
+    let owner = ''
+    let repo = ''
+    try {
+      const resolved = this.resolveOwnerRepo(registry)
+      owner = resolved.owner
+      repo = resolved.repo
+    } catch {
+      return false
+    }
+
+    const client = new GitHubClient({
+      baseUrl: registry.server && registry.server.startsWith('http') ? registry.server : undefined,
+      token,
+      timeoutMs: options?.timeoutMs
+    })
+
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : 'v1.0.0'
+    const tagName = version.startsWith('v') || /^\d/.test(version) ? version : `v${version}`
+    const filename = artifact.source ? path.basename(artifact.source) : artifact.name
+
+    try {
+      const release = await client.getReleaseByTag(owner, repo, tagName)
+      if (!release) {
+        return false
+      }
+      return Boolean(release.assets?.some(a => a.name === filename))
+    } catch (err: any) {
+      throw new Error(
+        `Failed to check artifact existence in GitHub Releases: ${client.maskSecrets(err?.message || String(err))}`
+      )
+    }
+  }
+
+  override async download(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    dest: string,
+    options?: DownloadOptions
+  ): Promise<DownloadResult> {
+    const creds = this.resolveCredentials(registry)
+    const { owner, repo } = this.resolveOwnerRepo(registry)
+    const client = new GitHubClient({
+      baseUrl: registry.server && registry.server.startsWith('http') ? registry.server : undefined,
+      token: creds.token || creds.password,
+      timeoutMs: options?.timeoutMs
+    })
+
+    const version = artifact.tags?.[0] || 'v1.0.0'
+    const tagName = version.startsWith('v') || /^\d/.test(version) ? version : `v${version}`
+    const filename = artifact.source ? path.basename(artifact.source) : artifact.name
+    const what = `${artifact.name} ${version} (${filename})`
+
+    const release = await client.getReleaseByTag(owner, repo, tagName)
+    const asset = release?.assets?.find(a => a.name === filename)
+    if (!asset) {
+      throw new Error(`${what} not found in GitHub release ${owner}/${repo}@${tagName}`)
+    }
+
+    // The asset API answers with a redirect to storage when asked for octet-stream
+    const assetUrl = client.getRepoApiUrl(owner, repo, `/releases/assets/${asset.id}`)
+    this.log(`  📥 Downloading ${what} from GitHub release ${owner}/${repo}@${tagName}`)
+    const res = await client.request(assetUrl, { headers: { Accept: 'application/octet-stream' } })
+    if (!res.ok) {
+      throw await this.downloadError(res, what, assetUrl)
+    }
+    return this.saveResponse(res, dest, assetUrl)
+  }
+
+  async login(registry: RegistryConfig, _options?: PublishOptions): Promise<void> {
+    const creds = this.resolveCredentials(registry)
+    if (!creds.token && !creds.password) {
+      this.log(`  ℹ No auth token configured for GitHub Releases ${registry.server}`)
+    }
+  }
+
+  protected async doPublish(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    options?: PublishOptions
+  ): Promise<{
+    ref: string
+    digest?: string
+    metadata?: Record<string, unknown>
+  }> {
+    const creds = this.resolveCredentials(registry)
+    const token = creds.token || creds.password
+    const { owner, repo } = this.resolveOwnerRepo(registry)
+
+    const client = new GitHubClient({
+      baseUrl: registry.server && registry.server.startsWith('http') ? registry.server : undefined,
+      token,
+      timeoutMs: options?.timeoutMs
+    })
+
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : 'v1.0.0'
+    const tagName = version.startsWith('v') || /^\d/.test(version) ? version : `v${version}`
+
+    let filePath = artifact.source
+    const stat = await fs.stat(filePath).catch(() => null)
+    if (!stat || !stat.isFile()) {
+      throw new Error(`GitHub Release asset source must be an existing file: ${filePath}`)
+    }
+
+    const filename = path.basename(filePath)
+    const fileBuffer = await fs.readFile(filePath)
+    const digest = `sha256:${crypto.createHash('sha256').update(fileBuffer).digest('hex')}`
+
+    this.log(`  📤 Uploading release asset "${filename}" to GitHub ${owner}/${repo} release ${tagName}...`)
+
+    if (options?.dryRun) {
+      this.log(`  [dryRun] Would upload asset ${filename} (${fileBuffer.length} bytes) to GitHub release ${tagName}`)
+      return {
+        ref: `${owner}/${repo}@${tagName}#${filename}`,
+        digest,
+        metadata: { owner, repo, tagName, filename, size: fileBuffer.length }
+      }
+    }
+
+    // Get or create release
+    let release = await client.getReleaseByTag(owner, repo, tagName)
+    if (!release) {
+      this.log(`  ✨ Creating new GitHub release ${tagName} in ${owner}/${repo}...`)
+      release = await client.createRelease(owner, repo, {
+        tagName,
+        name: artifact.name || tagName,
+        body: `Release ${tagName} published via OmniFlow.`
+      })
+    }
+
+    const uploaded = await client.uploadReleaseAsset(release.upload_url, filename, fileBuffer)
+
+    return {
+      ref: `${owner}/${repo}@${tagName}#${filename}`,
+      digest,
+      metadata: {
+        owner,
+        repo,
+        tagName,
+        filename,
+        assetId: uploaded.id,
+        downloadUrl: uploaded.browser_download_url,
+        releaseUrl: release.html_url,
+        size: fileBuffer.length
+      }
+    }
+  }
+}
+
+// Convenient alias
+export { GitHubReleasePublisher as GitHubGenericPublisher }