@forgehive/forge-cli 0.3.11 → 0.3.13

package/src/tasks/task/createTask.ts

@@ -8,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
@@ -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,14 +191,42 @@ export const createTaskCommand = createTask({
       forge.tasks = {}
     }
 
+    const taskUuid = uuidv4()
     forge.tasks[descriptor] = {
       path: `${taskPath}/${fileName}`,
       handler: taskName,
-      uuid: uuidv4()
+      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,10 +49,34 @@ const boundaries = {
 
     return buildsPath
   },
-  sendLogToAPI: async (profile: Profile, projectName: string, record: ExecutionRecord): Promise<boolean> => {
+  sendLogToAPI: async (
+    profile: Profile,
+    projectName: string,
+    record: ExecutionRecord,
+    taskUuid?: string,
+    projectUuid?: string
+  ): Promise<{ success: boolean; logUuid?: string; taskUuid?: string; skipRemoteLog?: boolean }> => {
+    // Check if we have required UUIDs for the new endpoint
+    if (!projectUuid || !taskUuid) {
+      console.log('===============================================')
+      console.log('⚠️  Remote logging skipped - missing UUIDs')
+      console.log('')
+      console.log('To enable remote logging with enhanced features:')
+      if (!projectUuid) {
+        console.log('• Use "forge project:create" to create a new project, or')
+        console.log('• Use "forge project:link" to connect to an existing project')
+      }
+      if (!taskUuid) {
+        console.log('• Use "forge project:sync" to get the task to have UUID')
+      }
+      console.log('===============================================')
+      return { success: true, skipRemoteLog: true }
+    }
+
     try {
       const config = {
         projectName,
+        projectUuid,
         apiKey: profile.apiKey,
         apiSecret: profile.apiSecret,
         host: profile.url,
@@ -62,21 +86,30 @@ const boundaries = {
       }
 
       const client = new HiveLogClient(config)
-      const result = await client.sendLog(record)
+      console.log('Sending execution log to Hive...')
+      const result = await client.sendLogByUuid(record, taskUuid)
 
-      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
+        console.log('✅ Log sent to Hive successfully')
+        console.log(`   Profile: ${profile.name}`)
+        console.log(`   Host: ${profile.url}`)
+
+        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
+        console.error('❌ Failed to send log to Hive:', profile.url)
+        return { success: false }
       }
     } catch (e) {
-      console.error('Failed to send log to API:', profile.url)
+      console.error('❌ Failed to send log to Hive:', profile.url)
       const error = e as Error
       console.error('Error:', error.message)
-      return false
+      return { success: false }
     }
   }
 }
@@ -97,6 +130,8 @@ 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 projectUuid = forge.project.uuid
+    const taskUuid = taskDescriptor?.uuid
 
     if (taskDescriptor === undefined) {
       throw new Error('Task is not defined on forge.json')
@@ -169,7 +204,11 @@ export const run = createTask({
 
     if (profile) {
       try {
-        await sendLogToAPI(profile, projectName, logItem)
+        const logResult = await sendLogToAPI(profile, projectName, logItem, taskUuid, projectUuid)
+
+        if (logResult.success && !logResult.skipRemoteLog && 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

@@ -48,6 +48,9 @@ export interface Profile {
   apiKey: string
   apiSecret: string
   url: string
+  teamName?: string
+  teamUuid?: string
+  userName?: string
 }
 
 export interface Profiles {