@forgehive/forge-cli 0.1.7 → 0.2.0

package/dist/runner.js

@@ -6,6 +6,15 @@ const info_1 = require("./tasks/conf/info");
 const createTask_1 = require("./tasks/task/createTask");
 const run_1 = require("./tasks/task/run");
 const remove_1 = require("./tasks/task/remove");
+const create_1 = require("./tasks/runner/create");
+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 add_1 = require("./tasks/auth/add");
+const switch_1 = require("./tasks/auth/switch");
+const list_1 = require("./tasks/auth/list");
+const remove_3 = require("./tasks/auth/remove");
 const runner = new runner_1.Runner((data) => {
     const { _, ...filteredObj } = data;
     return {
@@ -21,6 +30,17 @@ runner.load('info', info_1.info);
 runner.load('task:create', createTask_1.createTaskCommand);
 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 commands
+runner.load('runner:create', create_1.create);
+runner.load('runner:remove', remove_2.remove);
+runner.load('runner:bundle', bundle_1.bundle);
+// Auth commands
+runner.load('auth:add', add_1.add);
+runner.load('auth:switch', switch_1.switchProfile);
+runner.load('auth:list', list_1.list);
+runner.load('auth:remove', remove_3.remove);
 // Set handler
 runner.setHandler(async (data) => {
     const parsedArgs = runner.parseArguments(data);
@@ -34,16 +54,51 @@ runner.setHandler(async (data) => {
     }
     try {
         let result;
-        const taskWithDescriptor = ['task:create', 'task:remove'];
-        if (taskWithDescriptor.includes(taskName)) {
+        const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish'];
+        const commandsWithRunner = ['runner:create', 'runner:remove'];
+        if (commandsWithDescriptor.includes(taskName)) {
+            console.log('Running:', taskName, action);
             result = await task.run({ descriptorName: action });
         }
+        else if (commandsWithRunner.includes(taskName)) {
+            result = await task.run({
+                runnerName: action
+            });
+        }
+        else if (taskName === 'runner:bundle') {
+            const paths = args;
+            result = await task.run({
+                runnerName: action,
+                targetPath: paths.targetPath
+            });
+        }
+        else if (taskName === 'task:download') {
+            const { uuid } = args;
+            result = await task.run({
+                descriptorName: action,
+                uuid
+            });
+        }
         else if (taskName === 'task:run') {
             result = await task.run({
                 descriptorName: action,
                 args
             });
         }
+        else if (taskName === 'auth:add') {
+            const { apiKey, apiSecret, url } = args;
+            result = await task.run({
+                name: action,
+                apiKey,
+                apiSecret,
+                url
+            });
+        }
+        else if (taskName === 'auth:switch' || taskName === 'auth:remove') {
+            result = await task.run({
+                profileName: action
+            });
+        }
         else {
             result = await task.run(args);
         }

package/dist/tasks/auth/add.d.ts

@@ -0,0 +1,16 @@
+import { type Profiles } from '../types';
+export declare const add: import("@forgehive/task").TaskInstanceType<(argv: {
+    name: string;
+    apiKey: string;
+    apiSecret: string;
+    url: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    persistProfiles: (profiles: Profiles) => Promise<void>;
+}>) => Promise<{
+    status: string;
+    message: string;
+}>, {
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    persistProfiles: (profiles: Profiles) => Promise<void>;
+}>;

package/dist/tasks/auth/add.js

@@ -0,0 +1,50 @@
+"use strict";
+// TASK: add
+// Run this task with:
+// forge task:run auth:add
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const load_1 = require("./load");
+const schema = new schema_1.Schema({
+    name: schema_1.Schema.string(),
+    apiKey: schema_1.Schema.string(),
+    apiSecret: schema_1.Schema.string(),
+    url: schema_1.Schema.string()
+});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary(),
+    persistProfiles: async (profiles) => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
+        const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+        await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
+    }
+};
+exports.add = (0, task_1.createTask)(schema, boundaries, async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
+    const profiles = await loadProfiles({});
+    // Check if profile with same name already exists
+    const existingProfileIndex = profiles.profiles.findIndex(p => p.name === name);
+    if (existingProfileIndex >= 0) {
+        // Replace existing profile
+        profiles.profiles[existingProfileIndex] = { name, apiKey, apiSecret, url };
+    }
+    else {
+        // Add new profile
+        profiles.profiles.push({ name, apiKey, apiSecret, url });
+    }
+    // Set as default profile
+    profiles.default = name;
+    // Persist profiles
+    await persistProfiles(profiles);
+    return {
+        status: 'Ok',
+        message: `Profile '${name}' added and set as default`
+    };
+});

package/dist/tasks/auth/list.d.ts

@@ -0,0 +1,14 @@
+import { type Profiles } from '../types';
+export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+}>) => Promise<{
+    status: string;
+    profiles: never[];
+    default?: undefined;
+} | {
+    default: string;
+    status?: undefined;
+    profiles?: undefined;
+}>, {
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+}>;

package/dist/tasks/auth/list.js

@@ -0,0 +1,31 @@
+"use strict";
+// TASK: list
+// Run this task with:
+// forge task:run auth:list
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const load_1 = require("./load");
+const schema = new schema_1.Schema({});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary()
+};
+exports.list = (0, task_1.createTask)(schema, boundaries, async function (_argv, { loadProfiles }) {
+    const profiles = await loadProfiles({});
+    if (profiles.profiles.length === 0) {
+        console.log('No profiles found. Use auth:add to create one.');
+        return { status: 'Ok', profiles: [] };
+    }
+    console.log('Available profiles:');
+    profiles.profiles.forEach(profile => {
+        const isDefault = profile.name === profiles.default;
+        const prefix = isDefault ? '* ' : '  ';
+        console.log(`${prefix}${profile.name} - API Key: ${profile.apiKey}`);
+    });
+    console.log('\nUse auth:add to create or update a profile');
+    console.log('\nUse auth:switch to switch to a profile');
+    return {
+        default: profiles.default
+    };
+});

package/dist/tasks/auth/load.d.ts

@@ -0,0 +1,6 @@
+import { type Profiles } from '../types';
+export declare const load: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    ensureBuildsFolder: () => Promise<string>;
+}>) => Promise<Profiles>, {
+    ensureBuildsFolder: () => Promise<string>;
+}>;

package/dist/tasks/auth/load.js

@@ -0,0 +1,44 @@
+"use strict";
+// TASK: load
+// Run this task with:
+// forge task:run auth:load
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const schema = new schema_1.Schema({});
+const boundaries = {
+    ensureBuildsFolder: async () => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
+        try {
+            await promises_1.default.access(buildsPath);
+        }
+        catch {
+            await promises_1.default.mkdir(buildsPath, { recursive: true });
+        }
+        return buildsPath;
+    }
+};
+exports.load = (0, task_1.createTask)(schema, boundaries, async function (argv, { ensureBuildsFolder }) {
+    const buildsPath = await ensureBuildsFolder();
+    let profiles = {
+        default: '',
+        profiles: []
+    };
+    const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+    try {
+        const content = await promises_1.default.readFile(profilesPath, 'utf-8');
+        profiles = JSON.parse(content);
+    }
+    catch (_error) {
+        console.log('Creating profiles.json');
+        await promises_1.default.writeFile(profilesPath, '{"profiles": [], "default": ""}');
+    }
+    return profiles;
+});

package/dist/tasks/auth/loadCurrent.d.ts

@@ -0,0 +1,6 @@
+import { type Profile } from '../types';
+export declare const loadCurrent: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<import("../types").Profiles>>;
+}>) => Promise<Profile>, {
+    loadProfiles: (args: {}) => Promise<Promise<import("../types").Profiles>>;
+}>;

package/dist/tasks/auth/loadCurrent.js

@@ -0,0 +1,24 @@
+"use strict";
+// TASK: loadCurrent
+// Run this task with:
+// forge task:run auth:loadCurrent
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCurrent = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const load_1 = require("./load");
+const schema = new schema_1.Schema({});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary()
+};
+exports.loadCurrent = (0, task_1.createTask)(schema, boundaries, async function (_argv, { loadProfiles }) {
+    const profiles = await loadProfiles({});
+    if (!profiles.default || profiles.default === '') {
+        throw new Error('No default profile set. Please run forge task:run auth:add to create a profile.');
+    }
+    const defaultProfile = profiles.profiles.find(profile => profile.name === profiles.default);
+    if (!defaultProfile) {
+        throw new Error(`Default profile "${profiles.default}" not found in profiles.`);
+    }
+    return { ...defaultProfile, name: profiles.default };
+});

package/dist/tasks/auth/remove.d.ts

@@ -0,0 +1,13 @@
+import { type Profiles } from '../types';
+export declare const remove: import("@forgehive/task").TaskInstanceType<(argv: {
+    profileName: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    persistProfiles: (profiles: Profiles) => Promise<void>;
+}>) => Promise<{
+    status: string;
+    message: string;
+}>, {
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    persistProfiles: (profiles: Profiles) => Promise<void>;
+}>;

package/dist/tasks/auth/remove.js

@@ -0,0 +1,56 @@
+"use strict";
+// TASK: remove
+// Run this task with:
+// forge task:run auth:remove --profileName [name]
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const load_1 = require("./load");
+const schema = new schema_1.Schema({
+    profileName: schema_1.Schema.string()
+});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary(),
+    persistProfiles: async (profiles) => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
+        const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+        await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
+    }
+};
+exports.remove = (0, task_1.createTask)(schema, boundaries, async function ({ profileName }, { loadProfiles, persistProfiles }) {
+    const profiles = await loadProfiles({});
+    // Check if profile exists
+    const profileExists = profiles.profiles.some(profile => profile.name === profileName);
+    if (!profileExists) {
+        throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`);
+    }
+    // Remove the profile using filter
+    profiles.profiles = profiles.profiles.filter(profile => profile.name !== profileName);
+    // If the removed profile was the default, update the default
+    if (profiles.default === profileName) {
+        if (profiles.profiles.length > 0) {
+            // Set the first available profile as default
+            profiles.default = profiles.profiles[0].name;
+            console.log(`Default profile set to: ${profiles.default}`);
+        }
+        else {
+            // No profiles left, set default to empty
+            profiles.default = '';
+            console.log('No profiles left. Default set to empty.');
+        }
+    }
+    // Persist updated profiles
+    await persistProfiles(profiles);
+    console.log(`Profile "${profileName}" has been removed.`);
+    return {
+        status: 'Ok',
+        message: `Profile "${profileName}" has been removed.`
+    };
+});

package/dist/tasks/auth/switch.d.ts

@@ -0,0 +1,12 @@
+import { type Profiles } from '../types';
+export declare const switchProfile: import("@forgehive/task").TaskInstanceType<(argv: {
+    profileName: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    persistProfiles: (profiles: Profiles) => Promise<void>;
+}>) => Promise<{
+    default: string;
+}>, {
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    persistProfiles: (profiles: Profiles) => Promise<void>;
+}>;

package/dist/tasks/auth/switch.js

@@ -0,0 +1,43 @@
+"use strict";
+// TASK: switch
+// Run this task with:
+// forge task:run auth:switch --profileName [name]
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchProfile = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const load_1 = require("./load");
+const schema = new schema_1.Schema({
+    profileName: schema_1.Schema.string()
+});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary(),
+    persistProfiles: async (profiles) => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
+        const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+        await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
+    }
+};
+exports.switchProfile = (0, task_1.createTask)(schema, boundaries, async function ({ profileName }, { loadProfiles, persistProfiles }) {
+    // Load profiles
+    const profiles = await loadProfiles({});
+    // Check if profile exists
+    const profileExists = profiles.profiles.some(profile => profile.name === profileName);
+    if (!profileExists) {
+        throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`);
+    }
+    // Update default profile
+    profiles.default = profileName;
+    // Save updated profiles
+    await persistProfiles(profiles);
+    console.log(`Switched to profile: ${profileName}`);
+    return {
+        default: profileName
+    };
+});

package/dist/tasks/conf/info.d.ts

@@ -1,7 +1,14 @@
 export declare const info: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
     readFile: (filePath: string) => Promise<string>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
 }>) => Promise<{
     version: any;
+    profile: {
+        name: string;
+        url: string;
+        apiKey: string;
+    };
 }>, {
     readFile: (filePath: string) => Promise<string>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
 }>;

package/dist/tasks/conf/info.js

@@ -41,18 +41,23 @@ const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const schema = new schema_1.Schema({
-// No parameters needed for this task
-});
+const loadCurrent_1 = require("../auth/loadCurrent");
+const schema = new schema_1.Schema({});
 const boundaries = {
-    readFile: async (filePath) => fs.promises.readFile(filePath, 'utf-8')
+    readFile: async (filePath) => fs.promises.readFile(filePath, 'utf-8'),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary()
 };
-exports.info = (0, task_1.createTask)(schema, boundaries, async function (_argv, boundaries) {
+exports.info = (0, task_1.createTask)(schema, boundaries, async function (_argv, { loadCurrentProfile, readFile }) {
     const packageJsonPath = path.join(__dirname, '../../../package.json');
-    console.log('packageJsonPath', packageJsonPath);
-    const packageJsonContent = await boundaries.readFile(packageJsonPath);
+    const packageJsonContent = await readFile(packageJsonPath);
     const packageJson = JSON.parse(packageJsonContent);
+    const profile = await loadCurrentProfile({});
     return {
-        version: packageJson.version
+        version: packageJson.version,
+        profile: {
+            name: profile.name,
+            url: profile.url,
+            apiKey: profile.apiKey
+        }
     };
 });

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

@@ -0,0 +1,18 @@
+import { type ForgeConf } from '../types';
+export declare const bundle: import("@forgehive/task").TaskInstanceType<(argv: {
+    runnerName: string;
+    targetPath: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    getCwd: () => Promise<string>;
+    ensureDir: (dirPath: string) => Promise<void>;
+}>) => Promise<{
+    status: string;
+    runnerName: string;
+    entryPoint: string;
+    outputFile: string;
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    getCwd: () => Promise<string>;
+    ensureDir: (dirPath: string) => Promise<void>;
+}>;

package/dist/tasks/runner/bundle.js

@@ -0,0 +1,71 @@
+"use strict";
+// TASK: bundle
+// Run this task with:
+// forge task:run runner:bundle --runnerName=<runner-name> --targetPath=<target-path>
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundle = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const esbuild_1 = __importDefault(require("esbuild"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const load_1 = require("../conf/load");
+const schema = new schema_1.Schema({
+    runnerName: schema_1.Schema.string(),
+    targetPath: schema_1.Schema.string()
+});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    getCwd: async () => {
+        return process.cwd();
+    },
+    ensureDir: async (dirPath) => {
+        try {
+            await promises_1.default.access(dirPath);
+        }
+        catch (error) {
+            throw new Error(`Directory ${dirPath} does not exist`);
+        }
+    }
+};
+exports.bundle = (0, task_1.createTask)(schema, boundaries, async function ({ runnerName, targetPath }, { loadConf, getCwd, ensureDir }) {
+    // Load forge configuration
+    const forge = await loadConf({});
+    const cwd = await getCwd();
+    // Verify runner exists in forge.json
+    if (!forge.runners || !forge.runners[runnerName]) {
+        throw new Error(`Runner '${runnerName}' not found in forge.json configuration`);
+    }
+    // Get runner entry point from forge.json
+    const runnerConfig = forge.runners[runnerName];
+    const entryPoint = path_1.default.join(cwd, runnerConfig.path);
+    const outputFile = path_1.default.join(targetPath, `${runnerName}.js`);
+    console.log(`
+      ==================================================
+      Starting runner creation!
+      Creating runner: ${runnerName}
+      Entrypoint: ${entryPoint}
+      Output file: ${outputFile}
+      ==================================================
+    `);
+    // Ensure target directory exists
+    await ensureDir(path_1.default.dirname(targetPath));
+    // Build using esbuild
+    await esbuild_1.default.build({
+        entryPoints: [entryPoint],
+        outfile: outputFile,
+        bundle: true,
+        minify: true,
+        platform: 'node',
+        sourcemap: true
+    });
+    return {
+        status: 'Success',
+        runnerName,
+        entryPoint,
+        outputFile: path_1.default.join(targetPath, `${runnerName}.js`)
+    };
+});

package/dist/tasks/runner/create.d.ts

@@ -0,0 +1,21 @@
+import { type ForgeConf } from '../types';
+export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
+    runnerName: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    getCwd: () => Promise<string>;
+    persistRunner: (runnerPath: string, runnerName: string, content: string) => Promise<{
+        path: string;
+    }>;
+    persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+}>) => Promise<{
+    runnerPath: string;
+    runnerName: string;
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    getCwd: () => Promise<string>;
+    persistRunner: (runnerPath: string, runnerName: string, content: string) => Promise<{
+        path: string;
+    }>;
+    persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+}>;