@junctionpanel/server 0.1.16

package/dist/server/utils/worktree.js

@@ -0,0 +1,858 @@
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync } from "fs";
+import { join, basename, dirname, resolve, sep } from "path";
+import net from "node:net";
+import { createHash } from "node:crypto";
+import { createNameId } from "mnemonic-id";
+import { normalizeBaseRefName, readJunctionWorktreeMetadata, readJunctionWorktreeRuntimePort, writeJunctionWorktreeMetadata, writeJunctionWorktreeRuntimeMetadata, } from "./worktree-metadata.js";
+import { generateCitySlug } from "./city-names.js";
+const execAsync = promisify(exec);
+const READ_ONLY_GIT_ENV = {
+    ...process.env,
+    GIT_OPTIONAL_LOCKS: "0",
+};
+export class WorktreeSetupError extends Error {
+    constructor(message, results) {
+        super(message);
+        this.name = "WorktreeSetupError";
+        this.results = results;
+    }
+}
+export class WorktreeDestroyError extends Error {
+    constructor(message, results) {
+        super(message);
+        this.name = "WorktreeDestroyError";
+        this.results = results;
+    }
+}
+function readJunctionConfig(repoRoot) {
+    const junctionConfigPath = join(repoRoot, "junction.json");
+    if (!existsSync(junctionConfigPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(junctionConfigPath, "utf8"));
+    }
+    catch {
+        throw new Error(`Failed to parse junction.json`);
+    }
+}
+export function getWorktreeSetupCommands(repoRoot) {
+    const config = readJunctionConfig(repoRoot);
+    const setupCommands = config?.worktree?.setup;
+    if (!setupCommands || setupCommands.length === 0) {
+        return [];
+    }
+    return setupCommands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0);
+}
+export function getWorktreeDestroyCommands(repoRoot) {
+    const config = readJunctionConfig(repoRoot);
+    const destroyCommands = config?.worktree?.destroy;
+    if (!destroyCommands || destroyCommands.length === 0) {
+        return [];
+    }
+    return destroyCommands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0);
+}
+export function getWorktreeTerminalSpecs(repoRoot) {
+    const config = readJunctionConfig(repoRoot);
+    const terminals = config?.worktree?.terminals;
+    if (!Array.isArray(terminals) || terminals.length === 0) {
+        return [];
+    }
+    const specs = [];
+    for (const terminal of terminals) {
+        if (!terminal || typeof terminal !== "object") {
+            continue;
+        }
+        const rawCommand = terminal.command;
+        if (typeof rawCommand !== "string") {
+            continue;
+        }
+        const command = rawCommand.trim();
+        if (!command) {
+            continue;
+        }
+        const rawName = terminal.name;
+        const name = typeof rawName === "string" && rawName.trim().length > 0
+            ? rawName.trim()
+            : undefined;
+        specs.push({
+            ...(name ? { name } : {}),
+            command,
+        });
+    }
+    return specs;
+}
+async function execSetupCommand(command, options) {
+    const startedAt = Date.now();
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: "/bin/bash",
+        });
+        return {
+            command,
+            cwd: options.cwd,
+            stdout: stdout ?? "",
+            stderr: stderr ?? "",
+            exitCode: 0,
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    catch (error) {
+        return {
+            command,
+            cwd: options.cwd,
+            stdout: error?.stdout ?? "",
+            stderr: error?.stderr ??
+                (error instanceof Error ? error.message : String(error)),
+            exitCode: typeof error?.code === "number" ? error.code : null,
+            durationMs: Date.now() - startedAt,
+        };
+    }
+}
+async function execSetupCommandStreamed(options) {
+    return new Promise((resolve) => {
+        const startedAt = Date.now();
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        const finish = (exitCode) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            const result = {
+                command: options.command,
+                cwd: options.cwd,
+                stdout: stdoutChunks.join(""),
+                stderr: stderrChunks.join(""),
+                exitCode,
+                durationMs: Date.now() - startedAt,
+            };
+            options.onEvent?.({
+                type: "command_completed",
+                index: options.index,
+                total: options.total,
+                command: options.command,
+                cwd: options.cwd,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            });
+            resolve(result);
+        };
+        options.onEvent?.({
+            type: "command_started",
+            index: options.index,
+            total: options.total,
+            command: options.command,
+            cwd: options.cwd,
+        });
+        const child = spawn("/bin/bash", ["-lc", 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,
+                cwd: options.cwd,
+                stream: "stdout",
+                chunk: text,
+            });
+        });
+        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,
+                cwd: options.cwd,
+                stream: "stderr",
+                chunk: text,
+            });
+        });
+        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);
+        });
+    });
+}
+async function getAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once("error", reject);
+        server.listen(0, () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                server.close(() => reject(new Error("Failed to acquire available port")));
+                return;
+            }
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(address.port);
+            });
+        });
+    });
+}
+async function assertPortAvailable(port) {
+    await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once("error", (error) => {
+            const message = error?.code === "EADDRINUSE"
+                ? `Persisted worktree port ${port} is already in use`
+                : error instanceof Error
+                    ? error.message
+                    : String(error);
+            reject(new Error(message));
+        });
+        server.listen(port, () => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    });
+}
+async function inferRepoRootPathFromWorktreePath(worktreePath) {
+    try {
+        const commonDir = await getGitCommonDir(worktreePath);
+        const normalizedCommonDir = normalizePathForOwnership(commonDir);
+        // Normal repo/worktree: common dir is <repoRoot>/.git
+        if (basename(normalizedCommonDir) === ".git") {
+            return dirname(normalizedCommonDir);
+        }
+        // Bare repo: common dir is the repo dir itself
+        return normalizedCommonDir;
+    }
+    catch {
+        // Fallback: best-effort resolve toplevel (will be the worktree root in typical cases)
+        try {
+            const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", { cwd: worktreePath, env: READ_ONLY_GIT_ENV });
+            const topLevel = stdout.trim();
+            if (topLevel) {
+                return normalizePathForOwnership(topLevel);
+            }
+        }
+        catch {
+            // ignore
+        }
+        return normalizePathForOwnership(worktreePath);
+    }
+}
+export async function runWorktreeSetupCommands(options) {
+    // Read junction.json from the worktree (it will have the same content as the source repo)
+    const setupCommands = getWorktreeSetupCommands(options.worktreePath);
+    if (setupCommands.length === 0) {
+        return [];
+    }
+    const runtimeEnv = options.runtimeEnv ??
+        (await resolveWorktreeRuntimeEnv({
+            worktreePath: options.worktreePath,
+            branchName: options.branchName,
+            ...(options.repoRootPath ? { repoRootPath: options.repoRootPath } : {}),
+        }));
+    const setupEnv = {
+        ...process.env,
+        ...runtimeEnv,
+    };
+    const results = [];
+    for (const [index, cmd] of setupCommands.entries()) {
+        const result = options.onEvent
+            ? await execSetupCommandStreamed({
+                command: cmd,
+                cwd: options.worktreePath,
+                env: setupEnv,
+                index: index + 1,
+                total: setupCommands.length,
+                onEvent: options.onEvent,
+            })
+            : await execSetupCommand(cmd, {
+                cwd: options.worktreePath,
+                env: setupEnv,
+            });
+        results.push(result);
+        if (result.exitCode !== 0) {
+            if (options.cleanupOnFailure) {
+                try {
+                    await execAsync(`git worktree remove "${options.worktreePath}" --force`, {
+                        cwd: options.worktreePath,
+                    });
+                }
+                catch {
+                    rmSync(options.worktreePath, { recursive: true, force: true });
+                }
+            }
+            throw new WorktreeSetupError(`Worktree setup command failed: ${cmd}\n${result.stderr}`.trim(), results);
+        }
+    }
+    return results;
+}
+async function resolveBranchNameForWorktreePath(worktreePath) {
+    try {
+        const { stdout } = await execAsync("git branch --show-current", {
+            cwd: worktreePath,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const branchName = stdout.trim();
+        if (branchName.length > 0) {
+            return branchName;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return basename(worktreePath);
+}
+export async function resolveWorktreeRuntimeEnv(options) {
+    const repoRootPath = options.repoRootPath ?? (await inferRepoRootPathFromWorktreePath(options.worktreePath));
+    const branchName = options.branchName ?? (await resolveBranchNameForWorktreePath(options.worktreePath));
+    let worktreePort = readJunctionWorktreeRuntimePort(options.worktreePath);
+    if (worktreePort === null) {
+        worktreePort = await getAvailablePort();
+        const metadata = readJunctionWorktreeMetadata(options.worktreePath);
+        if (metadata) {
+            writeJunctionWorktreeRuntimeMetadata(options.worktreePath, { worktreePort });
+        }
+    }
+    else {
+        await assertPortAvailable(worktreePort);
+    }
+    return {
+        // Source checkout path is the original git repo root (shared across worktrees), not the
+        // worktree itself. This allows setup scripts to copy local files (e.g. .env) from the
+        // source checkout.
+        JUNCTION_SOURCE_CHECKOUT_PATH: repoRootPath,
+        // Backward-compatible alias.
+        JUNCTION_ROOT_PATH: repoRootPath,
+        JUNCTION_WORKTREE_PATH: options.worktreePath,
+        JUNCTION_BRANCH_NAME: branchName,
+        JUNCTION_WORKTREE_PORT: String(worktreePort),
+    };
+}
+export async function runWorktreeDestroyCommands(options) {
+    // Read junction.json from the worktree (it will have the same content as the source repo)
+    const destroyCommands = getWorktreeDestroyCommands(options.worktreePath);
+    if (destroyCommands.length === 0) {
+        return [];
+    }
+    const repoRootPath = options.repoRootPath ?? (await inferRepoRootPathFromWorktreePath(options.worktreePath));
+    const branchName = options.branchName ?? (await resolveBranchNameForWorktreePath(options.worktreePath));
+    const destroyEnv = {
+        ...process.env,
+        // Source checkout path is the original git repo root (shared across worktrees), not the
+        // worktree itself. This allows destroy scripts to clean resources using paths from the
+        // source checkout.
+        JUNCTION_SOURCE_CHECKOUT_PATH: repoRootPath,
+        // Backward-compatible alias.
+        JUNCTION_ROOT_PATH: repoRootPath,
+        JUNCTION_WORKTREE_PATH: options.worktreePath,
+        JUNCTION_BRANCH_NAME: branchName,
+    };
+    const results = [];
+    for (const cmd of destroyCommands) {
+        const result = await execSetupCommand(cmd, {
+            cwd: options.worktreePath,
+            env: destroyEnv,
+        });
+        results.push(result);
+        if (result.exitCode !== 0) {
+            throw new WorktreeDestroyError(`Worktree destroy command failed: ${cmd}\n${result.stderr}`.trim(), results);
+        }
+    }
+    return results;
+}
+/**
+ * Get the git common directory (shared across worktrees) for a given cwd.
+ * This is where refs, objects, etc. are stored.
+ */
+export async function getGitCommonDir(cwd) {
+    const { stdout } = await execAsync("git rev-parse --path-format=absolute --git-common-dir", { cwd, env: READ_ONLY_GIT_ENV });
+    const commonDir = stdout.trim();
+    if (!commonDir) {
+        throw new Error("Not in a git repository");
+    }
+    return commonDir;
+}
+/**
+ * Validate that a string is a valid git branch name slug
+ * Must be lowercase, alphanumeric, hyphens only
+ */
+export function validateBranchSlug(slug) {
+    if (!slug || slug.length === 0) {
+        return { valid: false, error: "Branch name cannot be empty" };
+    }
+    if (slug.length > 100) {
+        return { valid: false, error: "Branch name too long (max 100 characters)" };
+    }
+    // Check for valid characters: lowercase letters, numbers, hyphens, forward slashes
+    const validPattern = /^[a-z0-9-/]+$/;
+    if (!validPattern.test(slug)) {
+        return {
+            valid: false,
+            error: "Branch name must contain only lowercase letters, numbers, hyphens, and forward slashes",
+        };
+    }
+    // Cannot start or end with hyphen
+    if (slug.startsWith("-") || slug.endsWith("-")) {
+        return {
+            valid: false,
+            error: "Branch name cannot start or end with a hyphen",
+        };
+    }
+    // Cannot have consecutive hyphens
+    if (slug.includes("--")) {
+        return { valid: false, error: "Branch name cannot have consecutive hyphens" };
+    }
+    return { valid: true };
+}
+const MAX_SLUG_LENGTH = 50;
+/**
+ * Convert string to kebab-case for branch names
+ */
+export function slugify(input) {
+    const slug = input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (slug.length <= MAX_SLUG_LENGTH) {
+        return slug;
+    }
+    // Truncate at word boundary (hyphen) if possible
+    const truncated = slug.slice(0, MAX_SLUG_LENGTH);
+    const lastHyphen = truncated.lastIndexOf("-");
+    if (lastHyphen > MAX_SLUG_LENGTH / 2) {
+        return truncated.slice(0, lastHyphen);
+    }
+    return truncated.replace(/-+$/, "");
+}
+function generateWorktreeSlug() {
+    return createNameId();
+}
+const WORKTREE_PROJECT_HASH_LENGTH = 8;
+function deriveShortAlphanumericHash(value) {
+    const digest = createHash("sha256").update(value).digest();
+    let hashValue = 0n;
+    for (let index = 0; index < 8; index += 1) {
+        hashValue = (hashValue << 8n) | BigInt(digest[index] ?? 0);
+    }
+    return hashValue
+        .toString(36)
+        .padStart(13, "0")
+        .slice(0, WORKTREE_PROJECT_HASH_LENGTH);
+}
+export async function deriveWorktreeProjectHash(cwd) {
+    try {
+        const commonDir = await getGitCommonDir(cwd);
+        const normalizedCommonDir = normalizePathForOwnership(commonDir);
+        const repoRoot = basename(normalizedCommonDir) === ".git"
+            ? dirname(normalizedCommonDir)
+            : normalizedCommonDir;
+        return deriveShortAlphanumericHash(repoRoot);
+    }
+    catch {
+        return deriveShortAlphanumericHash(normalizePathForOwnership(cwd));
+    }
+}
+async function getJunctionWorktreesRoot(cwd, _junctionHome) {
+    const gitCommonDir = await getGitCommonDir(cwd);
+    const repoRoot = resolveRepoRootFromGitCommonDir(gitCommonDir);
+    return getInRepoWorktreesRoot(repoRoot);
+}
+function normalizePathForOwnership(input) {
+    try {
+        return realpathSync(input);
+    }
+    catch {
+        return resolve(input);
+    }
+}
+function resolveRepoRootFromGitCommonDir(commonDir) {
+    const normalizedCommonDir = normalizePathForOwnership(commonDir);
+    return basename(normalizedCommonDir) === ".git"
+        ? dirname(normalizedCommonDir)
+        : normalizedCommonDir;
+}
+export async function isJunctionOwnedWorktreeCwd(cwd, options) {
+    let gitCommonDir;
+    try {
+        gitCommonDir = await getGitCommonDir(cwd);
+    }
+    catch {
+        return {
+            allowed: false,
+            worktreePath: normalizePathForOwnership(cwd),
+        };
+    }
+    const repoRoot = resolveRepoRootFromGitCommonDir(gitCommonDir);
+    const worktreesRoot = await getJunctionWorktreesRoot(cwd, options?.junctionHome);
+    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
+    const resolvedCwd = normalizePathForOwnership(cwd);
+    if (!resolvedCwd.startsWith(resolvedRoot)) {
+        return {
+            allowed: false,
+            repoRoot,
+            worktreeRoot: worktreesRoot,
+            worktreePath: resolvedCwd,
+        };
+    }
+    const worktrees = await listJunctionWorktrees({ cwd, junctionHome: options?.junctionHome });
+    const allowed = worktrees.some((entry) => {
+        const worktreePath = resolve(entry.path);
+        return resolvedCwd === worktreePath || resolvedCwd.startsWith(worktreePath + sep);
+    });
+    return {
+        allowed,
+        repoRoot,
+        worktreeRoot: worktreesRoot,
+        worktreePath: resolvedCwd,
+    };
+}
+function parseWorktreeList(output) {
+    const entries = [];
+    let current = null;
+    for (const line of output.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (current?.path) {
+                entries.push(current);
+            }
+            current = { path: line.slice("worktree ".length).trim() };
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        if (line.startsWith("branch ")) {
+            const ref = line.slice("branch ".length).trim();
+            current.branchName = ref.startsWith("refs/heads/")
+                ? ref.slice("refs/heads/".length)
+                : ref;
+        }
+        else if (line.startsWith("HEAD ")) {
+            current.head = line.slice("HEAD ".length).trim();
+        }
+        else if (line.trim().length === 0) {
+            if (current.path) {
+                entries.push(current);
+            }
+            current = null;
+        }
+    }
+    if (current?.path) {
+        entries.push(current);
+    }
+    return entries;
+}
+export async function listJunctionWorktrees({ cwd, junctionHome, }) {
+    const worktreesRoot = await getJunctionWorktreesRoot(cwd, junctionHome);
+    const { stdout } = await execAsync("git worktree list --porcelain", {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+    });
+    const rootPrefix = normalizePathForOwnership(worktreesRoot) + sep;
+    return parseWorktreeList(stdout)
+        .map((entry) => ({ ...entry, path: normalizePathForOwnership(entry.path) }))
+        .filter((entry) => entry.path.startsWith(rootPrefix));
+}
+export async function resolveJunctionWorktreeRootForCwd(cwd, options) {
+    let gitCommonDir;
+    try {
+        gitCommonDir = await getGitCommonDir(cwd);
+    }
+    catch {
+        return null;
+    }
+    const worktreesRoot = await getJunctionWorktreesRoot(cwd, options?.junctionHome);
+    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
+    let worktreeRoot = null;
+    try {
+        const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", { cwd, env: READ_ONLY_GIT_ENV });
+        const trimmed = stdout.trim();
+        worktreeRoot = trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        worktreeRoot = null;
+    }
+    if (!worktreeRoot) {
+        return null;
+    }
+    const resolvedWorktreeRoot = normalizePathForOwnership(worktreeRoot);
+    if (!resolvedWorktreeRoot.startsWith(resolvedRoot)) {
+        return null;
+    }
+    const knownWorktrees = await listJunctionWorktrees({
+        cwd,
+        junctionHome: options?.junctionHome,
+    });
+    const match = knownWorktrees.find((entry) => entry.path === resolvedWorktreeRoot);
+    if (!match) {
+        return null;
+    }
+    return {
+        repoRoot: resolveRepoRootFromGitCommonDir(gitCommonDir),
+        worktreeRoot: worktreesRoot,
+        worktreePath: match.path,
+    };
+}
+export async function deleteJunctionWorktree({ cwd, worktreePath, worktreeSlug, junctionHome, }) {
+    if (!worktreePath && !worktreeSlug) {
+        throw new Error("worktreePath or worktreeSlug is required");
+    }
+    const worktreesRoot = await getJunctionWorktreesRoot(cwd, junctionHome);
+    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
+    const requestedPath = worktreePath ?? join(worktreesRoot, worktreeSlug);
+    const resolvedRequested = normalizePathForOwnership(requestedPath);
+    const resolvedWorktree = (await resolveJunctionWorktreeRootForCwd(requestedPath, { junctionHome }))?.worktreePath ??
+        resolvedRequested;
+    if (!resolvedWorktree.startsWith(resolvedRoot)) {
+        throw new Error("Refusing to delete non-Junction worktree");
+    }
+    await runWorktreeDestroyCommands({
+        worktreePath: resolvedWorktree,
+    });
+    await execAsync(`git worktree remove "${resolvedWorktree}" --force`, {
+        cwd,
+    });
+    if (existsSync(resolvedWorktree)) {
+        rmSync(resolvedWorktree, { recursive: true, force: true });
+    }
+}
+/**
+ * Create a git worktree with proper naming conventions
+ */
+export async function createWorktree({ branchName, cwd, baseBranch, worktreeSlug, runSetup = true, junctionHome, }) {
+    // Validate branch name
+    const validation = validateBranchSlug(branchName);
+    if (!validation.valid) {
+        throw new Error(`Invalid branch name: ${validation.error}`);
+    }
+    const normalizedBaseBranch = baseBranch ? normalizeBaseRefName(baseBranch) : "";
+    if (!normalizedBaseBranch) {
+        throw new Error("Base branch is required when creating a Junction worktree");
+    }
+    if (normalizedBaseBranch === "HEAD") {
+        throw new Error("Base branch cannot be HEAD when creating a Junction worktree");
+    }
+    // Resolve the base branch - try local first, then remote
+    let resolvedBaseBranch = normalizedBaseBranch;
+    try {
+        await execAsync(`git rev-parse --verify ${normalizedBaseBranch}`, { cwd });
+    }
+    catch {
+        // Local branch doesn't exist, try remote (origin/{branch})
+        try {
+            await execAsync(`git rev-parse --verify origin/${normalizedBaseBranch}`, { cwd });
+            resolvedBaseBranch = `origin/${normalizedBaseBranch}`;
+        }
+        catch {
+            throw new Error(`Base branch not found: ${normalizedBaseBranch}`);
+        }
+    }
+    const repoRoot = resolveRepoRootFromGitCommonDir(await getGitCommonDir(cwd));
+    ensureJunctionGitignore(repoRoot);
+    let worktreePath;
+    const desiredSlug = worktreeSlug || generateWorktreeSlug();
+    worktreePath = join(await getJunctionWorktreesRoot(cwd, junctionHome), desiredSlug);
+    mkdirSync(dirname(worktreePath), { recursive: true });
+    // Check if branch already exists
+    let branchExists = false;
+    try {
+        await execAsync(`git show-ref --verify --quiet refs/heads/${branchName}`, { cwd });
+        branchExists = 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
+    let newBranchName = candidateBranch;
+    let suffix = 1;
+    while (true) {
+        try {
+            await execAsync(`git show-ref --verify --quiet refs/heads/${newBranchName}`, { cwd });
+            // Branch exists, try with suffix
+            newBranchName = `${candidateBranch}-${suffix}`;
+            suffix++;
+        }
+        catch {
+            break;
+        }
+    }
+    // Also handle worktree path collision
+    let finalWorktreePath = worktreePath;
+    let pathSuffix = 1;
+    while (existsSync(finalWorktreePath)) {
+        finalWorktreePath = `${worktreePath}-${pathSuffix}`;
+        pathSuffix++;
+    }
+    const command = `git worktree add "${finalWorktreePath}" -b "${newBranchName}" "${base}"`;
+    await execAsync(command, { cwd });
+    worktreePath = normalizePathForOwnership(finalWorktreePath);
+    writeJunctionWorktreeMetadata(worktreePath, { baseRefName: normalizedBaseBranch });
+    if (runSetup) {
+        await runWorktreeSetupCommands({
+            worktreePath,
+            branchName: newBranchName,
+            cleanupOnFailure: true,
+        });
+    }
+    return {
+        branchName: newBranchName,
+        worktreePath,
+    };
+}
+// ============================================================================
+// In-repo worktree support (.junction/ directory)
+// ============================================================================
+const IN_REPO_WORKTREE_DIR = ".junction";
+/**
+ * Get the root directory for in-repo worktrees: `{repoRoot}/.junction`
+ */
+export function getInRepoWorktreesRoot(repoRoot) {
+    return join(repoRoot, IN_REPO_WORKTREE_DIR);
+}
+/**
+ * List existing worktree directory names inside `{repoRoot}/.junction/`.
+ */
+export function listInRepoWorktreeNames(repoRoot) {
+    const root = getInRepoWorktreesRoot(repoRoot);
+    if (!existsSync(root)) {
+        return [];
+    }
+    try {
+        return readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Ensure `.junction/` is ignored without mutating tracked files.
+ *
+ * Preference order:
+ * 1) If repo `.gitignore` already covers `.junction/`, do nothing.
+ * 2) Otherwise, append to `.git/info/exclude` (local-only ignore rules).
+ */
+export function ensureJunctionGitignore(repoRoot) {
+    const gitignorePath = join(repoRoot, ".gitignore");
+    const gitInfoExcludePath = join(repoRoot, ".git", "info", "exclude");
+    const entry = `/${IN_REPO_WORKTREE_DIR}/`;
+    const normalizedEntries = new Set([
+        entry,
+        IN_REPO_WORKTREE_DIR,
+        `${IN_REPO_WORKTREE_DIR}/`,
+        `/${IN_REPO_WORKTREE_DIR}`,
+    ]);
+    if (existsSync(gitignorePath)) {
+        const content = readFileSync(gitignorePath, "utf8");
+        const lines = content.split("\n").map((l) => l.trim());
+        if (lines.some((line) => normalizedEntries.has(line))) {
+            return;
+        }
+    }
+    const excludeDir = dirname(gitInfoExcludePath);
+    mkdirSync(excludeDir, { recursive: true });
+    const existingExclude = existsSync(gitInfoExcludePath)
+        ? readFileSync(gitInfoExcludePath, "utf8")
+        : "";
+    const excludeLines = existingExclude.split("\n").map((line) => line.trim());
+    if (excludeLines.some((line) => normalizedEntries.has(line))) {
+        return;
+    }
+    const prefix = existingExclude.length > 0 && !existingExclude.endsWith("\n") ? "\n" : "";
+    appendFileSync(gitInfoExcludePath, `${prefix}${entry}\n`, "utf8");
+}
+/**
+ * Check whether a path is already inside an in-repo `.junction/` worktree.
+ */
+export function isInsideInRepoWorktree(cwd) {
+    const parts = cwd.split(sep);
+    return parts.includes(IN_REPO_WORKTREE_DIR);
+}
+/**
+ * Create an in-repo worktree inside `{repoRoot}/.junction/{citySlug}`.
+ *
+ * The branch name is set to the city slug (e.g. "tokyo", "tokyo-v2").
+ */
+export async function createInRepoWorktree({ repoRoot, baseBranch, runSetup = false, }) {
+    ensureJunctionGitignore(repoRoot);
+    const existingNames = listInRepoWorktreeNames(repoRoot);
+    const slug = generateCitySlug(existingNames);
+    const worktreesRoot = getInRepoWorktreesRoot(repoRoot);
+    mkdirSync(worktreesRoot, { recursive: true });
+    const worktreePath = join(worktreesRoot, slug);
+    const normalizedBaseBranch = normalizeBaseRefName(baseBranch);
+    if (!normalizedBaseBranch) {
+        throw new Error("Base branch is required when creating an in-repo worktree");
+    }
+    // Resolve the base branch - try local first, then remote
+    let resolvedBaseBranch = normalizedBaseBranch;
+    try {
+        await execAsync(`git rev-parse --verify ${normalizedBaseBranch}`, { cwd: repoRoot });
+    }
+    catch {
+        try {
+            await execAsync(`git rev-parse --verify origin/${normalizedBaseBranch}`, { cwd: repoRoot });
+            resolvedBaseBranch = `origin/${normalizedBaseBranch}`;
+        }
+        catch {
+            throw new Error(`Base branch not found: ${normalizedBaseBranch}`);
+        }
+    }
+    // Find a unique branch name (city slug may collide with existing branches)
+    let branchName = slug;
+    let branchSuffix = 2;
+    while (true) {
+        try {
+            await execAsync(`git show-ref --verify --quiet refs/heads/${branchName}`, { cwd: repoRoot });
+            branchName = `${slug}-b${branchSuffix}`;
+            branchSuffix++;
+        }
+        catch {
+            break;
+        }
+    }
+    const command = `git worktree add "${worktreePath}" -b "${branchName}" "${resolvedBaseBranch}"`;
+    await execAsync(command, { cwd: repoRoot });
+    const resolvedWorktreePath = normalizePathForOwnership(worktreePath);
+    writeJunctionWorktreeMetadata(resolvedWorktreePath, { baseRefName: normalizedBaseBranch });
+    if (runSetup) {
+        await runWorktreeSetupCommands({
+            worktreePath: resolvedWorktreePath,
+            branchName,
+            cleanupOnFailure: true,
+        });
+    }
+    return {
+        branchName,
+        worktreePath: resolvedWorktreePath,
+        slug,
+    };
+}
+//# sourceMappingURL=worktree.js.map