Personal Access Tokens
A Personal Access Token (PAT) is a named, revocable credential you create once from the Lore panel and hand to anything that can’t complete an interactive sign-in — a CI/CD pipeline with no browser and no human to click through a login, or a desktop app or MCP client whose own connection dialog only offers a static credential field, not OAuth. After that, whatever holds the token authenticates on every use, with no human involved and no daily secret rotation.
How it works
A PAT is backed by its own dedicated identity-provider client (internally, a Service Account), bootstrapped once through your own browser session (so it inherits your permissions — see the callout below). Depending on where you’re using it, either the CLI silently mints a fresh short-lived token before every command, or — for lore-mcp — the server does the same before every tool call.
A PAT has the same permissions as the account that authorizes it in Step 2 below — there’s no separate scope box. If you need a token limited to a single namespace, invite a dedicated identity (e.g. ci-bot@yourcompany.com) as a publisher on that namespace first, then complete Step 2 while signed in as that identity — not your own personal account.
Step 1 — Create the token
- In the Lore panel, go to your org → Settings → Personal Access Tokens.
- Under New Personal Access Token, fill in a descriptive Name (e.g.
azure-pipelines-prod,github-copilot-desktop) — you’ll use this name to find and revoke it later. - Click Create & Authorize — you’re redirected immediately, there’s no separate confirmation step first.
Step 2 — Authorize it
You land on a normal sign-in screen — same as lore login. Sign in as the identity whose permissions you want the token to have (your own account, or a dedicated CI identity — see the warning above).
After you approve, you land on a confirmation page showing a value once:
LORE_AUTH_TOKEN=eyJvcmciOiJhY21lLWNvcnAiLCJpZCI6InN2Yy1jaS1hMWIyYzMiLCJzZWNyZXQiOiIuLi4ifQ==Treat this value like a password. It’s shown only once and is not recoverable — the panel never stores or displays it again, and navigating away loses it for good. Anyone who has it can act as you (or whichever identity authorized it) until it’s revoked. If you lose it, revoke the token and create a new one.
Step 3 — Use it
In a CI/CD pipeline
Store the value as a secret named LORE_AUTH_TOKEN in your CI system, then export it in the job environment. The CLI handles the rest — no lore login, no browser, no manual refresh.
Azure DevOps
# azure-pipelines.yml
variables:
- group: lore-ci-credentials # Variable Group containing LORE_AUTH_TOKEN as a secret variable
steps:
- script: |
lore pull m1cloud/azure-architect
lore publish ./my-skill
env:
LORE_AUTH_TOKEN: $(LORE_AUTH_TOKEN)Pipelines → Library → Variable groups → add LORE_AUTH_TOKEN, click the lock icon to mark it secret, then link the group to your pipeline with variables: - group:.
GitHub Actions
# .github/workflows/publish.yml
name: Publish Lore package
on:
push:
branches: [main]
jobs:
publish:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Install Lore CLI
run: curl -fsSL https://lore.infraestrutura.app/install.sh | sh
- name: Publish
run: lore publish ./my-skill
env:
LORE_AUTH_TOKEN: ${{ secrets.LORE_AUTH_TOKEN }}Repository or organization Settings → Secrets and variables → Actions → New repository secret → name it LORE_AUTH_TOKEN.
GitLab CI
# .gitlab-ci.yml
publish:
stage: deploy
image: alpine:3.20
script:
- apk add --no-cache curl
- curl -fsSL https://lore.infraestrutura.app/install.sh | sh
- lore publish ./my-skill
rules:
- if: '$CI_COMMIT_BRANCH == "main"'
# LORE_AUTH_TOKEN comes from a masked CI/CD variable — see note belowProject or group Settings → CI/CD → Variables → Add variable → key LORE_AUTH_TOKEN, check Mask variable (and Protect variable if this only runs on protected branches). GitLab injects CI/CD variables into the job environment automatically — no extra variables: block needed in the YAML.
As a static header, for an app with no OAuth support
Some MCP clients that connect to the hosted lore-mcp server (see MCP Server Setup) don’t support OAuth at all for custom remote servers — their own connection dialog only offers a static credential field, usually under a Headers or Authorization section, with no sign-in step. A PAT is exactly what belongs there: paste the value shown in Step 2 as the header’s value, prefixed with Bearer .
For example, in the standalone GitHub Copilot desktop app’s “Add MCP Server” dialog, click Add header, set the name to Authorization, and set the value to:
Bearer eyJvcmciOiJhY21lLWNvcnAiLCJpZCI6InN2Yy1jaS1hMWIyYzMiLCJzZWNyZXQiOiIuLi4ifQ==Leave OAuth Client ID blank in this case — you’re authenticating via the header instead. lore-mcp recognizes a PAT presented this way automatically and exchanges it for a fresh token on every call, exactly like the CLI does; there’s nothing else to configure, and nothing to refresh manually later.
Treat this value like a password here too. Anyone with access to this app’s MCP server configuration can read it back out and act as you until you revoke it.
Managing tokens
Back in Settings → Personal Access Tokens, each token shows its name, who authorized it, and when it was last used. Click Revoke to kill one immediately — the next pipeline run or app connection using it fails with unauthorized right away, no waiting for an expiry window.
Revoking a Personal Access Token never affects the personal lore login session of the identity that authorized it — they’re backed by separate identity-provider clients.
Relationship to LORE_AUTH_TOKEN (static token)
Personal Access Tokens and the static-token approach both use the same LORE_AUTH_TOKEN variable (or, for lore-mcp, the same Authorization: Bearer header) — the CLI and lore-mcp both tell them apart automatically (a plain JWT vs. a PAT) and refresh the latter transparently. If you’re on a Registry version that doesn’t yet expose Personal Access Tokens in the panel, fall back to the static-token guide and rotate manually.