@forgehive/forge-cli 0.3.9 → 0.3.11

package/src/tasks/project/link.ts

@@ -0,0 +1,106 @@
+// TASK: link
+// Run this task with:
+// forge project:link [uuid]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+const name = 'project:link'
+const description = 'Link an existing remote project to the local project by UUID'
+
+const schema = new Schema({
+  uuid: Schema.string()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  },
+  fetchProject: async (profile: Profile, uuid: string): Promise<Response> => {
+    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}`
+      }
+    })
+  }
+}
+
+export const link = 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.join(process.cwd(), 'forge.json')
+    const updatedConf: ForgeConf = {
+      ...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/src/tasks/project/unlink.ts

@@ -0,0 +1,74 @@
+// TASK: unlink
+// Run this task with:
+// forge project:unlink
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { type ForgeConf } from '../types'
+
+const name = 'project:unlink'
+const description = 'Remove the project UUID link from local forge.json'
+
+const schema = new Schema({
+  // No parameters needed for unlink
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  }
+}
+
+export const unlink = 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: ForgeConf = {
+      ...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: ForgeConf = {
+      ...updatedConf,
+      project: projectWithoutUuid
+    }
+
+    // Write the updated configuration back to forge.json
+    const forgePath = path.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/src/tasks/task/createTask.ts

@@ -1,5 +1,6 @@
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
+import { v4 as uuidv4 } from 'uuid'
 
 import Handlebars from 'handlebars'
 import path from 'path'
@@ -38,11 +39,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 {}
   }
 })
 
@@ -155,7 +155,8 @@ export const createTaskCommand = createTask({
 
     forge.tasks[descriptor] = {
       path: `${taskPath}/${fileName}`,
-      handler: taskName
+      handler: taskName,
+      uuid: uuidv4()
     }
 
     await persistConf(forge, cwd)

package/src/tasks/task/run.ts

@@ -31,15 +31,13 @@ const boundaries = {
   loadCurrentProfile: loadCurrentProfile.asBoundary(),
   bundleCreate: bundleCreate.asBoundary(),
   bundleLoad: bundleLoad.asBoundary(),
-  verifyLogFolder: async (logsPath: string): Promise<boolean> => {
-    // return true if the folder exists
+  ensureLogFolder: async (logsPath: string): Promise<void> => {
+    // create the folder if it doesn't exist
     try {
       await fs.access(logsPath)
     } catch (error) {
-      return false
+      await fs.mkdir(logsPath, { recursive: true })
     }
-
-    return true
   },
   ensureBuildsFolder: async (): Promise<string> => {
     const buildsPath = path.join(os.homedir(), '.forge', 'builds')
@@ -90,7 +88,7 @@ export const run = createTask({
     loadConf,
     bundleCreate,
     bundleLoad,
-    verifyLogFolder,
+    ensureLogFolder,
     ensureBuildsFolder,
     loadCurrentProfile,
     sendLogToAPI
@@ -111,14 +109,12 @@ export const run = 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.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.join(logFolderPath, descriptorName)

package/src/tasks/types.ts

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

package/src/test/tasks/create.test.ts

@@ -32,11 +32,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 {}
   }
 })
 
@@ -103,5 +102,7 @@ describe('Create task', () => {
     const forgeContent = await fs.promises.readFile(path.join(rootDir, 'forge.json'), 'utf-8') as string
     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')
   })
 })