@forgehive/forge-cli 0.3.1 → 0.3.3

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

@@ -0,0 +1,16 @@
+import { type InvokeResult } from '@forgehive/hive-sdk';
+import { type ForgeConf, type Profile } from '../types';
+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>>;
+    parseJSON: (jsonString: string) => Promise<unknown>;
+    invokeTask: (projectUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
+}>) => Promise<unknown>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    parseJSON: (jsonString: string) => Promise<unknown>;
+    invokeTask: (projectUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
+}>;

package/dist/tasks/task/invoke.js

@@ -0,0 +1,76 @@
+"use strict";
+// TASK: invoke
+// Run this task with:
+// forge task:run task:invoke
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invoke = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const hive_sdk_1 = require("@forgehive/hive-sdk");
+const load_1 = require("../conf/load");
+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()
+});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    parseJSON: async (jsonString) => {
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    },
+    invokeTask: async (projectUuid, profile, taskName, payload) => {
+        const client = (0, hive_sdk_1.createHiveClient)({
+            projectUuid,
+            apiKey: profile.apiKey,
+            apiSecret: profile.apiSecret,
+            host: profile.url
+        });
+        console.log(`Invoking task: ${taskName}`);
+        console.log('Payload:', payload);
+        console.log(`Using profile: ${profile.name} (${profile.url})`);
+        return await client.invoke(taskName, payload);
+    }
+};
+exports.invoke = (0, task_1.createTask)({
+    name,
+    description,
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName, json }, { loadConf, loadCurrentProfile, parseJSON, invokeTask }) {
+        // Load forge configuration
+        const forge = await loadConf({});
+        const taskDescriptor = forge.tasks[descriptorName];
+        if (taskDescriptor === undefined) {
+            throw new Error(`Task "${descriptorName}" is not defined in forge.json`);
+        }
+        // Check for project UUID
+        if (!forge.project.uuid) {
+            throw new Error('Project UUID is not defined in forge.json. Please ensure your project has a UUID.');
+        }
+        // Load profile (required for invoke)
+        let profile;
+        try {
+            profile = await loadCurrentProfile({});
+        }
+        catch (error) {
+            throw new Error('No profile found. Please authenticate first using: forge auth:add');
+        }
+        // Parse the JSON payload
+        const payload = await parseJSON(json);
+        // Invoke the task using the boundary
+        const result = await invokeTask(forge.project.uuid, profile, descriptorName, payload);
+        if ((0, hive_sdk_1.isInvokeError)(result)) {
+            throw new Error(`Task invocation failed: ${result.error}`);
+        }
+        console.log('Success! Task invoked successfully.');
+        return result?.responsePayload;
+    }
+});

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

@@ -16,7 +16,10 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     verifyLogFolder: (logsPath: string) => Promise<boolean>;
     ensureBuildsFolder: () => Promise<string>;
-    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: {
+        input: unknown;
+        metadata?: Record<string, string>;
+    }) => Promise<boolean>;
 }>) => Promise<any>, {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
@@ -31,5 +34,8 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     verifyLogFolder: (logsPath: string) => Promise<boolean>;
     ensureBuildsFolder: () => Promise<string>;
-    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: {
+        input: unknown;
+        metadata?: Record<string, string>;
+    }) => Promise<boolean>;
 }>;

package/dist/tasks/task/run.js

@@ -11,10 +11,10 @@ exports.run = void 0;
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
-const axios_1 = __importDefault(require("axios"));
 const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
 const record_tape_1 = require("@forgehive/record-tape");
+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");
@@ -53,25 +53,31 @@ const boundaries = {
     },
     sendLogToAPI: async (profile, projectName, taskName, logItem) => {
         try {
-            const logsUrl = `${profile.url}/api/tasks/log-ingest`;
-            const authToken = `${profile.apiKey}:${profile.apiSecret}`;
-            await axios_1.default.post(logsUrl, {
+            const config = {
                 projectName,
-                taskName,
-                logItem: JSON.stringify(logItem)
-            }, {
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    'Content-Type': 'application/json'
+                apiKey: profile.apiKey,
+                apiSecret: profile.apiSecret,
+                host: profile.url,
+                metadata: {
+                    environment: 'cli'
                 }
-            });
-            console.log('===============================================');
-            console.log('Log sent to API... ', profile.name, profile.url);
-            return true;
+            };
+            const client = new hive_sdk_1.HiveLogClient(config);
+            const result = await client.sendLog(taskName, logItem);
+            if (result === 'success') {
+                console.log('===============================================');
+                console.log('Log sent to API... ', profile.name, profile.url);
+                return true;
+            }
+            else {
+                console.error('Failed to send log to API:', profile.url);
+                return false;
+            }
         }
         catch (e) {
+            console.error('Failed to send log to API:', profile.url);
             const error = e;
-            console.error('Failed to send log to API:', error.message);
+            console.error('Error:', error.message);
             return false;
         }
     }

package/forge.json

@@ -109,6 +109,10 @@
     "bundle:fingerprint": {
       "path": "src/tasks/bundle/fingerprint.ts",
       "handler": "fingerprint"
+    },
+    "task:invoke": {
+      "path": "src/tasks/task/invoke.ts",
+      "handler": "invoke"
     }
   },
   "runners": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,10 +10,11 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/record-tape": "^0.2.1",
-      "@forgehive/runner": "^0.2.1",
+      "@forgehive/hive-sdk": "^0.0.3",
+      "@forgehive/record-tape": "^0.2.2",
+      "@forgehive/runner": "^0.2.2",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.2.1",
+      "@forgehive/task": "^0.2.2",
       "esbuild": "^0.25.0",
       "handlebars": "^4.7.8",
       "minimist": "^1.2.8"
@@ -26,10 +27,11 @@
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
+    "@forgehive/hive-sdk": "0.0.3",
+    "@forgehive/runner": "0.2.2",
+    "@forgehive/record-tape": "0.2.2",
     "@forgehive/schema": "0.1.4",
-    "@forgehive/runner": "0.2.1",
-    "@forgehive/record-tape": "0.2.1",
-    "@forgehive/task": "0.2.1"
+    "@forgehive/task": "0.2.2"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/src/runner.ts

@@ -18,6 +18,8 @@ import { replay as replayTask } from './tasks/task/replay'
 import { list as listTasks } from './tasks/task/list'
 import { describe as describeTask } from './tasks/task/describe'
 import { fingerprint as fingerprintTask } from './tasks/task/fingerprint'
+import { invoke as invokeTask } from './tasks/task/invoke'
+
 
 import { create as createRunner } from './tasks/runner/create'
 import { remove as removeRunner } from './tasks/runner/remove'
@@ -58,6 +60,7 @@ runner.load('task:replay', replayTask)
 runner.load('task:list', listTasks)
 runner.load('task:describe', describeTask)
 runner.load('task:fingerprint', fingerprintTask)
+runner.load('task:invoke', invokeTask)
 
 // Runner commands
 runner.load('runner:create', createRunner)
@@ -114,6 +117,13 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
         descriptorName: action,
         uuid
       })
+    } else if (taskName === 'task:invoke') {
+      const { json } = args as { json: string }
+
+      result = await task.run({
+        descriptorName: action,
+        json
+      })
     } else if (taskName === 'task:replay') {
       const { path, cache } = args as { path: string, cache: string }
 

package/src/tasks/task/invoke.ts

@@ -0,0 +1,93 @@
+// TASK: invoke
+// Run this task with:
+// forge task:run task:invoke
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import { createHiveClient, isInvokeError, type InvokeResult } from '@forgehive/hive-sdk'
+
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+const name = 'task:invoke'
+const description = 'Invoke a deployed task remotely using the Hive API'
+
+const schema = new Schema({
+  descriptorName: Schema.string(),
+  json: Schema.string()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  parseJSON: async (jsonString: string): Promise<unknown> => {
+    try {
+      return JSON.parse(jsonString)
+    } catch (error) {
+      throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  },
+  invokeTask: async (
+    projectUuid: string,
+    profile: Profile,
+    taskName: string,
+    payload: unknown
+  ): Promise<InvokeResult | null> => {
+    const client = createHiveClient({
+      projectUuid,
+      apiKey: profile.apiKey,
+      apiSecret: profile.apiSecret,
+      host: profile.url
+    })
+
+    console.log(`Invoking task: ${taskName}`)
+    console.log('Payload:', payload)
+    console.log(`Using profile: ${profile.name} (${profile.url})`)
+
+    return await client.invoke(taskName, payload)
+  }
+}
+
+export const invoke = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function ({ descriptorName, json }, { loadConf, loadCurrentProfile, parseJSON, invokeTask }) {
+    // Load forge configuration
+    const forge: ForgeConf = await loadConf({})
+    const taskDescriptor = forge.tasks[descriptorName as keyof typeof forge.tasks]
+
+    if (taskDescriptor === undefined) {
+      throw new Error(`Task "${descriptorName}" is not defined in forge.json`)
+    }
+
+    // Check for project UUID
+    if (!forge.project.uuid) {
+      throw new Error('Project UUID is not defined in forge.json. Please ensure your project has a UUID.')
+    }
+
+    // Load profile (required for invoke)
+    let profile: Profile
+    try {
+      profile = await loadCurrentProfile({})
+    } catch (error) {
+      throw new Error('No profile found. Please authenticate first using: forge auth:add')
+    }
+
+    // Parse the JSON payload
+    const payload = await parseJSON(json)
+
+    // Invoke the task using the boundary
+    const result = await invokeTask(forge.project.uuid, profile, descriptorName, payload)
+
+    if (isInvokeError(result)) {
+      throw new Error(`Task invocation failed: ${result.error}`)
+    }
+
+    console.log('Success! Task invoked successfully.')
+    return result?.responsePayload
+  }
+})
+

package/src/tasks/task/run.ts

@@ -6,11 +6,11 @@
 import path from 'path'
 import fs from 'fs/promises'
 import os from 'os'
-import axios from 'axios'
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 import { RecordTape } from '@forgehive/record-tape'
+import { HiveLogClient } from '@forgehive/hive-sdk'
 
 import { create as bundleCreate } from '../bundle/create'
 import { load as bundleLoad } from '../bundle/load'
@@ -51,29 +51,33 @@ const boundaries = {
 
     return buildsPath
   },
-  sendLogToAPI: async (profile: Profile, projectName: string, taskName: string, logItem: unknown): Promise<boolean> => {
+  sendLogToAPI: async (profile: Profile, projectName: string, taskName: string, logItem: { input: unknown; metadata?: Record<string, string> }): Promise<boolean> => {
     try {
-      const logsUrl = `${profile.url}/api/tasks/log-ingest`
-      const authToken = `${profile.apiKey}:${profile.apiSecret}`
-
-      await axios.post(logsUrl, {
+      const config = {
         projectName,
-        taskName,
-        logItem: JSON.stringify(logItem)
-      }, {
-        headers: {
-          Authorization: `Bearer ${authToken}`,
-          'Content-Type': 'application/json'
+        apiKey: profile.apiKey,
+        apiSecret: profile.apiSecret,
+        host: profile.url,
+        metadata: {
+          environment: 'cli'
         }
-      })
+      }
 
-      console.log('===============================================')
-      console.log('Log sent to API... ', profile.name, profile.url)
+      const client = new HiveLogClient(config)
+      const result = await client.sendLog(taskName, logItem)
 
-      return true
+      if (result === 'success') {
+        console.log('===============================================')
+        console.log('Log sent to API... ', profile.name, profile.url)
+        return true
+      } else {
+        console.error('Failed to send log to API:', profile.url)
+        return false
+      }
     } catch (e) {
+      console.error('Failed to send log to API:', profile.url)
       const error = e as Error
-      console.error('Failed to send log to API:', error.message)
+      console.error('Error:', error.message)
       return false
     }
   }

package/src/tasks/types.ts

@@ -20,6 +20,7 @@ export interface Infra {
 export interface ForgeConf {
   project: {
     name: string
+    uuid?: string
   }
   paths: {
     logs: string