@forgehive/forge-cli 0.1.8 → 0.2.0

package/src/tasks/auth/loadCurrent.ts

@@ -0,0 +1,35 @@
+// TASK: loadCurrent
+// Run this task with:
+// forge task:run auth:loadCurrent
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+
+import { load as loadProfiles } from './load'
+import { type Profile } from '../types'
+
+const schema = new Schema({})
+
+const boundaries = {
+  loadProfiles: loadProfiles.asBoundary()
+}
+
+export const loadCurrent = createTask(
+  schema,
+  boundaries,
+  async function (_argv, { loadProfiles }): Promise<Profile> {
+    const profiles = await loadProfiles({})
+
+    if (!profiles.default || profiles.default === '') {
+      throw new Error('No default profile set. Please run forge task:run auth:add to create a profile.')
+    }
+
+    const defaultProfile = profiles.profiles.find(profile => profile.name === profiles.default)
+
+    if (!defaultProfile) {
+      throw new Error(`Default profile "${profiles.default}" not found in profiles.`)
+    }
+
+    return { ...defaultProfile, name: profiles.default }
+  }
+)

package/src/tasks/auth/remove.ts

@@ -0,0 +1,66 @@
+// TASK: remove
+// Run this task with:
+// forge task:run auth:remove --profileName [name]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import path from 'path'
+import fs from 'fs/promises'
+import os from 'os'
+
+import { load as loadProfiles } from './load'
+import { type Profiles } from '../types'
+
+const schema = new Schema({
+  profileName: Schema.string()
+})
+
+const boundaries = {
+  loadProfiles: loadProfiles.asBoundary(),
+  persistProfiles: async (profiles: Profiles): Promise<void> => {
+    const buildsPath = path.join(os.homedir(), '.forge')
+    const profilesPath = path.join(buildsPath, 'profiles.json')
+    await fs.writeFile(profilesPath, JSON.stringify(profiles, null, 2))
+  }
+}
+
+export const remove = createTask(
+  schema,
+  boundaries,
+  async function ({ profileName }, { loadProfiles, persistProfiles }) {
+    const profiles = await loadProfiles({})
+
+    // Check if profile exists
+    const profileExists = profiles.profiles.some(profile => profile.name === profileName)
+
+    if (!profileExists) {
+      throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`)
+    }
+
+    // Remove the profile using filter
+    profiles.profiles = profiles.profiles.filter(profile => profile.name !== profileName)
+
+    // If the removed profile was the default, update the default
+    if (profiles.default === profileName) {
+      if (profiles.profiles.length > 0) {
+        // Set the first available profile as default
+        profiles.default = profiles.profiles[0].name
+        console.log(`Default profile set to: ${profiles.default}`)
+      } else {
+        // No profiles left, set default to empty
+        profiles.default = ''
+        console.log('No profiles left. Default set to empty.')
+      }
+    }
+
+    // Persist updated profiles
+    await persistProfiles(profiles)
+
+    console.log(`Profile "${profileName}" has been removed.`)
+
+    return {
+      status: 'Ok',
+      message: `Profile "${profileName}" has been removed.`
+    }
+  }
+)

package/src/tasks/auth/switch.ts

@@ -0,0 +1,53 @@
+// TASK: switch
+// Run this task with:
+// forge task:run auth:switch --profileName [name]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import path from 'path'
+import fs from 'fs/promises'
+import os from 'os'
+
+import { load as loadProfiles } from './load'
+import { type Profiles } from '../types'
+
+const schema = new Schema({
+  profileName: Schema.string()
+})
+
+const boundaries = {
+  loadProfiles: loadProfiles.asBoundary(),
+  persistProfiles: async (profiles: Profiles): Promise<void> => {
+    const buildsPath = path.join(os.homedir(), '.forge')
+    const profilesPath = path.join(buildsPath, 'profiles.json')
+    await fs.writeFile(profilesPath, JSON.stringify(profiles, null, 2))
+  }
+}
+
+export const switchProfile = createTask(
+  schema,
+  boundaries,
+  async function ({ profileName }, { loadProfiles, persistProfiles }) {
+    // Load profiles
+    const profiles = await loadProfiles({})
+
+    // Check if profile exists
+    const profileExists = profiles.profiles.some(profile => profile.name === profileName)
+
+    if (!profileExists) {
+      throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`)
+    }
+
+    // Update default profile
+    profiles.default = profileName
+
+    // Save updated profiles
+    await persistProfiles(profiles)
+
+    console.log(`Switched to profile: ${profileName}`)
+
+    return {
+      default: profileName
+    }
+  }
+)

package/src/tasks/conf/info.ts

@@ -7,26 +7,34 @@ import { Schema } from '@forgehive/schema'
 import * as fs from 'fs'
 import * as path from 'path'
 
-const schema = new Schema({
-  // No parameters needed for this task
-})
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+
+const schema = new Schema({})
 
 const boundaries = {
-  readFile: async (filePath: string): Promise<string> => fs.promises.readFile(filePath, 'utf-8')
+  readFile: async (filePath: string): Promise<string> => fs.promises.readFile(filePath, 'utf-8'),
+  loadCurrentProfile: loadCurrentProfile.asBoundary()
 }
 
 export const info = createTask(
   schema,
   boundaries,
-  async function (_argv, boundaries) {
+  async function (_argv, { loadCurrentProfile, readFile }) {
     const packageJsonPath = path.join(__dirname, '../../../package.json')
-    console.log('packageJsonPath', packageJsonPath)
 
-    const packageJsonContent = await boundaries.readFile(packageJsonPath)
+
+    const packageJsonContent = await readFile(packageJsonPath)
     const packageJson = JSON.parse(packageJsonContent)
 
+    const profile = await loadCurrentProfile({})
+
     return {
-      version: packageJson.version
+      version: packageJson.version,
+      profile: {
+        name: profile.name,
+        url: profile.url,
+        apiKey: profile.apiKey
+      }
     }
   }
 )

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', () => {