@forgehive/forge-cli 0.3.10 → 0.3.12

package/dist/runner.js

@@ -29,6 +29,11 @@ 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 clear_1 = require("./tasks/auth/clear");
+const create_2 = require("./tasks/project/create");
+const link_1 = require("./tasks/project/link");
+const unlink_1 = require("./tasks/project/unlink");
+const sync_1 = require("./tasks/project/sync");
 const runner = new runner_1.Runner((data) => {
     const { _, ...filteredObj } = data;
     return {
@@ -64,6 +69,12 @@ 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);
+runner.load('auth:clear', clear_1.clear);
+// Project commands
+runner.load('project:create', create_2.create);
+runner.load('project:link', link_1.link);
+runner.load('project:unlink', unlink_1.unlink);
+runner.load('project:sync', sync_1.sync);
 // Set handler
 runner.setHandler(async (data) => {
     const parsedArgs = runner.parseArguments(data);
@@ -74,12 +85,14 @@ runner.setHandler(async (data) => {
     let silent = false;
     const task = runner.getTask(taskName);
     if (!task) {
-        throw new Error(`Task "${taskName}" not found`);
+        throw new Error(`Forge command "${taskName}" not found`);
     }
     try {
         let result;
         const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish', 'task:describe', 'task:fingerprint'];
         const commandsWithRunner = ['runner:create', 'runner:remove'];
+        const commandsWithoutParams = ['project:unlink', 'project:sync', 'auth:clear'];
+        const silentCommands = ['task:describe', 'task:list', 'auth:list', 'info'];
         if (commandsWithDescriptor.includes(taskName)) {
             result = await task.run({ descriptorName: action });
         }
@@ -146,7 +159,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 +168,26 @@ 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 (commandsWithoutParams.includes(taskName)) {
+            result = await task.run({});
+        }
         else {
             result = await task.run(args);
-            if (taskName === 'info') {
-                silent = true;
-            }
         }
-        if (taskName === 'task:describe' || taskName === 'task:list') {
+        if (silentCommands.includes(taskName)) {
             silent = true;
         }
         return {

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

@@ -7,10 +7,26 @@ export declare const add: import("@forgehive/task").TaskInstanceType<(argv: {
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
+    fetchMeInfo: (apiKey: string, apiSecret: string, url: string) => Promise<{
+        success: boolean;
+        teamName?: string;
+        teamUuid?: string;
+        userName?: string;
+        error?: string;
+    }>;
 }>) => Promise<{
     status: string;
     message: string;
+    teamName: string | undefined;
+    userName: string | undefined;
 }>, {
     loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
+    fetchMeInfo: (apiKey: string, apiSecret: string, url: string) => Promise<{
+        success: boolean;
+        teamName?: string;
+        teamUuid?: string;
+        userName?: string;
+        error?: string;
+    }>;
 }>;

package/dist/tasks/auth/add.js

@@ -25,22 +25,72 @@ const boundaries = {
         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));
+    },
+    fetchMeInfo: async (apiKey, apiSecret, url) => {
+        try {
+            const response = await fetch(`${url}/api/me`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}:${apiSecret}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (response.ok) {
+                const data = await response.json();
+                return {
+                    success: true,
+                    teamName: data.team?.name,
+                    teamUuid: data.team?.uuid,
+                    userName: data.user?.name
+                };
+            }
+            else {
+                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+                return { success: false, error: errorData.error || `HTTP ${response.status}` };
+            }
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Network error' };
+        }
     }
 };
 exports.add = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
+    fn: async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles, fetchMeInfo }) {
         const profiles = await loadProfiles({});
+        console.log('Verifying credentials...');
+        // Fetch team and user information from /me endpoint
+        const meInfo = await fetchMeInfo(apiKey, apiSecret, url);
+        if (!meInfo.success) {
+            throw new Error(`Failed to verify credentials: ${meInfo.error}`);
+        }
+        console.log('✅ Credentials verified');
+        if (meInfo.userName) {
+            console.log(`   User: ${meInfo.userName}`);
+        }
+        if (meInfo.teamName) {
+            console.log(`   Team: ${meInfo.teamName}`);
+        }
+        // Create profile with team information
+        const profile = {
+            name,
+            apiKey,
+            apiSecret,
+            url,
+            teamName: meInfo.teamName,
+            teamUuid: meInfo.teamUuid,
+            userName: meInfo.userName
+        };
         // 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 };
+            profiles.profiles[existingProfileIndex] = profile;
         }
         else {
             // Add new profile
-            profiles.profiles.push({ name, apiKey, apiSecret, url });
+            profiles.profiles.push(profile);
         }
         // Set as default profile
         profiles.default = name;
@@ -48,7 +98,9 @@ exports.add = (0, task_1.createTask)({
         await persistProfiles(profiles);
         return {
             status: 'Ok',
-            message: `Profile '${name}' added and set as default`
+            message: `Profile '${name}' added and set as default`,
+            teamName: meInfo.teamName,
+            userName: meInfo.userName
         };
     }
 });

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

@@ -0,0 +1,16 @@
+import { type Profiles } from '../types';
+export declare const clear: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    clearProfiles: () => Promise<void>;
+}>) => Promise<{
+    status: string;
+    message: string;
+    clearedCount?: undefined;
+} | {
+    status: string;
+    message: string;
+    clearedCount: number;
+}>, {
+    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    clearProfiles: () => Promise<void>;
+}>;

package/dist/tasks/auth/clear.js

@@ -0,0 +1,54 @@
+"use strict";
+// TASK: clear
+// Run this task with:
+// forge task:run auth:clear
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clear = 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({});
+const boundaries = {
+    loadProfiles: load_1.load.asBoundary(),
+    clearProfiles: async () => {
+        const buildsPath = path_1.default.join(os_1.default.homedir(), '.forge');
+        const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+        // Create empty profiles structure
+        const emptyProfiles = {
+            default: '',
+            profiles: []
+        };
+        await promises_1.default.writeFile(profilesPath, JSON.stringify(emptyProfiles, null, 2));
+    }
+};
+exports.clear = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function (_argv, { loadProfiles, clearProfiles }) {
+        const profiles = await loadProfiles({});
+        if (profiles.profiles.length === 0) {
+            console.log('No profiles found to clear.');
+            return { status: 'Ok', message: 'No profiles found' };
+        }
+        const profileCount = profiles.profiles.length;
+        console.log(`Found ${profileCount} profile(s) to clear:`);
+        profiles.profiles.forEach(profile => {
+            console.log(`  - ${profile.name} (${profile.teamName || 'Unknown team'})`);
+        });
+        console.log('\\nClearing all profiles...');
+        // Clear all profiles
+        await clearProfiles();
+        console.log('✅ All profiles cleared successfully');
+        return {
+            status: 'Ok',
+            message: `Cleared ${profileCount} profile(s)`,
+            clearedCount: profileCount
+        };
+    }
+});

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

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

package/dist/tasks/auth/list.js

@@ -20,16 +20,36 @@ 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}`);
+            if (currentProfile.userName) {
+                console.log(`  User: ${currentProfile.userName}`);
+            }
+            if (currentProfile.teamName) {
+                console.log(`  Team: ${currentProfile.teamName}`);
+            }
+            console.log('');
+        }
+        console.log('Available profiles:\n');
+        const tableData = profiles.profiles.map(profile => ({
+            Name: profile.name,
+            'API Key': profile.apiKey,
+            URL: profile.url,
+            Team: profile.teamName || 'Unknown',
+            User: profile.userName || 'Unknown'
+        }));
+        console.table(tableData, ['Name', 'API Key', 'URL', 'Team', 'User']);
         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/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/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
+            }
+        };
+    }
+});