awsettings 0.1.0__py3-none-any.whl

awsettings/__init__.py

@@ -0,0 +1,15 @@
+"""awsettings — your agent's permissions and config, following you to the next machine.
+
+An agent harness keeps its permission allowlist, enabled tool servers and hooks in
+a local file. Work from a second machine and none of it is there: you re-approve
+the same action, by hand, once per surface, forever, while the copies drift apart
+and every one of them looks correct.
+
+    awsettings status
+    awsettings pull
+    awsettings push
+    awsettings hook install
+"""
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

awsettings/cli.py

@@ -0,0 +1,323 @@
+"""awsettings — your agent's permissions and config, following you to the next machine.
+
+    awsettings status                 what is here, what is remote, what differs
+    awsettings pull                   remote -> local (union; never drops a deny)
+    awsettings push                   local  -> remote (credentials stripped)
+    awsettings hook install           run it automatically from now on
+    awsettings hook uninstall
+    awsettings --self-test
+
+Exit **0** did the thing · **1** a rule refused it · **2** could not judge — the
+profile was unreachable, or a settings file would not parse. Never 0 for "I could
+not look": a sync that silently did nothing and one that had nothing to do are
+the same green run otherwise, and telling them apart is the whole point.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+from . import __version__
+from .core import SECRET_KEYS, diff_summary, merge, redact
+from .hooks import install_to, installed, uninstall_from
+from .profile import resolve
+from .store import CouldNotRunError, local_settings_path, read_json, write_json
+from .trust import UntrustedProfileError
+
+DEBOUNCE_STAMP = Path.home() / ".awsettings" / "last-push"
+DEBOUNCE_SECONDS = 5.0
+
+
+def _root(args) -> Path | None:
+    if args.user:
+        return None
+    return Path(args.root or os.getcwd())
+
+
+def cmd_status(args) -> int:
+    target = local_settings_path(_root(args))
+    backend = resolve(args.url, args.profile)
+    local = read_json(target)
+    try:
+        remote = backend.get()
+    except CouldNotRunError as exc:
+        print(f"local:  {target}")
+        print(f"remote: {backend.describe()}")
+        print(f"DEAD: {exc}")
+        return 2
+    merged = merge(local, remote)
+    lines = diff_summary(local, merged)
+    print(f"local:  {target} ({'present' if target.is_file() else 'absent'})")
+    print(f"remote: {backend.describe()}")
+    print(f"hooks:  {', '.join(installed(local)) or 'not installed'}")
+    if not lines:
+        print("in step: a pull would change nothing")
+        return 0
+    print(f"a pull would apply {len(lines)} change(s):")
+    for ln in lines:
+        print("  " + ln)
+    return 0
+
+
+def cmd_pull(args) -> int:
+    target = local_settings_path(_root(args))
+    backend = resolve(args.url, args.profile)
+    try:
+        local = read_json(target)
+        remote = backend.get()
+    except CouldNotRunError as exc:
+        # Offline is the normal state of a laptop. Say so and keep the local file.
+        if not args.quiet:
+            print(f"DEAD: {exc}")
+        return 2
+    merged = merge(local, remote, prune_denies=args.prune_denies)
+    lines = diff_summary(local, merged)
+    if not lines:
+        if not args.quiet:
+            print("already in step")
+        return 0
+    if args.dry_run:
+        print(f"would apply {len(lines)} change(s) to {target}:")
+        for ln in lines:
+            print("  " + ln)
+        return 0
+    write_json(target, merged)
+    if not args.quiet:
+        print(f"applied {len(lines)} change(s) to {target}:")
+        for ln in lines:
+            print("  " + ln)
+    return 0
+
+
+def cmd_push(args) -> int:
+    if args.debounce:
+        try:
+            last = DEBOUNCE_STAMP.stat().st_mtime
+            if time.time() - last < DEBOUNCE_SECONDS:
+                return 0
+        except OSError:
+            pass
+    target = local_settings_path(_root(args))
+    backend = resolve(args.url, args.profile)
+    try:
+        local = read_json(target)
+    except CouldNotRunError as exc:
+        if not args.quiet:
+            print(f"DEAD: {exc}")
+        return 2
+    snapshot = redact(local)
+    if args.dry_run:
+        print(json.dumps(snapshot, indent=2))
+        return 0
+    try:
+        backend.put(snapshot)
+    except CouldNotRunError as exc:
+        if not args.quiet:
+            print(f"DEAD: {exc}")
+        return 2
+    DEBOUNCE_STAMP.parent.mkdir(parents=True, exist_ok=True)
+    DEBOUNCE_STAMP.write_text(str(time.time()), encoding="utf-8")
+    if not args.quiet:
+        kept = sorted(snapshot)
+        dropped = sorted(k for k in local if k not in snapshot)
+        print(f"pushed {len(kept)} key(s) to {backend.describe()}")
+        if kept:
+            print("  sent:    " + ", ".join(kept))
+        if dropped:
+            print("  kept local: " + ", ".join(dropped))
+    return 0
+
+
+def cmd_hook(args) -> int:
+    target = local_settings_path(_root(args))
+    if args.action == "install":
+        path, evs = install_to(target)
+        print(f"installed into {path}: {', '.join(evs) or 'nothing'}")
+        print("  SessionStart -> pull   (a new machine is stale before its first tool call)")
+        print("  PostToolUse  -> push   (debounced; a rule you approve here is on its way)")
+        return 0
+    path, evs = uninstall_from(target)
+    print(f"removed from {path}; still installed: {', '.join(evs) or 'nothing'}")
+    return 0
+
+
+def self_test() -> int:
+    """Offline proof of the properties that can do harm. No network, no profile."""
+    import tempfile
+    problems: list[str] = []
+
+    # --- redaction: by NAME, not by shape --------------------------------
+    src = {
+        "env": {"OPENAI_API_KEY": "sk-real"},
+        "apiKeyHelper": "/bin/print-my-token",
+        "sandbox": {"enabled": True, "credentials": {"envVars": [{"name": "X"}]}},
+        "permissions": {"allow": ["Bash(git *)"]},
+        "someLocalExperiment": 1,
+    }
+    red = redact(src)
+    for k in ("env", "apiKeyHelper"):
+        if k in red:
+            problems.append(f"redact() let the credential key {k!r} through")
+    # Both halves, because the first alone passes VACUOUSLY when `sandbox` is not
+    # synced at all — which is exactly the state this shipped in, making the guard
+    # unreachable while its check stayed green.
+    if "sandbox" not in red:
+        problems.append("redact() dropped `sandbox` entirely, so the credential-subkey "
+                        "guard is unreachable — a protection nothing can run")
+    elif "credentials" in red["sandbox"]:
+        problems.append("redact() left sandbox.credentials in the snapshot")
+    elif red["sandbox"].get("enabled") is not True:
+        problems.append("redact() stripped more of `sandbox` than the credentials")
+    if "someLocalExperiment" in red:
+        problems.append("redact() pushed an unknown local key instead of leaving it home")
+    if src["env"]["OPENAI_API_KEY"] != "sk-real":
+        problems.append("redact() MUTATED its input")
+
+    # --- merge: union, not replace ---------------------------------------
+    local = {"permissions": {"allow": ["Bash(local *)"], "deny": ["Bash(rm -rf *)"]},
+             "enabledMcpjsonServers": ["aitheros"], "env": {"S": "keep"}}
+    remote = {"permissions": {"allow": ["Bash(portal *)"]},
+              "enabledMcpjsonServers": ["awsh"]}
+    m = merge(local, remote)
+    if sorted(m["permissions"]["allow"]) != ["Bash(local *)", "Bash(portal *)"]:
+        problems.append("merge() did not UNION allow rules — a device silently loses "
+                        "the rule the other one never had")
+    if m["permissions"]["deny"] != ["Bash(rm -rf *)"]:
+        problems.append("merge() dropped a local deny the remote did not carry")
+    if sorted(m["enabledMcpjsonServers"]) != ["aitheros", "awsh"]:
+        problems.append("merge() did not union enabledMcpjsonServers")
+    if m.get("env", {}).get("S") != "keep":
+        problems.append("merge() lost a device-local secret it must never touch")
+    if local["permissions"]["allow"] != ["Bash(local *)"]:
+        problems.append("merge() MUTATED its local input")
+
+    # --- a profile may not push credentials DOWN --------------------------
+    if merge({}, {"env": {"X": "y"}}).get("env") is not None:
+        problems.append("merge() accepted an env block pushed from the profile — a "
+                        "settings profile is not a secret channel")
+
+    # --- deny is one-way unless explicitly pruned -------------------------
+    if merge({"permissions": {"deny": ["Bash(curl *)"]}},
+             {"permissions": {"deny": []}})["permissions"]["deny"] != ["Bash(curl *)"]:
+        problems.append("a deny was dropped by a default sync — the one direction this "
+                        "must never go")
+    if merge({"permissions": {"deny": ["Bash(curl *)"]}}, {"permissions": {"deny": []}},
+             prune_denies=True)["permissions"]["deny"] != []:
+        problems.append("prune_denies=True did not prune")
+
+    # --- hooks are idempotent --------------------------------------------
+    from .hooks import plan
+    once = plan({})
+    twice = plan(once)
+    n = len(twice["hooks"]["SessionStart"])
+    if n != 1:
+        problems.append(f"installing twice left {n} SessionStart hooks — a hook that "
+                        f"accumulates runs N times per event")
+    if plan({"hooks": {"SessionStart": [{"matcher": "", "hooks": [
+            {"type": "command", "command": "somebody-elses-hook"}]}]}
+            })["hooks"]["SessionStart"].__len__() != 2:
+        problems.append("install clobbered somebody else's hook instead of adding to it")
+    from .hooks import uninstall as hk_uninstall
+    if installed(hk_uninstall(twice)):
+        problems.append("uninstall left one of our hooks behind")
+
+    # --- a malformed settings file RAISES, never reads as empty -----------
+    with tempfile.TemporaryDirectory() as td:
+        bad = Path(td) / "settings.local.json"
+        bad.write_text("{ not json", encoding="utf-8")
+        try:
+            read_json(bad)
+            problems.append("a malformed settings file read as EMPTY — that is how a "
+                            "sync overwrites a half-finished edit")
+        except CouldNotRunError:
+            pass
+        # ...and a write is atomic: no .tmp left behind.
+        good = Path(td) / "out.json"
+        write_json(good, {"a": 1})
+        if list(Path(td).glob("*.tmp")):
+            problems.append("write_json left a .tmp file behind")
+        if json.loads(good.read_text(encoding="utf-8")) != {"a": 1}:
+            problems.append("write_json did not write what it was given")
+
+    # --- the write target is the personal file ---------------------------
+    with tempfile.TemporaryDirectory() as td:
+        if local_settings_path(Path(td)).name != "settings.local.json":
+            problems.append("the write target is not settings.local.json — syncing into "
+                            "the committed settings.json hands the whole team one "
+                            "person's permission rules")
+
+    # --- the secret list is not empty ------------------------------------
+    if not SECRET_KEYS:
+        problems.append("the credential denylist is empty, so redact() is a no-op")
+
+    if problems:
+        print("SELF-TEST FAILED:")
+        for p in problems:
+            print("  x " + p)
+        return 1
+    print("self-test ok: credentials never leave or arrive, arrays union instead of "
+          "replacing, a deny is never dropped by default, hooks install once and do not "
+          "clobber, a malformed file refuses rather than reading empty, writes are "
+          "atomic, and the target is the personal settings file")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="awsettings",
+                                 description=__doc__.splitlines()[0])
+    ap.add_argument("--version", action="version", version=f"awsettings {__version__}")
+    ap.add_argument("--self-test", action="store_true")
+    ap.add_argument("--root", help="project root (default: cwd)")
+    ap.add_argument("--user", action="store_true",
+                    help="act on the user-level settings instead of a project's")
+    ap.add_argument("--url", help="profile endpoint (default: $AWSETTINGS_URL)")
+    ap.add_argument("--profile", help="profile FILE (default: $AWSETTINGS_PROFILE)")
+    ap.add_argument("--quiet", action="store_true")
+    sub = ap.add_subparsers(dest="cmd")
+
+    sub.add_parser("status")
+    p = sub.add_parser("pull")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--prune-denies", action="store_true",
+                   help="allow the profile to REMOVE deny/ask rules (off by default: a "
+                        "lost deny costs the thing it prevented)")
+    p = sub.add_parser("push")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--debounce", action="store_true")
+    p = sub.add_parser("hook")
+    p.add_argument("action", choices=["install", "uninstall"])
+
+    args = ap.parse_args(argv)
+    if args.self_test:
+        return self_test()
+    for name in ("dry_run", "prune_denies", "debounce"):
+        if not hasattr(args, name):
+            setattr(args, name, False)
+
+    try:
+        if args.cmd == "status":
+            return cmd_status(args)
+        if args.cmd == "pull":
+            return cmd_pull(args)
+        if args.cmd == "push":
+            return cmd_push(args)
+        if args.cmd == "hook":
+            return cmd_hook(args)
+    except UntrustedProfileError as exc:
+        # A profile that cannot be proven yours is REFUSED, and the settings
+        # are not applied. This is the one failure that must never be quiet.
+        print(f"REFUSED: {exc}")
+        return 2
+    except CouldNotRunError as exc:
+        print(f"DEAD: {exc}")
+        return 2
+    ap.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

awsettings/core.py

@@ -0,0 +1,180 @@
+"""The merge and the redaction. Pure, offline, and the only place harm can happen.
+
+Everything in this module is a function of its arguments. That is deliberate: the
+two operations that can hurt you — sending a credential somewhere, and losing a
+rule you were relying on — need no network to test, so they are tested without
+one.
+
+THE THREE RULES, each already paid for:
+
+1. **Credentials never travel, and are dropped by NAME.** Not by inspecting the
+   value. A "does this look like a token" heuristic passes every secret that does
+   not look like one, and that failure is invisible until the secret is already
+   published. A name-based denylist is auditable; a shape-based one is a hope.
+
+2. **Arrays UNION; they are never replaced.** A settings file is edited from more
+   than one place, so replace semantics means device B silently loses the rule
+   device A never had. This is not hypothetical: it is what happens to a shared
+   config any time one writer's copy is stamped over another's.
+
+3. **A deny is ONE-WAY.** A sync may ADD a deny or ask rule; it may never drop
+   one. A lost allow rule costs a prompt. A lost deny rule costs the thing the
+   deny existed to prevent — silently, on a machine whose owner still believes it
+   is there. `prune_denies` exists for the deliberate case and is never a default.
+"""
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+#: Array-valued keys that MERGE as a union rather than replacing (rule 2).
+UNION_ARRAYS: tuple[tuple[str, ...], ...] = (
+    ("permissions", "allow"),
+    ("permissions", "deny"),
+    ("permissions", "ask"),
+    ("permissions", "additionalDirectories"),
+    ("enabledMcpjsonServers",),
+    ("disabledMcpjsonServers",),
+)
+
+#: Keys whose VALUES are credentials, or commands that fetch one. Dropped whole
+#: from anything that leaves this machine, and refused on anything arriving.
+SECRET_KEYS = frozenset({
+    "env",                    # arbitrary values, routinely tokens
+    "apiKeyHelper",
+    "proxyAuthHelper",
+    "awsCredentialExport",
+    "awsAuthRefresh",
+    "gcpAuthRefresh",
+    "otelHeadersHelper",
+    "policyHelper",
+})
+
+#: Sub-objects that hold credential material inside an otherwise-syncable key.
+SECRET_SUBKEYS: dict[str, frozenset[str]] = {
+    "sandbox": frozenset({"credentials"}),
+}
+
+#: What is worth syncing. An unknown key is left at home rather than guessed at:
+#: it is far more likely a local experiment than a preference somebody wants
+#: pushed to every machine they own.
+SYNCED_KEYS = frozenset({
+    "permissions",
+    # `sandbox` carries the network allowlist and filesystem rules, which are
+    # exactly the kind of thing you want on every machine — and `sandbox.credentials`,
+    # which is exactly what must not travel. That pairing is why SECRET_SUBKEYS
+    # exists at all; leaving `sandbox` out of this set made that guard UNREACHABLE,
+    # i.e. deleted code wearing the shape of a protection. Caught by a test that
+    # asserted the strip, not by reading it.
+    "sandbox",
+    "enabledMcpjsonServers",
+    "disabledMcpjsonServers",
+    "enableAllProjectMcpServers",
+    "hooks",
+    "outputStyle",
+    "statusLine",
+    "alwaysThinkingEnabled",
+    "autoCompactEnabled",
+    "spinnerTipsEnabled",
+    "todoFeatureEnabled",
+    "attribution",
+})
+
+
+def redact(settings: dict[str, Any]) -> dict[str, Any]:
+    """The snapshot that may leave this machine. Never mutates the input."""
+    out: dict[str, Any] = {}
+    for k, v in settings.items():
+        if k in SECRET_KEYS or k not in SYNCED_KEYS:
+            continue
+        if k in SECRET_SUBKEYS and isinstance(v, dict):
+            v = {sk: sv for sk, sv in v.items() if sk not in SECRET_SUBKEYS[k]}
+        out[k] = copy.deepcopy(v)
+    return out
+
+
+def _get(d: dict[str, Any], path: tuple[str, ...]) -> Any:
+    cur: Any = d
+    for seg in path:
+        if not isinstance(cur, dict) or seg not in cur:
+            return None
+        cur = cur[seg]
+    return cur
+
+
+def _set(d: dict[str, Any], path: tuple[str, ...], value: Any) -> None:
+    cur = d
+    for seg in path[:-1]:
+        nxt = cur.get(seg)
+        if not isinstance(nxt, dict):
+            nxt = {}
+            cur[seg] = nxt
+        cur = nxt
+    cur[path[-1]] = value
+
+
+def merge(local: dict[str, Any], remote: dict[str, Any], *,
+          prune_denies: bool = False) -> dict[str, Any]:
+    """Remote over local, UNION on the array keys, credentials untouched.
+
+    Neither input is mutated. A credential block arriving from the remote is
+    REFUSED — a settings profile is not a secret channel, and a client that
+    accepts one becomes a way to push an `apiKeyHelper` at somebody.
+    """
+    out = copy.deepcopy(local)
+
+    for k, v in remote.items():
+        if k in SECRET_KEYS:
+            continue
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            merged = dict(out[k])
+            merged.update(v)
+            out[k] = merged
+        else:
+            out[k] = copy.deepcopy(v)
+
+    for path in UNION_ARRAYS:
+        lv, rv = _get(local, path), _get(remote, path)
+        if lv is None and rv is None:
+            continue
+        lv = lv if isinstance(lv, list) else []
+        rv = rv if isinstance(rv, list) else []
+        if prune_denies and path[-1] in ("deny", "ask"):
+            union = list(rv)
+        else:
+            union = list(lv)
+            union += [x for x in rv if x not in union]
+        _set(out, path, union)
+
+    # Device-local secrets survive verbatim. Stated explicitly rather than left
+    # to fall out of the loop above, because "preserved by omission" is exactly
+    # the kind of property a later refactor removes without noticing.
+    for k in SECRET_KEYS:
+        if k in local:
+            out[k] = copy.deepcopy(local[k])
+    return out
+
+
+def diff_summary(before: dict[str, Any], after: dict[str, Any]) -> list[str]:
+    """Human-readable list of what a merge actually changed.
+
+    A sync that reports "ok" and cannot say what it did is indistinguishable
+    from one that did nothing, which is how drift goes unnoticed for months.
+    """
+    lines: list[str] = []
+    for path in UNION_ARRAYS:
+        b = _get(before, path) or []
+        a = _get(after, path) or []
+        added = [x for x in a if x not in b]
+        removed = [x for x in b if x not in a]
+        label = ".".join(path)
+        for x in added:
+            lines.append(f"+ {label}: {x}")
+        for x in removed:
+            lines.append(f"- {label}: {x}")
+    for k in sorted(set(before) | set(after)):
+        if k in SECRET_KEYS or any(k == p[0] for p in UNION_ARRAYS):
+            continue
+        if before.get(k) != after.get(k):
+            lines.append(f"~ {k}")
+    return lines

awsettings/hooks.py

@@ -0,0 +1,117 @@
+"""The autonomy half: run the sync when a session opens, not when someone remembers.
+
+**Not a daemon, on purpose.** A background process is a second thing to keep
+alive on every surface this exists to stop hand-maintaining — and when it dies
+it dies quietly, which is the same failure as the drift it was meant to fix.
+A hook runs at a moment that already exists, has an owner, and is visible in the
+config file it lives in.
+
+Two hooks, and the split matters:
+
+* **SessionStart -> pull.** The moment a new machine, shell or container opens a
+  session is exactly when its settings are most likely to be stale, and it is
+  before any tool call has been refused.
+* **A settings write -> push.** Debounced, fail-soft. The trigger is the file
+  actually changing, so a rule you approve on one machine is on its way to the
+  others before you have finished the thought.
+
+Both are installed INTO the settings file the harness already reads, and both
+are idempotent: installing twice leaves one hook, because a hook that
+accumulates copies is a hook that eventually runs N times per event.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .store import read_json, write_json
+
+#: Marker that identifies OUR hook entries. Matching on the command string alone
+#: would fail the moment the command is reworded; a marker key survives that and
+#: makes removal exact rather than best-effort.
+MARKER = "awsettings"
+
+PULL_COMMAND = "awsettings pull --quiet || true"
+PUSH_COMMAND = "awsettings push --quiet --debounce || true"
+
+#: `|| true` on both is deliberate. A settings sync must never be able to fail a
+#: session open or a tool call: offline is the normal state of a laptop, and the
+#: correct behaviour offline is to keep the local file and carry on.
+
+
+def _entry(command: str, status_message: str) -> dict[str, Any]:
+    return {
+        "matcher": "",
+        "hooks": [{
+            "type": "command",
+            "command": command,
+            "timeout": 20,
+            "statusMessage": status_message,   # harness schema key: camelCase is theirs
+            MARKER: True,
+        }],
+    }
+
+
+def _is_ours(group: dict[str, Any]) -> bool:
+    return any(h.get(MARKER) for h in group.get("hooks", []) if isinstance(h, dict))
+
+
+def plan(settings: dict[str, Any]) -> dict[str, Any]:
+    """Return settings with our two hooks installed exactly once. Pure."""
+    import copy
+    out = copy.deepcopy(settings)
+    hooks = out.setdefault("hooks", {})
+    if not isinstance(hooks, dict):
+        raise TypeError("settings.hooks is not an object")
+
+    for event, command, msg in (
+        ("SessionStart", PULL_COMMAND, "Syncing agent settings..."),
+        ("PostToolUse", PUSH_COMMAND, "Pushing agent settings..."),
+    ):
+        groups = [g for g in hooks.get(event, []) if isinstance(g, dict)]
+        # Drop any previous copy of ours before adding, so install is idempotent
+        # and a reworded command replaces rather than accumulates.
+        groups = [g for g in groups if not _is_ours(g)]
+        groups.append(_entry(command, msg))
+        hooks[event] = groups
+    return out
+
+
+def uninstall(settings: dict[str, Any]) -> dict[str, Any]:
+    """Remove only our entries, leaving every other hook untouched."""
+    import copy
+    out = copy.deepcopy(settings)
+    hooks = out.get("hooks")
+    if not isinstance(hooks, dict):
+        return out
+    for event in list(hooks):
+        groups = [g for g in hooks.get(event, [])
+                  if isinstance(g, dict) and not _is_ours(g)]
+        if groups:
+            hooks[event] = groups
+        else:
+            del hooks[event]
+    if not hooks:
+        out.pop("hooks", None)
+    return out
+
+
+def installed(settings: dict[str, Any]) -> list[str]:
+    """Which events currently carry our hook."""
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        return []
+    return sorted(ev for ev, groups in hooks.items()
+                  if any(_is_ours(g) for g in groups if isinstance(g, dict)))
+
+
+def install_to(path: Path) -> tuple[Path, list[str]]:
+    data = read_json(path)
+    write_json(path, plan(data))
+    return path, installed(read_json(path))
+
+
+def uninstall_from(path: Path) -> tuple[Path, list[str]]:
+    data = read_json(path)
+    write_json(path, uninstall(data))
+    return path, installed(read_json(path))