Public changes compared with the previous published export: 89 files changed. Affected areas: - backend/app: 21 files - dependencies: 5 files - deployment and CI: 6 files - documentation: 2 files - frontend: 3 files - frontend/src: 20 files - project files: 1 file - tests: 30 files - unraid: 1 file Changed files: - Updated: ".env.example" - Updated: "Dockerfile.unraid" - Updated: "README.md" - Updated: "backend/Dockerfile" - Added: "backend/app/alerts.py" - Updated: "backend/app/auth.py" - Added: "backend/app/backups.py" - Updated: "backend/app/config_io.py" - Updated: "backend/app/demo.py" - Updated: "backend/app/discovery.py" - Updated: "backend/app/discovery_store.py" - Updated: "backend/app/docker_discovery.py" - Updated: "backend/app/events.py" - Updated: "backend/app/evidence.py" - Updated: "backend/app/health.py" - Updated: "backend/app/incidents.py" - Added: "backend/app/loops.py" - Updated: "backend/app/main.py" - Updated: "backend/app/models.py" - Updated: "backend/app/observation.py" - Updated: "backend/app/probes.py" - Added: "backend/app/response_cache.py" - Updated: "backend/app/scheduler.py" - Updated: "backend/app/semantic.py" - Updated: "backend/app/store.py" - Updated: "backend/pyproject.toml" - Updated: "backend/tests/test_api.py" - Updated: "backend/tests/test_config_io.py" - Updated: "backend/tests/test_demo.py" - Updated: "backend/tests/test_discovery_v120.py" - Updated: "backend/tests/test_health.py" - Updated: "backend/tests/test_probes.py" - Updated: "backend/tests/test_scheduler.py" - Updated: "backend/tests/test_v130_probe_reachability.py" - Updated: "backend/tests/test_v160_evidence_changes.py" - Added: "backend/tests/test_v163_alerts.py" - Added: "backend/tests/test_v163_backups.py" - Added: "backend/tests/test_v163_data_integrity.py" - Added: "backend/tests/test_v163_efficiency.py" - Added: "backend/tests/test_v163_health_performance.py" - Added: "backend/tests/test_v163_loops.py" - Added: "backend/tests/test_v163_management.py" - Added: "backend/tests/test_v163_realtime.py" - Added: "backend/tests/test_v163_security.py" - Added: "backend/tests/test_v163_semantic_etag.py" - Added: "compose.demo.yaml" - Updated: "compose.yaml" - Added: "docker-compose.broker.yml" - Updated: "docker-compose.yml" - Updated: "docs/ARCHITECTURE.md" - Added: "frontend/e2e/a11y.spec.ts" - Updated: "frontend/e2e/demo.spec.ts" - Updated: "frontend/index.html" - Updated: "frontend/nginx.conf" - Updated: "frontend/package-lock.json" - Updated: "frontend/package.json" - Updated: "frontend/playwright.config.ts" - Updated: "frontend/src/App.tsx" - Updated: "frontend/src/LivingEdge.tsx" - Added: "frontend/src/activityView.test.ts" - Added: "frontend/src/activityView.ts" - Updated: "frontend/src/api.ts" - Added: "frontend/src/apiAuth.test.ts" - Added: "frontend/src/components/ActionsMenu.tsx" - Added: "frontend/src/components/ConfirmDialog.test.tsx" - Added: "frontend/src/components/ConfirmDialog.tsx" - Added: "frontend/src/components/StatusIcon.tsx" - Updated: "frontend/src/demo/DemoWalkthrough.test.ts" - Updated: "frontend/src/demo/DemoWalkthrough.tsx" - Added: "frontend/src/elk-worker-url.d.ts" - Added: "frontend/src/labels.ts" - Updated: "frontend/src/main.tsx" - Added: "frontend/src/realtime/refreshPlan.test.ts" - Added: "frontend/src/realtime/refreshPlan.ts" - Updated: "frontend/src/realtime/useRealtimeEvents.ts" - Added: "frontend/src/routing/urlState.test.ts" - Added: "frontend/src/routing/urlState.ts" - Updated: "frontend/src/styles.css" - Added: "frontend/src/topology/GraphListView.test.tsx" - Added: "frontend/src/topology/GraphListView.tsx" - Updated: "frontend/src/topology/ServiceNode.tsx" - Updated: "frontend/src/topology/TopologyCommandBar.tsx" - Added: "frontend/src/topology/semanticGraph.test.ts" - Updated: "frontend/src/topology/semanticGraph.ts" - Added: "frontend/src/topologyLayout.test.ts" - Updated: "frontend/src/topologyLayout.ts" - Updated: "package-lock.json" - Updated: "package.json" - Updated: "unraid/my-servicemap.xml" Export provenance/manifests refreshed; excluded from the change summary. Publish curated ServiceMap source from af46f684e468dffd3a5190e28d3b572d4c26bfd7
1059 lines
31 KiB
TypeScript
1059 lines
31 KiB
TypeScript
import { SSE_EVENT_TYPES } from "./realtime/refreshPlan";
|
|
|
|
export type HealthStatus =
|
|
| "healthy"
|
|
| "degraded"
|
|
| "down"
|
|
| "unknown"
|
|
| "unmonitored"
|
|
| "recovering"
|
|
| "maintenance";
|
|
export type ServiceKind = "http" | "tcp" | "dns" | "tls";
|
|
export type Criticality = "low" | "medium" | "high" | "critical";
|
|
export type DiscoveryCategory =
|
|
| "application"
|
|
| "database"
|
|
| "cache"
|
|
| "proxy"
|
|
| "monitoring"
|
|
| "development"
|
|
| "storage"
|
|
| "infrastructure"
|
|
| "background_worker"
|
|
| "system"
|
|
| "unknown";
|
|
export type ComponentRole =
|
|
| "frontend"
|
|
| "api"
|
|
| "database"
|
|
| "cache"
|
|
| "proxy"
|
|
| "worker"
|
|
| "storage"
|
|
| "monitoring"
|
|
| "agent"
|
|
| "scheduler"
|
|
| "auxiliary"
|
|
| "unknown";
|
|
export type DiscoveryVisibility = "visible" | "hidden" | "ignored";
|
|
export type DiscoveryLifecycle =
|
|
"active" | "missing" | "stale" | "ignored" | "retired";
|
|
export type DiscoveryConfidence = "confirmed" | "high" | "medium" | "low";
|
|
export type RelationType =
|
|
"depends_on" | "routes_to" | "uses_storage" | "communicates_with";
|
|
export type MonitoringState =
|
|
| "active_probe"
|
|
| "docker_health"
|
|
| "appops_observation"
|
|
| "observed"
|
|
| "unmonitored"
|
|
| "disabled";
|
|
export type ProbeEndpointSource =
|
|
| "manual"
|
|
| "explicit_label"
|
|
| "known_url"
|
|
| "appops"
|
|
| "reverse_proxy"
|
|
| "published_port"
|
|
| "docker_healthcheck"
|
|
| "container_internal"
|
|
| "discovered_environment";
|
|
export type ProbeReachability =
|
|
"verified" | "reachable" | "unverified" | "internal_only" | "not_configured";
|
|
|
|
export type Service = {
|
|
id: string;
|
|
name: string;
|
|
kind: ServiceKind;
|
|
url: string | null;
|
|
host: string | null;
|
|
port: number | null;
|
|
depends_on: string[];
|
|
description: string | null;
|
|
tags: string[];
|
|
group: string | null;
|
|
environment: string | null;
|
|
owner: string | null;
|
|
enabled: boolean;
|
|
monitoring_enabled: boolean;
|
|
monitoring_state: MonitoringState;
|
|
probe_source: ProbeEndpointSource;
|
|
probe_reachability: ProbeReachability;
|
|
probe_confidence: DiscoveryConfidence;
|
|
runtime_state: string | null;
|
|
runtime_health: string | null;
|
|
application: string | null;
|
|
domain: string | null;
|
|
component_role: ComponentRole;
|
|
application_locked: boolean;
|
|
domain_locked: boolean;
|
|
component_role_locked: boolean;
|
|
criticality: Criticality;
|
|
category: DiscoveryCategory;
|
|
visibility: DiscoveryVisibility;
|
|
lifecycle: DiscoveryLifecycle;
|
|
source_type: string | null;
|
|
source_ref: string | null;
|
|
first_seen_at: string | null;
|
|
last_seen_at: string | null;
|
|
last_discovery_status: string | null;
|
|
container_image: string | null;
|
|
compose_project: string | null;
|
|
layout_x: number | null;
|
|
layout_y: number | null;
|
|
layout_pinned: boolean;
|
|
interval_seconds: number | null;
|
|
timeout_seconds: number | null;
|
|
retries: number | null;
|
|
failure_threshold: number;
|
|
recovery_threshold: number;
|
|
expected_status_min: number | null;
|
|
expected_status_max: number | null;
|
|
availability_target: number | null;
|
|
maintenance_enabled: boolean;
|
|
maintenance_reason: string | null;
|
|
state: HealthStatus;
|
|
failure_streak: number;
|
|
recovery_streak: number;
|
|
flapping: boolean;
|
|
flap_count: number;
|
|
last_state_change_at: string | null;
|
|
created_at: string;
|
|
updated_at: string;
|
|
};
|
|
|
|
export type ProbeResult = {
|
|
id: string;
|
|
service_id: string;
|
|
status: HealthStatus;
|
|
latency_ms: number | null;
|
|
detail: string;
|
|
checked_at: string;
|
|
trigger: string;
|
|
metadata: Record<string, unknown>;
|
|
};
|
|
|
|
export type EvidenceProvider = "active_probe" | "docker" | "appops" | "runtime" | "manual";
|
|
export type EvidenceScope = "component" | "application";
|
|
export type EvidenceFreshness = "fresh" | "stale" | "expired";
|
|
export type HealthResolutionReason =
|
|
| "selected_component_evidence"
|
|
| "application_scoped_only"
|
|
| "no_current_component_evidence"
|
|
| "stale_evidence"
|
|
| "expired_evidence"
|
|
| "selected_application_evidence"
|
|
| "component_failure"
|
|
| "component_dependency_impact"
|
|
| "component_coverage"
|
|
| "no_application_evidence";
|
|
export type HealthEvidence = {
|
|
id: string;
|
|
subject_type: string;
|
|
subject_id: string;
|
|
service_id: string | null;
|
|
provider: EvidenceProvider;
|
|
provider_ref: string | null;
|
|
status: HealthStatus;
|
|
scope: EvidenceScope;
|
|
confidence: number;
|
|
observed_at: string;
|
|
valid_until: string;
|
|
received_at: string;
|
|
summary: string;
|
|
metadata: Record<string, unknown>;
|
|
active: boolean;
|
|
superseded_by: string | null;
|
|
freshness: EvidenceFreshness;
|
|
};
|
|
export type HealthResolution = {
|
|
status: HealthStatus;
|
|
selected_evidence_id: string | null;
|
|
selected_provider: EvidenceProvider | null;
|
|
confidence: number | null;
|
|
reason_code: HealthResolutionReason;
|
|
explanation: string;
|
|
conflict: boolean;
|
|
evidence: HealthEvidence[];
|
|
};
|
|
export type ProviderStatus = {
|
|
provider: EvidenceProvider;
|
|
status: "healthy" | "degraded" | "unavailable" | "unknown";
|
|
observed_at: string;
|
|
valid_until: string;
|
|
detail: string;
|
|
metadata: Record<string, unknown>;
|
|
};
|
|
|
|
export type ServiceSnapshot = {
|
|
service: Service;
|
|
latest_probe: ProbeResult | null;
|
|
availability_24h: AvailabilitySummary | null;
|
|
dependency_status: HealthStatus;
|
|
effective_status: HealthStatus;
|
|
direct_status: HealthStatus;
|
|
flapping: boolean;
|
|
flap_count: number;
|
|
next_probe_at: string | null;
|
|
dependents: string[];
|
|
sources: ServiceSource[];
|
|
evidence: RelationEvidence[];
|
|
health_evidence: HealthEvidence[];
|
|
health_resolution: HealthResolution;
|
|
maintenance_until?: string | null;
|
|
};
|
|
|
|
export type ServiceSource = {
|
|
id: string;
|
|
source_type: string;
|
|
source_id: string;
|
|
source_name: string | null;
|
|
first_seen_at: string;
|
|
last_seen_at: string;
|
|
lifecycle: DiscoveryLifecycle;
|
|
managed: boolean;
|
|
metadata: Record<string, unknown>;
|
|
};
|
|
|
|
export type RelationEvidence = {
|
|
id: string;
|
|
source_service_id: string;
|
|
target_service_id: string | null;
|
|
target_ref: string | null;
|
|
relation_type: RelationType;
|
|
evidence_type: string;
|
|
confidence: DiscoveryConfidence;
|
|
explanation: string;
|
|
source_ref: string | null;
|
|
locked: boolean;
|
|
active: boolean;
|
|
first_seen_at: string;
|
|
last_seen_at: string;
|
|
};
|
|
|
|
export type LogicalRelation = {
|
|
id: string;
|
|
source_service_id: string;
|
|
target_service_id: string | null;
|
|
target_ref: string | null;
|
|
relation_type: RelationType;
|
|
confidence: DiscoveryConfidence;
|
|
active: boolean;
|
|
locked: boolean;
|
|
first_seen_at: string;
|
|
last_seen_at: string;
|
|
evidence: RelationEvidence[];
|
|
};
|
|
|
|
export type TopologySnapshot = {
|
|
id: string;
|
|
run_id: string | null;
|
|
created_at: string;
|
|
revision: string;
|
|
service_count: number;
|
|
relationship_count: number;
|
|
summary: Record<string, number>;
|
|
};
|
|
export type TopologyChange = {
|
|
change_type: "added" | "removed" | "changed";
|
|
entity_type: "service" | "relationship";
|
|
entity_id: string;
|
|
name: string;
|
|
before: Record<string, unknown> | null;
|
|
after: Record<string, unknown> | null;
|
|
};
|
|
export type TopologyDiff = {
|
|
before_snapshot_id: string | null;
|
|
after_snapshot_id: string;
|
|
added: TopologyChange[];
|
|
removed: TopologyChange[];
|
|
changed: TopologyChange[];
|
|
summary: Record<string, number>;
|
|
};
|
|
|
|
export type SemanticComponent = {
|
|
service_id: string;
|
|
name: string;
|
|
kind: ServiceKind;
|
|
application_id: string;
|
|
domain_id: string;
|
|
role: ComponentRole;
|
|
direct_status: HealthStatus;
|
|
effective_status: HealthStatus;
|
|
unknown_reason: HealthResolutionReason | null;
|
|
runtime_state: string | null;
|
|
runtime_health: string | null;
|
|
monitoring_state: MonitoringState;
|
|
latest_latency_ms: number | null;
|
|
dependency_ids: string[];
|
|
dependent_ids: string[];
|
|
root_cause: boolean;
|
|
affected: boolean;
|
|
};
|
|
|
|
export type SemanticApplication = {
|
|
id: string;
|
|
name: string;
|
|
domain_id: string;
|
|
component_ids: string[];
|
|
component_count: number;
|
|
roles: ComponentRole[];
|
|
status: HealthStatus;
|
|
status_explanation: string;
|
|
health_resolution: {
|
|
status: HealthStatus;
|
|
confidence: number | null;
|
|
explanation: string;
|
|
reason_code: HealthResolutionReason;
|
|
selected_evidence_id: string | null;
|
|
selected_provider: EvidenceProvider | null;
|
|
evidence_freshness: EvidenceFreshness | null;
|
|
conflict: boolean;
|
|
resolved_components: number;
|
|
unresolved_components: number;
|
|
component_coverage_percent: number;
|
|
};
|
|
dependency_application_ids: string[];
|
|
dependent_application_ids: string[];
|
|
monitored_components: number;
|
|
unmonitored_components: number;
|
|
resolved_components: number;
|
|
unresolved_components: number;
|
|
component_coverage_percent: number;
|
|
root_cause: boolean;
|
|
affected: boolean;
|
|
};
|
|
|
|
export type SemanticDomain = {
|
|
id: string;
|
|
name: string;
|
|
application_ids: string[];
|
|
application_count: number;
|
|
status: HealthStatus;
|
|
resolved_application_count: number;
|
|
unresolved_application_count: number;
|
|
application_coverage_percent: number;
|
|
incident_count: number;
|
|
root_cause: boolean;
|
|
affected: boolean;
|
|
};
|
|
|
|
export type SemanticTopology = {
|
|
generated_at: string;
|
|
domains: SemanticDomain[];
|
|
applications: SemanticApplication[];
|
|
components: SemanticComponent[];
|
|
relations: LogicalRelation[];
|
|
monitoring_coverage: Record<string, number>;
|
|
};
|
|
|
|
export type AvailabilitySummary = {
|
|
hours: number;
|
|
total_checks: number;
|
|
healthy_checks: number;
|
|
degraded_checks: number;
|
|
down_checks: number;
|
|
uptime_percent: number | null;
|
|
average_latency_ms: number | null;
|
|
last_checked_at: string | null;
|
|
target_percent: number | null;
|
|
meets_target: boolean | null;
|
|
};
|
|
|
|
export type ServiceInput = {
|
|
name: string;
|
|
kind: ServiceKind;
|
|
url?: string;
|
|
host?: string;
|
|
port?: number;
|
|
depends_on?: string[];
|
|
description?: string;
|
|
tags?: string[];
|
|
group?: string;
|
|
environment?: string;
|
|
owner?: string;
|
|
enabled?: boolean;
|
|
monitoring_enabled?: boolean;
|
|
monitoring_state?: MonitoringState;
|
|
probe_source?: ProbeEndpointSource;
|
|
probe_reachability?: ProbeReachability;
|
|
probe_confidence?: DiscoveryConfidence;
|
|
runtime_state?: string;
|
|
runtime_health?: string;
|
|
application?: string;
|
|
domain?: string;
|
|
component_role?: ComponentRole;
|
|
application_locked?: boolean;
|
|
domain_locked?: boolean;
|
|
component_role_locked?: boolean;
|
|
criticality?: Criticality;
|
|
category?: DiscoveryCategory;
|
|
visibility?: DiscoveryVisibility;
|
|
lifecycle?: DiscoveryLifecycle;
|
|
layout_x?: number;
|
|
layout_y?: number;
|
|
layout_pinned?: boolean;
|
|
interval_seconds?: number;
|
|
timeout_seconds?: number;
|
|
retries?: number;
|
|
failure_threshold?: number;
|
|
recovery_threshold?: number;
|
|
expected_status_min?: number;
|
|
expected_status_max?: number;
|
|
availability_target?: number;
|
|
source_type?: string;
|
|
source_ref?: string;
|
|
first_seen_at?: string;
|
|
last_seen_at?: string;
|
|
last_discovery_status?: string;
|
|
container_image?: string;
|
|
compose_project?: string;
|
|
maintenance_enabled?: boolean;
|
|
maintenance_reason?: string;
|
|
};
|
|
|
|
export type IncidentCandidate = {
|
|
service_id: string;
|
|
service_name: string;
|
|
status: HealthStatus;
|
|
reason: string;
|
|
affected_service_ids: string[];
|
|
affected_service_names: string[];
|
|
};
|
|
|
|
export type IncidentStatus = "open" | "acknowledged" | "resolved";
|
|
|
|
export type IncidentRecord = {
|
|
id: string;
|
|
status: IncidentStatus;
|
|
root_service_id: string;
|
|
root_service_name: string;
|
|
started_at: string;
|
|
detected_at: string;
|
|
acknowledged_at: string | null;
|
|
resolved_at: string | null;
|
|
title: string;
|
|
root_cause_reason: string;
|
|
affected_service_ids: string[];
|
|
affected_service_names: string[];
|
|
severity: Criticality;
|
|
latest_update_at: string;
|
|
};
|
|
|
|
export type IncidentTimelineEvent = {
|
|
id: string;
|
|
incident_id: string;
|
|
event_type: string;
|
|
message: string;
|
|
created_at: string;
|
|
service_id: string | null;
|
|
};
|
|
|
|
export type IncidentDetail = {
|
|
incident: IncidentRecord;
|
|
timeline: IncidentTimelineEvent[];
|
|
};
|
|
|
|
export type IncidentOverview = {
|
|
generated_at: string;
|
|
active: boolean;
|
|
candidates: IncidentCandidate[];
|
|
degraded_service_ids: string[];
|
|
down_service_ids: string[];
|
|
incidents: IncidentRecord[];
|
|
};
|
|
|
|
export type EventRecord = {
|
|
id: string;
|
|
event_type: string;
|
|
service_id: string | null;
|
|
incident_id: string | null;
|
|
from_status: HealthStatus | null;
|
|
to_status: HealthStatus | null;
|
|
message: string;
|
|
metadata: Record<string, unknown>;
|
|
created_at: string;
|
|
};
|
|
|
|
export type OverviewSummary = {
|
|
generated_at: string;
|
|
total_services: number;
|
|
health_counts: Record<string, number>;
|
|
active_incidents: number;
|
|
likely_root_causes: string[];
|
|
flapping_services: string[];
|
|
recent_events: EventRecord[];
|
|
monitoring_coverage: Record<string, number>;
|
|
};
|
|
|
|
export type DemoState = {
|
|
active: boolean;
|
|
enabled: boolean;
|
|
synthetic: boolean;
|
|
scenario_name: string | null;
|
|
service_count: number;
|
|
root_cause_service_id: string | null;
|
|
root_cause_service_name: string | null;
|
|
affected_service_ids: string[];
|
|
affected_service_names: string[];
|
|
affected_count: number;
|
|
};
|
|
|
|
export type DemoMutationResult = DemoState & {
|
|
created: number;
|
|
updated: number;
|
|
total: number;
|
|
restored: boolean;
|
|
};
|
|
|
|
export type DockerPort = {
|
|
container_port: string;
|
|
host_ip: string | null;
|
|
host_port: number | null;
|
|
};
|
|
|
|
export type DockerSuggestion = {
|
|
name: string;
|
|
kind: ServiceKind;
|
|
host: string | null;
|
|
port: number | null;
|
|
url: string | null;
|
|
group: string | null;
|
|
evidence: string[];
|
|
confidence: string;
|
|
depends_on_names: string[];
|
|
source_type: string | null;
|
|
source_ref: string | null;
|
|
stable_source_ref: string | null;
|
|
category: DiscoveryCategory;
|
|
visibility: DiscoveryVisibility;
|
|
relation_type: RelationType;
|
|
};
|
|
|
|
export type DockerCandidate = {
|
|
container_id: string;
|
|
name: string;
|
|
image: string;
|
|
state: string;
|
|
health: string | null;
|
|
networks: string[];
|
|
ports: DockerPort[];
|
|
labels: Record<string, string>;
|
|
import_state: string;
|
|
suggestions: DockerSuggestion[];
|
|
dependency_suggestions: string[];
|
|
stable_source_ref: string | null;
|
|
compose_project: string | null;
|
|
compose_service: string | null;
|
|
category: DiscoveryCategory;
|
|
visibility: DiscoveryVisibility;
|
|
lifecycle: DiscoveryLifecycle;
|
|
healthcheck_present: boolean;
|
|
environment_evidence: string[];
|
|
proxy_route_evidence: string[];
|
|
appops_app_id: string | null;
|
|
appops_category: string | null;
|
|
appops_criticality: string | null;
|
|
appops_health: string | null;
|
|
probe_candidates: ProbeEndpointCandidate[];
|
|
};
|
|
|
|
export type ProbeEndpointCandidate = {
|
|
source: ProbeEndpointSource;
|
|
kind: ServiceKind;
|
|
url: string | null;
|
|
host: string | null;
|
|
port: number | null;
|
|
reachability: ProbeReachability;
|
|
confidence: DiscoveryConfidence;
|
|
primary: boolean;
|
|
evidence: string;
|
|
preflight_detail: string | null;
|
|
preflight_latency_ms: number | null;
|
|
};
|
|
|
|
export type ProbeRepairChange = {
|
|
service_id: string;
|
|
service_name: string;
|
|
previous_monitoring_state: MonitoringState;
|
|
next_monitoring_state: MonitoringState;
|
|
previous_endpoint: string | null;
|
|
next_endpoint: string | null;
|
|
next_probe_source: ProbeEndpointSource | null;
|
|
next_probe_confidence: DiscoveryConfidence | null;
|
|
reason: string;
|
|
};
|
|
|
|
export type ProbeRepairReport = {
|
|
run_id: string | null;
|
|
dry_run: boolean;
|
|
inspected: number;
|
|
changed: number;
|
|
disabled_unsafe: number;
|
|
enabled_published: number;
|
|
docker_health_observed: number;
|
|
appops_observed: number;
|
|
runtime_observed: number;
|
|
unmonitored: number;
|
|
resolved_incidents: number;
|
|
changes: ProbeRepairChange[];
|
|
};
|
|
|
|
export type DockerDiscoveryResult = {
|
|
docker_host: string;
|
|
candidates: DockerCandidate[];
|
|
proxy_routes?: number;
|
|
};
|
|
|
|
export type DiscoveryObservation = {
|
|
id: string;
|
|
run_id: string;
|
|
source_id: string;
|
|
source_type: string;
|
|
source_name: string;
|
|
lifecycle: DiscoveryLifecycle;
|
|
change_type: string;
|
|
observed_at: string;
|
|
metadata: Record<string, unknown>;
|
|
};
|
|
|
|
export type TopologySuggestion = {
|
|
id: string;
|
|
run_id: string;
|
|
suggestion_type: string;
|
|
status: "open" | "accepted" | "rejected" | "superseded";
|
|
source_ref: string | null;
|
|
source_service_id: string | null;
|
|
target_ref: string | null;
|
|
target_service_id: string | null;
|
|
proposed_name: string | null;
|
|
proposed_kind: ServiceKind | null;
|
|
proposed_url: string | null;
|
|
proposed_host: string | null;
|
|
proposed_port: number | null;
|
|
proposed_category: DiscoveryCategory;
|
|
proposed_group: string | null;
|
|
relation_type: RelationType | null;
|
|
confidence: DiscoveryConfidence;
|
|
evidence: string[];
|
|
created_at: string;
|
|
updated_at: string;
|
|
};
|
|
|
|
export type DiscoveryDiff = {
|
|
new: number;
|
|
changed: number;
|
|
missing: number;
|
|
unchanged: number;
|
|
stale: number;
|
|
new_suggestions: number;
|
|
};
|
|
|
|
export type DiscoveryRun = {
|
|
id: string;
|
|
status: "idle" | "discovering" | "reconciling" | "completed" | "failed";
|
|
started_at: string;
|
|
completed_at: string | null;
|
|
source_counts: Record<string, number>;
|
|
diff: DiscoveryDiff;
|
|
error: string | null;
|
|
};
|
|
|
|
export type DiscoveryResult = DockerDiscoveryResult & {
|
|
run: DiscoveryRun;
|
|
suggestions: TopologySuggestion[];
|
|
observations: DiscoveryObservation[];
|
|
appops_available: boolean;
|
|
appops_mappings: number;
|
|
proxy_routes: number;
|
|
};
|
|
|
|
export type DiscoveryStatus = {
|
|
current: DiscoveryRun | null;
|
|
last_completed: DiscoveryRun | null;
|
|
active: boolean;
|
|
};
|
|
|
|
export type ReconcileResult = {
|
|
run: DiscoveryRun;
|
|
created: number;
|
|
updated: number;
|
|
unchanged: number;
|
|
missing: number;
|
|
retired: number;
|
|
accepted_relations: number;
|
|
open_suggestions: number;
|
|
service_ids: string[];
|
|
};
|
|
|
|
// The admin token is kept per browser tab (sessionStorage): it survives a
|
|
// reload but not closing the tab, and never reaches topology config.
|
|
const TOKEN_KEY = "servicemap.adminToken";
|
|
export const AUTH_REQUIRED_EVENT = "servicemap:auth-required";
|
|
|
|
function readStoredToken(): string | null {
|
|
try {
|
|
return window.sessionStorage.getItem(TOKEN_KEY);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
let accessToken: string | null = typeof window === "undefined" ? null : readStoredToken();
|
|
|
|
export function setApiAccessToken(token: string | null): void {
|
|
accessToken = token?.trim() || null;
|
|
try {
|
|
if (accessToken) window.sessionStorage.setItem(TOKEN_KEY, accessToken);
|
|
else window.sessionStorage.removeItem(TOKEN_KEY);
|
|
} catch {
|
|
// Storage may be unavailable (private mode); the token stays in memory.
|
|
}
|
|
}
|
|
|
|
export function hasApiAccessToken(): boolean {
|
|
return accessToken !== null;
|
|
}
|
|
|
|
/** An API failure that keeps the HTTP status, e.g. 401 for a locked editor. */
|
|
export class ApiError extends Error {
|
|
readonly status: number;
|
|
|
|
constructor(message: string, status: number) {
|
|
super(message);
|
|
this.name = "ApiError";
|
|
this.status = status;
|
|
}
|
|
}
|
|
|
|
function errorMessage(detail: unknown, status: number): string {
|
|
if (typeof detail === "string" && detail) return detail;
|
|
if (Array.isArray(detail)) {
|
|
// FastAPI validation errors: [{loc: [...], msg: "..."}]
|
|
const parts = detail
|
|
.map((item) => {
|
|
const entry = item as { loc?: unknown[]; msg?: string };
|
|
const field = Array.isArray(entry.loc) ? entry.loc.filter((part) => part !== "body").join(".") : "";
|
|
return entry.msg ? (field ? `${field}: ${entry.msg}` : entry.msg) : "";
|
|
})
|
|
.filter(Boolean);
|
|
if (parts.length) return parts.join("; ");
|
|
}
|
|
return `Verzoek mislukt (${status})`;
|
|
}
|
|
|
|
function requestHeaders(init?: RequestInit, token: string | null = accessToken): Headers {
|
|
const headers = new Headers(init?.headers);
|
|
if (init?.body !== undefined && !headers.has("Content-Type")) {
|
|
headers.set("Content-Type", "application/json");
|
|
}
|
|
if (token && !headers.has("Authorization")) headers.set("Authorization", `Bearer ${token}`);
|
|
return headers;
|
|
}
|
|
|
|
async function request<T>(url: string, init?: RequestInit, token: string | null = accessToken): Promise<T> {
|
|
// Spread init first: a caller's headers are merged above, never dropped.
|
|
const response = await fetch(url, { ...init, headers: requestHeaders(init, token) });
|
|
|
|
if (!response.ok) {
|
|
const payload = await response.json().catch(() => null);
|
|
if (response.status === 401 && token === accessToken && typeof window !== "undefined") {
|
|
// The tab's token is missing or no longer valid: forget it and let the
|
|
// UI ask for it. Explicit candidate tokens (verifyWriteAccess) don't.
|
|
if (accessToken) setApiAccessToken(null);
|
|
window.dispatchEvent(new Event(AUTH_REQUIRED_EVENT));
|
|
}
|
|
throw new ApiError(errorMessage(payload?.detail, response.status), response.status);
|
|
}
|
|
|
|
if (response.status === 204) return undefined as T;
|
|
return response.json() as Promise<T>;
|
|
}
|
|
|
|
export type AlertSettings = {
|
|
enabled: boolean;
|
|
ntfy_server: string;
|
|
ntfy_topic: string;
|
|
min_severity: Criticality;
|
|
delay_seconds: number;
|
|
notify_resolved: boolean;
|
|
reminder_minutes: number;
|
|
public_url: string;
|
|
ntfy_token_set?: boolean;
|
|
};
|
|
|
|
export type BackupInfo = {
|
|
name: string;
|
|
kind: "backup" | "pre-restore";
|
|
created_at: string;
|
|
size_bytes: number;
|
|
};
|
|
|
|
/** Download a backup with the tab's token (a plain link carries none). */
|
|
export async function downloadBackupFile(name: string): Promise<Blob> {
|
|
const response = await fetch(`/api/v1/backups/${encodeURIComponent(name)}`, {
|
|
headers: requestHeaders(),
|
|
});
|
|
if (!response.ok) {
|
|
const payload = await response.json().catch(() => null);
|
|
throw new ApiError(errorMessage(payload?.detail, response.status), response.status);
|
|
}
|
|
return response.blob();
|
|
}
|
|
|
|
export type ServiceMapMeta = {
|
|
version: string;
|
|
auth_mode: string;
|
|
write_auth?: "none" | "admin_token" | "oidc";
|
|
};
|
|
|
|
export const api = {
|
|
alertSettings: () => request<AlertSettings>("/api/v1/settings/alerts"),
|
|
/** ``ntfyToken``: undefined keeps the stored token, "" removes it. */
|
|
saveAlertSettings: (settings: AlertSettings, ntfyToken?: string) =>
|
|
request<AlertSettings>("/api/v1/settings/alerts", {
|
|
method: "PUT",
|
|
body: JSON.stringify({ ...settings, ntfy_token_set: undefined, ntfy_token: ntfyToken }),
|
|
}),
|
|
backups: () => request<BackupInfo[]>("/api/v1/backups"),
|
|
createBackup: () => request<BackupInfo>("/api/v1/backups", { method: "POST" }),
|
|
restoreBackup: (name: string) =>
|
|
request<BackupInfo>(`/api/v1/backups/${encodeURIComponent(name)}/restore`, { method: "POST" }),
|
|
testAlert: () =>
|
|
request<{ ok: boolean; detail: string }>("/api/v1/settings/alerts/test", { method: "POST" }),
|
|
meta: () => request<ServiceMapMeta>("/api/v1/meta"),
|
|
/** Resolves only when ``token`` may change ServiceMap. */
|
|
verifyWriteAccess: (token: string) =>
|
|
request<{ ok: boolean }>("/api/v1/auth/verify", { method: "POST" }, token.trim()),
|
|
listServices: (includeHidden = false) =>
|
|
request<ServiceSnapshot[]>(
|
|
`/api/v1/services?include_hidden=${includeHidden}`,
|
|
),
|
|
createService: (payload: ServiceInput) =>
|
|
request<Service>("/api/v1/services", {
|
|
method: "POST",
|
|
body: JSON.stringify(payload),
|
|
}),
|
|
updateService: (serviceId: string, payload: ServiceInput) =>
|
|
request<Service>(`/api/v1/services/${serviceId}`, {
|
|
method: "PUT",
|
|
body: JSON.stringify(payload),
|
|
}),
|
|
probeService: (serviceId: string) =>
|
|
request<ProbeResult>(`/api/v1/services/${serviceId}/probe`, {
|
|
method: "POST",
|
|
}),
|
|
probeAll: () =>
|
|
request<{ requested: number; completed: number; results: ProbeResult[] }>(
|
|
"/api/v1/probe-all",
|
|
{ method: "POST" },
|
|
),
|
|
deleteService: (serviceId: string) =>
|
|
request<void>(`/api/v1/services/${serviceId}`, { method: "DELETE" }),
|
|
history: (serviceId: string, limit = 24) =>
|
|
request<ProbeResult[]>(
|
|
`/api/v1/services/${serviceId}/history?limit=${limit}`,
|
|
),
|
|
availability: (serviceId: string, hours = 24) =>
|
|
request<AvailabilitySummary>(
|
|
`/api/v1/services/${serviceId}/availability?hours=${hours}`,
|
|
),
|
|
serviceEvidence: (serviceId: string) =>
|
|
request<HealthResolution>(`/api/v1/services/${serviceId}/evidence`),
|
|
providers: () => request<ProviderStatus[]>("/api/v1/providers"),
|
|
incidents: () => request<IncidentOverview>("/api/v1/incidents"),
|
|
incident: (incidentId: string) =>
|
|
request<IncidentDetail>(`/api/v1/incidents/${incidentId}`),
|
|
acknowledgeIncident: (incidentId: string) =>
|
|
request<IncidentDetail>(`/api/v1/incidents/${incidentId}/acknowledge`, {
|
|
method: "POST",
|
|
}),
|
|
events: (limit = 50, options: { eventType?: string; before?: string } = {}) => {
|
|
const params = new URLSearchParams({ limit: String(limit) });
|
|
if (options.eventType) params.set("event_type", options.eventType);
|
|
if (options.before) params.set("before", options.before);
|
|
return request<EventRecord[]>(`/api/v1/events?${params.toString()}`);
|
|
},
|
|
resolveIncident: (incidentId: string, note?: string) =>
|
|
request<IncidentDetail>(`/api/v1/incidents/${encodeURIComponent(incidentId)}/resolve`, {
|
|
method: "POST",
|
|
body: JSON.stringify({ note: note || null }),
|
|
}),
|
|
addIncidentNote: (incidentId: string, text: string) =>
|
|
request<IncidentDetail>(`/api/v1/incidents/${encodeURIComponent(incidentId)}/notes`, {
|
|
method: "POST",
|
|
body: JSON.stringify({ text }),
|
|
}),
|
|
overview: () => request<OverviewSummary>("/api/v1/overview"),
|
|
maintenance: (serviceId: string, enabled: boolean, reason?: string, until?: string | null) =>
|
|
request<Service>(`/api/v1/services/${serviceId}/maintenance`, {
|
|
method: "POST",
|
|
body: JSON.stringify({ enabled, reason, until: until ?? null }),
|
|
}),
|
|
demoState: () => request<DemoState>("/api/v1/demo"),
|
|
loadDemo: () =>
|
|
request<DemoMutationResult>("/api/v1/demo", { method: "POST" }),
|
|
resetDemo: () =>
|
|
request<DemoMutationResult>("/api/v1/demo/reset", { method: "POST" }),
|
|
exitDemo: () =>
|
|
request<DemoMutationResult>("/api/v1/demo/exit", { method: "POST" }),
|
|
importConfig: (
|
|
content: string,
|
|
format: "yaml" | "json",
|
|
mode: "merge" | "replace",
|
|
) =>
|
|
request<{ created: number; updated: number; total: number }>(
|
|
"/api/v1/config/import",
|
|
{ method: "POST", body: JSON.stringify({ content, format, mode }) },
|
|
),
|
|
exportConfig: async (format: "yaml" | "json") => {
|
|
const response = await fetch(`/api/v1/config?format=${format}`, { headers: requestHeaders() });
|
|
if (!response.ok) throw new Error(`Exporteren mislukt (${response.status})`);
|
|
return response.text();
|
|
},
|
|
discoverDocker: (dockerHost: string) =>
|
|
request<DockerDiscoveryResult>("/api/v1/docker/discover", {
|
|
method: "POST",
|
|
body: JSON.stringify({ docker_host: dockerHost }),
|
|
}),
|
|
runDiscovery: (
|
|
dockerHost?: string,
|
|
appopsUrl?: string,
|
|
includeStopped = false,
|
|
) =>
|
|
request<DiscoveryResult>("/api/v1/discovery/run", {
|
|
method: "POST",
|
|
body: JSON.stringify({
|
|
docker_host: dockerHost || undefined,
|
|
appops_url: appopsUrl || undefined,
|
|
include_stopped: includeStopped,
|
|
}),
|
|
}),
|
|
discoveryStatus: () => request<DiscoveryStatus>("/api/v1/discovery/status"),
|
|
discoveryItems: (runId?: string) =>
|
|
request<DiscoveryObservation[]>(
|
|
`/api/v1/discovery/items${runId ? `?run_id=${encodeURIComponent(runId)}` : ""}`,
|
|
),
|
|
discoverySuggestions: (status = "open") =>
|
|
request<TopologySuggestion[]>(
|
|
`/api/v1/discovery/suggestions?status=${status}`,
|
|
),
|
|
acceptSuggestion: (suggestionId: string) =>
|
|
request<TopologySuggestion>(
|
|
`/api/v1/discovery/suggestions/${suggestionId}/accept`,
|
|
{ method: "POST" },
|
|
),
|
|
rejectSuggestion: (suggestionId: string) =>
|
|
request<TopologySuggestion>(
|
|
`/api/v1/discovery/suggestions/${suggestionId}/reject`,
|
|
{ method: "POST" },
|
|
),
|
|
reconcileDiscovery: (runId?: string, applyHighConfidence = false) =>
|
|
request<ReconcileResult>("/api/v1/discovery/reconcile", {
|
|
method: "POST",
|
|
body: JSON.stringify({
|
|
run_id: runId,
|
|
apply_high_confidence: applyHighConfidence,
|
|
}),
|
|
}),
|
|
repairDiscoveredProbes: (dryRun = true, runId?: string) =>
|
|
request<ProbeRepairReport>(
|
|
`/api/v1/discovery/probes/repair?dry_run=${dryRun}${runId ? `&run_id=${encodeURIComponent(runId)}` : ""}`,
|
|
{ method: "POST" },
|
|
),
|
|
topologyEdges: () => request<RelationEvidence[]>("/api/v1/topology/edges"),
|
|
topologyRelations: () =>
|
|
request<LogicalRelation[]>("/api/v1/topology/relations"),
|
|
topologySnapshots: (limit = 30) =>
|
|
request<TopologySnapshot[]>(`/api/v1/topology/snapshots?limit=${limit}`),
|
|
topologyDiff: (afterSnapshotId: string, beforeSnapshotId?: string) =>
|
|
request<TopologyDiff>(
|
|
`/api/v1/topology/diff?after_snapshot_id=${encodeURIComponent(afterSnapshotId)}${beforeSnapshotId ? `&before_snapshot_id=${encodeURIComponent(beforeSnapshotId)}` : ""}`,
|
|
),
|
|
semanticTopology: () =>
|
|
request<SemanticTopology>("/api/v1/topology/semantic"),
|
|
createEdge: (payload: {
|
|
source_service_id: string;
|
|
target_service_id: string;
|
|
relation_type?: RelationType;
|
|
lock?: boolean;
|
|
explanation?: string;
|
|
}) =>
|
|
request<RelationEvidence>("/api/v1/topology/edges", {
|
|
method: "POST",
|
|
body: JSON.stringify(payload),
|
|
}),
|
|
edgeAction: (
|
|
evidenceId: string,
|
|
action: "confirm" | "reject" | "lock" | "remove",
|
|
) =>
|
|
request<RelationEvidence>(`/api/v1/topology/edges/${evidenceId}/action`, {
|
|
method: "POST",
|
|
body: JSON.stringify({ action }),
|
|
}),
|
|
};
|
|
|
|
export function subscribeToEvents(
|
|
onEvent: (event: EventRecord | Record<string, unknown>) => void,
|
|
onError?: () => void,
|
|
onOpen?: () => void,
|
|
): () => void {
|
|
if (accessToken) {
|
|
const controller = new AbortController();
|
|
void (async () => {
|
|
try {
|
|
const response = await fetch("/api/v1/events/stream", {
|
|
headers: { Authorization: `Bearer ${accessToken}`, Accept: "text/event-stream" },
|
|
signal: controller.signal,
|
|
});
|
|
if (!response.ok || !response.body) throw new Error(`SSE failed (${response.status})`);
|
|
onOpen?.();
|
|
const reader = response.body.getReader();
|
|
const decoder = new TextDecoder();
|
|
let buffer = "";
|
|
while (!controller.signal.aborted) {
|
|
const { value, done } = await reader.read();
|
|
if (done) break;
|
|
buffer += decoder.decode(value, { stream: true });
|
|
const frames = buffer.split("\n\n");
|
|
buffer = frames.pop() ?? "";
|
|
for (const frame of frames) {
|
|
const data = frame
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data:"))
|
|
.map((line) => line.slice(5).trim())
|
|
.join("\n");
|
|
if (!data) continue;
|
|
try {
|
|
onEvent(JSON.parse(data) as EventRecord);
|
|
} catch {
|
|
// Ignore a malformed event and retain the durable polling fallback.
|
|
}
|
|
}
|
|
}
|
|
if (!controller.signal.aborted) onError?.();
|
|
} catch {
|
|
if (!controller.signal.aborted) onError?.();
|
|
}
|
|
})();
|
|
return () => controller.abort();
|
|
}
|
|
const source = new EventSource("/api/v1/events/stream");
|
|
const emit = (message: MessageEvent) => {
|
|
try {
|
|
onEvent(JSON.parse(message.data) as EventRecord);
|
|
} catch {
|
|
/* reconnect/poll remains the fallback */
|
|
}
|
|
};
|
|
source.onmessage = emit;
|
|
// Named SSE events are only delivered to explicit listeners; a type missing
|
|
// here is silently dropped by EventSource.
|
|
for (const eventType of SSE_EVENT_TYPES) {
|
|
source.addEventListener(eventType, emit);
|
|
}
|
|
source.onerror = () => onError?.();
|
|
source.onopen = () => onOpen?.();
|
|
return () => source.close();
|
|
}
|