@forgehive/forge-cli 0.2.11 → 0.2.12

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/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/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.11",
+  "version": "0.2.12",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -13,24 +13,26 @@
       "@forgehive/record-tape": "^0.1.4",
       "@forgehive/runner": "^0.1.10",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.1.11",
+      "@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.10",
-    "@forgehive/record-tape": "0.1.4",
-    "@forgehive/schema": "0.1.4",
-    "@forgehive/task": "0.1.11"
+    "@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/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/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