@forgehive/forge-cli 0.2.13 → 0.3.0

package/src/utils/taskAnalysis.ts

@@ -0,0 +1,419 @@
+import * as ts from 'typescript'
+
+interface TaskLocation {
+  file: string
+  line: number
+  column: number
+}
+
+interface SchemaProperty {
+  type: string
+  optional?: boolean
+  default?: string
+}
+
+interface InputSchema {
+  type: string
+  properties: Record<string, SchemaProperty>
+}
+
+interface OutputType {
+  type: string
+  properties?: Record<string, SchemaProperty>
+}
+
+interface TaskFingerprint {
+  name: string
+  description?: string
+  location: TaskLocation
+  inputSchema: InputSchema
+  outputType: OutputType
+  boundaries: string[]
+  hash: string
+}
+
+// Simplified interface for filesystem output (excludes name, location, hash)
+export interface TaskFingerprintOutput {
+  description?: string
+  inputSchema: InputSchema
+  outputType: OutputType
+  boundaries: string[]
+}
+
+// Hash generation function
+function generateHash(input: string): string {
+  let hash = 0
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charCodeAt(i)
+    hash = ((hash << 5) - hash) + char
+    hash = hash & hash // Convert to 32-bit integer
+  }
+  return Math.abs(hash).toString(36)
+}
+
+// TypeScript AST analysis function
+function extractTaskFingerprints(sourceCode: string, filePath: string): TaskFingerprint[] {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true
+  )
+
+  const fingerprints: TaskFingerprint[] = []
+  let schemaNode: ts.Expression | null = null
+  let boundariesNode: ts.Expression | null = null
+
+  // First pass: find schema and boundaries variable declarations
+  function findVariables(node: ts.Node): void {
+    if (ts.isVariableStatement(node)) {
+      node.declarationList.declarations.forEach(decl => {
+        if (ts.isIdentifier(decl.name)) {
+          if (decl.name.text === 'schema' && decl.initializer) {
+            schemaNode = decl.initializer
+          } else if (decl.name.text === 'boundaries' && decl.initializer) {
+            boundariesNode = decl.initializer
+          }
+        }
+      })
+    }
+    ts.forEachChild(node, findVariables)
+  }
+
+  // Second pass: find createTask calls
+  function findCreateTask(node: ts.Node): void {
+    // Look for createTask calls
+    if (ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'createTask') {
+
+      const taskName = extractTaskName(node, sourceFile)
+      if (taskName) {
+        const fingerprint = analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode, boundariesNode)
+        if (fingerprint) {
+          fingerprints.push(fingerprint)
+        }
+      }
+    }
+
+    // Look for exported createTask assignments
+    if (ts.isVariableStatement(node) && node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+      node.declarationList.declarations.forEach(decl => {
+        if (ts.isVariableDeclaration(decl) &&
+            decl.initializer &&
+            ts.isCallExpression(decl.initializer) &&
+            ts.isIdentifier(decl.initializer.expression) &&
+            decl.initializer.expression.text === 'createTask') {
+
+          const taskName = ts.isIdentifier(decl.name) ? decl.name.text : 'unknown'
+          const fingerprint = analyzeCreateTaskCall(decl.initializer, sourceFile, filePath, taskName, schemaNode, boundariesNode)
+          if (fingerprint) {
+            fingerprints.push(fingerprint)
+          }
+        }
+      })
+    }
+
+    ts.forEachChild(node, findCreateTask)
+  }
+
+  // Execute both passes
+  findVariables(sourceFile)
+  findCreateTask(sourceFile)
+
+  return fingerprints
+}
+
+function extractTaskName(node: ts.CallExpression, _sourceFile: ts.SourceFile): string | null {
+  // Try to find the task name from variable assignment or export
+  let parent = node.parent
+  while (parent) {
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text
+    }
+    parent = parent.parent
+  }
+  return null
+}
+
+function analyzeCreateTaskCall(
+  node: ts.CallExpression,
+  sourceFile: ts.SourceFile,
+  filePath: string,
+  taskName: string,
+  schemaNode: ts.Expression | null = null,
+  boundariesNode: ts.Expression | null = null
+): TaskFingerprint | null {
+  try {
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart())
+    const args = node.arguments
+
+    // Use pre-found schema or fall back to argument analysis
+    let inputSchema: InputSchema = { type: 'object', properties: {} }
+    if (schemaNode) {
+      inputSchema = analyzeSchemaArg(schemaNode, sourceFile)
+    } else if (args[0]) {
+      inputSchema = analyzeSchemaArg(args[0], sourceFile)
+    }
+
+    // Use pre-found boundaries or fall back to argument analysis - simplified to just names
+    let boundaries: string[] = []
+    if (boundariesNode) {
+      boundaries = analyzeBoundariesArg(boundariesNode, sourceFile)
+    } else if (args[1]) {
+      boundaries = analyzeBoundariesArg(args[1], sourceFile)
+    }
+
+    // Extract function output type with better detection
+    let outputType: OutputType = { type: 'unknown' }
+    const functionArg = args[2]
+
+    if (functionArg) {
+      if (ts.isFunctionExpression(functionArg) || ts.isArrowFunction(functionArg)) {
+        // Better return type extraction
+        if (functionArg.type) {
+          const typeString = cleanTypeString(functionArg.type.getText(sourceFile))
+          outputType = { type: typeString }
+        } else {
+          // Try to infer from return statements with better object analysis
+          outputType = inferDetailedReturnType(functionArg, sourceFile)
+        }
+      }
+    }
+
+    // Generate hash from task signature
+    const hashInput = `${taskName}:${JSON.stringify(inputSchema)}:${JSON.stringify(boundaries)}`
+    const hash = generateHash(hashInput)
+
+    return {
+      name: taskName,
+      location: {
+        file: filePath,
+        line: position.line + 1,
+        column: position.character + 1
+      },
+      inputSchema,
+      outputType,
+      boundaries,
+      hash
+    }
+  } catch (error) {
+    console.warn(`Failed to analyze createTask call for ${taskName}:`, error)
+    return null
+  }
+}
+
+// Enhanced return type inference with detailed object analysis
+function inferDetailedReturnType(func: ts.FunctionExpression | ts.ArrowFunction, _sourceFile: ts.SourceFile): OutputType {
+  let returnType: OutputType = { type: 'unknown' }
+
+  function visitReturnStatements(node: ts.Node): void {
+    if (ts.isReturnStatement(node) && node.expression) {
+      if (ts.isObjectLiteralExpression(node.expression)) {
+        // Analyze object literal properties
+        const properties: Record<string, SchemaProperty> = {}
+        node.expression.properties.forEach(prop => {
+          if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            // Handle explicit property assignments: { propName: value }
+            const propName = prop.name.text
+            let propType = 'unknown'
+
+            // Try to infer property type from the initializer
+            if (ts.isStringLiteral(prop.initializer)) {
+              propType = 'string'
+            } else if (ts.isNumericLiteral(prop.initializer)) {
+              propType = 'number'
+            } else if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                       prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+              propType = 'boolean'
+            } else if (ts.isIdentifier(prop.initializer)) {
+              // Variable reference - try to infer from name
+              const varName = prop.initializer.text
+              propType = inferTypeFromVariableName(varName)
+            } else if (ts.isPropertyAccessExpression(prop.initializer)) {
+              // Property access like response.handler
+              propType = 'unknown'
+            }
+
+            properties[propName] = { type: propType }
+          } else if (ts.isShorthandPropertyAssignment(prop)) {
+            // Handle shorthand properties: { propName } (equivalent to { propName: propName })
+            const propName = prop.name.text
+            const propType = inferTypeFromVariableName(propName)
+            properties[propName] = { type: propType }
+          }
+        })
+
+        if (Object.keys(properties).length > 0) {
+          returnType = {
+            type: 'object',
+            properties
+          }
+        } else {
+          returnType = { type: 'object' }
+        }
+      } else if (ts.isStringLiteral(node.expression)) {
+        returnType = { type: 'string' }
+      } else if (ts.isNumericLiteral(node.expression)) {
+        returnType = { type: 'number' }
+      } else if (node.expression.kind === ts.SyntaxKind.TrueKeyword ||
+                 node.expression.kind === ts.SyntaxKind.FalseKeyword) {
+        returnType = { type: 'boolean' }
+      } else if (ts.isIdentifier(node.expression)) {
+        // Single variable return
+        const varType = inferTypeFromVariableName(node.expression.text)
+        returnType = { type: varType }
+      }
+    }
+    ts.forEachChild(node, visitReturnStatements)
+  }
+
+  if (func.body) {
+    visitReturnStatements(func.body)
+  }
+
+  return returnType
+}
+
+// Helper function to infer types from variable names
+function inferTypeFromVariableName(varName: string): string {
+  // Common patterns for type inference based on variable names
+  if (varName.includes('path') || varName.includes('Path') ||
+      varName.includes('name') || varName.includes('Name') ||
+      varName.includes('descriptor') || varName.includes('Descriptor') ||
+      varName.includes('fileName') || varName.includes('handler') ||
+      varName.includes('url') || varName.includes('id') ||
+      varName.includes('uuid') || varName.includes('token')) {
+    return 'string'
+  } else if (varName.includes('count') || varName.includes('Count') ||
+             varName.includes('size') || varName.includes('Size') ||
+             varName.includes('length') || varName.includes('Length') ||
+             varName.includes('index') || varName.includes('Index')) {
+    return 'number'
+  } else if (varName.includes('is') || varName.includes('has') ||
+             varName.includes('can') || varName.includes('should') ||
+             varName.includes('enabled') || varName.includes('success')) {
+    return 'boolean'
+  } else if (varName.includes('config') || varName.includes('Config') ||
+             varName.includes('options') || varName.includes('Options') ||
+             varName.includes('data') || varName.includes('result') ||
+             varName.includes('response') || varName.includes('error')) {
+    return 'unknown'
+  }
+
+  return 'unknown'
+}
+
+// Clean up type strings (remove Promise wrappers for boundaries)
+function cleanTypeString(typeString: string): string {
+  // Remove Promise wrapper for boundary functions
+  const promiseMatch = typeString.match(/Promise<(.+)>/)
+  if (promiseMatch) {
+    return promiseMatch[1]
+  }
+  return typeString
+}
+
+function analyzeSchemaArg(node: ts.Expression, sourceFile: ts.SourceFile): InputSchema {
+  // Handle variable references (e.g., when schema is defined as const schema = ...)
+  if (ts.isIdentifier(node) && node.text === 'schema') {
+    // This case is now handled by pre-finding the schema node
+    return { type: 'object', properties: {} }
+  }
+
+  // Handle direct Schema constructor calls
+  if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'Schema') {
+    const arg = node.arguments?.[0]
+    if (arg && ts.isObjectLiteralExpression(arg)) {
+      const properties: Record<string, SchemaProperty> = {}
+      arg.properties.forEach(prop => {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+          const propName = prop.name.text
+          const propValue = analyzeSchemaProp(prop.initializer, sourceFile)
+          properties[propName] = propValue
+        }
+      })
+      return { type: 'object', properties }
+    }
+  }
+  return { type: 'object', properties: {} }
+}
+
+// Enhanced schema property analysis
+function analyzeSchemaProp(node: ts.Expression, _sourceFile: ts.SourceFile): SchemaProperty {
+  // Analyze Schema.string(), Schema.number(), etc.
+  if (ts.isCallExpression(node)) {
+    if (ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === 'Schema') {
+
+      const methodName = node.expression.name.text
+      let baseType: SchemaProperty = { type: getSchemaTypeFromMethod(methodName) }
+
+      // Check for chained methods like .optional() or .default()
+      let current = node
+      while (current.parent && ts.isCallExpression(current.parent)) {
+        current = current.parent
+        if (ts.isPropertyAccessExpression(current.expression)) {
+          const chainedMethod = current.expression.name.text
+          if (chainedMethod === 'optional') {
+            baseType = { ...baseType, optional: true }
+          } else if (chainedMethod === 'default' && current.arguments[0]) {
+            baseType = { ...baseType, default: current.arguments[0].getText() }
+          }
+        }
+      }
+
+      return baseType
+    }
+  }
+  return { type: 'unknown' }
+}
+
+function getSchemaTypeFromMethod(methodName: string): string {
+  const typeMap: Record<string, string> = {
+    string: 'string',
+    number: 'number',
+    boolean: 'boolean',
+    array: 'array',
+    object: 'object'
+  }
+  return typeMap[methodName] || 'unknown'
+}
+
+function analyzeBoundariesArg(node: ts.Expression, _sourceFile: ts.SourceFile): string[] {
+  const boundaries: string[] = []
+
+  // Handle variable references (e.g., when boundaries is defined as const boundaries = ...)
+  if (ts.isIdentifier(node) && node.text === 'boundaries') {
+    // This case is now handled by pre-finding the boundaries node
+    return []
+  }
+
+  if (ts.isObjectLiteralExpression(node)) {
+    node.properties.forEach(prop => {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        const boundaryName = prop.name.text
+        boundaries.push(boundaryName)
+      }
+    })
+  }
+
+  return boundaries
+}
+
+// Export the core analysis function for reuse
+export function analyzeTaskFile(sourceCode: string, filePath: string, _expectedTaskName?: string): TaskFingerprintOutput | null {
+  const taskFingerprint = extractTaskFingerprints(sourceCode, filePath)[0]
+  if (!taskFingerprint) {
+    return null
+  }
+
+  // Return simplified output without name, location, hash
+  return {
+    description: taskFingerprint.description,
+    inputSchema: taskFingerprint.inputSchema,
+    outputType: taskFingerprint.outputType,
+    boundaries: taskFingerprint.boundaries
+  }
+}

package/dist/taskAdapter.d.ts

@@ -1,34 +0,0 @@
-import { TaskInstanceType, BaseFunction, Boundaries, ExecutionRecord, ReplayConfig } from '@forgehive/task';
-import { SchemaDescription } from '@forgehive/schema';
-/**
- * TaskAdapter wraps a TaskInstanceType to make it compatible with Runner
- * by handling boundary type issues
- */
-export declare class TaskAdapter<F extends BaseFunction, B extends Boundaries> {
-    private task;
-    constructor(task: TaskInstanceType<F, B>);
-    get version(): string;
-    getDescription(): string | undefined;
-    describe(): SchemaDescription;
-    run(argv?: Parameters<F>[0]): Promise<ReturnType<F>>;
-    safeReplay(executionLog: ExecutionRecord<any, any, any>, config: ReplayConfig<any>): Promise<[ReturnType<F> | null, Error | null, ExecutionRecord<Parameters<F>[0], ReturnType<F>, B>]>;
-    getMode(): import("@forgehive/task").Mode;
-    setMode(mode: string): void;
-    validate(argv?: any): any;
-    isValid(argv?: any): boolean;
-    addListener(fn: any): void;
-    removeListener(): void;
-    emit(data: any): void;
-    asBoundary(): (args: Parameters<F>[0]) => Promise<ReturnType<F>>;
-    getBoundaries(): import("@forgehive/task").WrappedBoundaries<B>;
-    setBoundariesData(data: any): void;
-    getBondariesData(): Record<string, unknown>;
-    mockBoundary(name: any, mockFn: any): any;
-    resetMock(name: any): any;
-    resetMocks(): void;
-    safeRun(argv?: Parameters<F>[0]): Promise<[ReturnType<F> | null, Error | null, ExecutionRecord<Parameters<F>[0], ReturnType<F>, B>]>;
-}
-/**
- * Helper function to adapt a task instance for Runner compatibility
- */
-export declare function adaptTask<F extends BaseFunction, B extends Boundaries>(task: TaskInstanceType<F, B>): TaskInstanceType;

package/dist/taskAdapter.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskAdapter = void 0;
-exports.adaptTask = adaptTask;
-/**
- * TaskAdapter wraps a TaskInstanceType to make it compatible with Runner
- * by handling boundary type issues
- */
-class TaskAdapter {
-    constructor(task) {
-        this.task = task;
-    }
-    // Forward all required methods to the underlying task
-    get version() {
-        return this.task.version;
-    }
-    getDescription() {
-        return this.task.getDescription();
-    }
-    describe() {
-        return this.task.describe();
-    }
-    async run(argv) {
-        return this.task.run(argv);
-    }
-    // This is the problematic method with boundary type incompatibilities
-    // Our implementation uses type assertions to make it compatible
-    async safeReplay(executionLog, config) {
-        // Type assertion to bridge the boundary type gap
-        return this.task.safeReplay(executionLog, config);
-    }
-    // Forward other methods as needed
-    getMode() {
-        return this.task.getMode();
-    }
-    setMode(mode) {
-        return this.task.setMode(mode);
-    }
-    validate(argv) {
-        return this.task.validate(argv);
-    }
-    isValid(argv) {
-        return this.task.isValid(argv);
-    }
-    addListener(fn) {
-        return this.task.addListener(fn);
-    }
-    removeListener() {
-        return this.task.removeListener();
-    }
-    emit(data) {
-        return this.task.emit(data);
-    }
-    asBoundary() {
-        return this.task.asBoundary();
-    }
-    getBoundaries() {
-        return this.task.getBoundaries();
-    }
-    setBoundariesData(data) {
-        return this.task.setBoundariesData(data);
-    }
-    getBondariesData() {
-        return this.task.getBondariesData();
-    }
-    mockBoundary(name, mockFn) {
-        return this.task.mockBoundary(name, mockFn);
-    }
-    resetMock(name) {
-        return this.task.resetMock(name);
-    }
-    resetMocks() {
-        return this.task.resetMocks();
-    }
-    async safeRun(argv) {
-        return this.task.safeRun(argv);
-    }
-}
-exports.TaskAdapter = TaskAdapter;
-/**
- * Helper function to adapt a task instance for Runner compatibility
- */
-function adaptTask(task) {
-    return new TaskAdapter(task);
-}

package/dist/templates/README.md

@@ -1,23 +0,0 @@
-# Templates Directory
-
-This directory contains Handlebars templates used by the CLI to generate files.
-
-## Templates
-
-- `task.hbs`: Template for generating new tasks
-
-## Important Note
-
-These templates are copied to the `dist/templates` directory during the build process.
-This ensures that the templates are available when the CLI is installed and used in production.
-
-The build script in `package.json` includes a step to copy these templates:
-
-```json
-"scripts": {
-  "build": "tsc && npm run copy-templates",
-  "copy-templates": "mkdir -p dist/templates && cp -r src/templates/* dist/templates/"
-}
-```
-
-If you add new templates, make sure they are properly copied to the dist folder. 

package/dist/templates/task.hbs

@@ -1,27 +0,0 @@
-// TASK: {{ taskName }}
-// Run this task with: 
-// shadow-cli {{ taskDescriptor }}
-
-import { createTask } from '@shadow/task'
-import { Schema } from '@shadow/schema'
-
-const schema = new Schema({
-  // Add your schema definitions here
-  // example: myParam: Schema.string()
-})
-
-const boundaries = {
-  // Add your boundary functions here
-  // example: readFile: async (path: string) => fs.readFile(path, 'utf-8')
-}
-
-export const {{ taskName }} = createTask(
-  schema,
-  boundaries,
-  async function (argv, boundaryFns) {
-    // Your task implementation goes here
-    const status = { status: 'Ok' }
-
-    return status
-  }
-) 

package/dist/test/utils.d.ts

@@ -1,2 +0,0 @@
-import { type WrappedBoundaryFunction } from '@forgehive/task';
-export declare const createBoundaryMock: () => WrappedBoundaryFunction;

package/dist/test/utils.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBoundaryMock = void 0;
-const createBoundaryMock = () => {
-    const mockFn = jest.fn().mockResolvedValue(undefined);
-    const boundaryMock = mockFn;
-    // Add required methods to satisfy the interface
-    boundaryMock.getTape = jest.fn().mockReturnValue([]);
-    boundaryMock.setTape = jest.fn();
-    boundaryMock.getMode = jest.fn().mockReturnValue('proxy');
-    boundaryMock.setMode = jest.fn();
-    boundaryMock.startRun = jest.fn();
-    boundaryMock.stopRun = jest.fn();
-    boundaryMock.getRunData = jest.fn().mockReturnValue([]);
-    return boundaryMock;
-};
-exports.createBoundaryMock = createBoundaryMock;

package/logs/auth:list.log

@@ -1,4 +0,0 @@
-{"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

@@ -1,2 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1,2 +0,0 @@
-{"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'"},{"input":["/Users/package.json"],"error":"ENOENT: no such file or directory, open '/Users/package.json'"}],"loadCurrentProfile":[]}}
-{"name":"conf:info","type":"error","input":{"name":"foobar"},"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/logs/runner:create.log

@@ -1,4 +0,0 @@
-{"name":"runner:create","type":"success","input":{},"output":{"status":"Ok"},"boundaries":{}}
-{"name":"runner:create","type":"success","input":{"runnerName":"inventory"},"output":{},"boundaries":{"loadConf":[{"input":[{}],"output":{"project":{"name":"forge-cli"},"paths":{"logs":"logs/","tasks":"src/tasks/","runners":"src/runners/","fixtures":"src/tests/fixtures","tests":"src/tests/"},"infra":{"region":"us-west-2","bucket":""},"tasks":{"bundle:create":{"path":"src/tasks/bundle/create.ts","handler":"create"},"bundle:load":{"path":"src/tasks/bundle/load.ts","handler":"load"},"task:run":{"path":"src/tasks/task/run.ts","handler":"run"},"task:remove":{"path":"src/tasks/task/remove.ts","handler":"remove"},"conf:info":{"path":"src/tasks/conf/info.ts","handler":"info"},"runner:create":{"path":"src/tasks/runner/create.ts","handler":"create"}},"runners":{}}},{"input":[{}],"output":{"project":{"name":"forge-cli"},"paths":{"logs":"logs/","tasks":"src/tasks/","runners":"src/runners/","fixtures":"src/tests/fixtures","tests":"src/tests/"},"infra":{"region":"us-west-2","bucket":""},"tasks":{"bundle:create":{"path":"src/tasks/bundle/create.ts","handler":"create"},"bundle:load":{"path":"src/tasks/bundle/load.ts","handler":"load"},"task:run":{"path":"src/tasks/task/run.ts","handler":"run"},"task:remove":{"path":"src/tasks/task/remove.ts","handler":"remove"},"conf:info":{"path":"src/tasks/conf/info.ts","handler":"info"},"runner:create":{"path":"src/tasks/runner/create.ts","handler":"create"}},"runners":{}}}],"getCwd":[{"input":[],"output":"/Users/danielzavaladlvega/forgehive/mono/apps/cli"},{"input":[],"output":"/Users/danielzavaladlvega/forgehive/mono/apps/cli"}],"persistRunner":[],"persistConf":[]}}
-{"name":"runner:create","type":"success","input":{"runnerName":"inventory"},"output":{},"boundaries":{"loadConf":[{"input":[{}],"output":{"project":{"name":"forge-cli"},"paths":{"logs":"logs/","tasks":"src/tasks/","runners":"src/runners/","fixtures":"src/tests/fixtures","tests":"src/tests/"},"infra":{"region":"us-west-2","bucket":""},"tasks":{"bundle:create":{"path":"src/tasks/bundle/create.ts","handler":"create"},"bundle:load":{"path":"src/tasks/bundle/load.ts","handler":"load"},"task:run":{"path":"src/tasks/task/run.ts","handler":"run"},"task:remove":{"path":"src/tasks/task/remove.ts","handler":"remove"},"conf:info":{"path":"src/tasks/conf/info.ts","handler":"info"},"runner:create":{"path":"src/tasks/runner/create.ts","handler":"create"}},"runners":{}}}],"getCwd":[{"input":[],"output":"/Users/danielzavaladlvega/forgehive/mono/apps/cli"}],"persistRunner":[],"persistConf":[]}}
-{"name":"runner:create","type":"error","input":{},"error":"Invalid input on: runnerName: Required","boundaries":{"loadConf":[],"getCwd":[],"persistRunner":[],"persistConf":[]}}