Factory Bridge Best Practices - Factory Documentation

Factory Bridge creates powerful opportunities to seamlessly integrate your local environment with Factory. This guide provides best practices to help you maximize the benefits while maintaining security and efficiency.

Workflow Integration

Development Environment Setup

Standardize Project Structures

Create consistent project structures across your repositories to make it easier to automate common tasks with Factory Bridge.

project-root/
├── src/
├── tests/
├── docs/
├── scripts/
└── package.json

Create Utility Scripts

Develop standardized utility scripts for common tasks to simplify command execution through Factory:

# build.sh
#!/bin/bash
echo "Building project..."
npm run build

This allows you to run ./scripts/build.sh instead of remembering complex build commands.

Set Up Path References

Store frequently used paths in your Factory sessions to make command execution more consistent:

Project path: /Users/username/projects/my-app
Build script: ./scripts/build.sh
Test script: ./scripts/test.sh

Task Automation

Common Development Tasks

Create command sequences for regular development tasks:

# Start development environment
cd /path/to/project
npm install
npm start

Factory can execute these commands in sequence, monitoring output at each stage.

Testing Workflows

Establish consistent testing workflows:

# Run tests for a specific feature
cd /path/to/project
npm test -- --filter=feature-name

Factory can execute tests and help analyze the results in the same session.

Deployment Preparation

Prepare for deployment with confidence:

# Prepare for deployment
cd /path/to/project
npm run lint
npm test
npm run build

Factory can execute these commands sequentially, only proceeding if each step succeeds.

Performance Optimization

Resource Management

Limit Long-Running Processes

Remember that each process started through Factory Bridge consumes resources on your local machine. Terminate processes when they’re no longer needed to free up resources.

Monitor Resource Usage

Periodically check system resource usage when running multiple processes through Factory Bridge to ensure optimal performance.

Command Execution Strategies

Choose the Right Working Directory

Always specify the most specific working directory for commands to avoid unexpected behavior and improve performance.

# Good practice
cd /path/to/specific/module
npm test

# Instead of
cd /path/to/large/project
cd module
npm test

Batch Similar Commands

Group similar commands to reduce overhead:

# Good practice
cd /path/to/project && npm install && npm test

# Instead of separate commands
cd /path/to/project
npm install
npm test

Use Background Processes When Appropriate

For long-running processes that you don’t need to monitor continuously, consider running them in the background:

nohup npm start > app.log 2>&1 &

This allows you to continue working with Factory while the process runs.

Security Best Practices

Access Control

Manage Pairing Codes Carefully

Treat your Factory Bridge pairing code like a password. Don’t share it with others, and regenerate it if you suspect it’s been compromised.

Use Separate Environments

Consider setting up different environments (e.g., development, testing, production) with appropriate access controls for each stage of development.

Command Execution Safety

Review Commands Before Execution

Always review commands suggested by Factory before allowing them to execute, especially commands that modify your system or access sensitive data.

Avoid Hardcoded Credentials

Never include credentials directly in commands. Instead, use environment variables or secure credential storage solutions.

# Avoid
mysql -u root -p"password"

# Better
mysql -u root -p
# Then use Pipe Process Input to enter the password

Limit Command Scope

Restrict commands to the minimum permissions needed for the task:

# Instead of
sudo npm install -g package

# Use
npm install --save-dev package

Data Protection

Handling Sensitive Data

Secure File Operations

Advanced Integration Techniques

Chaining Tools Together

Combine Factory Bridge tools for more complex workflows:

Interactive Script Execution

Execute a script that requires user input:

# Execute a Python script
python interactive_script.py

# Use Pipe Process Input to provide responses to prompts
# For each prompt: send input with appropriate termination

Process Management Lifecycle

Manage the complete lifecycle of a process:

# Start a server
npm start

# Interact with the server through another process
curl http://localhost:3000/api/test

# Terminate the server when testing is complete
# Use Kill Process tool with the server's PID

Custom Automation Scripts

Create custom scripts specifically designed to work well with Factory Bridge:

Progress Reporting

Design scripts with clear progress indicators:

#!/bin/bash
echo "Step 1: Installing dependencies..."
npm install
echo "Step 2: Running tests..."
npm test
echo "Step 3: Building application..."
npm run build
echo "Complete!"

This makes it easier to track progress in Factory.

Interactive Decision Points

Create scripts with clear interactive prompts:

#!/bin/bash
echo "Deploy to production? (y/n)"
read response
if [ "$response" = "y" ]; then
    echo "Deploying to production..."
    # deployment commands
else
    echo "Deployment cancelled."
fi

Factory can use the Pipe Process Input tool to respond to these prompts.

Troubleshooting Techniques

Diagnostic Strategies

Isolate Issues

When troubleshooting, isolate components to identify the source of problems:

# Test database connection
mysql -u username -p -e "SELECT 1"

# Test API endpoint
curl http://localhost:3000/api/health

# Check process status
ps aux | grep server

Capture Detailed Logs

Capture comprehensive logs for troubleshooting:

# Redirect both stdout and stderr to a log file
npm start > app.log 2>&1

# Use verbose mode when available
npm install --verbose

Check Environment Variables

Verify environment variables affecting your applications:

# Print environment variables
env | grep NODE

Common Resolution Patterns

Connection Issues

Command Execution Failures

Team Collaboration

Shared Workflows

Create and document standard Factory Bridge workflows for your team to ensure consistency and knowledge sharing.

Process Documentation

Document processes that use Factory Bridge in your team’s knowledge base, including common commands, troubleshooting steps, and best practices.

Real-world Examples

Full-stack Development Workflow

A typical full-stack development workflow using Factory Bridge:

Start the backend server:
```
cd /path/to/backend
npm start
```
In another Factory interaction, start the frontend:
```
cd /path/to/frontend
npm start
```
Run tests while both services are running:
```
cd /path/to/tests
npm test
```
Make code changes in Factory and see real-time updates
When finished, terminate both processes using their PIDs

Database Migration Workflow

A database migration workflow:

Create a backup:

pg_dump -U username -d database > backup.sql

Run migration scripts:
```
cd /path/to/migrations
./migrate.sh
```

Verify migration success:

psql -U username -d database -c "SELECT * FROM schema_migrations"

Run application tests against the migrated database:
```
cd /path/to/tests
npm run test:integration
```

Factory Bridge CLI Tools Reference

For detailed information on all available CLI tools, refer to the Factory Bridge CLI Tools Reference

User Guides

​Workflow Integration

​Development Environment Setup

​Task Automation

​Performance Optimization

​Resource Management

Limit Long-Running Processes

Monitor Resource Usage

​Command Execution Strategies

​Security Best Practices

​Access Control

Manage Pairing Codes Carefully

Use Separate Environments

​Command Execution Safety

​Data Protection

​Advanced Integration Techniques

​Chaining Tools Together

​Custom Automation Scripts

​Troubleshooting Techniques

​Diagnostic Strategies

​Common Resolution Patterns

​Team Collaboration