claude-multiacc 2.0.31 → 2.0.33

package/tests/test_shim_path.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""lib/shim_path.py — does a fresh login shell reach the shim?
+
+Everything runs against a temp HOME whose rc files this test writes, with a fake shim
+(`repo/bin/claude`, carrying the multiacc-shim header) and a fake real binary in
+`~/.local/bin`. Real shells are started (zsh/bash/sh, whichever are installed), the
+way a terminal or a `bash -lc` launcher starts them; nothing touches the operator's
+rc files, and nothing here needs a Claude Code install.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO / 'lib'))
+
+import shim_path  # noqa: E402
+
+MARK_BEGIN = '# >>> claude-multiacc >>>'
+MARK_END = '# <<< claude-multiacc <<<'
+
+
+def installed_block(repo_dir):
+    """The exact block lib/install_actions.sh writes for repo_dir."""
+    env = {**os.environ, 'REPO_DIR': str(repo_dir), 'MARK_BEGIN': MARK_BEGIN, 'MARK_END': MARK_END}
+    return subprocess.check_output(
+        ['bash', '-c', f'. "{REPO}/lib/install_actions.sh"; rc_block'], env=env, text=True)
+
+
+def legacy_block(repo_dir):
+    """The block as every install before the prompt hook wrote it."""
+    lines = installed_block(repo_dir).splitlines()
+    return '\n'.join(lines[:3] + [MARK_END]) + '\n'
+
+
+class ShimPathTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp(prefix='multiacc-shim-path-'))
+        self.addCleanup(shutil.rmtree, self.tmp, True)
+        self.home = self.tmp / 'home'
+        self.repo = self.tmp / 'repo'
+        (self.home / '.local' / 'bin').mkdir(parents=True)
+        (self.repo / 'bin').mkdir(parents=True)
+        for name in shim_path.NAMES:
+            shim = self.repo / 'bin' / name
+            shim.write_text('#!/bin/sh\n# claude-multiacc-shim (fake for tests)\necho SHIM\n')
+            shim.chmod(0o755)
+            real = self.home / '.local' / 'bin' / name
+            real.write_text('#!/bin/sh\necho REAL\n')
+            real.chmod(0o755)
+        self.shells = [s for s in ('zsh', 'bash', 'sh') if shim_path.shell_path(s)]
+        self.assertTrue(self.shells, 'no shell to test with')
+        os.environ.pop('CLAUDE_MULTIACC_PATH_PROBE', None)
+
+    def write(self, name, *parts):
+        (self.home / name).write_text(''.join(parts))
+
+    def probe(self):
+        return shim_path.probe(str(self.repo), home=str(self.home), user='tester', timeout=40)
+
+    def by_mode(self, rows):
+        return {row['mode']: row for row in rows}
+
+    def all_modes(self, rows, name, expect_ok):
+        for row in rows:
+            if row['error'] == 'shell not installed':
+                continue
+            with self.subTest(mode=row['mode'], name=name):
+                self.assertIsNone(row['error'], row)
+                self.assertIs(row['results'][name]['ok'], expect_ok, row)
+
+    def test_no_rc_files_means_this_repo_is_never_reached(self):
+        # The SYSTEM rc files still run (macOS path_helper adds /opt/homebrew/bin; a Linux
+        # root install's /etc/profile.d puts ITS shim first), so a real binary — or another
+        # install's shim — may be found. What must never be found is this repo's shim.
+        rows = self.probe()
+        for row in rows:
+            if row['error'] == 'shell not installed':
+                continue
+            self.assertIsNone(row['error'], row)
+            for name in shim_path.NAMES:
+                self.assertNotEqual(row['results'][name]['resolved'], str(self.repo / 'bin' / name))
+        text = '\n'.join(shim_path.render(rows))
+        if shim_path.bypassed(rows):
+            self.assertRegex(text, r'NOT ON PATH|BYPASSED')
+            self.assertIn('claude-multiacc install', text)
+
+    def test_installed_block_wins_in_every_shell(self):
+        block = installed_block(self.repo)
+        prepend = 'export PATH="$HOME/.local/bin:$PATH"\n'
+        self.write('.zshenv', block)
+        self.write('.zprofile', prepend, block)
+        self.write('.zshrc', prepend, block)
+        self.write('.profile', prepend, block)
+        self.write('.bashrc', prepend, block)
+        rows = self.probe()
+        for name in shim_path.NAMES:
+            self.all_modes(rows, name, True)
+        self.assertEqual(shim_path.bypassed(rows), [])
+        text = '\n'.join(shim_path.render(rows))
+        self.assertNotIn('BYPASSED', text)
+        self.assertIn('claude: OK', text)
+
+    def test_real_binary_prepended_after_the_block_is_reported(self):
+        block = installed_block(self.repo)
+        late = 'export PATH="$HOME/.local/bin:$PATH"\n'
+        self.write('.zshenv', block, late)
+        self.write('.zprofile', block, late)
+        self.write('.zshrc', block, late)
+        self.write('.profile', block, late)
+        rows = self.probe()
+        real = str(self.home / '.local' / 'bin' / 'claude')
+        # Non-interactive login shells see rc order alone: bypassed.
+        for mode, row in self.by_mode(rows).items():
+            if row['error'] == 'shell not installed':
+                continue
+            if mode.endswith('-lc'):
+                self.assertEqual(row['results']['claude']['resolved'], real, row)
+                self.assertFalse(row['results']['claude']['ok'])
+            else:
+                # Interactive shells reach a prompt: the hook puts the shim back first.
+                self.assertTrue(row['results']['claude']['ok'], row)
+        bad = shim_path.bypassed(rows)
+        self.assertTrue(bad)
+        self.assertTrue(all(mode.endswith('-lc') for mode, _n, _r in bad), bad)
+        text = '\n'.join(shim_path.render(rows))
+        self.assertIn(f'BYPASSED -> {real}', text)
+        self.assertIn('OUTSIDE the pool', text)
+
+    @unittest.skipUnless(shim_path.shell_path('zsh'), 'zsh required')
+    def test_interrupted_zshrc_is_the_incident_and_the_hook_fixes_it(self):
+        """my-mini 2026-09-17: ~/.zshrc stopped (Ctrl-C at the conda hook) before the
+        multiacc block, ~/.local/bin stayed in front, `claude` at that prompt ran the
+        real binary. With the legacy block the probe must SEE that; with the hooked
+        block the prompt must hand `claude` to the shim again."""
+        prepend = 'export PATH="$HOME/.local/bin:$PATH"\n'
+        for block, expect_ok in ((legacy_block(self.repo), False), (installed_block(self.repo), True)):
+            self.write('.zshenv', block)
+            self.write('.zprofile', prepend, block)
+            self.write('.zshrc', prepend, 'return 0  # interrupted before the block\n', block)
+            rows = self.by_mode(self.probe())
+            with self.subTest(hooked=expect_ok):
+                self.assertIs(rows['zsh -li']['results']['claude']['ok'], expect_ok, rows['zsh -li'])
+                # `zsh -lc` never reads ~/.zshrc, so it is fine either way.
+                self.assertTrue(rows['zsh -lc']['results']['claude']['ok'], rows['zsh -lc'])
+
+    def test_a_symlink_to_the_shim_counts_as_the_shim(self):
+        link_dir = self.tmp / 'usr-local-bin'
+        link_dir.mkdir()
+        os.symlink(self.repo / 'bin' / 'claude', link_dir / 'claude')
+        self.assertTrue(shim_path.is_shim(str(link_dir / 'claude'), str(self.repo), 'claude'))
+        copy = self.tmp / 'copy'
+        copy.write_text('#!/bin/sh\n# claude-multiacc-shim copied elsewhere\n')
+        self.assertTrue(shim_path.is_shim(str(copy), str(self.repo), 'claude'))
+        self.assertFalse(shim_path.is_shim(str(self.home / '.local' / 'bin' / 'claude'),
+                                           str(self.repo), 'claude'))
+        self.assertFalse(shim_path.is_shim(None, str(self.repo), 'claude'))
+        self.assertFalse(shim_path.is_shim(str(self.tmp / 'missing'), str(self.repo), 'claude'))
+
+    def test_rc_file_that_hangs_or_exits_is_an_error_not_a_verdict(self):
+        self.write('.profile', 'exit 3\n')
+        self.write('.zprofile', 'exit 3\n')
+        self.write('.zshrc', 'exit 3\n')
+        rows = self.by_mode(self.probe())
+        for mode in ('bash -lc', 'sh -lc', 'zsh -lc'):
+            if mode in rows and rows[mode]['error'] != 'shell not installed':
+                self.assertIn('without answering', rows[mode]['error'], rows[mode])
+                self.assertEqual(rows[mode]['results'], {})
+        self.write('.profile', 'sleep 30\n')
+        row = shim_path._run_mode('bash', '-lc', False, shim_path.NAMES, str(self.repo),
+                                  str(self.home), 'tester', timeout=1)
+        if row['error'] != 'shell not installed':
+            self.assertIn('no answer within 1s', row['error'])
+        text = '\n'.join(shim_path.render([row]))
+        self.assertIn('could not be probed', text)
+
+    def test_kill_switch_and_cli_exit_codes(self):
+        os.environ['CLAUDE_MULTIACC_PATH_PROBE'] = '0'
+        try:
+            self.assertEqual(self.probe(), [])
+            self.assertIn('probe disabled', '\n'.join(shim_path.render([])))
+        finally:
+            del os.environ['CLAUDE_MULTIACC_PATH_PROBE']
+        env = {**os.environ, 'HOME': str(self.home), 'USER': 'tester'}
+        env.pop('CLAUDE_MULTIACC_PATH_PROBE', None)
+        cli = [sys.executable, str(REPO / 'lib' / 'shim_path.py')]
+        self.assertEqual(subprocess.run(cli, env=env, capture_output=True).returncode, 2)
+        self.assertEqual(subprocess.run(cli + [str(self.repo), '--timeout=x'], env=env,
+                                        capture_output=True).returncode, 2)
+        # nothing in HOME -> this repo's shim is not reached -> 1 (unless a system-wide
+        # rc file on this host puts some other install's shim first, see above)
+        r = subprocess.run(cli + [str(self.repo), '--json'], env=env, capture_output=True, text=True)
+        import json
+        doc = json.loads(r.stdout)
+        self.assertEqual(r.returncode, 1 if doc['bypassed'] else 0, r.stderr)
+        self.assertEqual(doc['repo_dir'], str(self.repo))
+        block = installed_block(self.repo)
+        for rc in ('.zshenv', '.zprofile', '.zshrc', '.profile'):
+            self.write(rc, block)
+        r = subprocess.run(cli + [str(self.repo)], env=env, capture_output=True, text=True)
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        self.assertIn('claude: OK', r.stdout)
+
+    def test_probe_leaves_shell_history_alone(self):
+        block = installed_block(self.repo)
+        for rc in ('.zshenv', '.zprofile', '.zshrc', '.profile'):
+            self.write(rc, block)
+        before = sorted(p.name for p in self.home.iterdir())
+        self.probe()
+        after = sorted(p.name for p in self.home.iterdir())
+        self.assertEqual(before, after)
+        for hist in ('.zsh_history', '.bash_history', '.sh_history'):
+            self.assertFalse((self.home / hist).exists(), hist)
+
+    def test_rc_that_reads_stdin_costs_an_answer_not_a_verdict(self):
+        """A prompt or `read` in an rc file eats one line of the fed script. The lost
+        answer must show as a row error, never as NOT ON PATH — that would page."""
+        block = installed_block(self.repo)
+        eater = 'read -r _eaten\n'
+        self.write('.zshenv', block)
+        self.write('.zprofile', block)
+        self.write('.zshrc', block, eater)
+        self.write('.profile', block)
+        self.write('.bashrc', block, eater)
+        rows = self.by_mode(self.probe())
+        for mode in ('zsh -li', 'bash -li'):
+            row = rows.get(mode)
+            if not row or row['error'] == 'shell not installed':
+                continue
+            with self.subTest(mode=mode):
+                oks = [r['ok'] for r in row['results'].values()]
+                self.assertNotIn(False, oks, row)
+                # the eater swallowed the history line, the sentinel answers survived
+                self.assertTrue(row['results'], row)
+        self.assertEqual(shim_path.bypassed(list(rows.values())), [])
+        # ...and an rc that tries to eat EVERY line: depending on how the shell buffers a
+        # piped stdin the probe either still answers or reads as unanswered — either way
+        # every name is OK or unknown, never a bypass.
+        self.write('.zshrc', block, eater * 6)
+        self.write('.bashrc', block, eater * 6)
+        rows = self.by_mode(self.probe())
+        for mode in ('zsh -li', 'bash -li'):
+            row = rows.get(mode)
+            if not row or row['error'] == 'shell not installed':
+                continue
+            if row['results']:
+                self.assertNotIn(False, [r['ok'] for r in row['results'].values()], row)
+            else:
+                self.assertIn('without answering', row['error'], row)
+        self.assertEqual(shim_path.bypassed(list(rows.values())), [])
+
+    def test_rc_noise_does_not_break_the_report(self):
+        block = installed_block(self.repo)
+        noise = ("printf 'claude=/nowhere\\n'\n"                 # a bare line that looks like an answer
+                 "printf '\\xff\\xfe not utf-8 \\xc3\\n'\n"   # a latin-1 banner
+                 "sleep 3 &\n")                                     # a child holding stdout open
+        for rc in ('.zshenv', '.zprofile', '.zshrc', '.profile'):
+            self.write(rc, noise, block)
+        started = __import__('time').monotonic()
+        rows = shim_path.probe(str(self.repo), home=str(self.home), user='tester', timeout=20)
+        elapsed = __import__('time').monotonic() - started
+        for name in shim_path.NAMES:
+            self.all_modes(rows, name, True)
+        self.assertEqual(shim_path.bypassed(rows), [])
+        # the backgrounded child must not have cost the timeout
+        self.assertLess(elapsed, 15, elapsed)
+
+    def test_sh_alias_in_profile_is_not_a_bypass(self):
+        block = installed_block(self.repo)
+        self.write('.profile', block, "alias claude='claude --dangerously-skip-permissions'\n")
+        rows = self.by_mode(self.probe())
+        row = rows.get('sh -lc')
+        if row and row['error'] != 'shell not installed':
+            self.assertTrue(row['results']['claude']['ok'], row)
+
+
+if __name__ == '__main__':
+    unittest.main()