@junctionpanel/server 0.1.39 → 0.1.41

package/dist/server/server/session.js

@@ -19,10 +19,10 @@ import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from './ag
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from './agent/agent-response-loop.js';
 import { isValidAgentProvider, AGENT_PROVIDER_IDS } from './agent/provider-manifest.js';
 import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, isWorkspaceExplorerMissingPathError, } from './file-explorer/service.js';
-import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, restoreInRepoWorktree, } from '../utils/worktree.js';
+import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, attachInRepoWorktree, 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, resolveBaseRefWithSource, } from '../utils/checkout-git.js';
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestFailureLogs, getPullRequestStatus, searchPullRequests, 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';
@@ -906,6 +906,9 @@ export class Session {
                 case 'checkout_pr_status_request':
                     await this.handleCheckoutPrStatusRequest(msg);
                     break;
+                case 'checkout_pr_search_request':
+                    await this.handleCheckoutPrSearchRequest(msg);
+                    break;
                 case 'checkout_pr_failure_logs_request':
                     await this.handleCheckoutPrFailureLogsRequest(msg);
                     break;
@@ -1730,6 +1733,7 @@ export class Session {
     async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, labels) {
         const cwd = expandTilde(config.cwd);
         const normalized = this.normalizeGitOptions(gitOptions, legacyWorktreeName);
+        const requestedAttachBranch = normalized?.attachBranchName;
         let repoRoot;
         try {
             const { stdout } = await execAsync('git rev-parse --path-format=absolute --git-common-dir', {
@@ -1767,6 +1771,64 @@ export class Session {
                 };
             }
         }
+        if (requestedAttachBranch) {
+            const attachBranchSource = normalized?.attachBranchSource ?? 'remote';
+            const liveWorktrees = await listJunctionWorktrees({ cwd: repoRoot, junctionHome: this.junctionHome });
+            const localMatchingWorktree = attachBranchSource === 'local'
+                ? liveWorktrees.find((entry) => entry.branchName?.trim() === requestedAttachBranch)
+                : null;
+            if (localMatchingWorktree) {
+                this.sessionLogger.info({
+                    repoRoot,
+                    attachBranchName: requestedAttachBranch,
+                    attachBranchRef: `refs/heads/${requestedAttachBranch}`,
+                    worktreePath: localMatchingWorktree.path,
+                }, 'Reusing existing Junction worktree for agent');
+                return {
+                    sessionConfig: {
+                        ...config,
+                        cwd: localMatchingWorktree.path,
+                    },
+                    autoWorkspaceName: labels?.['junction:workspace'] ?? basename(localMatchingWorktree.path),
+                };
+            }
+            let requestedAttachTarget = null;
+            try {
+                requestedAttachTarget = await this.resolveAttachBranchTarget({
+                    repoRoot,
+                    branchName: requestedAttachBranch,
+                    branchSource: attachBranchSource,
+                    remoteName: normalized?.remoteName,
+                });
+            }
+            catch (error) {
+                this.sessionLogger.warn({
+                    err: error,
+                    repoRoot,
+                    attachBranchName: requestedAttachBranch,
+                    attachBranchSource,
+                }, 'Failed to resolve attach target before reuse lookup');
+            }
+            const matchingWorktree = requestedAttachTarget?.head
+                ? liveWorktrees.find((entry) => entry.branchName?.trim() === requestedAttachBranch
+                    && entry.head === requestedAttachTarget?.head)
+                : null;
+            if (matchingWorktree) {
+                this.sessionLogger.info({
+                    repoRoot,
+                    attachBranchName: requestedAttachBranch,
+                    attachBranchRef: requestedAttachTarget?.ref ?? null,
+                    worktreePath: matchingWorktree.path,
+                }, 'Reusing existing Junction worktree for agent');
+                return {
+                    sessionConfig: {
+                        ...config,
+                        cwd: matchingWorktree.path,
+                    },
+                    autoWorkspaceName: labels?.['junction:workspace'] ?? basename(matchingWorktree.path),
+                };
+            }
+        }
         const resolvedBase = normalized?.baseBranch
             ? {
                 ref: normalized.baseBranch,
@@ -1781,6 +1843,32 @@ export class Session {
         if (!baseBranch) {
             throw new Error('Unable to determine a base branch for worktree creation');
         }
+        if (requestedAttachBranch) {
+            this.sessionLogger.info({
+                repoRoot,
+                baseBranch,
+                baseBranchSource: resolvedBase.source,
+                attachBranchName: requestedAttachBranch,
+                attachBranchSource: normalized?.attachBranchSource ?? 'remote',
+            }, 'Attaching in-repo worktree for new agent');
+            const attachedWorktree = await attachInRepoWorktree({
+                repoRoot,
+                baseBranch,
+                baseBranchSource: resolvedBase.source,
+                remoteName: resolvedBase.remoteName ?? normalized?.remoteName,
+                branchName: requestedAttachBranch,
+                branchSource: normalized?.attachBranchSource ?? 'remote',
+                runSetup: false,
+            });
+            return {
+                sessionConfig: {
+                    ...config,
+                    cwd: attachedWorktree.worktreePath,
+                },
+                worktreeConfig: attachedWorktree,
+                autoWorkspaceName: attachedWorktree.slug,
+            };
+        }
         this.sessionLogger.info({ repoRoot, baseBranch, baseBranchSource: resolvedBase.source }, 'Creating in-repo worktree for new agent');
         const createdWorktree = await createInRepoWorktree({
             repoRoot,
@@ -2091,10 +2179,12 @@ export class Session {
         const createWorktree = Boolean(merged.createWorktree);
         const createNewBranch = Boolean(merged.createNewBranch);
         const normalizedBranchName = merged.newBranchName ? slugify(merged.newBranchName) : undefined;
+        const attachBranchName = merged.attachBranchName?.trim() || undefined;
+        const attachBranchSource = merged.attachBranchSource ?? 'remote';
         const normalizedWorktreeSlug = merged.worktreeSlug
             ? slugify(merged.worktreeSlug)
-            : normalizedBranchName;
-        if (!createWorktree && !createNewBranch && !baseBranch) {
+            : normalizedBranchName ?? (attachBranchName ? slugify(attachBranchName) : undefined);
+        if (!createWorktree && !createNewBranch && !attachBranchName && !baseBranch) {
             return null;
         }
         if (baseBranch) {
@@ -2112,6 +2202,12 @@ export class Session {
                 throw new Error(`Invalid branch name: ${validation.error}`);
             }
         }
+        if (attachBranchName) {
+            this.assertSafeGitRef(attachBranchName, 'attach branch');
+        }
+        if (attachBranchName && createNewBranch) {
+            throw new Error('Cannot both attach to an existing branch and create a new branch');
+        }
         if (normalizedWorktreeSlug) {
             const validation = validateBranchSlug(normalizedWorktreeSlug);
             if (!validation.valid) {
@@ -2126,7 +2222,56 @@ export class Session {
             newBranchName: normalizedBranchName,
             createWorktree,
             worktreeSlug: normalizedWorktreeSlug,
+            attachBranchName,
+            attachBranchSource,
+        };
+    }
+    async resolveAttachBranchTarget(options) {
+        const resolveLocalRef = async () => {
+            try {
+                const { stdout } = await execAsync(`git rev-parse refs/heads/${options.branchName}`, {
+                    cwd: options.repoRoot,
+                    env: READ_ONLY_GIT_ENV,
+                });
+                return {
+                    head: stdout.trim(),
+                    ref: `refs/heads/${options.branchName}`,
+                };
+            }
+            catch {
+                return null;
+            }
         };
+        if (options.branchSource === 'local') {
+            return resolveLocalRef();
+        }
+        const remotes = await listGitRemotes(options.repoRoot);
+        const effectiveRemoteName = options.remoteName && remotes.some((remote) => remote.name === options.remoteName)
+            ? options.remoteName
+            : remotes.find((remote) => remote.name === 'origin')?.name ?? remotes[0]?.name;
+        if (!effectiveRemoteName) {
+            return null;
+        }
+        this.assertSafeRemoteName(effectiveRemoteName);
+        try {
+            await execAsync(`git fetch ${effectiveRemoteName} --prune`, { cwd: options.repoRoot });
+        }
+        catch {
+            return null;
+        }
+        try {
+            const { stdout } = await execAsync(`git rev-parse refs/remotes/${effectiveRemoteName}/${options.branchName}`, {
+                cwd: options.repoRoot,
+                env: READ_ONLY_GIT_ENV,
+            });
+            return {
+                head: stdout.trim(),
+                ref: `refs/remotes/${effectiveRemoteName}/${options.branchName}`,
+            };
+        }
+        catch {
+            return null;
+        }
     }
     assertSafeGitRef(ref, label) {
         if (!SAFE_GIT_REF_PATTERN.test(ref) || ref.includes('..') || ref.includes('@{')) {
@@ -3442,6 +3587,39 @@ export class Session {
             });
         }
     }
+    async handleCheckoutPrSearchRequest(msg) {
+        const cwd = expandTilde(msg.cwd);
+        const { requestId } = msg;
+        try {
+            const result = await searchPullRequests(cwd, {
+                query: msg.query,
+                limit: msg.limit,
+                remoteName: msg.remoteName,
+            });
+            this.emit({
+                type: 'checkout_pr_search_response',
+                payload: {
+                    cwd,
+                    pullRequests: result.pullRequests,
+                    githubFeaturesEnabled: result.githubFeaturesEnabled,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: 'checkout_pr_search_response',
+                payload: {
+                    cwd,
+                    pullRequests: [],
+                    githubFeaturesEnabled: true,
+                    error: this.toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
     async handleCheckoutPrFailureLogsRequest(msg) {
         const { cwd, requestId } = msg;
         try {