@junctionpanel/server 0.1.60 → 0.1.62

package/dist/server/server/session.js

@@ -29,7 +29,7 @@ import { expandTilde } from '../utils/path.js';
 import { searchHomeDirectories, searchWorkspaceEntries, searchWorkspaceEntriesAtGitRef, searchGitRepositories, checkIsGitRepo, } from '../utils/directory-suggestions.js';
 import { cloneRepository } from '../utils/git-clone.js';
 import { initRepository } from '../utils/git-init.js';
-import { resolveClientMessageId } from './client-message-id.js';
+import { normalizeClientMessageId, resolveClientMessageId } from './client-message-id.js';
 import { deriveProjectGroupingKey, deriveProjectGroupingName } from '../shared/project-grouping.js';
 import { DEFAULT_DAEMON_PACKAGE_NAME, resolveDaemonPackageVersion, } from './daemon-package-context.js';
 import { runDaemonDoctor } from './daemon-doctor.js';
@@ -48,6 +48,8 @@ const READ_ONLY_GIT_ENV = {
 const DEFAULT_STORED_TIMELINE_FETCH_LIMIT = 200;
 const pendingAgentInitializations = new Map();
 const pendingAgentMessageExecutions = new Map();
+const CREATE_AGENT_REPLAY_WINDOW_MS = 30000;
+const pendingCreateAgentRequests = new Map();
 const sharedWorkspaceGitOperationStates = new Map();
 const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_IDS[0];
 const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
@@ -59,6 +61,30 @@ const WORKSPACE_STATUS_PR_PASSIVE_REFRESH_MS = 60000;
 const TERMINAL_STREAM_WINDOW_BYTES = 256 * 1024;
 const TERMINAL_STREAM_MAX_PENDING_BYTES = 2 * 1024 * 1024;
 const TERMINAL_STREAM_MAX_PENDING_CHUNKS = 2048;
+function buildCreateAgentReplayKey(clientId, clientMessageId) {
+    return JSON.stringify([clientId, clientMessageId]);
+}
+function deletePendingCreateAgentRequest(replayKey, expectedEntry) {
+    const existingEntry = pendingCreateAgentRequests.get(replayKey);
+    if (!existingEntry || (expectedEntry && existingEntry !== expectedEntry)) {
+        return;
+    }
+    clearTimeout(existingEntry.evictionTimer);
+    pendingCreateAgentRequests.delete(replayKey);
+}
+function storePendingCreateAgentRequest(replayKey, promise) {
+    const entry = {
+        promise,
+        evictionTimer: setTimeout(() => {
+            deletePendingCreateAgentRequest(replayKey, entry);
+        }, CREATE_AGENT_REPLAY_WINDOW_MS),
+    };
+    pendingCreateAgentRequests.set(replayKey, entry);
+    void promise.catch(() => {
+        deletePendingCreateAgentRequest(replayKey, entry);
+    });
+    return entry;
+}
 const DIRTY_WORKTREE_CONFIRMATION_REQUIRED = 'dirty_worktree_confirmation_required';
 class SessionRequestError extends Error {
     constructor(code, message) {
@@ -312,21 +338,23 @@ export class Session {
     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}`);
+        if (!input.suppressHistory) {
+            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, {
@@ -1555,7 +1583,7 @@ export class Session {
         const archivedAt = await this.getArchivedAt(agentId);
         if (archivedAt) {
             this.handleAgentRunError(agentId, new Error(`Agent ${agentId} is archived`), 'Refusing to send prompt to archived agent');
-            return;
+            return false;
         }
         try {
             await this.performAgentMessageSend({
@@ -1565,9 +1593,11 @@ export class Session {
                 images,
                 runOptions,
             });
+            return true;
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, 'Failed to send prompt to agent');
+            return false;
         }
     }
     /**
@@ -1576,96 +1606,147 @@ export class Session {
     async handleCreateAgentRequest(msg) {
         const { config, worktreeName, requestId, initialPrompt, clientMessageId, outputSchema, initialRunOptions, git, bootstrapSetupOverride, generalPreferencesApplied, images, labels, } = msg;
         this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ''}`);
+        const trimmedPrompt = initialPrompt?.trim() ?? '';
+        const hasInitialMessage = trimmedPrompt.length > 0 || Boolean(images?.length);
+        const normalizedClientMessageId = hasInitialMessage ? normalizeClientMessageId(clientMessageId) : undefined;
+        const createReplayKey = normalizedClientMessageId
+            ? buildCreateAgentReplayKey(this.clientId, normalizedClientMessageId)
+            : null;
         try {
-            const { sessionConfig, worktreeConfig, autoWorkspaceName } = await this.buildAgentSessionConfig(config, git, worktreeName, labels);
-            const mergedLabels = autoWorkspaceName
-                ? { ...labels, 'junction:workspace': autoWorkspaceName }
-                : labels;
-            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);
-                if (!agentPayload) {
-                    throw new Error(`Agent ${snapshot.id} not found after creation`);
-                }
-                this.emit({
-                    type: 'status',
-                    payload: {
-                        status: 'agent_created',
-                        agentId: snapshot.id,
-                        requestId,
-                        agent: agentPayload,
-                    },
+            const createAgentLaunch = async (clearReplayEntryOnDeferredFailure) => {
+                const { sessionConfig, worktreeConfig, autoWorkspaceName } = await this.buildAgentSessionConfig(config, git, worktreeName, labels);
+                const mergedLabels = autoWorkspaceName
+                    ? { ...labels, 'junction:workspace': autoWorkspaceName }
+                    : labels;
+                const snapshot = await this.agentManager.createAgent(sessionConfig, undefined, {
+                    labels: applyNotificationRelayOwnerLabel(mergedLabels, this.userId),
                 });
-            }
-            const trimmedPrompt = initialPrompt?.trim() ?? '';
-            const hasInitialMessage = trimmedPrompt.length > 0 || Boolean(images?.length);
-            const runInitialPrompt = async () => {
-                if (!hasInitialMessage) {
-                    return;
+                await this.forwardAgentUpdate(snapshot);
+                const runInitialPrompt = async () => {
+                    if (!hasInitialMessage) {
+                        return;
+                    }
+                    if (trimmedPrompt.length > 0) {
+                        scheduleAgentMetadataGeneration({
+                            agentManager: this.agentManager,
+                            agentId: snapshot.id,
+                            cwd: snapshot.cwd,
+                            initialPrompt: trimmedPrompt,
+                            explicitTitle: snapshot.config.title,
+                            junctionHome: this.junctionHome,
+                            logger: this.sessionLogger,
+                        });
+                    }
+                    const sendSucceeded = await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, normalizedClientMessageId ?? resolveClientMessageId(clientMessageId), images, normalizeAgentRunOptions({
+                        ...(outputSchema ? { outputSchema } : {}),
+                        ...(initialRunOptions ?? {}),
+                    }));
+                    if (!sendSucceeded) {
+                        clearReplayEntryOnDeferredFailure?.();
+                    }
+                };
+                const handleInitialPromptError = (promptError) => {
+                    clearReplayEntryOnDeferredFailure?.();
+                    this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
+                    this.emit({
+                        type: 'activity_log',
+                        payload: {
+                            id: uuidv4(),
+                            timestamp: new Date(),
+                            type: 'error',
+                            content: `Initial prompt failed: ${promptError?.message ?? promptError}`,
+                        },
+                    });
+                };
+                if (hasInitialMessage && !worktreeConfig) {
+                    void runInitialPrompt().catch(handleInitialPromptError);
                 }
-                if (trimmedPrompt.length > 0) {
-                    scheduleAgentMetadataGeneration({
-                        agentManager: this.agentManager,
+                if (worktreeConfig) {
+                    void runAsyncWorktreeBootstrap({
                         agentId: snapshot.id,
-                        cwd: snapshot.cwd,
-                        initialPrompt: trimmedPrompt,
-                        explicitTitle: snapshot.config.title,
-                        junctionHome: this.junctionHome,
+                        worktree: worktreeConfig,
+                        setupOverride: bootstrapSetupOverride,
+                        generalPreferencesApplied,
+                        terminalManager: this.terminalManager,
+                        appendTimelineItem: (item) => appendTimelineItemIfAgentKnown({
+                            agentManager: this.agentManager,
+                            agentId: snapshot.id,
+                            item,
+                        }),
+                        emitLiveTimelineItem: (item) => emitLiveTimelineItemIfAgentKnown({
+                            agentManager: this.agentManager,
+                            agentId: snapshot.id,
+                            item,
+                        }),
+                        onSetupSettled: async (result) => {
+                            if (!hasInitialMessage || result.setupStatus === 'failed') {
+                                if (hasInitialMessage && result.setupStatus === 'failed') {
+                                    clearReplayEntryOnDeferredFailure?.();
+                                }
+                                return;
+                            }
+                            await runInitialPrompt().catch(handleInitialPromptError);
+                        },
                         logger: this.sessionLogger,
+                    }).catch((bootstrapError) => {
+                        clearReplayEntryOnDeferredFailure?.();
+                        this.sessionLogger.error({ err: bootstrapError, agentId: snapshot.id }, `Failed to bootstrap worktree for agent ${snapshot.id}`);
                     });
                 }
-                await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, resolveClientMessageId(clientMessageId), images, normalizeAgentRunOptions({
-                    ...(outputSchema ? { outputSchema } : {}),
-                    ...(initialRunOptions ?? {}),
-                }));
+                this.sessionLogger.info({ agentId: snapshot.id, provider: snapshot.provider }, `Created agent ${snapshot.id} (${snapshot.provider})`);
+                return snapshot;
             };
-            const handleInitialPromptError = (promptError) => {
-                this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
+            let reusedExisting = false;
+            let snapshot;
+            let agentPayload;
+            if (createReplayKey) {
+                const existingEntry = pendingCreateAgentRequests.get(createReplayKey);
+                if (existingEntry) {
+                    reusedExisting = true;
+                    snapshot = await existingEntry.promise;
+                }
+                else {
+                    reusedExisting = false;
+                    let clearReplayEntryOnDeferredFailure = () => { };
+                    const nextPromise = createAgentLaunch(() => {
+                        clearReplayEntryOnDeferredFailure();
+                    });
+                    const nextEntry = storePendingCreateAgentRequest(createReplayKey, nextPromise);
+                    clearReplayEntryOnDeferredFailure = () => {
+                        deletePendingCreateAgentRequest(createReplayKey, nextEntry);
+                    };
+                    try {
+                        snapshot = await nextPromise;
+                    }
+                    catch (error) {
+                        deletePendingCreateAgentRequest(createReplayKey, nextEntry);
+                        throw error;
+                    }
+                }
+                agentPayload = await this.getAgentPayloadById(snapshot.id);
+                if (!agentPayload) {
+                    agentPayload = await this.buildAgentPayload(snapshot);
+                }
+            }
+            else {
+                snapshot = await createAgentLaunch();
+                agentPayload = await this.getAgentPayloadById(snapshot.id);
+                if (!agentPayload) {
+                    throw new Error(`Agent ${snapshot.id} not found after creation`);
+                }
+            }
+            if (requestId) {
                 this.emit({
-                    type: 'activity_log',
+                    type: 'status',
                     payload: {
-                        id: uuidv4(),
-                        timestamp: new Date(),
-                        type: 'error',
-                        content: `Initial prompt failed: ${promptError?.message ?? promptError}`,
-                    },
-                });
-            };
-            if (hasInitialMessage && !worktreeConfig) {
-                void runInitialPrompt().catch(handleInitialPromptError);
-            }
-            if (worktreeConfig) {
-                void runAsyncWorktreeBootstrap({
-                    agentId: snapshot.id,
-                    worktree: worktreeConfig,
-                    setupOverride: bootstrapSetupOverride,
-                    generalPreferencesApplied,
-                    terminalManager: this.terminalManager,
-                    appendTimelineItem: (item) => appendTimelineItemIfAgentKnown({
-                        agentManager: this.agentManager,
-                        agentId: snapshot.id,
-                        item,
-                    }),
-                    emitLiveTimelineItem: (item) => emitLiveTimelineItemIfAgentKnown({
-                        agentManager: this.agentManager,
+                        status: 'agent_created',
+                        reusedExisting,
                         agentId: snapshot.id,
-                        item,
-                    }),
-                    onSetupSettled: async (result) => {
-                        if (!hasInitialMessage || result.setupStatus === 'failed') {
-                            return;
-                        }
-                        await runInitialPrompt().catch(handleInitialPromptError);
+                        requestId,
+                        agent: agentPayload,
                     },
-                    logger: this.sessionLogger,
-                }).catch((bootstrapError) => {
-                    this.sessionLogger.error({ err: bootstrapError, agentId: snapshot.id }, `Failed to bootstrap worktree for agent ${snapshot.id}`);
                 });
             }
-            this.sessionLogger.info({ agentId: snapshot.id, provider: snapshot.provider }, `Created agent ${snapshot.id} (${snapshot.provider})`);
         }
         catch (error) {
             this.sessionLogger.error({ err: error }, 'Failed to create agent');
@@ -5585,6 +5666,7 @@ export class Session {
                 agentId,
                 text: msg.text,
                 ...(msg.messageId ? { messageId: msg.messageId } : {}),
+                ...(msg.suppressHistory ? { suppressHistory: true } : {}),
                 ...(msg.images ? { images: msg.images } : {}),
                 runOptions: normalizeAgentRunOptions(msg.runOptions),
             });