The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
import importlib.util
import io
import json
import os
import subprocess
import tempfile
import unittest
from contextlib import redirect_stderr, redirect_stdout
from datetime import datetime, timedelta, timezone
from pathlib import Path
SCRIPTS = Path(__file__).resolve().parents[1]
ROOT = SCRIPTS.parent
spec = importlib.util.spec_from_file_location("release_window", SCRIPTS / "release-window.py")
rw = importlib.util.module_from_spec(spec)
spec.loader.exec_module(rw)
VN = timezone(timedelta(hours=7))
CONFIG = json.loads((SCRIPTS / "release-window.json").read_text())
def at(day, hour, minute=0):
"""A VN wall-clock time on 2026-11-<day>, as an aware datetime in UTC (what git and CI report)."""
return datetime(2026, 11, day, hour, minute, tzinfo=VN).astimezone(timezone.utc)
def check(kind, now, last=None, urgent=None):
return rw.check(kind, now, last, CONFIG, urgent)
class WindowTests(unittest.TestCase):
def test_config_holds_the_numbers_in_the_shape_of_the_rules_record(self):
# The project rules record (#3216) keeps releaseWindow and releasePace in this shape; the guard reads it
# from there once that lands, so these keys are named the same.
self.assertEqual(CONFIG["releaseWindow"], {"start": "09:00", "end": "18:00", "timeZone": "Asia/Ho_Chi_Minh"})
self.assertEqual(CONFIG["releasePace"], {"backendEveryMinutes": 120, "backendPause": {"start": "09:00", "end": "10:00"}})
def test_grace_for_a_queued_workflow_is_data(self):
self.assertEqual(CONFIG["tagGraceMinutes"], 30)
def test_inside_the_window_is_allowed_for_every_kind(self):
for kind in ["cli", "desktop", "web"]:
for hour, minute in [(9, 0), (12, 30), (17, 59)]:
self.assertTrue(check(kind, at(5, hour, minute)).allowed, (kind, hour, minute))
for hour, minute in [(10, 0), (12, 30), (17, 59)]:
self.assertTrue(check("backend", at(5, hour, minute)).allowed, (hour, minute))
def test_before_the_window_is_refused_with_todays_opening(self):
verdict = check("cli", at(5, 8, 59))
self.assertFalse(verdict.allowed)
self.assertEqual(verdict.next_allowed, at(5, 9, 0))
def test_at_closing_time_and_after_is_refused_with_tomorrows_opening(self):
for hour, minute in [(18, 0), (18, 1), (23, 30)]:
verdict = check("desktop", at(5, hour, minute))
self.assertFalse(verdict.allowed, (hour, minute))
self.assertEqual(verdict.next_allowed, at(6, 9, 0))
def test_after_midnight_before_nine_opens_the_same_day(self):
verdict = check("web", at(6, 0, 30))
self.assertEqual(verdict.next_allowed, at(6, 9, 0))
def test_window_is_read_in_vietnam_time_not_utc(self):
# 02:30 UTC is 09:30 in Ho Chi Minh City: inside. 11:30 UTC is 18:30 there: outside.
self.assertTrue(check("cli", datetime(2026, 11, 5, 2, 30, tzinfo=timezone.utc)).allowed)
self.assertFalse(check("cli", datetime(2026, 11, 5, 11, 30, tzinfo=timezone.utc)).allowed)
def test_vietnam_has_no_daylight_shift(self):
# The US fall-back (2026-11-01) and spring-forward (2026-03-08) move nothing here.
for month, day in [(3, 7), (3, 9), (10, 31), (11, 2)]:
inside = datetime(2026, month, day, 9, 0, tzinfo=VN).astimezone(timezone.utc)
self.assertTrue(check("cli", inside).allowed, (month, day))
outside = datetime(2026, month, day, 18, 0, tzinfo=VN).astimezone(timezone.utc)
self.assertFalse(check("cli", outside).allowed, (month, day))
def test_naive_time_is_rejected(self):
with self.assertRaises(ValueError):
check("cli", datetime(2026, 11, 5, 12, 0))
class BackendPauseTests(unittest.TestCase):
"""Ken, 2026-11-05: no backend release inside 09:00-10:00 VN (the morning peak); apps keep 09:00."""
def test_backend_is_refused_inside_the_pause_with_the_pause_end(self):
for hour, minute in [(9, 0), (9, 30), (9, 59)]:
verdict = check("backend", at(5, hour, minute))
self.assertFalse(verdict.allowed, (hour, minute))
self.assertEqual(verdict.next_allowed, at(5, 10, 0))
self.assertIn("09:00-10:00", verdict.message)
def test_backend_opens_at_ten(self):
self.assertTrue(check("backend", at(5, 10, 0)).allowed)
def test_apps_and_web_are_not_paused(self):
for kind in ["cli", "desktop", "web"]:
self.assertTrue(check(kind, at(5, 9, 30)).allowed, kind)
def test_before_nine_a_backend_release_waits_for_ten(self):
self.assertEqual(check("backend", at(5, 8, 0)).next_allowed, at(5, 10, 0))
def test_pace_ending_inside_the_pause_waits_for_its_end(self):
# Last release 07:30 would allow 09:30, which is paused: the next time is 10:00.
verdict = check("backend", at(5, 9, 20), last=at(5, 7, 30))
self.assertEqual(verdict.next_allowed, at(5, 10, 0))
def test_a_null_pause_turns_it_off(self):
config = {**CONFIG, "releasePace": {**CONFIG["releasePace"], "backendPause": None}}
self.assertTrue(rw.check("backend", at(5, 9, 30), None, config, None).allowed)
def test_urgent_overrides_the_pause(self):
self.assertTrue(check("backend", at(5, 9, 30), urgent="P0: crash loop").allowed)
class PaceTests(unittest.TestCase):
def test_backend_within_two_hours_is_refused_with_the_time_it_opens(self):
verdict = check("backend", at(5, 12, 0), last=at(5, 10, 30))
self.assertFalse(verdict.allowed)
self.assertEqual(verdict.next_allowed, at(5, 12, 30))
def test_backend_after_two_hours_is_allowed(self):
self.assertTrue(check("backend", at(5, 12, 30), last=at(5, 10, 30)).allowed)
self.assertTrue(check("backend", at(5, 15, 0), last=at(5, 10, 30)).allowed)
def test_pace_that_ends_after_closing_moves_to_the_next_backend_opening(self):
verdict = check("backend", at(5, 17, 30), last=at(5, 17, 0))
self.assertFalse(verdict.allowed)
self.assertEqual(verdict.next_allowed, at(6, 10, 0))
def test_night_and_pace_together_name_the_later_time(self):
verdict = check("backend", at(5, 23, 0), last=at(5, 22, 0))
self.assertEqual(verdict.next_allowed, at(6, 10, 0))
def test_other_kinds_have_no_pace(self):
for kind in ["cli", "desktop", "web"]:
self.assertTrue(check(kind, at(5, 12, 0), last=at(5, 11, 55)).allowed, kind)
def test_first_ever_backend_release_has_no_pace(self):
self.assertTrue(check("backend", at(5, 12, 0), last=None).allowed)
def test_unknown_kind_is_an_error_not_a_pass(self):
with self.assertRaises(ValueError):
check("firmware", at(5, 12, 0))
def test_pace_past_closing_names_the_last_release(self):
text = check("backend", at(5, 17, 30), last=at(5, 17, 0)).message
self.assertIn("the last backend release was at 2026-11-05 17:00", text)
self.assertNotIn("the pace ends outside", text)
def test_message_names_guard_next_time_and_next_step(self):
text = check("backend", at(5, 12, 0), last=at(5, 11, 0)).message
self.assertIn("RELEASE_WINDOW", text)
self.assertIn("2026-11-05 13:00", text)
self.assertIn("Asia/Ho_Chi_Minh", text)
self.assertIn('--urgent "<reason>"', text)
class UrgentTests(unittest.TestCase):
def test_urgent_without_a_reason_is_refused(self):
for reason in ["", " ", None]:
verdict = check("backend", at(5, 23, 0), urgent="" if reason is None else reason)
self.assertFalse(verdict.allowed, repr(reason))
self.assertIn("needs a reason", verdict.message)
def test_urgent_with_a_reason_allows_night_and_pace(self):
verdict = check("backend", at(5, 23, 0), last=at(5, 22, 30), urgent="P0: sign-out loop")
self.assertTrue(verdict.allowed)
self.assertEqual(verdict.urgent_reason, "P0: sign-out loop")
self.assertIn("P0: sign-out loop", verdict.chat_line)
self.assertIn("2026-11-05 23:00", verdict.chat_line)
self.assertIn("backend", verdict.chat_line)
def test_urgent_inside_the_window_is_still_recorded(self):
verdict = check("cli", at(5, 12, 0), urgent="P0: crash on start")
self.assertTrue(verdict.allowed)
self.assertEqual(verdict.urgent_reason, "P0: crash on start")
def test_reason_is_one_line(self):
verdict = check("cli", at(5, 23, 0), urgent="P0: first\nsecond")
self.assertNotIn("\n", verdict.chat_line)
def git(repo, *args, env=None):
subprocess.run(["git", "-C", repo, *args], check=True, capture_output=True,
env={**os.environ, "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", "GIT_COMMITTER_NAME": "t",
"GIT_COMMITTER_EMAIL": "t@t", **(env or {})})
class GitAndCliTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.repo = self.tmp.name
git(self.repo, "init", "-q")
git(self.repo, "commit", "-q", "--allow-empty", "-m", "c")
def tag(self, name, when, message="release"):
stamp = when.isoformat()
git(self.repo, "tag", "-a", name, "-m", message, env={"GIT_COMMITTER_DATE": stamp})
def run_cli(self, *args):
out, err = io.StringIO(), io.StringIO()
with redirect_stdout(out), redirect_stderr(err):
code = rw.main(["--repo", self.repo, *args])
return code, out.getvalue(), err.getvalue()
def test_last_release_is_the_newest_tag_of_the_kind(self):
self.tag("v1.0.1_backend", at(5, 9, 0))
self.tag("v1.0.2_backend", at(5, 10, 30))
self.tag("v9.0.1_cli", at(5, 11, 55))
self.assertEqual(rw.last_release_time(self.repo, "backend"), at(5, 10, 30))
def test_no_tag_means_no_last_release(self):
self.assertIsNone(rw.last_release_time(self.repo, "backend"))
def test_cli_refuses_a_backend_release_within_two_hours_with_exit_2(self):
self.tag("v1.0.1_backend", at(5, 10, 30))
code, _, err = self.run_cli("--kind", "backend", "--now", at(5, 12, 0).isoformat())
self.assertEqual(code, 2)
self.assertIn("RELEASE_WINDOW", err)
self.assertIn("2026-11-05 12:30", err)
def test_cli_allows_a_backend_release_after_two_hours(self):
self.tag("v1.0.1_backend", at(5, 10, 30))
code, _, _ = self.run_cli("--kind", "backend", "--now", at(5, 12, 30).isoformat())
self.assertEqual(code, 0)
def test_the_tag_being_built_is_not_the_last_release(self):
self.tag("v1.0.1_backend", at(5, 9, 0))
self.tag("v1.0.2_backend", at(5, 12, 0))
code, _, err = self.run_cli("--kind", "backend", "--now", at(5, 12, 1).isoformat(),
"--exclude-tag", "v1.0.2_backend")
self.assertEqual(code, 0, err)
def test_cli_urgent_without_reason_is_refused_and_with_reason_prints_the_chat_line(self):
now = at(5, 23, 0).isoformat()
code, _, err = self.run_cli("--kind", "cli", "--now", now, "--urgent", "")
self.assertEqual(code, 2)
self.assertIn("needs a reason", err)
code, out, _ = self.run_cli("--kind", "cli", "--now", now, "--urgent", "P0: crash on start")
self.assertEqual(code, 0)
self.assertIn("Urgent cli release", out)
self.assertIn("P0: crash on start", out)
def test_tag_message_urgent_line_is_honored_by_the_workflow_check(self):
self.tag("v1.0.3_backend", at(5, 23, 0), message="backend release\n\nRelease-Urgent: P0: sign-out loop")
code, out, err = self.run_cli("--kind", "backend", "--now", at(5, 23, 1).isoformat(),
"--from-tag", "v1.0.3_backend", "--exclude-tag", "v1.0.3_backend")
self.assertEqual(code, 0, err)
self.assertIn("P0: sign-out loop", out)
def run_tag_at(self, name, when_made, now, message="release", kind="cli"):
self.tag(name, when_made, message=message)
return self.run_cli("--kind", kind, "--now", now.isoformat(), "--from-tag", name, "--exclude-tag", name)
def test_a_tag_at_0320_vn_without_a_reason_is_refused(self):
# 2026-11-06 03:20 VN: the hour a CLI and a Desktop release went out from a tag push.
code, _, err = self.run_tag_at("v1.0.1_cli", at(6, 3, 20), at(6, 3, 21))
self.assertEqual(code, 2)
self.assertIn("RELEASE_WINDOW", err)
def test_a_tag_at_0320_vn_with_an_emergency_reason_runs_and_posts_the_reason(self):
summary = Path(self.tmp.name) / "summary.md"
os.environ["GITHUB_STEP_SUMMARY"] = str(summary)
self.addCleanup(os.environ.pop, "GITHUB_STEP_SUMMARY", None)
for kind in ["cli", "desktop", "backend", "web"]:
with self.subTest(kind=kind):
code, out, err = self.run_tag_at(f"v1.0.1_{kind}", at(6, 3, 20), at(6, 3, 21), kind=kind,
message="release\n\nEmergency: sign-in loop on every start")
self.assertEqual(code, 0, err)
self.assertIn("sign-in loop on every start", out)
self.assertIn(f"Urgent {kind} release", summary.read_text())
self.assertIn("sign-in loop on every start", summary.read_text())
def test_an_emergency_line_with_no_reason_does_not_open_the_window(self):
for line in ["Emergency:", "Emergency: ", "Emergency: "]:
with self.subTest(line=line):
code, _, err = self.run_tag_at("v1.0.1_cli", at(6, 3, 20), at(6, 3, 21), message=f"release\n\n{line}")
self.assertEqual(code, 2, err)
git(self.repo, "tag", "-d", "v1.0.1_cli")
def test_the_emergency_word_must_start_a_line_of_the_tag_message(self):
code, _, _ = self.run_tag_at("v1.0.1_cli", at(6, 3, 20), at(6, 3, 21),
message="release\n\nthis is not an Emergency: really")
self.assertEqual(code, 2)
def test_a_lightweight_tag_cannot_claim_an_emergency_through_its_commit_message(self):
# `git tag -l --format=%(contents)` returns the commit message for a lightweight tag, which any push can set.
for line in ["Emergency: not a real one", "Release-Urgent: not a real one"]:
with self.subTest(line=line):
git(self.repo, "commit", "-q", "--allow-empty", "-m", f"fix\n\n{line}")
git(self.repo, "tag", "v1.0.1_cli")
code, _, err = self.run_cli("--kind", "cli", "--now", at(6, 3, 21).isoformat(),
"--from-tag", "v1.0.1_cli", "--exclude-tag", "v1.0.1_cli")
self.assertEqual(code, 2, err)
git(self.repo, "tag", "-d", "v1.0.1_cli")
def test_the_window_edges_for_a_tag_push(self):
for hour, minute, expected in [(8, 59, 2), (9, 0, 0), (17, 59, 0), (18, 0, 2)]:
with self.subTest(at=f"{hour:02d}:{minute:02d}"):
# Tagged and started at the same minute, so the grace does not hide the edge.
code, _, err = self.run_tag_at("v1.0.1_cli", at(6, hour, minute), at(6, hour, minute))
self.assertEqual(code, expected, err)
git(self.repo, "tag", "-d", "v1.0.1_cli")
def test_tag_without_urgent_line_is_refused_at_night(self):
self.tag("v1.0.3_backend", at(5, 23, 0))
code, _, err = self.run_cli("--kind", "backend", "--now", at(5, 23, 1).isoformat(),
"--from-tag", "v1.0.3_backend", "--exclude-tag", "v1.0.3_backend")
self.assertEqual(code, 2)
self.assertIn("RELEASE_WINDOW", err)
def test_a_release_queued_past_closing_is_judged_when_it_was_tagged(self):
# The script tagged at 17:55 inside the window; the workflow started at 18:04 after a CI queue.
self.tag("v1.0.1_cli", at(5, 17, 55))
code, _, err = self.run_cli("--kind", "cli", "--now", at(5, 18, 4).isoformat(),
"--from-tag", "v1.0.1_cli", "--exclude-tag", "v1.0.1_cli")
self.assertEqual(code, 0, err)
def test_a_tag_made_outside_the_window_is_still_refused_when_the_workflow_starts_late(self):
self.tag("v1.0.1_cli", at(5, 18, 2))
code, _, err = self.run_cli("--kind", "cli", "--now", at(5, 18, 4).isoformat(),
"--from-tag", "v1.0.1_cli", "--exclude-tag", "v1.0.1_cli")
self.assertEqual(code, 2)
self.assertIn("RELEASE_WINDOW", err)
def test_a_workflow_queued_longer_than_the_grace_is_judged_now(self):
self.tag("v1.0.1_cli", at(5, 17, 55))
code, _, _ = self.run_cli("--kind", "cli", "--now", at(5, 18, 40).isoformat(),
"--from-tag", "v1.0.1_cli", "--exclude-tag", "v1.0.1_cli")
self.assertEqual(code, 2)
def test_a_lightweight_tag_has_no_tagging_time_to_trust(self):
# Its date is the commit's, which anyone can set: a hand-made tag is judged by the clock.
git(self.repo, "tag", "v1.0.1_cli")
code, _, _ = self.run_cli("--kind", "cli", "--now", at(5, 18, 4).isoformat(),
"--from-tag", "v1.0.1_cli", "--exclude-tag", "v1.0.1_cli")
self.assertEqual(code, 2)
def test_a_tag_dated_after_now_is_judged_now(self):
self.tag("v1.0.1_cli", at(5, 17, 55))
code, _, _ = self.run_cli("--kind", "cli", "--now", at(5, 17, 50).isoformat(),
"--from-tag", "v1.0.1_cli", "--exclude-tag", "v1.0.1_cli")
self.assertEqual(code, 0)
def test_advisory_reports_but_does_not_fail(self):
code, _, err = self.run_cli("--kind", "cli", "--now", at(5, 23, 0).isoformat(), "--advisory")
self.assertEqual(code, 0)
self.assertIn("RELEASE_WINDOW", err)
if __name__ == "__main__":
unittest.main()