${success ? 'SDP connected' : 'Sign-in not completed'}
Return to Relay to continue. You can close this tab.
`, + ); + } +} diff --git a/src/main/sdp/SdpAttachments.test.ts b/src/main/sdp/SdpAttachments.test.ts new file mode 100644 index 00000000..3b8582e9 --- /dev/null +++ b/src/main/sdp/SdpAttachments.test.ts @@ -0,0 +1,93 @@ +import { describe, expect, it, vi } from 'vitest'; +import { SdpAttachmentMutationSchema } from '@shared/sdpAttachments'; +import { attachmentBody, attachmentDownloadUrl, downloadAttachment } from './SdpAttachments'; +import { SdpProvider } from './SdpProvider'; +import { submitMutation } from './SdpMutations'; +describe('SDP attachment boundary', () => { + it('uses the documented multipart upload without treating file text as markup', async () => { + const mutation = SdpAttachmentMutationSchema.parse({ + kind: 'attachment', + id: '123', + name: 'test.txt', + contentType: 'text/plain', + data: Buffer.from('').toString('base64'), + }); + const body = attachmentBody(mutation); + expect(body.get('addtoattachment')).toBe('true'); + expect(await (body.get('filename') as File).text()).toBe(''); + const provider = new SdpProvider(); + const json = vi + .spyOn(provider, 'json') + .mockResolvedValue({ response_status: { status_code: 2000 } }); + await submitMutation(provider, 'token', new AbortController().signal, mutation); + expect(json.mock.calls[0]?.[0]).toContain('/requests/123/_uploads'); + expect(json.mock.calls[0]?.[2]?.body).toBeInstanceOf(FormData); + expect(json.mock.calls[0]?.[2]?.headers).not.toHaveProperty('Content-Type'); + }); + it('rejects path-like filenames, malformed bytes and cross-ticket or external download paths', () => { + const value = { + kind: 'attachment', + id: '123', + name: 'test.txt', + contentType: 'text/plain', + data: 'dGVzdA==', + }; + for (const name of ['../test', 'folder\\test', 'test\n.txt']) + expect(SdpAttachmentMutationSchema.safeParse({ ...value, name }).success).toBe(false); + expect(() => attachmentBody({ ...value, kind: 'attachment', data: '' })).toThrow(); + expect(() => attachmentBody({ ...value, kind: 'attachment', data: 'a' })).toThrow(); + expect(attachmentDownloadUrl('123', '/requests/123/_uploads/4')).toBe( + 'https://support.campingworld.com/app/itdesk/api/v3/requests/123/_uploads/4', + ); + for (const url of [ + 'https://evil.test/requests/123/_uploads/4', + '/requests/124/_uploads/4', + '/requests/123/_uploads/4?token=anything', + 'file:///tmp/private', + '/requests/123/_uploads/../secrets', + ]) + expect(() => attachmentDownloadUrl('123', url)).toThrow(); + }); + it('rechecks the authorized ticket and accepts only its listed attachment', async () => { + const provider = new SdpProvider(); + vi.spyOn(provider, 'json').mockResolvedValue({ + request: { + id: '123', + attachments: [ + { + id: '4', + name: 'test.txt', + size: 4, + content_type: 'text/plain', + content_url: '/requests/123/_uploads/4', + }, + ], + }, + }); + const binary = vi.spyOn(provider, 'binary').mockResolvedValue(Buffer.from('test')); + const signal = new AbortController().signal; + expect(await downloadAttachment(provider, 'token', signal, '123', '4')).toEqual({ + name: 'test.txt', + contentType: 'text/plain', + data: 'dGVzdA==', + }); + await expect(downloadAttachment(provider, 'token', signal, '123', '5')).rejects.toThrow(); + expect(binary).toHaveBeenCalledTimes(1); + }); + it('bounds streaming downloads and refuses redirect responses', async () => { + const fetchImpl = vi + .fn() + .mockResolvedValue( + new Response('redirect', { status: 302, headers: { Location: 'https://evil.test' } }), + ); + const provider = new SdpProvider(fetchImpl); + await expect( + provider.binary('https://support.campingworld.com', new AbortController().signal), + ).rejects.toThrow(); + expect(fetchImpl.mock.calls[0]?.[1].redirect).toBe('error'); + fetchImpl.mockResolvedValueOnce(new Response(new Uint8Array(10 * 1024 * 1024 + 1))); + await expect( + provider.binary('https://support.campingworld.com', new AbortController().signal), + ).rejects.toThrow(); + }); +}); diff --git a/src/main/sdp/SdpAttachments.ts b/src/main/sdp/SdpAttachments.ts new file mode 100644 index 00000000..6f7bc92c --- /dev/null +++ b/src/main/sdp/SdpAttachments.ts @@ -0,0 +1,77 @@ +import { + SDP_ATTACHMENT_MAX_BYTES, + SdpAttachmentSchema, + type SdpAttachment, + type SdpAttachmentUpload, + type SdpAttachmentFile, +} from '@shared/sdpAttachments'; +import { SdpProvider, SdpProviderError, isObject } from './SdpProvider'; +import { resourceHeaders } from './SdpResources'; +const API = 'https://support.campingworld.com/app/itdesk/api/v3'; +export function projectAttachments(request: Recorddb01
', + status: { name: 'Open' }, + site: { name: 'Production' }, + scheduled_start_time: { value: '1000' }, + scheduled_end_time: { value: null }, + assets: [{ name: 'db01', secret: 'hidden' }], + services: [{ name: 'Payments' }], + udf_fields: { private: 'hidden' }, + }, + ], + list_info: { has_more_rows: true }, + }); + const page = await readChanges(provider, 'token', new AbortController().signal, { + action: 'readChanges', + problemStart: 800000000, + page: 1, + }); + expect(page).toMatchObject({ + page: 1, + hasMore: true, + changes: [ + { + id: '12', + number: 'CH 12', + scheduledStart: 1000, + scheduledEnd: null, + assets: ['db01'], + services: ['Payments'], + }, + ], + }); + expect(JSON.stringify(page)).not.toContain('hidden'); + const url = new URL(json.mock.calls[0]![0]); + expect(url.pathname).toBe('/app/itdesk/api/v3/changes'); + expect(JSON.parse(url.searchParams.get('input_data')!)).toMatchObject({ + list_info: { + start_index: 51, + row_count: 50, + search_criteria: { + field: 'scheduled_start_time', + value: '195200000', + children: [{ value: '800000000' }], + }, + }, + }); + expect(json.mock.calls[0]![2]).toMatchObject({ + headers: { Authorization: 'Zoho-oauthtoken token' }, + }); +}); +it('rejects malformed records and unknown pagination rather than claiming complete coverage', async () => { + const provider = new SdpProvider(); + const json = vi.spyOn(provider, 'json'); + for (const value of [ + { changes: [] }, + { changes: [{ id: 'bad' }], list_info: { has_more_rows: false } }, + { changes: [{ id: '1', assets: {} }], list_info: { has_more_rows: false } }, + ]) { + json.mockResolvedValue(value); + await expect( + readChanges(provider, 'token', new AbortController().signal, { + action: 'readChanges', + problemStart: 10000, + page: 0, + }), + ).rejects.toThrow(); + } +}); + +it('hydrates omitted affected systems from bounded detail reads and labels incomplete coverage', async () => { + const provider = new SdpProvider(); + const start = 10000000; + const rows = Array.from({ length: 12 }, (_, i) => ({ + id: String(i + 1), + title: 'Patch', + scheduled_start_time: { value: String(start - 1000) }, + scheduled_end_time: { value: String(start + 1000) }, + })); + const json = vi.spyOn(provider, 'json').mockImplementation(async (url) => { + const id = new URL(url).pathname.split('/').at(-1)!; + if (id === 'changes') return { changes: rows, list_info: { has_more_rows: false } }; + return { + change: { + ...rows[Number(id) - 1], + assets: [{ name: 'db01.prod.test' }], + services: [{ name: 'Payments' }], + configuration_items: [{ name: 'db02.prod.test' }], + }, + }; + }); + const result = await readChanges(provider, 'token', new AbortController().signal, { + action: 'readChanges', + problemStart: start, + page: 0, + }); + expect(json).toHaveBeenCalledTimes(11); + expect(result.detailsComplete).toBe(false); + expect(result.changes[0]).toMatchObject({ + assets: ['db01.prod.test'], + services: ['Payments'], + configurationItems: ['db02.prod.test'], + }); + expect(result.changes[11]?.assets).toEqual([]); + expect( + json.mock.calls + .slice(1) + .every(([url]) => + url.startsWith('https://support.campingworld.com/app/itdesk/api/v3/changes/'), + ), + ).toBe(true); +}); +it('rejects a detail returned for another change', async () => { + const provider = new SdpProvider(); + vi.spyOn(provider, 'json') + .mockResolvedValueOnce({ + changes: [{ id: '1', scheduled_start_time: { value: '1000' } }], + list_info: { has_more_rows: false }, + }) + .mockResolvedValueOnce({ change: { id: '2' } }); + await expect( + readChanges(provider, 'token', new AbortController().signal, { + action: 'readChanges', + problemStart: 2000, + page: 0, + }), + ).rejects.toThrow(); +}); diff --git a/src/main/sdp/SdpChanges.ts b/src/main/sdp/SdpChanges.ts new file mode 100644 index 00000000..7bce87b6 --- /dev/null +++ b/src/main/sdp/SdpChanges.ts @@ -0,0 +1,141 @@ +import { + SDP_CHANGE_LOOKBACK_MS, + SDP_CHANGE_GRACE_MS, + SdpChangeRecordSchema, + type SdpChangeRecord, + SdpChangesPageSchema, + type SdpChangesCommand, + type SdpChangesPage, +} from '@shared/sdpChanges'; +import { isObject, SdpProviderError, type SdpProvider } from './SdpProvider'; +import { resourceHeaders } from './SdpResources'; + +function label(value: unknown, max = 200): string { + if (isObject(value)) return label(value.display_value ?? value.name ?? value.value, max); + return typeof value === 'string' || typeof value === 'number' ? String(value).slice(0, max) : ''; +} +function time(value: unknown): number | null { + if (!isObject(value) || value.value === null || value.value === '') return null; + const result = Number(value.value); + return Number.isSafeInteger(result) && result > 0 && result <= 8640000000000000 ? result : null; +} +function names(value: unknown): string[] { + if (value == null) return []; + if (!Array.isArray(value) || value.length > 500) throw new SdpProviderError('invalid'); + return value.map((entry) => label(entry, 500)).filter(Boolean); +} +/** Account-bound, read-only projection; never persisted in snapshots or shared collections. */ +export async function readChanges( + provider: SdpProvider, + token: string, + signal: AbortSignal, + command: SdpChangesCommand, +): PromiseUnchanged formatting
', + requester: { email_id: 'requester@example.test' }, + status: { id: '1', name: 'Open' }, + udf_fields: { txt_major_incident: [], udf_char1: 'A' }, + }, + }; + }); + return { provider, json, signal: new AbortController().signal }; +} +describe('native SDP template forms', () => { + it('scopes technician choices to associated sites and groups using the Cloud lookup keys', async () => { + const { provider, json, signal } = setup(); + const form = await readForm(provider, 'token', signal, '123'); + await readOptions( + provider, + 'token', + signal, + { + action: 'readOptions', + id: '123', + field: 'technician', + page: 0, + search: '', + dependencies: { site: { id: '3' }, group: { id: '9' } }, + }, + form, + ); + const input = JSON.parse(new URL(json.mock.lastCall![0]).searchParams.get('input_data')!); + expect(input.list_info.search_criteria).toEqual([ + { field: 'associated_sites.id', condition: 'is', value: '3', logical_operator: 'and' }, + { field: 'groups.id', condition: 'is', value: '9', logical_operator: 'and' }, + { field: 'name', condition: 'like', values: [''], logical_operator: 'and' }, + ]); + }); + it('projects only active template fields and preserves provider edit restrictions', async () => { + const { provider, signal } = setup(); + const form = await readForm(provider, 'token', signal, '123'); + expect(form.fields.find((f) => f.key === 'created_time')?.readOnly).toBe(true); + expect(form.fields.some((f) => f.key.includes('secret'))).toBe(false); + expect(form.fields.find((f) => f.key === 'status')?.choices).toEqual([ + { label: 'Open', value: { id: '1', name: 'Open' } }, + { label: 'Closed', value: { id: '2', name: 'Closed' } }, + ]); + expect(form.fields.find((f) => f.key === 'udf_fields.txt_major_incident')).toMatchObject({ + kind: 'choice', + multiple: true, + }); + }); + it('uses a fixed tenant endpoint, scoped dependencies and paginated lookup search', async () => { + const { provider, json, signal } = setup(); + const form = await readForm(provider, 'token', signal, '123'); + const command = SdpOptionsCommandSchema.parse({ + action: 'readOptions', + id: '123', + field: 'group', + page: 1, + search: 'Example', + dependencies: { site: { id: '3' } }, + }); + expect(await readOptions(provider, 'token', signal, command, form)).toMatchObject({ + hasMore: true, + choices: [{ label: 'Example group' }], + }); + const url = new URL(json.mock.lastCall![0]); + expect(url.origin).toBe('https://support.campingworld.com'); + expect(JSON.parse(url.searchParams.get('input_data')!)).toMatchObject({ + list_info: { + start_index: 51, + search_criteria: [ + { field: 'site.id', condition: 'is', value: '3' }, + { field: 'name', values: ['Example'] }, + ], + }, + }); + await expect( + readOptions( + provider, + 'token', + signal, + { ...command, dependencies: { requester: { id: '4' } } }, + form, + ), + ).rejects.toThrow(); + expect(SdpOptionsCommandSchema.safeParse({ ...command, field: '../../users' }).success).toBe( + false, + ); + }); + it('rejects read-only, unknown and invalid values before any live write', async () => { + const { provider, json, signal } = setup(); + const invalidFields: RecordHello', + is_public: true, + type: 'REQREPLY', + in_reply_to: { id: '123' }, + }, + }); + }); +}); + +it.each([401, 403, 404])( + 'loads and saves supported template fields when optional metadata returns %s', + async (status) => { + const { provider, json, signal } = setup(); + const original = json.getMockImplementation()!; + json.mockImplementation(async (...args) => { + if (new URL(args[0]).pathname.endsWith('/udf_fields')) + throw new SdpProviderError('denied', 0, 'http', status); + return original(...args); + }); + const form = await readForm(provider, 'token', signal, '123'); + expect(form).toMatchObject({ canEdit: true, metadataAvailable: false }); + expect(form.fields.find((f) => f.key === 'technician')).toMatchObject({ + kind: 'lookup', + dependencies: ['site', 'group'], + }); + expect(form.fields.find((f) => f.key === 'created_time')?.readOnly).toBe(true); + expect(form.fields.find((f) => f.key === 'udf_fields.txt_major_incident')).toMatchObject({ + multiple: true, + kind: 'choice', + }); + await submitMutation(provider, 'token', signal, { + kind: 'edit', + id: '123', + fields: { subject: 'Updated', technician: null }, + }); + expect(json.mock.lastCall![2]?.method).toBe('PUT'); + }, +); + +it('does not fall back for an outage or authorize an edit without live permissions', async () => { + const { provider, json, signal } = setup(); + const original = json.getMockImplementation()!; + json.mockImplementation(async (...args) => { + if (new URL(args[0]).pathname.endsWith('/udf_fields')) throw new SdpProviderError('outage'); + return original(...args); + }); + await expect(readForm(provider, 'token', signal, '123')).rejects.toMatchObject({ + kind: 'outage', + }); + json.mockImplementation(async (...args) => { + if (new URL(args[0]).pathname.endsWith('/_links')) return { _links: [] }; + return original(...args); + }); + await expect( + validateFormMutation(provider, 'token', signal, { + kind: 'edit', + id: '123', + fields: { subject: 'No' }, + }), + ).rejects.toThrow(); + expect(json.mock.calls.some((c) => c[2]?.method)).toBe(false); +}); + +it('uses live labels and limits, preserves date-only values and writes metadata-defined dates correctly', async () => { + const { provider, json, signal } = setup(); + const original = json.getMockImplementation()!; + json.mockImplementation(async (...args) => { + const raw = (await original(...args)) as Record
' + 'Message content '.repeat(100) + '
'; + json.mockImplementation(async (...args) => { + if (new URL(args[0]).pathname.endsWith('/123/notifications/77')) + return { notification: { id: '77', subject: 'Selected message', description: body } }; + return original(...args); + }); + const context = await readReplyContext(provider, 'token', signal, '123', true, '77'); + expect(context).toMatchObject({ to: [], cc: [], body, canReply: true }); + expect(context.subject).toContain('Selected message'); + expect(context.subject).toMatch(/^Fwd:/); + json.mockImplementation(async (...args) => { + if (new URL(args[0]).pathname.endsWith('/123/notifications/77')) + return { notification: { id: '78', description: 'Different message' } }; + return original(...args); + }); + await expect(readReplyContext(provider, 'token', signal, '123', true, '77')).rejects.toThrow(); +}); + +it('loads bounded account-scoped choices and filters technicians by the selected group', async () => { + const { provider, json, signal } = setup(); + json.mockResolvedValue({ + technician: [ + { id: '9', name: 'Example' }, + { id: '10', name: 'Deleted', deleted: true }, + ], + list_info: { has_more_rows: true }, + }); + const result = await readStandardOptions(provider, 'token', signal, { + action: 'readStandardOptions', + field: 'technician', + groupId: '4', + search: 'Example', + page: 1, + }); + const url = new URL(json.mock.lastCall![0]); + expect(url.pathname).toBe('/app/itdesk/api/v3/requests/technician'); + expect(JSON.parse(url.searchParams.get('input_data')!)).toMatchObject({ + list_info: { + start_index: 51, + row_count: 50, + search_criteria: [ + { field: 'name', values: ['Example'] }, + { field: 'groups.id', value: '4' }, + ], + }, + }); + expect(result).toEqual({ + field: 'technician', + hasMore: true, + choices: [{ label: 'Example', value: { id: '9', name: 'Example' } }], + }); + json.mockResolvedValue({ unexpected: [] }); + await expect( + readStandardOptions(provider, 'token', signal, { + action: 'readStandardOptions', + field: 'group', + search: '', + page: 0, + }), + ).rejects.toThrow(); +}); + +describe('rich-text mutation boundary', () => { + it('retains explicit clears and passes only text to HTML encoding', () => { + const html = vi.fn((value: string) => `encoded:${value}`); + expect(editedRequest({ description: null, 'resolution.content': 'fixed' }, html)).toEqual({ + description: null, + resolution: { content: 'encoded:fixed' }, + }); + expect(html).toHaveBeenCalledExactlyOnceWith('fixed'); + for (const value of [true, 123, ['text'], { id: '123' }]) { + expect(() => editedRequest({ description: value }, html)).toThrow(SdpProviderError); + } + }); +}); diff --git a/src/main/sdp/SdpForms.ts b/src/main/sdp/SdpForms.ts new file mode 100644 index 00000000..1e3a4ef0 --- /dev/null +++ b/src/main/sdp/SdpForms.ts @@ -0,0 +1,505 @@ +import { z } from 'zod'; +import { + SdpFormSchema, + SdpOptionsSchema, + SdpReplyContextSchema, + type SdpStandardOptionsCommand, + type SdpForm, + type SdpFormField, + type SdpFieldValue, +} from '@shared/sdpForm'; +import type { SdpBrokerCommand } from '@shared/sdpAccount'; +import type { SdpMutation } from '@shared/sdpMutation'; +import { scalarText, SdpProvider, SdpProviderError, isObject } from './SdpProvider'; +import { loggers } from '../logger'; +import { publicFieldInfo, readCustomFieldCatalog } from './SdpFieldCatalog'; +import { validateRelation } from './SdpTicketRelations'; +const BASE = 'https://support.campingworld.com/app/itdesk/api/v3/requests'; +const headers = (token: string) => ({ + Authorization: `Zoho-oauthtoken ${token}`, + Accept: 'application/vnd.manageengine.sdp.v3+json', +}); +export class SdpFormUnavailableError extends Error { + constructor() { + super( + 'SDP did not authorize this editor request. Your account is still connected. Cancel to return to the ticket.', + ); + } +} +const object = (v: unknown): RecordTest', + group: { name: 'NOC' }, + template: { id: SDP_DEFAULT_INCIDENT_TEMPLATE.id }, + udf_fields: { txt_major_incident: ['Yes'] }, + }, + }); + expect( + SdpMutationSchema.safeParse({ kind: 'update', id: '../anything', fields: { status: 'Open' } }) + .success, + ).toBe(false); + expect( + SdpMutationSchema.safeParse({ kind: 'update', id: '1', fields: { arbitrary: true } }).success, + ).toBe(false); + }); + it('keeps notes private unless explicitly reviewed as requester-visible', async () => { + const provider = new SdpProvider(); + const json = vi + .spyOn(provider, 'json') + .mockResolvedValue({ response_status: { status_code: 2000 } }); + await submitMutation(provider, 'token', new AbortController().signal, { + kind: 'note', + id: '123', + body: 'Internal', + showToRequester: false, + }); + const input = JSON.parse( + new URLSearchParams(json.mock.calls[0]![2]?.body as string).get('input_data')!, + ); + expect(input.request_note).toMatchObject({ + show_to_requester: false, + notify_technician: false, + add_to_linked_requests: false, + }); + }); + it('preserves full-length subjects and only checks Major Incident for an explicit major create', async () => { + const provider = new SdpProvider(); + const json = vi.spyOn(provider, 'json').mockResolvedValue({ + response_status: { status_code: 2000 }, + request: { id: '123' }, + }); + const subject = 'A'.repeat(250); + for (const majorIncident of [true, false]) { + const mutation = SdpMutationSchema.parse({ + kind: 'create', + fields: { subject }, + majorIncident, + }); + await submitMutation(provider, 'token', new AbortController().signal, mutation); + const input = JSON.parse( + new URLSearchParams(json.mock.lastCall![2]?.body as string).get('input_data')!, + ); + expect(input.request.subject).toBe(subject); + expect(input.request.udf_fields).toEqual( + majorIncident ? { txt_major_incident: ['Yes'] } : undefined, + ); + expect(input.request.template).toEqual( + majorIncident ? { id: SDP_DEFAULT_INCIDENT_TEMPLATE.id } : undefined, + ); + } + expect( + SdpMutationSchema.safeParse({ + kind: 'create', + fields: { subject }, + majorIncident: true, + templateId: '42', + }).success, + ).toBe(false); + }); +}); + +it('forwards with explicit recipients, private visibility and the Cloud forward type', async () => { + const provider = new SdpProvider(); + const json = vi.spyOn(provider, 'json').mockImplementation(async (url, _signal, init) => { + if (init?.method) return { response_status: { status_code: 2000 } }; + if (url.includes('/notifications/_links')) return { _links: [{ name: 'add', method: 'post' }] }; + return { + request: { + id: '123', + subject: 'Synthetic', + requester: { email_id: 'requester@example.test' }, + }, + }; + }); + await submitMutation(provider, 'token', new AbortController().signal, { + kind: 'forward', + id: '123', + to: ['recipient@example.test'], + cc: [], + bcc: [], + subject: 'Fwd: Synthetic', + body: '', + isPublic: false, + }); + const call = json.mock.calls.find((c) => c[2]?.method)!; + expect(call[0]).toMatch(/\/requests\/123\/notifications$/); + expect( + JSON.parse(new URLSearchParams(call[2]!.body as string).get('input_data')!).notification, + ).toMatchObject({ + type: 'REQFORWARD', + in_reply_to: { id: '123' }, + to: ['recipient@example.test'], + is_public: false, + description: '<script>not executable</script>', + }); +}); diff --git a/src/main/sdp/SdpMutations.ts b/src/main/sdp/SdpMutations.ts new file mode 100644 index 00000000..eece7d45 --- /dev/null +++ b/src/main/sdp/SdpMutations.ts @@ -0,0 +1,222 @@ +import { editedRequest, validateFormMutation } from './SdpForms'; +import type { SdpForm } from '@shared/sdpForm'; +import { attachmentBody } from './SdpAttachments'; +import { createHash } from 'node:crypto'; +import { relationBaseline } from './SdpTicketRelations'; +import { + SDP_DEFAULT_INCIDENT_TEMPLATE, + type SdpMutation, + type SdpChangeResult, + type SdpRequestFields, +} from '@shared/sdpMutation'; +import { + scalarText, + SdpProvider, + SdpProviderError, + SdpValidationError, + validationFields, +} from './SdpProvider'; + +import { resourceBaseline, resourceInput, resourcePath } from './SdpResources'; +const BASE = 'https://support.campingworld.com/app/itdesk/api/v3/requests'; +const object = (value: unknown): value is Record
'); +function requestFields(fields: SdpRequestFields): Record
'); +function encode(value: string, codec: Codec): unknown { + switch (codec) { + case 'reminderMinutes': + return { minutes: Number(value) }; + case 'name': + return { name: value }; + case 'email': + return { email_id: value }; + case 'id': + return { id: value }; + case 'date': + return { value: String(Date.parse(value)) }; + case 'value': + return { value }; + case 'html': + return html(value); + case 'boolean': + return value === 'true'; + default: + return value; + } +} +export function resourceInput(value: SdpResourceMutation): Record
+ {!isPopout && (
+
+
+ )}
@@ -456,6 +525,8 @@ export function MainApp({
setTicketBridge(undefined)}
groups={data.groups}
contacts={data.contacts}
onCall={data.onCall}
@@ -528,6 +599,7 @@ export function MainApp({
)}
+ {mountedTabs.has('Tickets') && (
+
+
+
+
+ )}
{mountedTabs.has('Radar') && (
@@ -605,9 +686,11 @@ export function MainApp({
-
-
+ {!isPopout && (
+
+
+ )}
{!isPopout && (
diff --git a/src/renderer/src/__tests__/App.test.tsx b/src/renderer/src/__tests__/App.test.tsx
index 8c57a418..23db8e9a 100644
--- a/src/renderer/src/__tests__/App.test.tsx
+++ b/src/renderer/src/__tests__/App.test.tsx
@@ -131,6 +131,15 @@ vi.mock('../components/Toast', () => ({
useToast: () => ({ showToast: mockShowToast }),
}));
+vi.mock('../features/notifications/NotificationProvider', () => ({
+ NotificationProvider: ({ children }: { children: React.ReactNode }) => <>{children},
+ useOperationalToast: () => mockShowToast,
+ NOTIFICATION_NAVIGATION_EVENT: 'relay:notification-navigation',
+}));
+vi.mock('../features/notifications/NotificationCenter', () => ({
+ NotificationCenter: () => ,
+}));
+
// ── mock heavy sub-components ────────────────────────────────────────────────
vi.mock('../components/Sidebar', () => ({
Sidebar: ({
@@ -896,13 +905,14 @@ describe('MainApp', () => {
['4', 'Knowledge'],
['5', 'Status'],
['6', 'Problems'],
+ ['8', 'Tickets'],
])('navigates on Cmd+%s to %s', (key, destination) => {
renderApp();
fireEvent.keyDown(window, { key, metaKey: true });
expect(mockSetActiveTab).toHaveBeenCalledWith(destination);
});
- it.each(['8', '9'])('does not assign Cmd+%s', (key) => {
+ it.each(['9'])('does not assign Cmd+%s', (key) => {
renderApp();
fireEvent.keyDown(window, { key, metaKey: true });
expect(mockSetActiveTab).not.toHaveBeenCalled();
diff --git a/src/renderer/src/components/DynatraceProblemNotificationManager.tsx b/src/renderer/src/components/DynatraceProblemNotificationManager.tsx
index 7e04e2a4..158465d7 100644
--- a/src/renderer/src/components/DynatraceProblemNotificationManager.tsx
+++ b/src/renderer/src/components/DynatraceProblemNotificationManager.tsx
@@ -6,7 +6,7 @@ import {
type DynatraceProblemSeverity,
} from '@shared/dynatraceProblems';
import { useCollection } from '../hooks/useCollection';
-import { useToast } from './Toast';
+import { useOperationalToast } from '../features/notifications/NotificationProvider';
const SEVERITY_ORDER: Record = {
AVAILABILITY: 0,
@@ -41,7 +41,7 @@ function notificationMessage(problems: DynatraceProblemRecord[]): string {
export function DynatraceProblemNotificationManager({
onOpenProblems,
}: Readonly<{ onOpenProblems: () => void }>) {
- const { showToast } = useToast();
+ const showToast = useOperationalToast('Problems');
const { data: problems, loading } = useCollection(
DYNATRACE_PROBLEMS_COLLECTION,
{ sort: '-startTime', filter: 'scopeExcluded=false && status="OPEN"' },
@@ -65,7 +65,6 @@ export function DynatraceProblemNotificationManager({
delivery: 'dynatrace-problem',
action: { label: 'Open Problems', onClick: onOpenProblems },
});
- void globalThis.api?.playAlertSound?.().catch(() => undefined);
}, [onOpenProblems, showToast]);
useEffect(() => {
diff --git a/src/renderer/src/components/RadarQueueNotificationManager.tsx b/src/renderer/src/components/RadarQueueNotificationManager.tsx
index 70eb4526..509e5c6e 100644
--- a/src/renderer/src/components/RadarQueueNotificationManager.tsx
+++ b/src/renderer/src/components/RadarQueueNotificationManager.tsx
@@ -1,7 +1,7 @@
import { useEffect, useRef } from 'react';
import type { RadarSnapshot, RadarStatusColor } from '@shared/ipc';
import { useRadarSnapshot } from '../hooks/useRadarSnapshot';
-import { useToast } from './Toast';
+import { useOperationalToast } from '../features/notifications/NotificationProvider';
export type RadarTargetKey = 'prod01' | 'prod02' | 'transactionalEmails';
@@ -71,7 +71,7 @@ export function RadarQueueNotificationManager({
onOpenRadar,
}: Readonly<{ onOpenRadar: () => void }>) {
const { snapshot } = useRadarSnapshot();
- const { showToast } = useToast();
+ const showToast = useOperationalToast('Radar');
const previousTonesRef = useRef | null>(null);
useEffect(() => {
diff --git a/src/renderer/src/components/ShortcutsModal.tsx b/src/renderer/src/components/ShortcutsModal.tsx
index 37dc3f27..4fff579d 100644
--- a/src/renderer/src/components/ShortcutsModal.tsx
+++ b/src/renderer/src/components/ShortcutsModal.tsx
@@ -19,6 +19,7 @@ function getShortcuts(modKey: string, isWeb: boolean) {
{ keys: `${modKey} + 5`, description: 'Go to Service Status' },
{ keys: `${modKey} + 6`, description: 'Go to Dynatrace Problems' },
{ keys: `${modKey} + 7`, description: 'Go to Dispatcher Radar' },
+ { keys: `${modKey} + 8`, description: 'Go to Tickets' },
],
},
{
diff --git a/src/renderer/src/components/Sidebar.tsx b/src/renderer/src/components/Sidebar.tsx
index a379d8b7..812bd5ec 100644
--- a/src/renderer/src/components/Sidebar.tsx
+++ b/src/renderer/src/components/Sidebar.tsx
@@ -41,6 +41,24 @@ const navItems: { label: string; tab: TabName; icon: React.ReactNode }[] = [
{ label: 'Status', tab: 'Status', icon: = ({
diff --git a/src/renderer/src/components/Toast.tsx b/src/renderer/src/components/Toast.tsx
index 26692940..54bfb225 100644
--- a/src/renderer/src/components/Toast.tsx
+++ b/src/renderer/src/components/Toast.tsx
@@ -12,7 +12,12 @@ import { createClientId } from '../utils/clientId';
export type ToastType = 'success' | 'error' | 'info' | 'warning';
export type ToastDelivery =
- 'routine' | 'cloud-degradation' | 'cloud-outage' | 'radar-critical' | 'dynatrace-problem';
+ | 'routine'
+ | 'ticket'
+ | 'cloud-degradation'
+ | 'cloud-outage'
+ | 'radar-critical'
+ | 'dynatrace-problem';
export type ToastOptions = {
title?: string;
@@ -36,6 +41,7 @@ interface ToastMessage {
interface ToastContextType {
showToast: ShowToast;
+ dismissDelivery?: (delivery: ToastDelivery) => void;
}
type ToastAction =
@@ -54,6 +60,7 @@ function isOperationalToast(toast: ToastMessage): boolean {
function deliveryPriority(delivery: ToastDelivery): number {
switch (delivery) {
+ case 'ticket':
case 'dynatrace-problem':
return 4;
case 'radar-critical':
@@ -122,6 +129,7 @@ function findNextOperationalId(toasts: ToastMessage[]): string | null {
const queued = toasts.filter((toast) => toast.state === 'queued');
return (
queued.find((toast) => deliveryOf(toast) === 'dynatrace-problem')?.id ??
+ queued.find((toast) => deliveryOf(toast) === 'ticket')?.id ??
queued.find((toast) => deliveryOf(toast) === 'radar-critical')?.id ??
queued.find((toast) => deliveryOf(toast) === 'cloud-outage')?.id ??
queued.find((toast) => deliveryOf(toast) === 'cloud-degradation')?.id ??
@@ -271,7 +279,17 @@ export const ToastProvider: React.FC<{ children: ReactNode }> = ({ children }) =
};
}, []);
- const toastContextValue = useMemo(() => ({ showToast }), [showToast]);
+ const dismissDelivery = useCallback(
+ (delivery: ToastDelivery) => {
+ for (const toast of toastsRef.current)
+ if (deliveryOf(toast) === delivery) finalizeToastRemoval(toast.id);
+ },
+ [finalizeToastRemoval],
+ );
+ const toastContextValue = useMemo(
+ () => ({ showToast, dismissDelivery }),
+ [showToast, dismissDelivery],
+ );
const visibleToasts = toasts.filter((toast) => toast.state !== 'queued');
const orderedToasts = [
...visibleToasts.filter(isOperationalToast),
diff --git a/src/renderer/src/components/__tests__/Sidebar.test.tsx b/src/renderer/src/components/__tests__/Sidebar.test.tsx
index 3dd2699f..473339a3 100644
--- a/src/renderer/src/components/__tests__/Sidebar.test.tsx
+++ b/src/renderer/src/components/__tests__/Sidebar.test.tsx
@@ -93,7 +93,7 @@ describe('Sidebar', () => {
Reflect.deleteProperty(globalThis as Record, 'api');
});
- it('renders all seven shared destinations in their shortcut order', () => {
+ it('renders all eight shared destinations in their shortcut order', () => {
stubRuntime('web');
const { container } = render(
+
Local-only maintenance boundary
diff --git a/src/renderer/src/components/settings/administration/SdpServerSettings.test.tsx b/src/renderer/src/components/settings/administration/SdpServerSettings.test.tsx
new file mode 100644
index 00000000..3cd8f9ff
--- /dev/null
+++ b/src/renderer/src/components/settings/administration/SdpServerSettings.test.tsx
@@ -0,0 +1,46 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import type { BridgeAPI } from '@shared/ipc';
+import { SdpServerSettings } from './SdpServerSettings';
+const original = globalThis.api;
+afterEach(() => {
+ globalThis.api = original;
+});
+it('keeps setup in server administration and clears the submitted secret after saving', async () => {
+ const invoke = vi.fn().mockResolvedValue({
+ success: true,
+ data: {
+ configured: false,
+ revision: '',
+ cacheMinutes: 60,
+ gatewayEnabled: true,
+ gatewayPort: 8091,
+ },
+ });
+ globalThis.api = { ...original, sdpServer: invoke } as BridgeAPI;
+ render(();
+ const [clientId, setClientId] = useState('');
+ const [clientSecret, setClientSecret] = useState('');
+ const [minutes, setMinutes] = useState(60);
+ const [busy, setBusy] = useState(false);
+ const [feedback, setFeedback] = useState('');
+ const invoke = globalThis.api?.sdpServer;
+ useEffect(() => {
+ let active = true;
+ if (invoke)
+ void invoke({ action: 'status' })
+ .then((result) => {
+ if (!active) return;
+ if (result.success && result.data) {
+ setView(result.data);
+ setMinutes(result.data.cacheMinutes);
+ } else setFeedback(result.error ?? 'Open these settings on the Relay server computer.');
+ })
+ .catch(() => {
+ if (active) setFeedback('Server settings are unavailable.');
+ });
+ return () => {
+ active = false;
+ };
+ }, [invoke]);
+ async function run(command: SdpServerCommand) {
+ setBusy(true);
+ setFeedback('');
+ try {
+ const result = await invoke!(command);
+ if (!result.success || !result.data)
+ throw new Error(result.error ?? 'Could not save SDP settings.');
+ setView(result.data);
+ setMinutes(result.data.cacheMinutes);
+ setClientId('');
+ setClientSecret('');
+ setFeedback(
+ command.action === 'clear'
+ ? 'SDP disconnected. Saved copies removed.'
+ : 'Server setup saved. Users can connect their work accounts.',
+ );
+ } catch (error) {
+ setFeedback(error instanceof Error ? error.message : 'SDP settings unavailable.');
+ } finally {
+ setBusy(false);
+ }
+ }
+ return (
+
+ ServiceDesk Plus
+
+ );
+}
diff --git a/src/renderer/src/features/notifications/NotificationCenter.test.tsx b/src/renderer/src/features/notifications/NotificationCenter.test.tsx
new file mode 100644
index 00000000..b5f2dc75
--- /dev/null
+++ b/src/renderer/src/features/notifications/NotificationCenter.test.tsx
@@ -0,0 +1,103 @@
+import { act, cleanup, fireEvent, render, screen, within } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { NotificationCenter } from './NotificationCenter';
+import { NotificationProvider, useNotifications } from './NotificationProvider';
+
+vi.mock('../../services/pocketbase', () => ({ getPb: () => ({ baseURL: 'http://center.test' }) }));
+vi.mock('../../components/Toast', () => ({ useToast: () => ({ showToast: vi.fn() }) }));
+vi.mock('../tickets/SdpAlerts', () => ({
+ useSdpAlerts: () => ({ attention: false }),
+ SdpAlertControls: () => ,
+}));
+let state: NonNullable>;
+function Capture() {
+ state = useNotifications()!;
+ return
+ ,
+ );
+}
+beforeEach(() => localStorage.clear());
+afterEach(() => {
+ cleanup();
+ vi.useRealTimers();
+});
+
+it('labels severity, scopes both bulk actions to the source, and offers Undo', () => {
+ setup();
+ act(() => {
+ state.publish({
+ id: 'problem',
+ source: 'Problems',
+ title: 'Problem event',
+ message: 'Review problem',
+ type: 'error',
+ target: { source: 'Problems' },
+ });
+ state.publish({
+ id: 'radar',
+ source: 'Radar',
+ title: 'Radar event',
+ message: 'Review Radar',
+ type: 'warning',
+ target: { source: 'Radar' },
+ });
+ });
+ fireEvent.click(screen.getByRole('button', { name: /Notifications/ }));
+ expect(screen.getByRole('button', { name: /Problem event/ })).toHaveTextContent('Error');
+ expect(screen.getByRole('button', { name: /Radar event/ })).toHaveTextContent('Warning');
+ fireEvent.click(screen.getByRole('button', { name: 'Radar' }));
+ fireEvent.click(screen.getByRole('button', { name: 'Mark radar read' }));
+ expect(state.notices.find((n) => n.id === 'problem')?.read).toBe(false);
+ expect(screen.getByRole('button', { name: 'Mark radar read' })).toBeDisabled();
+ fireEvent.click(screen.getByRole('button', { name: 'Clear radar' }));
+ expect(screen.queryByRole('button', { name: /Radar event/ })).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole('button', { name: 'Undo clear' }));
+ expect(screen.getByRole('button', { name: /Radar event/ })).toBeInTheDocument();
+});
+it('shows persistent snooze and quiet status and updates at their time boundaries', () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date(2026, 8, 19, 22, 59));
+ setup();
+ act(() =>
+ state.savePreferences({
+ ...state.preferences,
+ snoozeUntil: Date.now() + 30000,
+ quietHoursEnabled: true,
+ quietStart: '22:00',
+ quietEnd: '23:00',
+ }),
+ );
+ expect(screen.getByRole('button', { name: /Notifications.*Snoozed/ })).toBeInTheDocument();
+ act(() => {
+ vi.advanceTimersByTime(30000);
+ });
+ expect(screen.getByRole('button', { name: /Notifications.*Quiet hours/ })).toBeInTheDocument();
+ act(() => {
+ vi.advanceTimersByTime(30000);
+ });
+ expect(screen.getByRole('button', { name: 'Notifications' })).toBeInTheDocument();
+});
+it('collapses per-source options and preserves times when quiet hours are toggled', () => {
+ setup();
+ fireEvent.click(screen.getByRole('button', { name: 'Notifications' }));
+ fireEvent.click(screen.getByRole('button', { name: 'Preferences' }));
+ const summary = screen.getByText('Tickets', { selector: 'summary' });
+ expect(summary.closest('details')).not.toHaveAttribute('open');
+ fireEvent.click(summary);
+ expect(
+ within(summary.closest('details')!).getByRole('button', { name: 'Ticket rules' }),
+ ).toBeVisible();
+ const toggle = screen.getByRole('checkbox', { name: 'Enable quiet hours' });
+ expect(toggle).not.toBeChecked();
+ fireEvent.click(toggle);
+ fireEvent.change(screen.getByLabelText('Quiet hours start'), { target: { value: '21:30' } });
+ fireEvent.click(toggle);
+ expect(screen.getByLabelText('Quiet hours start')).toBeDisabled();
+ fireEvent.click(toggle);
+ expect(screen.getByLabelText('Quiet hours start')).toHaveValue('21:30');
+});
diff --git a/src/renderer/src/features/notifications/NotificationCenter.tsx b/src/renderer/src/features/notifications/NotificationCenter.tsx
new file mode 100644
index 00000000..18380a0a
--- /dev/null
+++ b/src/renderer/src/features/notifications/NotificationCenter.tsx
@@ -0,0 +1,401 @@
+import { useEffect, useState } from 'react';
+import { quietNow } from '@shared/serviceDesk';
+import {
+ NOTIFICATION_SOURCES,
+ type NotificationPreferences,
+ type NotificationSource,
+} from '@shared/notifications';
+import { Modal } from '../../components/Modal';
+import { TactileButton } from '../../components/TactileButton';
+import { useSdpAlerts, SdpAlertControls } from '../tickets/SdpAlerts';
+import { TicketNotificationRules } from '../tickets/TicketNotifications';
+import { openNotificationTarget, useNotifications } from './NotificationProvider';
+import '../tickets/tickets.css';
+import './notifications.css';
+
+function useInterruptionStatus(preferences?: NotificationPreferences) {
+ const [now, setNow] = useState(Date.now);
+ const snoozeUntil = preferences?.snoozeUntil ?? 0;
+ useEffect(() => {
+ const remaining = snoozeUntil - Date.now();
+ const timer = setTimeout(
+ () => setNow(Date.now()),
+ Math.min(60000 - (Date.now() % 60000), remaining > 0 ? remaining : Infinity),
+ );
+ return () => clearTimeout(timer);
+ }, [now, snoozeUntil]);
+ const snoozed = snoozeUntil > now;
+ const quiet =
+ !!preferences?.quietHoursEnabled &&
+ quietNow(
+ {
+ ...preferences,
+ snoozeUntil: 0,
+ rules: [],
+ warningMinutes: 30,
+ },
+ now,
+ );
+ let pauseLabel = quiet ? 'Quiet hours' : '';
+ if (snoozed) pauseLabel = 'Snoozed';
+ return { snoozed, quiet, pauseLabel };
+}
+
+export function NotificationCenter() {
+ const notifications = useNotifications();
+ const sdp = useSdpAlerts();
+ const [open, setOpen] = useState(false);
+ const [rules, setRules] = useState(false);
+ const [section, setSection] = useState<'Inbox' | 'Preferences'>('Inbox');
+ const [source, setSource] = useState('All');
+ const { snoozed, quiet, pauseLabel } = useInterruptionStatus(notifications?.preferences);
+ if (!notifications) return null;
+ const {
+ notices,
+ preferences,
+ savePreferences,
+ storageError,
+ markRead,
+ clear,
+ undoClear,
+ clearedCount,
+ } = notifications;
+ const unread = notices.filter((notice) => !notice.read).length;
+ const visible = notices.filter((notice) => source === 'All' || notice.source === source);
+ const desktop = globalThis.api?.runtime.kind === 'electron';
+ return (
+ <>
+ setOpen(true)}
+ >
+ Notifications{unread > 0 ? ` (${unread} unread)` : ''}
+ {pauseLabel && · {pauseLabel}}
+ {sdp.attention && !}
+
+ {rules && (
+ {
+ setRules(false);
+ setOpen(true);
+ }}
+ />
+ )}
+ {open && (
+ setOpen(false)}
+ footer={
+ <>
+
+ savePreferences({
+ ...preferences,
+ snoozeUntil: snoozed ? 0 : Date.now() + 3600000,
+ })
+ }
+ >
+ {snoozed ? 'Resume alerts' : 'Snooze 1h'}
+
+ setOpen(false)}>
+ Done
+
+
+ }
+ >
+
+ {snoozed && (
+
+ )}
+
+ );
+}
diff --git a/src/renderer/src/features/notifications/NotificationProvider.test.tsx b/src/renderer/src/features/notifications/NotificationProvider.test.tsx
new file mode 100644
index 00000000..06609ab2
--- /dev/null
+++ b/src/renderer/src/features/notifications/NotificationProvider.test.tsx
@@ -0,0 +1,244 @@
+import { act, cleanup, render } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import {
+ NotificationProvider,
+ useNotifications,
+ type NotificationInput,
+} from './NotificationProvider';
+import { TICKET_NAVIGATION_EVENT } from '../tickets/ticketNavigation';
+const mocks = vi.hoisted(() => ({
+ toast: vi.fn(),
+ sound: vi.fn(async () => true),
+ desktop: vi.fn(async () => true),
+}));
+vi.mock('../../components/Toast', () => ({ useToast: () => ({ showToast: mocks.toast }) }));
+vi.mock('../../services/pocketbase', () => ({
+ getPb: () => ({ baseURL: 'http://notifications.test' }),
+}));
+const original = globalThis.api;
+let state: NonNullable>;
+function Capture() {
+ state = useNotifications()!;
+ return null;
+}
+function setup() {
+ return render(
+
+ ,
+ );
+}
+const notice: NotificationInput = {
+ id: 'reply-1',
+ source: 'Tickets',
+ title: 'Ticket #42',
+ message: 'New reply',
+ type: 'info',
+ target: { source: 'Tickets', ticketId: '123' },
+ sound: true,
+ options: { delivery: 'ticket' },
+};
+beforeEach(() => {
+ vi.clearAllMocks();
+ localStorage.clear();
+ globalThis.api = {
+ runtime: { kind: 'electron' },
+ playAlertSound: mocks.sound,
+ notifyTicket: mocks.desktop,
+ } as never;
+});
+afterEach(() => {
+ cleanup();
+ globalThis.api = original;
+ vi.useRealTimers();
+});
+it('deduplicates delivery, keeps a session inbox, and opens the exact ticket from a banner', () => {
+ const navigate = vi.fn();
+ window.addEventListener(TICKET_NAVIGATION_EVENT, navigate);
+ setup();
+ act(() => {
+ state.publish(notice);
+ state.publish(notice);
+ });
+ expect(state.notices).toHaveLength(1);
+ expect(mocks.toast).toHaveBeenCalledOnce();
+ expect(mocks.sound).toHaveBeenCalledOnce();
+ act(() => {
+ void mocks.toast.mock.calls[0]![2].action.onClick();
+ });
+ expect(state.notices[0]!.read).toBe(true);
+ expect(navigate.mock.calls[0]![0].detail).toMatchObject({
+ destination: 'ticket',
+ ticketId: '123',
+ });
+ expect(localStorage.getItem('relay:notifications:http://notifications.test')).toBeNull();
+ window.removeEventListener(TICKET_NAVIGATION_EVENT, navigate);
+});
+it('records all sources during snooze without banners, desktop notifications or sounds', () => {
+ setup();
+ act(() =>
+ state.savePreferences({ ...state.preferences, desktop: true, snoozeUntil: Date.now() + 60000 }),
+ );
+ act(() => {
+ state.publish(notice);
+ state.publish({ ...notice, id: 'radar-1', source: 'Radar', target: { source: 'Radar' } });
+ });
+ expect(state.notices).toHaveLength(2);
+ expect(mocks.toast).not.toHaveBeenCalled();
+ expect(mocks.desktop).not.toHaveBeenCalled();
+ expect(mocks.sound).not.toHaveBeenCalled();
+});
+it('applies shared quiet hours across midnight and resumes delivery after the interval', () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date(2026, 8, 19, 23, 30));
+ setup();
+ act(() =>
+ state.savePreferences({
+ ...state.preferences,
+ quietHoursEnabled: true,
+ quietStart: '22:00',
+ quietEnd: '07:00',
+ }),
+ );
+ act(() => state.publish(notice));
+ expect(mocks.toast).not.toHaveBeenCalled();
+ vi.setSystemTime(new Date(2026, 8, 20, 8, 0));
+ act(() => state.publish({ ...notice, id: 'reply-2' }));
+ expect(mocks.toast).toHaveBeenCalledOnce();
+});
+it('keeps quiet-hour times when disabled and continues delivery', () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date(2026, 8, 19, 23, 30));
+ setup();
+ act(() =>
+ state.savePreferences({
+ ...state.preferences,
+ quietHoursEnabled: false,
+ quietStart: '22:00',
+ quietEnd: '07:00',
+ }),
+ );
+ act(() => state.publish(notice));
+ expect(mocks.toast).toHaveBeenCalledOnce();
+ expect(state.preferences.quietStart).toBe('22:00');
+});
+it('honors quiet hours saved before the explicit toggle existed', () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date(2026, 8, 19, 23, 30));
+ const first = setup();
+ const legacy = { ...state.preferences, quietHoursEnabled: undefined };
+ localStorage.setItem(
+ 'relay:notifications:http://notifications.test',
+ JSON.stringify({ ...legacy, quietStart: '22:00', quietEnd: '07:00' }),
+ );
+ first.unmount();
+ setup();
+ act(() => state.publish(notice));
+ expect(mocks.toast).not.toHaveBeenCalled();
+});
+it('scopes mark-read and clear, restores without redelivery, and retains new entries', () => {
+ setup();
+ act(() => {
+ state.publish({ ...notice, at: 1 });
+ state.publish({ ...notice, id: 'radar', at: 2, source: 'Radar', target: { source: 'Radar' } });
+ });
+ act(() => state.markRead(undefined, 'Radar'));
+ expect(state.notices.find((n) => n.id === notice.id)?.read).toBe(false);
+ act(() => state.clear('Radar', true));
+ expect(state.clearedCount).toBe(1);
+ act(() => state.publish({ ...notice, id: 'new', at: 3 }));
+ mocks.toast.mockClear();
+ act(() => state.undoClear());
+ expect(state.notices.map((n) => n.id)).toEqual(['new', 'radar', 'reply-1']);
+ expect(state.notices[1]?.read).toBe(true);
+ expect(state.clearedCount).toBe(0);
+ expect(mocks.toast).not.toHaveBeenCalled();
+});
+it('never restores ticket notices purged by sign-out or an account reset', () => {
+ setup();
+ act(() => {
+ state.publish(notice);
+ state.publish({ ...notice, id: 'radar', source: 'Radar', target: { source: 'Radar' } });
+ });
+ act(() => state.clear(undefined, true));
+ act(() => state.clear('Tickets'));
+ act(() => state.undoClear());
+ expect(state.notices.map((n) => n.source)).toEqual(['Radar']);
+});
+it('preserves rule channel choices and filters sources without changing other sources', () => {
+ setup();
+ act(() =>
+ state.savePreferences({
+ ...state.preferences,
+ desktop: true,
+ sources: {
+ ...state.preferences.sources,
+ Radar: { ...state.preferences.sources.Radar, warning: false },
+ },
+ }),
+ );
+ act(() => {
+ state.publish({ ...notice, toast: false, desktop: false, sound: false });
+ state.publish({
+ ...notice,
+ id: 'radar-2',
+ type: 'warning',
+ source: 'Radar',
+ target: { source: 'Radar' },
+ });
+ });
+ expect(state.notices).toHaveLength(1);
+ expect(mocks.toast).not.toHaveBeenCalled();
+ expect(mocks.desktop).not.toHaveBeenCalled();
+ act(() =>
+ state.publish({
+ ...notice,
+ id: 'problem-1',
+ source: 'Problems',
+ target: { source: 'Problems' },
+ }),
+ );
+ act(() => state.clear('Tickets'));
+ expect(state.notices.map((n) => n.source)).toEqual(['Problems']);
+ expect(mocks.desktop).toHaveBeenCalledWith(
+ expect.objectContaining({
+ body: 'New activity needs attention. Open Relay to review.',
+ target: { source: 'Problems' },
+ }),
+ );
+});
+it('keeps desktop capabilities unavailable to the browser and bounds inbox history', () => {
+ globalThis.api = {
+ runtime: { kind: 'web' },
+ playAlertSound: mocks.sound,
+ notifyTicket: mocks.desktop,
+ } as never;
+ setup();
+ act(() => state.savePreferences({ ...state.preferences, desktop: true, toast: false }));
+ act(() => {
+ for (let i = 0; i < 205; i++) state.publish({ ...notice, id: `n-${i}` });
+ });
+ expect(state.notices).toHaveLength(200);
+ expect(mocks.desktop).not.toHaveBeenCalled();
+ expect(mocks.sound).not.toHaveBeenCalled();
+});
+it('validates native notification navigation and unregisters its listener', () => {
+ let callback: (value: unknown) => void = () => {};
+ const off = vi.fn();
+ globalThis.api!.onNotificationClick = ((cb: typeof callback) => {
+ callback = cb;
+ return off;
+ }) as never;
+ const navigate = vi.fn();
+ window.addEventListener(TICKET_NAVIGATION_EVENT, navigate);
+ const view = setup();
+ act(() => state.publish(notice));
+ act(() => callback({ source: 'Tickets', ticketId: 'javascript:bad' }));
+ expect(navigate).not.toHaveBeenCalled();
+ act(() => callback({ source: 'Tickets', ticketId: '123' }));
+ expect(navigate).toHaveBeenCalledOnce();
+ expect(state.notices[0]!.read).toBe(true);
+ view.unmount();
+ expect(off).toHaveBeenCalledOnce();
+ window.removeEventListener(TICKET_NAVIGATION_EVENT, navigate);
+});
diff --git a/src/renderer/src/features/notifications/NotificationProvider.tsx b/src/renderer/src/features/notifications/NotificationProvider.tsx
new file mode 100644
index 00000000..e2a56167
--- /dev/null
+++ b/src/renderer/src/features/notifications/NotificationProvider.tsx
@@ -0,0 +1,283 @@
+import {
+ createContext,
+ useCallback,
+ useContext,
+ useEffect,
+ useMemo,
+ useRef,
+ useState,
+ type PropsWithChildren,
+} from 'react';
+import {
+ defaultNotificationPreferences,
+ NotificationPreferencesSchema,
+ NotificationTargetSchema,
+ type NotificationPreferences,
+ type NotificationSource,
+ type NotificationTarget,
+} from '@shared/notifications';
+import { quietNow, TicketPreferencesSchema } from '@shared/serviceDesk';
+import {
+ useToast,
+ type ShowToast,
+ type ToastOptions,
+ type ToastType,
+} from '../../components/Toast';
+import { getPb } from '../../services/pocketbase';
+import { createClientId } from '../../utils/clientId';
+import { navigateTicketWorkspace } from '../tickets/ticketNavigation';
+
+export const NOTIFICATION_NAVIGATION_EVENT = 'relay:notification-navigation';
+export function openNotificationTarget(target: NotificationTarget): void {
+ if (target.source === 'Tickets') {
+ navigateTicketWorkspace({ destination: 'ticket', source: 'sdp', ticketId: target.ticketId });
+ } else window.dispatchEvent(new CustomEvent(NOTIFICATION_NAVIGATION_EVENT, { detail: target }));
+}
+export type NotificationInput = {
+ id?: string;
+ source: NotificationSource;
+ title: string;
+ message: string;
+ type: ToastType;
+ target: NotificationTarget;
+ at?: number;
+ inbox?: boolean;
+ toast?: boolean;
+ desktop?: boolean;
+ sound?: boolean;
+ interrupt?: boolean;
+ options?: ToastOptions;
+};
+export type RelayNotice = NotificationInput & { id: string; at: number; read: boolean };
+type NotificationContextValue = {
+ notices: RelayNotice[];
+ preferences: NotificationPreferences;
+ savePreferences: (next: NotificationPreferences) => void;
+ storageError: string;
+ publish: (input: NotificationInput) => void;
+ markRead: (id?: string, source?: NotificationSource) => void;
+ clear: (source?: NotificationSource, undoable?: boolean) => void;
+ undoClear: () => void;
+ clearedCount: number;
+};
+const NotificationContext = createContext(undefined);
+export const useNotifications = () => useContext(NotificationContext);
+
+export function NotificationProvider({ children }: Readonly) {
+ const { showToast, dismissDelivery } = useToast();
+ const storageKey = `relay:notifications:${getPb().baseURL}`;
+ const [preferences, setPreferences] = useState(() => {
+ try {
+ return NotificationPreferencesSchema.parse(
+ JSON.parse(localStorage.getItem(storageKey) ?? 'null'),
+ );
+ } catch {
+ const defaults = defaultNotificationPreferences();
+ try {
+ const old = TicketPreferencesSchema.parse(
+ JSON.parse(localStorage.getItem(`relay:sdp-alert-rules:${getPb().baseURL}`) ?? 'null'),
+ );
+ return {
+ ...defaults,
+ quietHoursEnabled: !!old.quietStart && !!old.quietEnd,
+ quietStart: old.quietStart,
+ quietEnd: old.quietEnd,
+ snoozeUntil: old.snoozeUntil,
+ };
+ } catch {
+ return defaults;
+ }
+ }
+ });
+ const [{ notices, cleared }, setInbox] = useState<{
+ notices: RelayNotice[];
+ cleared: RelayNotice[];
+ }>({ notices: [], cleared: [] });
+ const setNotices = useCallback((update: (old: RelayNotice[]) => RelayNotice[]) => {
+ setInbox((old) => ({ ...old, notices: update(old.notices) }));
+ }, []);
+ const [storageError, setStorageError] = useState('');
+ const seen = useRef(new Set());
+ const lastSound = useRef(0);
+ const current = useRef({ preferences, showToast, dismissDelivery });
+ current.current = { preferences, showToast, dismissDelivery };
+ const savePreferences = useCallback(
+ (next: NotificationPreferences) => {
+ const parsed = NotificationPreferencesSchema.parse(next);
+ setPreferences(parsed);
+ try {
+ localStorage.setItem(storageKey, JSON.stringify(parsed));
+ setStorageError('');
+ } catch {
+ setStorageError('Preferences apply to this session; device storage is unavailable.');
+ }
+ },
+ [storageKey],
+ );
+ const clear = useCallback((source?: NotificationSource, undoable = false) => {
+ if (!source || source === 'Tickets') current.current.dismissDelivery?.('ticket');
+ setInbox((old) => ({
+ notices: source ? old.notices.filter((notice) => notice.source !== source) : [],
+ // Account resets must also purge any ticket entries waiting for Undo.
+ cleared: undoable
+ ? old.notices.filter((notice) => !source || notice.source === source)
+ : old.cleared.filter((notice) => source && notice.source !== source),
+ }));
+ }, []);
+ const undoClear = useCallback(() => {
+ setInbox((old) => {
+ const existingIds = new Set(old.notices.map((notice) => notice.id));
+ return {
+ notices: [...old.notices, ...old.cleared.filter((notice) => !existingIds.has(notice.id))]
+ .sort((a, b) => b.at - a.at)
+ .slice(0, 200),
+ cleared: [],
+ };
+ });
+ }, []);
+ const markRead = useCallback(
+ (id?: string, source?: NotificationSource) => {
+ setNotices((old) =>
+ old.map((notice) =>
+ (!id || notice.id === id) && (!source || notice.source === source)
+ ? { ...notice, read: true }
+ : notice,
+ ),
+ );
+ },
+ [setNotices],
+ );
+ const publish = useCallback(
+ (input: NotificationInput) => {
+ const { preferences: prefs, showToast: toast } = current.current;
+ const rule = prefs.sources[input.source];
+ const level = input.type === 'success' ? 'info' : input.type;
+ if (!rule.enabled || !rule[level]) return;
+ const id = input.id ?? createClientId();
+ if (seen.current.has(id)) return;
+ seen.current.add(id);
+ if (seen.current.size > 1000) seen.current.delete(seen.current.values().next().value!);
+ const notice: RelayNotice = { ...input, id, at: input.at ?? Date.now(), read: false };
+ if (input.inbox !== false) setNotices((old) => [notice, ...old].slice(0, 200));
+ if (
+ input.interrupt === false ||
+ quietNow(
+ {
+ ...prefs,
+ quietStart: prefs.quietHoursEnabled ? prefs.quietStart : '',
+ rules: [],
+ warningMinutes: 30,
+ },
+ Date.now(),
+ )
+ )
+ return;
+ const open = () => {
+ markRead(id);
+ if (input.options?.action) input.options.action.onClick();
+ else openNotificationTarget(input.target);
+ };
+ if (prefs.toast && input.toast !== false)
+ toast(input.message, input.type, {
+ ...input.options,
+ title: input.title,
+ durationMs: input.options?.durationMs ?? 8000,
+ action: { label: input.options?.action?.label ?? `Open ${input.source}`, onClick: open },
+ });
+ const desktop = globalThis.api?.runtime.kind === 'electron';
+ if (desktop && prefs.desktop && input.desktop !== false)
+ void globalThis.api
+ ?.notifyTicket?.({
+ title: `Relay — ${input.source.toLowerCase()}`,
+ body: 'New activity needs attention. Open Relay to review.',
+ target: input.target,
+ })
+ .catch(() => undefined);
+ if (
+ desktop &&
+ prefs.sound &&
+ (input.sound ?? rule.sound) &&
+ Date.now() - lastSound.current >= 1000
+ ) {
+ lastSound.current = Date.now();
+ void globalThis.api?.playAlertSound?.().catch(() => undefined);
+ }
+ },
+ [markRead, setNotices],
+ );
+ useEffect(
+ () =>
+ globalThis.api?.onNotificationClick?.((target) => {
+ const parsed = NotificationTargetSchema.safeParse(target);
+ if (!parsed.success) return;
+ const destination = parsed.data;
+ setNotices((old) => readTarget(old, destination));
+ openNotificationTarget(destination);
+ }),
+ [setNotices],
+ );
+ const value = useMemo(
+ () => ({
+ notices,
+ preferences,
+ savePreferences,
+ storageError,
+ publish,
+ markRead,
+ clear,
+ undoClear,
+ clearedCount: cleared.length,
+ }),
+ [
+ notices,
+ preferences,
+ savePreferences,
+ storageError,
+ publish,
+ markRead,
+ clear,
+ undoClear,
+ cleared.length,
+ ],
+ );
+ return {children} ;
+}
+
+/** Preserve each source's detector and action; deliver operational events through one policy. */
+export function useOperationalToast(source: Exclude): ShowToast {
+ const context = useNotifications();
+ const publish = context?.publish;
+ const { showToast } = useToast();
+ return useCallback(
+ (message, type, options) => {
+ if (!publish || !options?.delivery || options.delivery === 'routine') {
+ showToast(message, type, options);
+ if (!publish && source === 'Problems')
+ void globalThis.api?.playAlertSound?.().catch(() => undefined);
+ return;
+ }
+ publish({
+ source,
+ title: options.title ?? source,
+ message,
+ type,
+ target: { source },
+ options,
+ });
+ },
+ [publish, source, showToast],
+ );
+}
+
+function readTarget(notices: RelayNotice[], destination: NotificationTarget): RelayNotice[] {
+ return notices.map((notice) => {
+ if (notice.target.source !== destination.source) return notice;
+ if (
+ destination.source === 'Tickets' &&
+ notice.target.source === 'Tickets' &&
+ notice.target.ticketId !== destination.ticketId
+ )
+ return notice;
+ return { ...notice, read: true };
+ });
+}
diff --git a/src/renderer/src/features/notifications/notifications.css b/src/renderer/src/features/notifications/notifications.css
new file mode 100644
index 00000000..ba9b15f9
--- /dev/null
+++ b/src/renderer/src/features/notifications/notifications.css
@@ -0,0 +1,128 @@
+.notification-attention {
+ color: var(--alarm-bright);
+ font-weight: var(--weight-semibold);
+}
+.notification-sources,
+.notification-inbox-actions,
+.notification-source-options,
+.notification-quiet-hours {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 8px;
+ align-items: center;
+}
+.notification-sources {
+ margin-top: 16px;
+}
+.notification-inbox-actions {
+ justify-content: flex-end;
+ border-bottom: 1px solid var(--color-border-subtle);
+ padding-block: 8px;
+}
+.notification-empty {
+ color: var(--color-text-secondary);
+ padding-block: 24px;
+}
+.notification-entry {
+ display: grid;
+ gap: 6px;
+ width: 100%;
+ padding: 16px 12px;
+ text-align: left;
+ font: inherit;
+ color: var(--color-text-secondary);
+ background: transparent;
+ border: 0;
+ border-bottom: 1px solid var(--color-border-subtle);
+ cursor: pointer;
+ overflow-wrap: anywhere;
+}
+.notification-entry:hover {
+ background: var(--color-bg-card-hover);
+}
+.notification-entry:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: -2px;
+}
+.notification-entry.is-unread {
+ box-shadow: inset 2px 0 var(--accent);
+}
+.notification-entry strong {
+ color: var(--color-text-primary);
+}
+.notification-meta {
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: space-between;
+ gap: 8px;
+ font-size: var(--text-xs);
+ color: var(--color-text-tertiary);
+}
+.notification-preferences {
+ display: grid;
+ gap: 20px;
+ padding-top: 20px;
+}
+.notification-preferences fieldset {
+ display: grid;
+ gap: 12px;
+ min-width: 0;
+ margin: 0;
+ padding: 12px 0 0;
+ border: 0;
+ border-top: 1px solid var(--color-border-subtle);
+}
+.notification-preferences legend {
+ padding-right: 12px;
+ font-weight: var(--weight-semibold);
+}
+.notification-quiet-hours label {
+ display: grid;
+ gap: 6px;
+ flex: 1;
+ min-width: 150px;
+}
+
+.notification-source-details {
+ border-top: 1px solid var(--color-border-subtle);
+}
+.notification-source-details summary {
+ padding-block: 12px;
+ font-weight: var(--weight-semibold);
+ cursor: pointer;
+}
+.notification-source-details summary span {
+ float: right;
+ margin-left: 12px;
+ color: var(--color-text-secondary);
+ font-weight: var(--weight-regular);
+}
+.notification-source-details summary:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+.notification-source-details fieldset {
+ border: 0;
+ padding-bottom: 12px;
+}
+.notification-undo {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ flex-wrap: wrap;
+ gap: 8px;
+}
+.notification-pause,
+.notification-severity {
+ color: var(--color-text-secondary);
+}
+.notification-severity--warning {
+ color: var(--color-warning);
+}
+.notification-severity--error {
+ color: var(--alarm-bright);
+}
+
+.notification-dialog input[type='checkbox'] {
+ accent-color: var(--accent);
+}
diff --git a/src/renderer/src/features/tickets/LiveSdpNotificationNavigation.test.tsx b/src/renderer/src/features/tickets/LiveSdpNotificationNavigation.test.tsx
new file mode 100644
index 00000000..9ea79f93
--- /dev/null
+++ b/src/renderer/src/features/tickets/LiveSdpNotificationNavigation.test.tsx
@@ -0,0 +1,68 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { ELECTRON_RUNTIME } from '@shared/runtime';
+import { LiveSdpQueues } from './LiveSdpQueues';
+vi.mock('../../services/pocketbase', () => ({ getPb: () => ({ baseURL: 'http://draft.test' }) }));
+vi.mock('./SdpNativeEditor', () => ({
+ SdpNativeEditor: ({ onClose }: Readonly<{ onClose: () => void }>) => (
+ <>
+
+
+
+ ),
+}));
+const original = globalThis.api;
+afterEach(() => {
+ cleanup();
+ globalThis.api = original;
+});
+it('defers notification navigation while a draft is open and opens it after the draft ends', async () => {
+ let view: unknown;
+ const invoke = vi.fn().mockImplementation(async (command) => {
+ if (command.action === 'status' && view) return { success: true, data: view };
+ const id = command.id ?? '123';
+ view = {
+ configured: true,
+ status: 'connected',
+ replyActivity: {
+ id,
+ number: id,
+ subject: `Ticket ${id}`,
+ status: 'Open',
+ priority: 'Low',
+ group: 'NOC',
+ technician: '',
+ createdAt: 1000,
+ dueAt: null,
+ },
+ detail: { id, description: '', conversations: [], page: 0, hasMore: false },
+ snapshot: { source: 'live', fetchedAt: Date.now(), expiresAt: Date.now() + 60000 },
+ detailSnapshot: { source: 'live', fetchedAt: Date.now(), expiresAt: Date.now() + 60000 },
+ };
+ return { success: true, data: view };
+ });
+ globalThis.api = { ...original, runtime: ELECTRON_RUNTIME, sdpAccount: invoke } as never;
+ const rendered = render(
+ Hello & welcome
Reply'
+ }
+ />,
+ );
+ expect(container).toHaveTextContent('Hello & welcome');
+ expect(container).toHaveTextContent('Reply');
+ expect(container.querySelector('script,img,a,iframe')).toBeNull();
+ expect(container.querySelector('p')).not.toBeNull();
+ expect(container).not.toHaveTextContent('bad()');
+});
+
+it('preserves complete form tables while discarding source styles and event handlers', () => {
+ const { container } = render(
+ Responsibilities Example access Approval limit 1500 ;
+ }>();
+ const handledRequest = useRef(0);
+ const openedFrom = useRef(null);
+ const [view, setView] = useState();
+ const [queue, setQueue] = useState('NOC');
+ const [page, setPage] = useState(0);
+ const [search, setSearch] = useState('');
+ const [selected, setSelected] = useState('');
+ const [openedTicket, setOpenedTicket] = useState();
+ const [detailSection, setDetailSection] = useState('Conversations');
+ const [account, setAccount] = useState(false);
+ const [error, setError] = useState('');
+ const [requestBusy, setRequestBusy] = useState(false);
+ const [bulkIds, setBulkIds] = useState([]);
+ const [bulkTickets, setBulkTickets] = useState();
+ const busy = requestBusy || !!bulkTickets;
+ const pending = useRef(false);
+ const epoch = useRef(0);
+ const alive = useRef(true);
+ const refreshing = useRef(false);
+ const invoke = globalThis.api?.sdpAccount;
+ const available = globalThis.api?.runtime.kind === 'electron' && !!invoke;
+ const connected = view?.status === 'connected';
+ const openNotifiedTicket = useEffectEvent(
+ (id: string) => void run({ action: 'readDetail', id, page: 0 }),
+ );
+ useEffect(() => {
+ if (
+ !connected ||
+ request?.source !== 'sdp' ||
+ request.sequence === handledRequest.current ||
+ nativeEditor ||
+ editor ||
+ requestBusy
+ )
+ return;
+ handledRequest.current = request.sequence;
+ if (request.major) setEditor({ mode: 'major', problem: request.problem });
+ else if (request.ticketId) openNotifiedTicket(request.ticketId);
+ }, [connected, request, nativeEditor, editor, requestBusy]);
+ useEffect(() => {
+ if (!connected && !requestBusy) {
+ setEditor(undefined);
+ setNativeEditor(undefined);
+ setSelected('');
+ setOpenedTicket(undefined);
+ }
+ }, [connected, requestBusy]);
+ useEffect(() => {
+ alive.current = true;
+ return () => {
+ alive.current = false;
+ };
+ }, []);
+ function toggleBulk(id: string, checked: boolean) {
+ setBulkIds((ids) => (checked ? [...ids, id] : ids.filter((value) => value !== id)));
+ }
+ async function run(command: SdpAccountCommand) {
+ if (command.action !== 'readDetail') setBulkIds([]);
+ if (!invoke || pending.current || bulkTickets) return;
+ const current = ++epoch.current;
+ pending.current = true;
+ setRequestBusy(true);
+ setError('');
+ if (command.action === 'readDetail') {
+ if (selected !== command.id) setDetailSection('Conversations');
+ setView((old) =>
+ old ? { ...old, detail: undefined, detailSnapshot: undefined, message: undefined } : old,
+ );
+ setOpenedTicket(
+ (old) => view?.queuePage?.tickets.find((item) => item.id === command.id) ?? old,
+ );
+ setSelected(command.id);
+ } else {
+ setView((old) =>
+ old
+ ? {
+ ...old,
+ queuePage: undefined,
+ detail: undefined,
+ snapshot: undefined,
+ detailSnapshot: undefined,
+ }
+ : old,
+ );
+ setSelected('');
+ setOpenedTicket(undefined);
+ }
+ if (command.action === 'clearCopies') {
+ setSearch('');
+ resetSdpNotifications();
+ }
+ try {
+ const result = await invoke(command);
+ if (!result.success || !result.data)
+ throw new Error(result.error ?? 'SDP could not complete this action.');
+ if (alive.current && current === epoch.current) setView(result.data);
+ } catch {
+ if (alive.current && current === epoch.current) {
+ setView(undefined);
+ setError(
+ 'Could not load SDP. Check the server connection and your work sign-in, then retry.',
+ );
+ }
+ } finally {
+ pending.current = false;
+ if (alive.current) setRequestBusy(false);
+ }
+ }
+ useEffect(() => {
+ if (!available) return;
+ let active = true;
+ let checking = false;
+ const check = async () => {
+ if (checking || pending.current || refreshing.current) return;
+ checking = true;
+ const current = epoch.current;
+ try {
+ const result = await invoke!({ action: 'status' });
+ if (!active || current !== epoch.current) return;
+ if (result.success && result.data) {
+ setView(result.data);
+ setError('');
+ } else {
+ setView(undefined);
+ setError('Relay is unavailable. Live ticket data has been hidden.');
+ }
+ } catch {
+ if (active && current === epoch.current) {
+ setView(undefined);
+ setError('Relay is unavailable. Live ticket data has been hidden.');
+ }
+ } finally {
+ checking = false;
+ }
+ };
+ void check();
+ const timer = setInterval(() => void check(), 5000);
+ return () => {
+ active = false;
+ clearInterval(timer);
+ };
+ }, [available, invoke]);
+ const refreshVisible = useEffectEvent(async () => {
+ if (
+ !invoke ||
+ !connected ||
+ pending.current ||
+ refreshing.current ||
+ nativeEditor ||
+ editor ||
+ bulkTickets ||
+ account
+ )
+ return;
+ const current = ++epoch.current;
+ refreshing.current = true;
+ try {
+ const result = await invoke({ action: 'refreshVisible' });
+ if (alive.current && current === epoch.current && result.success && result.data)
+ setView(result.data);
+ } finally {
+ refreshing.current = false;
+ }
+ });
+ useEffect(() => {
+ if (!available) return;
+ const timer = setInterval(() => {
+ void refreshVisible().catch(() => undefined);
+ }, 30_000);
+ return () => clearInterval(timer);
+ }, [available]);
+ useEffect(() => {
+ // Opening a draft invalidates any older background response without resetting the draft.
+ if (nativeEditor || editor || bulkTickets || account) epoch.current++;
+ }, [nativeEditor, editor, bulkTickets, account]);
+ function applyResult(next: SdpAccountView) {
+ epoch.current++;
+ setView(next);
+ }
+ useEffect(() => {
+ if (!view?.snapshot) return;
+ const timer = setTimeout(
+ () => {
+ setView((old) =>
+ old ? { ...old, queuePage: undefined, ticket: undefined, snapshot: undefined } : old,
+ );
+ setSelected('');
+ setOpenedTicket(undefined);
+ },
+ Math.max(0, view.snapshot.expiresAt - Date.now()),
+ );
+ return () => clearTimeout(timer);
+ }, [view?.snapshot]);
+ useEffect(() => {
+ if (!view?.detailSnapshot) return;
+ const timer = setTimeout(
+ () =>
+ setView((old) => (old ? { ...old, detail: undefined, detailSnapshot: undefined } : old)),
+ Math.max(0, view.detailSnapshot.expiresAt - Date.now()),
+ );
+ return () => clearTimeout(timer);
+ }, [view?.detailSnapshot]);
+ const result =
+ view?.queuePage?.queue === queue && view.queuePage.page === page ? view.queuePage : undefined;
+ const tickets =
+ result?.tickets.filter(
+ (ticket) =>
+ `${ticket.number} ${ticket.subject} ${ticket.technician}`
+ .toLowerCase()
+ .includes(search.toLowerCase()) &&
+ (!filters.status || ticket.status === filters.status) &&
+ (!filters.priority || ticket.priority === filters.priority) &&
+ (!filters.technician || ticket.technician === filters.technician) &&
+ (!filters.due ||
+ (ticket.dueAt !== null &&
+ (filters.due === 'overdue'
+ ? ticket.dueAt < Date.now()
+ : ticket.dueAt >= Date.now() && ticket.dueAt < Date.now() + 86400000))),
+ ) ?? [];
+ const queueTicket = selectedTicket(view, selected, openedTicket);
+ const ticket =
+ queueTicket && view?.replyActivity?.id === selected
+ ? {
+ ...queueTicket,
+ ...view.replyActivity,
+ }
+ : queueTicket;
+ function load(nextQueue: SdpQueue, nextPage = 0) {
+ if (nextQueue === queue && result?.filters) {
+ setPage(nextPage);
+ void run({ action: 'readQueue', queue: nextQueue, page: nextPage, filters: result.filters });
+ return;
+ }
+ setQueue(nextQueue);
+ setPage(nextPage);
+ setSearch('');
+ setFilters({ status: '', priority: '', technician: '', due: '' });
+ void run({ action: 'readQueue', queue: nextQueue, page: nextPage });
+ }
+ const showWorkspace = connected || !!result || !!ticket || !!editor || !!nativeEditor;
+ const resultCaption = `${tickets.length} ${tickets.length === 1 ? 'ticket' : 'tickets'}`;
+ const filterCaption = result?.filters ? ' · Filtered' : '';
+ return (
+
+
+ {view?.status === 'connecting' ? 'Continue work sign-in' : 'Connect work account'}
+
+ )}
+
+ );
+}
+
+function selectedTicket(
+ view: SdpAccountView | undefined,
+ selected: string,
+ opened?: import('@shared/sdpAccount').SdpQueueTicket,
+) {
+ return (
+ view?.queuePage?.tickets.find((item) => item.id === selected) ??
+ (view?.replyActivity?.id === selected ? view.replyActivity : undefined) ??
+ (opened?.id === selected ? opened : undefined)
+ );
+}
diff --git a/src/renderer/src/features/tickets/SdpAccountPanel.test.tsx b/src/renderer/src/features/tickets/SdpAccountPanel.test.tsx
new file mode 100644
index 00000000..30b44b88
--- /dev/null
+++ b/src/renderer/src/features/tickets/SdpAccountPanel.test.tsx
@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { fireEvent, render, screen } from '@testing-library/react';
+import { ELECTRON_RUNTIME, WEB_RUNTIME } from '@shared/runtime';
+import type { BridgeAPI } from '@shared/ipc';
+import { SdpAccountPanel } from './SdpAccountPanel';
+
+const originalApi = globalThis.api;
+afterEach(() => {
+ globalThis.api = originalApi;
+});
+describe('SDP account panel', () => {
+ it('never offers desktop credentials or sign-in to Relay Web', () => {
+ const invoke = vi.fn();
+ globalThis.api = { ...originalApi, runtime: WEB_RUNTIME, sdpAccount: invoke } as BridgeAPI;
+ render(();
+ const [busy, setBusy] = useState(false);
+ const [error, setError] = useState('');
+ const actionEpoch = useRef(0);
+ const actionPending = useRef(false);
+ const invoke = globalThis.api?.sdpAccount;
+ const available = globalThis.api?.runtime.kind === 'electron' && !!invoke;
+ useEffect(() => {
+ if (!available) return;
+ let active = true;
+ let pending = false;
+ const poll = async () => {
+ if (pending || actionPending.current) return;
+ const epoch = actionEpoch.current;
+ pending = true;
+ try {
+ const result = await invoke!({ action: 'status' });
+ if (epoch !== actionEpoch.current) return;
+ if (active && result.success && result.data) {
+ setView(result.data);
+ setError('');
+ } else if (active) {
+ setView(undefined);
+ setError(result.error ?? 'Could not read SDP connection status.');
+ }
+ } catch {
+ if (active && epoch === actionEpoch.current) {
+ setView(undefined);
+ setError('Could not read SDP connection status.');
+ }
+ } finally {
+ pending = false;
+ }
+ };
+ void poll();
+ const timer = setInterval(() => void poll(), 5000);
+ return () => {
+ active = false;
+ clearInterval(timer);
+ };
+ }, [available, invoke]);
+
+ useEffect(() => {
+ if (!view?.snapshot) return;
+ const timer = setTimeout(
+ () =>
+ setView((current) =>
+ current ? { ...current, ticket: undefined, snapshot: undefined } : current,
+ ),
+ Math.max(0, view.snapshot.expiresAt - Date.now()),
+ );
+ return () => clearTimeout(timer);
+ }, [view?.snapshot]);
+
+ async function run(command: SdpAccountCommand) {
+ if (command.action === 'disconnect' || command.action === 'connect') resetSdpNotifications();
+ actionEpoch.current++;
+ actionPending.current = true;
+ setBusy(true);
+ setError('');
+ try {
+ const result = await invoke!(command);
+ if (!result.success || !result.data)
+ throw new Error(result.error ?? 'SDP connection failed.');
+ setView(result.data);
+ } catch (reason) {
+ setView(undefined);
+ setError(reason instanceof Error ? reason.message : 'SDP connection failed.');
+ } finally {
+ actionPending.current = false;
+ setBusy(false);
+ }
+ }
+ return (
+ Done}
+ >
+
+ );
+}
diff --git a/src/renderer/src/features/tickets/SdpAlerts.test.tsx b/src/renderer/src/features/tickets/SdpAlerts.test.tsx
new file mode 100644
index 00000000..c4777814
--- /dev/null
+++ b/src/renderer/src/features/tickets/SdpAlerts.test.tsx
@@ -0,0 +1,98 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
+import type { BridgeAPI } from '@shared/ipc';
+import { SdpAlertControls, useSdpAlerts } from './SdpAlerts';
+function SdpAlerts({
+ connected,
+ resetKey = 0,
+}: Readonly<{ connected: boolean; resetKey?: number }>) {
+ const state = useSdpAlerts(connected, resetKey);
+ return {}} />;
+}
+vi.mock('../../services/pocketbase', () => ({ getPb: () => ({ baseURL: 'http://monitor.test' }) }));
+vi.mock('../../hooks/useCollection', () => ({ useCollection: () => ({ data: [] }) }));
+const original = globalThis.api;
+afterEach(() => {
+ cleanup();
+ globalThis.api = original;
+ vi.useRealTimers();
+});
+it('starts automatically, heartbeats with a snapshot cursor, and unsubscribes on pause and disconnect', async () => {
+ vi.useFakeTimers();
+ const invoke = vi.fn().mockResolvedValue({
+ success: true,
+ data: {
+ configured: true,
+ status: 'connected',
+ monitoring: { state: 'live', nextCheckAt: 30000 },
+ monitor: { tickets: [], fetchedAt: 1000, truncated: false, generation: 'a' },
+ },
+ });
+ globalThis.api = { sdpAccount: invoke } as unknown as BridgeAPI;
+ const view = render((() => {
+ try {
+ return TicketPreferencesSchema.parse(JSON.parse(localStorage.getItem(key) ?? 'null'));
+ } catch {
+ return { ...defaultTicketPreferences(), rules: [] };
+ }
+ });
+ const [enabled, setEnabled] = useState(false);
+ const [message, setMessage] = useState('Monitoring off');
+ const engine = useRef(new SdpAlertEngine());
+ const links = useCollection(SDP_LINK_COLLECTION);
+ const problems = useCollection('dynatrace_problems');
+ const current = useRef({
+ preferences,
+ linked: new Set(links.data.filter((link) => !link.suppressed).map((link) => link.ticketId)),
+ links: links.data,
+ problems: problems.data,
+ });
+ current.current = {
+ preferences,
+ linked: new Set(links.data.filter((link) => !link.suppressed).map((link) => link.ticketId)),
+ links: links.data,
+ problems: problems.data,
+ };
+ useEffect(() => {
+ if (!connected) {
+ engine.current.reset();
+ clear?.('Tickets');
+ }
+ setAttention(false);
+ setEnabled(connected);
+ setMessage(connected ? 'Starting queue monitoring…' : 'Monitoring off');
+ }, [connected, clear]);
+ useEffect(() => {
+ if (previousReset.current === resetKey) return;
+ previousReset.current = resetKey;
+ setAttention(false);
+ setEnabled(false);
+ engine.current.reset();
+ clear?.('Tickets');
+ setMessage('Monitoring off · Saved data cleared');
+ }, [resetKey, clear]);
+ useEffect(() => {
+ const reset = () => {
+ setEnabled(false);
+ engine.current.reset();
+ clear?.('Tickets');
+ setMessage('Monitoring paused');
+ };
+ window.addEventListener(SDP_NOTIFICATIONS_RESET, reset);
+ return () => window.removeEventListener(SDP_NOTIFICATIONS_RESET, reset);
+ }, [clear]);
+ useEffect(() => {
+ if (!enabled || !connected || !globalThis.api?.sdpAccount) return;
+ const evaluator = engine.current;
+ const autoLink = new SdpWorkflowAutoLink();
+ let active = true;
+ let running = false;
+ let after: number | undefined;
+ let generation: string | undefined;
+ const linkWorkflowTickets = async (monitor: SdpMonitor, coverage: string) => {
+ try {
+ const linked = await autoLink.scan(
+ monitor.tickets,
+ current.current.problems,
+ current.current.links,
+ async (input) => {
+ const result = await globalThis.api!.sdpAccount!({
+ action: 'verifyWorkflowTicket',
+ id: input.ticketId,
+ problemId: input.problemId,
+ environment: input.environment,
+ });
+ if (!result.success || result.data?.status !== 'connected')
+ throw new Error('SdpAlerts: SDP operation did not return the expected result.');
+ return result.data.workflowTicketMatch === true;
+ },
+ (input) => linkSdpProblem(input, true),
+ () => active,
+ );
+ if (active && linked)
+ setMessage(`${coverage} · ${linked} workflow ticket${linked === 1 ? '' : 's'} linked`);
+ } catch {
+ if (active) {
+ setAttention(true);
+ setMessage(
+ `${coverage} · Automatic linking will retry; check the SDP and Relay connections.`,
+ );
+ }
+ }
+ };
+ const check = async () => {
+ if (running) return;
+ running = true;
+ try {
+ const result = await globalThis.api!.sdpAccount!({ action: 'monitorQueues', after });
+ if (!active) return;
+ if (!result.success || !result.data)
+ throw new Error('SdpAlerts: SDP operation did not return the expected result.');
+ if (result.data.monitoring?.state === 'backoff') {
+ setAttention(true);
+ evaluator.reset();
+ clear?.('Tickets');
+ after = undefined;
+ setMessage(
+ `${monitorFailure(result.data.monitoring.failure)} Next check ${new Date(result.data.monitoring.nextCheckAt).toLocaleTimeString()}.`,
+ );
+ return;
+ }
+ const { monitor } = result.data;
+ if (!monitor) return;
+ setAttention(false);
+ if (generation && generation !== monitor.generation) clear?.('Tickets');
+ generation = monitor.generation;
+ after = monitor.fetchedAt;
+ const deliveries = evaluator.evaluate(
+ monitor,
+ { ...current.current.preferences, quietStart: '', quietEnd: '', snoozeUntil: 0 },
+ current.current.linked,
+ );
+ for (const delivery of deliveries) {
+ const { notice, rule } = delivery;
+ publish?.({
+ id: `${monitor.generation}:${notice.id}`,
+ source: 'Tickets',
+ title: `Ticket #${notice.number}`,
+ message: `${rule.name} · ${notice.event}`,
+ type: notice.event === 'sla-breached' ? 'error' : 'info',
+ target: { source: 'Tickets', ticketId: notice.ticketId },
+ at: notice.at,
+ inbox: rule.inbox,
+ toast: rule.toast,
+ desktop: rule.desktop,
+ sound: rule.sound,
+ options: { delivery: 'ticket', action: undefined },
+ });
+ }
+ const coverage = monitor.truncated
+ ? 'Partial coverage: newest 1,000 per queue'
+ : `${monitor.tickets.length} tickets checked`;
+ setMessage(`${coverage} · ${new Date(monitor.fetchedAt).toLocaleTimeString()}`);
+ await linkWorkflowTickets(monitor, coverage);
+ } catch {
+ if (active) {
+ setAttention(true);
+ engine.current.reset();
+ clear?.('Tickets');
+ after = undefined;
+ setMessage('Waiting for the Relay server. Reconnecting automatically…');
+ }
+ } finally {
+ running = false;
+ }
+ };
+ void check();
+ const timer = setInterval(() => void check(), 5000);
+ return () => {
+ active = false;
+ clearInterval(timer);
+ evaluator.reset();
+ void globalThis.api
+ ?.sdpAccount?.({ action: 'monitorQueues', enabled: false })
+ .catch(() => undefined);
+ };
+ }, [enabled, connected, publish, clear]);
+ function savePreferences(next: TicketPreferences) {
+ setPreferences(next);
+ try {
+ localStorage.setItem(key, JSON.stringify(next));
+ } catch {
+ setMessage('Rules apply to this session; device storage is unavailable.');
+ }
+ }
+ return { connected, enabled, setEnabled, attention, message, preferences, savePreferences };
+}
+export function SdpAlertControls({
+ state,
+ onRules,
+}: Readonly<{
+ state: ReturnType;
+ onRules: () => void;
+}>) {
+ return (
+
+
+ );
+}
+
+function monitorFailure(kind?: string): string {
+ switch (kind) {
+ case 'timeout':
+ return 'The queue scan took too long.';
+ case 'invalid':
+ return 'Relay could not read an SDP queue response.';
+ case 'throttled':
+ return 'SDP requested a pause before more API calls.';
+ case 'denied':
+ return 'SDP access needs to be verified again.';
+ case 'outage':
+ return 'SDP could not be reached.';
+ default:
+ return 'Queue monitoring could not complete.';
+ }
+}
diff --git a/src/renderer/src/features/tickets/SdpAttachmentsPanel.test.tsx b/src/renderer/src/features/tickets/SdpAttachmentsPanel.test.tsx
new file mode 100644
index 00000000..14f878f1
--- /dev/null
+++ b/src/renderer/src/features/tickets/SdpAttachmentsPanel.test.tsx
@@ -0,0 +1,120 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import type { BridgeAPI } from '@shared/ipc';
+import { SdpAttachmentsPanel } from './SdpAttachmentsPanel';
+const original = globalThis.api;
+afterEach(() => {
+ globalThis.api = original;
+});
+it('requires a separate confirmation after selecting an attachment and never retries an uncertain upload', async () => {
+ const invoke = vi.fn().mockImplementation(async (command) => {
+ if (command.action === 'confirmChange') throw new Error('connection lost');
+ return {
+ success: true,
+ data: {
+ configured: true,
+ status: 'connected',
+ review: {
+ confirmationId: 'f6d1a214-87d9-45ef-9bce-b1a850e5d301',
+ expiresAt: Date.now() + 300000,
+ mutation: { ...command.mutation, data: '' },
+ },
+ },
+ };
+ });
+ globalThis.api = { ...original, sdpAccount: invoke } as BridgeAPI;
+ render((null);
+ const uploadButton = useRef(null);
+ const helpId = useId();
+ const [activity, setActivity] = useState();
+ const [review, setReview] = useState();
+ const [size, setSize] = useState(0);
+ const [busy, setBusy] = useState(false);
+ const [message, setMessage] = useState('');
+ const locked = useRef(false);
+ async function upload(file: File) {
+ if (locked.current) return;
+ if (!file.size || file.size > SDP_ATTACHMENT_MAX_BYTES) {
+ setMessage('Choose a file between 1 byte and 10 MB.');
+ return;
+ }
+ locked.current = true;
+ setBusy(true);
+ setActivity('prepare');
+ setMessage('');
+ try {
+ const bytes = new Uint8Array(await file.arrayBuffer());
+ let binary = '';
+ for (let offset = 0; offset < bytes.length; offset += 8192)
+ binary += String.fromCodePoint(...bytes.subarray(offset, offset + 8192));
+ const result = await globalThis.api!.sdpAccount!({
+ action: 'prepareChange',
+ mutation: {
+ kind: 'attachment',
+ id,
+ name: file.name,
+ contentType: file.type || 'application/octet-stream',
+ data: btoa(binary),
+ },
+ });
+ if (!result.success || !result.data?.review)
+ throw new Error('SdpAttachmentsPanel: SDP operation did not return the expected result.');
+ setSize(file.size);
+ setReview(result.data.review);
+ } catch {
+ setMessage('Could not prepare the attachment. Check the file, connection and permissions.');
+ } finally {
+ locked.current = false;
+ setBusy(false);
+ setActivity(undefined);
+ }
+ }
+ async function confirm() {
+ if (!review || locked.current) return;
+ locked.current = true;
+ setBusy(true);
+ setActivity('upload');
+ const confirmationId = review.confirmationId;
+ setReview(undefined);
+ try {
+ const result = await globalThis.api!.sdpAccount!({ action: 'confirmChange', confirmationId });
+ if (!result.success || !result.data)
+ throw new Error('SdpAttachmentsPanel: SDP operation did not return the expected result.');
+ setMessage(result.data.message ?? 'Check SDP for the upload result.');
+ onResult(result.data);
+ } catch {
+ setMessage(
+ 'The result is uncertain. Check SDP before uploading again. Relay will not retry automatically.',
+ );
+ } finally {
+ locked.current = false;
+ setBusy(false);
+ setActivity(undefined);
+ }
+ }
+ async function download(attachmentId: string) {
+ if (locked.current) return;
+ locked.current = true;
+ setBusy(true);
+ setActivity(attachmentId);
+ setMessage('');
+ try {
+ const result = await globalThis.api!.sdpAccount!({
+ action: 'downloadAttachment',
+ id,
+ attachmentId,
+ });
+ setMessage(
+ result.success
+ ? (result.data?.message ?? 'Download finished.')
+ : 'The attachment could not be downloaded.',
+ );
+ } catch {
+ setMessage('The attachment could not be downloaded. Check your connection and permissions.');
+ } finally {
+ locked.current = false;
+ setBusy(false);
+ setActivity(undefined);
+ }
+ }
+ function close() {
+ if (!busy) {
+ setReview(undefined);
+ void globalThis.api?.sdpAccount?.({ action: 'cancelChange' });
+ requestAnimationFrame(() => uploadButton.current?.focus());
+ }
+ }
+ let uploadLabel = 'Add attachment';
+ if (activity === 'prepare') uploadLabel = 'Preparing…';
+ if (activity === 'upload') uploadLabel = 'Uploading…';
+ return (
+
+
+
+ Cancel
+
+ void confirm()}
+ >
+ Upload attachment
+
+
+ }
+ >
+
+ )}
+
+ );
+}
diff --git a/src/renderer/src/features/tickets/SdpBulkDialog.test.tsx b/src/renderer/src/features/tickets/SdpBulkDialog.test.tsx
new file mode 100644
index 00000000..733abafb
--- /dev/null
+++ b/src/renderer/src/features/tickets/SdpBulkDialog.test.tsx
@@ -0,0 +1,71 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { BridgeAPI } from '@shared/ipc';
+import { SdpBulkDialog } from './SdpBulkDialog';
+const original = globalThis.api;
+afterEach(() => {
+ globalThis.api = original;
+});
+const tickets = ['123', '456'].map((id) => ({
+ id,
+ number: id,
+ subject: 'Sample ' + id,
+ status: 'Open',
+ priority: 'Low',
+ group: 'NOC' as const,
+ technician: 'Example',
+ createdAt: 0,
+ dueAt: null,
+}));
+it('reviews explicit targets and displays partial results without retrying', async () => {
+ const invoke = vi.fn().mockImplementation(async (c) => ({
+ success: true,
+ data: {
+ configured: true,
+ status: 'connected',
+ ...(c.action === 'readStandardOptions'
+ ? {
+ options: {
+ field: c.field,
+ hasMore: false,
+ choices: [{ label: 'Closed', value: { id: '2', name: 'Closed' } }],
+ },
+ }
+ : {}),
+ ...(c.action === 'prepareChange'
+ ? {
+ review: {
+ confirmationId: '00000000-0000-4000-8000-000000000001',
+ expiresAt: Date.now() + 60000,
+ mutation: c.mutation,
+ },
+ }
+ : {
+ bulkResult: [
+ { id: '123', status: 'confirmed' },
+ { id: '456', status: 'uncertain' },
+ ],
+ message: 'Batch stopped',
+ }),
+ },
+ }));
+ globalThis.api = { ...original, sdpAccount: invoke } as BridgeAPI;
+ render(({});
+ const [groupId, setGroupId] = useState();
+ const [review, setReview] = useState();
+ const [results, setResults] = useState();
+ const [message, setMessage] = useState('');
+ const [busy, setBusy] = useState(false);
+ const [finished, setFinished] = useState(false);
+ const locked = useRef(false);
+ async function submit() {
+ if (locked.current || finished) return;
+ const parsed = SdpBulkMutationSchema.safeParse({
+ kind: 'bulk',
+ ids: tickets.map((t) => t.id),
+ fields: patch,
+ });
+ if (!parsed.success) {
+ setMessage('Choose at least one change for up to 20 tickets.');
+ return;
+ }
+ const confirming = !!review;
+ const command = review
+ ? { action: 'confirmChange' as const, confirmationId: review.confirmationId }
+ : { action: 'prepareChange' as const, mutation: parsed.data };
+ locked.current = true;
+ setBusy(true);
+ setMessage('');
+ if (confirming) {
+ setReview(undefined);
+ setFinished(true);
+ }
+ try {
+ const result = await globalThis.api!.sdpAccount!(command);
+ if (!result.success || !result.data)
+ throw new Error('SdpBulkDialog: SDP operation did not return the expected result.');
+ if (confirming) {
+ setResults(result.data.bulkResult);
+ setMessage(result.data.message ?? 'Check each ticket in SDP.');
+ onResult(result.data);
+ } else if (result.data.review?.mutation.kind === 'bulk') setReview(result.data.review);
+ else throw new Error('SdpBulkDialog: SDP operation did not return the expected result.');
+ } catch {
+ setMessage(
+ confirming
+ ? 'The result is uncertain. Check all selected tickets in SDP before trying again. Nothing will be retried automatically.'
+ : 'Could not prepare these changes. Refresh the queue and check your access.',
+ );
+ } finally {
+ locked.current = false;
+ setBusy(false);
+ }
+ }
+ function close() {
+ if (busy) return;
+ void globalThis.api?.sdpAccount?.({ action: 'cancelChange' });
+ onClose();
+ }
+ return (
+
+
+ {finished ? 'Done' : 'Cancel'}
+
+ {!finished && (
+ void submit()}
+ >
+ {review ? `Confirm ${tickets.length} live changes` : 'Review bulk changes'}
+
+ )}
+
+ }
+ >
+
One server setup. Each person signs in with their own work account.
+ {!invoke &&Configure this on the Relay server computer.
} + {view && ( + + )} + {feedback && ( ++ +
+ )} ++ +
+ )} + {quiet && !snoozed && ( ++ +
+ )} + {storageError &&{storageError}
} + {section === 'Inbox' ? ( + <> + +
+ !notice.read)}
+ onClick={() => markRead(undefined, source === 'All' ? undefined : source)}
+ >
+ {source === 'All' ? 'Mark all read' : `Mark ${source.toLowerCase()} read`}
+
+ clear(source === 'All' ? undefined : source, true)}
+ >
+ Clear {source === 'All' ? 'inbox' : source.toLowerCase()}
+
+
+ {clearedCount > 0 && (
+
+
+
+ Undo clear
+
+
+ )}
+ {!visible.length && (
+ + No notifications{source === 'All' ? '' : ` from ${source.toLowerCase()}`} yet. +
+ )} +
+ {visible.map((notice) => (
+
+ ))}
+
+
+ ) : (
+
+
+
+ {NOTIFICATION_SOURCES.map((name) => (
+
+ )}
+
+
+ ))}
+ + {name} + {preferences.sources[name].enabled ? 'Enabled' : 'Off'} +
+ +Example internal note
', + author: 'Example technician', + createdAt: 1000, + }, + ], + description: 'Example description
', + page: 0, + hasMore: false, + conversations: [ + { + id: '5', + author: 'Example author', + subject: 'Reply', + body: 'Example reply
', + createdAt: 1000, + }, + ], + }, + } + : {}), + snapshot: { source: 'live', fetchedAt: Date.now(), expiresAt: Date.now() + 60000 }, + } + : {}), + }, + })); + globalThis.api = { ...original, runtime: ELECTRON_RUNTIME, sdpAccount: invoke } as BridgeAPI; + render(Notified conversation
', + page: 0, + hasMore: false, + conversations: [], + }, + detailSnapshot: { + source: 'live', + fetchedAt: Date.now(), + expiresAt: Date.now() + 60000, + }, + } + : {}), + }, + })); + globalThis.api = { ...original, runtime: ELECTRON_RUNTIME, sdpAccount: invoke } as BridgeAPI; + render( +
+ SDP · Your work account}
+ />
+ {showWorkspace && (
+ <>
+
+
+ setAccount(true)}>
+ Work account
+
+ load(queue, page)}
+ >
+ {busy ? 'Loading…' : 'Refresh queue'}
+
+ {view?.testControls === true && (
+ void run({ action: 'clearCopies' })}
+ >
+ Clear my saved SDP data
+
+ )}
+
+
+ setEditor({ mode: 'major' })}
+ >
+ Major incident
+
+ setEditor({ mode: 'create' })}
+ >
+ New ticket
+
+
+
+ {
+ setBulkTickets(undefined);
+ setBulkIds([]);
+ }}
+ onResult={applyResult}
+ />
+ )}
+ {error && (
+ setAccount(true)}
+ />
+ )}
+ {showWorkspace && (
+ <>
+ {!ticket && result && (
+
+
+ )}
+ setEditor(undefined)}
+ onResult={(next) => {
+ applyResult(next);
+ if (next.changeResult?.kind === 'create' && editor.problem && editor.mode === 'major') {
+ void linkSdpProblem({
+ ticketId: next.changeResult.id,
+ ticketNumber: next.changeResult.number,
+ problemId: editor.problem.problemId,
+ environment: editor.problem.environmentUrl,
+ }).catch(() =>
+ setError(
+ 'Ticket created, but the problem link was not saved. Open the ticket to link it.',
+ ),
+ );
+ }
+ }}
+ />
+ )}
+ {account && setAccount(false)} />}
+
+ );
+}
+
+function SdpConnectionPrompt({
+ available,
+ view,
+ busy,
+ error,
+ onConnect,
+}: Readonly<{
+ available: boolean;
+ view: SdpAccountView | undefined;
+ busy: boolean;
+ error: string;
+ onConnect: () => void;
+}>) {
+ let title = 'Live tickets are available on desktop';
+ if (available)
+ title =
+ view?.status === 'expired' ? 'Reconnect your work account' : 'Connect your work account';
+ return (
+
+
+ {result && view?.snapshot && (
+
+ )}
+
+
+ )}
+
+ {request?.ticketId &&
+ request.sequence !== handledRequest.current &&
+ (nativeEditor || editor) && (
+ + +
+ )} + {bulkTickets && ( ++ {error} +
+ )} + {view?.message && ( ++ +
+ )} + {!showWorkspace && ( +
+ {queue} queue
+
+ {result.tickets.length}
+ on this page
+
+
+ -
+ {[...new Set(result.tickets.map((item) => item.status))].map((status) => (
+
- {status} +
- {result.tickets.filter((item) => item.status === status).length} +
+
+ ))}
+
+ Unread replies
+ {result.tickets.filter((item) => item.replyUnread).length}
+
+
+
+ {(
+ [
+ ['status', 'Status'],
+ ['priority', 'Priority'],
+ ['technician', 'Technician'],
+ ] as const
+ ).map(([key, label]) => (
+
+ ))}
+
+ {
+ const filter = Object.fromEntries(
+ Object.entries({ ...filters, search }).filter(([, v]) => v),
+ ) as SdpQueueFilters;
+ setPage(0);
+ void run({
+ action: 'readQueue',
+ queue,
+ page: 0,
+ ...(Object.keys(filter).length ? { filters: filter } : {}),
+ });
+ }}
+ >
+ Apply filters
+
+ {
+ setFilters({ status: '', priority: '', technician: '', due: '' });
+ setSearch('');
+ setPage(0);
+ if (connected) void run({ action: 'readQueue', queue, page: 0 });
+ }}
+ >
+ Clear filters
+
+
+
+
+
+
+ {result && tickets.length === 0 && (
+
+ {ticket && (
+ setEditor({ mode, ticket })}
+ onResult={applyResult}
+ onRefresh={(nextPage, includeAutoNotifications) =>
+ void run({
+ action: 'readDetail',
+ id: ticket.id,
+ page: nextPage,
+ ...((includeAutoNotifications ?? view?.detail?.includeAutoNotifications)
+ ? { includeAutoNotifications: true }
+ : {}),
+ })
+ }
+ onClose={() => {
+ setSelected('');
+ setOpenedTicket(undefined);
+ requestAnimationFrame(() => openedFrom.current?.focus());
+ }}
+ />
+ )}
+
+
+ )}
+ {editor && (
+
+ {result ? `${resultCaption}${filterCaption}` : 'Queue not loaded'}
+
+ | Ticket | +Priority / status | +Group / technician | +Due | +
|---|---|---|---|
| + + + | ++ {item.priority} + {item.status} + | ++ {item.group} + {item.technician} + | +{date(item.dueAt)} | +
+ {search ? 'No matches in these results.' : 'No tickets returned for this queue.'} +
+ )} + {!result && connected && !busy && ( ++ Choose a queue or Refresh queue to load tickets. +
+ )} +
+ load(queue, page - 1)}
+ >
+ Previous
+
+ = 19}
+ onClick={() => load(queue, page + 1)}
+ >
+ Next
+
+ Page {page + 1}
+
+ {title}
++ {available + ? 'Sign in to view your SDP queues and work on tickets. Your work account determines access.' + : 'Open Relay desktop to connect your SDP account. Web sign-in is not available yet.'} +
+ {available && !view && !error && ( ++ +
+ )} + {available && ( +
+
+ + Your work account determines access in SDP. This connection belongs to this desktop + session. +
+ {!available ? ( ++ +
+ ) : ( + <> + {!view && !error && ( ++ +
+ )} + {view && ( + + )} + {view && !view.configured && ( ++ +
+ )} + {view?.configured && ( +
+ {(view.status === 'disconnected' || view.status === 'expired') && (
+ void run({ action: 'connect' })}
+ >
+ Sign in with work account
+
+ )}
+ {(view.status === 'connected' || view.status === 'connecting') && (
+ void run({ action: 'disconnect' })}>
+ {view.status === 'connecting' ? 'Cancel sign-in' : 'Disconnect'}
+
+ )}
+
+ )}
+ {error && (
+ + {error} +
+ )} + + )} ++ SDP determines your permissions. Sign-in requests read, create, update and delete access; + every live change requires review and confirmation. Existing read-only sessions need a new + work sign-in to grant these permissions. Saved outage copies remain read-only. +
+
+ state.setEnabled(!state.enabled)}
+ >
+ {state.enabled ? 'Stop monitoring' : 'Monitor queues'}
+
+
+ Ticket rules
+
+
+ + +
+
+
+ How ticket monitoring works
++ Queues are checked every 30 seconds while Relay is running and your SDP account is + connected, including when you use another tab. A full check runs every five minutes. + Coverage is limited to 1,000 tickets per queue; the first scan establishes a baseline. + Busy queues may require another scan for replies. Matching NOC workflow tickets are + automatically linked after their description confirms the exact Dynatrace problem URL. Up + to five candidates are checked per scan; ambiguous matches stay unlinked. Unlinking + prevents automatic relinking across the workspace. Ticket rules are opt-in. +
+
+
+ + Attachments {files.length} +
++ {enabled + ? 'Up to 10 MB per file. Review before uploading.' + : 'Reconnect to SDP to upload or save files.'} +
+ {!files.length &&No attachments yet.
} + {!!files.length && ( +-
+ {files.map((file) => (
+
-
+
+ + {file.name} + + {fileSize(file.size)} + {file.size > SDP_ATTACHMENT_MAX_BYTES && ' · Over the 10 MB download limit'} + ++} + aria-label={`Save ${file.name}`} + loading={activity === file.id} + disabled={!enabled || busy || !!review || file.size > SDP_ATTACHMENT_MAX_BYTES} + onClick={() => void download(file.id)} + > + {activity === file.id ? 'Saving…' : 'Save file'} + +
+ ))}
+
+ +
+ )} + {review?.mutation.kind === 'attachment' && ( +
+
+
+ {review.mutation.name}
+
+ {fileSize(size)} · Ticket {number}
+
+
+ + The file becomes a ticket attachment and may be visible to the requester according to + SDP permissions. +
++ Each ticket is updated separately. A conflict or unconfirmed result stops the remaining + changes. SDP may send notifications. +
+-
+ {tickets.map((ticket) => (
+
- + #{ticket.number} — {ticket.subject} + {results && ( + + {' '} + · {outcomes[results.find((r) => r.id === ticket.id)?.status ?? 'not-attempted']} + + )} + + ))} +
+ +
+ )} + {!finished && + (review ? ( +-
+ {Object.entries(patch).map(([key, value]) => (
+
- {fields[key as keyof typeof fields]} +
- {value ?? 'Unassigned'} +
+
+ ))}
+
+
Leave fields blank to keep their existing values. Choose values from SDP.
+ {Object.entries(fields).map(([key, label]) => ( +
+ {standardFieldKey(key) ? (
+ {
+ if (key === 'group') setGroupId(id);
+ setPatch((current) => {
+ const next = { ...current };
+ if (value) next[key as keyof SdpRequestFields] = value;
+ else delete next[key as keyof SdpRequestFields];
+ if (key === 'group') delete next.technician;
+ return next;
+ });
+ }}
+ />
+ ) : (
+