do-again 0.1.1__tar.gz → 0.2.0__tar.gz

{do_again-0.1.1 → do_again-0.2.0}/.github/workflows/npm-release.yml

@@ -32,3 +32,19 @@ jobs:
       - run: npm ci
       - run: npm test
       - run: npm publish
+      - name: Wait for npm registry availability
+        shell: bash
+        run: |
+          version=$(node -p "require('./package.json').version")
+          for attempt in $(seq 1 120); do
+            published=$(npm view "do-again@$version" version 2>/dev/null || true)
+            latest=$(npm view do-again dist-tags.latest 2>/dev/null || true)
+            if [ "$published" = "$version" ] && [ "$latest" = "$version" ]; then
+              echo "do-again@$version is available from the public npm registry"
+              exit 0
+            fi
+            echo "Waiting for npm registry propagation ($attempt/120)..."
+            sleep 15
+          done
+          echo "Timed out waiting for do-again@$version to become publicly available" >&2
+          exit 1

{do_again-0.1.1 → do_again-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: do-again
-Version: 0.1.1
+Version: 0.2.0
 Summary: Policy-controlled local execution for agent-driven development workflows
 Project-URL: Homepage, https://github.com/Tran-Steven/do-again
 Project-URL: Repository, https://github.com/Tran-Steven/do-again
@@ -94,9 +94,27 @@ The npm package ships the same Python runtime from this repository behind a smal
 ```bash
 do-again doctor
 do-again init
+do-again install
 do-again status
 ```
 
+## Service lifecycle
+
+On macOS, Do Again can install a per-repository launchd agent:
+
+    do-again install
+    do-again status
+    do-again restart
+    do-again stop
+    do-again uninstall
+
+For attended or cross-platform use, run the agent in the foreground:
+
+    do-again run
+    do-again run --once
+
+Each repository gets an isolated runtime, control worktree, state directory, policy copy, and service label under ~/.do_again. The installed service runs from a copied runtime so installs made through either PyPI or npm remain stable after the invoking shell exits.
+
 ## Why Do Again
 
 - Explicit policy-based command permissions
@@ -111,11 +129,11 @@ do-again status
 
 | Platform | Status | Service backend |
 | --- | --- | --- |
-| macOS | Core working | launchd |
-| Linux | Adapter scaffolded | systemd user service |
-| Windows | Adapter scaffolded | Windows service |
+| macOS | Service lifecycle working | launchd |
+| Linux | Foreground runner working; service adapter scaffolded | systemd user service |
+| Windows | Foreground runner working; service adapter scaffolded | Windows service |
 
-Do Again is currently alpha software. macOS is the first active service platform while Linux and Windows service integration are being completed behind the same interface.
+Do Again is currently alpha software. The foreground runner works across the supported Python platforms; macOS is the first platform with an installable background service while Linux and Windows service integration are being completed behind the same interface.
 
 ## Development
 
@@ -129,7 +147,7 @@ do-again doctor
 
 ## Release model
 
-Releases use semantic versioning. Pushing a version tag such as `v0.1.1` validates the shared release version, publishes the Python distribution to PyPI and the Node launcher to npm through Trusted Publishing, and creates the matching GitHub Release.
+Releases use semantic versioning. Pushing a version tag such as `v0.2.0` validates the shared release version, publishes the Python distribution to PyPI and the Node launcher to npm through Trusted Publishing, and creates the matching GitHub Release.
 
 PyPI distribution name: `do-again`
 

{do_again-0.1.1 → do_again-0.2.0}/README.md

@@ -59,9 +59,27 @@ The npm package ships the same Python runtime from this repository behind a smal
 ```bash
 do-again doctor
 do-again init
+do-again install
 do-again status
 ```
 
+## Service lifecycle
+
+On macOS, Do Again can install a per-repository launchd agent:
+
+    do-again install
+    do-again status
+    do-again restart
+    do-again stop
+    do-again uninstall
+
+For attended or cross-platform use, run the agent in the foreground:
+
+    do-again run
+    do-again run --once
+
+Each repository gets an isolated runtime, control worktree, state directory, policy copy, and service label under ~/.do_again. The installed service runs from a copied runtime so installs made through either PyPI or npm remain stable after the invoking shell exits.
+
 ## Why Do Again
 
 - Explicit policy-based command permissions
@@ -76,11 +94,11 @@ do-again status
 
 | Platform | Status | Service backend |
 | --- | --- | --- |
-| macOS | Core working | launchd |
-| Linux | Adapter scaffolded | systemd user service |
-| Windows | Adapter scaffolded | Windows service |
+| macOS | Service lifecycle working | launchd |
+| Linux | Foreground runner working; service adapter scaffolded | systemd user service |
+| Windows | Foreground runner working; service adapter scaffolded | Windows service |
 
-Do Again is currently alpha software. macOS is the first active service platform while Linux and Windows service integration are being completed behind the same interface.
+Do Again is currently alpha software. The foreground runner works across the supported Python platforms; macOS is the first platform with an installable background service while Linux and Windows service integration are being completed behind the same interface.
 
 ## Development
 
@@ -94,7 +112,7 @@ do-again doctor
 
 ## Release model
 
-Releases use semantic versioning. Pushing a version tag such as `v0.1.1` validates the shared release version, publishes the Python distribution to PyPI and the Node launcher to npm through Trusted Publishing, and creates the matching GitHub Release.
+Releases use semantic versioning. Pushing a version tag such as `v0.2.0` validates the shared release version, publishes the Python distribution to PyPI and the Node launcher to npm through Trusted Publishing, and creates the matching GitHub Release.
 
 PyPI distribution name: `do-again`
 

{do_again-0.1.1 → do_again-0.2.0}/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "do-again",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "do-again",
-      "version": "0.1.1",
+      "version": "0.2.0",
       "license": "MIT",
       "bin": {
         "do-again": "bin/do-again.js"

{do_again-0.1.1 → do_again-0.2.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "do-again",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Policy-controlled local execution for AI coding agents",
   "license": "MIT",
   "author": "Steven Tran",
@@ -12,7 +12,8 @@
     "bin/",
     "src/do_again/**/*.py",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "src/do_again/default_policy.json"
   ],
   "engines": {
     "node": ">=18"

{do_again-0.1.1 → do_again-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "do-again"
-version = "0.1.1"
+version = "0.2.0"
 description = "Policy-controlled local execution for agent-driven development workflows"
 readme = "README.md"
 requires-python = ">=3.11"

do_again-0.2.0/src/do_again/cli.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+from .platforms.detect import detect_platform
+from .service.runtime import (
+    ServiceError,
+    find_repo,
+    install_service,
+    restart_service,
+    run_foreground,
+    service_status,
+    stop_service,
+    uninstall_service,
+)
+
+
+def doctor() -> int:
+    info = detect_platform()
+    checks = {
+        "python": sys.version_info >= (3, 11),
+        "git": shutil.which("git") is not None,
+        "platform": info.supported,
+    }
+    for key, ok in checks.items():
+        print(f"{'OK' if ok else 'FAIL'} {key}")
+    print(f"platform_name={info.name}")
+    print(f"service_manager={info.service_manager}")
+    return 0 if all(checks.values()) else 1
+
+
+def _print_service_status(value: dict[str, object]) -> None:
+    for key in (
+        "platform",
+        "service_manager",
+        "repo",
+        "label",
+        "installed",
+        "running",
+        "pid",
+        "runtime_dir",
+        "control_worktree",
+    ):
+        if key in value:
+            print(f"{key}={value[key]}")
+
+
+def status(path: str = ".") -> int:
+    info = detect_platform()
+    try:
+        repo = find_repo(path)
+    except ServiceError:
+        print(f"platform={info.name}")
+        print(f"service_manager={info.service_manager}")
+        return 0
+    try:
+        value = service_status(repo)
+    except ServiceError as exc:
+        print(f"do-again: {exc}", file=sys.stderr)
+        return 1
+    _print_service_status(value)
+    return 0
+
+
+def init_project(path: str) -> int:
+    target = Path(path).expanduser().resolve()
+    target.mkdir(parents=True, exist_ok=True)
+    config = target / "do-again.toml"
+    if config.exists():
+        print(str(config))
+        return 0
+    config.write_text('[do_again]\ncontrol_branch = "operator-control"\n')
+    print(str(config))
+    return 0
+
+
+def _service_action(action: str, path: str) -> int:
+    try:
+        if action == "install":
+            value = install_service(path)
+        elif action == "stop":
+            value = stop_service(path)
+        elif action == "restart":
+            value = restart_service(path)
+        elif action == "uninstall":
+            value = uninstall_service(path)
+        else:
+            raise ServiceError(f"unsupported service action: {action}")
+    except ServiceError as exc:
+        print(f"do-again: {exc}", file=sys.stderr)
+        return 1
+    _print_service_status(value)
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="do-again")
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("doctor")
+
+    status_parser = sub.add_parser("status")
+    status_parser.add_argument("path", nargs="?", default=".")
+
+    init_parser = sub.add_parser("init")
+    init_parser.add_argument("path", nargs="?", default=".")
+
+    for name in ("install", "stop", "restart", "uninstall"):
+        command = sub.add_parser(name)
+        command.add_argument("path", nargs="?", default=".")
+
+    run_parser = sub.add_parser("run")
+    run_parser.add_argument("path", nargs="?", default=".")
+    run_parser.add_argument("--once", action="store_true")
+
+    args = parser.parse_args()
+    if args.command == "doctor":
+        return doctor()
+    if args.command == "status":
+        return status(args.path)
+    if args.command == "init":
+        return init_project(args.path)
+    if args.command in {"install", "stop", "restart", "uninstall"}:
+        return _service_action(args.command, args.path)
+    if args.command == "run":
+        try:
+            return run_foreground(args.path, once=args.once)
+        except ServiceError as exc:
+            print(f"do-again: {exc}", file=sys.stderr)
+            return 1
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

do_again-0.2.0/src/do_again/service/__init__.py

@@ -0,0 +1,3 @@
+from .runtime import ServiceError, install_service, restart_service, run_foreground, service_status, stop_service, uninstall_service
+
+__all__ = ["ServiceError", "install_service", "restart_service", "run_foreground", "service_status", "stop_service", "uninstall_service"]

do_again-0.2.0/src/do_again/service/runtime.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import plistlib
+import re
+import shutil
+import subprocess
+import sys
+import time
+import tomllib
+from dataclasses import asdict, dataclass
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+from ..core.agent import Agent
+from ..platforms.detect import detect_platform
+from ..platforms.macos import service_definition_path
+
+
+class ServiceError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class RuntimeLayout:
+    repo: Path
+    branch: str
+    key: str
+    label: str
+    root: Path
+    control_worktree: Path
+    state_dir: Path
+    policy_path: Path
+    runtime_source: Path
+    metadata_path: Path
+    stdout_log: Path
+    stderr_log: Path
+
+
+def _run(argv: list[str], *, cwd: Path | None = None, check: bool = True) -> subprocess.CompletedProcess[str]:
+    proc = subprocess.run(argv, cwd=cwd, text=True, capture_output=True)
+    if check and proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout).strip()
+        raise ServiceError(f"{' '.join(argv)} failed ({proc.returncode}): {detail}")
+    return proc
+
+
+def find_repo(path: str | Path = ".") -> Path:
+    candidate = Path(path).expanduser().resolve()
+    proc = _run(["git", "-C", str(candidate), "rev-parse", "--show-toplevel"], check=False)
+    if proc.returncode != 0:
+        raise ServiceError(f"not inside a Git repository: {candidate}")
+    return Path(proc.stdout.strip()).resolve()
+
+
+def _config_branch(repo: Path) -> str:
+    config = repo / "do-again.toml"
+    if not config.is_file():
+        return "operator-control"
+    try:
+        value = tomllib.loads(config.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError) as exc:
+        raise ServiceError(f"invalid Do Again config: {config}: {exc}") from exc
+    branch = str(value.get("do_again", {}).get("control_branch", "operator-control")).strip()
+    if not re.fullmatch(r"[A-Za-z0-9._/-]{1,120}", branch) or branch.startswith("-") or ".." in branch:
+        raise ServiceError(f"invalid control branch: {branch!r}")
+    return branch
+
+
+def runtime_layout(repo: Path) -> RuntimeLayout:
+    repo = repo.resolve()
+    branch = _config_branch(repo)
+    key = hashlib.sha256(str(repo).encode("utf-8")).hexdigest()[:12]
+    label = f"io.github.tran-steven.do-again.{key}"
+    home = Path(os.environ.get("DO_AGAIN_HOME", str(Path.home() / ".do_again"))).expanduser().resolve()
+    root = home / "projects" / key
+    return RuntimeLayout(
+        repo=repo,
+        branch=branch,
+        key=key,
+        label=label,
+        root=root,
+        control_worktree=root / "control",
+        state_dir=root / "state",
+        policy_path=root / "policy.json",
+        runtime_source=root / "runtime",
+        metadata_path=root / "runtime.json",
+        stdout_log=root / "logs" / "agent.out.log",
+        stderr_log=root / "logs" / "agent.err.log",
+    )
+
+
+def _default_policy() -> dict[str, Any]:
+    text = resources.files("do_again").joinpath("default_policy.json").read_text(encoding="utf-8")
+    value = json.loads(text)
+    if not isinstance(value, dict):
+        raise ServiceError("bundled default policy is invalid")
+    return value
+
+
+def _ensure_remote_control_branch(layout: RuntimeLayout) -> None:
+    remote = _run(
+        ["git", "-C", str(layout.repo), "ls-remote", "--exit-code", "--heads", "origin", layout.branch],
+        check=False,
+    )
+    if remote.returncode != 0:
+        _run(["git", "-C", str(layout.repo), "push", "origin", f"HEAD:refs/heads/{layout.branch}"])
+    _run(["git", "-C", str(layout.repo), "fetch", "--quiet", "origin", layout.branch])
+
+
+def _ensure_control_worktree(layout: RuntimeLayout) -> None:
+    if layout.control_worktree.exists():
+        check = _run(
+            ["git", "-C", str(layout.control_worktree), "rev-parse", "--show-toplevel"],
+            check=False,
+        )
+        if check.returncode != 0:
+            raise ServiceError(f"control path exists but is not a Git worktree: {layout.control_worktree}")
+        dirty = _run(["git", "-C", str(layout.control_worktree), "status", "--porcelain"])
+        if dirty.stdout.strip():
+            raise ServiceError(f"control worktree is dirty: {layout.control_worktree}")
+        return
+    layout.control_worktree.parent.mkdir(parents=True, exist_ok=True)
+    _run(
+        [
+            "git",
+            "-C",
+            str(layout.repo),
+            "worktree",
+            "add",
+            "--detach",
+            str(layout.control_worktree),
+            f"origin/{layout.branch}",
+        ]
+    )
+
+
+def _copy_runtime(layout: RuntimeLayout) -> None:
+    package_root = Path(__file__).resolve().parents[1]
+    target = layout.runtime_source / "do_again"
+    if target.exists():
+        shutil.rmtree(target)
+    layout.runtime_source.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(
+        package_root,
+        target,
+        ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo"),
+    )
+
+
+def prepare_runtime(repo: Path) -> RuntimeLayout:
+    layout = runtime_layout(repo)
+    layout.state_dir.mkdir(parents=True, exist_ok=True)
+    layout.stdout_log.parent.mkdir(parents=True, exist_ok=True)
+    _ensure_remote_control_branch(layout)
+    _ensure_control_worktree(layout)
+
+    policy = _default_policy()
+    policy["control_branch"] = layout.branch
+    policy["agent_launchd_label"] = layout.label
+    layout.policy_path.write_text(json.dumps(policy, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    _copy_runtime(layout)
+
+    metadata = {
+        "schema_version": 1,
+        "repo": str(layout.repo),
+        "control_branch": layout.branch,
+        "control_worktree": str(layout.control_worktree),
+        "state_dir": str(layout.state_dir),
+        "policy": str(layout.policy_path),
+        "service_label": layout.label,
+    }
+    layout.metadata_path.write_text(json.dumps(metadata, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return layout
+
+
+def _domain() -> str:
+    return f"gui/{os.getuid()}"
+
+
+def _launchd_plist(layout: RuntimeLayout) -> dict[str, Any]:
+    path = os.environ.get("PATH", "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin")
+    return {
+        "Label": layout.label,
+        "ProgramArguments": [
+            sys.executable,
+            "-m",
+            "do_again.core.agent",
+            "--repo",
+            str(layout.repo),
+            "--control-worktree",
+            str(layout.control_worktree),
+            "--branch",
+            layout.branch,
+            "--policy",
+            str(layout.policy_path),
+            "--state-dir",
+            str(layout.state_dir),
+        ],
+        "WorkingDirectory": str(layout.repo),
+        "EnvironmentVariables": {
+            "PATH": path,
+            "PYTHONPATH": str(layout.runtime_source),
+            "PYTHONDONTWRITEBYTECODE": "1",
+            "PYTHONUNBUFFERED": "1",
+        },
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "ProcessType": "Background",
+        "ThrottleInterval": 5,
+        "StandardOutPath": str(layout.stdout_log),
+        "StandardErrorPath": str(layout.stderr_log),
+    }
+
+
+def _require_macos() -> None:
+    info = detect_platform()
+    if info.name != "macos":
+        raise ServiceError(
+            f"background service lifecycle is currently supported on macOS only; detected {info.name}"
+        )
+
+
+def _launchctl(*args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
+    return _run(["launchctl", *args], check=check)
+
+
+def _loaded(layout: RuntimeLayout) -> bool:
+    return _launchctl("print", f"{_domain()}/{layout.label}", check=False).returncode == 0
+
+
+def _wait_loaded(layout: RuntimeLayout, expected: bool, timeout: float = 8.0) -> None:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if _loaded(layout) is expected:
+            return
+        time.sleep(0.1)
+    state = "loaded" if expected else "unloaded"
+    raise ServiceError(f"launchd service did not become {state}: {layout.label}")
+
+
+def service_status(path: str | Path = ".") -> dict[str, Any]:
+    repo = find_repo(path)
+    layout = runtime_layout(repo)
+    info = detect_platform()
+    result: dict[str, Any] = {
+        "repo": str(repo),
+        "platform": info.name,
+        "service_manager": info.service_manager,
+        "label": layout.label,
+        "runtime_dir": str(layout.root),
+        "control_worktree": str(layout.control_worktree),
+        "installed": False,
+        "running": False,
+        "pid": None,
+    }
+    if info.name != "macos":
+        return result
+    plist = service_definition_path(layout.label)
+    result["installed"] = plist.is_file()
+    probe = _launchctl("print", f"{_domain()}/{layout.label}", check=False)
+    if probe.returncode == 0:
+        result["running"] = True
+        match = re.search(r"\bpid\s*=\s*(\d+)", probe.stdout)
+        if match:
+            result["pid"] = int(match.group(1))
+    return result
+
+
+def install_service(path: str | Path = ".") -> dict[str, Any]:
+    _require_macos()
+    repo = find_repo(path)
+    existing = runtime_layout(repo)
+    if _loaded(existing):
+        proc = _launchctl("bootout", f"{_domain()}/{existing.label}", check=False)
+        if proc.returncode != 0:
+            raise ServiceError(f"launchctl bootout failed: {(proc.stderr or proc.stdout).strip()}")
+        _wait_loaded(existing, False)
+
+    layout = prepare_runtime(repo)
+    plist = service_definition_path(layout.label)
+    plist.parent.mkdir(parents=True, exist_ok=True)
+    plist.write_bytes(plistlib.dumps(_launchd_plist(layout), sort_keys=True))
+    os.chmod(plist, 0o644)
+
+    boot = _launchctl("bootstrap", _domain(), str(plist), check=False)
+    if boot.returncode != 0:
+        raise ServiceError(f"launchctl bootstrap failed: {(boot.stderr or boot.stdout).strip()}")
+    _wait_loaded(layout, True)
+    return service_status(repo)
+
+
+def stop_service(path: str | Path = ".") -> dict[str, Any]:
+    _require_macos()
+    repo = find_repo(path)
+    layout = runtime_layout(repo)
+    before = _loaded(layout)
+    proc = _launchctl("bootout", f"{_domain()}/{layout.label}", check=False)
+    if before and proc.returncode != 0:
+        raise ServiceError(f"launchctl bootout failed: {(proc.stderr or proc.stdout).strip()}")
+    if before:
+        _wait_loaded(layout, False)
+    return service_status(repo)
+
+
+def restart_service(path: str | Path = ".") -> dict[str, Any]:
+    _require_macos()
+    repo = find_repo(path)
+    layout = runtime_layout(repo)
+    plist = service_definition_path(layout.label)
+    if not plist.is_file():
+        raise ServiceError("Do Again is not installed for this repository; run do-again install first")
+    current = service_status(repo)
+    if current["running"]:
+        proc = _launchctl("kickstart", "-k", f"{_domain()}/{layout.label}", check=False)
+    else:
+        proc = _launchctl("bootstrap", _domain(), str(plist), check=False)
+    if proc.returncode != 0:
+        raise ServiceError(f"launchctl restart failed: {(proc.stderr or proc.stdout).strip()}")
+    _wait_loaded(layout, True)
+    return service_status(repo)
+
+
+def uninstall_service(path: str | Path = ".") -> dict[str, Any]:
+    _require_macos()
+    repo = find_repo(path)
+    layout = runtime_layout(repo)
+    if _loaded(layout):
+        proc = _launchctl("bootout", f"{_domain()}/{layout.label}", check=False)
+        if proc.returncode != 0:
+            raise ServiceError(f"launchctl bootout failed: {(proc.stderr or proc.stdout).strip()}")
+        _wait_loaded(layout, False)
+    plist = service_definition_path(layout.label)
+    try:
+        plist.unlink()
+    except FileNotFoundError:
+        pass
+    if layout.control_worktree.exists():
+        _run(
+            ["git", "-C", str(repo), "worktree", "remove", "--force", str(layout.control_worktree)],
+            check=False,
+        )
+    if layout.root.exists():
+        shutil.rmtree(layout.root)
+    return {
+        "repo": str(repo),
+        "label": layout.label,
+        "installed": False,
+        "running": False,
+    }
+
+
+def run_foreground(path: str | Path = ".", *, once: bool = False) -> int:
+    repo = find_repo(path)
+    if detect_platform().name == "macos" and service_status(repo)["running"]:
+        raise ServiceError("background service is already running; stop it before using foreground mode")
+    layout = prepare_runtime(repo)
+    agent = Agent(
+        repo=repo,
+        control_worktree=layout.control_worktree,
+        branch=layout.branch,
+        policy_path=layout.policy_path,
+        state_dir=layout.state_dir,
+    )
+    return agent.run(once=once)
+
+
+def layout_as_dict(path: str | Path = ".") -> dict[str, Any]:
+    return asdict(runtime_layout(find_repo(path)))

do_again-0.2.0/templates/policy.json

@@ -0,0 +1,137 @@
+{
+  "schema_version": 1,
+  "control_branch": "operator-control",
+  "poll_seconds": 3,
+  "max_request_ttl_seconds": 3600,
+  "default_timeout_seconds": 120,
+  "absolute_timeout_seconds": 3600,
+  "max_output_bytes": 262144,
+  "allowed_operations": [
+    "status",
+    "read_file",
+    "run_tests",
+    "repo_script",
+    "control_plane_launcher",
+    "deploy_cp1_bundle_at_stop",
+    "scratch_script",
+    "extended_exec",
+    "process_signal",
+    "launchctl_action",
+    "self_update",
+    "artifact_get",
+    "artifact_put",
+    "capture_screenshot",
+    "full_process_list"
+  ],
+  "approved_cwd_roots": [
+    "$REPO",
+    "$HOME/.do_again_control_plane",
+    "$HOME/.do_again_bridge",
+    "$HOME/.do_again",
+    "/tmp"
+  ],
+  "read_roots": [
+    "$REPO",
+    "$HOME/.do_again_control_plane",
+    "$HOME/.do_again_bridge",
+    "$HOME/.do_again",
+    "/tmp"
+  ],
+  "repo_script_prefixes": [
+    "tools/",
+    "control_plane/",
+    "scripts/"
+  ],
+  "allowed_launcher_subcommands": [
+    "session-intake",
+    "session-resolution"
+  ],
+  "extended_exec_binaries": [
+    "python3",
+    "git",
+    "bash",
+    "zsh",
+    "sh",
+    "ps",
+    "jq",
+    "cat",
+    "tail",
+    "head",
+    "grep",
+    "rg",
+    "find",
+    "sed",
+    "ls",
+    "stat",
+    "shasum",
+    "date",
+    "sleep",
+    "wc",
+    "sort",
+    "uniq",
+    "cut",
+    "tr",
+    "pwd",
+    "uname",
+    "df",
+    "du",
+    "lsof",
+    "vm_stat",
+    "networkQuality"
+  ],
+  "git_allowed_subcommands": [
+    "status",
+    "fetch",
+    "pull",
+    "log",
+    "show",
+    "diff",
+    "rev-parse",
+    "branch",
+    "switch",
+    "checkout",
+    "worktree",
+    "merge-base",
+    "cat-file",
+    "ls-tree",
+    "remote"
+  ],
+  "launchctl_allowed_subcommands": [
+    "print",
+    "kickstart",
+    "bootstrap",
+    "bootout"
+  ],
+  "launchctl_label_prefixes": [
+    "io.github.tran-steven."
+  ],
+  "process_signal_allowlist": [
+    "TERM",
+    "INT",
+    "HUP",
+    "KILL"
+  ],
+  "python_allowed_modules": [
+    "unittest",
+    "py_compile"
+  ],
+  "hard_denied_binaries": [
+    "sudo",
+    "su",
+    "doas",
+    "rm",
+    "dd",
+    "diskutil",
+    "fdisk",
+    "mkfs",
+    "mount",
+    "umount",
+    "docker",
+    "podman"
+  ],
+  "max_scratch_script_bytes": 65536,
+  "max_inline_artifact_bytes": 450000,
+  "max_screenshot_width": 1440,
+  "screenshot_jpeg_quality": 55,
+  "agent_launchd_label": "io.github.tran-steven.do-again"
+}

do_again-0.2.0/tests/test_service.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from do_again.platforms.base import PlatformInfo
+from do_again.service.runtime import (
+    ServiceError,
+    _default_policy,
+    _launchd_plist,
+    runtime_layout,
+)
+
+
+class ServiceRuntimeTests(unittest.TestCase):
+    def test_runtime_layout_is_stable_and_project_scoped(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            repo = root / "repo"
+            repo.mkdir()
+            with patch.dict(os.environ, {"DO_AGAIN_HOME": str(root / "home")}):
+                first = runtime_layout(repo)
+                second = runtime_layout(repo)
+            self.assertEqual(first.key, second.key)
+            self.assertEqual(first.label, second.label)
+            self.assertTrue(first.label.startswith("io.github.tran-steven.do-again."))
+            self.assertEqual(first.root.parent, (root / "home" / "projects").resolve())
+
+    def test_default_policy_is_packaged(self) -> None:
+        policy = _default_policy()
+        self.assertEqual(policy["schema_version"], 1)
+        self.assertIn("scratch_script", policy["allowed_operations"])
+        self.assertTrue(policy["agent_launchd_label"].startswith("io.github.tran-steven.do-again"))
+
+    def test_launchd_plist_uses_copied_runtime(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            repo = root / "repo"
+            repo.mkdir()
+            with patch.dict(os.environ, {"DO_AGAIN_HOME": str(root / "home")}):
+                layout = runtime_layout(repo)
+            value = _launchd_plist(layout)
+            self.assertEqual(value["Label"], layout.label)
+            self.assertEqual(value["WorkingDirectory"], str(repo.resolve()))
+            self.assertEqual(value["EnvironmentVariables"]["PYTHONPATH"], str(layout.runtime_source))
+            self.assertIn("do_again.core.agent", value["ProgramArguments"])
+            self.assertTrue(value["KeepAlive"])
+
+    @patch("do_again.service.runtime.detect_platform")
+    def test_background_lifecycle_rejects_non_macos(self, detect) -> None:
+        detect.return_value = PlatformInfo(name="linux", service_manager="systemd", supported=True)
+        from do_again.service.runtime import install_service
+
+        with self.assertRaises(ServiceError):
+            install_service(".")
+
+
+if __name__ == "__main__":
+    unittest.main()

do_again-0.1.1/src/do_again/cli.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-from .platforms.detect import detect_platform
-
-
-def doctor() -> int:
-    info = detect_platform()
-    checks = {
-        "python": sys.version_info >= (3, 11),
-        "git": shutil.which("git") is not None,
-        "platform": info.supported,
-    }
-    for key, ok in checks.items():
-        print(f"{'OK' if ok else 'FAIL'} {key}")
-    print(f"platform_name={info.name}")
-    print(f"service_manager={info.service_manager}")
-    return 0 if all(checks.values()) else 1
-
-
-def status() -> int:
-    info = detect_platform()
-    print(f"platform={info.name}")
-    print(f"service_manager={info.service_manager}")
-    return 0
-
-
-def init_project(path: str) -> int:
-    target = Path(path).expanduser().resolve()
-    target.mkdir(parents=True, exist_ok=True)
-    config = target / "do-again.toml"
-    if config.exists():
-        print(str(config))
-        return 0
-    config.write_text('[do_again]\ncontrol_branch = "operator-control"\n')
-    print(str(config))
-    return 0
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(prog="do-again")
-    sub = parser.add_subparsers(dest="command", required=True)
-    sub.add_parser("doctor")
-    sub.add_parser("status")
-    init_parser = sub.add_parser("init")
-    init_parser.add_argument("path", nargs="?", default=".")
-    args = parser.parse_args()
-    if args.command == "doctor":
-        return doctor()
-    if args.command == "status":
-        return status()
-    if args.command == "init":
-        return init_project(args.path)
-    return 2
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())