@forgehive/forge-cli 0.2.9 → 0.2.10

package/dist/runner.js

@@ -18,6 +18,8 @@ const remove_2 = require("./tasks/runner/remove");
 const bundle_1 = require("./tasks/runner/bundle");
 const publish_1 = require("./tasks/task/publish");
 const download_1 = require("./tasks/task/download");
+const replay_1 = require("./tasks/task/replay");
+const download_2 = require("./tasks/fixture/download");
 const add_1 = require("./tasks/auth/add");
 const switch_1 = require("./tasks/auth/switch");
 const list_1 = require("./tasks/auth/list");
@@ -39,10 +41,13 @@ runner.load('task:run', run_1.run);
 runner.load('task:remove', remove_1.remove);
 runner.load('task:publish', publish_1.publish);
 runner.load('task:download', download_1.download);
+runner.load('task:replay', replay_1.replay);
 // Runner commands
 runner.load('runner:create', create_1.create);
 runner.load('runner:remove', remove_2.remove);
 runner.load('runner:bundle', bundle_1.bundle);
+// Fixture commands
+runner.load('fixture:download', download_2.download);
 // Auth commands
 runner.load('auth:add', add_1.add);
 runner.load('auth:switch', switch_1.switchProfile);
@@ -86,12 +91,27 @@ runner.setHandler(async (data) => {
                 uuid
             });
         }
+        else if (taskName === 'task:replay') {
+            const { path, cache } = args;
+            result = await task.run({
+                descriptorName: action,
+                path,
+                cache
+            });
+        }
         else if (taskName === 'task:run') {
             result = await task.run({
                 descriptorName: action,
                 args
             });
         }
+        else if (taskName === 'fixture:download') {
+            const { uuid } = args;
+            result = await task.run({
+                descriptorName: action,
+                uuid
+            });
+        }
         else if (taskName === 'auth:add') {
             const { apiKey, apiSecret, url } = args;
             result = await task.run({

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

@@ -0,0 +1,34 @@
+import { Profile } from '../types';
+interface FixtureData {
+    name: string;
+    [key: string]: unknown;
+}
+interface FixtureResponse {
+    fixture: FixtureData;
+    [key: string]: unknown;
+}
+export declare const download: import("@forgehive/task").TaskInstanceType<(argv: {
+    uuid: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    downloadFixture: (uuid: string, profile: Profile) => Promise<FixtureResponse>;
+    getCwd: () => Promise<string>;
+    persistFixture: (filePath: string, data: FixtureData) => Promise<{
+        path: string;
+    }>;
+    checkFileExists: (filePath: string) => Promise<boolean>;
+}>) => Promise<{
+    status: string;
+    path: string;
+}>, {
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    downloadFixture: (uuid: string, profile: Profile) => Promise<FixtureResponse>;
+    getCwd: () => Promise<string>;
+    persistFixture: (filePath: string, data: FixtureData) => Promise<{
+        path: string;
+    }>;
+    checkFileExists: (filePath: string) => Promise<boolean>;
+}>;
+export {};

package/dist/tasks/fixture/download.js

@@ -0,0 +1,106 @@
+"use strict";
+// TASK: download
+// Run this task with:
+// forge task:run fixture:download --uuid [fixture-uuid]
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.download = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const axios_1 = __importDefault(require("axios"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const loadCurrent_1 = require("../auth/loadCurrent");
+const load_1 = require("../conf/load");
+const description = 'Download a fixture by UUID to a path based on task descriptor returned from API';
+const schema = new schema_1.Schema({
+    uuid: schema_1.Schema.string()
+});
+const boundaries = {
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    loadConf: load_1.load.asBoundary(),
+    downloadFixture: async (uuid, profile) => {
+        const downloadUrl = `${profile.url}/api/fixture/${uuid}`;
+        console.log(`Downloading fixture from ${downloadUrl}...`);
+        const authToken = `${profile.apiKey}:${profile.apiSecret}`;
+        const response = await axios_1.default.get(downloadUrl, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data;
+    },
+    getCwd: async () => {
+        return process.cwd();
+    },
+    persistFixture: async (filePath, data) => {
+        const dirPath = path_1.default.dirname(filePath);
+        await promises_1.default.mkdir(dirPath, { recursive: true });
+        await promises_1.default.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+        return {
+            path: filePath
+        };
+    },
+    checkFileExists: async (filePath) => {
+        try {
+            await promises_1.default.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+};
+exports.download = (0, task_1.createTask)(schema, boundaries, async function ({ uuid }, { downloadFixture, getCwd, persistFixture, checkFileExists, loadCurrentProfile, loadConf }) {
+    console.log('==================================================');
+    console.log(`Attempting to download fixture with uuid: ${uuid}`);
+    const profile = await loadCurrentProfile({});
+    const cwd = await getCwd();
+    const forge = await loadConf({});
+    // Download from hive api server first to get the task descriptor
+    let response;
+    try {
+        response = await downloadFixture(uuid, profile);
+    }
+    catch (e) {
+        const error = e;
+        console.error('Error downloading fixture:', error.message, error.status);
+        if (error.status === 404) {
+            throw new Error('Fixture not found');
+        }
+        throw new Error('Failed to download fixture');
+    }
+    // Extract task descriptor from the response
+    const taskName = response.fixture.name;
+    // Determine the output path using forge fixtures path and task descriptor
+    const fixturesBasePath = forge.paths.fixtures || 'fixtures';
+    const fixtureDir = path_1.default.join(fixturesBasePath, taskName);
+    const fixturePath = path_1.default.join(fixtureDir, `${uuid}.json`);
+    const filePath = path_1.default.resolve(cwd, fixturePath);
+    console.log(`Fixture will be saved to: ${filePath}`);
+    // Check if file already exists
+    const fileExists = await checkFileExists(filePath);
+    if (fileExists) {
+        console.log(`Fixture will be updated at ${filePath}`);
+    }
+    console.log(`
+    ==================================================
+    Starting fixture download!
+    Fixture UUID: ${uuid}
+    Task Name: ${taskName}
+    Saving to: ${filePath}
+    ==================================================
+    Replay with: forge task:replay --path ${filePath}
+    ==================================================
+    `);
+    // Persist fixture to file
+    await persistFixture(filePath, response.fixture);
+    return {
+        status: 'Downloaded',
+        path: filePath
+    };
+});
+exports.download.setDescription(description);

package/dist/tasks/init.js

@@ -31,9 +31,9 @@ exports.init = (0, task_1.createTask)(schema, boundaries, async function (argv,
         },
         paths: {
             logs: 'logs/',
+            fixtures: 'fixtures/',
             tasks: 'src/tasks/',
             runners: 'src/runners/',
-            fixtures: 'src/tests/fixtures',
             tests: 'src/tests/'
         },
         infra: {

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

@@ -0,0 +1,47 @@
+import { type ForgeConf, type Profile } from '../types';
+interface Fixture {
+    fixtureUUID: string;
+    name: string;
+    type: 'success' | 'error';
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    boundaries: Record<string, unknown>;
+    context: Record<string, unknown>;
+}
+export declare const replay: import("@forgehive/task").TaskInstanceType<(argv: {
+    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>>;
+    bundleCreate: (args: {
+        entryPoint: string;
+        outputFile: string;
+    }) => Promise<Promise<{
+        outputFile: string;
+    }>>;
+    bundleLoad: (args: {
+        bundlePath: string;
+    }) => Promise<Promise<any>>;
+    ensureBuildsFolder: () => Promise<string>;
+    verifyLogFolder: (logsPath: string) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown, fixtureUUID: string) => Promise<boolean>;
+}>) => Promise<any>, {
+    readFixture: (filePath: string) => Promise<Fixture>;
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    bundleCreate: (args: {
+        entryPoint: string;
+        outputFile: string;
+    }) => Promise<Promise<{
+        outputFile: string;
+    }>>;
+    bundleLoad: (args: {
+        bundlePath: string;
+    }) => Promise<Promise<any>>;
+    ensureBuildsFolder: () => Promise<string>;
+    verifyLogFolder: (logsPath: string) => Promise<boolean>;
+    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown, fixtureUUID: string) => Promise<boolean>;
+}>;
+export {};

package/dist/tasks/task/replay.js

@@ -0,0 +1,172 @@
+"use strict";
+// TASK: replay
+// Run this task with:
+// forge task:run task:replay
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replay = 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 os_1 = __importDefault(require("os"));
+const axios_1 = __importDefault(require("axios"));
+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({
+    path: schema_1.Schema.string(),
+    cache: schema_1.Schema.string().optional()
+});
+const boundaries = {
+    readFixture: async (filePath) => {
+        const fileContent = await promises_1.default.readFile(filePath, 'utf-8');
+        const parsedData = JSON.parse(fileContent);
+        return parsedData;
+    },
+    loadConf: load_2.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    bundleCreate: create_1.create.asBoundary(),
+    bundleLoad: load_1.load.asBoundary(),
+    ensureBuildsFolder: async () => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge', 'builds');
+        try {
+            await promises_1.default.access(buildsPath);
+        }
+        catch {
+            await promises_1.default.mkdir(buildsPath, { recursive: true });
+        }
+        return buildsPath;
+    },
+    verifyLogFolder: async (logsPath) => {
+        // return true if the folder exists
+        try {
+            await promises_1.default.access(logsPath);
+        }
+        catch (error) {
+            return false;
+        }
+        return true;
+    },
+    sendLogToAPI: async (profile, projectName, taskName, logItem, 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'
+                }
+            });
+            console.log('===============================================');
+            console.log('Log sent to API... ', profile.name, profile.url);
+            console.log('Replay from fixture UUID:', fixtureUUID);
+            return true;
+        }
+        catch (e) {
+            const error = e;
+            console.error('Failed to send log to API:', error.message);
+            return false;
+        }
+    }
+};
+exports.replay = (0, task_1.createTask)(schema, boundaries, async function (argv, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
+    console.log('Input path:', argv.path);
+    // Read the file from the provided path
+    const fixture = await readFixture(argv.path);
+    // Load forge configuration
+    const forge = await loadConf({});
+    const taskName = fixture.name;
+    const taskDescriptor = forge.tasks[taskName];
+    const projectName = forge.project.name;
+    if (taskDescriptor === undefined) {
+        throw new Error(`Task ${taskName} is not defined in forge.json`);
+    }
+    // Try to load profile, but continue if not found
+    let profile = null;
+    try {
+        profile = await loadCurrentProfile({});
+    }
+    catch (error) {
+        // Profile not found or not configured, continue without it
+        console.log('No profile found, logs will not be sent to remote API');
+    }
+    // Verify if log folder exists
+    const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
+    const logFolderExists = await verifyLogFolder(logFolderPath);
+    if (!logFolderExists) {
+        throw new Error(`Log folder "${logFolderPath}" does not exist`);
+    }
+    // Prepare paths
+    const entryPoint = path_1.default.join(process.cwd(), taskDescriptor.path);
+    const buildsPath = await ensureBuildsFolder();
+    const outputFile = path_1.default.join(buildsPath, `${taskName}.js`);
+    // Bundle the task
+    await bundleCreate({
+        entryPoint,
+        outputFile
+    });
+    // Load the bundled task
+    const bundle = await bundleLoad({
+        bundlePath: outputFile
+    });
+    // Get the task handler
+    const task = bundle[taskDescriptor.handler];
+    if (!task) {
+        throw new Error(`Handler "${taskDescriptor.handler}" not found in bundle`);
+    }
+    // Configure boundaries based on cache parameter if provided
+    const boundaryConfig = {};
+    if (argv.cache) {
+        // Parse the comma-separated list and trim each item
+        const cacheBoundaries = argv.cache.split(',').map(b => b.trim());
+        // Log which boundaries will use cache mode
+        if (cacheBoundaries.length > 0) {
+            // Set each specified boundary to 'replay' mode
+            cacheBoundaries.forEach(boundary => {
+                boundaryConfig[boundary] = 'replay';
+            });
+        }
+    }
+    console.log('==================================================');
+    console.log('UUID:', fixture.fixtureUUID);
+    console.log('Name:', fixture.name);
+    console.log('Context:', fixture.context);
+    console.log('==================================================');
+    console.log('Replay:', fixture.input);
+    console.log('Boundaries:', JSON.stringify(fixture.boundaries, null, 2));
+    console.log('==================================================');
+    console.log('Boundary config:', boundaryConfig);
+    console.log('==================================================');
+    // Perform the replay
+    const [result, error, record] = await task.safeReplay({
+        input: fixture.input,
+        output: fixture.output,
+        boundaries: fixture.boundaries,
+    }, {
+        boundaries: boundaryConfig // Use configured boundary modes
+    });
+    // Send the log to API if profile is available
+    if (profile) {
+        try {
+            await sendLogToAPI(profile, projectName, taskName, record, fixture.fixtureUUID);
+        }
+        catch (e) {
+            console.error('Failed to send log to API:', e);
+        }
+    }
+    if (error) {
+        throw new Error(error.message);
+    }
+    return result;
+});
+exports.replay.setDescription(description);

package/forge.json

@@ -4,9 +4,9 @@
   },
   "paths": {
     "logs": "logs/",
+    "fixtures": "fixtures",
     "tasks": "src/tasks/",
     "runners": "src/runners/",
-    "fixtures": "src/tests/fixtures",
     "tests": "src/tests/"
   },
   "infra": {
@@ -77,6 +77,14 @@
     "auth:remove": {
       "path": "src/tasks/auth/remove.ts",
       "handler": "remove"
+    },
+    "task:replay": {
+      "path": "src/tasks/task/replay.ts",
+      "handler": "replay"
+    },
+    "fixture:download": {
+      "path": "src/tasks/fixture/download.ts",
+      "handler": "download"
     }
   },
   "runners": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,10 +10,10 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/record-tape": "^0.1.1",
-      "@forgehive/runner": "^0.1.7",
+      "@forgehive/record-tape": "^0.1.3",
+      "@forgehive/runner": "^0.1.9",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.1.7",
+      "@forgehive/task": "^0.1.9",
       "esbuild": "^0.25.0",
       "handlebars": "^4.7.8",
       "minimist": "^1.2.8"
@@ -25,10 +25,10 @@
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
-    "@forgehive/runner": "0.1.8",
-    "@forgehive/record-tape": "0.1.2",
+    "@forgehive/runner": "0.1.9",
     "@forgehive/schema": "0.1.4",
-    "@forgehive/task": "0.1.8"
+    "@forgehive/task": "0.1.9",
+    "@forgehive/record-tape": "0.1.3"
   },
   "devDependencies": {
     "@types/jest": "^29.5.3",

package/src/runner.ts

@@ -18,6 +18,9 @@ import { remove as removeRunner } from './tasks/runner/remove'
 import { bundle as bundleRunner } from './tasks/runner/bundle'
 import { publish as publishTask } from './tasks/task/publish'
 import { download as downloadTask } from './tasks/task/download'
+import { replay as replayTask } from './tasks/task/replay'
+
+import { download as downloadFixture } from './tasks/fixture/download'
 
 import { add as addProfile } from './tasks/auth/add'
 import { switchProfile } from './tasks/auth/switch'
@@ -48,12 +51,16 @@ runner.load('task:run', taskRunCommand)
 runner.load('task:remove', taskRemoveCommand)
 runner.load('task:publish', publishTask)
 runner.load('task:download', downloadTask)
+runner.load('task:replay', replayTask)
 
 // Runner commands
 runner.load('runner:create', createRunner)
 runner.load('runner:remove', removeRunner)
 runner.load('runner:bundle', bundleRunner)
 
+// Fixture commands
+runner.load('fixture:download', downloadFixture)
+
 // Auth commands
 runner.load('auth:add', addProfile)
 runner.load('auth:switch', switchProfile)
@@ -101,11 +108,26 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
         descriptorName: action,
         uuid
       })
+    } else if (taskName === 'task:replay') {
+      const { path, cache } = args as { path: string, cache: string }
+
+      result = await task.run({
+        descriptorName: action,
+        path,
+        cache
+      })
     } else if (taskName === 'task:run') {
       result = await task.run({
         descriptorName: action,
         args
       })
+    } else if (taskName === 'fixture:download') {
+      const { uuid } = args as { uuid: string }
+
+      result = await task.run({
+        descriptorName: action,
+        uuid
+      })
     } else if (taskName === 'auth:add') {
       const { apiKey, apiSecret, url } = args as { name: string, apiKey: string, apiSecret: string, url: string }
 

package/src/tasks/fixture/download.ts

@@ -0,0 +1,143 @@
+// TASK: download
+// Run this task with:
+// forge task:run fixture:download --uuid [fixture-uuid]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import axios from 'axios'
+import path from 'path'
+import fs from 'fs/promises'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { load as loadConf } from '../conf/load'
+import { Profile } from '../types'
+
+// Define the Fixture data structure
+interface FixtureData {
+  name: string;
+  [key: string]: unknown;
+}
+
+interface FixtureResponse {
+  fixture: FixtureData;
+  [key: string]: unknown;
+}
+
+const description = 'Download a fixture by UUID to a path based on task descriptor returned from API'
+
+const schema = new Schema({
+  uuid: Schema.string()
+})
+
+const boundaries = {
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  loadConf: loadConf.asBoundary(),
+  downloadFixture: async (uuid: string, profile: Profile): Promise<FixtureResponse> => {
+    const downloadUrl = `${profile.url}/api/fixture/${uuid}`
+
+    console.log(`Downloading fixture from ${downloadUrl}...`)
+
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    const response = await axios.get(downloadUrl, {
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        'Content-Type': 'application/json'
+      }
+    })
+
+    return response.data
+  },
+  getCwd: async (): Promise<string> => {
+    return process.cwd()
+  },
+  persistFixture: async (filePath: string, data: FixtureData): Promise<{ path: string }> => {
+    const dirPath = path.dirname(filePath)
+
+    await fs.mkdir(dirPath, { recursive: true })
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
+
+    return {
+      path: filePath
+    }
+  },
+  checkFileExists: async (filePath: string): Promise<boolean> => {
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+export const download = createTask(
+  schema,
+  boundaries,
+  async function ({ uuid }, {
+    downloadFixture,
+    getCwd,
+    persistFixture,
+    checkFileExists,
+    loadCurrentProfile,
+    loadConf
+  }) {
+    console.log('==================================================')
+    console.log(`Attempting to download fixture with uuid: ${uuid}`)
+
+    const profile = await loadCurrentProfile({})
+    const cwd = await getCwd()
+    const forge = await loadConf({})
+
+    // Download from hive api server first to get the task descriptor
+    let response
+    try {
+      response = await downloadFixture(uuid, profile)
+    } catch (e: unknown) {
+      const error = e as { status?: number, message: string }
+      console.error('Error downloading fixture:', error.message, error.status)
+
+      if (error.status === 404) {
+        throw new Error('Fixture not found')
+      }
+
+      throw new Error('Failed to download fixture')
+    }
+
+    // Extract task descriptor from the response
+    const taskName = response.fixture.name
+
+    // Determine the output path using forge fixtures path and task descriptor
+    const fixturesBasePath = forge.paths.fixtures || 'fixtures'
+    const fixtureDir = path.join(fixturesBasePath, taskName)
+    const fixturePath = path.join(fixtureDir, `${uuid}.json`)
+    const filePath = path.resolve(cwd, fixturePath)
+
+    console.log(`Fixture will be saved to: ${filePath}`)
+
+    // Check if file already exists
+    const fileExists = await checkFileExists(filePath)
+    if (fileExists) {
+      console.log(`Fixture will be updated at ${filePath}`)
+    }
+
+    console.log(`
+    ==================================================
+    Starting fixture download!
+    Fixture UUID: ${uuid}
+    Task Name: ${taskName}
+    Saving to: ${filePath}
+    ==================================================
+    Replay with: forge task:replay --path ${filePath}
+    ==================================================
+    `)
+
+    // Persist fixture to file
+    await persistFixture(filePath, response.fixture)
+
+    return {
+      status: 'Downloaded',
+      path: filePath
+    }
+  }
+)
+
+download.setDescription(description)

package/src/tasks/init.ts

@@ -36,9 +36,9 @@ export const init = createTask(
       },
       paths: {
         logs: 'logs/',
+        fixtures: 'fixtures/',
         tasks: 'src/tasks/',
         runners: 'src/runners/',
-        fixtures: 'src/tests/fixtures',
         tests: 'src/tests/'
       },
       infra: {

package/src/tasks/task/replay.ts

@@ -0,0 +1,211 @@
+// TASK: replay
+// Run this task with:
+// forge task:run task:replay
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import axios from 'axios'
+
+import { create as bundleCreate } from '../bundle/create'
+import { load as bundleLoad } from '../bundle/load'
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+// Define the fixture structure type
+interface Fixture {
+  fixtureUUID: string;
+  name: string;
+  type: 'success' | 'error';
+  input: Record<string, unknown>;
+  output: Record<string, unknown>;
+  boundaries: Record<string, unknown>;
+  context: Record<string, unknown>;
+}
+
+const description = 'Replay a task execution from a specified path'
+
+const schema = new Schema({
+  path: Schema.string(),
+  cache: Schema.string().optional()
+})
+
+const boundaries = {
+  readFixture: async (filePath: string): Promise<Fixture> => {
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const parsedData = JSON.parse(fileContent) as Fixture
+
+    return parsedData
+  },
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  bundleCreate: bundleCreate.asBoundary(),
+  bundleLoad: bundleLoad.asBoundary(),
+  ensureBuildsFolder: async (): Promise<string> => {
+    const buildsPath = path.join(os.homedir(), '.forge', 'builds')
+    try {
+      await fs.access(buildsPath)
+    } catch {
+      await fs.mkdir(buildsPath, { recursive: true })
+    }
+
+    return buildsPath
+  },
+  verifyLogFolder: async (logsPath: string): Promise<boolean> => {
+    // return true if the folder exists
+    try {
+      await fs.access(logsPath)
+    } catch (error) {
+      return false
+    }
+
+    return true
+  },
+  sendLogToAPI: async (profile: Profile, projectName: string, taskName: string, logItem: unknown, fixtureUUID: string): Promise<boolean> => {
+    try {
+      const logsUrl = `${profile.url}/api/tasks/log-ingest`
+      const authToken = `${profile.apiKey}:${profile.apiSecret}`
+
+      await axios.post(logsUrl, {
+        projectName,
+        taskName,
+        logItem: JSON.stringify(logItem),
+        replayFrom: fixtureUUID
+      }, {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      console.log('===============================================')
+      console.log('Log sent to API... ', profile.name, profile.url)
+      console.log('Replay from fixture UUID:', fixtureUUID)
+
+      return true
+    } catch (e) {
+      const error = e as Error
+      console.error('Failed to send log to API:', error.message)
+      return false
+    }
+  }
+}
+
+export const replay = createTask(
+  schema,
+  boundaries,
+  async function (argv, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
+    console.log('Input path:', argv.path)
+
+    // Read the file from the provided path
+    const fixture = await readFixture(argv.path)
+
+    // Load forge configuration
+    const forge: ForgeConf = await loadConf({})
+    const taskName = fixture.name
+    const taskDescriptor = forge.tasks[taskName as keyof typeof forge.tasks]
+    const projectName = forge.project.name
+
+    if (taskDescriptor === undefined) {
+      throw new Error(`Task ${taskName} is not defined in forge.json`)
+    }
+
+    // Try to load profile, but continue if not found
+    let profile = null
+    try {
+      profile = await loadCurrentProfile({})
+    } catch (error) {
+      // Profile not found or not configured, continue without it
+      console.log('No profile found, logs will not be sent to remote API')
+    }
+
+    // Verify if log folder exists
+    const logFolderPath = path.join(process.cwd(), forge.paths.logs)
+    const logFolderExists = await verifyLogFolder(logFolderPath)
+    if (!logFolderExists) {
+      throw new Error(`Log folder "${logFolderPath}" does not exist`)
+    }
+
+    // Prepare paths
+    const entryPoint = path.join(process.cwd(), taskDescriptor.path)
+    const buildsPath = await ensureBuildsFolder()
+    const outputFile = path.join(buildsPath, `${taskName}.js`)
+
+    // Bundle the task
+    await bundleCreate({
+      entryPoint,
+      outputFile
+    })
+
+    // Load the bundled task
+    const bundle = await bundleLoad({
+      bundlePath: outputFile
+    })
+
+    // Get the task handler
+    const task = bundle[taskDescriptor.handler]
+
+    if (!task) {
+      throw new Error(`Handler "${taskDescriptor.handler}" not found in bundle`)
+    }
+
+    // Configure boundaries based on cache parameter if provided
+    const boundaryConfig: Record<string, string> = {}
+
+    if (argv.cache) {
+      // Parse the comma-separated list and trim each item
+      const cacheBoundaries = argv.cache.split(',').map(b => b.trim())
+
+      // Log which boundaries will use cache mode
+      if (cacheBoundaries.length > 0) {
+        // Set each specified boundary to 'replay' mode
+        cacheBoundaries.forEach(boundary => {
+          boundaryConfig[boundary] = 'replay'
+        })
+      }
+    }
+
+    console.log('==================================================')
+    console.log('UUID:', fixture.fixtureUUID)
+    console.log('Name:', fixture.name)
+    console.log('Context:', fixture.context)
+    console.log('==================================================')
+    console.log('Replay:', fixture.input)
+    console.log('Boundaries:', JSON.stringify(fixture.boundaries, null, 2))
+    console.log('==================================================')
+    console.log('Boundary config:', boundaryConfig)
+    console.log('==================================================')
+
+    // Perform the replay
+    const [result, error, record] = await task.safeReplay(
+      {
+        input: fixture.input,
+        output: fixture.output,
+        boundaries: fixture.boundaries,
+      },
+      {
+        boundaries: boundaryConfig // Use configured boundary modes
+      }
+    )
+
+    // Send the log to API if profile is available
+    if (profile) {
+      try {
+        await sendLogToAPI(profile, projectName, taskName, record, fixture.fixtureUUID)
+      } catch (e) {
+        console.error('Failed to send log to API:', e)
+      }
+    }
+
+    if (error) {
+      throw new Error(error.message)
+    }
+
+    return result
+  }
+)
+
+replay.setDescription(description)