@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/worktree-landing.js

@@ -1,56 +1,4 @@
-// The judgment shared by every path that lands a managed worktree onto its
-// base branch. These functions run no subprocesses and touch no filesystem:
-// they decide from Git output that the caller already has in hand.
-//
-// Two callers execute the same decision in two forms — `worktree.ts`'s
-// synchronous `close` (an API handler, already blocking) and
-// `worktree-sweep.ts`'s asynchronous daemon sweep (which must never block the
-// event loop). Only the process plumbing differs; the rules that decide whether
-// local work is at risk live here once, so the two can never drift.
-/** Split `git status --porcelain` (v1 format) into tracked modifications and
- *  untracked paths. A rename entry (`R  old -> new`) reports the destination:
- *  that is the path an incoming commit would collide with. */
-export function parseStatusPorcelain(porcelain) {
-    const tracked = [];
-    const untracked = [];
-    for (const line of porcelain.split('\n')) {
-        if (line.length < 4)
-            continue;
-        const code = line.slice(0, 2);
-        const rest = line.slice(3);
-        const path = rest.includes(' -> ') ? rest.slice(rest.indexOf(' -> ') + 4) : rest;
-        const unquoted = path.startsWith('"') && path.endsWith('"') ? path.slice(1, -1) : path;
-        if (code === '??')
-            untracked.push(unquoted);
-        else if (code !== '!!')
-            tracked.push(unquoted);
-    }
-    return { tracked, untracked };
-}
-/** How to fast-forward a base checkout that may hold local changes.
- *
- *  Git is less fragile than it looks here: a fast-forward refuses only when an
- *  incoming commit touches a file with local modifications, so DISJOINT local
- *  changes are carried along fine and need no stash at all. Overlap is the
- *  blocker, not dirt.
- *
- *  Untracked files are different. They also do not block a fast-forward unless
- *  an incoming commit adds the same path — and that collision is a refusal
- *  rather than a stash, because sweeping a person's untracked file into a stash
- *  to make room for a commit is not a trade this code may make on their behalf. */
-export function planLandIntoCheckout(status, incoming) {
-    const arriving = new Set(incoming);
-    const collisions = status.untracked.filter((path) => arriving.has(path));
-    if (collisions.length > 0)
-        return { kind: 'refuse', collisions };
-    const overlapping = status.tracked.filter((path) => arriving.has(path));
-    return overlapping.length > 0 ? { kind: 'stash', overlapping } : { kind: 'direct' };
-}
-/** The `git update-ref --stdin` body that deletes a managed branch ONLY while
- *  the ref that proved its content already landed is still at the exact SHA the
- *  proof inspected. Compare-and-delete is the whole ownership guard: a branch
- *  or base someone else moved between the proof and this transaction aborts it
- *  instead of losing the work. */
-export function refDeleteTransactionStdin(branch, branchSha, containingRef, containingSha) {
-    return `verify ${containingRef} ${containingSha}\ndelete refs/heads/${branch} ${branchSha}\n`;
-}
+var a=Object.defineProperty;var o=(e,n)=>a(e,"name",{value:n,configurable:!0});function u(e){const n=[],s=[];for(const t of e.split(`
+`)){if(t.length<4)continue;const r=t.slice(0,2),i=t.slice(3),c=i.includes(" -> ")?i.slice(i.indexOf(" -> ")+4):i,l=c.startsWith('"')&&c.endsWith('"')?c.slice(1,-1):c;r==="??"?s.push(l):r!=="!!"&&n.push(l)}return{tracked:n,untracked:s}}o(u,"parseStatusPorcelain");function f(e,n){const s=new Set(n),t=e.untracked.filter(i=>s.has(i));if(t.length>0)return{kind:"refuse",collisions:t};const r=e.tracked.filter(i=>s.has(i));return r.length>0?{kind:"stash",overlapping:r}:{kind:"direct"}}o(f,"planLandIntoCheckout");function h(e,n,s,t){return`verify ${s} ${t}
+delete refs/heads/${e} ${n}
+`}o(h,"refDeleteTransactionStdin");export{u as parseStatusPorcelain,f as planLandIntoCheckout,h as refDeleteTransactionStdin};

package/dist/core/worktree-mutation-async.js

@@ -1,280 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { abandonWorktreeAndRepoint, getNode } from './canvas/index.js';
-import { isPidAlive } from './canvas/pid.js';
-import { CONFIG_FILE, CRTR_DIR_NAME, STATE_FILE } from '../types.js';
-import { withExclusiveDirectoryLockAsync } from './exclusive-lock.js';
-import { gitAsync } from './git.js';
-import { WORKTREE_LOCK_WAIT_MS, checkoutPathForBranchInList, isManagedWorktreeBase, managedWorktreePath, persistClosedWorktreeState, worktreeLockPathForCommonDir, WorktreeError } from './worktree.js';
-import { proveBranchContained } from './worktree-containment.js';
-import { refDeleteTransactionStdin } from './worktree-landing.js';
-const LOCK_WAIT_MS = Math.min(WORKTREE_LOCK_WAIT_MS, 25_000);
-function detailOf(result) { return (result.stderr.trim() || result.stdout.trim()).trim(); }
-async function runGit(cwd, args, code, next) {
-    const result = await gitAsync(args, cwd);
-    if (result.status !== 0)
-        throw new WorktreeError(code, `git ${args.join(' ')} failed`, next, detailOf(result));
-    return result.stdout.trim();
-}
-async function commonGitDir(cwd) {
-    return realpathSync(resolve(cwd, await runGit(cwd, ['rev-parse', '--git-common-dir'], 'git_common_dir_failed', 'Inspect the repository git metadata, then retry.')));
-}
-async function withRepositoryLock(cwd, action) {
-    const commonDir = await commonGitDir(cwd);
-    return withExclusiveDirectoryLockAsync(worktreeLockPathForCommonDir(commonDir), action, {
-        timeoutMs: LOCK_WAIT_MS,
-        timeoutError: () => new WorktreeError('worktree_lock_timeout', `timed out waiting to create a managed worktree in ${commonDir}`, 'Wait for the other managed-worktree operation to finish, then retry.'),
-    });
-}
-async function resolveLandableBase(cwd, baseRef) {
-    const ref = `refs/heads/${baseRef}`;
-    const exists = await gitAsync(['show-ref', '--verify', '--quiet', ref], cwd);
-    if (exists.status === 1 && exists.executionFailed !== true)
-        throw new WorktreeError('missing_base_branch', `managed worktree base '${baseRef}' does not name an existing local branch`, 'The base must be a local branch that landing can fast-forward — freshen your local branch from origin first (rebase-not-merge), then base on it.');
-    if (exists.status !== 0)
-        throw new WorktreeError('base_branch_inspection_failed', `could not inspect local base branch '${baseRef}' (git show-ref exited with status ${exists.status})`, 'Inspect the repository and its Git metadata, then retry.', `status: ${exists.status}\nstderr: ${exists.stderr.trim() || '<empty>'}`);
-    return runGit(cwd, ['rev-parse', '--verify', ref], 'base_branch_resolve_failed', 'Inspect the local base branch, then retry.');
-}
-function seedExclude(repoRoot, commonDir) {
-    try {
-        const path = join(commonDir, 'info', 'exclude');
-        mkdirSync(dirname(path), { recursive: true });
-        let current = '';
-        try {
-            current = readFileSync(path, 'utf8');
-        }
-        catch { /* first write */ }
-        const patterns = [`/${CRTR_DIR_NAME}/${CONFIG_FILE}`, `/${CRTR_DIR_NAME}/${STATE_FILE}`];
-        if (patterns.every((pattern) => current.split('\n').map((line) => line.trim()).includes(pattern)))
-            return;
-        writeFileSync(path, `${current}${current !== '' && !current.endsWith('\n') ? '\n' : ''}# crtr: exclude crtr's own untracked project-scope bookkeeping (auto-added at managed-worktree creation)\n${patterns.filter((pattern) => !current.split('\n').map((line) => line.trim()).includes(pattern)).join('\n')}\n`);
-    }
-    catch { /* cosmetic only */ }
-}
-export async function rollbackManagedWorktreeAsync(wt) {
-    await withRepositoryLock(wt.repo_root, async () => {
-        const branch = await gitAsync(['rev-parse', '--verify', `refs/heads/${wt.branch}`], wt.repo_root);
-        if (branch.status !== 0 || branch.stdout.trim() !== wt.base_sha)
-            return;
-        const list = await gitAsync(['worktree', 'list', '--porcelain'], wt.repo_root);
-        if (list.status !== 0)
-            return;
-        if (list.stdout.split('\n').some((line) => line.trim() === `branch refs/heads/${wt.branch}`)) {
-            if ((await gitAsync(['worktree', 'remove', '--force', wt.path], wt.repo_root)).status !== 0)
-                return;
-        }
-        else if (existsSync(wt.path)) {
-            try {
-                rmSync(wt.path, { recursive: true, force: true });
-            }
-            catch {
-                return;
-            }
-        }
-        await gitAsync(['update-ref', '-d', `refs/heads/${wt.branch}`, wt.base_sha], wt.repo_root);
-    });
-}
-export async function createManagedWorktreeAsync(cwd, nodeId, baseRef = 'main') {
-    const repoRoot = await runGit(cwd, ['rev-parse', '--show-toplevel'], 'not_git_repo', 'Pass --cwd <real repo> pointing inside a git repository.');
-    if (isManagedWorktreeBase(repoRoot)) {
-        throw new WorktreeError('managed_worktree_base', `cwd ${repoRoot} is a managed worktree and cannot be used as a managed worktree base`, 'Pass --cwd <real repo> pointing at the repository’s primary checkout.');
-    }
-    const commonDir = await commonGitDir(repoRoot);
-    return withExclusiveDirectoryLockAsync(worktreeLockPathForCommonDir(commonDir), async () => {
-        const baseSha = await resolveLandableBase(repoRoot, baseRef);
-        const path = managedWorktreePath(nodeId);
-        const branch = `crtr/${nodeId}`;
-        if (existsSync(path))
-            throw new WorktreeError('worktree_path_exists', `managed worktree path already exists: ${path}`, 'Remove the stale path or choose a fresh node id.');
-        if ((await gitAsync(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], repoRoot)).status === 0)
-            throw new WorktreeError('worktree_branch_exists', `managed worktree branch already exists: ${branch}`, 'Remove the stale branch or choose a fresh node id.');
-        const wt = { state: 'open', path, branch, repo_root: repoRoot, base_ref: baseRef, base_sha: baseSha, created: new Date().toISOString() };
-        await runGit(repoRoot, ['branch', branch, baseSha], 'worktree_branch_create_failed', 'Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.');
-        const added = await gitAsync(['worktree', 'add', path, branch], repoRoot);
-        if (added.status !== 0) {
-            await gitAsync(['update-ref', '-d', `refs/heads/${branch}`, baseSha], repoRoot);
-            throw new WorktreeError('worktree_add_failed', 'git worktree add failed', 'Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.', detailOf(added));
-        }
-        seedExclude(repoRoot, commonDir);
-        return wt;
-    }, { timeoutMs: LOCK_WAIT_MS, timeoutError: () => new WorktreeError('worktree_lock_timeout', `timed out waiting to create a managed worktree in ${commonDir}`, 'Wait for the other managed-worktree operation to finish, then retry.') });
-}
-async function cleanTip(wt) {
-    if (wt.state !== 'open' || !existsSync(wt.path))
-        return null;
-    const branch = await gitAsync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path);
-    const status = await gitAsync(['status', '--porcelain'], wt.path);
-    const head = await gitAsync(['rev-parse', 'HEAD'], wt.path);
-    if (branch.status !== 0 || branch.stdout.trim() !== wt.branch || status.status !== 0 || status.stdout.trim() !== '' || head.status !== 0)
-        return null;
-    const gitPath = await gitAsync(['rev-parse', '--git-path', 'rebase-merge'], wt.path);
-    if (gitPath.status !== 0 || existsSync(gitPath.stdout.trim()))
-        return null;
-    return head.stdout.trim();
-}
-async function containedInLocalBase(wt, head) {
-    try {
-        const base = await resolveLandableBase(wt.path, wt.base_ref);
-        return (await gitAsync(['merge-base', '--is-ancestor', head, base], wt.path)).status === 0;
-    }
-    catch (error) {
-        if (error instanceof WorktreeError && error.code === 'missing_base_branch' && head === wt.base_sha)
-            return true;
-        throw error;
-    }
-}
-function deferred(wt) {
-    return { node_id: '', branch: wt.branch, worktree_path: wt.path, worktree_removed: false, worktree_remove_error: `cleanup pending: the caller checkout at ${wt.path} remains intact.`, branch_deleted: false, branch_delete_error: `cleanup pending: local branch ${wt.branch} remains checked out at ${wt.path}.` };
-}
-/** A missing checkout can be concluded only when its branch is already gone,
- * or the recorded base or its upstream contains the branch and it has no other
- * checkout. */
-async function proveAbsentPathManagedWorktree(wt) {
-    if (wt.state !== 'open' || existsSync(wt.path))
-        return null;
-    const branchRef = `refs/heads/${wt.branch}`;
-    const branchExists = await gitAsync(['show-ref', '--verify', '--quiet', branchRef], wt.repo_root);
-    if (branchExists.status === 1 && branchExists.executionFailed !== true)
-        return { branchSha: null };
-    if (branchExists.status !== 0)
-        return null;
-    const branch = await gitAsync(['rev-parse', '--verify', branchRef], wt.repo_root);
-    if (branch.status !== 0)
-        return null;
-    const branchSha = branch.stdout.trim();
-    const worktreeList = await gitAsync(['worktree', 'list', '--porcelain'], wt.repo_root);
-    if (worktreeList.status !== 0 || checkoutPathForBranchInList(worktreeList.stdout, wt.branch) !== null)
-        return null;
-    const containment = await proveBranchContained(wt.repo_root, wt, branchSha);
-    return containment === null ? null : { branchSha, containment };
-}
-async function autoDropAbsentPathManagedWorktreeLocked(nodeId, wt, proof) {
-    if (existsSync(wt.path))
-        return null;
-    if (proof.branchSha === null) {
-        persistClosedWorktreeState(nodeId, wt, 'complete');
-        return { node_id: nodeId, branch: wt.branch, worktree_path: wt.path, worktree_removed: true, branch_deleted: true };
-    }
-    if (proof.containment === undefined)
-        return null;
-    // `update-ref` bypasses Git's checked-out-branch protection. A person can
-    // add a worktree after the list above, so the delivered branch stays intact:
-    // its containment proof concludes this node without risking that checkout.
-    persistClosedWorktreeState(nodeId, wt, 'complete');
-    return { node_id: nodeId, branch: wt.branch, worktree_path: wt.path, worktree_removed: true, branch_deleted: false, branch_delete_error: `local branch ${wt.branch} is delivered but retained because its checkout status can change outside crtr's repository lock.` };
-}
-/** Conclude an absent checkout only from the same branch-delivery proof used by
- * push-final and explicit close. */
-export async function concludeAbsentManagedWorktreeAsync(nodeId) {
-    const wt = getNode(nodeId)?.managed_worktree;
-    if (wt === undefined || wt === null || wt.state !== 'open' || existsSync(wt.path))
-        return null;
-    if (await proveAbsentPathManagedWorktree(wt) === null)
-        return null;
-    return withRepositoryLock(wt.repo_root, async () => {
-        const locked = getNode(nodeId)?.managed_worktree;
-        if (locked === undefined || locked === null || locked.state !== 'open')
-            return null;
-        const proof = await proveAbsentPathManagedWorktree(locked);
-        if (proof === null)
-            return null;
-        const dropped = await autoDropAbsentPathManagedWorktreeLocked(nodeId, locked, proof);
-        return dropped === null ? null : { dropped, landedSha: proof.branchSha ?? locked.base_sha };
-    });
-}
-export async function autoDropCleanManagedWorktreeAsync(nodeId) {
-    const wt = getNode(nodeId)?.managed_worktree;
-    if (wt === undefined || wt === null || wt.state !== 'open')
-        return null;
-    if (!existsSync(wt.path))
-        return (await concludeAbsentManagedWorktreeAsync(nodeId))?.dropped ?? null;
-    const initial = await cleanTip(wt);
-    if (initial === null || !(await containedInLocalBase(wt, initial)))
-        return null;
-    return withRepositoryLock(wt.path, async () => {
-        const locked = getNode(nodeId)?.managed_worktree;
-        if (locked === undefined || locked === null || locked.state !== 'open')
-            return null;
-        const head = await cleanTip(locked);
-        if (head === null || head !== initial || !(await containedInLocalBase(locked, head)))
-            return null;
-        persistClosedWorktreeState(nodeId, locked, 'pending');
-        return { ...deferred(locked), node_id: nodeId };
-    });
-}
-async function rebaseInProgress(cwd) {
-    for (const path of ['rebase-merge', 'rebase-apply']) {
-        const result = await gitAsync(['rev-parse', '--git-path', path], cwd);
-        if (result.status !== 0 || existsSync(result.stdout.trim()))
-            return true;
-    }
-    return false;
-}
-function persistAbandoned(nodeId, wt, tip, at, by, branch = wt.branch) {
-    abandonWorktreeAndRepoint(nodeId, { cwd: wt.repo_root, abandoned: { branch, tip_sha: tip, at, by } });
-}
-export async function abandonManagedWorktreeAsync(nodeId, by) {
-    const wt = getNode(nodeId)?.managed_worktree;
-    if (wt === undefined || wt === null || wt.state !== 'open')
-        throw new WorktreeError('no_managed_worktree', `node ${nodeId} has no open managed worktree`, 'Nothing to abandon for this node.');
-    return withRepositoryLock(wt.path, async () => {
-        const node = getNode(nodeId);
-        const current = node?.managed_worktree;
-        if (node === null || current === undefined || current === null || current.state !== 'open')
-            throw new WorktreeError('no_managed_worktree', `node ${nodeId} has no open managed worktree`, 'Nothing to abandon for this node.');
-        if (node.status === 'active' || node.status === 'idle' || isPidAlive(node.pi_pid))
-            throw new WorktreeError('node_running', `node ${nodeId} is still running`, 'Stop the node before abandoning its managed worktree.');
-        if (!existsSync(current.path))
-            throw new WorktreeError('worktree_missing', `managed worktree path is missing: ${current.path}`, 'Inspect the branch and worktree registration, then retry.');
-        const branch = await runGit(current.path, ['rev-parse', '--abbrev-ref', 'HEAD'], 'branch_check_failed', 'Inspect the worktree manually, then retry.');
-        const recorded = await gitAsync(['show-ref', '--verify', '--quiet', `refs/heads/${current.branch}`], current.path);
-        if (branch !== current.branch) {
-            if (recorded.status === 0 || branch === 'HEAD')
-                throw new WorktreeError('wrong_branch', `managed worktree is not on its recorded branch (expected ${current.branch}, found ${branch === 'HEAD' ? 'detached HEAD' : branch})`, `Inspect ${current.path}, then rerun \`crtr node worktree abandon\`.`);
-            if (await rebaseInProgress(current.path) || (await runGit(current.path, ['status', '--porcelain'], 'status_failed', 'Inspect the worktree manually, then retry.')) !== '')
-                throw new WorktreeError('dirty_worktree', 'managed worktree has uncommitted changes', `Commit or stash them in ${current.path}, then rerun \`crtr node worktree abandon\`.`);
-            const tip = await runGit(current.path, ['rev-parse', 'HEAD'], 'abandon_tip_failed', 'Inspect the worktree manually, then retry.');
-            await runGit(current.repo_root, ['worktree', 'remove', current.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-            const at = new Date().toISOString();
-            persistAbandoned(nodeId, current, tip, at, by, branch);
-            return { node_id: nodeId, branch, tip_sha: tip, worktree_path: current.path, branch_deleted: false };
-        }
-        const head = await runGit(current.path, ['rev-parse', 'HEAD'], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-        let cleanBase = null;
-        try {
-            const base = await resolveLandableBase(current.path, current.base_ref);
-            if ((await gitAsync(['merge-base', '--is-ancestor', head, base], current.path)).status === 0)
-                cleanBase = base;
-        }
-        catch (error) {
-            if (!(error instanceof WorktreeError) || error.code !== 'missing_base_branch')
-                throw error;
-        }
-        const at = new Date().toISOString();
-        const status = await runGit(current.path, ['status', '--porcelain'], 'status_failed', 'Inspect the worktree manually, then retry.');
-        if (cleanBase !== null && head === current.base_sha) {
-            const tree = await runGit(current.repo_root, ['rev-parse', `${head}^{tree}`], 'abandon_tree_failed', 'Inspect the branch manually, then retry.');
-            const marker = await runGit(current.repo_root, ['-c', 'user.name=crtr-abandon', '-c', 'user.email=crtr-abandon@localhost', 'commit-tree', tree, '-p', head, '-m', 'crtr-abandon', '-m', `Crtr-Abandon: ${nodeId} ${at}`], 'abandon_commit_failed', 'Inspect the branch manually, then retry.');
-            await runGit(current.repo_root, ['update-ref', `refs/heads/${current.branch}`, marker, head], 'abandon_marker_failed', 'The branch changed while abandon was starting; inspect the worktree, then retry.');
-            await runGit(current.repo_root, ['worktree', 'remove', current.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-            const deleted = await gitAsync(['update-ref', '--stdin'], current.repo_root, refDeleteTransactionStdin(current.branch, marker, `refs/heads/${current.base_ref}`, cleanBase));
-            if (deleted.status === 0) {
-                persistClosedWorktreeState(nodeId, current, 'complete');
-                return { node_id: nodeId, branch: current.branch, tip_sha: marker, worktree_path: current.path, branch_deleted: true };
-            }
-            persistAbandoned(nodeId, current, marker, at, by);
-            return { node_id: nodeId, branch: current.branch, tip_sha: marker, worktree_path: current.path, branch_deleted: false };
-        }
-        if (!await rebaseInProgress(current.path) && status === '') {
-            await runGit(current.repo_root, ['worktree', 'remove', current.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-            persistAbandoned(nodeId, current, head, at, by);
-            return { node_id: nodeId, branch: current.branch, tip_sha: head, worktree_path: current.path, branch_deleted: false };
-        }
-        await runGit(current.path, ['add', '--all'], 'abandon_stage_failed', 'Inspect the worktree manually, then retry.');
-        await runGit(current.path, ['-c', 'user.name=crtr-abandon', '-c', 'user.email=crtr-abandon@localhost', 'commit', '--allow-empty', '-m', 'crtr-abandon', '-m', `Crtr-Abandon: ${nodeId} ${at}`], 'abandon_commit_failed', 'Inspect the worktree manually, then retry.');
-        const tip = await runGit(current.path, ['rev-parse', 'HEAD'], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-        await runGit(current.repo_root, ['worktree', 'remove', current.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-        persistAbandoned(nodeId, current, tip, at, by);
-        return { node_id: nodeId, branch: current.branch, tip_sha: tip, worktree_path: current.path, branch_deleted: false };
-    });
-}
+var T=Object.defineProperty;var o=(e,r)=>T(e,"name",{value:r,configurable:!0});import{existsSync as p,mkdirSync as F,readFileSync as H,realpathSync as R,rmSync as O,writeFileSync as I}from"node:fs";import{dirname as B,join as N,resolve as j}from"node:path";import{abandonWorktreeAndRepoint as q,getNode as _}from"./canvas/index.js";import{isPidAlive as G}from"./canvas/pid.js";import{CONFIG_FILE as K,CRTR_DIR_NAME as $,STATE_FILE as z}from"../types.js";import{withExclusiveDirectoryLockAsync as A}from"./exclusive-lock.js";import{gitAsync as s}from"./git.js";import{WORKTREE_LOCK_WAIT_MS as J,checkoutPathForBranchInList as Q,isManagedWorktreeBase as U,managedWorktreePath as V,persistClosedWorktreeState as b,worktreeLockPathForCommonDir as S,WorktreeError as h}from"./worktree.js";import{proveBranchContained as X}from"./worktree-containment.js";import{refDeleteTransactionStdin as Y}from"./worktree-landing.js";const x=Math.min(J,25e3);function D(e){return(e.stderr.trim()||e.stdout.trim()).trim()}o(D,"detailOf");async function c(e,r,a,n){const t=await s(r,e);if(t.status!==0)throw new h(a,`git ${r.join(" ")} failed`,n,D(t));return t.stdout.trim()}o(c,"runGit");async function E(e){return R(j(e,await c(e,["rev-parse","--git-common-dir"],"git_common_dir_failed","Inspect the repository git metadata, then retry.")))}o(E,"commonGitDir");async function k(e,r){const a=await E(e);return A(S(a),r,{timeoutMs:x,timeoutError:o(()=>new h("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${a}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}o(k,"withRepositoryLock");async function g(e,r){const a=`refs/heads/${r}`,n=await s(["show-ref","--verify","--quiet",a],e);if(n.status===1&&n.executionFailed!==!0)throw new h("missing_base_branch",`managed worktree base '${r}' does not name an existing local branch`,"The base must be a local branch that landing can fast-forward \u2014 freshen your local branch from origin first (rebase-not-merge), then base on it.");if(n.status!==0)throw new h("base_branch_inspection_failed",`could not inspect local base branch '${r}' (git show-ref exited with status ${n.status})`,"Inspect the repository and its Git metadata, then retry.",`status: ${n.status}
+stderr: ${n.stderr.trim()||"<empty>"}`);return c(e,["rev-parse","--verify",a],"base_branch_resolve_failed","Inspect the local base branch, then retry.")}o(g,"resolveLandableBase");function Z(e,r){try{const a=N(r,"info","exclude");F(B(a),{recursive:!0});let n="";try{n=H(a,"utf8")}catch{}const t=[`/${$}/${K}`,`/${$}/${z}`];if(t.every(i=>n.split(`
+`).map(l=>l.trim()).includes(i)))return;I(a,`${n}${n!==""&&!n.endsWith(`
+`)?`
+`:""}# crtr: exclude crtr's own untracked project-scope bookkeeping (auto-added at managed-worktree creation)
+${t.filter(i=>!n.split(`
+`).map(l=>l.trim()).includes(i)).join(`
+`)}
+`)}catch{}}o(Z,"seedExclude");async function me(e){await k(e.repo_root,async()=>{const r=await s(["rev-parse","--verify",`refs/heads/${e.branch}`],e.repo_root);if(r.status!==0||r.stdout.trim()!==e.base_sha)return;const a=await s(["worktree","list","--porcelain"],e.repo_root);if(a.status===0){if(a.stdout.split(`
+`).some(n=>n.trim()===`branch refs/heads/${e.branch}`)){if((await s(["worktree","remove","--force",e.path],e.repo_root)).status!==0)return}else if(p(e.path))try{O(e.path,{recursive:!0,force:!0})}catch{return}await s(["update-ref","-d",`refs/heads/${e.branch}`,e.base_sha],e.repo_root)}})}o(me,"rollbackManagedWorktreeAsync");async function _e(e,r,a="main"){const n=await c(e,["rev-parse","--show-toplevel"],"not_git_repo","Pass --cwd <real repo> pointing inside a git repository.");if(U(n))throw new h("managed_worktree_base",`cwd ${n} is a managed worktree and cannot be used as a managed worktree base`,"Pass --cwd <real repo> pointing at the repository\u2019s primary checkout.");const t=await E(n);return A(S(t),async()=>{const i=await g(n,a),l=V(r),u=`crtr/${r}`;if(p(l))throw new h("worktree_path_exists",`managed worktree path already exists: ${l}`,"Remove the stale path or choose a fresh node id.");if((await s(["show-ref","--verify","--quiet",`refs/heads/${u}`],n)).status===0)throw new h("worktree_branch_exists",`managed worktree branch already exists: ${u}`,"Remove the stale branch or choose a fresh node id.");const w={state:"open",path:l,branch:u,repo_root:n,base_ref:a,base_sha:i,created:new Date().toISOString()};await c(n,["branch",u,i],"worktree_branch_create_failed","Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.");const f=await s(["worktree","add",l,u],n);if(f.status!==0)throw await s(["update-ref","-d",`refs/heads/${u}`,i],n),new h("worktree_add_failed","git worktree add failed","Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.",D(f));return Z(n,t),w},{timeoutMs:x,timeoutError:o(()=>new h("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${t}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}o(_e,"createManagedWorktreeAsync");async function W(e){if(e.state!=="open"||!p(e.path))return null;const r=await s(["rev-parse","--abbrev-ref","HEAD"],e.path),a=await s(["status","--porcelain"],e.path),n=await s(["rev-parse","HEAD"],e.path);if(r.status!==0||r.stdout.trim()!==e.branch||a.status!==0||a.stdout.trim()!==""||n.status!==0)return null;const t=await s(["rev-parse","--git-path","rebase-merge"],e.path);return t.status!==0||p(t.stdout.trim())?null:n.stdout.trim()}o(W,"cleanTip");async function M(e,r){try{const a=await g(e.path,e.base_ref);return(await s(["merge-base","--is-ancestor",r,a],e.path)).status===0}catch(a){if(a instanceof h&&a.code==="missing_base_branch"&&r===e.base_sha)return!0;throw a}}o(M,"containedInLocalBase");function ee(e){return{node_id:"",branch:e.branch,worktree_path:e.path,worktree_removed:!1,worktree_remove_error:`cleanup pending: the caller checkout at ${e.path} remains intact.`,branch_deleted:!1,branch_delete_error:`cleanup pending: local branch ${e.branch} remains checked out at ${e.path}.`}}o(ee,"deferred");async function L(e){if(e.state!=="open"||p(e.path))return null;const r=`refs/heads/${e.branch}`,a=await s(["show-ref","--verify","--quiet",r],e.repo_root);if(a.status===1&&a.executionFailed!==!0)return{branchSha:null};if(a.status!==0)return null;const n=await s(["rev-parse","--verify",r],e.repo_root);if(n.status!==0)return null;const t=n.stdout.trim(),i=await s(["worktree","list","--porcelain"],e.repo_root);if(i.status!==0||Q(i.stdout,e.branch)!==null)return null;const l=await X(e.repo_root,e,t);return l===null?null:{branchSha:t,containment:l}}o(L,"proveAbsentPathManagedWorktree");async function te(e,r,a){return p(r.path)?null:a.branchSha===null?(b(e,r,"complete"),{node_id:e,branch:r.branch,worktree_path:r.path,worktree_removed:!0,branch_deleted:!0}):a.containment===void 0?null:(b(e,r,"complete"),{node_id:e,branch:r.branch,worktree_path:r.path,worktree_removed:!0,branch_deleted:!1,branch_delete_error:`local branch ${r.branch} is delivered but retained because its checkout status can change outside crtr's repository lock.`})}o(te,"autoDropAbsentPathManagedWorktreeLocked");async function re(e){const r=_(e)?.managed_worktree;return r==null||r.state!=="open"||p(r.path)||await L(r)===null?null:k(r.repo_root,async()=>{const a=_(e)?.managed_worktree;if(a==null||a.state!=="open")return null;const n=await L(a);if(n===null)return null;const t=await te(e,a,n);return t===null?null:{dropped:t,landedSha:n.branchSha??a.base_sha}})}o(re,"concludeAbsentManagedWorktreeAsync");async function we(e){const r=_(e)?.managed_worktree;if(r==null||r.state!=="open")return null;if(!p(r.path))return(await re(e))?.dropped??null;const a=await W(r);return a===null||!await M(r,a)?null:k(r.path,async()=>{const n=_(e)?.managed_worktree;if(n==null||n.state!=="open")return null;const t=await W(n);return t===null||t!==a||!await M(n,t)?null:(b(e,n,"pending"),{...ee(n),node_id:e})})}o(we,"autoDropCleanManagedWorktreeAsync");async function C(e){for(const r of["rebase-merge","rebase-apply"]){const a=await s(["rev-parse","--git-path",r],e);if(a.status!==0||p(a.stdout.trim()))return!0}return!1}o(C,"rebaseInProgress");function y(e,r,a,n,t,i=r.branch){q(e,{cwd:r.repo_root,abandoned:{branch:i,tip_sha:a,at:n,by:t}})}o(y,"persistAbandoned");async function be(e,r){const a=_(e)?.managed_worktree;if(a==null||a.state!=="open")throw new h("no_managed_worktree",`node ${e} has no open managed worktree`,"Nothing to abandon for this node.");return k(a.path,async()=>{const n=_(e),t=n?.managed_worktree;if(n===null||t===void 0||t===null||t.state!=="open")throw new h("no_managed_worktree",`node ${e} has no open managed worktree`,"Nothing to abandon for this node.");if(n.status==="active"||n.status==="idle"||G(n.pi_pid))throw new h("node_running",`node ${e} is still running`,"Stop the node before abandoning its managed worktree.");if(!p(t.path))throw new h("worktree_missing",`managed worktree path is missing: ${t.path}`,"Inspect the branch and worktree registration, then retry.");const i=await c(t.path,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry."),l=await s(["show-ref","--verify","--quiet",`refs/heads/${t.branch}`],t.path);if(i!==t.branch){if(l.status===0||i==="HEAD")throw new h("wrong_branch",`managed worktree is not on its recorded branch (expected ${t.branch}, found ${i==="HEAD"?"detached HEAD":i})`,`Inspect ${t.path}, then rerun \`crtr node worktree abandon\`.`);if(await C(t.path)||await c(t.path,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.")!=="")throw new h("dirty_worktree","managed worktree has uncommitted changes",`Commit or stash them in ${t.path}, then rerun \`crtr node worktree abandon\`.`);const d=await c(t.path,["rev-parse","HEAD"],"abandon_tip_failed","Inspect the worktree manually, then retry.");await c(t.repo_root,["worktree","remove",t.path],"worktree_remove_failed","Inspect the worktree manually, then retry.");const m=new Date().toISOString();return y(e,t,d,m,r,i),{node_id:e,branch:i,tip_sha:d,worktree_path:t.path,branch_deleted:!1}}const u=await c(t.path,["rev-parse","HEAD"],"abandon_tip_failed","Inspect the branch manually, then retry.");let w=null;try{const d=await g(t.path,t.base_ref);(await s(["merge-base","--is-ancestor",u,d],t.path)).status===0&&(w=d)}catch(d){if(!(d instanceof h)||d.code!=="missing_base_branch")throw d}const f=new Date().toISOString(),P=await c(t.path,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.");if(w!==null&&u===t.base_sha){const d=await c(t.repo_root,["rev-parse",`${u}^{tree}`],"abandon_tree_failed","Inspect the branch manually, then retry."),m=await c(t.repo_root,["-c","user.name=crtr-abandon","-c","user.email=crtr-abandon@localhost","commit-tree",d,"-p",u,"-m","crtr-abandon","-m",`Crtr-Abandon: ${e} ${f}`],"abandon_commit_failed","Inspect the branch manually, then retry.");return await c(t.repo_root,["update-ref",`refs/heads/${t.branch}`,m,u],"abandon_marker_failed","The branch changed while abandon was starting; inspect the worktree, then retry."),await c(t.repo_root,["worktree","remove",t.path],"worktree_remove_failed","Inspect the worktree manually, then retry."),(await s(["update-ref","--stdin"],t.repo_root,Y(t.branch,m,`refs/heads/${t.base_ref}`,w))).status===0?(b(e,t,"complete"),{node_id:e,branch:t.branch,tip_sha:m,worktree_path:t.path,branch_deleted:!0}):(y(e,t,m,f,r),{node_id:e,branch:t.branch,tip_sha:m,worktree_path:t.path,branch_deleted:!1})}if(!await C(t.path)&&P==="")return await c(t.repo_root,["worktree","remove",t.path],"worktree_remove_failed","Inspect the worktree manually, then retry."),y(e,t,u,f,r),{node_id:e,branch:t.branch,tip_sha:u,worktree_path:t.path,branch_deleted:!1};await c(t.path,["add","--all"],"abandon_stage_failed","Inspect the worktree manually, then retry."),await c(t.path,["-c","user.name=crtr-abandon","-c","user.email=crtr-abandon@localhost","commit","--allow-empty","-m","crtr-abandon","-m",`Crtr-Abandon: ${e} ${f}`],"abandon_commit_failed","Inspect the worktree manually, then retry.");const v=await c(t.path,["rev-parse","HEAD"],"abandon_tip_failed","Inspect the branch manually, then retry.");return await c(t.repo_root,["worktree","remove",t.path],"worktree_remove_failed","Inspect the worktree manually, then retry."),y(e,t,v,f,r),{node_id:e,branch:t.branch,tip_sha:v,worktree_path:t.path,branch_deleted:!1}})}o(be,"abandonManagedWorktreeAsync");export{be as abandonManagedWorktreeAsync,we as autoDropCleanManagedWorktreeAsync,re as concludeAbsentManagedWorktreeAsync,_e as createManagedWorktreeAsync,me as rollbackManagedWorktreeAsync};

package/dist/core/worktree-quarantine.js

@@ -1,54 +1 @@
-// Read-only inventory of managed worktrees the daemon sweep could not
-// reconcile. Its whole purpose is turning an invisible accumulation into a
-// short, explained list a human can act on, so it reports the recorded refusal
-// reason alongside the resources still held: the checkout path, its branch, and
-// what that checkout costs on disk.
-//
-// Nothing here mutates. Disposal belongs to the sweep
-// (`worktree-sweep.ts`), which is the one authority for removing a checkout.
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { getNode, listNodes } from './canvas/index.js';
-/** Disk usage of one directory in bytes, or null when it cannot be measured.
- *  `du` is spawned asynchronously: a managed checkout can be tens of gigabytes,
- *  and this runs inside the daemon, which must never block its event loop. */
-async function directorySizeBytes(path) {
-    if (!existsSync(path))
-        return null;
-    return new Promise((resolve) => {
-        const child = spawn('du', ['-sk', path]);
-        let stdout = '';
-        child.stdout.on('data', (d) => (stdout += d.toString()));
-        child.stderr.on('data', () => { });
-        child.on('error', () => resolve(null));
-        child.on('close', (status) => {
-            if (status !== 0)
-                return resolve(null);
-            const kb = Number(stdout.trim().split(/\s+/)[0]);
-            resolve(Number.isSafeInteger(kb) ? kb * 1024 : null);
-        });
-    });
-}
-/** Every managed worktree the sweep has flagged as needing attention, oldest
- *  refusal first. Reads node records only — a checkout crtr did not create has
- *  no node record and is never reported. */
-export async function listQuarantinedManagedWorktrees() {
-    const found = [];
-    for (const row of listNodes()) {
-        const wt = getNode(row.node_id)?.managed_worktree;
-        if (wt?.sweep?.quarantined !== true)
-            continue;
-        found.push({
-            node_id: row.node_id,
-            path: wt.path,
-            branch: wt.branch,
-            repo_root: wt.repo_root,
-            reason: wt.sweep.reason,
-            ...(wt.sweep.detail === undefined ? {} : { detail: wt.sweep.detail }),
-            attempts: wt.sweep.attempts,
-            last_attempt: wt.sweep.last_attempt,
-        });
-    }
-    found.sort((a, b) => a.last_attempt.localeCompare(b.last_attempt));
-    return Promise.all(found.map(async (entry) => ({ ...entry, size_bytes: await directorySizeBytes(entry.path) })));
-}
+var i=Object.defineProperty;var r=(o,e)=>i(o,"name",{value:e,configurable:!0});import{spawn as d}from"node:child_process";import{existsSync as p}from"node:fs";import{getNode as l,listNodes as u}from"./canvas/index.js";async function m(o){return p(o)?new Promise(e=>{const t=d("du",["-sk",o]);let a="";t.stdout.on("data",n=>a+=n.toString()),t.stderr.on("data",()=>{}),t.on("error",()=>e(null)),t.on("close",n=>{if(n!==0)return e(null);const s=Number(a.trim().split(/\s+/)[0]);e(Number.isSafeInteger(s)?s*1024:null)})}):null}r(m,"directorySizeBytes");async function b(){const o=[];for(const e of u()){const t=l(e.node_id)?.managed_worktree;t?.sweep?.quarantined===!0&&o.push({node_id:e.node_id,path:t.path,branch:t.branch,repo_root:t.repo_root,reason:t.sweep.reason,...t.sweep.detail===void 0?{}:{detail:t.sweep.detail},attempts:t.sweep.attempts,last_attempt:t.sweep.last_attempt})}return o.sort((e,t)=>e.last_attempt.localeCompare(t.last_attempt)),Promise.all(o.map(async e=>({...e,size_bytes:await m(e.path)})))}r(b,"listQuarantinedManagedWorktrees");export{b as listQuarantinedManagedWorktrees};