@junctionpanel/server 0.1.35 → 0.1.36

package/dist/server/server/session.js

@@ -33,6 +33,8 @@ import { deriveProjectGroupingKey, deriveProjectGroupingName } from '../shared/p
 import { DEFAULT_DAEMON_PACKAGE_NAME, resolveDaemonPackageVersion, } from './daemon-package-context.js';
 import { runDaemonDoctor } from './daemon-doctor.js';
 import { MANAGED_DAEMON_PROVIDERS, autoRouteProviderExecutable, loadDaemonProviderSettings, saveDaemonProviderExecutablePath, } from './daemon-provider-settings.js';
+import { applyNotificationRelayOwnerLabel, preserveNotificationRelayOwnerLabel, } from './notifications/relay-ownership.js';
+import { saveNotificationRelayConfig } from './notifications/relay-store.js';
 import { resolvePackageUpdateInfo } from './package-update.js';
 import { loadPersistedConfig } from './persisted-config.js';
 const execAsync = promisify(exec);
@@ -42,6 +44,7 @@ const READ_ONLY_GIT_ENV = {
 };
 const DEFAULT_STORED_TIMELINE_FETCH_LIMIT = 200;
 const pendingAgentInitializations = new Map();
+const pendingAgentMessageExecutions = new Map();
 const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_IDS[0];
 const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
 const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5000;
@@ -247,6 +250,61 @@ export class Session {
             },
         });
     }
+    enqueueAcceptedAgentMessageExecution(input) {
+        const previous = pendingAgentMessageExecutions.get(input.agentId) ?? Promise.resolve();
+        const execution = previous
+            .catch(() => undefined)
+            .then(async () => {
+            const startedAt = Date.now();
+            const phaseTimings = {
+                performSendMs: 0,
+                waitForRunStartMs: 0,
+            };
+            const performSendStartedAt = Date.now();
+            await this.performAgentMessageSend(input);
+            phaseTimings.performSendMs = Date.now() - performSendStartedAt;
+            const waitForRunStartStartedAt = Date.now();
+            await this.agentManager.waitForAgentRunStart(input.agentId);
+            phaseTimings.waitForRunStartMs = Date.now() - waitForRunStartStartedAt;
+            this.sessionLogger.debug({
+                agentId: input.agentId,
+                durationMs: Date.now() - startedAt,
+                ...phaseTimings,
+            }, 'Accepted send_agent_message_request execution started');
+        });
+        const trackedExecution = execution.finally(() => {
+            if (pendingAgentMessageExecutions.get(input.agentId) === trackedExecution) {
+                pendingAgentMessageExecutions.delete(input.agentId);
+            }
+        });
+        pendingAgentMessageExecutions.set(input.agentId, trackedExecution);
+        return trackedExecution;
+    }
+    async performAgentMessageSend(input) {
+        await this.ensureAgentLoaded(input.agentId);
+        await this.interruptAgentIfRunning(input.agentId);
+        try {
+            this.agentManager.recordUserMessage(input.agentId, input.text, {
+                messageId: input.messageId,
+                emitState: false,
+                images: input.images?.map((image) => ({
+                    data: image.preview?.data ?? image.data,
+                    mimeType: image.preview?.mimeType ?? image.mimeType,
+                    ...(image.label ? { label: image.label } : {}),
+                    ...(image.preview?.width != null ? { width: image.preview.width } : {}),
+                    ...(image.preview?.height != null ? { height: image.preview.height } : {}),
+                })),
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: input.agentId }, `Failed to record user message for agent ${input.agentId}`);
+        }
+        const prompt = this.buildAgentPrompt(input.text, input.images);
+        const started = this.startAgentStream(input.agentId, prompt, input.runOptions);
+        if (!started.ok) {
+            throw new Error(started.error);
+        }
+    }
     /**
      * Initialize Agent MCP client for this session using in-memory transport
      */
@@ -889,6 +947,9 @@ export class Session {
                 case 'auto_route_provider_request':
                     await this.handleAutoRouteProviderRequest(msg);
                     break;
+                case 'update_notification_relay_config_request':
+                    await this.handleUpdateNotificationRelayConfigRequest(msg);
+                    break;
                 case 'clear_agent_attention':
                     await this.handleClearAgentAttention(msg.agentId);
                     break;
@@ -1357,7 +1418,7 @@ export class Session {
                     await this.agentManager.setTitle(agentId, normalizedName);
                 }
                 if (normalizedLabels) {
-                    await this.agentManager.setLabels(agentId, normalizedLabels);
+                    await this.agentManager.setLabels(agentId, preserveNotificationRelayOwnerLabel(liveAgent.labels, normalizedLabels));
                 }
             }
             else {
@@ -1368,7 +1429,11 @@ export class Session {
                 await this.agentStorage.upsert({
                     ...existing,
                     ...(normalizedName ? { title: normalizedName } : {}),
-                    ...(normalizedLabels ? { labels: { ...existing.labels, ...normalizedLabels } } : {}),
+                    ...(normalizedLabels
+                        ? {
+                            labels: preserveNotificationRelayOwnerLabel(existing.labels, normalizedLabels),
+                        }
+                        : {}),
                 });
             }
             this.emit({
@@ -1409,30 +1474,17 @@ export class Session {
             return;
         }
         try {
-            await this.ensureAgentLoaded(agentId);
-        }
-        catch (error) {
-            this.handleAgentRunError(agentId, error, 'Failed to initialize agent before sending prompt');
-            return;
-        }
-        try {
-            await this.interruptAgentIfRunning(agentId);
-        }
-        catch (error) {
-            this.handleAgentRunError(agentId, error, 'Failed to interrupt running agent before sending prompt');
-            return;
-        }
-        const prompt = this.buildAgentPrompt(text, images);
-        try {
-            this.agentManager.recordUserMessage(agentId, text, {
+            await this.performAgentMessageSend({
+                agentId,
+                text,
                 messageId,
-                emitState: false,
+                images,
+                runOptions,
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to record user message for agent ${agentId}`);
+            this.handleAgentRunError(agentId, error, 'Failed to send prompt to agent');
         }
-        this.startAgentStream(agentId, prompt, runOptions);
     }
     /**
      * Handle create agent request
@@ -1445,7 +1497,9 @@ export class Session {
             const mergedLabels = autoWorkspaceName
                 ? { ...labels, 'junction:workspace': autoWorkspaceName }
                 : labels;
-            const snapshot = await this.agentManager.createAgent(sessionConfig, undefined, { labels: mergedLabels });
+            const snapshot = await this.agentManager.createAgent(sessionConfig, undefined, {
+                labels: applyNotificationRelayOwnerLabel(mergedLabels, this.userId),
+            });
             await this.forwardAgentUpdate(snapshot);
             if (requestId) {
                 const agentPayload = await this.getAgentPayloadById(snapshot.id);
@@ -1941,6 +1995,46 @@ export class Session {
             });
         }
     }
+    async handleUpdateNotificationRelayConfigRequest(msg) {
+        try {
+            const relayUrl = msg.relayUrl?.trim();
+            const token = msg.token?.trim();
+            const expiresAt = msg.expiresAt?.trim();
+            const providedCount = [msg.relayUrl, msg.token, msg.expiresAt].filter((value) => value !== undefined).length;
+            if (providedCount === 0) {
+                saveNotificationRelayConfig(this.junctionHome, this.userId, null);
+            }
+            else if (providedCount !== 3 || !relayUrl || !token || !expiresAt) {
+                throw new SessionRequestError('invalid_notification_relay_config', 'relayUrl, token, and expiresAt must be provided together');
+            }
+            else {
+                saveNotificationRelayConfig(this.junctionHome, this.userId, {
+                    relayUrl,
+                    token,
+                    expiresAt,
+                });
+            }
+            this.emit({
+                type: 'update_notification_relay_config_response',
+                payload: {
+                    success: true,
+                    error: null,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, 'Failed to update notification relay config');
+            this.emit({
+                type: 'update_notification_relay_config_response',
+                payload: {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
     normalizeGitOptions(gitOptions, legacyWorktreeName) {
         const fallbackOptions = legacyWorktreeName
             ? {
@@ -4423,7 +4517,8 @@ export class Session {
         }
         try {
             const agentId = resolved.agentId;
-            const archivedAt = await this.getArchivedAt(agentId);
+            const storedRecord = await this.agentStorage.get(agentId);
+            const archivedAt = storedRecord?.archivedAt ?? null;
             if (archivedAt) {
                 this.emit({
                     type: 'send_agent_message_response',
@@ -4436,57 +4531,13 @@ export class Session {
                 });
                 return;
             }
-            await this.ensureAgentLoaded(agentId);
-            await this.interruptAgentIfRunning(agentId);
-            try {
-                this.agentManager.recordUserMessage(agentId, msg.text, {
-                    messageId: msg.messageId,
-                    emitState: false,
-                });
-            }
-            catch (error) {
-                this.sessionLogger.error({ err: error, agentId }, 'Failed to record user message for send_agent_message_request');
-            }
-            const prompt = this.buildAgentPrompt(msg.text, msg.images);
-            const started = this.startAgentStream(agentId, prompt, normalizeAgentRunOptions(msg.runOptions));
-            if (!started.ok) {
-                this.emit({
-                    type: 'send_agent_message_response',
-                    payload: {
-                        requestId: msg.requestId,
-                        agentId,
-                        accepted: false,
-                        error: started.error,
-                    },
-                });
-                return;
-            }
-            const startAbort = new AbortController();
-            const startTimeoutMs = 15000;
-            const startTimeout = setTimeout(() => startAbort.abort('timeout'), startTimeoutMs);
-            try {
-                await this.agentManager.waitForAgentRunStart(agentId, { signal: startAbort.signal });
-            }
-            catch (error) {
-                const message = error instanceof Error
-                    ? error.message
-                    : typeof error === 'string'
-                        ? error
-                        : 'Unknown error';
-                this.emit({
-                    type: 'send_agent_message_response',
-                    payload: {
-                        requestId: msg.requestId,
-                        agentId,
-                        accepted: false,
-                        error: message,
-                    },
-                });
-                return;
-            }
-            finally {
-                clearTimeout(startTimeout);
-            }
+            await this.enqueueAcceptedAgentMessageExecution({
+                agentId,
+                text: msg.text,
+                ...(msg.messageId ? { messageId: msg.messageId } : {}),
+                ...(msg.images ? { images: msg.images } : {}),
+                runOptions: normalizeAgentRunOptions(msg.runOptions),
+            });
             this.emit({
                 type: 'send_agent_message_response',
                 payload: {