@minionry/minion 0.7.36

package/dist/server/services/websocket/git-worktree-handlers.js

@@ -0,0 +1,521 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { abortMerge, completeMerge, createWorktree, createWorktreePr, discardMergeBlockers, GIT_VIEW_TAB_ID, isInsideGitRepo, isSafeDiscardPath, isValidWorktreePath, listWorktrees, mergeWorktreeBranch, popMergeStashBySha, previewMerge, pushWorktree, readCurrentBranch, removeWorktree, resolveGitDirectory, resolveMainWorktreePath, } from '../git/index.js';
+import { resolvePmDir } from '../plan/parser.js';
+import { dispatchByType } from './dispatch-util.js';
+import { FILES_VIEW_TAB_ID } from './file-explorer-handlers.js';
+import { handleGitStatus } from './git-handlers.js';
+import { handleGitLog } from './git-log-handlers.js';
+import { sendGitError } from './git-utils.js';
+import { clearScope, resolveScopeDir, scopeRepoPath, scopeRepoWorktrees, scopeWorktreePath, setScopeRepo, setScopeRepoWorktree, setScopeWorktree, } from './handler-context.js';
+import { notifySdkGitWorktreesChanged } from './sdk-git-host.js';
+export { deriveWorktreePath, findWorktreePathForBranch, parseWorktreePorcelain, parseWorktreeStatusSummary } from '../git/index.js';
+function persistBoardWorktree(workingDir, boardId, worktreePath, branch, repoPath) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const wsPath = join(pmDir, 'workspace.json');
+    if (!existsSync(wsPath))
+        return;
+    try {
+        const workspace = JSON.parse(readFileSync(wsPath, 'utf-8'));
+        if (!workspace.boardWorktrees)
+            workspace.boardWorktrees = {};
+        const entry = {
+            ...(worktreePath && branch ? { path: worktreePath, branch } : {}),
+            ...(repoPath ? { repoPath } : {}),
+        };
+        if (entry.path || entry.repoPath)
+            workspace.boardWorktrees[boardId] = entry;
+        else
+            delete workspace.boardWorktrees[boardId];
+        writeFileSync(wsPath, JSON.stringify(workspace, null, 2), 'utf-8');
+    }
+    catch {   }
+}
+function isBoardId(id) {
+    return id.startsWith('BOARD-');
+}
+export function persistScopeBinding(ctx, workingDir, scopeId) {
+    const worktreePath = scopeWorktreePath(ctx, scopeId) ?? null;
+    const repoPath = scopeRepoPath(ctx, scopeId) ?? null;
+    const branch = ctx.gitBranches.get(scopeId) ?? null;
+    const registry = ctx.getRegistry(workingDir);
+    registry.updateTabWorktree(scopeId, worktreePath, branch);
+    registry.updateTabRepoPath(scopeId, repoPath);
+    registry.updateTabRepoWorktrees(scopeId, scopeRepoWorktrees(ctx, scopeId));
+    if (isBoardId(scopeId))
+        persistBoardWorktree(workingDir, scopeId, worktreePath, branch, repoPath);
+}
+export async function handleGitWorktreeMessage(ctx, ws, msg, tabId, gitDir, workingDir) {
+    const handlers = {
+        gitWorktreeList: () => handleGitWorktreeList(ctx, ws, msg, tabId, gitDir),
+        gitWorktreeCreate: () => handleGitWorktreeCreate(ctx, ws, msg, tabId, gitDir),
+        gitWorktreeCreateAndAssign: () => handleGitWorktreeCreateAndAssign(ctx, ws, msg, tabId, gitDir, workingDir),
+        gitWorktreeRemove: () => handleGitWorktreeRemove(ctx, ws, msg, tabId, gitDir, workingDir),
+        tabWorktreeSwitch: () => handleTabWorktreeSwitch(ctx, ws, msg, tabId, workingDir),
+        tabRepoWorktreeSwitch: () => handleTabRepoWorktreeSwitch(ctx, ws, msg, tabId, workingDir),
+        gitWorktreePush: () => handleGitWorktreePush(ctx, ws, msg, tabId, gitDir),
+        gitWorktreeCreatePR: () => handleGitWorktreeCreatePR(ctx, ws, msg, tabId, gitDir),
+        gitMergePreview: () => handleGitMergePreview(ctx, ws, msg, tabId, gitDir),
+        gitWorktreeMerge: () => handleGitWorktreeMerge(ctx, ws, msg, tabId, gitDir, workingDir),
+        gitMergeAbort: () => handleGitMergeAbort(ctx, ws, msg, tabId, gitDir),
+        gitMergeComplete: () => handleGitMergeComplete(ctx, ws, msg, tabId, gitDir),
+        gitMergeStashPop: () => handleGitMergeStashPop(ctx, ws, msg, tabId, gitDir),
+        gitMergeDiscardBlockers: () => handleGitMergeDiscardBlockers(ctx, ws, msg, tabId, gitDir),
+    };
+    await dispatchByType(handlers, 'git-worktree', msg.type, (type) => {
+        sendGitError(ctx, ws, tabId, `Unknown git worktree message type: ${type}`);
+    });
+}
+async function handleGitWorktreeList(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const includeStatus = msg.data?.includeStatus === true;
+        const result = await listWorktrees({ cwd: workingDir, includeStatus });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, {
+            type: 'gitWorktreeListResult',
+            tabId,
+            data: includeStatus ? { worktrees: result.value, withStatus: true } : { worktrees: result.value },
+        });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitWorktreeCreate(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { branchName, baseBranch, path: worktreePath } = msg.data || {};
+        if (!branchName) {
+            sendGitError(ctx, ws, tabId, 'Branch name is required');
+            return;
+        }
+        const result = await createWorktree({ cwd: workingDir, branchName, baseBranch, path: worktreePath });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, {
+            type: 'gitWorktreeCreated',
+            tabId,
+            data: { path: result.value.path, branch: result.value.branch, head: result.value.head },
+        });
+        notifySdkGitWorktreesChanged();
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitWorktreeCreateAndAssign(ctx, ws, msg, tabId, gitDir, workingDir) {
+    try {
+        const { branchName, baseBranch, path: worktreePath } = msg.data || {};
+        if (!branchName) {
+            sendGitError(ctx, ws, tabId, 'Branch name is required');
+            return;
+        }
+        const result = await createWorktree({ cwd: gitDir, branchName, baseBranch, path: worktreePath });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        const { path: wtPath, head } = result.value;
+        setScopeWorktree(ctx, tabId, wtPath);
+        ctx.gitBranches.set(tabId, branchName);
+        persistScopeBinding(ctx, workingDir, tabId);
+        ctx.send(ws, {
+            type: 'gitWorktreeCreatedAndAssigned',
+            tabId,
+            data: { tabId, path: wtPath, branch: branchName, head },
+        });
+        notifySdkGitWorktreesChanged();
+        handleGitStatus(ctx, ws, tabId, wtPath);
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+function cleanupWorktreeReferences(ctx, workingDir, wtPath) {
+    const resolvedWtPath = join(wtPath);
+    const matchesRemoved = (path) => path === resolvedWtPath || path === wtPath;
+    for (const [tid, scope] of [...ctx.gitScopes]) {
+        if (matchesRemoved(scope.worktreePath)) {
+            setScopeWorktree(ctx, tid, null);
+            ctx.gitBranches.delete(tid);
+            persistScopeBinding(ctx, workingDir, tid);
+        }
+        const removedRepoRoots = Object.entries(scope.repoWorktrees ?? {})
+            .filter(([, entry]) => matchesRemoved(entry.worktreePath))
+            .map(([repoRoot]) => repoRoot);
+        if (removedRepoRoots.length === 0)
+            continue;
+        for (const repoRoot of removedRepoRoots)
+            setScopeRepoWorktree(ctx, tid, repoRoot, null);
+        persistScopeBinding(ctx, workingDir, tid);
+        ctx.broadcastToAll({ type: 'tabRepoWorktreesSwitched', tabId: tid, data: { tabId: tid, ...repoWorktreeSnapshot(ctx, tid) } });
+    }
+}
+async function handleGitWorktreeRemove(ctx, ws, msg, tabId, gitDir, workingDir) {
+    try {
+        const { path: wtPath, force, deleteBranch } = msg.data || {};
+        if (!wtPath) {
+            sendGitError(ctx, ws, tabId, 'Worktree path is required');
+            return;
+        }
+        const cwd = await resolveMainWorktreePath(gitDir);
+        const result = await removeWorktree({ cwd, path: wtPath, force, deleteBranch });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        cleanupWorktreeReferences(ctx, workingDir, wtPath);
+        ctx.send(ws, { type: 'gitWorktreeRemoved', tabId, data: { path: wtPath } });
+        notifySdkGitWorktreesChanged();
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleTabWorktreeSwitch(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { tabId: targetTabId, worktreePath, allowCustom } = msg.data || {};
+        const resolvedTabId = targetTabId || tabId;
+        if (!worktreePath) {
+            setScopeWorktree(ctx, resolvedTabId, null);
+            ctx.gitBranches.delete(resolvedTabId);
+            persistScopeBinding(ctx, workingDir, resolvedTabId);
+            const repoPath = scopeRepoPath(ctx, resolvedTabId) ?? null;
+            ctx.send(ws, { type: 'tabWorktreeSwitched', tabId: resolvedTabId, data: { tabId: resolvedTabId, worktreePath: null, branch: null, repoPath } });
+            notifySdkGitWorktreesChanged();
+            refreshScopeAfterWorktreeSwitch(ctx, ws, resolvedTabId, repoPath ?? workingDir);
+            return;
+        }
+        const repoDir = scopeRepoPath(ctx, resolvedTabId) ?? workingDir;
+        const isRegistered = await isValidWorktreePath(worktreePath, repoDir);
+        if (!isRegistered && !(allowCustom === true && (await isInsideGitRepo(worktreePath)))) {
+            sendGitError(ctx, ws, tabId, `'${worktreePath}' is not a registered worktree of this scope's repository`);
+            return;
+        }
+        setScopeWorktree(ctx, resolvedTabId, worktreePath);
+        const branch = await readCurrentBranch(worktreePath);
+        ctx.gitBranches.set(resolvedTabId, branch);
+        persistScopeBinding(ctx, workingDir, resolvedTabId);
+        ctx.send(ws, {
+            type: 'tabWorktreeSwitched',
+            tabId: resolvedTabId,
+            data: { tabId: resolvedTabId, worktreePath, branch, repoPath: scopeRepoPath(ctx, resolvedTabId) ?? null },
+        });
+        notifySdkGitWorktreesChanged();
+        refreshScopeAfterWorktreeSwitch(ctx, ws, resolvedTabId, worktreePath);
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+function refreshScopeAfterWorktreeSwitch(ctx, ws, tabId, gitDir) {
+    if (tabId === FILES_VIEW_TAB_ID)
+        return;
+    (async () => {
+        await handleGitStatus(ctx, ws, tabId, gitDir);
+        await handleGitLog(ctx, ws, { type: 'gitLog', tabId, data: { limit: 20 } }, tabId, gitDir);
+    })().catch((error) => {
+        console.error('[handleTabWorktreeSwitch] scope refresh failed:', error);
+    });
+}
+const APP_HOST_SCOPE_ID = '__app_host__';
+function isAgentTabScope(scopeId) {
+    return !isBoardId(scopeId) && scopeId !== GIT_VIEW_TAB_ID && scopeId !== FILES_VIEW_TAB_ID && scopeId !== APP_HOST_SCOPE_ID;
+}
+function repoWorktreeSnapshot(ctx, scopeId) {
+    return {
+        repoWorktrees: scopeRepoWorktrees(ctx, scopeId),
+        worktreePath: scopeWorktreePath(ctx, scopeId) ?? null,
+        repoPath: scopeRepoPath(ctx, scopeId) ?? null,
+    };
+}
+function sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId, error) {
+    const data = {
+        tabId: scopeId,
+        ...repoWorktreeSnapshot(ctx, scopeId),
+        ...(requestId ? { requestId } : {}),
+        ...(error ? { error } : {}),
+    };
+    ctx.send(ws, { type: 'tabRepoWorktreesSwitched', tabId: scopeId, data });
+}
+async function adoptLegacyAxes(ctx, scopeId) {
+    const legacyWorktree = scopeWorktreePath(ctx, scopeId);
+    const legacyRepo = scopeRepoPath(ctx, scopeId);
+    if (!legacyWorktree && !legacyRepo)
+        return;
+    if (legacyWorktree) {
+        const root = await resolveMainWorktreePath(legacyWorktree);
+        const alreadyMapped = scopeRepoWorktrees(ctx, scopeId).some((selection) => selection.repoRoot === root);
+        if (root !== legacyWorktree && !alreadyMapped) {
+            setScopeRepoWorktree(ctx, scopeId, root, { worktreePath: legacyWorktree, branch: ctx.gitBranches.get(scopeId) ?? null });
+        }
+    }
+    setScopeWorktree(ctx, scopeId, null);
+    setScopeRepo(ctx, scopeId, null);
+    ctx.gitBranches.delete(scopeId);
+}
+function normalizeBranch(branch) {
+    return branch === 'HEAD' || branch === '' ? null : branch;
+}
+async function validateRepoPath(workingDir, repoPath) {
+    const resolved = await resolveGitDirectory({ cwd: workingDir, directory: repoPath });
+    if (!resolved.ok)
+        return { error: resolved.error };
+    if (!(await isInsideGitRepo(resolved.value.directory)))
+        return { error: `'${repoPath}' is not a git repository` };
+    return { repoRoot: await resolveMainWorktreePath(resolved.value.directory) };
+}
+async function applySelectOp(ctx, scopeId, workingDir, data) {
+    const validated = await validateRepoPath(workingDir, data.repoPath);
+    if ('error' in validated)
+        return validated.error;
+    const { repoRoot } = validated;
+    if (data.worktreePath === null || data.worktreePath === repoRoot) {
+        await adoptLegacyAxes(ctx, scopeId);
+        setScopeRepoWorktree(ctx, scopeId, repoRoot, null);
+        return undefined;
+    }
+    if (!(await isValidWorktreePath(data.worktreePath, repoRoot))) {
+        return `'${data.worktreePath}' is not a registered worktree of ${repoRoot}`;
+    }
+    const branch = normalizeBranch(await readCurrentBranch(data.worktreePath));
+    await adoptLegacyAxes(ctx, scopeId);
+    setScopeRepoWorktree(ctx, scopeId, repoRoot, { worktreePath: data.worktreePath, branch });
+    return undefined;
+}
+async function applyCreateOp(ctx, scopeId, workingDir, data) {
+    const validated = await validateRepoPath(workingDir, data.repoPath);
+    if ('error' in validated)
+        return validated.error;
+    const { repoRoot } = validated;
+    const branchName = data.branchName.trim();
+    if (!branchName)
+        return 'Branch name is required';
+    const result = await createWorktree({ cwd: repoRoot, branchName, baseBranch: data.baseBranch });
+    if (!result.ok)
+        return result.error;
+    await adoptLegacyAxes(ctx, scopeId);
+    setScopeRepoWorktree(ctx, scopeId, repoRoot, { worktreePath: result.value.path, branch: branchName });
+    return undefined;
+}
+function refreshScopeAfterRepoWorktreeSwitch(ctx, ws, scopeId, gitDir) {
+    handleGitStatus(ctx, ws, scopeId, gitDir).catch((error) => {
+        console.error('[handleTabRepoWorktreeSwitch] scope refresh failed:', error);
+    });
+}
+async function processTabRepoWorktreeSwitch(ctx, ws, scopeId, workingDir, data) {
+    const requestId = data.requestId;
+    if (!isAgentTabScope(scopeId)) {
+        sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId, `'${scopeId}' is not an Agent tab — per-repo worktree selections are Agent-tab only`);
+        return;
+    }
+    try {
+        if (data.op === 'clear') {
+            clearScope(ctx, scopeId);
+            ctx.gitBranches.delete(scopeId);
+            persistScopeBinding(ctx, workingDir, scopeId);
+            sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId);
+            notifySdkGitWorktreesChanged();
+            refreshScopeAfterRepoWorktreeSwitch(ctx, ws, scopeId, resolveScopeDir(ctx, scopeId, workingDir));
+            return;
+        }
+        if (data.op !== 'select' && data.op !== 'create') {
+            sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId, `Unknown tabRepoWorktreeSwitch op: ${String(data.op)}`);
+            return;
+        }
+        const error = data.op === 'select'
+            ? await applySelectOp(ctx, scopeId, workingDir, data)
+            : await applyCreateOp(ctx, scopeId, workingDir, data);
+        if (error) {
+            sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId, error);
+            return;
+        }
+        persistScopeBinding(ctx, workingDir, scopeId);
+        sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId);
+        notifySdkGitWorktreesChanged();
+        refreshScopeAfterRepoWorktreeSwitch(ctx, ws, scopeId, resolveScopeDir(ctx, scopeId, workingDir));
+    }
+    catch (error) {
+        sendTabRepoWorktreesSwitched(ctx, ws, scopeId, requestId, error instanceof Error ? error.message : String(error));
+    }
+}
+const repoWorktreeSwitchQueues = new Map();
+function runSerializedForScope(scopeId, run) {
+    const prior = repoWorktreeSwitchQueues.get(scopeId) ?? Promise.resolve();
+    const current = prior
+        .catch(() => { })
+        .then(run)
+        .catch((error) => {
+        console.error(`[handleTabRepoWorktreeSwitch] command failed for scope ${scopeId}:`, error);
+    })
+        .finally(() => {
+        if (repoWorktreeSwitchQueues.get(scopeId) === current)
+            repoWorktreeSwitchQueues.delete(scopeId);
+    });
+    repoWorktreeSwitchQueues.set(scopeId, current);
+    return current;
+}
+export async function handleTabRepoWorktreeSwitch(ctx, ws, msg, tabId, workingDir) {
+    const data = (msg.data || {});
+    const scopeId = data.tabId || tabId;
+    await runSerializedForScope(scopeId, () => processTabRepoWorktreeSwitch(ctx, ws, scopeId, workingDir, data));
+}
+async function handleGitWorktreePush(ctx, ws, msg, tabId, _workingDir) {
+    try {
+        const { worktreePath, remote, branch, setUpstream } = msg.data || {};
+        if (!worktreePath) {
+            sendGitError(ctx, ws, tabId, 'Worktree path is required');
+            return;
+        }
+        const result = await pushWorktree({ cwd: worktreePath, remote, branch, setUpstream });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitWorktreePushed', tabId, data: { output: result.value.output, upstream: result.value.upstream } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitWorktreeCreatePR(ctx, ws, msg, tabId, _workingDir) {
+    try {
+        const { worktreePath, title, body, baseBranch, draft } = msg.data || {};
+        if (!worktreePath) {
+            sendGitError(ctx, ws, tabId, 'Worktree path is required');
+            return;
+        }
+        const result = await createWorktreePr({ cwd: worktreePath, title, body, baseBranch, draft });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitWorktreePRCreated', tabId, data: { prUrl: result.value.prUrl, prNumber: result.value.prNumber } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitMergePreview(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { sourceBranch, targetBranch } = msg.data || {};
+        if (!sourceBranch || !targetBranch) {
+            sendGitError(ctx, ws, tabId, 'Source and target branches are required');
+            return;
+        }
+        const preview = await previewMerge({ cwd: workingDir, sourceBranch, targetBranch });
+        ctx.send(ws, { type: 'gitMergePreviewResult', tabId, data: preview });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitWorktreeMerge(ctx, ws, msg, tabId, gitDir, workingDir) {
+    try {
+        const { sourceBranch, targetBranch, strategy, commitMessage, deleteWorktree, deleteBranch, stashFirst } = msg.data || {};
+        if (!sourceBranch || !targetBranch || !strategy) {
+            sendGitError(ctx, ws, tabId, 'Source branch, target branch, and strategy are required');
+            return;
+        }
+        const { data, removedWorktreePath } = await mergeWorktreeBranch({
+            cwd: gitDir, sourceBranch, targetBranch, strategy,
+            commitMessage, deleteWorktree, deleteBranch, stashFirst,
+        });
+        if (removedWorktreePath)
+            cleanupWorktreeReferences(ctx, workingDir, removedWorktreePath);
+        ctx.send(ws, {
+            type: 'gitWorktreeMergeResult',
+            tabId,
+            data: removedWorktreePath ? { ...data, removedWorktreePath } : data,
+        });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitMergeStashPop(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { stashSha, targetWorktreePath } = msg.data || {};
+        if (!stashSha) {
+            ctx.send(ws, { type: 'gitMergeStashPopped', tabId, data: { success: false, error: 'Missing stash reference' } });
+            return;
+        }
+        const path = targetWorktreePath || (await resolveMainWorktreePath(workingDir));
+        const result = await popMergeStashBySha(path, stashSha);
+        if (result.exitCode !== 0) {
+            ctx.send(ws, { type: 'gitMergeStashPopped', tabId, data: { success: false, error: result.error || 'Failed to pop stash', targetWorktreePath: path } });
+            return;
+        }
+        ctx.send(ws, { type: 'gitMergeStashPopped', tabId, data: { success: true, targetWorktreePath: path } });
+        handleGitStatus(ctx, ws, tabId, path);
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitMergeDiscardBlockers(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { paths, targetWorktreePath } = msg.data || {};
+        if (!Array.isArray(paths) || paths.length === 0) {
+            ctx.send(ws, { type: 'gitMergeBlockersDiscarded', tabId, data: { success: false, error: 'No paths to discard' } });
+            return;
+        }
+        if (!paths.every(isSafeDiscardPath)) {
+            ctx.send(ws, { type: 'gitMergeBlockersDiscarded', tabId, data: { success: false, error: 'Invalid path in discard list' } });
+            return;
+        }
+        const path = targetWorktreePath || (await resolveMainWorktreePath(workingDir));
+        const result = await discardMergeBlockers({ cwd: path, paths });
+        if (!result.ok) {
+            ctx.send(ws, {
+                type: 'gitMergeBlockersDiscarded',
+                tabId,
+                data: { success: false, error: result.error, targetWorktreePath: path },
+            });
+            return;
+        }
+        ctx.send(ws, { type: 'gitMergeBlockersDiscarded', tabId, data: { success: true, targetWorktreePath: path, paths } });
+        handleGitStatus(ctx, ws, tabId, path);
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+function mergeResolutionTarget(msg) {
+    const { targetWorktreePath } = msg.data || {};
+    return typeof targetWorktreePath === 'string' && targetWorktreePath.length > 0 ? targetWorktreePath : undefined;
+}
+async function handleGitMergeAbort(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const result = await abortMerge({ cwd: workingDir, targetWorktreePath: mergeResolutionTarget(msg) });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitMergeAborted', tabId, data: { aborted: true } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitMergeComplete(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const result = await completeMerge({ cwd: workingDir, targetWorktreePath: mergeResolutionTarget(msg) });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitMergeCompleted', tabId, data: { success: true, mergeCommit: result.value.mergeCommit } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}

package/dist/server/services/websocket/handler-context.js

@@ -0,0 +1,113 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+function redirectThroughRepoWorktrees(map, base) {
+    if (!map)
+        return undefined;
+    let longestRoot;
+    for (const root of Object.keys(map)) {
+        if (base !== root && !base.startsWith(`${root}/`))
+            continue;
+        if (!longestRoot || root.length > longestRoot.length)
+            longestRoot = root;
+    }
+    return longestRoot === undefined ? undefined : map[longestRoot].worktreePath + base.slice(longestRoot.length);
+}
+export function resolveScopeDir(ctx, scopeId, workingDir) {
+    const scope = ctx.gitScopes.get(scopeId);
+    if (scope?.worktreePath)
+        return scope.worktreePath;
+    const base = scope?.repoPath ?? workingDir;
+    return redirectThroughRepoWorktrees(scope?.repoWorktrees, base) ?? base;
+}
+export function scopeExecutionDir(ctx, scopeId, workingDir) {
+    const scope = ctx.gitScopes.get(scopeId);
+    if (scope?.worktreePath)
+        return scope.worktreePath;
+    if (scope?.repoPath)
+        return redirectThroughRepoWorktrees(scope.repoWorktrees, scope.repoPath) ?? scope.repoPath;
+    if (workingDir === undefined)
+        return undefined;
+    return redirectThroughRepoWorktrees(scope?.repoWorktrees, workingDir);
+}
+export function scopeRepoWorktrees(ctx, scopeId) {
+    const map = ctx.gitScopes.get(scopeId)?.repoWorktrees;
+    if (!map)
+        return [];
+    return Object.entries(map)
+        .map(([repoRoot, entry]) => ({ repoRoot, worktreePath: entry.worktreePath, branch: entry.branch }))
+        .sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
+}
+export function setScopeRepoWorktree(ctx, scopeId, repoRoot, entry) {
+    const next = { ...ctx.gitScopes.get(scopeId)?.repoWorktrees };
+    if (entry)
+        next[repoRoot] = entry;
+    else
+        delete next[repoRoot];
+    mutateScope(ctx, scopeId, { repoWorktrees: next });
+}
+export function scopeWorktreePath(ctx, scopeId) {
+    return ctx.gitScopes.get(scopeId)?.worktreePath;
+}
+export function scopeRepoPath(ctx, scopeId) {
+    return ctx.gitScopes.get(scopeId)?.repoPath;
+}
+export function hasScopeBinding(ctx, scopeId) {
+    return ctx.gitScopes.has(scopeId);
+}
+function mutateScope(ctx, scopeId, patch) {
+    const next = { ...ctx.gitScopes.get(scopeId), ...patch };
+    if (!next.repoPath)
+        delete next.repoPath;
+    if (!next.worktreePath)
+        delete next.worktreePath;
+    if (next.repoWorktrees && Object.keys(next.repoWorktrees).length === 0)
+        delete next.repoWorktrees;
+    if (!next.repoPath && !next.worktreePath && !next.repoWorktrees)
+        ctx.gitScopes.delete(scopeId);
+    else
+        ctx.gitScopes.set(scopeId, next);
+    ctx.gitHeadWatcher?.retrack();
+}
+export function setScopeWorktree(ctx, scopeId, worktreePath) {
+    mutateScope(ctx, scopeId, { worktreePath: worktreePath ?? undefined });
+}
+export function setScopeRepo(ctx, scopeId, repoPath) {
+    mutateScope(ctx, scopeId, { repoPath: repoPath ?? undefined });
+}
+export function clearScope(ctx, scopeId) {
+    if (!ctx.gitScopes.delete(scopeId))
+        return;
+    ctx.gitHeadWatcher?.retrack();
+}
+export function trackedScopeDirs(ctx) {
+    const entries = [];
+    for (const [scopeId, scope] of ctx.gitScopes) {
+        const dir = scope.worktreePath ?? scope.repoPath;
+        if (dir)
+            entries.push([scopeId, dir]);
+    }
+    return entries;
+}
+export function trackedScopeRepoPaths(ctx) {
+    const roots = new Set();
+    for (const scope of ctx.gitScopes.values()) {
+        if (scope.repoPath)
+            roots.add(scope.repoPath);
+        if (scope.repoWorktrees) {
+            for (const repoRoot of Object.keys(scope.repoWorktrees))
+                roots.add(repoRoot);
+        }
+    }
+    return [...roots];
+}
+export function trackedRepoWorktreeEntries(ctx) {
+    const entries = [];
+    for (const [scopeId, scope] of ctx.gitScopes) {
+        if (!scope.repoWorktrees)
+            continue;
+        for (const [repoRoot, entry] of Object.entries(scope.repoWorktrees)) {
+            entries.push([scopeId, repoRoot, entry.worktreePath]);
+        }
+    }
+    return entries;
+}