@loucompanion/forge-bridge 0.1.1-dev.8dcbc6245e51 → 0.1.1-dev.9219f8477b8a

package/dist/worktree/worktree.service.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { GitClient } from "../shared/git/git.js";
 import { ensureDirectory, isSubPath, resolveExistingDirectoryPath, safeSegment } from "../shared/path/path.js";
-import { injectWorktreeArtifacts } from "./artifact-injector.js";
+import { filterArtifactsForLane, injectWorktreeArtifacts } from "./artifact-injector.js";
 import { warmWorktreeDependencies } from "./dependency-warmer.js";
 export class GitWorktreeService {
     git;
@@ -17,9 +17,12 @@ export class GitWorktreeService {
         await this.ensureBaseBranch(repoPath, baseBranch);
         const shortId = request.workItem.id.replace(/-/g, "").slice(0, 12);
         const kind = safeSegment(request.workItem.kind, "work-item");
-        const branchName = normalizeBranchName(`${kind}/${shortId}`, "work-item/unknown");
-        const worktreeRoot = path.join(path.dirname(repoPath), ".forge-worktrees", path.basename(repoPath));
-        const worktreePath = path.join(worktreeRoot, kind, shortId);
+        const fallbackWorktreeKey = `${kind}/${shortId}`;
+        const worktreeKey = request.worktreeKey?.trim() || fallbackWorktreeKey;
+        const worktreeSegments = worktreeKeySegments(worktreeKey, kind, shortId);
+        const branchName = normalizeBranchName(worktreeSegments.join("/"), "work-item/unknown");
+        const worktreeRoot = resolveWorktreeRoot(allowedRoot, repoPath);
+        const worktreePath = path.join(worktreeRoot, ...worktreeSegments);
         const resolvedWorktreeParent = await ensureDirectory(path.dirname(worktreePath));
         if (!isSubPath(allowedRoot, resolvedWorktreeParent)) {
             throw new Error(`Worktree path must stay under ${allowedRoot}.`);
@@ -35,10 +38,17 @@ export class GitWorktreeService {
             if (!isSubPath(allowedRoot, resolvedWorktreePath)) {
                 throw new Error(`Worktree path must stay under ${allowedRoot}.`);
             }
+            const currentBranch = await this.currentBranch(resolvedWorktreePath);
+            if (currentBranch !== branchName) {
+                throw new Error(`Existing worktree ${resolvedWorktreePath} is on branch '${currentBranch}', expected '${branchName}'.`);
+            }
         }
         await this.ensureGitIdentity(resolvedWorktreePath);
-        if (request.artifacts.length > 0) {
-            await injectWorktreeArtifacts(resolvedWorktreePath, request.artifacts);
+        await clearRunArtifactRoots(resolvedWorktreePath, request);
+        const qaReworkPacketPath = await materializeQaReworkPacket(resolvedWorktreePath, request);
+        const artifacts = filterArtifactsForLane(request.artifacts, request.lane, request.phase);
+        if (artifacts.length > 0) {
+            await injectWorktreeArtifacts(resolvedWorktreePath, artifacts);
         }
         const dependencyWarm = await warmWorktreeDependencies({
             baseCheckoutPath: repoPath,
@@ -52,7 +62,8 @@ export class GitWorktreeService {
             branchName,
             baseBranch,
             cleanupWorktrees: request.cleanupWorktrees,
-            dependencyWarm
+            dependencyWarm,
+            qaReworkPacketPath
         };
     }
     async release(handle) {
@@ -78,7 +89,11 @@ export class GitWorktreeService {
         if (!repo.cloneOnDemand) {
             throw new Error("Repo has no server-local path and cloneOnDemand is disabled.");
         }
-        const repoPath = path.join(allowedRoot, `${safeSegment(repo.name, "repo")}-${repo.id.replace(/-/g, "")}`);
+        const discovered = await this.findExistingRepoPath(repo, allowedRoot);
+        if (discovered) {
+            return discovered;
+        }
+        const repoPath = path.join(managedRepoRoot(allowedRoot), `${safeSegment(repo.name, "repo")}-${repo.id.replace(/-/g, "")}`);
         if (!(await gitMetadataExists(repoPath, allowedRoot))) {
             const repoPathExists = await pathExists(repoPath);
             if (repoPathExists) {
@@ -109,6 +124,46 @@ export class GitWorktreeService {
         }
         return resolved;
     }
+    async findExistingRepoPath(repo, allowedRoot) {
+        const expectedRemote = normalizeRemote(repo.remoteUrl);
+        const rawName = repo.name.trim();
+        const nameCandidates = uniqueStrings([
+            isSinglePathSegment(rawName) ? path.join(allowedRoot, rawName) : "",
+            path.join(allowedRoot, safeSegment(repo.name, "repo"))
+        ]);
+        for (const candidate of nameCandidates) {
+            const resolved = await this.resolveMatchingRepo(candidate, allowedRoot, expectedRemote);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        if (expectedRemote.length > 0) {
+            const entries = await fs.readdir(allowedRoot, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name === ".forge-worktrees") {
+                    continue;
+                }
+                const resolved = await this.resolveMatchingRepo(path.join(allowedRoot, entry.name), allowedRoot, expectedRemote);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+        return null;
+    }
+    async resolveMatchingRepo(candidate, allowedRoot, expectedRemote) {
+        if (!(await gitMetadataExists(candidate, allowedRoot))) {
+            return null;
+        }
+        if (expectedRemote.length > 0) {
+            const origin = await this.git.run(candidate, ["remote", "get-url", "origin"]).catch(() => "");
+            if (normalizeRemote(origin) !== expectedRemote) {
+                return null;
+            }
+        }
+        const resolved = await resolveExistingDirectoryPath(candidate);
+        return isSubPath(allowedRoot, resolved) ? resolved : null;
+    }
     async ensureBaseBranch(repoPath, baseBranch) {
         if (await this.gitRefExists(repoPath, `refs/heads/${baseBranch}`)) {
             return;
@@ -127,11 +182,23 @@ export class GitWorktreeService {
     async gitRefExists(repoPath, gitRef) {
         return this.git.run(repoPath, ["show-ref", "--verify", "--quiet", gitRef]).then(() => true).catch(() => false);
     }
+    async currentBranch(repoPath) {
+        return (await this.git.run(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    }
     async ensureGitIdentity(repoPath) {
         await this.git.run(repoPath, ["config", "user.email", "forge-bridge@forge.local"]);
         await this.git.run(repoPath, ["config", "user.name", "Forge Bridge"]);
     }
 }
+function managedRepoRoot(allowedRoot) {
+    return path.join(allowedRoot, ".forge-worktrees", "_repos");
+}
+function resolveWorktreeRoot(allowedRoot, repoPath) {
+    const baseName = path.basename(repoPath);
+    return isSubPath(managedRepoRoot(allowedRoot), repoPath)
+        ? path.join(allowedRoot, ".forge-worktrees", baseName)
+        : path.join(path.dirname(repoPath), ".forge-worktrees", baseName);
+}
 function isCloneableRemote(remoteUrl) {
     const trimmed = remoteUrl?.trim() ?? "";
     if (trimmed.length === 0 || trimmed.startsWith("local://")) {
@@ -139,6 +206,76 @@ function isCloneableRemote(remoteUrl) {
     }
     return trimmed.startsWith("git@") || trimmed.includes("://") || path.isAbsolute(trimmed);
 }
+async function clearRunArtifactRoots(worktreePath, request) {
+    const roots = new Set();
+    roots.add(workItemArtifactRoot(worktreePath, request.workItem.id));
+    const ownerType = normalizeOwnerType(request.ownerType);
+    const ownerId = request.ownerId?.trim();
+    if (ownerType && ownerId) {
+        roots.add(ownerArtifactRoot(worktreePath, ownerType, ownerId));
+    }
+    for (const root of roots) {
+        const resolvedRoot = path.resolve(root);
+        if (!isSubPath(worktreePath, resolvedRoot)) {
+            throw new Error(`Artifact root must stay under ${worktreePath}.`);
+        }
+        await ensureNoSymlinkPathSegments(worktreePath, resolvedRoot, "Artifact root must not traverse symlinked path segments.");
+        await fs.rm(resolvedRoot, { recursive: true, force: true });
+        await fs.mkdir(resolvedRoot, { recursive: true });
+    }
+}
+async function materializeQaReworkPacket(worktreePath, request) {
+    const qaRework = request.qaRework;
+    if (!qaRework) {
+        return undefined;
+    }
+    const artifactRoot = artifactRootForRequest(worktreePath, request);
+    const packetFileName = qaReworkPacketFileName(qaRework.packetPath);
+    const packetPath = path.join(artifactRoot, packetFileName);
+    const paths = new Set([packetPath, path.join(artifactRoot, "qa-rework-packet.json")]);
+    const packetJson = qaRework.packetJson.endsWith("\n") ? qaRework.packetJson : `${qaRework.packetJson}\n`;
+    for (const target of paths) {
+        const resolvedTarget = path.resolve(target);
+        if (!isSubPath(worktreePath, resolvedTarget)) {
+            throw new Error(`QA rework packet path must stay under ${worktreePath}.`);
+        }
+        await ensureNoSymlinkPathSegments(worktreePath, path.dirname(resolvedTarget), "QA rework packet path must not traverse symlinked path segments.");
+        await fs.mkdir(path.dirname(resolvedTarget), { recursive: true });
+        await fs.writeFile(resolvedTarget, packetJson, "utf8");
+    }
+    return path.resolve(packetPath);
+}
+function artifactRootForRequest(worktreePath, request) {
+    const ownerType = normalizeOwnerType(request.ownerType);
+    const ownerId = request.ownerId?.trim();
+    if (ownerType && ownerId) {
+        return ownerArtifactRoot(worktreePath, ownerType, ownerId);
+    }
+    return workItemArtifactRoot(worktreePath, request.workItem.id);
+}
+function workItemArtifactRoot(worktreePath, workItemId) {
+    return path.join(worktreePath, ".forge", "work-items", safeSegment(workItemId, "work item id"), "artifacts");
+}
+function ownerArtifactRoot(worktreePath, ownerType, ownerId) {
+    return path.join(worktreePath, ".forge", ownerType === "story" ? "stories" : "work-items", safeSegment(ownerId, "owner id"), "artifacts");
+}
+function normalizeOwnerType(value) {
+    const normalized = (value ?? "").trim().toLowerCase().replace(/-/g, "_");
+    if (normalized === "story") {
+        return "story";
+    }
+    if (normalized === "work_item" || normalized === "workitem" || normalized === "work item") {
+        return "work_item";
+    }
+    return null;
+}
+function qaReworkPacketFileName(packetPath) {
+    const normalized = packetPath.trim().replace(/\\/g, "/");
+    const fileName = normalized.split("/").filter(Boolean).at(-1) ?? "";
+    return /^qa-rework-packet(?:\.attempt-\d+)?\.json$/i.test(fileName)
+        ? fileName
+        : "qa-rework-packet.json";
+}
 export function normalizeBranchName(value, fallback) {
     const branch = (value?.trim() || fallback).trim();
     if (branch.length === 0 ||
@@ -151,6 +288,7 @@ export function normalizeBranchName(value, fallback) {
         branch.endsWith(".") ||
         branch.toLowerCase().endsWith(".lock") ||
         /\s/.test(branch) ||
+        // eslint-disable-next-line no-control-regex -- Git branch validation must reject ASCII control characters.
         /[\u0000-\u001f~^:?*[\\]/.test(branch) ||
         branch.split("/").some((part) => part.length === 0 || part.startsWith(".") || part.toLowerCase().endsWith(".lock"))) {
         throw new Error("Git branch name must be valid, without whitespace, and cannot start with '-'.");
@@ -187,6 +325,39 @@ async function gitMetadataExists(repoPath, allowedRoot) {
     const resolvedGitDir = await resolveExistingDirectoryPath(gitDirPath);
     return isSubPath(allowedRoot, resolvedGitDir);
 }
+async function ensureNoSymlinkPathSegments(root, targetPath, errorMessage) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedTarget = path.resolve(targetPath);
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(errorMessage);
+    }
+    let current = resolvedRoot;
+    const rootStat = await fs.lstat(current);
+    if (rootStat.isSymbolicLink()) {
+        throw new Error(errorMessage);
+    }
+    if (!relative) {
+        return;
+    }
+    for (const segment of relative.split(path.sep)) {
+        if (!segment) {
+            continue;
+        }
+        current = path.join(current, segment);
+        const stat = await fs.lstat(current).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!stat) {
+            return;
+        }
+        if (stat.isSymbolicLink()) {
+            throw new Error(errorMessage);
+        }
+    }
+}
 async function pathExists(inputPath) {
     return fs.stat(inputPath).then(() => true).catch(() => false);
 }
@@ -194,3 +365,63 @@ async function directoryExists(inputPath) {
     const stat = await fs.stat(inputPath).catch(() => null);
     return stat?.isDirectory() ?? false;
 }
+function uniqueStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+function worktreeKeySegments(worktreeKey, fallbackKind, fallbackShortId) {
+    const segments = worktreeKey
+        .split("/")
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0)
+        .map((segment) => safeSegment(segment, "worktree"));
+    return segments.length > 0 ? segments : [fallbackKind, fallbackShortId];
+}
+function isSinglePathSegment(value) {
+    return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\");
+}
+function normalizeRemote(remoteUrl) {
+    const trimmed = remoteUrl?.trim() ?? "";
+    if (trimmed.length === 0) {
+        return "";
+    }
+    const gitHubSsh = /^git@github\.com:(.+)$/i.exec(trimmed);
+    if (gitHubSsh) {
+        return stripGitSuffix(`https://github.com/${gitHubSsh[1]}`).toLowerCase();
+    }
+    if (path.isAbsolute(trimmed)) {
+        return normalizeLocalPath(trimmed);
+    }
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol === "file:") {
+            return normalizeLocalPath(normalizeFileUrlPath(url));
+        }
+        url.username = "";
+        url.password = "";
+        url.hash = "";
+        return stripGitSuffix(url.toString().replace(/\/$/, "")).toLowerCase();
+    }
+    catch {
+        return stripGitSuffix(trimmed.replace(/\\/g, "/")).toLowerCase();
+    }
+}
+function stripGitSuffix(value) {
+    return value.replace(/\.git$/i, "").replace(/\/$/, "");
+}
+function normalizeFileUrlPath(url) {
+    const pathname = decodeURIComponent(url.pathname);
+    return /^\/[A-Za-z]:[\\/]/.test(pathname) ? pathname.slice(1) : pathname;
+}
+function normalizeLocalPath(value) {
+    const normalized = path.resolve(value).replace(/\\/g, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/worktree/worktree.types.d.ts

@@ -1,12 +1,18 @@
-import type { DispatchRepo, DispatchWorkItem, DispatchResolvedArtifact } from "../session/session.types.js";
+import type { DispatchQaReworkContext, DispatchRepo, DispatchWorkItem, DispatchResolvedArtifact } from "../session/session.types.js";
 import type { WarmDependenciesResult } from "./dependency-warmer.js";
 export interface WorktreePrepareRequest {
     readonly repo: DispatchRepo;
     readonly workItem: DispatchWorkItem;
     readonly baseBranch: string;
+    readonly worktreeKey?: string | null;
+    readonly ownerType?: string | null;
+    readonly ownerId?: string | null;
+    readonly lane: string;
+    readonly phase: string;
     readonly allowedRepoRoot: string;
     readonly cleanupWorktrees: boolean;
     readonly artifacts: readonly DispatchResolvedArtifact[];
+    readonly qaRework?: DispatchQaReworkContext | null;
     readonly warmPathOverrides?: readonly string[];
 }
 export interface WorktreeHandle {
@@ -16,4 +22,5 @@ export interface WorktreeHandle {
     readonly baseBranch: string;
     readonly cleanupWorktrees: boolean;
     readonly dependencyWarm?: WarmDependenciesResult;
+    readonly qaReworkPacketPath?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.1-dev.8dcbc6245e51",
+  "version": "0.1.1-dev.9219f8477b8a",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",
@@ -30,7 +30,7 @@
     "url": "https://github.com/coleman399/Forge/issues"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.13.0"
   },
   "publishConfig": {
     "access": "public"
@@ -39,14 +39,19 @@
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest",
-    "smoke:package": "npm run build && node scripts/smoke-package.mjs"
+    "smoke:package": "npm run build && node scripts/smoke-package.mjs",
+    "lint": "eslint \"src/**/*.ts\" \"scripts/**/*.mjs\" \"vitest.config.ts\""
   },
   "dependencies": {
     "@microsoft/signalr": "^8.0.17"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/node": "^22.15.32",
+    "eslint": "^10.5.0",
+    "globals": "^17.6.0",
     "typescript": "^5.8.3",
+    "typescript-eslint": "^8.61.1",
     "vitest": "^3.2.3"
   }
 }