@forgehive/forge-cli 0.3.11 → 0.3.13

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

@@ -17,7 +17,12 @@ 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, projectUuid?: string) => Promise<{
+        success: boolean;
+        logUuid?: string;
+        taskUuid?: string;
+        skipRemoteLog?: boolean;
+    }>;
 }>) => Promise<any>, {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
@@ -32,5 +37,10 @@ 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, projectUuid?: string) => Promise<{
+        success: boolean;
+        logUuid?: string;
+        taskUuid?: string;
+        skipRemoteLog?: boolean;
+    }>;
 }>;

package/dist/tasks/task/run.js

@@ -50,10 +50,27 @@ const boundaries = {
         }
         return buildsPath;
     },
-    sendLogToAPI: async (profile, projectName, record) => {
+    sendLogToAPI: async (profile, projectName, record, taskUuid, projectUuid) => {
+        // 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,22 +79,29 @@ const boundaries = {
                 }
             };
             const client = new hive_sdk_1.HiveLogClient(config);
-            const result = await client.sendLog(record);
-            if (result === 'success') {
+            console.log('Sending execution log to Hive...');
+            const result = await client.sendLogByUuid(record, taskUuid);
+            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;
+                    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;
             console.error('Error:', error.message);
-            return false;
+            return { success: false };
         }
     }
 };
@@ -89,6 +113,8 @@ exports.run = (0, task_1.createTask)({
         const forge = await loadConf({});
         const taskDescriptor = forge.tasks[descriptorName];
         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');
         }
@@ -149,7 +175,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, 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/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/logs/task:list.log

@@ -0,0 +1 @@
+{"input":{},"boundaries":{"loadConf":[{"input":[{}],"output":{"project":{"name":"forge-cli"},"paths":{"logs":"logs/","fixtures":"fixtures","fingerprints":"fingerprints/","tasks":"src/tasks/","runners":"src/runners/","tests":"src/tests/"},"infra":{"region":"us-west-2","bucket":""},"tasks":{"task:createTask":{"path":"src/tasks/task/createTask.ts","handler":"createTask"},"bundle:create":{"path":"src/tasks/bundle/create.ts","handler":"create"},"bundle:load":{"path":"src/tasks/bundle/load.ts","handler":"load"},"task:run":{"path":"src/tasks/task/run.ts","handler":"run"},"task:remove":{"path":"src/tasks/task/remove.ts","handler":"remove"},"conf:info":{"path":"src/tasks/conf/info.ts","handler":"info"},"runner:create":{"path":"src/tasks/runner/create.ts","handler":"create"},"runner:remove":{"path":"src/tasks/runner/remove.ts","handler":"remove"},"runner:bundle":{"path":"src/tasks/runner/bundle.ts","handler":"bundle"},"task:publish":{"path":"src/tasks/task/publish.ts","handler":"publish"},"task:download":{"path":"src/tasks/task/download.ts","handler":"download"},"auth:add":{"path":"src/tasks/auth/add.ts","handler":"add"},"auth:load":{"path":"src/tasks/auth/load.ts","handler":"load"},"auth:loadCurrent":{"path":"src/tasks/auth/loadCurrent.ts","handler":"loadCurrent"},"auth:switch":{"path":"src/tasks/auth/switch.ts","handler":"switchProfile"},"auth:list":{"path":"src/tasks/auth/list.ts","handler":"list"},"auth:remove":{"path":"src/tasks/auth/remove.ts","handler":"remove"},"task:replay":{"path":"src/tasks/task/replay.ts","handler":"replay"},"fixture:download":{"path":"src/tasks/fixture/download.ts","handler":"download"},"bundle:zip":{"path":"src/tasks/bundle/zip.ts","handler":"zip"},"task:list":{"path":"src/tasks/task/list.ts","handler":"list"},"task:describe":{"path":"src/tasks/task/describe.ts","handler":"describe"},"task:fingerprint":{"path":"src/tasks/task/fingerprint.ts","handler":"fingerprint"},"bundle:fingerprint":{"path":"src/tasks/bundle/fingerprint.ts","handler":"fingerprint"},"task:invoke":{"path":"src/tasks/task/invoke.ts","handler":"invoke"},"docs:download":{"path":"src/tasks/docs/download.ts","handler":"download"},"project:create":{"path":"src/tasks/project/create.ts","handler":"create"},"project:link":{"path":"src/tasks/project/link.ts","handler":"link","uuid":"cb9f82e1-d397-46d9-9f0d-2b0e3becbfa1"},"project:unlink":{"path":"src/tasks/project/unlink.ts","handler":"unlink","uuid":"414d37de-793c-4d01-899d-69515f5e0948"}},"runners":{}},"timing":{"startTime":1755627445111,"endTime":1755627445112,"duration":1}}]},"metadata":{"environment":"cli"},"metrics":[],"type":"success","output":{"taskCount":29},"timing":{"startTime":1755627445111,"endTime":1755627445112,"duration":1}}

package/logs/test:guidance.log

@@ -0,0 +1 @@
+{"input":{},"boundaries":{},"taskName":"test:guidance","metadata":{"environment":"cli"},"metrics":[],"type":"success","output":{},"timing":{"startTime":1755627427045,"endTime":1755627427045,"duration":0}}

package/logs/test:uuid.log

@@ -0,0 +1 @@
+{"uuid":"0198bfeb-69c0-77e8-882b-a76dcb9300f9","input":{},"boundaries":{},"taskName":"test:uuid","metadata":{"environment":"cli"},"metrics":[],"type":"success","output":{},"timing":{"startTime":1755566533056,"endTime":1755566533057,"duration":1}}

package/logs/test:uuidCheck.log

@@ -0,0 +1 @@
+{"input":{},"boundaries":{},"taskName":"test:uuidCheck","metadata":{"environment":"cli"},"metrics":[],"type":"success","output":{},"timing":{"startTime":1755567492456,"endTime":1755567492456,"duration":0}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,11 +10,11 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/hive-sdk": "^0.1.2",
-      "@forgehive/record-tape": "^0.2.5",
-      "@forgehive/runner": "^0.2.5",
+      "@forgehive/hive-sdk": "^0.1.4",
+      "@forgehive/record-tape": "^0.2.6",
+      "@forgehive/runner": "^0.2.6",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.2.5",
+      "@forgehive/task": "^0.2.6",
       "esbuild": "^0.25.0",
       "handlebars": "^4.7.8",
       "minimist": "^1.2.8",
@@ -30,11 +30,11 @@
     "minimist": "^1.2.8",
     "typescript": "^5.3.3",
     "uuid": "^11.1.0",
-    "@forgehive/hive-sdk": "0.1.2",
-    "@forgehive/record-tape": "0.2.5",
-    "@forgehive/runner": "0.2.5",
-    "@forgehive/schema": "0.1.4",
-    "@forgehive/task": "0.2.5"
+    "@forgehive/record-tape": "0.2.6",
+    "@forgehive/hive-sdk": "0.1.4",
+    "@forgehive/task": "0.2.6",
+    "@forgehive/runner": "0.2.6",
+    "@forgehive/schema": "0.1.4"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

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