pi-forge 1.3.4 → 1.3.6

package/dist/server/routes/git.js

@@ -1,6 +1,7 @@
-import { GitCommandError, GitNotInstalledError, InvalidBranchNameError, checkoutBranch, commit, createBranch, deleteBranch, fetch, addRemote, getBranches, getRemotes, removeRemote, getDiff, getFileDiff, getLog, getStagedDiff, getStatus, initRepo, isGitRepo, pull, push, revertPaths, stagePaths, unstagePaths, } from "../git-runner.js";
+import { GitCommandError, GitNotInstalledError, InvalidBranchNameError, checkoutBranch, commit, createBranch, deleteBranch, fetch, addRemote, getBranches, getRemotes, removeRemote, getDiff, getFileDiff, getLog, getStagedDiff, getStatus, getWorktrees, initRepo, isGitRepo, pull, push, revertPaths, stagePaths, unstagePaths, } from "../git-runner.js";
 import { applyHunks, HunkStagingError } from "../git-hunk-stager.js";
 import { config } from "../config.js";
+import { PathOutsideRootError } from "../file-manager.js";
 import { getProject } from "../project-manager.js";
 import { errorSchema } from "./_schemas.js";
 /* ----------------------------- schemas ----------------------------- */
@@ -107,6 +108,34 @@ const remotesSchema = {
         },
     },
 };
+const worktreesSchema = {
+    type: "object",
+    required: ["isGitRepo", "worktrees"],
+    properties: {
+        isGitRepo: { type: "boolean" },
+        worktrees: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["path", "bare", "detached", "current"],
+                properties: {
+                    path: { type: "string" },
+                    head: { type: "string" },
+                    branch: { type: "string" },
+                    bare: { type: "boolean" },
+                    detached: { type: "boolean" },
+                    current: { type: "boolean" },
+                },
+            },
+        },
+    },
+};
+class InvalidWorktreePathError extends Error {
+    constructor(path) {
+        super(`invalid worktree path: ${path}`);
+        this.name = "InvalidWorktreePathError";
+    }
+}
 /* ----------------------------- error mapping ----------------------------- */
 function mapError(reply, err) {
     if (err instanceof GitNotInstalledError) {
@@ -118,6 +147,12 @@ function mapError(reply, err) {
     if (err instanceof InvalidBranchNameError) {
         return reply.code(400).send({ error: "invalid_branch_name", message: err.message });
     }
+    if (err instanceof InvalidWorktreePathError) {
+        return reply.code(400).send({ error: "invalid_worktree_path", message: err.message });
+    }
+    if (err instanceof PathOutsideRootError) {
+        return reply.code(403).send({ error: "path_not_allowed", message: "path outside workspace" });
+    }
     if (err instanceof GitCommandError) {
         // Git "rejected" / "non-fast-forward" / commit hook failures /
         // missing upstream are user-actionable, not server bugs. 400
@@ -173,6 +208,36 @@ async function withProject(projectId, reply, fn) {
         return mapError(reply, err);
     }
 }
+async function resolveGitCwd(project, worktreePath) {
+    if (worktreePath === undefined)
+        return project.path;
+    const listed = await getWorktrees(project.path);
+    const match = listed.worktrees.find((w) => w.path === worktreePath);
+    if (match === undefined)
+        throw new InvalidWorktreePathError(worktreePath);
+    return match.path;
+}
+async function withGitCwd(projectId, worktreePath, reply, fn) {
+    const project = await resolveProject(projectId, reply);
+    if (project === undefined)
+        return reply;
+    try {
+        const cwd = await resolveGitCwd(project, worktreePath);
+        return await fn(cwd);
+    }
+    catch (err) {
+        return mapError(reply, err);
+    }
+}
+const projectWorktreeQuerySchema = {
+    type: "object",
+    required: ["projectId"],
+    properties: {
+        projectId: { type: "string", minLength: 1 },
+        worktreePath: { type: "string", minLength: 1 },
+    },
+};
+const worktreeBodyProperty = { worktreePath: { type: "string", minLength: 1 } };
 /* ----------------------------- routes ----------------------------- */
 export const gitRoutes = async (fastify) => {
     fastify.post("/git/init", {
@@ -230,48 +295,65 @@ export const gitRoutes = async (fastify) => {
                 "`{ isGitRepo: false, files: [] }` (NOT 500) so the panel can sit " +
                 "quiet on plain folders.",
             tags: ["git"],
+            querystring: projectWorktreeQuerySchema,
+            response: {
+                200: statusSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
+            },
+        },
+    }, async (req, reply) => withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getStatus(cwd)));
+    fastify.get("/git/worktrees", {
+        schema: {
+            description: "List registered git worktrees for the project's repository. Returned absolute paths " +
+                "can be passed back as `worktreePath` to git routes and are accepted only if still registered.",
+            tags: ["git"],
             querystring: {
                 type: "object",
                 required: ["projectId"],
                 properties: { projectId: { type: "string", minLength: 1 } },
             },
-            response: { 200: statusSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
+            response: {
+                200: worktreesSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
+            },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.query.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            return await getStatus(project.path);
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withProject(req.query.projectId, reply, async (p) => {
+        return getWorktrees(p.path);
+    }));
     fastify.get("/git/diff", {
         schema: {
             description: "Unstaged unified diff for the project (working tree vs index).",
             tags: ["git"],
-            querystring: {
-                type: "object",
-                required: ["projectId"],
-                properties: { projectId: { type: "string", minLength: 1 } },
+            querystring: projectWorktreeQuerySchema,
+            response: {
+                200: diffSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
             },
-            response: { 200: diffSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
         },
-    }, async (req, reply) => withProject(req.query.projectId, reply, (p) => getDiff(p.path)));
+    }, async (req, reply) => withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getDiff(cwd)));
     fastify.get("/git/diff/staged", {
         schema: {
             description: "Staged unified diff (index vs HEAD).",
             tags: ["git"],
-            querystring: {
-                type: "object",
-                required: ["projectId"],
-                properties: { projectId: { type: "string", minLength: 1 } },
+            querystring: projectWorktreeQuerySchema,
+            response: {
+                200: diffSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
             },
-            response: { 200: diffSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
         },
-    }, async (req, reply) => withProject(req.query.projectId, reply, (p) => getStagedDiff(p.path)));
+    }, async (req, reply) => withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getStagedDiff(cwd)));
     fastify.get("/git/diff/file", {
         schema: {
             description: "Unified diff for a single file. `?staged=1` for the index↔HEAD diff; " +
@@ -284,13 +366,20 @@ export const gitRoutes = async (fastify) => {
                     projectId: { type: "string", minLength: 1 },
                     path: { type: "string", minLength: 1 },
                     staged: { type: "string", enum: ["0", "1", "true", "false"] },
+                    worktreePath: { type: "string", minLength: 1 },
                 },
             },
-            response: { 200: diffSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
+            response: {
+                200: diffSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
+            },
         },
     }, async (req, reply) => {
         const staged = req.query.staged === "1" || req.query.staged === "true";
-        return withProject(req.query.projectId, reply, (p) => getFileDiff(p.path, req.query.path, staged));
+        return withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getFileDiff(cwd, req.query.path, staged));
     });
     fastify.get("/git/log", {
         schema: {
@@ -302,41 +391,52 @@ export const gitRoutes = async (fastify) => {
                 properties: {
                     projectId: { type: "string", minLength: 1 },
                     limit: { type: "string", pattern: "^[0-9]+$" },
+                    worktreePath: { type: "string", minLength: 1 },
                 },
             },
-            response: { 200: logSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
+            response: {
+                200: logSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
+            },
         },
     }, async (req, reply) => {
         const limit = req.query.limit !== undefined
             ? Math.min(1000, Math.max(1, Number.parseInt(req.query.limit, 10)))
             : 30;
-        return withProject(req.query.projectId, reply, (p) => getLog(p.path, limit));
+        return withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getLog(cwd, limit));
     });
     fastify.get("/git/branches", {
         schema: {
             description: "Local + remote branch list with `current` flag.",
             tags: ["git"],
-            querystring: {
-                type: "object",
-                required: ["projectId"],
-                properties: { projectId: { type: "string", minLength: 1 } },
+            querystring: projectWorktreeQuerySchema,
+            response: {
+                200: branchesSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
             },
-            response: { 200: branchesSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
         },
-    }, async (req, reply) => withProject(req.query.projectId, reply, (p) => getBranches(p.path)));
+    }, async (req, reply) => withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getBranches(cwd)));
     fastify.get("/git/remotes", {
         schema: {
             description: "Configured git remotes with their fetch + push URLs. " +
                 "Empty array for non-git projects or repos with no remotes.",
             tags: ["git"],
-            querystring: {
-                type: "object",
-                required: ["projectId"],
-                properties: { projectId: { type: "string", minLength: 1 } },
+            querystring: projectWorktreeQuerySchema,
+            response: {
+                200: remotesSchema,
+                400: errorSchema,
+                403: errorSchema,
+                404: errorSchema,
+                500: errorSchema,
             },
-            response: { 200: remotesSchema, 400: errorSchema, 404: errorSchema, 500: errorSchema },
         },
-    }, async (req, reply) => withProject(req.query.projectId, reply, (p) => getRemotes(p.path)));
+    }, async (req, reply) => withGitCwd(req.query.projectId, req.query.worktreePath, reply, (cwd) => getRemotes(cwd)));
     fastify.post("/git/remote/add", {
         schema: {
             description: "Add a git remote (`git remote add <name> <url>`). Name is " +
@@ -352,6 +452,7 @@ export const gitRoutes = async (fastify) => {
                     projectId: { type: "string", minLength: 1 },
                     name: { type: "string", minLength: 1 },
                     url: { type: "string", minLength: 1, maxLength: 1024 },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -361,18 +462,10 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            await addRemote(project.path, req.body.name, req.body.url);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        await addRemote(cwd, req.body.name, req.body.url);
+        return { ok: true };
+    }));
     fastify.delete("/git/remote/:name", {
         schema: {
             description: "Remove a git remote (`git remote remove <name>`). 400 " +
@@ -383,11 +476,7 @@ export const gitRoutes = async (fastify) => {
                 required: ["name"],
                 properties: { name: { type: "string", minLength: 1 } },
             },
-            querystring: {
-                type: "object",
-                required: ["projectId"],
-                properties: { projectId: { type: "string", minLength: 1 } },
-            },
+            querystring: projectWorktreeQuerySchema,
             response: {
                 200: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"] },
                 400: errorSchema,
@@ -395,18 +484,10 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.query.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            await removeRemote(project.path, req.params.name);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.query.projectId, req.query.worktreePath, reply, async (cwd) => {
+        await removeRemote(cwd, req.params.name);
+        return { ok: true };
+    }));
     fastify.post("/git/checkout", {
         schema: {
             description: "Switch the working tree to `branch`. Refuses on a dirty tree (git's " +
@@ -421,6 +502,7 @@ export const gitRoutes = async (fastify) => {
                 properties: {
                     projectId: { type: "string", minLength: 1 },
                     branch: { type: "string", minLength: 1 },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -430,18 +512,10 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            await checkoutBranch(project.path, req.body.branch);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        await checkoutBranch(cwd, req.body.branch);
+        return { ok: true };
+    }));
     fastify.post("/git/branch/create", {
         schema: {
             description: "Create a local branch. `startPoint` (defaults to HEAD) accepts any ref " +
@@ -457,6 +531,7 @@ export const gitRoutes = async (fastify) => {
                     name: { type: "string", minLength: 1 },
                     startPoint: { type: "string", minLength: 1 },
                     checkout: { type: "boolean" },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -466,23 +541,15 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            const opts = {};
-            if (req.body.startPoint !== undefined)
-                opts.startPoint = req.body.startPoint;
-            if (req.body.checkout !== undefined)
-                opts.checkout = req.body.checkout;
-            await createBranch(project.path, req.body.name, opts);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        const opts = {};
+        if (req.body.startPoint !== undefined)
+            opts.startPoint = req.body.startPoint;
+        if (req.body.checkout !== undefined)
+            opts.checkout = req.body.checkout;
+        await createBranch(cwd, req.body.name, opts);
+        return { ok: true };
+    }));
     fastify.delete("/git/branch/:name", {
         schema: {
             description: "Delete a local branch via `git branch -d <name>`. `?force=1` switches " +
@@ -500,6 +567,7 @@ export const gitRoutes = async (fastify) => {
                 properties: {
                     projectId: { type: "string", minLength: 1 },
                     force: { type: "string", enum: ["0", "1", "true", "false"] },
+                    worktreePath: { type: "string", minLength: 1 },
                 },
             },
             response: {
@@ -510,17 +578,11 @@ export const gitRoutes = async (fastify) => {
             },
         },
     }, async (req, reply) => {
-        const project = await resolveProject(req.query.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            const force = req.query.force === "1" || req.query.force === "true";
-            await deleteBranch(project.path, req.params.name, { force });
+        const force = req.query.force === "1" || req.query.force === "true";
+        return withGitCwd(req.query.projectId, req.query.worktreePath, reply, async (cwd) => {
+            await deleteBranch(cwd, req.params.name, { force });
             return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
+        });
     });
     fastify.post("/git/stage", {
         schema: {
@@ -543,6 +605,7 @@ export const gitRoutes = async (fastify) => {
                         // even a very wide repo land well under 1000 paths.
                         maxItems: 1000,
                     },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -552,18 +615,10 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            await stagePaths(project.path, req.body.paths);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        await stagePaths(cwd, req.body.paths);
+        return { ok: true };
+    }));
     fastify.post("/git/unstage", {
         schema: {
             description: "Unstage one or more files (`git restore --staged -- <paths>`).",
@@ -585,6 +640,7 @@ export const gitRoutes = async (fastify) => {
                         // even a very wide repo land well under 1000 paths.
                         maxItems: 1000,
                     },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -594,18 +650,10 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            await unstagePaths(project.path, req.body.paths);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        await unstagePaths(cwd, req.body.paths);
+        return { ok: true };
+    }));
     fastify.post("/git/apply-hunks", {
         schema: {
             description: "Stage or unstage selected hunks of a single file. Builds a " +
@@ -630,6 +678,7 @@ export const gitRoutes = async (fastify) => {
                         minItems: 1,
                         maxItems: 1_000,
                     },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -647,12 +696,9 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
         try {
-            const { totalHunks } = await applyHunks(project.path, req.body.path, req.body.hunkIndices, req.body.mode);
+            const { totalHunks } = await applyHunks(cwd, req.body.path, req.body.hunkIndices, req.body.mode);
             return { ok: true, totalHunks };
         }
         catch (err) {
@@ -663,9 +709,9 @@ export const gitRoutes = async (fastify) => {
             if (err instanceof HunkStagingError) {
                 return { ok: false, error: err.code, totalHunks: 0 };
             }
-            return mapError(reply, err);
+            throw err;
         }
-    });
+    }));
     fastify.post("/git/revert", {
         schema: {
             description: "Discard local changes for the given files via `git restore " +
@@ -692,6 +738,7 @@ export const gitRoutes = async (fastify) => {
                         // even a very wide repo land well under 1000 paths.
                         maxItems: 1000,
                     },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -701,18 +748,10 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            await revertPaths(project.path, req.body.paths);
-            return { ok: true };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        await revertPaths(cwd, req.body.paths);
+        return { ok: true };
+    }));
     fastify.post("/git/commit", {
         schema: {
             description: "Commit the currently-staged changes. Pre-commit hooks fire as " +
@@ -726,6 +765,7 @@ export const gitRoutes = async (fastify) => {
                 properties: {
                     projectId: { type: "string", minLength: 1 },
                     message: { type: "string", minLength: 1 },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -740,19 +780,11 @@ export const gitRoutes = async (fastify) => {
             },
         },
     }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
         const message = req.body.message.trim();
         if (message.length === 0) {
             return reply.code(400).send({ error: "empty_message" });
         }
-        try {
-            return await commit(project.path, message);
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
+        return withGitCwd(req.body.projectId, req.body.worktreePath, reply, (cwd) => commit(cwd, message));
     });
     fastify.post("/git/fetch", {
         schema: {
@@ -768,6 +800,7 @@ export const gitRoutes = async (fastify) => {
                     projectId: { type: "string", minLength: 1 },
                     remote: { type: "string", minLength: 1 },
                     prune: { type: "boolean" },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -777,23 +810,15 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            const opts = {};
-            if (req.body.remote !== undefined)
-                opts.remote = req.body.remote;
-            if (req.body.prune !== undefined)
-                opts.prune = req.body.prune;
-            const { stdout } = await fetch(project.path, opts);
-            return { output: stdout };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        const opts = {};
+        if (req.body.remote !== undefined)
+            opts.remote = req.body.remote;
+        if (req.body.prune !== undefined)
+            opts.prune = req.body.prune;
+        const { stdout } = await fetch(cwd, opts);
+        return { output: stdout };
+    }));
     fastify.post("/git/pull", {
         schema: {
             description: "git pull — fetches AND merges (or rebases with `rebase: true`). " +
@@ -810,6 +835,7 @@ export const gitRoutes = async (fastify) => {
                     remote: { type: "string", minLength: 1 },
                     branch: { type: "string", minLength: 1 },
                     rebase: { type: "boolean" },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -819,25 +845,17 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            const opts = {};
-            if (req.body.remote !== undefined)
-                opts.remote = req.body.remote;
-            if (req.body.branch !== undefined)
-                opts.branch = req.body.branch;
-            if (req.body.rebase !== undefined)
-                opts.rebase = req.body.rebase;
-            const { stdout } = await pull(project.path, opts);
-            return { output: stdout };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        const opts = {};
+        if (req.body.remote !== undefined)
+            opts.remote = req.body.remote;
+        if (req.body.branch !== undefined)
+            opts.branch = req.body.branch;
+        if (req.body.rebase !== undefined)
+            opts.rebase = req.body.rebase;
+        const { stdout } = await pull(cwd, opts);
+        return { output: stdout };
+    }));
     fastify.post("/git/push", {
         config: {
             rateLimit: {
@@ -862,6 +880,7 @@ export const gitRoutes = async (fastify) => {
                     remote: { type: "string", minLength: 1 },
                     branch: { type: "string", minLength: 1 },
                     setUpstream: { type: "boolean" },
+                    ...worktreeBodyProperty,
                 },
             },
             response: {
@@ -875,24 +894,16 @@ export const gitRoutes = async (fastify) => {
                 500: errorSchema,
             },
         },
-    }, async (req, reply) => {
-        const project = await resolveProject(req.body.projectId, reply);
-        if (project === undefined)
-            return reply;
-        try {
-            const opts = {};
-            if (req.body.remote !== undefined)
-                opts.remote = req.body.remote;
-            if (req.body.branch !== undefined)
-                opts.branch = req.body.branch;
-            if (req.body.setUpstream !== undefined)
-                opts.setUpstream = req.body.setUpstream;
-            const { stdout } = await push(project.path, opts);
-            return { output: stdout };
-        }
-        catch (err) {
-            return mapError(reply, err);
-        }
-    });
+    }, async (req, reply) => withGitCwd(req.body.projectId, req.body.worktreePath, reply, async (cwd) => {
+        const opts = {};
+        if (req.body.remote !== undefined)
+            opts.remote = req.body.remote;
+        if (req.body.branch !== undefined)
+            opts.branch = req.body.branch;
+        if (req.body.setUpstream !== undefined)
+            opts.setUpstream = req.body.setUpstream;
+        const { stdout } = await push(cwd, opts);
+        return { output: stdout };
+    }));
 };
 //# sourceMappingURL=git.js.map