arashi 1.23.0 → 1.24.1

package/README.md

@@ -41,7 +41,17 @@ It also runs a quick `arashi --version` smoke test before declaring success.
 
 If curl installation fails, or if the smoke test reports a bad release artifact, use npm installation below or the manual release instructions in [`docs/INSTALLATION.md`](./docs/INSTALLATION.md).
 
-### Option 2: Install with npm
+### Option 2: Install on Windows with PowerShell
+
+PowerShell is the canonical Windows installer:
+
+```powershell
+powershell -c "irm https://arashi.haphazard.dev/install.ps1 | iex"
+```
+
+It verifies and installs `arashi.bin.exe`, the extensionless `arashi` wrapper for Git Bash, `arashi.ps1`, and `arashi.bat` from the same release. The default directory is `%USERPROFILE%\.arashi\bin`; the installer adds it to the persistent user PATH. It does not create or modify `.bashrc` or another shell profile. Open a new Git Bash window before running `arashi --version` so it inherits the PATH change.
+
+### Option 3: Install with npm
 
 ```bash
 npm install -g arashi
@@ -93,13 +103,17 @@ chmod +x arashi
 sudo mv arashi /usr/local/bin/arashi
 ```
 
-Windows (PowerShell):
+Windows (PowerShell and Git Bash):
 
 ```powershell
-Invoke-WebRequest -Uri "https://github.com/corwinm/arashi/releases/latest/download/arashi-windows-x64.exe" -OutFile "arashi.exe"
-# Move arashi.exe to a folder on your PATH
+# Download arashi-windows-x64.exe, arashi, arashi.ps1, arashi.bat,
+# and arashi-checksums.txt from the same release.
+# Verify all four payload files against arashi-checksums.txt.
+# Rename arashi-windows-x64.exe to arashi.bin.exe and keep the four files together on PATH.
 ```
 
+Windows manual installation requires `arashi-windows-x64.exe`, `arashi`, `arashi.ps1`, `arashi.bat`, and `arashi-checksums.txt` from the same release. Verify all four payload files, rename the executable to `arashi.bin.exe`, and keep the payload together on PATH.
+
 You can also build from source for local development:
 
 ```bash
@@ -117,12 +131,12 @@ Arashi currently provides these commands:
 - `arashi update [--check] [--dry-run] [--yes]`
 - `arashi add <git-url>`
 - `arashi clone [--all]`
-- `arashi create <branch> [--tmux|--sesh|--herdr]`
+- `arashi create <branch> [--tab] [--tmux|--sesh|--herdr]`
 - `arashi list`
 - `arashi status`
 - `arashi remove <branch|path>`
 - `arashi prune [--dry-run]` - clean stale Git worktree metadata
-- `arashi switch [filter] [--repos|--all] [--cd|--no-cd] [--tmux|--sesh|--herdr] [--no-default-launch]`
+- `arashi switch [filter] [--repos|--all] [--tab] [--cd|--no-cd] [--tmux|--sesh|--herdr] [--no-default-launch]`
 - `arashi shell init <bash|zsh|fish>`
 - `arashi shell install`
 - `arashi pull`
@@ -141,6 +155,7 @@ arashi create feature-auth-refresh
 arashi create feature-auth-refresh --launch
 arashi create feature-auth-refresh --tmux
 arashi create feature-auth-refresh --herdr
+arashi create feature-auth-refresh --tab
 arashi create feature-auth-refresh --no-launch
 arashi shell install
 arashi status
@@ -151,11 +166,14 @@ arashi switch --repos docs                  # repo-name matching in child repos
 arashi switch --cd feature-auth-refresh     # parent-shell cd when shell integration is active
 arashi switch --tmux feature-auth-refresh   # force a new plain tmux window
 arashi switch --herdr feature-auth-refresh  # open or focus a persistent Herdr workspace
+arashi switch --tab feature-auth-refresh    # request a true tab or managed equivalent
 arashi switch --no-default-launch           # bypass configured sesh/Herdr mode once
 ```
 
 Explicit `--tmux` is a per-invocation launcher override for `create` and `switch`; it is not a persisted configuration mode. It requires an active tmux context whose `TMUX` value is non-empty after trimming, uses the selected worktree path as one argv-safe `tmux new-window -c` argument, and does not fall back to another launcher when the prerequisite or launch fails. On `create`, it implies both launch and switch, while validation failures occur before worktree mutation.
 
+`--tab` is a CLI-only launch disposition for `create` and `switch`; it is never persisted. It requests a true terminal tab or documented managed-context equivalent, implies launch (and selection for `create`), overrides automatic parent-shell `cd`, and never degrades to a window or another launcher. Unsupported adapters fail with `TAB_DISPOSITION_UNSUPPORTED`; launch/preflight failures use `LAUNCH_FAILED`. Human-only tab launch is incompatible with `--json`.
+
 ### Managed Git ignore rules
 
 Configured workspaces keep `reposDir` and `worktreesDir` effectively ignored. Arashi asks Git
@@ -272,7 +290,7 @@ bindkey -s '^s' 'sesh connect $(arashi list | fzf)\n'
 
 You can also use `arashi switch --sesh` directly inside tmux to open the selected worktree in a new tmux window.
 
-`arashi switch` checks managed contexts in this order: tmux → Herdr → cmux → integrated IDE → Kitty. Managed Kitty selection requires both `KITTY_PID` and `KITTY_WINDOW_ID`; `TERM=xterm-kitty` alone remains only generic terminal evidence.
+`arashi switch` checks managed contexts in this order: tmux → Herdr → cmux → integrated IDE → Kitty. Managed Kitty selection applies when any one of `KITTY_PID`, `KITTY_WINDOW_ID`, or `TERM=xterm-kitty` is present after normalization.
 
 Managed Kitty requires Kitty 0.43 or newer plus working `kitten @` remote control. Arashi reuses only its exact worktree marker and focuses that tab before launching a new session-backed tab. Once managed Kitty is selected, missing or unsupported tooling, denied remote control, duplicate markers, and validation failures are reported directly instead of falling back to another launcher.
 

package/bin/arashi

@@ -14,23 +14,36 @@ done
 SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_SOURCE")" && pwd)"
 BINARY="$SCRIPT_DIR/arashi.bin"
 
-# Use platform-specific binary if main binary doesn't exist
+# Use the Windows binary only with explicit Git-for-Windows/MSYS/Cygwin evidence.
+# arashi.bin always retains precedence when both binaries are present.
 if [ ! -f "$BINARY" ]; then
   PLATFORM=$(uname -s | tr '[:upper:]' '[:lower:]')
   ARCH=$(uname -m)
-  
-  case "$PLATFORM-$ARCH" in
-    darwin-arm64)
-      BINARY="$SCRIPT_DIR/arashi-macos-arm64"
-      ;;
-    linux-x86_64)
-      BINARY="$SCRIPT_DIR/arashi-linux-x64"
-      ;;
-    *)
-      echo "Error: Unsupported platform $PLATFORM-$ARCH" >&2
-      exit 1
-      ;;
+  WINDOWS_SHELL="false"
+
+  case "${MSYSTEM:-}" in
+    MINGW*|MSYS*) WINDOWS_SHELL="true" ;;
   esac
+  case "$PLATFORM" in
+    mingw*|msys*|cygwin*) WINDOWS_SHELL="true" ;;
+  esac
+
+  if [ "$WINDOWS_SHELL" = "true" ]; then
+    BINARY="$SCRIPT_DIR/arashi.bin.exe"
+  else
+    case "$PLATFORM-$ARCH" in
+      darwin-arm64)
+        BINARY="$SCRIPT_DIR/arashi-macos-arm64"
+        ;;
+      linux-x86_64)
+        BINARY="$SCRIPT_DIR/arashi-linux-x64"
+        ;;
+      *)
+        echo "Error: Unsupported platform $PLATFORM-$ARCH" >&2
+        exit 1
+        ;;
+    esac
+  fi
 fi
 
 if [ ! -f "$BINARY" ]; then
@@ -49,7 +62,11 @@ for arg in "$@"; do
       esac
       continue
       ;;
-    *) command="$arg"; break ;;
+    *)
+      if [ -z "$command" ]; then
+        command="$arg"
+      fi
+      ;;
   esac
 done
 

package/bin/prepare-spawn-command.js

@@ -0,0 +1,44 @@
+const WINDOWS_BATCH_FILE = /\.(?:cmd|bat)$/i;
+const CMD_ARGUMENT_VARIABLE_PREFIX = "ARASHI_CMD_ARGUMENT_";
+
+// Quote according to CommandLineToArgvW's rules. The result is stored in an
+// environment variable and introduced with ordinary expansion. Cmd expands each
+// fixed %VARIABLE% token once, but does not rescan user-controlled contents as
+// command syntax. Delayed expansion stays disabled so literal ! characters survive.
+const quoteWindowsArgument = (argument) =>
+  `"${argument.replaceAll(/(\\*)"/g, String.raw`$1$1\"`).replace(/(\\*)$/, "$1$1")}"`;
+
+export function prepareSpawnCommand(
+  command,
+  platform = process.platform,
+  env = process.env,
+  forceWindowsShell = false,
+) {
+  const executable = command[0];
+  if (
+    platform !== "win32" ||
+    (!forceWindowsShell && !WINDOWS_BATCH_FILE.test(executable))
+  ) {
+    return { args: command.slice(1), command: executable, windowsVerbatimArguments: false };
+  }
+
+  const values = command.map((argument) => quoteWindowsArgument(argument));
+  const variableNames = values.map((_value, index) => `${CMD_ARGUMENT_VARIABLE_PREFIX}${index}`);
+
+  const commandInterpreter =
+    Object.entries(env).find(([key]) => key.toLowerCase() === "comspec")?.[1] ?? "cmd.exe";
+
+  return {
+    args: ["/d", "/v:off", "/s", "/c", `"${variableNames.map((name) => `%${name}%`).join(" ")}"`],
+    command: commandInterpreter,
+    env: {
+      ...Object.fromEntries(
+        Object.entries(env).filter(
+          ([name]) => !name.toUpperCase().startsWith(CMD_ARGUMENT_VARIABLE_PREFIX),
+        ),
+      ),
+      ...Object.fromEntries(variableNames.map((name, index) => [name, values[index]])),
+    },
+    windowsVerbatimArguments: true,
+  };
+}

package/bin/update.js

@@ -1,9 +1,10 @@
 import { spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { getPlatformInfo, installBinary, MANUAL_INSTALL_URL, PACKAGE_NAME } from "./install-binary.js";
+import { prepareSpawnCommand } from "./prepare-spawn-command.js";
 
 export const UPDATE_COMMAND_DESCRIPTION = "Check for and apply Arashi updates";
 
@@ -97,15 +98,84 @@ export async function fetchLatestGitHubRelease({ fetchImpl = fetch, repo = "corw
   };
 }
 
+function normalizeInstallPath(value) {
+  return String(value ?? "")
+    .trim()
+    .replaceAll("\\", "/")
+    .replace(/\/+$/, "")
+    .toLowerCase();
+}
+
+function readEnvironmentValue(env, name) {
+  return Object.entries(env).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1] ?? "";
+}
+
+function readEnvironmentPath(env, name) {
+  return normalizeInstallPath(readEnvironmentValue(env, name));
+}
+
+function detectPackageManagerFromInstallRoot(rootDir, env) {
+  const root = normalizeInstallPath(rootDir);
+  if (!root) return null;
+
+  const userProfile = readEnvironmentPath(env, "USERPROFILE");
+  const home = userProfile || readEnvironmentPath(env, "HOME");
+  const appData =
+    readEnvironmentPath(env, "APPDATA") ||
+    (userProfile ? `${userProfile}/appdata/roaming` : "");
+  const localAppData =
+    readEnvironmentPath(env, "LOCALAPPDATA") ||
+    (userProfile ? `${userProfile}/appdata/local` : "");
+
+  if (home && root === `${home}/.vite-plus/packages/${PACKAGE_NAME}/current/package`) {
+    return "vite-plus";
+  }
+  if (appData && root === `${appData}/npm/node_modules/${PACKAGE_NAME}`) return "npm";
+  if (localAppData && root === `${localAppData}/yarn/data/global/node_modules/${PACKAGE_NAME}`) {
+    return "yarn";
+  }
+  if (userProfile && root === `${userProfile}/.bun/install/global/node_modules/${PACKAGE_NAME}`) {
+    return "bun";
+  }
+
+  const pnpmHomes = new Set(
+    [localAppData ? `${localAppData}/pnpm` : "", readEnvironmentPath(env, "PNPM_HOME")].filter(Boolean),
+  );
+  for (const pnpmHome of pnpmHomes) {
+    const relativeRoot = root.startsWith(`${pnpmHome}/`) ? root.slice(pnpmHome.length + 1) : "";
+    if (
+      /^global\/[^/]+\/(?:\.pnpm\/[^/]+\/node_modules|node_modules)\/arashi$/.test(relativeRoot)
+    ) {
+      return "pnpm";
+    }
+  }
+
+  return null;
+}
+
 export function selectPackageManagerCommand({ env = process.env, rootDir } = {}) {
-  const userAgent = env.npm_config_user_agent ?? "";
-  const execPath = env.npm_execpath ?? "";
+  const installRootManager = detectPackageManagerFromInstallRoot(rootDir, env);
+  if (installRootManager === "vite-plus") {
+    return { args: ["update", "-g", PACKAGE_NAME], command: "vp", label: "Vite+" };
+  }
+  if (installRootManager === "pnpm") {
+    return { args: ["add", "-g", `${PACKAGE_NAME}@latest`], command: "pnpm", label: "pnpm" };
+  }
+  if (installRootManager === "yarn") {
+    return { args: ["global", "add", `${PACKAGE_NAME}@latest`], command: "yarn", label: "yarn" };
+  }
+  if (installRootManager === "bun") {
+    return { args: ["add", "-g", `${PACKAGE_NAME}@latest`], command: "bun", label: "bun" };
+  }
+  if (installRootManager === "npm") {
+    return { args: ["install", "-g", `${PACKAGE_NAME}@latest`], command: "npm", label: "npm" };
+  }
+
+  const userAgent = readEnvironmentValue(env, "npm_config_user_agent");
+  const execPath = readEnvironmentValue(env, "npm_execpath");
   const combined = `${userAgent} ${execPath}`.toLowerCase();
-  const normalizedRootDir = String(rootDir ?? "").toLowerCase();
   const looksLikeVitePlus =
-    combined.includes("vite-plus") ||
-    /(^|[\\/\s])vp(?:\.exe)?($|[\\/\s])/.test(combined) ||
-    /(^|[\\/])\.vite-plus([\\/]|$)/.test(normalizedRootDir);
+    combined.includes("vite-plus") || /(^|[\\/\s])vp(?:\.exe)?($|[\\/\s])/.test(combined);
 
   if (looksLikeVitePlus) {
     return { args: ["update", "-g", PACKAGE_NAME], command: "vp", label: "Vite+" };
@@ -212,7 +282,8 @@ export async function runNpmManagedUpdate(argv = [], options = {}) {
     return 0;
   }
 
-  const packageManager = options.packageManager ?? selectPackageManagerCommand(options);
+  const packageManager =
+    options.packageManager ?? selectPackageManagerCommand({ ...options, rootDir });
   log(`Update available: ${PACKAGE_NAME} v${metadata.version} -> v${latestVersion}`);
 
   if (flags.check) {
@@ -240,10 +311,21 @@ export async function runNpmManagedUpdate(argv = [], options = {}) {
   }
 
   const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
-  const result = spawnSyncImpl(packageManager.command, packageManager.args, {
-    cwd: rootDir,
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const updateCwd = options.updateCwd ?? dirname(process.execPath);
+  const invocation = prepareSpawnCommand(
+    [packageManager.command, ...packageManager.args],
+    platform,
+    env,
+    true,
+  );
+  const result = spawnSyncImpl(invocation.command, invocation.args, {
+    cwd: updateCwd,
     encoding: "utf8",
+    env: invocation.env ?? env,
     stdio: "inherit",
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
   });
 
   if (result.error) {
@@ -256,20 +338,39 @@ export async function runNpmManagedUpdate(argv = [], options = {}) {
     return 1;
   }
 
-  let updatedMetadata = metadata;
   try {
-    updatedMetadata = await readPackageMetadata(rootDir, options);
-  } catch {
-    updatedMetadata = { ...metadata, version: latestVersion };
-  }
+    let activeRootDir = rootDir;
+    if (packageManager.command === "pnpm") {
+      const rootInvocation = prepareSpawnCommand([packageManager.command, "root", "-g"], platform, env, true);
+      const rootResult = spawnSyncImpl(rootInvocation.command, rootInvocation.args, {
+        cwd: updateCwd,
+        encoding: "utf8",
+        env: rootInvocation.env ?? env,
+        windowsVerbatimArguments: rootInvocation.windowsVerbatimArguments,
+      });
+      if (rootResult.error) throw rootResult.error;
+      if (rootResult.status !== 0) {
+        throw new Error(`pnpm root -g failed with exit code ${rootResult.status ?? "unknown"}`);
+      }
+      const globalRoot = String(rootResult.stdout ?? "").trim();
+      if (!globalRoot) throw new Error("pnpm root -g returned an empty path");
+      const separator = platform === "win32" ? "\\" : "/";
+      activeRootDir = `${globalRoot.replace(/[\\/]+$/, "")}${separator}${PACKAGE_NAME}`;
+    }
+
+    let updatedMetadata = metadata;
+    try {
+      updatedMetadata = await readPackageMetadata(activeRootDir, options);
+    } catch {
+      updatedMetadata = { ...metadata, version: latestVersion };
+    }
 
-  try {
     const installBinaryImpl = options.installBinaryImpl ?? installBinary;
     const installResult = await installBinaryImpl({
       ...options,
       binDir: options.binDir,
       force: true,
-      rootDir,
+      rootDir: activeRootDir,
       version: updatedMetadata.version,
     });
     log(`✓ Updated ${PACKAGE_NAME} from v${metadata.version} to v${updatedMetadata.version}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arashi",
-  "version": "1.23.0",
+  "version": "1.24.1",
   "description": "Git worktree manager for meta-repositories - The eye of the storm for your development workflow",
   "keywords": [
     "cli",
@@ -30,6 +30,7 @@
     "bin/arashi",
     "bin/arashi.js",
     "bin/install-binary.js",
+    "bin/prepare-spawn-command.js",
     "bin/update.js",
     "bin/arashi.bat",
     "bin/arashi.ps1",