import React, { useEffect, useId, useRef, useState } from 'react' import { KeyRound, Plus, Trash2, Copy, Check, AlertTriangle, Briefcase, CalendarDays, MapPin, StickyNote, Ticket, Hotel, Users, Star, BarChart3, type LucideIcon, } from 'lucide-react' import { PUBLIC_API_SCOPES, type PublicApiScope } from '@trek/shared' import Section from './Section' import ConfirmDialog from '../shared/ConfirmDialog' import { Tooltip } from '../shared/Tooltip' import { DialogButton, DialogFooter, DialogHeader, DialogShell, DialogTile, FooterSpacer, NEUTRAL_TINT, fs } from '../shared/DialogShell' import { EditorField, GRID_2, INPUT, LABEL } from '../shared/dialogParts' import { SETTINGS_BUTTON_PRIMARY, SETTINGS_ICON_BUTTON, SettingsHint, StatusPill } from './settingsKit' import { useTranslation } from '../../i18n' import { useDateFormat } from '../../hooks/useDateFormat' import { formatDisplayDate } from '../../utils/dateFormat' import { useToast } from '../shared/Toast' import { authApi } from '../../api/client' /** * Keys for the public API — the credential a user hands to other software that * should read their trips. * * Its own section rather than a third tab under MCP: an API key is not an MCP * credential, it does not need the MCP addon, and burying it under a heading * about AI assistants is how people end up minting the wrong kind. The two look * alike deliberately (name, prefix, shown once) because they are the same * gesture; what differs is which door they open. * * State lives here rather than in the tab's shared hook so the section works on * an instance with MCP switched off. */ interface ApiKey { id: number name: string token_prefix: string created_at: string last_used_at: string | null /** 'all' for every key minted before scopes existed, and for any key created without narrowing. */ scope_mode?: 'all' | 'limited' scopes?: PublicApiScope[] } /** The server refuses an eleventh key (`TokenService.createToken`). */ const MAX_KEYS = 10 /** The glyph each area already wears elsewhere in the app, so the list reads like the planner. */ const SCOPE_ICONS: Record = { trips: Briefcase, days: CalendarDays, places: MapPin, notes: StickyNote, reservations: Ticket, accommodations: Hotel, travellers: Users, 'bucket-list': Star, stats: BarChart3, } /** SQLite hands out "YYYY-MM-DD HH:MM:SS" in UTC, which Safari will not parse as it stands. */ function formatStamp(ts: string, locale: string, dateFormat: string): string { const iso = ts.includes('T') ? ts : ts.replace(' ', 'T') const d = new Date(/(Z|[+-]\d{2}:?\d{2})$/.test(iso) ? iso : `${iso}Z`) return Number.isNaN(d.getTime()) ? ts : formatDisplayDate(d, locale, {}, dateFormat) } /** * The usage hint with its header names and path set as code. * * Every locale quotes the two headers the same way, so they can be picked out * of the sentence instead of cutting it into fragments a translator would have * to reassemble. A translation that drops the quotes simply stays plain text. */ function withCode(text: string): React.ReactNode[] { return text.split(/("[^"]+"|\/api\/v1)/).map((part, i) => { if (i % 2 === 0) return part return ( {part.replace(/^"|"$/g, '')} ) }) } export default function ApiKeysSection(): React.ReactElement { const { t, locale } = useTranslation() const toast = useToast() const dialogLabelId = useId() const [keys, setKeys] = useState([]) /** A failed load must not read as "you have no keys": that sends people off minting duplicates. */ const [loadState, setLoadState] = useState<'loading' | 'ready' | 'failed'>('loading') const [modalOpen, setModalOpen] = useState(false) const [newName, setNewName] = useState('') const [creating, setCreating] = useState(false) /** The raw key, held only until the modal closes — the server keeps a hash. */ const [created, setCreated] = useState(null) const [deleteId, setDeleteId] = useState(null) const [copied, setCopied] = useState<'key' | 'endpoint' | null>(null) const copiedTimer = useRef | undefined>(undefined) /** * What the new key may read. Starts as everything, because that is what a key * did before this existed and what most integrations want — narrowing is a * deliberate act, and the dialog should not make the common case work harder. */ const [newScopes, setNewScopes] = useState>(new Set(PUBLIC_API_SCOPES)) const endpoint = `${window.location.origin}/api/v1` const atLimit = keys.length >= MAX_KEYS const allSelected = newScopes.size === PUBLIC_API_SCOPES.length const canCreate = !!newName.trim() && !creating && newScopes.size > 0 useEffect(() => { let cancelled = false authApi.apiKeys.list() .then(d => { if (cancelled) return setKeys(d.tokens || []) setLoadState('ready') }) .catch(() => { if (!cancelled) setLoadState('failed') }) return () => { cancelled = true clearTimeout(copiedTimer.current) } }, []) const handleCreate = async () => { // Enter in the name field arrives here past the button's disabled state, and // an empty selection must not fall through to the "no narrowing" branch // below, which would mint a key that reads everything. if (!canCreate) return setCreating(true) try { // All of them selected means "no narrowing", which is what the server // stores as `all` — sending the full list would record it as a limited key // that happens to allow everything, and a section added in a later version // would then be refused for a key nobody meant to restrict. const narrowed = allSelected ? undefined : [...newScopes] const d = await authApi.apiKeys.create(newName.trim(), narrowed) setCreated(d.token.raw_token) setKeys(prev => [ { id: d.token.id, name: d.token.name, token_prefix: d.token.token_prefix, created_at: d.token.created_at, last_used_at: null, scope_mode: d.token.scope_mode, scopes: d.token.scopes, }, ...prev, ]) setNewName('') } catch { toast.error(t('settings.apiKeys.createFailed')) } finally { setCreating(false) } } const handleDelete = async (id: number) => { try { await authApi.apiKeys.delete(id) setKeys(prev => prev.filter(k => k.id !== id)) toast.success(t('settings.apiKeys.deleted')) } catch { toast.error(t('settings.apiKeys.deleteFailed')) } } const handleCopy = async (text: string, what: 'key' | 'endpoint') => { try { // Absent on a plain-http origin, which is exactly where a self-run // instance on the LAN tends to live. if (!navigator.clipboard) throw new Error('clipboard unavailable') await navigator.clipboard.writeText(text) setCopied(what) clearTimeout(copiedTimer.current) copiedTimer.current = setTimeout(() => setCopied(null), 2000) } catch { toast.error(t('settings.apiKeys.copyFailed')) } } const resetForm = () => { setCreated(null) setCopied(null) setNewName('') setNewScopes(new Set(PUBLIC_API_SCOPES)) } const openModal = () => { resetForm() setModalOpen(true) } const closeModal = () => { setModalOpen(false) resetForm() } const toggleScope = (scope: PublicApiScope) => { setNewScopes(prev => { const next = new Set(prev) if (next.has(scope)) next.delete(scope) else next.add(scope) return next }) } const header = ( } tint={NEUTRAL_TINT} labelId={dialogLabelId} // Once the key is on screen the cross does what Done does: it is a deliberate // click, unlike the Escape and backdrop the shell ignores below. onClose={closeModal} title={created ? t('settings.apiKeys.modal.createdTitle') : t('settings.apiKeys.modal.createTitle')} /> ) const footer = created ? ( {t('settings.apiKeys.modal.done')} ) : ( {t('common.cancel')} : undefined}> {creating ? t('settings.apiKeys.modal.creating') : t('settings.apiKeys.modal.create')} ) return ( <>
0 ? {keys.length}/{MAX_KEYS} : undefined} action={( )} > {t('settings.apiKeys.description')} {atLimit && (

{t('settings.apiKeys.limitReached', { count: MAX_KEYS })}

)} {loadState === 'loading' && (
)} {loadState === 'failed' && (

{t('settings.apiKeys.loadFailed')}

)} {loadState === 'ready' && keys.length === 0 && (

{t('settings.apiKeys.empty')}

)} {keys.length > 0 && (
    {keys.map(key => ( setDeleteId(key.id)} /> ))}
)}
{t('settings.apiKeys.endpoint')}
{endpoint}
{withCode(t('settings.apiKeys.docsHint'))}
{} : closeModal} blocked={!!created} labelledBy={dialogLabelId} width="detail" header={header} footer={footer} > {created ? ( <>

{t('settings.apiKeys.modal.createdWarning')}

{created}
) : ( <> setNewName(e.target.value)} onKeyDown={e => { if (e.key === 'Enter') void handleCreate() }} placeholder={t('settings.apiKeys.modal.namePlaceholder')} maxLength={100} className={INPUT} autoFocus />
{t('settings.apiScopes.title')}
{t('settings.apiScopes.hint')}
{PUBLIC_API_SCOPES.map(scope => ( toggleScope(scope)} /> ))}
{newScopes.size === 0 && (

{t('settings.apiScopes.noneSelected')}

)}
)}
setDeleteId(null)} onConfirm={() => { if (deleteId !== null) void handleDelete(deleteId) }} title={t('settings.apiKeys.deleteTitle')} message={t('settings.apiKeys.deleteMessage')} confirmLabel={t('settings.apiKeys.deleteTitle')} /> ) } function ApiKeyRow({ apiKey, locale, onDelete }: { apiKey: ApiKey; locale: string; onDelete: () => void }): React.ReactElement { const { t } = useTranslation() const dateFormat = useDateFormat() const scopes = apiKey.scope_mode === 'limited' ? apiKey.scopes : undefined return (
  • {apiKey.name} {apiKey.token_prefix}…

    {t('settings.apiKeys.createdAt')} {formatStamp(apiKey.created_at, locale, dateFormat)} {', '} {apiKey.last_used_at ? `${t('settings.apiKeys.usedAt')} ${formatStamp(apiKey.last_used_at, locale, dateFormat)}` : t('settings.apiKeys.neverUsed')}

    {/* What the key may read. Shown on the row rather than behind a detail view: the whole reason to narrow a key is to be able to see later that you did. */}
    {scopes ? scopes.map(scope => { const Icon = SCOPE_ICONS[scope] return ( : undefined}> {t(`settings.apiScopes.${scope}`)} ) }) : ( {t('settings.apiScopes.all')} )}
  • ) } /** * One area the key may read. The whole tile is the control: a bare browser * checkbox is a small target and ignores the user's accent. */ function ScopeOption({ icon: Icon, label, checked, onToggle }: { icon: LucideIcon label: string checked: boolean onToggle: () => void }): React.ReactElement { return ( ) }