# io.github.michal-lefler/secureflows-mcp-server (remote · www.secure-flows.com)

MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.

- Trust score: 57/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-21

## Components

- remote · `www.secure-flows.com`: 57/100 (this document), [markdown](https://verifymcp.io/servers/michal-lefler-secureflows-mcp-server/www.md), [page](https://verifymcp.io/servers/michal-lefler-secureflows-mcp-server/www)

## Channel facts

- Endpoint: `https://www.secure-flows.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.2.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-21.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 18 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 56/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 4016 tokens (~223/item across 18 items; 18 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 13% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http michal-lefler-secureflows-mcp-server https://www.secure-flows.com/mcp
```

### Codex

```toml
[mcp_servers.michal-lefler-secureflows-mcp-server]
url = "https://www.secure-flows.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "michal-lefler-secureflows-mcp-server": {
      "type": "remote",
      "url": "https://www.secure-flows.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add michal-lefler-secureflows-mcp-server --url https://www.secure-flows.com/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  michal-lefler-secureflows-mcp-server:
    url: "https://www.secure-flows.com/mcp"
```

### Other

```json
{
  "mcpServers": {
    "michal-lefler-secureflows-mcp-server": {
      "type": "http",
      "url": "https://www.secure-flows.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-21 (score 57, +1)

- [functional improvement] Stability: unverified → 0.03

### 2026-08-20 (score 56)

First indexed and scored.

## MCP tools (18)

### `get_sessions` (~112 tokens)

Get the current session payload

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object)

### `post_sessions` (~203 tokens)

Create a new session

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.

Input parameters:

- `auth` (object)
- `body` (object, required)
- `connection` (object, required)
- `params` (object)
- `query` (object)

### `get_sessions_identity` (~271 tokens)

Get signed-in user's stable id and email (app UI, backend correlation)

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object)

### `post_sessions_get_or_create` (~275 tokens)

Reuse active session or create one

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.

Input parameters:

- `auth` (object)
- `body` (object, required)
- `connection` (object, required)
- `params` (object)
- `query` (object)

### `post_sessions_renew_session_token` (~309 tokens)

Renew session JWT (replace expired 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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object, required)
- `query` (object)

### `post_sessions_set_key` (~152 tokens)

Set a value inside the session payload

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.

Input parameters:

- `auth` (object)
- `body` (required): JSON body can be either `{ "value": <x> }` (preferred) or a raw JSON value.
- `connection` (object, required)
- `params` (object, required)
- `query` (object)

### `get_sessions_get_key` (~123 tokens)

Get a single value from the session payload

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object, required)
- `query` (object)

### `delete_sessions_delete_key` (~107 tokens)

Delete a key from the session payload

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object, required)
- `query` (object)

### `post_sessions_revoke` (~122 tokens)

Revoke the current session (by session token)

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object)

### `auth_session_callback` (~441 tokens)

Session login callback (redirect)

\**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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object, required)

### `get_auth_logout` (~322 tokens)

Log out (browser redirect helper; first-party cookie clearing)

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object, required)

### `post_auth_logout` (~250 tokens)

Log out (invalidate sessionToken + revoke Firebase refresh tokens)

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object)

### `get_sessions_my` (~155 tokens)

List my sessions (paged, sortable, filterable)

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object, required)

### `post_sessions_revoke_session_id` (~123 tokens)

Revoke a session owned by the current user

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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object, required)
- `query` (object)

### `get_docs_search` (~108 tokens)

Semantic documentation 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.

Input parameters:

- `auth` (object)
- `body`
- `connection` (object, required)
- `params` (object)
- `query` (object, required)

### `secureflows_build_login_url` (~351 tokens)

Build secureFlows hosted 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.

Input parameters:

- `appId` (string, required): App id from the human prompt ("appId = ...")
- `expiredToken` (string): The old sessionToken to renew. Only read when intent=renew_expired_token. Setting this after an explicit sign-out is the "send a dead JWT into hosted login" anti-pattern — it breaks renewal when the…
- `intent` (string): fresh_login: normal sign-in, or app-load restore with no prior token (default — almost always correct, including after an explicit sign-out). renew_expired_token: ONLY when resuming the SAME still-in…
- `origin` (string): secureFlows origin — always https://www.secure-flows.com in production
- `redirectUri` (string, required): The app's unguarded /callback URL, built from the published/allowlisted app origin — never from an iframe or editor chrome origin.
- `workspaceName` (string, required): Workspace name from the human prompt ("workspace = ...")

### `secureflows_build_logout_url` (~249 tokens)

Build secureFlows redirect-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.

Input parameters:

- `origin` (string): secureFlows origin — always https://www.secure-flows.com in production
- `postLogoutRedirectUri` (string, required): Where the browser lands after logout completes — allowlisted, must NOT be /callback, and must NOT itself contain session_token.
- `sessionToken` (string, required): The current sessionToken to invalidate.

### `secureflows_lint_integration` (~343 tokens)

Static-scan generated code for secureFlows anti-patterns

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.

Input parameters:

- `files` (object, required): Map of relative file path -> full file source to scan, e.g. { "src/lib/secureflows.js": "..." }

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/michal-lefler-secureflows-mcp-server/www#diagnostics

## Score history

- 2026-08-21: 57
- 2026-08-20: 56

## Links

- Remote endpoint: https://www.secure-flows.com/mcp
- Repository: https://github.com/michal-lefler/secureflows-mcp-server
- Website: https://www.secure-flows.com/
- Changelog RSS feed: https://verifymcp.io/servers/michal-lefler-secureflows-mcp-server/www.xml
- Changelog JSON feed: https://verifymcp.io/servers/michal-lefler-secureflows-mcp-server/www.json
- HTML version of this page: https://verifymcp.io/servers/michal-lefler-secureflows-mcp-server/www