crewly 1.20.148 → 1.20.149

package/dist/backend/backend/src/services/cloud/cloud-disconnect-notice.service.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Cloud disconnect notice — tells the owner on Slack when this machine has
+ * lost Crewly Cloud, and lets them fix it from their phone.
+ *
+ * Why: inbound Slack reaches a machine only through Cloud → relay. When a
+ * machine's Cloud sign-in expires (or Cloud is unreachable) its agents can
+ * still post, but every message to them queues in Cloud unseen. On
+ * 2026-09-27 a second Mac sat like that for hours; nobody was told, and the
+ * owner — never at the machine — could not fix it remotely.
+ *
+ * What it does, once a minute:
+ * 1. Detect ({@link evaluateDisconnect}): signed in (a Cloud config exists)
+ *    AND (sync is `auth_expired` OR Cloud has not answered for 15 min).
+ * 2. When the sign-in is the problem, run `crewly cloud login --no-browser`
+ *    in a PTY ({@link startCloudLogin}) — the same device pairing the owner
+ *    would run by hand — and take the approve link it prints.
+ * 3. DM the owner through the Slack Web API with the bot tokens this machine
+ *    already holds (outbound needs no Cloud), link included.
+ * 4. The CLI waits for the approval and saves the credentials itself; then
+ *    CloudSync is restarted and the owner gets 「已重新连上 Cloud…」.
+ *    If the CLI asks for typed input, the owner's reply is read straight from
+ *    the DM (`conversations.history`) — it cannot arrive through Cloud.
+ *
+ * Rate limit: one notice per disconnect episode, repeated at most every 6 h,
+ * persisted under the Crewly home so a restart does not re-notify. An
+ * expired link is replaced by editing the same message (no new
+ * notification); a failed login gets one brief note and waits for the next
+ * window. Kill switch: `CREWLY_CLOUD_DISCONNECT_NOTICE=0`.
+ *
+ * @module services/cloud/cloud-disconnect-notice.service
+ */
+import type { OwnerDirectDm } from '../slack/slack-owner-direct-dm.js';
+import type { CloudSyncHealth } from './cloud-sync.types.js';
+import { type CloudLoginHandle } from './cloud-login-runner.js';
+/** Minimal logger. */
+export interface DisconnectNoticeLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+}
+/** Everything the service touches outside itself. */
+export interface CloudDisconnectNoticeDeps {
+    /** State file (`<crewlyHome>/cloud/disconnect-notice.json`) */
+    stateFile: string;
+    /** A Cloud config exists (signed in, not logged out) */
+    isSignedIn: () => Promise<boolean>;
+    /** CloudSyncService health */
+    getHealth: () => CloudSyncHealth;
+    /** This machine's name */
+    getDeviceName: () => Promise<string>;
+    /** Owner DM over the bot token, or null when Slack is not configured here */
+    getDm: () => OwnerDirectDm | null;
+    /** Start `crewly cloud login` in a PTY (throws when it cannot) */
+    startLogin: () => CloudLoginHandle;
+    /** After a successful CLI login: make sure CloudSync runs on the new credentials */
+    reconnect: () => Promise<boolean>;
+    logger: DisconnectNoticeLogger;
+    now: () => number;
+    schedule: (fn: () => void, ms: number) => unknown;
+    cancel: (handle: unknown) => void;
+    thresholdMs?: number;
+    repeatMs?: number;
+    checkIntervalMs?: number;
+    linkWaitMs?: number;
+    loginRetryMs?: number;
+    replyPollMs?: number;
+    replyMaxWaitMs?: number;
+}
+/** Watches the Cloud connection and DMs the owner when it is lost. */
+export declare class CloudDisconnectNoticeService {
+    private readonly deps;
+    private readonly thresholdMs;
+    private readonly repeatMs;
+    private readonly checkIntervalMs;
+    private readonly linkWaitMs;
+    private readonly loginRetryMs;
+    private readonly replyPollMs;
+    private readonly replyMaxWaitMs;
+    private monitorStartedAt;
+    private timer;
+    private stopped;
+    private ticking;
+    private login;
+    private lastLoginAttemptAt;
+    private replyTimer;
+    private replyDeadline;
+    private lastReplyTs;
+    /** Where the current notice is (for reading the owner's replies) */
+    private notice;
+    /** Serialises checks and login outcomes so neither overwrites the other's state */
+    private chain;
+    /**
+     * @param deps - Collaborators (see {@link CloudDisconnectNoticeDeps})
+     */
+    constructor(deps: CloudDisconnectNoticeDeps);
+    /** Start checking every minute. */
+    start(): void;
+    /** Stop checking and kill any login run. */
+    stop(): void;
+    /**
+     * One check. Public for tests; the timer calls it every minute.
+     *
+     * @returns Resolves when the check (and any notice) is done
+     */
+    tick(): Promise<void>;
+    /**
+     * Run `fn` after every earlier check / login outcome has finished.
+     *
+     * @param fn - Work that reads and writes the state file
+     * @returns Resolves when `fn` is done (never rejects)
+     */
+    private serial;
+    /**
+     * The check itself: detect, then notify, refresh the link, or close the episode.
+     */
+    private check;
+    /**
+     * Send the notice (first of the episode, or the 6-hourly repeat).
+     *
+     * @param state - Episode state (updated in place)
+     * @param reason - Why
+     */
+    private sendNotice;
+    /**
+     * Whether to start a new login run and put its link into the notice:
+     * sign-in problem, a notice to edit, no live run, not blocked by a failed
+     * login, and not retried within the last few minutes.
+     *
+     * @param state - Episode state
+     * @param now - Now (epoch ms)
+     * @returns True to refresh
+     */
+    private shouldRefreshLink;
+    /**
+     * Start a login run and edit the notice to carry its link (the link in it
+     * is missing or has expired). Editing does not notify the owner again.
+     *
+     * @param state - Episode state (updated in place)
+     */
+    private refreshLink;
+    /**
+     * Start (or reuse) a CLI login run and wait briefly for its link.
+     *
+     * @returns The run's snapshot with a link, or null when none came
+     */
+    private ensureLoginLink;
+    /**
+     * A login run ended.
+     *
+     * @param handle - The run
+     * @param snapshot - How it ended
+     */
+    private onLoginFinished;
+    /**
+     * Tell the owner briefly that the login did not finish, and hold further
+     * login runs until the next notice window.
+     *
+     * @param state - Episode state (updated in place)
+     * @param detail - Owner-facing reason
+     */
+    private blockUntilNextWindow;
+    /**
+     * The episode is over: forget it and, when the owner was told and the
+     * machine is back, say so.
+     *
+     * @param reconnected - Back on Cloud (false = logged out on purpose)
+     */
+    private endEpisode;
+    /** Read the owner's DM replies while the CLI waits for typed input. */
+    private startReplyPolling;
+    /** Stop reading replies. */
+    private stopReplyPolling;
+    /**
+     * This machine's name (hostname fallback is the caller's job).
+     *
+     * @returns The name
+     */
+    private deviceName;
+    /** Schedule the next check. */
+    private scheduleNext;
+}
+/** Live hooks the server provides to {@link createCloudDisconnectNoticeService}. */
+export interface CloudDisconnectNoticeWiring {
+    /** Crewly home (the state file lives here) */
+    crewlyHome: string;
+    /** Owner DM over this machine's bot token, or null when Slack is not configured */
+    getDm: () => OwnerDirectDm | null;
+    /** Restart CloudSync on the credentials the CLI saved */
+    reconnect: () => Promise<boolean>;
+    /** This machine's name */
+    getDeviceName: () => Promise<string>;
+}
+/**
+ * Build the service with the real Cloud config, CloudSync health, CLI login,
+ * clock and timers.
+ *
+ * @param wiring - Server hooks
+ * @returns The service (not started)
+ */
+export declare function createCloudDisconnectNoticeService(wiring: CloudDisconnectNoticeWiring): CloudDisconnectNoticeService;
+//# sourceMappingURL=cloud-disconnect-notice.service.d.ts.map

package/dist/backend/backend/src/services/cloud/cloud-disconnect-notice.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-disconnect-notice.service.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/cloud/cloud-disconnect-notice.service.ts"],"names":[],"mappings":"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"}

package/dist/backend/backend/src/services/cloud/cloud-disconnect-notice.service.js

@@ -0,0 +1,485 @@
+/**
+ * Cloud disconnect notice — tells the owner on Slack when this machine has
+ * lost Crewly Cloud, and lets them fix it from their phone.
+ *
+ * Why: inbound Slack reaches a machine only through Cloud → relay. When a
+ * machine's Cloud sign-in expires (or Cloud is unreachable) its agents can
+ * still post, but every message to them queues in Cloud unseen. On
+ * 2026-09-27 a second Mac sat like that for hours; nobody was told, and the
+ * owner — never at the machine — could not fix it remotely.
+ *
+ * What it does, once a minute:
+ * 1. Detect ({@link evaluateDisconnect}): signed in (a Cloud config exists)
+ *    AND (sync is `auth_expired` OR Cloud has not answered for 15 min).
+ * 2. When the sign-in is the problem, run `crewly cloud login --no-browser`
+ *    in a PTY ({@link startCloudLogin}) — the same device pairing the owner
+ *    would run by hand — and take the approve link it prints.
+ * 3. DM the owner through the Slack Web API with the bot tokens this machine
+ *    already holds (outbound needs no Cloud), link included.
+ * 4. The CLI waits for the approval and saves the credentials itself; then
+ *    CloudSync is restarted and the owner gets 「已重新连上 Cloud…」.
+ *    If the CLI asks for typed input, the owner's reply is read straight from
+ *    the DM (`conversations.history`) — it cannot arrive through Cloud.
+ *
+ * Rate limit: one notice per disconnect episode, repeated at most every 6 h,
+ * persisted under the Crewly home so a restart does not re-notify. An
+ * expired link is replaced by editing the same message (no new
+ * notification); a failed login gets one brief note and waits for the next
+ * window. Kill switch: `CREWLY_CLOUD_DISCONNECT_NOTICE=0`.
+ *
+ * @module services/cloud/cloud-disconnect-notice.service
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { CLOUD_DISCONNECT_NOTICE_CONSTANTS } from '../../../../config/constants.js';
+import { LoggerService } from '../core/logger.service.js';
+import { resolveRunningPackageRoot } from '../system/auto-update.utils.js';
+import { CloudClientService } from './cloud-client.service.js';
+import { CloudSyncService } from './cloud-sync.service.js';
+import { isCloudLoginFinished, startCloudLogin } from './cloud-login-runner.js';
+import { RECONNECTED_NOTICE, clearNoticeState, composeDisconnectNotice, composeLoginFailedNotice, evaluateDisconnect, readNoticeState, shouldNotify, writeNoticeState, } from './cloud-disconnect-notice.utils.js';
+const C = CLOUD_DISCONNECT_NOTICE_CONSTANTS;
+/**
+ * Owner-facing text for how a login run ended.
+ *
+ * @param snapshot - The finished run
+ * @returns Short Chinese reason
+ */
+function loginFailureDetail(snapshot) {
+    if (snapshot.state === 'timed_out')
+        return '等待超时';
+    if (snapshot.state === 'expired')
+        return '链接已过期';
+    if (snapshot.message && /denied/i.test(snapshot.message))
+        return '登录被拒绝';
+    return '登录命令出错';
+}
+/** Watches the Cloud connection and DMs the owner when it is lost. */
+export class CloudDisconnectNoticeService {
+    deps;
+    thresholdMs;
+    repeatMs;
+    checkIntervalMs;
+    linkWaitMs;
+    loginRetryMs;
+    replyPollMs;
+    replyMaxWaitMs;
+    monitorStartedAt = 0;
+    timer = null;
+    stopped = true;
+    ticking = false;
+    login = null;
+    lastLoginAttemptAt = 0;
+    replyTimer = null;
+    replyDeadline = 0;
+    lastReplyTs = null;
+    /** Where the current notice is (for reading the owner's replies) */
+    notice = null;
+    /** Serialises checks and login outcomes so neither overwrites the other's state */
+    chain = Promise.resolve();
+    /**
+     * @param deps - Collaborators (see {@link CloudDisconnectNoticeDeps})
+     */
+    constructor(deps) {
+        this.deps = deps;
+        this.thresholdMs = deps.thresholdMs ?? C.DISCONNECT_THRESHOLD_MS;
+        this.repeatMs = deps.repeatMs ?? C.REPEAT_INTERVAL_MS;
+        this.checkIntervalMs = deps.checkIntervalMs ?? C.CHECK_INTERVAL_MS;
+        this.linkWaitMs = deps.linkWaitMs ?? C.LINK_WAIT_MS;
+        this.loginRetryMs = deps.loginRetryMs ?? C.LOGIN_RETRY_MS;
+        this.replyPollMs = deps.replyPollMs ?? C.REPLY_POLL_INTERVAL_MS;
+        this.replyMaxWaitMs = deps.replyMaxWaitMs ?? C.REPLY_MAX_WAIT_MS;
+    }
+    /** Start checking every minute. */
+    start() {
+        if (!this.stopped)
+            return;
+        this.stopped = false;
+        this.monitorStartedAt = this.deps.now();
+        this.scheduleNext();
+    }
+    /** Stop checking and kill any login run. */
+    stop() {
+        this.stopped = true;
+        if (this.timer !== null)
+            this.deps.cancel(this.timer);
+        this.timer = null;
+        this.stopReplyPolling();
+        this.login?.cancel();
+        this.login = null;
+    }
+    /**
+     * One check. Public for tests; the timer calls it every minute.
+     *
+     * @returns Resolves when the check (and any notice) is done
+     */
+    async tick() {
+        if (this.ticking)
+            return;
+        this.ticking = true;
+        try {
+            await this.serial(() => this.check());
+        }
+        finally {
+            this.ticking = false;
+        }
+    }
+    /**
+     * Run `fn` after every earlier check / login outcome has finished.
+     *
+     * @param fn - Work that reads and writes the state file
+     * @returns Resolves when `fn` is done (never rejects)
+     */
+    serial(fn) {
+        const run = this.chain.then(fn).catch((error) => {
+            this.deps.logger.warn('Cloud disconnect check failed', { error: error instanceof Error ? error.message : String(error) });
+        });
+        this.chain = run;
+        return run;
+    }
+    /**
+     * The check itself: detect, then notify, refresh the link, or close the episode.
+     */
+    async check() {
+        const now = this.deps.now();
+        const verdict = evaluateDisconnect({
+            signedIn: await this.deps.isSignedIn(),
+            health: this.deps.getHealth(),
+            monitorStartedAt: this.monitorStartedAt || now,
+            now,
+            thresholdMs: this.thresholdMs,
+        });
+        const state = readNoticeState(this.deps.stateFile);
+        if (verdict.status === 'signed_out') {
+            // Logged out on purpose: nothing to tell, nothing to fix.
+            if (state)
+                await this.endEpisode(false);
+            return;
+        }
+        if (verdict.status === 'connected') {
+            if (state)
+                await this.endEpisode(true);
+            return;
+        }
+        if (verdict.status !== 'disconnected')
+            return;
+        const current = state ?? {
+            episodeStartedAt: new Date(verdict.since).toISOString(),
+            reason: verdict.reason,
+            lastNotifiedAt: null,
+        };
+        current.reason = verdict.reason;
+        if (current.channelId && current.messageTs)
+            this.notice = { channelId: current.channelId, ts: current.messageTs };
+        if (shouldNotify(state, now, this.repeatMs)) {
+            await this.sendNotice(current, verdict.reason);
+        }
+        else if (this.shouldRefreshLink(current, now)) {
+            await this.refreshLink(current);
+        }
+        writeNoticeState(this.deps.stateFile, current);
+    }
+    /**
+     * Send the notice (first of the episode, or the 6-hourly repeat).
+     *
+     * @param state - Episode state (updated in place)
+     * @param reason - Why
+     */
+    async sendNotice(state, reason) {
+        const now = this.deps.now();
+        const dm = this.deps.getDm();
+        if (!dm) {
+            this.deps.logger.warn('Disconnected from Crewly Cloud; Slack is not configured here, so the owner was not notified', { reason });
+            state.lastNotifiedAt = new Date(now).toISOString();
+            return;
+        }
+        // A new window lifts the block a failed login set.
+        delete state.loginBlockedUntil;
+        const link = reason === 'auth' ? await this.ensureLoginLink() : null;
+        const text = composeDisconnectNotice({
+            deviceName: await this.deviceName(),
+            reason,
+            since: Date.parse(state.episodeStartedAt),
+            loginUrl: link?.url ?? null,
+            userCode: link?.userCode ?? null,
+        });
+        try {
+            const posted = await dm.send(text);
+            state.lastNotifiedAt = new Date(now).toISOString();
+            state.channelId = posted.channelId;
+            state.messageTs = posted.ts;
+            state.hasLink = !!link?.url;
+            this.notice = { channelId: posted.channelId, ts: posted.ts };
+            this.lastReplyTs = posted.ts;
+            this.deps.logger.info('Owner told that this machine is disconnected from Crewly Cloud', { reason, withLink: state.hasLink });
+            if (this.login?.get().needsInput)
+                this.startReplyPolling();
+        }
+        catch (error) {
+            // Not recorded as notified: the next check tries again.
+            this.deps.logger.warn('Could not DM the owner about the Cloud disconnect', { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * Whether to start a new login run and put its link into the notice:
+     * sign-in problem, a notice to edit, no live run, not blocked by a failed
+     * login, and not retried within the last few minutes.
+     *
+     * @param state - Episode state
+     * @param now - Now (epoch ms)
+     * @returns True to refresh
+     */
+    shouldRefreshLink(state, now) {
+        if (state.reason !== 'auth' || !state.channelId || !state.messageTs)
+            return false;
+        if (this.login && !isCloudLoginFinished(this.login.get().state))
+            return false;
+        if (state.loginBlockedUntil && Date.parse(state.loginBlockedUntil) > now)
+            return false;
+        return now - this.lastLoginAttemptAt >= this.loginRetryMs;
+    }
+    /**
+     * Start a login run and edit the notice to carry its link (the link in it
+     * is missing or has expired). Editing does not notify the owner again.
+     *
+     * @param state - Episode state (updated in place)
+     */
+    async refreshLink(state) {
+        const dm = this.deps.getDm();
+        if (!dm || !state.channelId || !state.messageTs)
+            return;
+        const link = await this.ensureLoginLink();
+        if (!link?.url)
+            return;
+        const text = composeDisconnectNotice({
+            deviceName: await this.deviceName(),
+            reason: 'auth',
+            since: Date.parse(state.episodeStartedAt),
+            loginUrl: link.url,
+            userCode: link.userCode,
+        });
+        try {
+            await dm.update(state.channelId, state.messageTs, text);
+            state.hasLink = true;
+            this.deps.logger.info('Cloud re-login link in the owner notice refreshed');
+        }
+        catch (error) {
+            this.deps.logger.warn('Could not update the Cloud disconnect notice with a new link', { error: error instanceof Error ? error.message : String(error) });
+            this.login?.cancel();
+            await this.blockUntilNextWindow(state, '链接已过期');
+        }
+    }
+    /**
+     * Start (or reuse) a CLI login run and wait briefly for its link.
+     *
+     * @returns The run's snapshot with a link, or null when none came
+     */
+    async ensureLoginLink() {
+        if (!this.login || isCloudLoginFinished(this.login.get().state)) {
+            this.lastLoginAttemptAt = this.deps.now();
+            let handle;
+            try {
+                handle = this.deps.startLogin();
+            }
+            catch (error) {
+                this.deps.logger.warn('Could not start `crewly cloud login`', { error: error instanceof Error ? error.message : String(error) });
+                return null;
+            }
+            this.login = handle;
+            handle.onChange((snapshot) => {
+                if (snapshot.needsInput)
+                    this.startReplyPolling();
+            });
+            void handle.done.then((snapshot) => this.serial(() => this.onLoginFinished(handle, snapshot)));
+        }
+        const snapshot = await this.login.waitForLink(this.linkWaitMs);
+        return snapshot.url && !isCloudLoginFinished(snapshot.state) ? snapshot : null;
+    }
+    /**
+     * A login run ended.
+     *
+     * @param handle - The run
+     * @param snapshot - How it ended
+     */
+    async onLoginFinished(handle, snapshot) {
+        if (this.login === handle)
+            this.login = null;
+        this.stopReplyPolling();
+        if (this.stopped || snapshot.state === 'cancelled')
+            return;
+        if (snapshot.state === 'succeeded') {
+            let ok = false;
+            try {
+                ok = await this.deps.reconnect();
+            }
+            catch (error) {
+                this.deps.logger.warn('Cloud login succeeded but reconnecting failed', { error: error instanceof Error ? error.message : String(error) });
+            }
+            if (ok) {
+                this.deps.logger.info('Reconnected to Crewly Cloud after the owner signed in again');
+                await this.endEpisode(true);
+            }
+            return;
+        }
+        const state = readNoticeState(this.deps.stateFile);
+        if (!state?.lastNotifiedAt)
+            return;
+        // An expired link is replaced in place by the next check when the
+        // notice can be edited; anything else waits for the next window.
+        if (snapshot.state === 'expired' && state.channelId && state.messageTs) {
+            state.hasLink = false;
+            writeNoticeState(this.deps.stateFile, state);
+            return;
+        }
+        this.deps.logger.info('Cloud re-login did not finish', { state: snapshot.state });
+        await this.blockUntilNextWindow(state, loginFailureDetail(snapshot));
+        writeNoticeState(this.deps.stateFile, state);
+    }
+    /**
+     * Tell the owner briefly that the login did not finish, and hold further
+     * login runs until the next notice window.
+     *
+     * @param state - Episode state (updated in place)
+     * @param detail - Owner-facing reason
+     */
+    async blockUntilNextWindow(state, detail) {
+        const last = state.lastNotifiedAt ? Date.parse(state.lastNotifiedAt) : this.deps.now();
+        const retryAt = last + this.repeatMs;
+        state.loginBlockedUntil = new Date(retryAt).toISOString();
+        state.hasLink = false;
+        const dm = this.deps.getDm();
+        if (!dm)
+            return;
+        try {
+            await dm.send(composeLoginFailedNotice(detail, retryAt));
+        }
+        catch (error) {
+            this.deps.logger.warn('Could not tell the owner the Cloud re-login did not finish', { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * The episode is over: forget it and, when the owner was told and the
+     * machine is back, say so.
+     *
+     * @param reconnected - Back on Cloud (false = logged out on purpose)
+     */
+    async endEpisode(reconnected) {
+        const state = readNoticeState(this.deps.stateFile);
+        clearNoticeState(this.deps.stateFile);
+        this.notice = null;
+        this.lastReplyTs = null;
+        this.stopReplyPolling();
+        if (this.login && !isCloudLoginFinished(this.login.get().state))
+            this.login.cancel();
+        this.login = null;
+        this.lastLoginAttemptAt = 0;
+        if (!reconnected || !state?.lastNotifiedAt)
+            return;
+        const dm = this.deps.getDm();
+        if (!dm)
+            return;
+        try {
+            await dm.send(RECONNECTED_NOTICE);
+            this.deps.logger.info('Owner told that this machine is back on Crewly Cloud');
+        }
+        catch (error) {
+            this.deps.logger.warn('Could not tell the owner the machine is back on Cloud', { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /** Read the owner's DM replies while the CLI waits for typed input. */
+    startReplyPolling() {
+        if (this.replyTimer !== null || this.stopped || !this.notice)
+            return;
+        this.replyDeadline = this.deps.now() + this.replyMaxWaitMs;
+        const { channelId, ts: noticeTs } = this.notice;
+        const poll = async () => {
+            this.replyTimer = null;
+            const login = this.login;
+            if (this.stopped || !login || !login.get().needsInput)
+                return;
+            if (this.deps.now() >= this.replyDeadline) {
+                this.deps.logger.info('Stopped waiting for the owner to answer the Cloud login in Slack');
+                return;
+            }
+            try {
+                const dm = this.deps.getDm();
+                const replies = dm ? await dm.readOwnerReplies(channelId, this.lastReplyTs ?? noticeTs) : [];
+                const reply = replies[replies.length - 1];
+                if (reply) {
+                    this.lastReplyTs = reply.ts;
+                    // Never log the reply: it may be a token.
+                    login.input(reply.text);
+                    this.deps.logger.info('Owner reply typed into `crewly cloud login`');
+                    return;
+                }
+            }
+            catch (error) {
+                this.deps.logger.warn('Could not read the owner DM for a login reply', { error: error instanceof Error ? error.message : String(error) });
+            }
+            this.replyTimer = this.deps.schedule(() => void poll(), this.replyPollMs);
+        };
+        this.replyTimer = this.deps.schedule(() => void poll(), this.replyPollMs);
+    }
+    /** Stop reading replies. */
+    stopReplyPolling() {
+        if (this.replyTimer !== null)
+            this.deps.cancel(this.replyTimer);
+        this.replyTimer = null;
+    }
+    /**
+     * This machine's name (hostname fallback is the caller's job).
+     *
+     * @returns The name
+     */
+    async deviceName() {
+        try {
+            return await this.deps.getDeviceName();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /** Schedule the next check. */
+    scheduleNext() {
+        if (this.stopped)
+            return;
+        this.timer = this.deps.schedule(() => {
+            this.timer = null;
+            void this.tick().finally(() => this.scheduleNext());
+        }, this.checkIntervalMs);
+    }
+}
+/**
+ * Build the service with the real Cloud config, CloudSync health, CLI login,
+ * clock and timers.
+ *
+ * @param wiring - Server hooks
+ * @returns The service (not started)
+ */
+export function createCloudDisconnectNoticeService(wiring) {
+    const logger = LoggerService.getInstance().createComponentLogger('CloudDisconnectNotice');
+    return new CloudDisconnectNoticeService({
+        stateFile: path.join(wiring.crewlyHome, C.STATE_FILE),
+        isSignedIn: async () => fs.existsSync(CloudClientService.getConfigPath()),
+        getHealth: () => CloudSyncService.getInstance().getHealth(),
+        getDeviceName: wiring.getDeviceName,
+        getDm: wiring.getDm,
+        startLogin: () => {
+            const root = resolveRunningPackageRoot(process.argv[1]);
+            const cliEntry = root ? path.join(root, C.CLI_ENTRY) : null;
+            if (!cliEntry || !fs.existsSync(cliEntry))
+                throw new Error('crewly CLI not found next to the running backend');
+            return startCloudLogin({ cliEntry });
+        },
+        reconnect: wiring.reconnect,
+        logger,
+        now: Date.now,
+        schedule: (fn, ms) => {
+            const t = setTimeout(fn, ms);
+            t.unref?.();
+            return t;
+        },
+        cancel: (handle) => clearTimeout(handle),
+    });
+}
+//# sourceMappingURL=cloud-disconnect-notice.service.js.map