@forgehive/forge-cli 0.2.10 → 0.2.12

package/dist/index.js

@@ -7,9 +7,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const minimist_1 = __importDefault(require("minimist"));
 const runner_1 = __importDefault(require("./runner"));
 const args = (0, minimist_1.default)(process.argv.slice(2));
-runner_1.default.handler(args).then(data => {
+runner_1.default.handler(args).then((data) => {
+    const { silent, outcome, result } = data;
+    if (silent) {
+        return;
+    }
     console.log('===============================================');
-    console.log('Outcome', data);
+    console.log(`Outcome: ${outcome}`);
+    console.log('===============================================');
+    console.log('Result', result);
     console.log('===============================================');
 }).catch((e) => {
     console.error(e);

package/dist/runner.js

@@ -57,9 +57,10 @@ runner.load('auth:remove', remove_3.remove);
 runner.setHandler(async (data) => {
     const parsedArgs = runner.parseArguments(data);
     const { taskName, action, args } = parsedArgs;
-    console.log('========================================');
+    console.log('===============================================');
     console.log(`Running: ${taskName} ${action ? action : ''} ${JSON.stringify(args)}`);
-    console.log('========================================');
+    console.log('===============================================');
+    let silent = false;
     const task = runner.getTask(taskName);
     if (!task) {
         throw new Error(`Task "${taskName}" not found`);
@@ -111,6 +112,7 @@ runner.setHandler(async (data) => {
                 descriptorName: action,
                 uuid
             });
+            silent = true;
         }
         else if (taskName === 'auth:add') {
             const { apiKey, apiSecret, url } = args;
@@ -130,6 +132,7 @@ runner.setHandler(async (data) => {
             result = await task.run(args);
         }
         return {
+            silent,
             outcome: 'Success',
             taskName,
             result

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

@@ -0,0 +1,26 @@
+import archiver from 'archiver';
+import fs from 'fs';
+export declare const bytesToMB: (bytes: number) => string;
+export declare const zip: import("@forgehive/task").TaskInstanceType<(argv: {
+    dir: string;
+    input: string;
+    output: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    createWriteStream: (outputPath: string) => Promise<fs.WriteStream>;
+    createArchiver: (format: "zip", options: {
+        zlib: {
+            level: number;
+        };
+    }) => Promise<archiver.Archiver>;
+    resolvePathDir: (dir: string, filename: string) => Promise<string>;
+    fileExists: (filePath: string) => Promise<boolean>;
+}>) => Promise<unknown>, {
+    createWriteStream: (outputPath: string) => Promise<fs.WriteStream>;
+    createArchiver: (format: "zip", options: {
+        zlib: {
+            level: number;
+        };
+    }) => Promise<archiver.Archiver>;
+    resolvePathDir: (dir: string, filename: string) => Promise<string>;
+    fileExists: (filePath: string) => Promise<boolean>;
+}>;

package/dist/tasks/bundle/zip.js

@@ -0,0 +1,96 @@
+"use strict";
+// TASK: zip
+// Run this task with:
+// forge task:run bundle:zip --dir .builds/ --input dailyUpdate.js --output dailyUpdate.zip
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zip = exports.bytesToMB = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const archiver_1 = __importDefault(require("archiver"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const description = 'Zip a bundle file for distribution';
+const schema = new schema_1.Schema({
+    dir: schema_1.Schema.string(),
+    input: schema_1.Schema.string(),
+    output: schema_1.Schema.string()
+});
+const boundaries = {
+    createWriteStream: async (outputPath) => {
+        return fs_1.default.createWriteStream(outputPath);
+    },
+    createArchiver: async (format, options) => {
+        return (0, archiver_1.default)(format, options);
+    },
+    resolvePathDir: async (dir, filename) => {
+        return path_1.default.resolve(dir, filename);
+    },
+    fileExists: async (filePath) => {
+        try {
+            await fs_1.default.promises.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+};
+const bytesToMB = (bytes) => {
+    const MB = bytes / (1024 * 1024);
+    return `${MB.toFixed(2)} MB`;
+};
+exports.bytesToMB = bytesToMB;
+exports.zip = (0, task_1.createTask)(schema, boundaries, async function ({ dir, input, output }, { createWriteStream, createArchiver, resolvePathDir, fileExists }) {
+    const outputPath = await resolvePathDir(dir, output);
+    const inputPath = await resolvePathDir(dir, input);
+    const inputMapPath = inputPath + '.map';
+    // Check if input file exists
+    const inputExists = await fileExists(inputPath);
+    if (!inputExists) {
+        throw new Error(`Input file does not exist: ${inputPath}`);
+    }
+    // Check if source map exists before creating Promise
+    const mapExists = await fileExists(inputMapPath);
+    // Handle async operations outside of Promise constructor
+    const outStream = await createWriteStream(outputPath);
+    const archive = await createArchiver('zip', {
+        zlib: { level: 9 } // Sets the compression level
+    });
+    return new Promise((resolve, reject) => {
+        archive.on('error', function (err) {
+            reject(err);
+        });
+        outStream.on('end', function () {
+            console.log('Data has been drained');
+        });
+        outStream.on('close', function () {
+            setTimeout(() => {
+                resolve({
+                    output,
+                    outputPath,
+                    size: archive.pointer()
+                });
+            }, 100);
+        });
+        archive.on('warning', function (err) {
+            if (err.code === 'ENOENT') {
+                console.warn('ENOENT', err);
+            }
+            else {
+                reject(err);
+            }
+        });
+        archive.pipe(outStream);
+        // Add the main bundle file
+        archive.file(inputPath, { name: 'index.js' });
+        // Add source map if it exists
+        if (mapExists) {
+            archive.file(inputMapPath, { name: 'index.js.map' });
+        }
+        archive.finalize();
+    });
+});
+exports.zip.setDescription(description);

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

@@ -1,6 +1,7 @@
 import { Profile } from '../types';
 interface FixtureData {
     name: string;
+    boundaries: Record<string, unknown>;
     [key: string]: unknown;
 }
 interface FixtureResponse {
@@ -17,10 +18,10 @@ export declare const download: import("@forgehive/task").TaskInstanceType<(argv:
     persistFixture: (filePath: string, data: FixtureData) => Promise<{
         path: string;
     }>;
-    checkFileExists: (filePath: string) => Promise<boolean>;
 }>) => Promise<{
     status: string;
     path: string;
+    shortPath: string;
 }>, {
     loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
     loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
@@ -29,6 +30,5 @@ export declare const download: import("@forgehive/task").TaskInstanceType<(argv:
     persistFixture: (filePath: string, data: FixtureData) => Promise<{
         path: string;
     }>;
-    checkFileExists: (filePath: string) => Promise<boolean>;
 }>;
 export {};

package/dist/tasks/fixture/download.js

@@ -43,20 +43,12 @@ const boundaries = {
         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 }) {
+exports.download = (0, task_1.createTask)(schema, boundaries, async function ({ uuid }, { downloadFixture, getCwd, persistFixture, loadCurrentProfile, loadConf }) {
     console.log('==================================================');
     console.log(`Attempting to download fixture with uuid: ${uuid}`);
+    console.log('==================================================');
     const profile = await loadCurrentProfile({});
     const cwd = await getCwd();
     const forge = await loadConf({});
@@ -73,34 +65,35 @@ exports.download = (0, task_1.createTask)(schema, boundaries, async function ({
         }
         throw new Error('Failed to download fixture');
     }
-    // Extract task descriptor from the response
-    const taskName = response.fixture.name;
+    const fixture = response.fixture;
+    const taskName = fixture.taskName;
     // 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);
+    // Get the relative path for display in the replay command
+    const shortPath = path_1.default.join(taskName, `${uuid}.json`);
+    console.log(`
+==================================================
+Fixture download completed!
+==================================================
+Fixture UUID: ${uuid}
+Task Name: ${taskName}
+Saved to: ${filePath}
+==================================================
+Boundaries: ${Object.keys(fixture.boundaries).join(', ')}
+==================================================
+Replay with:
+forge task:replay ${taskName} --path ${shortPath}
+==================================================
+    `);
     return {
         status: 'Downloaded',
-        path: filePath
+        path: filePath,
+        shortPath: shortPath
     };
 });
 exports.download.setDescription(description);

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

@@ -14,6 +14,11 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
     bundleLoad: (args: {
         bundlePath: string;
     }) => Promise<Promise<any>>;
+    bundleZip: (args: {
+        dir: string;
+        input: string;
+        output: string;
+    }) => Promise<Promise<unknown>>;
     readFileUtf8: (filePath: string) => Promise<string>;
     readFileBinary: (filePath: string) => Promise<Buffer>;
     publishTask: (data: any, profile: Profile) => Promise<any>;
@@ -35,6 +40,11 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
     bundleLoad: (args: {
         bundlePath: string;
     }) => Promise<Promise<any>>;
+    bundleZip: (args: {
+        dir: string;
+        input: string;
+        output: string;
+    }) => Promise<Promise<unknown>>;
     readFileUtf8: (filePath: string) => Promise<string>;
     readFileBinary: (filePath: string) => Promise<Buffer>;
     publishTask: (data: any, profile: Profile) => Promise<any>;

package/dist/tasks/task/publish.js

@@ -16,6 +16,7 @@ const os_1 = __importDefault(require("os"));
 const load_1 = require("../conf/load");
 const create_1 = require("../bundle/create");
 const load_2 = require("../bundle/load");
+const zip_1 = require("../bundle/zip");
 const loadCurrent_1 = require("../auth/loadCurrent");
 const schema = new schema_1.Schema({
     descriptorName: schema_1.Schema.string()
@@ -28,6 +29,7 @@ const boundaries = {
     loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
     bundleCreate: create_1.create.asBoundary(),
     bundleLoad: load_2.load.asBoundary(),
+    bundleZip: zip_1.zip.asBoundary(),
     readFileUtf8: async (filePath) => {
         return promises_1.default.readFile(filePath, 'utf-8');
     },
@@ -75,7 +77,7 @@ const boundaries = {
         return buildsPath;
     }
 };
-exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile, uploadBundleWithPresignedUrl }) {
+exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, bundleZip, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile, uploadBundleWithPresignedUrl }) {
     const cwd = await getCwd();
     const forgeJson = await loadConf({});
     const profile = await loadCurrentProfile({});
@@ -87,12 +89,20 @@ exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ d
     const entryPoint = path_1.default.join(cwd, taskDescriptor.path);
     const buildsPath = await ensureBuildsFolder();
     const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
+    const zipFile = `${descriptorName}.zip`;
     // Bundle the task
     await bundleCreate({
         entryPoint,
         outputFile
     });
     console.log('Bundle created...');
+    // Zip the bundle
+    await bundleZip({
+        dir: buildsPath,
+        input: `${descriptorName}.js`,
+        output: zipFile
+    });
+    console.log('Bundle zipped...');
     // Load the bundled task
     const bundle = await bundleLoad({
         bundlePath: outputFile
@@ -105,13 +115,16 @@ exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ d
     const schemaDescriptor = schema.describe();
     // Read the task file content
     const sourceCode = await readFileUtf8(entryPoint);
-    const bundleContent = await readFileBinary(outputFile);
+    // Read the zipped bundle instead of the raw bundle
+    const zipPath = path_1.default.join(buildsPath, zipFile);
+    const bundleContent = await readFileBinary(zipPath);
     // Get bundle size
     const bundleSize = bundleContent.length;
     // First, publish task metadata and get presigned URL for bundle upload
     const data = {
         ...taskDescriptor,
         taskName: descriptorName,
+        handler: taskDescriptor.handler,
         projectName,
         description,
         schemaDescriptor: JSON.stringify(schemaDescriptor),
@@ -122,9 +135,9 @@ exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ d
     // Publish metadata to hive api server
     console.log(`Publishing metadata and source code to ${profile.url}...`);
     const publishResponse = await publishTask(data, profile);
-    // Upload bundle using the presigned URL
+    // Upload zipped bundle using the presigned URL
     if (publishResponse.bundleUploadUrl) {
-        console.log('Uploading bundle...');
+        console.log('Uploading zipped bundle...');
         await uploadBundleWithPresignedUrl(publishResponse.bundleUploadUrl, bundleContent);
         return {
             descriptor: taskDescriptor,

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

@@ -1,7 +1,8 @@
 import { type ForgeConf, type Profile } from '../types';
 interface Fixture {
     fixtureUUID: string;
-    name: string;
+    taskName: string;
+    projectName: string;
     type: 'success' | 'error';
     input: Record<string, unknown>;
     output: Record<string, unknown>;
@@ -10,6 +11,7 @@ interface Fixture {
 }
 export declare const replay: import("@forgehive/task").TaskInstanceType<(argv: {
     path: string;
+    descriptorName: string;
     cache?: string | undefined;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     readFixture: (filePath: string) => Promise<Fixture>;

package/dist/tasks/task/replay.js

@@ -19,6 +19,7 @@ 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()
 });
@@ -79,18 +80,23 @@ const boundaries = {
         }
     }
 };
-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);
+exports.replay = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, path: fixturePath, cache }, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
+    console.log('Input descriptorName:', descriptorName);
+    console.log('Input path:', fixturePath);
+    console.log('Input cache:', cache);
     // Load forge configuration
     const forge = await loadConf({});
-    const taskName = fixture.name;
-    const taskDescriptor = forge.tasks[taskName];
+    const taskDescriptor = forge.tasks[descriptorName];
     const projectName = forge.project.name;
     if (taskDescriptor === undefined) {
-        throw new Error(`Task ${taskName} is not defined in forge.json`);
+        throw new Error(`Task ${descriptorName} is not defined in forge.json`);
     }
+    // Resolve the fixture path (check if absolute, if not make it relative to logs folder)
+    const resolvedFixturePath = path_1.default.isAbsolute(fixturePath)
+        ? fixturePath
+        : path_1.default.join(process.cwd(), forge.paths.fixtures, fixturePath);
+    // Read the file from the provided path
+    const fixture = await readFixture(resolvedFixturePath);
     // Try to load profile, but continue if not found
     let profile = null;
     try {
@@ -109,7 +115,7 @@ exports.replay = (0, task_1.createTask)(schema, boundaries, async function (argv
     // 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`);
+    const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
     // Bundle the task
     await bundleCreate({
         entryPoint,
@@ -126,20 +132,21 @@ exports.replay = (0, task_1.createTask)(schema, boundaries, async function (argv
     }
     // Configure boundaries based on cache parameter if provided
     const boundaryConfig = {};
-    if (argv.cache) {
+    if (cache) {
         // Parse the comma-separated list and trim each item
-        const cacheBoundaries = argv.cache.split(',').map(b => b.trim());
+        const cacheBoundaries = 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 => {
+            cacheBoundaries.forEach((boundary) => {
                 boundaryConfig[boundary] = 'replay';
             });
         }
     }
     console.log('==================================================');
     console.log('UUID:', fixture.fixtureUUID);
-    console.log('Name:', fixture.name);
+    console.log('Task name:', fixture.taskName);
+    console.log('Project name:', fixture.projectName);
     console.log('Context:', fixture.context);
     console.log('==================================================');
     console.log('Replay:', fixture.input);
@@ -158,7 +165,7 @@ exports.replay = (0, task_1.createTask)(schema, boundaries, async function (argv
     // Send the log to API if profile is available
     if (profile) {
         try {
-            await sendLogToAPI(profile, projectName, taskName, record, fixture.fixtureUUID);
+            await sendLogToAPI(profile, projectName, descriptorName, record, fixture.fixtureUUID);
         }
         catch (e) {
             console.error('Failed to send log to API:', e);

package/forge.json

@@ -85,6 +85,10 @@
     "fixture:download": {
       "path": "src/tasks/fixture/download.ts",
       "handler": "download"
+    },
+    "bundle:zip": {
+      "path": "src/tasks/bundle/zip.ts",
+      "handler": "zip"
     }
   },
   "runners": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,27 +10,29 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/record-tape": "^0.1.3",
-      "@forgehive/runner": "^0.1.9",
+      "@forgehive/record-tape": "^0.1.4",
+      "@forgehive/runner": "^0.1.10",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.1.9",
+      "@forgehive/task": "^0.1.12",
       "esbuild": "^0.25.0",
       "handlebars": "^4.7.8",
       "minimist": "^1.2.8"
     }
   },
   "dependencies": {
+    "archiver": "^7.0.1",
     "axios": "^1.8.4",
     "dotenv": "^16.5.0",
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
-    "@forgehive/runner": "0.1.9",
-    "@forgehive/schema": "0.1.4",
-    "@forgehive/task": "0.1.9",
-    "@forgehive/record-tape": "0.1.3"
+    "@forgehive/runner": "0.1.11",
+    "@forgehive/record-tape": "0.1.5",
+    "@forgehive/task": "0.1.12",
+    "@forgehive/schema": "0.1.4"
   },
   "devDependencies": {
+    "@types/archiver": "^6.0.3",
     "@types/jest": "^29.5.3",
     "@types/minimist": "^1.2.5",
     "@types/node": "^20.4.5",

package/src/index.ts

@@ -5,9 +5,23 @@ import runner from './runner'
 
 const args = minimist(process.argv.slice(2))
 
-runner.handler(args).then(data => {
+type RunnerResult = {
+  silent: boolean
+  outcome: 'Success' | 'Failure'
+  taskName: string
+  result: unknown
+}
+
+runner.handler(args).then((data) => {
+  const { silent, outcome, result } = data as RunnerResult
+  if (silent) {
+    return
+  }
+
+  console.log('===============================================')
+  console.log(`Outcome: ${outcome}`)
   console.log('===============================================')
-  console.log('Outcome', data)
+  console.log('Result', result)
   console.log('===============================================')
 }).catch((e) => {
   console.error(e)

package/src/runner.ts

@@ -72,10 +72,11 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
   const parsedArgs = runner.parseArguments(data)
   const { taskName, action, args } = parsedArgs
 
-  console.log('========================================')
+  console.log('===============================================')
   console.log(`Running: ${taskName} ${action ? action : ''} ${JSON.stringify(args)}`)
-  console.log('========================================')
+  console.log('===============================================')
 
+  let silent = false
   const task = runner.getTask(taskName)
   if (!task) {
     throw new Error(`Task "${taskName}" not found`)
@@ -128,6 +129,7 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
         descriptorName: action,
         uuid
       })
+      silent = true
     } else if (taskName === 'auth:add') {
       const { apiKey, apiSecret, url } = args as { name: string, apiKey: string, apiSecret: string, url: string }
 
@@ -146,6 +148,7 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
     }
 
     return {
+      silent,
       outcome: 'Success',
       taskName,
       result

package/src/tasks/bundle/zip.ts

@@ -0,0 +1,109 @@
+// TASK: zip
+// Run this task with:
+// forge task:run bundle:zip --dir .builds/ --input dailyUpdate.js --output dailyUpdate.zip
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import archiver from 'archiver'
+import fs from 'fs'
+import path from 'path'
+
+const description = 'Zip a bundle file for distribution'
+
+const schema = new Schema({
+  dir: Schema.string(),
+  input: Schema.string(),
+  output: Schema.string()
+})
+
+const boundaries = {
+  createWriteStream: async (outputPath: string): Promise<fs.WriteStream> => {
+    return fs.createWriteStream(outputPath)
+  },
+  createArchiver: async (format: 'zip', options: { zlib: { level: number } }): Promise<archiver.Archiver> => {
+    return archiver(format, options)
+  },
+  resolvePathDir: async (dir: string, filename: string): Promise<string> => {
+    return path.resolve(dir, filename)
+  },
+  fileExists: async (filePath: string): Promise<boolean> => {
+    try {
+      await fs.promises.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+export const bytesToMB = (bytes: number): string => {
+  const MB = bytes / (1024 * 1024)
+  return `${MB.toFixed(2)} MB`
+}
+
+export const zip = createTask(
+  schema,
+  boundaries,
+  async function ({ dir, input, output }, { createWriteStream, createArchiver, resolvePathDir, fileExists }) {
+    const outputPath = await resolvePathDir(dir, output)
+    const inputPath = await resolvePathDir(dir, input)
+    const inputMapPath = inputPath + '.map'
+
+    // Check if input file exists
+    const inputExists = await fileExists(inputPath)
+    if (!inputExists) {
+      throw new Error(`Input file does not exist: ${inputPath}`)
+    }
+
+    // Check if source map exists before creating Promise
+    const mapExists = await fileExists(inputMapPath)
+
+    // Handle async operations outside of Promise constructor
+    const outStream = await createWriteStream(outputPath)
+    const archive = await createArchiver('zip', {
+      zlib: { level: 9 } // Sets the compression level
+    })
+
+    return new Promise((resolve, reject) => {
+      archive.on('error', function (err: Error) {
+        reject(err)
+      })
+
+      outStream.on('end', function () {
+        console.log('Data has been drained')
+      })
+
+      outStream.on('close', function () {
+        setTimeout(() => {
+          resolve({
+            output,
+            outputPath,
+            size: archive.pointer()
+          })
+        }, 100)
+      })
+
+      archive.on('warning', function (err: archiver.ArchiverError) {
+        if (err.code === 'ENOENT') {
+          console.warn('ENOENT', err)
+        } else {
+          reject(err)
+        }
+      })
+
+      archive.pipe(outStream)
+
+      // Add the main bundle file
+      archive.file(inputPath, { name: 'index.js' })
+
+      // Add source map if it exists
+      if (mapExists) {
+        archive.file(inputMapPath, { name: 'index.js.map' })
+      }
+
+      archive.finalize()
+    })
+  }
+)
+
+zip.setDescription(description)

package/src/tasks/fixture/download.ts

@@ -14,6 +14,7 @@ import { Profile } from '../types'
 // Define the Fixture data structure
 interface FixtureData {
   name: string;
+  boundaries: Record<string, unknown>;
   [key: string]: unknown;
 }
 
@@ -58,14 +59,6 @@ const boundaries = {
     return {
       path: filePath
     }
-  },
-  checkFileExists: async (filePath: string): Promise<boolean> => {
-    try {
-      await fs.access(filePath)
-      return true
-    } catch {
-      return false
-    }
   }
 }
 
@@ -76,12 +69,12 @@ export const download = createTask(
     downloadFixture,
     getCwd,
     persistFixture,
-    checkFileExists,
     loadCurrentProfile,
     loadConf
   }) {
     console.log('==================================================')
     console.log(`Attempting to download fixture with uuid: ${uuid}`)
+    console.log('==================================================')
 
     const profile = await loadCurrentProfile({})
     const cwd = await getCwd()
@@ -102,8 +95,8 @@ export const download = createTask(
       throw new Error('Failed to download fixture')
     }
 
-    // Extract task descriptor from the response
-    const taskName = response.fixture.name
+    const fixture = response.fixture as FixtureData
+    const taskName = fixture.taskName as string
 
     // Determine the output path using forge fixtures path and task descriptor
     const fixturesBasePath = forge.paths.fixtures || 'fixtures'
@@ -111,31 +104,31 @@ export const download = createTask(
     const fixturePath = path.join(fixtureDir, `${uuid}.json`)
     const filePath = path.resolve(cwd, fixturePath)
 
-    console.log(`Fixture will be saved to: ${filePath}`)
+    // Persist fixture to file
+    await persistFixture(filePath, response.fixture)
 
-    // Check if file already exists
-    const fileExists = await checkFileExists(filePath)
-    if (fileExists) {
-      console.log(`Fixture will be updated at ${filePath}`)
-    }
+    // Get the relative path for display in the replay command
+    const shortPath = path.join(taskName, `${uuid}.json`)
 
     console.log(`
-    ==================================================
-    Starting fixture download!
-    Fixture UUID: ${uuid}
-    Task Name: ${taskName}
-    Saving to: ${filePath}
-    ==================================================
-    Replay with: forge task:replay --path ${filePath}
-    ==================================================
+==================================================
+Fixture download completed!
+==================================================
+Fixture UUID: ${uuid}
+Task Name: ${taskName}
+Saved to: ${filePath}
+==================================================
+Boundaries: ${Object.keys(fixture.boundaries).join(', ')}
+==================================================
+Replay with:
+forge task:replay ${taskName} --path ${shortPath}
+==================================================
     `)
 
-    // Persist fixture to file
-    await persistFixture(filePath, response.fixture)
-
     return {
       status: 'Downloaded',
-      path: filePath
+      path: filePath,
+      shortPath: shortPath
     }
   }
 )

package/src/tasks/task/publish.ts

@@ -13,6 +13,7 @@ import os from 'os'
 import { load as loadConf } from '../conf/load'
 import { create as bundleCreate } from '../bundle/create'
 import { load as bundleLoad } from '../bundle/load'
+import { zip as bundleZip } from '../bundle/zip'
 import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
 import { Profile } from '../types'
 
@@ -28,6 +29,7 @@ const boundaries = {
   loadCurrentProfile: loadCurrentProfile.asBoundary(),
   bundleCreate: bundleCreate.asBoundary(),
   bundleLoad: bundleLoad.asBoundary(),
+  bundleZip: bundleZip.asBoundary(),
   readFileUtf8: async (filePath: string): Promise<string> => {
     return fs.readFile(filePath, 'utf-8')
   },
@@ -88,6 +90,7 @@ export const publish = createTask(
     loadConf,
     bundleCreate,
     bundleLoad,
+    bundleZip,
     readFileUtf8,
     readFileBinary,
     publishTask,
@@ -108,6 +111,7 @@ export const publish = createTask(
     const entryPoint = path.join(cwd, taskDescriptor.path)
     const buildsPath = await ensureBuildsFolder()
     const outputFile = path.join(buildsPath, `${descriptorName}.js`)
+    const zipFile = `${descriptorName}.zip`
 
     // Bundle the task
     await bundleCreate({
@@ -117,6 +121,15 @@ export const publish = createTask(
 
     console.log('Bundle created...')
 
+    // Zip the bundle
+    await bundleZip({
+      dir: buildsPath,
+      input: `${descriptorName}.js`,
+      output: zipFile
+    })
+
+    console.log('Bundle zipped...')
+
     // Load the bundled task
     const bundle = await bundleLoad({
       bundlePath: outputFile
@@ -131,7 +144,9 @@ export const publish = createTask(
 
     // Read the task file content
     const sourceCode = await readFileUtf8(entryPoint)
-    const bundleContent = await readFileBinary(outputFile)
+    // Read the zipped bundle instead of the raw bundle
+    const zipPath = path.join(buildsPath, zipFile)
+    const bundleContent = await readFileBinary(zipPath)
 
     // Get bundle size
     const bundleSize = bundleContent.length
@@ -140,6 +155,7 @@ export const publish = createTask(
     const data = {
       ...taskDescriptor,
       taskName: descriptorName,
+      handler: taskDescriptor.handler,
       projectName,
       description,
       schemaDescriptor: JSON.stringify(schemaDescriptor),
@@ -152,9 +168,9 @@ export const publish = createTask(
     console.log(`Publishing metadata and source code to ${profile.url}...`)
     const publishResponse = await publishTask(data, profile)
 
-    // Upload bundle using the presigned URL
+    // Upload zipped bundle using the presigned URL
     if (publishResponse.bundleUploadUrl) {
-      console.log('Uploading bundle...')
+      console.log('Uploading zipped bundle...')
       await uploadBundleWithPresignedUrl(
         publishResponse.bundleUploadUrl,
         bundleContent

package/src/tasks/task/replay.ts

@@ -18,7 +18,8 @@ import { type ForgeConf, type Profile } from '../types'
 // Define the fixture structure type
 interface Fixture {
   fixtureUUID: string;
-  name: string;
+  taskName: string;
+  projectName: string;
   type: 'success' | 'error';
   input: Record<string, unknown>;
   output: Record<string, unknown>;
@@ -29,6 +30,7 @@ interface Fixture {
 const description = 'Replay a task execution from a specified path'
 
 const schema = new Schema({
+  descriptorName: Schema.string(),
   path: Schema.string(),
   cache: Schema.string().optional()
 })
@@ -97,22 +99,28 @@ const boundaries = {
 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)
+  async function ({ descriptorName, path: fixturePath, cache }, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
+    console.log('Input descriptorName:', descriptorName)
+    console.log('Input path:', fixturePath)
+    console.log('Input cache:', cache)
 
     // Load forge configuration
     const forge: ForgeConf = await loadConf({})
-    const taskName = fixture.name
-    const taskDescriptor = forge.tasks[taskName as keyof typeof forge.tasks]
+    const taskDescriptor = forge.tasks[descriptorName as keyof typeof forge.tasks]
     const projectName = forge.project.name
 
     if (taskDescriptor === undefined) {
-      throw new Error(`Task ${taskName} is not defined in forge.json`)
+      throw new Error(`Task ${descriptorName} is not defined in forge.json`)
     }
 
+    // Resolve the fixture path (check if absolute, if not make it relative to logs folder)
+    const resolvedFixturePath = path.isAbsolute(fixturePath)
+      ? fixturePath
+      : path.join(process.cwd(), forge.paths.fixtures, fixturePath)
+
+    // Read the file from the provided path
+    const fixture = await readFixture(resolvedFixturePath)
+
     // Try to load profile, but continue if not found
     let profile = null
     try {
@@ -132,7 +140,7 @@ export const replay = createTask(
     // Prepare paths
     const entryPoint = path.join(process.cwd(), taskDescriptor.path)
     const buildsPath = await ensureBuildsFolder()
-    const outputFile = path.join(buildsPath, `${taskName}.js`)
+    const outputFile = path.join(buildsPath, `${descriptorName}.js`)
 
     // Bundle the task
     await bundleCreate({
@@ -155,14 +163,14 @@ export const replay = createTask(
     // Configure boundaries based on cache parameter if provided
     const boundaryConfig: Record<string, string> = {}
 
-    if (argv.cache) {
+    if (cache) {
       // Parse the comma-separated list and trim each item
-      const cacheBoundaries = argv.cache.split(',').map(b => b.trim())
+      const cacheBoundaries = cache.split(',').map((b: string) => b.trim())
 
       // Log which boundaries will use cache mode
       if (cacheBoundaries.length > 0) {
         // Set each specified boundary to 'replay' mode
-        cacheBoundaries.forEach(boundary => {
+        cacheBoundaries.forEach((boundary: string) => {
           boundaryConfig[boundary] = 'replay'
         })
       }
@@ -170,7 +178,8 @@ export const replay = createTask(
 
     console.log('==================================================')
     console.log('UUID:', fixture.fixtureUUID)
-    console.log('Name:', fixture.name)
+    console.log('Task name:', fixture.taskName)
+    console.log('Project name:', fixture.projectName)
     console.log('Context:', fixture.context)
     console.log('==================================================')
     console.log('Replay:', fixture.input)
@@ -194,7 +203,7 @@ export const replay = createTask(
     // Send the log to API if profile is available
     if (profile) {
       try {
-        await sendLogToAPI(profile, projectName, taskName, record, fixture.fixtureUUID)
+        await sendLogToAPI(profile, projectName, descriptorName, record, fixture.fixtureUUID)
       } catch (e) {
         console.error('Failed to send log to API:', e)
       }