@leverege/build-tools 2.113.6 → 2.114.0-DEVOP-578.2

package/src/k8s/commands/exe.mjs

@@ -0,0 +1,57 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { $ } from 'zx'
+
+import { log, errorExit } from '../../Utils.mjs'
+import { overwhelmGate } from '../lib/gate.mjs'
+import { listPods } from '../lib/kubectl.mjs'
+import { selectPod } from '../lib/select.mjs'
+
+const TARGETS = {
+  cnpg:            { ns: 'cnpg-operands', query: null,         cmd: [ 'bash' ] },
+  es8:             { ns: 'elastic',       query: null,         cmd: [ 'bash' ] },
+  elastic8:        { ns: 'elastic',       query: null,         cmd: [ 'bash' ] },
+  grafana:         { ns: 'prometheus',    query: 'grafana',    cmd: [ 'bash' ] },
+  grafold:         { ns: 'monitoring',    query: 'grafana',    cmd: [ 'bash' ] },
+  'prom-operator': { ns: 'prometheus',    query: null,         cmd: [ 'bash' ] },
+  prometheus:      { ns: 'prometheus',    query: null,         cmd: [ 'bash' ] },
+  psql:            { ns: 'cnpg-operands', query: 'postgresql', cmd: [ 'psql', '-U', 'postgres' ] },
+  pgsql:           { ns: 'cnpg-operands', query: 'postgresql', cmd: [ 'psql', '-U', 'postgres' ] },
+  redis:           { ns: 'default',       query: 'redis',      cmd: [ 'redis-cli' ] },
+  'redis-cli':     { ns: 'default',       query: 'redis',      cmd: [ 'redis-cli' ] },
+  valkey:          { ns: 'default',       query: 'valkey',     cmd: [ 'valkey-cli' ] },
+  'valkey-cli':    { ns: 'default',       query: 'valkey',     cmd: [ 'valkey-cli' ] },
+}
+
+export const exeCommand = new Command( 'exe' )
+  .description( 'Exec into a pod interactively' )
+  .argument( '[target]', `shortcut: ${Object.keys( TARGETS ).join( ', ' )}` )
+  .action( async ( target ) => {
+    await overwhelmGate()
+    const cfg = target ?
+      TARGETS[target] :
+      { ns: 'default', query: null, cmd: [ 'bash' ] }
+
+    if ( target && !cfg ) {
+      errorExit( `Unknown target: ${target}\nValid: ${Object.keys( TARGETS ).join( ', ' )}` )
+    }
+
+    let pods = await listPods( cfg.ns )
+    if ( cfg.query ) {
+      pods = pods.filter( p => p.name.includes( cfg.query ) )
+    }
+    if ( !pods.length ) {
+      errorExit( `No pods found in ${cfg.ns}${cfg.query ? ` matching "${cfg.query}"` : ''}` )
+    }
+
+    const { namespace, name } = pods.length === 1 ?
+      pods[0] :
+      await selectPod( pods, 'Select pod to exec into' )
+
+    log( chalk.cyan( `\nexec  →  ${namespace}/${name}\n` ) )
+    try {
+      await $( { stdio: 'inherit', verbose: false } )`kubectl exec -it -n ${namespace} ${name} -- ${cfg.cmd}`
+    } catch ( e ) {
+      if ( e.exitCode !== 130 ) throw e
+    }
+  } )

package/src/k8s/commands/fwd.mjs

@@ -0,0 +1,35 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { $ } from 'zx'
+
+import { log, errorExit } from '../../Utils.mjs'
+import { overwhelmGate } from '../lib/gate.mjs'
+
+const TARGETS = {
+  elastic: { ns: 'elastic',    svc: 'elasticsearch8',           port: 9200 },
+  redis:   { ns: 'default',    svc: 'redis-master',             port: 6379 },
+  valkey:  { ns: 'default',    svc: 'valkey-master',            port: 6379 },
+  prom:    { ns: 'prometheus', svc: 'prometheus-operated',      port: 9090 },
+  alert:   { ns: 'prometheus', svc: 'alertmanager-operated',    port: 9093 },
+  grafana: { ns: 'prometheus', svc: 'prometheus-stack-grafana', port: 3000 },
+}
+
+export const fwdCommand = new Command( 'fwd' )
+  .description( 'Port-forward to a cluster endpoint' )
+  .argument( '<target>', `target: ${Object.keys( TARGETS ).join( ', ' )}` )
+  .option( '-l, --local <port>', 'override local port' )
+  .action( async ( target, opts ) => {
+    await overwhelmGate()
+    const cfg = TARGETS[target]
+    if ( !cfg ) {
+      errorExit( `Unknown target: ${target}\nValid: ${Object.keys( TARGETS ).join( ', ' )}` )
+    }
+    const localPort = opts.local ?? cfg.port
+    log( chalk.cyan( `\nForwarding  localhost:${localPort}  →  ${cfg.ns}/${cfg.svc}:${cfg.port}` ) )
+    log( chalk.gray( 'Ctrl+C to stop\n' ) )
+    try {
+      await $( { stdio: 'inherit', verbose: false } )`kubectl port-forward -n ${cfg.ns} svc/${cfg.svc} ${localPort}:${cfg.port}`
+    } catch ( e ) {
+      if ( e.exitCode !== 130 ) throw e
+    }
+  } )

package/src/k8s/commands/log.mjs

@@ -0,0 +1,76 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { $ } from 'zx'
+
+import { log, getDateTimestamp } from '../../Utils.mjs'
+import { overwhelmGate } from '../lib/gate.mjs'
+import { listPods } from '../lib/kubectl.mjs'
+import { selectPod } from '../lib/select.mjs'
+
+const PINO = [ '-c', '-t', 'HH:MM:ss.l', '-i', 'severity' ]
+
+// Heuristic: strip replicaset+pod hashes for Deployments, ordinal for StatefulSets
+function containerFromPod( podName ) {
+  const parts = podName.split( '-' )
+  const last = parts.at( -1 )
+  const prev = parts.at( -2 )
+  const isHash = s => s && /^[a-z0-9]{5,10}$/.test( s )
+  if ( isHash( last ) && isHash( prev ) ) return parts.slice( 0, -2 ).join( '-' )
+  if ( /^\d+$/.test( last ) ) return parts.slice( 0, -1 ).join( '-' )
+  return parts.slice( 0, -1 ).join( '-' )
+}
+
+function logFile( name, tee ) {
+  return typeof tee === 'string' ? tee : `${name}-${getDateTimestamp()}.log`
+}
+
+async function stream( $i, args, { pretty, tee, name } ) {
+  if ( pretty && tee ) {
+    await $i`kubectl ${args} | tee ${logFile( name, tee )} | pino-pretty ${PINO}`
+  } else if ( pretty ) {
+    await $i`kubectl ${args} | pino-pretty ${PINO}`
+  } else if ( tee ) {
+    await $i`kubectl ${args} | tee ${logFile( name, tee )}`
+  } else {
+    await $i`kubectl ${args}`
+  }
+}
+
+export const logCommand = new Command( 'log' )
+  .description( 'Stream pod logs with pino-pretty formatting' )
+  .argument( '[service]', 'app label selector (app=<service>); interactive pod picker if omitted' )
+  .option( '-n, --namespace <ns>', 'namespace', 'default' )
+  .option( '-c, --container <name>', 'container name (derived from pod name if omitted)' )
+  .option( '--tail <n>', 'initial lines to show', '50' )
+  .option( '--tee [file]', 'also write raw logs to a timestamped file' )
+  .option( '--no-pretty', 'skip pino-pretty, raw output' )
+  .action( async ( service, opts ) => {
+    await overwhelmGate()
+    const $i = $( { stdio: 'inherit', verbose: false } )
+
+    if ( service ) {
+      const { namespace: ns, tail } = opts
+      const args = [ 'logs', '--follow', '-n', ns, '-l', `app=${service}`, '--max-log-requests=16', `--tail=${tail}` ]
+      log( chalk.cyan( `\nStreaming  ${ns}/app=${service}\n` ) )
+      try {
+        await stream( $i, args, { pretty: opts.pretty, tee: opts.tee, name: service } )
+      } catch ( e ) {
+        if ( e.exitCode !== 130 ) throw e
+      }
+      return
+    }
+
+    // Interactive pod picker — all namespaces unless -n was given
+    const ns = opts.namespace !== 'default' ? opts.namespace : undefined
+    const pods = await listPods( ns )
+    const { namespace, name: podName } = await selectPod( pods, 'Select a pod to stream' )
+    const container = opts.container ?? containerFromPod( podName )
+    const args = [ 'logs', '--follow', '-n', namespace, podName, '-c', container, `--tail=${opts.tail}` ]
+
+    log( chalk.cyan( `\nStreaming  ${namespace}/${podName}  (container: ${container})\n` ) )
+    try {
+      await stream( $i, args, { pretty: opts.pretty, tee: opts.tee, name: container } )
+    } catch ( e ) {
+      if ( e.exitCode !== 130 ) throw e
+    }
+  } )

package/src/k8s/commands/roll.mjs

@@ -0,0 +1,37 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { $ } from 'zx'
+
+import { log } from '../../Utils.mjs'
+import { overwhelmGate } from '../lib/gate.mjs'
+import { listDeployments } from '../lib/kubectl.mjs'
+import { selectDeployment } from '../lib/select.mjs'
+
+export const rollCommand = new Command( 'roll' )
+  .description( 'Rolling restart of one or more deployments' )
+  .argument( '[deployments...]', 'deployment names (interactive if omitted)' )
+  .option( '-n, --namespace <ns>', 'namespace', 'default' )
+  .action( async ( deployments, opts ) => {
+    await overwhelmGate()
+
+    let targets = deployments
+    if ( !targets.length ) {
+      const all = await listDeployments( opts.namespace )
+      targets = [ await selectDeployment( all, 'Select deployment to restart' ) ]
+    }
+
+    log( chalk.cyan( '\nrolling restart\n' ) )
+    for ( const deploy of targets ) {
+      try {
+        // sequential by design — report status per deployment as each completes
+        // eslint-disable-next-line no-await-in-loop
+        await $`kubectl rollout restart deployment ${deploy} -n ${opts.namespace}`
+        log( `  ${chalk.green( 'SUCCESS' )}  ${deploy}` )
+        // eslint-disable-next-line no-await-in-loop
+        await $`send-to-slack ${'k8scale roll ' + deploy}`.catch( () => {} )
+      } catch {
+        log( `  ${chalk.red( 'FAILURE' )}  ${deploy}` )
+      }
+    }
+    log( '' )
+  } )

package/src/k8s/commands/scale.mjs

@@ -0,0 +1,43 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { $ } from 'zx'
+
+import { log, errorExit } from '../../Utils.mjs'
+import { overwhelmGate } from '../lib/gate.mjs'
+import { listDeployments } from '../lib/kubectl.mjs'
+import { selectDeployment } from '../lib/select.mjs'
+
+export const scaleCommand = new Command( 'scale' )
+  .description( 'Scale a deployment up or down' )
+  .argument( '<direction>', 'up or dn' )
+  .argument( '[deployments...]', 'deployment names (interactive if omitted)' )
+  .option( '-n, --namespace <ns>', 'namespace', 'default' )
+  .action( async ( direction, deployments, opts ) => {
+    if ( direction !== 'up' && direction !== 'dn' ) {
+      errorExit( 'Direction must be up or dn' )
+    }
+    await overwhelmGate()
+
+    const replicas = direction === 'up' ? 1 : 0
+
+    let targets = deployments
+    if ( !targets.length ) {
+      const all = await listDeployments( opts.namespace )
+      targets = [ await selectDeployment( all, 'Select deployment to scale' ) ]
+    }
+
+    log( chalk.cyan( `\nscale ${direction}\n` ) )
+    for ( const deploy of targets ) {
+      try {
+        // sequential by design — report status per deployment as each completes
+        // eslint-disable-next-line no-await-in-loop
+        await $`kubectl scale --replicas=${replicas} deployment ${deploy} -n ${opts.namespace}`
+        log( `  ${chalk.green( 'SUCCESS' )}  ${deploy}` )
+        // eslint-disable-next-line no-await-in-loop
+        await $`send-to-slack ${'k8scale ' + direction + ' ' + deploy}`.catch( () => {} )
+      } catch {
+        log( `  ${chalk.red( 'FAILURE' )}  ${deploy}` )
+      }
+    }
+    log( '' )
+  } )

package/src/k8s/k8s.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { program } from 'commander'
+import { $ } from 'zx'
+
+import { fwdCommand } from './commands/fwd.mjs'
+import { exeCommand } from './commands/exe.mjs'
+import { scaleCommand } from './commands/scale.mjs'
+import { rollCommand } from './commands/roll.mjs'
+import { logCommand } from './commands/log.mjs'
+import { completionCommand } from './commands/completion.mjs'
+import { hibernateCommand, wakeCommand } from './commands/cryo.mjs'
+
+$.verbose = false
+
+program
+  .name( 'k8s' )
+  .description( 'Leverege k8s toolkit — forward, exec, scale, roll, log' )
+  .addCommand( fwdCommand )
+  .addCommand( exeCommand )
+  .addCommand( scaleCommand )
+  .addCommand( rollCommand )
+  .addCommand( logCommand )
+  .addCommand( completionCommand )
+  .addCommand( hibernateCommand )
+  .addCommand( wakeCommand )
+  .parse()

package/src/k8s/lib/gate.mjs

@@ -0,0 +1,9 @@
+import { $ } from 'zx'
+
+export async function overwhelmGate() {
+  try {
+    await $({ stdio: 'inherit', verbose: false })`overwhelm`
+  } catch {
+    process.exit(1)
+  }
+}

package/src/k8s/lib/kubectl.mjs

@@ -0,0 +1,26 @@
+import { $ } from 'zx'
+
+export async function listPods(namespace) {
+  const result = namespace
+    ? await $`kubectl get pods -n ${namespace} --no-headers`
+    : await $`kubectl get pods --all-namespaces --no-headers`
+
+  return result.stdout.trim().split('\n').filter(Boolean).map(line => {
+    const cols = line.trim().split(/\s+/)
+    if (namespace) {
+      const [name, , status] = cols
+      return { namespace, name, status }
+    }
+    const [ns, name, , status] = cols
+    return { namespace: ns, name, status }
+  })
+}
+
+export async function listDeployments(namespace) {
+  const result = namespace
+    ? await $`kubectl get deploy -n ${namespace} --no-headers -o name`
+    : await $`kubectl get deploy --all-namespaces --no-headers -o name`
+
+  return result.stdout.trim().split('\n').filter(Boolean)
+    .map(n => n.replace(/^deployment\.apps\//, ''))
+}

package/src/k8s/lib/select.mjs

@@ -0,0 +1,18 @@
+import enquirer from 'enquirer'
+
+const { AutoComplete } = enquirer
+
+export async function selectPod(pods, message = 'Select a pod') {
+  const choices = pods.map(p => `${p.namespace}/${p.name}  (${p.status})`)
+  const prompt = new AutoComplete({ name: 'pod', message, limit: 15, choices })
+  const selected = await prompt.run()
+  // parse "namespace/podname  (status)" back to { namespace, name }
+  const [ns, rest] = selected.split('/')
+  const name = rest.trim().split(/\s+/)[0]
+  return { namespace: ns, name }
+}
+
+export async function selectDeployment(deployments, message = 'Select a deployment') {
+  const prompt = new AutoComplete({ name: 'deploy', message, limit: 15, choices: deployments })
+  return prompt.run()
+}

package/src/overwhelm.mjs

@@ -157,7 +157,7 @@ Object.keys( over ).forEach( ( key ) => {
 } )
 
 if ( varErrors.length > 0 ) {
-  log( chalk.red.bold( '\n***ERROR: unkown variable reference(s) in overwhelm.yaml:\n' ) )
+  log( chalk.red.bold( '\n***ERROR: unknown variable reference(s) in overwhelm.yaml:\n' ) )
   varErrors.forEach( ( error ) => {
     log( `     ${chalk.yellow.bold( error )}` )
   } )

package/src/repo-panopticon.mjs

@@ -27,8 +27,8 @@ let latestOrbVersion = null
 const CHECKS = [
   {
     label : 'cir',
-    fn    : ( { dir } ) => {
-      const cfgPath = path.join( dir, '.circleci', 'config.yml' )
+    fn    : ( { gitRoot } ) => {
+      const cfgPath = path.join( gitRoot, '.circleci', 'config.yml' )
       if ( !fs.existsSync( cfgPath ) ) return { value : SYM_BAD }
       try {
         const content = fs.readFileSync( cfgPath, 'utf8' )
@@ -40,7 +40,7 @@ const CHECKS = [
         if ( major === 1 ) return { value : chalk.yellow( '1' ) }
         const isLatest = !latestOrbVersion || match[1] === latestOrbVersion
         const color = isLatest ? chalk.green : chalk.yellow
-        const hasGHA = fs.existsSync( path.join( dir, '.github', 'workflows', 'ci.yml' ) )
+        const hasGHA = fs.existsSync( path.join( gitRoot, '.github', 'workflows', 'ci.yml' ) )
         return { value : hasGHA ? color( '★' ) : color( `${major}` ) }
       } catch {
         return { value : chalk.hex( '#FFA500' )( 'L' ) }
@@ -80,13 +80,16 @@ const CHECKS = [
     },
   },
   {
-    label : 'bbl',
-    fn    : ( { dir, pkg } ) => {
-      const configFiles = [ '.babelrc', '.babelrc.js', '.babelrc.json', 'babel.config.js', 'babel.config.json', 'babel.config.cjs' ]
-      const hasConfig   = configFiles.some( f => fs.existsSync( path.join( dir, f ) ) )
-      const allDeps     = { ...( pkg?.dependencies ?? {} ), ...( pkg?.devDependencies ?? {} ) }
-      const hasDep      = Object.keys( allDeps ).some( k => k.includes( 'babel' ) )
-      return { value : ( hasConfig || hasDep ) ? SYM_BAD : chalk.dim( '–' ) }
+    label : 'git',
+    fn    : ( { gitRoot } ) => {
+      try {
+        const gitConfig = fs.readFileSync( path.join( gitRoot, '.git', 'config' ), 'utf8' )
+        if ( /bitbucket/i.test( gitConfig ) ) return { value : chalk.red( 'bb' ) }
+        if ( /github\.com/i.test( gitConfig ) ) return { value : chalk.green( 'gh' ) }
+        return { value : chalk.dim( '?' ) }
+      } catch {
+        return { value : chalk.dim( '?' ) }
+      }
     },
   },
 ]
@@ -286,7 +289,7 @@ function renderTable( rows ) {
     nameHdr,
     center( 'mgr', 3 ),
     center( 'pkg', pkgW ),
-    center( 'git', gitW ),
+    center( 'tag', gitW ),
     center( 'scop', scopeW ),
     ...CHECKS.map( c => center( c.label, c.label.length ) ),
   ].join( '  ' )
@@ -333,13 +336,14 @@ program
   .addHelpText( 'after', `
 ${chalk.yellow( 'Columns:' )}
   ${chalk.green( 'pkg' )}    version from package.json
-  ${chalk.green( 'git' )}    latest semver git tag (green=match, yellow=mismatch, red=untagged)
+  ${chalk.green( 'tag' )}    latest semver git tag (green=match, yellow=mismatch, red=untagged)
   ${chalk.green( 'name' )}  orange if dirty: pull/fetch failed (regular repos) or local modifications present (workspace packages)
   ${chalk.green( 'scope' )}  package scope: @org, PRVT, or PUBL
   ${chalk.green( 'cir' )}    CI status: ✘=missing, L=legacy, 1=orb v1, green 2/★=orb v2 current, yellow 2/★=orb v2 stale
   ${chalk.green( 'ESM' )}    "type": "module" in package.json
   ${chalk.green( 'har' )}    .har directory present at repo root
   ${chalk.green( 'lnt' )}    ESLint version from node_modules (✘=no lint script, ?=not installed, yellow=v8, green=v9+)
+  ${chalk.green( 'git' )}    origin remote: green gh=GitHub, red bb=Bitbucket
 
 ${chalk.yellow( 'Monorepos:' )}
   Workspace packages are discovered automatically — passing a monorepo root

package/src/service-man/config/Config.mjs

@@ -66,7 +66,7 @@ export default class Config {
       dumpDir,
       {
         recursive : true,
-        filter : source => !source.endsWith( '.js' )
+        filter : source => !source.endsWith( '.mjs' )
       } )
 
     const fh = await fs.open( `${dumpDir}/.nohelm`, 'a' )

package/src/service-man/config/iam-roles/leveregeVertexEndpointUser.json

@@ -0,0 +1,10 @@
+{
+  "description": "Leverege vertex endpoint permission for Gemini",
+  "includedPermissions": [
+    "aiplatform.endpoints.get",
+    "aiplatform.endpoints.list",
+    "aiplatform.endpoints.predict"
+  ],
+  "stage": "BETA",
+  "title": "Leverege Vertex Endpoint User"
+}

package/src/service-man/config/service-accounts/llm-prompt-server.json

@@ -0,0 +1,6 @@
+{
+  "roles" : [
+    "leveregePubSub",
+    "leveregeSecretsViewer"
+  ]
+}

package/src/service-man/config/service-accounts/triton-inference-server.json

@@ -0,0 +1,5 @@
+{
+  "roles" : [
+    "leveregeStorageObjectAdmin"
+  ]
+}

package/src/service-man/config/service-accounts/vms-server.json

@@ -0,0 +1,8 @@
+{
+  "roles" : [
+    "leveregeBigQueryReader",
+    "leveregePubSub",
+    "leveregeSecretsViewer",
+    "leveregeStorageObjectAdmin"
+  ]
+}

package/src/service-man/gcloud-k8s/ServiceAccountManager.mjs

@@ -164,8 +164,8 @@ export default class ServiceAccountManager {
 
     try {
       await this.serviceAccountExists( serviceName )
-      log( `The gcloud SA ${serviceName} already exists - skipping recreation` )
-      process.exit( 0 )
+      log( `The gcloud SA ${serviceName} already exists - skipping` )
+      return
     } catch ( err ) {
       if ( err.exitCode !== 1 ) {
         log( chalk.red.bold( `\n  ***${err.stderr}` ) )
@@ -211,20 +211,24 @@ export default class ServiceAccountManager {
 
     for ( let i = 0; i < saNames.length; i++ ) {
       const saName = saNames[i]
+      let exists = false
       try {
         await this.serviceAccountExists( saName ) // eslint-disable-line no-await-in-loop
+        exists = true
         if ( overwrite ) {
           log( '\nRecreating existing SvcAct =>', chalk.yellow( saName ) )
           await this.deleteServiceAccount( saName, k8sProject ) // eslint-disable-line no-await-in-loop
+          exists = false
         } else {
-          log( '\nSkip existing SvcAct =>', chalk.yellow( saName ) )
-          continue
+          log( '\nRebinding existing SvcAct =>', chalk.yellow( saName ) )
         }
       } catch ( err ) { // eslint-disable-line no-unused-vars
         log( '\nCreating new SvcAcct =>', chalk.green( saName ) )
       }
 
-      await this.createServiceAccount( saName, k8sProject ) // eslint-disable-line no-await-in-loop
+      if ( !exists ) {
+        await this.createServiceAccount( saName, k8sProject ) // eslint-disable-line no-await-in-loop
+      }
 
       const saRoles = svcCfg.serviceAccounts[saName].roles
       await this.bindIamRoles( saName, saRoles, k8sProject ) // eslint-disable-line no-await-in-loop

package/src/artifacts/ArtifactPuller.mjs

@@ -1,131 +0,0 @@
-/* eslint-disable security/detect-non-literal-fs-filename */
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { shellCmd, log, debug, err } from '../Utils.mjs'
-
-import { parseGenericArtifactSchemaToRemoteRelativePath, parseGenericArtifactSchemaToLocalRelativePath, listGenericArtifactFiles, parseGenericArtifactFileToRemoteRelativePath, parseGenericArtifactSchemaToArtifactName } from './Utils.mjs'
-
-class ArtifactPuller {
-  constructor( path, artifact ) {
-    this.path = path
-    this.artifact = artifact
-  }
-
-  async pull() {
-    throw new Error( 'Not implemented' )
-  }
-}
-
-class GenericArtifactPuller extends ArtifactPuller {
-
-  async downloadFile( remoteRelativePath, localRelativePath ) {
-    debug( { remoteRelativePath, localRelativePath }, '<==Download File' )
-
-    const isBasenameDifferent = path.basename( localRelativePath ) !== path.basename( remoteRelativePath )
-
-    let tmpLocalRelativePath
-    if ( isBasenameDifferent ) {
-      const artifactName = parseGenericArtifactSchemaToArtifactName( this.artifact )
-      const encodedArtifactName = artifactName.replaceAll( ':', '_' ).replaceAll( '/', '_' ).replaceAll( '%2F', '_' )
-      tmpLocalRelativePath = path.join( '/', 'tmp', encodedArtifactName )
-    } else {
-      await fs.promises.mkdir( path.dirname( localRelativePath ), { recursive : true } )
-    }
-
-    try {
-      const command = `gcloud artifacts generic download \
-      --project=${this.artifact.project} \
-      --location=${this.artifact.location} \
-      --repository=${this.artifact.repository} \
-      --package=${this.artifact.package} \
-      --version=${this.artifact.version} \
-      --name="${remoteRelativePath}" \
-      --destination=${tmpLocalRelativePath || path.dirname( localRelativePath )}`
-
-      debug( { command }, '<==Download File Command' )
-
-      await shellCmd( command )
-
-      if ( isBasenameDifferent ) {
-        await fs.promises.rename( tmpLocalRelativePath, localRelativePath )
-      }
-
-      return true
-    } catch ( error ) {
-      err( `Error downloading file: ${localRelativePath} ${error.message}` )
-      return false
-    }
-  }
-
-  async downloadDirectory( remoteRelativePath, localRelativePath ) {
-
-    await fs.promises.mkdir( localRelativePath, { recursive : true } )
-
-    const command = `gcloud artifacts generic download \
-      --project=${this.artifact.project} \
-      --location=${this.artifact.location} \
-      --repository=${this.artifact.repository} \
-      --package=${this.artifact.package} \
-      --version=${this.artifact.version} \
-      --destination=${localRelativePath}`
-
-    debug( { command }, '<==Download Directory Command' )
-
-    await shellCmd( command )
-  }
-
-  async downloadNestedDirectory( remoteRelativePath, localRelativePath ) {
-    debug( { remoteRelativePath, localRelativePath }, '<==Download Nested Directory' )
-
-    const files = await listGenericArtifactFiles( this.artifact )
-    await Promise.all(
-      files
-        .reduce( ( acc, file ) => {
-          const remoteFilePath = parseGenericArtifactFileToRemoteRelativePath( file )
-          if ( remoteFilePath.startsWith( remoteRelativePath ) ) {
-            const remoteFilePathWithoutRemotePath = remoteFilePath.replace( remoteRelativePath, '' )
-            const localFilePath = path.join( localRelativePath, remoteFilePathWithoutRemotePath )
-            acc.push( this.downloadFile( remoteFilePath, localFilePath ) )
-          }
-          return acc
-        }, [] )
-    )
-  }
-
-  async pull() {
-    log( `Pulling artifact: ${this.artifact.name}` )
-    
-    debug( { artifact : this.artifact }, '<==Pulling artifact' )
-
-    try {
-      const remoteRelativePath = parseGenericArtifactSchemaToRemoteRelativePath( this.artifact )
-      const localRelativePath = parseGenericArtifactSchemaToLocalRelativePath( this.artifact )
-
-      if ( this.artifact.remote_file_path && this.artifact.local_file_path ) {
-        await this.downloadFile( remoteRelativePath, path.join( this.path, localRelativePath ) )
-      } else if ( this.artifact.remote_file_path && this.artifact.local_path ) {
-        await this.downloadFile( remoteRelativePath, path.join( this.path, localRelativePath ) )
-      } else if ( this.artifact.remote_file_path && !this.artifact.local_path && !this.artifact.local_file_path ) {
-        await this.downloadFile( remoteRelativePath, path.join( this.path, localRelativePath ) )
-      } else if ( this.artifact.remote_path && this.artifact.local_path ) {
-        await this.downloadNestedDirectory( remoteRelativePath, path.join( this.path, localRelativePath ) )
-      } else if ( this.artifact.remote_path && !this.artifact.local_path && !this.artifact.local_file_path ) {
-        await this.downloadDirectory( remoteRelativePath, path.join( this.path, localRelativePath ) )
-      } else if ( !this.artifact.remote_path && !this.artifact.remote_file_path && this.artifact.local_path ) {
-        await this.downloadDirectory( remoteRelativePath, path.join( this.path, localRelativePath ) )
-      } else {
-        throw new Error( 'No valid paths provided' )
-      }
-
-      log( `Successfully pulled artifact: ${this.artifact.name}` )
-
-      return true
-    } catch ( error ) {
-      err( `Error pulling artifact: ${this.artifact.name} ${error.message}` )
-    }
-    return false
-  }
-}
-
-export { ArtifactPuller, GenericArtifactPuller }