@jacebenson/jsn 0.0.10 → 1.0.2

package/README.md

@@ -2,28 +2,17 @@
 
 A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.
 
-## Versions
-
-| Version | Language | Branch | Install | Status |
-|---------|----------|--------|---------|--------|
-| Go | Go | `main` | Binary / `go install` | Stable |
-| Node.js | JavaScript (Node 18+) | `nodejs` | `npm install -g` | Active development |
-
-Both versions share the same CLI interface and are tested against the same ServiceNow PDI.
-
 ## Installation
 
-### npm (Node.js version — cross-platform)
+### npm (Cross-platform — recommended for Windows)
 
 ```bash
-npm install -g @jacebenson/jsn@node
+npm install -g @jacebenson/jsn
 ```
 
-> **Note:** The `@node` dist-tag is required. The `latest` tag currently points to the Go shim wrapper (v1.0.1).
+Works on macOS, Linux, and Windows. The correct binary for your platform is downloaded automatically during install.
 
-No compilation needed. Works on macOS, Linux, and Windows with Node.js 18+.
-
-### Download Binary (Go version)
+### Download Binary
 
 ```bash
 # Download the latest release
@@ -32,7 +21,7 @@ chmod +x jsn
 sudo mv jsn /usr/local/bin/
 ```
 
-### Go Install (Go version)
+### Go Install
 
 ```bash
 go install github.com/jacebenson/jsn/cmd/jsn@latest
@@ -318,7 +307,7 @@ jsn auth status
 jsn auth logout
 ```
 
-Credentials are stored in `~/.config/servicenow/credentials/` (file-based, OS keychain coming soon).
+Credentials are securely stored in your OS keychain (or file fallback at `~/.config/servicenow/credentials/`).
 
 ## Environment Variables
 
@@ -342,8 +331,6 @@ jsn incidents list
 
 ## Shell Completion
 
-> **Note:** Shell completion is available in the Go version only.
-
 ```bash
 # Bash
 source <(jsn completion bash)
@@ -394,39 +381,10 @@ Error (usage): Instance URL required. Set via --instance flag, SERVICENOW_INSTAN
 - `--instance` flag
 - `SERVICENOW_INSTANCE_URL` environment variable
 
-## Development
-
-This repository maintains two parallel implementations:
-
-- **`main`** — Go implementation (stable)
-- **`nodejs`** — Node.js implementation (active development)
-
-Both branches share the same CLI interface and are kept in sync for feature parity.
-
-### Node.js version
-
-```bash
-git checkout nodejs
-npm install
-npm test        # Run tests
-npm run lint    # Run ESLint
-npm run start   # Run CLI locally
-```
-
-### Releasing
-
-```bash
-# From nodejs branch — creates node-v* tag and publishes to npm
-npm run release -- patch
-
-# From main branch — creates go-v* tag and builds binaries
-npm run release -- patch
-```
-
 ## Contributing
 
 1. Fork the repository
-2. Create a feature branch (target the appropriate branch: `main` or `nodejs`)
+2. Create a feature branch
 3. Make your changes
 4. Add tests
 5. Submit a pull request

package/bin/jsn.js

@@ -1,5 +1,60 @@
 #!/usr/bin/env node
+/**
+ * JSN CLI binary wrapper
+ *
+ * This script finds the downloaded platform-specific binary and spawns it,
+ * forwarding all arguments, stdin, stdout, and stderr.
+ */
 
-import { cli } from '../src/cli.js';
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
 
-cli.parse();
+function getBinaryPath() {
+  const binaryDir = path.join(__dirname, '..', 'binary');
+  const binaryName = os.platform() === 'win32' ? 'jsn.exe' : 'jsn';
+  const binaryPath = path.join(binaryDir, binaryName);
+
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  // Fallback: check if running from source/build
+  const devPath = path.join(__dirname, '..', 'jsn');
+  if (fs.existsSync(devPath)) {
+    return devPath;
+  }
+
+  // Another fallback for dev
+  const devPath2 = path.join(__dirname, '..', 'jsn.exe');
+  if (fs.existsSync(devPath2)) {
+    return devPath2;
+  }
+
+  console.error('Error: JSN binary not found.');
+  console.error('');
+  console.error('The binary should have been downloaded during npm install.');
+  console.error('Try reinstalling the package:');
+  console.error('  npm uninstall -g @jacebenson/jsn');
+  console.error('  npm install -g @jacebenson/jsn');
+  console.error('');
+  console.error('Or download manually from:');
+  console.error('  https://github.com/jacebenson/jsn/releases');
+  process.exit(1);
+}
+
+const binaryPath = getBinaryPath();
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  windowsHide: true,
+});
+
+child.on('exit', (code) => {
+  process.exit(code ?? 0);
+});
+
+child.on('error', (err) => {
+  console.error(`Failed to start JSN: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,44 +1,40 @@
 {
   "name": "@jacebenson/jsn",
-  "version": "0.0.10",
+  "version": "1.0.2",
   "description": "A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.",
-  "type": "module",
+  "homepage": "https://github.com/jacebenson/jsn#readme",
+  "bugs": {
+    "url": "https://github.com/jacebenson/jsn/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jacebenson/jsn.git"
+  },
+  "license": "MIT",
+  "author": "Jace Benson",
+  "type": "commonjs",
+  "files": [
+    "bin",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
   "bin": {
     "jsn": "bin/jsn.js"
   },
-  "main": "src/cli.js",
   "scripts": {
-    "test": "node --test $(find test -name '*.test.js')",
-    "lint": "npx eslint src/ bin/ test/",
-    "start": "node bin/jsn.js",
-    "tag-reminder": "node scripts/tag-reminder.js",
-    "release": "node scripts/release.js"
+    "postinstall": "node scripts/npm-install.js"
   },
-  "keywords": [
-    "servicenow",
-    "cli",
-    "rest-api",
-    "automation"
-  ],
-  "author": "Jace Benson",
-  "license": "MIT",
   "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "@inquirer/prompts": "^7.5.1",
-    "chalk": "^5.4.1",
-    "cli-table3": "^0.6.5",
-    "yargs": "^17.7.2"
-  },
-  "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "globals": "^17.6.0"
+    "node": ">=14"
   },
-  "files": [
-    "bin/jsn.js",
-    "src/",
-    "README.md",
-    "LICENSE"
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
   ]
 }

package/scripts/install.sh

@@ -0,0 +1,227 @@
+#!/usr/bin/env bash
+# JSN CLI Installer
+# Installs the latest JSN release from GitHub
+#
+# Usage:
+#   curl -fsSL https://jsn.jace.pro/install | bash
+#
+# Environment:
+#   JSN_VERSION    Install specific version (e.g., 0.4.1)
+#   NO_COLOR       Disable colored output (https://no-color.org)
+
+set -euo pipefail
+
+REPO="jacebenson/jsn"
+BINARY_NAME="jsn"
+INSTALL_DIR="${JSN_INSTALL_DIR:-}"
+VERSION="${JSN_VERSION:-}"
+
+# Colors - respect NO_COLOR (https://no-color.org)
+if [[ -z "${NO_COLOR:-}" ]] && [[ -t 1 ]]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  NC='\033[0m'
+  BOLD='\033[1m'
+else
+  RED=''
+  GREEN=''
+  YELLOW=''
+  NC=''
+  BOLD=''
+fi
+
+info() { echo -e "${GREEN}✓${NC} $1"; }
+step() { echo -e "${BOLD}→${NC} $1"; }
+warn() { echo -e "${YELLOW}⚠${NC} $1"; }
+error() { echo -e "${RED}✗${NC} $1" >&2; exit 1; }
+
+detect_platform() {
+  local os arch
+  
+  os=$(uname -s | tr '[:upper:]' '[:lower:]')
+  case "$os" in
+    linux) PLATFORM="linux" ;;
+    darwin) PLATFORM="darwin" ;;
+    mingw*|msys*|cygwin*) 
+      PLATFORM="windows"
+      BINARY_NAME="jsn.exe"
+      ;;
+    *) error "Unsupported OS: $os" ;;
+  esac
+  
+  arch=$(uname -m)
+  case "$arch" in
+    x86_64|amd64) ARCH="amd64" ;;
+    arm64|aarch64) ARCH="arm64" ;;
+    armv7l) ARCH="arm" ;;
+    *) error "Unsupported architecture: $arch" ;;
+  esac
+}
+
+get_latest_version() {
+  # Use redirect URL instead of API to avoid rate limits
+  local url
+  url=$(curl -fsSL -o /dev/null -w '%{url_effective}' "https://github.com/${REPO}/releases/latest" 2>/dev/null) || true
+  local version="${url##*/}"
+  version="${version#v}"
+  
+  if [[ ! $version =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    error "Could not determine latest version. Check your network connection."
+  fi
+  
+  echo "$version"
+}
+
+setup_install_dir() {
+  if [[ -z "$INSTALL_DIR" ]]; then
+    if [[ -w "/usr/local/bin" ]]; then
+      INSTALL_DIR="/usr/local/bin"
+    else
+      INSTALL_DIR="$HOME/.local/bin"
+    fi
+  fi
+  mkdir -p "$INSTALL_DIR"
+}
+
+download_and_install() {
+  local version="$1"
+  local tmp_dir
+  tmp_dir=$(mktemp -d)
+  trap "rm -rf '$tmp_dir'" EXIT
+  
+  # Determine archive extension
+  local ext
+  if [[ "$PLATFORM" == "windows" ]]; then
+    ext="zip"
+  else
+    ext="tar.gz"
+  fi
+  
+  local filename="jsn_v${version}_${PLATFORM}_${ARCH}.${ext}"
+  local url="https://github.com/${REPO}/releases/download/v${version}/${filename}"
+  
+  step "Downloading JSN v${version} for ${PLATFORM}/${ARCH}..."
+  if ! curl -fsSL "$url" -o "${tmp_dir}/${filename}"; then
+    error "Download failed from $url"
+  fi
+  
+  step "Extracting..."
+  cd "$tmp_dir"
+  if [[ "$PLATFORM" == "windows" ]]; then
+    unzip -q "$filename"
+  else
+    tar -xzf "$filename"
+  fi
+  
+  # Find binary using shell globbing (Windows find is different)
+  local binary_file=""
+  for f in jsn jsn.exe jsn_*; do
+    if [[ -f "$f" ]] && [[ "$f" != "*.tar.gz" ]] && [[ "$f" != "*.zip" ]]; then
+      binary_file="$f"
+      break
+    fi
+  done
+  
+  if [[ -z "$binary_file" ]]; then
+    error "Could not find binary in archive"
+    ls -la
+    exit 1
+  fi
+  
+  step "Installing to $INSTALL_DIR..."
+  if [[ -w "$INSTALL_DIR" ]]; then
+    mv "$binary_file" "$INSTALL_DIR/$BINARY_NAME"
+  else
+    mv "$binary_file" "$INSTALL_DIR/$BINARY_NAME" 2>/dev/null || {
+      warn "Need sudo access to install to $INSTALL_DIR"
+      sudo mv "$binary_file" "$INSTALL_DIR/$BINARY_NAME"
+    }
+  fi
+  
+  chmod +x "$INSTALL_DIR/$BINARY_NAME" 2>/dev/null || true
+}
+
+setup_path() {
+  # Check if already in PATH
+  if [[ ":$PATH:" == *":$INSTALL_DIR:"* ]]; then
+    return 0
+  fi
+  
+  # Determine shell config file
+  local shell_rc=""
+  if [[ "$PLATFORM" == "windows" ]]; then
+    # On Windows, always use .bashrc for Git Bash
+    shell_rc="$HOME/.bashrc"
+  else
+    case "${SHELL:-}" in
+      */zsh) shell_rc="$HOME/.zshrc" ;;
+      */bash) shell_rc="$HOME/.bashrc" ;;
+      *) shell_rc="$HOME/.profile" ;;
+    esac
+  fi
+  
+  # Check if already in config
+  if [[ -f "$shell_rc" ]] && grep -qF "$INSTALL_DIR" "$shell_rc" 2>/dev/null; then
+    return 0
+  fi
+  
+  step "Adding $INSTALL_DIR to PATH in $shell_rc"
+  echo "" >> "$shell_rc"
+  echo "# Added by JSN installer" >> "$shell_rc"
+  echo "export PATH=\"$INSTALL_DIR:\$PATH\"" >> "$shell_rc"
+  info "Added to $shell_rc"
+  warn "Run: source $shell_rc"
+  
+  # On Windows, also warn about CMD/PowerShell
+  if [[ "$PLATFORM" == "windows" ]]; then
+    echo ""
+    warn "For Command Prompt or PowerShell, add this to your PATH manually:"
+    echo "  $INSTALL_DIR"
+    echo "  setx PATH \"%PATH%;$INSTALL_DIR\""
+  fi
+}
+
+verify_install() {
+  local installed_version
+  if installed_version=$("$INSTALL_DIR/$BINARY_NAME" version 2>/dev/null | tail -1); then
+    info "${installed_version}"
+    return 0
+  fi
+  error "Installation failed - JSN not working"
+}
+
+main() {
+  step "Installing JSN..."
+  
+  detect_platform
+  
+  if [[ -n "$VERSION" ]]; then
+    # Strip leading 'v' if present
+    VERSION="${VERSION#v}"
+    if [[ ! $VERSION =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+      error "Invalid version format: $VERSION (expected: 0.4.1)"
+    fi
+  else
+    VERSION=$(get_latest_version)
+  fi
+  
+  setup_install_dir
+  download_and_install "$VERSION"
+  setup_path
+  verify_install "$PLATFORM"
+  
+  echo ""
+  info "JSN installed successfully!"
+  echo ""
+  echo "  Run 'jsn' to get started (setup will run automatically on first use)"
+  echo ""
+  
+  if [[ "$PLATFORM" == "windows" ]]; then
+    warn "Windows users: Add $INSTALL_DIR to your PATH manually:"
+    echo "  setx PATH \"%PATH%;$INSTALL_DIR\""
+    echo ""
+  fi
+}
+
+main "$@"

package/scripts/npm-install.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/**
+ * JSN npm postinstall script
+ *
+ * Downloads the correct platform-specific binary from GitHub releases
+ * and places it in the `binary/` directory for the wrapper to find.
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const REPO = 'jacebenson/jsn';
+const BINARY_DIR = path.join(__dirname, '..', 'binary');
+
+const PLATFORM_MAP = {
+  darwin: 'darwin',
+  linux: 'linux',
+  win32: 'windows',
+};
+
+const ARCH_MAP = {
+  x64: 'amd64',
+  arm64: 'arm64',
+};
+
+function detectPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const mappedPlatform = PLATFORM_MAP[platform];
+  const mappedArch = ARCH_MAP[arch];
+
+  if (!mappedPlatform) {
+    throw new Error(
+      `Unsupported platform: ${platform}. ` +
+        `Supported platforms: ${Object.keys(PLATFORM_MAP).join(', ')}`
+    );
+  }
+
+  if (!mappedArch) {
+    throw new Error(
+      `Unsupported architecture: ${arch}. ` +
+        `Supported architectures: ${Object.keys(ARCH_MAP).join(', ')}`
+    );
+  }
+
+  // Windows arm64 can run amd64 binaries, so fall back
+  if (mappedPlatform === 'windows' && mappedArch === 'arm64') {
+    console.log(
+      'Warning: Windows arm64 build not available, using amd64 binary.'
+    );
+    return { platform: 'windows', arch: 'amd64', fallback: true };
+  }
+
+  return { platform: mappedPlatform, arch: mappedArch };
+}
+
+function getVersion() {
+  // npm sets this during install
+  if (process.env.npm_package_version) {
+    return process.env.npm_package_version;
+  }
+
+  // Fallback: read package.json
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  return pkg.version;
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https
+      .get(url, { timeout: 30000 }, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          // Follow redirect
+          return downloadFile(response.headers.location, dest)
+            .then(resolve)
+            .catch(reject);
+        }
+
+        if (response.statusCode !== 200) {
+          reject(
+            new Error(
+              `Download failed: HTTP ${response.statusCode} for ${url}`
+            )
+          );
+          return;
+        }
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close(resolve);
+        });
+      })
+      .on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      })
+      .on('timeout', () => {
+        fs.unlink(dest, () => {});
+        reject(new Error('Download timeout'));
+      });
+  });
+}
+
+function extractArchive(archivePath, destDir) {
+  const ext = path.extname(archivePath);
+  const isWindows = os.platform() === 'win32';
+
+  if (archivePath.endsWith('.zip')) {
+    // Use PowerShell on Windows, unzip elsewhere
+    if (isWindows) {
+      execSync(
+        `powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force"`,
+        { stdio: 'inherit' }
+      );
+    } else {
+      execSync(`unzip -q -o "${archivePath}" -d "${destDir}"`, {
+        stdio: 'inherit',
+      });
+    }
+  } else if (archivePath.endsWith('.tar.gz')) {
+    execSync(`tar -xzf "${archivePath}" -C "${destDir}"`, {
+      stdio: 'inherit',
+    });
+  } else {
+    throw new Error(`Unknown archive format: ${archivePath}`);
+  }
+}
+
+function findBinary(extractDir) {
+  const binaryName = os.platform() === 'win32' ? 'jsn.exe' : 'jsn';
+
+  // The archive contains just the binary directly
+  const directPath = path.join(extractDir, binaryName);
+  if (fs.existsSync(directPath)) {
+    return directPath;
+  }
+
+  // Sometimes archives have nested directories
+  const entries = fs.readdirSync(extractDir);
+  for (const entry of entries) {
+    const entryPath = path.join(extractDir, entry);
+    const stat = fs.statSync(entryPath);
+    if (stat.isDirectory()) {
+      const nestedPath = path.join(entryPath, binaryName);
+      if (fs.existsSync(nestedPath)) {
+        return nestedPath;
+      }
+    }
+  }
+
+  throw new Error(
+    `Could not find ${binaryName} in extracted archive. Contents: ${entries.join(', ')}`
+  );
+}
+
+async function main() {
+  // Skip if running in development (from git repo)
+  if (fs.existsSync(path.join(__dirname, '..', 'go.mod'))) {
+    console.log('Development environment detected. Skipping binary download.');
+    console.log('Build the binary manually: go build ./cmd/jsn');
+    return;
+  }
+
+  const { platform, arch } = detectPlatform();
+  const version = getVersion();
+
+  // Development placeholder version
+  if (version === '0.0.0') {
+    console.log('Warning: version is 0.0.0, skipping binary download.');
+    console.log('This is expected when installing from source.');
+    return;
+  }
+
+  const ext = platform === 'windows' ? 'zip' : 'tar.gz';
+  const filename = `jsn_v${version}_${platform}_${arch}.${ext}`;
+  const url = `https://github.com/${REPO}/releases/download/v${version}/${filename}`;
+
+  console.log(`Downloading JSN v${version} for ${platform}/${arch}...`);
+  console.log(`  ${url}`);
+
+  // Ensure binary directory exists
+  if (!fs.existsSync(BINARY_DIR)) {
+    fs.mkdirSync(BINARY_DIR, { recursive: true });
+  }
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsn-install-'));
+  const archivePath = path.join(tmpDir, filename);
+
+  try {
+    await downloadFile(url, archivePath);
+    console.log('Extracting...');
+    extractArchive(archivePath, tmpDir);
+
+    const extractedBinary = findBinary(tmpDir);
+    const binaryName = platform === 'windows' ? 'jsn.exe' : 'jsn';
+    const finalPath = path.join(BINARY_DIR, binaryName);
+
+    // Move binary to final location
+    fs.copyFileSync(extractedBinary, finalPath);
+
+    // Make executable on Unix
+    if (platform !== 'windows') {
+      fs.chmodSync(finalPath, 0o755);
+    }
+
+    console.log(`Installed JSN binary to ${finalPath}`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.error('');
+    console.error('Failed to download the JSN binary.');
+    console.error('You can still use the CLI if you have a binary installed manually.');
+    console.error('Download from: https://github.com/jacebenson/jsn/releases');
+
+    // Don't fail the npm install — the user can fix this later
+    process.exit(0);
+  } finally {
+    // Cleanup temp directory
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(`Unexpected error: ${err.message}`);
+  process.exit(0); // Don't fail npm install
+});