132 lines
4.0 KiB
TypeScript
132 lines
4.0 KiB
TypeScript
import type {
|
|
MessagingPlatformsResponse,
|
|
MessagingPlatformTestResponse,
|
|
MessagingPlatformUpdate,
|
|
PairingResponse,
|
|
PairingUser,
|
|
WebhookCreatePayload,
|
|
WebhookCreateResponse,
|
|
WebhookEnableResponse,
|
|
WebhooksResponse
|
|
} from '@/types/hermes'
|
|
|
|
import { hermesApi, profileScoped } from './client'
|
|
|
|
export function getMessagingPlatforms(profile?: null | string): Promise<MessagingPlatformsResponse> {
|
|
return hermesApi<MessagingPlatformsResponse>({
|
|
...profileScoped(profile),
|
|
path: '/api/messaging/platforms'
|
|
})
|
|
}
|
|
|
|
export function updateMessagingPlatform(
|
|
platformId: string,
|
|
body: MessagingPlatformUpdate,
|
|
profile?: null | string
|
|
): Promise<{ ok: boolean; platform: string }> {
|
|
return hermesApi<{ ok: boolean; platform: string }>({
|
|
...profileScoped(profile),
|
|
path: `/api/messaging/platforms/${encodeURIComponent(platformId)}`,
|
|
method: 'PUT',
|
|
body
|
|
})
|
|
}
|
|
|
|
export function testMessagingPlatform(
|
|
platformId: string,
|
|
profile?: null | string
|
|
): Promise<MessagingPlatformTestResponse> {
|
|
return hermesApi<MessagingPlatformTestResponse>({
|
|
...profileScoped(profile),
|
|
path: `/api/messaging/platforms/${encodeURIComponent(platformId)}/test`,
|
|
method: 'POST'
|
|
})
|
|
}
|
|
|
|
// -- Pairing (who may DM the bot) --------------------------------------------
|
|
// Unknown DMers get a one-time code and land in `pending` until an admin
|
|
// approves them. Approval grants on the row's `request_id`, never on the code:
|
|
// the code is the requester's proof that the channel is theirs and is never
|
|
// returned by the API, while an authenticated admin is only ever identifying
|
|
// a row they can already see.
|
|
|
|
export function getPairing(profile?: null | string): Promise<PairingResponse> {
|
|
return hermesApi<PairingResponse>({
|
|
...profileScoped(profile),
|
|
path: '/api/pairing'
|
|
})
|
|
}
|
|
|
|
export function approvePairing(
|
|
platform: string,
|
|
requestId: string,
|
|
profile?: null | string
|
|
): Promise<{ ok: boolean; user: PairingUser }> {
|
|
return hermesApi<{ ok: boolean; user: PairingUser }>({
|
|
...profileScoped(profile),
|
|
path: '/api/pairing/approve',
|
|
method: 'POST',
|
|
// These endpoints read the profile off the body, not the query string —
|
|
// `profileScoped()` alone would approve into the wrong profile's store.
|
|
body: { platform, request_id: requestId, ...profileScoped(profile) }
|
|
})
|
|
}
|
|
|
|
export function revokePairing(platform: string, userId: string, profile?: null | string): Promise<{ ok: boolean }> {
|
|
return hermesApi<{ ok: boolean }>({
|
|
...profileScoped(profile),
|
|
path: '/api/pairing/revoke',
|
|
method: 'POST',
|
|
body: { platform, user_id: userId, ...profileScoped(profile) }
|
|
})
|
|
}
|
|
|
|
// -- Webhooks (subscription CRUD) --------------------------------------------
|
|
// The webhook receiver is its own gateway platform; subscriptions live in a
|
|
// shared JSON store the CLI/dashboard also drive. Enable mutates config and
|
|
// best-effort restarts the gateway; subscription changes hot-reload.
|
|
|
|
export function getWebhooks(): Promise<WebhooksResponse> {
|
|
return hermesApi<WebhooksResponse>({
|
|
...profileScoped(),
|
|
path: '/api/webhooks'
|
|
})
|
|
}
|
|
|
|
export function enableWebhooks(): Promise<WebhookEnableResponse> {
|
|
return hermesApi<WebhookEnableResponse>({
|
|
...profileScoped(),
|
|
path: '/api/webhooks/enable',
|
|
method: 'POST'
|
|
})
|
|
}
|
|
|
|
export function createWebhook(body: WebhookCreatePayload): Promise<WebhookCreateResponse> {
|
|
return hermesApi<WebhookCreateResponse>({
|
|
...profileScoped(),
|
|
path: '/api/webhooks',
|
|
method: 'POST',
|
|
body
|
|
})
|
|
}
|
|
|
|
export function deleteWebhook(name: string): Promise<{ ok: boolean }> {
|
|
return hermesApi<{ ok: boolean }>({
|
|
...profileScoped(),
|
|
path: `/api/webhooks/${encodeURIComponent(name)}`,
|
|
method: 'DELETE'
|
|
})
|
|
}
|
|
|
|
export function setWebhookEnabled(
|
|
name: string,
|
|
enabled: boolean
|
|
): Promise<{ enabled: boolean; name: string; ok: boolean }> {
|
|
return hermesApi<{ enabled: boolean; name: string; ok: boolean }>({
|
|
...profileScoped(),
|
|
path: `/api/webhooks/${encodeURIComponent(name)}/enabled`,
|
|
method: 'PUT',
|
|
body: { enabled }
|
|
})
|
|
}
|