@forgehive/forge-cli 0.1.7 → 0.2.0

package/dist/tasks/runner/create.js

@@ -0,0 +1,97 @@
+"use strict";
+// TASK: create
+// Run this task with:
+// forge task:run runner:create --runnerName <runner-name>
+// forge task:run runner:create --runnerName inventory
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const handlebars_1 = __importDefault(require("handlebars"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const camelCase_1 = require("../../utils/camelCase");
+const load_1 = require("../conf/load");
+// Define the template content directly in the code
+const RUNNER_TEMPLATE = `// RUNNER: {{ runnerName }}
+import { Runner } from '@forgehive/runner'
+
+// Import your tasks here
+// import { EXAMPLE_TASK } from '../../tasks/MODULE/TASK'
+
+const {{ runnerName }}Runner = new Runner()
+
+// Load your tasks here
+// runner.load('MODULE:TASK', EXAMPLE_TASK)
+
+export { {{ runnerName }}Runner }
+`;
+const schema = new schema_1.Schema({
+    runnerName: schema_1.Schema.string()
+});
+const boundaries = {
+    // Load boundaries
+    loadConf: load_1.load.asBoundary(),
+    getCwd: async () => {
+        return process.cwd();
+    },
+    // Persist boundaries
+    persistRunner: async (runnerPath, runnerName, content) => {
+        const folderPath = path_1.default.join(runnerPath, runnerName);
+        const filePath = path_1.default.join(folderPath, 'index.ts');
+        let err;
+        try {
+            await promises_1.default.stat(folderPath);
+        }
+        catch (e) {
+            err = e;
+        }
+        if (err === undefined) {
+            throw new Error(`Runner folder '${folderPath}' already exists.`);
+        }
+        await promises_1.default.mkdir(folderPath, { recursive: true });
+        await promises_1.default.writeFile(filePath, content, 'utf-8');
+        return {
+            path: filePath.toString()
+        };
+    },
+    persistConf: async (forge, cwd) => {
+        const forgePath = path_1.default.join(cwd, 'forge.json');
+        await promises_1.default.writeFile(forgePath, JSON.stringify(forge, null, 2));
+    }
+};
+exports.create = (0, task_1.createTask)(schema, boundaries, async function ({ runnerName }, { persistRunner, loadConf, persistConf, getCwd }) {
+    const formattedName = (0, camelCase_1.camelCase)(runnerName);
+    const cwd = await getCwd();
+    const forge = await loadConf({});
+    const runnerPath = forge.paths.runners;
+    console.log(`
+    ==================================================
+    Starting runner creation!
+    Creating runner: ${formattedName}
+    Into: ${runnerPath}${formattedName}/index.ts
+    ==================================================
+    `);
+    const comp = handlebars_1.default.compile(RUNNER_TEMPLATE);
+    const content = comp({
+        runnerName: formattedName
+    });
+    await persistRunner(runnerPath, formattedName, content);
+    if (forge.runners === undefined) {
+        forge.runners = {};
+    }
+    // Create runner descriptor
+    const runnerDescriptor = {
+        path: `${runnerPath}${formattedName}/index.ts`,
+        version: '0.0.1'
+    };
+    forge.runners[formattedName] = runnerDescriptor;
+    await persistConf(forge, cwd);
+    return {
+        runnerPath: `${runnerPath}/${formattedName}`,
+        runnerName: formattedName
+    };
+});

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

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

package/dist/tasks/runner/remove.js

@@ -0,0 +1,58 @@
+"use strict";
+// TASK: remove
+// Run this task with:
+// forge task:run runner:remove --runnerName <runner-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 camelCase_1 = require("../../utils/camelCase");
+const load_1 = require("../conf/load");
+const schema = new schema_1.Schema({
+    runnerName: schema_1.Schema.string()
+});
+const boundaries = {
+    // Load boundaries
+    loadConf: load_1.load.asBoundary(),
+    getCwd: async () => {
+        return process.cwd();
+    },
+    // File system operations
+    removeRunner: async (runnerPath) => {
+        await promises_1.default.rm(runnerPath, { recursive: true, force: true });
+    },
+    // Configuration operations
+    persistConf: async (forge, cwd) => {
+        const forgePath = path_1.default.join(cwd, 'forge.json');
+        await promises_1.default.writeFile(forgePath, JSON.stringify(forge, null, 2));
+    }
+};
+exports.remove = (0, task_1.createTask)(schema, boundaries, async function ({ runnerName }, { loadConf, getCwd, removeRunner, persistConf }) {
+    const formattedName = (0, camelCase_1.camelCase)(runnerName);
+    const cwd = await getCwd();
+    const forge = await loadConf({});
+    if (!forge.runners || !forge.runners[formattedName]) {
+        throw new Error(`Runner '${formattedName}' not found in forge.json configuration`);
+    }
+    const runnerConfig = forge.runners[formattedName];
+    const runnerFolder = path_1.default.join(cwd, path_1.default.dirname(runnerConfig.path));
+    console.log(`
+    ==================================================
+    Removing runner: ${formattedName}
+    Path: ${runnerFolder}
+    ==================================================
+    `);
+    await removeRunner(runnerFolder);
+    delete forge.runners[formattedName];
+    await persistConf(forge, cwd);
+    return {
+        status: 'success',
+        message: `Runner '${formattedName}' successfully removed`,
+        runnerName: formattedName
+    };
+});

package/dist/tasks/task/createTask.js

@@ -20,6 +20,8 @@ const TASK_TEMPLATE = `// TASK: {{ taskName }}
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 
+const description = 'Add task description here'
+
 const schema = new Schema({
   // Add your schema definitions here
   // example: myParam: Schema.string()
@@ -42,6 +44,8 @@ export const {{ taskName }} = createTask(
     return status
   }
 )
+
+{{ taskName }}.setDescription(description)
 `;
 const schema = new schema_1.Schema({
     descriptorName: schema_1.Schema.string()

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

@@ -0,0 +1,58 @@
+import { Profile, type ForgeConf } from '../types';
+export declare const download: import("@forgehive/task").TaskInstanceType<(argv: {
+    descriptorName: string;
+    uuid: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    downloadTask: (uuid: string, profile: Profile) => Promise<any>;
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    getCwd: () => Promise<string>;
+    parseTaskName: (taskDescriptor: string) => Promise<{
+        descriptor: string;
+        taskName: string;
+        fileName: string;
+        dir?: string;
+    }>;
+    persistTask: (dir: string, fileName: string, content: string, cwd: string) => Promise<{
+        path: string;
+    }>;
+    persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+    checkTaskExists: (dir: string, fileName: string) => Promise<boolean>;
+}>) => Promise<{
+    error: string;
+    taskPath: string;
+    descriptor: string;
+    message?: undefined;
+    fileName?: undefined;
+    handler?: undefined;
+} | {
+    error: string;
+    message: string;
+    taskPath: string;
+    descriptor: string;
+    fileName?: undefined;
+    handler?: undefined;
+} | {
+    taskPath: string;
+    fileName: string;
+    descriptor: string;
+    handler: any;
+    error?: undefined;
+    message?: undefined;
+}>, {
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    downloadTask: (uuid: string, profile: Profile) => Promise<any>;
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    getCwd: () => Promise<string>;
+    parseTaskName: (taskDescriptor: string) => Promise<{
+        descriptor: string;
+        taskName: string;
+        fileName: string;
+        dir?: string;
+    }>;
+    persistTask: (dir: string, fileName: string, content: string, cwd: string) => Promise<{
+        path: string;
+    }>;
+    persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
+    checkTaskExists: (dir: string, fileName: string) => Promise<boolean>;
+}>;

package/dist/tasks/task/download.js

@@ -0,0 +1,153 @@
+"use strict";
+// TASK: download
+// Run this task with:
+// forge task:run task:download --descriptorName [name] --uuid [task-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 camelCase_1 = require("../../utils/camelCase");
+const load_1 = require("../conf/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
+const schema = new schema_1.Schema({
+    descriptorName: schema_1.Schema.string(),
+    uuid: schema_1.Schema.string()
+});
+const boundaries = {
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    downloadTask: async (uuid, profile) => {
+        const downloadUrl = `${profile.url}/api/tasks/download`;
+        console.log(`Downloading task from ${downloadUrl}...`);
+        const authToken = `${profile.apiKey}:${profile.apiSecret}`;
+        const response = await axios_1.default.post(downloadUrl, { uuid }, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data;
+    },
+    loadConf: load_1.load.asBoundary(),
+    getCwd: async () => {
+        return process.cwd();
+    },
+    parseTaskName: async (taskDescriptor) => {
+        const res = taskDescriptor.split(':');
+        if (res.length === 1) {
+            return {
+                descriptor: `${(0, camelCase_1.camelCase)(res[0])}`,
+                taskName: `${(0, camelCase_1.camelCase)(res[0])}`,
+                fileName: `${(0, camelCase_1.camelCase)(res[0])}.ts`
+            };
+        }
+        return {
+            dir: res[0],
+            descriptor: `${res[0]}:${(0, camelCase_1.camelCase)(res[1])}`,
+            taskName: `${(0, camelCase_1.camelCase)(res[1])}`,
+            fileName: `${(0, camelCase_1.camelCase)(res[1])}.ts`
+        };
+    },
+    persistTask: async (dir, fileName, content, cwd) => {
+        const dirPath = path_1.default.resolve(cwd, dir);
+        const taskPath = path_1.default.resolve(dirPath, fileName);
+        await promises_1.default.mkdir(dirPath, { recursive: true });
+        await promises_1.default.writeFile(taskPath, content, 'utf-8');
+        return {
+            path: taskPath.toString()
+        };
+    },
+    persistConf: async (forge, cwd) => {
+        const forgePath = path_1.default.join(cwd, 'forge.json');
+        await promises_1.default.writeFile(forgePath, JSON.stringify(forge, null, 2));
+    },
+    checkTaskExists: async (dir, fileName) => {
+        const taskPath = path_1.default.resolve(dir, fileName);
+        try {
+            await promises_1.default.access(taskPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+};
+exports.download = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, uuid }, { downloadTask, getCwd, parseTaskName, persistTask, loadConf, persistConf, checkTaskExists, loadCurrentProfile }) {
+    console.log(`Attempting to download task with descriptor: ${descriptorName} and uuid: ${uuid}`);
+    // Parse descriptor name to get task details
+    const { taskName, fileName, descriptor, dir } = await parseTaskName(descriptorName);
+    const profile = await loadCurrentProfile({});
+    const cwd = await getCwd();
+    const forge = await loadConf({});
+    let taskPath = forge.paths.tasks;
+    if (dir !== undefined) {
+        taskPath = path_1.default.join(taskPath, dir);
+    }
+    // Check if task already exists
+    const taskExists = await checkTaskExists(taskPath, fileName);
+    if (taskExists) {
+        console.log(`Task ${descriptor} already exists at ${taskPath}/${fileName}`);
+        return {
+            error: 'Task already exists',
+            taskPath: `${taskPath}/${fileName}`,
+            descriptor
+        };
+    }
+    // Download from hive api server
+    let response;
+    try {
+        response = await downloadTask(uuid, profile);
+    }
+    catch (e) {
+        const error = e;
+        console.error('Error downloading task:', error.message, error.status);
+        if (error.status === 404) {
+            return {
+                error: 'Task not found',
+                taskPath: `${taskPath}/${fileName}`,
+                descriptor
+            };
+        }
+        return {
+            error: 'Failed to download task',
+            message: error.message,
+            taskPath: `${taskPath}/${fileName}`,
+            descriptor
+        };
+    }
+    console.log(`
+    ==================================================
+    Starting task download!
+    Creating: ${taskName}
+    Dir:  ${dir ?? ''}
+    Into: ${taskPath}
+    ==================================================
+    `);
+    console.log('Writing task file:', taskPath, fileName);
+    console.log('Handler:', response.handler);
+    console.log('Source code:', response.sourceCode);
+    // Persist task with cwd
+    await persistTask(taskPath, fileName, response.sourceCode, cwd);
+    // Update forge.json with the new task
+    if (forge.tasks === undefined) {
+        forge.tasks = {};
+    }
+    forge.tasks[descriptor] = {
+        path: `${taskPath}/${fileName}`,
+        handler: response.handler
+    };
+    console.log('Forge:', forge);
+    await persistConf(forge, cwd);
+    return {
+        taskPath,
+        fileName,
+        descriptor,
+        handler: response.handler
+    };
+});

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

@@ -0,0 +1,41 @@
+import { Profile } from '../types';
+export declare const publish: import("@forgehive/task").TaskInstanceType<(argv: {
+    descriptorName: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    getCwd: () => Promise<string>;
+    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    bundleCreate: (args: {
+        entryPoint: string;
+        outputFile: string;
+    }) => Promise<Promise<{
+        outputFile: string;
+    }>>;
+    bundleLoad: (args: {
+        bundlePath: string;
+    }) => Promise<Promise<any>>;
+    readFileUtf8: (filePath: string) => Promise<string>;
+    readFileBinary: (filePath: string) => Promise<Buffer>;
+    publishTask: (data: any, profile: Profile) => Promise<any>;
+    ensureBuildsFolder: () => Promise<string>;
+}>) => Promise<{
+    descriptor: import("../types").TaskDescriptor;
+    publishResponse: any;
+}>, {
+    getCwd: () => Promise<string>;
+    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    bundleCreate: (args: {
+        entryPoint: string;
+        outputFile: string;
+    }) => Promise<Promise<{
+        outputFile: string;
+    }>>;
+    bundleLoad: (args: {
+        bundlePath: string;
+    }) => Promise<Promise<any>>;
+    readFileUtf8: (filePath: string) => Promise<string>;
+    readFileBinary: (filePath: string) => Promise<Buffer>;
+    publishTask: (data: any, profile: Profile) => Promise<any>;
+    ensureBuildsFolder: () => Promise<string>;
+}>;

package/dist/tasks/task/publish.js

@@ -0,0 +1,106 @@
+"use strict";
+// TASK: publish
+// Run this task with:
+// forge task:run task:publish --descriptorMame task-name
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publish = 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 os_1 = __importDefault(require("os"));
+const load_1 = require("../conf/load");
+const create_1 = require("../bundle/create");
+const load_2 = require("../bundle/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
+const schema = new schema_1.Schema({
+    descriptorName: schema_1.Schema.string()
+});
+const boundaries = {
+    getCwd: async () => {
+        return process.cwd();
+    },
+    loadConf: load_1.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    bundleCreate: create_1.create.asBoundary(),
+    bundleLoad: load_2.load.asBoundary(),
+    readFileUtf8: async (filePath) => {
+        return promises_1.default.readFile(filePath, 'utf-8');
+    },
+    readFileBinary: async (filePath) => {
+        return promises_1.default.readFile(filePath);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    publishTask: async (data, profile) => {
+        const publishUrl = `${profile.url}/api/tasks/publish`;
+        console.log(`Publishing task to ${publishUrl}...`);
+        const authToken = `${profile.apiKey}:${profile.apiSecret}`;
+        const response = await axios_1.default.post(publishUrl, data, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data;
+    },
+    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;
+    }
+};
+exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile }) {
+    const cwd = await getCwd();
+    const forgeJson = await loadConf({});
+    const profile = await loadCurrentProfile({});
+    const taskDescriptor = forgeJson.tasks[descriptorName];
+    const projectName = forgeJson.project.name;
+    if (taskDescriptor === undefined) {
+        throw new Error('Task is not defined on forge.json');
+    }
+    const entryPoint = path_1.default.join(cwd, taskDescriptor.path);
+    const buildsPath = await ensureBuildsFolder();
+    const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
+    console.log('entryPoint:', entryPoint);
+    console.log('buildsPath:', buildsPath);
+    console.log('outputFile:', outputFile);
+    // 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];
+    const description = task.getDescription() ?? '';
+    const schema = task.getSchema() || new schema_1.Schema({});
+    const schemaDescriptor = schema.describe();
+    // Read the task file content and bundle
+    const sourceCode = await readFileUtf8(entryPoint);
+    const bundleContent = await readFileBinary(outputFile);
+    const data = {
+        ...taskDescriptor,
+        taskName: descriptorName,
+        projectName,
+        description,
+        schemaDescriptor: JSON.stringify(schemaDescriptor),
+        sourceCode,
+        bundle: bundleContent.toString('base64')
+    };
+    // Publish to hive api server
+    const response = await publishTask(data, profile);
+    console.log('Publish response:', response);
+    return { descriptor: taskDescriptor, publishResponse: response };
+});

package/dist/tasks/types.d.ts

@@ -35,3 +35,13 @@ export interface TaskName {
     fileName: string;
     dir?: string;
 }
+export interface Profile {
+    name: string;
+    apiKey: string;
+    apiSecret: string;
+    url: string;
+}
+export interface Profiles {
+    default: string;
+    profiles: Profile[];
+}

package/dist/test/tasks/create.test.js

@@ -15,6 +15,8 @@ const expectedContent = `// TASK: newTask
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 
+const description = 'Add task description here'
+
 const schema = new Schema({
   // Add your schema definitions here
   // example: myParam: Schema.string()
@@ -37,6 +39,8 @@ export const newTask = createTask(
     return status
   }
 )
+
+newTask.setDescription(description)
 `;
 describe('Create task', () => {
     let volume;

package/forge.json

@@ -33,6 +33,50 @@
     "conf:info": {
       "path": "src/tasks/conf/info.ts",
       "handler": "info"
+    },
+    "runner:create": {
+      "path": "src/tasks/runner/create.ts",
+      "handler": "create"
+    },
+    "runner:remove": {
+      "path": "src/tasks/runner/remove.ts",
+      "handler": "remove"
+    },
+    "runner:bundle": {
+      "path": "src/tasks/runner/bundle.ts",
+      "handler": "bundle"
+    },
+    "task:publish": {
+      "path": "src/tasks/task/publish.ts",
+      "handler": "publish"
+    },
+    "task:download": {
+      "path": "src/tasks/task/download.ts",
+      "handler": "download"
+    },
+    "auth:add": {
+      "path": "src/tasks/auth/add.ts",
+      "handler": "add"
+    },
+    "auth:load": {
+      "path": "src/tasks/auth/load.ts",
+      "handler": "load"
+    },
+    "auth:loadCurrent": {
+      "path": "src/tasks/auth/loadCurrent.ts",
+      "handler": "loadCurrent"
+    },
+    "auth:switch": {
+      "path": "src/tasks/auth/switch.ts",
+      "handler": "switchProfile"
+    },
+    "auth:list": {
+      "path": "src/tasks/auth/list.ts",
+      "handler": "list"
+    },
+    "auth:remove": {
+      "path": "src/tasks/auth/remove.ts",
+      "handler": "remove"
     }
   },
   "runners": {}

package/logs/auth:list.log

@@ -0,0 +1,4 @@
+{"name":"auth:list","type":"success","input":{},"output":{"status":"Ok","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},{"name":"localNext","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:3000"}],"default":"localNext"},"boundaries":{"loadProfiles":[{"input":[{}],"output":{"default":"localNext","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},{"name":"localNext","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:3000"}]}},{"input":[{}],"output":{"default":"localNext","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},{"name":"localNext","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:3000"}]}}]}}
+{"name":"auth:list","type":"success","input":{},"output":{"status":"Ok","default":"localNext"},"boundaries":{"loadProfiles":[{"input":[{}],"output":{"default":"localNext","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},{"name":"localNext","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:3000"}]}}]}}
+{"name":"auth:list","type":"success","input":{},"output":{"default":"localNext"},"boundaries":{"loadProfiles":[{"input":[{}],"output":{"default":"localNext","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},{"name":"localNext","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:3000"}]}}]}}
+{"name":"auth:list","type":"success","input":{},"output":{"default":"localNext"},"boundaries":{"loadProfiles":[{"input":[{}],"output":{"default":"localNext","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},{"name":"localNext","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:3000"}]}}]}}

package/logs/auth:load.log

@@ -0,0 +1,2 @@
+{"name":"auth:load","type":"error","input":{},"error":"ENOENT: no such file or directory, open '/Users/danielzavaladlvega/.forge/profiles.json'","boundaries":{"ensureBuildsFolder":[{"input":[],"output":"/Users/danielzavaladlvega/.forge"},{"input":[],"output":"/Users/danielzavaladlvega/.forge"}]}}
+{"name":"auth:load","type":"success","input":{},"output":{"profiles":[]},"boundaries":{"ensureBuildsFolder":[{"input":[],"output":"/Users/danielzavaladlvega/.forge"}]}}

package/logs/auth:loadCurrent.log

@@ -0,0 +1 @@
+{"name":"auth:loadCurrent","type":"success","input":{},"output":{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"},"boundaries":{"loadProfiles":[{"input":[{}],"output":{"default":"local","profiles":[{"name":"local","apiKey":"b4b5a766fcd7dc2d059e8f96a57c8edd","apiSecret":"2900246cb8bebcbeaadbe6348477592f42d62788d13fd4067588438bc11bf116","url":"http://localhost:4000"}]}}]}}