chrome-proc 1.0.0 → 1.0.1

package/.claude/scripts/deploy-local.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")/../.."
+
+echo "Linking local chrome-proc to global npm..."
+npm link
+
+echo ""
+echo "Verifying installation..."
+GLOBAL_BIN="$(npm prefix -g)/bin/chrome-proc"
+if [ -L "$GLOBAL_BIN" ]; then
+    TARGET="$(readlink "$GLOBAL_BIN")"
+    echo "Global binary linked: $GLOBAL_BIN -> $TARGET"
+else
+    echo "Warning: $GLOBAL_BIN is not a symlink"
+fi
+
+echo ""
+echo "Running chrome-proc --version (or help)..."
+chrome-proc --help | head -3

package/.claude/scripts/publish-npm.sh

@@ -5,28 +5,47 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
 cd "$PROJECT_DIR"
 
-echo "=== npm publish routine for chrome-proc ==="
+BUMP="${1:-patch}"
 
-# 1. Verify npm auth
-echo ""
-echo "[1/5] Checking npm authentication..."
-if ! npm whoami > /dev/null 2>&1; then
-    echo "ERROR: You are not logged into npm."
-    echo "Please run: npm login"
-    echo "Then re-run this script."
-    exit 1
+if [[ "$BUMP" != "patch" && "$BUMP" != "minor" && "$BUMP" != "major" ]]; then
+  echo "Usage: $0 [patch|minor|major]  (default: patch)"
+  exit 1
 fi
-USERNAME=$(npm whoami)
-echo "Authenticated as: $USERNAME"
 
-# 2. Build project
-echo ""
-echo "[2/5] Building project..."
+# ── Guard checks ────────────────────────────────────────────────────────────
+
+echo "==> Checking working tree is clean..."
+if ! git diff --exit-code --quiet || ! git diff --cached --exit-code --quiet; then
+  echo "ERROR: Working tree has uncommitted changes. Commit or stash them first."
+  exit 1
+fi
+
+echo "==> Checking current branch is main..."
+BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+if [[ "$BRANCH" != "main" ]]; then
+  echo "ERROR: Must be on 'main' to publish (currently on '$BRANCH')."
+  exit 1
+fi
+
+echo "==> Checking npm authentication..."
+if ! npm whoami &>/dev/null; then
+  echo "ERROR: Not logged in to npm. Run 'npm login' first."
+  exit 1
+fi
+
+# ── Bump version ────────────────────────────────────────────────────────────
+
+echo "==> Bumping $BUMP version..."
+npm version "$BUMP" --no-git-tag-version
+NEW_VERSION="$(node -p "require('./package.json').version")"
+echo "    New version: $NEW_VERSION"
+
+# ── Build ───────────────────────────────────────────────────────────────────
+
+echo "==> Building..."
 npm run build
 
-# 3. Verify artifacts
-echo ""
-echo "[3/5] Verifying build artifacts..."
+echo "==> Verifying build artifacts..."
 if [ ! -f "dist/index.js" ]; then
     echo "ERROR: dist/index.js not found. Build may have failed."
     exit 1
@@ -37,35 +56,40 @@ if [ ! -f "bin/chrome-proc" ]; then
 fi
 echo "Artifacts verified."
 
-# 4. Check if version already exists
-echo ""
-echo "[4/5] Checking if version already exists on npm..."
-VERSION=$(node -p "require('./package.json').version")
-if npm view "chrome-proc@$VERSION" version > /dev/null 2>&1; then
-    echo "ERROR: chrome-proc@$VERSION already exists on npm."
-    echo "Please bump the version in package.json before publishing."
-    exit 1
-fi
-echo "Version $VERSION is available for publish."
+# ── Publish ─────────────────────────────────────────────────────────────────
 
-# 5. Publish
-echo ""
-echo "[5/5] Publishing chrome-proc@$VERSION to npm..."
+echo "==> Publishing chrome-proc@$NEW_VERSION to npm..."
 npm publish --access public
 
-# 6. Verify
-echo ""
-echo "Verifying publish..."
-sleep 2
-PUBLISHED_VERSION=$(npm view chrome-proc version 2>/dev/null || echo "")
-if [ "$PUBLISHED_VERSION" = "$VERSION" ]; then
-    echo "SUCCESS: chrome-proc@$VERSION is now live on npm!"
-    echo ""
-    echo "You can install it with:"
-    echo "  npm install -g chrome-proc"
+# ── Commit + tag + push (after successful publish) ──────────────────────────
+
+echo "==> Committing version bump..."
+git add package.json package-lock.json
+git commit -m "$NEW_VERSION"
+
+echo "==> Generating tag description..."
+LAST_TAG="$(git describe --tags --abbrev=0 2>/dev/null || echo "")"
+if [[ -n "$LAST_TAG" ]]; then
+  COMMITS="$(git log "$LAST_TAG"..HEAD --oneline)"
+  PROMPT="Here are the commits since $LAST_TAG:
+$COMMITS
+
+Write a concise release note summary for version $NEW_VERSION suitable for an annotated git tag. Use a short paragraph or bullet points."
 else
-    echo "WARNING: Publish command succeeded but verification failed."
-    echo "Published version: $PUBLISHED_VERSION"
-    echo "Expected version: $VERSION"
-    echo "Check https://www.npmjs.com/package/chrome-proc for status."
+  PROMPT="Write a concise release note summary for version $NEW_VERSION suitable for an annotated git tag. This is the first release."
 fi
+
+TAG_MSG="$(cc-hub run -p "$PROMPT")"
+
+echo "==> Creating annotated tag v$NEW_VERSION..."
+TMPFILE="$(mktemp)"
+printf '%s\n' "$TAG_MSG" > "$TMPFILE"
+git tag -a "v$NEW_VERSION" -F "$TMPFILE"
+rm -f "$TMPFILE"
+
+echo "==> Pushing commit and tag to origin/main..."
+git push origin main
+git push origin "v$NEW_VERSION"
+
+echo ""
+echo "✓ Released chrome-proc@$NEW_VERSION"

package/CLAUDE.md

@@ -0,0 +1,10 @@
+# chrome-proc
+
+## Work Log
+
+### 2026-05-10 17:49:52 — Session: 77ad126d-67e8-4819-9ca5-21747d7fc43b
+- Designed and implemented cross-platform support for `chrome-proc` via a unified facade (`src/platform/*`) covering macOS, Linux, and Windows.
+- Key abstraction: `IPlatformProvider` / `IProcessManager` interfaces with per-platform implementations for Chrome path resolution, default data directories, process listing, and signal-based killing.
+- Refactored `process.ts` into a thin delegation layer so commands remain platform-agnostic; `launch.ts`, `localState.ts`, and `completion.ts` updated to consume the facade.
+- Added PowerShell completion generation for Windows alongside existing bash/zsh completions.
+- Built and verified on macOS; deployed locally via `npm link` so the global CLI runs the updated code.

package/README.md

@@ -1 +1,50 @@
+# chrome-proc
 
+Manage Chrome browser processes, profiles, and CDP endpoints.
+
+## Installation
+
+```bash
+npm install -g chrome-proc
+```
+
+## Usage
+
+```bash
+chrome-proc <command> [options]
+```
+
+### Commands
+
+- `list` — List Chrome processes
+  - `-v, --verbose` — Show full command line
+  - `-j, --json` — Output as JSON lines
+- `kill` — Kill Chrome processes
+  - `-f, --force` — Use SIGKILL instead of SIGTERM
+  - `-a, --all` — Kill helper processes too
+- `launch` — Launch Chrome browser
+  - `--dir <dir>` — Chrome user data directory
+  - `--profile <profile>` — Chrome profile name
+  - `-d, --debug` — Enable remote debugging mode
+  - `-p, --debugging-port <port>` — Remote debugging port
+- `profile` — Manage Chrome profiles
+  - `profile list [-j, --json]`
+  - `profile name <profile_dir> <new_name>`
+  - `profile delete <profile_dir>`
+- `cdp` — List CDP WebSocket URLs
+  - `-j, --json` — Output as JSON lines
+- `completion <shell>` — Generate shell completion script
+
+## Shell Completions
+
+Add to your shell config:
+
+**Bash** (`~/.bashrc`):
+```bash
+eval "$(chrome-proc completion bash)"
+```
+
+**Zsh** (`~/.zshrc`):
+```zsh
+eval "$(chrome-proc completion zsh)"
+```

package/dist/commands/completion.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionCommand = completionCommand;
+const platform_1 = require("../platform");
+const localState_1 = require("../utils/localState");
+function completionCommand(shell) {
+    const platform = (0, platform_1.getPlatform)();
+    const shells = platform.supportedShells();
+    if (!shells.includes(shell)) {
+        console.error(`Error: unsupported shell '${shell}'. Supported: ${shells.join(", ")}`);
+        process.exit(1);
+    }
+    console.log(platform.generateCompletion(shell, getProfileDirs()));
+}
+function getProfileDirs() {
+    try {
+        const state = (0, localState_1.readLocalState)();
+        return Object.keys(state.profile?.info_cache ?? {});
+    }
+    catch {
+        return [];
+    }
+}

package/dist/commands/launch.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchCommand = launchCommand;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const platform_1 = require("../platform");
 const process_1 = require("../utils/process");
 function launchCommand(options) {
-    const chromeBin = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+    const chromeBin = (0, platform_1.getPlatform)().getChromeExecutablePath();
     const profile = options.profile ?? process.env.CHROME_PROFILE ?? "";
     const dataDir = options.dir ?? process.env.CHROME_DATA_DIR ?? "";
     if (!(0, fs_1.existsSync)(chromeBin)) {
@@ -29,10 +30,9 @@ function launchCommand(options) {
         console.error("Warning: --debugging-port is ignored without --debug");
     }
     if ((0, process_1.isChromeRunning)()) {
-        const { execSync } = require("child_process");
-        const existing = execSync('pgrep -x "Google Chrome" | tr "\\n" " " | sed "s/ $//"', { encoding: "utf-8" }).trim();
-        if (existing) {
-            console.error(`Warning: Chrome is already running (PIDs: ${existing})`);
+        const existing = (0, process_1.getChromePids)(true);
+        if (existing.length > 0) {
+            console.error(`Warning: Chrome is already running (PIDs: ${existing.join(" ")})`);
         }
     }
     console.log("Launching Chrome...");

package/dist/index.js

@@ -7,6 +7,7 @@ const kill_1 = require("./commands/kill");
 const launch_1 = require("./commands/launch");
 const profile_1 = require("./commands/profile");
 const cdp_1 = require("./commands/cdp");
+const completion_1 = require("./commands/completion");
 const program = new commander_1.Command();
 program
     .name("chrome-proc")
@@ -66,4 +67,10 @@ program
     .action(async (options) => {
     await (0, cdp_1.cdpCommand)(options);
 });
+program
+    .command("completion <shell>")
+    .description("Generate shell completion script (bash or zsh)")
+    .action((shell) => {
+    (0, completion_1.completionCommand)(shell);
+});
 program.parse();

package/dist/platform/completion-helpers.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBashCompletion = generateBashCompletion;
+exports.generateZshCompletion = generateZshCompletion;
+exports.generatePowerShellCompletion = generatePowerShellCompletion;
+function generateBashCompletion(profileDirs) {
+    const profileDirsNewline = profileDirs.join("\n");
+    return `#!/usr/bin/env bash
+_chrome_proc() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  local commands="list kill launch profile cdp completion"
+  local profile_subcommands="list name delete"
+
+  local list_opts="--verbose --json"
+  local kill_opts="--force --all"
+  local launch_opts="--dir --profile --debug --debugging-port"
+  local profile_list_opts="--json"
+  local cdp_opts="--json"
+  local completion_shells="bash zsh powershell"
+
+  local profile_dirs='
+${profileDirsNewline}
+'
+
+  local cmd=""
+  local subcmd=""
+  local i=1
+
+  while [[ $i -lt $COMP_CWORD ]]; do
+    local word="\${COMP_WORDS[$i]}"
+    if [[ "$word" != -* ]]; then
+      if [[ -z "$cmd" ]]; then
+        cmd="$word"
+      elif [[ "$cmd" == "profile" && -z "$subcmd" ]]; then
+        subcmd="$word"
+        break
+      else
+        break
+      fi
+    fi
+    ((i++))
+  done
+
+  if [[ -z "$cmd" ]]; then
+    if [[ "$cur" == -* ]]; then
+      COMPREPLY=()
+    else
+      COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+    fi
+    return
+  fi
+
+  case "$cmd" in
+    list)
+      COMPREPLY=( $(compgen -W "$list_opts" -- "$cur") )
+      ;;
+    kill)
+      COMPREPLY=( $(compgen -W "$kill_opts" -- "$cur") )
+      ;;
+    launch)
+      COMPREPLY=( $(compgen -W "$launch_opts" -- "$cur") )
+      ;;
+    cdp)
+      COMPREPLY=( $(compgen -W "$cdp_opts" -- "$cur") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "$completion_shells" -- "$cur") )
+      ;;
+    profile)
+      if [[ -z "$subcmd" ]]; then
+        if [[ "$cur" == -* ]]; then
+          COMPREPLY=()
+        else
+          COMPREPLY=( $(compgen -W "$profile_subcommands" -- "$cur") )
+        fi
+      else
+        case "$subcmd" in
+          list)
+            COMPREPLY=( $(compgen -W "$profile_list_opts" -- "$cur") )
+            ;;
+          name|delete)
+            if [[ -n "$profile_dirs" && ( -z "$prev" || "$prev" == "name" || "$prev" == "delete" ) ]]; then
+              local OLD_IFS="$IFS"
+              IFS=$'\n'
+              COMPREPLY=( $(compgen -W "$profile_dirs" -- "$cur") )
+              IFS="$OLD_IFS"
+            else
+              COMPREPLY=()
+            fi
+            ;;
+          *)
+            COMPREPLY=()
+            ;;
+        esac
+      fi
+      ;;
+    *)
+      COMPREPLY=()
+      ;;
+  esac
+}
+
+complete -F _chrome_proc chrome-proc
+`;
+}
+function generateZshCompletion(profileDirs) {
+    const profileDirsNewline = profileDirs.join("\n");
+    return `#!/usr/bin/env zsh
+#compdef chrome-proc
+
+_chrome_proc() {
+  local curcontext="$curcontext" state line
+  typeset -A opt_args
+
+  local profile_dirs='
+${profileDirsNewline}
+'
+
+  _arguments -C \\
+    '1: :->command' \\
+    '2: :->subcommand' \\
+    '*: :->args'
+
+  case "$state" in
+    command)
+      local commands=(list kill launch profile cdp completion)
+      _describe -t commands 'chrome-proc command' commands
+      ;;
+    subcommand)
+      case "$line[1]" in
+        list)
+          local opts=('--verbose:Show full command line' '--json:Output as JSON lines')
+          _describe -t options 'list options' opts
+          ;;
+        kill)
+          local opts=('--force:Use SIGKILL instead of SIGTERM' '--all:Kill helper processes too')
+          _describe -t options 'kill options' opts
+          ;;
+        launch)
+          local opts=('--dir:Chrome user data directory' '--profile:Chrome profile name' '--debug:Enable remote debugging mode' '--debugging-port:Remote debugging port')
+          _describe -t options 'launch options' opts
+          ;;
+        cdp)
+          local opts=('--json:Output as JSON lines')
+          _describe -t options 'cdp options' opts
+          ;;
+        completion)
+          local shells=(bash zsh powershell)
+          _describe -t shells 'shell' shells
+          ;;
+        profile)
+          local subcmds=(list name delete)
+          _describe -t subcommands 'profile subcommand' subcmds
+          ;;
+      esac
+      ;;
+    args)
+      case "$line[1]" in
+        list)
+          local opts=('--verbose:Show full command line' '--json:Output as JSON lines')
+          _describe -t options 'list options' opts
+          ;;
+        kill)
+          local opts=('--force:Use SIGKILL instead of SIGTERM' '--all:Kill helper processes too')
+          _describe -t options 'kill options' opts
+          ;;
+        launch)
+          local opts=('--dir:Chrome user data directory' '--profile:Chrome profile name' '--debug:Enable remote debugging mode' '--debugging-port:Remote debugging port')
+          _describe -t options 'launch options' opts
+          ;;
+        cdp)
+          local opts=('--json:Output as JSON lines')
+          _describe -t options 'cdp options' opts
+          ;;
+        profile)
+          case "$line[2]" in
+            list)
+              local opts=('--json:Output as JSON lines')
+              _describe -t options 'profile list options' opts
+              ;;
+            name|delete)
+              if [[ -n "$profile_dirs" ]]; then
+                local dirs=(\${(f)profile_dirs})
+                _describe -t directories 'profile directory' dirs
+              fi
+              ;;
+          esac
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_chrome_proc "$@"
+`;
+}
+function generatePowerShellCompletion(profileDirs) {
+    const profileDirsQuoted = profileDirs.map((d) => `'${d.replace(/'/g, "''")}'`).join(", ");
+    return `Register-ArgumentCompleter -Native -CommandName chrome-proc -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $commands = @('list', 'kill', 'launch', 'profile', 'cdp', 'completion')
+    $profileSubcommands = @('list', 'name', 'delete')
+    $tokens = $commandAst.CommandElements | ForEach-Object { $_.Value }
+    $cmd = $tokens[1]
+    $subcmd = $tokens[2]
+
+    if (-not $cmd) {
+        $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+        return
+    }
+
+    switch ($cmd) {
+        'list' {
+            @('--verbose', '--json') | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+        }
+        'kill' {
+            @('--force', '--all') | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+        }
+        'launch' {
+            @('--dir', '--profile', '--debug', '--debugging-port') | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+        }
+        'cdp' {
+            @('--json') | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+        }
+        'completion' {
+            @('bash', 'zsh', 'powershell') | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+        }
+        'profile' {
+            if (-not $subcmd) {
+                $profileSubcommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+            } else {
+                switch ($subcmd) {
+                    'list' {
+                        @('--json') | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+                    }
+                    'name' {
+                        $profileDirs = @(${profileDirsQuoted})
+                        $profileDirs | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+                    }
+                    'delete' {
+                        $profileDirs = @(${profileDirsQuoted})
+                        $profileDirs | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { $_ }
+                    }
+                }
+            }
+        }
+    }
+}
+`;
+}

package/dist/platform/darwin.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.darwinProvider = void 0;
+const child_process_1 = require("child_process");
+const os_1 = require("os");
+const completion_helpers_1 = require("./completion-helpers");
+const CHROME_BIN = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+function getChromePids(exact = false) {
+    try {
+        const flag = exact ? "-x" : "-f";
+        const output = (0, child_process_1.execSync)(`pgrep ${flag} "Google Chrome"`, { encoding: "utf-8" });
+        return output
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim() !== "")
+            .map((line) => parseInt(line.trim(), 10))
+            .filter((pid) => !isNaN(pid));
+    }
+    catch {
+        return [];
+    }
+}
+function getProcessArgs(pid) {
+    try {
+        return (0, child_process_1.execSync)(`ps -p "${pid}" -o args=`, { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "?";
+    }
+}
+function getProcessName(pid) {
+    try {
+        return (0, child_process_1.execSync)(`ps -p "${pid}" -o comm=`, { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "?";
+    }
+}
+function killPid(pid, signal) {
+    try {
+        (0, child_process_1.execSync)(`/bin/kill -${signal} "${pid}"`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isChromeRunning() {
+    return getChromePids(true).length > 0;
+}
+const processManager = {
+    getChromePids,
+    getProcessArgs,
+    getProcessName,
+    killPid,
+    isChromeRunning,
+};
+exports.darwinProvider = {
+    name: "darwin",
+    getChromeExecutablePath() {
+        return CHROME_BIN;
+    },
+    getDefaultChromeDataDir() {
+        return `${(0, os_1.homedir)()}/Library/Application Support/Google/Chrome`;
+    },
+    getProcessManager() {
+        return processManager;
+    },
+    supportedShells() {
+        return ["bash", "zsh"];
+    },
+    generateCompletion(shell, profileDirs) {
+        switch (shell) {
+            case "bash":
+                return (0, completion_helpers_1.generateBashCompletion)(profileDirs);
+            case "zsh":
+                return (0, completion_helpers_1.generateZshCompletion)(profileDirs);
+            default:
+                throw new Error(`Unsupported shell: ${shell}`);
+        }
+    },
+};

package/dist/platform/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatform = getPlatform;
+const darwin_1 = require("./darwin");
+const linux_1 = require("./linux");
+const win32_1 = require("./win32");
+const providers = {
+    darwin: darwin_1.darwinProvider,
+    linux: linux_1.linuxProvider,
+    win32: win32_1.win32Provider,
+};
+function getPlatform() {
+    const p = providers[process.platform];
+    if (!p) {
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+    return p;
+}