crewly 1.20.147 → 1.20.149

package/dist/backend/backend/src/index.js

@@ -23,7 +23,7 @@ import { TerminalGateway, setTerminalGateway } from './websocket/terminal.gatewa
 import { initializeChatGateway } from './websocket/chat.gateway.js';
 import { LoggerService } from './services/core/logger.service.js';
 import { retryWithBackoff } from './services/core/retry.util.js';
-import { CREWLY_CONSTANTS, ORCHESTRATOR_SESSION_NAME, ORCHESTRATOR_ROLE, ORCHESTRATOR_WINDOW_NAME, MESSAGE_QUEUE_CONSTANTS, RUNTIME_TYPES, AUDITOR_CONSTANTS, AUDITOR_SCHEDULER_CONSTANTS, API_SECURITY_CONSTANTS, } from './constants.js';
+import { CREWLY_CONSTANTS, ORCHESTRATOR_SESSION_NAME, CLOUD_DISCONNECT_NOTICE_CONSTANTS, ORCHESTRATOR_ROLE, ORCHESTRATOR_WINDOW_NAME, MESSAGE_QUEUE_CONSTANTS, RUNTIME_TYPES, AUDITOR_CONSTANTS, AUDITOR_SCHEDULER_CONSTANTS, API_SECURITY_CONSTANTS, } from './constants.js';
 import { getSettingsService } from './services/settings/index.js';
 import { MemoryService } from './services/memory/memory.service.js';
 import { getImprovementStartupService } from './services/orchestrator/improvement-startup.service.js';
@@ -109,6 +109,9 @@ import { assertBuildProvenance } from './utils/build-provenance.js';
 import { isNativeBindingFatalError } from './utils/native-binding.utils.js';
 import { VersionCheckService } from './services/system/version-check.service.js';
 import { AutoUpdateService, createAutoUpdateService } from './services/system/auto-update.service.js';
+import { createCloudDisconnectNoticeService, } from './services/cloud/cloud-disconnect-notice.service.js';
+import { isNoticeEnabled } from './services/cloud/cloud-disconnect-notice.utils.js';
+import { createOwnerDirectDm } from './services/slack/slack-owner-direct-dm.js';
 import { LogRotationService } from './services/session/log-rotation.service.js';
 import { AuditorSchedulerService } from './services/agent/auditor-scheduler.service.js';
 import { setAuditorSchedulerService } from './controllers/auditor/auditor.controller.js';
@@ -212,6 +215,8 @@ export class CrewlyServer {
     chatV2Dispatcher = null;
     // Shutdown state
     isShuttingDown = false;
+    /** Tells the owner on Slack when this machine loses Crewly Cloud */
+    cloudDisconnectNotice = null;
     /** Epoch ms of the last shutdown signal acted on (dedups process-group delivery) */
     lastShutdownSignalAt = 0;
     /** Interrupted turns loaded at boot, resumed once their agents are back */
@@ -2300,16 +2305,35 @@ export class CrewlyServer {
                                 triggerId,
                                 requestId: template.requestId,
                             });
-                            await TaskPoolService.getInstance().addToPool(workItem);
-                            // Project as a trigger_action TaskRecord
-                            await taskProjection.createRecord({
-                                title: workItem.title,
-                                type: 'trigger_action',
-                                ownerAgent: 'system',
-                                triggerId,
-                                workItemId: workItem.id,
-                            });
-                            logger.info('TriggerEngine: WorkItem enqueued', { triggerId, workItemId: workItem.id });
+                            // Each fire is a full wake-up for the target. Skip it when the same
+                            // work is still open: an identical item from an earlier fire, or —
+                            // for an idle-verify watcher — the bridge's Verify item for that
+                            // worker (agent:idle_after_task fires on every busy→idle).
+                            const { findOpenDuplicateWorkItem, findCoveringVerifyItem } = await import('./utils/trigger-workitem-dedupe.utils.js');
+                            const poolItems = await TaskPoolService.getInstance().getAllItems().catch(() => []);
+                            const draft = { target: workItem.target, owner: workItem.owner, title: workItem.title };
+                            const duplicate = findOpenDuplicateWorkItem(poolItems, draft)
+                                ?? findCoveringVerifyItem(poolItems, trigger, draft);
+                            if (duplicate) {
+                                logger.debug('TriggerEngine: WorkItem skipped — same work already open', {
+                                    triggerId,
+                                    target: workItem.target,
+                                    title: workItem.title,
+                                    existingWorkItemId: duplicate.id,
+                                });
+                            }
+                            else {
+                                await TaskPoolService.getInstance().addToPool(workItem);
+                                // Project as a trigger_action TaskRecord
+                                await taskProjection.createRecord({
+                                    title: workItem.title,
+                                    type: 'trigger_action',
+                                    ownerAgent: 'system',
+                                    triggerId,
+                                    workItemId: workItem.id,
+                                });
+                                logger.info('TriggerEngine: WorkItem enqueued', { triggerId, workItemId: workItem.id });
+                            }
                         }
                         catch (err) {
                             logger.warn('TriggerEngine: createWorkItem failed', {
@@ -2554,6 +2578,9 @@ export class CrewlyServer {
             // orchestrator auto-start so an upgrade boot is known when the
             // "back online" announcement is composed.
             this.startAutoUpdate();
+            // Tell the owner (Slack DM, phone re-login link) when this machine
+            // loses Crewly Cloud — inbound Slack then queues in Cloud unseen.
+            this.startCloudDisconnectNotice();
             // V3-only as of spec 2026-05-06-task-management-v1-deprecation.md.
             // The legacy `TaskTrackingService.startAutoSync()` is gone — V3
             // task-pool reconciler owns lifecycle cleanup now.
@@ -3640,6 +3667,53 @@ export class CrewlyServer {
             });
         }
     }
+    /**
+     * Start the Cloud disconnect notice: DM the owner on Slack when this
+     * machine has lost Crewly Cloud (sign-in expired, Cloud unreachable), with
+     * a re-login link from `crewly cloud login` run by Crewly itself. The DM
+     * goes straight through the Slack Web API with the orchestrator's own bot
+     * (falling back to the workspace bot) — outbound Slack needs no Cloud.
+     * Off with `CREWLY_CLOUD_DISCONNECT_NOTICE=0`. Never throws.
+     */
+    startCloudDisconnectNotice() {
+        if (!isNoticeEnabled(process.env[CLOUD_DISCONNECT_NOTICE_CONSTANTS.ENV_SWITCH])) {
+            this.logger.info('Cloud disconnect notice off (CREWLY_CLOUD_DISCONNECT_NOTICE=0)');
+            return;
+        }
+        try {
+            const service = createCloudDisconnectNoticeService({
+                crewlyHome: this.config.crewlyHome,
+                getDm: () => {
+                    const slack = getSlackService();
+                    const ownerUserId = slack.getOwnerUserId?.() ?? null;
+                    const botToken = getSlackAgentIdentityService()?.getInstalled(ORCHESTRATOR_SESSION_NAME)?.botToken ?? slack.getBotToken();
+                    return ownerUserId && botToken ? createOwnerDirectDm({ botToken, ownerUserId }) : null;
+                },
+                reconnect: async () => {
+                    // The CLI already POSTed /api/cloud/connect; connect again from
+                    // the saved config so CloudSync surely runs on the new token
+                    // (the CLI may target another port, or sync was mid-error).
+                    const { CloudClientService } = await import('./services/cloud/cloud-client.service.js');
+                    const { CloudSyncService } = await import('./services/cloud/cloud-sync.service.js');
+                    const { performCloudConnect } = await import('./controllers/cloud/cloud.controller.js');
+                    const config = await CloudClientService.getInstance().loadPersistedConfig();
+                    if (!config)
+                        return false;
+                    CloudSyncService.getInstance().stop();
+                    await performCloudConnect({ cloudUrl: config.cloudUrl, token: config.token, refreshToken: config.refreshToken });
+                    return CloudSyncService.getInstance().getState() === 'syncing';
+                },
+                getDeviceName: async () => (await DeviceIdentityService.getInstance().getOrCreateIdentity()).deviceName,
+            });
+            service.start();
+            this.cloudDisconnectNotice = service;
+        }
+        catch (error) {
+            this.logger.warn('Cloud disconnect notice not started (non-fatal)', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     /**
      * Load interrupted turns left by the previous shutdown (fresh ones only).
      */
@@ -4065,6 +4139,7 @@ export class CrewlyServer {
         const exitCode = options.exitCode ?? PROCESS_EXIT_CODES.SUCCESS;
         this.logger.info('Shutting down Crewly server...', { reason: options.reason ?? 'unspecified' });
         AutoUpdateService.getInstance()?.stop();
+        this.cloudDisconnectNotice?.stop();
         // Safe restart: stop delivering, wait for agents mid-turn, persist the rest.
         // Runs before the force-exit timer below, which only bounds the teardown.
         await this.drainInFlightTurns(options.reason ?? 'shutdown', options.drain !== false);