@forgehive/forge-cli 0.3.10 → 0.3.12

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/project/unlink.d.ts

@@ -0,0 +1,11 @@
+import { type ForgeConf } from '../types';
+export declare const unlink: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+}>) => Promise<{
+    success: boolean;
+    unlinkedUuid: string;
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+}>;

package/dist/tasks/project/unlink.js

@@ -0,0 +1,65 @@
+"use strict";
+// TASK: unlink
+// Run this task with:
+// forge project:unlink
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlink = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const load_1 = require("../conf/load");
+const name = 'project:unlink';
+const description = 'Remove the project UUID link from local forge.json';
+const schema = new schema_1.Schema({
+// No parameters needed for unlink
+});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    writeFile: async (filePath, content) => {
+        await promises_1.default.writeFile(filePath, content, 'utf-8');
+    }
+};
+exports.unlink = (0, task_1.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 = {
+            ...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 = {
+            ...updatedConf,
+            project: projectWithoutUuid
+        };
+        // Write the updated configuration back to forge.json
+        const forgePath = path_1.default.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/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

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTaskCommand = void 0;
 const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
+const uuid_1 = require("uuid");
 const handlebars_1 = __importDefault(require("handlebars"));
 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 }}
@@ -40,11 +42,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_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,11 +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
+            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/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

@@ -9,6 +9,7 @@ export interface RunnerDescriptor {
 export interface TaskDescriptor {
     path: string;
     handler: string;
+    uuid?: string;
 }
 export interface Infra {
     region: string;
@@ -42,6 +43,9 @@ export interface Profile {
     apiKey: string;
     apiSecret: string;
     url: string;
+    teamName?: string;
+    teamUuid?: string;
+    userName?: string;
 }
 export interface Profiles {
     default: string;

package/dist/test/tasks/create.test.js

@@ -35,11 +35,10 @@ export const newTask = 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 {}
   }
 })
 
@@ -94,5 +93,7 @@ describe('Create task', () => {
         const forgeContent = await fs.promises.readFile(path_1.default.join(rootDir, 'forge.json'), 'utf-8');
         const forgeConf = JSON.parse(forgeContent);
         expect(forgeConf.tasks['sample:newTask']).toBeDefined();
+        expect(forgeConf.tasks['sample:newTask'].uuid).toBeDefined();
+        expect(typeof forgeConf.tasks['sample:newTask'].uuid).toBe('string');
     });
 });

package/forge.json

@@ -118,6 +118,20 @@
     "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": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.3.10",
+  "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",
@@ -29,11 +29,12 @@
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
     "typescript": "^5.3.3",
-    "@forgehive/hive-sdk": "0.1.2",
+    "uuid": "^11.1.0",
+    "@forgehive/hive-sdk": "0.1.3",
     "@forgehive/record-tape": "0.2.5",
-    "@forgehive/task": "0.2.5",
     "@forgehive/runner": "0.2.5",
-    "@forgehive/schema": "0.1.4"
+    "@forgehive/schema": "0.1.4",
+    "@forgehive/task": "0.2.5"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",