devops-bot-sdk 1.6.53__tar.gz → 1.6.56__tar.gz

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.53
+Version: 1.6.56
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.53
+Version: 1.6.56
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -137,6 +137,7 @@ sdk/ui/static/schedules.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
+sdk/vendor/aidraftsman-cli-0.1.0.tgz
 tests/test_activity_collectors.py
 tests/test_activity_core.py
 tests/test_activity_macos.py
@@ -167,6 +168,7 @@ tests/test_epic_decompose_run.py
 tests/test_epic_inherited_agent_id.py
 tests/test_epic_session_isolation.py
 tests/test_estimator.py
+tests/test_fallback_cli.py
 tests/test_firewall_open_on_update.py
 tests/test_formats.py
 tests/test_git_action.py

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/pyproject.toml

@@ -68,7 +68,7 @@ where = ["."]
 include = ["sdk*"]
 
 [tool.setuptools.package-data]
-sdk = ["py.typed", "ui/static/*"]
+sdk = ["py.typed", "ui/static/*", "vendor/*.tgz"]
 
 [tool.ruff]
 line-length   = 100

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/sdk/__init__.py

@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.53"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.56"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/sdk/agentd.py

@@ -199,6 +199,11 @@ def _daemon_running() -> int | None:
     return None
 
 
+#: Set in the environment right before the macOS re-exec below, read back by the
+#: fresh interpreter so it knows it IS the detached daemon and must not fork again.
+_DAEMONIZED_ENV = "AGENTOS_AGENTD_DAEMONIZED"
+
+
 def _daemonize() -> bool:
     """Detach the current process from the terminal (POSIX double-fork).
 
@@ -207,10 +212,23 @@ def _daemonize() -> bool:
     _LOG_FILE and a PID file is written so `status` can find the daemon.
     Returns False (stays in the foreground) on platforms without os.fork
     (e.g. Windows).
+
+    On macOS the detached child re-execs a fresh interpreter instead of running
+    the daemon in-process (see below); ``main()`` re-enters here with the
+    ``_DAEMONIZED_ENV`` marker set, where setsid, the redirected fds 0/1/2 and the
+    PID file already survive the exec, so we only re-point the stream wrappers.
     """
     if not hasattr(os, "fork"):
         return False  # caller falls back to foreground
 
+    if os.environ.get(_DAEMONIZED_ENV) == "1":
+        # Don't leak the one-shot marker to subprocesses the daemon later spawns
+        # (claude, git, …) — they must never think THEY are the detached daemon.
+        os.environ.pop(_DAEMONIZED_ENV, None)
+        sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
+        sys.stderr = sys.stdout
+        return True
+
     _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
 
     # First fork: let the shell reap the parent and return the prompt.
@@ -232,13 +250,27 @@ def _daemonize() -> bool:
     os.close(devnull)
     os.close(logfd)
 
+    _PID_FILE.write_text(str(os.getpid()))
+
+    # macOS: re-exec a FRESH interpreter so the daemon's networking runs in a clean
+    # process image. A bare double-fork() with NO exec() leaves Apple's higher-level
+    # frameworks (Network.framework DNS/NAT64, the libsystem_trace os_log cache)
+    # half-initialised in the child, and the first getaddrinfo on the asyncio resolver
+    # thread then SIGSEGVs ("crashed on child side of fork pre-exec"). OBJC_DISABLE_
+    # INITIALIZE_FORK_SAFETY silences only the objc guard, not these — so it is not
+    # enough on macOS 26. The exec'd process keeps this PID, setsid session and fds.
+    if sys.platform == "darwin":
+        os.environ[_DAEMONIZED_ENV] = "1"
+        try:
+            os.execv(sys.executable, [sys.executable, sys.argv[0], *sys.argv[1:]])
+        except Exception:  # noqa: BLE001 — exec failed; fall back to in-process daemon
+            os.environ.pop(_DAEMONIZED_ENV, None)
+
     # Line-buffer stdout/stderr so progress reaches the log live rather than
     # sitting in Python's block-buffer for a non-tty stream (same fix
     # sdk/run_auto.py applies for the same reason).
     sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
     sys.stderr = sys.stdout
-
-    _PID_FILE.write_text(str(os.getpid()))
     return True
 
 
@@ -736,17 +768,22 @@ class AgentDaemon:
 
 def start(foreground: bool = False) -> None:
     """Start agentd — in the background by default, attached with --foreground."""
+    # macOS re-exec of the already-detached daemon (see _daemonize): this process
+    # IS the daemon — the duplicate guard, banner and stop-flag clear all ran in
+    # the original process before the fork, so skip straight to re-detaching.
+    resuming = os.environ.get(_DAEMONIZED_ENV) == "1"
     if not foreground:
-        pid = _daemon_running()
-        if pid:
-            print(f"agentd is already running in the background (pid {pid}).")
-            print(f"  logs:   {_LOG_FILE}")
-            return
+        if not resuming:
+            pid = _daemon_running()
+            if pid:
+                print(f"agentd is already running in the background (pid {pid}).")
+                print(f"  logs:   {_LOG_FILE}")
+                return
 
-        print("agentd starting in the background — it keeps running after you "
-              "close this terminal.")
-        print(f"  logs:   {_LOG_FILE}")
-        _clear_stop()  # a fresh start clears any stale stop flag
+            print("agentd starting in the background — it keeps running after you "
+                  "close this terminal.")
+            print(f"  logs:   {_LOG_FILE}")
+            _clear_stop()  # a fresh start clears any stale stop flag
         if not _daemonize():
             print("note: background mode unavailable on this platform — running "
                   "in the foreground.")

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/sdk/ipc/handlers.py

@@ -3920,12 +3920,15 @@ _HOME_PATH_RE = re.compile(r"(?<![\w.])~(?:/[A-Za-z0-9._\- ]+)+")
 # `[\\/]+` in the separator position, not a single `\\`: a doubled separator is a
 # thing people write (`D://Nexus-AI` — the exact form in one bug report) and the
 # old pattern rejected it outright, sending the ticket to the ~/AgentOS fallback.
-_WIN_PATH_RE = re.compile(r"[A-Za-z]:[\\/]+(?:[^\\/:*?\"<>|\r\n]+[\\/]*)+")
+# The drive letter must not follow a word character: in `https://host/...` the
+# `s:` of the scheme otherwise reads as drive S:, so any ticket quoting a web link
+# "named" the folder `s://host/...` and was refused as unresolvable.
+_WIN_PATH_RE = re.compile(r"(?<![A-Za-z0-9_])[A-Za-z]:[\\/]+(?:[^\\/:*?\"<>|\r\n]+[\\/]*)+")
 # Windows path written with FORWARD slashes (e.g. C:/Users/me/new_tasks) — common on
 # Windows. Segments here also allow spaces, for the same reason the backslash form
 # does; over-capture is settled afterwards by `_trim_to_existing_dir`, not by trying
 # to tell a folder name from prose with a regex.
-_WIN_FS_PATH_RE = re.compile(r"[A-Za-z]:/+(?:[^\\/:*?\"<>|\r\n]+/*)+")
+_WIN_FS_PATH_RE = re.compile(r"(?<![A-Za-z0-9_])[A-Za-z]:/+(?:[^\\/:*?\"<>|\r\n]+/*)+")
 # A QUOTED path (single/double/back quotes) — the reliable way to give a path that
 # contains spaces, on any OS. Accepts a drive letter with EITHER separator (C:\ or C:/).
 _QUOTED_PATH_RE = re.compile(r"""["'`]\s*((?:[A-Za-z]:[\\/]|~/|/)[^"'`\r\n]+?)\s*["'`]""")

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/sdk/local_exec.py

@@ -552,7 +552,7 @@ def _local_mcp_servers() -> dict[str, dict]:
     return servers
 
 
-async def run_claude_local(
+async def _run_claude_cli(
     prompt: str,
     project_path: str,
     *,
@@ -1042,3 +1042,305 @@ async def run_claude_local(
         provider=provider,
         model=cli_model["name"] or None,
     ))
+
+
+# ── Fallback: the AI Draftsman CLI ─────────────────────────────────────────
+# When the `claude` CLI is not working — not installed, logged out, out of
+# usage, or dying before it even starts a session — the ticket is re-run on
+# our own AI Draftsman CLI (`aidraftsman`, npm package @aidraftsman/cli) instead
+# of failing or parking. It is the same job against the same project dir: the
+# prompt goes in on stdin, `-p --output-format json` prints one JSON object.
+# The CLI is bundled in sdk/vendor/ and npm-installed into ~/.agentos/aidraftsman
+# the first time it is needed; one already on PATH is used instead. It needs
+# its own login on the box (`ad auth login`, or AD_API_KEY in the env).
+#
+# What it does NOT do: honour the PreToolUse approval guard, resume a Claude
+# session, or stream progress events. So a resumed run never falls back (the
+# prompt would be "continue" with no context behind it), and the permission
+# mode defaults to acceptEdits — file edits apply, but a shell command that is
+# not read-only is denied rather than run unguarded. Set
+# AGENTOS_FALLBACK_PERMISSION_MODE=bypass to let it run every command.
+#
+# Settings (process env or ~/.agentos/.env):
+#   AGENTOS_FALLBACK_CLI              path to the CLI (default: PATH, then bundled), or "off"
+#   AGENTOS_FALLBACK_AGENT            agent id/name for `--agent` (default: gateway's choice)
+#   AGENTOS_FALLBACK_PERMISSION_MODE  default | acceptEdits | plan | bypass
+
+_FALLBACK_MODES = ("default", "acceptEdits", "plan", "bypass")
+
+
+def _setting(key: str) -> str:
+    value = os.environ.get(key, "").strip()
+    if value:
+        return value
+    try:
+        from sdk.config import _dotenv_value
+        return (_dotenv_value(key) or "").strip()
+    except Exception:  # noqa: BLE001 — a config hiccup must never break resolution
+        return ""
+
+
+#: The CLI ships inside the SDK (sdk/vendor/*.tgz) so every box has it without
+#: a separate install step; it is npm-installed from there on first use.
+_VENDOR_DIR = Path(__file__).parent / "vendor"
+
+
+def _fallback_disabled() -> bool:
+    return _setting("AGENTOS_FALLBACK_CLI").lower() in ("off", "0", "false", "no", "none")
+
+
+def _bundled_tarball() -> Path | None:
+    tarballs = sorted(_VENDOR_DIR.glob("aidraftsman-cli-*.tgz"))
+    return tarballs[-1] if tarballs else None
+
+
+def _bundled_bin(tarball: Path) -> Path:
+    """Where the bundled tarball's `aidraftsman` lands once installed.
+
+    One prefix per tarball name, so an SDK update that ships a new CLI version
+    installs it fresh rather than reusing the old one.
+    """
+    prefix = config._CONFIG_DIR / "aidraftsman" / tarball.name.removesuffix(".tgz")
+    name = "aidraftsman.cmd" if sys.platform == "win32" else "aidraftsman"
+    return prefix / "node_modules" / ".bin" / name
+
+
+def fallback_cli_path() -> str | None:
+    """Absolute path to an installed `aidraftsman` CLI, or None if absent or disabled.
+
+    Resolution order: ``AGENTOS_FALLBACK_CLI``, then ``PATH``, then the copy
+    installed from the bundled tarball. Never installs anything — see
+    :func:`ensure_fallback_cli` for that.
+    """
+    if _fallback_disabled():
+        return None
+    override = _setting("AGENTOS_FALLBACK_CLI")
+    if override and Path(override).exists():
+        return override
+    found = shutil.which("aidraftsman")
+    if found:
+        return found
+    tarball = _bundled_tarball()
+    if tarball and _bundled_bin(tarball).exists():
+        return str(_bundled_bin(tarball))
+    return None
+
+
+def _install_bundled(tarball: Path) -> str | None:
+    """``npm install`` the bundled tarball into a private prefix (no sudo, no -g)."""
+    npm = shutil.which("npm")
+    if not npm:
+        print("aidraftsman fallback unavailable: npm not found (Node.js 20+ required)", flush=True)
+        return None
+    bin_path = _bundled_bin(tarball)
+    prefix = bin_path.parents[2]
+    prefix.mkdir(parents=True, exist_ok=True)
+    cmd = [npm, "install", "--prefix", str(prefix), "--no-audit", "--no-fund",
+           "--omit=dev", str(tarball)]
+    if sys.platform == "win32" and npm.lower().endswith((".cmd", ".bat")):
+        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
+    print(f"installing bundled {tarball.name} into {prefix}", flush=True)
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, errors="replace",
+                              timeout=600)
+    except Exception as exc:  # noqa: BLE001 — never raise into a ticket run
+        print(f"aidraftsman install failed: {exc}", flush=True)
+        return None
+    if proc.returncode != 0 or not bin_path.exists():
+        print(f"aidraftsman install failed: {(proc.stderr or proc.stdout).strip()[-300:]}",
+              flush=True)
+        return None
+    return str(bin_path)
+
+
+async def ensure_fallback_cli() -> str | None:
+    """:func:`fallback_cli_path`, installing the bundled CLI first if needed."""
+    found = fallback_cli_path()
+    if found or _fallback_disabled():
+        return found
+    tarball = _bundled_tarball()
+    if not tarball:
+        return None
+    return await asyncio.to_thread(_install_bundled, tarball)
+
+
+def _claude_not_working(result: dict[str, Any]) -> bool:
+    """True when the run failed because of the `claude` CLI, not the task.
+
+    A task that ran and failed on its own merits (an error result, a full
+    context window, a capped response) would fail the same way elsewhere, so
+    those stay with the caller's existing recovery.
+    """
+    if result.get("ok"):
+        return False
+    if result.get("auth_expired") or result.get("limit_exceeded"):
+        return True
+    if result.get("context_exceeded") or result.get("output_cap_exceeded"):
+        return False
+    # No session id means the CLI never got as far as its init event: missing,
+    # crashed on start-up, or hung before doing anything.
+    return not result.get("session_id")
+
+
+def _git_changed_files(path: Path) -> set[str] | None:
+    """Paths `git status` reports as changed/untracked, or None outside a repo."""
+    try:
+        proc = subprocess.run(["git", "status", "--porcelain", "-uall"], cwd=str(path),
+                              capture_output=True, text=True, timeout=30)
+    except Exception:  # noqa: BLE001 — no git, or a slow repo: just skip the list
+        return None
+    if proc.returncode != 0:
+        return None
+    out = set()
+    for line in proc.stdout.splitlines():
+        name = line[3:].split(" -> ")[-1].strip().strip('"')
+        if name:
+            out.add(str(path / name))
+    return out
+
+
+async def run_fallback_cli(
+    prompt: str,
+    project_path: str,
+    *,
+    timeout: float = _DEFAULT_TIMEOUT_S,
+    github_token: str | None = None,
+    extra_env: dict[str, str] | None = None,
+    tier: str | None = None,
+    provider: str | None = None,
+) -> dict[str, Any]:
+    """Run ``prompt`` on the AI Draftsman CLI. Same result shape as the claude run."""
+    cli = await ensure_fallback_cli()
+    if not cli:
+        return _result(ok=False, error="AI Draftsman CLI not available (needs Node.js 20+ "
+                                       "and npm to install the bundled copy).",
+                       tier=tier, provider=provider)
+
+    path = Path(project_path).expanduser()
+    path.mkdir(parents=True, exist_ok=True)
+
+    mode = _setting("AGENTOS_FALLBACK_PERMISSION_MODE") or "acceptEdits"
+    if mode not in _FALLBACK_MODES:
+        mode = "acceptEdits"
+    cmd = [cli, "-p", "--output-format", "json", "--permission-mode", mode]
+    agent = _setting("AGENTOS_FALLBACK_AGENT")
+    if agent:
+        cmd += ["--agent", agent]
+    # npm installs a .cmd shim on Windows — same reason as the claude spawn.
+    if sys.platform == "win32" and cli.lower().endswith((".cmd", ".bat")):
+        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
+
+    env = dict(os.environ)
+    if extra_env:
+        env.update({k: str(v) for k, v in extra_env.items() if v is not None})
+    if github_token:
+        env["GH_TOKEN"] = github_token
+        env["GITHUB_TOKEN"] = github_token
+        env["GIT_CONFIG_COUNT"] = "1"
+        env["GIT_CONFIG_KEY_0"] = (
+            f"url.https://x-access-token:{github_token}@github.com/.insteadOf"
+        )
+        env["GIT_CONFIG_VALUE_0"] = "https://github.com/"
+
+    before = _git_changed_files(path)
+    print(f"aidraftsman fallback spawn | mode={mode} | {path}", flush=True)
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, cwd=str(path), env=env,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(
+            proc.communicate((prompt or "").encode("utf-8")), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        return _result(ok=False, error=f"aidraftsman CLI timed out after {timeout:.0f}s",
+                       tier=tier, provider=provider, model="aidraftsman")
+    except asyncio.CancelledError:
+        try:
+            proc.kill()
+        except ProcessLookupError:
+            pass
+        raise
+
+    after = _git_changed_files(path)
+    files_changed = sorted(after - before) if before is not None and after is not None else []
+    err_text = stderr.decode("utf-8", errors="replace").strip()
+
+    data: dict[str, Any] = {}
+    for line in reversed(stdout.decode("utf-8", errors="replace").splitlines()):
+        try:
+            data = json.loads(line)
+            break
+        except json.JSONDecodeError:
+            continue
+    if proc.returncode != 0 or not isinstance(data, dict) or "result" not in data:
+        err = err_text[-500:] or f"aidraftsman exited with code {proc.returncode}"
+        return _result(ok=False, error=err, files_changed=files_changed,
+                       auth_expired=proc.returncode == 2 or _is_auth_error(err),
+                       tier=tier, provider=provider, model="aidraftsman")
+
+    usage = data.get("usage") or {}
+    in_tok = int(usage.get("prompt_tokens", 0) or 0)
+    out_tok = int(usage.get("completion_tokens", 0) or 0)
+    text = str(data.get("result") or "")
+    return _result(
+        ok=True,
+        result=text,
+        longest_text=text,
+        input_tokens=in_tok,
+        output_tokens=out_tok,
+        total_tokens=int(usage.get("total_tokens", 0) or 0) or in_tok + out_tok,
+        files_changed=files_changed,
+        tier=tier,
+        provider=provider,
+        model=f"aidraftsman:{data.get('agent') or 'auto'}",
+    )
+
+
+async def run_claude_local(
+    prompt: str,
+    project_path: str,
+    *,
+    allowed_tools: list[str] | None = None,
+    on_event: EventHandler | None = None,
+    timeout: float = _DEFAULT_TIMEOUT_S,
+    github_token: str | None = None,
+    resume_session_id: str | None = None,
+    approval_dir: str | None = None,
+    idle_timeout: float = _IDLE_TIMEOUT_S,
+    max_output_tokens: int | None = None,
+    extra_env: dict[str, str] | None = None,
+    unset_env: list[str] | None = None,
+    settings_env: dict[str, str] | None = None,
+    tier: str | None = None,
+    provider: str | None = None,
+) -> dict[str, Any]:
+    """Run the local `claude` CLI; if the CLI itself is not working, re-run on
+    the AI Draftsman CLI. See ``_run_claude_cli`` for the arguments and the
+    result shape, and the fallback notes above ``run_fallback_cli``.
+    """
+    result = await _run_claude_cli(
+        prompt, project_path,
+        allowed_tools=allowed_tools, on_event=on_event, timeout=timeout,
+        github_token=github_token, resume_session_id=resume_session_id,
+        approval_dir=approval_dir, idle_timeout=idle_timeout,
+        max_output_tokens=max_output_tokens, extra_env=extra_env,
+        unset_env=unset_env, settings_env=settings_env, tier=tier, provider=provider,
+    )
+    if resume_session_id or not _claude_not_working(result) or _fallback_disabled():
+        return result
+
+    print(f"claude CLI not working ({(result.get('error') or '')[:200]}) — "
+          f"falling back to aidraftsman", flush=True)
+    fallback = await run_fallback_cli(
+        prompt, project_path, timeout=timeout, github_token=github_token,
+        extra_env=extra_env, tier=tier, provider=provider,
+    )
+    if fallback["ok"]:
+        return fallback
+    # Both failed: keep the claude result (its limit/auth flags drive the
+    # caller's parking and alerts) and say what the fallback hit too.
+    result["error"] = f"{result.get('error')} | aidraftsman fallback: {fallback.get('error')}"
+    return result

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/sdk/platform_compat.py

@@ -80,12 +80,21 @@ def ensure_utf8_stdio() -> None:
 def ensure_macos_fork_safety() -> None:
     """Stop macOS from killing our background daemons with a native abort.
 
-    ``agentos-auto`` / ``agentos-agentd`` double-fork (fork + setsid, no exec)
-    into a background daemon that then does networking (httpx → CFNetwork /
+    ``agentos-auto`` / ``agentos-agentd`` double-fork (fork + setsid) into a
+    background daemon that then does networking (httpx → CFNetwork /
     SystemConfiguration) and TLS. When the Objective-C runtime detects objc use
     after a bare ``fork()`` with no ``exec()`` it calls ``abort()`` — which macOS
     surfaces as the "Python quit unexpectedly" crash dialog. Exporting
-    ``OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`` disables that guard.
+    ``OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`` disables that *objc* guard.
+
+    It is NOT sufficient on its own: Apple's higher-level frameworks (Network.
+    framework's DNS/NAT64 path, the libsystem_trace ``os_log`` cache) are also
+    fork-unsafe and will SIGSEGV in the forked child on the first ``getaddrinfo``
+    — the env var does not cover them. The actual fix for that is in each daemon's
+    ``_daemonize()``, which re-execs a fresh interpreter after the double-fork so
+    the daemon runs in a clean process image. This shim remains the belt to that
+    braces: it quiets the objc guard and short-circuits the ``_scproxy`` lookup for
+    any pre-fork or non-daemon objc use, and seeds the var for the exec'd child.
 
     The objc runtime reads that variable when its dylib is first mapped (that is
     interpreter startup on framework Python builds), so setting it via

{devops_bot_sdk-1.6.53 → devops_bot_sdk-1.6.56}/sdk/run_auto.py

@@ -330,6 +330,23 @@ def _daemon_running() -> int | None:
     return None
 
 
+#: Set in the environment right before the macOS re-exec below, read back by the
+#: fresh interpreter so it knows it IS the detached daemon and must not fork again.
+_DAEMONIZED_ENV = "AGENTOS_AUTO_DAEMONIZED"
+
+
+def _relog_line_buffered() -> None:
+    """Point sys.stdout/stderr at _LOG_FILE line-buffered.
+
+    When stdout is a file (not a tty) Python block-buffers it, so progress printed
+    via _send() would sit in the buffer and never reach the log until the process
+    exits — making the daemon look idle. A line-buffered writer flushes every
+    progress line live, exactly like the foreground run.
+    """
+    sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
+    sys.stderr = sys.stdout
+
+
 def _daemonize() -> bool:
     """Detach the current process from the terminal (POSIX double-fork).
 
@@ -337,10 +354,23 @@ def _daemonize() -> bool:
     os._exit() and never return. stdout/stderr are redirected to _LOG_FILE and a
     PID file is written so `stop`/`status` can find the loop. Returns False (stays
     in the foreground) on platforms without os.fork (e.g. Windows).
+
+    On macOS the detached child does NOT run the loop in-process: it re-execs a
+    fresh interpreter (see below) and ``main()`` re-enters here with the
+    ``_DAEMONIZED_ENV`` marker set — at which point setsid, the redirected fds
+    0/1/2 and the PID file already survive from before the exec, so we only
+    re-point the Python stream wrappers and report "I am the daemon".
     """
     if not hasattr(os, "fork"):
         return False  # caller falls back to foreground
 
+    if os.environ.get(_DAEMONIZED_ENV) == "1":
+        # Don't leak the one-shot marker to subprocesses the loop later spawns
+        # (claude, git, …) — they must never think THEY are the detached daemon.
+        os.environ.pop(_DAEMONIZED_ENV, None)
+        _relog_line_buffered()
+        return True
+
     _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
 
     # First fork: let the shell reap the parent and return the prompt.
@@ -362,15 +392,24 @@ def _daemonize() -> bool:
     os.close(devnull)
     os.close(logfd)
 
-    # CRITICAL: when stdout is a file (not a tty) Python block-buffers it, so
-    # progress printed via _send() would sit in the buffer and never reach the
-    # log until the process exits — making the daemon look idle. Replace the
-    # streams with line-buffered writers so every progress line is flushed live,
-    # exactly like the foreground run.
-    sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
-    sys.stderr = sys.stdout
-
     _write_pid()
+
+    # macOS: re-exec a FRESH interpreter so the daemon that does networking runs in
+    # a clean process image. A bare double-fork() with NO exec() leaves Apple's
+    # higher-level frameworks (Network.framework's DNS/NAT64 path, the libsystem_trace
+    # os_log cache) half-initialised in the child, and the FIRST getaddrinfo on the
+    # asyncio resolver thread then SIGSEGVs ("crashed on child side of fork pre-exec").
+    # OBJC_DISABLE_INITIALIZE_FORK_SAFETY only silences the objc +initialize guard,
+    # NOT these frameworks — so the env var alone is not enough on macOS 26. The exec'd
+    # process keeps this PID, this setsid session and the fds 0/1/2 redirected above.
+    if sys.platform == "darwin":
+        os.environ[_DAEMONIZED_ENV] = "1"
+        try:
+            os.execv(sys.executable, [sys.executable, sys.argv[0], *sys.argv[1:]])
+        except Exception:  # noqa: BLE001 — exec failed; fall back to in-process daemon
+            os.environ.pop(_DAEMONIZED_ENV, None)
+
+    _relog_line_buffered()
     return True
 
 
@@ -1460,6 +1499,11 @@ def main() -> None:
         #   ticket K...  → ONLY the named Jira keys (any status, in order)
         #   story [K...] → convert Stories → Tasks only (with PRD); NO coding.
         #                  With keys: those Stories; without: every To Do Story.
+        # macOS re-exec of the already-detached daemon (see _daemonize): this
+        # process IS the loop owner — the update, the duplicate-loop guard and the
+        # banner all ran in the original process before the fork, so skip them and
+        # go straight to detaching (a no-op fork here) and running the loop.
+        resuming = os.environ.get(_DAEMONIZED_ENV) == "1"
         only_keys: list[str] | None = None
         stories_only = cmd in ("story", "stories")
         # `--agent-only` narrows whichever mode was chosen to the agent-tagged
@@ -1480,17 +1524,19 @@ def main() -> None:
         # long-lived old daemon would pin `stop`/`status` to a stale version. Runs
         # in the FOREGROUND so the user sees update output; re-execs on the new
         # code. Skipped with --no-update or AGENTOS_NO_UPDATE=1.
-        if "--no-update" not in argv:
+        if not resuming and "--no-update" not in argv:
             from sdk.updater import auto_update_and_reexec
             auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
 
         # Refuse to start a second loop — one background daemon owns the queue.
-        pid = _daemon_running()
-        if pid:
-            print(f"agentos-auto is already running in the background (pid {pid}).")
-            print(f"  logs:   {_LOG_FILE}")
-            print("  stop:   agentos-auto stop")
-            return
+        # (The re-exec'd daemon IS that loop; its own live PID would trip this.)
+        if not resuming:
+            pid = _daemon_running()
+            if pid:
+                print(f"agentos-auto is already running in the background (pid {pid}).")
+                print(f"  logs:   {_LOG_FILE}")
+                print("  stop:   agentos-auto stop")
+                return
 
         workspace_root = _parse_workspace_root(argv)
 
@@ -1513,7 +1559,7 @@ def main() -> None:
         # the loop — it runs until `agentos-auto stop`. `--foreground`/`-f` keeps it
         # attached (useful for debugging). On platforms without fork we stay attached.
         foreground = "--foreground" in argv or "-f" in argv
-        if not foreground and hasattr(os, "fork"):
+        if not foreground and not resuming and hasattr(os, "fork"):
             if stories_only:
                 target = (f" — stories→tasks: {', '.join(only_keys)}" if only_keys
                           else " — converting all To Do Stories → Tasks")
@@ -1527,7 +1573,7 @@ def main() -> None:
             print("  status: agentos-auto status")
             print("  stop:   agentos-auto stop")
         if not foreground and _daemonize():
-            # detached daemon child only
+            # detached daemon child only (on macOS, the re-exec'd process)
             _run_loop(workspace_root, only_keys, stories_only, agent_only)
             return
         if not foreground: