repoburg 1.3.201 → 1.3.204

package/daemon/dist/agentPane.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Agent-pane embed — loads the agent-pane backend bundle in-process so the
+ * daemon serves it behind its own port (no second listener).
+ *
+ * The bundle (agent-pane/backend/dist/server.js, ESM, built by esbuild) is
+ * loaded with a dynamic import; its `createAgentPaneApp` factory builds the
+ * Fastify app with an explicit DB path. The daemon delegates `/api/*` requests
+ * to `fastify.routing()` and routes `/ws` upgrades to the app's WebSocket
+ * server. Env kill-switch: REPOBURG_EMBED_AGENT_PANE=0 disables the embed.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAgentPaneDist = resolveAgentPaneDist;
+exports.agentPaneDbDir = agentPaneDbDir;
+exports.migrateLegacyDb = migrateLegacyDb;
+exports.loadAgentPane = loadAgentPane;
+exports.createPaneDelegate = createPaneDelegate;
+exports.createUpgradeRouter = createUpgradeRouter;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const url_1 = require("url");
+/**
+ * Resolve the agent-pane bundle path ABSOLUTELY (pm2 God-daemon-cwd bug class:
+ * never resolve runtime paths against the process cwd).
+ *
+ * Works for dev (daemon/src or daemon/dist under the repo) and for the
+ * published layout (repoburg/daemon/dist -> repoburg/agent-pane/backend/dist).
+ */
+function resolveAgentPaneDist(fromDir) {
+    return path_1.default.resolve(fromDir, '../../agent-pane/backend/dist/server.js');
+}
+/** Directory holding the embedded app's DB (alongside services.json). */
+function agentPaneDbDir(home = os_1.default.homedir()) {
+    return path_1.default.join(home, '.repoburg', 'agent-pane');
+}
+/**
+ * One-time migration: copy the legacy dev DB into the embedded location.
+ *
+ * Copies the DB file plus any WAL/SHM sidecars. No-op when the source is
+ * missing (published installs) or the destination already exists.
+ *
+ * @returns true when a copy was performed.
+ */
+function migrateLegacyDb(sourceDbPath, destDbPath) {
+    if (!fs_extra_1.default.existsSync(sourceDbPath) || fs_extra_1.default.existsSync(destDbPath)) {
+        return false;
+    }
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(destDbPath));
+    const sidecars = ['', '-wal', '-shm'];
+    for (const suffix of sidecars) {
+        const src = `${sourceDbPath}${suffix}`;
+        if (fs_extra_1.default.existsSync(src)) {
+            fs_extra_1.default.copyFileSync(src, `${destDbPath}${suffix}`);
+        }
+    }
+    console.log(`[agentPane] migrated legacy DB ${sourceDbPath} -> ${destDbPath}`);
+    return true;
+}
+/** Load and initialise the embedded agent-pane app. Returns null when disabled/absent. */
+async function loadAgentPane(opts = {}) {
+    if ((opts.envDisable ?? process.env.REPOBURG_EMBED_AGENT_PANE) === '0') {
+        console.log('[agentPane] embed disabled via REPOBURG_EMBED_AGENT_PANE=0');
+        return null;
+    }
+    const distPath = opts.distPath ?? resolveAgentPaneDist(__dirname);
+    if (!fs_extra_1.default.existsSync(distPath)) {
+        console.warn(`[agentPane] bundle not found at ${distPath} — /api/* responds 503`);
+        return null;
+    }
+    const dbPath = opts.dbPath ?? path_1.default.join(agentPaneDbDir(), 'data.db');
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(dbPath));
+    migrateLegacyDb(opts.legacyDbPath ?? resolveAgentPaneDist(__dirname).replace('dist/server.js', 'data.db'), dbPath);
+    // Dynamic import: the bundle is ESM; the daemon itself is CommonJS.
+    // new Function keeps the RUNTIME import even under ts-jest, which would
+    // otherwise transpile import() into require() (ESM-incompatible).
+    const dynamicImport = new Function('specifier', 'return import(specifier);');
+    const mod = await dynamicImport((0, url_1.pathToFileURL)(distPath).href);
+    const { fastify, wss } = await mod.createAgentPaneApp(dbPath);
+    await fastify.ready();
+    console.log(`[agentPane] embedded app ready (db: ${dbPath})`);
+    return {
+        routing: fastify.routing.bind(fastify),
+        handleWsUpgrade: (req, socket, head) => {
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit('connection', ws, req);
+            });
+        },
+        shutdown: mod.shutdownAllProviders,
+        close: () => fastify.close(),
+    };
+}
+/**
+ * Express middleware delegating `/api/*` to the embedded app.
+ *
+ * Mount BEFORE `express.json()` — Fastify parses its own request bodies, and
+ * the stream can only be consumed once.
+ */
+function createPaneDelegate(pane) {
+    return (req, res) => {
+        if (!pane) {
+            res.status(503).json({ error: 'agent-pane is not available on this daemon' });
+            return;
+        }
+        pane.routing(req, res);
+    };
+}
+/**
+ * Single upgrade router for the daemon's HTTP server.
+ *
+ * `/ws` goes to the embedded agent-pane app (when present); everything else —
+ * e.g. the platform frontend's auth WebSocket — goes to the daemon wss.
+ */
+function createUpgradeRouter(pane, daemonWss) {
+    return (req, socket, head) => {
+        const url = req.url || '';
+        if (pane && url.startsWith('/ws')) {
+            pane.handleWsUpgrade(req, socket, head);
+            return;
+        }
+        daemonWss.handleUpgrade(req, socket, head, (ws) => {
+            daemonWss.emit('connection', ws, req);
+        });
+    };
+}

package/daemon/dist/agentPane.spec.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Specs for the agent-pane embed: path resolution, legacy DB migration,
+ * delegation middleware, upgrade routing, and the loader (stub + real bundle).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const agentPane_1 = require("./agentPane");
+// Stub bundle contents: an ESM module satisfying the embed contract.
+const STUB_DIST = `
+export async function createAgentPaneApp(dbPath) {
+  globalThis.__stubDbPath = dbPath;
+  return {
+    fastify: {
+      ready: async () => {},
+      routing: (req, res) => { res.end('pane:' + req.url); },
+      close: async () => {},
+    },
+    wss: {
+      handleUpgrade: (req, socket, head, cb) => { cb({ stub: true }); },
+      emit: () => {},
+    },
+  };
+}
+export async function shutdownAllProviders() { globalThis.__stubShutdown = true; }
+`;
+function writeStubDist(dir) {
+    fs_extra_1.default.ensureDirSync(dir);
+    const distPath = path_1.default.join(dir, 'server.js');
+    fs_extra_1.default.writeFileSync(distPath, STUB_DIST);
+    return distPath;
+}
+function tmpDir(name) {
+    return fs_extra_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `agentpane-${name}-`));
+}
+function makeLegacyDb(dir, content = 'legacy-data') {
+    const legacyDb = path_1.default.join(dir, 'legacy', 'data.db');
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(legacyDb));
+    fs_extra_1.default.writeFileSync(legacyDb, content);
+    return legacyDb;
+}
+describe('resolveAgentPaneDist', () => {
+    it('resolves an absolute path under the repo/package layout from either src or dist', () => {
+        const fromSrc = (0, agentPane_1.resolveAgentPaneDist)('/repo/daemon/src');
+        const fromDist = (0, agentPane_1.resolveAgentPaneDist)('/repo/daemon/dist');
+        expect(fromSrc).toBe('/repo/agent-pane/backend/dist/server.js');
+        expect(fromDist).toBe('/repo/agent-pane/backend/dist/server.js');
+        expect(path_1.default.isAbsolute(fromSrc)).toBe(true);
+    });
+});
+describe('agentPaneDbDir', () => {
+    it('lives under ~/.repoburg/agent-pane', () => {
+        expect((0, agentPane_1.agentPaneDbDir)('/home/tester')).toBe(path_1.default.join('/home/tester', '.repoburg', 'agent-pane'));
+    });
+});
+describe('migrateLegacyDb', () => {
+    it('copies the DB plus WAL/SHM sidecars when the destination is missing', () => {
+        const dir = tmpDir('migrate');
+        const src = path_1.default.join(dir, 'data.db');
+        fs_extra_1.default.writeFileSync(src, 'base');
+        fs_extra_1.default.writeFileSync(`${src}-wal`, 'wal');
+        const dest = path_1.default.join(dir, 'dest', 'data.db');
+        expect((0, agentPane_1.migrateLegacyDb)(src, dest)).toBe(true);
+        expect(fs_extra_1.default.readFileSync(dest, 'utf-8')).toBe('base');
+        expect(fs_extra_1.default.readFileSync(`${dest}-wal`, 'utf-8')).toBe('wal');
+    });
+    it('is a no-op when the destination already exists', () => {
+        const dir = tmpDir('migrate-dest-exists');
+        const src = path_1.default.join(dir, 'data.db');
+        const dest = path_1.default.join(dir, 'out', 'data.db');
+        fs_extra_1.default.writeFileSync(src, 'base');
+        fs_extra_1.default.ensureDirSync(path_1.default.dirname(dest));
+        fs_extra_1.default.writeFileSync(dest, 'existing');
+        expect((0, agentPane_1.migrateLegacyDb)(src, dest)).toBe(false);
+        expect(fs_extra_1.default.readFileSync(dest, 'utf-8')).toBe('existing');
+    });
+    it('is a no-op when the source is missing', () => {
+        const dir = tmpDir('migrate-no-source');
+        expect((0, agentPane_1.migrateLegacyDb)(path_1.default.join(dir, 'absent.db'), path_1.default.join(dir, 'out', 'data.db'))).toBe(false);
+    });
+});
+describe('createPaneDelegate', () => {
+    it('responds 503 when the pane is not loaded', () => {
+        const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+        (0, agentPane_1.createPaneDelegate)(null)({}, res);
+        expect(res.status).toHaveBeenCalledWith(503);
+        expect(res.json).toHaveBeenCalledWith({ error: 'agent-pane is not available on this daemon' });
+    });
+    it('routes raw request/response into the embedded fastify router', () => {
+        const routing = jest.fn();
+        const pane = {
+            routing,
+            handleWsUpgrade: jest.fn(),
+            shutdown: jest.fn(),
+            close: jest.fn(),
+        };
+        const req = { url: '/api/sessions' };
+        const res = {};
+        (0, agentPane_1.createPaneDelegate)(pane)(req, res);
+        expect(routing).toHaveBeenCalledWith(req, res);
+    });
+});
+describe('createUpgradeRouter', () => {
+    it('sends /ws upgrades to the embedded pane', () => {
+        const pane = {
+            routing: jest.fn(),
+            handleWsUpgrade: jest.fn(),
+            shutdown: jest.fn(),
+            close: jest.fn(),
+        };
+        const daemonWss = { handleUpgrade: jest.fn(), emit: jest.fn() };
+        const route = (0, agentPane_1.createUpgradeRouter)(pane, daemonWss);
+        route({ url: '/ws' }, {}, Buffer.alloc(0));
+        expect(pane.handleWsUpgrade).toHaveBeenCalled();
+        expect(daemonWss.handleUpgrade).not.toHaveBeenCalled();
+    });
+    it('sends non-/ws upgrades to the daemon wss and emits connection', () => {
+        const pane = { handleWsUpgrade: jest.fn() };
+        const daemonWss = {
+            handleUpgrade: jest.fn((_req, _socket, _head, cb) => cb({ daemon: true })),
+            emit: jest.fn(),
+        };
+        const route = (0, agentPane_1.createUpgradeRouter)(pane, daemonWss);
+        route({ url: '/' }, {}, Buffer.alloc(0));
+        expect(pane.handleWsUpgrade).not.toHaveBeenCalled();
+        expect(daemonWss.handleUpgrade).toHaveBeenCalled();
+        expect(daemonWss.emit).toHaveBeenCalledWith('connection', { daemon: true }, { url: '/' });
+    });
+    it('falls back to the daemon wss for /ws when the pane is absent', () => {
+        const daemonWss = {
+            handleUpgrade: jest.fn((_req, _socket, _head, cb) => cb({})),
+            emit: jest.fn(),
+        };
+        const route = (0, agentPane_1.createUpgradeRouter)(null, daemonWss);
+        route({ url: '/ws' }, {}, Buffer.alloc(0));
+        expect(daemonWss.handleUpgrade).toHaveBeenCalled();
+    });
+});
+describe('loadAgentPane', () => {
+    it('returns null when disabled via the kill-switch', async () => {
+        expect(await (0, agentPane_1.loadAgentPane)({ envDisable: '0', distPath: 'unused' })).toBeNull();
+    });
+    it('returns null when the bundle is missing', async () => {
+        const dir = tmpDir('no-dist');
+        expect(await (0, agentPane_1.loadAgentPane)({ distPath: path_1.default.join(dir, 'absent.js') })).toBeNull();
+    });
+    it('loads the stub bundle, wires routing/shutdown, and migrates the legacy DB', async () => {
+        const dir = tmpDir('full');
+        const distPath = writeStubDist(path_1.default.join(dir, 'dist'));
+        const dbPath = path_1.default.join(dir, 'home', 'data.db');
+        const legacyDb = makeLegacyDb(dir);
+        const pane = await (0, agentPane_1.loadAgentPane)({ distPath, dbPath, legacyDbPath: legacyDb });
+        expect(pane).not.toBeNull();
+        // DB dir created + legacy DB migrated in.
+        expect(fs_extra_1.default.readFileSync(dbPath, 'utf-8')).toBe('legacy-data');
+        // routing delegates to the stub fastify.
+        const chunks = [];
+        const res = { end: (s) => chunks.push(s) };
+        pane.routing({ url: '/api/sessions' }, res);
+        expect(chunks[0]).toBe('pane:/api/sessions');
+        await pane.shutdown();
+        await pane.close();
+    });
+    it('does not copy a legacy DB over an existing embedded DB', async () => {
+        const dir = tmpDir('no-overwrite');
+        const distPath = writeStubDist(path_1.default.join(dir, 'dist'));
+        const dbPath = path_1.default.join(dir, 'home', 'data.db');
+        const legacyDb = makeLegacyDb(dir);
+        fs_extra_1.default.ensureDirSync(path_1.default.dirname(dbPath));
+        fs_extra_1.default.writeFileSync(dbPath, 'embedded-data');
+        await (0, agentPane_1.loadAgentPane)({ distPath, dbPath, legacyDbPath: legacyDb });
+        expect(fs_extra_1.default.readFileSync(dbPath, 'utf-8')).toBe('embedded-data');
+    });
+    // NOTE: the real bundle is NOT loaded here — jest's vm module loader
+    // cannot provide the CJS interop the bundle's native deps need
+    // ("exports is not defined"). Real-bundle boot is validated by the live
+    // daemon E2E (Phase 5 of the merge plan).
+});

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/index.js

@@ -13,17 +13,28 @@ const services_1 = __importDefault(require("./api/services"));
 const auth_1 = __importDefault(require("./api/auth"));
 const registry_1 = __importDefault(require("./api/registry"));
 const mcp_gateway_1 = require("./mcp-gateway");
+const agentPane_1 = require("./agentPane");
 const PORT = 9998;
 async function main() {
     await serviceManager_1.serviceManager.connect();
+    // Embedded agent-pane backend — served on THIS port (no second listener).
+    // Failure is non-fatal: the daemon keeps managing services, /api/* -> 503.
+    const pane = await (0, agentPane_1.loadAgentPane)().catch((err) => {
+        console.warn('[agentPane] embed failed:', err);
+        return null;
+    });
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
-    const wss = new ws_1.WebSocketServer({ server });
+    // Daemon wss in noServer mode — the shared upgrade router dispatches below.
+    const wss = new ws_1.WebSocketServer({ noServer: true });
     app.use((0, cors_1.default)({
         origin: '*', // Allow all
         methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
         credentials: true,
     }));
+    // Embedded agent-pane API. MUST precede express.json() — Fastify parses its
+    // own request bodies; the stream can only be consumed once.
+    app.all('/api/*', (0, agentPane_1.createPaneDelegate)(pane));
     app.use(express_1.default.json());
     // API Routers
     app.use('/services', services_1.default);
@@ -51,19 +62,28 @@ async function main() {
         ws.on('close', () => console.log('Client disconnected from daemon WebSocket'));
         ws.on('error', (error) => console.error('WebSocket error:', error));
     });
+    // Single upgrade router: '/ws' -> embedded agent-pane, everything else -> daemon wss.
+    server.on('upgrade', (0, agentPane_1.createUpgradeRouter)(pane, wss));
     server.listen(PORT, () => {
         console.log(`Repoburg Platform Daemon listening on http://localhost:${PORT}`);
         console.log(`MCP Gateway available at http://localhost:${PORT}/mcp`);
     });
-    // Clean up MCP gateway sessions on shutdown.
-    process.on('SIGINT', async () => {
-        await mcp_gateway_1.mcpGateway.closeAllSessions();
-        process.exit(0);
-    });
-    process.on('SIGTERM', async () => {
+    // Clean up MCP gateway sessions and the embedded agent-pane on shutdown.
+    const shutdown = async () => {
+        if (pane) {
+            try {
+                await pane.shutdown();
+                await pane.close();
+            }
+            catch (err) {
+                console.error('[agentPane] shutdown failed:', err);
+            }
+        }
         await mcp_gateway_1.mcpGateway.closeAllSessions();
         process.exit(0);
-    });
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
 }
 main().catch(err => {
     console.error("Failed to start daemon:", err);

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/daemon/package.json

@@ -8,7 +8,7 @@
     "build": "tsc",
     "start": "cross-env NODE_ENV=production node dist/index.js",
     "dev": "NODE_ENV=development ts-node-dev --respawn --transpile-only src/index.ts",
-    "test": "jest"
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest"
   },
   "keywords": [],
   "author": "Celal Ertug",