Permissions Broker

Setup (Do This First)

Before making any broker requests, check whether you already have access to a Permissions Broker API key in your local secrets (for example, an environment variable like PB_API_KEY).

If you do NOT have an API key available:

1. 1. Ask the user to create one in Telegram by messaging the bot:

CODEBLOCK0

1. 2. Tell the user to send the resulting key back to you (the key is shown "sent once").
2. Ask whether they want you to store/reuse it across sessions.

- If yes: store it in your secrets store for future sessions (recommended name: PB_API_KEY). - If no/unclear: treat it as session-only and ask for it again next time.

1. 4. Remember only the storage location (e.g. "Permissions Broker key is stored in PB_API_KEY"), never the secret value.

Important:

• - Never commit the key to the repo.
• Never include the key in code, logs, or error output.
• Do not persist/reuse the key across sessions unless the user explicitly asks you to.
• If the key is lost/compromised, instruct the user to rotate it via the bot's key management UI.

Provider connections:

• - The user links providers in Telegram using /connect.
• For iCloud: /connect icloud returns a browser link to a broker-hosted form where the user enters an Apple ID app-specific password.

Overview

Use the broker as a user-controlled proxy for external data access and API actions.

The mental model:

1. 1. You propose a specific upstream request (URL + method + body)
2. The user approves/denies it in Telegram
3. You poll for approval
4. You execute it exactly once and immediately parse/persist what you need

This skill is intentionally provider-agnostic. Provider support grows over time.

Agent Response Style (Important)

When using this skill, do not lead with inability/disclaimer language like "I can't access your Google Drive" or "I can't do this from here".

Instead:

• - Treat the broker as the standard mechanism for access.
• Ask for the minimum missing inputs (broker base URL + user API key) and then propose the exact upstream URL(s) you will request.
• Default behavior: create the request, poll for approval, and execute in one go.
• Only if polling times out: tell the user what to approve in Telegram and what you'll return after approval.

Avoid:

• - Long meta explanations about the repo setup.
• Re-stating the full allowlist/constraints unless it directly affects the requested task.

Preferred framing:

• - "I can do that via your Permissions Broker. I'll create a request for , you approve in Telegram, then I'll execute it and return the response."

Polling Behavior (Important)

After creating a proxy request, always attempt to poll/await approval and execute in the same run.
Only ask the user to approve in Telegram if polling times out.

Guidelines:

• - Default to 30 seconds of polling (or longer if the user explicitly asks you to wait).
• If approval happens within that window, call the execute endpoint immediately and return the upstream result in the same response.
• If approval has not happened within that window:

- Return the request_id. - Tell the user to approve/deny the request in Telegram. - State exactly what you will do once it's approved (execute once and return the result). - Continue polling on the next user message.

Core Workflow

1. 1. Collect inputs

• - User API key (never paste into logs; never store in repo)

1. 2. Decide how to access the provider

• - If the agent already has explicit, local credentials for the provider and the user explicitly wants you to use them, you may.
• Otherwise (default), use the broker.
• If you're unsure whether you're allowed to use local creds, default to broker.

1. 2. Create a proxy request

• - Call POST /v1/proxy/request with:

- upstream_url: the full external service API URL you want to call - method: GET (default) or POST/PUT/PATCH/DELETE - headers (optional): request headers to forward (never include authorization) - body (optional): request body - the broker stores request body bytes and interprets them based on headers.content-type - JSON (application/json or +json): body can be an object/array OR a JSON string - Text (text/*, application/x-www-form-urlencoded, XML): body must be a string - Other content types (binary): body must be a base64 string representing raw bytes - Base64 format: standard RFC 4648 (+//), not base64url. - Include padding (=) when in doubt. - Do not include data:...;base64, prefixes. - optional consent_hint: requester note shown to the user in Telegram. Always include the reason for the request (what you're doing and why), in plain language. - optional idempotency_key: reuse request id on retries

Notes on forwarded headers:

• - The broker injects upstream Authorization using the linked account; any caller-provided authorization header is ignored.
• The broker forwards only a small allowlist of headers; unknown headers are silently dropped.

Broker-only rendering hints (not forwarded upstream):

• - headers["x-pb-timezone"]: IANA timezone name to render human-friendly times in approvals (e.g. America/Los_Angeles).

1. 3. The user is prompted to approve in Telegram.

The approval prompt includes:

• - API key label (trusted identity)
• interpreted summary when recognized (best-effort)
• raw URL details

1. 4. Poll for status / retrieve result

• - Poll GET /v1/proxy/requests/:id until the request is APPROVED.
• Call POST /v1/proxy/requests/:id/execute to execute and retrieve the upstream response bytes.
• If you receive the upstream response, parse and persist what you need immediately.
• Do not assume you can execute the same request again.

Important:

• - Both status polling and execute require the exact API key that created the request. Using a different API key (even for the same user) returns 403.

Sample Code (Create + Await)

Use these snippets to create a broker request, poll status, then execute to retrieve upstream bytes.

JavaScript/TypeScript (Bun/Node)

CODEBLOCK1

Supported Providers (Today)

The broker enforces an allowlist and chooses which linked account (OAuth token)
to use based on the upstream hostname.

Currently supported:

• - Google

- Hosts: docs.googleapis.com, www.googleapis.com, sheets.googleapis.com - Typical uses: Drive listing/search, Docs reads, Sheets range reads

• - GitHub

- Host: api.github.com - Typical uses: PRs/issues/comments/labels and other GitHub actions

• - iCloud (CalDAV)

- Hosts: discovered on connect (starts at caldav.icloud.com) - Typical uses: Calendar events (VEVENT) and Reminders/tasks (VTODO)

• - Spotify

- Host: api.spotify.com - Typical uses: read profile, list playlists/tracks, control playback

If you need a provider that isn't supported yet:

• - Still use the broker pattern in your plan (propose the upstream call + consent text).
• Then tell the user which host(s) need to be enabled/implemented.

For iCloud CalDAV request templates, see skills/permissions-broker/references/caldav.md.

Git Operations (Smart HTTP Proxy)

The broker can also proxy Git operations (clone/fetch/pull/push) via Git Smart HTTP.

This is separate from /v1/proxy.

High-level flow:

1. 1. Create a git session (POST /v1/git/sessions).
2. The user approves/denies the session in Telegram.
3. Poll session status (GET /v1/git/sessions/:id) until approved.
4. Fetch a session-scoped remote URL (GET /v1/git/sessions/:id/remote).
5. Run git clone / git push against that remote URL.

Important behavior:

• - Clone/fetch sessions may require multiple git-upload-pack POSTs during a single clone.
• Push sessions are single-use and may become unusable after the first git-receive-pack.
• Push protections are enforced by the broker:

- tag pushes are rejected - ref deletes are rejected - default-branch pushes may be blocked unless explicitly allowed in the approval

Endpoints

Auth for all git session endpoints:

• - INLINECODE53

Create session

• - INLINECODE54
• JSON body:

- operation: "clone", "fetch", "pull", or "push" - repo: "owner/repo" (GitHub) - optional consent_hint: requester note shown to the user in Telegram. Always include the reason for the session (what you're doing and why).

• - Response: INLINECODE63

Poll status

• - GET /v1/git/sessions/:id (status JSON)

Get remote URL

• - INLINECODE65
• Response: INLINECODE66

Example: Clone

1. 1. Create session:

CODEBLOCK2

Example: Fetch

Use fetch when you already have a repo locally and just need to update refs.

1. 1. Create session:

CODEBLOCK3

1. 2. Poll until approved.

1. 3. Get remote_url, then:

CODEBLOCK4

Example: Pull

INLINECODE68 is a fetch plus a local merge/rebase. The broker only proxies the network portion.

CODEBLOCK5

1. 2. Poll until status == "APPROVED".

1. 3. Get remote_url, then:

CODEBLOCK6

Example: Push New Branch (Recommended)

1. 1. Create session:

CODEBLOCK7

1. 2. Poll until approved.

1. 3. Get remote_url, add as a remote, then push to a non-default branch:

CODEBLOCK8

Notes:

• - Prefer creating a new branch name (e.g. pb/<task>/<timestamp>) rather than pushing to main.
• If the broker session becomes USED, create a new push session.

Python (requests)

CODEBLOCK9

Constraints You Must Respect

• - Upstream scheme: HTTPS only.
• Upstream host allowlist: provider-defined (the request must target a supported host).
• Upstream methods: GET/POST/PUT/PATCH/DELETE.
• Upstream response size cap: 1 MiB.
• Upstream request body cap: 256 KiB.
• One-time execution: after executing a request, you cannot execute it again.

Sheets Note (Without Drama)

The broker supports the Google Sheets API host (sheets.googleapis.com).

Preferred approach for reading spreadsheet data:

1. 1. Use Drive search/list to find the spreadsheet file.
2. Use Sheets values read to fetch only the range you need.

Fallback:

• - Use Drive export to fetch contents as CSV when that is sufficient.

Note: large exports can exceed the broker's 1 MiB upstream response cap.
If an export fails due to size, narrow the scope (smaller range, fewer tabs, or fewer rows/columns).

Handling Common Terminal States

• - 202: request is still actionable; JSON includes status (often PENDING_APPROVAL, APPROVED, or EXECUTING).

- If status == APPROVED, execute immediately. - Otherwise keep polling.

• - 403: denied by user.
• 403: forbidden (wrong API key or request not accessible) is also possible; inspect {error: ...}.
• 408: approval expired (user did not decide in time).
• 409: already executing; retry shortly.
• 410: already executed; recreate the request if you still need it.

How To Build Upstream URLs (Google example)

Prefer narrow reads so approvals are understandable and responses are small.

• - Drive search/list files: INLINECODE88

- Use q, pageSize, and fields to minimize payload.

• - Drive export file contents: INLINECODE92

- Useful for Google Docs/Sheets export to text/plain or text/csv.

• - Docs structured doc read: INLINECODE95

See references/api_reference.md for endpoint details and a Google URL cheat sheet.

How To Build Upstream URLs (GitHub examples)

• - Create PR: INLINECODE97

- JSON body: { "title": "...", "head": "branch", "base": "main", "body": "..." }

• - Create issue: INLINECODE99

- JSON body: INLINECODE100

Data Handling Rules

• - Treat the user's API key as secret.

Resources

• - Reference: INLINECODE101