feat-forge 1.0.1

package/dist/lib/git.js

@@ -0,0 +1,170 @@
+import path from 'path';
+import { execa } from 'execa';
+import { pathExists } from './fs.js';
+export var GitOperation;
+(function (GitOperation) {
+    GitOperation["Merge"] = "merge";
+    GitOperation["Rebase"] = "rebase";
+})(GitOperation || (GitOperation = {}));
+export async function findGitRoot(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const gitPath = path.join(current, '.git');
+        if (await pathExists(gitPath)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error('Not inside a git repository (no .git directory found).');
+        }
+        current = parent;
+    }
+}
+/**
+ * Run a git command inside the given repo root.
+ */
+export async function runGit(repoRoot, args) {
+    await execa('git', args, { cwd: repoRoot, stdio: 'inherit' });
+}
+/**
+ * Return git status porcelain output for the given working directory.
+ */
+export async function getGitStatusPorcelain(cwd) {
+    const result = await execa('git', ['status', '--porcelain'], { cwd });
+    return result.stdout.trim();
+}
+/**
+ * Return true if a branch exists.
+ */
+export async function gitBranchExists(repoRoot, branchName) {
+    try {
+        await execa('git', ['rev-parse', '--verify', branchName], { cwd: repoRoot });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Return true if a path exists in the given branch.
+ */
+export async function gitPathExistsInBranch(repoRoot, branchName, targetPath) {
+    try {
+        await execa('git', ['cat-file', '-e', `${branchName}:${targetPath}`], { cwd: repoRoot });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the current branch name for a repo.
+ */
+export async function getCurrentBranch(repoRoot) {
+    try {
+        const result = await execa('git', ['branch', '--show-current'], { cwd: repoRoot });
+        return result.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Checkout a branch in a repo.
+ */
+export async function checkoutBranch(repoRoot, branchName) {
+    await execa('git', ['checkout', branchName], { cwd: repoRoot, stdio: 'inherit' });
+}
+/**
+ * Create a new branch in a repo.
+ */
+export async function createBranch(repoRoot, branchName, baseBranch) {
+    const args = ['branch', branchName];
+    if (baseBranch) {
+        args.push(baseBranch);
+    }
+    await runGit(repoRoot, args);
+}
+/**
+ * Get all branches in a repo.
+ */
+export async function getBranches(repoRoot, prefix) {
+    const args = ['branch', '--format=%(refname:short)'];
+    if (prefix) {
+        args.push('--list', `${prefix}*`);
+    }
+    const result = await execa('git', args, { cwd: repoRoot });
+    return result.stdout.split('\n').filter((b) => b.trim().length > 0);
+}
+/**
+ * Get all worktrees for a repo with their paths and branches.
+ */
+export async function getGitWorktrees(repoRoot) {
+    try {
+        const result = await execa('git', ['worktree', 'list', '--porcelain'], { cwd: repoRoot });
+        const lines = result.stdout.split('\n');
+        const worktrees = [];
+        let currentPath = '';
+        let currentBranch = '';
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                currentPath = line.substring('worktree '.length);
+            }
+            else if (line.startsWith('branch ')) {
+                currentBranch = line.substring('branch '.length).replace(/^refs\/heads\//, '');
+            }
+            else if (line === '' && currentPath) {
+                if (currentBranch) {
+                    worktrees.push({ path: currentPath, branch: currentBranch });
+                }
+                currentPath = '';
+                currentBranch = '';
+            }
+        }
+        // Handle last entry if file doesn't end with blank line
+        if (currentPath && currentBranch) {
+            worktrees.push({ path: currentPath, branch: currentBranch });
+        }
+        return worktrees;
+    }
+    catch {
+        throw new Error(`Failed to get worktrees for repo at ${repoRoot}. Ensure it's a valid git repository and that git is installed.`);
+    }
+}
+/**
+ * Display summary of git operation results.
+ *
+ * @param results - Array of operation results
+ * @param operationType - Name of the operation (e.g., "merge", "rebase")
+ */
+export function displayOperationSummary(results, operationType) {
+    console.log(`\n=== ${operationType.charAt(0).toUpperCase() + operationType.slice(1)} Summary ===`);
+    const successful = results.filter((r) => r.success);
+    const conflicts = results.filter((r) => r.hasConflicts);
+    const failed = results.filter((r) => !r.success && !r.hasConflicts);
+    if (successful.length > 0) {
+        console.log(`\n✅ Successful ${operationType}s (${successful.length}):`);
+        successful.forEach((r) => console.log(`   - ${r.repo}`));
+    }
+    if (conflicts.length > 0) {
+        console.log(`\n⚠️  Conflicts to resolve (${conflicts.length}):`);
+        conflicts.forEach((r) => console.log(`   - ${r.repo}`));
+    }
+    if (failed.length > 0) {
+        console.log(`\n❌ Failed ${operationType}s (${failed.length}):`);
+        failed.forEach((r) => console.log(`   - ${r.repo}`));
+    }
+    // Summary message
+    if (conflicts.length === 0 && failed.length === 0) {
+        console.log(`\n🎉 All ${operationType}s completed successfully!`);
+    }
+    else {
+        console.log(`\n⚠️  Some ${operationType}s need attention. Please resolve conflicts or errors before continuing.`);
+        console.log(`After resolving conflicts, you can continue with: git ${operationType} --continue`);
+    }
+    return {
+        successful,
+        conflicts,
+        failed,
+    };
+}

package/dist/lib/hooks.js

@@ -0,0 +1,98 @@
+import { readdir } from 'fs/promises';
+import path from 'path';
+import { pathExists } from './fs.js';
+import { getScriptExtension } from './platform.js';
+import { executeScript } from './bootstrap.js';
+/**
+ * Available hook event types that can be triggered throughout the forge lifecycle.
+ * Each event can have multiple hooks (e.g., postStart.sh, postStart_01.sh).
+ */
+export var HookEvent;
+(function (HookEvent) {
+    /** Triggered after a branch is started */
+    HookEvent["POST_START"] = "postStart";
+    /** Triggered before a merge operation */
+    HookEvent["PRE_MERGE"] = "preMerge";
+    /** Triggered after a merge operation */
+    HookEvent["POST_MERGE"] = "postMerge";
+    /** Triggered before stopping a branch */
+    HookEvent["PRE_STOP"] = "preStop";
+    /** Triggered before a rebase operation */
+    HookEvent["PRE_REBASE"] = "preRebase";
+    /** Triggered after a rebase operation */
+    HookEvent["POST_REBASE"] = "postRebase";
+    /** Triggered before deleting a branch */
+    HookEvent["PRE_DELETE"] = "preDelete";
+    /** Triggered before archiving a branch */
+    HookEvent["PRE_ARCHIVE"] = "preArchive";
+    /** Triggered after refreshing agent context files */
+    HookEvent["POST_REFRESH_AGENTS"] = "postRefreshAgents";
+    /** Triggered after setting active specs */
+    HookEvent["POST_SET_ACTIVE_SPECS"] = "postSetActiveSpecs";
+})(HookEvent || (HookEvent = {}));
+/**
+ * Discover available hooks for a specific event type.
+ * Returns hook names matching the event type without extension (e.g., 'postStart' from 'postStart.sh').
+ * Supports multiple hooks for the same event (e.g., postStart, postStart_01, postStart_02).
+ * Hooks are returned in alphabetical order for predictable execution.
+ *
+ * @param repositoryPath - Path to the repository/worktree
+ * @param repoConfigFolderPath - Relative path to the repo config folder (e.g., '.forge')
+ * @param eventType - Type of event (HookEvent enum value)
+ * @returns Array of hook names in alphabetical order
+ */
+export async function discoverHooksForEvent(repositoryPath, repoConfigFolderPath, eventType) {
+    const hooksDir = path.join(repositoryPath, repoConfigFolderPath, 'hooks');
+    if (!(await pathExists(hooksDir))) {
+        return [];
+    }
+    try {
+        const files = await readdir(hooksDir);
+        const scriptExtension = getScriptExtension();
+        const hookNames = files
+            .filter((file) => {
+            if (!file.endsWith(scriptExtension)) {
+                return false;
+            }
+            const hookName = file.slice(0, -scriptExtension.length);
+            // Match exact event type or event type with suffix (e.g., postStart, postStart_01)
+            return hookName === eventType || hookName.startsWith(`${eventType}_`);
+        })
+            .map((file) => file.slice(0, -scriptExtension.length))
+            .sort(); // Sort alphabetically for predictable order
+        return hookNames;
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Execute all hooks for a specific event type.
+ * Hooks are executed in alphabetical order for predictable, consistent execution.
+ *
+ * @param repositoryPath - Path to the repository/worktree
+ * @param repoConfigFolderPath - Relative path to the repo config folder (e.g., '.forge')
+ * @param eventType - Type of event (HookEvent enum value)
+ * @param params - Optional parameters to pass to hooks as environment variables (FORGE_HOOK_PARAM_NAME)
+ * @returns Array of hook names that were executed
+ * @throws Error if any hook fails
+ */
+export async function executeHooksForEvent(repositoryPath, repoConfigFolderPath, eventType, params) {
+    const hookNames = await discoverHooksForEvent(repositoryPath, repoConfigFolderPath, eventType);
+    if (hookNames.length === 0) {
+        return [];
+    }
+    const scriptExtension = getScriptExtension();
+    const executedHooks = [];
+    for (const hookName of hookNames) {
+        const scriptPath = path.join(repositoryPath, repoConfigFolderPath, 'hooks', `${hookName}${scriptExtension}`);
+        try {
+            await executeScript(scriptPath, repositoryPath, `hook: ${hookName}`, params);
+            executedHooks.push(hookName);
+        }
+        catch (error) {
+            throw new Error(`Hook ${hookName} failed in ${repositoryPath}`);
+        }
+    }
+    return executedHooks;
+}

package/dist/lib/ide.js

@@ -0,0 +1,75 @@
+import { writeFile } from 'fs/promises';
+import path from 'path';
+import { pathExists } from './fs.js';
+import { IDEName } from '../foundation/types/IDEName.js';
+import { slugify } from './slug.js';
+/**
+ * Get the default CLI command for an IDE
+ * @param ideName - The IDE name
+ * @returns The default CLI command for the IDE
+ */
+export function getDefaultIDECommand(ideName) {
+    const defaultCommands = {
+        [IDEName.VSCODE]: 'code',
+    };
+    return defaultCommands[ideName];
+}
+/**
+ * Create IDE workspace files for a feature
+ */
+export async function createIDEWorkspaces(branchName, branchRoot, mainRepoName, repositories, ides, agents) {
+    for (const ide of ides) {
+        if (!ide.createWorkspace) {
+            continue;
+        }
+        switch (ide.name) {
+            case IDEName.VSCODE:
+                await createVSCodeWorkspaceFile(branchName, branchRoot, ide, mainRepoName, repositories, agents);
+                break;
+            default:
+                console.warn(`Unknown IDE: ${ide.name}, skipping workspace creation`);
+        }
+    }
+}
+export async function getWorkspaceFileName(branchName, ideName) {
+    // FIXME: must handle IDE specific file extensions (.code-workspace for VSCode, .cw for Cursor, .wsp for Windsurf, etc.)
+    return `${slugify(branchName, false)}.code-workspace`;
+}
+/**
+ * Create a VSCode-style workspace file (.code-workspace)
+ * Also works for Cursor and Windsurf which use the same format
+ */
+async function createVSCodeWorkspaceFile(branchName, branchRoot, ide, mainRepoName, repositories, agents) {
+    const workspaceFileName = await getWorkspaceFileName(branchName, ide.name);
+    const workspaceFilePath = path.join(branchRoot, workspaceFileName);
+    // Check if workspace already exists
+    if (await pathExists(workspaceFilePath)) {
+        console.log(`Workspace file already exists: ${workspaceFileName}`);
+        return;
+    }
+    // Build workspace settings
+    const settings = { ...ide.settings };
+    const workspace = {
+        // folders: repositories.map((repo) => ({ path: `./${repo.name}` })),
+        folders: [{ path: '.' }], // allow visibility on .xxx folders, used by many agents
+        settings,
+    };
+    await writeFile(workspaceFilePath, JSON.stringify(workspace, null, 2), 'utf8');
+    console.log(`Created ${ide.name} workspace: ${workspaceFileName}`);
+}
+/**
+ * Update IDE settings in an existing workspace
+ */
+export async function updateIDEWorkspace(workspaceFilePath, ideName, newSettings) {
+    if (!(await pathExists(workspaceFilePath))) {
+        throw new Error(`Workspace file not found: ${workspaceFilePath}`);
+    }
+    const content = await import('fs/promises').then((m) => m.readFile(workspaceFilePath, 'utf8'));
+    const workspace = JSON.parse(content);
+    workspace.settings = {
+        ...workspace.settings,
+        ...newSettings,
+    };
+    await writeFile(workspaceFilePath, JSON.stringify(workspace, null, 2), 'utf8');
+    console.log(`Updated ${ideName} workspace: ${path.basename(workspaceFilePath)}`);
+}

package/dist/lib/merger.js

@@ -0,0 +1,103 @@
+function isObject(item) {
+    return item && typeof item === 'object' && item !== null;
+}
+function isArray(item) {
+    return Array.isArray(item);
+}
+export class MergerOptions {
+    /**
+     * If true, arrays will be merged instead of replaced
+     * @default false
+     */
+    mergeArrays = false;
+    /**
+     * If true, undefined values in sources will be merged and overwrite existing values in target.
+     * If false, undefined values will be ignored.
+     */
+    mergeUndefined = true;
+    constructor(options = {}) {
+        Object.assign(this, options);
+    }
+}
+/**
+ * Class that provides a merge function to deep merge objects
+ * with options
+ */
+export class Merger {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        this.options = Object.assign(new MergerOptions(), options);
+    }
+    static build(options = {}) {
+        return new Merger(options);
+    }
+    /**
+     * Like Object.assign but will do a deep merge
+     * @param target where all sources will be merged
+     * @param sources what to merge into target, one or multiple
+     * @returns
+     */
+    merge(target, ...sources) {
+        if (isObject(target)) {
+            let sLen = sources.length;
+            for (let i = 0; i < sLen; i++) {
+                const source = sources[i];
+                if (isObject(source)) {
+                    for (const key in source) {
+                        if (source.hasOwnProperty(key)) {
+                            if (source[key] instanceof Date) {
+                                target[key] = new Date(source[key].getTime());
+                            }
+                            else if (isArray(source[key])) {
+                                if (this.options.mergeArrays) {
+                                    target[key] = (target[key] || []).concat(source[key]);
+                                }
+                                else {
+                                    target[key] = source[key].slice();
+                                }
+                            }
+                            else if (isObject(source[key])) {
+                                if (!target[key]) {
+                                    target[key] = {};
+                                }
+                                this.merge(target[key], source[key]);
+                            }
+                            else {
+                                if (source[key] === undefined && !this.options.mergeUndefined) {
+                                    continue;
+                                }
+                                Object.assign(target, { [key]: source[key] });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return target;
+    }
+}
+const defaultMerge = Merger.build();
+const arrayMerger = Merger.build({ mergeArrays: true });
+const mergeDropUndefinedMerger = Merger.build({ mergeUndefined: false });
+/**
+ * Like Object.assign but will do a deep merge
+ * @param target where all sources will be merged
+ * @param sources what to merge into target, one or multiple
+ * @returns
+ */
+export const merge = defaultMerge.merge.bind(defaultMerge);
+/**
+ * Like Object.assign but will do a deep merge and will concat arrays instead of replacing them
+ * @param target where all sources will be merged
+ * @param sources what to merge into target, one or multiple
+ * @returns
+ */
+export const mergeConcatArrays = arrayMerger.merge.bind(arrayMerger);
+/**
+ * Like Object.assign but will do a deep merge and will ignore undefined values in sources
+ * @param target where all sources will be merged
+ * @param sources what to merge into target, one or multiple
+ * @returns
+ */
+export const mergeDropUndefined = mergeDropUndefinedMerger.merge.bind(mergeDropUndefinedMerger);

package/dist/lib/platform.js

@@ -0,0 +1,13 @@
+/**
+ * Check if the current platform is Windows
+ */
+export function isWindows() {
+    return process.platform === 'win32';
+}
+/**
+ * Get the script extension based on the current platform
+ * @returns '.bat' on Windows, '.sh' on other platforms
+ */
+export function getScriptExtension() {
+    return isWindows() ? '.bat' : '.sh';
+}

package/dist/lib/prompt.js

@@ -0,0 +1,134 @@
+import { select, input, confirm, checkbox } from '@inquirer/prompts';
+import { getBranches } from './git.js';
+/**
+ * Prompt the user to pick a single choice by key.
+ */
+export async function promptChoice(message, choices) {
+    return await select({
+        message,
+        choices,
+    });
+}
+/**
+ * Prompt the user for free-form input.
+ */
+export async function promptText(message) {
+    return await input({
+        message,
+    });
+}
+/**
+ * Prompt the user for a yes/no confirmation.
+ */
+export async function promptConfirm(message) {
+    return await confirm({
+        message,
+    });
+}
+/**
+ * Prompt the user to select multiple items using checkboxes.
+ */
+export async function promptCheckbox(message, choices) {
+    return await checkbox({
+        message,
+        choices: choices.map((choice) => ({
+            name: choice.name,
+            value: choice.value,
+            checked: choice.checked || false,
+        })),
+    });
+}
+/**
+ * Prompt user to select a branch from available local branches.
+ *
+ * Displays common branches (main, master, dev, develop, trunk) first,
+ * followed by feature branches (optional) and other branches,
+ * and allows manual entry via "Other" option.
+ *
+ * @param repoRoot - The repository root to query for branches
+ * @param message - Custom message for the prompt
+ * @param includeFeatureBranches - Whether to include feature/ branches in the list
+ * @returns The selected branch name
+ * @throws Error if branch name is empty or selection is invalid
+ */
+export async function promptForBranch(repoRoot, message, featureBranchPrefix, includeFeatureBranches = false) {
+    // Get all local branches
+    const allBranches = await getBranches(repoRoot);
+    // Common branches to prioritize in the selection menu
+    const commonBranches = ['main', 'master', 'dev', 'develop', 'trunk'];
+    // Separate branches by type
+    const priorityBranches = commonBranches.filter((b) => allBranches.includes(b));
+    const featureBranches = allBranches.filter((b) => b.startsWith(featureBranchPrefix));
+    const otherBranches = allBranches.filter((b) => !commonBranches.includes(b) && !b.startsWith(featureBranchPrefix));
+    // Build choices menu
+    const choices = [];
+    // Add priority branches first
+    for (const branch of priorityBranches) {
+        choices.push({ name: branch, value: branch });
+    }
+    // Add feature branches if requested
+    if (includeFeatureBranches && featureBranches.length > 0) {
+        for (const branch of featureBranches) {
+            choices.push({ name: branch, value: branch });
+        }
+    }
+    // Add other branches
+    for (const branch of otherBranches) {
+        choices.push({ name: branch, value: branch });
+    }
+    // Add manual entry option
+    choices.push({ name: 'Other (enter branch name)', value: '__other__' });
+    let branchName = null;
+    // Expect a choice to be made until a valid branch name is obtained
+    while (true) {
+        const selection = await promptChoice(message, choices);
+        // Handle manual entry
+        if (selection === '__other__') {
+            const branchNameInput = await promptText('Enter branch name:');
+            if (branchNameInput) {
+                branchName = branchNameInput;
+                break;
+            }
+        }
+        else {
+            branchName = selection;
+            break;
+        }
+    }
+    return branchName;
+}
+export var DirtyAction;
+(function (DirtyAction) {
+    DirtyAction["Commit"] = "A";
+    DirtyAction["Cancel"] = "B";
+    DirtyAction["Discard"] = "C";
+})(DirtyAction || (DirtyAction = {}));
+function isDirtyAction(value) {
+    return value === DirtyAction.Commit || value === DirtyAction.Cancel || value === DirtyAction.Discard;
+}
+/**
+ * Prompt user to select an action for dirty worktrees.
+ *
+ * Presents options to commit changes, discard changes, or stop the operation.
+ * Returns the user's choice as 'A', 'B', or 'C'.
+ */
+export async function promptDirtyActions() {
+    while (true) {
+        const answer = await promptChoice('Worktree contain uncommitted changes. Choose an action:', [
+            { value: DirtyAction.Commit, name: 'Commit work (you will be asked for a commit message)' },
+            { value: DirtyAction.Cancel, name: 'Stop here and do nothing' },
+            { value: DirtyAction.Discard, name: 'Discard work and remove worktrees' },
+        ]);
+        if (isDirtyAction(answer)) {
+            if (answer === DirtyAction.Commit) {
+                const commitMessage = await promptText('Enter commit message:');
+                if (!commitMessage) {
+                    console.log('Commit message is required.');
+                    continue;
+                }
+                return { action: DirtyAction.Commit, commitMessage };
+            }
+            return { action: answer };
+        }
+    }
+}

package/dist/lib/proxy-dashboard.js

@@ -0,0 +1,75 @@
+import http from 'http';
+async function checkHealth(target) {
+    return new Promise((resolve) => {
+        const req = http.get(target, { timeout: 2000 }, (res) => {
+            res.resume();
+            resolve(true);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+export async function handleDashboardRequest(req, res, routingTable, proxyPort) {
+    const statuses = [];
+    const checks = Array.from(routingTable.entries()).map(async ([key, route]) => {
+        const healthy = await checkHealth(route.url);
+        statuses.push({ key, route, healthy });
+    });
+    await Promise.all(checks);
+    statuses.sort((a, b) => a.route.branchName.localeCompare(b.route.branchName) || a.route.serviceName.localeCompare(b.route.serviceName));
+    const grouped = new Map();
+    for (const s of statuses) {
+        const list = grouped.get(s.route.branchName) ?? [];
+        list.push(s);
+        grouped.set(s.route.branchName, list);
+    }
+    const rows = Array.from(grouped.entries())
+        .map(([branchName, services]) => {
+        const header = `<tr class="branch-header"><td colspan="4"><strong>${branchName}</strong></td></tr>`;
+        const serviceRows = services
+            .map((s) => {
+            const statusBadge = s.healthy
+                ? '<span style="color:#22c55e;font-weight:bold">● UP</span>'
+                : '<span style="color:#ef4444;font-weight:bold">● DOWN</span>';
+            return `<tr>
+                    <td>${s.route.serviceName}</td>
+                    <td><a href="${s.route.proxyUrl}" target="_blank">${s.route.proxyUrl}</a></td>
+                    <td><a href="${s.route.url}" target="_blank">${s.route.url}</a></td>
+                    <td>${statusBadge}</td>
+                </tr>`;
+        })
+            .join('\n');
+        return header + '\n' + serviceRows;
+    })
+        .join('\n');
+    const html = `<!DOCTYPE html>
+<html><head>
+<meta charset="utf-8">
+<meta http-equiv="refresh" content="30">
+<title>Feat-Forge Proxy Dashboard</title>
+<style>
+  body { font-family: system-ui, sans-serif; margin: 2rem; background: #0f172a; color: #e2e8f0; }
+  h1 { color: #38bdf8; }
+  table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
+  th, td { padding: 0.6rem 1rem; text-align: left; border-bottom: 1px solid #334155; }
+  th { background: #1e293b; color: #94a3b8; font-size: 0.85rem; text-transform: uppercase; }
+  tr:hover { background: #1e293b; }
+  .branch-header td { background: #1e293b; border-bottom: 2px solid #475569; padding-top: 1rem; color: #f1f5f9; font-size: 1rem; }
+  a { color: #38bdf8; text-decoration: none; }
+  a:hover { text-decoration: underline; }
+  .meta { color: #64748b; font-size: 0.85rem; margin-top: 0.5rem; }
+</style>
+</head><body>
+<h1>Feat-Forge Proxy Dashboard</h1>
+<p class="meta">${statuses.length} routes &middot; auto-refresh 30s &middot; proxy port ${proxyPort}</p>
+<table>
+<thead><tr><th>Service</th><th>Proxy URL</th><th>Target</th><th>Status</th></tr></thead>
+<tbody>${rows || '<tr><td colspan="4" style="text-align:center;color:#64748b">No routes configured. Run <code>forge services scan</code> on active branches.</td></tr>'}</tbody>
+</table>
+</body></html>`;
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+}