@forgehive/forge-cli 0.3.11 → 0.3.12

package/dist/tasks/task/run.d.ts

@@ -17,7 +17,11 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     ensureLogFolder: (logsPath: string) => Promise<void>;
     ensureBuildsFolder: () => Promise<string>;
-    sendLogToAPI: (profile: Profile, projectName: string, record: ExecutionRecord) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, projectName: string, record: ExecutionRecord, taskUuid?: string) => Promise<{
+        success: boolean;
+        logUuid?: string;
+        taskUuid?: string;
+    }>;
 }>) => Promise<any>, {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
@@ -32,5 +36,9 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     ensureLogFolder: (logsPath: string) => Promise<void>;
     ensureBuildsFolder: () => Promise<string>;
-    sendLogToAPI: (profile: Profile, projectName: string, record: ExecutionRecord) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, projectName: string, record: ExecutionRecord, taskUuid?: string) => Promise<{
+        success: boolean;
+        logUuid?: string;
+        taskUuid?: string;
+    }>;
 }>;

package/dist/tasks/task/run.js

@@ -50,7 +50,7 @@ const boundaries = {
         }
         return buildsPath;
     },
-    sendLogToAPI: async (profile, projectName, record) => {
+    sendLogToAPI: async (profile, projectName, record, taskUuid) => {
         try {
             const config = {
                 projectName,
@@ -63,21 +63,25 @@ const boundaries = {
             };
             const client = new hive_sdk_1.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;
+                    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;
             console.error('Error:', error.message);
-            return false;
+            return { success: false };
         }
     }
 };
@@ -89,6 +93,7 @@ exports.run = (0, task_1.createTask)({
         const forge = await loadConf({});
         const taskDescriptor = forge.tasks[descriptorName];
         const projectName = forge.project.name;
+        const taskUuid = taskDescriptor?.uuid;
         if (taskDescriptor === undefined) {
             throw new Error('Task is not defined on forge.json');
         }
@@ -149,7 +154,10 @@ exports.run = (0, task_1.createTask)({
         await tape.save();
         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/dist/tasks/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,7 +10,7 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/hive-sdk": "^0.1.2",
+      "@forgehive/hive-sdk": "^0.1.3",
       "@forgehive/record-tape": "^0.2.5",
       "@forgehive/runner": "^0.2.5",
       "@forgehive/schema": "^0.1.4",
@@ -30,7 +30,7 @@
     "minimist": "^1.2.8",
     "typescript": "^5.3.3",
     "uuid": "^11.1.0",
-    "@forgehive/hive-sdk": "0.1.2",
+    "@forgehive/hive-sdk": "0.1.3",
     "@forgehive/record-tape": "0.2.5",
     "@forgehive/runner": "0.2.5",
     "@forgehive/schema": "0.1.4",

package/src/runner.ts

@@ -32,10 +32,12 @@ import { add as addProfile } from './tasks/auth/add'
 import { switchProfile } from './tasks/auth/switch'
 import { list as listProfiles } from './tasks/auth/list'
 import { remove as removeProfile } from './tasks/auth/remove'
+import { clear as clearProfiles } from './tasks/auth/clear'
 
 import { create as createProject } from './tasks/project/create'
 import { link as linkProject } from './tasks/project/link'
 import { unlink as unlinkProject } from './tasks/project/unlink'
+import { sync as syncProject } from './tasks/project/sync'
 
 interface CliParsedArguments extends RunnerParsedArguments {
   action: string;
@@ -83,11 +85,13 @@ runner.load('auth:add', addProfile)
 runner.load('auth:switch', switchProfile)
 runner.load('auth:list', listProfiles)
 runner.load('auth:remove', removeProfile)
+runner.load('auth:clear', clearProfiles)
 
 // Project commands
 runner.load('project:create', createProject)
 runner.load('project:link', linkProject)
 runner.load('project:unlink', unlinkProject)
+runner.load('project:sync', syncProject)
 
 // Set handler
 runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
@@ -101,7 +105,7 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
   let silent = false
   const task = runner.getTask(taskName)
   if (!task) {
-    throw new Error(`Task "${taskName}" not found`)
+    throw new Error(`Forge command "${taskName}" not found`)
   }
 
   try {
@@ -109,6 +113,8 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
 
     const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish', 'task:describe', 'task:fingerprint']
     const commandsWithRunner = ['runner:create', 'runner:remove']
+    const commandsWithoutParams = ['project:unlink', 'project:sync', 'auth:clear']
+    const silentCommands = ['task:describe', 'task:list', 'auth:list', 'info']
 
     if (commandsWithDescriptor.includes(taskName)) {
       result = await task.run({ descriptorName: action })
@@ -195,17 +201,14 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
       result = await task.run({
         uuid
       })
-    } else if (taskName === 'project:unlink') {
+    } else if (commandsWithoutParams.includes(taskName)) {
       result = await task.run({})
     } else {
       result = await task.run(args)
 
-      if (taskName === 'info') {
-        silent = true
-      }
     }
 
-    if (taskName === 'task:describe' || taskName === 'task:list' || taskName === 'auth:list') {
+    if (silentCommands.includes(taskName)) {
       silent = true
     }
 

package/src/tasks/auth/add.ts

@@ -24,23 +24,83 @@ const boundaries = {
     const buildsPath = path.join(os.homedir(), '.forge')
     const profilesPath = path.join(buildsPath, 'profiles.json')
     await fs.writeFile(profilesPath, JSON.stringify(profiles, null, 2))
+  },
+  fetchMeInfo: async (apiKey: string, apiSecret: string, url: string): Promise<{
+    success: boolean
+    teamName?: string
+    teamUuid?: string
+    userName?: string
+    error?: string
+  }> => {
+    try {
+      const response = await fetch(`${url}/api/me`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${apiKey}:${apiSecret}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        return {
+          success: true,
+          teamName: data.team?.name,
+          teamUuid: data.team?.uuid,
+          userName: data.user?.name
+        }
+      } 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' }
+    }
   }
 }
 
 export const add = createTask({
   schema,
   boundaries,
-  fn: async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
+  fn: async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles, fetchMeInfo }) {
     const profiles = await loadProfiles({})
 
+    console.log('Verifying credentials...')
+
+    // Fetch team and user information from /me endpoint
+    const meInfo = await fetchMeInfo(apiKey, apiSecret, url)
+
+    if (!meInfo.success) {
+      throw new Error(`Failed to verify credentials: ${meInfo.error}`)
+    }
+
+    console.log('✅ Credentials verified')
+    if (meInfo.userName) {
+      console.log(`   User: ${meInfo.userName}`)
+    }
+    if (meInfo.teamName) {
+      console.log(`   Team: ${meInfo.teamName}`)
+    }
+
+    // Create profile with team information
+    const profile = {
+      name,
+      apiKey,
+      apiSecret,
+      url,
+      teamName: meInfo.teamName,
+      teamUuid: meInfo.teamUuid,
+      userName: meInfo.userName
+    }
+
     // Check if profile with same name already exists
     const existingProfileIndex = profiles.profiles.findIndex(p => p.name === name)
     if (existingProfileIndex >= 0) {
       // Replace existing profile
-      profiles.profiles[existingProfileIndex] = { name, apiKey, apiSecret, url }
+      profiles.profiles[existingProfileIndex] = profile
     } else {
       // Add new profile
-      profiles.profiles.push({ name, apiKey, apiSecret, url })
+      profiles.profiles.push(profile)
     }
 
     // Set as default profile
@@ -51,7 +111,9 @@ export const add = createTask({
 
     return {
       status: 'Ok',
-      message: `Profile '${name}' added and set as default`
+      message: `Profile '${name}' added and set as default`,
+      teamName: meInfo.teamName,
+      userName: meInfo.userName
     }
   }
 })

package/src/tasks/auth/clear.ts

@@ -0,0 +1,63 @@
+// TASK: clear
+// Run this task with:
+// forge task:run auth:clear
+
+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({})
+
+const boundaries = {
+  loadProfiles: loadProfiles.asBoundary(),
+  clearProfiles: async (): Promise<void> => {
+    const buildsPath = path.join(os.homedir(), '.forge')
+    const profilesPath = path.join(buildsPath, 'profiles.json')
+
+    // Create empty profiles structure
+    const emptyProfiles: Profiles = {
+      default: '',
+      profiles: []
+    }
+
+    await fs.writeFile(profilesPath, JSON.stringify(emptyProfiles, null, 2))
+  }
+}
+
+export const clear = createTask({
+  schema,
+  boundaries,
+  fn: async function (_argv, { loadProfiles, clearProfiles }) {
+    const profiles = await loadProfiles({})
+
+    if (profiles.profiles.length === 0) {
+      console.log('No profiles found to clear.')
+      return { status: 'Ok', message: 'No profiles found' }
+    }
+
+    const profileCount = profiles.profiles.length
+    console.log(`Found ${profileCount} profile(s) to clear:`)
+
+    profiles.profiles.forEach(profile => {
+      console.log(`  - ${profile.name} (${profile.teamName || 'Unknown team'})`)
+    })
+
+    console.log('\\nClearing all profiles...')
+
+    // Clear all profiles
+    await clearProfiles()
+
+    console.log('✅ All profiles cleared successfully')
+
+    return {
+      status: 'Ok',
+      message: `Cleared ${profileCount} profile(s)`,
+      clearedCount: profileCount
+    }
+  }
+})

package/src/tasks/auth/list.ts

@@ -32,6 +32,12 @@ export const list = createTask({
       console.log(`  Name: ${currentProfile.name}`)
       console.log(`  API Key: ${currentProfile.apiKey}`)
       console.log(`  URL: ${currentProfile.url}`)
+      if (currentProfile.userName) {
+        console.log(`  User: ${currentProfile.userName}`)
+      }
+      if (currentProfile.teamName) {
+        console.log(`  Team: ${currentProfile.teamName}`)
+      }
       console.log('')
     }
 
@@ -40,10 +46,12 @@ export const list = createTask({
     const tableData = profiles.profiles.map(profile => ({
       Name: profile.name,
       'API Key': profile.apiKey,
-      URL: profile.url
+      URL: profile.url,
+      Team: profile.teamName || 'Unknown',
+      User: profile.userName || 'Unknown'
     }))
 
-    console.table(tableData, ['Name', 'API Key', 'URL'])
+    console.table(tableData, ['Name', 'API Key', 'URL', 'Team', 'User'])
 
     console.log('\nUse auth:add to create or update a profile')
     console.log('Use auth:switch [name] or auth:switch [index] to switch profiles')

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/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 }
   }
 })