@forgehive/forge-cli 0.1.8 → 0.2.0

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

@@ -45,6 +45,38 @@
     "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"}]}}]}}

package/logs/conf:info.log

@@ -0,0 +1 @@
+{"name":"conf:info","type":"error","input":{},"error":"ENOENT: no such file or directory, open '/Users/package.json'","boundaries":{"readFile":[{"input":["/Users/package.json"],"error":"ENOENT: no such file or directory, open '/Users/package.json'"}],"loadCurrentProfile":[]}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,13 +20,14 @@
     }
   },
   "dependencies": {
+    "axios": "^1.8.4",
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
-    "@forgehive/task": "0.1.4",
     "@forgehive/schema": "0.1.4",
-    "@forgehive/runner": "0.1.4",
-    "@forgehive/record-tape": "0.0.1"
+    "@forgehive/task": "0.1.4",
+    "@forgehive/record-tape": "0.0.1",
+    "@forgehive/runner": "0.1.4"
   },
   "devDependencies": {
     "@types/jest": "^29.5.3",

package/src/runner.ts

@@ -11,6 +11,13 @@ import { remove as taskRemoveCommand } from './tasks/task/remove'
 import { create as createRunner } from './tasks/runner/create'
 import { remove as removeRunner } from './tasks/runner/remove'
 import { bundle as bundleRunner } from './tasks/runner/bundle'
+import { publish as publishTask } from './tasks/task/publish'
+import { download as downloadTask } from './tasks/task/download'
+
+import { add as addProfile } from './tasks/auth/add'
+import { switchProfile } from './tasks/auth/switch'
+import { list as listProfiles } from './tasks/auth/list'
+import { remove as removeProfile } from './tasks/auth/remove'
 
 interface CliParsedArguments extends RunnerParsedArguments {
   action: string;
@@ -34,12 +41,20 @@ runner.load('info', info)
 runner.load('task:create', createTaskCommand)
 runner.load('task:run', taskRunCommand)
 runner.load('task:remove', taskRemoveCommand)
+runner.load('task:publish', publishTask)
+runner.load('task:download', downloadTask)
 
 // Runner commands
 runner.load('runner:create', createRunner)
 runner.load('runner:remove', removeRunner)
 runner.load('runner:bundle', bundleRunner)
 
+// Auth commands
+runner.load('auth:add', addProfile)
+runner.load('auth:switch', switchProfile)
+runner.load('auth:list', listProfiles)
+runner.load('auth:remove', removeProfile)
+
 // Set handler
 runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
   const parsedArgs = runner.parseArguments(data)
@@ -57,10 +72,11 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
   try {
     let result
 
-    const commandsWithDescriptor = ['task:create', 'task:remove']
+    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({
@@ -73,11 +89,31 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
         runnerName: action,
         targetPath: paths.targetPath
       })
+    } else if (taskName === 'task:download') {
+      const { uuid } = args as { uuid: string }
+
+      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 as { name: string, apiKey: string, apiSecret: string, url: string }
+
+      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/src/tasks/auth/add.ts

@@ -0,0 +1,57 @@
+// TASK: add
+// Run this task with:
+// forge task:run auth:add
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import path from 'path'
+import fs from 'fs/promises'
+import os from 'os'
+
+import { load as loadProfiles } from './load'
+import { type Profiles } from '../types'
+
+const schema = new Schema({
+  name: Schema.string(),
+  apiKey: Schema.string(),
+  apiSecret: Schema.string(),
+  url: Schema.string()
+})
+
+const boundaries = {
+  loadProfiles: loadProfiles.asBoundary(),
+  persistProfiles: async (profiles: Profiles): Promise<void> => {
+    const buildsPath = path.join(os.homedir(), '.forge')
+    const profilesPath = path.join(buildsPath, 'profiles.json')
+    await fs.writeFile(profilesPath, JSON.stringify(profiles, null, 2))
+  }
+}
+
+export const add = 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/src/tasks/auth/list.ts

@@ -0,0 +1,43 @@
+// TASK: list
+// Run this task with:
+// forge task:run auth:list
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+
+import { load as loadProfiles } from './load'
+import { type Profiles } from '../types'
+
+const schema = new Schema({})
+
+const boundaries = {
+  loadProfiles: loadProfiles.asBoundary()
+}
+
+export const list = createTask(
+  schema,
+  boundaries,
+  async function (_argv, { loadProfiles }) {
+    const profiles: 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/src/tasks/auth/load.ts

@@ -0,0 +1,51 @@
+// TASK: load
+// Run this task with:
+// forge task:run auth:load
+
+import os from 'os'
+import path from 'path'
+import fs from 'fs/promises'
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+
+import { type Profiles } from '../types'
+
+const schema = new Schema({})
+
+const boundaries = {
+  ensureBuildsFolder: async (): Promise<string> => {
+    const buildsPath = path.join(os.homedir(), '.forge')
+    try {
+      await fs.access(buildsPath)
+    } catch {
+      await fs.mkdir(buildsPath, { recursive: true })
+    }
+
+    return buildsPath
+  }
+}
+
+export const load = createTask(
+  schema,
+  boundaries,
+  async function (argv, { ensureBuildsFolder }) {
+    const buildsPath = await ensureBuildsFolder()
+
+    let profiles: Profiles = {
+      default: '',
+      profiles: []
+    }
+
+    const profilesPath = path.join(buildsPath, 'profiles.json')
+    try {
+      const content = await fs.readFile(profilesPath, 'utf-8')
+      profiles = JSON.parse(content) as Profiles
+    } catch (_error) {
+      console.log('Creating profiles.json')
+      await fs.writeFile(profilesPath, '{"profiles": [], "default": ""}')
+    }
+
+    return profiles
+  }
+)