mct-cli 0.2.3__py3-none-any.whl

mct/__init__.py

@@ -0,0 +1,5 @@
+"""macOS Configuration Tools - A CLI for managing macOS settings declaratively."""
+
+from importlib.metadata import version
+
+__version__ = version("macos-config-tools")

mct/cli.py

@@ -0,0 +1,224 @@
+import importlib.metadata
+
+import typer
+
+from .commands.dock import dock_app
+from .commands.finder import finder_app
+from .commands.keyboard import keyboard_app
+from .commands.screenshot import screenshot_app
+from .commands.system import system_app
+from .config import (
+    CONFIG_PATH,
+    SETTINGS,
+    apply_config,
+    compute_diff,
+    flatten_config,
+    load_config,
+    read_current_state,
+    save_config,
+    unflatten_config,
+)
+
+app = typer.Typer()
+app.add_typer(dock_app, name="dock", help="Manage dock settings")
+app.add_typer(finder_app, name="finder", help="Manage Finder settings")
+app.add_typer(keyboard_app, name="keyboard", help="Manage keyboard settings")
+app.add_typer(screenshot_app, name="screenshot", help="Manage screenshot settings")
+app.add_typer(system_app, name="system", help="Manage system settings")
+
+
+def _version_callback(value: bool):
+    if value:
+        version = importlib.metadata.version("macos-config-tools")
+        typer.echo(f"mct version: {version}")
+        raise typer.Exit()
+
+
+@app.callback()
+def callback(
+    version: bool = typer.Option(
+        False, "--version", "-v", help="Show the version and exit.", callback=_version_callback
+    )
+):
+    """macOS Configuration Tools - Manage macOS system settings declaratively."""
+    pass
+
+
+@app.command()
+def apply(
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Show what would change without applying"),
+    config_file: str = typer.Option(None, "--config", "-c", help="Path to config file"),
+):
+    """Apply settings from config file to the system."""
+    path = config_file if config_file else CONFIG_PATH
+
+    if config_file:
+        from pathlib import Path
+        path = Path(config_file)
+        if not path.exists():
+            typer.echo(f"Error: Config file not found: {path}")
+            raise typer.Exit(1)
+        import yaml
+        with open(path) as f:
+            config = yaml.safe_load(f) or {}
+    else:
+        config = load_config()
+
+    if not config:
+        typer.echo(f"No config file found at {CONFIG_PATH}")
+        typer.echo("Run 'mct export' to create one from current settings")
+        raise typer.Exit(1)
+
+    flat_config = flatten_config(config)
+
+    # Filter to only known settings
+    valid_config = {k: v for k, v in flat_config.items() if k in SETTINGS}
+    unknown_keys = set(flat_config.keys()) - set(SETTINGS.keys())
+
+    if unknown_keys:
+        typer.echo(f"Warning: Unknown settings will be ignored: {', '.join(sorted(unknown_keys))}")
+
+    diffs = apply_config(valid_config, dry_run=dry_run)
+
+    if not diffs:
+        typer.echo("System is already in sync with config")
+        return
+
+    if dry_run:
+        typer.echo("Changes that would be applied:")
+    else:
+        typer.echo("Applied changes:")
+
+    for diff in diffs:
+        current = diff.current if diff.current is not None else "(not set)"
+        typer.echo(f"  {diff.key}: {current} -> {diff.desired}")
+
+    if dry_run:
+        typer.echo(f"\nRun without --dry-run to apply {len(diffs)} change(s)")
+
+
+@app.command()
+def export(
+    output: str = typer.Option(None, "--output", "-o", help="Output file path (default: stdout)"),
+    save: bool = typer.Option(False, "--save", "-s", help=f"Save to {CONFIG_PATH}"),
+):
+    """Export current system settings to YAML."""
+    import yaml
+
+    current_state = read_current_state()
+    config = unflatten_config(current_state)
+
+    yaml_output = yaml.dump(config, default_flow_style=False, sort_keys=False)
+
+    if save:
+        save_config(config)
+        typer.echo(f"Config saved to {CONFIG_PATH}")
+    elif output:
+        from pathlib import Path
+        Path(output).parent.mkdir(parents=True, exist_ok=True)
+        with open(output, "w") as f:
+            f.write(yaml_output)
+        typer.echo(f"Config exported to {output}")
+    else:
+        typer.echo(yaml_output)
+
+
+@app.command()
+def diff(
+    config_file: str = typer.Option(None, "--config", "-c", help="Path to config file"),
+):
+    """Show differences between config file and current system state."""
+    if config_file:
+        from pathlib import Path
+        path = Path(config_file)
+        if not path.exists():
+            typer.echo(f"Error: Config file not found: {path}")
+            raise typer.Exit(1)
+        import yaml
+        with open(path) as f:
+            config = yaml.safe_load(f) or {}
+    else:
+        config = load_config()
+
+    if not config:
+        typer.echo(f"No config file found at {CONFIG_PATH}")
+        typer.echo("Run 'mct export --save' to create one")
+        raise typer.Exit(1)
+
+    flat_config = flatten_config(config)
+    valid_config = {k: v for k, v in flat_config.items() if k in SETTINGS}
+
+    diffs = compute_diff(valid_config)
+
+    if not diffs:
+        typer.echo("System is in sync with config")
+        return
+
+    typer.echo(f"Found {len(diffs)} difference(s):\n")
+    for d in diffs:
+        current = d.current if d.current is not None else "(not set)"
+        typer.echo(f"  {d.key}:")
+        typer.echo(f"    current: {current}")
+        typer.echo(f"    config:  {d.desired}")
+        typer.echo()
+
+
+@app.command()
+def settings():
+    """List all available settings."""
+    typer.echo("Available settings:\n")
+
+    # Group by category
+    categories: dict[str, list[str]] = {}
+    for key in sorted(SETTINGS.keys()):
+        category = key.split(".")[0]
+        if category not in categories:
+            categories[category] = []
+        categories[category].append(key)
+
+    for category, keys in categories.items():
+        typer.echo(f"{category}:")
+        for key in keys:
+            setting = SETTINGS[key]
+            typer.echo(f"  {key}: {setting.description}")
+        typer.echo()
+
+
+@app.command()
+def init():
+    """Create a starter config file with common settings."""
+    if CONFIG_PATH.exists():
+        if not typer.confirm(f"Config already exists at {CONFIG_PATH}. Overwrite?"):
+            raise typer.Exit(0)
+
+    starter_config = {
+        "dock": {
+            "size": 48,
+            "autohide": False,
+            "show_recents": False,
+        },
+        "finder": {
+            "show_extensions": True,
+            "show_hidden": False,
+            "show_path_bar": True,
+        },
+        "screenshot": {
+            "format": "png",
+            "disable_shadow": True,
+        },
+        "keyboard": {
+            "press_and_hold": False,
+        },
+    }
+
+    save_config(starter_config)
+    typer.echo(f"Created starter config at {CONFIG_PATH}")
+    typer.echo("Edit the file, then run 'mct apply' to apply settings")
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

mct/commands/dock.py

@@ -0,0 +1,164 @@
+"""Dock settings management."""
+
+from typing import Optional
+
+import typer
+
+from ..defaults import read, write, restart_app
+
+dock_app = typer.Typer()
+
+# Valid values for on/off commands
+ON_VALUES = ("on", "true", "1", "yes")
+OFF_VALUES = ("off", "false", "0", "no")
+
+
+def parse_bool(value: str) -> bool | None:
+    """Parse a boolean string value."""
+    if value.lower() in ON_VALUES:
+        return True
+    if value.lower() in OFF_VALUES:
+        return False
+    return None
+
+
+@dock_app.command()
+def size(value: Optional[int] = typer.Argument(None, help="Size (32-128)")):
+    """Get or set dock icon size."""
+    if value is None:
+        current = read("com.apple.dock", "tilesize")
+        typer.echo(current if current else "64 (default)")
+        return
+
+    if not 32 <= value <= 128:
+        typer.echo("Error: size must be between 32 and 128")
+        raise typer.Exit(1)
+
+    write("com.apple.dock", "tilesize", value, "int")
+    restart_app("Dock")
+    typer.echo(f"Dock size set to {value}")
+
+
+@dock_app.command()
+def autohide(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set dock auto-hide."""
+    if value is None:
+        current = read("com.apple.dock", "autohide")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.dock", "autohide", parsed, "bool")
+    restart_app("Dock")
+    typer.echo(f"Dock auto-hide {'enabled' if parsed else 'disabled'}")
+
+
+@dock_app.command()
+def locked(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set dock size lock."""
+    if value is None:
+        current = read("com.apple.dock", "size-immutable")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.dock", "size-immutable", parsed, "bool")
+    restart_app("Dock")
+    typer.echo(f"Dock size {'locked' if parsed else 'unlocked'}")
+
+
+@dock_app.command()
+def magnification(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set dock magnification."""
+    if value is None:
+        current = read("com.apple.dock", "magnification")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.dock", "magnification", parsed, "bool")
+    restart_app("Dock")
+    typer.echo(f"Dock magnification {'enabled' if parsed else 'disabled'}")
+
+
+@dock_app.command()
+def recents(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set showing recent apps in dock."""
+    if value is None:
+        current = read("com.apple.dock", "show-recents")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.dock", "show-recents", parsed, "bool")
+    restart_app("Dock")
+    typer.echo(f"Recent apps {'shown' if parsed else 'hidden'}")
+
+
+POSITIONS = ("left", "bottom", "right")
+
+
+@dock_app.command()
+def position(value: Optional[str] = typer.Argument(None, help="left/bottom/right")):
+    """Get or set dock position."""
+    if value is None:
+        current = read("com.apple.dock", "orientation")
+        typer.echo(current if current else "bottom")
+        return
+
+    if value.lower() not in POSITIONS:
+        typer.echo(f"Error: use {', '.join(POSITIONS)}")
+        raise typer.Exit(1)
+
+    write("com.apple.dock", "orientation", value.lower(), "string")
+    restart_app("Dock")
+    typer.echo(f"Dock position set to {value.lower()}")
+
+
+SETTINGS_MAP = {
+    "size": ("com.apple.dock", "tilesize", "int", 64),
+    "autohide": ("com.apple.dock", "autohide", "bool", False),
+    "locked": ("com.apple.dock", "size-immutable", "bool", False),
+    "magnification": ("com.apple.dock", "magnification", "bool", False),
+    "recents": ("com.apple.dock", "show-recents", "bool", True),
+    "position": ("com.apple.dock", "orientation", "string", "bottom"),
+}
+
+
+@dock_app.command()
+def reset(setting: Optional[str] = typer.Argument(None, help="Setting to reset (or omit for all)")):
+    """Reset dock settings to macOS defaults."""
+    if setting is None:
+        # Reset all
+        for name, (domain, key, vtype, default) in SETTINGS_MAP.items():
+            write(domain, key, default, vtype)
+            typer.echo(f"  {name}: reset to {default}")
+        restart_app("Dock")
+        typer.echo("All dock settings reset")
+        return
+
+    if setting not in SETTINGS_MAP:
+        typer.echo(f"Error: unknown setting '{setting}'")
+        typer.echo(f"Available: {', '.join(SETTINGS_MAP.keys())}")
+        raise typer.Exit(1)
+
+    domain, key, vtype, default = SETTINGS_MAP[setting]
+    write(domain, key, default, vtype)
+    restart_app("Dock")
+    typer.echo(f"Dock {setting} reset to {default}")

mct/commands/finder.py

@@ -0,0 +1,153 @@
+"""Finder settings management."""
+
+from typing import Optional
+
+import typer
+
+from ..defaults import read, write, restart_app
+
+finder_app = typer.Typer()
+
+ON_VALUES = ("on", "true", "1", "yes")
+OFF_VALUES = ("off", "false", "0", "no")
+
+
+def parse_bool(value: str) -> bool | None:
+    """Parse a boolean string value."""
+    if value.lower() in ON_VALUES:
+        return True
+    if value.lower() in OFF_VALUES:
+        return False
+    return None
+
+
+@finder_app.command()
+def extensions(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set showing all file extensions."""
+    if value is None:
+        current = read("NSGlobalDomain", "AppleShowAllExtensions")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("NSGlobalDomain", "AppleShowAllExtensions", parsed, "bool")
+    restart_app("Finder")
+    typer.echo(f"File extensions {'shown' if parsed else 'hidden'}")
+
+
+@finder_app.command()
+def hidden(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set showing hidden files (dotfiles)."""
+    if value is None:
+        current = read("com.apple.finder", "AppleShowAllFiles")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.finder", "AppleShowAllFiles", parsed, "bool")
+    restart_app("Finder")
+    typer.echo(f"Hidden files {'shown' if parsed else 'hidden'}")
+
+
+@finder_app.command()
+def pathbar(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set showing path bar at bottom."""
+    if value is None:
+        current = read("com.apple.finder", "ShowPathbar")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.finder", "ShowPathbar", parsed, "bool")
+    restart_app("Finder")
+    typer.echo(f"Path bar {'shown' if parsed else 'hidden'}")
+
+
+@finder_app.command()
+def statusbar(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set showing status bar at bottom."""
+    if value is None:
+        current = read("com.apple.finder", "ShowStatusBar")
+        typer.echo("on" if current else "off")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    write("com.apple.finder", "ShowStatusBar", parsed, "bool")
+    restart_app("Finder")
+    typer.echo(f"Status bar {'shown' if parsed else 'hidden'}")
+
+
+VIEW_STYLES = {
+    "icon": "icnv",
+    "list": "Nlsv",
+    "column": "clmv",
+    "gallery": "glyv",
+}
+VIEW_STYLES_REVERSE = {v: k for k, v in VIEW_STYLES.items()}
+
+
+@finder_app.command()
+def view(style: Optional[str] = typer.Argument(None, help="icon/list/column/gallery")):
+    """Get or set default Finder view style."""
+    if style is None:
+        current = read("com.apple.finder", "FXPreferredViewStyle")
+        name = VIEW_STYLES_REVERSE.get(current, current or "icon")
+        typer.echo(name)
+        return
+
+    if style.lower() not in VIEW_STYLES:
+        typer.echo(f"Error: use {', '.join(VIEW_STYLES.keys())}")
+        raise typer.Exit(1)
+
+    write("com.apple.finder", "FXPreferredViewStyle", VIEW_STYLES[style.lower()], "string")
+    restart_app("Finder")
+    typer.echo(f"Default view set to {style.lower()}")
+
+
+SETTINGS_MAP = {
+    "extensions": ("NSGlobalDomain", "AppleShowAllExtensions", "bool", True),
+    "hidden": ("com.apple.finder", "AppleShowAllFiles", "bool", False),
+    "pathbar": ("com.apple.finder", "ShowPathbar", "bool", False),
+    "statusbar": ("com.apple.finder", "ShowStatusBar", "bool", False),
+    "view": ("com.apple.finder", "FXPreferredViewStyle", "string", "icnv"),
+}
+
+
+@finder_app.command()
+def reset(setting: Optional[str] = typer.Argument(None, help="Setting to reset (or omit for all)")):
+    """Reset Finder settings to macOS defaults."""
+    if setting is None:
+        for name, (domain, key, vtype, default) in SETTINGS_MAP.items():
+            write(domain, key, default, vtype)
+            display = default if vtype != "bool" else ("on" if default else "off")
+            typer.echo(f"  {name}: reset to {display}")
+        restart_app("Finder")
+        typer.echo("All Finder settings reset")
+        return
+
+    if setting not in SETTINGS_MAP:
+        typer.echo(f"Error: unknown setting '{setting}'")
+        typer.echo(f"Available: {', '.join(SETTINGS_MAP.keys())}")
+        raise typer.Exit(1)
+
+    domain, key, vtype, default = SETTINGS_MAP[setting]
+    write(domain, key, default, vtype)
+    restart_app("Finder")
+    display = default if vtype != "bool" else ("on" if default else "off")
+    typer.echo(f"Finder {setting} reset to {display}")

mct/commands/keyboard.py

@@ -0,0 +1,72 @@
+"""Keyboard settings management."""
+
+from typing import Optional
+
+import typer
+
+from ..defaults import read, write
+
+keyboard_app = typer.Typer()
+
+ON_VALUES = ("on", "true", "1", "yes")
+OFF_VALUES = ("off", "false", "0", "no")
+
+
+def parse_bool(value: str) -> bool | None:
+    """Parse a boolean string value."""
+    if value.lower() in ON_VALUES:
+        return True
+    if value.lower() in OFF_VALUES:
+        return False
+    return None
+
+
+@keyboard_app.command()
+def repeat(value: Optional[str] = typer.Argument(None, help="on/off")):
+    """Get or set key repeat (off = press-and-hold for accents)."""
+    if value is None:
+        # ApplePressAndHoldEnabled=true means repeat is OFF (accents ON)
+        press_hold = read("NSGlobalDomain", "ApplePressAndHoldEnabled")
+        typer.echo("off" if press_hold else "on")
+        return
+
+    parsed = parse_bool(value)
+    if parsed is None:
+        typer.echo("Error: use 'on' or 'off'")
+        raise typer.Exit(1)
+
+    # Invert: repeat on = press-and-hold off
+    write("NSGlobalDomain", "ApplePressAndHoldEnabled", not parsed, "bool")
+    if parsed:
+        typer.echo("Key repeat enabled (press-and-hold for accents disabled)")
+    else:
+        typer.echo("Key repeat disabled (press-and-hold for accents enabled)")
+    typer.echo("Note: restart apps to apply")
+
+
+SETTINGS_MAP = {
+    "repeat": ("NSGlobalDomain", "ApplePressAndHoldEnabled", "bool", True),  # True = repeat OFF
+}
+
+
+@keyboard_app.command()
+def reset(setting: Optional[str] = typer.Argument(None, help="Setting to reset (or omit for all)")):
+    """Reset keyboard settings to macOS defaults."""
+    if setting is None:
+        for name, (domain, key, vtype, default) in SETTINGS_MAP.items():
+            write(domain, key, default, vtype)
+            # Default is press-and-hold ON (repeat OFF)
+            typer.echo(f"  {name}: reset to off (press-and-hold enabled)")
+        typer.echo("All keyboard settings reset")
+        typer.echo("Note: restart apps to apply")
+        return
+
+    if setting not in SETTINGS_MAP:
+        typer.echo(f"Error: unknown setting '{setting}'")
+        typer.echo(f"Available: {', '.join(SETTINGS_MAP.keys())}")
+        raise typer.Exit(1)
+
+    domain, key, vtype, default = SETTINGS_MAP[setting]
+    write(domain, key, default, vtype)
+    typer.echo(f"Keyboard {setting} reset to off (press-and-hold enabled)")
+    typer.echo("Note: restart apps to apply")