claude-multiacc 2.0.27 → 2.0.28

package/lib/install_calendar.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Calendar job templates, sourced only by mac_schedule_install in install.sh.
+
+  cat > "$PLIST_HEALTH" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>$LABEL.health</string>
+  <key>ProgramArguments</key><array>
+    <string>$REPO_DIR/bin/claude-accounts</string>
+    <string>health</string>
+  </array>
+$(plist_env_block)  <key>StartCalendarInterval</key><dict>
+    <key>Weekday</key><integer>1</integer>
+    <key>Hour</key><integer>9</integer>
+    <key>Minute</key><integer>17</integer>
+  </dict>
+  <key>StandardOutPath</key><string>/dev/null</string>
+  <key>StandardErrorPath</key><string>/dev/null</string>
+</dict></plist>
+EOF
+
+  cat > "$PLIST_UPDATE" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>$LABEL.update</string>
+  <key>ProgramArguments</key><array>
+    <string>$REPO_DIR/bin/claude-accounts</string>
+    <string>self-update</string>
+    <string>--quiet</string>
+  </array>
+$(plist_env_block)  <key>StartCalendarInterval</key><dict>
+    <key>Hour</key><integer>4</integer>
+    <key>Minute</key><integer>7</integer>
+  </dict>
+  <key>StandardOutPath</key><string>/dev/null</string>
+  <key>StandardErrorPath</key><string>/dev/null</string>
+</dict></plist>
+EOF
+
+  cat > "$PLIST_CODEX_HEALTH" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>$LABEL.codex-health</string>
+  <key>ProgramArguments</key><array>
+    <string>$REPO_DIR/bin/codex-accounts</string>
+    <string>health</string>
+  </array>
+$(plist_env_block)  <key>StartCalendarInterval</key><dict>
+    <key>Weekday</key><integer>1</integer>
+    <key>Hour</key><integer>9</integer>
+    <key>Minute</key><integer>37</integer>
+  </dict>
+  <key>StandardOutPath</key><string>/dev/null</string>
+  <key>StandardErrorPath</key><string>/dev/null</string>
+</dict></plist>
+EOF

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.27",
+  "version": "2.0.28",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
     "claude-multiacc": "bin/cli.mjs",
+    "claude-accounts": "bin/claude-accounts",
+    "codex-accounts": "bin/codex-accounts",
     "multiacc-select": "bin/multiacc-select"
   },
   "files": [
@@ -53,7 +55,8 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
-    "test": "bash tests/run-tests.sh && python3 tests/test_selector.py"
+    "test": "bash tests/run-tests.sh && python3 tests/test_selector.py && npm run test:commands",
+    "test:commands": "python3 tests/test_packaged_commands.py"
   },
   "dependencies": {
     "update-notifier": "^7.3.1"

package/tests/packaged_command_support.py

@@ -0,0 +1,81 @@
+"""Offline npm installation and isolated command execution for the CLI contract."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def run(args, env, cwd, **kwargs):
+    return subprocess.run(args, env=env, cwd=cwd, text=True, capture_output=True, timeout=90, **kwargs)
+
+
+def install_package(test):
+    scratch = tempfile.TemporaryDirectory(prefix="multiacc-packaged-commands-")
+    test.addClassCleanup(scratch.cleanup)
+    test.work = Path(scratch.name).resolve()
+    test.prefix = test.work / "npm prefix"
+    test.home = test.work / "home"
+    test.home.mkdir()
+    npm = shutil.which("npm")
+    cache = subprocess.check_output([npm, "config", "get", "cache"], text=True).strip()
+    paths = [str(Path(shutil.which(name)).parent) for name in ("node", "python3", "npm")]
+    test.env = {
+        "HOME": str(test.home), "PATH": os.pathsep.join(dict.fromkeys(paths + ["/usr/bin", "/bin"])),
+        "CI": "1", "NO_UPDATE_NOTIFIER": "1", "PYTHONDONTWRITEBYTECODE": "1",
+        "CLAUDE_MULTIACC_KEYCHAIN": "0", "CLAUDE_MULTIACC_NO_SYNC": "1", "CODEX_MULTIACC_NO_SYNC": "1",
+        "CLAUDE_ACCOUNTS_ROOT": str(test.home / ".claude-accounts"),
+        "CODEX_ACCOUNTS_ROOT": str(test.home / ".codex-accounts"),
+        "npm_config_cache": cache, "npm_config_update_notifier": "false",
+        "npm_config_prefix": str(test.prefix), "npm_config_offline": "true",
+        "npm_config_ignore_scripts": "true",
+    }
+    packed = run([npm, "pack", "--ignore-scripts", "--pack-destination", str(test.work)],
+                 test.env, ROOT)
+    if packed.returncode:
+        raise RuntimeError(packed.stderr)
+    # npm 11 emits a JSON array; npm 12 keys it by package name. Test the artifact
+    # itself so npm's presentation format cannot strand an otherwise valid release.
+    archives = list(test.work.glob("*.tgz"))
+    if len(archives) != 1:
+        raise RuntimeError(f"Expected one packed archive, found {len(archives)}")
+    archive = archives[0]
+    installed = run([npm, "install", "-g", "--prefix", str(test.prefix), "--ignore-scripts", "--offline",
+                     "--no-audit", "--no-fund", str(archive)], test.env, test.work)
+    if installed.returncode:
+        raise RuntimeError("Offline install failed; run npm install --ignore-scripts to warm dependencies.\n"
+                           + installed.stderr)
+    test.package = test.prefix / "lib/node_modules/claude-multiacc"
+    test.env["PATH"] = str(test.prefix / "bin") + os.pathsep + test.env["PATH"]
+    guard = test.prefix / "bin/npm"
+    guard.write_text('#!/usr/bin/env bash\necho "unexpected npm invocation" >&2\nexit 89\n')
+    guard.chmod(0o755)
+    for name in ("claude", "codex", "security", "launchctl", "crontab", "ln"):
+        guard = test.prefix / "bin" / name
+        guard.write_text('#!/usr/bin/env bash\n'
+                         'printf "%s\\n" "$0 $*" >> "$HOME/tool-calls"\nexit 1\n')
+        guard.chmod(0o755)
+
+
+def seed_pools(test):
+    for provider in ("claude", "codex"):
+        pool = Path(test.env[f"{provider.upper()}_ACCOUNTS_ROOT"])
+        account = pool / "acct-01"
+        account.mkdir(parents=True)
+        (pool / "accounts.json").write_text(json.dumps({
+            "version": 1, "server": "none", "threshold": 90,
+            "accounts": [{"id": "acct-01", "email": f"{provider}@example.test",
+                          "home": "mac" if os.uname().sysname == "Darwin" else "server"}],
+        }))
+        credential = ({"tokens": {"access_token": "fixture", "refresh_token": "fixture"}}
+                      if provider == "codex" else {"claudeAiOauth": {
+                          "accessToken": "fixture", "refreshToken": "fixture", "expiresAt": 9999999999999}})
+        filename = "auth.json" if provider == "codex" else ".credentials.json"
+        (account / filename).write_text(json.dumps(credential))
+        fake = test.prefix / "bin" / provider
+        fake.write_text('#!/usr/bin/env bash\nprintf "OK\\n"\n')
+        fake.chmod(0o755)

package/tests/test_packaged_commands.py

@@ -0,0 +1,170 @@
+"""Exercise documented commands from npm's actual bin links, without shell rc files."""
+
+import json
+from pathlib import Path
+import plistlib
+import re
+import shlex
+import shutil
+import unittest
+
+from packaged_command_support import ROOT, install_package, run, seed_pools
+
+
+@unittest.skipUnless(shutil.which("node") and shutil.which("npm"), "Node/npm required")
+class PackagedCommandsTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        install_package(cls)
+
+    def test_global_commands_work_without_postinstall_or_shell_rc(self):
+        for command in ("claude-multiacc", "claude-accounts", "codex-accounts", "multiacc-select"):
+            with self.subTest(command=command):
+                resolved = shutil.which(command, path=self.env["PATH"])
+                self.assertEqual(resolved, str(self.prefix / "bin" / command))
+                flag = "--version" if command == "multiacc-select" else "--help"
+                result = run([command, flag], self.env, self.work)
+                self.assertEqual(result.returncode, 0, result.stderr)
+        for shell in ("bash", "zsh"):
+            if not shutil.which(shell):
+                continue
+            result = run([shell, "-fc", "codex-accounts verify --help"], self.env, self.work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+        for command in ("claude-accounts", "codex-accounts"):
+            result = run([command, "list"], self.env, self.work)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("run claude-multiacc install first", result.stderr)
+
+    def test_every_account_help_command_dispatches_directly_and_via_wrapper(self):
+        for provider in ("claude", "codex"):
+            direct = f"{provider}-accounts"
+            help_result = run([str(self.package / "bin" / direct), "--help"], self.env, self.work)
+            verbs = set(re.findall(rf"^  {direct} ([a-z-]+)", help_result.stdout, re.MULTILINE))
+            self.assertGreaterEqual(len(verbs), 18)
+            wrapper = ["claude-multiacc"] + (["codex"] if provider == "codex" else [])
+            for prefix in ([direct], wrapper):
+                for verb in sorted(verbs):
+                    with self.subTest(prefix=prefix, verb=verb):
+                        result = run(prefix + [verb, "--help"], self.env, self.work)
+                        self.assertEqual(result.returncode, 0, result.stderr)
+                        self.assertIn(f"{direct} {verb}", result.stdout)
+                result = run(prefix + ["not-a-command", "--help"], self.env, self.work)
+                self.assertNotEqual(result.returncode, 0)
+
+    def test_wrapper_and_installer_help_have_no_side_effects(self):
+        before = sorted(str(path) for path in self.home.rglob("*"))
+        for verb in ("help", "install", "update", "uninstall", "doctor", "self-update", "codex", "select"):
+            with self.subTest(verb=verb):
+                result = run(["claude-multiacc", verb, "--help"], self.env, self.work)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertRegex(result.stdout, r"(?i)usage")
+        result = run([str(self.package / "install.sh"), "--help"], self.env, self.work)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(before, sorted(str(path) for path in self.home.rglob("*")))
+
+    def test_verify_and_json_reports_use_the_correct_pool(self):
+        seed_pools(self)
+        for provider in ("claude", "codex"):
+            wrapper = ["claude-multiacc"] + (["codex"] if provider == "codex" else [])
+            for prefix in ([f"{provider}-accounts"], wrapper):
+                for verb in ("list", "status"):
+                    result = run(prefix + [verb, "--json"], self.env, self.work)
+                    self.assertEqual(result.returncode, 0, result.stderr)
+                    self.assertEqual(json.loads(result.stdout)["provider"], provider)
+                for flags, expected in ((["--quick"], ": OK"), ([], ": PASS")):
+                    result = run(prefix + ["verify"] + flags, self.env, self.work)
+                    self.assertEqual(result.returncode, 0, result.stderr)
+                    self.assertIn(f"{provider}@example.test{expected}", result.stdout)
+
+    def test_self_update_uses_the_running_install_prefix(self):
+        fake_npm = self.prefix / "bin/npm"
+        original = fake_npm.read_text()
+        fake_npm.write_text('#!/usr/bin/env bash\n'
+                            'if [ "$1" = view ]; then echo 999.0.0; exit 0; fi\n'
+                            'printf "%s\\n" "$@" > "$HOME/update-args"\nexit 42\n')
+        fake_npm.chmod(0o755)
+        try:
+            result = run(["claude-multiacc", "self-update"], self.env, self.work)
+            self.assertNotEqual(result.returncode, 0)
+            args = (self.home / "update-args").read_text().splitlines()
+            self.assertEqual(args, ["install", "-g", "--prefix", str(self.prefix), "claude-multiacc@latest"])
+        finally:
+            fake_npm.write_text(original)
+
+    def test_git_and_npx_path_entrypoint_matches_npm(self):
+        entrypoint = self.package / "bin/claude-multiacc"
+        self.assertTrue(entrypoint.is_file())
+        result = run([str(entrypoint), "--version"], self.env, self.work)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), json.loads((self.package / "package.json").read_text())["version"])
+
+    def test_installer_is_idempotent_and_instances_leave_system_commands_alone(self):
+        uname = self.prefix / "bin/uname"
+        identity = self.prefix / "bin/id"
+        uname.write_text('#!/usr/bin/env bash\necho Darwin\n')
+        identity.write_text('#!/usr/bin/env bash\necho 0\n')
+        uname.chmod(0o755)
+        identity.chmod(0o755)
+        try:
+            for _ in range(2):
+                result = run(["claude-multiacc", "install", "--no-server", "--no-schedule"], self.env, self.work)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertNotIn("status |", result.stdout)
+            for rc in (".zshenv", ".zprofile", ".zshrc"):
+                self.assertEqual((self.home / rc).read_text().count("# >>> claude-multiacc >>>"), 1)
+            calls = (self.home / "tool-calls").read_text()
+            self.assertNotRegex(calls, r"/(launchctl|crontab|ln) ")
+            script = 'source "$0" --no-server --no-schedule; mac_schedule_install'
+            result = run(["bash", "-c", script, str(self.package / "install.sh")], self.env, self.work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            plists = list((self.home / "Library/LaunchAgents").glob("*.plist"))
+            self.assertEqual(len(plists), 5)
+            for path in plists:
+                job = plistlib.loads(path.read_bytes())
+                self.assertIn("PATH", job["EnvironmentVariables"])
+                self.assertTrue(Path(job["ProgramArguments"][0]).is_file())
+            result = run(["claude-multiacc", "uninstall"], self.env, self.work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertNotIn("claude-multiacc", (self.home / ".zshrc").read_text())
+            self.assertTrue((self.home / ".codex-accounts/accounts.json").exists())
+            uname.write_text('#!/usr/bin/env bash\necho Linux\n')
+            (self.home / "tool-calls").write_text("")
+            args = ["install", "--instance", "sandbox", "--no-server", "--no-schedule"]
+            result = run(["claude-multiacc"] + args, self.env, self.work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertNotIn("/ln ", (self.home / "tool-calls").read_text())
+        finally:
+            uname.unlink()
+            identity.unlink()
+
+    def test_selector_transport_and_version_match_across_entrypoints(self):
+        expected = None
+        for prefix in (["multiacc-select"], ["claude-multiacc", "select"]):
+            version = run(prefix + ["--version"], self.env, self.work)
+            self.assertEqual(version.returncode, 0, version.stderr)
+            result = run(prefix + ["--request-json", "-", "--response-json", "-"], self.env, self.work, input="{}")
+            self.assertEqual(result.returncode, 0, result.stderr)
+            response = json.loads(result.stdout)
+            self.assertEqual(response["selector_version"], version.stdout.strip())
+            self.assertEqual(response["error_code"], "invalid_request")
+            if expected is not None:
+                self.assertEqual(response, expected)
+            expected = response
+
+    def test_documented_shell_examples_parse_and_command_names_exist(self):
+        documents = [ROOT / "README.md", *sorted((ROOT / "docs").glob("*.md"))]
+        for document in documents:
+            for block in re.findall(r"```(?:bash|sh)\n(.*?)```", document.read_text(), re.DOTALL):
+                result = run(["bash", "-n"], self.env, self.work, input=block)
+                self.assertEqual(result.returncode, 0, f"{document.name}: {result.stderr}")
+                for line in block.splitlines():
+                    tokens = shlex.split(line, comments=True)
+                    if not tokens or tokens[0] not in ("claude-accounts", "codex-accounts", "claude-multiacc"):
+                        continue
+                    self.assertNotIn("|", tokens, f"{document.name}: alternatives must be separate commands")
+                    self.assertIsNone(re.search(r"--[a-z-]+#", line), line)
+                    self.assertIsNotNone(shutil.which(tokens[0], path=self.env["PATH"]), line)
+
+
+if __name__ == "__main__":
+    unittest.main()