@junctionpanel/server 0.1.32 → 0.1.34

package/dist/server/server/session.js

@@ -11,8 +11,9 @@ import { buildConfigOverrides, buildSessionConfig, extractTimestamps, extractTim
 import { experimental_createMCPClient } from 'ai';
 import { buildProviderRegistry } from './agent/provider-registry.js';
 import { applyProviderEnv, } from './agent/provider-launch-config.js';
+import { buildPermissionRecoveryFingerprint } from './agent/agent-permission-fingerprint.js';
 import { scheduleAgentMetadataGeneration } from './agent/agent-metadata-generator.js';
-import { resolveEffectiveThinkingOptionId, toAgentPayload } from './agent/agent-projections.js';
+import { toAgentPayload, resolveEffectiveThinkingOptionId, toStoredAgentPayload, } from './agent/agent-projections.js';
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from './agent/timeline-append.js';
 import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from './agent/timeline-projection.js';
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from './agent/agent-response-loop.js';
@@ -21,7 +22,7 @@ import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from
 import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, restoreInRepoWorktree, } from '../utils/worktree.js';
 import { readJunctionWorktreeMetadata } from '../utils/worktree-metadata.js';
 import { runAsyncWorktreeBootstrap } from './worktree-bootstrap.js';
-import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestFailureLogs, getPullRequestStatus, listGitRemotes, mergePullRequest, resolveBaseRef, } from '../utils/checkout-git.js';
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestFailureLogs, getPullRequestStatus, listGitRemotes, mergePullRequest, resolveBaseRefWithSource, } from '../utils/checkout-git.js';
 import { getProjectIcon } from '../utils/project-icon.js';
 import { expandTilde } from '../utils/path.js';
 import { searchHomeDirectories, searchWorkspaceEntries, searchWorkspaceEntriesAtGitRef, searchGitRepositories, checkIsGitRepo, } from '../utils/directory-suggestions.js';
@@ -29,9 +30,10 @@ import { cloneRepository } from '../utils/git-clone.js';
 import { initRepository } from '../utils/git-init.js';
 import { resolveClientMessageId } from './client-message-id.js';
 import { deriveProjectGroupingKey, deriveProjectGroupingName } from '../shared/project-grouping.js';
-import { resolveDaemonVersion } from './daemon-version.js';
+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 { resolvePackageUpdateInfo } from './package-update.js';
 import { loadPersistedConfig } from './persisted-config.js';
 const execAsync = promisify(exec);
 const READ_ONLY_GIT_ENV = {
@@ -338,63 +340,7 @@ export class Session {
         return payload;
     }
     buildStoredAgentPayload(record) {
-        const defaultCapabilities = {
-            supportsStreaming: false,
-            supportsSessionPersistence: true,
-            supportsDynamicModes: false,
-            supportsMcpServers: false,
-            supportsReasoningStream: false,
-            supportsToolInvocations: true,
-        };
-        const createdAt = new Date(record.createdAt);
-        const updatedAt = new Date(record.lastActivityAt ?? record.updatedAt);
-        const lastUserMessageAt = record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null;
-        const provider = coerceAgentProvider(this.sessionLogger, record.provider, record.id);
-        const runtimeInfo = record.runtimeInfo
-            ? {
-                provider: coerceAgentProvider(this.sessionLogger, record.runtimeInfo.provider, record.id),
-                sessionId: record.runtimeInfo.sessionId,
-                ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'model')
-                    ? { model: record.runtimeInfo.model ?? null }
-                    : {}),
-                ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'thinkingOptionId')
-                    ? { thinkingOptionId: record.runtimeInfo.thinkingOptionId ?? null }
-                    : {}),
-                ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'modeId')
-                    ? { modeId: record.runtimeInfo.modeId ?? null }
-                    : {}),
-                ...(record.runtimeInfo.extra ? { extra: record.runtimeInfo.extra } : {}),
-            }
-            : undefined;
-        return {
-            id: record.id,
-            provider,
-            cwd: record.cwd,
-            model: record.config?.model ?? null,
-            thinkingOptionId: record.config?.thinkingOptionId ?? null,
-            effectiveThinkingOptionId: resolveEffectiveThinkingOptionId({
-                runtimeInfo,
-                configuredThinkingOptionId: record.config?.thinkingOptionId ?? null,
-            }),
-            ...(runtimeInfo ? { runtimeInfo } : {}),
-            createdAt: createdAt.toISOString(),
-            updatedAt: updatedAt.toISOString(),
-            lastUserMessageAt: lastUserMessageAt ? lastUserMessageAt.toISOString() : null,
-            status: record.lastStatus,
-            capabilities: defaultCapabilities,
-            currentModeId: record.lastModeId ?? null,
-            availableModes: [],
-            pendingPermissions: [],
-            persistence: toAgentPersistenceHandle(this.sessionLogger, record.persistence),
-            lastUsage: undefined,
-            lastError: undefined,
-            title: record.title ?? null,
-            requiresAttention: record.requiresAttention ?? false,
-            attentionReason: record.attentionReason ?? null,
-            attentionTimestamp: record.attentionTimestamp ?? null,
-            archivedAt: record.archivedAt ?? null,
-            labels: record.labels,
-        };
+        return toStoredAgentPayload(record);
     }
     fetchStoredTimeline(record, options) {
         const rows = (record.timelineRows ?? []).map((row) => ({ ...row }));
@@ -542,6 +488,7 @@ export class Session {
                 this.sessionLogger.info({ agentId, provider: record.provider }, 'Agent created from stored config');
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
+            await this.reconcilePersistedPendingPermissions(record, agentId);
             return this.agentManager.getAgent(agentId) ?? snapshot;
         })();
         pendingAgentInitializations.set(agentId, initPromise);
@@ -555,6 +502,45 @@ export class Session {
             }
         }
     }
+    async reconcilePersistedPendingPermissions(record, agentId) {
+        const persistedPending = record.pendingPermissions ?? [];
+        if (persistedPending.length === 0) {
+            return;
+        }
+        const liveAgent = this.agentManager.getAgent(agentId);
+        const sessionPending = liveAgent && liveAgent.lifecycle !== 'closed'
+            ? liveAgent.session.getPendingPermissions()
+            : [];
+        const recoveredIds = new Set(sessionPending.map((request) => request.id));
+        const recoveredFingerprints = new Set(sessionPending.map((request) => buildPermissionRecoveryFingerprint(request)));
+        const expiredRequests = persistedPending.filter((request) => {
+            if (recoveredIds.has(request.id)) {
+                return false;
+            }
+            return !recoveredFingerprints.has(buildPermissionRecoveryFingerprint(request));
+        });
+        if (expiredRequests.length === 0) {
+            return;
+        }
+        if (liveAgent && liveAgent.lifecycle !== 'closed') {
+            const expiredIds = new Set(expiredRequests.map((request) => request.id));
+            const expiredFingerprints = new Set(expiredRequests.map((request) => buildPermissionRecoveryFingerprint(request)));
+            this.agentManager.prunePendingPermissions(agentId, {
+                requestIds: expiredIds,
+                requestFingerprints: expiredFingerprints,
+                settleLifecycleIfInactive: sessionPending.length === 0,
+            });
+        }
+        if (sessionPending.length === 0) {
+            await this.agentManager.clearAgentAttention(agentId);
+        }
+        const requestLabel = expiredRequests.length === 1 ? 'approval request' : `${expiredRequests.length} approval requests`;
+        await this.agentManager.appendTimelineItem(agentId, {
+            type: 'error',
+            message: `${requestLabel} expired while the daemon was offline. Re-run the request if you still want to continue.`,
+        });
+        this.agentManager.notifyAgentState(agentId);
+    }
     matchesAgentFilter(options) {
         const { agent, project, filter } = options;
         if (filter?.labels) {
@@ -1209,6 +1195,8 @@ export class Session {
                 restoredWorktree = await restoreInRepoWorktree({
                     repoRoot: record.archivedWorktree.repoRoot,
                     baseBranch: record.archivedWorktree.baseBranch,
+                    baseBranchSource: record.archivedWorktree.baseBranchSource ?? 'remote',
+                    remoteName: record.archivedWorktree.remoteName ?? undefined,
                     branchName: record.archivedWorktree.branchName,
                     worktreeSlug: record.archivedWorktree.worktreeSlug,
                     runSetup: false,
@@ -1322,6 +1310,8 @@ export class Session {
             return {
                 repoRoot: ownership.repoRoot,
                 baseBranch: metadata.baseRefName,
+                baseBranchSource: metadata.version === 3 ? metadata.baseBranchSource : 'remote',
+                remoteName: metadata.version === 3 ? metadata.remoteName ?? null : null,
                 branchName,
                 worktreeSlug: basename(resolvedWorktree.worktreePath),
                 originalCwd: resolvedWorktree.worktreePath,
@@ -1719,15 +1709,26 @@ export class Session {
                 };
             }
         }
-        const baseBranch = normalized?.baseBranch ?? (await resolveBaseRef(repoRoot, { remoteName: normalized?.remoteName }));
+        const resolvedBase = normalized?.baseBranch
+            ? {
+                ref: normalized.baseBranch,
+                source: normalized.baseBranchSource ?? 'remote',
+                remoteName: normalized?.remoteName ?? null,
+            }
+            : await resolveBaseRefWithSource(repoRoot, {
+                remoteName: normalized?.remoteName,
+                source: normalized?.baseBranchSource ?? 'remote',
+            });
+        const baseBranch = resolvedBase.ref;
         if (!baseBranch) {
             throw new Error('Unable to determine a base branch for worktree creation');
         }
-        this.sessionLogger.info({ repoRoot, baseBranch }, 'Creating in-repo worktree for new agent');
+        this.sessionLogger.info({ repoRoot, baseBranch, baseBranchSource: resolvedBase.source }, 'Creating in-repo worktree for new agent');
         const createdWorktree = await createInRepoWorktree({
             repoRoot,
             baseBranch,
-            remoteName: normalized?.remoteName,
+            baseBranchSource: resolvedBase.source,
+            remoteName: resolvedBase.remoteName ?? normalized?.remoteName,
             runSetup: false,
         });
         return {
@@ -1797,12 +1798,7 @@ export class Session {
         }
     }
     resolveDaemonVersionSafe() {
-        try {
-            return resolveDaemonVersion(import.meta.url);
-        }
-        catch {
-            return null;
-        }
+        return resolveDaemonPackageVersion(import.meta.url);
     }
     toDaemonMetadata(input) {
         const homeDir = input?.homeDir ?? homedir();
@@ -1822,6 +1818,7 @@ export class Session {
                 type: 'run_daemon_doctor_response',
                 payload: {
                     daemon: result.daemon,
+                    update: result.update,
                     summary: result.summary,
                     checks: result.checks,
                     ranAt: result.ranAt,
@@ -1837,6 +1834,11 @@ export class Session {
                 type: 'run_daemon_doctor_response',
                 payload: {
                     daemon: this.toDaemonMetadata(snapshot),
+                    update: resolvePackageUpdateInfo({
+                        npmInvocation: null,
+                        packageName: DEFAULT_DAEMON_PACKAGE_NAME,
+                        currentVersion: this.resolveDaemonVersionSafe(),
+                    }),
                     summary: 'fail',
                     checks: [],
                     ranAt: new Date().toISOString(),
@@ -1914,21 +1916,16 @@ export class Session {
             if (!executablePath) {
                 throw new SessionRequestError('provider_not_found', `Could not automatically locate ${msg.provider} on this daemon.`);
             }
-            const snapshot = saveDaemonProviderExecutablePath({
-                junctionHome: this.junctionHome,
-                provider: msg.provider,
-                executablePath,
-            });
             this.emit({
                 type: 'auto_route_provider_response',
                 payload: {
-                    daemon: this.toDaemonMetadata(snapshot),
-                    provider: snapshot.providers[msg.provider],
+                    daemon: this.toDaemonMetadata(),
+                    provider: msg.provider,
+                    executablePath,
                     error: null,
                     requestId: msg.requestId,
                 },
             });
-            await this.handleRestartServerRequest(msg.requestId, 'settings_update');
         }
         catch (error) {
             this.sessionLogger.error({ err: error, provider: msg.provider }, 'Failed to auto-route provider executable');
@@ -1936,7 +1933,8 @@ export class Session {
                 type: 'auto_route_provider_response',
                 payload: {
                     daemon: this.toDaemonMetadata(),
-                    provider: null,
+                    provider: msg.provider,
+                    executablePath: null,
                     error: error instanceof Error ? error.message : String(error),
                     requestId: msg.requestId,
                 },
@@ -1957,6 +1955,7 @@ export class Session {
             return null;
         }
         const baseBranch = merged.baseBranch?.trim() || undefined;
+        const baseBranchSource = merged.baseBranchSource ?? 'remote';
         const remoteName = merged.remoteName?.trim() || undefined;
         const createWorktree = Boolean(merged.createWorktree);
         const createNewBranch = Boolean(merged.createNewBranch);
@@ -1973,12 +1972,6 @@ export class Session {
         if (remoteName) {
             this.assertSafeRemoteName(remoteName);
         }
-        if (createWorktree && !baseBranch) {
-            throw new Error('Base branch is required when creating a worktree');
-        }
-        if (createNewBranch && !baseBranch) {
-            throw new Error('Base branch is required when creating a new branch');
-        }
         if (createNewBranch) {
             if (!normalizedBranchName) {
                 throw new Error('New branch name is required');
@@ -1996,6 +1989,7 @@ export class Session {
         }
         return {
             baseBranch,
+            baseBranchSource,
             remoteName,
             createNewBranch,
             newBranchName: normalizedBranchName,
@@ -2599,6 +2593,8 @@ export class Session {
             const branches = await listBranchSuggestions(resolvedCwd, {
                 query,
                 limit,
+                preferredBranches: msg.preferredBranches,
+                source: msg.source,
                 remoteName: msg.remoteName,
             });
             this.emit({
@@ -4219,6 +4215,15 @@ export class Session {
             });
             return;
         }
+        const existing = this.agentManager.getAgent(resolved.agentId);
+        if (!existing) {
+            const record = await this.agentStorage.get(resolved.agentId);
+            if (record && !record.internal && !record.archivedAt) {
+                await this.ensureAgentLoaded(resolved.agentId).catch((error) => {
+                    this.sessionLogger.warn({ err: error, agentId: resolved.agentId }, 'Failed to lazily load agent before fetch_agent_response; falling back to stored state');
+                });
+            }
+        }
         const agent = await this.getAgentPayloadById(resolved.agentId);
         if (!agent) {
             this.emit({
@@ -4535,7 +4540,8 @@ export class Session {
                 return;
             }
             const final = this.buildStoredAgentPayload(record);
-            const status = record.attentionReason === 'permission'
+            const hasPendingPermission = final.pendingPermissions.length > 0;
+            const status = hasPendingPermission
                 ? 'permission'
                 : record.lastStatus === 'error'
                     ? 'error'