# io.github.michal-lefler/secure-flows

> MCP server for secureFlows (secure-flows.com). Alias of io.github.michal-lefler/secureflows-mcp.

- name: io.github.michal-lefler/secure-flows
- version: 0.2.0
- connection class: R0 (autonomous)
- trust: 94/100
- quality: 65/100 (needs work)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.michal-lefler%2Fsecure-flows
- tools: https://api.protogrid.dev/v1/servers/io.github.michal-lefler%2Fsecure-flows/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "secure-flows": {
      "type": "http",
      "url": "https://www.secure-flows.com/mcp?alias=secure-flows"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 99
- freshness: 85
- provenance: 90
- drivers: +repository +namespace-matches-repo +website +reachable +uptime-97% ~updated-56d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 65/100 (needs work)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 64 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 4 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- fail `tools.annotations`: no tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
- fail `tools.directory_hints`: no tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: post_sessions (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); get_sessions_identity (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); post_sessions_renew_session_token (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); …
- pass `tools.token_cost`: about 7,929 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 50 (weight 15)

- pass `stability.changes`: 2 tool changes in 30 days
- fail `stability.rug_pull`: 1 tools kept their name but changed most of their description in 30 days; review before trusting them

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 18, about 7,929 tokens to load them all
- tool set hash: a853b7166902b3ab2015a9b0e16ad9a9
- tools last changed: 2026-09-30T19:00:27.745Z
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.michal-lefler/secure-flows.svg)](https://protogrid.dev/servers/io.github.michal-lefler/secure-flows)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

- 2026-09-30 `post_sessions_revoke_session_id` changed (description)
  - before: Self-service dashboard endpoint. Revokes a session owned by the caller in the current workspace. Requires workspace **`enableSelfService: true`**. Source: POST /api/v1/sessions/revoke/{sessionId} Requires `auth.userToken` and forwards it as a Bearer token. Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
  - after: Self-service dashboard endpoint. Revokes a session owned by the caller in the current workspace. The session ends and its stored data is destroyed permanently; this is not sign-out. Requires workspace **`enableSelfService: true`**. Source: POST /api/v1/sessions/revoke/{sessionId} Requires `auth.userToken` and forwards it as a Bearer token. Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- 2026-09-30 `post_sessions_revoke` changed (title, description) **meaning changed**
  - before: Revokes the session referenced by the internal SESSION Bearer token. This endpoint is useful for automation clients that only hold a session token and want to revoke it cleanly. Source: POST /api/v1/sessions/revoke Requires `auth.sessionToken` and forwards it as a Bearer token. Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
  - after: Permanently revokes the session referenced by the internal SESSION Bearer token. The session ends and everything stored in it is destroyed and cannot be restored. This is NOT sign-out: to sign a user out and keep their data, use POST /api/v1/auth/logout (or, in a browser, the redirect helper GET /api/v1/auth/logout). Call revoke only when the user or an admin deliberately wants the session and its data deleted, for example on account deletion. Source: POST /api/v1/sessions/revoke Requires `auth.sessionToken` and forwards it as a Bearer token. Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.

Full history: https://api.protogrid.dev/v1/servers/io.github.michal-lefler%2Fsecure-flows/changes

## Remotes

- https://www.secure-flows.com/mcp?alias=secure-flows (streamable-http, auth none, reachable true, uptime30d 0.9741379)

## Packages

_none_

## Tools (18)

- `auth_session_callback`: **Browser redirect endpoint** used after hosted `/app/sessions/login`. No `Authorization` header.

1. Verifies **`firebaseToken`** (Firebase ID token).
2. Ensures **`client_redirect_uri`** is allowlisted for **`app_id`** (same rules as `validate-redirect`).
3. **Create vs renew:** If **`session_token`** is absent, **reuses the newest active session** for
   **`(workspace_name, Firebase UID, app_id)`** or **creates** one (`get-or-create`). Optional
   **`payload`** (URL-encoded JSON **object**, default `{}`) is stored **only on create** — ignored when
   reusing an existing session. If **`session_token`** is present (previous session JWT, may be expired),
   **renews** that session; **`payload`** must **not** be sent on the same request. Optional
   **`ttl_seconds`** applies to both paths (default **0** = unlimited; otherwise **60–604800**). When the
   Firebase token includes **`email`**, the server best-effort persists or backfills it on the workspace
   end-user row (audit display only).
4. Responds with **`302 Found`** to `client_redirect_uri` with query params **`sessionToken`**
   and, if provided, **`state`**.

If **`client_redirect_uri`** is not allowed for **`app_id`**, responds **`400`** and does **not**
redirect (open-redirect mitigation). Other failures return an HTTP error status with a JSON
**`{"status", "error"}`** body and do **not** redirect.

Source: GET /api/v1/auth/callback
No Authorization header is required.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `delete_sessions_delete_key`: Removes `key` from the session payload and returns `true` if the key existed.

Source: DELETE /api/v1/sessions/delete/{key}
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `get_auth_logout`: Browser-friendly logout endpoint for **cross-site** clients (e.g. apps running on `localhost`).

Use this as a **top-level navigation** (not XHR/fetch) so `Clear-Site-Data` is applied in a
**first-party** context on `secure-flows.com`, making cookie/session clearing reliable even when
third-party cookies are blocked.

**Critical client rules:**
- Clear your in-app `sessionToken` state **before** navigating.
- **Never** include `session_token` inside `redirect_uri` (that would silently renew and defeat logout).

This endpoint (best-effort / idempotent for browser UX):
- Invalidates the provided `session_token` by incrementing `tokenRevision` when the token still
  matches an **active** session (no new token is issued).
- If the session is already expired/revoked or the revision was superseded by renew, still
  completes logout UX (does **not** return 401 solely for that reason).
- Revokes Firebase refresh tokens for the session’s stored Firebase UID when known.
- Sets `Clear-Site-Data: "cookies"`.
- Redirects the browser to `redirect_uri`.

Source: GET /api/v1/auth/logout
No Authorization header is required.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `get_docs_search`: Embeds the query with Ollama (`nomic-embed-text`) and returns the closest public doc chunks
from the environment's search index (pgvector).

Source: GET /api/v1/docs/search
No Authorization header is required.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `get_sessions`: Returns the decrypted session payload for the authenticated internal session token.

Response shape is a **flat JSON object**. Empty payload returns `{}`.

Source: GET /api/v1/sessions
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `get_sessions_get_key`: Retrieves the decrypted payload value for `key`.

**Important:** `404` means the key was never written (normal first-use case). Do not treat as an error.

Source: GET /api/v1/sessions/get/{key}
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `get_sessions_identity`: Returns the workspace end-user's **`userId`** and **email** for the authenticated session
token. Does not return Firebase UID or session payload.

`userId` is a stable, opaque identifier for this person across sessions and logins — it is
**not** derived from Firebase. Use it as the correlation key when your own backend needs to
link an external event (e.g. a billing provider webhook you receive and verify yourself)
back to this user. Do not use the session token or session id for this — sessions expire and
rotate, `userId` does not.

Email is best-effort from hosted login (Firebase `email` claim persisted on the user row).
When unknown, `email` is `null`. Browser SDK: **`secureflows-js`** **`fetchSessionIdentity(token)`** (≥ 0.1.15 for `userId`).

Source: GET /api/v1/sessions/identity
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `get_sessions_my`: Returns a page of sessions for the current user within the current workspace.
Self-service dashboard endpoint — requires workspace **`enableSelfService: true`**.
Payload is included only for rows whose computed status is active.
Sort keys match the admin workspace session list; `pageSize` is clamped to 1–200 (default 20).

Source: GET /api/v1/sessions/my
Requires `auth.userToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_auth_logout`: Logs out the current session **without revoking** it.

**Browser warning:** calling this endpoint via XHR/fetch from a different origin than `secure-flows.com`
is not a reliable way to clear hosted-login cookies. For browser apps (especially localhost), prefer the
redirect helper `GET /api/v1/auth/logout?session_token=...&redirect_uri=...`.

Behavior:
- **Invalidates** the current `sessionToken` by incrementing `tokenRevision` (no new token is issued).
- Calls Firebase `revokeRefreshTokens(firebaseUid)` using the session’s stored Firebase UID.
- Sets `Clear-Site-Data: "cookies"` to clear browser cookies (including Firebase session cookie).

Session payload and session row are **not** deleted or modified (other than `tokenRevision`).

Source: POST /api/v1/auth/logout
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_sessions`: Verifies **Firebase** ID token, creates a session for **`workspaceName`**, stores serialized
**`payload`** (defaults to `{}` when omitted), and returns **`sessionToken`** (JWT; subject = internal session id).
Default server-side TTL is **1 hour** (implementation detail).

If the Firebase token includes **`email`**, the server best-effort persists it on the workspace
end-user row (for audit display). Prefer **`POST /sessions/get-or-create`** for hosted-login-style
flows that should reuse an active session.

Source: POST /api/v1/sessions
Requires `auth.firebaseToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_sessions_get_or_create`: Verifies **Firebase** ID token. If an **active** session already exists for
**`(workspaceName, Firebase UID, app_id)`**, returns a new **`sessionToken`** JWT for the **most
recently created** matching row (touches activity; does not create a duplicate session). The request
**`payload` is ignored on reuse** — it is applied only when a new session row is created. Prefer a
dedicated `app_id` per integration surface, or revoke old sessions, if you need a fresh payload.

Otherwise behaves like **`POST /sessions`** (new row + default **1 hour** TTL).

If the Firebase token includes **`email`**, the server best-effort persists or backfills it on the
workspace end-user row (including when reusing an existing session). Intended for integrators that
mirror hosted login session reuse.

Source: POST /api/v1/sessions/get-or-create
Requires `auth.firebaseToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_sessions_renew_session_token`: Verifies **Firebase** ID token. Parses **`sessionToken`** path segment as an internal SESSION JWT **without
enforcing JWT expiry** (signature and `tokenType=SESSION` are still validated). Loads the
session by id from the token subject; the Firebase UID must match the session owner.
Increments **`tokenRevision`** on the server so **previous session JWTs** (same session id,
older revision) are no longer accepted for `GET/POST/DELETE /sessions/...`.
Returns a **new `sessionToken`** (with the new `tokenRevision` claim) and the current decrypted
**payload**; extends server-side session expiry by **1 hour**.

If the Firebase token includes **`email`**, the server best-effort backfills it on the session owner
when the user row has no email yet (audit display only).

Use the path form `POST /api/v1/sessions/renew/{sessionToken}` — **URL-encode** the JWT (e.g. `encodeURIComponent` in JS).

Source: POST /api/v1/sessions/renew/{sessionToken}
Requires `auth.firebaseToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_sessions_revoke`: Permanently revokes the session referenced by the internal SESSION Bearer token. The session ends and everything stored in it is destroyed and cannot be restored. This is NOT sign-out: to sign a user out and keep their data, use POST /api/v1/auth/logout (or, in a browser, the redirect helper GET /api/v1/auth/logout). Call revoke only when the user or an admin deliberately wants the session and its data deleted, for example on account deletion.

Source: POST /api/v1/sessions/revoke
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_sessions_revoke_session_id`: Self-service dashboard endpoint. Revokes a session owned by the caller in the current workspace.
The session ends and its stored data is destroyed permanently; this is not sign-out.
Requires workspace **`enableSelfService: true`**.

Source: POST /api/v1/sessions/revoke/{sessionId}
Requires `auth.userToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `post_sessions_set_key`: Sets a key in the encrypted session payload and returns the updated decrypted payload. If the JSON body is `{ "value": <x> }`, the server unwraps it and stores `<x>` directly.

Source: POST /api/v1/sessions/set/{key}
Requires `auth.sessionToken` and forwards it as a Bearer token.
Prefer connection.workspaceName and connection.appId as stable config instead of generating identity fields dynamically.
- `secureflows_build_login_url`: Builds a correct hosted-login redirect URL. Needs no secureFlows token — safe to call at app-scaffolding time,
before any user session exists, which is the phase most secureFlows integration mistakes happen in.

Always targets /app/sessions/login (session apps). Never builds the legacy /app/login console URL,
which returns a firebaseToken your SecureFlowsCallback handler cannot consume and causes an infinite redirect loop.

Use this instead of hand-building the URL with URLSearchParams — hand-built login URLs are the #1 source of the
login-loop and stale-renewal bugs documented in SKILL.md.
- `secureflows_build_logout_url`: Builds a correct redirect-logout URL and refuses to build one that violates the two documented logout anti-patterns:
a redirect_uri pointing at /callback (SPA callback handlers treat the tokenless return as a failed login and loop),
and a redirect_uri that itself embeds session_token (silently renews the old session instead of signing out).

The result always instructs top-level navigation, never fetch/XHR — cross-site fetch() to this endpoint gets a 200 but
browsers silently ignore its Clear-Site-Data header on cross-site responses, so the hosted-login cookie survives and the
user silently re-authenticates on the next login redirect. This tool never builds a revoke request: revoke permanently
destroys the user's data and must only run on an explicit "delete my account" action, never on ordinary sign-out.
- `secureflows_lint_integration`: Checks source you already generated against the secureFlows integration rules. Needs no secureFlows token; safe at
scaffolding time. Pass every auth/session-related file in one call — some checks are evaluated across the whole set.

Two kinds of findings:
  • scope "file"    — a forbidden construct is present (localStorage token, legacy /app/login, fetch-based logout,
    client-side JWT decode, empty catch, restore non-auth errors clearing session UI, Continue CTA gated on null session, ...), reported at an exact file:line.
  • scope "project" — REQUIRED handling is missing everywhere you passed in: detecting 401/410 but never clearing the
    token, never handling 403, or handling 403 without the BILLING_GRACE_LOCK carve-out. These are the defects that
    actually dominate real generated apps, and no "forbidden pattern" check can see them, because the bug is an absence.

Heuristic text analysis, not a parser or a type checker. It can miss things it has no rule for, and a project check can
be satisfied by the right keyword in the wrong place. It is a fast first pass — not a substitute for the Agent
implementation checklist in SKILL.md, and specifically not for the checks that need a running app (auth-guard mount
races, the fresh-reload check). Fix every "error" before calling an integration done; treat "needs_review" as a lead.