tide-commander 1.95.0 → 1.96.0

package/dist/src/packages/server/routes/buildings.js

@@ -0,0 +1,298 @@
+/**
+ * Building Routes
+ * REST API endpoints for building lifecycle and control.
+ *
+ * This is the canonical surface for agents managing buildings. The
+ * underlying buildingService handles validation, ID generation,
+ * credential encryption, broadcast events, and PM2/Docker/Terminal
+ * reconciliation.
+ *
+ * Routes:
+ *   GET    /api/buildings                      - List buildings (secrets redacted)
+ *   GET    /api/buildings/:id                  - Get one building (secrets redacted)
+ *   POST   /api/buildings                      - Create a building
+ *   PATCH  /api/buildings/:id                  - Partial update
+ *   DELETE /api/buildings/:id[?cleanup=false]  - Delete (default: cleanup runtime artifacts)
+ *
+ *   POST   /api/buildings/:id/command          - { command } start|stop|restart|healthCheck|logs|delete
+ *   GET    /api/buildings/:id/logs?lines=200&service=foo - Snapshot logs (PM2/Docker/custom)
+ *   POST   /api/buildings/:id/sync-status      - Force PM2/Docker status refresh
+ *   POST   /api/buildings/:id/subordinates     - Assign subordinates (boss only)
+ *
+ *   POST   /api/buildings/boss/:id/command     - { command } start_all|stop_all|restart_all
+ *
+ *   GET    /api/buildings/docker/containers    - List adoptable containers + compose projects
+ */
+import { Router } from 'express';
+import { buildingService } from '../services/index.js';
+import * as dockerService from '../services/docker-service.js';
+import * as terminalService from '../services/terminal-service.js';
+import { broadcast } from '../websocket/handler.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('BuildingRoutes');
+const router = Router();
+let broadcastFn = null;
+/**
+ * Wire the WebSocket broadcaster. Called from the websocket handler at startup.
+ * Falls back to the directly-imported broadcast() at call time if not wired,
+ * which lets these routes work in tests that don't initialise the WS layer.
+ */
+export function setBroadcast(fn) {
+    broadcastFn = fn;
+}
+function emit(message) {
+    if (broadcastFn) {
+        broadcastFn(message);
+    }
+    else {
+        // In production setBroadcast() is always called from the WS handler init;
+        // this fallback keeps unit tests working without the full WS bootstrap.
+        try {
+            broadcast(message);
+        }
+        catch {
+            // No WS server up — broadcast is best-effort.
+        }
+    }
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const VALID_COMMANDS = new Set([
+    'start', 'stop', 'restart', 'healthCheck', 'logs', 'delete',
+]);
+const VALID_BOSS_COMMANDS = new Set([
+    'start_all', 'stop_all', 'restart_all',
+]);
+function redactDatabaseConnection(c) {
+    return {
+        id: c.id,
+        name: c.name,
+        engine: c.engine,
+        host: c.host,
+        port: c.port,
+        username: c.username,
+        database: c.database,
+        filepath: c.filepath,
+        ssl: c.ssl,
+        hasPassword: Boolean(c.password),
+        ssh: c.ssh
+            ? {
+                enabled: c.ssh.enabled,
+                host: c.ssh.host,
+                port: c.ssh.port,
+                username: c.ssh.username,
+                authMethod: c.ssh.authMethod,
+                hasPassword: Boolean(c.ssh.password),
+                hasPrivateKey: Boolean(c.ssh.privateKey || c.ssh.privateKeyPath),
+            }
+            : undefined,
+    };
+}
+/**
+ * Strip secret fields before returning a building over HTTP.
+ * Plaintext credentials may sit in memory after the agent creates a building,
+ * but they must never come back out of GET responses.
+ */
+function redactBuilding(building) {
+    const out = { ...building };
+    if (building.database?.connections) {
+        out.database = {
+            ...building.database,
+            connections: building.database.connections.map(redactDatabaseConnection),
+        };
+    }
+    return out;
+}
+// ─── CRUD ─────────────────────────────────────────────────────────────────────
+// GET /api/buildings — list all buildings (redacted)
+router.get('/', (_req, res) => {
+    const buildings = buildingService.getBuildings().map(redactBuilding);
+    res.json({ buildings });
+});
+// GET /api/buildings/docker/containers — adoptable containers + compose projects
+// (Must come before /:id so the docker prefix doesn't match as an id.)
+router.get('/docker/containers', async (_req, res) => {
+    try {
+        const [containers, composeProjects] = await Promise.all([
+            dockerService.listAllContainers(),
+            dockerService.listComposeProjects(),
+        ]);
+        res.json({ containers, composeProjects });
+    }
+    catch (err) {
+        log.error('Failed to list Docker resources:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// POST /api/buildings/boss/:id/command — body { command }
+// Must come before /:id/command so 'boss' isn't matched as an id.
+router.post('/boss/:id/command', async (req, res) => {
+    const command = req.body?.command;
+    if (!command || !VALID_BOSS_COMMANDS.has(command)) {
+        res.status(400).json({
+            error: `command must be one of: ${[...VALID_BOSS_COMMANDS].join(', ')}`,
+        });
+        return;
+    }
+    try {
+        const result = await buildingService.executeBossBuildingCommand(req.params.id, command, emit);
+        res.json(result);
+    }
+    catch (err) {
+        log.error(`Boss command failed for ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// GET /api/buildings/:id — fetch one (redacted)
+router.get('/:id', (req, res) => {
+    const building = buildingService.getBuilding(req.params.id);
+    if (!building) {
+        res.status(404).json({ error: `Building not found: ${req.params.id}` });
+        return;
+    }
+    res.json(redactBuilding(building));
+});
+// POST /api/buildings — create
+router.post('/', async (req, res) => {
+    try {
+        const result = await buildingService.createBuilding(req.body, emit);
+        if (!result.ok) {
+            res.status(result.status).json({ error: 'Validation failed', errors: result.errors });
+            return;
+        }
+        res.status(201).json(redactBuilding(result.building));
+    }
+    catch (err) {
+        log.error('Failed to create building:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// PATCH /api/buildings/:id — partial update
+router.patch('/:id', async (req, res) => {
+    try {
+        const result = await buildingService.updateBuilding(req.params.id, req.body, emit);
+        if (!result.ok) {
+            res.status(result.status).json({
+                error: result.status === 404 ? 'Not found' : 'Validation failed',
+                errors: result.errors,
+            });
+            return;
+        }
+        res.json(redactBuilding(result.building));
+    }
+    catch (err) {
+        log.error(`Failed to update building ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// DELETE /api/buildings/:id?cleanup=false — delete (optionally skip runtime cleanup)
+router.delete('/:id', async (req, res) => {
+    try {
+        const cleanup = req.query.cleanup !== 'false';
+        const result = await buildingService.deleteBuilding(req.params.id, emit, { cleanup });
+        if (!result.ok) {
+            res.status(result.status).json({ error: result.error });
+            return;
+        }
+        res.json({ deleted: true });
+    }
+    catch (err) {
+        log.error(`Failed to delete building ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// ─── Controls ─────────────────────────────────────────────────────────────────
+// POST /api/buildings/:id/command — body { command }
+router.post('/:id/command', async (req, res) => {
+    const command = req.body?.command;
+    if (!command || !VALID_COMMANDS.has(command)) {
+        res.status(400).json({
+            error: `command must be one of: ${[...VALID_COMMANDS].join(', ')}`,
+        });
+        return;
+    }
+    try {
+        const result = await buildingService.executeCommand(req.params.id, command, emit);
+        if (!result.success && result.error?.includes('not found')) {
+            res.status(404).json({ error: result.error });
+            return;
+        }
+        res.json(result);
+    }
+    catch (err) {
+        log.error(`Command ${command} failed for ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// GET /api/buildings/:id/logs?lines=200&service=foo — snapshot logs
+router.get('/:id/logs', async (req, res) => {
+    const lines = Number.parseInt(String(req.query.lines ?? '200'), 10);
+    const service = typeof req.query.service === 'string' ? req.query.service : undefined;
+    try {
+        const result = await buildingService.getBuildingLogs(req.params.id, Number.isFinite(lines) && lines > 0 ? Math.min(lines, 5000) : 200, service);
+        if (!result.ok) {
+            res.status(result.status).json({ error: result.error });
+            return;
+        }
+        res.json({ source: result.source, logs: result.logs, lines: result.logs.split('\n').length });
+    }
+    catch (err) {
+        log.error(`Logs fetch failed for ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// POST /api/buildings/:id/sync-status — force PM2/Docker status refresh
+router.post('/:id/sync-status', async (req, res) => {
+    const building = buildingService.getBuilding(req.params.id);
+    if (!building) {
+        res.status(404).json({ error: `Building not found: ${req.params.id}` });
+        return;
+    }
+    try {
+        if (building.pm2?.enabled) {
+            await buildingService.syncPM2Status(building.id, emit);
+            const refreshed = buildingService.getBuilding(building.id);
+            res.json({ source: 'pm2', status: refreshed?.status, pm2Status: refreshed?.pm2Status });
+            return;
+        }
+        if (building.docker?.enabled) {
+            await buildingService.syncDockerStatus(building.id, emit);
+            const refreshed = buildingService.getBuilding(building.id);
+            res.json({ source: 'docker', status: refreshed?.status, dockerStatus: refreshed?.dockerStatus });
+            return;
+        }
+        if (building.terminal?.enabled) {
+            const status = terminalService.getTerminalStatus(building);
+            res.json({ source: 'terminal', status: status ? 'running' : 'stopped', terminalStatus: status });
+            return;
+        }
+        res.json({ source: 'none', status: building.status });
+    }
+    catch (err) {
+        log.error(`sync-status failed for ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// POST /api/buildings/:id/subordinates — body { subordinateBuildingIds: string[] }
+router.post('/:id/subordinates', async (req, res) => {
+    const ids = req.body?.subordinateBuildingIds;
+    if (!Array.isArray(ids) || ids.some((s) => typeof s !== 'string')) {
+        res.status(400).json({ error: 'subordinateBuildingIds must be an array of strings' });
+        return;
+    }
+    try {
+        const result = await buildingService.assignSubordinates(req.params.id, ids, emit);
+        if (!result.ok) {
+            res.status(result.status).json({
+                error: result.status === 404 ? 'Not found' : 'Invalid request',
+                errors: result.errors,
+            });
+            return;
+        }
+        res.json(redactBuilding(result.building));
+    }
+    catch (err) {
+        log.error(`assignSubordinates failed for ${req.params.id}:`, err);
+        res.status(500).json({ error: err.message });
+    }
+});
+export default router;

package/dist/src/packages/server/routes/index.js

@@ -24,6 +24,7 @@ import eventRouter from './event-routes.js';
 import workflowRouter from './workflow-routes.js';
 import sessionsRouter from './sessions.js';
 import databaseRouter from './database.js';
+import buildingsRouter, { setBroadcast as setBuildingsBroadcast } from './buildings.js';
 import { getPlugins } from '../integrations/integration-registry.js';
 const router = Router();
 // Health check
@@ -50,6 +51,7 @@ router.use('/events', eventRouter);
 router.use('/workflows', workflowRouter);
 router.use('/sessions', sessionsRouter);
 router.use('/database', databaseRouter);
+router.use('/buildings', buildingsRouter);
 // Integration plugin routes (e.g. /api/slack/*, /api/documents/*, /api/jira/*)
 // Uses lazy lookup so plugins can be registered after route setup
 router.use((req, res, next) => {
@@ -68,5 +70,5 @@ router.use('/config', raw({ type: 'application/zip', limit: '100mb' }), configRo
 // Permission routes are mounted at root level since they're called as /api/permission-request
 router.use('/', permissionsRouter);
 // Export the broadcast setters for WebSocket handler to use
-export { setNotificationBroadcast, setExecBroadcast, setFocusAgentBroadcast, setAgentsBroadcast, setTriggerBroadcast };
+export { setNotificationBroadcast, setExecBroadcast, setFocusAgentBroadcast, setAgentsBroadcast, setTriggerBroadcast, setBuildingsBroadcast };
 export default router;