@getpaseo/server 0.1.59 → 0.1.61

package/dist/server/utils/worktree.js

@@ -1,20 +1,26 @@
-import { exec } from "child_process";
+import { execFile, spawn } from "child_process";
 import { promisify } from "util";
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync } from "fs";
+import { rm, stat } from "fs/promises";
 import { join, basename, dirname, resolve, sep } from "path";
 import net from "node:net";
 import { createHash } from "node:crypto";
-import { createNameId } from "mnemonic-id";
+import * as pty from "node-pty";
+import stripAnsi from "strip-ansi";
+import { buildStringCommandShellInvocation } from "./string-command-shell.js";
 import { normalizeBaseRefName, readPaseoWorktreeMetadata, readPaseoWorktreeRuntimePort, writePaseoWorktreeMetadata, writePaseoWorktreeRuntimeMetadata, } from "./worktree-metadata.js";
 import { runGitCommand } from "./run-git-command.js";
-import { platformBash, spawnProcess } from "./spawn.js";
 import { resolvePaseoHome } from "../server/paseo-home.js";
+import { ensureNodePtySpawnHelperExecutableForCurrentPlatform } from "../terminal/terminal.js";
 import { parseGitRevParsePath, resolveGitRevParsePath } from "./git-rev-parse-path.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 const READ_ONLY_GIT_ENV = {
     ...process.env,
     GIT_OPTIONAL_LOCKS: "0",
 };
+export function isServiceScript(config) {
+    return "type" in config && config.type === "service";
+}
 export class WorktreeSetupError extends Error {
     constructor(message, results) {
         super(message);
@@ -29,6 +35,21 @@ export class WorktreeTeardownError extends Error {
         this.results = results;
     }
 }
+export class BranchAlreadyCheckedOutError extends Error {
+    constructor(branchName) {
+        super(`Branch already checked out: ${branchName}`);
+        this.name = "BranchAlreadyCheckedOutError";
+        this.branchName = branchName;
+    }
+}
+export class UnknownBranchError extends Error {
+    constructor(params) {
+        super(`Unknown branch: ${params.branchName}`);
+        this.name = "UnknownBranchError";
+        this.branchName = params.branchName;
+        this.cwd = params.cwd;
+    }
+}
 function readPaseoConfig(repoRoot) {
     const paseoConfigPath = join(repoRoot, "paseo.json");
     if (!existsSync(paseoConfigPath)) {
@@ -85,13 +106,89 @@ export function getWorktreeTerminalSpecs(repoRoot) {
     }
     return specs;
 }
+export function getScriptConfigs(repoRoot) {
+    const config = readPaseoConfig(repoRoot);
+    const scripts = config?.scripts;
+    if (!scripts || typeof scripts !== "object") {
+        return new Map();
+    }
+    const result = new Map();
+    for (const [name, entry] of Object.entries(scripts)) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const rawCommand = entry.command;
+        if (typeof rawCommand !== "string") {
+            continue;
+        }
+        const command = rawCommand.trim();
+        if (!command) {
+            continue;
+        }
+        const scriptConfig = entry.type === "service"
+            ? {
+                type: "service",
+                command,
+            }
+            : { command };
+        if (isServiceScript(scriptConfig) &&
+            typeof entry.port === "number" &&
+            Number.isFinite(entry.port)) {
+            scriptConfig.port = entry.port;
+        }
+        result.set(name, scriptConfig);
+    }
+    return result;
+}
+export function processCarriageReturns(text) {
+    if (!text.includes("\r")) {
+        return text;
+    }
+    const output = [];
+    let line = [];
+    let cursor = 0;
+    const flushLine = () => {
+        output.push(line.join(""));
+        line = [];
+        cursor = 0;
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (char === "\r") {
+            if (text[index + 1] === "\n") {
+                flushLine();
+                output.push("\n");
+                index += 1;
+                continue;
+            }
+            cursor = 0;
+            continue;
+        }
+        if (char === "\n") {
+            flushLine();
+            output.push("\n");
+            continue;
+        }
+        if (cursor < line.length) {
+            line[cursor] = char;
+        }
+        else {
+            line.push(char);
+        }
+        cursor += 1;
+    }
+    if (line.length > 0) {
+        output.push(line.join(""));
+    }
+    return output.join("");
+}
 async function execSetupCommand(command, options) {
     const startedAt = Date.now();
+    const shellInvocation = buildStringCommandShellInvocation({ command });
     try {
-        const { stdout, stderr } = await execAsync(command, {
+        const { stdout, stderr } = await execFileAsync(shellInvocation.shell, shellInvocation.args, {
             cwd: options.cwd,
             env: options.env,
-            ...(process.platform === "win32" ? {} : { shell: "/bin/bash" }),
         });
         return {
             command,
@@ -119,6 +216,27 @@ async function execSetupCommandStreamed(options) {
         const stdoutChunks = [];
         const stderrChunks = [];
         let settled = false;
+        const emitOutput = (stream, chunk) => {
+            const text = stripAnsi(chunk);
+            if (!text) {
+                return;
+            }
+            if (stream === "stdout") {
+                stdoutChunks.push(text);
+            }
+            else {
+                stderrChunks.push(text);
+            }
+            options.onEvent?.({
+                type: "output",
+                index: options.index,
+                total: options.total,
+                command: options.command,
+                cwd: options.cwd,
+                stream,
+                chunk: text,
+            });
+        };
         const finish = (exitCode) => {
             if (settled) {
                 return;
@@ -152,45 +270,48 @@ async function execSetupCommandStreamed(options) {
             command: options.command,
             cwd: options.cwd,
         });
-        const shell = platformBash();
-        const child = spawnProcess(shell.command, [...shell.flag, options.command], {
-            cwd: options.cwd,
-            env: options.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        child.stdout?.on("data", (chunk) => {
-            const text = chunk.toString();
-            stdoutChunks.push(text);
-            options.onEvent?.({
-                type: "output",
-                index: options.index,
-                total: options.total,
-                command: options.command,
+        const spawnWithPipes = () => {
+            const shellInvocation = buildStringCommandShellInvocation({ command: options.command });
+            const child = spawn(shellInvocation.shell, shellInvocation.args, {
                 cwd: options.cwd,
-                stream: "stdout",
-                chunk: text,
+                env: options.env,
+                stdio: ["ignore", "pipe", "pipe"],
             });
-        });
-        child.stderr?.on("data", (chunk) => {
-            const text = chunk.toString();
-            stderrChunks.push(text);
-            options.onEvent?.({
-                type: "output",
-                index: options.index,
-                total: options.total,
-                command: options.command,
+            child.stdout?.on("data", (chunk) => {
+                emitOutput("stdout", chunk.toString());
+            });
+            child.stderr?.on("data", (chunk) => {
+                emitOutput("stderr", chunk.toString());
+            });
+            child.on("error", (error) => {
+                emitOutput("stderr", error instanceof Error ? error.message : String(error));
+                finish(null);
+            });
+            child.on("close", (code) => {
+                finish(typeof code === "number" ? code : null);
+            });
+        };
+        try {
+            ensureNodePtySpawnHelperExecutableForCurrentPlatform();
+            const shellInvocation = buildStringCommandShellInvocation({ command: options.command });
+            const terminal = pty.spawn(shellInvocation.shell, shellInvocation.args, {
                 cwd: options.cwd,
-                stream: "stderr",
-                chunk: text,
+                env: options.env,
+                name: "xterm-color",
+                cols: 120,
+                rows: 30,
             });
-        });
-        child.on("error", (error) => {
-            stderrChunks.push(error instanceof Error ? error.message : String(error));
-            finish(null);
-        });
-        child.on("close", (code) => {
-            finish(typeof code === "number" ? code : null);
-        });
+            terminal.onData((data) => {
+                emitOutput("stdout", data);
+            });
+            terminal.onExit(({ exitCode }) => {
+                finish(typeof exitCode === "number" ? exitCode : null);
+            });
+        }
+        catch (error) {
+            emitOutput("stderr", error instanceof Error ? error.message : String(error));
+            spawnWithPipes();
+        }
     });
 }
 async function getAvailablePort() {
@@ -456,9 +577,6 @@ export function slugify(input) {
     }
     return truncated.replace(/-+$/, "");
 }
-function generateWorktreeSlug() {
-    return createNameId();
-}
 const WORKTREE_PROJECT_HASH_LENGTH = 8;
 function deriveShortAlphanumericHash(value) {
     const digest = createHash("sha256").update(value).digest();
@@ -503,36 +621,44 @@ function resolveRepoRootFromGitCommonDir(commonDir) {
         : normalizedCommonDir;
 }
 export async function isPaseoOwnedWorktreeCwd(cwd, options) {
-    let gitCommonDir;
+    const resolvedCwd = normalizePathForOwnership(cwd);
+    // repoRoot is best-effort: git may be unreachable from the worktree (e.g. a
+    // previous archive attempt removed the admin dir before the working tree
+    // could be fully cleaned up). We still want to allow archiving in that case.
+    let repoRoot;
     try {
-        gitCommonDir = await getGitCommonDir(cwd);
+        const gitCommonDir = await getGitCommonDir(cwd);
+        repoRoot = resolveRepoRootFromGitCommonDir(gitCommonDir);
     }
     catch {
+        // ignore
+    }
+    const paseoHome = options?.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
+    const paseoWorktreesPrefix = normalizePathForOwnership(join(paseoHome, "worktrees")) + sep;
+    // Ownership is defined by the path living under $PASEO_HOME/worktrees/<hash>/<slug>[/...].
+    // The <hash>/<slug> prefix is Paseo-private — nothing else writes there — so the
+    // path shape alone is sufficient proof of ownership, even when git has already
+    // forgotten about the worktree.
+    if (!resolvedCwd.startsWith(paseoWorktreesPrefix)) {
         return {
             allowed: false,
-            worktreePath: normalizePathForOwnership(cwd),
+            ...(repoRoot !== undefined ? { repoRoot } : {}),
+            worktreePath: resolvedCwd,
         };
     }
-    const repoRoot = resolveRepoRootFromGitCommonDir(gitCommonDir);
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome);
-    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
-    const resolvedCwd = normalizePathForOwnership(cwd);
-    if (!resolvedCwd.startsWith(resolvedRoot)) {
+    const relative = resolvedCwd.slice(paseoWorktreesPrefix.length);
+    const parts = relative.split(sep).filter((part) => part.length > 0);
+    if (parts.length < 2) {
         return {
             allowed: false,
-            repoRoot,
-            worktreeRoot: worktreesRoot,
+            ...(repoRoot !== undefined ? { repoRoot } : {}),
             worktreePath: resolvedCwd,
         };
     }
-    const worktrees = await listPaseoWorktrees({ cwd, paseoHome: options?.paseoHome });
-    const allowed = worktrees.some((entry) => {
-        const worktreePath = resolve(entry.path);
-        return resolvedCwd === worktreePath || resolvedCwd.startsWith(worktreePath + sep);
-    });
+    const worktreesRoot = join(paseoHome, "worktrees", parts[0]);
     return {
-        allowed,
-        repoRoot,
+        allowed: true,
+        ...(repoRoot !== undefined ? { repoRoot } : {}),
         worktreeRoot: worktreesRoot,
         worktreePath: resolvedCwd,
     };
@@ -596,6 +722,29 @@ export async function listPaseoWorktrees({ cwd, paseoHome, }) {
         createdAt: resolveWorktreeCreatedAtIso(entry.path),
     }));
 }
+export async function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, }) {
+    const worktrees = await listPaseoWorktrees({
+        cwd: repoRoot,
+        paseoHome,
+    });
+    const slugSuffix = `${sep}${slug}`;
+    const existingWorktree = worktrees.find((worktree) => worktree.path.endsWith(slugSuffix));
+    if (!existingWorktree) {
+        return null;
+    }
+    const { stdout } = await runGitCommand(["branch", "--show-current"], {
+        cwd: existingWorktree.path,
+        env: READ_ONLY_GIT_ENV,
+    });
+    const branchName = stdout.trim();
+    if (!branchName) {
+        throw new Error(`Unable to resolve branch for existing worktree: ${existingWorktree.path}`);
+    }
+    return {
+        branchName,
+        worktreePath: existingWorktree.path,
+    };
+}
 export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
     let gitCommonDir;
     try {
@@ -638,119 +787,275 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
         worktreePath: match.path,
     };
 }
-export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, paseoHome, }) {
+export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, }) {
     if (!worktreePath && !worktreeSlug) {
         throw new Error("worktreePath or worktreeSlug is required");
     }
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
-    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
-    const requestedPath = worktreePath ?? join(worktreesRoot, worktreeSlug);
+    // Resolve the worktrees-root. With a repo cwd we hash it the normal way; if
+    // git has forgotten about the worktree we expect the caller to hand us the
+    // path-derived worktreesRoot from the ownership check.
+    let resolvedWorktreesRoot;
+    if (worktreesRoot) {
+        resolvedWorktreesRoot = worktreesRoot;
+    }
+    else if (cwd) {
+        resolvedWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
+    }
+    else {
+        throw new Error("cwd or worktreesRoot is required to delete a Paseo worktree");
+    }
+    const resolvedRoot = normalizePathForOwnership(resolvedWorktreesRoot) + sep;
+    const requestedPath = worktreePath ?? join(resolvedWorktreesRoot, worktreeSlug);
     const resolvedRequested = normalizePathForOwnership(requestedPath);
     const resolvedWorktree = (await resolvePaseoWorktreeRootForCwd(requestedPath, { paseoHome }))?.worktreePath ??
         resolvedRequested;
     if (!resolvedWorktree.startsWith(resolvedRoot)) {
         throw new Error("Refusing to delete non-Paseo worktree");
     }
-    await runWorktreeTeardownCommands({
-        worktreePath: resolvedWorktree,
-    });
-    await runGitCommand(["worktree", "remove", resolvedWorktree, "--force"], {
-        cwd,
-        timeout: 120000,
-    });
-    if (existsSync(resolvedWorktree)) {
-        rmSync(resolvedWorktree, { recursive: true, force: true });
+    if (await pathExists(resolvedWorktree)) {
+        await runWorktreeTeardownCommands({
+            worktreePath: resolvedWorktree,
+        });
+    }
+    if (cwd) {
+        try {
+            await runGitCommand(["worktree", "remove", resolvedWorktree, "--force"], {
+                cwd,
+                timeout: 120000,
+            });
+        }
+        catch {
+            // `git worktree remove` fails if the admin dir is already gone (e.g. a
+            // prior archive attempt removed it before the working tree could be
+            // fully cleaned up), or if the repo root has moved. Fall through to the
+            // rm retry loop below so the operation stays idempotent.
+        }
+    }
+    await removeDirectoryWithRetries(resolvedWorktree);
+    if (cwd) {
+        try {
+            await runGitCommand(["worktree", "prune"], { cwd, timeout: 30000 });
+        }
+        catch {
+            // not critical; git will prune lazily
+        }
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function removeDirectoryWithRetries(path) {
+    if (!(await pathExists(path))) {
+        return;
+    }
+    const delaysMs = [0, 100, 300, 700, 1500];
+    let lastError = null;
+    for (const delay of delaysMs) {
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        try {
+            await rm(path, { recursive: true, force: true });
+            if (!(await pathExists(path))) {
+                return;
+            }
+            lastError = new Error(`Directory still present after rm: ${path}`);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (await pathExists(path)) {
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`Failed to remove worktree directory: ${path}`);
     }
 }
 /**
  * Create a git worktree with proper naming conventions
  */
-export async function createWorktree({ branchName, cwd, baseBranch, worktreeSlug, runSetup = true, paseoHome, }) {
-    // Validate branch name
+export const createWorktree = async ({ cwd, source, worktreeSlug, runSetup, paseoHome, }) => {
+    const sourcePlan = await resolveWorktreeSourcePlan({ cwd, source, desiredSlug: worktreeSlug });
+    let worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome), worktreeSlug);
+    mkdirSync(dirname(worktreePath), { recursive: true });
+    // Also handle worktree path collision
+    let finalWorktreePath = worktreePath;
+    let pathSuffix = 1;
+    while (existsSync(finalWorktreePath)) {
+        finalWorktreePath = `${worktreePath}-${pathSuffix}`;
+        pathSuffix++;
+    }
+    // Primitive owner for `git worktree add`; callers route through createWorktreeCore.
+    await runGitCommand(["worktree", "add", finalWorktreePath, ...sourcePlan.addArguments], {
+        cwd,
+        timeout: 120000,
+    });
+    worktreePath = normalizePathForOwnership(finalWorktreePath);
+    if (sourcePlan.pushRemote) {
+        await configureWorktreePushRemote({
+            cwd,
+            branchName: sourcePlan.branchName,
+            remote: sourcePlan.pushRemote,
+        });
+    }
+    writePaseoWorktreeMetadata(worktreePath, { baseRefName: sourcePlan.metadataBaseRefName });
+    if (runSetup) {
+        await runWorktreeSetupCommands({
+            worktreePath,
+            branchName: sourcePlan.branchName,
+            cleanupOnFailure: true,
+        });
+    }
+    return {
+        branchName: sourcePlan.branchName,
+        worktreePath,
+    };
+};
+async function resolveWorktreeSourcePlan({ cwd, source, desiredSlug, }) {
+    switch (source.kind) {
+        case "branch-off": {
+            const branchName = source.newBranchName;
+            validateWorktreeBranchName(branchName);
+            const normalizedBaseBranch = normalizeRequiredBaseBranch(source.baseBranch);
+            const resolvedBaseBranch = await resolveBaseBranchForWorktree(cwd, normalizedBaseBranch);
+            const branchExists = await localBranchExists(cwd, branchName);
+            const base = branchExists ? branchName : resolvedBaseBranch;
+            const candidateBranch = branchExists ? desiredSlug : branchName;
+            const newBranchName = await resolveUniqueLocalBranchName(cwd, candidateBranch);
+            return {
+                branchName: newBranchName,
+                metadataBaseRefName: normalizedBaseBranch,
+                addArguments: ["-b", newBranchName, base],
+            };
+        }
+        case "checkout-branch": {
+            validateWorktreeBranchName(source.branchName);
+            if (!(await localBranchExists(cwd, source.branchName))) {
+                try {
+                    await runGitCommand(["fetch", "origin", `${source.branchName}:${source.branchName}`], {
+                        cwd,
+                        timeout: 120000,
+                    });
+                }
+                catch {
+                    throw new UnknownBranchError({ branchName: source.branchName, cwd });
+                }
+            }
+            if (await isBranchCheckedOut(cwd, source.branchName)) {
+                throw new BranchAlreadyCheckedOutError(source.branchName);
+            }
+            return {
+                branchName: source.branchName,
+                metadataBaseRefName: source.branchName,
+                addArguments: [source.branchName],
+            };
+        }
+        case "checkout-github-pr": {
+            const localBranchCandidate = source.localBranchName ?? source.headRef;
+            validateWorktreeBranchName(localBranchCandidate);
+            const localBranchName = await resolveUniqueLocalBranchName(cwd, localBranchCandidate);
+            const normalizedBaseRefName = normalizeRequiredBaseBranch(source.baseRefName);
+            await runGitCommand([
+                "fetch",
+                "origin",
+                `refs/pull/${source.githubPrNumber}/head:refs/heads/${localBranchName}`,
+                "--force",
+            ], {
+                cwd,
+                timeout: 120000,
+            });
+            return {
+                branchName: localBranchName,
+                metadataBaseRefName: normalizedBaseRefName,
+                addArguments: [localBranchName],
+                ...(source.pushRemoteUrl
+                    ? {
+                        pushRemote: {
+                            name: `paseo-pr-${source.githubPrNumber}`,
+                            url: source.pushRemoteUrl,
+                            headRef: source.headRef,
+                        },
+                    }
+                    : {}),
+            };
+        }
+    }
+}
+async function configureWorktreePushRemote(options) {
+    await runGitCommand(["config", `remote.${options.remote.name}.url`, options.remote.url], {
+        cwd: options.cwd,
+    });
+    await runGitCommand(["config", `remote.${options.remote.name}.push`, `HEAD:refs/heads/${options.remote.headRef}`], { cwd: options.cwd });
+    await runGitCommand(["config", `branch.${options.branchName}.remote`, options.remote.name], {
+        cwd: options.cwd,
+    });
+    await runGitCommand(["config", `branch.${options.branchName}.merge`, `refs/heads/${options.remote.headRef}`], { cwd: options.cwd });
+}
+function validateWorktreeBranchName(branchName) {
     const validation = validateBranchSlug(branchName);
     if (!validation.valid) {
         throw new Error(`Invalid branch name: ${validation.error}`);
     }
-    const normalizedBaseBranch = baseBranch ? normalizeBaseRefName(baseBranch) : "";
+}
+function normalizeRequiredBaseBranch(baseBranch) {
+    const normalizedBaseBranch = normalizeBaseRefName(baseBranch);
     if (!normalizedBaseBranch) {
         throw new Error("Base branch is required when creating a Paseo worktree");
     }
     if (normalizedBaseBranch === "HEAD") {
         throw new Error("Base branch cannot be HEAD when creating a Paseo worktree");
     }
-    // Resolve the base branch - prefer origin/{branch}, then fall back to local
-    let resolvedBaseBranch = normalizedBaseBranch;
+    return normalizedBaseBranch;
+}
+async function resolveBaseBranchForWorktree(cwd, normalizedBaseBranch) {
     try {
         await runGitCommand(["rev-parse", "--verify", `origin/${normalizedBaseBranch}`], { cwd });
-        resolvedBaseBranch = `origin/${normalizedBaseBranch}`;
+        return `origin/${normalizedBaseBranch}`;
     }
     catch {
         try {
             await runGitCommand(["rev-parse", "--verify", normalizedBaseBranch], { cwd });
+            return normalizedBaseBranch;
         }
         catch {
             throw new Error(`Base branch not found: ${normalizedBaseBranch}`);
         }
     }
-    let worktreePath;
-    const desiredSlug = worktreeSlug || generateWorktreeSlug();
-    worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome), desiredSlug);
-    mkdirSync(dirname(worktreePath), { recursive: true });
-    // Check if branch already exists
-    let branchExists = false;
+}
+async function localBranchExists(cwd, branchName) {
     try {
         await runGitCommand(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
             cwd,
         });
-        branchExists = true;
+        return true;
     }
     catch {
-        branchExists = false;
-    }
-    // Always create a new branch for the worktree
-    // If branchName already exists, use it as base and create worktree-slug as branch name
-    // If branchName doesn't exist, create it from baseBranch (resolved to remote if needed)
-    const base = branchExists ? branchName : resolvedBaseBranch;
-    const candidateBranch = branchExists ? desiredSlug : branchName;
-    // Find unique branch name if collision
+        return false;
+    }
+}
+async function resolveUniqueLocalBranchName(cwd, candidateBranch) {
     let newBranchName = candidateBranch;
     let suffix = 1;
-    while (true) {
-        try {
-            await runGitCommand(["show-ref", "--verify", "--quiet", `refs/heads/${newBranchName}`], {
-                cwd,
-            });
-            // Branch exists, try with suffix
-            newBranchName = `${candidateBranch}-${suffix}`;
-            suffix++;
-        }
-        catch {
-            break;
-        }
+    while (await localBranchExists(cwd, newBranchName)) {
+        newBranchName = `${candidateBranch}-${suffix}`;
+        suffix++;
     }
-    // Also handle worktree path collision
-    let finalWorktreePath = worktreePath;
-    let pathSuffix = 1;
-    while (existsSync(finalWorktreePath)) {
-        finalWorktreePath = `${worktreePath}-${pathSuffix}`;
-        pathSuffix++;
-    }
-    await runGitCommand(["worktree", "add", finalWorktreePath, "-b", newBranchName, base], {
+    return newBranchName;
+}
+async function isBranchCheckedOut(cwd, branchName) {
+    const { stdout } = await runGitCommand(["worktree", "list", "--porcelain"], {
         cwd,
-        timeout: 120000,
+        env: READ_ONLY_GIT_ENV,
     });
-    worktreePath = normalizePathForOwnership(finalWorktreePath);
-    writePaseoWorktreeMetadata(worktreePath, { baseRefName: normalizedBaseBranch });
-    if (runSetup) {
-        await runWorktreeSetupCommands({
-            worktreePath,
-            branchName: newBranchName,
-            cleanupOnFailure: true,
-        });
-    }
-    return {
-        branchName: newBranchName,
-        worktreePath,
-    };
+    return parseWorktreeList(stdout).some((entry) => entry.branchName === branchName);
 }
 //# sourceMappingURL=worktree.js.map