@humanu/orchestra 0.5.22 → 0.5.25

package/install.js

@@ -111,7 +111,23 @@ function linkCompatibilityBinary(binaryPath) {
 function installPrebuiltBinary() {
   const platform = getPlatformKey();
   const source = path.join(prebuiltDir, platform, BINARY_NAME);
+  
   if (!fs.existsSync(source)) {
+    console.log(`⚠️  No prebuilt binary found for ${platform}`);
+    
+    // Check if we have binaries for other platforms (for debugging)
+    if (fs.existsSync(prebuiltDir)) {
+      const availablePlatforms = fs.readdirSync(prebuiltDir).filter(item => {
+        const platformPath = path.join(prebuiltDir, item);
+        return fs.statSync(platformPath).isDirectory() && 
+               fs.existsSync(path.join(platformPath, BINARY_NAME));
+      });
+      
+      if (availablePlatforms.length > 0) {
+        console.log(`   Available platforms: ${availablePlatforms.join(', ')}`);
+      }
+    }
+    
     return false;
   }
 
@@ -124,24 +140,61 @@ function installPrebuiltBinary() {
 
 function buildFromSource() {
   if (!hasLocalSource) {
-    console.error('No prebuilt binary available and source tree not found.');
-    console.error('Clone the repository and run `cargo build --release` to build locally.');
+    console.error('❌ No prebuilt binary available and source tree not found.');
+    console.error('');
+    console.error('This usually happens when:');
+    console.error('1. The npm package was built on a different platform (e.g., macOS vs Linux)');
+    console.error('2. The binary for your platform is missing from the package');
+    console.error('');
+    console.error('Solutions:');
+    console.error('1. Install from source (requires Rust toolchain):');
+    console.error('   git clone https://github.com/humanunsupervised/orchestra.git');
+    console.error('   cd orchestra');
+    console.error('   cargo build --release');
+    console.error('');
+    console.error('2. Use a pre-built release:');
+    console.error('   Download from: https://github.com/humanunsupervised/orchestra/releases');
+    console.error('');
+    console.error('3. Install Rust and build locally:');
+    console.error('   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+    console.error('   source ~/.cargo/env');
+    console.error('   cargo build --release');
     process.exit(1);
   }
 
   try {
     execSync('cargo --version', { stdio: 'ignore' });
   } catch (error) {
-    console.error('Rust toolchain not found. Install Rust from https://rustup.rs/.');
+    console.error('❌ Rust toolchain not found.');
+    console.error('');
+    console.error('Install Rust from https://rustup.rs/');
+    console.error('Then run: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh');
     process.exit(1);
   }
 
-  console.log('Building from source...');
-  execSync('cargo build --release', { stdio: 'inherit', cwd: path.join(projectRoot, 'gw-tui') });
+  console.log('🔨 Building from source... (this may take a few minutes)');
+  console.log('   Working directory:', path.join(projectRoot, 'gw-tui'));
+  
+  try {
+    execSync('cargo build --release', { stdio: 'inherit', cwd: path.join(projectRoot, 'gw-tui') });
+  } catch (error) {
+    console.error('❌ Build failed.');
+    console.error('');
+    console.error('Common issues:');
+    console.error('- Missing system dependencies (openssl, pkg-config, etc.)');
+    console.error('- Network issues during dependency download');
+    console.error('');
+    console.error('Try installing dependencies:');
+    console.error('- Ubuntu/Debian: sudo apt-get install libssl-dev pkg-config');
+    console.error('- macOS: brew install openssl pkg-config');
+    console.error('- Fedora: sudo dnf install openssl-devel pkgconfig');
+    process.exit(1);
+  }
 
   const builtBinary = path.join(projectRoot, 'gw-tui', 'target', 'release', 'gw-tui');
   if (!fs.existsSync(builtBinary)) {
-    console.error('Build finished but gw-tui binary was not produced.');
+    console.error('❌ Build finished but gw-tui binary was not produced.');
+    console.error('   Expected location:', builtBinary);
     process.exit(1);
   }
 
@@ -149,6 +202,8 @@ function buildFromSource() {
   fs.copyFileSync(builtBinary, destination);
   fs.chmodSync(destination, 0o755);
   linkCompatibilityBinary(destination);
+  
+  console.log('✅ Successfully built from source!');
 }
 
 function assetsReady() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanu/orchestra",
-  "version": "0.5.22",
+  "version": "0.5.25",
   "description": "AI-powered Git worktree and tmux session manager with modern TUI",
   "keywords": [
     "git",

package/resources/scripts/copy_env.sh

@@ -0,0 +1,244 @@
+#!/bin/bash
+
+###############################################################################
+# copy_env.sh – Shared helpers for copying .env/config files into worktrees
+# ---------------------------------------------------------------------------
+# Provides reusable functions consumed by commands.sh, gw-bridge.sh, and any
+# other shell entry point. Adds structured logging so we can troubleshoot which
+# files were selected and whether individual copy operations succeeded.
+###############################################################################
+
+# Global variables populated by copy_env_files
+COPY_ENV_LAST_COPIED=0
+COPY_ENV_LAST_TARGET=""
+COPY_ENV_LOG_FILE=""
+
+# Internal: write a log line (timestamped). Respects COPY_ENV_VERBOSE: if set to
+# 1, the message is also echoed to stderr for real-time debugging.
+copy_env_log() {
+    local level="$1"
+    shift
+    local message="$*"
+    local timestamp
+    timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
+    if [[ -n "$COPY_ENV_LOG_FILE" ]]; then
+        if ! printf '%s [%s] %s\n' "$timestamp" "$level" "$message" >>"$COPY_ENV_LOG_FILE" 2>/dev/null; then
+            # If we cannot write to the configured log file, drop logging to disk
+            COPY_ENV_LOG_FILE=""
+        fi
+    fi
+    if [[ ${COPY_ENV_VERBOSE:-0} -eq 1 ]]; then
+        printf '[copy-env][%s] %s\n' "$level" "$message" >&2
+    fi
+}
+
+# Determine which locations to copy by reading <repo>/.orchestra/options.json.
+copy_env_load_locations() {
+    local repo_root="$1"
+    local config_file="$repo_root/.orchestra/options.json"
+
+    if [[ -f "$config_file" ]]; then
+        if command -v jq >/dev/null 2>&1; then
+            jq -r '(.copy_locations // ["/"])[]' "$config_file" 2>/dev/null || printf '/\n'
+            return
+        elif command -v python3 >/dev/null 2>&1; then
+            python3 - "$config_file" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+config_path = Path(sys.argv[1])
+try:
+    data = json.loads(config_path.read_text())
+except Exception:
+    data = {}
+locations = data.get("copy_locations")
+if isinstance(locations, list) and locations:
+    for entry in locations:
+        if isinstance(entry, str):
+            print(entry)
+else:
+    print("/")
+PY
+            return
+        fi
+    fi
+    # Fallback: default to repo root
+    printf '/\n'
+}
+
+# Copy .env files from the source worktree into the target worktree.
+# Arguments:
+#   $1 - source root (worktree we are copying from)
+#   $2 - target root (new or existing worktree)
+#   $3 - repository shared root (defaults to source root)
+#   $4 - quiet flag (1 suppresses user-facing echo output)
+copy_env_files() {
+    local source_root="$1"
+    local target_root="$2"
+    local repo_root="${3:-$source_root}"
+    local quiet="${4:-0}"
+
+    COPY_ENV_LAST_COPIED=0
+    COPY_ENV_LAST_TARGET="$target_root"
+
+    local enable_logs=${COPY_ENV_ENABLE_LOG:-0}
+    local log_file="${COPY_ENV_LOG_FILE:-}"
+    local log_dir="${COPY_ENV_LOG_DIR:-}"
+
+    if [[ -n "$log_file" ]]; then
+        mkdir -p "$(dirname "$log_file")" 2>/dev/null || true
+        COPY_ENV_LOG_FILE="$log_file"
+    elif [[ $enable_logs -eq 1 || -n "$log_dir" ]]; then
+        log_dir="${log_dir:-$repo_root/.orchestra/logs}"
+        mkdir -p "$log_dir" 2>/dev/null || true
+        COPY_ENV_LOG_FILE="$log_dir/copy-env.log"
+    else
+        COPY_ENV_LOG_FILE=""
+    fi
+
+    copy_env_log "INFO" "Starting copy (source=$source_root, target=$target_root, repo=$repo_root)"
+
+    local override_locations="${COPY_ENV_OVERRIDE_LOCATIONS:-}"
+    unset COPY_ENV_OVERRIDE_LOCATIONS
+    local locations=()
+    if [[ -n "$override_locations" ]]; then
+        while IFS= read -r line; do
+            [[ -z "$line" ]] && continue
+            locations+=("$line")
+        done <<<"$override_locations"
+    else
+        while IFS= read -r line; do
+            [[ -z "$line" ]] && continue
+            locations+=("$line")
+        done < <(copy_env_load_locations "$repo_root")
+    fi
+
+    if [[ ${#locations[@]} -eq 0 ]]; then
+        locations=("/")
+    fi
+
+    local bases=("$source_root")
+    if [[ -n "$repo_root" && "$repo_root" != "$source_root" ]]; then
+        bases+=("$repo_root")
+    fi
+
+    local overall_copied=0
+    local overall_failed=0
+
+    (( quiet != 1 )) && echo "🔧 Copying .env files to worktree..."
+
+    for raw_location in "${locations[@]}"; do
+        local trimmed
+        trimmed="$(printf '%s' "$raw_location" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"
+        [[ -z "$trimmed" ]] && continue
+
+        local rel="${trimmed#/}"
+        rel="${rel#./}"
+
+        local location_copied=0
+        local location_failed=0
+
+        for base in "${bases[@]}"; do
+            [[ -z "$base" ]] && continue
+
+            copy_env_log "DEBUG" "Checking location '$trimmed' in base '$base'"
+
+            if [[ "$trimmed" == "/" ]]; then
+                local found_root=0
+                for env_file in "$base"/.env*; do
+                    [[ -f "$env_file" ]] || continue
+                    mkdir -p "$target_root"
+                    local err_msg
+                    err_msg="$(cp "$env_file" "$target_root/$(basename "$env_file")" 2>&1)"
+                    if [[ $? -eq 0 ]]; then
+                        (( overall_copied++ ))
+                        location_copied=1
+                        found_root=1
+                        (( quiet != 1 )) && echo "   ✅ Copied $(basename "$env_file") from $base/"
+                        copy_env_log "INFO" "Copied $(basename "$env_file") from $base/"
+                    else
+                        (( overall_failed++ ))
+                        (( location_failed++ ))
+                        (( quiet != 1 )) && echo "   ❌ Failed to copy $(basename "$env_file") from $base/"
+                        copy_env_log "ERROR" "Failed to copy $(basename "$env_file") from $base/: ${err_msg:-unknown error}"
+                    fi
+                done
+                if [[ $found_root -eq 1 ]]; then
+                    break
+                fi
+            else
+                local source_path="$base/$rel"
+                if [[ -d "$source_path" ]]; then
+                    local dest_dir="$target_root/$rel"
+                    mkdir -p "$dest_dir"
+                    local found_any=0
+                    for env_file in "$source_path"/.env*; do
+                        [[ -f "$env_file" ]] || continue
+                        local err_msg
+                        err_msg="$(cp "$env_file" "$dest_dir/$(basename "$env_file")" 2>&1)"
+                        if [[ $? -eq 0 ]]; then
+                            (( overall_copied++ ))
+                            location_copied=1
+                            found_any=1
+                            (( quiet != 1 )) && echo "   ✅ Copied $(basename "$env_file") from $rel/"
+                            copy_env_log "INFO" "Copied $(basename "$env_file") from $rel/"
+                        else
+                            (( overall_failed++ ))
+                            (( location_failed++ ))
+                            (( quiet != 1 )) && echo "   ❌ Failed to copy $(basename "$env_file") from $rel/"
+                            copy_env_log "ERROR" "Failed to copy $(basename "$env_file") from $rel/: ${err_msg:-unknown error}"
+                        fi
+                    done
+                    if [[ $found_any -eq 1 ]]; then
+                        break
+                    fi
+                elif [[ -f "$source_path" ]]; then
+                    local dest_dir
+                    dest_dir="$(dirname "$rel")"
+                    if [[ "$dest_dir" != "." ]]; then
+                        mkdir -p "$target_root/$dest_dir"
+                    else
+                        mkdir -p "$target_root"
+                    fi
+                    local err_msg
+                    err_msg="$(cp "$source_path" "$target_root/$rel" 2>&1)"
+                    if [[ $? -eq 0 ]]; then
+                        (( overall_copied++ ))
+                        location_copied=1
+                        (( quiet != 1 )) && echo "   ✅ Copied $rel"
+                        copy_env_log "INFO" "Copied file $rel"
+                    else
+                        (( overall_failed++ ))
+                        (( location_failed++ ))
+                        (( quiet != 1 )) && echo "   ❌ Failed to copy $rel"
+                        copy_env_log "ERROR" "Failed to copy file $rel: ${err_msg:-unknown error}"
+                    fi
+                    break
+                fi
+            fi
+        done
+
+        if [[ $location_copied -eq 0 ]]; then
+            if [[ "$trimmed" == "/" ]]; then
+                (( quiet != 1 )) && echo "   ⚠️  No .env files found in any root"
+                copy_env_log "WARN" "No .env files discovered for '/'"
+            else
+                (( quiet != 1 )) && echo "   ⚠️  No .env files found for $trimmed"
+                copy_env_log "WARN" "No .env files found for '$trimmed'"
+            fi
+        fi
+    done
+
+    COPY_ENV_LAST_COPIED=$overall_copied
+
+    if [[ $overall_copied -eq 0 ]]; then
+        copy_env_log "WARN" "Completed with no files copied"
+        (( quiet != 1 )) && echo "   ⚠️  No environment files copied."
+    else
+        copy_env_log "INFO" "Completed: $overall_copied file(s) copied, failures=$overall_failed"
+        (( quiet != 1 )) && echo "   ✅ Environment files copied ($overall_copied)."
+    fi
+
+    return 0
+}