crewly 1.20.306 → 1.20.308

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

@@ -77,6 +77,8 @@ import { parseSlackThreadKey } from './services/slack/slack-thread-key.js';
 import { LIVENESS_MONITOR_CONSTANTS, INPUT_CIRCUIT_CONSTANTS, INPUT_BLOCKED_RETRY_CONSTANTS } from './constants.js';
 import { InputBlockedRetryService } from './services/messaging/input-blocked-retry.service.js';
 import { driveCapabilities } from './services/drive/drive-agent.service.js';
+import { canvasCapabilities } from './services/board/canvas/canvas-inbound.service.js';
+import { isBoardPushDisabled } from './services/board/board-push.service.js';
 import { teamMoveCapabilities } from './services/team-move/team-move-driver.service.js';
 import { SUB_AGENT_QUEUE_CONSTANTS, CHAT_CONTEXT_CONSTANTS, SAFE_RESTART, AUTO_UPDATE_CONSTANTS, PROCESS_EXIT_CODES, CLAUDE_STARTUP_CONSTANTS, WEB_CONSTANTS, TICKET_CONSTANTS, UNASSIGNED_ROUTE_CONSTANTS, CLOUD_TALK_CONSTANTS, STANDING_ANSWERS_CONSTANTS, TICKET_AUTOPILOT_CONSTANTS, TICKET_HYGIENE_CONSTANTS, EXPERIMENT_CONSTANTS, WORK_ITEM_DESTINATION_CONSTANTS, CODEX_USAGE_SYNC_CONSTANTS, ANTIGRAVITY_USAGE_SYNC_CONSTANTS, OWNER_AUTH_CONSTANTS, CREWLY_APPS_CONSTANTS, SLACK_AGENT_DM_CONSTANTS, BRIEFING_CONSTANTS, DRIVE_CONSTANTS, POOL_PRUNE_CONSTANTS } from './constants.js';
 import { randomUUID } from 'crypto';
@@ -335,6 +337,11 @@ export class CrewlyServer {
     /** Gaps in this backend's life are told to the owner (crewly#1015 §12) */
     livenessMonitor = null;
     waitingItemsSync = null;
+    ownerBoard = null;
+    /** Canvas: follows the agents' transcripts for their own text lines (crewly#1247 v2) */
+    canvasTail = null;
+    /** Canvas: masked terminal streams the owner opened in the portal */
+    canvasTerminal = 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 */
@@ -2958,6 +2965,78 @@ export class CrewlyServer {
                                 error: waitingErr instanceof Error ? waitingErr.message : String(waitingErr),
                             });
                         }
+                        // Crewly Canvas (crewly#1247 v2): the owner's actions from the portal
+                        // canvas (message an agent, stop it, open its masked terminal) arrive as
+                        // `canvas_action` pushes; the handler fetches each with this machine's
+                        // token and runs it. Starting it advertises `canvas_actions` to Cloud.
+                        try {
+                            // The board's kill switch also keeps the canvas actions off this machine
+                            if (isBoardPushDisabled())
+                                throw new Error('CREWLY_BOARD_PUSH=0');
+                            const [{ CanvasInboundService }, { CanvasTerminalService }, { createStopAgent, createSecretsProvider }, { CloudClientService }, { buildAgentRoster }, { intakeChatV2OwnerMessage }, { getTicketIntakeService }, { getBoardService }, { getApiToken }, { internalCredentialHeaders },] = await Promise.all([
+                                import('./services/board/canvas/canvas-inbound.service.js'),
+                                import('./services/board/canvas/canvas-terminal.service.js'),
+                                import('./services/board/canvas/canvas-wiring.js'),
+                                import('./services/cloud/cloud-client.service.js'),
+                                import('./services/cloud/agent-roster.utils.js'),
+                                import('./services/v3/ticket-channel-hooks.js'),
+                                import('./services/v3/ticket-intake.service.js'),
+                                import('./services/board/board.service.js'),
+                                import('./services/core/api-token.service.js'),
+                                import('./services/core/owner-auth.service.js'),
+                            ]);
+                            const cloudClient = CloudClientService.getInstance();
+                            const cloud = {
+                                getToken: () => cloudClient.getToken(),
+                                getCloudUrl: () => cloudClient.getCloudUrl(),
+                                tryRefreshToken: () => cloudClient.tryRefreshToken(),
+                            };
+                            const identity = async () => {
+                                const id = await DeviceIdentityService.getInstance().getOrCreateIdentity();
+                                return { instanceId: id.deviceId, deviceName: id.deviceName };
+                            };
+                            const terminal = new CanvasTerminalService({
+                                cloud,
+                                identity,
+                                capture: (session, lines) => getSessionBackendSync()?.captureOutput(session, lines) ?? null,
+                                exists: (session) => getSessionBackendSync()?.sessionExists(session) === true,
+                                secrets: createSecretsProvider(),
+                            });
+                            this.canvasTerminal = terminal;
+                            new CanvasInboundService({
+                                source: sync,
+                                cloud,
+                                chat: chatService,
+                                identity,
+                                deliver: async (channel, message) => {
+                                    const toDispatch = await intakeChatV2OwnerMessage(getTicketIntakeService(), channel, message, CLOUD_TALK_CONSTANTS.INTAKE_ORIGIN);
+                                    await chatDispatcher.dispatchMessage(channel, toDispatch);
+                                },
+                                agentExists: async (session) => buildAgentRoster(await this.storageService.getTeams()).some((a) => a.agentSession === session),
+                                stopAgent: createStopAgent({
+                                    webPort: this.config.webPort,
+                                    teams: () => this.storageService.getTeams(),
+                                    headers: () => {
+                                        let token = null;
+                                        try {
+                                            token = getApiToken();
+                                        }
+                                        catch {
+                                            token = null;
+                                        }
+                                        return { ...(token ? { [API_SECURITY_CONSTANTS.TOKEN_HEADER]: token } : {}), ...internalCredentialHeaders('relay') };
+                                    },
+                                }),
+                                terminal,
+                                // Someone is at the canvas: push live for a while
+                                onAction: () => getBoardService()?.push.noteViewer(),
+                            }).start();
+                        }
+                        catch (canvasErr) {
+                            this.logger.warn('Canvas action handler wiring skipped', {
+                                error: canvasErr instanceof Error ? canvasErr.message : String(canvasErr),
+                            });
+                        }
                         // Mobile app: generic allowlisted REST passthrough over the same
                         // relay (api_request → local HTTP → api_response). Non-fatal.
                         try {
@@ -3872,6 +3951,9 @@ export class CrewlyServer {
             // "Waiting on you" (§F): tickets in 待验收 go to Crewly Cloud as text
             // snapshots, so the portal lists them for every machine.
             void this.startWaitingItemsSync();
+            // Owner board (crewly#1247): outcomes + live activity, pushed to Cloud
+            // every 60 s and on change. CREWLY_BOARD_PUSH=0 turns the push off.
+            void this.startOwnerBoard();
             // 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.
@@ -5369,7 +5451,7 @@ export class CrewlyServer {
                 // whether this machine takes `talk_message` — also for machines
                 // without Slack, which never send the registry heartbeat.
                 roster: async () => buildAgentRoster(await this.storageService.getTeams()),
-                capabilities: () => [...cloudTalkCapabilities(), ...waitingActionCapabilities(), ...talkTranscribeCapabilities(), ...driveCapabilities(), ...teamMoveCapabilities()],
+                capabilities: () => [...cloudTalkCapabilities(), ...waitingActionCapabilities(), ...canvasCapabilities(), ...talkTranscribeCapabilities(), ...driveCapabilities(), ...teamMoveCapabilities()],
                 onNewMessage: (listener) => {
                     chat.on('chat_message', listener);
                     return () => chat.off('chat_message', listener);
@@ -5441,7 +5523,7 @@ export class CrewlyServer {
                 agentNames: async () => new Map(buildAgentRoster(await this.storageService.getTeams())
                     .filter((a) => a.displayName)
                     .map((a) => [a.agentSession, a.displayName])),
-                capabilities: () => [...cloudTalkCapabilities(), ...waitingActionCapabilities(), ...talkTranscribeCapabilities(), ...driveCapabilities(), ...teamMoveCapabilities()],
+                capabilities: () => [...cloudTalkCapabilities(), ...waitingActionCapabilities(), ...canvasCapabilities(), ...talkTranscribeCapabilities(), ...driveCapabilities(), ...teamMoveCapabilities()],
                 onTicketChange: (listener) => RequestService.getInstance().onChange(() => listener()),
             });
             setWaitingItemsSyncService(service);
@@ -5454,6 +5536,91 @@ export class CrewlyServer {
             });
         }
     }
+    /**
+     * Start the owner board: the local `GET /api/board` always works; the push
+     * to Crewly Cloud runs while the machine is signed in. Never throws.
+     */
+    async startOwnerBoard() {
+        try {
+            const [{ BoardService, setBoardService }, { createProductionBoardSources }, { CloudClientService }, { getBoardActivity }] = await Promise.all([
+                import('./services/board/board.service.js'),
+                import('./services/board/board.sources.js'),
+                import('./services/cloud/cloud-client.service.js'),
+                import('./services/board/board-activity.tracker.js'),
+            ]);
+            const cloud = CloudClientService.getInstance();
+            // Project roots turn file paths into repo-relative ones
+            getBoardActivity().setRootsResolver((session) => this.boardProjectRoots(session));
+            const service = new BoardService({
+                sources: createProductionBoardSources({ storage: this.storageService }),
+                cloud: { getToken: () => cloud.getToken(), getCloudUrl: () => cloud.getCloudUrl(), tryRefreshToken: () => cloud.tryRefreshToken() },
+            });
+            setBoardService(service);
+            service.start();
+            this.ownerBoard = service;
+            await this.startCanvasTail(service);
+        }
+        catch (error) {
+            this.logger.warn('Owner board not started (non-fatal)', { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * Canvas (crewly#1247 v2): follow the agents' transcripts for their own
+     * short text lines (and Codex's tool calls). Off with the board push.
+     */
+    async startCanvasTail(service) {
+        try {
+            if (service.push.disabled)
+                return;
+            const [{ TranscriptTailService }, { createTranscriptLocator, createSecretsProvider }, recovery] = await Promise.all([
+                import('./services/board/canvas/canvas-transcript.tail.js'),
+                import('./services/board/canvas/canvas-wiring.js'),
+                import('./services/agent/runtime-session-recovery.js'),
+            ]);
+            const { findCodexRollout } = await import('./services/monitoring/codex-rollout-sync.service.js');
+            const persistence = getSessionStatePersistence();
+            const locate = createTranscriptLocator({
+                meta: (session) => {
+                    try {
+                        return persistence.getSessionMetadata(session);
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+                claudeHomes: (meta) => [meta.env?.CLAUDE_CONFIG_DIR, recovery.defaultClaudeHome()].filter((h) => typeof h === 'string' && h.length > 0),
+                findClaude: recovery.findClaudeTranscript,
+                codexHome: recovery.defaultCodexHome,
+                findCodex: findCodexRollout,
+            });
+            this.canvasTail = new TranscriptTailService({
+                steps: service.tracker.steps,
+                sessions: () => service.builder.knownSessions(),
+                locate,
+                roots: (session) => this.boardProjectRoots(session),
+                secrets: createSecretsProvider(),
+                isLive: () => service.push.isLive(),
+            });
+            this.canvasTail.start();
+        }
+        catch (error) {
+            this.logger.warn('Canvas transcript tail not started (non-fatal)', { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /** Cached project paths for the board's relative file paths. */
+    boardRootsCache = { at: 0, roots: [] };
+    boardProjectRoots(_session) {
+        if (Date.now() - this.boardRootsCache.at > 60_000) {
+            this.boardRootsCache.at = Date.now();
+            void this.storageService
+                .getProjects()
+                .then((projects) => {
+                this.boardRootsCache.roots = projects.map((p) => p.path).filter(Boolean);
+            })
+                .catch(() => undefined);
+        }
+        return this.boardRootsCache.roots;
+    }
     /**
      * Load interrupted turns left by the previous shutdown (fresh ones only).
      */
@@ -6761,6 +6928,9 @@ export class CrewlyServer {
         this.cloudDisconnectNotice?.stop();
         this.conversationCloudSync?.stop();
         this.waitingItemsSync?.stop();
+        this.ownerBoard?.stop();
+        this.canvasTail?.stop();
+        this.canvasTerminal?.closeAll();
         // 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);