claude-multiacc 2.0.52 → 2.0.54

package/README.md

@@ -326,6 +326,16 @@ maintains only while a run is alive. The shim spawns a short detached poll befor
 session's own start time — in `<acct>/.sessions-index`; selection then tail-scans those
 transcripts.
 
+Fresh account seeding creates `~/.claude/projects` before linking each account, even
+if stock Claude has never run on that machine. For an existing pool with private
+`<acct>/projects` trees, run `python3 lib/claude_pool_prepare.py apply`. It
+defers a private-history migration while a pooled Claude session is active,
+merges transcripts into the shared tree when idle, archives
+conflicting versions under `~/.claude-accounts/history-repair/`, and sets the
+interactive default to `bypassPermissions` in the global and pooled account
+settings. `check` reports readiness without changing files. The bypass default is
+an operator choice for trusted runner machines; ordinary installs do not change it.
+
 Everything about the rule is built to under-claim rather than over-claim, because a
 wrongly parked account is worse than a missed limit:
 

package/lib/claude_pool_prepare.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Prepare one local Claude pool's shared history and interactive permission default."""
+
+from __future__ import annotations
+
+import argparse
+import fcntl
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+
+
+def account_dirs(root: Path) -> list[Path]:
+    manifest = root / "accounts.json"
+    if not manifest.is_file():
+        return []
+    data = json.loads(manifest.read_text())
+    ids = [item["id"] for item in data.get("accounts", [])]
+    if any(not re.fullmatch(r"acct-[0-9]{2}", value) for value in ids):
+        raise ValueError("invalid account id in manifest")
+    return [root / value for value in ids if (root / value).is_dir()]
+
+
+def same_history(path: Path, shared: Path) -> bool:
+    return path.is_dir() and path.resolve() == shared.resolve()
+
+
+def active_pool_session(accounts: list[Path]) -> bool:
+    for account in accounts:
+        for marker in (account / "sessions").glob("*.json"):
+            if marker.stem.isdecimal():
+                try:
+                    os.kill(int(marker.stem), 0)
+                except ProcessLookupError:
+                    continue
+                except PermissionError:
+                    return True
+                return True
+    return False
+
+
+def save_conflict(path: Path, archive: Path, account: str, relative: Path) -> None:
+    destination = archive / "conflicts" / account / relative
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    number = 1
+    while os.path.lexists(destination):
+        destination = destination.with_name(f"{relative.name}.{number}")
+        number += 1
+    path.rename(destination)
+
+
+def merge_history(source: Path, shared: Path, archive: Path) -> tuple[int, int]:
+    moved = conflicts = 0
+    for base, directories, files in os.walk(source):
+        current = Path(base)
+        relative = current.relative_to(source)
+        destination = shared / relative
+        destination.mkdir(parents=True, exist_ok=True)
+        for name in list(directories):
+            if (current / name).is_symlink():
+                directories.remove(name)
+                files.append(name)
+        for name in files:
+            item = current / name
+            target = destination / name
+            if not os.path.lexists(target):
+                item.rename(target)
+                moved += 1
+            elif item.lstat().st_mtime_ns > target.lstat().st_mtime_ns:
+                save_conflict(target, archive, source.name, relative / name)
+                item.rename(target)
+                conflicts += 1
+            else:
+                save_conflict(item, archive, source.name, relative / name)
+                conflicts += 1
+    for base, _, _ in os.walk(source, topdown=False):
+        Path(base).rmdir()
+    return moved, conflicts
+
+
+def prepare_history(home: Path, root: Path, accounts: list[Path]) -> tuple[int, int]:
+    shared = home / ".claude" / "projects"
+    if os.path.lexists(shared) and not shared.is_dir():
+        raise ValueError("global Claude history is not a directory")
+    for account in accounts:
+        projects = account / "projects"
+        if (account.is_symlink() and os.path.lexists(projects) and not same_history(projects, shared)
+                or projects.is_symlink() and not same_history(projects, shared)
+                or os.path.lexists(projects) and not projects.is_dir()):
+            raise ValueError(f"custom history entry for {account.name}")
+    if active_pool_session(accounts) and any(
+            (account / "projects").is_dir() and not same_history(account / "projects", shared)
+            for account in accounts):
+        raise RuntimeError("active Claude pool session; retry history repair after it exits")
+    shared.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    if not shared.is_dir():
+        source = next((d / "projects" for d in accounts if not d.is_symlink()
+                       and (d / "projects").is_dir() and not (d / "projects").is_symlink()), None)
+        if source is None:
+            shared.mkdir(mode=0o700)
+        else:
+            source.rename(shared)
+            source.symlink_to(shared, target_is_directory=True)
+    archive = root / "history-repair"
+    originals = archive / "originals"
+    for account in accounts:
+        projects = account / "projects"
+        if same_history(projects, shared):
+            continue
+        if projects.is_dir():
+            originals.mkdir(parents=True, exist_ok=True)
+            archive.chmod(0o700)
+            originals.chmod(0o700)
+            saved = originals / account.name
+            number = 1
+            while saved.exists():
+                saved = originals / f"{account.name}-{number}"
+                number += 1
+            projects.rename(saved)
+        projects.symlink_to(shared, target_is_directory=True)
+    moved = conflicts = 0
+    if originals.is_dir():
+        for source in sorted(originals.iterdir()):
+            count, duplicates = merge_history(source, shared, archive)
+            moved += count
+            conflicts += duplicates
+    return moved, conflicts
+
+
+def set_default_mode(path: Path) -> bool:
+    data = json.loads(path.read_text()) if path.exists() else {}
+    permissions = data.setdefault("permissions", {})
+    if not isinstance(permissions, dict):
+        raise ValueError(f"invalid permissions in {path}")
+    if permissions.get("defaultMode") == "bypassPermissions":
+        return False
+    permissions["defaultMode"] = "bypassPermissions"
+    mode = path.stat().st_mode & 0o777 if path.exists() else 0o600
+    descriptor, temporary = tempfile.mkstemp(prefix=".settings-", dir=path.parent)
+    try:
+        with os.fdopen(descriptor, "w") as stream:
+            json.dump(data, stream, indent=2, ensure_ascii=False)
+            stream.write("\n")
+        os.chmod(temporary, mode)
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    return True
+
+
+def validate_settings(paths: list[Path]) -> None:
+    for path in paths:
+        if path.is_symlink():
+            raise ValueError(f"custom settings link for {path.parent.name}")
+        if path.exists():
+            data = json.loads(path.read_text())
+            if not isinstance(data, dict) or not isinstance(data.get("permissions", {}), dict):
+                raise ValueError(f"invalid settings for {path.parent.name}")
+
+
+def is_ready(home: Path, accounts: list[Path]) -> bool:
+    shared = home / ".claude" / "projects"
+    if not shared.is_dir() or any(not same_history(d / "projects", shared) for d in accounts):
+        return False
+    for path in [home / ".claude" / "settings.json", *(d / "settings.json" for d in accounts)]:
+        try:
+            if json.loads(path.read_text())["permissions"]["defaultMode"] != "bypassPermissions":
+                return False
+        except (OSError, ValueError, KeyError, TypeError):
+            return False
+    return True
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("verb", choices=("check", "apply"))
+    parser.add_argument("--home", type=Path, default=Path.home())
+    parser.add_argument("--root", type=Path, default=None)
+    args = parser.parse_args()
+    home = args.home.resolve()
+    root = (args.root or Path(os.environ.get("CLAUDE_ACCOUNTS_ROOT", home / ".claude-accounts"))).resolve()
+    if args.verb == "check":
+        accounts = account_dirs(root)
+        ready = is_ready(home, accounts)
+        print(json.dumps({"ready": ready, "accounts": len(accounts)}))
+        return 0 if ready else 1
+    root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    descriptor = os.open(root / ".pool-prepare.lock", os.O_CREAT | os.O_RDWR, 0o600)
+    with os.fdopen(descriptor, "w") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        accounts = account_dirs(root)
+        settings = [home / ".claude" / "settings.json", *(d / "settings.json" for d in accounts)]
+        validate_settings(settings)
+        moved, conflicts = prepare_history(home, root, accounts)
+        changed = sum(set_default_mode(path) for path in settings)
+    ready = is_ready(home, accounts)
+    print(json.dumps({"ready": ready, "accounts": len(accounts), "files_moved": moved,
+                      "conflicts_archived": conflicts, "settings_updated": changed}))
+    return 0 if ready else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/common.sh

@@ -781,8 +781,14 @@ PYEOF
   if [ ! -e "$d/CLAUDE.md" ] && [ -f "$HOME/.claude/CLAUDE.md" ]; then
     ln -s "$HOME/.claude/CLAUDE.md" "$d/CLAUDE.md" 2>/dev/null || true
   fi
-  if [ ! -e "$d/projects" ] && [ -d "$HOME/.claude/projects" ]; then
-    ln -s "$HOME/.claude/projects" "$d/projects" 2>/dev/null || true
+  # A fresh machine may seed pooled accounts before stock Claude has ever created
+  # ~/.claude/projects. Create the shared tree first or each account will create
+  # its own private history, making --resume depend on the next random pick.
+  if [ ! -e "$d/projects" ] && [ ! -L "$d/projects" ]; then
+    mkdir -p -m 700 "$HOME/.claude" "$HOME/.claude/projects" 2>/dev/null || true
+    if [ "$d" != "$HOME/.claude" ] && [ -d "$HOME/.claude/projects" ]; then
+      ln -s "$HOME/.claude/projects" "$d/projects" 2>/dev/null || true
+    fi
   fi
   seed_mcp_registry "$d"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.52",
+  "version": "2.0.54",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -58,7 +58,7 @@
     "test": "npm run test:core && npm run test:seeding && npm run test:commands",
     "test:core": "bash tests/run-tests.sh && npm run test:selector && python3 tests/test_shim_path.py",
     "test:selector": "python3 -m unittest discover -s tests -p 'test_selector*.py'",
-    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_mcp_registry.py && npm run test:codex-settings",
+    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 tests/test_mcp_registry.py && npm run test:codex-settings",
     "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py",
     "test:commands": "python3 tests/test_packaged_commands.py"
   },

package/tests/test_account_seeding.py

@@ -87,6 +87,19 @@ class AccountSeedingTests(unittest.TestCase):
                 self.seed(provider)
                 self.assertEqual((account / name).read_text(), original)
 
+    def test_claude_history_is_shared_even_before_stock_claude_runs(self):
+        shared = self.home / ".claude" / "projects"
+        self.assertFalse(shared.exists())
+        first = self.seed("claude")
+        second = self.seed("claude", self.home / ".claude-accounts" / "acct-02")
+        self.assertTrue(shared.is_dir())
+        self.assertEqual((first / "projects").resolve(), shared.resolve())
+        self.assertEqual((second / "projects").resolve(), shared.resolve())
+        session = first / "projects" / "-work" / "session.jsonl"
+        session.parent.mkdir()
+        session.write_text("session\n")
+        self.assertEqual((second / "projects" / "-work" / "session.jsonl").read_text(), "session\n")
+
     def test_local_sync_repairs_only_manifest_accounts(self):
         for provider, name, _ in PROVIDERS:
             with self.subTest(provider=provider):

package/tests/test_claude_pool_prepare.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""The local Claude pool repair retains every transcript and existing setting."""
+
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+SCRIPT = Path(__file__).resolve().parents[1] / "lib" / "claude_pool_prepare.py"
+
+
+class ClaudePoolPrepareTests(unittest.TestCase):
+    def setUp(self):
+        self.work = tempfile.TemporaryDirectory()
+        self.addCleanup(self.work.cleanup)
+        self.home = Path(self.work.name)
+        self.root = self.home / ".claude-accounts"
+        self.root.mkdir()
+        self.accounts = [self.root / f"acct-{number:02d}" for number in (1, 2)]
+        for account in self.accounts:
+            account.mkdir()
+        (self.root / "accounts.json").write_text(json.dumps({
+            "accounts": [{"id": account.name} for account in self.accounts],
+        }))
+
+    def run_prepare(self, verb):
+        return subprocess.run([sys.executable, str(SCRIPT), verb, "--home", str(self.home)],
+                              capture_output=True, text=True)
+
+    def test_fresh_pool_starts_shared_and_bypassed(self):
+        self.assertEqual(self.run_prepare("check").returncode, 1)
+        result = self.run_prepare("apply")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout)["accounts"], 2)
+        shared = self.home / ".claude" / "projects"
+        self.assertTrue(shared.is_dir())
+        for account in self.accounts:
+            self.assertTrue((account / "projects").is_symlink())
+            self.assertEqual((account / "projects").resolve(), shared.resolve())
+            self.assertEqual(json.loads((account / "settings.json").read_text())
+                             ["permissions"]["defaultMode"], "bypassPermissions")
+        self.assertEqual(self.run_prepare("check").returncode, 0)
+
+    def test_split_history_merges_and_preserves_conflicting_transcripts(self):
+        first, second = self.accounts
+        first_session = first / "projects" / "-work" / "session.jsonl"
+        second_session = second / "projects" / "-work" / "session.jsonl"
+        for session, content, stamp in ((first_session, "old\n", 10),
+                                        (second_session, "new\n", 20)):
+            session.parent.mkdir(parents=True)
+            session.write_text(content)
+            os.utime(session, (stamp, stamp))
+        (first / "projects" / "-work" / "first.jsonl").write_text("first\n")
+        (second / "projects" / "-work" / "second.jsonl").write_text("second\n")
+        (first / "settings.json").write_text(json.dumps({
+            "model": "opus", "permissions": {"defaultMode": "auto", "allow": ["Bash"]}}))
+        result = self.run_prepare("apply")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout)["conflicts_archived"], 1)
+        for account in self.accounts:
+            self.assertEqual((account / "projects" / "-work" / "session.jsonl").read_text(), "new\n")
+            self.assertTrue((account / "projects" / "-work" / "first.jsonl").exists())
+            self.assertTrue((account / "projects" / "-work" / "second.jsonl").exists())
+        self.assertEqual((self.root / "history-repair" / "conflicts" / "acct-02" / "-work" /
+                          "session.jsonl").read_text(), "old\n")
+        settings = json.loads((first / "settings.json").read_text())
+        self.assertEqual(settings["model"], "opus")
+        self.assertEqual(settings["permissions"]["allow"], ["Bash"])
+        self.assertEqual(settings["permissions"]["defaultMode"], "bypassPermissions")
+        self.assertEqual(json.loads(self.run_prepare("apply").stdout)["files_moved"], 0)
+
+    def test_custom_history_link_is_not_replaced(self):
+        custom = self.home / "custom-projects"
+        custom.mkdir()
+        (self.accounts[0] / "projects").symlink_to(custom)
+        result = self.run_prepare("apply")
+        self.assertNotEqual(result.returncode, 0)
+        self.assertEqual((self.accounts[0] / "projects").resolve(), custom.resolve())
+
+    def test_private_history_waits_for_active_pool_session(self):
+        projects = self.accounts[0] / "projects"
+        projects.mkdir()
+        sessions = self.accounts[1] / "sessions"
+        sessions.mkdir()
+        (sessions / f"{os.getpid()}.json").write_text("{}")
+        result = self.run_prepare("apply")
+        self.assertNotEqual(result.returncode, 0)
+        self.assertTrue(projects.is_dir())
+        self.assertFalse(projects.is_symlink())
+        self.assertFalse((self.home / ".claude" / "projects").exists())
+
+    def test_custom_settings_link_is_not_replaced(self):
+        custom = self.home / "settings.json"
+        custom.write_text("{}")
+        (self.accounts[0] / "settings.json").symlink_to(custom)
+        result = self.run_prepare("apply")
+        self.assertNotEqual(result.returncode, 0)
+        self.assertTrue((self.accounts[0] / "settings.json").is_symlink())
+        self.assertFalse((self.home / ".claude" / "projects").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()