@forgehive/forge-cli 0.3.10 → 0.3.12

package/src/tasks/project/create.ts

@@ -0,0 +1,111 @@
+// TASK: create
+// Run this task with:
+// forge task:run project:create
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import { v4 as uuidv4 } from 'uuid'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+const name = 'project:create'
+const description = 'Create a new project in ForgeHive'
+
+const schema = new Schema({
+  projectName: Schema.string().optional(),
+  description: Schema.string().optional()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  },
+  createProject: async (profile: Profile, payload: { projectName: string; description: string; uuid: string }): Promise<Response> => {
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    return await fetch(`${profile.url}/api/projects`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      body: JSON.stringify(payload)
+    })
+  }
+}
+
+export const create = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function (argv, { loadConf, loadCurrentProfile, writeFile, createProject }) {
+    const { projectName: inputProjectName, description } = argv
+
+    // Load current configuration
+    const conf = await loadConf({})
+
+    // Use provided projectName or fall back to forge.json project name
+    const projectName = inputProjectName || conf.project.name
+
+    if (!projectName) {
+      throw new Error('Project name is required. Provide --projectName or ensure forge.json has a project name.')
+    }
+
+    // Check if project already has a UUID, generate one if not
+    let projectUuid = conf.project.uuid
+    if (!projectUuid) {
+      projectUuid = uuidv4()
+
+      // Update forge.json with the new UUID
+      const forgePath = path.join(process.cwd(), 'forge.json')
+      const updatedConf: ForgeConf = {
+        ...conf,
+        project: {
+          ...conf.project,
+          uuid: projectUuid
+        }
+      }
+
+      await writeFile(forgePath, JSON.stringify(updatedConf, null, 2))
+      console.log(`Generated and saved project UUID: ${projectUuid}`)
+    }
+
+    // Load current profile for API authentication
+    const profile = await loadCurrentProfile({})
+
+    // Prepare API request payload
+    const payload = {
+      projectName,
+      description: description || '',
+      uuid: projectUuid
+    }
+
+    // Make API request to create project
+    const response = await createProject(profile, payload)
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      throw new Error(`Failed to create project: ${response.status} ${response.statusText} - ${errorText}`)
+    }
+
+    const result = await response.json()
+
+    console.log('Project created successfully!')
+    console.log(`Project UUID: ${result.project.uuid}`)
+    console.log(`Project Name: ${result.project.projectName}`)
+    console.log(`\n🌐 View your project on the dashboard: ${profile.url}/dashboard/projects/${result.project.uuid}`)
+
+    return {
+      success: true,
+      project: result.project,
+      localUuid: projectUuid
+    }
+  }
+})
+

package/src/tasks/project/link.ts

@@ -0,0 +1,106 @@
+// TASK: link
+// Run this task with:
+// forge project:link [uuid]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+const name = 'project:link'
+const description = 'Link an existing remote project to the local project by UUID'
+
+const schema = new Schema({
+  uuid: Schema.string()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  },
+  fetchProject: async (profile: Profile, uuid: string): Promise<Response> => {
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    console.log(`Fetching project ${uuid} from ${profile.url}...`)
+    return await fetch(`${profile.url}/api/projects/${uuid}`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${authToken}`
+      }
+    })
+  }
+}
+
+export const link = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function ({ uuid }, { loadConf, loadCurrentProfile, writeFile, fetchProject }) {
+    // Load current configuration and profile
+    const conf = await loadConf({})
+
+    // Check if project already has a UUID
+    if (conf.project.uuid) {
+      throw new Error(`Project is already linked to UUID: ${conf.project.uuid}. Use a different project or remove the existing UUID from forge.json first.`)
+    }
+
+    const profile = await loadCurrentProfile({})
+
+    console.log(`Checking if project ${uuid} exists on ${profile.url}...`)
+
+    // Check if project exists on remote
+    const response = await fetchProject(profile, uuid)
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Project with UUID ${uuid} not found on ${profile.url}. Please verify the UUID is correct.`)
+      } else if (response.status === 401) {
+        throw new Error('Authentication failed. Please check your profile credentials with \'forge auth:list\'.')
+      } else {
+        const errorText = await response.text()
+        throw new Error(`Failed to verify project: ${response.status} ${response.statusText} - ${errorText}`)
+      }
+    }
+
+    const projectData = await response.json()
+    const project = projectData.project
+
+    console.log(`✓ Found project: ${project.projectName}`)
+    console.log(`  Description: ${project.description || 'No description'}`)
+    console.log(`  Tasks: ${project.tasks.length} task(s)`)
+
+    // Update forge.json with the UUID
+    const forgePath = path.join(process.cwd(), 'forge.json')
+    const updatedConf: ForgeConf = {
+      ...conf,
+      project: {
+        ...conf.project,
+        uuid: uuid
+      }
+    }
+
+    await writeFile(forgePath, JSON.stringify(updatedConf, null, 2))
+
+    console.log(`\n✓ Successfully linked project ${uuid} to local forge.json`)
+    console.log(`  Local project name: ${conf.project.name}`)
+    console.log(`  Remote project name: ${project.projectName}`)
+    console.log(`\n🌐 View your project on the dashboard: ${profile.url}/dashboard/projects/${uuid}`)
+
+    return {
+      success: true,
+      linkedProject: {
+        uuid: project.uuid,
+        name: project.projectName,
+        description: project.description,
+        tasksCount: project.tasks.length
+      }
+    }
+  }
+})
+

package/src/tasks/project/sync.ts

@@ -0,0 +1,202 @@
+// TASK: sync
+// Run this task with:
+// forge task:run project:sync
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import { v4 as uuidv4 } from 'uuid'
+
+import { load } from '../conf/load'
+import { loadCurrent } from '../auth/loadCurrent'
+import { type ForgeConf } from '../types'
+import path from 'path'
+import fs from 'fs/promises'
+
+const schema = new Schema({})
+
+const boundaries = {
+  loadConf: load.asBoundary(),
+  loadCurrentProfile: loadCurrent.asBoundary(),
+  getCwd: async (): Promise<string> => {
+    return process.cwd()
+  },
+  persistConf: async (forge: ForgeConf, cwd: string): Promise<void> => {
+    const forgePath = path.join(cwd, 'forge.json')
+    await fs.writeFile(forgePath, JSON.stringify(forge, null, 2))
+  },
+  syncTasksToHive: async (
+    projectUuid: string,
+    tasks: Array<{ uuid: string; name: string }>,
+    apiKey: string,
+    apiSecret: string,
+    baseUrl: string
+  ): Promise<{
+    success: boolean
+    error?: string
+    data?: {
+      projectUuid: string
+      projectName: string
+      summary: {
+        total: number
+        created: number
+        updated: number
+        errors: number
+      }
+      results: {
+        created: Array<{ uuid: string; taskName: string; action: string }>
+        updated: Array<{ uuid: string; taskName: string; previousName: string; action: string }>
+        errors: Array<{ uuid: string; taskName: string; error: string }>
+      }
+    }
+  }> => {
+    try {
+      const url = `${baseUrl}/api/projects/${projectUuid}/sync`
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}:${apiSecret}`
+        },
+        body: JSON.stringify({ tasks })
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        return { success: true, data }
+      } else {
+        const errorData = await response.json().catch(() => ({ error: `HTTP ${response.status} - ${response.statusText}` }))
+        return { success: false, error: errorData.error || `HTTP ${response.status} - ${response.statusText}` }
+      }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Network error' }
+    }
+  }
+}
+
+export const sync = createTask({
+  schema,
+  boundaries,
+  fn: async function (_argv, {
+    loadConf,
+    loadCurrentProfile,
+    getCwd,
+    persistConf,
+    syncTasksToHive
+  }) {
+    const cwd = await getCwd()
+    const forge = await loadConf({})
+
+    // Check if project has UUID
+    if (!forge.project.uuid) {
+      throw new Error('Project does not have a UUID. Please run "forge project:link" to connect to a Hive project.')
+    }
+
+    console.log(`
+    ==================================================
+    Starting project sync to Hive!
+    Project: ${forge.project.name}
+    UUID: ${forge.project.uuid}
+    ==================================================
+    `)
+
+    // Ensure all tasks have UUIDs and collect them for sync
+    let configUpdated = false
+    const tasksToSync: Array<{ uuid: string; name: string }> = []
+
+    if (!forge.tasks) {
+      forge.tasks = {}
+    }
+
+    for (const [taskDescriptor, taskData] of Object.entries(forge.tasks)) {
+      if (!taskData.uuid) {
+        taskData.uuid = uuidv4()
+        configUpdated = true
+        console.log(`  ➕ Generated UUID for task: ${taskDescriptor}`)
+      }
+
+      // Use the task descriptor (key) as the name for the API
+      const taskName = taskDescriptor
+      tasksToSync.push({
+        uuid: taskData.uuid,
+        name: taskName
+      })
+    }
+
+    // Save config if we added UUIDs
+    if (configUpdated) {
+      await persistConf(forge, cwd)
+      console.log('  💾 Updated forge.json with new UUIDs')
+    }
+
+    if (tasksToSync.length === 0) {
+      console.log('  ℹ️  No tasks found to sync')
+      return { status: 'no-tasks', message: 'No tasks found in project' }
+    }
+
+    console.log(`  📊 Found ${tasksToSync.length} tasks to sync`)
+
+    try {
+      const profile = await loadCurrentProfile({})
+      const result = await syncTasksToHive(
+        forge.project.uuid,
+        tasksToSync,
+        profile.apiKey,
+        profile.apiSecret,
+        profile.url
+      )
+
+      if (result.success && result.data) {
+        const { summary, results } = result.data
+
+        console.log('\\n  ✅ Sync completed successfully!')
+        console.log(`     Total tasks: ${summary.total}`)
+        console.log(`     Created: ${summary.created}`)
+        console.log(`     Updated: ${summary.updated}`)
+        console.log(`     Errors: ${summary.errors}`)
+
+        if (results.created.length > 0) {
+          console.log('\\n  🆕 Created tasks:')
+          results.created.forEach(task => {
+            console.log(`     • ${task.taskName} (${task.uuid})`)
+          })
+        }
+
+        if (results.updated.length > 0) {
+          console.log('\\n  🔄 Updated tasks:')
+          results.updated.forEach(task => {
+            console.log(`     • ${task.taskName} (was: ${task.previousName}) (${task.uuid})`)
+          })
+        }
+
+        if (results.errors.length > 0) {
+          console.log('\\n  ❌ Tasks with errors:')
+          results.errors.forEach(task => {
+            console.log(`     • ${task.taskName}: ${task.error} (${task.uuid})`)
+          })
+        }
+
+        const projectUrl = `${profile.url}/dashboard/projects/${forge.project.uuid}`
+        console.log(`\\n  🔗 View your project: ${projectUrl}`)
+
+        return {
+          status: 'success',
+          summary,
+          results,
+          projectUrl
+        }
+      } else {
+        throw new Error(result.error || 'Unknown sync error')
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+
+      if (errorMessage.includes('No default profile')) {
+        console.log('\\n  ⚠️  No authentication profile found. Run "forge auth:add" to configure.')
+        return { status: 'no-auth', message: 'No authentication profile configured' }
+      } else {
+        console.log(`\\n  ❌ Sync failed: ${errorMessage}`)
+        return { status: 'error', message: errorMessage }
+      }
+    }
+  }
+})

package/src/tasks/project/unlink.ts

@@ -0,0 +1,74 @@
+// TASK: unlink
+// Run this task with:
+// forge project:unlink
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { type ForgeConf } from '../types'
+
+const name = 'project:unlink'
+const description = 'Remove the project UUID link from local forge.json'
+
+const schema = new Schema({
+  // No parameters needed for unlink
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  }
+}
+
+export const unlink = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function (argv, { loadConf, writeFile }) {
+    // Load current configuration
+    const conf = await loadConf({})
+
+    // Check if project has a UUID to unlink
+    if (!conf.project.uuid) {
+      throw new Error('No project UUID found in forge.json. The project is not currently linked to a remote project.')
+    }
+
+    const currentUuid = conf.project.uuid
+
+    // Remove the UUID from the project configuration
+    const updatedConf: ForgeConf = {
+      ...conf,
+      project: {
+        ...conf.project,
+        uuid: undefined
+      }
+    }
+
+    // Clean up undefined values by creating a new object without the uuid field
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { uuid, ...projectWithoutUuid } = updatedConf.project
+    const finalConf: ForgeConf = {
+      ...updatedConf,
+      project: projectWithoutUuid
+    }
+
+    // Write the updated configuration back to forge.json
+    const forgePath = path.join(process.cwd(), 'forge.json')
+    await writeFile(forgePath, JSON.stringify(finalConf, null, 2))
+
+    console.log(`✓ Successfully unlinked project from UUID: ${currentUuid}`)
+    console.log('  The project is no longer linked to a remote project.')
+    console.log('  You can now link to a different project using \'forge project:link [uuid]\'')
+
+    return {
+      success: true,
+      unlinkedUuid: currentUuid
+    }
+  }
+})
+

package/src/tasks/task/createTask.ts

@@ -1,5 +1,6 @@
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
+import { v4 as uuidv4 } from 'uuid'
 
 import Handlebars from 'handlebars'
 import path from 'path'
@@ -7,6 +8,7 @@ import fs from 'fs/promises'
 import { camelCase } from '../../utils/camelCase'
 
 import { load } from '../conf/load'
+import { loadCurrent } from '../auth/loadCurrent'
 import { type TaskName, type ForgeConf } from '../types'
 
 // Define the template content directly in the code
@@ -38,11 +40,10 @@ export const {{ taskName }} = createTask({
   boundaries,
   fn: async function (argv, boundaries) {
     console.log('input:', argv)
-    console.log('boundaries:', boundaries)
+    console.log('boundaries:', Object.keys(boundaries))
     // Your task implementation goes here
-    const status = { status: 'Ok' }
 
-    return status
+    return {}
   }
 })
 
@@ -55,6 +56,7 @@ const schema = new Schema({
 const boundaries = {
   // Load boundaries
   loadConf: load.asBoundary(),
+  loadCurrentProfile: loadCurrent.asBoundary(),
   loadTemplate: async (): Promise<string> => {
     return TASK_TEMPLATE
   },
@@ -106,6 +108,40 @@ const boundaries = {
   persistConf: async (forge: ForgeConf, cwd: string): Promise<void> => {
     const forgePath = path.join(cwd, 'forge.json')
     await fs.writeFile(forgePath, JSON.stringify(forge, null, 2))
+  },
+  createTaskInHive: async (
+    projectUuid: string,
+    taskUuid: string,
+    taskName: string,
+    description: string,
+    apiKey: string,
+    apiSecret: string,
+    baseUrl: string
+  ): Promise<{ success: boolean; taskUrl?: string; error?: string }> => {
+    try {
+      const url = `${baseUrl}/api/projects/${projectUuid}/tasks/${taskUuid}`
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}:${apiSecret}`
+        },
+        body: JSON.stringify({
+          taskName,
+          description
+        })
+      })
+
+      if (response.ok) {
+        const taskUrl = `${baseUrl}/tasks/${taskUuid}`
+        return { success: true, taskUrl }
+      } else {
+        const errorData = await response.json().catch(() => ({ error: 'Unknown error' }))
+        return { success: false, error: errorData.error || `HTTP ${response.status}` }
+      }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Network error' }
+    }
   }
 }
 
@@ -118,7 +154,9 @@ export const createTaskCommand = createTask({
     loadConf,
     persistConf,
     parseTaskName,
-    getCwd
+    getCwd,
+    loadCurrentProfile,
+    createTaskInHive
   }) {
     const { taskName, fileName, descriptor, dir } = await parseTaskName(descriptorName)
     const cwd = await getCwd()
@@ -153,13 +191,42 @@ export const createTaskCommand = createTask({
       forge.tasks = {}
     }
 
+    const taskUuid = uuidv4()
     forge.tasks[descriptor] = {
       path: `${taskPath}/${fileName}`,
-      handler: taskName
+      handler: taskName,
+      uuid: taskUuid
     }
 
     await persistConf(forge, cwd)
 
+    // Try to create task in Hive if user has profile and project UUID
+    if (forge.project.uuid) {
+      try {
+        const profile = await loadCurrentProfile({})
+        const result = await createTaskInHive(
+          forge.project.uuid,
+          taskUuid,
+          descriptor,
+          'Add task description here',
+          profile.apiKey,
+          profile.apiSecret,
+          profile.url
+        )
+
+        if (result.success && result.taskUrl) {
+          console.log('\\n✅ Task created successfully in Hive!')
+          console.log(`🔗 View your task: ${result.taskUrl}`)
+        } else {
+          console.log(`\n⚠️  Task created locally but could not sync to Hive: ${result.error}`)
+          console.log(`🔗 Host: ${profile.url}`)
+        }
+      } catch (error) {
+        // Silently continue if no profile is configured
+        console.log('\\n📝 Task created locally. Configure a profile with \'forge auth:add\' to sync with Hive.')
+      }
+    }
+
     return { taskPath, fileName }
   }
 })

package/src/tasks/task/run.ts

@@ -49,7 +49,7 @@ const boundaries = {
 
     return buildsPath
   },
-  sendLogToAPI: async (profile: Profile, projectName: string, record: ExecutionRecord): Promise<boolean> => {
+  sendLogToAPI: async (profile: Profile, projectName: string, record: ExecutionRecord, taskUuid?: string): Promise<{ success: boolean; logUuid?: string; taskUuid?: string }> => {
     try {
       const config = {
         projectName,
@@ -64,19 +64,25 @@ const boundaries = {
       const client = new HiveLogClient(config)
       const result = await client.sendLog(record)
 
-      if (result === 'success') {
+      if (result === 'success' || (typeof result === 'object' && 'uuid' in result)) {
         console.log('===============================================')
         console.log('Log sent to API... ', profile.name, profile.url)
-        return true
+
+        if (typeof result === 'object' && result && 'uuid' in result) {
+          const logResponse = result as { uuid: string }
+          return { success: true, logUuid: logResponse.uuid, taskUuid }
+        }
+
+        return { success: true, taskUuid }
       } else {
         console.error('Failed to send log to API:', profile.url)
-        return false
+        return { success: false }
       }
     } catch (e) {
       console.error('Failed to send log to API:', profile.url)
       const error = e as Error
       console.error('Error:', error.message)
-      return false
+      return { success: false }
     }
   }
 }
@@ -97,6 +103,7 @@ export const run = createTask({
     const forge: ForgeConf = await loadConf({})
     const taskDescriptor = forge.tasks[descriptorName as keyof typeof forge.tasks]
     const projectName = forge.project.name
+    const taskUuid = taskDescriptor?.uuid
 
     if (taskDescriptor === undefined) {
       throw new Error('Task is not defined on forge.json')
@@ -169,7 +176,11 @@ export const run = createTask({
 
     if (profile) {
       try {
-        await sendLogToAPI(profile, projectName, logItem)
+        const logResult = await sendLogToAPI(profile, projectName, logItem, taskUuid)
+
+        if (logResult.success && taskUuid) {
+          console.log(`🔗 View execution logs: ${profile.url}/tasks/${taskUuid}?tab=logs`)
+        }
       } catch (e) {
         console.error('Failed to send log to API:', e)
       }

package/src/tasks/types.ts

@@ -10,6 +10,7 @@ export interface RunnerDescriptor {
 export interface TaskDescriptor {
   path: string
   handler: string
+  uuid?: string
 }
 
 export interface Infra {
@@ -47,6 +48,9 @@ export interface Profile {
   apiKey: string
   apiSecret: string
   url: string
+  teamName?: string
+  teamUuid?: string
+  userName?: string
 }
 
 export interface Profiles {