shieldcortex 3.0.3 → 3.1.0

package/dist/api/routes/recall.js

@@ -0,0 +1,36 @@
+import { searchMemoriesExplained } from '../../memory/store.js';
+export function registerRecallRoutes(app, requireNotLocked) {
+    app.get('/api/recall/explain', requireNotLocked, async (req, res) => {
+        try {
+            const query = typeof req.query.query === 'string' ? req.query.query.trim() : '';
+            if (!query) {
+                return res.status(400).json({ error: 'query is required' });
+            }
+            const project = typeof req.query.project === 'string' ? req.query.project : undefined;
+            const type = typeof req.query.type === 'string' ? req.query.type : undefined;
+            const category = typeof req.query.category === 'string' ? req.query.category : undefined;
+            const limit = Math.min(parseInt(req.query.limit, 10) || 10, 50);
+            const includeDecayed = req.query.includeDecayed === 'true';
+            const includeGlobal = req.query.includeGlobal !== 'false';
+            const results = await searchMemoriesExplained({
+                query,
+                project,
+                type: type,
+                category: category,
+                limit,
+                includeDecayed,
+                includeGlobal,
+            });
+            res.json({
+                query,
+                project: project ?? null,
+                total: results.length,
+                sideEffects: 'disabled',
+                results,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+}

package/dist/api/routes/system.d.ts

@@ -0,0 +1,9 @@
+import type { Express } from 'express';
+import { WebSocket } from 'ws';
+import type { MemoryEvent } from '../events.js';
+interface SystemRouteDeps {
+    broadcast: (event: MemoryEvent) => void;
+    clients: Set<WebSocket>;
+}
+export declare function registerSystemRoutes(app: Express, deps: SystemRouteDeps): void;
+export {};

package/dist/api/routes/system.js

@@ -0,0 +1,266 @@
+import { WebSocket } from 'ws';
+import { getCloudConfig, getCloudSyncControls, getDeviceId, getDeviceName, getDefenceMode, getOpenClawMemoryConfig, isConfigTampered, readRawConfig, setCloudConfig, setCloudSyncControls, setDefenceMode, setOpenClawMemoryConfig, } from '../../cloud/config.js';
+import { getQueueStats } from '../../cloud/sync-queue.js';
+import { getDatabase } from '../../database/init.js';
+import { getRequiredTier, isFeatureEnabled } from '../../license/gate.js';
+import { getControlStatus, isKillSwitchActive, pause, resume } from '../control.js';
+import { checkForUpdates, getCurrentVersion, getRunningVersion, performUpdate, scheduleRestart, } from '../version.js';
+export function registerSystemRoutes(app, deps) {
+    const { broadcast, clients } = deps;
+    app.get('/api/control/status', (_req, res) => {
+        try {
+            res.json(getControlStatus());
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/control/pause', (_req, res) => {
+        try {
+            if (isKillSwitchActive()) {
+                return res.status(409).json({ error: 'Kill switch is active — use /api/iron-dome/resume to deactivate first', code: 'KILL_SWITCH_ACTIVE' });
+            }
+            pause();
+            res.json({ paused: true, message: 'Memory creation paused' });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/control/resume', (_req, res) => {
+        try {
+            if (isKillSwitchActive()) {
+                return res.status(409).json({ error: 'Kill switch is active — use /api/iron-dome/resume to deactivate first', code: 'KILL_SWITCH_ACTIVE' });
+            }
+            resume();
+            res.json({ paused: false, message: 'Memory creation resumed' });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/cloud/config', (_req, res) => {
+        try {
+            const config = getCloudConfig();
+            res.json({
+                enabled: config.cloudEnabled,
+                apiKeySet: !!config.cloudApiKey,
+                baseUrl: config.cloudBaseUrl,
+                syncControls: getCloudSyncControls(),
+                openclawMemory: getOpenClawMemoryConfig(),
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/cloud/config', (req, res) => {
+        try {
+            const { cloudApiKey, cloudEnabled, cloudBaseUrl, cloudSyncProjectMode, cloudSyncProjects, cloudSyncContentMode, cloudSyncExcludeSensitive, openclawAutoMemory, openclawAutoMemoryDedupe, openclawAutoMemoryNoveltyThreshold, openclawAutoMemoryMaxRecent, } = req.body;
+            if (openclawAutoMemory !== undefined && typeof openclawAutoMemory !== 'boolean') {
+                return res.status(400).json({ error: 'openclawAutoMemory must be a boolean' });
+            }
+            if (openclawAutoMemoryDedupe !== undefined && typeof openclawAutoMemoryDedupe !== 'boolean') {
+                return res.status(400).json({ error: 'openclawAutoMemoryDedupe must be a boolean' });
+            }
+            if (openclawAutoMemoryNoveltyThreshold !== undefined &&
+                (typeof openclawAutoMemoryNoveltyThreshold !== 'number' || Number.isNaN(openclawAutoMemoryNoveltyThreshold))) {
+                return res.status(400).json({ error: 'openclawAutoMemoryNoveltyThreshold must be a number' });
+            }
+            if (openclawAutoMemoryMaxRecent !== undefined &&
+                (typeof openclawAutoMemoryMaxRecent !== 'number' || Number.isNaN(openclawAutoMemoryMaxRecent))) {
+                return res.status(400).json({ error: 'openclawAutoMemoryMaxRecent must be a number' });
+            }
+            if (cloudSyncProjectMode !== undefined &&
+                cloudSyncProjectMode !== 'all' &&
+                cloudSyncProjectMode !== 'include' &&
+                cloudSyncProjectMode !== 'exclude') {
+                return res.status(400).json({ error: 'cloudSyncProjectMode must be all, include, or exclude' });
+            }
+            if (cloudSyncContentMode !== undefined &&
+                cloudSyncContentMode !== 'full' &&
+                cloudSyncContentMode !== 'metadata') {
+                return res.status(400).json({ error: 'cloudSyncContentMode must be full or metadata' });
+            }
+            if (cloudSyncExcludeSensitive !== undefined &&
+                typeof cloudSyncExcludeSensitive !== 'boolean') {
+                return res.status(400).json({ error: 'cloudSyncExcludeSensitive must be a boolean' });
+            }
+            if (cloudSyncProjects !== undefined &&
+                (!Array.isArray(cloudSyncProjects) || cloudSyncProjects.some((value) => typeof value !== 'string'))) {
+                return res.status(400).json({ error: 'cloudSyncProjects must be an array of strings' });
+            }
+            setCloudConfig({
+                ...(cloudApiKey !== undefined && { cloudApiKey }),
+                ...(cloudEnabled !== undefined && { cloudEnabled }),
+                ...(cloudBaseUrl !== undefined && { cloudBaseUrl }),
+            });
+            setCloudSyncControls({
+                ...(cloudSyncProjectMode !== undefined && { projectMode: cloudSyncProjectMode }),
+                ...(cloudSyncProjects !== undefined && { projects: cloudSyncProjects }),
+                ...(cloudSyncContentMode !== undefined && { contentMode: cloudSyncContentMode }),
+                ...(cloudSyncExcludeSensitive !== undefined && { excludeSensitive: cloudSyncExcludeSensitive }),
+            });
+            setOpenClawMemoryConfig({
+                ...(openclawAutoMemory !== undefined && { autoMemory: openclawAutoMemory }),
+                ...(openclawAutoMemoryDedupe !== undefined && { dedupe: openclawAutoMemoryDedupe }),
+                ...(openclawAutoMemoryNoveltyThreshold !== undefined && { noveltyThreshold: openclawAutoMemoryNoveltyThreshold }),
+                ...(openclawAutoMemoryMaxRecent !== undefined && { maxRecent: openclawAutoMemoryMaxRecent }),
+            });
+            const updated = getCloudConfig();
+            res.json({
+                success: true,
+                enabled: updated.cloudEnabled,
+                apiKeySet: !!updated.cloudApiKey,
+                baseUrl: updated.cloudBaseUrl,
+                syncControls: getCloudSyncControls(),
+                openclawMemory: getOpenClawMemoryConfig(),
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/defence/config', (_req, res) => {
+        try {
+            res.json({ mode: getDefenceMode(), tampered: isConfigTampered() });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/defence/config', (req, res) => {
+        try {
+            const { mode } = req.body;
+            const validModes = ['strict', 'balanced', 'permissive'];
+            if (!mode || !validModes.includes(mode)) {
+                return res.status(400).json({ error: `Invalid mode. Must be one of: ${validModes.join(', ')}` });
+            }
+            setDefenceMode(mode);
+            res.json({ success: true, mode });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/cloud/sync-status', (_req, res) => {
+        try {
+            const config = getCloudConfig();
+            const raw = readRawConfig();
+            const queue = getQueueStats();
+            res.json({
+                enabled: config.cloudEnabled,
+                apiKeySet: !!config.cloudApiKey,
+                baseUrl: config.cloudBaseUrl,
+                featureEnabled: isFeatureEnabled('cloud_sync'),
+                requiredTier: getRequiredTier('cloud_sync'),
+                controls: getCloudSyncControls(),
+                lastSyncAt: (typeof raw.lastSyncAt === 'string' ? raw.lastSyncAt : null),
+                device: {
+                    id: getDeviceId(),
+                    name: getDeviceName(),
+                    platform: `${process.platform}/${process.arch}`,
+                },
+                queue: {
+                    pending: queue.pending,
+                    failed: queue.failed,
+                    synced: queue.synced,
+                    byKind: queue.byKind,
+                    oldestPendingAt: queue.oldestPendingAt,
+                    nextRetryAt: queue.nextRetryAt,
+                    lastError: queue.lastError,
+                    lastErrorKind: queue.lastErrorKind,
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/cloud/projects', (_req, res) => {
+        try {
+            const db = getDatabase();
+            const rows = db.prepare(`
+        SELECT project, COUNT(*) as count
+        FROM memories
+        WHERE project IS NOT NULL AND TRIM(project) != ''
+        GROUP BY project
+        ORDER BY count DESC, project ASC
+      `).all();
+            res.json({
+                projects: rows.map((row) => ({
+                    project: row.project,
+                    count: Number(row.count ?? 0),
+                })),
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/version', (_req, res) => {
+        try {
+            const version = getCurrentVersion();
+            const runningVersion = getRunningVersion();
+            res.json({ version, runningVersion, stale: runningVersion !== version });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/version/check', async (req, res) => {
+        try {
+            res.json(await checkForUpdates(req.query.force === 'true'));
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/version/update', async (_req, res) => {
+        try {
+            broadcast({
+                type: 'update_started',
+                timestamp: new Date().toISOString(),
+                data: { message: 'Update in progress...' },
+            });
+            const result = await performUpdate();
+            broadcast({
+                type: result.success ? 'update_complete' : 'update_failed',
+                timestamp: new Date().toISOString(),
+                data: result,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/version/restart', (_req, res) => {
+        try {
+            broadcast({
+                type: 'server_restarting',
+                timestamp: new Date().toISOString(),
+                data: { message: 'Server restarting in 3 seconds...' },
+            });
+            for (const client of clients) {
+                try {
+                    if (client.readyState === WebSocket.OPEN) {
+                        client.send(JSON.stringify({
+                            type: 'server_restarting',
+                            timestamp: new Date().toISOString(),
+                            data: { reconnectIn: 5000 },
+                        }));
+                    }
+                }
+                catch (error) {
+                    console.error('[shieldcortex] WebSocket send failed during restart:', error);
+                }
+            }
+            res.json({ success: true, message: 'Server will restart in 3 seconds' });
+            scheduleRestart(3000);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+}