@forgehive/forge-cli 0.1.7 → 0.2.0

package/src/tasks/runner/create.ts

@@ -0,0 +1,121 @@
+// TASK: create
+// Run this task with:
+// forge task:run runner:create --runnerName <runner-name>
+// forge task:run runner:create --runnerName inventory
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+
+import Handlebars from 'handlebars'
+import path from 'path'
+import fs from 'fs/promises'
+import { camelCase } from '../../utils/camelCase'
+
+import { load } from '../conf/load'
+import { type RunnerDescriptor, type ForgeConf } from '../types'
+
+// Define the template content directly in the code
+const RUNNER_TEMPLATE = `// RUNNER: {{ runnerName }}
+import { Runner } from '@forgehive/runner'
+
+// Import your tasks here
+// import { EXAMPLE_TASK } from '../../tasks/MODULE/TASK'
+
+const {{ runnerName }}Runner = new Runner()
+
+// Load your tasks here
+// runner.load('MODULE:TASK', EXAMPLE_TASK)
+
+export { {{ runnerName }}Runner }
+`
+
+const schema = new Schema({
+  runnerName: Schema.string()
+})
+
+const boundaries = {
+  // Load boundaries
+  loadConf: load.asBoundary(),
+  getCwd: async (): Promise<string> => {
+    return process.cwd()
+  },
+
+  // Persist boundaries
+  persistRunner: async (runnerPath: string, runnerName: string, content: string): Promise<{ path: string }> => {
+    const folderPath = path.join(runnerPath, runnerName)
+    const filePath = path.join(folderPath, 'index.ts')
+
+    let err
+    try {
+      await fs.stat(folderPath)
+    } catch (e) {
+      err = e
+    }
+
+    if (err === undefined) {
+      throw new Error(`Runner folder '${folderPath}' already exists.`)
+    }
+
+    await fs.mkdir(folderPath, { recursive: true })
+    await fs.writeFile(filePath, content, 'utf-8')
+
+    return {
+      path: filePath.toString()
+    }
+  },
+  persistConf: async (forge: ForgeConf, cwd: string): Promise<void> => {
+    const forgePath = path.join(cwd, 'forge.json')
+    await fs.writeFile(forgePath, JSON.stringify(forge, null, 2))
+  }
+}
+
+export const create = createTask(
+  schema,
+  boundaries,
+  async function ({ runnerName }, {
+    persistRunner,
+    loadConf,
+    persistConf,
+    getCwd
+  }) {
+    const formattedName = camelCase(runnerName)
+    const cwd = await getCwd()
+
+    const forge = await loadConf({})
+    const runnerPath = forge.paths.runners
+
+    console.log(`
+    ==================================================
+    Starting runner creation!
+    Creating runner: ${formattedName}
+    Into: ${runnerPath}${formattedName}/index.ts
+    ==================================================
+    `)
+
+    const comp = Handlebars.compile(RUNNER_TEMPLATE)
+    const content = comp({
+      runnerName: formattedName
+    })
+
+    await persistRunner(runnerPath, formattedName, content)
+
+    if (forge.runners === undefined) {
+      forge.runners = {}
+    }
+
+    // Create runner descriptor
+    const runnerDescriptor: RunnerDescriptor = {
+      path: `${runnerPath}${formattedName}/index.ts`,
+      version: '0.0.1'
+    }
+
+    forge.runners[formattedName] = runnerDescriptor
+
+    await persistConf(forge, cwd)
+
+    return {
+      runnerPath: `${runnerPath}/${formattedName}`,
+      runnerName: formattedName
+    }
+  }
+)

package/src/tasks/runner/remove.ts

@@ -0,0 +1,74 @@
+// TASK: remove
+// Run this task with:
+// forge task:run runner:remove --runnerName <runner-name>
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import path from 'path'
+import fs from 'fs/promises'
+import { camelCase } from '../../utils/camelCase'
+import { load } from '../conf/load'
+import { type ForgeConf } from '../types'
+
+const schema = new Schema({
+  runnerName: Schema.string()
+})
+
+const boundaries = {
+  // Load boundaries
+  loadConf: load.asBoundary(),
+  getCwd: async (): Promise<string> => {
+    return process.cwd()
+  },
+
+  // File system operations
+  removeRunner: async (runnerPath: string): Promise<void> => {
+    await fs.rm(runnerPath, { recursive: true, force: true })
+  },
+  // Configuration operations
+  persistConf: async (forge: ForgeConf, cwd: string): Promise<void> => {
+    const forgePath = path.join(cwd, 'forge.json')
+    await fs.writeFile(forgePath, JSON.stringify(forge, null, 2))
+  }
+}
+
+export const remove = createTask(
+  schema,
+  boundaries,
+  async function ({ runnerName }, {
+    loadConf,
+    getCwd,
+    removeRunner,
+    persistConf
+  }) {
+    const formattedName = camelCase(runnerName)
+    const cwd = await getCwd()
+    const forge = await loadConf({})
+
+    if (!forge.runners || !forge.runners[formattedName]) {
+      throw new Error(`Runner '${formattedName}' not found in forge.json configuration`)
+    }
+
+    const runnerConfig = forge.runners[formattedName]
+    const runnerFolder = path.join(cwd, path.dirname(runnerConfig.path))
+
+    console.log(`
+    ==================================================
+    Removing runner: ${formattedName}
+    Path: ${runnerFolder}
+    ==================================================
+    `)
+
+    await removeRunner(runnerFolder)
+
+    delete forge.runners[formattedName]
+
+    await persistConf(forge, cwd)
+
+    return {
+      status: 'success',
+      message: `Runner '${formattedName}' successfully removed`,
+      runnerName: formattedName
+    }
+  }
+)

package/src/tasks/task/createTask.ts

@@ -18,6 +18,8 @@ const TASK_TEMPLATE = `// TASK: {{ taskName }}
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 
+const description = 'Add task description here'
+
 const schema = new Schema({
   // Add your schema definitions here
   // example: myParam: Schema.string()
@@ -40,6 +42,8 @@ export const {{ taskName }} = createTask(
     return status
   }
 )
+
+{{ taskName }}.setDescription(description)
 `
 
 const schema = new Schema({

package/src/tasks/task/download.ts

@@ -0,0 +1,192 @@
+// TASK: download
+// Run this task with:
+// forge task:run task:download --descriptorName [name] --uuid [task-uuid]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import axios from 'axios'
+import path from 'path'
+import fs from 'fs/promises'
+import { camelCase } from '../../utils/camelCase'
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { Profile, type ForgeConf } from '../types'
+
+const schema = new Schema({
+  descriptorName: Schema.string(),
+  uuid: Schema.string()
+})
+
+const boundaries = {
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  downloadTask: async (uuid: string, profile: Profile): Promise<any> => {
+    const downloadUrl = `${profile.url}/api/tasks/download`
+
+    console.log(`Downloading task from ${downloadUrl}...`)
+
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    const response = await axios.post(downloadUrl, { uuid }, {
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        'Content-Type': 'application/json'
+      }
+    })
+
+    return response.data
+  },
+  loadConf: loadConf.asBoundary(),
+  getCwd: async (): Promise<string> => {
+    return process.cwd()
+  },
+  parseTaskName: async (taskDescriptor: string): Promise<{
+    descriptor: string
+    taskName: string
+    fileName: string
+    dir?: string
+  }> => {
+    const res: string[] = taskDescriptor.split(':')
+
+    if (res.length === 1) {
+      return {
+        descriptor: `${camelCase(res[0])}`,
+        taskName: `${camelCase(res[0])}`,
+        fileName: `${camelCase(res[0])}.ts`
+      }
+    }
+
+    return {
+      dir: res[0],
+      descriptor: `${res[0]}:${camelCase(res[1])}`,
+      taskName: `${camelCase(res[1])}`,
+      fileName: `${camelCase(res[1])}.ts`
+    }
+  },
+  persistTask: async (dir: string, fileName: string, content: string, cwd: string): Promise<{ path: string }> => {
+    const dirPath = path.resolve(cwd, dir)
+    const taskPath = path.resolve(dirPath, fileName)
+
+    await fs.mkdir(dirPath, { recursive: true })
+    await fs.writeFile(taskPath, content, 'utf-8')
+
+
+    return {
+      path: taskPath.toString()
+    }
+  },
+  persistConf: async (forge: ForgeConf, cwd: string): Promise<void> => {
+    const forgePath = path.join(cwd, 'forge.json')
+    await fs.writeFile(forgePath, JSON.stringify(forge, null, 2))
+  },
+  checkTaskExists: async (dir: string, fileName: string): Promise<boolean> => {
+    const taskPath = path.resolve(dir, fileName)
+
+    try {
+      await fs.access(taskPath)
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+export const download = createTask(
+  schema,
+  boundaries,
+  async function ({ descriptorName, uuid }, {
+    downloadTask,
+    getCwd,
+    parseTaskName,
+    persistTask,
+    loadConf,
+    persistConf,
+    checkTaskExists,
+    loadCurrentProfile
+  }) {
+    console.log(`Attempting to download task with descriptor: ${descriptorName} and uuid: ${uuid}`)
+
+    // Parse descriptor name to get task details
+    const { taskName, fileName, descriptor, dir } = await parseTaskName(descriptorName)
+    const profile = await loadCurrentProfile({})
+    const cwd = await getCwd()
+    const forge = await loadConf({})
+
+    let taskPath: string = forge.paths.tasks
+
+    if (dir !== undefined) {
+      taskPath = path.join(taskPath, dir)
+    }
+
+    // Check if task already exists
+    const taskExists = await checkTaskExists(taskPath, fileName)
+    if (taskExists) {
+      console.log(`Task ${descriptor} already exists at ${taskPath}/${fileName}`)
+      return {
+        error: 'Task already exists',
+        taskPath: `${taskPath}/${fileName}`,
+        descriptor
+      }
+    }
+
+    // Download from hive api server
+    let response
+    try {
+      response = await downloadTask(uuid, profile)
+    } catch (e: unknown) {
+      const error = e as { status: number, message: string }
+      console.error('Error downloading task:', error.message, error.status)
+
+      if (error.status === 404) {
+        return {
+          error: 'Task not found',
+          taskPath: `${taskPath}/${fileName}`,
+          descriptor
+        }
+      }
+
+      return {
+        error: 'Failed to download task',
+        message: error.message,
+        taskPath: `${taskPath}/${fileName}`,
+        descriptor
+      }
+    }
+
+    console.log(`
+    ==================================================
+    Starting task download!
+    Creating: ${taskName}
+    Dir:  ${dir ?? ''}
+    Into: ${taskPath}
+    ==================================================
+    `)
+
+    console.log('Writing task file:', taskPath, fileName)
+    console.log('Handler:', response.handler)
+    console.log('Source code:', response.sourceCode)
+
+    // Persist task with cwd
+    await persistTask(taskPath, fileName, response.sourceCode, cwd)
+
+    // Update forge.json with the new task
+    if (forge.tasks === undefined) {
+      forge.tasks = {}
+    }
+
+    forge.tasks[descriptor] = {
+      path: `${taskPath}/${fileName}`,
+      handler: response.handler
+    }
+
+    console.log('Forge:', forge)
+
+    await persistConf(forge, cwd)
+
+    return {
+      taskPath,
+      fileName,
+      descriptor,
+      handler: response.handler
+    }
+  }
+)

package/src/tasks/task/publish.ts

@@ -0,0 +1,135 @@
+// TASK: publish
+// Run this task with:
+// forge task:run task:publish --descriptorMame task-name
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import axios from 'axios'
+
+import path from 'path'
+import fs from 'fs/promises'
+import os from 'os'
+
+import { load as loadConf } from '../conf/load'
+import { create as bundleCreate } from '../bundle/create'
+import { load as bundleLoad } from '../bundle/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { Profile } from '../types'
+
+const schema = new Schema({
+  descriptorName: Schema.string()
+})
+
+const boundaries = {
+  getCwd: async (): Promise<string> => {
+    return process.cwd()
+  },
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  bundleCreate: bundleCreate.asBoundary(),
+  bundleLoad: bundleLoad.asBoundary(),
+  readFileUtf8: async (filePath: string): Promise<string> => {
+    return fs.readFile(filePath, 'utf-8')
+  },
+  readFileBinary: async (filePath: string): Promise<Buffer> => {
+    return fs.readFile(filePath)
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  publishTask: async (data: any, profile: Profile): Promise<any> => {
+    const publishUrl = `${profile.url}/api/tasks/publish`
+
+    console.log(`Publishing task to ${publishUrl}...`)
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    const response = await axios.post(publishUrl, data, {
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        'Content-Type': 'application/json'
+      }
+    })
+
+    return response.data
+  },
+
+  ensureBuildsFolder: async (): Promise<string> => {
+    const buildsPath = path.join(os.homedir(), '.forge', 'builds')
+    try {
+      await fs.access(buildsPath)
+    } catch {
+      await fs.mkdir(buildsPath, { recursive: true })
+    }
+
+    return buildsPath
+  }
+}
+
+export const publish = createTask(
+  schema,
+  boundaries,
+  async function ({ descriptorName }, {
+    getCwd,
+    ensureBuildsFolder,
+    loadConf,
+    bundleCreate,
+    bundleLoad,
+    readFileUtf8,
+    readFileBinary,
+    publishTask,
+    loadCurrentProfile
+  }) {
+    const cwd = await getCwd()
+    const forgeJson = await loadConf({})
+    const profile = await loadCurrentProfile({})
+
+    const taskDescriptor = forgeJson.tasks[descriptorName as keyof typeof forgeJson.tasks]
+    const projectName = forgeJson.project.name
+
+    if (taskDescriptor === undefined) {
+      throw new Error('Task is not defined on forge.json')
+    }
+
+    const entryPoint = path.join(cwd, taskDescriptor.path)
+    const buildsPath = await ensureBuildsFolder()
+    const outputFile = path.join(buildsPath, `${descriptorName}.js`)
+
+    console.log('entryPoint:', entryPoint)
+    console.log('buildsPath:', buildsPath)
+    console.log('outputFile:', outputFile)
+
+    // Bundle the task
+    await bundleCreate({
+      entryPoint,
+      outputFile
+    })
+
+    // Load the bundled task
+    const bundle = await bundleLoad({
+      bundlePath: outputFile
+    })
+
+    // Get the task handler
+    const task = bundle[taskDescriptor.handler]
+    const description = task.getDescription() ?? ''
+    const schema = task.getSchema() || new Schema({})
+    const schemaDescriptor = schema.describe()
+
+    // Read the task file content and bundle
+    const sourceCode = await readFileUtf8(entryPoint)
+    const bundleContent = await readFileBinary(outputFile)
+
+    const data = {
+      ...taskDescriptor,
+      taskName: descriptorName,
+      projectName,
+      description,
+      schemaDescriptor: JSON.stringify(schemaDescriptor),
+      sourceCode,
+      bundle: bundleContent.toString('base64')
+    }
+
+    // Publish to hive api server
+    const response = await publishTask(data, profile)
+
+    console.log('Publish response:', response)
+    return { descriptor: taskDescriptor, publishResponse: response }
+  }
+)

package/src/tasks/types.ts

@@ -39,3 +39,15 @@ export interface TaskName {
   fileName: string
   dir?: string
 }
+
+export interface Profile {
+  name: string
+  apiKey: string
+  apiSecret: string
+  url: string
+}
+
+export interface Profiles {
+  default: string
+  profiles: Profile[]
+}

package/src/test/tasks/create.test.ts

@@ -12,6 +12,8 @@ const expectedContent = `// TASK: newTask
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 
+const description = 'Add task description here'
+
 const schema = new Schema({
   // Add your schema definitions here
   // example: myParam: Schema.string()
@@ -34,6 +36,8 @@ export const newTask = createTask(
     return status
   }
 )
+
+newTask.setDescription(description)
 `
 
 describe('Create task', () => {