@openhands/extensions 0.7.2 → 0.9.0

package/skills/jira-issue-to-pr/scripts/main.py

@@ -0,0 +1,341 @@
+"""
+Jira issue-to-PR poller — reads all configuration from config.json in the same directory.
+
+config.json fields:
+  jira_base_url          e.g. "https://yourcompany.atlassian.net"
+  jira_email             Atlassian account email used for Basic auth
+  jira_token_secret      Name of the OpenHands secret holding the Jira API token
+  jira_label             Label to watch for (default: "create-pr")
+  max_new_per_run        Max conversations dispatched per run (default: 5)
+
+The target GitHub repository is NOT configured here. Each Jira ticket body must include
+the repo in "owner/repo" format; the spawned agent extracts it from the ticket text.
+"""
+import base64, json, os, re, sys, tempfile, urllib.error, urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+
+# ── Load config ───────────────────────────────────────────────────────────────
+_HERE = Path(__file__).parent
+with open(_HERE / "config.json") as _f:
+    _cfg = json.load(_f)
+
+JIRA_BASE_URL      = _cfg["jira_base_url"].rstrip("/")
+JIRA_EMAIL         = _cfg["jira_email"]
+JIRA_TOKEN_SECRET  = _cfg.get("jira_token_secret", "JIRA_CLOUD_KEY")
+JIRA_LABEL         = _cfg.get("jira_label", "create-pr")
+MAX_NEW_PER_RUN    = int(_cfg.get("max_new_per_run", 5))
+
+# ── KV store helpers ──────────────────────────────────────────────────────────
+_KV_TOKEN  = os.environ.get("AUTOMATION_KV_TOKEN", "")
+_KV_BASE   = os.environ.get("AUTOMATION_API_URL", "").rstrip("/")
+_STATE_KEY = "state"
+
+
+def kv_available():
+    return bool(_KV_TOKEN and _KV_BASE)
+
+
+def kv_get(key):
+    req = urllib.request.Request(
+        f"{_KV_BASE}/v1/kv/{key}",
+        headers={"Authorization": f"Bearer {_KV_TOKEN}"},
+    )
+    try:
+        with urllib.request.urlopen(req) as r:
+            return json.loads(r.read())["value"]
+    except urllib.error.HTTPError as exc:
+        if exc.code == 404:
+            return None
+        raise
+
+
+def kv_set(key, value):
+    req = urllib.request.Request(
+        f"{_KV_BASE}/v1/kv/{key}",
+        data=json.dumps(value).encode(),
+        headers={
+            "Authorization": f"Bearer {_KV_TOKEN}",
+            "Content-Type": "application/json",
+        },
+        method="PUT",
+    )
+    with urllib.request.urlopen(req) as r:
+        r.read()
+
+
+def _state_file_path():
+    workspace_base = os.environ.get("WORKSPACE_BASE", "")
+    root = (Path(workspace_base).resolve().parent.parent if workspace_base
+            else Path.home() / ".openhands" / "workspaces")
+    state_dir = root / "automation-state"
+    state_dir.mkdir(parents=True, exist_ok=True)
+    payload       = json.loads(os.environ.get("AUTOMATION_EVENT_PAYLOAD", "{}"))
+    automation_id = payload.get("automation_id", "default")
+    return state_dir / f"jira_poller_{automation_id}.json"
+
+
+def load_state():
+    if kv_available():
+        data = kv_get(_STATE_KEY)
+        if data is not None:
+            print("State loaded from KV store")
+            return data
+        return {"processed_keys": []}
+    path = _state_file_path()
+    if path.exists():
+        try:
+            return json.loads(path.read_text())
+        except Exception as exc:
+            print(f"Warning: state file unreadable ({exc}); starting fresh")
+    return {"processed_keys": []}
+
+
+def save_state(state):
+    if kv_available():
+        kv_set(_STATE_KEY, state)
+        print("State saved to KV store")
+        return
+    path = _state_file_path()
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(state, indent=2))
+    tmp.replace(path)
+    print(f"State saved to {path}")
+
+
+# ── Required stdlib helpers ───────────────────────────────────────────────────
+def get_secret(name):
+    url = os.environ.get("AGENT_SERVER_URL", "").rstrip("/")
+    key = os.environ.get("SESSION_API_KEY") or os.environ.get("OH_SESSION_API_KEYS_0", "")
+    with urllib.request.urlopen(urllib.request.Request(
+        f"{url}/api/settings/secrets/{name}", headers={"X-Session-API-Key": key}
+    )) as r:
+        return r.read().decode().strip()
+
+
+def fire_callback(status="COMPLETED", error=None):
+    url = os.environ.get("AUTOMATION_CALLBACK_URL", "")
+    if not url:
+        return
+    body = {"status": status, "run_id": os.environ.get("AUTOMATION_RUN_ID", "")}
+    if error:
+        body["error"] = error
+    try:
+        urllib.request.urlopen(urllib.request.Request(
+            url, data=json.dumps(body).encode(),
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {os.environ.get('AUTOMATION_CALLBACK_API_KEY', '')}",
+            }
+        ))
+    except Exception as e:
+        print(f"Callback error (non-fatal): {e}")
+
+
+# ── Jira helpers ──────────────────────────────────────────────────────────────
+def extract_adf_text(adf):
+    """Recursively extract plain text from Atlassian Document Format."""
+    if not isinstance(adf, dict):
+        return adf or ""
+    parts = []
+    for node in adf.get("content", []):
+        if node.get("type") == "text":
+            parts.append(node.get("text", ""))
+        elif "content" in node:
+            parts.append(extract_adf_text(node))
+    return " ".join(p for p in parts if p).strip()
+
+
+def fetch_labeled_issues(auth_header):
+    """Return open Jira issues with JIRA_LABEL using the current v3 search endpoint."""
+    url  = f"{JIRA_BASE_URL}/rest/api/3/search/jql"
+    body = json.dumps({
+        "jql":        f'labels = "{JIRA_LABEL}" AND statusCategory != Done',
+        "fields":     ["key", "summary", "description", "status", "updated"],
+        "maxResults": 50,
+    }).encode()
+    req = urllib.request.Request(
+        url, data=body,
+        headers={
+            "Authorization": auth_header,
+            "Content-Type":  "application/json",
+            "Accept":        "application/json",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req) as r:
+            return json.loads(r.read()).get("issues", [])
+    except urllib.error.HTTPError as exc:
+        body_text = exc.read().decode(errors="replace")
+        raise RuntimeError(f"Jira search failed {exc.code}: {body_text[:500]}") from exc
+
+
+def post_jira_comment(issue_key, auth_header, text):
+    """Post a plain-text comment on a Jira issue using ADF."""
+    url  = f"{JIRA_BASE_URL}/rest/api/3/issue/{issue_key}/comment"
+    body = json.dumps({
+        "body": {
+            "type":    "doc",
+            "version": 1,
+            "content": [{
+                "type":    "paragraph",
+                "content": [{"type": "text", "text": text}],
+            }],
+        }
+    }).encode()
+    req = urllib.request.Request(
+        url, data=body,
+        headers={
+            "Authorization": auth_header,
+            "Content-Type":  "application/json",
+            "Accept":        "application/json",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req) as r:
+            r.read()
+    except urllib.error.HTTPError as exc:
+        body_text = exc.read().decode(errors="replace")
+        print(f"Warning: failed to post Jira comment on {issue_key} ({exc.code}): {body_text[:200]}")
+
+
+# ── Timestamp helpers ─────────────────────────────────────────────────────────
+def _parse_ts(ts):
+    """Parse an ISO-8601 timestamp, normalising +HHMM → +HH:MM for Python < 3.11."""
+    normalized = re.sub(r'([+-])(\d{2})(\d{2})$', r'\1\2:\3', ts)
+    return datetime.fromisoformat(normalized)
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+try:
+    jira_token  = get_secret(JIRA_TOKEN_SECRET)
+    auth_header = "Basic " + base64.b64encode(
+        f"{JIRA_EMAIL}:{jira_token}".encode()
+    ).decode()
+
+    state          = load_state()
+    processed_keys = set(state.get("processed_keys", []))
+
+    # On the very first run there is no baseline timestamp.  Record one now so
+    # that all pre-existing issues (created before this moment) are silently
+    # skipped — preventing a thundering-herd of conversations on first deploy.
+    if "first_run_at" not in state:
+        state["first_run_at"] = datetime.now(timezone.utc).isoformat()
+        save_state(state)
+        print(f"First run — baseline recorded at {state['first_run_at']}; "
+              "issues created before this timestamp will be skipped.")
+
+    first_run_at = _parse_ts(state["first_run_at"])
+
+    print(f"Polling {JIRA_BASE_URL} for issues labeled '{JIRA_LABEL}'…")
+    issues = fetch_labeled_issues(auth_header)
+    print(f"Total matching issues : {len(issues)}")
+
+    new_issues = [
+        i for i in issues
+        if i["key"] not in processed_keys
+        and _parse_ts(i["fields"]["updated"]) >= first_run_at
+    ]
+    print(f"New (unprocessed, after baseline) : {len(new_issues)}")
+
+    if len(new_issues) > MAX_NEW_PER_RUN:
+        print(f"Capping at {MAX_NEW_PER_RUN} per run "
+              f"({len(new_issues)} available); remainder picked up on next run.")
+        new_issues = new_issues[:MAX_NEW_PER_RUN]
+
+    if not new_issues:
+        save_state(state)
+        fire_callback("COMPLETED")
+        sys.exit(0)
+
+    # Start one agent conversation per new issue via the agent server HTTP API.
+    agent_url   = os.environ.get("AGENT_SERVER_URL", "").rstrip("/")
+    session_key = os.environ.get("SESSION_API_KEY") or os.environ.get("OH_SESSION_API_KEYS_0", "")
+
+    # Fetch settings with encrypted secrets so llm.api_key is a Fernet token
+    # (starts with gAAAAA) rather than the masked "**********" placeholder.
+    # The conversation payload must include secrets_encrypted: True so the
+    # agent-server decrypts it server-side; we never handle the plaintext key.
+    with urllib.request.urlopen(urllib.request.Request(
+        f"{agent_url}/api/settings",
+        headers={"X-Session-API-Key": session_key, "X-Expose-Secrets": "encrypted"},
+    )) as r:
+        settings = json.loads(r.read())
+
+    agent_settings = settings.get("agent_settings", {})
+    agent_settings.pop("schema_version", None)
+    # Drop mcp_config to avoid MCP connection failures at conversation creation time.
+    agent_settings.pop("mcp_config", None)
+    ctx = agent_settings.setdefault("agent_context", {})
+    ctx.update({"load_public_skills": True, "load_user_skills": True, "load_project_skills": True})
+    max_iterations = (settings.get("conversation_settings") or {}).get("max_iterations") or 1000
+
+    for issue in new_issues:
+        key         = issue["key"]
+        summary     = issue["fields"]["summary"]
+        description = extract_adf_text(issue["fields"].get("description"))
+        branch      = f"jira/{key.lower()}"
+
+        prompt = f"""Create a GitHub Pull Request for the following Jira issue.
+
+Jira Issue : {key}
+Summary    : {summary}
+Description: {description or "No description provided."}
+
+Steps:
+1. Find the target GitHub repository in the Description above. Look for a reference in
+   "owner/repo" format (e.g. "acme-org/backend") or a full GitHub URL
+   (e.g. "https://github.com/acme-org/backend"). Use that repository.
+   If no repository is mentioned, create a file `jira/{key}/notes.md` with the issue
+   details and print a message explaining that no GitHub repo was found in the ticket.
+2. Clone the repository (e.g. https://github.com/<owner>/<repo>).
+3. Create branch `{branch}` from the default branch.
+4. Implement the changes described in the issue.
+   If the description is vague or missing, create `jira/{key}/notes.md`
+   with the issue key, summary, and description as a placeholder.
+5. Commit, push the branch, and open a Pull Request:
+   - Title : [{key}] {summary}
+   - Body  : Reference the Jira issue key and describe the changes made.
+6. Print the PR URL when done.
+"""
+        workdir = tempfile.mkdtemp(prefix=f"jira-{key.lower()}-")
+        payload = {
+            "secrets_encrypted":   True,
+            "agent_settings":      agent_settings,
+            "workspace":           {"kind": "LocalWorkspace", "working_dir": workdir},
+            "confirmation_policy": {"kind": "NeverConfirm"},
+            "max_iterations":      max_iterations,
+            "stuck_detection":     True,
+            "autotitle":           True,
+            "worktree":            False,
+            "initial_message": {
+                "role":    "user",
+                "content": [{"type": "text", "text": prompt}],
+                "run":     True,
+            },
+        }
+        conv_req = urllib.request.Request(
+            f"{agent_url}/api/conversations",
+            data=json.dumps(payload).encode(),
+            headers={"Content-Type": "application/json", "X-Session-API-Key": session_key},
+        )
+        with urllib.request.urlopen(conv_req) as r:
+            conv = json.loads(r.read())
+
+        conv_id  = conv.get("id")
+        conv_url = f"{agent_url}/conversations/{conv_id}"
+        print(f"✓ Conversation started for {key}: id={conv_id}")
+
+        post_jira_comment(key, auth_header, f"I'm on it: {conv_url}")
+
+        processed_keys.add(key)
+        state["processed_keys"] = list(processed_keys)
+        save_state(state)
+
+    fire_callback("COMPLETED")
+
+except Exception as e:
+    print(f"ERROR: {e}", file=sys.stderr)
+    import traceback; traceback.print_exc()
+    fire_callback("FAILED", str(e))
+    sys.exit(1)

package/skills/jupyter/SKILL.md

@@ -33,6 +33,12 @@ jupyter nbconvert --to markdown notebook.ipynb  # Convert to Markdown
 grep -n "search_term" notebook.ipynb
 ```
 
+PowerShell equivalent:
+
+```powershell
+Select-String -Path notebook.ipynb -Pattern "search_term"
+```
+
 ## Cell Structure
 ```python
 # Code cell
@@ -47,4 +53,4 @@ for cell in nb['cells']:
     if cell['cell_type'] == 'code':
         cell['outputs'] = []
         cell['execution_count'] = None
-```
+```

package/skills/kubernetes/SKILL.md

@@ -14,6 +14,7 @@ triggers:
 KIND (Kubernetes IN Docker) is a tool for running local Kubernetes clusters using Docker containers as nodes. It's designed for testing Kubernetes applications locally.
 
 IMPORTANT: Before you proceed with installation, make sure you have docker installed locally.
+Windows PowerShell equivalents for installing KIND and kubectl are in `references/windows.md`.
 
 ### Installation
 
@@ -45,4 +46,4 @@ Create a basic KIND cluster:
 
 ```bash
 kind create cluster
-```
+```

package/skills/kubernetes/references/windows.md

@@ -0,0 +1,38 @@
+# Windows Notes for KIND and kubectl
+
+Use these PowerShell forms instead of the Linux `curl`, `chmod`, and `sudo mv` commands.
+
+## Install KIND
+
+```powershell
+$binDir = Join-Path $env:USERPROFILE "bin"
+New-Item -ItemType Directory -Force $binDir | Out-Null
+
+Invoke-WebRequest `
+  -Uri "https://kind.sigs.k8s.io/dl/v0.22.0/kind-windows-amd64" `
+  -OutFile (Join-Path $binDir "kind.exe")
+```
+
+Ensure `$binDir` is on `PATH` for the current shell:
+
+```powershell
+$env:PATH = "$binDir;$env:PATH"
+```
+
+## Install kubectl
+
+```powershell
+$version = (Invoke-RestMethod "https://dl.k8s.io/release/stable.txt").Trim()
+Invoke-WebRequest `
+  -Uri "https://dl.k8s.io/release/$version/bin/windows/amd64/kubectl.exe" `
+  -OutFile (Join-Path $binDir "kubectl.exe")
+```
+
+## Create a Cluster
+
+Docker Desktop must be running before creating a KIND cluster.
+
+```powershell
+kind create cluster
+kubectl cluster-info
+```

package/skills/linear/SKILL.md

@@ -9,6 +9,8 @@ triggers:
 
 # Linear
 
+Windows PowerShell equivalents for the repeated Linear GraphQL `curl` and environment-variable snippets are in `references/windows.md`.
+
 <IMPORTANT>
 Before performing any Linear operations, check if the required environment variable is set:
 

package/skills/linear/references/windows.md

@@ -0,0 +1,29 @@
+# Windows Notes for Linear API Commands
+
+Use these PowerShell forms when running the Linear GraphQL examples natively on Windows.
+
+## Check the API Key
+
+```powershell
+if ($env:LINEAR_API_KEY) { "LINEAR_API_KEY is set" } else { "LINEAR_API_KEY is NOT set" }
+```
+
+## Send a GraphQL Request
+
+Use `curl.exe` for curl syntax, or use `Invoke-RestMethod` with a JSON body.
+
+```powershell
+$body = @{
+  query = "query { viewer { assignedIssues(first: 50) { nodes { id identifier title } } } }"
+} | ConvertTo-Json -Depth 10
+
+Invoke-RestMethod `
+  -Uri "https://api.linear.app/graphql" `
+  -Method Post `
+  -Headers @{ "Content-Type" = "application/json"; Authorization = $env:LINEAR_API_KEY } `
+  -Body $body
+```
+
+## Translate Shell Variables
+
+Replace `$LINEAR_API_KEY` with `$env:LINEAR_API_KEY`. Replace pipes to `jq` with `ConvertFrom-Json` if using `curl.exe`.

package/skills/linear-triage/SKILL.md

@@ -80,6 +80,8 @@ curl -s -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
   }'
 ```
 
+PowerShell note: use `curl.exe` for this exact flag syntax, and replace `${OPENHANDS_HOST}` / `$OPENHANDS_AUTOMATION_API_KEY` with `$env:OPENHANDS_HOST` / `$env:OPENHANDS_AUTOMATION_API_KEY` if running it natively.
+
 ### Step 5 — Confirm
 
 Tell the user:

package/skills/notion/SKILL.md

@@ -7,6 +7,8 @@ triggers:
 
 # Notion
 
+Windows PowerShell equivalents for the repeated Notion REST `curl`, environment-variable, and JSON-body snippets are in `references/windows.md`.
+
 <IMPORTANT>
 If authenticated Notion MCP tools are available in the environment, use them first. MCP tools do not require passing `NOTION_INTEGRATION_KEY` as a tool argument; authentication is handled by the configured MCP integration.
 

package/skills/notion/references/windows.md

@@ -0,0 +1,43 @@
+# Windows Notes for Notion REST Commands
+
+Use these PowerShell forms when running the Notion direct-API examples natively on Windows.
+
+## Check the Integration Key
+
+```powershell
+if ($env:NOTION_INTEGRATION_KEY) { "NOTION_INTEGRATION_KEY is set" } else { "NOTION_INTEGRATION_KEY is NOT set" }
+```
+
+## Base Headers
+
+```powershell
+$headers = @{
+  Authorization = "Bearer $env:NOTION_INTEGRATION_KEY"
+  "Notion-Version" = "2022-06-28"
+  "Content-Type" = "application/json"
+}
+```
+
+## Search
+
+```powershell
+$body = @{
+  query = "OpenHands Wiki"
+  page_size = 10
+} | ConvertTo-Json -Depth 10
+
+Invoke-RestMethod -Uri "https://api.notion.com/v1/search" -Method Post -Headers $headers -Body $body
+```
+
+## Variable Interpolation in JSON
+
+For examples that embed IDs in JSON, build a PowerShell object and convert it rather than mixing shell quotes:
+
+```powershell
+$body = @{
+  parent = @{ type = "page_id"; page_id = $env:PARENT_PAGE_ID }
+  properties = @{
+    title = @{ title = @(@{ type = "text"; text = @{ content = "My new page" } }) }
+  }
+} | ConvertTo-Json -Depth 20
+```

package/skills/openhands-api/SKILL.md

@@ -11,6 +11,7 @@ triggers:
 ---
 
 This skill documents the **OpenHands Cloud API** (V1), commonly used **agent-server APIs**, and small, easy-to-copy clients.
+Windows PowerShell equivalents for the shell examples in this skill are in `references/windows.md`.
 
 It is intentionally focused on common OpenHands API workflows:
 

package/skills/openhands-api/references/windows.md

@@ -0,0 +1,44 @@
+# Windows Notes for OpenHands API Commands
+
+Use these PowerShell forms when running this skill's shell examples natively on Windows.
+
+## Environment Variables
+
+```powershell
+$env:OPENHANDS_CLOUD_API_KEY = "..."
+```
+
+## Curl Examples
+
+Call `curl.exe` and use PowerShell backticks for line continuation:
+
+```powershell
+curl.exe -X POST "https://app.all-hands.dev/api/v1/app-conversations" `
+  -H "Authorization: Bearer $env:OPENHANDS_CLOUD_API_KEY" `
+  -H "Content-Type: application/json" `
+  -d '{
+    "initial_message": {
+      "content": [{"type": "text", "text": "Investigate flaky tests in tests/test_api.py."}]
+    },
+    "selected_repository": "owner/repo"
+  }'
+```
+
+## Python Here-doc Debugging Examples
+
+PowerShell does not support Bash here-docs like `python3 - <<'PY'`. Save the script to a temp file and pipe the API response into it.
+
+```powershell
+$script = Join-Path $env:TEMP "openhands-events.py"
+@'
+import json, sys
+items = (json.load(sys.stdin) or {}).get("items", [])
+for i, e in enumerate(items):
+    print(f"{i:04d}  {e.get('timestamp','')}  {e.get('source','')}  {e.get('kind','')}")
+'@ | Set-Content -LiteralPath $script -Encoding utf8
+
+curl.exe -s "https://app.all-hands.dev/api/v1/conversation/$env:APP_CONVERSATION_ID/events/search?limit=100" `
+  -H "Authorization: Bearer $env:OPENHANDS_CLOUD_API_KEY" `
+  -H "Accept: application/json" |
+  python $script
+```

package/skills/openhands-automation/SKILL.md

@@ -19,6 +19,7 @@ triggers:
 # OpenHands Automations
 
 Create and manage automations that run inside an OpenHands agent server — triggered by cron schedules or webhook events (GitHub, custom services).
+Windows PowerShell equivalents for the automation API `curl` examples and shell-variable conventions are in `references/windows.md`.
 
 ## Automation Creation Process
 The agent must follow these steps when creating an automation:

package/skills/openhands-automation/references/custom-automation.md

@@ -272,6 +272,26 @@ with OpenHandsCloudWorkspace(
 # OpenHandsCloudWorkspace.__exit__ fires the completion callback here.
 ```
 
+### Selecting an LLM profile
+
+The automation service injects an `AUTOMATION_MODEL` environment variable holding the **LLM profile name** the automation should run with. This is the profile a user selects when editing the automation, or — when none is selected — a snapshot of the user's active profile taken when the automation was created. To honor it on every run, read `AUTOMATION_MODEL` and pass it to `workspace.get_llm(profile_name=...)`:
+
+```python
+# AUTOMATION_MODEL is the selected profile name (absent when none was chosen).
+model_profile = os.environ.get("AUTOMATION_MODEL") or None
+try:
+    llm = workspace.get_llm(profile_name=model_profile)
+except FileNotFoundError:
+    # The profile was renamed or deleted after the automation was created;
+    # fall back to the user's default LLM rather than failing the run.
+    if not model_profile:
+        raise
+    print(f"profile {model_profile!r} not found; falling back to default profile")
+    llm = workspace.get_llm()
+```
+
+Calling `workspace.get_llm()` with no `profile_name` always uses the user's default LLM. The built-in prompt and plugin presets already follow the pattern above; custom scripts should too so the selected profile is honored regardless of trigger type or execution backend.
+
 ### Conversation Persistence
 
 Conversations started during a run remain accessible in the OpenHands UI after the run completes — users can view the history and continue interacting. By default, `Conversation` does not delete the conversation on close:

package/skills/openhands-automation/references/windows.md

@@ -0,0 +1,57 @@
+# Windows Notes for OpenHands Automation Commands
+
+Use these PowerShell forms when running the automation API examples natively on Windows.
+
+## Set the API Host
+
+`OPENHANDS_HOST` is a shell convention in this skill. In PowerShell, set it as:
+
+```powershell
+$env:OPENHANDS_HOST = "https://app.all-hands.dev"
+```
+
+## Authentication Header
+
+```powershell
+$headers = @{
+  Authorization = "Bearer $env:OPENHANDS_API_KEY"
+  "Content-Type" = "application/json"
+}
+```
+
+## Prompt Preset Request
+
+```powershell
+$body = @{
+  name = "My Automation Name"
+  prompt = "What the automation should do"
+  trigger = @{
+    type = "cron"
+    schedule = "0 9 * * *"
+    timezone = "UTC"
+  }
+} | ConvertTo-Json -Depth 20
+
+Invoke-RestMethod `
+  -Uri "$env:OPENHANDS_HOST/api/automation/v1/preset/prompt" `
+  -Method Post `
+  -Headers $headers `
+  -Body $body
+```
+
+## Curl Examples
+
+If copying an existing `curl` snippet, call `curl.exe`, replace `${OPENHANDS_HOST}` with `$env:OPENHANDS_HOST`, and replace `${OPENHANDS_API_KEY}` with `$env:OPENHANDS_API_KEY`.
+
+```powershell
+curl.exe "$env:OPENHANDS_HOST/api/automation/v1?limit=20" `
+  -H "Authorization: Bearer $env:OPENHANDS_API_KEY"
+```
+
+## Packaging Custom Automations
+
+Modern Windows includes `tar.exe`, which can create the `.tar.gz` files expected by the upload API:
+
+```powershell
+tar.exe -czf $tarball -C $buildDir .
+```

package/skills/pdflatex/SKILL.md

@@ -13,6 +13,8 @@ PdfLatex is a tool that converts Latex sources into PDF. This is specifically ve
 apt-get install texlive-latex-base
 ```
 
+On Windows, install MiKTeX or TeX Live with the native installer or a package manager such as `winget`. The `apt-get` commands only work in Linux or WSL.
+
 * Also install the recommended and extra fonts to avoid running into errors, when trying to use pdflatex on latex files with more fonts.
 
 ```
@@ -31,4 +33,4 @@ Once installed as above, you may be able to create PDF files from latex sources
 pdflatex latex_source_name.tex
 ```
 
-Ref: http://kkpradeeban.blogspot.com/2014/04/installing-latexpdflatex-on-ubuntu.html
+Ref: http://kkpradeeban.blogspot.com/2014/04/installing-latexpdflatex-on-ubuntu.html