@jetbrains/junie-cli 562.3.0 → 624.1.0

package/bin/index.js

@@ -3,14 +3,13 @@ const {spawnSync} = require('child_process')
 const {getExecutable} = require('../getExecutable')
 
 function main() {
-  try {
-    const exe = getExecutable()
-    const result = spawnSync(exe, process.argv.slice(2), {stdio: 'inherit'})
-    process.exit(result.status ?? 0)
-  } catch (error) {
-    console.error('[Junie] Error:', error.message)
+  const exe = getExecutable()
+  if (!exe) {
     process.exit(1)
   }
+
+  const result = spawnSync(exe, process.argv.slice(2), {stdio: 'inherit'})
+  process.exit(result.status ?? 0)
 }
 
-main()
+main()

package/getExecutable.js

@@ -1,34 +1,21 @@
 const fs = require('fs')
 const path = require('path')
-const { platform } = require("node:os")
-
-function getExpectedBinaryPath() {
-  const workDir = path.resolve(__dirname, 'bin', 'junie')
-
-  return platform() === 'darwin'
-    ? path.join(workDir, 'Applications', 'junie.app', 'Contents', 'MacOS', 'junie')
-    : path.join(workDir, 'junie', 'bin', 'junie')
-}
+const os = require('os')
 
+const JUNIE_BIN = path.join(os.homedir(), '.local', 'bin')
 
 function getExecutable() {
-  const markerFile = path.resolve(__dirname, 'bin', 'junie.download')
-
-  if (fs.existsSync(markerFile)) {
-    const binaryPath = getExpectedBinaryPath()
+  const shimPath = path.join(JUNIE_BIN, 'junie')
 
-    if (fs.existsSync(binaryPath)) {
-      return binaryPath
-    } else {
-      console.error('Junie binary not found. Please re-install the package')
-    }
-  } else {
-    console.error('Junie download is corrupted. Please re-install the package')
+  if (fs.existsSync(shimPath)) {
+    return shimPath
   }
-}
 
+  console.error('[Junie] Shim not found at', shimPath)
+  console.error('[Junie] Please reinstall: npm install @jetbrains/junie-cli')
+  return null
+}
 
 module.exports = {
-  getExpectedBinaryPath,
   getExecutable,
-};
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jetbrains/junie-cli",
-  "version": "562.3.0",
-  "junieVersion": "562.3",
+  "version": "624.1.0",
+  "junieVersion": "624.1",
   "description": "Junie command‑line client",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": "https://github.com/jetbrains-junie/junie",
@@ -21,6 +21,7 @@
   },
   "files": [
     "bin/",
+    "shim/",
     "postinstall.js",
     "getExecutable.js"
   ],

package/postinstall.js

@@ -5,7 +5,29 @@ const fs = require("fs")
 const { pipeline } = require("stream/promises")
 const unzipper = require('unzipper')
 const os = require("os")
-const { getExpectedBinaryPath } = require("./getExecutable")
+const { execSync } = require("child_process")
+
+// Check for Windows early and exit gracefully
+if (os.platform() === 'win32') {
+  console.log('')
+  console.log('╭──────────────────────────────────────────────────────╮')
+  console.log('│                                                      │')
+  console.log('│  Junie CLI does not support Windows yet.             │')
+  console.log('│  Supported platforms: macOS, Linux                   │')
+  console.log('│                                                      │')
+  console.log('│  Stay tuned for Windows support in future releases!  │')
+  console.log('│                                                      │')
+  console.log('╰──────────────────────────────────────────────────────╯')
+  console.log('')
+  process.exit(0)
+}
+
+// === Configuration ===
+const JUNIE_BIN = path.join(os.homedir(), '.local', 'bin')
+const JUNIE_DATA = path.join(os.homedir(), '.local', 'share', 'junie')
+const VERSIONS_DIR = path.join(JUNIE_DATA, 'versions')
+const UPDATES_DIR = path.join(JUNIE_DATA, 'updates')
+const CURRENT_LINK = path.join(JUNIE_DATA, 'current')
 
 const ARCH_MAP = {
   x64: 'amd64',
@@ -71,15 +93,68 @@ function chmodRecursive(dirPath) {
   }
 }
 
+function installShim() {
+  const shimPath = path.join(JUNIE_BIN, 'junie')
+  const shimSource = path.join(__dirname, 'shim', 'junie')
+
+  // Check if shim already exists
+  if (fs.existsSync(shimPath)) {
+    console.log('[Junie] Updating shim at', shimPath)
+  } else {
+    console.log('[Junie] Installing shim to', shimPath)
+  }
+
+  // Copy shim.sh to ~/.local/bin/junie
+  const shimContent = fs.readFileSync(shimSource, 'utf8')
+  fs.writeFileSync(shimPath, shimContent, { mode: 0o755 })
+}
+
+function printPathInstructions() {
+  const currentPath = process.env.PATH || ''
+  if (!currentPath.includes(JUNIE_BIN)) {
+    console.log('')
+    console.log('╭──────────────────────────────────────────────────────╮')
+    console.log('│                                                      │')
+    console.log('│  Add ~/.local/bin to your PATH to use junie directly │')
+    console.log('│                                                      │')
+    console.log('│  Run: export PATH="$HOME/.local/bin:$PATH"           │')
+    console.log('│                                                      │')
+    console.log('│  Or add to your shell profile (~/.bashrc, ~/.zshrc)  │')
+    console.log('│                                                      │')
+    console.log('╰──────────────────────────────────────────────────────╯')
+    console.log('')
+  }
+}
+
 async function downloadAndInstall() {
   const {arch, osName} = resolveTarget()
   const url = buildUrl({arch, osName})
-  const workDir = path.resolve(__dirname, 'bin', 'junie')
-  const markerFile = path.resolve(__dirname, 'bin', 'junie.download')
+  const version = require("./package.json").junieVersion
+  const targetDir = path.join(VERSIONS_DIR, version)
+
+  // Create directories
+  fs.mkdirSync(JUNIE_BIN, {recursive: true})
+  fs.mkdirSync(targetDir, {recursive: true})
+  fs.mkdirSync(UPDATES_DIR, {recursive: true})
 
-  fs.mkdirSync(workDir, {recursive: true})
+  // Install shim
+  installShim()
 
-  const zipPath = path.join(workDir, 'junie.zip')
+  // Check if version already installed
+  if (fs.existsSync(CURRENT_LINK)) {
+    try {
+      const currentVersion = path.basename(fs.readlinkSync(CURRENT_LINK))
+      if (currentVersion === version && fs.readdirSync(targetDir).length > 0) {
+        console.log(`[Junie] Version ${version} already installed`)
+        printPathInstructions()
+        return path.join(targetDir, 'junie')
+      }
+    } catch {
+      // Continue with installation
+    }
+  }
+
+  const zipPath = path.join(targetDir, 'junie.zip')
   console.log(`[Junie] Downloading from ${url}`)
 
   const res = await fetch(url)
@@ -87,31 +162,34 @@ async function downloadAndInstall() {
 
   await pipeline(res.body, fs.createWriteStream(zipPath))
 
-  await fs.createReadStream(zipPath).pipe(unzipper.Extract({ path: workDir })).promise()
-
-  chmodRecursive(workDir)
-  stripQuarantine(workDir)
+  console.log('[Junie] Extracting...')
+  await fs.createReadStream(zipPath).pipe(unzipper.Extract({ path: targetDir })).promise()
 
-  const binaryPath = getExpectedBinaryPath()
-  // Re-assert main binary is executable (cheap, idempotent)
-  try { fs.chmodSync(binaryPath, 0o755); } catch {}
+  chmodRecursive(targetDir)
+  stripQuarantine(targetDir)
 
   fs.rmSync(zipPath)
 
-  fs.writeFileSync(markerFile, binaryPath, 'utf8')
+  // Update current symlink atomically
+  const tempLink = path.join(JUNIE_DATA, 'current.tmp')
+  try { fs.unlinkSync(tempLink) } catch {}
+  fs.symlinkSync(targetDir, tempLink)
+  fs.renameSync(tempLink, CURRENT_LINK)
 
-  console.log('[Junie] Installation complete.')
+  console.log(`[Junie] Installed version ${version}`)
+  printPathInstructions()
 
-  return binaryPath
+  return path.join(targetDir, 'junie')
 }
 
 async function main() {
   try {
     await downloadAndInstall()
+    console.log('[Junie] Installation complete.')
   } catch (error) {
     console.error('[Junie] Post-install error:', error)
     process.exit(1)
   }
 }
 
-main()
+main()

package/shim/junie

@@ -0,0 +1,295 @@
+#!/bin/bash
+#
+# Junie CLI Shim
+#
+# This script is the entry point for Junie CLI. It handles:
+# 1. Applying pending updates before launching
+# 2. Version selection via JUNIE_VERSION env or --use-version flag
+# 3. Executing the appropriate version binary
+#
+# Installation locations:
+#   Shim:     ~/.local/bin/junie
+#   Data:     ~/.local/share/junie/
+#   Versions: ~/.local/share/junie/versions/<version>/junie
+#   Updates:  ~/.local/share/junie/updates/
+
+set -euo pipefail
+
+# === Configuration ===
+JUNIE_DATA="${JUNIE_DATA:-$HOME/.local/share/junie}"
+VERSIONS_DIR="$JUNIE_DATA/versions"
+UPDATES_DIR="$JUNIE_DATA/updates"
+CURRENT_LINK="$JUNIE_DATA/current"
+PENDING_UPDATE="$UPDATES_DIR/pending-update.json"
+
+# === Utility Functions ===
+
+# Log message to stderr
+log() {
+  echo "[Junie] $*" >&2
+}
+
+# Check if a command exists
+has_command() {
+  command -v "$1" > /dev/null 2>&1
+}
+
+# Parse JSON field (basic, works without jq)
+# Usage: parse_json "field" < file.json
+parse_json_field() {
+  local field="$1"
+  # Extract value for "field": "value" or "field": number
+  grep -o "\"$field\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" | head -1 | sed 's/.*:[[:space:]]*"\([^"]*\)"/\1/' || true
+}
+
+# Parse JSON field with jq if available, fallback to grep
+get_json_field() {
+  local file="$1"
+  local field="$2"
+
+  if has_command jq; then
+    jq -r ".$field // empty" "$file" 2>/dev/null || true
+  else
+    parse_json_field "$field" < "$file"
+  fi
+}
+
+# Calculate SHA-256 checksum
+sha256sum_file() {
+  local file="$1"
+  if has_command shasum; then
+    shasum -a 256 "$file" | cut -d' ' -f1
+  elif has_command sha256sum; then
+    sha256sum "$file" | cut -d' ' -f1
+  else
+    log "Warning: No SHA-256 tool available, skipping checksum verification"
+    echo ""
+  fi
+}
+
+# Get binary path for a given version
+# Handles different package structures (macOS app bundle, Linux, direct binary)
+get_binary_path() {
+  local version="$1"
+  local version_dir="$VERSIONS_DIR/$version"
+
+  # macOS: look for .app bundle
+  if [[ -d "$version_dir/Applications/junie.app" ]]; then
+    echo "$version_dir/Applications/junie.app/Contents/MacOS/junie"
+  # Linux: look for junie/bin/junie
+  elif [[ -f "$version_dir/junie/bin/junie" ]]; then
+    echo "$version_dir/junie/bin/junie"
+  # Fallback: direct junie binary
+  elif [[ -f "$version_dir/junie" ]]; then
+    echo "$version_dir/junie"
+  else
+    echo ""
+  fi
+}
+
+# === Apply Pending Update ===
+apply_pending_update() {
+  if [[ ! -f "$PENDING_UPDATE" ]]; then
+    return 0
+  fi
+
+  log "Applying pending update..."
+
+  # Parse manifest
+  local version zip_path sha256
+  version=$(get_json_field "$PENDING_UPDATE" "version")
+  zip_path=$(get_json_field "$PENDING_UPDATE" "zipPath")
+  sha256=$(get_json_field "$PENDING_UPDATE" "sha256")
+
+  if [[ -z "$version" || -z "$zip_path" ]]; then
+    log "Invalid pending update manifest, skipping"
+    rm -f "$PENDING_UPDATE"
+    return 1
+  fi
+
+  if [[ ! -f "$zip_path" ]]; then
+    log "Update file not found: $zip_path"
+    rm -f "$PENDING_UPDATE"
+    return 1
+  fi
+
+  # Verify checksum if available
+  if [[ -n "$sha256" ]]; then
+    local actual_sha256
+    actual_sha256=$(sha256sum_file "$zip_path")
+
+    # Case-insensitive comparison (compatible with bash 3.x on macOS)
+    if [[ -n "$actual_sha256" ]] && ! echo "$actual_sha256" | grep -qi "^${sha256}$"; then
+      log "Checksum mismatch, skipping update"
+      log "Expected: $sha256"
+      log "Got: $actual_sha256"
+      rm -f "$PENDING_UPDATE" "$zip_path"
+      return 1
+    fi
+  fi
+
+  # Extract to versions directory
+  local target_dir="$VERSIONS_DIR/$version"
+  mkdir -p "$target_dir"
+
+  log "Extracting to $target_dir..."
+
+  if has_command unzip; then
+    unzip -q -o "$zip_path" -d "$target_dir"
+  elif has_command tar; then
+    # Fallback for .tar.gz files
+    tar -xzf "$zip_path" -C "$target_dir"
+  else
+    log "Error: No extraction tool available (unzip or tar)"
+    return 1
+  fi
+
+  # Make binary executable
+  chmod +x "$target_dir/junie" 2>/dev/null || true
+
+  # Remove quarantine on macOS
+  xattr -dr com.apple.quarantine "$target_dir" 2>/dev/null || true
+
+  # Update current symlink atomically
+  ln -sfn "$target_dir" "$CURRENT_LINK"
+
+  # Cleanup
+  rm -f "$zip_path" "$PENDING_UPDATE"
+
+  log "Updated to version $version"
+}
+
+# === Resolve Version ===
+resolve_version() {
+  local version=""
+
+  # Priority 1: --use-version flag
+  for arg in "$@"; do
+    case "$arg" in
+      --use-version=*)
+        version="${arg#--use-version=}"
+        break
+        ;;
+    esac
+  done
+
+  # Priority 2: JUNIE_VERSION environment variable
+  if [[ -z "$version" && -n "${JUNIE_VERSION:-}" ]]; then
+    version="$JUNIE_VERSION"
+  fi
+
+  # Priority 3: current symlink
+  if [[ -z "$version" ]]; then
+    if [[ -L "$CURRENT_LINK" ]]; then
+      version=$(basename "$(readlink "$CURRENT_LINK")")
+    elif [[ -d "$CURRENT_LINK" ]]; then
+      # current might be a directory in some setups
+      version=$(basename "$CURRENT_LINK")
+    fi
+  fi
+
+  if [[ -z "$version" ]]; then
+    log "Error: No version found. Please reinstall Junie."
+    log "Run: curl -fsSL https://junie.jetbrains.com/install.sh | bash"
+    exit 1
+  fi
+
+  # Verify version exists
+  if [[ ! -d "$VERSIONS_DIR/$version" ]]; then
+    log "Error: Version $version not found in $VERSIONS_DIR"
+    log "Available versions:"
+    ls -1 "$VERSIONS_DIR" 2>/dev/null || log "  (none)"
+    exit 1
+  fi
+
+  echo "$version"
+}
+
+# === Filter Shim-Specific Arguments ===
+# Global array to store filtered args (needed because bash can't return arrays)
+FILTERED_ARGS=()
+
+filter_args() {
+  FILTERED_ARGS=()
+  for arg in "$@"; do
+    case "$arg" in
+      --use-version=*) ;; # Skip shim-specific flag
+      *) FILTERED_ARGS+=("$arg") ;;
+    esac
+  done
+}
+
+# === Handle Shim Commands ===
+handle_shim_commands() {
+  case "${1:-}" in
+    --shim-version)
+      echo "junie-shim 1.0.0"
+      exit 0
+      ;;
+    --list-versions)
+      echo "Installed versions:"
+      if [[ -d "$VERSIONS_DIR" ]]; then
+        local current_version=""
+        if [[ -L "$CURRENT_LINK" ]]; then
+          current_version=$(basename "$(readlink "$CURRENT_LINK")")
+        fi
+        for v in "$VERSIONS_DIR"/*/; do
+          local vname=$(basename "$v")
+          if [[ "$vname" == "$current_version" ]]; then
+            echo "  $vname (current)"
+          else
+            echo "  $vname"
+          fi
+        done
+      else
+        echo "  (none)"
+      fi
+      exit 0
+      ;;
+    --switch-version=*)
+      local new_version="${1#--switch-version=}"
+      if [[ ! -d "$VERSIONS_DIR/$new_version" ]]; then
+        log "Error: Version $new_version not found"
+        exit 1
+      fi
+      ln -sfn "$VERSIONS_DIR/$new_version" "$CURRENT_LINK"
+      log "Switched to version $new_version"
+      exit 0
+      ;;
+  esac
+}
+
+# === Main ===
+main() {
+  # Handle shim-specific commands
+  handle_shim_commands "$@"
+
+  # Apply pending update if exists
+  apply_pending_update || true
+
+  # Resolve which version to run
+  local version
+  version=$(resolve_version "$@")
+
+  # Get binary path (handles macOS app bundle, Linux, direct binary)
+  local binary
+  binary=$(get_binary_path "$version")
+
+  if [[ -z "$binary" || ! -x "$binary" ]]; then
+    log "Error: Binary not found or not executable for version $version"
+    log "Looked in: $VERSIONS_DIR/$version"
+    exit 1
+  fi
+
+  # Set required environment variable for Junie
+  export EJ_RUNNER_PWD="${EJ_RUNNER_PWD:-$(pwd)}"
+
+  # Set JUNIE_DATA for the app to know where data is stored
+  export JUNIE_DATA="$JUNIE_DATA"
+
+  # Filter out shim-specific args and execute
+  filter_args "$@"
+  exec "$binary" ${FILTERED_ARGS[@]+"${FILTERED_ARGS[@]}"}
+}
+
+main "$@"