@forgehive/forge-cli 0.3.2 → 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/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.2",
+  "version": "0.3.3",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,7 +10,7 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/hive-sdk": "^0.0.2",
+      "@forgehive/hive-sdk": "^0.0.3",
       "@forgehive/record-tape": "^0.2.2",
       "@forgehive/runner": "^0.2.2",
       "@forgehive/schema": "^0.1.4",
@@ -27,11 +27,11 @@
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
-    "@forgehive/hive-sdk": "0.0.2",
-    "@forgehive/record-tape": "0.2.2",
-    "@forgehive/task": "0.2.2",
+    "@forgehive/hive-sdk": "0.0.3",
     "@forgehive/runner": "0.2.2",
-    "@forgehive/schema": "0.1.4"
+    "@forgehive/record-tape": "0.2.2",
+    "@forgehive/schema": "0.1.4",
+    "@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/types.ts

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