docker-client-mx 1.35.0

package/dist-electron/ipc.js

@@ -0,0 +1,783 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCrashWatch = startCrashWatch;
+exports.flushEventHistory = flushEventHistory;
+exports.registerIpcHandlers = registerIpcHandlers;
+exports.attachWindow = attachWindow;
+const electron_1 = require("electron");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const channels_1 = require("./channels");
+const compose_1 = require("./compose");
+const compose_files_1 = require("./compose-files");
+const containers_1 = require("./containers");
+const port_conflicts_1 = require("./port-conflicts");
+const assistant_1 = require("./assistant");
+const assistant_key_1 = require("./assistant-key");
+const assistant_models_1 = require("./assistant-models");
+const contexts_1 = require("./contexts");
+const diagnosis_1 = require("./diagnosis");
+const docker_client_1 = require("./docker-client");
+const engine_1 = require("./engine");
+const health_1 = require("./health");
+const wiring_1 = require("./wiring");
+const attention_1 = require("./attention");
+const wiring_watch_1 = require("./wiring-watch");
+const image_history_1 = require("./image-history");
+const restart_policy_1 = require("./restart-policy");
+const run_command_1 = require("./run-command");
+const exec_1 = require("./exec");
+const host_shell_1 = require("./host-shell");
+const host_overview_1 = require("./host-overview");
+const terminal_transcript_1 = require("./terminal-transcript");
+const crash_1 = require("./crash");
+const container_events_1 = require("./container-events");
+const event_store_1 = require("./event-store");
+const events_1 = require("./events");
+const files_1 = require("./files");
+const volume_files_1 = require("./volume-files");
+const self_update_1 = require("./self-update");
+const settings_1 = require("./settings");
+const servers_1 = require("./servers");
+const i18n_1 = require("./i18n");
+const updates_1 = require("./updates");
+const volume_backup_1 = require("./volume-backup");
+const navigation_1 = require("./navigation");
+const images_1 = require("./images");
+const logs_1 = require("./logs");
+const networks_1 = require("./networks");
+const pull_1 = require("./pull");
+const renew_1 = require("./renew");
+const run_1 = require("./run");
+const volumes_1 = require("./volumes");
+const merged_logs_1 = require("./merged-logs");
+const stats_1 = require("./stats");
+const streams_1 = require("./streams");
+const system_1 = require("./system");
+/**
+ * Alles wat de renderer aanlevert wordt hier gecontroleerd voordat het een dockerode-aanroep
+ * in gaat. De renderer draait gesandboxed en laadt geen vreemde inhoud, dus dit is vooral een
+ * vangnet voor onze eigen fouten — maar het is het enige punt waar de grens ligt.
+ */
+const containerAction = zod_1.z.enum(['start', 'stop', 'restart', 'pause', 'unpause', 'remove']);
+const containerId = zod_1.z.string().min(1).max(128);
+// Het maximum telt alleen bij on-failure; honderd pogingen is al ruim voorbij waar het nog zin heeft.
+const restartPolicy = zod_1.z.object({
+    name: zod_1.z.enum(['no', 'always', 'unless-stopped', 'on-failure']),
+    maximumRetryCount: zod_1.z.number().int().min(0).max(100),
+});
+const containerIds = zod_1.z.array(containerId).max(1000);
+const streamId = zod_1.z.string().min(1).max(64);
+const logTail = zod_1.z.number().int().min(0).max(10_000);
+// Een referentie mag een registryhost, een pad, een tag en een digest bevatten; ruimer dan
+// dit wordt het niet, en alles wat er niet in past wijst de daemon toch af.
+const imageReference = zod_1.z.string().min(1).max(256).regex(/^[\w./:@-]+$/);
+const truthy = zod_1.z.boolean();
+// Een pad in de container. files.ts maakt het absoluut en net; hier alleen een grens.
+const containerPath = zod_1.z.string().min(1).max(4096);
+const fileKind = zod_1.z.enum(['dir', 'file']);
+// Een sleutel van de Claude API is een regel van een paar honderd tekens; main kijkt de vorm na.
+const apiKey = zod_1.z.string().min(1).max(512);
+// Een vraag aan Claude. Ruim, maar geen heel logbestand: dat haalt Claude zelf op.
+const question = zod_1.z.string().trim().min(1).max(4000);
+// Alleen de schakelaars; `strict` zodat een onbekende sleutel niet stil genegeerd wordt.
+const settingsPatch = zod_1.z
+    .object({
+    startAtLogin: zod_1.z.boolean().optional(),
+    notifyCrash: zod_1.z.boolean().optional(),
+    notifyUnhealthy: zod_1.z.boolean().optional(),
+    notifyWiring: zod_1.z.boolean().optional(),
+    autoUpdate: zod_1.z.boolean().optional(),
+    language: zod_1.z.enum(i18n_1.LANGUAGES).optional(),
+    assistantModel: zod_1.z.enum(assistant_models_1.ASSISTANT_MODELS).optional(),
+})
+    .strict();
+// Lokale paden die de preload uit gesleepte File-objecten haalde. Absoluut, en een handvol.
+const localPaths = zod_1.z.array(zod_1.z.string().min(1).max(4096).refine((value) => path.isAbsolute(value))).max(100);
+// Een distronaam zoals WSL die toestaat. main controleert daarna nog of hij in `wsl -l` staat.
+const wslDistro = zod_1.z.string().min(1).max(64).regex(/^[\w.-]+$/);
+// Volumenamen, netwerk-id's en contextnamen komen uit onze eigen lijst; dit is een grens,
+// geen validatie van wat Docker toelaat.
+const resourceName = zod_1.z.string().min(1).max(256);
+// Een extra naam in een netwerk. Docker laat hier hetzelfde toe als bij een containernaam.
+const networkAlias = zod_1.z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[\w][\w.-]*$/, {
+    error: () => (0, i18n_1.t)({
+        en: 'An alias may only contain letters, digits, dots, hyphens and underscores.',
+        nl: 'Een alias mag alleen letters, cijfers, punt, streepje en underscore bevatten.',
+        de: 'Ein Alias darf nur Buchstaben, Ziffern, Punkte, Bindestriche und Unterstriche enthalten.',
+        fr: 'Un alias ne peut contenir que des lettres, des chiffres, des points, des tirets et des underscores.',
+        es: 'Un alias solo puede contener letras, dígitos, puntos, guiones y guiones bajos.',
+    }),
+});
+/** Vorm en lengte; of het subnet en de gateway kloppen zegt createNetwork, in de taal van de app. */
+const newNetwork = zod_1.z.object({
+    name: resourceName,
+    // `bridge`, `overlay`, `macvlan`, of een plugin; de daemon zegt zelf of hij hem kent.
+    driver: zod_1.z.string().min(1).max(128).regex(/^[\w./:@-]+$/),
+    internal: truthy,
+    // Ruim genoeg voor een IPv6-CIDR, dat met 39 tekens plus het achtervoegsel het langst is.
+    subnet: zod_1.z.string().min(1).max(64).nullable(),
+    gateway: zod_1.z.string().min(1).max(64).nullable(),
+});
+/** Vorm en lengte; of het pad en de server kloppen zegt createVolume, in de taal van de app. */
+const newVolume = zod_1.z.object({
+    name: resourceName,
+    storage: zod_1.z.discriminatedUnion('kind', [
+        // `local`, of een plugin als `rexray/ebs:latest`; de daemon zegt zelf of hij hem kent.
+        zod_1.z.object({ kind: zod_1.z.literal('docker'), driver: zod_1.z.string().min(1).max(128).regex(/^[\w./:@-]+$/) }),
+        zod_1.z.object({ kind: zod_1.z.literal('folder'), path: zod_1.z.string().min(1).max(1024) }),
+        zod_1.z.object({ kind: zod_1.z.literal('nfs'), server: zod_1.z.string().min(1).max(253), path: zod_1.z.string().min(1).max(1024) }),
+    ]),
+});
+/** Vorm en lengte; of de waarden kloppen zegt createContext, met een melding die iemand begrijpt. */
+const newServer = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(64),
+    description: zod_1.z.string().max(200).nullable(),
+    kind: zod_1.z.enum(['ssh', 'tcp']),
+    host: zod_1.z.string().min(1).max(253),
+    port: zod_1.z.number().int().min(1).max(65_535).nullable(),
+    username: zod_1.z.string().max(64).nullable(),
+});
+const serverTestTarget = zod_1.z.union([zod_1.z.object({ context: resourceName }), zod_1.z.object({ server: newServer })]);
+const hostKeyName = zod_1.z.string().min(1).max(300);
+const hostKeyFingerprint = zod_1.z.string().min(1).max(100);
+const terminalSize = zod_1.z.number().int().min(1).max(1000);
+// Toetsaanslagen en geplakte tekst. Ruim genoeg voor een plak-actie, met een bovengrens zodat
+// één bericht niet ongelimiteerd geheugen vraagt.
+const terminalInput = zod_1.z.string().max(100_000);
+// Wat de opruimdialoog aanvinkt. `strict`: een onbekende sleutel is een renderer die iets
+// anders denkt op te ruimen dan main, en dan liever niets doen.
+const pruneSelection = zod_1.z
+    .object({
+    containers: zod_1.z.boolean(),
+    networks: zod_1.z.boolean(),
+    volumes: zod_1.z.boolean(),
+    images: zod_1.z.boolean(),
+    allImages: zod_1.z.boolean(),
+    buildCache: zod_1.z.boolean(),
+})
+    .strict();
+/**
+ * Het run-formulier. Dit is het enige punt in de app waar de renderer een containerspecificatie
+ * aanlevert, dus hier wordt echt gecontroleerd: poortnummers binnen bereik, een doelpad dat een
+ * absoluut pad ís, en een variabelenaam zonder `=` — die zou de KEY=value-notatie breken.
+ *
+ * De meldingen als functie: het schema staat vast, de taal niet.
+ */
+const runOptions = zod_1.z.object({
+    image: imageReference,
+    name: zod_1.z
+        .string()
+        .max(128)
+        .regex(/^[\w][\w.-]*$/, {
+        error: () => (0, i18n_1.t)({
+            en: 'A container name may only contain letters, digits, dots, hyphens and underscores.',
+            nl: 'Een containernaam mag alleen letters, cijfers, punt, streepje en underscore bevatten.',
+            de: 'Ein Containername darf nur Buchstaben, Ziffern, Punkte, Bindestriche und Unterstriche enthalten.',
+            fr: 'Un nom de conteneur ne peut contenir que des lettres, des chiffres, des points, des tirets et des underscores.',
+            es: 'Un nombre de contenedor solo puede contener letras, dígitos, puntos, guiones y guiones bajos.',
+        }),
+    })
+        .nullable(),
+    ports: zod_1.z
+        .array(zod_1.z.object({
+        hostPort: zod_1.z.number().int().min(1).max(65_535).nullable(),
+        containerPort: zod_1.z.number().int().min(1).max(65_535),
+        protocol: zod_1.z.enum(['tcp', 'udp']),
+    }))
+        .max(100),
+    volumes: zod_1.z
+        .array(zod_1.z.object({
+        source: zod_1.z.string().min(1).max(1024),
+        target: zod_1.z
+            .string()
+            .min(1)
+            .max(1024)
+            .startsWith('/', { error: () => (0, i18n_1.t)({
+                en: 'The path in the container must be absolute.',
+                nl: 'Het pad in de container moet absoluut zijn.',
+                de: 'Der Pfad im Container muss absolut sein.',
+                fr: 'Le chemin dans le conteneur doit être absolu.',
+                es: 'La ruta en el contenedor debe ser absoluta.',
+            }) }),
+        readOnly: zod_1.z.boolean(),
+    }))
+        .max(100),
+    env: zod_1.z
+        .array(zod_1.z.object({
+        key: zod_1.z
+            .string()
+            .min(1)
+            .max(256)
+            .refine((key) => !key.includes('='), { error: () => (0, i18n_1.t)({
+                en: 'A variable name may not contain =.',
+                nl: 'Een variabelenaam mag geen = bevatten.',
+                de: 'Ein Variablenname darf kein = enthalten.',
+                fr: 'Un nom de variable ne peut pas contenir de =.',
+                es: 'Un nombre de variable no puede contener =.',
+            }) }),
+        value: zod_1.z.string().max(32_768),
+    }))
+        .max(200),
+    network: resourceName.nullable(),
+    networkAlias: networkAlias.nullable(),
+    restart: zod_1.z.enum(['no', 'unless-stopped']),
+});
+/**
+ * De containers die meedoen in de gebundelde logweergave. Begrensd zoals de andere lijsten:
+ * de renderer stuurt wat er draait, en dat mag niet ongelimiteerd zijn.
+ */
+const logSources = zod_1.z
+    .array(zod_1.z.object({
+    containerId: zod_1.z.string().min(1).max(128),
+    containerName: zod_1.z.string().max(256),
+    composeProject: zod_1.z.string().max(256).nullable(),
+    composeService: zod_1.z.string().max(256).nullable(),
+}))
+    .max(200);
+const windows = new Map();
+/**
+ * De open shells, op het id dat de renderer kreeg. Het register hieronder sluit ze als het
+ * venster verdwijnt; deze map is er alleen om bij een lopende sessie te kunnen om naar te
+ * schrijven en hem te laten schalen.
+ */
+const execSessions = new Map();
+/**
+ * Wat de host-shell van elk venster liet zien, voor Claude in de tab ernaast. Per venster en
+ * niet per stream: bij opnieuw openen begint een nieuw transcript, en een venster heeft er
+ * hooguit één.
+ */
+const hostTranscripts = new Map();
+/**
+ * De events-stream voor crashmeldingen. Eén voor de hele app en niet per venster: een melding
+ * hoort ook te komen als er geen venster open is en de app in het systeemvak staat.
+ */
+let crashWatch = null;
+/** Een afzender die niets verstuurt; de crashwatcher heeft alleen de ruwe events nodig. */
+const NO_WINDOW = { send: () => undefined, isDestroyed: () => false };
+/**
+ * Begint met het volgen van crashes op de huidige verbinding. Na een contextwissel start
+ * `useContext` hem opnieuw, met een verse detector: wat de vorige daemon aan stops zag, zegt
+ * niets over de nieuwe.
+ */
+function startCrashWatch(onCrash, onWiring = () => undefined) {
+    crashWatch?.watcher.stop();
+    crashWatch?.wiring.stop();
+    // Wat er van de vorige context nog weg moest, eerst; die begint zo meteen niet meer bij.
+    events().flush();
+    const context = activeContext;
+    const detector = new crash_1.CrashDetector();
+    // Verder waar het vorige keer ophield, ook als de app intussen herstart is.
+    const current = events().load(context);
+    const record = (raw) => {
+        if (current.record(raw)) {
+            events().changed(context, current);
+        }
+    };
+    history = current;
+    // Een container die zijn netwerk of poorten kwijt is: nakijken na elk event dat het kan veroorzaken.
+    const wiring = new wiring_watch_1.WiringWatch({ check: () => readAttention(), notify: onWiring });
+    const watcher = new events_1.EventsWatcher(NO_WINDOW, undefined, (raw) => {
+        record(raw);
+        if (wiring_watch_1.WiringWatch.relevant(raw)) {
+            wiring.poke();
+        }
+        const notice = detector.observe(raw);
+        if (notice !== null) {
+            onCrash(notice);
+        }
+    });
+    crashWatch = { watcher, wiring, onCrash, onWiring };
+    watcher.start();
+    // Ook wat er bij het opstarten al mis is; traefik was al stuk toen de app startte.
+    wiring.poke();
+    // Wat de daemon nog weet, zodat de tab Gebeurtenissen niet leeg begint. Lukt het niet, dan
+    // begint hij leeg; dat is geen reden voor een melding.
+    (0, container_events_1.readDaemonEvents)()
+        .then((daemonEvents) => daemonEvents.forEach(record))
+        .catch(() => undefined);
+}
+/** De lijst van fase 40, voor het dashboard en voor de meldingen van fase 43. */
+async function readAttention() {
+    return (0, attention_1.buildAttention)({
+        containers: await (0, containers_1.listContainers)(),
+        eventsOf: (name) => history.eventsOf(name),
+        wiringOf: (id) => (0, wiring_1.readContainerWiring)(id),
+        now: Date.now(),
+    });
+}
+/** Bij het afsluiten: wat nog op schijf moest, nu. */
+function flushEventHistory() {
+    eventStore?.flush();
+}
+let eventStore = null;
+/** Pas bij het eerste gebruik: de gebruikersmap staat pas vast als main.ts hem gezet heeft. */
+function events() {
+    const file = () => path.join(electron_1.app.getPath('userData'), 'events.json');
+    eventStore ??= new event_store_1.EventStore({
+        read: () => {
+            try {
+                return (0, node_fs_1.readFileSync)(file(), 'utf8');
+            }
+            catch {
+                return null;
+            }
+        },
+        write: (text) => (0, node_fs_1.writeFileSync)(file(), text),
+        now: () => Date.now(),
+    });
+    return eventStore;
+}
+/**
+ * Wat er met containers gebeurd is, per naam. Hoort bij de crashwatcher: die volgt de stream al,
+ * app-breed en ook zonder venster, en begint bij een contextwissel opnieuw — net als dit.
+ */
+let history = new container_events_1.ContainerHistory();
+/**
+ * Een mislukte compose-opdracht met, bij een bezette poort, wie hem heeft. Hier en niet in
+ * compose.ts, want `containers.ts` leunt al op compose.ts en de lijst moet uit containers.ts komen.
+ */
+async function withPortHolder(result) {
+    if (result.ok) {
+        return result;
+    }
+    const lead = () => (0, i18n_1.t)({
+        en: 'Compose could not start a service: one of its ports is taken.',
+        nl: 'Compose kon een service niet starten: een van de poorten is bezet.',
+        de: 'Compose konnte einen Dienst nicht starten: einer der Ports ist belegt.',
+        fr: 'Compose n’a pas pu démarrer un service : l’un des ports est pris.',
+        es: 'Compose no pudo iniciar un servicio: uno de los puertos está ocupado.',
+    });
+    return { ok: false, problem: await (0, port_conflicts_1.explainPortConflict)(result.problem, containers_1.listContainers, { lead }) };
+}
+/** Welke context de app gebruikt. Bij het opstarten volgen we die van de CLI. */
+let activeContext = (0, contexts_1.currentContextName)();
+/**
+ * Claude, met dezelfde bronnen als de rest van de app. Hier en niet in assistant.ts, zodat die
+ * zonder Docker te testen is.
+ */
+const assistant = new assistant_1.AssistantService({
+    apiKey: () => (0, assistant_key_1.readApiKey)(),
+    model: () => (0, settings_1.assistantModel)(),
+    diagnose: (id) => (0, diagnosis_1.buildDiagnosis)(id, { appVersion: electron_1.app.getVersion(), context: activeContext }),
+    describeHost: async () => (0, host_overview_1.renderHostOverview)({
+        appVersion: electron_1.app.getVersion(),
+        context: activeContext,
+        engine: await (0, engine_1.readEngineStatus)(),
+        containers: await (0, containers_1.listContainers)().catch(() => []),
+    }),
+    terminal: (ownerId, lines) => hostTranscripts.get(ownerId)?.lines(lines) ?? null,
+    source: {
+        listContainers: () => (0, containers_1.listContainers)(),
+        inspect: async (id) => (await (0, docker_client_1.getConnection)().docker.getContainer(id).inspect()),
+        logs: (id, tty, tail) => (0, diagnosis_1.readLogs)(id, tty, tail),
+        events: (id) => (0, diagnosis_1.readEvents)(id, new Date()),
+        stats: async (id) => {
+            const raw = (await (0, docker_client_1.getConnection)().docker.getContainer(id).stats({ stream: false }));
+            const memory = (0, stats_1.toMemoryBytes)(raw);
+            return { cpuPercent: (0, stats_1.toCpuPercent)(raw), memoryBytes: memory.used, memoryLimitBytes: memory.limit };
+        },
+    },
+});
+function requireState(senderId) {
+    const state = windows.get(senderId);
+    if (state === undefined) {
+        throw new Error((0, i18n_1.t)({
+            en: 'This window has no stream registry.',
+            nl: 'Dit venster heeft geen streamregister.',
+            de: 'Dieses Fenster hat kein Streamregister.',
+            fr: 'Cette fenêtre n’a pas de registre de flux.',
+            es: 'Esta ventana no tiene registro de streams.',
+        }));
+    }
+    return state;
+}
+/**
+ * Zet de watchers en het streamregister van een venster opnieuw op.
+ *
+ * Nieuwe instanties en niet de oude opnieuw starten: `stop()` zet ze definitief stil, juist
+ * zodat een stream die nog aan het openen was niet alsnog binnenkomt nadat het venster weg is.
+ */
+function startWatchers(state) {
+    state.stats = new stats_1.StatsWatcher(state.sender);
+    state.mergedLogs = new merged_logs_1.MergedLogsWatcher(state.sender);
+    state.events = new events_1.EventsWatcher(state.sender);
+    state.streams = new streams_1.StreamRegistry(state.sender);
+    state.events.start();
+}
+function stopWatchers(state) {
+    state.stats.stop();
+    state.mergedLogs.stop();
+    state.events.stop();
+    state.streams.closeAll();
+}
+/**
+ * Schakelt om naar een andere context.
+ *
+ * Dit is bewust één functie. Alles wat aan de oude daemon hing moet dicht voordat de nieuwe
+ * verbinding er staat: de stats-streams, de events-stream, de logvensters, een lopende pull en
+ * elke open shell. Laat je er één staan, dan blijft die stilletjes van de vorige daemon lezen
+ * en klopt de helft van wat je ziet niet meer.
+ *
+ * `~/.docker/config.json` blijft ongemoeid: de keuze geldt voor deze app, niet voor je terminal.
+ */
+async function useContext(name) {
+    const target = (0, contexts_1.listContexts)(activeContext).find((context) => context.name === name);
+    if (target === undefined) {
+        return { ok: false, problem: (0, i18n_1.t)({
+                en: `Context '${name}' does not exist (anymore).`,
+                nl: `Context '${name}' bestaat niet (meer).`,
+                de: `Context '${name}' existiert nicht (mehr).`,
+                fr: `Le context '${name}' n’existe pas (ou plus).`,
+                es: `El context '${name}' no existe (ya).`,
+            }) };
+    }
+    if (!target.supported) {
+        return { ok: false, problem: target.reason ?? (0, i18n_1.t)({
+                en: `Context '${name}' is not supported.`,
+                nl: `Context '${name}' wordt niet ondersteund.`,
+                de: `Context '${name}' wird nicht unterstützt.`,
+                fr: `Le context '${name}' n’est pas pris en charge.`,
+                es: `El context '${name}' no es compatible.`,
+            }) };
+    }
+    for (const state of windows.values()) {
+        stopWatchers(state);
+    }
+    execSessions.clear();
+    (0, docker_client_1.setConnection)((0, docker_client_1.connectionFromHost)(target.host, target.tlsDir));
+    activeContext = name;
+    (0, compose_1.resetComposeStatus)();
+    const status = await (0, engine_1.readEngineStatus)();
+    if (crashWatch !== null) {
+        startCrashWatch(crashWatch.onCrash, crashWatch.onWiring);
+    }
+    for (const state of windows.values()) {
+        startWatchers(state);
+        // Alles opnieuw ophalen: de stores luisteren al op dit kanaal, dus dit is genoeg om de
+        // hele app op de nieuwe daemon te zetten.
+        state.streams.send(channels_1.CHANNELS.dockerEvents, ['container', 'image', 'volume', 'network']);
+    }
+    return { ok: true, status };
+}
+/**
+ * Laat de verbinding het adres van de actieve context volgen.
+ *
+ * Zonder dit praat de app met wat DOCKER_HOST of het platform aangeeft, en dat is niet
+ * noodzakelijk waar de CLI naar wijst: op Docker Desktop luistert `default` op
+ * docker_engine en `desktop-linux` op dockerDesktopLinuxEngine. Beide werken, dus het valt
+ * niet op — tot je een tweede daemon hebt en de app naar de verkeerde kijkt.
+ */
+function applyActiveContext() {
+    const target = (0, contexts_1.listContexts)(activeContext).find((context) => context.name === activeContext);
+    if (target?.supported === true) {
+        (0, docker_client_1.setConnection)((0, docker_client_1.connectionFromHost)(target.host, target.tlsDir));
+    }
+}
+const hostKeys = new servers_1.HostKeyInbox();
+/**
+ * Test een bewaarde context met zijn eigen certificaten, of een server uit het formulier. Van
+ * die laatste maken we het adres hier, met dezelfde controle als bij het bewaren: zo test je
+ * precies wat je straks toevoegt.
+ */
+function testTarget(target) {
+    if ('server' in target) {
+        const address = (0, contexts_1.serverHost)(target.server);
+        return 'problem' in address
+            ? Promise.resolve({ ok: false, problem: address.problem, unknownHostKey: null })
+            : (0, servers_1.testServer)(address.host, null, hostKeys);
+    }
+    const context = (0, contexts_1.listContexts)(activeContext).find((candidate) => candidate.name === target.context);
+    if (context === undefined) {
+        return Promise.resolve({
+            ok: false,
+            problem: (0, i18n_1.t)({
+                en: `Context '${target.context}' does not exist (anymore).`,
+                nl: `Context '${target.context}' bestaat niet (meer).`,
+                de: `Context '${target.context}' existiert nicht (mehr).`,
+                fr: `Le context '${target.context}' n’existe pas (ou plus).`,
+                es: `El context '${target.context}' no existe (ya).`,
+            }),
+            unknownHostKey: null,
+        });
+    }
+    return (0, servers_1.testServer)(context.host, context.tlsDir, hostKeys);
+}
+/** Wat een shell in een container en een shell op de host delen: het stream-id en het opruimen. */
+async function openShell(senderId, cols, rows, open) {
+    const state = requireState(senderId);
+    const size = { cols: terminalSize.parse(cols), rows: terminalSize.parse(rows) };
+    const reserved = state.streams.reserve('exec');
+    const outcome = await open(size, (chunk) => state.streams.send(`${channels_1.CHANNELS.execData}:${reserved}`, chunk), () => state.streams.send(`${channels_1.CHANNELS.execEnd}:${reserved}`, undefined));
+    if (!outcome.ok) {
+        state.streams.close(reserved);
+        return { ok: false, problem: outcome.problem };
+    }
+    execSessions.set(reserved, outcome.session);
+    state.streams.attach(reserved, {
+        destroy: () => {
+            outcome.session.destroy();
+            execSessions.delete(reserved);
+        },
+    });
+    return { ok: true, streamId: reserved, shell: outcome.session.shell };
+}
+/**
+ * `ipcMain.handle`, maar met een fout die de renderer kan tonen. Wat een handler gooit komt
+ * aan als "Error invoking remote method '…': " plus de melding; die melding maken we hier
+ * leesbaar, en de renderer haalt het voorvoegsel eraf.
+ */
+function handle(channel, listener) {
+    electron_1.ipcMain.handle(channel, async (event, ...args) => {
+        try {
+            return await listener(event, ...args);
+        }
+        catch (err) {
+            throw (0, docker_client_1.readableError)(err, (0, docker_client_1.getConnection)().endpoint);
+        }
+    });
+}
+/**
+ * De enige plek waar kanalen aan ipcMain hangen. Dat staat los van de domeinmodules zelf,
+ * om twee redenen: het is één lijst om te overzien welk oppervlak de renderer krijgt, en de
+ * domeinmodules blijven vrij van een import van 'electron' — dat module bestaat niet buiten
+ * Electron, en dus ook niet in een unittest.
+ */
+function registerIpcHandlers() {
+    applyActiveContext();
+    handle(channels_1.CHANNELS.engineStatus, () => (0, engine_1.readEngineStatus)());
+    handle(channels_1.CHANNELS.engineStartWsl, (_event, distro) => (0, engine_1.startWsl)(wslDistro.parse(distro)));
+    handle(channels_1.CHANNELS.engineStartWslDaemon, (_event, distro) => (0, engine_1.startWslDaemon)(wslDistro.parse(distro)));
+    handle(channels_1.CHANNELS.containersList, () => (0, containers_1.listContainers)());
+    handle(channels_1.CHANNELS.containersInspect, (_event, id) => (0, containers_1.inspectContainer)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.containersHealth, (_event, id) => (0, health_1.readContainerHealth)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.containersEvents, (_event, name) => history.eventsOf(resourceName.parse(name)));
+    handle(channels_1.CHANNELS.containersWiring, (_event, id) => (0, wiring_1.readContainerWiring)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.containersAttention, () => readAttention());
+    handle(channels_1.CHANNELS.containersRunCommand, (_event, id) => (0, run_command_1.readRunCommand)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.containersRestartPolicy, (_event, id) => (0, restart_policy_1.readRestartPolicy)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.containersSetRestartPolicy, (_event, id, policy) => (0, restart_policy_1.applyRestartPolicy)(containerId.parse(id), restartPolicy.parse(policy)));
+    handle(channels_1.CHANNELS.containersDiagnose, (_event, id) => (0, diagnosis_1.buildDiagnosis)(containerId.parse(id), { appVersion: electron_1.app.getVersion(), context: activeContext }));
+    handle(channels_1.CHANNELS.containersAction, (_event, action, id) => (0, containers_1.runContainerAction)(containerAction.parse(action), containerId.parse(id)));
+    handle(channels_1.CHANNELS.containersWatchStats, async (event, ids) => {
+        await windows.get(event.sender.id)?.stats.watch(containerIds.parse(ids));
+    });
+    handle(channels_1.CHANNELS.imagesList, () => (0, images_1.listImages)());
+    handle(channels_1.CHANNELS.imagesHistory, (_event, reference) => (0, image_history_1.readImageHistory)(imageReference.parse(reference)));
+    handle(channels_1.CHANNELS.imagesRemove, (_event, reference, force) => (0, images_1.removeImage)(imageReference.parse(reference), truthy.parse(force)));
+    handle(channels_1.CHANNELS.imagesPrune, (_event, all) => (0, images_1.pruneImages)(truthy.parse(all)));
+    handle(channels_1.CHANNELS.imagesRun, (_event, options) => (0, run_1.runContainer)(runOptions.parse(options)));
+    handle(channels_1.CHANNELS.imagesPull, async (event, reference) => {
+        const state = requireState(event.sender.id);
+        const reserved = state.streams.reserve('pull');
+        const channel = `${channels_1.CHANNELS.imagesPullProgress}:${reserved}`;
+        const outcome = await (0, pull_1.openPullStream)(imageReference.parse(reference), (progress) => {
+            // Na een pull wijst de tag misschien ergens anders heen; het oude antwoord klopt dan niet
+            // meer. Alles wissen: `nginx` ophalen raakt ook wat als `nginx:latest` onthouden was.
+            if (progress.done) {
+                (0, updates_1.clearUpdateCache)();
+            }
+            state.streams.send(channel, progress);
+        });
+        if (!outcome.ok) {
+            // Het id weer vrijgeven; anders blijft er een reservering hangen waar nooit een stream
+            // bij komt.
+            state.streams.close(reserved);
+            return { ok: false, problem: outcome.problem };
+        }
+        state.streams.attach(reserved, outcome.stream);
+        return { ok: true, streamId: reserved };
+    });
+    handle(channels_1.CHANNELS.imagesCheckUpdates, () => (0, updates_1.checkImageUpdates)());
+    handle(channels_1.CHANNELS.imagesStale, (_event, reference) => (0, renew_1.listStaleContainers)(imageReference.parse(reference)));
+    handle(channels_1.CHANNELS.imagesRenew, (_event, reference) => (0, renew_1.renewContainers)(imageReference.parse(reference)));
+    handle(channels_1.CHANNELS.imagesPullClose, (event, id) => {
+        windows.get(event.sender.id)?.streams.close(streamId.parse(id));
+    });
+    handle(channels_1.CHANNELS.volumesList, () => (0, volumes_1.listVolumes)());
+    handle(channels_1.CHANNELS.volumesSizes, () => (0, volumes_1.readVolumeSizes)());
+    handle(channels_1.CHANNELS.volumesCreate, (_event, volume) => (0, volumes_1.createVolume)(newVolume.parse(volume)));
+    handle(channels_1.CHANNELS.volumesRemove, (_event, name, force) => (0, volumes_1.removeVolume)(resourceName.parse(name), truthy.parse(force)));
+    handle(channels_1.CHANNELS.volumesPrune, (_event, all) => (0, volumes_1.pruneVolumes)(truthy.parse(all)));
+    handle(channels_1.CHANNELS.volumesBrowse, (_event, name, dir) => (0, volume_files_1.listVolumeDirectory)(resourceName.parse(name), containerPath.parse(dir)));
+    handle(channels_1.CHANNELS.volumesCloseBrowser, () => (0, volume_files_1.closeVolumeBrowser)());
+    handle(channels_1.CHANNELS.volumesBackup, (event, name) => (0, volume_backup_1.backupVolume)(resourceName.parse(name), async (suggestedName) => {
+        const owner = electron_1.BrowserWindow.fromWebContents(event.sender);
+        const options = { defaultPath: suggestedName, filters: [{ name: (0, i18n_1.t)({ en: 'Backup', nl: 'Back-up', de: 'Sicherung', fr: 'Sauvegarde', es: 'Copia de seguridad' }), extensions: ['tar'] }] };
+        const choice = owner === null ? await electron_1.dialog.showSaveDialog(options) : await electron_1.dialog.showSaveDialog(owner, options);
+        return choice.canceled || choice.filePath === undefined ? null : choice.filePath;
+    }));
+    handle(channels_1.CHANNELS.volumesRestore, async (event, name) => {
+        const volume = resourceName.parse(name);
+        const owner = electron_1.BrowserWindow.fromWebContents(event.sender);
+        const options = { properties: ['openFile'], filters: [{ name: (0, i18n_1.t)({ en: 'Backup', nl: 'Back-up', de: 'Sicherung', fr: 'Sauvegarde', es: 'Copia de seguridad' }), extensions: ['tar'] }] };
+        const choice = owner === null ? await electron_1.dialog.showOpenDialog(options) : await electron_1.dialog.showOpenDialog(owner, options);
+        return (0, volume_backup_1.restoreVolume)(volume, choice.canceled ? null : (choice.filePaths[0] ?? null));
+    });
+    handle(channels_1.CHANNELS.networksList, () => (0, networks_1.listNetworks)());
+    handle(channels_1.CHANNELS.networksCreate, (_event, network) => (0, networks_1.createNetwork)(newNetwork.parse(network)));
+    handle(channels_1.CHANNELS.networksRemove, (_event, id) => (0, networks_1.removeNetwork)(resourceName.parse(id)));
+    handle(channels_1.CHANNELS.networksPrune, () => (0, networks_1.pruneNetworks)());
+    handle(channels_1.CHANNELS.networksMembers, (_event, name) => (0, networks_1.listNetworkMembers)(resourceName.parse(name)));
+    handle(channels_1.CHANNELS.networksOfContainer, (_event, id) => (0, networks_1.listContainerNetworks)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.networksConnect, (_event, network, id, alias) => (0, networks_1.connectContainer)(resourceName.parse(network), containerId.parse(id), networkAlias.nullable().parse(alias)));
+    handle(channels_1.CHANNELS.networksDisconnect, (_event, network, id) => (0, networks_1.disconnectContainer)(resourceName.parse(network), containerId.parse(id)));
+    handle(channels_1.CHANNELS.composeStatus, () => (0, compose_1.readComposeStatus)());
+    handle(channels_1.CHANNELS.composeUp, async (_event, name) => withPortHolder(await (0, compose_1.runComposeCommand)(resourceName.parse(name), 'up')));
+    handle(channels_1.CHANNELS.composeDown, (_event, name) => (0, compose_1.runComposeCommand)(resourceName.parse(name), 'down'));
+    handle(channels_1.CHANNELS.composeRecreate, async (_event, name, service) => withPortHolder(await (0, compose_1.recreateService)(resourceName.parse(name), resourceName.parse(service))));
+    handle(channels_1.CHANNELS.composeFiles, (_event, name) => (0, compose_files_1.readProjectFiles)(resourceName.parse(name)));
+    handle(channels_1.CHANNELS.composeConfig, (_event, name) => (0, compose_files_1.readResolvedConfig)(resourceName.parse(name)));
+    handle(channels_1.CHANNELS.systemDiskUsage, () => (0, system_1.readDiskUsage)());
+    handle(channels_1.CHANNELS.systemPrune, (_event, selection) => (0, system_1.pruneSystem)(pruneSelection.parse(selection)));
+    handle(channels_1.CHANNELS.navigationTakePending, () => (0, navigation_1.takePendingRoute)());
+    handle(channels_1.CHANNELS.assistantStatus, () => ({ configured: (0, assistant_key_1.hasApiKey)(), storageAvailable: (0, assistant_key_1.keyStoreAvailable)() }));
+    handle(channels_1.CHANNELS.assistantSetKey, (_event, key) => (0, assistant_key_1.saveApiKey)(apiKey.parse(key)));
+    handle(channels_1.CHANNELS.assistantClearKey, () => {
+        (0, assistant_key_1.removeApiKey)();
+        return { configured: (0, assistant_key_1.hasApiKey)(), storageAvailable: (0, assistant_key_1.keyStoreAvailable)() };
+    });
+    handle(channels_1.CHANNELS.assistantStart, (event, id) => {
+        const sender = event.sender;
+        return assistant.start(sender.id, containerId.nullable().parse(id), (conversation, payload) => {
+            if (!sender.isDestroyed()) {
+                sender.send(`${channels_1.CHANNELS.assistantEvent}:${conversation}`, payload);
+            }
+        });
+    });
+    handle(channels_1.CHANNELS.assistantAsk, (event, id, text) => assistant.ask(event.sender.id, streamId.parse(id), question.parse(text)));
+    handle(channels_1.CHANNELS.assistantClose, (event, id) => assistant.close(event.sender.id, streamId.parse(id)));
+    handle(channels_1.CHANNELS.settingsGet, () => (0, settings_1.readSettings)());
+    handle(channels_1.CHANNELS.settingsUpdate, (_event, patch) => (0, settings_1.updateSettings)(settingsPatch.parse(patch)));
+    handle(channels_1.CHANNELS.appUpdateGet, () => (0, self_update_1.readAppUpdate)());
+    handle(channels_1.CHANNELS.appUpdateCheck, () => (0, self_update_1.checkForAppUpdate)());
+    // Via before-quit in main.ts, net als Afsluiten in het systeemvak: dan ruimt die ook de
+    // hulpcontainers van de host-terminal op.
+    handle(channels_1.CHANNELS.appQuit, () => electron_1.app.quit());
+    handle(channels_1.CHANNELS.appUpdateInstall, () => (0, self_update_1.installAppUpdate)());
+    handle(channels_1.CHANNELS.filesList, (_event, id, dir) => (0, files_1.listDirectory)(containerId.parse(id), containerPath.parse(dir)));
+    handle(channels_1.CHANNELS.filesChanges, (_event, id) => (0, files_1.listChanges)(containerId.parse(id)));
+    handle(channels_1.CHANNELS.filesDownload, (event, id, source, kind) => (0, files_1.downloadPath)(containerId.parse(id), containerPath.parse(source), fileKind.parse(kind), async (suggestedName) => {
+        const owner = electron_1.BrowserWindow.fromWebContents(event.sender);
+        const options = { defaultPath: suggestedName };
+        const choice = owner === null ? await electron_1.dialog.showSaveDialog(options) : await electron_1.dialog.showSaveDialog(owner, options);
+        return choice.canceled || choice.filePath === undefined ? null : choice.filePath;
+    }));
+    handle(channels_1.CHANNELS.filesUpload, (_event, id, dir, locals) => (0, files_1.uploadFiles)(containerId.parse(id), containerPath.parse(dir), localPaths.parse(locals)));
+    handle(channels_1.CHANNELS.filesChooseAndUpload, async (event, id, dir) => {
+        const owner = electron_1.BrowserWindow.fromWebContents(event.sender);
+        const options = { properties: ['openFile', 'multiSelections'] };
+        const choice = owner === null ? await electron_1.dialog.showOpenDialog(options) : await electron_1.dialog.showOpenDialog(owner, options);
+        if (choice.canceled) {
+            return { ok: true, count: 0 };
+        }
+        return (0, files_1.uploadFiles)(containerId.parse(id), containerPath.parse(dir), choice.filePaths);
+    });
+    handle(channels_1.CHANNELS.contextsList, () => (0, contexts_1.listContexts)(activeContext));
+    handle(channels_1.CHANNELS.contextsUse, (_event, name) => useContext(resourceName.parse(name)));
+    handle(channels_1.CHANNELS.contextsCreate, (_event, server) => (0, contexts_1.createContext)(newServer.parse(server)));
+    handle(channels_1.CHANNELS.contextsRemove, (_event, name) => (0, contexts_1.removeContext)(resourceName.parse(name), activeContext));
+    handle(channels_1.CHANNELS.contextsTest, (_event, target) => testTarget(serverTestTarget.parse(target)));
+    handle(channels_1.CHANNELS.contextsTrustHostKey, (_event, name, shown) => hostKeys.trust(hostKeyName.parse(name), hostKeyFingerprint.parse(shown)));
+    handle(channels_1.CHANNELS.execOpen, (event, id, cols, rows) => {
+        const target = containerId.parse(id);
+        return openShell(event.sender.id, cols, rows, (size, onData, onEnd) => (0, exec_1.openExec)(target, size, onData, onEnd));
+    });
+    handle(channels_1.CHANNELS.execOpenHost, (event, cols, rows) => {
+        const transcript = new terminal_transcript_1.TerminalTranscript();
+        const owner = event.sender.id;
+        hostTranscripts.set(owner, transcript);
+        return openShell(owner, cols, rows, (size, onData, onEnd) => (0, host_shell_1.openHostShell)(size, (chunk) => {
+            transcript.append(chunk);
+            onData(chunk);
+        }, onEnd));
+    });
+    handle(channels_1.CHANNELS.execWrite, (_event, id, data) => {
+        execSessions.get(streamId.parse(id))?.write(terminalInput.parse(data));
+    });
+    handle(channels_1.CHANNELS.execResize, (_event, id, cols, rows) => {
+        execSessions.get(streamId.parse(id))?.resize(terminalSize.parse(cols), terminalSize.parse(rows));
+    });
+    handle(channels_1.CHANNELS.execClose, (event, id) => {
+        windows.get(event.sender.id)?.streams.close(streamId.parse(id));
+    });
+    handle(channels_1.CHANNELS.logsOpen, async (event, id, tail) => {
+        const state = requireState(event.sender.id);
+        // Het id wordt uitgegeven vóór de stream bestaat, zodat een close() tijdens het openen
+        // niet in het luchtledige valt. Zie StreamRegistry.
+        const reserved = state.streams.reserve('logs');
+        const channel = `${channels_1.CHANNELS.logsLines}:${reserved}`;
+        const stream = await (0, logs_1.openLogStream)(containerId.parse(id), logTail.parse(tail), (lines) => {
+            state.streams.send(channel, lines);
+        });
+        state.streams.attach(reserved, stream);
+        return reserved;
+    });
+    handle(channels_1.CHANNELS.logsClose, (event, id) => {
+        windows.get(event.sender.id)?.streams.close(streamId.parse(id));
+    });
+    handle(channels_1.CHANNELS.logsWatchAll, async (event, sources) => {
+        await requireState(event.sender.id).mergedLogs.watch(logSources.parse(sources));
+    });
+}
+/**
+ * Hangt de streams aan één venster. Ze horen bij dat venster en niet bij de app: zonder het
+ * opruimen hieronder blijft een stats-, log- of execstream doorlopen nadat het venster weg is.
+ */
+function attachWindow(window) {
+    const sender = window.webContents;
+    const state = {
+        sender,
+        stats: new stats_1.StatsWatcher(sender),
+        mergedLogs: new merged_logs_1.MergedLogsWatcher(sender),
+        events: new events_1.EventsWatcher(sender),
+        streams: new streams_1.StreamRegistry(sender),
+    };
+    windows.set(sender.id, state);
+    state.events.start();
+    sender.once('destroyed', () => {
+        stopWatchers(state);
+        assistant.closeOwner(sender.id);
+        hostTranscripts.delete(sender.id);
+        windows.delete(sender.id);
+    });
+}
+//# sourceMappingURL=ipc.js.map