arsam
36eb0c63c0
Import the existing local project snapshot. This commit organizes existing files; it does not represent newly developed functionality.
1405 lines
71 KiB
Markdown
1405 lines
71 KiB
Markdown
# CoaxysPanel Backend Product Contract
|
|
|
|
## Purpose
|
|
|
|
1. CoaxysPanel is a hosting control panel product with a production-oriented frontend already in place.
|
|
2. The backend should become the trusted control plane behind the existing frontend.
|
|
3. The backend should provide account, server, website, domain, file, database, email, security, automation, backup, notification, audit, support, and settings services.
|
|
4. The backend should treat the current frontend mock service layer as the public frontend contract surface.
|
|
5. The backend should preserve the product feel of a dense hosting administration interface.
|
|
6. The backend should support the CoaxysPanel brand without using third-party control-panel trademarks or copied assets.
|
|
7. The backend should be designed for real hosting operations, not only visual demos.
|
|
8. The backend should keep destructive infrastructure operations guarded by explicit policy.
|
|
9. The backend should keep the frontend responsive while long-running operations continue asynchronously.
|
|
10. The backend should provide typed, stable, versionable responses for all frontend modules.
|
|
11. The backend should make real infrastructure state visible without exposing unsafe command execution to the browser.
|
|
12. The backend should separate user-facing workflows from privileged host-level execution.
|
|
13. The backend should support mock, staging, and production environments through the same conceptual contracts.
|
|
14. The backend should make it possible to replace mock data one service at a time.
|
|
15. The backend should not require the frontend to know implementation details of servers, packages, daemons, or storage engines.
|
|
16. The frontend should continue to depend on service interfaces rather than importing raw backend payloads directly.
|
|
17. The frontend should receive normalized data that matches the current DTO vocabulary.
|
|
18. The frontend should show loading, success, error, empty, permission, maintenance, and partial-failure states from backend signals.
|
|
19. The backend should provide enough metadata for the frontend to explain status clearly.
|
|
20. The backend should treat every panel action as an auditable business event.
|
|
|
|
## Product Scope
|
|
|
|
21. The backend should own authentication and session lifecycle.
|
|
22. The backend should own account selection and current server context.
|
|
23. The backend should own permission evaluation for all modules.
|
|
24. The backend should own hosting-account data.
|
|
25. The backend should own website and application records.
|
|
26. The backend should own domain records and DNS-zone state.
|
|
27. The backend should own file-manager metadata and file-operation jobs.
|
|
28. The backend should own database inventory and database-user relationships.
|
|
29. The backend should own mailbox inventory and email-routing state.
|
|
30. The backend should own metrics ingestion and metric summaries.
|
|
31. The backend should own security findings and security policy state.
|
|
32. The backend should own software-runtime availability.
|
|
33. The backend should own advanced tools that inspect or coordinate server state.
|
|
34. The backend should own server-administration models.
|
|
35. The backend should own users, teams, resellers, roles, and package models.
|
|
36. The backend should own backup schedules, backup artifacts, and restore jobs.
|
|
37. The backend should own automation definitions and automation execution history.
|
|
38. The backend should own notification delivery preferences and notification events.
|
|
39. The backend should own audit-event persistence.
|
|
40. The backend should own support-ticket and diagnostic-report state.
|
|
41. The backend should own global and per-account settings.
|
|
42. The backend should provide read models optimized for the frontend shell.
|
|
43. The backend should provide write models optimized for validated panel operations.
|
|
44. The backend should define ownership boundaries for every module.
|
|
45. The backend should preserve module independence where practical.
|
|
46. The backend should support future module additions without rewriting the app shell.
|
|
47. The backend should expose consistent navigation and capability metadata.
|
|
48. The backend should identify unavailable modules explicitly.
|
|
49. The backend should avoid hidden failures behind generic success messages.
|
|
50. The backend should make backend maintenance state visible to the frontend.
|
|
|
|
## Core Principles
|
|
|
|
51. The backend should be contract-first.
|
|
52. The backend should be permission-aware by default.
|
|
53. The backend should be tenant-aware by default.
|
|
54. The backend should be audit-aware by default.
|
|
55. The backend should be failure-aware by default.
|
|
56. The backend should be localization-ready.
|
|
57. The backend should be observability-ready.
|
|
58. The backend should be horizontally scalable where panel traffic requires it.
|
|
59. The backend should support background jobs for slow operations.
|
|
60. The backend should support eventual consistency where infrastructure state cannot be instant.
|
|
61. The backend should not block ordinary UI reads on slow server probes.
|
|
62. The backend should not expose raw secrets to the browser after creation.
|
|
63. The backend should not expose host credentials to frontend clients.
|
|
64. The backend should not treat frontend validation as sufficient.
|
|
65. The backend should not trust client-provided role or permission claims.
|
|
66. The backend should not assume a single server forever.
|
|
67. The backend should not assume a single account forever.
|
|
68. The backend should not assume all customers have the same feature set.
|
|
69. The backend should not require every operation to be synchronous.
|
|
70. The backend should not create fake success for infrastructure actions.
|
|
71. The backend should provide explicit job states for deferred work.
|
|
72. The backend should provide explicit conflict states for contested resources.
|
|
73. The backend should provide explicit validation fields for form errors.
|
|
74. The backend should provide explicit maintenance states for unavailable modules.
|
|
75. The backend should provide explicit permission states for denied modules.
|
|
76. The backend should provide stable identifiers across refreshes.
|
|
77. The backend should provide human-readable names alongside stable identifiers.
|
|
78. The backend should preserve immutable audit data.
|
|
79. The backend should keep destructive actions reversible when the domain allows it.
|
|
80. The backend should document irreversible actions in response metadata.
|
|
|
|
## API Envelope
|
|
|
|
81. Every backend response should use a standard envelope.
|
|
82. Successful responses should contain `data`.
|
|
83. Successful responses should contain `meta`.
|
|
84. Successful responses should contain `error: null`.
|
|
85. Failed responses should contain `data: null`.
|
|
86. Failed responses should contain `meta`.
|
|
87. Failed responses should contain a structured `error`.
|
|
88. The error object should contain a stable code.
|
|
89. The error object should contain a human-readable message.
|
|
90. The error object should contain field-level errors when validation fails.
|
|
91. The meta object should include a request identifier.
|
|
92. The meta object should include pagination metadata for list responses.
|
|
93. The meta object should include sort metadata when sorting is applied.
|
|
94. The meta object should include filter metadata when filters are applied.
|
|
95. The meta object should include permission metadata when useful.
|
|
96. The meta object should include partial-failure metadata when applicable.
|
|
97. The meta object should include freshness metadata for cached infrastructure state.
|
|
98. The meta object should include maintenance metadata for degraded services.
|
|
99. The meta object should include job metadata when an operation starts background work.
|
|
100. The meta object should include rate-limit metadata where customer-facing limits exist.
|
|
|
|
## API Consistency
|
|
|
|
101. List endpoints should share pagination semantics.
|
|
102. List endpoints should share search semantics.
|
|
103. List endpoints should share filter semantics.
|
|
104. List endpoints should share sort semantics.
|
|
105. List endpoints should provide total counts when feasible.
|
|
106. List endpoints should provide cursor metadata when offset pagination is unsuitable.
|
|
107. Detail endpoints should include all fields needed by the current page.
|
|
108. Detail endpoints should avoid requiring many dependent calls for first render.
|
|
109. Mutation endpoints should return the updated resource or a job reference.
|
|
110. Bulk endpoints should return per-item status.
|
|
111. Bulk endpoints should report partial failures explicitly.
|
|
112. Create endpoints should return the canonical new resource identifier.
|
|
113. Update endpoints should report conflict versions when optimistic concurrency fails.
|
|
114. Delete endpoints should distinguish soft delete, trash, archive, and permanent delete.
|
|
115. Restore endpoints should describe restored scope.
|
|
116. Import endpoints should describe parsed resources, warnings, and rejected records.
|
|
117. Export endpoints should return export metadata and delivery status.
|
|
118. Validation endpoints should return field-level errors without performing the operation.
|
|
119. Preview endpoints should return impact summaries without performing the operation.
|
|
120. Capability endpoints should describe what the authenticated user can see and do.
|
|
|
|
## Frontend Wiring Contract
|
|
|
|
121. The frontend should keep using `src/api/services` as the service boundary.
|
|
122. The frontend should switch from mock services to HTTP-backed services behind the same method names.
|
|
123. The frontend should preserve TanStack Query query keys as stable cache concepts.
|
|
124. The frontend should invalidate query groups after successful mutations.
|
|
125. The frontend should use backend request identifiers in error displays where helpful.
|
|
126. The frontend should map backend field errors into React Hook Form fields.
|
|
127. The frontend should keep route definitions independent from HTTP transport details.
|
|
128. The frontend should receive permission data before showing protected module actions.
|
|
129. The frontend should treat backend permission denials as valid product states.
|
|
130. The frontend should treat backend maintenance states as valid product states.
|
|
131. The frontend should show backend job progress for long-running operations.
|
|
132. The frontend should show backend conflict warnings before overwriting data.
|
|
133. The frontend should show backend validation messages without inventing alternate meanings.
|
|
134. The frontend should not infer infrastructure success from a started job.
|
|
135. The frontend should not assume mock-only latency in production.
|
|
136. The frontend should not assume all tables fit in memory.
|
|
137. The frontend should not assume all file trees are small.
|
|
138. The frontend should not assume all log streams are finite.
|
|
139. The frontend should not assume all charts have complete data.
|
|
140. The frontend should not assume all routes are available for every role.
|
|
|
|
## Authentication
|
|
|
|
141. The backend should provide login.
|
|
142. The backend should provide logout.
|
|
143. The backend should provide session refresh.
|
|
144. The backend should provide session expiration signals.
|
|
145. The backend should provide forgot-password flow state.
|
|
146. The backend should provide reset-password flow state.
|
|
147. The backend should provide two-factor challenge state.
|
|
148. The backend should provide recovery-code challenge state.
|
|
149. The backend should provide passkey authentication state.
|
|
150. The backend should provide device-verification state.
|
|
151. The backend should provide account-locked state.
|
|
152. The backend should provide invitation-acceptance state.
|
|
153. The backend should provide first-run setup state.
|
|
154. The backend should provide current-user identity.
|
|
155. The backend should provide current-account identity.
|
|
156. The backend should provide current-server identity.
|
|
157. The backend should provide available account selectors.
|
|
158. The backend should provide available server selectors.
|
|
159. The backend should provide user preferences after authentication.
|
|
160. The backend should provide active session metadata.
|
|
|
|
## Authentication Safety
|
|
|
|
161. Password validation should be enforced by the backend.
|
|
162. Two-factor policy should be enforced by the backend.
|
|
163. Passkey policy should be enforced by the backend.
|
|
164. Recovery-code policy should be enforced by the backend.
|
|
165. Device verification should be enforced by the backend.
|
|
166. Account lockout should be enforced by the backend.
|
|
167. Session timeout should be enforced by the backend.
|
|
168. Session revocation should be enforced by the backend.
|
|
169. Invitation expiration should be enforced by the backend.
|
|
170. First-run setup completion should be enforced by the backend.
|
|
171. Login attempts should be audited.
|
|
172. Failed login attempts should be audited.
|
|
173. Password resets should be audited.
|
|
174. Two-factor changes should be audited.
|
|
175. Passkey changes should be audited.
|
|
176. Trusted-device changes should be audited.
|
|
177. Session termination should be audited.
|
|
178. Account lock events should be audited.
|
|
179. Recovery-code usage should be audited.
|
|
180. Invitation acceptance should be audited.
|
|
|
|
## Permissions
|
|
|
|
181. The backend should own the canonical permission model.
|
|
182. The backend should support module permissions.
|
|
183. The backend should support action permissions.
|
|
184. The backend should support account-scoped permissions.
|
|
185. The backend should support server-scoped permissions.
|
|
186. The backend should support reseller-scoped permissions.
|
|
187. The backend should support support-operator permissions.
|
|
188. The backend should support read-only auditor permissions.
|
|
189. The backend should support custom roles.
|
|
190. The backend should support permission inheritance.
|
|
191. The backend should support permission overrides.
|
|
192. The backend should support permission previews.
|
|
193. The backend should support permission-denied response states.
|
|
194. The backend should support permission metadata in navigation responses.
|
|
195. The backend should support feature-list restrictions.
|
|
196. The backend should support package restrictions.
|
|
197. The backend should support suspension restrictions.
|
|
198. The backend should support maintenance restrictions.
|
|
199. The backend should support emergency-lockdown restrictions.
|
|
200. The backend should make permissions auditable.
|
|
|
|
## Dashboard
|
|
|
|
201. The backend should provide dashboard account information.
|
|
202. The backend should provide dashboard server information.
|
|
203. The backend should provide dashboard resource usage.
|
|
204. The backend should provide dashboard service status.
|
|
205. The backend should provide dashboard quick-action availability.
|
|
206. The backend should provide dashboard widget preferences.
|
|
207. The backend should provide dashboard widget order.
|
|
208. The backend should provide dashboard hidden-widget state.
|
|
209. The backend should provide dashboard refresh timestamps.
|
|
210. The backend should provide dashboard stale-data indicators.
|
|
211. The backend should provide dashboard partial-failure indicators.
|
|
212. The backend should provide dashboard empty states for new accounts.
|
|
213. The backend should provide dashboard warnings for quota pressure.
|
|
214. The backend should provide dashboard warnings for service degradation.
|
|
215. The backend should provide dashboard warnings for expiring certificates.
|
|
216. The backend should provide dashboard warnings for failed backups.
|
|
217. The backend should provide dashboard warnings for security findings.
|
|
218. The backend should provide dashboard links to relevant modules.
|
|
219. The backend should provide dashboard metrics at suitable granularity.
|
|
220. The backend should keep dashboard reads fast.
|
|
|
|
## Tools Registry
|
|
|
|
221. The backend should expose available tools for the authenticated user.
|
|
222. The backend should expose tool categories.
|
|
223. The backend should expose tool labels.
|
|
224. The backend should expose tool descriptions.
|
|
225. The backend should expose tool keywords.
|
|
226. The backend should expose tool badges.
|
|
227. The backend should expose tool warnings.
|
|
228. The backend should expose tool permission status.
|
|
229. The backend should expose tool availability status.
|
|
230. The backend should expose tool maintenance status.
|
|
231. The backend should expose tool favorite state.
|
|
232. The backend should expose recently used tools.
|
|
233. The backend should accept favorite ordering.
|
|
234. The backend should accept recently used updates.
|
|
235. The backend should support tool search.
|
|
236. The backend should support category filtering.
|
|
237. The backend should support tools hidden by packages.
|
|
238. The backend should support tools hidden by reseller policy.
|
|
239. The backend should support tools disabled by server capability.
|
|
240. The backend should make tool metadata stable enough for frontend caching.
|
|
|
|
## Websites
|
|
|
|
241. The backend should provide website lists.
|
|
242. The backend should provide website details.
|
|
243. The backend should provide website creation state.
|
|
244. The backend should provide website runtime choices.
|
|
245. The backend should provide domain assignment choices.
|
|
246. The backend should provide SSL assignment choices.
|
|
247. The backend should provide backup assignment choices.
|
|
248. The backend should provide database assignment choices.
|
|
249. The backend should provide repository assignment choices.
|
|
250. The backend should provide upload assignment choices.
|
|
251. The backend should validate website names.
|
|
252. The backend should validate document roots.
|
|
253. The backend should validate runtime settings.
|
|
254. The backend should validate environment variables.
|
|
255. The backend should validate resource limits.
|
|
256. The backend should validate deployment settings.
|
|
257. The backend should validate maintenance-mode settings.
|
|
258. The backend should validate redirect settings.
|
|
259. The backend should validate health-check settings.
|
|
260. The backend should return website creation as a job when provisioning is required.
|
|
|
|
## Website Operations
|
|
|
|
261. Website creation should be auditable.
|
|
262. Website deletion should be auditable.
|
|
263. Website cloning should be auditable.
|
|
264. Website staging creation should be auditable.
|
|
265. Website deployment should be auditable.
|
|
266. Website rollback should be auditable.
|
|
267. Website domain assignment should be auditable.
|
|
268. Website SSL assignment should be auditable.
|
|
269. Website backup assignment should be auditable.
|
|
270. Website runtime changes should be auditable.
|
|
271. Website environment changes should be auditable.
|
|
272. Website resource-limit changes should be auditable.
|
|
273. Website process changes should be auditable.
|
|
274. Website maintenance-mode changes should be auditable.
|
|
275. Website redirect changes should be auditable.
|
|
276. Website health-check changes should be auditable.
|
|
277. Website log access should be permission-gated.
|
|
278. Website deployment logs should be streamable.
|
|
279. Website access logs should be filterable.
|
|
280. Website error logs should be filterable.
|
|
|
|
## Domains
|
|
|
|
281. The backend should provide domain lists.
|
|
282. The backend should provide domain details.
|
|
283. The backend should provide subdomain records.
|
|
284. The backend should provide alias records.
|
|
285. The backend should provide parked-domain records.
|
|
286. The backend should provide redirect records.
|
|
287. The backend should provide domain transfer status.
|
|
288. The backend should provide domain verification status.
|
|
289. The backend should provide DNSSEC status.
|
|
290. The backend should provide nameserver settings.
|
|
291. The backend should provide domain health state.
|
|
292. The backend should provide propagation status.
|
|
293. The backend should provide certificate status.
|
|
294. The backend should validate domain syntax.
|
|
295. The backend should validate ownership checks.
|
|
296. The backend should validate redirect targets.
|
|
297. The backend should validate nameserver changes.
|
|
298. The backend should validate alias conflicts.
|
|
299. The backend should validate subdomain conflicts.
|
|
300. The backend should report DNS and certificate dependencies clearly.
|
|
|
|
## DNS
|
|
|
|
301. The backend should provide DNS-zone records.
|
|
302. The backend should support A records.
|
|
303. The backend should support AAAA records.
|
|
304. The backend should support CNAME records.
|
|
305. The backend should support MX records.
|
|
306. The backend should support TXT records.
|
|
307. The backend should support SRV records.
|
|
308. The backend should support CAA records.
|
|
309. The backend should support NS records.
|
|
310. The backend should support PTR records where applicable.
|
|
311. The backend should validate record names.
|
|
312. The backend should validate record values.
|
|
313. The backend should validate TTL values.
|
|
314. The backend should validate priority values.
|
|
315. The backend should validate record conflicts.
|
|
316. The backend should validate apex restrictions.
|
|
317. The backend should validate CNAME exclusivity.
|
|
318. The backend should validate MX dependencies.
|
|
319. The backend should validate CAA syntax.
|
|
320. The backend should return propagation-check state.
|
|
|
|
## DNS Operations
|
|
|
|
321. DNS record creation should be auditable.
|
|
322. DNS record editing should be auditable.
|
|
323. DNS record duplication should be auditable.
|
|
324. DNS record deletion should be auditable.
|
|
325. DNS bulk deletion should be auditable.
|
|
326. DNS imports should be auditable.
|
|
327. DNS exports should be auditable.
|
|
328. Raw-zone edits should be auditable.
|
|
329. DNSSEC changes should be auditable.
|
|
330. Nameserver changes should be auditable.
|
|
331. DNS operations should identify affected zones.
|
|
332. DNS operations should identify affected records.
|
|
333. DNS operations should identify conflicts.
|
|
334. DNS operations should identify warnings.
|
|
335. DNS operations should identify propagation expectations.
|
|
336. DNS operations should not require frontend parsing of raw zone files.
|
|
337. DNS operations should return normalized records.
|
|
338. DNS operations should preserve comments where the backend supports them.
|
|
339. DNS operations should protect provider-managed records.
|
|
340. DNS operations should expose read-only records as read-only.
|
|
|
|
## Files
|
|
|
|
341. The backend should provide directory trees.
|
|
342. The backend should provide file lists.
|
|
343. The backend should provide file details.
|
|
344. The backend should provide file previews.
|
|
345. The backend should provide image previews.
|
|
346. The backend should provide text previews.
|
|
347. The backend should provide source previews.
|
|
348. The backend should provide upload jobs.
|
|
349. The backend should provide download authorizations.
|
|
350. The backend should provide archive jobs.
|
|
351. The backend should provide extract jobs.
|
|
352. The backend should provide compress jobs.
|
|
353. The backend should provide trash state.
|
|
354. The backend should provide restore state.
|
|
355. The backend should provide permission metadata.
|
|
356. The backend should provide ownership metadata.
|
|
357. The backend should provide checksum metadata.
|
|
358. The backend should provide storage usage.
|
|
359. The backend should provide hidden-file visibility policy.
|
|
360. The backend should provide conflict-resolution options.
|
|
|
|
## File Operations
|
|
|
|
361. File upload should be job-aware.
|
|
362. Multi-file upload should be job-aware.
|
|
363. Drag-and-drop upload should be job-aware.
|
|
364. File rename should be conflict-aware.
|
|
365. File move should be conflict-aware.
|
|
366. File copy should be conflict-aware.
|
|
367. File duplicate should be conflict-aware.
|
|
368. File delete should be trash-aware.
|
|
369. File restore should be conflict-aware.
|
|
370. File creation should validate path and name.
|
|
371. Directory creation should validate path and name.
|
|
372. Archive creation should report progress.
|
|
373. Archive extraction should report progress.
|
|
374. Compression should report progress.
|
|
375. Permission changes should be auditable.
|
|
376. Ownership display should be accurate.
|
|
377. Checksum calculation should be asynchronous for large files.
|
|
378. Source editing should preserve encoding metadata.
|
|
379. Source editing should detect concurrent modifications.
|
|
380. Source editing should report validation warnings where supported.
|
|
|
|
## File Safety
|
|
|
|
381. The backend should prevent path traversal.
|
|
382. The backend should enforce account root boundaries.
|
|
383. The backend should hide unauthorized paths.
|
|
384. The backend should protect system paths.
|
|
385. The backend should protect panel-owned files.
|
|
386. The backend should enforce upload size limits.
|
|
387. The backend should enforce file count limits.
|
|
388. The backend should enforce extension restrictions where configured.
|
|
389. The backend should scan uploads where policy requires it.
|
|
390. The backend should quarantine suspicious files where policy requires it.
|
|
391. The backend should avoid exposing server absolute paths beyond allowed account context.
|
|
392. The backend should avoid exposing raw host usernames unless policy permits it.
|
|
393. The backend should represent symlinks safely.
|
|
394. The backend should make destructive file operations reversible when possible.
|
|
395. The backend should require confirmation metadata for permanent deletes.
|
|
396. The backend should keep operation transcripts for audits.
|
|
397. The backend should support Web Disk state.
|
|
398. The backend should support FTP account state.
|
|
399. The backend should support FTP session state.
|
|
400. The backend should support Git repository state.
|
|
|
|
## Databases
|
|
|
|
401. The backend should provide MySQL database state.
|
|
402. The backend should provide MariaDB database state.
|
|
403. The backend should provide PostgreSQL database state.
|
|
404. The backend should provide database user state.
|
|
405. The backend should provide database permission state.
|
|
406. The backend should provide database creation workflow state.
|
|
407. The backend should provide remote access state.
|
|
408. The backend should provide backup state.
|
|
409. The backend should provide restore state.
|
|
410. The backend should provide size analytics.
|
|
411. The backend should provide active connection state.
|
|
412. The backend should provide slow query summaries.
|
|
413. The backend should provide process-list state.
|
|
414. The backend should provide admin-tool launch readiness.
|
|
415. The backend should validate database names.
|
|
416. The backend should validate database usernames.
|
|
417. The backend should validate passwords.
|
|
418. The backend should validate privileges.
|
|
419. The backend should validate remote hosts.
|
|
420. The backend should validate backup policies.
|
|
|
|
## Database Operations
|
|
|
|
421. Database creation should be auditable.
|
|
422. Database deletion should be auditable.
|
|
423. Database rename should be auditable where supported.
|
|
424. Database user creation should be auditable.
|
|
425. Database user deletion should be auditable.
|
|
426. Database password changes should be auditable.
|
|
427. Database privilege changes should be auditable.
|
|
428. Remote access changes should be auditable.
|
|
429. Database backup creation should be auditable.
|
|
430. Database restore should be auditable.
|
|
431. Admin-tool launch should be auditable.
|
|
432. Connection tests should return explicit results.
|
|
433. Connection tests should not expose passwords.
|
|
434. Process-list actions should be permission-gated.
|
|
435. Slow query access should be permission-gated.
|
|
436. Database analytics should be cacheable.
|
|
437. Database storage values should be normalized.
|
|
438. Database engines should be represented explicitly.
|
|
439. Database versions should be represented explicitly.
|
|
440. Database limits should be represented explicitly.
|
|
|
|
## Email
|
|
|
|
441. The backend should provide email account state.
|
|
442. The backend should provide mailbox creation state.
|
|
443. The backend should provide quota state.
|
|
444. The backend should provide password-management state.
|
|
445. The backend should provide forwarder state.
|
|
446. The backend should provide domain-forwarder state.
|
|
447. The backend should provide routing state.
|
|
448. The backend should provide autoresponder state.
|
|
449. The backend should provide default-address state.
|
|
450. The backend should provide mailing-list state.
|
|
451. The backend should provide delivery-tracking state.
|
|
452. The backend should provide email-filter state.
|
|
453. The backend should provide global-filter state.
|
|
454. The backend should provide spam-filtering state.
|
|
455. The backend should provide DKIM state.
|
|
456. The backend should provide SPF state.
|
|
457. The backend should provide DMARC state.
|
|
458. The backend should provide encryption state.
|
|
459. The backend should provide calendar state.
|
|
460. The backend should provide contact state.
|
|
|
|
## Email Operations
|
|
|
|
461. Mailbox creation should be auditable.
|
|
462. Mailbox deletion should be auditable.
|
|
463. Mailbox quota changes should be auditable.
|
|
464. Mailbox password changes should be auditable.
|
|
465. Forwarder changes should be auditable.
|
|
466. Routing changes should be auditable.
|
|
467. Autoresponder changes should be auditable.
|
|
468. Default-address changes should be auditable.
|
|
469. Mailing-list changes should be auditable.
|
|
470. Delivery tracking should be searchable.
|
|
471. Email filters should be testable.
|
|
472. Spam filter changes should be auditable.
|
|
473. DKIM changes should be auditable.
|
|
474. SPF changes should be auditable.
|
|
475. DMARC changes should be auditable.
|
|
476. Encryption key changes should be auditable.
|
|
477. Mail queue actions should be auditable.
|
|
478. Mail log access should be permission-gated.
|
|
479. Webmail launch should be auditable.
|
|
480. Client configuration should be generated from canonical server data.
|
|
|
|
## Email Client Configuration
|
|
|
|
481. The backend should provide IMAP settings.
|
|
482. The backend should provide SMTP settings.
|
|
483. The backend should provide POP3 settings.
|
|
484. The backend should provide TLS information.
|
|
485. The backend should provide mobile configuration data.
|
|
486. The backend should provide desktop configuration data.
|
|
487. The backend should provide server hostnames.
|
|
488. The backend should provide ports.
|
|
489. The backend should provide encryption requirements.
|
|
490. The backend should provide authentication methods.
|
|
491. The backend should provide username formats.
|
|
492. The backend should provide mailbox storage data.
|
|
493. The backend should provide last-login data.
|
|
494. The backend should provide forwarding state.
|
|
495. The backend should provide spam score summaries.
|
|
496. The backend should provide authentication status.
|
|
497. The backend should provide active sessions.
|
|
498. The backend should provide device setup hints as data.
|
|
499. The backend should avoid exposing passwords.
|
|
500. The backend should keep generated settings account-specific.
|
|
|
|
## Metrics
|
|
|
|
501. The backend should provide visitor metrics.
|
|
502. The backend should provide access-log summaries.
|
|
503. The backend should provide error-log summaries.
|
|
504. The backend should provide bandwidth metrics.
|
|
505. The backend should provide raw-access metadata.
|
|
506. The backend should provide AWStats-style metrics.
|
|
507. The backend should provide Webalizer-style metrics.
|
|
508. The backend should provide resource-usage metrics.
|
|
509. The backend should provide CPU history.
|
|
510. The backend should provide memory history.
|
|
511. The backend should provide disk history.
|
|
512. The backend should provide network-traffic history.
|
|
513. The backend should provide HTTP-status distributions.
|
|
514. The backend should provide top URLs.
|
|
515. The backend should provide top referrers.
|
|
516. The backend should provide top countries.
|
|
517. The backend should provide top user agents.
|
|
518. The backend should provide top IP addresses.
|
|
519. The backend should provide database performance metrics.
|
|
520. The backend should provide email-delivery metrics.
|
|
|
|
## Metrics Behavior
|
|
|
|
521. Metrics responses should support date ranges.
|
|
522. Metrics responses should support comparison ranges.
|
|
523. Metrics responses should support export metadata.
|
|
524. Metrics responses should support live-update indicators.
|
|
525. Metrics responses should support empty states.
|
|
526. Metrics responses should support delayed-ingestion states.
|
|
527. Metrics responses should support partial data warnings.
|
|
528. Metrics responses should support timezone-aware labels.
|
|
529. Metrics responses should support account scoping.
|
|
530. Metrics responses should support domain scoping.
|
|
531. Metrics responses should support website scoping.
|
|
532. Metrics responses should support server scoping.
|
|
533. Metrics responses should normalize units.
|
|
534. Metrics responses should identify sampled data.
|
|
535. Metrics responses should identify estimated data.
|
|
536. Metrics responses should avoid leaking other tenants.
|
|
537. Metrics exports should be auditable.
|
|
538. Metrics retention should be policy-driven.
|
|
539. Metrics aggregation should be product-consistent.
|
|
540. Metrics freshness should be visible.
|
|
|
|
## Security
|
|
|
|
541. The backend should provide SSL/TLS status.
|
|
542. The backend should provide certificate management state.
|
|
543. The backend should provide Let's Encrypt state.
|
|
544. The backend should provide custom certificate upload state.
|
|
545. The backend should provide CSR state.
|
|
546. The backend should provide private-key metadata.
|
|
547. The backend should provide automatic HTTPS state.
|
|
548. The backend should provide HTTPS redirect state.
|
|
549. The backend should provide HSTS state.
|
|
550. The backend should provide SSH access state.
|
|
551. The backend should provide SSH key state.
|
|
552. The backend should provide IP blocker state.
|
|
553. The backend should provide firewall state.
|
|
554. The backend should provide port-rule state.
|
|
555. The backend should provide brute-force protection state.
|
|
556. The backend should provide WAF rule state.
|
|
557. The backend should provide malware scanning state.
|
|
558. The backend should provide antivirus scanning state.
|
|
559. The backend should provide file-integrity state.
|
|
560. The backend should provide security-advisor state.
|
|
|
|
## Security Operations
|
|
|
|
561. Certificate issuance should be job-aware.
|
|
562. Certificate renewal should be job-aware.
|
|
563. Certificate upload should validate chains.
|
|
564. CSR generation should be auditable.
|
|
565. Private-key import should be guarded.
|
|
566. HTTPS redirect changes should be auditable.
|
|
567. HSTS changes should be auditable.
|
|
568. SSH key changes should be auditable.
|
|
569. IP blocker changes should be auditable.
|
|
570. Firewall changes should be auditable.
|
|
571. Port-rule changes should be auditable.
|
|
572. Brute-force policy changes should be auditable.
|
|
573. WAF rule changes should be auditable.
|
|
574. Malware scans should be job-aware.
|
|
575. Antivirus scans should be job-aware.
|
|
576. Integrity scans should be job-aware.
|
|
577. Security findings should have severity.
|
|
578. Security findings should have target metadata.
|
|
579. Security findings should have recommended actions.
|
|
580. Security findings should have remediation status.
|
|
|
|
## Defensive Boundary
|
|
|
|
581. The backend should treat security modules as defensive administration interfaces.
|
|
582. The backend should not expose offensive attack tooling.
|
|
583. The backend should not execute arbitrary user-provided attack payloads.
|
|
584. The backend should not provide exploit automation.
|
|
585. The backend should not provide credential harvesting features.
|
|
586. The backend should not expose private keys after creation unless explicit policy allows it.
|
|
587. The backend should not reveal sensitive scan internals to unauthorized users.
|
|
588. The backend should not allow firewall lockout without recovery policy.
|
|
589. The backend should not allow security-policy bypass from the frontend.
|
|
590. The backend should not silently downgrade security settings.
|
|
591. The backend should provide safe previews for risky changes.
|
|
592. The backend should provide typed confirmation requirements.
|
|
593. The backend should provide reason-field requirements.
|
|
594. The backend should provide second-factor requirements for critical actions.
|
|
595. The backend should provide impact descriptions for critical actions.
|
|
596. The backend should provide audit previews for critical actions.
|
|
597. The backend should provide rollback metadata where possible.
|
|
598. The backend should provide emergency-contact or recovery metadata where appropriate.
|
|
599. The backend should preserve evidence for security events.
|
|
600. The backend should make security state explainable.
|
|
|
|
## Software And Runtimes
|
|
|
|
601. The backend should provide PHP version state.
|
|
602. The backend should provide PHP extension state.
|
|
603. The backend should provide PHP configuration state.
|
|
604. The backend should provide per-domain PHP version state.
|
|
605. The backend should provide PHP-FPM settings state.
|
|
606. The backend should provide Node.js application state.
|
|
607. The backend should provide Node.js version state.
|
|
608. The backend should provide Python application state.
|
|
609. The backend should provide Python version state.
|
|
610. The backend should provide Ruby application state.
|
|
611. The backend should provide Docker application state.
|
|
612. The backend should provide Composer state.
|
|
613. The backend should provide npm script state.
|
|
614. The backend should provide package-manager status.
|
|
615. The backend should provide application-installer state.
|
|
616. The backend should provide runtime environment variables.
|
|
617. The backend should provide process-manager state.
|
|
618. The backend should provide website optimization state.
|
|
619. The backend should provide compression state.
|
|
620. The backend should provide cache state.
|
|
|
|
## Runtime Framework
|
|
|
|
621. Runtime definitions should be data-driven.
|
|
622. Runtime versions should be explicit.
|
|
623. Runtime extensions should be explicit.
|
|
624. Runtime process managers should be explicit.
|
|
625. Runtime environment-variable rules should be explicit.
|
|
626. Runtime resource limits should be explicit.
|
|
627. Runtime compatibility warnings should be explicit.
|
|
628. Runtime update availability should be explicit.
|
|
629. Runtime deprecation state should be explicit.
|
|
630. Runtime default settings should be explicit.
|
|
631. Runtime package operations should be job-aware.
|
|
632. Runtime process operations should be job-aware.
|
|
633. Runtime configuration changes should be auditable.
|
|
634. Runtime package changes should be auditable.
|
|
635. Runtime version changes should be auditable.
|
|
636. Runtime environment changes should be auditable.
|
|
637. Runtime restart requirements should be visible.
|
|
638. Runtime rollback availability should be visible.
|
|
639. Runtime future additions should not require frontend redesign.
|
|
640. Runtime labels should remain product-friendly.
|
|
|
|
## Advanced Tools
|
|
|
|
641. The backend should provide cron-job state.
|
|
642. The backend should provide task-scheduler state.
|
|
643. The backend should provide DNS lookup state.
|
|
644. The backend should provide traceroute state.
|
|
645. The backend should provide index-manager state.
|
|
646. The backend should provide error-page state.
|
|
647. The backend should provide MIME type state.
|
|
648. The backend should provide Apache handler state.
|
|
649. The backend should provide Nginx snippet state.
|
|
650. The backend should provide reverse-proxy rule state.
|
|
651. The backend should provide process-manager state.
|
|
652. The backend should provide service-manager state.
|
|
653. The backend should provide terminal session state.
|
|
654. The backend should provide log-viewer state.
|
|
655. The backend should provide queue-manager state.
|
|
656. The backend should provide webhook state.
|
|
657. The backend should provide API explorer metadata.
|
|
658. The backend should provide API documentation metadata.
|
|
659. The backend should provide environment-inspector state.
|
|
660. The backend should provide system-information state.
|
|
|
|
## Terminal
|
|
|
|
661. The terminal backend should be mockable.
|
|
662. The terminal backend should be permission-gated.
|
|
663. The terminal backend should be session-scoped.
|
|
664. The terminal backend should be server-scoped.
|
|
665. The terminal backend should provide connection state.
|
|
666. The terminal backend should provide tab state.
|
|
667. The terminal backend should provide transcript state.
|
|
668. The terminal backend should provide resize state.
|
|
669. The terminal backend should provide copy-paste policy.
|
|
670. The terminal backend should provide search metadata.
|
|
671. The terminal backend should provide reconnect state.
|
|
672. The terminal backend should provide fullscreen state metadata.
|
|
673. The terminal backend should provide clear-session actions.
|
|
674. The terminal backend should provide transcript download metadata.
|
|
675. The terminal backend should not expose unrestricted command execution to normal users.
|
|
676. The terminal backend should not bypass account isolation.
|
|
677. The terminal backend should not bypass audit logging.
|
|
678. The terminal backend should not bypass role restrictions.
|
|
679. The terminal backend should distinguish mock sessions from real sessions.
|
|
680. The terminal backend should be optional per server.
|
|
|
|
## Server Administration
|
|
|
|
681. The backend should provide server overview state.
|
|
682. The backend should provide server status.
|
|
683. The backend should provide services state.
|
|
684. The backend should provide process state.
|
|
685. The backend should provide network-interface state.
|
|
686. The backend should provide mounted-filesystem state.
|
|
687. The backend should provide storage-device state.
|
|
688. The backend should provide system-update state.
|
|
689. The backend should provide kernel information.
|
|
690. The backend should provide reboot state.
|
|
691. The backend should provide shutdown state.
|
|
692. The backend should provide hostname state.
|
|
693. The backend should provide timezone state.
|
|
694. The backend should provide DNS resolver state.
|
|
695. The backend should provide nameserver state.
|
|
696. The backend should provide firewall state.
|
|
697. The backend should provide package-update state.
|
|
698. The backend should provide service-log state.
|
|
699. The backend should provide health-check state.
|
|
700. The backend should provide server-registration state.
|
|
|
|
## Dangerous Server Actions
|
|
|
|
701. Reboot actions should require confirmation.
|
|
702. Shutdown actions should require confirmation.
|
|
703. Package update actions should require confirmation.
|
|
704. Kernel update actions should require confirmation.
|
|
705. Firewall lockout-risk actions should require confirmation.
|
|
706. Service restart actions should require confirmation where impact exists.
|
|
707. Migration actions should require confirmation.
|
|
708. Destructive storage actions should require confirmation.
|
|
709. Hostname changes should require impact summaries.
|
|
710. Timezone changes should require impact summaries.
|
|
711. DNS resolver changes should require impact summaries.
|
|
712. Nameserver changes should require impact summaries.
|
|
713. Reboot actions should request a reason field.
|
|
714. Shutdown actions should request a reason field.
|
|
715. Migration actions should request a reason field.
|
|
716. Destructive storage actions should request a reason field.
|
|
717. Critical actions should support mock two-factor confirmation in frontend mode.
|
|
718. Critical actions should enforce real second-factor confirmation in production mode.
|
|
719. Critical actions should create audit-preview metadata.
|
|
720. Critical actions should create final audit entries.
|
|
|
|
## Users And Teams
|
|
|
|
721. The backend should provide hosting-user state.
|
|
722. The backend should provide team-member state.
|
|
723. The backend should provide role state.
|
|
724. The backend should provide permission state.
|
|
725. The backend should provide reseller-account state.
|
|
726. The backend should provide hosting-package state.
|
|
727. The backend should provide account-quota state.
|
|
728. The backend should provide feature-list state.
|
|
729. The backend should provide impersonation state.
|
|
730. The backend should provide invitation state.
|
|
731. The backend should provide suspended-account state.
|
|
732. The backend should provide account-termination state.
|
|
733. The backend should provide account-migration state.
|
|
734. The backend should provide ownership-transfer state.
|
|
735. The backend should provide access-log state.
|
|
736. The backend should provide session-management state.
|
|
737. The backend should validate user email addresses.
|
|
738. The backend should validate role assignments.
|
|
739. The backend should validate package assignments.
|
|
740. The backend should validate quota assignments.
|
|
|
|
## Roles
|
|
|
|
741. The backend should support super administrator role.
|
|
742. The backend should support server administrator role.
|
|
743. The backend should support reseller role.
|
|
744. The backend should support hosting account owner role.
|
|
745. The backend should support developer role.
|
|
746. The backend should support billing viewer role.
|
|
747. The backend should support support operator role.
|
|
748. The backend should support read-only auditor role.
|
|
749. The backend should support custom role.
|
|
750. The backend should provide detailed permission matrices.
|
|
751. The backend should provide module-level permissions.
|
|
752. The backend should provide action-level permissions.
|
|
753. The backend should provide resource-level permissions where needed.
|
|
754. The backend should provide permission templates.
|
|
755. The backend should provide permission diffs.
|
|
756. The backend should provide permission-impact previews.
|
|
757. The backend should audit role creation.
|
|
758. The backend should audit role updates.
|
|
759. The backend should audit role deletion.
|
|
760. The backend should audit impersonation events.
|
|
|
|
## Backups
|
|
|
|
761. The backend should provide backup dashboard state.
|
|
762. The backend should provide full-account backup state.
|
|
763. The backend should provide website backup state.
|
|
764. The backend should provide database backup state.
|
|
765. The backend should provide email backup state.
|
|
766. The backend should provide configuration backup state.
|
|
767. The backend should provide incremental backup state.
|
|
768. The backend should provide snapshot backup state.
|
|
769. The backend should provide scheduled backup state.
|
|
770. The backend should provide retention-policy state.
|
|
771. The backend should provide backup-destination state.
|
|
772. The backend should provide restore-wizard state.
|
|
773. The backend should provide backup-browser state.
|
|
774. The backend should provide backup-verification state.
|
|
775. The backend should provide encryption status.
|
|
776. The backend should provide storage usage.
|
|
777. The backend should provide failed-job history.
|
|
778. The backend should provide download authorization.
|
|
779. The backend should provide delete state.
|
|
780. The backend should provide clone-from-backup state.
|
|
|
|
## Backup Destinations
|
|
|
|
781. Local storage should be represented as a destination.
|
|
782. SFTP should be represented as a destination.
|
|
783. S3-compatible storage should be represented as a destination.
|
|
784. Backblaze B2 should be represented as a destination.
|
|
785. Google Cloud Storage should be represented as a destination.
|
|
786. Azure Blob Storage should be represented as a destination.
|
|
787. Custom object storage should be represented as a destination.
|
|
788. Destination credentials should not be revealed after creation.
|
|
789. Destination tests should return explicit connection status.
|
|
790. Destination tests should return explicit permission status.
|
|
791. Destination capacity should be visible where available.
|
|
792. Destination encryption should be visible.
|
|
793. Destination retention should be visible.
|
|
794. Destination failure state should be visible.
|
|
795. Destination last-success metadata should be visible.
|
|
796. Destination last-failure metadata should be visible.
|
|
797. Destination changes should be auditable.
|
|
798. Destination deletion should be guarded.
|
|
799. Destination reuse should be supported.
|
|
800. Destination policy should be account-scoped.
|
|
|
|
## Restore
|
|
|
|
801. Restore operations should be wizard-driven.
|
|
802. Restore operations should include scope selection.
|
|
803. Restore operations should include conflict policy.
|
|
804. Restore operations should include impact preview.
|
|
805. Restore operations should include reason capture.
|
|
806. Restore operations should include second-factor confirmation.
|
|
807. Restore operations should include audit-preview metadata.
|
|
808. Restore operations should include job progress.
|
|
809. Restore operations should include rollback availability where possible.
|
|
810. Restore operations should include post-restore validation.
|
|
811. Restore operations should report partial success.
|
|
812. Restore operations should report skipped resources.
|
|
813. Restore operations should report overwritten resources.
|
|
814. Restore operations should report created resources.
|
|
815. Restore operations should report failed resources.
|
|
816. Restore operations should report warnings.
|
|
817. Restore operations should be auditable.
|
|
818. Restore downloads should be permission-gated.
|
|
819. Restore destructive choices should be explicit.
|
|
820. Restore state should remain visible after page refresh.
|
|
|
|
## Automation
|
|
|
|
821. The backend should provide scheduled-task state.
|
|
822. The backend should provide deployment-pipeline state.
|
|
823. The backend should provide webhook state.
|
|
824. The backend should provide event-trigger state.
|
|
825. The backend should provide automation-template state.
|
|
826. The backend should provide retry-policy state.
|
|
827. The backend should provide execution-history state.
|
|
828. The backend should provide failed-execution state.
|
|
829. The backend should provide environment-based workflow state.
|
|
830. The backend should provide backup automation state.
|
|
831. The backend should provide certificate automation state.
|
|
832. The backend should provide update automation state.
|
|
833. The backend should provide monitoring automation state.
|
|
834. The backend should provide notification automation state.
|
|
835. The backend should validate triggers.
|
|
836. The backend should validate conditions.
|
|
837. The backend should validate actions.
|
|
838. The backend should validate branches.
|
|
839. The backend should validate execution previews.
|
|
840. The backend should validate test-mode constraints.
|
|
|
|
## Notifications
|
|
|
|
841. The backend should provide notification-center state.
|
|
842. The backend should provide read/unread state.
|
|
843. The backend should provide categories.
|
|
844. The backend should provide notification preferences.
|
|
845. The backend should provide email notification settings.
|
|
846. The backend should provide webhook notification settings.
|
|
847. The backend should provide browser notification settings.
|
|
848. The backend should provide critical alerts.
|
|
849. The backend should provide security alerts.
|
|
850. The backend should provide backup alerts.
|
|
851. The backend should provide resource alerts.
|
|
852. The backend should provide SSL alerts.
|
|
853. The backend should provide deployment alerts.
|
|
854. The backend should provide notification delivery status.
|
|
855. The backend should provide notification retry status.
|
|
856. The backend should provide notification suppression state.
|
|
857. The backend should provide quiet-hour state.
|
|
858. The backend should provide digest state.
|
|
859. The backend should audit preference changes.
|
|
860. The backend should preserve critical-alert history.
|
|
|
|
## Support
|
|
|
|
861. The backend should provide documentation metadata.
|
|
862. The backend should provide knowledge-base metadata.
|
|
863. The backend should provide system-diagnostics state.
|
|
864. The backend should provide support-ticket lists.
|
|
865. The backend should provide ticket details.
|
|
866. The backend should provide ticket replies.
|
|
867. The backend should provide file attachment metadata.
|
|
868. The backend should provide ticket status.
|
|
869. The backend should provide ticket priority.
|
|
870. The backend should provide diagnostic-report generation state.
|
|
871. The backend should validate ticket subjects.
|
|
872. The backend should validate ticket messages.
|
|
873. The backend should validate attachments.
|
|
874. The backend should validate ticket ownership.
|
|
875. The backend should audit ticket creation.
|
|
876. The backend should audit ticket replies.
|
|
877. The backend should audit ticket status changes.
|
|
878. The backend should audit diagnostic report generation.
|
|
879. The backend should protect sensitive diagnostic data.
|
|
880. The backend should expose shareable diagnostic summaries.
|
|
|
|
## Settings
|
|
|
|
881. The backend should provide general settings.
|
|
882. The backend should provide branding settings.
|
|
883. The backend should provide logo metadata.
|
|
884. The backend should provide theme settings.
|
|
885. The backend should provide accent-color settings.
|
|
886. The backend should provide locale settings.
|
|
887. The backend should provide date-format settings.
|
|
888. The backend should provide time-format settings.
|
|
889. The backend should provide timezone settings.
|
|
890. The backend should provide session-timeout settings.
|
|
891. The backend should provide security defaults.
|
|
892. The backend should provide password policy.
|
|
893. The backend should provide two-factor policy.
|
|
894. The backend should provide email settings.
|
|
895. The backend should provide notification settings.
|
|
896. The backend should provide backup defaults.
|
|
897. The backend should provide DNS defaults.
|
|
898. The backend should provide SSL defaults.
|
|
899. The backend should provide runtime defaults.
|
|
900. The backend should provide file-manager settings.
|
|
|
|
## More Settings
|
|
|
|
901. The backend should provide API settings.
|
|
902. The backend should provide feature flags.
|
|
903. The backend should provide experimental feature state.
|
|
904. The backend should provide privacy settings.
|
|
905. The backend should provide data-retention settings.
|
|
906. The backend should provide maintenance-mode settings.
|
|
907. Settings changes should be auditable.
|
|
908. Branding changes should be auditable.
|
|
909. Theme changes should be user-scoped or account-scoped as policy requires.
|
|
910. Locale changes should be user-scoped or account-scoped as policy requires.
|
|
911. Security-default changes should be guarded.
|
|
912. Password-policy changes should be guarded.
|
|
913. Two-factor-policy changes should be guarded.
|
|
914. API-setting changes should be guarded.
|
|
915. Feature-flag changes should be guarded.
|
|
916. Maintenance-mode changes should be guarded.
|
|
917. Settings should support live preview where the frontend already previews state.
|
|
918. Settings should distinguish draft values from saved values.
|
|
919. Settings should expose inherited values.
|
|
920. Settings should expose overridden values.
|
|
|
|
## Audit Logs
|
|
|
|
921. The backend should create audit entries for authentication events.
|
|
922. The backend should create audit entries for permission events.
|
|
923. The backend should create audit entries for website events.
|
|
924. The backend should create audit entries for domain events.
|
|
925. The backend should create audit entries for DNS events.
|
|
926. The backend should create audit entries for file events.
|
|
927. The backend should create audit entries for database events.
|
|
928. The backend should create audit entries for email events.
|
|
929. The backend should create audit entries for metric export events.
|
|
930. The backend should create audit entries for security events.
|
|
931. The backend should create audit entries for software events.
|
|
932. The backend should create audit entries for advanced-tool events.
|
|
933. The backend should create audit entries for server events.
|
|
934. The backend should create audit entries for user events.
|
|
935. The backend should create audit entries for reseller events.
|
|
936. The backend should create audit entries for backup events.
|
|
937. The backend should create audit entries for restore events.
|
|
938. The backend should create audit entries for automation events.
|
|
939. The backend should create audit entries for notification events.
|
|
940. The backend should create audit entries for settings events.
|
|
|
|
## Audit Metadata
|
|
|
|
941. Audit entries should include actor identity.
|
|
942. Audit entries should include actor role context.
|
|
943. Audit entries should include account context.
|
|
944. Audit entries should include server context.
|
|
945. Audit entries should include reseller context where applicable.
|
|
946. Audit entries should include target type.
|
|
947. Audit entries should include target identifier.
|
|
948. Audit entries should include target label.
|
|
949. Audit entries should include action.
|
|
950. Audit entries should include outcome.
|
|
951. Audit entries should include request identifier.
|
|
952. Audit entries should include IP address.
|
|
953. Audit entries should include user agent where available.
|
|
954. Audit entries should include timestamp.
|
|
955. Audit entries should include reason field where required.
|
|
956. Audit entries should include confirmation metadata where required.
|
|
957. Audit entries should include before-and-after metadata where safe.
|
|
958. Audit entries should avoid storing secrets.
|
|
959. Audit entries should be immutable.
|
|
960. Audit entries should be exportable by authorized users.
|
|
|
|
## Jobs
|
|
|
|
961. The backend should represent long-running operations as jobs.
|
|
962. Jobs should have stable identifiers.
|
|
963. Jobs should have type.
|
|
964. Jobs should have status.
|
|
965. Jobs should have progress.
|
|
966. Jobs should have started timestamp.
|
|
967. Jobs should have updated timestamp.
|
|
968. Jobs should have completed timestamp when complete.
|
|
969. Jobs should have actor metadata.
|
|
970. Jobs should have target metadata.
|
|
971. Jobs should have cancellability metadata.
|
|
972. Jobs should have retry metadata.
|
|
973. Jobs should have warnings.
|
|
974. Jobs should have errors.
|
|
975. Jobs should have result summaries.
|
|
976. Jobs should have audit references.
|
|
977. Jobs should support polling.
|
|
978. Jobs should support event updates where available.
|
|
979. Jobs should remain visible after navigation.
|
|
980. Jobs should expire according to retention policy.
|
|
|
|
## Real-Time Events
|
|
|
|
981. The backend should provide event streams for job progress.
|
|
982. The backend should provide event streams for notifications.
|
|
983. The backend should provide event streams for terminal sessions.
|
|
984. The backend should provide event streams for log viewers.
|
|
985. The backend should provide event streams for deployment logs.
|
|
986. The backend should provide event streams for backup progress.
|
|
987. The backend should provide event streams for restore progress.
|
|
988. The backend should provide event streams for automation executions.
|
|
989. Event messages should include type.
|
|
990. Event messages should include timestamp.
|
|
991. Event messages should include account context.
|
|
992. Event messages should include server context where relevant.
|
|
993. Event messages should include payload.
|
|
994. Event messages should include request or job references where relevant.
|
|
995. Event messages should preserve authorization boundaries.
|
|
996. Event messages should support reconnect behavior.
|
|
997. Event messages should support last-seen cursors where applicable.
|
|
998. Event messages should not expose data from other tenants.
|
|
999. Event messages should be versionable.
|
|
1000. Event messages should remain compatible with frontend state updates.
|
|
|
|
## Errors
|
|
|
|
1001. The backend should provide validation errors.
|
|
1002. The backend should provide permission errors.
|
|
1003. The backend should provide authentication errors.
|
|
1004. The backend should provide conflict errors.
|
|
1005. The backend should provide not-found errors.
|
|
1006. The backend should provide rate-limit errors.
|
|
1007. The backend should provide maintenance errors.
|
|
1008. The backend should provide dependency errors.
|
|
1009. The backend should provide partial-failure errors.
|
|
1010. The backend should provide network-facing timeout errors.
|
|
1011. Error codes should be stable.
|
|
1012. Error messages should be readable.
|
|
1013. Error fields should map to form fields.
|
|
1014. Error metadata should include request identifiers.
|
|
1015. Error metadata should include retryability where relevant.
|
|
1016. Error metadata should include support references where relevant.
|
|
1017. Error metadata should avoid leaking secrets.
|
|
1018. Error metadata should avoid leaking host internals.
|
|
1019. Error states should be testable by the frontend.
|
|
1020. Error states should be documented as product behavior.
|
|
|
|
## Data Model Expectations
|
|
|
|
1021. Resource identifiers should be stable.
|
|
1022. Resource labels should be human-readable.
|
|
1023. Resource status values should be enumerated.
|
|
1024. Resource timestamps should be normalized.
|
|
1025. Resource ownership should be explicit.
|
|
1026. Resource server placement should be explicit.
|
|
1027. Resource account placement should be explicit.
|
|
1028. Resource feature availability should be explicit.
|
|
1029. Resource permission availability should be explicit.
|
|
1030. Resource maintenance availability should be explicit.
|
|
1031. Resource soft-delete state should be explicit.
|
|
1032. Resource archival state should be explicit.
|
|
1033. Resource health state should be explicit.
|
|
1034. Resource warning state should be explicit.
|
|
1035. Resource dependency state should be explicit.
|
|
1036. Resource quota impact should be explicit.
|
|
1037. Resource audit metadata should be explicit.
|
|
1038. Resource version metadata should be explicit where edits can conflict.
|
|
1039. Resource display metadata should be frontend-friendly.
|
|
1040. Resource transport metadata should remain separate from business data.
|
|
|
|
## Frontend State
|
|
|
|
1041. The frontend should keep global UI state in Zustand only for UI concerns.
|
|
1042. The frontend should keep server data in TanStack Query.
|
|
1043. The frontend should keep form state in React Hook Form.
|
|
1044. The frontend should keep validation schemas aligned with backend validation concepts.
|
|
1045. The frontend should keep route definitions centralized.
|
|
1046. The frontend should keep permission definitions centralized.
|
|
1047. The frontend should keep table definitions close to feature views.
|
|
1048. The frontend should keep mock services replaceable.
|
|
1049. The frontend should keep loading skeletons for backend latency.
|
|
1050. The frontend should keep empty states for backend empty responses.
|
|
|
|
## Frontend Data Handling
|
|
|
|
1051. The frontend should cache list reads by module and filter state.
|
|
1052. The frontend should cache detail reads by stable resource identifier.
|
|
1053. The frontend should invalidate related reads after mutations.
|
|
1054. The frontend should preserve optimistic UI only where backend confirmation semantics allow it.
|
|
1055. The frontend should avoid optimistic UI for irreversible operations.
|
|
1056. The frontend should show job progress for asynchronous operations.
|
|
1057. The frontend should show stale data indicators from backend metadata.
|
|
1058. The frontend should show partial-failure messages from backend metadata.
|
|
1059. The frontend should show maintenance banners from backend metadata.
|
|
1060. The frontend should show permission-denied states from backend responses.
|
|
1061. The frontend should use request IDs in support-friendly errors.
|
|
1062. The frontend should use backend-provided display labels.
|
|
1063. The frontend should use backend-provided status values.
|
|
1064. The frontend should use backend-provided quota values.
|
|
1065. The frontend should use backend-provided unit metadata.
|
|
1066. The frontend should use backend-provided route availability.
|
|
1067. The frontend should not parse logs when backend can provide structured summaries.
|
|
1068. The frontend should not calculate security scores from raw findings.
|
|
1069. The frontend should not calculate billing-grade usage from approximate metrics.
|
|
1070. The frontend should not invent backend capability state.
|
|
|
|
## Internationalization
|
|
|
|
1071. Backend-provided labels should be localizable where they are product copy.
|
|
1072. Backend-provided enum display names should be localizable.
|
|
1073. Backend-provided validation messages should support localization.
|
|
1074. Backend-provided timestamps should be timezone-neutral.
|
|
1075. Backend-provided durations should be unit-neutral.
|
|
1076. Backend-provided numeric values should be raw numbers plus unit context.
|
|
1077. Backend-provided currency values should include currency codes where billing appears.
|
|
1078. Backend-provided country names should use stable codes plus display labels.
|
|
1079. Backend-provided language choices should use stable locale identifiers.
|
|
1080. Backend-provided date formatting should not be preformatted unless explicitly needed.
|
|
|
|
## Performance
|
|
|
|
1081. Backend dashboard reads should be fast.
|
|
1082. Backend navigation reads should be fast.
|
|
1083. Backend permission reads should be fast.
|
|
1084. Backend table reads should support pagination.
|
|
1085. Backend file-list reads should support virtualized frontend consumption.
|
|
1086. Backend log reads should support streaming or cursor windows.
|
|
1087. Backend metric reads should support aggregation.
|
|
1088. Backend search reads should support bounded result sets.
|
|
1089. Backend expensive reads should expose freshness metadata.
|
|
1090. Backend expensive reads should support cached summaries.
|
|
1091. Backend write operations should not block on nonessential refresh work.
|
|
1092. Backend long-running writes should return jobs.
|
|
1093. Backend heavy exports should return jobs.
|
|
1094. Backend imports should return parsed previews or jobs.
|
|
1095. Backend file operations should return progress for large work.
|
|
1096. Backend backup operations should return progress.
|
|
1097. Backend restore operations should return progress.
|
|
1098. Backend metrics should avoid over-fetching by default.
|
|
1099. Backend tables should avoid returning unused giant payloads.
|
|
1100. Backend responses should remain predictable under load.
|
|
|
|
## Observability
|
|
|
|
1101. The backend should emit structured logs.
|
|
1102. The backend should emit request metrics.
|
|
1103. The backend should emit job metrics.
|
|
1104. The backend should emit module health metrics.
|
|
1105. The backend should emit dependency health metrics.
|
|
1106. The backend should emit authentication metrics.
|
|
1107. The backend should emit authorization-denial metrics.
|
|
1108. The backend should emit validation-failure metrics.
|
|
1109. The backend should emit audit-write metrics.
|
|
1110. The backend should emit notification-delivery metrics.
|
|
1111. The backend should emit backup-success metrics.
|
|
1112. The backend should emit backup-failure metrics.
|
|
1113. The backend should emit restore-success metrics.
|
|
1114. The backend should emit restore-failure metrics.
|
|
1115. The backend should emit certificate-renewal metrics.
|
|
1116. The backend should emit security-scan metrics.
|
|
1117. The backend should emit database-operation metrics.
|
|
1118. The backend should emit file-operation metrics.
|
|
1119. The backend should emit email-delivery metrics.
|
|
1120. The backend should correlate logs with request IDs.
|
|
|
|
## Compliance And Privacy
|
|
|
|
1121. The backend should minimize sensitive data sent to the frontend.
|
|
1122. The backend should minimize secrets stored in audit logs.
|
|
1123. The backend should minimize personal data in exports.
|
|
1124. The backend should support data retention policies.
|
|
1125. The backend should support privacy settings.
|
|
1126. The backend should support account data export where product policy requires it.
|
|
1127. The backend should support account data deletion where product policy requires it.
|
|
1128. The backend should distinguish operational logs from audit logs.
|
|
1129. The backend should distinguish customer data from platform data.
|
|
1130. The backend should support consent-sensitive notification channels where required.
|
|
1131. The backend should keep diagnostic reports scoped.
|
|
1132. The backend should redact credentials from diagnostic reports.
|
|
1133. The backend should redact tokens from diagnostic reports.
|
|
1134. The backend should redact private keys from diagnostic reports.
|
|
1135. The backend should redact connection strings from diagnostic reports.
|
|
1136. The backend should redact environment secrets from diagnostic reports.
|
|
1137. The backend should provide safe support summaries.
|
|
1138. The backend should provide retention metadata to the settings UI.
|
|
1139. The backend should make privacy-impacting changes auditable.
|
|
1140. The backend should keep compliance behavior explicit.
|
|
|
|
## Migration From Mock Services
|
|
|
|
1141. Mock services should remain useful for local frontend development.
|
|
1142. HTTP services should preserve the same conceptual methods.
|
|
1143. DTO names should remain aligned with existing contracts.
|
|
1144. Response envelopes should remain aligned with existing contracts.
|
|
1145. Error envelopes should remain aligned with existing contracts.
|
|
1146. Pagination contracts should remain aligned with existing contracts.
|
|
1147. Filtering contracts should remain aligned with existing contracts.
|
|
1148. Sorting contracts should remain aligned with existing contracts.
|
|
1149. Search contracts should remain aligned with existing contracts.
|
|
1150. Bulk-operation contracts should remain aligned with existing contracts.
|
|
1151. Job-progress contracts should remain aligned with existing contracts.
|
|
1152. Audit-metadata contracts should remain aligned with existing contracts.
|
|
1153. Permission-check contracts should remain aligned with existing contracts.
|
|
1154. WebSocket-event contracts should remain aligned with existing contracts.
|
|
1155. Mock latency should remain configurable.
|
|
1156. Mock errors should remain configurable.
|
|
1157. Mock maintenance states should remain configurable.
|
|
1158. Mock permission states should remain configurable.
|
|
1159. Mock empty states should remain configurable.
|
|
1160. Mock data should remain realistic enough for UI regression tests.
|
|
|
|
## Release Readiness
|
|
|
|
1161. The backend should be considered ready only when auth flows are wired.
|
|
1162. The backend should be considered ready only when permission checks are authoritative.
|
|
1163. The backend should be considered ready only when dashboard reads are real.
|
|
1164. The backend should be considered ready only when primary module lists are real.
|
|
1165. The backend should be considered ready only when destructive actions are guarded.
|
|
1166. The backend should be considered ready only when audit logging is durable.
|
|
1167. The backend should be considered ready only when job progress is reliable.
|
|
1168. The backend should be considered ready only when frontend errors are explainable.
|
|
1169. The backend should be considered ready only when observability is in place.
|
|
1170. The backend should be considered ready only when backup and restore semantics are clear.
|
|
1171. The backend should be considered ready only when security module boundaries are enforced.
|
|
1172. The backend should be considered ready only when tenant boundaries are enforced.
|
|
1173. The backend should be considered ready only when performance targets are met.
|
|
1174. The backend should be considered ready only when e2e frontend flows pass against it.
|
|
1175. The backend should be considered ready only when support diagnostics are safe.
|
|
1176. The backend should be considered ready only when settings persistence is reliable.
|
|
1177. The backend should be considered ready only when notification delivery is observable.
|
|
1178. The backend should be considered ready only when restore operations are auditable.
|
|
1179. The backend should be considered ready only when migration from mock mode is reversible.
|
|
1180. The backend should be considered ready only when product behavior is documented.
|
|
|
|
## Non-Goals For The Frontend Contract
|
|
|
|
1181. The frontend should not become a host command runner.
|
|
1182. The frontend should not own backend authorization decisions.
|
|
1183. The frontend should not own backend quota enforcement.
|
|
1184. The frontend should not own backend security scoring.
|
|
1185. The frontend should not own backend backup integrity checks.
|
|
1186. The frontend should not own backend restore correctness.
|
|
1187. The frontend should not own DNS conflict detection.
|
|
1188. The frontend should not own certificate validation.
|
|
1189. The frontend should not own database privilege truth.
|
|
1190. The frontend should not own email-routing truth.
|
|
1191. The frontend should not own package availability truth.
|
|
1192. The frontend should not own server health truth.
|
|
1193. The frontend should not own audit durability.
|
|
1194. The frontend should not own tenant isolation.
|
|
1195. The frontend should not own secret storage.
|
|
1196. The frontend should not own long-running job execution.
|
|
1197. The frontend should not own terminal execution policy.
|
|
1198. The frontend should not own infrastructure rollback policy.
|
|
1199. The frontend should not own compliance retention.
|
|
1200. The frontend should not own platform incident state.
|
|
|
|
## Final Product Expectations
|
|
|
|
1201. CoaxysPanel should feel like one integrated hosting control center.
|
|
1202. The backend should make every visible tool meaningful.
|
|
1203. The backend should make every primary action traceable.
|
|
1204. The backend should make every dangerous action deliberate.
|
|
1205. The backend should make every permission boundary enforceable.
|
|
1206. The backend should make every long-running operation observable.
|
|
1207. The backend should make every validation failure actionable.
|
|
1208. The backend should make every support escalation easier to diagnose.
|
|
1209. The backend should make the frontend replace mock data without redesign.
|
|
1210. The backend should make future modules fit the same service pattern.
|
|
1211. The backend should make account, server, and reseller context explicit everywhere.
|
|
1212. The backend should make failures honest rather than decorative.
|
|
1213. The backend should make infrastructure state understandable to administrators.
|
|
1214. The backend should make security state understandable without exposing offensive capability.
|
|
1215. The backend should make backup and restore trust visible.
|
|
1216. The backend should make automation predictable.
|
|
1217. The backend should make notifications useful instead of noisy.
|
|
1218. The backend should make audit logs complete enough for accountability.
|
|
1219. The backend should make settings changes safe to preview and safe to save.
|
|
1220. The backend and frontend together should preserve the premium CoaxysPanel experience.
|