@forgehive/forge-cli 0.3.11 → 0.3.13

package/dist/runner.js

@@ -29,9 +29,11 @@ const add_1 = require("./tasks/auth/add");
 const switch_1 = require("./tasks/auth/switch");
 const list_2 = require("./tasks/auth/list");
 const remove_3 = require("./tasks/auth/remove");
+const clear_1 = require("./tasks/auth/clear");
 const create_2 = require("./tasks/project/create");
 const link_1 = require("./tasks/project/link");
 const unlink_1 = require("./tasks/project/unlink");
+const sync_1 = require("./tasks/project/sync");
 const runner = new runner_1.Runner((data) => {
     const { _, ...filteredObj } = data;
     return {
@@ -67,10 +69,12 @@ runner.load('auth:add', add_1.add);
 runner.load('auth:switch', switch_1.switchProfile);
 runner.load('auth:list', list_2.list);
 runner.load('auth:remove', remove_3.remove);
+runner.load('auth:clear', clear_1.clear);
 // Project commands
 runner.load('project:create', create_2.create);
 runner.load('project:link', link_1.link);
 runner.load('project:unlink', unlink_1.unlink);
+runner.load('project:sync', sync_1.sync);
 // Set handler
 runner.setHandler(async (data) => {
     const parsedArgs = runner.parseArguments(data);
@@ -81,12 +85,14 @@ runner.setHandler(async (data) => {
     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 {
         let result;
         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 });
         }
@@ -175,16 +181,13 @@ runner.setHandler(async (data) => {
                 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;
         }
         return {

package/dist/tasks/auth/add.d.ts

@@ -7,10 +7,26 @@ export declare const add: import("@forgehive/task").TaskInstanceType<(argv: {
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
+    fetchMeInfo: (apiKey: string, apiSecret: string, url: string) => Promise<{
+        success: boolean;
+        teamName?: string;
+        teamUuid?: string;
+        userName?: string;
+        error?: string;
+    }>;
 }>) => Promise<{
     status: string;
     message: string;
+    teamName: string | undefined;
+    userName: string | undefined;
 }>, {
     loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
+    fetchMeInfo: (apiKey: string, apiSecret: string, url: string) => Promise<{
+        success: boolean;
+        teamName?: string;
+        teamUuid?: string;
+        userName?: string;
+        error?: string;
+    }>;
 }>;

package/dist/tasks/auth/add.js

@@ -25,22 +25,72 @@ const boundaries = {
         const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
         const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
         await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
+    },
+    fetchMeInfo: async (apiKey, apiSecret, url) => {
+        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' };
+        }
     }
 };
 exports.add = (0, task_1.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
         profiles.default = name;
@@ -48,7 +98,9 @@ exports.add = (0, task_1.createTask)({
         await persistProfiles(profiles);
         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/dist/tasks/auth/clear.d.ts

@@ -0,0 +1,16 @@
+import { type Profiles } from '../types';
+export declare const clear: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    clearProfiles: () => Promise<void>;
+}>) => Promise<{
+    status: string;
+    message: string;
+    clearedCount?: undefined;
+} | {
+    status: string;
+    message: string;
+    clearedCount: number;
+}>, {
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    clearProfiles: () => Promise<void>;
+}>;

package/dist/tasks/auth/clear.js

@@ -0,0 +1,54 @@
+"use strict";
+// TASK: clear
+// Run this task with:
+// forge task:run auth:clear
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clear = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const load_1 = require("./load");
+const schema = new schema_1.Schema({});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary(),
+    clearProfiles: async () => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
+        const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+        // Create empty profiles structure
+        const emptyProfiles = {
+            default: '',
+            profiles: []
+        };
+        await promises_1.default.writeFile(profilesPath, JSON.stringify(emptyProfiles, null, 2));
+    }
+};
+exports.clear = (0, task_1.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/dist/tasks/auth/list.d.ts

@@ -11,6 +11,8 @@ export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {},
         Name: string;
         'API Key': string;
         URL: string;
+        Team: string;
+        User: string;
     }[];
     status?: undefined;
 }>, {

package/dist/tasks/auth/list.js

@@ -27,15 +27,23 @@ exports.list = (0, task_1.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('');
         }
         console.log('Available profiles:\n');
         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');
         console.log('========================================');

package/dist/tasks/project/sync.d.ts

@@ -0,0 +1,116 @@
+import { type ForgeConf } from '../types';
+export declare const sync: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    getCwd: () => Promise<string>;
+    persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+    syncTasksToHive: (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;
+                }>;
+            };
+        };
+    }>;
+}>) => Promise<{
+    status: string;
+    message: string;
+    summary?: undefined;
+    results?: undefined;
+    projectUrl?: undefined;
+} | {
+    status: 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;
+        }>;
+    };
+    projectUrl: string;
+    message?: undefined;
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    getCwd: () => Promise<string>;
+    persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+    syncTasksToHive: (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;
+                }>;
+            };
+        };
+    }>;
+}>;

package/dist/tasks/project/sync.js

@@ -0,0 +1,152 @@
+"use strict";
+// TASK: sync
+// Run this task with:
+// forge task:run project:sync
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const uuid_1 = require("uuid");
+const load_1 = require("../conf/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const schema = new schema_1.Schema({});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    getCwd: async () => {
+        return process.cwd();
+    },
+    persistConf: async (forge, cwd) => {
+        const forgePath = path_1.default.join(cwd, 'forge.json');
+        await promises_1.default.writeFile(forgePath, JSON.stringify(forge, null, 2));
+    },
+    syncTasksToHive: async (projectUuid, tasks, apiKey, apiSecret, baseUrl) => {
+        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' };
+        }
+    }
+};
+exports.sync = (0, task_1.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 = [];
+        if (!forge.tasks) {
+            forge.tasks = {};
+        }
+        for (const [taskDescriptor, taskData] of Object.entries(forge.tasks)) {
+            if (!taskData.uuid) {
+                taskData.uuid = (0, uuid_1.v4)();
+                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/dist/tasks/task/createTask.d.ts

@@ -3,6 +3,7 @@ export declare const createTaskCommand: import("@forgehive/task").TaskInstanceTy
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
     loadTemplate: () => Promise<string>;
     getCwd: () => Promise<string>;
     parseTaskName: (taskDescriptor: string) => Promise<TaskName>;
@@ -10,11 +11,17 @@ export declare const createTaskCommand: import("@forgehive/task").TaskInstanceTy
         path: string;
     }>;
     persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+    createTaskInHive: (projectUuid: string, taskUuid: string, taskName: string, description: string, apiKey: string, apiSecret: string, baseUrl: string) => Promise<{
+        success: boolean;
+        taskUrl?: string;
+        error?: string;
+    }>;
 }>) => Promise<{
     taskPath: string;
     fileName: string;
 }>, {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
     loadTemplate: () => Promise<string>;
     getCwd: () => Promise<string>;
     parseTaskName: (taskDescriptor: string) => Promise<TaskName>;
@@ -22,4 +29,9 @@ export declare const createTaskCommand: import("@forgehive/task").TaskInstanceTy
         path: string;
     }>;
     persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+    createTaskInHive: (projectUuid: string, taskUuid: string, taskName: string, description: string, apiKey: string, apiSecret: string, baseUrl: string) => Promise<{
+        success: boolean;
+        taskUrl?: string;
+        error?: string;
+    }>;
 }>;

package/dist/tasks/task/createTask.js

@@ -12,6 +12,7 @@ const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const camelCase_1 = require("../../utils/camelCase");
 const load_1 = require("../conf/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
 // Define the template content directly in the code
 // This eliminates the need to find and load an external file
 const TASK_TEMPLATE = `// TASK: {{ taskName }}
@@ -55,6 +56,7 @@ const schema = new schema_1.Schema({
 const boundaries = {
     // Load boundaries
     loadConf: load_1.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
     loadTemplate: async () => {
         return TASK_TEMPLATE;
     },
@@ -100,12 +102,39 @@ const boundaries = {
     persistConf: async (forge, cwd) => {
         const forgePath = path_1.default.join(cwd, 'forge.json');
         await promises_1.default.writeFile(forgePath, JSON.stringify(forge, null, 2));
+    },
+    createTaskInHive: async (projectUuid, taskUuid, taskName, description, apiKey, apiSecret, baseUrl) => {
+        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' };
+        }
     }
 };
 exports.createTaskCommand = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function ({ descriptorName }, { loadTemplate, persistTask, loadConf, persistConf, parseTaskName, getCwd }) {
+    fn: async function ({ descriptorName }, { loadTemplate, persistTask, loadConf, persistConf, parseTaskName, getCwd, loadCurrentProfile, createTaskInHive }) {
         const { taskName, fileName, descriptor, dir } = await parseTaskName(descriptorName);
         const cwd = await getCwd();
         const forge = await loadConf({});
@@ -132,12 +161,32 @@ exports.createTaskCommand = (0, task_1.createTask)({
         if (forge.tasks === undefined) {
             forge.tasks = {};
         }
+        const taskUuid = (0, uuid_1.v4)();
         forge.tasks[descriptor] = {
             path: `${taskPath}/${fileName}`,
             handler: taskName,
-            uuid: (0, uuid_1.v4)()
+            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 };
     }
 });