@forgehive/forge-cli 0.3.9 → 0.3.11

package/dist/runner.js

@@ -29,6 +29,9 @@ const add_1 = require("./tasks/auth/add");
 const switch_1 = require("./tasks/auth/switch");
 const list_2 = require("./tasks/auth/list");
 const remove_3 = require("./tasks/auth/remove");
+const create_2 = require("./tasks/project/create");
+const link_1 = require("./tasks/project/link");
+const unlink_1 = require("./tasks/project/unlink");
 const runner = new runner_1.Runner((data) => {
     const { _, ...filteredObj } = data;
     return {
@@ -64,6 +67,10 @@ runner.load('auth:add', add_1.add);
 runner.load('auth:switch', switch_1.switchProfile);
 runner.load('auth:list', list_2.list);
 runner.load('auth:remove', remove_3.remove);
+// Project commands
+runner.load('project:create', create_2.create);
+runner.load('project:link', link_1.link);
+runner.load('project:unlink', unlink_1.unlink);
 // Set handler
 runner.setHandler(async (data) => {
     const parsedArgs = runner.parseArguments(data);
@@ -146,7 +153,7 @@ runner.setHandler(async (data) => {
         }
         else if (taskName === 'auth:switch' || taskName === 'auth:remove') {
             result = await task.run({
-                profileName: action
+                profileName: String(action)
             });
         }
         else if (taskName === 'docs:download') {
@@ -155,13 +162,29 @@ runner.setHandler(async (data) => {
                 path
             });
         }
+        else if (taskName === 'project:create') {
+            const { projectName, description } = args;
+            result = await task.run({
+                projectName,
+                description
+            });
+        }
+        else if (taskName === 'project:link') {
+            const { uuid } = args;
+            result = await task.run({
+                uuid
+            });
+        }
+        else if (taskName === 'project:unlink') {
+            result = await task.run({});
+        }
         else {
             result = await task.run(args);
             if (taskName === 'info') {
                 silent = true;
             }
         }
-        if (taskName === 'task:describe' || taskName === 'task:list') {
+        if (taskName === 'task:describe' || taskName === 'task:list' || taskName === 'auth:list') {
             silent = true;
         }
         return {

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

@@ -7,8 +7,12 @@ export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {},
     default?: undefined;
 } | {
     default: string;
+    profiles: {
+        Name: string;
+        'API Key': string;
+        URL: string;
+    }[];
     status?: undefined;
-    profiles?: undefined;
 }>, {
     loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
 }>;

package/dist/tasks/auth/list.js

@@ -20,16 +20,28 @@ exports.list = (0, task_1.createTask)({
             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}`);
-        });
+        // Show current profile
+        const currentProfile = profiles.profiles.find(profile => profile.name === profiles.default);
+        if (currentProfile) {
+            console.log('Current Profile:');
+            console.log(`  Name: ${currentProfile.name}`);
+            console.log(`  API Key: ${currentProfile.apiKey}`);
+            console.log(`  URL: ${currentProfile.url}`);
+            console.log('');
+        }
+        console.log('Available profiles:\n');
+        const tableData = profiles.profiles.map(profile => ({
+            Name: profile.name,
+            'API Key': profile.apiKey,
+            URL: profile.url
+        }));
+        console.table(tableData, ['Name', 'API Key', 'URL']);
         console.log('\nUse auth:add to create or update a profile');
-        console.log('\nUse auth:switch to switch to a profile');
+        console.log('Use auth:switch [name] or auth:switch [index] to switch profiles');
+        console.log('========================================');
         return {
-            default: profiles.default
+            default: profiles.default,
+            profiles: tableData
         };
     }
 });

package/dist/tasks/auth/load.js

@@ -41,6 +41,7 @@ exports.load = (0, task_1.createTask)({
         }
         catch (_error) {
             console.log('Creating profiles.json');
+            console.log('===============================================');
             await promises_1.default.writeFile(profilesPath, '{"profiles": [], "default": ""}');
         }
         return profiles;

package/dist/tasks/auth/switch.js

@@ -1,7 +1,7 @@
 "use strict";
 // TASK: switch
 // Run this task with:
-// forge task:run auth:switch --profileName [name]
+// forge auth:switch [name] or forge auth:switch [index]
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,18 +30,34 @@ exports.switchProfile = (0, task_1.createTask)({
     fn: 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.`);
+        if (profiles.profiles.length === 0) {
+            throw new Error('No profiles found. Use auth:add to create one.');
+        }
+        let targetProfile;
+        // Check if profileName is a number (index)
+        const indexInput = parseInt(profileName, 10);
+        if (!isNaN(indexInput)) {
+            // Using index
+            if (indexInput < 0 || indexInput >= profiles.profiles.length) {
+                throw new Error(`Profile index ${indexInput} is out of range. Use auth:list to see available profiles (0-${profiles.profiles.length - 1}).`);
+            }
+            targetProfile = profiles.profiles[indexInput].name;
+        }
+        else {
+            // Using profile name
+            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.`);
+            }
+            targetProfile = profileName;
         }
         // Update default profile
-        profiles.default = profileName;
+        profiles.default = targetProfile;
         // Save updated profiles
         await persistProfiles(profiles);
-        console.log(`Switched to profile: ${profileName}`);
+        console.log(`Switched to profile: ${targetProfile}`);
         return {
-            default: profileName
+            default: targetProfile
         };
     }
 });

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

@@ -3,6 +3,11 @@ export declare const info: import("@forgehive/task").TaskInstanceType<(argv: {},
     loadConfig: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
 }>) => Promise<{
+    version: any;
+    profile: null;
+    paths: null;
+    error: string;
+} | {
     version: any;
     profile: {
         name: string;
@@ -14,6 +19,7 @@ export declare const info: import("@forgehive/task").TaskInstanceType<(argv: {},
         fixtures: string;
         fingerprints: string;
     };
+    error?: undefined;
 }>, {
     readFile: (filePath: string) => Promise<string>;
     loadConfig: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;

package/dist/tasks/conf/info.js

@@ -56,7 +56,30 @@ exports.info = (0, task_1.createTask)({
         const packageJsonPath = path.join(__dirname, '../../../package.json');
         const packageJsonContent = await readFile(packageJsonPath);
         const packageJson = JSON.parse(packageJsonContent);
-        const config = await loadConfig({});
+        let config;
+        try {
+            config = await loadConfig({});
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('ENOENT')) {
+                console.log('============ Forge CLI Information ============');
+                console.log('===============================================');
+                console.log();
+                console.log(`Version: ${packageJson.version}`);
+                console.log();
+                console.log('❌ No forge.json file found in current directory.');
+                console.log('   Run "forge init" to create a new Forge project.');
+                console.log();
+                console.log('===============================================');
+                return {
+                    version: packageJson.version,
+                    profile: null,
+                    paths: null,
+                    error: 'No forge.json found'
+                };
+            }
+            throw error;
+        }
         // Display human-friendly information
         console.log('===============================================');
         console.log('============ Forge CLI Information ============');

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

@@ -0,0 +1,27 @@
+import { type ForgeConf, type Profile } from '../types';
+export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
+    description?: string | undefined;
+    projectName?: string | undefined;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    createProject: (profile: Profile, payload: {
+        projectName: string;
+        description: string;
+        uuid: string;
+    }) => Promise<Response>;
+}>) => Promise<{
+    success: boolean;
+    project: any;
+    localUuid: string;
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    createProject: (profile: Profile, payload: {
+        projectName: string;
+        description: string;
+        uuid: string;
+    }) => Promise<Response>;
+}>;

package/dist/tasks/project/create.js

@@ -0,0 +1,96 @@
+"use strict";
+// TASK: create
+// Run this task with:
+// forge task:run project:create
+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 uuid_1 = require("uuid");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const load_1 = require("../conf/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
+const name = 'project:create';
+const description = 'Create a new project in ForgeHive';
+const schema = new schema_1.Schema({
+    projectName: schema_1.Schema.string().optional(),
+    description: schema_1.Schema.string().optional()
+});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    writeFile: async (filePath, content) => {
+        await promises_1.default.writeFile(filePath, content, 'utf-8');
+    },
+    createProject: async (profile, payload) => {
+        const authToken = `${profile.apiKey}:${profile.apiSecret}`;
+        return await fetch(`${profile.url}/api/projects`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${authToken}`
+            },
+            body: JSON.stringify(payload)
+        });
+    }
+};
+exports.create = (0, task_1.createTask)({
+    name,
+    description,
+    schema,
+    boundaries,
+    fn: async function (argv, { loadConf, loadCurrentProfile, writeFile, createProject }) {
+        const { projectName: inputProjectName, description } = argv;
+        // Load current configuration
+        const conf = await loadConf({});
+        // Use provided projectName or fall back to forge.json project name
+        const projectName = inputProjectName || conf.project.name;
+        if (!projectName) {
+            throw new Error('Project name is required. Provide --projectName or ensure forge.json has a project name.');
+        }
+        // Check if project already has a UUID, generate one if not
+        let projectUuid = conf.project.uuid;
+        if (!projectUuid) {
+            projectUuid = (0, uuid_1.v4)();
+            // Update forge.json with the new UUID
+            const forgePath = path_1.default.join(process.cwd(), 'forge.json');
+            const updatedConf = {
+                ...conf,
+                project: {
+                    ...conf.project,
+                    uuid: projectUuid
+                }
+            };
+            await writeFile(forgePath, JSON.stringify(updatedConf, null, 2));
+            console.log(`Generated and saved project UUID: ${projectUuid}`);
+        }
+        // Load current profile for API authentication
+        const profile = await loadCurrentProfile({});
+        // Prepare API request payload
+        const payload = {
+            projectName,
+            description: description || '',
+            uuid: projectUuid
+        };
+        // Make API request to create project
+        const response = await createProject(profile, payload);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to create project: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const result = await response.json();
+        console.log('Project created successfully!');
+        console.log(`Project UUID: ${result.project.uuid}`);
+        console.log(`Project Name: ${result.project.projectName}`);
+        console.log(`\n🌐 View your project on the dashboard: ${profile.url}/dashboard/projects/${result.project.uuid}`);
+        return {
+            success: true,
+            project: result.project,
+            localUuid: projectUuid
+        };
+    }
+});

package/dist/tasks/project/link.d.ts

@@ -0,0 +1,22 @@
+import { type ForgeConf, type Profile } from '../types';
+export declare const link: import("@forgehive/task").TaskInstanceType<(argv: {
+    uuid: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    fetchProject: (profile: Profile, uuid: string) => Promise<Response>;
+}>) => Promise<{
+    success: boolean;
+    linkedProject: {
+        uuid: any;
+        name: any;
+        description: any;
+        tasksCount: any;
+    };
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    fetchProject: (profile: Profile, uuid: string) => Promise<Response>;
+}>;

package/dist/tasks/project/link.js

@@ -0,0 +1,95 @@
+"use strict";
+// TASK: link
+// Run this task with:
+// forge project:link [uuid]
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.link = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const load_1 = require("../conf/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
+const name = 'project:link';
+const description = 'Link an existing remote project to the local project by UUID';
+const schema = new schema_1.Schema({
+    uuid: schema_1.Schema.string()
+});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
+    writeFile: async (filePath, content) => {
+        await promises_1.default.writeFile(filePath, content, 'utf-8');
+    },
+    fetchProject: async (profile, uuid) => {
+        const authToken = `${profile.apiKey}:${profile.apiSecret}`;
+        console.log(`Fetching project ${uuid} from ${profile.url}...`);
+        return await fetch(`${profile.url}/api/projects/${uuid}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${authToken}`
+            }
+        });
+    }
+};
+exports.link = (0, task_1.createTask)({
+    name,
+    description,
+    schema,
+    boundaries,
+    fn: async function ({ uuid }, { loadConf, loadCurrentProfile, writeFile, fetchProject }) {
+        // Load current configuration and profile
+        const conf = await loadConf({});
+        // Check if project already has a UUID
+        if (conf.project.uuid) {
+            throw new Error(`Project is already linked to UUID: ${conf.project.uuid}. Use a different project or remove the existing UUID from forge.json first.`);
+        }
+        const profile = await loadCurrentProfile({});
+        console.log(`Checking if project ${uuid} exists on ${profile.url}...`);
+        // Check if project exists on remote
+        const response = await fetchProject(profile, uuid);
+        if (!response.ok) {
+            if (response.status === 404) {
+                throw new Error(`Project with UUID ${uuid} not found on ${profile.url}. Please verify the UUID is correct.`);
+            }
+            else if (response.status === 401) {
+                throw new Error('Authentication failed. Please check your profile credentials with \'forge auth:list\'.');
+            }
+            else {
+                const errorText = await response.text();
+                throw new Error(`Failed to verify project: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+        }
+        const projectData = await response.json();
+        const project = projectData.project;
+        console.log(`✓ Found project: ${project.projectName}`);
+        console.log(`  Description: ${project.description || 'No description'}`);
+        console.log(`  Tasks: ${project.tasks.length} task(s)`);
+        // Update forge.json with the UUID
+        const forgePath = path_1.default.join(process.cwd(), 'forge.json');
+        const updatedConf = {
+            ...conf,
+            project: {
+                ...conf.project,
+                uuid: uuid
+            }
+        };
+        await writeFile(forgePath, JSON.stringify(updatedConf, null, 2));
+        console.log(`\n✓ Successfully linked project ${uuid} to local forge.json`);
+        console.log(`  Local project name: ${conf.project.name}`);
+        console.log(`  Remote project name: ${project.projectName}`);
+        console.log(`\n🌐 View your project on the dashboard: ${profile.url}/dashboard/projects/${uuid}`);
+        return {
+            success: true,
+            linkedProject: {
+                uuid: project.uuid,
+                name: project.projectName,
+                description: project.description,
+                tasksCount: project.tasks.length
+            }
+        };
+    }
+});

package/dist/tasks/project/unlink.d.ts

@@ -0,0 +1,11 @@
+import { type ForgeConf } from '../types';
+export declare const unlink: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+}>) => Promise<{
+    success: boolean;
+    unlinkedUuid: string;
+}>, {
+    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+}>;

package/dist/tasks/project/unlink.js

@@ -0,0 +1,65 @@
+"use strict";
+// TASK: unlink
+// Run this task with:
+// forge project:unlink
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlink = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const load_1 = require("../conf/load");
+const name = 'project:unlink';
+const description = 'Remove the project UUID link from local forge.json';
+const schema = new schema_1.Schema({
+// No parameters needed for unlink
+});
+const boundaries = {
+    loadConf: load_1.load.asBoundary(),
+    writeFile: async (filePath, content) => {
+        await promises_1.default.writeFile(filePath, content, 'utf-8');
+    }
+};
+exports.unlink = (0, task_1.createTask)({
+    name,
+    description,
+    schema,
+    boundaries,
+    fn: async function (argv, { loadConf, writeFile }) {
+        // Load current configuration
+        const conf = await loadConf({});
+        // Check if project has a UUID to unlink
+        if (!conf.project.uuid) {
+            throw new Error('No project UUID found in forge.json. The project is not currently linked to a remote project.');
+        }
+        const currentUuid = conf.project.uuid;
+        // Remove the UUID from the project configuration
+        const updatedConf = {
+            ...conf,
+            project: {
+                ...conf.project,
+                uuid: undefined
+            }
+        };
+        // Clean up undefined values by creating a new object without the uuid field
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { uuid, ...projectWithoutUuid } = updatedConf.project;
+        const finalConf = {
+            ...updatedConf,
+            project: projectWithoutUuid
+        };
+        // Write the updated configuration back to forge.json
+        const forgePath = path_1.default.join(process.cwd(), 'forge.json');
+        await writeFile(forgePath, JSON.stringify(finalConf, null, 2));
+        console.log(`✓ Successfully unlinked project from UUID: ${currentUuid}`);
+        console.log('  The project is no longer linked to a remote project.');
+        console.log('  You can now link to a different project using \'forge project:link [uuid]\'');
+        return {
+            success: true,
+            unlinkedUuid: currentUuid
+        };
+    }
+});

package/dist/tasks/task/createTask.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTaskCommand = void 0;
 const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
+const uuid_1 = require("uuid");
 const handlebars_1 = __importDefault(require("handlebars"));
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
@@ -40,11 +41,10 @@ export const {{ taskName }} = createTask({
   boundaries,
   fn: async function (argv, boundaries) {
     console.log('input:', argv)
-    console.log('boundaries:', boundaries)
+    console.log('boundaries:', Object.keys(boundaries))
     // Your task implementation goes here
-    const status = { status: 'Ok' }
 
-    return status
+    return {}
   }
 })
 
@@ -134,7 +134,8 @@ exports.createTaskCommand = (0, task_1.createTask)({
         }
         forge.tasks[descriptor] = {
             path: `${taskPath}/${fileName}`,
-            handler: taskName
+            handler: taskName,
+            uuid: (0, uuid_1.v4)()
         };
         await persistConf(forge, cwd);
         return { taskPath, fileName };

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

@@ -15,7 +15,7 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     bundleLoad: (args: {
         bundlePath: string;
     }) => Promise<Promise<any>>;
-    verifyLogFolder: (logsPath: string) => Promise<boolean>;
+    ensureLogFolder: (logsPath: string) => Promise<void>;
     ensureBuildsFolder: () => Promise<string>;
     sendLogToAPI: (profile: Profile, projectName: string, record: ExecutionRecord) => Promise<boolean>;
 }>) => Promise<any>, {
@@ -30,7 +30,7 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     bundleLoad: (args: {
         bundlePath: string;
     }) => Promise<Promise<any>>;
-    verifyLogFolder: (logsPath: string) => Promise<boolean>;
+    ensureLogFolder: (logsPath: string) => Promise<void>;
     ensureBuildsFolder: () => Promise<string>;
     sendLogToAPI: (profile: Profile, projectName: string, record: ExecutionRecord) => Promise<boolean>;
 }>;

package/dist/tasks/task/run.js

@@ -31,15 +31,14 @@ const boundaries = {
     loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
     bundleCreate: create_1.create.asBoundary(),
     bundleLoad: load_1.load.asBoundary(),
-    verifyLogFolder: async (logsPath) => {
-        // return true if the folder exists
+    ensureLogFolder: async (logsPath) => {
+        // create the folder if it doesn't exist
         try {
             await promises_1.default.access(logsPath);
         }
         catch (error) {
-            return false;
+            await promises_1.default.mkdir(logsPath, { recursive: true });
         }
-        return true;
     },
     ensureBuildsFolder: async () => {
         const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge', 'builds');
@@ -85,7 +84,7 @@ const boundaries = {
 exports.run = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, verifyLogFolder, ensureBuildsFolder, loadCurrentProfile, sendLogToAPI }) {
+    fn: async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, ensureLogFolder, ensureBuildsFolder, loadCurrentProfile, sendLogToAPI }) {
         // Load forge configuration
         const forge = await loadConf({});
         const taskDescriptor = forge.tasks[descriptorName];
@@ -101,13 +100,11 @@ exports.run = (0, task_1.createTask)({
         catch (error) {
             // Profile not found or not configured, continue without it
             console.log('No profile found, logs will not be sent to remote API');
+            console.log('===============================================');
         }
-        // Verify if log folder exists
+        // Ensure log folder exists
         const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
-        const logFolderExists = await verifyLogFolder(logFolderPath);
-        if (!logFolderExists) {
-            throw new Error(`Log folder "${logFolderPath}" does not exist`);
-        }
+        await ensureLogFolder(logFolderPath);
         // Prepare paths
         const logsPath = path_1.default.join(logFolderPath, descriptorName);
         const entryPoint = path_1.default.join(process.cwd(), taskDescriptor.path);

package/dist/tasks/types.d.ts

@@ -9,6 +9,7 @@ export interface RunnerDescriptor {
 export interface TaskDescriptor {
     path: string;
     handler: string;
+    uuid?: string;
 }
 export interface Infra {
     region: string;