Skip to content

Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.

Check for Docker again while server setup waits on it (#955)

Abel Dantas031e0a6a2eca
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fff9e0b67..7abb8b285 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1829,6 +1829,13 @@ version of their own to them without also giving them a release of their own.
### [Unreleased]
+#### Fixed
+- **Setting up a server notices Docker once it starts.** "Set up a server on
+ this computer" checked for Docker only when the step opened, so installing or
+ starting Docker meanwhile left the setup skipping Mattermost until you went
+ back. It now checks again every few seconds, and when Console regains focus,
+ while Docker isn't answering.
+
### [0.40.1] - 2026-10-21
#### Added
diff --git a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/AddServerModal.tsx b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/AddServerModal.tsx
index 12bd38210..73989ffea 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/AddServerModal.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/AddServerModal.tsx
@@ -32,6 +32,7 @@ import {
urlOrigin,
} from '@shared/core/switch-servers/switch-servers';
import { ConnectionsStep } from './connections-step';
+import { recheckDocker } from './docker-recheck';
import { LinkAccountsStep } from './link-accounts-step';
import { localServerStore } from './local-server-store';
import { LogTail } from './log-tail';
@@ -152,6 +153,9 @@ const CHOICE_FOR_STEP: Record<Step, AddServerChoiceName | null> = {
linkAccounts: null,
};
+/** How often the local setup step asks again for a Docker that wasn't answering. */
+const DOCKER_RECHECK_MS = 3000;
+
export const AddServerModal = observer(function AddServerModal(props: Props) {
const isEdit = props.serverId != null;
const openedAt: Step = isEdit ? 'external' : (props.mode ?? 'choose');
@@ -533,6 +537,15 @@ export const LocalSetupStep = observer(function LocalSetupStep({
const needsDocker = store.runtime === 'docker';
const canStart = running || (store.runtime !== null && (!needsDocker || dockerReady));
+ // People install or start Docker while this step is open, so keep asking
+ // until it answers. Leaving the step, starting the server or Docker
+ // answering ends it.
+ const waitingForDocker = dockerUnavailable !== null && idle;
+ useEffect(() => {
+ if (!waitingForDocker) return;
+ return recheckDocker(() => store.checkDocker(), window, DOCKER_RECHECK_MS);
+ }, [store, waitingForDocker]);
+
// The pager's back arrow only ever repeats the footer's Back, so the two read
// one const. Open during the install too: the store is a singleton the main
// process streams into, so leaving loses only what is on screen, and holding
diff --git a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/docker-recheck.test.ts b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/docker-recheck.test.ts
new file mode 100644
index 000000000..213653953
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/docker-recheck.test.ts
@@ -0,0 +1,67 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { recheckDocker } from './docker-recheck';
+
+beforeEach(() => {
+ vi.useFakeTimers();
+});
+
+afterEach(() => {
+ vi.useRealTimers();
+});
+
+describe('recheckDocker', () => {
+ it('asks again a while after each check finishes', async () => {
+ const check = vi.fn(() => Promise.resolve());
+ const stop = recheckDocker(check, new EventTarget(), 3000);
+
+ await vi.advanceTimersByTimeAsync(2999);
+ expect(check).toHaveBeenCalledTimes(0);
+ await vi.advanceTimersByTimeAsync(1);
+ expect(check).toHaveBeenCalledTimes(1);
+ await vi.advanceTimersByTimeAsync(3000);
+ expect(check).toHaveBeenCalledTimes(2);
+ stop();
+ });
+
+ it('waits for a slow check instead of starting another', async () => {
+ let finish: () => void = () => {};
+ const check = vi.fn(() => new Promise<void>((resolve) => (finish = resolve)));
+ const target = new EventTarget();
+ const stop = recheckDocker(check, target, 3000);
+
+ await vi.advanceTimersByTimeAsync(3000);
+ target.dispatchEvent(new Event('focus'));
+ await vi.advanceTimersByTimeAsync(20_000);
+ expect(check).toHaveBeenCalledTimes(1);
+
+ finish();
+ await vi.advanceTimersByTimeAsync(3000);
+ expect(check).toHaveBeenCalledTimes(2);
+ stop();
+ });
+
+ it('checks at once when the window regains focus', async () => {
+ const check = vi.fn(() => Promise.resolve());
+ const target = new EventTarget();
+ const stop = recheckDocker(check, target, 3000);
+
+ target.dispatchEvent(new Event('focus'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(check).toHaveBeenCalledTimes(1);
+ stop();
+ });
+
+ it('does nothing more once stopped, even when a check finishes later', async () => {
+ let finish: () => void = () => {};
+ const check = vi.fn(() => new Promise<void>((resolve) => (finish = resolve)));
+ const target = new EventTarget();
+ const stop = recheckDocker(check, target, 3000);
+
+ await vi.advanceTimersByTimeAsync(3000);
+ stop();
+ finish();
+ target.dispatchEvent(new Event('focus'));
+ await vi.advanceTimersByTimeAsync(60_000);
+ expect(check).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/docker-recheck.ts b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/docker-recheck.ts
new file mode 100644
index 000000000..99bea9e25
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/docker-recheck.ts
@@ -0,0 +1,29 @@
+type FocusTarget = Pick<EventTarget, 'addEventListener' | 'removeEventListener'>;
+
+/**
+ * Asks for Docker again until stopped: `everyMs` after each check finishes, and
+ * at once when the window regains focus. A check can take seconds while Docker
+ * boots, so checks never overlap, and none is scheduled after stopping.
+ * Returns the function that stops it.
+ */
+export function recheckDocker(check: () => Promise<void>, target: FocusTarget, everyMs: number) {
+ let stopped = false;
+ let checking = false;
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ const run = () => {
+ if (stopped || checking) return;
+ checking = true;
+ clearTimeout(timer);
+ void check().finally(() => {
+ checking = false;
+ if (!stopped) timer = setTimeout(run, everyMs);
+ });
+ };
+ timer = setTimeout(run, everyMs);
+ target.addEventListener('focus', run);
+ return () => {
+ stopped = true;
+ clearTimeout(timer);
+ target.removeEventListener('focus', run);
+ };
+}
diff --git a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-docker-check.test.ts b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-docker-check.test.ts
new file mode 100644
index 000000000..3b42339a2
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-docker-check.test.ts
@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+/**
+ * The local setup step asks for Docker on open, on a timer and on window focus.
+ * Two checks in flight could finish out of order and leave an older "not
+ * running" on screen after a newer "available", so the store runs one at a time.
+ */
+
+const detectDocker = vi.fn();
+vi.mock('@renderer/lib/ipc', () => ({
+ rpc: { localSwitchServer: { detectDocker: () => detectDocker() } },
+ events: { on: () => () => {} },
+}));
+vi.mock('@renderer/features/locations/stores/agents-store', () => ({ agentsStore: {} }));
+vi.mock('./switch-servers-store', () => ({
+ switchServersStore: { init: () => Promise.resolve() },
+}));
+
+import { LocalServerStore } from './local-server-store';
+
+beforeEach(() => {
+ detectDocker.mockReset();
+});
+
+describe('checking for Docker', () => {
+ it('shares one check between callers while it is in flight', async () => {
+ let answer: (value: unknown) => void = () => {};
+ detectDocker.mockReturnValue(new Promise((resolve) => (answer = resolve)));
+ const store = new LocalServerStore();
+
+ const first = store.checkDocker();
+ const second = store.checkDocker();
+ answer({ available: true });
+ await Promise.all([first, second]);
+
+ expect(detectDocker).toHaveBeenCalledTimes(1);
+ expect(store.docker).toEqual({ available: true });
+ });
+
+ it('asks again once the previous check has finished', async () => {
+ detectDocker
+ .mockResolvedValueOnce({ available: false, reason: 'daemon', detail: 'not running' })
+ .mockResolvedValueOnce({ available: true });
+ const store = new LocalServerStore();
+
+ await store.checkDocker();
+ expect(store.docker).toMatchObject({ available: false });
+ await store.checkDocker();
+
+ expect(detectDocker).toHaveBeenCalledTimes(2);
+ expect(store.docker).toEqual({ available: true });
+ });
+});
diff --git a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-store.ts b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-store.ts
index b55960185..6024d7577 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-store.ts
+++ b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/local-server-store.ts
@@ -57,9 +57,10 @@ export class LocalServerStore {
* defeat the batching it exists for. */
/* internal */ pendingLines: string[] = [];
/* internal */ flushTimer: ReturnType<typeof setTimeout> | null = null;
+ /* internal */ dockerCheck: Promise<void> | null = null;
constructor() {
- makeAutoObservable(this, { pendingLines: false, flushTimer: false });
+ makeAutoObservable(this, { pendingLines: false, flushTimer: false, dockerCheck: false });
}
/** Headline and detail as one string, for the modals that have a single slot. */
@@ -182,7 +183,18 @@ export class LocalServerStore {
this.flushLines();
}
- async checkDocker(): Promise<void> {
+ /**
+ * One Docker check at a time: the setup step asks on open, on a timer and on
+ * window focus, and a slow older answer must not overwrite a newer one.
+ */
+ checkDocker(): Promise<void> {
+ this.dockerCheck ??= this.detectDocker().finally(() => {
+ this.dockerCheck = null;
+ });
+ return this.dockerCheck;
+ }
+
+ private async detectDocker(): Promise<void> {
try {
const docker = await rpc.localSwitchServer.detectDocker();
runInAction(() => {