agentic-runner 3.5.0__tar.gz → 3.7.0__tar.gz

{agentic_runner-3.5.0 → agentic_runner-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-runner
-Version: 3.5.0
+Version: 3.7.0
 Summary: The Agentic OS Runner: an activity-only Temporal executor for workspaces, Agent Runtimes and verb seams
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{agentic_runner-3.5.0 → agentic_runner-3.7.0}/src/agentic_runner/__init__.py

@@ -7,6 +7,6 @@ stay on the platform; this package imports none of them, and a CI partition test
 (``tests/test_package_partition.py``) fails the build if that changes.
 """
 
-__version__ = "3.5.0"
+__version__ = "3.7.0"
 
 __all__ = ["__version__"]

{agentic_runner-3.5.0 → agentic_runner-3.7.0}/src/agentic_runner/activities.py

@@ -118,6 +118,7 @@ from agentic_runner.message_store import MessageStore, WorkflowSignaller
 from agentic_runner.registration import RunnerRegistrationError
 from agentic_runner.runtime import verifier_command
 from agentic_runner.runtime.verifier_command import CommandValidationError
+from agentic_runner.usage_windows import UsageWindows
 from agentic_runner.workers._runtime_support import (
     RESERVED_DIRECTIVE_ENV,
     bound_text,
@@ -174,6 +175,7 @@ from agentic_runner_contracts.activity_io import (
     GitHubCallError,
     GitHubCallFailure,
     HarnessHold,
+    HarnessHoldKind,
     LearningDirectiveInput,
     LearningDirectiveOutput,
     MemberDirectiveInput,
@@ -1616,10 +1618,13 @@ class RunnerRalphActivities:
         tool_server_health: ToolServerHealthLog | None = None,
         attempt_records: AttemptRecords | None = None,
         directives_in_flight: DirectivesInFlight | None = None,
+        usage_windows: UsageWindows | None = None,
     ) -> None:
         self._fastapi_client = fastapi_client
         # Read by the harness self-test, which never runs beside a Contract's Directive.
         self._directives_in_flight = directives_in_flight or DirectivesInFlight()
+        # Local-agents 10: None off a user-hosted Runner, which reports no usage windows.
+        self._usage_windows = usage_windows
         # Wall-clock source for per-Directive runtime, accrued against the Budget's
         # wall-clock dimension (ADR-0007). Activities run outside the Temporal sandbox,
         # so a real monotonic clock is allowed here (it must never be used in the
@@ -5273,6 +5278,13 @@ class RunnerRalphActivities:
             error=result.error,
             now=datetime.now(UTC),
         )
+        if self._usage_windows is not None and runtime_state.contract_id:
+            self._usage_windows.after_directive(
+                runtime_state.contract_id,
+                runtime_state.cli_kind,
+                result.usage_windows,
+                usage_limit=hold is not None and hold.kind == HarnessHoldKind.USAGE_LIMIT,
+            )
         if hold is None:
             return None
         await self._fastapi_client.append_evidence(

{agentic_runner-3.5.0 → agentic_runner-3.7.0}/src/agentic_runner/device_login_activities.py

@@ -13,7 +13,8 @@ from datetime import UTC, datetime
 from temporalio import activity
 from temporalio.exceptions import ApplicationError
 
-from agentic_runner.auth_mode import SHARED_RUNNER_SIGN_IN_RULE
+from agentic_runner.auth_mode import SHARED_RUNNER_SIGN_IN_RULE, is_shared_runner
+from agentic_runner.workers.claude_sign_in import OAUTH_TOKEN
 from agentic_runner.workers.contract_device_login import ContractDeviceLogin
 from agentic_runner.workers.contract_isolation import ContractIsolation
 from agentic_runner_contracts.activity_io import (
@@ -36,10 +37,10 @@ class ContractDeviceLoginActivities:
         host_party: str | None = None,
     ) -> None:
         self._contract_isolation = contract_isolation
-        # The party this process was registered as hosted by. A shared Runner never runs a
-        # subscription, so it never starts or reads one either (local-agents 04).
+        # The party this process was registered as hosted by. A shared Runner signs in only
+        # a Claude Code long-lived token (local-agents 04, amended by 21).
         self._host_party = host_party
-        # Injectable for tests; None falls through to the real `codex` subprocess.
+        # Injectable for tests; None falls through to the real vendor CLIs.
         self._device_login = device_login or ContractDeviceLogin(contract_isolation)
 
     def activity_callables(self) -> list[Callable[..., object]]:
@@ -52,9 +53,12 @@ class ContractDeviceLoginActivities:
     async def sign_in_contract_device_login(
         self, request: ContractDeviceLoginInput
     ) -> ContractDeviceLoginResult:
-        self._refuse_on_shared_runner()
+        long_lived = request.runtime_kind == "claude_code" and (request.method or OAUTH_TOKEN) == (
+            OAUTH_TOKEN
+        )
+        self._refuse_on_shared_runner(allow=long_lived)
         prompt = await self._device_login.sign_in(
-            request.contract_id, runtime_kind=request.runtime_kind
+            request.contract_id, runtime_kind=request.runtime_kind, method=request.method
         )
         return ContractDeviceLoginResult(
             contract_id=prompt.contract_id,
@@ -62,12 +66,24 @@ class ContractDeviceLoginActivities:
             verification_uri=prompt.verification_uri,
             user_code=prompt.user_code,
             expires_at=prompt.expires_at.isoformat(),
+            sign_in_id=prompt.sign_in_id,
         )
 
     @activity.defn(name="check_contract_device_login_status")
     async def check_contract_device_login_status(
         self, request: ContractDeviceLoginStatusInput
     ) -> ContractDeviceLoginStatusResult:
+        if request.runtime_kind == "claude_code":
+            self._refuse_on_shared_runner(allow=True)
+            status = await self._device_login.claude.status(request.contract_id)
+            return ContractDeviceLoginStatusResult(
+                contract_id=request.contract_id,
+                runtime_kind=request.runtime_kind,
+                token_present=status.logged_in,
+                delivered_at=None,
+                auth_method=status.auth_method,
+                subscription_type=status.subscription_type,
+            )
         self._refuse_on_shared_runner()
         present = self._device_login.token_present(
             request.contract_id, runtime_kind=request.runtime_kind
@@ -86,18 +102,20 @@ class ContractDeviceLoginActivities:
             delivered_at=delivered_at,
         )
 
-    def _refuse_on_shared_runner(self) -> None:
+    def _refuse_on_shared_runner(self, *, allow: bool = False) -> None:
         """Non-retryable, and typed by the rule: there is no Work Record to write Evidence
         on here, so the failure the platform's sign-in workflow receives names it.
 
-        Only a Runner known to be the person's own signs in: one whose state names no host
-        party (registered before issue 42) is refused too, as `choose_auth_mode` never runs
-        a subscription on it either."""
+        Only a Runner known to be the person's own signs in, except that a shared Runner
+        may make (``allow``) a Claude Code long-lived token (local-agents 21). One whose
+        state names no host party (registered before issue 42) is refused either way, as
+        `choose_auth_mode` never runs a subscription on it."""
 
-        if self._host_party != "user":
+        if self._host_party != "user" and not (allow and is_shared_runner(self._host_party)):
             raise ApplicationError(
                 f"this Runner is hosted by {self._host_party!r}; only a person's own Runner "
-                "signs in, a shared Runner runs API keys only",
+                "signs in, a shared Runner runs API keys and Claude Code long-lived tokens "
+                "only",
                 type=SHARED_RUNNER_SIGN_IN_RULE,
                 non_retryable=True,
             )

{agentic_runner-3.5.0 → agentic_runner-3.7.0}/src/agentic_runner/sealed_box.py

@@ -61,6 +61,7 @@ from agentic_runner_contracts.sealed_credential import (
     SEAL_DOMAIN,
     OpenedCredential,
     SealedCredential,
+    SealedSignInCode,
     delivery_binding,
     key_fingerprint,
 )
@@ -516,15 +517,25 @@ class SealedCredentialStream:
         if not self._awaiting:
             self._keys.retire_previous()
 
+    def open_sign_in_code(self, sealed: SealedSignInCode) -> str | None:
+        """A relayed sign-in code, or None when it does not open (local-agents 05).
+
+        Opened with the same Recipient Key as a slot, but never held: the caller types it
+        into the waiting CLI and drops it.
+        """
+
+        return self._open_with(sealed.recipient_key_id, sealed.binding(), sealed.ciphertext)
+
     def _open(self, sealed: SealedCredential) -> str | None:
+        return self._open_with(sealed.recipient_key_id, sealed.binding(), sealed.ciphertext)
+
+    def _open_with(self, recipient_key_id: str, binding: bytes, ciphertext: str) -> str | None:
         for pair in (self._keys.current(), self._keys.previous()):
-            if pair is None or pair.key_id != sealed.recipient_key_id:
+            if pair is None or pair.key_id != recipient_key_id:
                 continue
             try:
                 return open_sealed(
-                    private_key=pair.private_key,
-                    binding=sealed.binding(),
-                    ciphertext=sealed.ciphertext,
+                    private_key=pair.private_key, binding=binding, ciphertext=ciphertext
                 )
             except SealedCredentialError:
                 return None

{agentic_runner-3.5.0 → agentic_runner-3.7.0}/src/agentic_runner/service.py

@@ -98,11 +98,19 @@ from agentic_runner.sealed_box import (
 )
 from agentic_runner.tiny_http import HttpRequest, read_request, write_json
 from agentic_runner.triage_activities import RunnerTriageActivities
+from agentic_runner.usage_windows import (
+    ClaudeUsageScreenProbe,
+    CodexRateLimitsProbe,
+    UsageWindowProbe,
+    UsageWindows,
+)
 from agentic_runner.user_sources import ProxyTriage, UserSourcePoller
 from agentic_runner.workers.acp_runtime import ACP_BRIDGES, AcpRuntime
 from agentic_runner.workers.agent_runtime import AgentRuntime
 from agentic_runner.workers.claude_runtime import ClaudeRuntime
+from agentic_runner.workers.claude_sign_in import ClaudeSignIns
 from agentic_runner.workers.codex_runtime import CodexRuntime
+from agentic_runner.workers.contract_device_login import ContractDeviceLogin
 from agentic_runner.workers.contract_isolation import UID_MAP_FILENAME, ContractIsolation
 from agentic_runner.workers.fastapi_client import DirectiveTokenSource, RunnerFastApiClient
 from agentic_runner.workers.settings import WorkerSettings, get_worker_settings
@@ -124,7 +132,11 @@ from agentic_runner_contracts.runner_registration import (
     ResourcePressure,
 )
 from agentic_runner_contracts.runtime_context import WorkerRuntimeContextResolver
-from agentic_runner_contracts.sealed_credential import key_fingerprint
+from agentic_runner_contracts.sealed_credential import (
+    SignInCodeOutcome,
+    SignInCodeRelay,
+    key_fingerprint,
+)
 
 __all__ = [
     "AGENT_TOKEN_ENV",
@@ -575,8 +587,15 @@ class ControlPlaneStream:
     runtimes: Mapping[str, AgentRuntime] = field(default_factory=dict)
     contracts: ContractIsolation | None = None
     self_tests: HarnessSelfTests | None = None
+    # Local-agents 10: each subscription's usage windows; None off a user-hosted Runner.
+    usage_windows: UsageWindows | None = None
     # Local-agents 04b: which delivered references fill the LLM proxy's slot, and where.
     llm_slots: Mapping[str, LlmProvider] = field(default_factory=lambda: dict(LLM_SLOT_REFERENCES))
+    # Local-agents 05: the Claude Code sign-ins a relayed code is typed into.
+    sign_ins: ClaudeSignIns | None = None
+    # Reported once, on the beat after the relay: a lost beat loses the outcome, and the
+    # console's own wait on the sign-in is what tells the person.
+    _sign_in_outcomes: list[SignInCodeRelay] = field(default_factory=list)
     _delivered: set[tuple[str, str]] = field(default_factory=set)
     _offered_to_proxy: dict[tuple[str, str], str] = field(default_factory=dict)
     _last_seen: tuple[float, datetime] | None = None
@@ -642,6 +661,11 @@ class ControlPlaneStream:
                 if self.self_tests is not None
                 else None
             ),
+            usage_windows=(
+                self.usage_windows.windows(contract_id, cli_kind)
+                if self.usage_windows is not None and not delivered
+                else None
+            ),
         )
 
     async def directive_token(self, directive_id: str) -> str:
@@ -679,11 +703,14 @@ class ControlPlaneStream:
             clock_skew_seconds=self._clock_skew(now),
             source_status=self.sources.statuses() if self.sources is not None else [],
             tool_servers=self.tool_servers.latest() if self.tool_servers is not None else [],
+            sign_in_codes=self._sign_in_outcomes,
         )
+        self._sign_in_outcomes = []
         ack = await self.client.heartbeat(self.state, envelope)
         if self.sources is not None:
             self.sources.assign(ack.user_sources)
         await self._deliver_transcripts(ack)
+        await self._relay_sign_in_codes(ack)
         if self.lifecycle is not None:
             self.lifecycle.acknowledge(lifecycle)
         if self.heartbeat_stamp is not None:
@@ -730,6 +757,28 @@ class ControlPlaneStream:
                     "transcript %s could not be delivered: %s", request.request_id, error
                 )
 
+    async def _relay_sign_in_codes(self, ack: HeartbeatAck) -> None:
+        """Type each relayed code into the sign-in it names (local-agents 05).
+
+        The code is opened, written to that sign-in's PTY and dropped here; nothing logs
+        it and only its outcome travels back.
+        """
+
+        for sealed in ack.sign_in_codes:
+            code = self.sealed.open_sign_in_code(sealed)
+            if code is None:
+                outcome = SignInCodeOutcome.UNOPENABLE
+            elif self.sign_ins is None:
+                outcome = SignInCodeOutcome.UNKNOWN
+            else:
+                outcome = await self.sign_ins.relay(
+                    str(sealed.contract_id), sealed.sign_in_id, code
+                )
+            del code
+            self._sign_in_outcomes.append(
+                SignInCodeRelay(sign_in_id=sealed.sign_in_id, outcome=outcome)
+            )
+
     def _sync_delivered(self) -> None:
         """The resolver holds exactly what the last ack let this installation open."""
 
@@ -980,6 +1029,9 @@ async def _serve_registered(
         served=runtimes,
         monotonic=time.monotonic,
     )
+    usage_windows = build_usage_windows(
+        host_party=state.host_party, runtimes=runtimes, isolation=isolation, in_flight=in_flight
+    )
     stream = ControlPlaneStream(
         client=RunnerRegistrationClient(base_url=control_plane, client=http_client),
         state=state,
@@ -1007,6 +1059,7 @@ async def _serve_registered(
         runtimes=runtimes,
         contracts=isolation,
         self_tests=self_tests,
+        usage_windows=usage_windows,
     )
     stream.sources = UserSourcePoller(
         stream=SignedIntakeStream(stream.client, state),
@@ -1019,6 +1072,8 @@ async def _serve_registered(
     )
     messages = MessageStore(state_dir / MESSAGES_DIR)
     stream.messages = messages
+    sign_ins = ClaudeSignIns(build_contract_isolation(settings, can_separate_uids=can_change_uid))
+    stream.sign_ins = sign_ins
     tool_servers = ToolServerHealthLog()
     stream.tool_servers = tool_servers
     link = HeartbeatLink(stream, ceilings=proxy.ceilings)
@@ -1065,6 +1120,8 @@ async def _serve_registered(
                 token_source=stream,
                 messages=messages,
                 tool_servers=tool_servers,
+                sign_ins=sign_ins,
+                usage_windows=usage_windows,
                 # The wake signal rides the connection this process polls with: one
                 # namespace, the Organisation's own (PRD issue 52, map ticket 15 §2).
                 signaller=TemporalWorkflowSignaller(client),
@@ -1082,16 +1139,24 @@ async def _serve_registered(
         self_test = asyncio.create_task(
             _self_test_forever(self_tests, isolation, SELF_TEST_SWEEP_SECONDS)
         )
+        sweeps = [beat, poll, self_test]
+        if usage_windows is not None:
+            sweeps.append(
+                asyncio.create_task(
+                    _usage_windows_forever(usage_windows, isolation, proxy, SELF_TEST_SWEEP_SECONDS)
+                )
+            )
         readiness.ready = True
         await run_runner_lifecycle_hook(hooks, HookName.RUNNER_STARTUP)
         try:
             await run_worker_until_terminated(worker, stop=stop)
         finally:
             readiness.ready = False
-            for task in (beat, poll, self_test):
+            for task in sweeps:
                 task.cancel()
                 with contextlib.suppress(asyncio.CancelledError):
                     await task
+            await sign_ins.close()
             await run_runner_lifecycle_hook(hooks, HookName.RUNNER_SHUTDOWN)
             await _report_stop(link, lifecycle)
     return 1 if revoked.is_set() else 0
@@ -1187,6 +1252,56 @@ async def _self_test_forever(
         await asyncio.sleep(interval)
 
 
+def build_usage_windows(
+    *,
+    host_party: str,
+    runtimes: Mapping[str, AgentRuntime],
+    isolation: ContractIsolation,
+    in_flight: DirectivesInFlight,
+) -> UsageWindows | None:
+    """A probe per served harness, or None off a user-hosted Runner (local-agents 10).
+
+    Subscriptions follow the person (local-agents 04): only a user-hosted Runner runs one,
+    so only there is a usage window anyone's to read.
+    """
+
+    if host_party != "user":
+        return None
+    probes: dict[str, UsageWindowProbe] = {
+        "codex_cli": CodexRateLimitsProbe(),
+        "claude_code": ClaudeUsageScreenProbe(),
+    }
+    return UsageWindows(
+        probes={kind: probe for kind, probe in probes.items() if kind in runtimes},
+        sandbox_for=lambda contract_id, cli_kind: isolation.existing_sandbox(
+            contract_id, runtime_kind=cli_kind
+        ),
+        in_flight=in_flight,
+        monotonic=time.monotonic,
+    )
+
+
+async def _usage_windows_forever(
+    usage_windows: UsageWindows, isolation: ContractIsolation, proxy: LlmProxy, interval: float
+) -> None:
+    """Each signed-in harness root's usage windows, whenever its probe falls due
+    (local-agents 10). A root with a delivered key runs on the proxy, not a subscription."""
+
+    while True:
+        delivered = {
+            (str(slot.contract_id), slot.runtime_kind)
+            for slot in proxy.slots.statuses()
+            if slot.present
+        }
+        try:
+            await usage_windows.run_due(
+                [root for root in isolation.harness_roots() if root not in delivered]
+            )
+        except Exception as error:  # noqa: BLE001 - a lost sweep is retried on the next one
+            _logger.warning("usage window sweep failed: %s", error)
+        await asyncio.sleep(interval)
+
+
 def _activities(
     fastapi: RunnerFastApiClient,
     *,
@@ -1204,6 +1319,8 @@ def _activities(
     messages: MessageStore | None = None,
     signaller: TemporalWorkflowSignaller | None = None,
     tool_servers: ToolServerHealthLog | None = None,
+    sign_ins: ClaudeSignIns | None = None,
+    usage_windows: UsageWindows | None = None,
 ) -> list[Callable[..., Any]]:
     github_client = GitHubAppClient(
         app_id=os.getenv("GITHUB_APP_ID"),
@@ -1251,11 +1368,14 @@ def _activities(
         tool_server_health=tool_servers,
         attempt_records=attempt_records,
         directives_in_flight=directives_in_flight,
+        usage_windows=usage_windows,
     )
     return [
         *ralph.activity_callables(),
         *ContractDeviceLoginActivities(
-            contract_isolation=isolation, host_party=state.host_party or None
+            contract_isolation=isolation,
+            device_login=ContractDeviceLogin(isolation, claude=sign_ins),
+            host_party=state.host_party or None,
         ).activity_callables(),
         *RunnerTriageActivities(
             proxy=proxy,