multi-claude-cli 0.4.0__py3-none-any.whl

multi_claude/doctor.py

@@ -0,0 +1,221 @@
+"""`multi-claude doctor`：只读检查多账号环境是否健康（方案 v0.2 §5.1.2）。
+
+所有检查都不修改任何东西、不读凭据：登录检查沿用 identity.probe 的存在性探测。
+每条非 ok 结果的 message 里给出修复命令，由用户自己执行。
+配置文件或迁移记录损坏时不抛异常，而是记成对应检查项的 error，其余不依赖配置的检查照常执行，
+这样 `doctor --json` 在任何状态下都输出合法 JSON。
+"""
+
+import os
+import platform as py_platform
+import shutil
+import stat
+from typing import List, NamedTuple, Optional, Tuple
+
+from . import accounts, identity, launcher, migrate, routes, shellpath
+from .config import IDENTITY_DEFAULT, Account, Config, ConfigError, load_config
+from .fsutil import expand
+
+LEVEL_OK = "ok"
+LEVEL_WARN = "warn"
+LEVEL_ERROR = "error"
+
+
+class Check(NamedTuple):
+    id: str
+    level: str
+    # 检查对象：账号名、变量名、路径等；全局检查用 "-"
+    subject: str
+    message: str
+
+
+def run_checks() -> List[Check]:
+    checks: List[Check] = []
+    checks.append(_check_journal())
+    config, config_check = _load()
+    checks.append(config_check)
+    checks.append(_check_claude_on_path())
+    checks.extend(_check_auth_env())
+    if config is None:
+        return checks
+    checks.append(_check_bin_on_path(config))
+    for account in config.accounts.values():
+        checks.extend(_check_account(config, account))
+    checks.extend(_check_routes(config))
+    return checks
+
+
+def _check_routes(config: Config) -> List[Check]:
+    """路由启用时检查 claude-auto 与每条规则（方案 feature-directory-routing §5.1.6）。"""
+    if not config.routes_enabled:
+        return []
+    checks: List[Check] = []
+    status = routes.router_status(config)
+    path = routes.router_path(config.bin_dir)
+    if status == "ok":
+        checks.append(Check("router", LEVEL_OK, routes.ROUTER_NAME, path))
+    else:
+        hint = {"missing": "is missing", "stale": "is out of date",
+                "conflict": "is taken by a file multi-claude does not manage"}[status]
+        checks.append(Check("router", LEVEL_ERROR, routes.ROUTER_NAME,
+                            "{} {}; run `multi-claude apply`".format(path, hint)))
+    for rule in config.route_rules:
+        if config.find(rule.account) is None:
+            checks.append(Check("route-account", LEVEL_ERROR, rule.path,
+                                "uses account {!r}, which is not registered; run `multi-claude route {} --remove` "
+                                "or register the account".format(rule.account, rule.path)))
+        if not os.path.isdir(expand(rule.path)):
+            checks.append(Check("route-path", LEVEL_WARN, rule.path,
+                                "the directory does not exist, so this route is ignored"))
+    if config.route_default is not None and config.find(config.route_default) is None:
+        checks.append(Check("route-account", LEVEL_ERROR, "(default)",
+                            "uses account {!r}, which is not registered; run `multi-claude route --no-default` "
+                            "or register the account".format(config.route_default)))
+    return checks
+
+
+def _check_journal() -> Check:
+    try:
+        journal = migrate.load_journal()
+    except migrate.JournalError as exc:
+        return Check("journal", LEVEL_ERROR, "-", "{}; see the README on abandoning a migration".format(exc))
+    if journal is not None:
+        name = journal.get("name")
+        return Check("journal", LEVEL_ERROR, str(name),
+                     "an unfinished migration exists; run `multi-claude migrate-default {}`".format(name))
+    return Check("journal", LEVEL_OK, "-", "no unfinished migration")
+
+
+def _load() -> Tuple[Optional[Config], Check]:
+    try:
+        config, exists = load_config()
+    except ConfigError as exc:
+        return None, Check("config", LEVEL_ERROR, "-", str(exc))
+    if not exists:
+        # 没有配置也照常检查全局项；默认配置里没有账号，按账号的检查自然为空。
+        return config, Check("config", LEVEL_WARN, "-", "no configuration yet; run `multi-claude add NAME`")
+    return config, Check("config", LEVEL_OK, "-", "configuration is valid")
+
+
+def _check_claude_on_path() -> Check:
+    found = shutil.which("claude")
+    if found is None:
+        return Check("claude-on-path", LEVEL_ERROR, "claude", "`claude` is not on PATH; install Claude Code")
+    return Check("claude-on-path", LEVEL_OK, "claude", found)
+
+
+def _check_auth_env() -> List[Check]:
+    checks = []
+    for variable in migrate.isolation_env_variables():
+        if not os.environ.get(variable):
+            continue
+        # 只报变量名，绝不输出变量的值（多为凭据）。
+        if variable in launcher.AUTH_OVERRIDE_ENV:
+            message = "set in this shell; launchers clear it, but running `claude` directly uses it"
+        else:
+            message = "set in this shell; every account launched from it will share it"
+        checks.append(Check("auth-env", LEVEL_WARN, variable, message))
+    if not checks:
+        checks.append(Check("auth-env", LEVEL_OK, "-", "no variable overrides the accounts' logins"))
+    return checks
+
+
+def _path_entries() -> List[str]:
+    return [os.path.abspath(os.path.expanduser(entry))
+            for entry in os.environ.get("PATH", "").split(os.pathsep) if entry]
+
+
+def _check_bin_on_path(config: Config) -> Check:
+    bin_dir = expand(config.bin_dir)
+    if bin_dir not in _path_entries():
+        return Check("bin-on-path", LEVEL_WARN, bin_dir,
+                     "the launcher directory is not on PATH; " + shellpath.path_hint(
+                         bin_dir, os.environ.get("SHELL"), py_platform.system()))
+    return Check("bin-on-path", LEVEL_OK, bin_dir, "on PATH")
+
+
+def _check_account(config: Config, account: Account) -> List[Check]:
+    name = account.name
+    directory = accounts.account_dir(config, name)
+    checks: List[Check] = []
+
+    status = accounts.launcher_status(config, name)
+    if status == "ok":
+        checks.append(Check("launcher", LEVEL_OK, name, "up to date"))
+    else:
+        hint = {"missing": "the launcher is missing",
+                "stale": "the launcher is out of date",
+                "conflict": "the launcher path is taken by a file multi-claude does not manage"}[status]
+        checks.append(Check("launcher", LEVEL_ERROR, name, "{}; run `multi-claude apply`".format(hint)))
+
+    expected = launcher.launcher_path(expand(config.bin_dir), name)
+    found = shutil.which(launcher.LAUNCHER_PREFIX + name)
+    # 找不到时由 bin-on-path 或 launcher 检查报告，这里只管“PATH 上先找到了别的同名文件”。
+    if found is not None and os.path.realpath(found) != os.path.realpath(expected):
+        checks.append(Check("launcher-shadowed", LEVEL_WARN, name,
+                            "{} comes first on PATH and hides {}".format(found, expected)))
+
+    checks.extend(_check_account_dir(name, directory))
+    if account.identity == IDENTITY_DEFAULT:
+        link = accounts.default_link_status(config, account)
+        if link != "ok":
+            checks.append(Check("default-link", LEVEL_ERROR, name,
+                                "{} is {}; restore the link to {} or run `multi-claude migrate-default {}`".format(
+                                    accounts.default_dir(), link, directory, name)))
+        else:
+            checks.append(Check("default-link", LEVEL_OK, name, "{} -> {}".format(accounts.default_dir(), directory)))
+
+    for item in config.shared_items:
+        path = os.path.join(directory, item)
+        if os.path.islink(path) and not os.path.exists(path):
+            checks.append(Check("shared-link", LEVEL_WARN, name,
+                                "{} is a broken link to {}".format(path, os.readlink(path))))
+
+    login = identity.probe(account.identity, directory)
+    if login in (identity.LOGIN_NONE, identity.LOGIN_UNKNOWN):
+        message = ("no login found; start `claude-{}` and log in".format(name) if login == identity.LOGIN_NONE
+                   else "could not check the login (the keychain query failed)")
+        checks.append(Check("login", LEVEL_WARN, name, message))
+    else:
+        checks.append(Check("login", LEVEL_OK, name, login))
+    return checks
+
+
+def _check_account_dir(name: str, directory: str) -> List[Check]:
+    try:
+        mode = stat.S_IMODE(os.stat(directory).st_mode)
+    except OSError:
+        return [Check("account-dir", LEVEL_ERROR, name, "{} does not exist".format(directory))]
+    if not os.path.isdir(directory):
+        return [Check("account-dir", LEVEL_ERROR, name, "{} is not a directory".format(directory))]
+    if mode & 0o077:
+        # 目录里有会话记录，Linux 上还有 .credentials.json，组或其他用户不应能读写。
+        return [Check("account-dir", LEVEL_WARN, name,
+                      "{} has mode {:o}; run `chmod 700 '{}'`".format(directory, mode, directory))]
+    return [Check("account-dir", LEVEL_OK, name, directory)]
+
+
+def summary(checks: List[Check]) -> dict:
+    counts = {LEVEL_OK: 0, LEVEL_WARN: 0, LEVEL_ERROR: 0}
+    for check in checks:
+        counts[check.level] += 1
+    return counts
+
+
+def format_text(checks: List[Check], verbose: bool) -> List[str]:
+    lines = ["[{}] {} {}: {}".format(check.level, check.id, check.subject, check.message)
+             for check in checks if verbose or check.level != LEVEL_OK]
+    counts = summary(checks)
+    lines.append("{} ok, {} warning(s), {} error(s)".format(counts[LEVEL_OK], counts[LEVEL_WARN],
+                                                             counts[LEVEL_ERROR]))
+    return lines
+
+
+def exit_code(checks: List[Check]) -> int:
+    return 1 if any(check.level == LEVEL_ERROR for check in checks) else 0
+
+
+def to_dict(checks: List[Check]) -> dict:
+    return {"schema_version": 1,
+            "checks": [check._asdict() for check in checks],
+            "summary": summary(checks)}

multi_claude/env.py

@@ -0,0 +1,46 @@
+"""按账号构造进程环境，与启动命令 `claude-<名称>` 的语义一致（方案 feature-rename-mcp §5.1.4）。
+
+`multi-claude mcp NAME …` 不能经启动命令转交：固定参数排在子命令之前，`--allowedTools` 这类取多个值的
+选项会把 `mcp`、`add` 吞成自己的值。所以这里用 Python 复刻启动命令里与环境有关的部分（不含固定参数）。
+两套实现必须保持一致：测试会对同一账号比较本模块的结果与启动命令实际导出的环境。
+处理顺序与 launcher.render 相同：身份 → 清除鉴权覆盖变量 → 额外环境变量 → 代理。
+"""
+
+from typing import Dict, Mapping
+
+from . import accounts, launcher
+from .config import IDENTITY_DEFAULT, PROXY_INHERIT, PROXY_OFF, PROXY_VARS, Account, Config
+
+
+def account_env(config: Config, account: Account, base: Mapping[str, str]) -> Dict[str, str]:
+    env = dict(base)
+    if account.identity == IDENTITY_DEFAULT:
+        # default 身份靠“不设 CLAUDE_CONFIG_DIR”使用 ~/.claude 与不带后缀的钥匙串条目。
+        env.pop("CLAUDE_CONFIG_DIR", None)
+        env.pop("CLAUDE_SECURESTORAGE_CONFIG_DIR", None)
+    else:
+        env.pop("CLAUDE_SECURESTORAGE_CONFIG_DIR", None)
+        env["CLAUDE_CONFIG_DIR"] = accounts.account_dir(config, account.name)
+    for name in launcher.AUTH_OVERRIDE_ENV:
+        env.pop(name, None)
+    for key, value in config.effective_env(account).items():
+        env[key] = launcher.expand_value(value)
+    _apply_proxy(env, account.proxy)
+    return env
+
+
+def _apply_proxy(env: Dict[str, str], proxy: str) -> None:
+    if proxy == PROXY_INHERIT:
+        return
+    if proxy == PROXY_OFF:
+        for name in PROXY_VARS:
+            env.pop(name, None)
+        return
+    for name in ("HTTPS_PROXY", "HTTP_PROXY", "https_proxy", "http_proxy"):
+        env[name] = proxy
+    env.pop("ALL_PROXY", None)
+    env.pop("all_proxy", None)
+    # 与启动命令的 ${NO_PROXY:+$NO_PROXY,} 相同：原值为空时不留前导逗号。
+    for name in ("NO_PROXY", "no_proxy"):
+        current = env.get(name, "")
+        env[name] = "{},{}".format(current, launcher._NO_PROXY_HOSTS) if current else launcher._NO_PROXY_HOSTS

multi_claude/fsutil.py

@@ -0,0 +1,234 @@
+"""文件系统工具：原子写入、路径判定、文件清单与校验、跳过特殊文件的复制。
+
+本模块只做与业务无关的文件操作，不读取配置，也不输出日志；
+调用方负责决定何时调用以及如何报告结果。
+"""
+
+import hashlib
+import os
+import shutil
+import stat
+import tempfile
+from typing import Callable, Dict, List, Optional, Tuple
+
+# entry_kind() 的返回值
+KIND_MISSING = "missing"
+KIND_LINK = "link"
+KIND_DIR = "dir"
+KIND_FILE = "file"
+# socket、FIFO、设备文件等运行时产物
+KIND_SPECIAL = "special"
+
+
+def expand(path: str) -> str:
+    """展开 `~` 并转成绝对路径；不解析软链，调用方需要真实路径时自行 realpath。"""
+    return os.path.abspath(os.path.expanduser(path))
+
+
+def is_under(path: str, root: str) -> bool:
+    """path 等于 root 或位于 root 之下。
+
+    必须按路径段比较：直接用 startswith(root) 会把 `~/.claude-shared`
+    误判为位于 `~/.claude` 之下。
+    """
+    root = root.rstrip(os.sep) or os.sep
+    if path == root:
+        return True
+    prefix = root if root.endswith(os.sep) else root + os.sep
+    return path.startswith(prefix)
+
+
+def entry_kind(path: str) -> str:
+    """按 lstat 判断目录项类型，不跟随软链；断开的软链返回 KIND_LINK。"""
+    try:
+        st = os.lstat(path)
+    except FileNotFoundError:
+        return KIND_MISSING
+    if stat.S_ISLNK(st.st_mode):
+        return KIND_LINK
+    if stat.S_ISDIR(st.st_mode):
+        return KIND_DIR
+    if stat.S_ISREG(st.st_mode):
+        return KIND_FILE
+    return KIND_SPECIAL
+
+
+def same_target(link_path: str, target: str) -> bool:
+    """link_path 解析后的真实路径是否与 target 的真实路径相同。
+
+    两边都用 realpath，这样 `~` 写法、多级软链或尾部斜杠都不影响判断。
+    """
+    return os.path.realpath(link_path) == os.path.realpath(target)
+
+
+def atomic_write(path: str, content: str, mode: int = 0o644) -> None:
+    """原子替换 path 的内容：写临时文件、fsync，再用 os.replace 覆盖。
+
+    进程在任何时刻被杀，path 要么是旧内容，要么是完整的新内容，
+    不会出现写了一半的文件。临时文件与目标在同一目录，保证 replace 不跨设备。
+    """
+    directory = os.path.dirname(path) or "."
+    os.makedirs(directory, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(prefix=".multi-claude-", dir=directory)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(content)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.chmod(tmp_path, mode)
+        os.replace(tmp_path, path)
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except FileNotFoundError:
+            pass
+        raise
+    _fsync_dir(directory)
+
+
+def _fsync_dir(directory: str) -> None:
+    # 让 rename 本身落盘；部分文件系统不支持对目录 fsync，失败可以忽略。
+    try:
+        dir_fd = os.open(directory, os.O_RDONLY)
+    except OSError:
+        return
+    try:
+        os.fsync(dir_fd)
+    except OSError:
+        pass
+    finally:
+        os.close(dir_fd)
+
+
+def read_text(path: str) -> Optional[str]:
+    """读取 UTF-8 文本；文件不存在、不可读或不是文本时返回 None。"""
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            return handle.read()
+    except (OSError, UnicodeDecodeError):
+        return None
+
+
+def remove_path(path: str) -> None:
+    """删除一个目录项：软链只删链接本身，目录整体删除，普通文件直接删除。
+
+    路径不存在时什么也不做，便于中断后重跑时重复调用。
+    """
+    kind = entry_kind(path)
+    if kind == KIND_MISSING:
+        return
+    if kind == KIND_DIR:
+        _grant_owner_access(path)
+        shutil.rmtree(path)
+    else:
+        os.unlink(path)
+
+
+def _grant_owner_access(root: str) -> None:
+    """删除前给目录树里的每个目录补上本人的读、写、执行权限。
+
+    没有读或执行权限的目录，rmtree 既列不出内容也删不掉里面的文件；
+    而用 rmtree 的错误回调补权限再重试并不可靠（新版 rmtree 按文件描述符遍历，
+    回调拿到的函数可能是 os.open，直接重调会抛 TypeError）。
+    所以先自上而下补齐权限：父目录先改，os.walk 才能继续列出子目录。软链不跟随、不修改。
+    权限已齐全的目录不动：中途遇到无权修改的目录会抛错，此时已处理过的目录应尽量保持原样。
+    """
+    _add_owner_rwx(root)
+    for dirpath, dirnames, _filenames in os.walk(root, followlinks=False):
+        for name in dirnames:
+            full = os.path.join(dirpath, name)
+            if entry_kind(full) == KIND_DIR:
+                _add_owner_rwx(full)
+
+
+def _add_owner_rwx(path: str) -> None:
+    mode = stat.S_IMODE(os.lstat(path).st_mode)
+    if mode & stat.S_IRWXU != stat.S_IRWXU:
+        os.chmod(path, mode | stat.S_IRWXU)
+
+
+# 清单条目：(类型, 大小, SHA-256 或软链目标)。目录的大小与哈希固定为 0 和空串。
+ManifestEntry = Tuple[str, int, str]
+
+
+def build_manifest(root: str) -> Tuple[Dict[str, ManifestEntry], List[str]]:
+    """递归生成 root 的文件清单，返回 (清单, 跳过的特殊文件相对路径)。
+
+    软链不跟随，只记录链接目标；socket、FIFO、设备文件属于运行时产物，
+    不进清单，单独返回给调用方写日志。
+    """
+    manifest: Dict[str, ManifestEntry] = {}
+    skipped: List[str] = []
+    # onerror 必须抛出：os.walk 默认静默跳过读不了的目录，两侧清单会同样缺一整棵子树，
+    # 校验因此误判“一致”，随后 park 并删除备份，数据就丢了。
+    for dirpath, dirnames, filenames in os.walk(root, onerror=_raise, followlinks=False):
+        rel_dir = os.path.relpath(dirpath, root)
+        entries = [(name, True) for name in dirnames] + [(name, False) for name in filenames]
+        for name, _is_dir_hint in entries:
+            full = os.path.join(dirpath, name)
+            rel = name if rel_dir == "." else os.path.join(rel_dir, name)
+            kind = entry_kind(full)
+            if kind == KIND_LINK:
+                manifest[rel] = (KIND_LINK, 0, os.readlink(full))
+            elif kind == KIND_DIR:
+                manifest[rel] = (KIND_DIR, 0, "")
+            elif kind == KIND_FILE:
+                manifest[rel] = (KIND_FILE, os.lstat(full).st_size, _sha256(full))
+            elif kind == KIND_SPECIAL:
+                skipped.append(rel)
+    return manifest, skipped
+
+
+def _raise(exc: OSError) -> None:
+    raise exc
+
+
+def _sha256(path: str) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def copy_tree(src: str, dst: str, on_progress: Optional[Callable[[str], None]] = None) -> List[str]:
+    """把 src 复制到尚不存在的 dst，返回跳过的特殊文件相对路径。
+
+    与 shutil.copytree 的区别：遇到 socket、FIFO、设备文件时跳过而不是报错
+    （copytree 会抛 `Operation not supported on socket` 并留下半份目标）。
+    软链按软链本身复制；普通文件用 copy2 保留权限位和时间戳。
+    目录权限在内容复制完后再设置，避免只读目录挡住后续写入。
+    on_progress 在每个普通文件复制后调用一次，供测试在复制中途注入中断。
+    """
+    skipped: List[str] = []
+    dir_modes: List[Tuple[str, str]] = []
+    os.makedirs(dst)
+    dir_modes.append((src, dst))
+    for dirpath, dirnames, filenames in os.walk(src, onerror=_raise, followlinks=False):
+        rel_dir = os.path.relpath(dirpath, src)
+        target_dir = dst if rel_dir == "." else os.path.join(dst, rel_dir)
+        for name in list(dirnames) + list(filenames):
+            full = os.path.join(dirpath, name)
+            target = os.path.join(target_dir, name)
+            kind = entry_kind(full)
+            if kind == KIND_LINK:
+                os.symlink(os.readlink(full), target)
+            elif kind == KIND_DIR:
+                os.mkdir(target)
+                dir_modes.append((full, target))
+            elif kind == KIND_FILE:
+                shutil.copy2(full, target, follow_symlinks=False)
+                if on_progress is not None:
+                    on_progress(target)
+            elif kind == KIND_SPECIAL:
+                skipped.append(os.path.relpath(full, src))
+    for source_dir, target_dir in reversed(dir_modes):
+        shutil.copystat(source_dir, target_dir, follow_symlinks=False)
+    return skipped
+
+
+def diff_manifests(expected: Dict[str, ManifestEntry], actual: Dict[str, ManifestEntry]) -> List[str]:
+    """返回两份清单不一致的相对路径（排序后），空列表表示完全一致。"""
+    mismatched = [rel for rel in expected if actual.get(rel) != expected[rel]]
+    mismatched.extend(rel for rel in actual if rel not in expected)
+    return sorted(set(mismatched))

multi_claude/hook.py

@@ -0,0 +1,90 @@
+"""statusLine 钩子入口（方案 feature-hook-latency）。
+
+状态栏每次刷新都会启动一次钩子，它的耗时直接加在显示上，所以这里只导入 os、sys、tempfile：
+读完 stdin 后，把用量采集交给一个与 Claude 断开的后台进程，自己立刻 exec 原命令。
+采集逻辑本身在 statusline.capture，只在后台进程里导入。
+
+不要在本模块顶层导入 multi_claude 的其它模块：那会把 config、platform（含 ctypes）等
+重新带回显示路径。
+"""
+
+import os
+import sys
+import tempfile
+
+HOOK_COMMAND = "statusline-hook"
+SHELL = "/bin/sh"
+# 设为 1 时在本进程同步采集（v0.2.0 的行为）。只供测试判定“不写快照”的场景，不写进 README。
+SYNC_ENV = "MULTI_CLAUDE_HOOK_SYNC"
+
+
+def main(args: list) -> int:
+    """钩子：后台采集用量，再把进程交给 `/bin/sh -c <原命令>`。
+
+    成功时不返回（exec）。只有准备 stdin 或 exec 本身失败时返回 127，这时状态栏为空，
+    原因写到 stderr（Claude 只把它记进调试日志）。采集无论成败都不影响显示。
+    """
+    if len(args) != 1:
+        sys.stderr.write("usage: multi-claude {} COMMAND\n".format(HOOK_COMMAND))
+        return 2
+    original = args[0]
+    data = sys.stdin.buffer.read()
+    if os.environ.get(SYNC_ENV) == "1":
+        _capture(data)
+    else:
+        _capture_in_background(data)
+    try:
+        # stdin 已被读完，原命令需要同样的输入：放进一个已 unlink 的临时文件再接到 fd 0。
+        # 用 exec 而不是子进程，原命令的输出、退出码与收到的信号才与 Claude 直接执行时一致。
+        replay = tempfile.TemporaryFile()
+        replay.write(data)
+        replay.flush()
+        replay.seek(0)
+        os.dup2(replay.fileno(), 0)
+        sys.stdout.flush()
+        sys.stderr.flush()
+        os.execv(SHELL, [SHELL, "-c", original])
+    except OSError as exc:
+        sys.stderr.write("multi-claude {}: cannot run {}: {}\n".format(HOOK_COMMAND, SHELL, exc))
+    return 127
+
+
+def _capture_in_background(data: bytes) -> None:
+    """两次 fork + setsid，让采集在一个与 Claude 断开的孙进程里运行。
+
+    中间进程立即退出并在这里被回收，不留僵尸；孙进程归 init 所有，不在 Claude 的进程组里。
+    孙进程先把 stdio 指向 /dev/null：继承来的 stdout 只要还开着，Claude 就可能一直等它关闭，
+    状态栏又会被采集拖慢。fork 失败只是少采一次，不影响显示。
+    """
+    try:
+        pid = os.fork()
+    except OSError:
+        return
+    if pid > 0:
+        try:
+            os.waitpid(pid, 0)
+        except OSError:
+            pass
+        return
+    # 中间进程与孙进程：无论发生什么都必须 os._exit，绝不能回到上面的 exec 路径。
+    try:
+        os.setsid()
+        if os.fork() > 0:
+            os._exit(0)
+        devnull = os.open(os.devnull, os.O_RDWR)
+        for fd in (0, 1, 2):
+            os.dup2(devnull, fd)
+        _capture(data)
+    except BaseException:  # noqa: BLE001 — 后台进程的任何异常都只能吞掉
+        pass
+    os._exit(0)
+
+
+def _capture(data: bytes) -> None:
+    try:
+        from datetime import datetime, timezone
+
+        from . import statusline
+        statusline.capture(data, os.environ, datetime.now(timezone.utc))
+    except Exception:  # noqa: BLE001 — 采集是旁路，任何异常都不能影响状态栏
+        pass

multi_claude/identity.py

@@ -0,0 +1,94 @@
+"""凭据定位与只读的登录状态探测（方案 §5.1.9）。
+
+Claude Code 在 macOS 上把登录凭据存进钥匙串，服务名由配置目录的路径字符串决定
+（方案 §3 依据 2）；Linux 上存进配置目录里的 `.credentials.json`（依据 3）。
+本模块只计算“凭据应该在哪里”，并查询它是否存在：
+
+- 绝不读取、复制或删除凭据内容；
+- 钥匙串只调用 `security find-generic-password -a <账户> -s <服务名>`，不带 -w / -g，
+  只看退出码。整个工具只有这一处调用 `security`，测试会断言它收到的参数。
+"""
+
+import hashlib
+import os
+import pwd
+import re
+import subprocess
+import sys
+import unicodedata
+
+from .config import IDENTITY_DEFAULT
+
+SERVICE_BASE = "Claude Code-credentials"
+CREDENTIALS_FILE = ".credentials.json"
+
+# probe() 的返回值
+LOGIN_KEYCHAIN = "keychain"
+LOGIN_FILE = "file"
+LOGIN_NONE = "none"
+LOGIN_UNKNOWN = "unknown"
+
+# security 的退出码 44 = errSecItemNotFound（条目不存在）
+_SECURITY_NOT_FOUND = 44
+_KEYCHAIN_ACCOUNT_PATTERN = re.compile(r"^[a-zA-Z0-9._-]+$")
+
+
+def service_name(identity: str, account_dir: str) -> str:
+    """该账号在 macOS 钥匙串里的服务名。
+
+    default 身份不设 CLAUDE_CONFIG_DIR，Claude 用不带后缀的服务名；dir 身份的后缀是
+    启动命令里那串路径（先做 NFC 规范化，与 Claude 的 we() 一致）的 SHA-256 前 8 位。
+    这里假定正式环境（OAUTH_FILE_SUFFIX 为空）：设置了 CLAUDE_CODE_CUSTOM_OAUTH_URL 时
+    服务名中段会多出 `-custom-oauth`，调用方负责提示探测结果可能不准。
+    """
+    if identity == IDENTITY_DEFAULT:
+        return SERVICE_BASE
+    normalized = unicodedata.normalize("NFC", account_dir)
+    suffix = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:8]
+    return "{}-{}".format(SERVICE_BASE, suffix)
+
+
+def keychain_account() -> str:
+    """与 Claude 的 ok() 相同：取 USER，缺失时取当前 uid 的用户名；不合规则时用 claude-code-user。"""
+    user = os.environ.get("USER")
+    if not user:
+        try:
+            user = pwd.getpwuid(os.getuid()).pw_name
+        except KeyError:
+            user = ""
+    if not _KEYCHAIN_ACCOUNT_PATTERN.match(user):
+        return "claude-code-user"
+    return user
+
+
+def credentials_file(account_dir: str) -> str:
+    return os.path.join(account_dir, CREDENTIALS_FILE)
+
+
+def probe(identity: str, account_dir: str) -> str:
+    """返回登录凭据所在的位置：keychain、file、none 或 unknown（查询本身失败）。
+
+    macOS 先查钥匙串，再查凭据文件（钥匙串写入失败时 Claude 会退回到文件）；
+    其它平台只查凭据文件。只用于提示，不参与任何写操作的判定。
+    """
+    keychain_state = LOGIN_NONE
+    if sys.platform == "darwin":
+        keychain_state = _probe_keychain(service_name(identity, account_dir))
+        if keychain_state == LOGIN_KEYCHAIN:
+            return LOGIN_KEYCHAIN
+    if os.path.isfile(credentials_file(account_dir)):
+        return LOGIN_FILE
+    return keychain_state
+
+
+def _probe_keychain(service: str) -> str:
+    try:
+        proc = subprocess.run(["security", "find-generic-password", "-a", keychain_account(), "-s", service],
+                              stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return LOGIN_UNKNOWN
+    if proc.returncode == 0:
+        return LOGIN_KEYCHAIN
+    if proc.returncode == _SECURITY_NOT_FOUND:
+        return LOGIN_NONE
+    return LOGIN_UNKNOWN