@ticatec/omniflow-gitlab 1.0.0

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@ticatec/omniflow-gitlab",
+  "version": "1.0.0",
+  "description": "All-in-one GitLab artifact provider for OmniFlow: Container Registry, NPM, Maven, and Generic package registries",
+  "homepage": "https://github.com/ticatec/omniflow#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ticatec/omniflow.git",
+    "directory": "omniflow-gitlab"
+  },
+  "bugs": {
+    "url": "https://github.com/ticatec/omniflow/issues"
+  },
+  "author": "Henry Feng <huili.f@gmail.com>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@ticatec/omniflow-artifact": "^1.0.0",
+    "@ticatec/omniflow-core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.4.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.10.2",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.9",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "README_CN.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "typecheck": "tsc --noEmit",
+    "publish:npm": "pnpm publish --access public --no-git-checks"
+  }
+}

package/src/artifacts/GitLabContainerPublisher.ts

@@ -0,0 +1,50 @@
+import { BaseDockerPublisher } from '@ticatec/omniflow-artifact'
+import type { RegistryConfig } from '@ticatec/omniflow-artifact'
+import { isGitLabHost } from '../client/GitLabClient.js'
+
+/**
+ * GitLab Container Registry Publisher.
+ *
+ * Supports both gitlab.com Container Registry (registry.gitlab.com)
+ * and self-hosted GitLab container registries.
+ */
+export class GitLabContainerPublisher extends BaseDockerPublisher {
+  readonly id = 'gitlab-container'
+  readonly name = 'GitLab Container Registry'
+  readonly platform = 'gitlab'
+  override readonly priority = 20
+
+  override detect(registry: RegistryConfig): boolean {
+    if (registry.type !== 'docker' && registry.type !== 'container') {
+      return false
+    }
+
+    const regName = (registry.name || '').toLowerCase()
+    if (regName === 'gitlab' || regName.startsWith('gitlab-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      return isGitLabHost(parsed.hostname)
+    } catch {
+      return false
+    }
+  }
+
+  override buildRepositoryUrl(registry: RegistryConfig, imageName: string): string {
+    const host = this.normalizeServerHost(registry.server)
+    const cleanImage = imageName.replace(/^\/+/, '')
+
+    const ns = (registry.namespace || '').replace(/\/+$/, '')
+    if (ns) {
+      if (cleanImage.startsWith(`${ns}/`)) {
+        return `${host}/${cleanImage}`
+      }
+      return `${host}/${ns}/${cleanImage}`
+    }
+
+    return `${host}/${cleanImage}`
+  }
+}

package/src/artifacts/GitLabGenericPublisher.ts

@@ -0,0 +1,221 @@
+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 { GitLabClient, isGitLabHost } from '../client/GitLabClient.js'
+
+/**
+ * GitLab Generic Package Registry Publisher.
+ *
+ * Publishes arbitrary binary artifacts, tarballs (tar.gz), or zip files
+ * to GitLab's built-in Generic package registry.
+ * Endpoint format: PUT https://<gitlab_host>/api/v4/projects/<projectId>/packages/generic/<packageName>/<version>/<filename>
+ */
+export class GitLabGenericPublisher extends BasePublisher {
+  readonly id = 'gitlab-generic'
+  readonly name = 'GitLab Generic Package Registry'
+  readonly platform = 'gitlab'
+  readonly artifactType = 'generic'
+  override readonly priority = 20
+
+  override detect(registry: RegistryConfig): boolean {
+    if (registry.type !== 'generic' && registry.type !== 'archive') {
+      return false
+    }
+
+    const regName = (registry.name || '').toLowerCase()
+    if (regName === 'gitlab' || regName.startsWith('gitlab-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      return isGitLabHost(parsed.hostname)
+    } catch {
+      return false
+    }
+  }
+
+  override buildTargetRef(artifact: ArtifactPayload, _registry: RegistryConfig): string {
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : 'latest'
+    const filename = path.basename(artifact.source)
+    return `${artifact.name}/${version}/${filename}`
+  }
+
+  override async exists(artifact: ArtifactPayload, registry: RegistryConfig): Promise<boolean> {
+    const creds = this.resolveCredentials(registry)
+    const token = creds.token || creds.password
+    const reg = registry as RegistryConfig & { metadata?: Record<string, unknown> }
+    const projectId =
+      reg.namespace?.trim() ||
+      (reg.options?.projectId as string | undefined)?.trim() ||
+      (reg.metadata?.projectId as string | undefined)?.trim()
+
+    if (!projectId) return false
+
+    const client = new GitLabClient({
+      baseUrl: registry.server,
+      token,
+      username: creds.username,
+      password: creds.password
+    })
+
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : 'latest'
+    const packageName = artifact.name
+    const filename = path.basename(artifact.source)
+
+    const baseUrl = client.getPackageApiUrl(projectId, 'generic')
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, '')
+    const targetUrl = `${cleanBaseUrl}/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}/${encodeURIComponent(filename)}`
+
+    try {
+      const res = await client.request(targetUrl, { 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 GitLab Generic registry (${res.status}): ${errText}`)
+    } catch (err: any) {
+      if (err?.message?.includes('Failed to check artifact existence in GitLab')) {
+        throw err
+      }
+      throw new Error(
+        `Failed to check artifact existence in GitLab Generic registry: ${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 reg = registry as RegistryConfig & { metadata?: Record<string, unknown> }
+    const projectId =
+      reg.namespace?.trim() ||
+      (reg.options?.projectId as string | undefined)?.trim() ||
+      (reg.metadata?.projectId as string | undefined)?.trim()
+    if (!projectId) {
+      throw new Error(`GitLab Generic registry requires a valid project ID (specify via registry.namespace)`)
+    }
+
+    const client = new GitLabClient({
+      baseUrl: registry.server,
+      token: creds.token || creds.password,
+      username: creds.username,
+      password: creds.password,
+      timeoutMs: options?.timeoutMs
+    })
+
+    const version = artifact.tags?.[0] || 'latest'
+    const filename = path.basename(artifact.source)
+    const baseUrl = client.getPackageApiUrl(projectId, 'generic').replace(/\/+$/, '')
+    const targetUrl = `${baseUrl}/${encodeURIComponent(artifact.name)}/${encodeURIComponent(version)}/${encodeURIComponent(filename)}`
+    const masked = client.maskSecrets(targetUrl)
+
+    this.log(`  📥 Downloading ${artifact.name} ${version} from GitLab: ${masked}`)
+    const res = await client.request(targetUrl, { method: 'GET' })
+    if (!res.ok) {
+      throw await this.downloadError(res, `${artifact.name} ${version} (${filename})`, masked)
+    }
+    return this.saveResponse(res, dest, masked)
+  }
+
+  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 GitLab Generic registry ${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 reg = registry as RegistryConfig & { metadata?: Record<string, unknown> }
+    const projectId =
+      reg.namespace?.trim() ||
+      (reg.options?.projectId as string | undefined)?.trim() ||
+      (reg.metadata?.projectId as string | undefined)?.trim()
+
+    if (!projectId) {
+      throw new Error(
+        `GitLab Generic registry requires a valid project ID (specify via registry.namespace)`
+      )
+    }
+
+    const client = new GitLabClient({
+      baseUrl: registry.server,
+      token,
+      username: creds.username,
+      password: creds.password
+    })
+
+    const version = artifact.tags && artifact.tags.length > 0 ? artifact.tags[0] : 'latest'
+    const packageName = artifact.name
+
+    let filePath = artifact.source
+    const stat = await fs.stat(filePath).catch(() => null)
+    if (!stat || !stat.isFile()) {
+      throw new Error(`Generic artifact 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')}`
+
+    const baseUrl = client.getPackageApiUrl(projectId, 'generic')
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, '')
+    const targetUrl = `${cleanBaseUrl}/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}/${encodeURIComponent(filename)}`
+
+    this.log(`  📤 Uploading Generic package file to GitLab: ${targetUrl}`)
+
+    if (options?.dryRun) {
+      this.log(`  [dryRun] Would PUT ${filename} (${fileBuffer.length} bytes) to ${targetUrl}`)
+      return {
+        ref: `${packageName}/${version}/${filename}`,
+        digest,
+        metadata: { targetUrl, size: fileBuffer.length }
+      }
+    }
+
+    const res = await client.request(targetUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/octet-stream'
+      },
+      body: fileBuffer
+    })
+
+    if (!res.ok && res.status !== 201 && res.status !== 200) {
+      const errText = await client.extractErrorMessage(res)
+      throw new Error(`Failed to upload generic package to GitLab (${res.status}): ${errText}`)
+    }
+
+    return {
+      ref: `${packageName}/${version}/${filename}`,
+      digest,
+      metadata: {
+        packageName,
+        version,
+        filename,
+        targetUrl,
+        size: fileBuffer.length
+      }
+    }
+  }
+}

package/src/artifacts/GitLabMavenPublisher.ts

@@ -0,0 +1,224 @@
+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 { GitLabClient, isGitLabHost } from '../client/GitLabClient.js'
+
+/**
+ * GitLab Maven Package Registry Publisher.
+ *
+ * Endpoint format: PUT https://<gitlab_host>/api/v4/projects/<projectId>/packages/maven/{groupId}/{artifactId}/{version}/{filename}
+ */
+export class GitLabMavenPublisher extends BasePublisher {
+  readonly id = 'gitlab-maven'
+  readonly name = 'GitLab Maven Repository'
+  readonly platform = 'gitlab'
+  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 === 'gitlab' || regName.startsWith('gitlab-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      return isGitLabHost(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}`
+  }
+
+  override async exists(artifact: ArtifactPayload, registry: RegistryConfig): Promise<boolean> {
+    const creds = this.resolveCredentials(registry)
+    const token = creds.token || creds.password
+    const reg = registry as RegistryConfig & { metadata?: Record<string, unknown> }
+    const projectId =
+      reg.namespace?.trim() ||
+      (reg.options?.projectId as string | undefined)?.trim() ||
+      (reg.metadata?.projectId as string | undefined)?.trim()
+
+    if (!projectId) return false
+
+    const client = new GitLabClient({
+      baseUrl: registry.server,
+      token,
+      username: creds.username,
+      password: creds.password
+    })
+
+    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, 'GitLab')
+
+    const baseUrl = client.getPackageApiUrl(projectId, 'maven')
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, '')
+    const targetUrl = `${cleanBaseUrl}/${groupPath}/${artifactId}/${version}/${jarFilename}`
+
+    try {
+      const res = await client.request(targetUrl, { 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 GitLab Maven registry (${res.status}): ${errText}`)
+    } catch (err: any) {
+      if (err?.message?.includes('Failed to check artifact existence in GitLab')) {
+        throw err
+      }
+      throw new Error(
+        `Failed to check artifact existence in GitLab 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 GitLab 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 reg = registry as RegistryConfig & { metadata?: Record<string, unknown> }
+    const projectId =
+      reg.namespace?.trim() ||
+      (reg.options?.projectId as string | undefined)?.trim() ||
+      (reg.metadata?.projectId as string | undefined)?.trim()
+
+    if (!projectId) {
+      throw new Error(
+        `GitLab Maven registry requires a valid project ID (specify via registry.namespace)`
+      )
+    }
+
+    const client = new GitLabClient({
+      baseUrl: registry.server,
+      token,
+      username: creds.username,
+      password: creds.password
+    })
+
+    // 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, 'GitLab')
+
+    const jarBuffer = await fs.readFile(jarPath)
+    const digest = `sha256:${crypto.createHash('sha256').update(jarBuffer).digest('hex')}`
+
+    const baseUrl = client.getPackageApiUrl(projectId, 'maven')
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, '')
+    const targetUrl = `${cleanBaseUrl}/${groupPath}/${artifactId}/${version}/${jarFilename}`
+
+    this.log(`  📤 Uploading Maven JAR to GitLab: ${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 pomFilename = `${artifactId}-${version}.pom`
+      const pomTargetUrl = `${cleanBaseUrl}/${groupPath}/${artifactId}/${version}/${pomFilename}`
+      this.log(`  📤 Uploading Maven POM to GitLab: ${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 GitLab (${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 GitLab (${res.status}): ${errText}`)
+    }
+
+    return {
+      ref: `${groupId}:${artifactId}:${version}`,
+      digest,
+      metadata: {
+        groupId,
+        artifactId,
+        version,
+        targetUrl,
+        size: jarBuffer.length
+      }
+    }
+  }
+}

package/src/artifacts/GitLabNpmPublisher.ts

@@ -0,0 +1,90 @@
+import { BaseNpmPublisher } from '@ticatec/omniflow-artifact'
+import type { ArtifactPayload, PublishOptions, RegistryConfig } from '@ticatec/omniflow-artifact'
+import { isGitLabHost } from '../client/GitLabClient.js'
+
+/**
+ * GitLab NPM Package Registry Publisher.
+ *
+ * Endpoint format: https://<gitlab_host>/api/v4/projects/<projectId>/packages/npm/
+ */
+export class GitLabNpmPublisher extends BaseNpmPublisher {
+  readonly id = 'gitlab-npm'
+  readonly name = 'GitLab NPM Registry'
+  readonly platform = 'gitlab'
+  override readonly priority = 20
+
+  override detect(registry: RegistryConfig): boolean {
+    if (registry.type !== 'npm') {
+      return false
+    }
+
+    const regName = (registry.name || '').toLowerCase()
+    if (regName === 'gitlab' || regName.startsWith('gitlab-')) {
+      return true
+    }
+
+    const server = (registry.server || '').toLowerCase()
+    try {
+      const parsed = new URL(server.includes('://') ? server : `https://${server}`)
+      return isGitLabHost(parsed.hostname)
+    } catch {
+      return false
+    }
+  }
+
+  override normalizeRegistryUrl(server: string, _registryOrNamespace?: RegistryConfig | string): string {
+    let url = server.trim()
+    if (!/^https?:\/\//i.test(url)) {
+      url = `https://${url}`
+    }
+
+    const parsed = new URL(url)
+    const cleanBase = url.replace(/\/+$/, '')
+
+    // M6 Escape hatch: if server URL already has path segments containing /packages/npm, use it as-is
+    if (parsed.pathname.includes('/packages/npm')) {
+      return cleanBase.endsWith('/') ? cleanBase : `${cleanBase}/`
+    }
+
+    // Extract projectId strictly from namespace or options/metadata
+    let projectId: string | undefined
+    if (typeof _registryOrNamespace === 'string') {
+      projectId = _registryOrNamespace.trim()
+    } else if (_registryOrNamespace && typeof _registryOrNamespace === 'object') {
+      const reg = _registryOrNamespace as RegistryConfig & { metadata?: Record<string, unknown> }
+      projectId =
+        reg.namespace?.trim() ||
+        (reg.options?.projectId as string | undefined)?.trim() ||
+        (reg.metadata?.projectId as string | undefined)?.trim()
+    }
+
+    if (!projectId) {
+      throw new Error(
+        `GitLab NPM registry requires a valid project ID (specify via registry.namespace or full server URL)`
+      )
+    }
+
+    return `${cleanBase}/api/v4/projects/${encodeURIComponent(projectId)}/packages/npm/`
+  }
+
+  // NOTE: login() is intentionally NOT overridden here. BaseNpmPublisher handles .npmrc backup,
+  // auth token injection, and cleanup(session) in finally to ensure credential cleanup (S1 fix).
+
+  protected override async doPublish(
+    artifact: ArtifactPayload,
+    registry: RegistryConfig,
+    options?: PublishOptions
+  ): Promise<{
+    ref: string
+    metadata?: Record<string, unknown>
+  }> {
+    const owner = registry.namespace
+    if (owner && !artifact.name.startsWith(`@`)) {
+      this.log(
+        `  ⚠ Notice: Package "${artifact.name}" is not scoped. GitLab typically recommends package names to be scoped (e.g. @<group>/<package>).`
+      )
+    }
+
+    return super.doPublish(artifact, registry, options)
+  }
+}