@auxiora/dashboard 1.0.0

package/src/types.ts

@@ -0,0 +1,269 @@
+export interface DashboardConfig {
+  enabled: boolean;
+  sessionTtlMs: number;
+}
+
+export interface DashboardSession {
+  id: string;
+  createdAt: number;
+  lastActive: number;
+  ip: string;
+}
+
+export interface PersonalityTemplateSummary {
+  id: string;
+  name: string;
+  description: string;
+  preview: string;
+}
+
+export interface SetupDeps {
+  personality?: {
+    listTemplates(): Promise<PersonalityTemplateSummary[]>;
+    applyTemplate(id: string): Promise<void>;
+    buildCustom(config: Record<string, unknown>): Promise<string>;
+    getActiveTemplate?(): Promise<{ id: string; name: string } | null>;
+  };
+  saveConfig?: (updates: Record<string, unknown>) => Promise<void>;
+  getAgentName?: () => string;
+  getAgentPronouns?: () => string;
+  getAgentConfig?: () => Record<string, unknown>;
+  getSoulContent?: () => Promise<string | null>;
+  saveSoulContent?: (content: string) => Promise<void>;
+  hasSoulFile?: () => Promise<boolean>;
+  vaultExists?: () => Promise<boolean>;
+  onSetupComplete?: () => Promise<void>;
+}
+
+export interface DashboardDeps {
+  vault: {
+    get(name: string): string | undefined;
+    has(name: string): boolean;
+    add(name: string, value: string): Promise<void>;
+    unlock(password: string): Promise<void>;
+    changePassword(newPassword: string): Promise<void>;
+  };
+  onVaultUnlocked?: () => Promise<void>;
+  getActiveModel?: () => { provider: string; model: string };
+  behaviors?: {
+    list(filter?: { type?: string; status?: string }): Promise<any[]>;
+    get(id: string): Promise<any | undefined>;
+    create(input: Record<string, unknown>): Promise<any>;
+    update(id: string, updates: Record<string, unknown>): Promise<any>;
+    remove(id: string): Promise<boolean>;
+  };
+  webhooks?: {
+    list(): Promise<any[]>;
+    create(options: Record<string, unknown>): Promise<any>;
+    update?(id: string, updates: Record<string, unknown>): Promise<any>;
+    delete(id: string): Promise<boolean>;
+  };
+  getConfiguredChannels?: () => Array<{ type: string; enabled: boolean }>;
+  getActiveAgents?: () => Array<{
+    id: string;
+    type: string;
+    description: string;
+    channelType?: string;
+    startedAt: string;
+  }>;
+  getConnections: () => Array<{
+    id: string;
+    authenticated: boolean;
+    channelType: string;
+    lastActive: number;
+    voiceActive?: boolean;
+  }>;
+  getAuditEntries: (limit?: number) => Promise<any[]>;
+  getPlugins?: () => Array<{
+    name: string;
+    version: string;
+    file: string;
+    toolCount: number;
+    toolNames: string[];
+    behaviorNames: string[];
+    providerNames: string[];
+    permissions: string[];
+    status: string;
+    error?: string;
+  }>;
+  pluginManager?: {
+    enable(id: string): Promise<boolean>;
+    disable(id: string): Promise<boolean>;
+    remove(id: string): Promise<boolean>;
+    getConfig(id: string): Record<string, unknown> | null;
+    setConfig(id: string, config: Record<string, unknown>): Promise<boolean>;
+    getPermissions(id: string): string[] | null;
+    setPermissions(id: string, permissions: string[]): Promise<boolean>;
+  };
+  marketplace?: {
+    search(query: string): Promise<any[]>;
+    getPlugin(id: string): Promise<any | null>;
+    install(id: string): Promise<{ success: boolean; error?: string }>;
+  };
+  getMemories?: () => Promise<Array<{
+    id: string;
+    content: string;
+    category: string;
+    source: string;
+    createdAt: number;
+    updatedAt: number;
+    accessCount: number;
+  }>>;
+  memory?: {
+    getLivingState(): Promise<{
+      facts: any[];
+      relationships: any[];
+      patterns: any[];
+      adaptations: any[];
+      stats: any;
+    }>;
+    getStats(): Promise<any>;
+    getAdaptations(): Promise<any[]>;
+    deleteMemory(id: string): Promise<boolean>;
+    exportAll(): Promise<any>;
+    importAll(data: { memories: any[] }): Promise<{ imported: number; skipped: number }>;
+  };
+  setup?: SetupDeps;
+  orchestration?: {
+    getConfig(): {
+      enabled: boolean;
+      maxConcurrentAgents: number;
+      allowedPatterns: string[];
+    };
+    getHistory(limit?: number): Array<{
+      workflowId: string;
+      pattern: string;
+      taskCount: number;
+      totalCost: number;
+      duration: number;
+      timestamp: number;
+    }>;
+  };
+  models?: {
+    listProviders(): Array<{
+      name: string;
+      displayName: string;
+      available: boolean;
+      models: Record<string, unknown>;
+    }>;
+    getRoutingConfig(): {
+      enabled: boolean;
+      primary: string;
+      fallback?: string;
+      defaultModel?: string;
+      rules: unknown[];
+      preferences: Record<string, unknown>;
+      costLimits: Record<string, unknown>;
+    };
+    getCostSummary(): {
+      today: number;
+      thisMonth: number;
+      budgetRemaining?: number;
+      isOverBudget: boolean;
+      warningThresholdReached: boolean;
+    };
+  };
+  // --- [P13] Connectors ---
+  connectors?: {
+    list(): Array<{ id: string; name: string; category: string; auth: { type: string } }>;
+    get(id: string): any | undefined;
+    connect(connectorId: string, credentials: Record<string, string>, label?: string): Promise<any | null>;
+    disconnect(connectorId: string): Promise<boolean>;
+    getActions(connectorId: string): any[];
+    executeAction(connectorId: string, actionId: string, params: Record<string, unknown>): Promise<{ success: boolean; data?: unknown; error?: string }>;
+  };
+  // --- Trust / Autonomy (Phase 12) ---
+  trust?: {
+    getLevels(): Record<string, number>;
+    getLevel(domain: string): number;
+    setLevel(domain: string, level: number, reason: string): Promise<void>;
+    getAuditEntries(limit?: number): any[];
+    getAuditEntry(id: string): any | undefined;
+    rollback(id: string): Promise<{ success: boolean; error?: string }>;
+    getPromotions(): any[];
+  };
+  // --- [P6] Desktop ---
+  desktop?: {
+    getStatus(): {
+      status: string;
+      autoStart: boolean;
+      hotkey: string;
+      notificationsEnabled: boolean;
+      ollamaRunning: boolean;
+      updateChannel: string;
+    };
+    updateConfig(updates: Record<string, unknown>): Promise<Record<string, unknown>>;
+    sendNotification(payload: { title: string; body: string }): Promise<void>;
+    checkUpdates(): Promise<{
+      available: boolean;
+      currentVersion: string;
+      latestVersion?: string;
+      channel: string;
+    }>;
+  };
+  // --- Cloud (Phase 7) ---
+  cloud?: import('./cloud-types.js').CloudDeps;
+  // --- [P14] Team / Social ---
+  team?: {
+    listUsers(): Promise<any[]>;
+    createUser(name: string, role: string, channels?: any[]): Promise<any>;
+    deleteUser(id: string): Promise<boolean>;
+  };
+  // --- [P14] Workflows ---
+  workflows?: {
+    listActive(): Promise<any[]>;
+    listAll(): Promise<any[]>;
+    getStatus(id: string): Promise<any | undefined>;
+    createWorkflow(options: any): Promise<any>;
+    completeStep(workflowId: string, stepId: string, completedBy: string): Promise<any>;
+    cancelWorkflow(id: string): Promise<boolean>;
+    getPendingApprovals(userId?: string): Promise<any[]>;
+    approve(id: string, userId: string, reason?: string): Promise<any>;
+    reject(id: string, userId: string, reason?: string): Promise<any>;
+  };
+  // --- [P14] Agent Protocol ---
+  agentProtocol?: {
+    getIdentity(): any;
+    getInbox(limit?: number): any[];
+    discover(query: string): Promise<any[]>;
+    getDirectory(): Promise<any[]>;
+  };
+  // --- [P15] Screen ---
+  screen?: {
+    capture(): Promise<{ image: string; dimensions: { width: number; height: number } }>;
+    analyze(question?: string): Promise<string>;
+  };
+  // --- [P15] Ambient ---
+  ambient?: {
+    getPatterns(): any[];
+    getNotifications(): any[];
+    dismissNotification(id: string): boolean;
+    getBriefing(time: string): any;
+    getAnticipations(): any[];
+  };
+  // --- [P15] Conversation ---
+  conversation?: {
+    getState(): string;
+    start(): void;
+    stop(): void;
+    getTurnCount(): number;
+  };
+  // --- Chat session history ---
+  sessions?: {
+    getWebchatMessages(): Promise<Array<{ id: string; role: string; content: string; timestamp: number }>>;
+    listChats(options?: { archived?: boolean; limit?: number; offset?: number }): Array<{ id: string; title: string; channel: string; createdAt: number; updatedAt: number; archived: boolean }>;
+    createChat(title?: string): { id: string; title: string; channel: string; createdAt: number; updatedAt: number; archived: boolean };
+    renameChat(chatId: string, title: string): void;
+    archiveChat(chatId: string): void;
+    deleteChat(chatId: string): void;
+    getChatMessages(chatId: string): Array<{ id: string; role: string; content: string; timestamp: number }>;
+  };
+}
+
+export const DEFAULT_DASHBOARD_CONFIG: DashboardConfig = {
+  enabled: false,
+  sessionTtlMs: 86_400_000,
+};
+
+export const MAX_LOGIN_ATTEMPTS = 5;
+export const LOGIN_WINDOW_MS = 60_000;

package/tests/auth.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { DashboardAuth } from '../src/auth.js';
+import { MAX_LOGIN_ATTEMPTS } from '../src/types.js';
+
+describe('DashboardAuth', () => {
+  let auth: DashboardAuth;
+
+  beforeEach(() => {
+    auth = new DashboardAuth(3_600_000); // 1 hour TTL
+  });
+
+  it('should create and validate a session', () => {
+    const sessionId = auth.createSession('127.0.0.1');
+    expect(auth.validateSession(sessionId)).toBe(true);
+  });
+
+  it('should reject unknown session', () => {
+    expect(auth.validateSession('nonexistent')).toBe(false);
+  });
+
+  it('should expire sessions after TTL', () => {
+    const shortAuth = new DashboardAuth(1); // 1ms TTL
+    const sessionId = shortAuth.createSession('127.0.0.1');
+
+    // Wait for expiry
+    vi.useFakeTimers();
+    vi.advanceTimersByTime(10);
+    expect(shortAuth.validateSession(sessionId)).toBe(false);
+    vi.useRealTimers();
+  });
+
+  it('should destroy a session on logout', () => {
+    const sessionId = auth.createSession('127.0.0.1');
+    expect(auth.destroySession(sessionId)).toBe(true);
+    expect(auth.validateSession(sessionId)).toBe(false);
+  });
+
+  it('should rate limit after max attempts', () => {
+    const ip = '192.168.1.1';
+    for (let i = 0; i < MAX_LOGIN_ATTEMPTS; i++) {
+      auth.recordAttempt(ip);
+    }
+    expect(auth.isRateLimited(ip)).toBe(true);
+  });
+
+  it('should not rate limit under the threshold', () => {
+    const ip = '192.168.1.1';
+    auth.recordAttempt(ip);
+    expect(auth.isRateLimited(ip)).toBe(false);
+  });
+});

package/tests/cloud-router.test.ts

@@ -0,0 +1,249 @@
+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';
+import type { CloudDeps } from '../src/cloud-types.js';
+
+function createMockCloud(): CloudDeps {
+  return {
+    signup: vi.fn().mockResolvedValue({ tenantId: 'tenant-123', token: 'jwt-token-abc' }),
+    login: vi.fn().mockResolvedValue({ tenantId: 'tenant-123', token: 'jwt-token-abc' }),
+    getTenant: vi.fn().mockResolvedValue({
+      id: 'tenant-123',
+      name: 'Alice',
+      email: 'alice@test.com',
+      plan: 'pro',
+      status: 'active',
+      createdAt: '2025-01-01T00:00:00Z',
+    }),
+    changePlan: vi.fn().mockResolvedValue({ success: true }),
+    getUsage: vi.fn().mockResolvedValue({
+      usage: { maxMessages: 42 },
+      quotas: { maxMessages: 5000 },
+    }),
+    getBilling: vi.fn().mockResolvedValue({
+      plan: 'pro',
+      invoices: [{ id: 'inv_1', amount: 1900, status: 'paid', created: '2025-01-01' }],
+    }),
+    addPaymentMethod: vi.fn().mockResolvedValue({ success: true }),
+    exportData: vi.fn().mockResolvedValue({ downloadUrl: '/exports/tenant-123.zip' }),
+    deleteTenant: vi.fn().mockResolvedValue({ success: true }),
+  };
+}
+
+function createMockDeps(cloud?: CloudDeps): DashboardDeps {
+  return {
+    vault: {
+      get: vi.fn(),
+      has: vi.fn().mockReturnValue(false),
+      add: vi.fn(),
+    },
+    getConnections: vi.fn().mockReturnValue([]),
+    getAuditEntries: vi.fn().mockResolvedValue([]),
+    cloud,
+  };
+}
+
+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('Cloud Dashboard Routes', () => {
+  let cloud: CloudDeps;
+  let app: express.Express;
+
+  beforeEach(() => {
+    cloud = createMockCloud();
+    const deps = createMockDeps(cloud);
+    ({ app } = createApp(deps));
+  });
+
+  describe('POST /cloud/signup', () => {
+    it('should create a new tenant', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/signup')
+        .set('Cookie', cookie)
+        .send({ email: 'alice@test.com', name: 'Alice', password: 'secret123' });
+      expect(res.status).toBe(201);
+      expect(res.body.data.tenantId).toBe('tenant-123');
+      expect(res.body.data.token).toBeDefined();
+    });
+
+    it('should reject missing fields', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/signup')
+        .set('Cookie', cookie)
+        .send({ email: 'alice@test.com' });
+      expect(res.status).toBe(400);
+    });
+
+    it('should return 503 when cloud not configured', async () => {
+      const deps = createMockDeps(); // no cloud
+      const { app: noCloudApp } = createApp(deps);
+      const cookie = await loginAndGetCookie(noCloudApp);
+      const res = await request(noCloudApp)
+        .post('/api/v1/dashboard/cloud/signup')
+        .set('Cookie', cookie)
+        .send({ email: 'a@b.com', name: 'A', password: 'pass' });
+      expect(res.status).toBe(503);
+    });
+  });
+
+  describe('POST /cloud/login', () => {
+    it('should login a tenant', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/login')
+        .set('Cookie', cookie)
+        .send({ email: 'alice@test.com', password: 'secret123' });
+      expect(res.status).toBe(200);
+      expect(res.body.data.token).toBeDefined();
+    });
+
+    it('should reject invalid credentials', async () => {
+      (cloud.login as any).mockResolvedValue(null);
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/login')
+        .set('Cookie', cookie)
+        .send({ email: 'alice@test.com', password: 'wrong' });
+      expect(res.status).toBe(401);
+    });
+  });
+
+  describe('GET /cloud/tenant', () => {
+    it('should return tenant info', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/cloud/tenant')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123');
+      expect(res.status).toBe(200);
+      expect(res.body.data.email).toBe('alice@test.com');
+    });
+
+    it('should require x-tenant-id header', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/cloud/tenant')
+        .set('Cookie', cookie);
+      expect(res.status).toBe(400);
+    });
+
+    it('should return 404 for unknown tenant', async () => {
+      (cloud.getTenant as any).mockResolvedValue(null);
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/cloud/tenant')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'nonexistent');
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('POST /cloud/tenant/plan', () => {
+    it('should change plan', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/tenant/plan')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123')
+        .send({ plan: 'team' });
+      expect(res.status).toBe(200);
+      expect(res.body.data.success).toBe(true);
+    });
+  });
+
+  describe('GET /cloud/tenant/usage', () => {
+    it('should return usage data', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/cloud/tenant/usage')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123');
+      expect(res.status).toBe(200);
+      expect(res.body.data.usage.maxMessages).toBe(42);
+    });
+  });
+
+  describe('GET /cloud/tenant/billing', () => {
+    it('should return billing info', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .get('/api/v1/dashboard/cloud/tenant/billing')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123');
+      expect(res.status).toBe(200);
+      expect(res.body.data.plan).toBe('pro');
+      expect(res.body.data.invoices).toHaveLength(1);
+    });
+  });
+
+  describe('POST /cloud/tenant/billing/payment-method', () => {
+    it('should add payment method', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/tenant/billing/payment-method')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123')
+        .send({ token: 'tok_visa' });
+      expect(res.status).toBe(200);
+      expect(res.body.data.success).toBe(true);
+    });
+
+    it('should reject missing token', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/tenant/billing/payment-method')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123')
+        .send({});
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('POST /cloud/tenant/export', () => {
+    it('should export tenant data', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .post('/api/v1/dashboard/cloud/tenant/export')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123');
+      expect(res.status).toBe(200);
+      expect(res.body.data.downloadUrl).toBeDefined();
+    });
+  });
+
+  describe('DELETE /cloud/tenant', () => {
+    it('should delete tenant', async () => {
+      const cookie = await loginAndGetCookie(app);
+      const res = await request(app)
+        .delete('/api/v1/dashboard/cloud/tenant')
+        .set('Cookie', cookie)
+        .set('x-tenant-id', 'tenant-123');
+      expect(res.status).toBe(200);
+      expect(res.body.data.success).toBe(true);
+    });
+  });
+});