Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
#!/usr/bin/env python3
"""Route build/test tools using ~/.config/hiroute/validation.json."""
import argparse
import importlib.util
import json
from pathlib import Path
import shlex
import subprocess
import sys
CONFIG = Path.home() / ".config/hiroute/validation.json"
LEGACY = Path.home() / ".config/hiroute/remote-rust.json"
REPO = Path(__file__).resolve().parent.parent
TARGETS = ("backend", "desktop", "frontend")
def ssh_host(value):
if not isinstance(value, str) or not value or value.startswith("-") or any(c.isspace() for c in value):
raise ValueError("host must be an SSH host/alias, not options or a command")
return value
def configuration(path=CONFIG, platform=None, legacy=LEGACY):
platform = platform or sys.platform
defaults = {"backend": {"transport": "local"}, "frontend": {"transport": "local"}}
if platform == "darwin":
defaults["desktop"] = {"transport": "local"}
configured = {}
if path.exists():
data = json.loads(path.read_text())
if (not isinstance(data, dict) or set(data) - {"version", "targets"}
or type(data.get("version")) is not int or data["version"] != 1
or not isinstance(data.get("targets"), dict)):
raise ValueError("Expected validation.json version 1 and targets object")
if set(data["targets"]) - set(TARGETS):
raise ValueError("Unknown validation target")
configured = data["targets"]
if platform == "darwin" and "backend" not in configured and legacy.exists():
defaults["backend"] = {"transport": "ssh", "host": ssh_host(json.loads(legacy.read_text())["host"])}
defaults.update(configured)
for name, target in defaults.items():
if not isinstance(target, dict) or set(target) - {"transport", "host", "repo", "path", "jobs", "pilot_cli"}:
raise ValueError("Unknown fields in target " + name)
if target.get("transport") not in ("local", "ssh"):
raise ValueError("Expected transport local/ssh for " + name)
if target["transport"] == "ssh":
ssh_host(target.get("host"))
if name != "backend" and not target.get("repo"):
raise ValueError("SSH " + name + " requires repo on that host")
elif "host" in target:
raise ValueError("Local target must not specify host")
if "jobs" in target and (type(target["jobs"]) is not int or target["jobs"] < 1):
raise ValueError("jobs must be a positive integer")
for key in ("repo", "pilot_cli"):
if key in target and (not isinstance(target[key], str) or not target[key] or "\0" in target[key]):
raise ValueError(key + " must be a nonempty path")
if "path" in target and (not isinstance(target["path"], list) or any(
not isinstance(p, str) or not p or "\0" in p or ":" in p for p in target["path"])):
raise ValueError("path must be a list of directories")
if name == "backend" and target["transport"] == "ssh" and set(target) - {"transport", "host"}:
raise ValueError("SSH backend uses the existing workbench; configure only transport and host")
if name == "frontend" and set(target) & {"jobs", "pilot_cli"}:
raise ValueError("frontend does not use jobs/pilot_cli")
return defaults
def with_candidate(arguments, repo):
arguments = list(arguments)
if arguments[:1] in (["run"], ["acquire"]):
boundary = arguments.index("--") if "--" in arguments else len(arguments)
options = arguments[:boundary]
if not any(a == "--sha" or a.startswith("--sha=") for a in options):
sha = subprocess.check_output(["git", "-C", str(repo), "rev-parse", "HEAD"], text=True).strip()
arguments[1:1] = ["--sha", sha]
return arguments
def dispatch(targets, action, arguments, frontend_dist=None, dry_run=False):
name = "desktop" if action in ("pilot", "pilot-cli", "pilot-build") else action
if action == "doctor":
if len(arguments) != 1 or arguments[0] not in TARGETS:
raise ValueError("doctor requires backend, desktop or frontend")
name = arguments[0]
arguments = []
if name not in targets:
raise ValueError("Configure a " + name + " target in ~/.config/hiroute/validation.json")
target = targets[name]
if frontend_dist and not (arguments[:1] == ["run"] and (
action == "desktop" or (action == "backend" and target["transport"] == "ssh"))):
raise ValueError("--frontend-dist is only for desktop run or SSH backend run")
if action == "desktop" or (action == "backend" and target["transport"] == "local"):
options = arguments[:arguments.index("--")] if "--" in arguments else arguments
if options[:1] == ["run"] and any(a in ("-h", "--help") for a in options):
# Help belongs to the caller's wrapper, just like admission. Do not
# require an SSH connection or an upgraded execution-host checkout.
spec = importlib.util.spec_from_file_location("validation_host", REPO / "scripts/validation-host.py")
host = importlib.util.module_from_spec(spec)
spec.loader.exec_module(host)
return host.run_help(REPO, action)
if action in ("backend", "desktop", "pilot-build"):
arguments = with_candidate(arguments, REPO)
if name == "backend" and target["transport"] == "ssh":
if action == "doctor":
# This is read-only; no worker submission or sccache server startup.
payload = dict(target=target, action="doctor", name=name, arguments=[], repo="~/git/HiRoute")
else:
if frontend_dist:
arguments[1:1] = ["--frontend-dist", frontend_dist]
argv = [sys.executable, str(REPO / "scripts/remote-rust.py"), "--host", target["host"], *arguments]
if dry_run:
print(json.dumps({"target": target, "argv": argv}, indent=2))
return 0
return subprocess.call(argv, cwd=REPO)
else:
repo = target.get("repo", str(REPO))
payload = dict(target=target, action=action, name=name, arguments=arguments, repo=repo,
frontend_dist=frontend_dist)
executor = (REPO / "scripts/validation-host.py").read_text()
if dry_run:
print(json.dumps(payload, indent=2))
return 0
if action in ("pilot", "pilot-build"):
payload["bundle"] = {name: (REPO / "scripts" / name).read_text() for name in
("pilot-builds.py", "local-rust.py", "remote-rust.py", "desktop-pilot.py", "pilot-native-app.py", "validation-report.py")}
if target["transport"] == "local":
argv = [sys.executable, "-c", executor]
else:
argv = ["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", target["host"],
"python3 -c " + shlex.quote(executor)]
return subprocess.run(argv, input=json.dumps(payload), text=True).returncode
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--config", type=Path, default=CONFIG)
parser.add_argument("--dry-run", action="store_true")
parser.add_argument("--frontend-dist", help="Execution-host frontend directory for desktop run or SSH backend run")
parser.add_argument("action", choices=("show", "doctor", *TARGETS, "pilot", "pilot-cli", "pilot-build", "windows"))
parser.add_argument("arguments", nargs=argparse.REMAINDER)
args = parser.parse_args()
if args.action == "windows":
if args.config != CONFIG or args.dry_run or args.frontend_dist:
parser.error("Pass Windows-specific options after windows")
return subprocess.call([sys.executable, str(REPO / "scripts/windows-dev.py"), *args.arguments])
if args.config != CONFIG and not args.config.is_file():
parser.error("Explicit --config does not exist")
targets = configuration(args.config)
if args.action == "show":
if args.arguments or args.frontend_dist:
parser.error("show takes no extra arguments")
print(json.dumps({"config": str(args.config), "targets": targets}, indent=2))
return 0
return dispatch(targets, args.action, args.arguments, args.frontend_dist, args.dry_run)
if __name__ == "__main__":
try:
sys.exit(main())
except (ValueError, KeyError, OSError, subprocess.SubprocessError) as error:
print(str(error), file=sys.stderr)
sys.exit(2)