Google Antigravity

@@ -16,12 +16,12 @@ container (the WSL2 Adom-Workspace on Windows, the Lima container on a Mac):     adom-antigravity open                # focus the Antigravity panel in the editor     adom-antigravity serve --print-url   # the dock dashboard (what a dock click runs) """-import argparse, glob, json, os, platform, shutil, subprocess, sys, time, urllib.request, urllib.error, urllib.parse+import argparse, fcntl, glob, json, os, platform, shutil, signal, subprocess, sys, time, urllib.request, urllib.error, urllib.parse from pathlib import Path from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer  ROOT = Path(__file__).resolve().parent-VERSION = '0.1.5'+VERSION = '0.1.6' EXT_ID = 'Google.google-antigravity' CLI_INSTALL = 'https://antigravity.google/cli/install.sh' EXT_DIRS = [Path.home() / '.local/share/code-server/extensions', Path.home() / '.vscode-server/extensions']@@ -222,6 +222,10 @@ class Handler(SimpleHTTPRequestHandler):         b = r.read(); self.send_response(r.status); self.send_header('Content-Type', r.headers.get('Content-Type', 'application/json')); self.send_header('Content-Length', str(len(b))); self.end_headers(); self.wfile.write(b)      def do_GET(self):+        if self.path == '/api/health':+            # Dock readiness must not wait for agy or editor port discovery.+            return self.json({'app': 'adom/antigravity', 'version': VERSION,+                              'pid': os.getpid(), 'state': 'healthy'})         if self.path in ['/api/status', '/state']:             return self.json(context())         if self.path == '/events':@@ -269,6 +273,93 @@ class Handler(SimpleHTTPRequestHandler):         return self.send_error(404)  +def server_identity(url):+    """Cheap readiness probe; allow older servers time for their full diagnostics."""+    try:+        return json.load(urllib.request.urlopen(url + 'api/health', timeout=1))+    except urllib.error.HTTPError as e:+        if e.code != 404:+            raise+    # 0.1.5's status can take 8s for agy, 4.5s for editor ports, and 1.5s+    # for the hub. A short timeout falsely declares that live server dead.+    return json.load(urllib.request.urlopen(url + 'api/status', timeout=20))+++def retire_server(port):+    """Retire only our same-user Python server owning this loopback listener."""+    inodes = set()+    for line in Path('/proc/net/tcp').read_text().splitlines()[1:]:+        fields = line.split()+        if fields[1] == f'0100007F:{port:04X}' and fields[3] == '0A':+            inodes.add(fields[9])+    owners = []+    for proc in Path('/proc').iterdir():+        if not proc.name.isdigit():+            continue+        try:+            if proc.stat().st_uid != os.getuid():+                continue+            links = {os.readlink(fd) for fd in (proc / 'fd').iterdir()}+            if not any(f'socket:[{inode}]' in links for inode in inodes):+                continue+            argv = (proc / 'cmdline').read_bytes().rstrip(b'\0').split(b'\0')+            if (len(argv) != 5 or Path(os.fsdecode(argv[1])).name != Path(__file__).name+                    or argv[2:] != [b'_serve', b'--port', str(port).encode()]):+                raise RuntimeError('Refusing to stop an unrecognized port owner')+            owners.append(int(proc.name))+        except (FileNotFoundError, PermissionError, ProcessLookupError):+            continue+    if len(owners) != 1:+        raise RuntimeError('Cannot identify exactly one Antigravity server owning the port')+    pid = owners[0]+    # A pidfd binds the signal to this process, even if Linux later reuses its PID.+    with os.fdopen(os.pidfd_open(pid), 'rb') as process_handle:+        argv = Path(f'/proc/{pid}/cmdline').read_bytes().rstrip(b'\0').split(b'\0')+        if (len(argv) != 5 or Path(os.fsdecode(argv[1])).name != Path(__file__).name+                or argv[2:] != [b'_serve', b'--port', str(port).encode()]):+            raise RuntimeError('Port owner changed before retirement')+        signal.pidfd_send_signal(process_handle.fileno(), signal.SIGTERM)+    for _ in range(50):+        try:+            alive = bool(Path(f'/proc/{pid}/cmdline').read_bytes())+        except FileNotFoundError:+            alive = False+        if not alive:+            return+        time.sleep(.1)+    raise RuntimeError('Previous dashboard did not stop; refusing to force-kill it')+++def ensure_server(port, log):+    url = f'http://127.0.0.1:{port}/'+    try:+        running = server_identity(url)+    except (OSError, ValueError):+        running = None+    if running:+        if running.get('app') != 'adom/antigravity':+            raise RuntimeError('Port is occupied by a different service')+        if running.get('version') == VERSION:+            return url+        old_version = tuple(int(v) for v in running['version'].split('.'))+        if old_version > tuple(int(v) for v in VERSION.split('.')):+            raise RuntimeError('Refusing to replace a newer Antigravity dashboard')+        retire_server(port)+    with (log / 'dashboard.log').open('ab') as out:+        process = subprocess.Popen([sys.executable, str(Path(__file__).resolve()), '_serve', '--port', str(port)], stdin=subprocess.DEVNULL, stdout=out, stderr=out, start_new_session=True)+    for _ in range(50):+        if process.poll() is not None:+            raise RuntimeError('Dashboard process exited; inspect ' + str(log / 'dashboard.log'))+        try:+            ready = server_identity(url)+            if ready.get('app') == 'adom/antigravity' and ready.get('version') == VERSION:+                return url+        except (OSError, ValueError):+            pass+        time.sleep(.1)+    raise RuntimeError('Dashboard failed to start; inspect ' + str(log / 'dashboard.log'))++ def main():     p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)     p.add_argument('command', choices=['status', 'context', 'install-extension', 'install-cli', 'open', 'serve', '_serve'])@@ -284,23 +375,10 @@ def main():         r = open_panel(a.new); print(json.dumps(r, indent=2)); sys.exit(0 if r.get('ok') else 1)     if a.command == '_serve':         ThreadingHTTPServer(('127.0.0.1', a.port), Handler).serve_forever(); return-    url = f'http://127.0.0.1:{a.port}/'-    try:-        r = json.load(urllib.request.urlopen(url + 'api/status', timeout=1)); assert r.get('app') == 'adom/antigravity' and r['version'] == VERSION-    except Exception:-        log = Path.home() / '.local/state/adom/antigravity'; log.mkdir(parents=True, exist_ok=True)-        with (log / 'dashboard.log').open('ab') as out:-            subprocess.Popen([sys.executable, str(Path(__file__).resolve()), '_serve', '--port', str(a.port)], stdout=out, stderr=out, start_new_session=True)-        for _ in range(50):-            try:-                ready = json.load(urllib.request.urlopen(url + 'api/status', timeout=.5))-                if ready.get('app') != 'adom/antigravity' or ready.get('version') != VERSION:-                    raise RuntimeError('Port is occupied by a different service')-                break-            except Exception:-                time.sleep(.1)-        else:-            raise RuntimeError('Dashboard failed to start; inspect ' + str(log / 'dashboard.log'))+    log = Path.home() / '.local/state/adom/antigravity'; log.mkdir(parents=True, exist_ok=True)+    with (log / f'launch-{a.port}.lock').open('a') as lock:+        fcntl.flock(lock, fcntl.LOCK_EX)+        url = ensure_server(a.port, log)     print(url, flush=True)  

@@ -0,0 +1,150 @@+"""Launch contract regressions: slow diagnostics must not break the dock."""+import json+import os+from pathlib import Path+import signal+import socket+import subprocess+import sys+import tempfile+import threading+import time+import unittest+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer+from unittest.mock import patch++import adom_antigravity as app+++class LegacyHandler(BaseHTTPRequestHandler):+    def log_message(self, *args):+        pass++    def do_GET(self):+        if self.path != '/api/status':+            self.send_error(404)+            return+        time.sleep(1.6)  # ConfRoomROG; longer than both original startup budgets.+        body = json.dumps({'app': 'adom/antigravity', 'version': app.VERSION}).encode()+        self.send_response(200)+        self.send_header('Content-Length', str(len(body)))+        self.end_headers()+        self.wfile.write(body)+++class StartupTests(unittest.TestCase):+    @staticmethod+    def free_port():+        with socket.socket() as sock:+            sock.bind(('127.0.0.1', 0))+            return sock.getsockname()[1]++    def serve_fixture(self, handler):+        server = ThreadingHTTPServer(('127.0.0.1', 0), handler)+        thread = threading.Thread(target=server.serve_forever, daemon=True)+        thread.start()+        self.addCleanup(server.server_close)+        self.addCleanup(server.shutdown)+        return server.server_port++    def launch(self, port, home):+        return subprocess.run(+            [sys.executable, str(Path(app.__file__)), 'serve', '--print-url', '--port', str(port)],+            env={**os.environ, 'HOME': home}, capture_output=True, text=True, timeout=25)++    def test_legacy_slow_status_is_reused_without_spawning(self):+        port = self.serve_fixture(LegacyHandler)+        with tempfile.TemporaryDirectory() as home:+            result = self.launch(port, home)+            self.assertEqual(result.returncode, 0, result.stderr)+            self.assertEqual(result.stdout.strip(), f'http://127.0.0.1:{port}/')+            self.assertFalse((Path(home) / '.local/state/adom/antigravity/dashboard.log').exists())++    def test_health_does_not_run_external_diagnostics(self):+        port = self.serve_fixture(app.Handler)+        with patch.object(app, 'context', side_effect=AssertionError('diagnostics ran')):+            self.assertEqual(app.server_identity(f'http://127.0.0.1:{port}/')['pid'], os.getpid())++    def test_cold_start_then_relaunch_keeps_same_process(self):+        with socket.socket() as sock:+            sock.bind(('127.0.0.1', 0))+            port = sock.getsockname()[1]+        with tempfile.TemporaryDirectory() as home:+            first = self.launch(port, home)+            self.assertEqual(first.returncode, 0, first.stderr)+            url = first.stdout.strip()+            pid = app.server_identity(url)['pid']+            try:+                second = self.launch(port, home)+                self.assertEqual(second.returncode, 0, second.stderr)+                self.assertEqual(second.stdout.strip(), url)+                self.assertEqual(app.server_identity(url)['pid'], pid)+            finally:+                os.kill(pid, signal.SIGTERM)++    def test_other_service_is_not_terminated(self):+        class OtherHandler(LegacyHandler):+            def do_GET(self):+                body = b'{"app":"another-app","version":"1"}'+                self.send_response(200)+                self.send_header('Content-Length', str(len(body)))+                self.end_headers()+                self.wfile.write(body)+        port = self.serve_fixture(OtherHandler)+        with tempfile.TemporaryDirectory() as home:+            result = self.launch(port, home)+            self.assertNotEqual(result.returncode, 0)+            self.assertEqual(app.server_identity(f'http://127.0.0.1:{port}/')['app'], 'another-app')++    @unittest.skipUnless(os.environ.get('ANTIGRAVITY_PREDECESSOR'), 'requires a registry predecessor')+    def test_registry_predecessor_upgrade_is_scoped_to_port(self):+        self.check_upgrade(os.environ['ANTIGRAVITY_PREDECESSOR'])++    def test_upgrade_of_server_with_current_lifecycle(self):+        with tempfile.TemporaryDirectory() as directory:+            predecessor = Path(directory) / Path(app.__file__).name+            predecessor.write_text(Path(app.__file__).read_text().replace(+                "VERSION = '0.1.6'", "VERSION = '0.1.5'"))+            self.check_upgrade(str(predecessor))++    def check_upgrade(self, predecessor):+        with tempfile.TemporaryDirectory() as home:+            ports = [self.free_port(), self.free_port()]+            old = [subprocess.Popen(+                [sys.executable, predecessor, '_serve', '--port', str(port)],+                env={**os.environ, 'HOME': home}, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)+                for port in ports]+            current_pid = None+            try:+                for index, port in enumerate(ports):+                    for _ in range(50):+                        self.assertIsNone(old[index].poll(), 'Predecessor process exited')+                        try:+                            state = app.server_identity(f'http://127.0.0.1:{port}/')+                            self.assertEqual(state['version'], '0.1.5')+                            break+                        except OSError:+                            time.sleep(.1)+                    else:+                        self.fail('Predecessor never started')+                result = self.launch(ports[0], home)+                self.assertEqual(result.returncode, 0, result.stderr)+                state = app.server_identity(result.stdout.strip())+                current_pid = state['pid']+                self.assertEqual(state['version'], app.VERSION)+                old[0].wait(timeout=5)+                self.assertIsNone(old[1].poll(), 'Another port was affected')+                again = self.launch(ports[0], home)+                self.assertEqual(again.returncode, 0, again.stderr)+                self.assertEqual(app.server_identity(again.stdout.strip())['pid'], current_pid)+            finally:+                if current_pid:+                    os.kill(current_pid, signal.SIGTERM)+                for process in old:+                    if process.poll() is None:+                        process.terminate()+                    process.wait(timeout=5)+++if __name__ == '__main__':+    unittest.main()