fix: automations workflow_spec API + runtime shell (v0.43.0)

Author: kmjones1979

README.md

@@ -303,20 +303,25 @@ client.auth.social_login(provider="google", id_token="...")
 ### Automations
 
 ```python
-# Create a cron-based automation
+# Create a cron-based automation (workflow_spec required)
 client.automations.create(
-    agent_id,
     name="rotate-api-key",
-    schedule="0 0 * * 0",  # weekly
-    action_type="secret_rotate",
-    action_config={"path": "api-keys/stripe", "length": 64},
+    agent_id=agent_id,
+    trigger_type="cron",
+    cron_expr="0 0 * * 0",  # weekly
+    timezone="UTC",
+    workflow_spec={
+        "steps": [
+            {"type": "log", "action": "run_agent_task", "message": "Rotate weekly API keys"}
+        ]
+    },
 )
 
-# List automations
-autos = client.automations.list(agent_id)
+# List automations in the org
+autos = client.automations.list()
 
 # Manually trigger
-client.automations.trigger(agent_id, automation_id)
+client.automations.trigger(automation_id)
 ```
 
 ### Agent Memory
@@ -342,19 +347,23 @@ client.memory.clear(agent_id)
 runtime = client.runtimes.create(
     agent_id=agent_id,
     name="my-agent-runtime",
-    image="ghcr.io/my-org/agent:latest",
-    env={"MODEL": "gpt-4"},
-    memory_mb=512,
+    template="python",
+    preset="small",
+    env_public={"MODEL": "gpt-4"},
+    shell_access_enabled=True,
 )
 
 # List runtimes
-runtimes = client.runtimes.list(agent_id=agent_id)
+runtimes = client.runtimes.list()
 
-# Get logs
+# Lifecycle
+client.runtimes.start(runtime_id)
 logs = client.runtimes.logs(runtime_id, limit=100)
+client.runtimes.stop(runtime_id)
 
-# Restart
-client.runtimes.restart(runtime_id)
+# Interactive shell (human-only, step-up password / passkey / reauth token)
+session = client.runtimes.create_shell_session(runtime_id, password="...")
+# Connect a WebSocket client to session.data["ws_url"] with the session_token
 ```
 
 ### Discovery

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oneclaw"
-version = "0.42.0"
+version = "0.43.0"
 description = "Official Python SDK for the 1Claw secrets management platform"
 readme = "README.md"
 license = "MIT"

src/oneclaw/resources/automations.py

@@ -10,83 +10,96 @@
 
 
 class AutomationsResource:
-    """Cron-based scheduled tasks for agents."""
+    """Scheduled, event-driven, and webhook-triggered agent workflows."""
 
     def __init__(self, http: HttpClient) -> None:
         self._http = http
 
     def create(
         self,
-        agent_id: str,
         *,
         name: str,
-        schedule: str,
-        action_type: str,
-        action_config: dict[str, Any],
-        description: str | None = None,
-        enabled: bool = True,
+        agent_id: str,
+        trigger_type: str,
+        workflow_spec: dict[str, Any] | list[Any],
+        cron_expr: str | None = None,
+        timezone: str = "UTC",
+        event_filter: dict[str, Any] | None = None,
     ) -> OneclawResponse[Any]:
-        """Create a new automation for an agent."""
+        """Create a new automation.
+
+        ``workflow_spec`` is required: either a step array or ``{"steps": [...]}``.
+        For cron triggers, pass ``cron_expr``. ``trigger_type="schedule"`` is
+        accepted by the API and normalized to ``cron``.
+        """
         body: dict[str, Any] = {
             "name": name,
-            "schedule": schedule,
-            "action_type": action_type,
-            "action_config": action_config,
-            "enabled": enabled,
+            "agent_id": agent_id,
+            "trigger_type": trigger_type,
+            "timezone": timezone,
+            "workflow_spec": workflow_spec,
         }
-        if description is not None:
-            body["description"] = description
-        return self._http.request("POST", f"/v1/agents/{agent_id}/automations", body=body)
+        if cron_expr is not None:
+            body["cron_expr"] = cron_expr
+        if event_filter is not None:
+            body["event_filter"] = event_filter
+        return self._http.request("POST", "/v1/automations", body=body)
 
-    def list(self, agent_id: str) -> OneclawResponse[Any]:
-        """List automations for an agent."""
-        return self._http.request("GET", f"/v1/agents/{agent_id}/automations")
+    def list(self) -> OneclawResponse[Any]:
+        """List automations for the current organization."""
+        return self._http.request("GET", "/v1/automations")
 
-    def get(self, agent_id: str, automation_id: str) -> OneclawResponse[Any]:
+    def get(self, automation_id: str) -> OneclawResponse[Any]:
         """Get a specific automation."""
-        return self._http.request("GET", f"/v1/agents/{agent_id}/automations/{automation_id}")
+        return self._http.request("GET", f"/v1/automations/{automation_id}")
 
     def update(
         self,
-        agent_id: str,
         automation_id: str,
         *,
         name: str | None = None,
-        schedule: str | None = None,
-        action_config: dict[str, Any] | None = None,
-        enabled: bool | None = None,
+        cron_expr: str | None = None,
+        timezone: str | None = None,
+        event_filter: dict[str, Any] | None = None,
+        workflow_spec: dict[str, Any] | list[Any] | None = None,
+        is_active: bool | None = None,
     ) -> OneclawResponse[Any]:
         """Update an existing automation."""
         body: dict[str, Any] = {}
         if name is not None:
             body["name"] = name
-        if schedule is not None:
-            body["schedule"] = schedule
-        if action_config is not None:
-            body["action_config"] = action_config
-        if enabled is not None:
-            body["enabled"] = enabled
-        return self._http.request(
-            "PATCH", f"/v1/agents/{agent_id}/automations/{automation_id}", body=body
-        )
+        if cron_expr is not None:
+            body["cron_expr"] = cron_expr
+        if timezone is not None:
+            body["timezone"] = timezone
+        if event_filter is not None:
+            body["event_filter"] = event_filter
+        if workflow_spec is not None:
+            body["workflow_spec"] = workflow_spec
+        if is_active is not None:
+            body["is_active"] = is_active
+        return self._http.request("PATCH", f"/v1/automations/{automation_id}", body=body)
 
-    def delete(self, agent_id: str, automation_id: str) -> OneclawResponse[Any]:
+    def delete(self, automation_id: str) -> OneclawResponse[Any]:
         """Delete an automation."""
-        return self._http.request(
-            "DELETE", f"/v1/agents/{agent_id}/automations/{automation_id}"
-        )
+        return self._http.request("DELETE", f"/v1/automations/{automation_id}")
 
     def list_runs(
-        self, agent_id: str, automation_id: str, *, limit: int | None = None
+        self, automation_id: str, *, limit: int | None = None
     ) -> OneclawResponse[Any]:
         """List recent runs for an automation."""
         query: dict[str, Any] | None = {"limit": limit} if limit else None
         return self._http.request(
-            "GET", f"/v1/agents/{agent_id}/automations/{automation_id}/runs", query=query
+            "GET", f"/v1/automations/{automation_id}/runs", query=query
         )
 
-    def trigger(self, agent_id: str, automation_id: str) -> OneclawResponse[Any]:
+    def trigger(
+        self, automation_id: str, *, input: dict[str, Any] | None = None
+    ) -> OneclawResponse[Any]:
         """Manually trigger an automation run."""
+        body: dict[str, Any] = {}
+        if input is not None:
+            body["input"] = input
         return self._http.request(
-            "POST", f"/v1/agents/{agent_id}/automations/{automation_id}/trigger"
+            "POST", f"/v1/automations/{automation_id}/trigger", body=body
         )

src/oneclaw/resources/runtimes.py

@@ -20,35 +20,53 @@ def create(
         *,
         agent_id: str,
         name: str,
-        image: str,
-        env: dict[str, str] | None = None,
-        cpu: str | None = None,
-        memory_mb: int | None = None,
-        replicas: int | None = None,
-        health_check_path: str | None = None,
+        template: str | None = None,
+        preset: str | None = None,
+        image: str | None = None,
+        env_public: dict[str, str] | None = None,
+        idle_timeout_secs: int | None = None,
+        expose_http: bool | None = None,
+        http_port: int | None = None,
+        slug: str | None = None,
+        inbound_auth: str | None = None,
+        shell_access_enabled: bool | None = None,
+        shell_auth_policy: str | None = None,
+        shell_max_session_minutes: int | None = None,
     ) -> OneclawResponse[Any]:
         """Create a new runtime deployment."""
         body: dict[str, Any] = {
             "agent_id": agent_id,
             "name": name,
-            "image": image,
         }
-        if env is not None:
-            body["env"] = env
-        if cpu is not None:
-            body["cpu"] = cpu
-        if memory_mb is not None:
-            body["memory_mb"] = memory_mb
-        if replicas is not None:
-            body["replicas"] = replicas
-        if health_check_path is not None:
-            body["health_check_path"] = health_check_path
+        if template is not None:
+            body["template"] = template
+        if preset is not None:
+            body["preset"] = preset
+        if image is not None:
+            body["image"] = image
+        if env_public is not None:
+            body["env_public"] = env_public
+        if idle_timeout_secs is not None:
+            body["idle_timeout_secs"] = idle_timeout_secs
+        if expose_http is not None:
+            body["expose_http"] = expose_http
+        if http_port is not None:
+            body["http_port"] = http_port
+        if slug is not None:
+            body["slug"] = slug
+        if inbound_auth is not None:
+            body["inbound_auth"] = inbound_auth
+        if shell_access_enabled is not None:
+            body["shell_access_enabled"] = shell_access_enabled
+        if shell_auth_policy is not None:
+            body["shell_auth_policy"] = shell_auth_policy
+        if shell_max_session_minutes is not None:
+            body["shell_max_session_minutes"] = shell_max_session_minutes
         return self._http.request("POST", "/v1/runtimes", body=body)
 
-    def list(self, *, agent_id: str | None = None) -> OneclawResponse[Any]:
-        """List runtimes, optionally filtered by agent."""
-        query: dict[str, Any] | None = {"agent_id": agent_id} if agent_id else None
-        return self._http.request("GET", "/v1/runtimes", query=query)
+    def list(self) -> OneclawResponse[Any]:
+        """List runtimes for the current organization."""
+        return self._http.request("GET", "/v1/runtimes")
 
     def get(self, runtime_id: str) -> OneclawResponse[Any]:
         """Get a runtime by ID."""
@@ -58,27 +76,56 @@ def update(
         self,
         runtime_id: str,
         *,
+        name: str | None = None,
         image: str | None = None,
-        env: dict[str, str] | None = None,
-        replicas: int | None = None,
-        status: str | None = None,
+        env_public: dict[str, str] | None = None,
+        idle_timeout_secs: int | None = None,
+        expose_http: bool | None = None,
+        http_port: int | None = None,
+        slug: str | None = None,
+        inbound_auth: str | None = None,
+        shell_access_enabled: bool | None = None,
+        shell_auth_policy: str | None = None,
+        shell_max_session_minutes: int | None = None,
     ) -> OneclawResponse[Any]:
         """Update a runtime deployment."""
         body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
         if image is not None:
             body["image"] = image
-        if env is not None:
-            body["env"] = env
-        if replicas is not None:
-            body["replicas"] = replicas
-        if status is not None:
-            body["status"] = status
+        if env_public is not None:
+            body["env_public"] = env_public
+        if idle_timeout_secs is not None:
+            body["idle_timeout_secs"] = idle_timeout_secs
+        if expose_http is not None:
+            body["expose_http"] = expose_http
+        if http_port is not None:
+            body["http_port"] = http_port
+        if slug is not None:
+            body["slug"] = slug
+        if inbound_auth is not None:
+            body["inbound_auth"] = inbound_auth
+        if shell_access_enabled is not None:
+            body["shell_access_enabled"] = shell_access_enabled
+        if shell_auth_policy is not None:
+            body["shell_auth_policy"] = shell_auth_policy
+        if shell_max_session_minutes is not None:
+            body["shell_max_session_minutes"] = shell_max_session_minutes
         return self._http.request("PATCH", f"/v1/runtimes/{runtime_id}", body=body)
 
     def delete(self, runtime_id: str) -> OneclawResponse[Any]:
         """Delete a runtime deployment."""
         return self._http.request("DELETE", f"/v1/runtimes/{runtime_id}")
 
+    def start(self, runtime_id: str) -> OneclawResponse[Any]:
+        """Start a stopped runtime."""
+        return self._http.request("POST", f"/v1/runtimes/{runtime_id}/start")
+
+    def stop(self, runtime_id: str) -> OneclawResponse[Any]:
+        """Stop a running runtime."""
+        return self._http.request("POST", f"/v1/runtimes/{runtime_id}/stop")
+
     def logs(
         self, runtime_id: str, *, since: str | None = None, limit: int | None = None
     ) -> OneclawResponse[Any]:
@@ -90,6 +137,25 @@ def logs(
             query["limit"] = limit
         return self._http.request("GET", f"/v1/runtimes/{runtime_id}/logs", query=query or None)
 
-    def restart(self, runtime_id: str) -> OneclawResponse[Any]:
-        """Restart a runtime."""
-        return self._http.request("POST", f"/v1/runtimes/{runtime_id}/restart")
+    def create_shell_session(
+        self,
+        runtime_id: str,
+        *,
+        password: str | None = None,
+        totp_code: str | None = None,
+        passkey_credential: dict[str, Any] | None = None,
+        reauth_token: str | None = None,
+    ) -> OneclawResponse[Any]:
+        """Create an interactive shell WebSocket session (human-only, step-up auth)."""
+        body: dict[str, Any] = {}
+        if password is not None:
+            body["password"] = password
+        if totp_code is not None:
+            body["totp_code"] = totp_code
+        if passkey_credential is not None:
+            body["passkey_credential"] = passkey_credential
+        if reauth_token is not None:
+            body["reauth_token"] = reauth_token
+        return self._http.request(
+            "POST", f"/v1/runtimes/{runtime_id}/shell/session", body=body
+        )