feat-forge 1.0.1

package/dist/foundation/PathHelper.js

@@ -0,0 +1,56 @@
+import path from 'path';
+import { FEAT_FORGE_CONFIG_FOLDER, TEMP_FEATURE_ARCHIVE_FOLDER, TEMP_FEATURE_INIT_FOLDER, TEMP_FOLDER, TemporaryFolderType, } from '../lib/constants.js';
+import { branchNameAsPath } from '../lib/branch.js';
+export class PathHelper {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    get folders() {
+        return this.context.options.folders;
+    }
+    get rootDir() {
+        return this.context.rootDir;
+    }
+    get worktreesRoot() {
+        return path.join(this.rootDir, this.folders.worktrees);
+    }
+    get featForgeConfigRoot() {
+        return path.join(this.rootDir, FEAT_FORGE_CONFIG_FOLDER);
+    }
+    get tempFolderRoot() {
+        return path.join(this.featForgeConfigRoot, TEMP_FOLDER);
+    }
+    getPathInRoot(...segments) {
+        return path.join(this.rootDir, ...segments);
+    }
+    getPathInWorktrees(...segments) {
+        return path.join(this.worktreesRoot, ...segments);
+    }
+    getBranchRootPath(branchName) {
+        return this.getPathInBranchRoot(branchNameAsPath(branchName));
+    }
+    getPathInBranchRoot(branchName, ...segments) {
+        return this.getPathInWorktrees(branchNameAsPath(branchName), ...segments);
+    }
+    /**
+     * Get the temporary folder path for a specific operation (e.g. feature-init, feature-archive).
+     * Default Pattern: <rootDir>/.feat-forge/tmp/<operation>/<slug>/<repoName>/
+     */
+    getPathInTemp(...segments) {
+        return path.join(this.tempFolderRoot, ...segments);
+    }
+    /**
+     * Get the temporary worktree path for a specific repository and operation type.
+     */
+    getTempWorktreePathForRepo(type, branchName, repoName) {
+        switch (type) {
+            case TemporaryFolderType.BRANCH_INIT:
+                return this.getPathInTemp(TEMP_FEATURE_INIT_FOLDER, branchNameAsPath(branchName), repoName);
+            case TemporaryFolderType.BRANCH_ARCHIVE:
+                return this.getPathInTemp(TEMP_FEATURE_ARCHIVE_FOLDER, branchNameAsPath(branchName), repoName);
+            default:
+                throw new Error(`Unknown temporary type: ${type}`);
+        }
+    }
+}

package/dist/foundation/PortAllocator.js

@@ -0,0 +1,192 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ForgePortAllocationsLoadError, ForgePortRangeExhaustedError } from '../foundation/errors/index.js';
+import { PortAllocatorDTO, } from '../foundation/types/Services.js';
+import { pathExists, readJSONFile, writeTextFile } from '../lib/fs.js';
+import { Type } from 'class-transformer';
+import { IsArray, ValidateNested } from 'class-validator';
+const PORT_ALLOCATIONS_FILE = 'port-allocations.json';
+/**
+ * Business entity representing port allocation for a branch
+ */
+export class BranchPortAllocation {
+    /**
+     * Branch name
+     */
+    name;
+    /**
+     * Starting port number for this branch's allocation range
+     */
+    start;
+    /**
+     * Ending port number for this branch's allocation range
+     */
+    end;
+    /**
+     * Services with their allocated ports for this branch
+     */
+    services; // Maps service name to its allocated port
+    constructor(branchName, start, end, services = []) {
+        this.name = branchName;
+        this.start = start;
+        this.end = end;
+        this.services = services;
+    }
+    static load(file) {
+        return new BranchPortAllocation(file.name, file.start, file.end, file.services);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            start: this.start,
+            end: this.end,
+            services: this.services,
+        };
+    }
+    get nextAvailablePort() {
+        const usedPorts = this.services.map((s) => s.port);
+        if (usedPorts.length === 0) {
+            return this.start;
+        }
+        const nextPort = Math.max(...usedPorts) + 1;
+        if (nextPort > this.end) {
+            throw new ForgePortRangeExhaustedError();
+        }
+        return nextPort;
+    }
+    hasService(serviceName) {
+        return this.services.some((s) => s.name === serviceName);
+    }
+    getService(serviceName) {
+        return this.services.find((s) => s.name === serviceName);
+    }
+    /**
+     * Allocate a port for the given service. Returns the existing port if already allocated,
+     * or assigns the next available port.
+     */
+    allocatePort(service) {
+        const serviceName = service.name;
+        const existingService = this.getService(serviceName);
+        if (existingService) {
+            return existingService.port;
+        }
+        const nextPort = this.nextAvailablePort;
+        if (nextPort > this.end) {
+            throw new ForgePortRangeExhaustedError(`Cannot allocate port for service "${serviceName}": Port range exhausted (${this.start}-${this.end}).`);
+        }
+        this.services.push({ ...service, port: nextPort });
+        return nextPort;
+    }
+    getServices() {
+        return this.services.slice();
+    }
+}
+/**
+ * Port allocator manages port assignments for services across branches
+ */
+export class PortAllocator {
+    forgeContext;
+    allocations;
+    constructor(forgeContext, allocations) {
+        this.forgeContext = forgeContext;
+        this.allocations = allocations;
+    }
+    /**
+     * Load or create port allocations from rootDir
+     */
+    static async load(forgeContext) {
+        const portAllocationFilePath = this.getPortAllocationsFilePath(forgeContext);
+        let allocations = [];
+        if (await pathExists(portAllocationFilePath)) {
+            try {
+                const portAllocationFile = await readJSONFile(PortAllocatorDTO, portAllocationFilePath);
+                allocations = portAllocationFile.allocations.map(BranchPortAllocation.load);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new ForgePortAllocationsLoadError(error.message);
+                }
+                throw error;
+            }
+        }
+        return new PortAllocator(forgeContext, allocations);
+    }
+    static getPortAllocationsFilePath(forgeContext) {
+        return forgeContext.paths.getPathInRoot(PORT_ALLOCATIONS_FILE);
+    }
+    /**
+     * Persist allocations to disk
+     */
+    toJSON() {
+        return {
+            _doNotEdit: "This file is auto-generated by 'forge services scan'. Manual edits will be lost on next generation.",
+            allocations: this.allocations.map((alloc) => alloc.toJSON()),
+        };
+    }
+    async save() {
+        const filePath = PortAllocator.getPortAllocationsFilePath(this.forgeContext);
+        const content = JSON.stringify(this, null, 2);
+        await writeTextFile(filePath, content);
+    }
+    get config() {
+        return this.forgeContext.config.options.proxy;
+    }
+    getAllocation(branchName) {
+        return this.allocations.find((alloc) => alloc.name === branchName);
+    }
+    hasAllocation(branchName) {
+        return this.allocations.some((alloc) => alloc.name === branchName);
+    }
+    /**
+     * Get or create allocation for a branch
+     */
+    getOrCreateBranchAllocation(branchName) {
+        if (this.hasAllocation(branchName)) {
+            return this.getAllocation(branchName);
+        }
+        const branchIndex = this.allocations.length;
+        const start = this.config.servicesBasePort + branchIndex * this.config.branchRangeSize;
+        const end = start + this.config.branchRangeSize - 1;
+        const allocation = new BranchPortAllocation(branchName, start, end);
+        this.allocations.push(allocation);
+        return allocation;
+    }
+    /**
+     * Allocate ports for services in a branch
+     * Returns mapping of service names to assigned ports
+     */
+    allocateBranchServicesPorts(branchName, services) {
+        const allocation = this.getOrCreateBranchAllocation(branchName);
+        for (const service of services) {
+            allocation.allocatePort(service);
+        }
+        return allocation;
+    }
+    /**
+     * Allocate ports for all repositories in a branch at once
+     */
+    allocatePorts(branchName, repoServices) {
+        for (const repoService of repoServices) {
+            this.allocateBranchServicesPorts(branchName, repoService.services);
+        }
+    }
+    /**
+     * Get all allocations
+     */
+    getAllAllocations() {
+        return this.allocations.slice();
+    }
+}
+__decorate([
+    IsArray(),
+    ValidateNested({ each: true }),
+    Type(() => BranchPortAllocation),
+    __metadata("design:type", Array)
+], PortAllocator.prototype, "allocations", void 0);

package/dist/foundation/Proxy.js

@@ -0,0 +1,176 @@
+import { FEAT_FORGE_GENERATED_SERVICES_FILE } from '../lib/constants.js';
+import { handleDashboardRequest } from '../lib/proxy-dashboard.js';
+import { getServiceOutputs, loadGeneratedServicesFile } from '../lib/services.js';
+import fs from 'fs';
+import { createServer, ServerResponse } from 'http';
+import { createProxyServer } from 'http-proxy-3';
+export class Proxy {
+    context;
+    server = null;
+    routingTable = new Map();
+    stopWatching = null;
+    constructor(context) {
+        this.context = context;
+    }
+    async start(options = {}) {
+        const proxyConfig = this.context.options.proxy;
+        if (!proxyConfig.enabled) {
+            console.error('❌ Proxy is disabled in configuration. Set proxy.enabled to true in .feat-forge.json');
+            return;
+        }
+        const port = options.port ?? proxyConfig.port;
+        const branchContexts = await this.context.loadActiveBranchesContexts();
+        if (branchContexts.length === 0) {
+            console.log('⚠️  No active branches found. Start a branch first with `forge start <branch>`.');
+            return;
+        }
+        this.registerShutdownHandlers();
+        this.routingTable = await this.buildRoutingTable(branchContexts);
+        this.showSummary(port);
+        this.startServer(port);
+        this.startWatching();
+        console.log(`\n🚀 Proxy server running on http://localhost:${port}`);
+        console.log(`📊 Dashboard: http://localhost:${port}`);
+        console.log('\nPress Ctrl+C to stop.\n');
+    }
+    stop() {
+        this.stopWatching?.();
+        this.stopWatching = null;
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+    async buildRoutingTable(branchContexts) {
+        const table = new Map();
+        for (const branchContext of branchContexts) {
+            try {
+                const generated = await loadGeneratedServicesFile(branchContext);
+                for (const service of generated.services) {
+                    const { proxyUrl, url, key, name } = getServiceOutputs(this.context, branchContext, service);
+                    table.set(key, {
+                        branchName: branchContext.branchName,
+                        serviceName: name,
+                        url,
+                        proxyUrl,
+                    });
+                }
+            }
+            catch {
+                // Branch has no generated services file, skip
+            }
+        }
+        return table;
+    }
+    startServer(port) {
+        const proxy = createProxyServer({});
+        proxy.on('error', (err, req, res) => {
+            if (res instanceof ServerResponse && !res.headersSent) {
+                res.writeHead(502, { 'Content-Type': 'text/plain' });
+                res.end(`502 Bad Gateway - Service is down or unreachable`);
+            }
+        });
+        this.server = createServer((req, res) => {
+            const host = req.headers.host || '';
+            const hostWithoutPort = host.split(':')[0];
+            const parts = hostWithoutPort.replace(/\.localhost$/, '').split('.');
+            if (parts.length < 2 || hostWithoutPort === 'localhost') {
+                return handleDashboardRequest(req, res, this.routingTable, port);
+            }
+            const key = parts.join('.');
+            const route = this.routingTable.get(key);
+            if (!route) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end(`404 Not Found - No route for "${key}"`);
+                return;
+            }
+            proxy.web(req, res, { target: route.url });
+        });
+        this.server.on('upgrade', (req, socket, head) => {
+            const host = req.headers.host || '';
+            const hostWithoutPort = host.split(':')[0];
+            const parts = hostWithoutPort.replace(/\.localhost$/, '').split('.');
+            const key = parts.join('.');
+            const route = this.routingTable.get(key);
+            if (route) {
+                proxy.ws(req, socket, head, { target: route.url });
+            }
+            else {
+                socket.destroy();
+            }
+        });
+        this.server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`\n❌ Port ${port} is already in use. Please choose a different proxy port.\n`);
+                process.exit(1);
+            }
+            throw err;
+        });
+        this.server.listen(port);
+    }
+    startWatching() {
+        const watchers = [];
+        let debounceTimer = null;
+        const rebuild = async () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(async () => {
+                try {
+                    const branchContexts = await this.context.loadActiveBranchesContexts();
+                    this.routingTable = await this.buildRoutingTable(branchContexts);
+                    console.log(`\n🔄 Routing table reloaded (${this.routingTable.size} routes)`);
+                }
+                catch (err) {
+                    console.error('⚠️  Failed to reload routing table:', err);
+                }
+            }, 500);
+        };
+        const worktreesRoot = this.context.paths.worktreesRoot;
+        if (fs.existsSync(worktreesRoot)) {
+            try {
+                const watcher = fs.watch(worktreesRoot, { recursive: true }, (event, filename) => {
+                    if (filename && filename.endsWith(FEAT_FORGE_GENERATED_SERVICES_FILE)) {
+                        rebuild();
+                    }
+                });
+                watchers.push(watcher);
+            }
+            catch {
+                const watcher = fs.watch(worktreesRoot, () => rebuild());
+                watchers.push(watcher);
+            }
+        }
+        this.stopWatching = () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            watchers.forEach((w) => w.close());
+        };
+    }
+    showSummary(port) {
+        console.log('\nProxy Routing Table:');
+        const byBranch = new Map();
+        for (const [key, route] of this.routingTable) {
+            const entries = byBranch.get(route.branchName) || [];
+            entries.push({ serviceName: route.serviceName, key, target: route.url });
+            byBranch.set(route.branchName, entries);
+        }
+        for (const [branch, services] of byBranch) {
+            console.log(`\n  📦 ${branch}:`);
+            for (const svc of services) {
+                console.log(`      🚀 ${svc.serviceName}`);
+                console.log(`          🔀 http://${svc.key}.localhost:${port}`);
+                console.log(`          🎯 ${svc.target}`);
+            }
+        }
+    }
+    registerShutdownHandlers() {
+        const cleanup = () => {
+            console.log('\n\nShutting down proxy...');
+            this.stop();
+            console.log('Proxy stopped.');
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    }
+}