repoburg 1.3.201 → 1.3.202

package/daemon/dist/api/services.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const serviceManager_1 = require("../serviceManager");
 const checkAuth_1 = require("../middleware/checkAuth");
+const workspace_validation_1 = require("../workspace-validation");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const router = (0, express_1.Router)();
 router.get('/', (req, res) => {
@@ -28,6 +29,9 @@ router.post('/start', checkAuth_1.checkAuth, async (req, res) => {
         res.status(201).json(service);
     }
     catch (error) {
+        if (error instanceof workspace_validation_1.WorkspaceValidationError) {
+            return res.status(400).json({ error: error.message });
+        }
         const message = error instanceof Error ? error.message : 'An unknown error occurred';
         res.status(500).json({ error: message });
     }

package/daemon/dist/serviceManager.js

@@ -37,10 +37,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serviceManager = void 0;
+exports.backendScriptPath = backendScriptPath;
+exports.describeError = describeError;
 const pm2_1 = __importDefault(require("pm2"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const stateManager_1 = require("./stateManager");
+const workspace_validation_1 = require("./workspace-validation");
+/**
+ * Resolve the backend entry script. Production resolves ABSOLUTELY from the
+ * package layout: pm2 resolves bare script names against ITS daemon cwd,
+ * which breaks `repoburg-backend` whenever the PM2 God daemon runs from an
+ * unrelated directory.
+ */
+function backendScriptPath(fromDir, isDevelopment) {
+    return isDevelopment
+        ? path_1.default.resolve(fromDir, '../../backend/dist/main.js')
+        : path_1.default.resolve(fromDir, '../../backend/dist/src/main.js');
+}
+/** Human message for unknown errors (pm2 throws arrays of Errors). */
+function describeError(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (Array.isArray(error))
+        return error.map(describeError).join('; ');
+    return String(error);
+}
 const get_port_1 = __importStar(require("./utils/get-port"));
 class ServiceManager {
     constructor() {
@@ -137,27 +159,25 @@ class ServiceManager {
         };
     }
     async start(projectPath, customName) {
-        const absolutePath = path_1.default.resolve(projectPath);
-        console.log(`Starting service absolutePath ${projectPath}`);
-        const name = customName || path_1.default.basename(absolutePath);
+        const name = customName || path_1.default.basename(path_1.default.resolve(projectPath));
+        // Validate BEFORE the same-name replacement below: the service being
+        // replaced must not collide with itself, but every other service counts.
+        const others = stateManager_1.stateManager.getServices().filter((s) => s.name !== name);
+        const absolutePath = (0, workspace_validation_1.validateWorkspacePath)(projectPath, others.map((s) => ({ name: s.name, path: s.path })));
+        console.log(`Starting service for workspace ${absolutePath}`);
         if (stateManager_1.stateManager.getService(name)) {
             console.log(`Service '${name}' already exists. Removing it before starting a new one.`);
             await this.remove(name);
         }
         const port = await (0, get_port_1.default)({ port: (0, get_port_1.portNumbers)(3400, 3999) });
         const isDevelopment = process.env.NODE_ENV === 'development';
-        let script;
         let interpreter = undefined;
+        const script = backendScriptPath(__dirname, isDevelopment);
         if (isDevelopment) {
             interpreter = 'node';
-            // In development, resolve relative to __dirname of this file
-            script = path_1.default.resolve(__dirname, '../../backend/dist/main.js');
             console.log(`[ServiceManager] Development mode detected (NODE_ENV=${process.env.NODE_ENV}).`);
         }
         else {
-            // In production, we use the command exposed by the npm package's bin field.
-            // pm2 will resolve this from the system's PATH.
-            script = 'repoburg-backend';
             console.log(`[ServiceManager] Production mode detected (NODE_ENV=${process.env.NODE_ENV}).`);
         }
         console.log(`[ServiceManager] Starting backend service using script: ${script}`);
@@ -190,9 +210,8 @@ class ServiceManager {
             return newService;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'An unknown error occurred';
             console.error(`Failed to start service for ${projectPath}:`, error);
-            throw new Error(`Failed to start service: ${message}`);
+            throw new Error(`Failed to start service: ${describeError(error)}`);
         }
     }
     async stop(name) {

package/daemon/dist/serviceManager.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const serviceManager_1 = require("./serviceManager");
+describe('backendScriptPath', () => {
+    it('resolves the repo build in development', () => {
+        expect((0, serviceManager_1.backendScriptPath)(path_1.default.join('/repo', 'daemon', 'src'), true)).toBe(path_1.default.join('/repo', 'backend', 'dist', 'main.js'));
+    });
+    it('resolves the package build absolutely in production', () => {
+        expect((0, serviceManager_1.backendScriptPath)(path_1.default.join('/pkg', 'repoburg', 'daemon', 'dist'), false)).toBe(path_1.default.join('/pkg', 'repoburg', 'backend', 'dist', 'src', 'main.js'));
+    });
+});
+describe('describeError', () => {
+    it('returns the message of an Error', () => {
+        expect((0, serviceManager_1.describeError)(new Error('boom'))).toBe('boom');
+    });
+    it('joins pm2 arrays of Errors', () => {
+        expect((0, serviceManager_1.describeError)([new Error('a'), new Error('b')])).toBe('a; b');
+    });
+    it('stringifies non-Error values', () => {
+        expect((0, serviceManager_1.describeError)('plain')).toBe('plain');
+    });
+});

package/daemon/dist/workspace-validation.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceValidationError = void 0;
+exports.validateWorkspacePath = validateWorkspacePath;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/** Thrown when a workspace path fails start validation (HTTP 400 in the API). */
+class WorkspaceValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceValidationError';
+    }
+}
+exports.WorkspaceValidationError = WorkspaceValidationError;
+/** true when child is strictly under parent (not equal). */
+function isUnder(child, parent) {
+    return child.startsWith(parent + path_1.sep);
+}
+/**
+ * Validate a workspace path before a backend is started for it:
+ *  - must be absolute,
+ *  - must exist and be a directory,
+ *  - must not be $HOME or a filesystem root,
+ *  - must not overlap another service workspace (nested either way).
+ * Returns the resolved absolute path; throws WorkspaceValidationError
+ * with a clear message otherwise.
+ */
+function validateWorkspacePath(projectPath, existingServices) {
+    if (!projectPath || !(0, path_1.isAbsolute)(projectPath)) {
+        throw new WorkspaceValidationError(`Project path must be absolute (got "${projectPath}").`);
+    }
+    const resolved = (0, path_1.resolve)(projectPath);
+    let stat;
+    try {
+        stat = (0, fs_1.statSync)(resolved);
+    }
+    catch {
+        throw new WorkspaceValidationError(`Workspace directory does not exist: ${resolved}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new WorkspaceValidationError(`Workspace path is not a directory: ${resolved}`);
+    }
+    if (resolved === (0, os_1.homedir)()) {
+        throw new WorkspaceValidationError(`Refusing to use the home directory as a workspace: ${resolved}`);
+    }
+    if (resolved === (0, path_1.parse)(resolved).root) {
+        throw new WorkspaceValidationError(`Refusing to use a filesystem root as a workspace: ${resolved}`);
+    }
+    for (const svc of existingServices) {
+        const svcPath = (0, path_1.resolve)(svc.path);
+        if (svcPath === resolved) {
+            throw new WorkspaceValidationError(`Workspace ${resolved} is already served by service "${svc.name}".`);
+        }
+        if (isUnder(resolved, svcPath)) {
+            throw new WorkspaceValidationError(`Workspace ${resolved} is nested inside existing service "${svc.name}" (${svcPath}).`);
+        }
+        if (isUnder(svcPath, resolved)) {
+            throw new WorkspaceValidationError(`Workspace ${resolved} contains existing service "${svc.name}" (${svcPath}).`);
+        }
+    }
+    return resolved;
+}

package/daemon/dist/workspace-validation.spec.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const workspace_validation_1 = require("./workspace-validation");
+describe('validateWorkspacePath', () => {
+    let dir;
+    let otherDir;
+    let filePath;
+    beforeAll(() => {
+        dir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'ws-valid-'));
+        otherDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'ws-other-'));
+        (0, fs_1.mkdirSync)((0, path_1.join)(dir, 'child'));
+        filePath = (0, path_1.join)(dir, 'not-a-dir');
+        (0, fs_1.writeFileSync)(filePath, 'file');
+    });
+    afterAll(() => {
+        (0, fs_1.rmSync)(dir, { recursive: true, force: true });
+        (0, fs_1.rmSync)(otherDir, { recursive: true, force: true });
+    });
+    it('accepts an existing absolute directory and returns the resolved path', () => {
+        const resolved = (0, path_1.resolve)(dir);
+        expect((0, workspace_validation_1.validateWorkspacePath)(dir, [])).toBe(resolved);
+    });
+    it('normalizes redundant path segments', () => {
+        const messy = (0, path_1.join)(dir, 'a', '..', 'b', '..');
+        expect((0, workspace_validation_1.validateWorkspacePath)(messy, [])).toBe((0, path_1.resolve)(dir));
+    });
+    it('rejects non-absolute paths', () => {
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)('relative/path', [])).toThrow(workspace_validation_1.WorkspaceValidationError);
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)('', [])).toThrow(workspace_validation_1.WorkspaceValidationError);
+    });
+    it('rejects paths that do not exist', () => {
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)((0, path_1.join)(dir, 'missing'), [])).toThrow(/Workspace directory does not exist/);
+    });
+    it('rejects paths that are not directories', () => {
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)(filePath, [])).toThrow(/not a directory/);
+    });
+    it('rejects the home directory', () => {
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)((0, os_1.homedir)(), [])).toThrow(/home directory/);
+    });
+    it('rejects filesystem roots', () => {
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)((0, path_1.parse)(dir).root, [])).toThrow(/filesystem root/);
+    });
+    it('rejects a duplicate of an existing service workspace', () => {
+        const existing = [{ name: 'svc', path: otherDir }];
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)(otherDir, existing)).toThrow(/already served/);
+    });
+    it('rejects a workspace nested inside an existing service', () => {
+        const existing = [{ name: 'svc', path: dir }];
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)((0, path_1.join)(dir, 'child'), [])).not.toThrow();
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)((0, path_1.join)(dir, 'child'), existing)).toThrow(/nested inside/);
+    });
+    it('rejects a workspace that contains an existing service', () => {
+        const existing = [{ name: 'svc', path: (0, path_1.join)(dir, 'child') }];
+        expect(() => (0, workspace_validation_1.validateWorkspacePath)(dir, existing)).toThrow(/contains existing service/);
+    });
+    it('accepts a sibling of an existing service', () => {
+        const existing = [{ name: 'svc', path: otherDir }];
+        expect((0, workspace_validation_1.validateWorkspacePath)(dir, existing)).toBe((0, path_1.resolve)(dir));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repoburg",
-  "version": "1.3.201",
+  "version": "1.3.202",
   "description": "A local AI-powered software developer assistant that runs on your own machine.",
   "author": "Celal Ertug",
   "license": "SEE LICENSE IN LICENSE",