@forgehive/forge-cli 0.3.17 → 0.5.1

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

@@ -1,11 +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>>;
+export declare const unlink: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     writeFile: (filePath: string, content: string) => Promise<void>;
 }>) => Promise<{
     success: boolean;
     unlinkedUuid: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     writeFile: (filePath: string, content: string) => Promise<void>;
 }>;

package/dist/tasks/runner/bundle.d.ts

@@ -3,7 +3,7 @@ export declare const bundle: import("@forgehive/task").TaskInstanceType<(argv: {
     runnerName: string;
     targetPath: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     ensureDir: (dirPath: string) => Promise<void>;
 }>) => Promise<{
@@ -12,7 +12,7 @@ export declare const bundle: import("@forgehive/task").TaskInstanceType<(argv: {
     entryPoint: string;
     outputFile: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     ensureDir: (dirPath: string) => Promise<void>;
 }>;

package/dist/tasks/runner/bundle.js

@@ -14,8 +14,8 @@ const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const load_1 = require("../conf/load");
 const schema = new schema_1.Schema({
-    runnerName: schema_1.Schema.string(),
-    targetPath: schema_1.Schema.string()
+    runnerName: schema_1.Schema.string().describe('The name of the runner to bundle'),
+    targetPath: schema_1.Schema.string().describe('Target path for the bundled runner')
 });
 const boundaries = {
     loadConf: load_1.load.asBoundary(),

package/dist/tasks/runner/create.d.ts

@@ -2,7 +2,7 @@ import { type ForgeConf } from '../types';
 export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
     runnerName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     persistRunner: (runnerPath: string, runnerName: string, content: string) => Promise<{
         path: string;
@@ -12,7 +12,7 @@ export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
     runnerPath: string;
     runnerName: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     persistRunner: (runnerPath: string, runnerName: string, content: string) => Promise<{
         path: string;

package/dist/tasks/runner/create.js

@@ -30,7 +30,7 @@ const {{ runnerName }}Runner = new Runner()
 export { {{ runnerName }}Runner }
 `;
 const schema = new schema_1.Schema({
-    runnerName: schema_1.Schema.string()
+    runnerName: schema_1.Schema.string().describe('The name of the runner to create')
 });
 const boundaries = {
     // Load boundaries

package/dist/tasks/runner/remove.d.ts

@@ -2,7 +2,7 @@ import { type ForgeConf } from '../types';
 export declare const remove: import("@forgehive/task").TaskInstanceType<(argv: {
     runnerName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     removeRunner: (runnerPath: string) => Promise<void>;
     persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
@@ -11,7 +11,7 @@ export declare const remove: import("@forgehive/task").TaskInstanceType<(argv: {
     message: string;
     runnerName: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     removeRunner: (runnerPath: string) => Promise<void>;
     persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;

package/dist/tasks/runner/remove.js

@@ -14,7 +14,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const camelCase_1 = require("../../utils/camelCase");
 const load_1 = require("../conf/load");
 const schema = new schema_1.Schema({
-    runnerName: schema_1.Schema.string()
+    runnerName: schema_1.Schema.string().describe('The name of the runner to remove')
 });
 const boundaries = {
     // Load boundaries

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

@@ -2,8 +2,8 @@ import { type TaskName, type ForgeConf } from '../types';
 export declare const createTaskCommand: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profile>>;
     loadTemplate: () => Promise<string>;
     getCwd: () => Promise<string>;
     parseTaskName: (taskDescriptor: string) => Promise<TaskName>;
@@ -20,8 +20,8 @@ export declare const createTaskCommand: import("@forgehive/task").TaskInstanceTy
     taskPath: string;
     fileName: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profile>>;
     loadTemplate: () => Promise<string>;
     getCwd: () => Promise<string>;
     parseTaskName: (taskDescriptor: string) => Promise<TaskName>;

package/dist/tasks/task/createTask.js

@@ -26,8 +26,9 @@ const name = '{{ taskDescriptor }}'
 const description = 'Add task description here'
 
 const schema = new Schema({
-  // Add your schema definitions here
-  // example: myParam: Schema.string()
+  // Add your schema definitions here.
+  // Use .describe() so the field shows up in \`forge {{ taskDescriptor }} --help\`.
+  // example: myParam: Schema.string().describe('What this parameter is for')
 })
 
 const boundaries = {

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

@@ -2,7 +2,7 @@ import { type ForgeConf } from '../types';
 export declare const describe: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -21,7 +21,7 @@ export declare const describe: import("@forgehive/task").TaskInstanceType<(argv:
     schema: any;
     boundaries: string[];
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;

package/dist/tasks/task/describe.js

@@ -17,7 +17,7 @@ const load_1 = require("../bundle/load");
 const load_2 = require("../conf/load");
 const description = 'Describe a task with detailed information about its schema, boundaries and configuration';
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name to describe (e.g. domain:taskName)')
 });
 const boundaries = {
     loadConf: load_2.load.asBoundary(),

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

@@ -3,9 +3,9 @@ export declare const download: import("@forgehive/task").TaskInstanceType<(argv:
     descriptorName: string;
     uuid: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     downloadTask: (uuid: string, profile: Profile) => Promise<any>;
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     parseTaskName: (taskDescriptor: string) => Promise<{
         descriptor: string;
@@ -40,9 +40,9 @@ export declare const download: import("@forgehive/task").TaskInstanceType<(argv:
     error?: undefined;
     message?: undefined;
 }>, {
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     downloadTask: (uuid: string, profile: Profile) => Promise<any>;
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     getCwd: () => Promise<string>;
     parseTaskName: (taskDescriptor: string) => Promise<{
         descriptor: string;

package/dist/tasks/task/download.js

@@ -16,8 +16,8 @@ const camelCase_1 = require("../../utils/camelCase");
 const load_1 = require("../conf/load");
 const loadCurrent_1 = require("../auth/loadCurrent");
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string(),
-    uuid: schema_1.Schema.string()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name (e.g. domain:taskName)'),
+    uuid: schema_1.Schema.string().describe('The UUID of the task version to download')
 });
 const boundaries = {
     loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),

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

@@ -2,7 +2,7 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     getCwd: () => Promise<string>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
     bundleFingerprint: (args: {
         descriptorName: string;
         filePath?: string | undefined;
@@ -40,7 +40,7 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
     };
 }>, {
     getCwd: () => Promise<string>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
     bundleFingerprint: (args: {
         descriptorName: string;
         filePath?: string | undefined;

package/dist/tasks/task/fingerprint.js

@@ -14,7 +14,7 @@ const load_1 = require("../conf/load");
 const fingerprint_1 = require("../bundle/fingerprint");
 const description = 'Analyze a specific task and generate detailed fingerprint without bundling';
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name to fingerprint (e.g. domain:taskName)')
 });
 const boundaries = {
     getCwd: async () => {

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

@@ -4,13 +4,13 @@ export declare const invoke: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
     json: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     parseJSON: (jsonString: string) => Promise<unknown>;
     invokeTask: (projectUuid: string, taskUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
 }>) => Promise<unknown>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     parseJSON: (jsonString: string) => Promise<unknown>;
     invokeTask: (projectUuid: string, taskUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
 }>;

package/dist/tasks/task/invoke.js

@@ -12,8 +12,8 @@ const loadCurrent_1 = require("../auth/loadCurrent");
 const name = 'task:invoke';
 const description = 'Invoke a deployed task remotely using the Hive API';
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string(),
-    json: schema_1.Schema.string()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name (e.g. domain:taskName)'),
+    json: schema_1.Schema.string().describe('JSON string of arguments to pass to the task')
 });
 const boundaries = {
     loadConf: load_1.load.asBoundary(),

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

@@ -1,6 +1,6 @@
 import { type ForgeConf } from '../types';
-export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+export declare const list: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
 }>) => Promise<{
     taskCount: number;
     tasks: never[];
@@ -8,5 +8,5 @@ export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {},
     taskCount: number;
     tasks?: undefined;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
 }>;

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

@@ -4,8 +4,8 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     getCwd: () => Promise<string>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -59,8 +59,8 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
     fingerprint: boolean;
 }>, {
     getCwd: () => Promise<string>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;

package/dist/tasks/task/publish.js

@@ -20,7 +20,7 @@ const zip_1 = require("../bundle/zip");
 const fingerprint_1 = require("../bundle/fingerprint");
 const loadCurrent_1 = require("../auth/loadCurrent");
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name to publish (e.g. domain:taskName)')
 });
 const boundaries = {
     getCwd: async () => {

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

@@ -2,14 +2,14 @@ import { type ForgeConf } from '../types';
 export declare const remove: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     persistConf: (forge: ForgeConf) => Promise<void>;
     deleteFile: (filePath: string) => Promise<void>;
 }>) => Promise<{
     status: string;
     message: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
     persistConf: (forge: ForgeConf) => Promise<void>;
     deleteFile: (filePath: string) => Promise<void>;
 }>;

package/dist/tasks/task/remove.js

@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const load_1 = require("../conf/load");
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name to remove (e.g. domain:taskName)')
 });
 const boundaries = {
     loadConf: load_1.load.asBoundary(),

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

@@ -1,3 +1,4 @@
+import { type ExecutionRecord } from '@forgehive/hive-sdk';
 import { type ForgeConf, type Profile } from '../types';
 interface Fixture {
     fixtureUUID: string;
@@ -10,13 +11,13 @@ interface Fixture {
     context: Record<string, unknown>;
 }
 export declare const replay: import("@forgehive/task").TaskInstanceType<(argv: {
-    path: string;
     descriptorName: string;
+    path: string;
     cache?: string | undefined;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     readFixture: (filePath: string) => Promise<Fixture>;
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -28,11 +29,14 @@ export declare const replay: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     ensureBuildsFolder: () => Promise<string>;
     verifyLogFolder: (logsPath: string) => Promise<boolean>;
-    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown, fixtureUUID: string) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, record: ExecutionRecord, fixtureUUID: string) => Promise<{
+        success: boolean;
+        logUuid?: string;
+    }>;
 }>) => Promise<any>, {
     readFixture: (filePath: string) => Promise<Fixture>;
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -44,6 +48,9 @@ export declare const replay: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     ensureBuildsFolder: () => Promise<string>;
     verifyLogFolder: (logsPath: string) => Promise<boolean>;
-    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown, fixtureUUID: string) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, record: ExecutionRecord, fixtureUUID: string) => Promise<{
+        success: boolean;
+        logUuid?: string;
+    }>;
 }>;
 export {};

package/dist/tasks/task/replay.js

@@ -12,16 +12,16 @@ const schema_1 = require("@forgehive/schema");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
-const axios_1 = __importDefault(require("axios"));
+const hive_sdk_1 = require("@forgehive/hive-sdk");
 const create_1 = require("../bundle/create");
 const load_1 = require("../bundle/load");
 const load_2 = require("../conf/load");
 const loadCurrent_1 = require("../auth/loadCurrent");
 const description = 'Replay a task execution from a specified path';
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string(),
-    path: schema_1.Schema.string(),
-    cache: schema_1.Schema.string().optional()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name to replay (e.g. domain:taskName)'),
+    path: schema_1.Schema.string().describe('Path to the execution log fixture to replay'),
+    cache: schema_1.Schema.string().describe('Cache mode for boundaries during replay').optional()
 });
 const boundaries = {
     readFixture: async (filePath) => {
@@ -53,30 +53,41 @@ const boundaries = {
         }
         return true;
     },
-    sendLogToAPI: async (profile, projectName, taskName, logItem, fixtureUUID) => {
+    sendLogToAPI: async (profile, record, fixtureUUID) => {
         try {
-            const logsUrl = `${profile.url}/api/tasks/log-ingest`;
-            const authToken = `${profile.apiKey}:${profile.apiSecret}`;
-            await axios_1.default.post(logsUrl, {
-                projectName,
-                taskName,
-                logItem: JSON.stringify(logItem),
-                replayFrom: fixtureUUID
-            }, {
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    'Content-Type': 'application/json'
+            // Use createClientFromForgeConf to automatically load forge.json with task UUIDs
+            const client = (0, hive_sdk_1.createClientFromForgeConf)('./forge.json', {
+                apiKey: profile.apiKey,
+                apiSecret: profile.apiSecret,
+                host: profile.url,
+                metadata: {
+                    environment: 'cli',
+                    replayFrom: fixtureUUID
                 }
             });
             console.log('===============================================');
-            console.log('Log sent to API... ', profile.name, profile.url);
-            console.log('Replay from fixture UUID:', fixtureUUID);
-            return true;
+            console.log('Sending replay log to Hive...');
+            const result = await client.sendLog(record);
+            if (result === 'success' || (typeof result === 'object' && 'uuid' in result)) {
+                console.log('✅ Log sent to API...', profile.name, profile.url);
+                console.log('Replay from fixture UUID:', fixtureUUID);
+                console.log('===============================================');
+                if (typeof result === 'object' && result && 'uuid' in result) {
+                    return { success: true, logUuid: result.uuid };
+                }
+                return { success: true };
+            }
+            else {
+                console.error('❌ Failed to send log to Hive');
+                console.log('===============================================');
+                return { success: false };
+            }
         }
         catch (e) {
             const error = e;
-            console.error('Failed to send log to API:', error.message);
-            return false;
+            console.error('❌ Failed to send log to API:', error.message);
+            console.log('===============================================');
+            return { success: false };
         }
     }
 };
@@ -90,7 +101,6 @@ exports.replay = (0, task_1.createTask)({
         // Load forge configuration
         const forge = await loadConf({});
         const taskDescriptor = forge.tasks[descriptorName];
-        const projectName = forge.project.name;
         if (taskDescriptor === undefined) {
             throw new Error(`Task ${descriptorName} is not defined in forge.json`);
         }
@@ -168,7 +178,7 @@ exports.replay = (0, task_1.createTask)({
         // Send the log to API if profile is available
         if (profile) {
             try {
-                await sendLogToAPI(profile, projectName, descriptorName, record, fixture.fixtureUUID);
+                await sendLogToAPI(profile, record, fixture.fixtureUUID);
             }
             catch (e) {
                 console.error('Failed to send log to API:', e);

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

@@ -4,8 +4,8 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
     args: Record<string, string | number | boolean>;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -17,15 +17,15 @@ 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, taskUuid?: string, projectUuid?: string) => Promise<{
+    sendLogToAPI: (profile: Profile, record: ExecutionRecord, taskUuid?: string) => Promise<{
         success: boolean;
         logUuid?: string;
         taskUuid?: string;
         skipRemoteLog?: boolean;
     }>;
 }>) => Promise<any>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -37,7 +37,7 @@ 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, taskUuid?: string, projectUuid?: string) => Promise<{
+    sendLogToAPI: (profile: Profile, record: ExecutionRecord, taskUuid?: string) => Promise<{
         success: boolean;
         logUuid?: string;
         taskUuid?: string;

package/dist/tasks/task/run.js

@@ -22,8 +22,8 @@ const loadCurrent_1 = require("../auth/loadCurrent");
 // For now, we'll use a simple schema without the record type
 // TODO: Use Schema.record once it's properly built and available
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string(),
-    args: schema_1.Schema.mixedRecord()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name to run (e.g. domain:taskName)'),
+    args: schema_1.Schema.mixedRecord().describe('Arguments to pass to the task')
     // args will be passed directly without schema validation for now
 });
 const boundaries = {
@@ -50,39 +50,32 @@ const boundaries = {
         }
         return buildsPath;
     },
-    sendLogToAPI: async (profile, projectName, record, taskUuid, projectUuid) => {
-        // Check if we have required UUIDs for the new endpoint
-        if (!projectUuid || !taskUuid) {
+    sendLogToAPI: async (profile, record, taskUuid) => {
+        // Check if we have required UUID for the task
+        if (!taskUuid) {
             console.log('===============================================');
-            console.log('⚠️  Remote logging skipped - missing UUIDs');
+            console.log('⚠️  Remote logging skipped - missing task UUID');
             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('• Use "forge project:sync" to sync tasks and get UUIDs');
             console.log('===============================================');
             return { success: true, skipRemoteLog: true };
         }
         try {
-            const config = {
-                projectName,
-                projectUuid,
+            // Use createClientFromForgeConf to automatically load forge.json with task UUIDs
+            const client = (0, hive_sdk_1.createClientFromForgeConf)('./forge.json', {
                 apiKey: profile.apiKey,
                 apiSecret: profile.apiSecret,
                 host: profile.url,
                 metadata: {
                     environment: 'cli'
                 }
-            };
-            const client = new hive_sdk_1.HiveLogClient(config);
+            });
+            console.log('===============================================');
             console.log('Sending execution log to Hive...');
-            const result = await client.sendLogByUuid(record, taskUuid);
+            const result = await client.sendLog(record);
             if (result === 'success' || (typeof result === 'object' && 'uuid' in result)) {
-                console.log('===============================================');
+                console.log('');
                 console.log('✅ Log sent to Hive successfully');
                 console.log(`   Profile: ${profile.name}`);
                 console.log(`   Host: ${profile.url}`);
@@ -93,14 +86,18 @@ const boundaries = {
                 return { success: true, taskUuid };
             }
             else {
+                console.log('');
                 console.error('❌ Failed to send log to Hive:', profile.url);
+                console.log('===============================================');
                 return { success: false };
             }
         }
         catch (e) {
+            console.log('===============================================');
             console.error('❌ Failed to send log to Hive:', profile.url);
             const error = e;
             console.error('Error:', error.message);
+            console.log('===============================================');
             return { success: false };
         }
     }
@@ -112,8 +109,6 @@ exports.run = (0, task_1.createTask)({
         // Load forge configuration
         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');
@@ -175,7 +170,7 @@ exports.run = (0, task_1.createTask)({
         await tape.save();
         if (profile) {
             try {
-                const logResult = await sendLogToAPI(profile, projectName, logItem, taskUuid, projectUuid);
+                const logResult = await sendLogToAPI(profile, logItem, taskUuid);
                 if (logResult.success && !logResult.skipRemoteLog && taskUuid) {
                     console.log(`🔗 View execution logs: ${profile.url}/tasks/${taskUuid}?tab=logs`);
                 }