@forgehive/forge-cli 0.3.10 → 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/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
+            }
+        };
+    }
+});

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/types.d.ts

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

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

@@ -35,11 +35,10 @@ export const newTask = 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 {}
   }
 })
 
@@ -94,5 +93,7 @@ describe('Create task', () => {
         const forgeContent = await fs.promises.readFile(path_1.default.join(rootDir, 'forge.json'), 'utf-8');
         const forgeConf = JSON.parse(forgeContent);
         expect(forgeConf.tasks['sample:newTask']).toBeDefined();
+        expect(forgeConf.tasks['sample:newTask'].uuid).toBeDefined();
+        expect(typeof forgeConf.tasks['sample:newTask'].uuid).toBe('string');
     });
 });

package/forge.json

@@ -118,6 +118,20 @@
     "docs:download": {
       "path": "src/tasks/docs/download.ts",
       "handler": "download"
+    },
+    "project:create": {
+      "path": "src/tasks/project/create.ts",
+      "handler": "create"
+    },
+    "project:link": {
+      "path": "src/tasks/project/link.ts",
+      "handler": "link",
+      "uuid": "cb9f82e1-d397-46d9-9f0d-2b0e3becbfa1"
+    },
+    "project:unlink": {
+      "path": "src/tasks/project/unlink.ts",
+      "handler": "unlink",
+      "uuid": "414d37de-793c-4d01-899d-69515f5e0948"
     }
   },
   "runners": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -29,11 +29,12 @@
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
     "typescript": "^5.3.3",
+    "uuid": "^11.1.0",
     "@forgehive/hive-sdk": "0.1.2",
     "@forgehive/record-tape": "0.2.5",
-    "@forgehive/task": "0.2.5",
     "@forgehive/runner": "0.2.5",
-    "@forgehive/schema": "0.1.4"
+    "@forgehive/schema": "0.1.4",
+    "@forgehive/task": "0.2.5"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/src/runner.ts

@@ -20,7 +20,6 @@ import { describe as describeTask } from './tasks/task/describe'
 import { fingerprint as fingerprintTask } from './tasks/task/fingerprint'
 import { invoke as invokeTask } from './tasks/task/invoke'
 
-
 import { create as createRunner } from './tasks/runner/create'
 import { remove as removeRunner } from './tasks/runner/remove'
 import { bundle as bundleRunner } from './tasks/runner/bundle'
@@ -34,6 +33,10 @@ import { switchProfile } from './tasks/auth/switch'
 import { list as listProfiles } from './tasks/auth/list'
 import { remove as removeProfile } from './tasks/auth/remove'
 
+import { create as createProject } from './tasks/project/create'
+import { link as linkProject } from './tasks/project/link'
+import { unlink as unlinkProject } from './tasks/project/unlink'
+
 interface CliParsedArguments extends RunnerParsedArguments {
   action: string;
 }
@@ -81,6 +84,11 @@ runner.load('auth:switch', switchProfile)
 runner.load('auth:list', listProfiles)
 runner.load('auth:remove', removeProfile)
 
+// Project commands
+runner.load('project:create', createProject)
+runner.load('project:link', linkProject)
+runner.load('project:unlink', unlinkProject)
+
 // Set handler
 runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
   const parsedArgs = runner.parseArguments(data)
@@ -167,7 +175,7 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
       })
     } else if (taskName === 'auth:switch' || taskName === 'auth:remove') {
       result = await task.run({
-        profileName: action
+        profileName: String(action)
       })
     } else if (taskName === 'docs:download') {
       const { path } = args as { path?: string }
@@ -175,6 +183,20 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
       result = await task.run({
         path
       })
+    } else if (taskName === 'project:create') {
+      const { projectName, description } = args as { projectName?: string, description?: string }
+
+      result = await task.run({
+        projectName,
+        description
+      })
+    } else if (taskName === 'project:link') {
+      const { uuid } = args as { uuid: string }
+      result = await task.run({
+        uuid
+      })
+    } else if (taskName === 'project:unlink') {
+      result = await task.run({})
     } else {
       result = await task.run(args)
 
@@ -183,7 +205,7 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
       }
     }
 
-    if (taskName === 'task:describe' || taskName === 'task:list') {
+    if (taskName === 'task:describe' || taskName === 'task:list' || taskName === 'auth:list') {
       silent = true
     }