@auxiora/dashboard 1.0.0

package/tests/desktop-router.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { createDashboardRouter } from '../src/router.js';
+import type { DashboardDeps } from '../src/types.js';
+
+function createMockDeps(): DashboardDeps {
+  return {
+    vault: {
+      get: vi.fn(() => undefined),
+      has: vi.fn(() => false),
+      add: vi.fn(),
+    },
+    getConnections: vi.fn().mockReturnValue([]),
+    getAuditEntries: vi.fn().mockResolvedValue([]),
+    setup: {
+      getAgentName: () => 'TestAgent',
+      hasSoulFile: async () => true,
+    },
+    desktop: {
+      getStatus: vi.fn().mockReturnValue({
+        status: 'running',
+        autoStart: false,
+        hotkey: 'CommandOrControl+Shift+A',
+        notificationsEnabled: true,
+        ollamaRunning: false,
+        updateChannel: 'stable',
+      }),
+      updateConfig: vi.fn().mockResolvedValue({
+        autoStart: true,
+        hotkey: 'CommandOrControl+Shift+A',
+      }),
+      sendNotification: vi.fn().mockResolvedValue(undefined),
+      checkUpdates: vi.fn().mockResolvedValue({
+        available: false,
+        currentVersion: '2.0.0',
+        channel: 'stable',
+      }),
+    },
+  };
+}
+
+function createApp(deps: DashboardDeps) {
+  const app = express();
+  app.use(express.json());
+  const { router, auth } = createDashboardRouter({
+    deps,
+    config: { enabled: true, sessionTtlMs: 86_400_000 },
+    verifyPassword: (input: string) => input === 'correct-password',
+  });
+  app.use('/api/v1/dashboard', router);
+  return { app, auth };
+}
+
+function loginAndGetCookie(app: express.Express): Promise<string> {
+  return request(app)
+    .post('/api/v1/dashboard/auth/login')
+    .send({ password: 'correct-password' })
+    .then((res) => {
+      const cookie = res.headers['set-cookie'];
+      return Array.isArray(cookie) ? cookie[0] : cookie;
+    });
+}
+
+describe('Desktop dashboard routes', () => {
+  let deps: DashboardDeps;
+  let app: express.Express;
+  let cookie: string;
+
+  beforeEach(async () => {
+    deps = createMockDeps();
+    const created = createApp(deps);
+    app = created.app;
+    cookie = await loginAndGetCookie(app);
+  });
+
+  describe('GET /desktop/status', () => {
+    it('should return desktop status', async () => {
+      const res = await request(app)
+        .get('/api/v1/dashboard/desktop/status')
+        .set('Cookie', cookie);
+
+      expect(res.status).toBe(200);
+      expect(res.body.data.status).toBe('running');
+      expect(res.body.data.hotkey).toBe('CommandOrControl+Shift+A');
+    });
+
+    it('should return 503 when desktop not available', async () => {
+      const noDeps = createMockDeps();
+      delete noDeps.desktop;
+      const noDesktopApp = createApp(noDeps);
+      const noCookie = await loginAndGetCookie(noDesktopApp.app);
+
+      const res = await request(noDesktopApp.app)
+        .get('/api/v1/dashboard/desktop/status')
+        .set('Cookie', noCookie);
+
+      expect(res.status).toBe(503);
+    });
+  });
+
+  describe('POST /desktop/config', () => {
+    it('should update desktop config', async () => {
+      const res = await request(app)
+        .post('/api/v1/dashboard/desktop/config')
+        .set('Cookie', cookie)
+        .send({ autoStart: true });
+
+      expect(res.status).toBe(200);
+      expect(res.body.data).toBeDefined();
+      expect(deps.desktop!.updateConfig).toHaveBeenCalledWith({ autoStart: true });
+    });
+  });
+
+  describe('POST /desktop/notification', () => {
+    it('should send a notification', async () => {
+      const res = await request(app)
+        .post('/api/v1/dashboard/desktop/notification')
+        .set('Cookie', cookie)
+        .send({ title: 'Test', body: 'Hello' });
+
+      expect(res.status).toBe(200);
+      expect(res.body.data.sent).toBe(true);
+      expect(deps.desktop!.sendNotification).toHaveBeenCalledWith({
+        title: 'Test',
+        body: 'Hello',
+      });
+    });
+
+    it('should require title and body', async () => {
+      const res = await request(app)
+        .post('/api/v1/dashboard/desktop/notification')
+        .set('Cookie', cookie)
+        .send({ title: 'No body' });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('GET /desktop/updates', () => {
+    it('should check for updates', async () => {
+      const res = await request(app)
+        .get('/api/v1/dashboard/desktop/updates')
+        .set('Cookie', cookie);
+
+      expect(res.status).toBe(200);
+      expect(res.body.data.available).toBe(false);
+      expect(res.body.data.currentVersion).toBe('2.0.0');
+    });
+  });
+});

package/tests/router.test.ts

@@ -0,0 +1,388 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { createDashboardRouter } from '../src/router.js';
+import type { DashboardDeps } from '../src/types.js';
+
+function createMockDeps(): DashboardDeps {
+  return {
+    vault: {
+      get: vi.fn((name: string) => {
+        if (name === 'DASHBOARD_PASSWORD') return 'hashed-pw';
+        return undefined;
+      }),
+      has: vi.fn((name: string) => name === 'DASHBOARD_PASSWORD'),
+      add: vi.fn(),
+    },
+    behaviors: {
+      list: vi.fn().mockResolvedValue([
+        { id: 'bh-1', type: 'scheduled', status: 'active', action: 'test', runCount: 5, failCount: 0 },
+      ]),
+      update: vi.fn().mockResolvedValue({ id: 'bh-1', status: 'paused' }),
+      remove: vi.fn().mockResolvedValue(true),
+    },
+    webhooks: {
+      list: vi.fn().mockResolvedValue([
+        { id: 'wh-1', name: 'hook-1', type: 'generic', enabled: true, secret: 'real-secret' },
+      ]),
+      update: vi.fn().mockResolvedValue({ id: 'wh-1', name: 'hook-1', enabled: false, secret: 'real-secret' }),
+      delete: vi.fn().mockResolvedValue(true),
+    },
+    getConnections: vi.fn().mockReturnValue([
+      { id: 'conn-1', authenticated: true, channelType: 'webchat', lastActive: Date.now(), voiceActive: false },
+    ]),
+    getAuditEntries: vi.fn().mockResolvedValue([
+      { timestamp: '2026-01-01T00:00:00Z', event: 'system.startup', details: {} },
+    ]),
+    getPlugins: vi.fn().mockReturnValue([
+      { name: 'test-plugin', version: '1.0.0', file: 'test.js', toolCount: 1, toolNames: ['test_tool'], behaviorNames: [], providerNames: [], permissions: ['NETWORK'], status: 'loaded' },
+    ]),
+    pluginManager: {
+      enable: vi.fn().mockResolvedValue(true),
+      disable: vi.fn().mockResolvedValue(true),
+      remove: vi.fn().mockResolvedValue(true),
+      getConfig: vi.fn().mockReturnValue({ key: 'value' }),
+      setConfig: vi.fn().mockResolvedValue(true),
+      getPermissions: vi.fn().mockReturnValue(['NETWORK']),
+      setPermissions: vi.fn().mockResolvedValue(true),
+    },
+    marketplace: {
+      search: vi.fn().mockResolvedValue([{ name: 'cool-plugin', version: '1.0.0' }]),
+      getPlugin: vi.fn().mockResolvedValue({ name: 'cool-plugin', version: '1.0.0', description: 'Cool' }),
+      install: vi.fn().mockResolvedValue({ success: true }),
+    },
+    getMemories: vi.fn().mockResolvedValue([
+      { id: 'mem-abc', content: 'Likes TypeScript', category: 'preference', source: 'explicit', createdAt: Date.now(), updatedAt: Date.now(), accessCount: 1 },
+    ]),
+  };
+}
+
+function createApp(deps: DashboardDeps) {
+  const app = express();
+  app.use(express.json());
+  const { router, auth } = createDashboardRouter({
+    deps,
+    config: { enabled: true, sessionTtlMs: 86_400_000 },
+    verifyPassword: (input: string) => input === 'correct-password',
+  });
+  app.use('/api/v1/dashboard', router);
+  return { app, auth };
+}
+
+function loginAndGetCookie(app: express.Express): Promise<string> {
+  return request(app)
+    .post('/api/v1/dashboard/auth/login')
+    .send({ password: 'correct-password' })
+    .then((res) => {
+      const cookie = res.headers['set-cookie'];
+      return Array.isArray(cookie) ? cookie[0] : cookie;
+    });
+}
+
+describe('Dashboard Router', () => {
+  let deps: DashboardDeps;
+  let app: express.Express;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    ({ app } = createApp(deps));
+  });
+
+  describe('auth', () => {
+    it('should login with correct password', async () => {
+      const res = await request(app)
+        .post('/api/v1/dashboard/auth/login')
+        .send({ password: 'correct-password' });
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.headers['set-cookie']).toBeDefined();
+    });
+
+    it('should reject wrong password', async () => {
+      const res = await request(app)
+        .post('/api/v1/dashboard/auth/login')
+        .send({ password: 'wrong' });
+      expect(res.status).toBe(401);
+    });
+
+    it('should rate limit login attempts', async () => {
+      for (let i = 0; i < 5; i++) {
+        await request(app)
+          .post('/api/v1/dashboard/auth/login')
+          .send({ password: 'wrong' });
+      }
+      const res = await request(app)
+        .post('/api/v1/dashboard/auth/login')
+        .send({ password: 'wrong' });
+      expect(res.status).toBe(429);
+    });
+
+    it('should check auth status', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/auth/check')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.authenticated).toBe(true);
+    });
+
+    it('should logout and invalidate session', async () => {
+      const cookie = await loginAndGetCookie(app);
+      await request(app)
+        .post('/api/v1/dashboard/auth/logout')
+        .set('Cookie', cookie);
+
+      const res = await request(app)
+        .get('/api/v1/dashboard/auth/check')
+        .set('Cookie', cookie);
+      expect(res.body.authenticated).toBe(false);
+    });
+
+    it('should reject unauthenticated API requests', async () => {
+      const res = await request(app).get('/api/v1/dashboard/behaviors');
+      expect(res.status).toBe(401);
+    });
+  });
+
+  describe('behaviors API', () => {
+    it('should list behaviors', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/behaviors')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toHaveLength(1);
+    });
+
+    it('should patch behavior status', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .patch('/api/v1/dashboard/behaviors/bh-1')
+        .set('Cookie', cookie)
+        .send({ status: 'paused' });
+      expect(res.status).toBe(200);
+    });
+
+    it('should delete a behavior', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .delete('/api/v1/dashboard/behaviors/bh-1')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+    });
+
+    it('should return 401 without auth', async () => {
+      const res = await request(app).get('/api/v1/dashboard/behaviors');
+      expect(res.status).toBe(401);
+    });
+  });
+
+  describe('webhooks API', () => {
+    it('should list webhooks with redacted secrets', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/webhooks')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data[0].secret).toBe('***');
+    });
+
+    it('should patch webhook enabled status', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .patch('/api/v1/dashboard/webhooks/wh-1')
+        .set('Cookie', cookie)
+        .send({ enabled: false });
+      expect(res.status).toBe(200);
+      expect(res.body.data.secret).toBe('***');
+    });
+
+    it('should delete a webhook', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .delete('/api/v1/dashboard/webhooks/wh-1')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe('sessions API', () => {
+    it('should list active connections', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/sessions')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toHaveLength(1);
+    });
+  });
+
+  describe('audit API', () => {
+    it('should return audit entries', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/audit')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toHaveLength(1);
+    });
+  });
+
+  describe('status API', () => {
+    it('should return system status', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/status')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.uptime).toBeDefined();
+      expect(res.body.data.connections).toBe(1);
+    });
+  });
+
+  describe('plugins API', () => {
+    it('should list loaded plugins', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/plugins')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toHaveLength(1);
+      expect(res.body.data[0].name).toBe('test-plugin');
+    });
+  });
+
+  describe('memories API', () => {
+    it('should list memories', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/memories')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toHaveLength(1);
+      expect(res.body.data[0].content).toBe('Likes TypeScript');
+    });
+  });
+
+  describe('plugin management API', () => {
+    it('should get a single plugin by id', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/plugins/test-plugin')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.name).toBe('test-plugin');
+    });
+
+    it('should return 404 for unknown plugin', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/plugins/nonexistent')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(404);
+    });
+
+    it('should enable a plugin', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/plugins/test-plugin/enable')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.enabled).toBe(true);
+    });
+
+    it('should disable a plugin', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/plugins/test-plugin/disable')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.disabled).toBe(true);
+    });
+
+    it('should delete a plugin', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .delete('/api/v1/dashboard/plugins/test-plugin')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.deleted).toBe(true);
+    });
+
+    it('should get plugin config', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/plugins/test-plugin/config')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.key).toBe('value');
+    });
+
+    it('should set plugin config', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/plugins/test-plugin/config')
+        .set('Cookie', cookie)
+        .send({ newKey: 'newValue' });
+      expect(res.status).toBe(200);
+      expect(res.body.data.updated).toBe(true);
+    });
+
+    it('should get plugin permissions', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/plugins/test-plugin/permissions')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toEqual(['NETWORK']);
+    });
+
+    it('should set plugin permissions', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/plugins/test-plugin/permissions')
+        .set('Cookie', cookie)
+        .send({ permissions: ['NETWORK', 'FILESYSTEM'] });
+      expect(res.status).toBe(200);
+      expect(res.body.data.updated).toBe(true);
+    });
+
+    it('should reject invalid permissions body', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/plugins/test-plugin/permissions')
+        .set('Cookie', cookie)
+        .send({ permissions: 'not-array' });
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('marketplace API', () => {
+    it('should search marketplace', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/marketplace')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data).toHaveLength(1);
+    });
+
+    it('should get marketplace plugin details', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/marketplace/cool-plugin')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.name).toBe('cool-plugin');
+    });
+
+    it('should install from marketplace', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/marketplace/cool-plugin/install')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(200);
+      expect(res.body.data.success).toBe(true);
+    });
+  });
+});