@loucompanion/forge-bridge 0.1.1-dev.32d4dd5874ee → 0.1.1-dev.40fbc494669b

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 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, kind, shortId);
+        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) {
@@ -171,6 +182,9 @@ 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"]);
@@ -192,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 ||
@@ -204,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 '-'.");
@@ -240,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);
 }
@@ -259,6 +377,14 @@ function uniqueStrings(values) {
     }
     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("\\");
 }

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.32d4dd5874ee",
+  "version": "0.1.1-dev.40fbc494669b",
   "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"
   }
 }