Normalize bare owner/repo npm sources and detect installed bin

Fixes a confusing failure when users pass --npm owner/repo: npm treats it
as a GitHub shorthand instead of a scoped package, so no binary is
created and the install fails with "binary not found". NewNpmInstaller
now rewrites bare owner/repo strings to @owner/repo, and Install snapshots
the npm global bin dir to discover binaries with unexpected names and
report a helpful error when none are produced.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: git-hulk

internal/installer/npm.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	osexec "os/exec"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"github.com/git-hulk/clime/internal/plugin"
@@ -23,9 +24,12 @@ type NpmInstaller struct {
 }
 
 // NewNpmInstaller returns an NpmInstaller for the given npm package.
+// A bare "owner/repo" string is treated as a scoped package and rewritten to
+// "@owner/repo"; npm would otherwise resolve it as a GitHub shorthand, which
+// is rarely what callers want when they specify --npm.
 func NewNpmInstaller(pkg string) *NpmInstaller {
 	return &NpmInstaller{
-		Package:         pkg,
+		Package:         normalizeNpmPackageName(pkg),
 		runNpmInstall:   runNpmGlobalInstall,
 		runNpmUpdate:    runNpmGlobalUpdate,
 		runNpmUninstall: runNpmGlobalUninstall,
@@ -35,27 +39,43 @@ func NewNpmInstaller(pkg string) *NpmInstaller {
 	}
 }
 
+// normalizeNpmPackageName prepends "@" to bare "owner/repo" strings so npm
+// treats them as scoped registry packages rather than GitHub shorthand.
+// Inputs that are already scoped, unscoped, URLs, protocol-prefixed
+// (git+https://, github:, file:, etc.), or local paths are returned as-is.
+func normalizeNpmPackageName(pkg string) string {
+	pkg = strings.TrimSpace(pkg)
+	if pkg == "" || strings.HasPrefix(pkg, "@") {
+		return pkg
+	}
+	if strings.ContainsAny(pkg, ":\\") || strings.HasPrefix(pkg, ".") || strings.HasPrefix(pkg, "/") {
+		return pkg
+	}
+	if strings.Count(pkg, "/") == 1 {
+		return "@" + pkg
+	}
+	return pkg
+}
+
 func (n *NpmInstaller) Install(name string) (string, error) {
 	if _, err := osexec.LookPath("npm"); err != nil {
 		return "", fmt.Errorf("npm is not installed or not on PATH: %w", err)
 	}
 
+	npmBinDir, err := n.npmGlobalBinDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to determine npm global bin directory: %w", err)
+	}
+	before := snapshotDirEntries(npmBinDir)
+
 	if err := n.runNpmInstall(n.Package); err != nil {
 		return "", fmt.Errorf("npm install failed: %w", err)
 	}
 
 	binName := plugin.BinPrefix + name
-	npmBinDir, err := n.npmGlobalBinDir()
+	binaryPath, err := locateNpmInstalledBinary(npmBinDir, n.Package, name, binName, before)
 	if err != nil {
-		return "", fmt.Errorf("failed to determine npm global bin directory: %w", err)
-	}
-	binaryPath := filepath.Join(npmBinDir, binName)
-
-	if _, err := os.Stat(binaryPath); err != nil {
-		binaryPath = filepath.Join(npmBinDir, name)
-		if _, err := os.Stat(binaryPath); err != nil {
-			return "", fmt.Errorf("binary %q or %q not found in npm global bin dir %q after install: %w", binName, name, npmBinDir, err)
-		}
+		return "", err
 	}
 
 	installDir, err := n.pluginBinDir()
@@ -164,6 +184,56 @@ func npmGlobalBinDir() (string, error) {
 	return filepath.Join(strings.TrimSpace(string(out)), "bin"), nil
 }
 
+// snapshotDirEntries returns the set of entry names directly under dir, or an
+// empty set if the directory cannot be read.
+func snapshotDirEntries(dir string) map[string]struct{} {
+	set := make(map[string]struct{})
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return set
+	}
+	for _, e := range entries {
+		set[e.Name()] = struct{}{}
+	}
+	return set
+}
+
+// locateNpmInstalledBinary picks the binary that an npm install created.
+// It prefers clime-<name>, then <name>, then falls back to a single new entry
+// added to npmBinDir during the install. The error explains why no candidate
+// was found, including any unexpected new entries.
+func locateNpmInstalledBinary(npmBinDir, pkg, name, binName string, before map[string]struct{}) (string, error) {
+	if path := filepath.Join(npmBinDir, binName); fileExists(path) {
+		return path, nil
+	}
+	if path := filepath.Join(npmBinDir, name); fileExists(path) {
+		return path, nil
+	}
+
+	after := snapshotDirEntries(npmBinDir)
+	var added []string
+	for entry := range after {
+		if _, existed := before[entry]; !existed {
+			added = append(added, entry)
+		}
+	}
+	sort.Strings(added)
+
+	switch len(added) {
+	case 0:
+		return "", fmt.Errorf("npm install of %q did not create a binary in %q; the package may not provide a CLI (check that the package name is correct, e.g. a scoped package starting with \"@\")", pkg, npmBinDir)
+	case 1:
+		return filepath.Join(npmBinDir, added[0]), nil
+	default:
+		return "", fmt.Errorf("npm install of %q created multiple binaries in %q (%s); none matched %q or %q — rerun with a plugin name matching one of them", pkg, npmBinDir, strings.Join(added, ", "), binName, name)
+	}
+}
+
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
 // getNpmInstalledVersion returns the actual installed version of an npm package.
 func getNpmInstalledVersion(pkg string) (string, error) {
 	out, err := osexec.Command("npm", "list", "-g", pkg, "--json").Output()

internal/installer/npm_test.go

@@ -1,7 +1,9 @@
 package installer
 
 import (
+	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/git-hulk/clime/internal/plugin"
@@ -84,6 +86,131 @@ func TestNpmInstallerUpdateUpToDate(t *testing.T) {
 	}
 }
 
+func TestLocateNpmInstalledBinaryPrefersClimePrefix(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	mustTouch(t, filepath.Join(dir, "clime-deploy"))
+	mustTouch(t, filepath.Join(dir, "deploy"))
+
+	path, err := locateNpmInstalledBinary(dir, "@myorg/clime-deploy", "deploy", "clime-deploy", map[string]struct{}{})
+	if err != nil {
+		t.Fatalf("locateNpmInstalledBinary() error = %v", err)
+	}
+	if want := filepath.Join(dir, "clime-deploy"); path != want {
+		t.Fatalf("path = %q, want %q", path, want)
+	}
+}
+
+func TestLocateNpmInstalledBinaryFallsBackToName(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	mustTouch(t, filepath.Join(dir, "codex"))
+
+	path, err := locateNpmInstalledBinary(dir, "@openai/codex", "codex", "clime-codex", map[string]struct{}{})
+	if err != nil {
+		t.Fatalf("locateNpmInstalledBinary() error = %v", err)
+	}
+	if want := filepath.Join(dir, "codex"); path != want {
+		t.Fatalf("path = %q, want %q", path, want)
+	}
+}
+
+func TestLocateNpmInstalledBinaryDiscoversNewBinary(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	mustTouch(t, filepath.Join(dir, "existing"))
+	before := snapshotDirEntries(dir)
+	mustTouch(t, filepath.Join(dir, "weirdname"))
+
+	path, err := locateNpmInstalledBinary(dir, "some-package", "tool", "clime-tool", before)
+	if err != nil {
+		t.Fatalf("locateNpmInstalledBinary() error = %v", err)
+	}
+	if want := filepath.Join(dir, "weirdname"); path != want {
+		t.Fatalf("path = %q, want %q", path, want)
+	}
+}
+
+func TestLocateNpmInstalledBinaryErrorsWhenNoBinaryCreated(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	mustTouch(t, filepath.Join(dir, "preexisting"))
+	before := snapshotDirEntries(dir)
+
+	_, err := locateNpmInstalledBinary(dir, "openai/codex", "codex", "clime-codex", before)
+	if err == nil {
+		t.Fatal("expected error when npm install produced no new binary")
+	}
+	if !strings.Contains(err.Error(), "did not create a binary") {
+		t.Fatalf("error = %q, want it to mention missing binary", err)
+	}
+	if !strings.Contains(err.Error(), "openai/codex") {
+		t.Fatalf("error = %q, want it to reference the package", err)
+	}
+}
+
+func TestLocateNpmInstalledBinaryErrorsOnAmbiguousNewBinaries(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	before := snapshotDirEntries(dir)
+	mustTouch(t, filepath.Join(dir, "tsc"))
+	mustTouch(t, filepath.Join(dir, "tsserver"))
+
+	_, err := locateNpmInstalledBinary(dir, "typescript", "ts", "clime-ts", before)
+	if err == nil {
+		t.Fatal("expected error when multiple new binaries match nothing")
+	}
+	if !strings.Contains(err.Error(), "tsc") || !strings.Contains(err.Error(), "tsserver") {
+		t.Fatalf("error = %q, want it to list both binaries", err)
+	}
+}
+
+func TestNormalizeNpmPackageName(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		in   string
+		want string
+	}{
+		{"openai/codex", "@openai/codex"},
+		{"  openai/codex  ", "@openai/codex"},
+		{"@openai/codex", "@openai/codex"},
+		{"@openai/codex@1.0.0", "@openai/codex@1.0.0"},
+		{"lodash", "lodash"},
+		{"lodash@4.17.0", "lodash@4.17.0"},
+		{"git+https://github.com/openai/codex.git", "git+https://github.com/openai/codex.git"},
+		{"github:openai/codex", "github:openai/codex"},
+		{"file:./local", "file:./local"},
+		{"./local-package", "./local-package"},
+		{"/abs/path/pkg", "/abs/path/pkg"},
+		{"", ""},
+	}
+	for _, c := range cases {
+		got := normalizeNpmPackageName(c.in)
+		if got != c.want {
+			t.Errorf("normalizeNpmPackageName(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestNewNpmInstallerNormalizesPackage(t *testing.T) {
+	t.Parallel()
+	n := NewNpmInstaller("openai/codex")
+	if n.Package != "@openai/codex" {
+		t.Fatalf("Package = %q, want %q", n.Package, "@openai/codex")
+	}
+}
+
+func mustTouch(t *testing.T, path string) {
+	t.Helper()
+	f, err := os.Create(path)
+	if err != nil {
+		t.Fatalf("create %s: %v", path, err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatalf("close %s: %v", path, err)
+	}
+}
+
 func TestNpmInstallerPluginType(t *testing.T) {
 	t.Parallel()
 	n := NewNpmInstaller("@myorg/clime-deploy")