@loucompanion/forge-bridge 0.1.1-dev.242bb53ef13f

package/dist/shared/redaction/redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function redactSecrets<T>(value: T, exactSecrets?: readonly string[]): T;
+export declare function redactText(value: string, exactSecrets?: readonly string[]): string;

package/dist/shared/redaction/redaction.js

@@ -0,0 +1,30 @@
+const secretKeyPattern = /(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
+export function redactSecrets(value, exactSecrets = []) {
+    return redactValue(value, exactSecrets);
+}
+export function redactText(value, exactSecrets = []) {
+    let redacted = value;
+    for (const secret of exactSecrets) {
+        if (secret.length > 0) {
+            redacted = redacted.split(secret).join("[REDACTED]");
+        }
+    }
+    return redacted
+        .replace(/(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)(["':=\s]+)([^"',\s]+)/gi, "$1$2[REDACTED]")
+        .replace(/(sk-[a-zA-Z0-9_-]{12,})/g, "[REDACTED]");
+}
+function redactValue(value, exactSecrets) {
+    if (typeof value === "string") {
+        return redactText(value, exactSecrets);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactValue(item, exactSecrets));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        secretKeyPattern.test(key) ? "[REDACTED]" : redactValue(item, exactSecrets)
+    ]));
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const forgeBridgeVersion = "0.1.0";

package/dist/version.js

@@ -0,0 +1 @@
+export const forgeBridgeVersion = "0.1.0";

package/dist/worktree/index.d.ts

@@ -0,0 +1,2 @@
+export { GitWorktreeService } from "./worktree.service.js";
+export type { WorktreeService } from "./worktree.base.js";

package/dist/worktree/index.js

@@ -0,0 +1 @@
+export { GitWorktreeService } from "./worktree.service.js";

package/dist/worktree/internals.d.ts

@@ -0,0 +1,3 @@
+export { normalizeBranchName } from "./worktree.service.js";
+export type { WorktreeService } from "./worktree.base.js";
+export type { WorktreeHandle, WorktreePrepareRequest } from "./worktree.types.js";

package/dist/worktree/internals.js

@@ -0,0 +1 @@
+export { normalizeBranchName } from "./worktree.service.js";

package/dist/worktree/worktree.base.d.ts

@@ -0,0 +1,5 @@
+import type { WorktreeHandle, WorktreePrepareRequest } from "./worktree.types.js";
+export interface WorktreeService {
+    prepare(request: WorktreePrepareRequest): Promise<WorktreeHandle>;
+    release(handle: WorktreeHandle): Promise<void>;
+}

package/dist/worktree/worktree.base.js

@@ -0,0 +1 @@
+export {};

package/dist/worktree/worktree.service.d.ts

@@ -0,0 +1,12 @@
+import { GitClient } from "../shared/git/git.js";
+import type { WorktreeService } from "./worktree.base.js";
+import type { WorktreeHandle, WorktreePrepareRequest } from "./worktree.types.js";
+export declare class GitWorktreeService implements WorktreeService {
+    private readonly git;
+    constructor(git?: GitClient);
+    prepare(request: WorktreePrepareRequest): Promise<WorktreeHandle>;
+    release(handle: WorktreeHandle): Promise<void>;
+    private resolveRepoPath;
+    private ensureGitIdentity;
+}
+export declare function normalizeBranchName(value: string | null | undefined, fallback: string): string;

package/dist/worktree/worktree.service.js

@@ -0,0 +1,139 @@
+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";
+export class GitWorktreeService {
+    git;
+    constructor(git = new GitClient()) {
+        this.git = git;
+    }
+    async prepare(request) {
+        const allowedRoot = await ensureDirectory(request.allowedRepoRoot);
+        const repoPath = await this.resolveRepoPath(request.repo, allowedRoot);
+        const baseBranch = normalizeBranchName(request.baseBranch, "develop");
+        await this.ensureGitIdentity(repoPath);
+        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 resolvedWorktreeParent = await ensureDirectory(path.dirname(worktreePath));
+        if (!isSubPath(allowedRoot, resolvedWorktreeParent)) {
+            throw new Error(`Worktree path must stay under ${allowedRoot}.`);
+        }
+        const exists = await directoryExists(worktreePath);
+        let resolvedWorktreePath;
+        if (!exists) {
+            await this.git.run(repoPath, ["worktree", "add", "-B", branchName, worktreePath, baseBranch]);
+            resolvedWorktreePath = await resolveExistingDirectoryPath(worktreePath);
+        }
+        else {
+            resolvedWorktreePath = await resolveExistingDirectoryPath(worktreePath);
+            if (!isSubPath(allowedRoot, resolvedWorktreePath)) {
+                throw new Error(`Worktree path must stay under ${allowedRoot}.`);
+            }
+        }
+        await this.ensureGitIdentity(resolvedWorktreePath);
+        return {
+            repoPath,
+            worktreePath: resolvedWorktreePath,
+            branchName,
+            baseBranch,
+            cleanupWorktrees: request.cleanupWorktrees
+        };
+    }
+    async release(handle) {
+        if (!handle.cleanupWorktrees || !(await directoryExists(handle.worktreePath))) {
+            return;
+        }
+        try {
+            await this.git.run(handle.repoPath, ["worktree", "remove", "--force", handle.worktreePath]);
+            await this.git.run(handle.repoPath, ["worktree", "prune"]);
+        }
+        catch {
+            await fs.rm(handle.worktreePath, { recursive: true, force: true });
+        }
+    }
+    async resolveRepoPath(repo, allowedRoot) {
+        if (repo.serverLocalPath && repo.serverLocalPath.trim().length > 0) {
+            const requestedPath = await resolveExistingDirectoryPath(repo.serverLocalPath);
+            if (!isSubPath(allowedRoot, requestedPath) || !(await gitMetadataExists(requestedPath, allowedRoot))) {
+                throw new Error(`Repo server-local path must be an existing Git repository under ${allowedRoot}.`);
+            }
+            return requestedPath;
+        }
+        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, "")}`);
+        if (!(await gitMetadataExists(repoPath, allowedRoot))) {
+            await fs.mkdir(repoPath, { recursive: true });
+            await this.git.run(repoPath, ["init", "-b", normalizeBranchName(repo.defaultBranch, "develop")]);
+            await this.ensureGitIdentity(repoPath);
+            await fs.writeFile(path.join(repoPath, "README.md"), `# ${repo.name}\n`, "utf8");
+            await this.git.run(repoPath, ["add", "README.md"]);
+            await this.git.run(repoPath, ["commit", "-m", "seed forge bridge repo"]);
+        }
+        const resolved = await resolveExistingDirectoryPath(repoPath);
+        if (!isSubPath(allowedRoot, resolved)) {
+            throw new Error(`Repo path must stay under ${allowedRoot}.`);
+        }
+        return resolved;
+    }
+    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"]);
+    }
+}
+export function normalizeBranchName(value, fallback) {
+    const branch = (value?.trim() || fallback).trim();
+    if (branch.length === 0 ||
+        branch.startsWith("-") ||
+        branch === "@" ||
+        branch.includes("..") ||
+        branch.includes("//") ||
+        branch.includes("@{") ||
+        branch.endsWith("/") ||
+        branch.endsWith(".") ||
+        branch.toLowerCase().endsWith(".lock") ||
+        /\s/.test(branch) ||
+        /[\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 '-'.");
+    }
+    return branch;
+}
+async function gitMetadataExists(repoPath, allowedRoot) {
+    const gitPath = path.join(repoPath, ".git");
+    const stat = await fs.lstat(gitPath).catch(() => null);
+    if (!stat) {
+        return false;
+    }
+    if (stat.isSymbolicLink()) {
+        const resolvedGitPath = await resolveExistingDirectoryPath(gitPath);
+        return isSubPath(allowedRoot, resolvedGitPath);
+    }
+    if (stat.isDirectory()) {
+        const resolvedGitPath = await resolveExistingDirectoryPath(gitPath);
+        return isSubPath(allowedRoot, resolvedGitPath);
+    }
+    if (!stat.isFile()) {
+        return false;
+    }
+    const content = (await fs.readFile(gitPath, "utf8")).trim();
+    const prefix = "gitdir:";
+    if (!content.toLowerCase().startsWith(prefix)) {
+        return false;
+    }
+    const gitDir = content.slice(prefix.length).trim();
+    if (gitDir.length === 0) {
+        return false;
+    }
+    const gitDirPath = path.isAbsolute(gitDir) ? gitDir : path.join(repoPath, gitDir);
+    const resolvedGitDir = await resolveExistingDirectoryPath(gitDirPath);
+    return isSubPath(allowedRoot, resolvedGitDir);
+}
+async function directoryExists(inputPath) {
+    const stat = await fs.stat(inputPath).catch(() => null);
+    return stat?.isDirectory() ?? false;
+}

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

@@ -0,0 +1,15 @@
+import type { DispatchRepo, DispatchWorkItem } from "../session/session.types.js";
+export interface WorktreePrepareRequest {
+    readonly repo: DispatchRepo;
+    readonly workItem: DispatchWorkItem;
+    readonly baseBranch: string;
+    readonly allowedRepoRoot: string;
+    readonly cleanupWorktrees: boolean;
+}
+export interface WorktreeHandle {
+    readonly repoPath: string;
+    readonly worktreePath: string;
+    readonly branchName: string;
+    readonly baseBranch: string;
+    readonly cleanupWorktrees: boolean;
+}

package/dist/worktree/worktree.types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@loucompanion/forge-bridge",
+  "version": "0.1.1-dev.242bb53ef13f",
+  "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "forge-bridge": "./dist/cli/bin.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/coleman399/Forge.git",
+    "directory": "tools/forge-bridge"
+  },
+  "homepage": "https://github.com/coleman399/Forge/tree/develop/tools/forge-bridge#readme",
+  "bugs": {
+    "url": "https://github.com/coleman399/Forge/issues"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "smoke:package": "npm run build && node scripts/smoke-package.mjs"
+  },
+  "dependencies": {
+    "@microsoft/signalr": "^8.0.17"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.32",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3"
+  }
+}