@cachly-dev/mcp-server 0.10.64 → 0.10.66

package/src/__tests__/confidence.test.ts

@@ -1,285 +0,0 @@
-/**
- * Tests for confidence.ts
- *
- * Covers:
- *   calculateConfidence – decay model (fresh / aging / warn / stale)
- *   confidenceBadge     – emoji + human label
- *   simpleHash          – determinism, uniqueness, fixed length
- *   STRUCTURED_TEMPLATES – required fields, hints
- *   Constants           – sensible defaults and relationships
- *
- * Run: npx vitest run src/__tests__/confidence.test.ts
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  calculateConfidence,
-  confidenceBadge,
-  STRUCTURED_TEMPLATES,
-  CONFIDENCE_WARN_DAYS,
-  CONFIDENCE_STALE_DAYS,
-  CONFIDENCE_WARN_VALUE,
-  CONFIDENCE_STALE_VALUE,
-  simpleHash,
-} from '../confidence.js';
-
-// ── Constant sanity ───────────────────────────────────────────────────────────
-
-describe('Confidence constants', () => {
-  it('CONFIDENCE_WARN_DAYS < CONFIDENCE_STALE_DAYS', () => {
-    expect(CONFIDENCE_WARN_DAYS).toBeLessThan(CONFIDENCE_STALE_DAYS);
-  });
-
-  it('CONFIDENCE_WARN_VALUE > CONFIDENCE_STALE_VALUE', () => {
-    expect(CONFIDENCE_WARN_VALUE).toBeGreaterThan(CONFIDENCE_STALE_VALUE);
-  });
-
-  it('CONFIDENCE_WARN_VALUE < 1.0 and > 0', () => {
-    expect(CONFIDENCE_WARN_VALUE).toBeLessThan(1.0);
-    expect(CONFIDENCE_WARN_VALUE).toBeGreaterThan(0);
-  });
-
-  it('CONFIDENCE_STALE_VALUE < 1.0 and > 0', () => {
-    expect(CONFIDENCE_STALE_VALUE).toBeLessThan(1.0);
-    expect(CONFIDENCE_STALE_VALUE).toBeGreaterThan(0);
-  });
-
-  it('defaults to 5 warn days and 10 stale days (when env vars absent)', () => {
-    // These may be overridden via env, but assert sensible defaults
-    expect(CONFIDENCE_WARN_DAYS).toBeGreaterThanOrEqual(1);
-    expect(CONFIDENCE_STALE_DAYS).toBeGreaterThanOrEqual(CONFIDENCE_WARN_DAYS + 1);
-  });
-});
-
-// ── calculateConfidence ───────────────────────────────────────────────────────
-
-describe('calculateConfidence', () => {
-  /** Returns an ISO timestamp that is `days` old from now. */
-  function tsAgo(days: number): string {
-    return new Date(Date.now() - days * 86400000).toISOString();
-  }
-
-  it('returns 1.0 for brand-new lesson (age ≈ 0)', () => {
-    const c = calculateConfidence({ ts: new Date().toISOString() });
-    expect(c).toBeCloseTo(1.0, 2);
-  });
-
-  it('prefers verified_at over ts', () => {
-    // ts is very old, but verified_at is recent → should NOT be stale
-    const c = calculateConfidence({
-      ts: tsAgo(365),
-      verified_at: tsAgo(0),
-    });
-    expect(c).toBeCloseTo(1.0, 2);
-  });
-
-  it('returns exactly CONFIDENCE_WARN_VALUE at exactly CONFIDENCE_WARN_DAYS', () => {
-    const c = calculateConfidence({ ts: tsAgo(CONFIDENCE_WARN_DAYS) });
-    // At exactly the warn threshold the function returns CONFIDENCE_WARN_VALUE
-    expect(c).toBeCloseTo(CONFIDENCE_WARN_VALUE, 3);
-  });
-
-  it('returns exactly CONFIDENCE_STALE_VALUE at exactly CONFIDENCE_STALE_DAYS', () => {
-    const c = calculateConfidence({ ts: tsAgo(CONFIDENCE_STALE_DAYS) });
-    expect(c).toBe(CONFIDENCE_STALE_VALUE);
-  });
-
-  it('caps at CONFIDENCE_STALE_VALUE for very old lessons', () => {
-    const c = calculateConfidence({ ts: tsAgo(365) });
-    expect(c).toBe(CONFIDENCE_STALE_VALUE);
-  });
-
-  it('linearly decreases between 0 and CONFIDENCE_WARN_DAYS', () => {
-    const midDays = CONFIDENCE_WARN_DAYS / 2;
-    const c = calculateConfidence({ ts: tsAgo(midDays) });
-    // at half-way to warn: 1.0 - (0.5 * (1.0 - CONFIDENCE_WARN_VALUE))
-    const expected = 1.0 - 0.5 * (1.0 - CONFIDENCE_WARN_VALUE);
-    expect(c).toBeCloseTo(expected, 3);
-  });
-
-  it('is monotonically decreasing with age', () => {
-    const c0 = calculateConfidence({ ts: tsAgo(0) });
-    const c1 = calculateConfidence({ ts: tsAgo(CONFIDENCE_WARN_DAYS * 0.3) });
-    const c2 = calculateConfidence({ ts: tsAgo(CONFIDENCE_WARN_DAYS * 0.7) });
-    const c3 = calculateConfidence({ ts: tsAgo(CONFIDENCE_WARN_DAYS) });
-    const c4 = calculateConfidence({ ts: tsAgo(CONFIDENCE_STALE_DAYS) });
-    expect(c0).toBeGreaterThanOrEqual(c1);
-    expect(c1).toBeGreaterThan(c2);
-    expect(c2).toBeGreaterThan(c3);
-    expect(c3).toBeGreaterThan(c4);
-  });
-
-  it('value between WARN and STALE ages equals CONFIDENCE_WARN_VALUE', () => {
-    const betweenDays = (CONFIDENCE_WARN_DAYS + CONFIDENCE_STALE_DAYS) / 2;
-    const c = calculateConfidence({ ts: tsAgo(betweenDays) });
-    expect(c).toBe(CONFIDENCE_WARN_VALUE);
-  });
-
-  it('ignores recall_count (not used in calculation)', () => {
-    const ts = new Date().toISOString();
-    const c1 = calculateConfidence({ ts, recall_count: 0 });
-    const c2 = calculateConfidence({ ts, recall_count: 100 });
-    expect(c1).toBeCloseTo(c2, 5);
-  });
-});
-
-// ── confidenceBadge ───────────────────────────────────────────────────────────
-
-describe('confidenceBadge', () => {
-  it('returns ✅ for confidence >= 0.9 (fresh)', () => {
-    expect(confidenceBadge(1.0, 0)).toBe('✅');
-    expect(confidenceBadge(0.9, 1)).toBe('✅');
-    expect(confidenceBadge(0.95, 2)).toBe('✅');
-  });
-
-  it('returns ⚠️ prefix for warn range [0.7, 0.9)', () => {
-    const badge = confidenceBadge(0.7, 6);
-    expect(badge).toMatch(/^⚠️/);
-    expect(badge).toContain('6d old');
-    expect(badge).toContain('70%');
-    expect(badge).toContain('verify before applying');
-  });
-
-  it('⚠️ badge rounds age to nearest day', () => {
-    const badge = confidenceBadge(0.75, 4.6);
-    expect(badge).toContain('5d old');  // Math.round(4.6) = 5
-  });
-
-  it('returns 🔴 STALE prefix for confidence < 0.7', () => {
-    const badge = confidenceBadge(0.5, 12);
-    expect(badge).toMatch(/^🔴 STALE/);
-    expect(badge).toContain('12d old');
-    expect(badge).toContain('50%');
-    expect(badge).toContain('likely outdated');
-  });
-
-  it('🔴 badge for exactly 0.0 confidence', () => {
-    const badge = confidenceBadge(0.0, 99);
-    expect(badge).toMatch(/^🔴 STALE/);
-    expect(badge).toContain('0%');
-  });
-
-  it('edge: confidence exactly 0.7 returns ⚠️ (not 🔴)', () => {
-    const badge = confidenceBadge(0.7, 5);
-    expect(badge).toMatch(/^⚠️/);
-  });
-
-  it('edge: confidence exactly 0.9 returns ✅ (not ⚠️)', () => {
-    expect(confidenceBadge(0.9, 1)).toBe('✅');
-  });
-});
-
-// ── simpleHash ────────────────────────────────────────────────────────────────
-
-describe('simpleHash', () => {
-  it('returns exactly 12 characters', () => {
-    expect(simpleHash('hello world')).toHaveLength(12);
-    expect(simpleHash('')).toHaveLength(12);
-    expect(simpleHash('x'.repeat(10000))).toHaveLength(12);
-  });
-
-  it('returns only hex characters [0-9a-f]', () => {
-    const hash = simpleHash('test input 123');
-    expect(hash).toMatch(/^[0-9a-f]{12}$/);
-  });
-
-  it('is deterministic — same input always yields same hash', () => {
-    const input = 'docker compose up -d --build api';
-    const h1 = simpleHash(input);
-    const h2 = simpleHash(input);
-    const h3 = simpleHash(input);
-    expect(h1).toBe(h2);
-    expect(h2).toBe(h3);
-  });
-
-  it('different inputs yield different hashes (collision resistance)', () => {
-    const inputs = [
-      'deploy:api',
-      'deploy:web',
-      'fix:redis-timeout',
-      'infra:clickhouse',
-      '',
-      'a',
-      ' ',
-      '0',
-    ];
-    const hashes = inputs.map(simpleHash);
-    const unique = new Set(hashes);
-    expect(unique.size).toBe(inputs.length);
-  });
-
-  it('is sensitive to character order', () => {
-    expect(simpleHash('abc')).not.toBe(simpleHash('cba'));
-    expect(simpleHash('ab')).not.toBe(simpleHash('ba'));
-  });
-
-  it('is sensitive to whitespace differences', () => {
-    expect(simpleHash('hello world')).not.toBe(simpleHash('helloworld'));
-    expect(simpleHash('hello world')).not.toBe(simpleHash('hello  world'));
-  });
-
-  it('works with unicode input', () => {
-    const h1 = simpleHash('日本語テスト');
-    const h2 = simpleHash('中文测试');
-    expect(h1).toHaveLength(12);
-    expect(h2).toHaveLength(12);
-    expect(h1).not.toBe(h2);
-  });
-
-  it('works with newlines and special chars', () => {
-    const h = simpleHash('line1\nline2\ttab\r\n');
-    expect(h).toHaveLength(12);
-    expect(h).toMatch(/^[0-9a-f]{12}$/);
-  });
-});
-
-// ── STRUCTURED_TEMPLATES ──────────────────────────────────────────────────────
-
-describe('STRUCTURED_TEMPLATES', () => {
-  it('contains all expected category keys', () => {
-    const expected = ['deploy', 'bash', 'infra', 'pricing', 'stripe'];
-    for (const key of expected) {
-      expect(STRUCTURED_TEMPLATES, `Missing key: "${key}"`).toHaveProperty(key);
-    }
-  });
-
-  it('every entry has a non-empty hint string', () => {
-    for (const [key, tmpl] of Object.entries(STRUCTURED_TEMPLATES)) {
-      expect(typeof tmpl.hint, `hint for "${key}" is not a string`).toBe('string');
-      expect(tmpl.hint.length, `hint for "${key}" is empty`).toBeGreaterThan(0);
-    }
-  });
-
-  it('every entry has a required array', () => {
-    for (const [key, tmpl] of Object.entries(STRUCTURED_TEMPLATES)) {
-      expect(Array.isArray(tmpl.required), `required for "${key}" is not an array`).toBe(true);
-    }
-  });
-
-  it('deploy / bash / infra require commands[]', () => {
-    for (const key of ['deploy', 'bash', 'infra']) {
-      expect(STRUCTURED_TEMPLATES[key].required, `${key} should require commands`).toContain('commands');
-    }
-  });
-
-  it('pricing / stripe have empty required list (free-form)', () => {
-    expect(STRUCTURED_TEMPLATES['pricing'].required).toHaveLength(0);
-    expect(STRUCTURED_TEMPLATES['stripe'].required).toHaveLength(0);
-  });
-
-  it('hints mention the category key', () => {
-    for (const [key, tmpl] of Object.entries(STRUCTURED_TEMPLATES)) {
-      expect(tmpl.hint.toLowerCase(), `hint for "${key}" should mention the key`).toContain(key);
-    }
-  });
-
-  it('is a plain object (not prototype-polluted)', () => {
-    expect(Object.getPrototypeOf(STRUCTURED_TEMPLATES)).toBe(Object.prototype);
-  });
-
-  it('all category keys are valid topic prefixes (lowercase, no special chars)', () => {
-    for (const key of Object.keys(STRUCTURED_TEMPLATES)) {
-      expect(key).toMatch(/^[a-z][a-z0-9_-]*$/);
-    }
-  });
-});

package/src/__tests__/e2e/api-auth.test.ts

@@ -1,182 +0,0 @@
-/**
- * E2E: Authenticated API endpoints
- *
- * Requires: E2E_JWT, E2E_INSTANCE_ID
- * Run: npx vitest run src/__tests__/e2e/api-auth.test.ts
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { cfg, requireAuth, apiGet, apiPost } from './config.js';
-
-beforeAll(() => requireAuth());
-
-describe('Auth guard', () => {
-  it('GET /api/v1/instances without token returns 401', async () => {
-    const { status } = await apiGet('/api/v1/instances', '');
-    expect(status).toBe(401);
-  });
-
-  it('GET /api/v1/instances with invalid token returns 401', async () => {
-    const { status } = await apiGet('/api/v1/instances', 'not-a-real-token');
-    expect(status).toBe(401);
-  });
-
-  it('GET /api/v1/instances with valid token returns 200', async () => {
-    const { status } = await apiGet('/api/v1/instances');
-    expect(status).toBe(200);
-  });
-});
-
-describe('Instances API', () => {
-  // API returns { data: Instance[], count: number }
-  it('returns object with data array', async () => {
-    const { body } = await apiGet('/api/v1/instances');
-    const b = body as { data?: unknown[]; count?: number };
-    expect(Array.isArray(b.data)).toBe(true);
-    expect(typeof b.count).toBe('number');
-  });
-
-  it('each instance has required fields', async () => {
-    const { body } = await apiGet('/api/v1/instances');
-    const instances = ((body as { data?: Record<string, unknown>[] }).data) ?? [];
-    if (instances.length === 0) return; // fresh account — skip
-    for (const inst of instances) {
-      expect(typeof inst.id).toBe('string');
-      expect(typeof inst.name).toBe('string');
-      expect(typeof inst.status).toBe('string');
-      expect(typeof inst.tier).toBe('string');
-    }
-  });
-
-  it('test instance is present and running', async () => {
-    const { body } = await apiGet('/api/v1/instances');
-    const instances = ((body as { data?: Record<string, unknown>[] }).data) ?? [];
-    const found = instances.find((i) => i.id === cfg.instanceId);
-    expect(found).toBeDefined();
-    expect(found!.status).toBe('running');
-  });
-});
-
-describe('Single instance GET', () => {
-  it('returns 200 for test instance', async () => {
-    const { status } = await apiGet(`/api/v1/instances/${cfg.instanceId}`);
-    expect(status).toBe(200);
-  });
-
-  it('returns 404 for non-existent instance', async () => {
-    const { status } = await apiGet('/api/v1/instances/00000000-0000-0000-0000-000000000000');
-    expect([403, 404]).toContain(status);
-  });
-
-  it('instance body has id, status running, tier, name', async () => {
-    const { body } = await apiGet(`/api/v1/instances/${cfg.instanceId}`);
-    const inst = body as Record<string, unknown>;
-    expect(inst.id).toBe(cfg.instanceId);
-    expect(inst.status).toBe('running');
-    expect(typeof inst.tier).toBe('string');
-    expect(typeof inst.name).toBe('string');
-  });
-});
-
-describe('Connection endpoint', () => {
-  it('returns 200 with connection details for running instance', async () => {
-    const { status, body } = await apiGet(`/api/v1/instances/${cfg.instanceId}/connection`);
-    expect(status).toBe(200);
-    const conn = body as Record<string, unknown>;
-    expect(typeof conn.host).toBe('string');
-    expect(typeof conn.port).toBe('number');
-    expect(typeof conn.password).toBe('string');
-    expect((conn.host as string).length).toBeGreaterThan(3);
-  });
-
-  it('connection host is not localhost (prod/dev has real host)', async () => {
-    const { body } = await apiGet(`/api/v1/instances/${cfg.instanceId}/connection`);
-    const conn = body as Record<string, unknown>;
-    expect(String(conn.host)).not.toBe('localhost');
-    expect(String(conn.host)).not.toBe('127.0.0.1');
-  });
-
-  it('port is within valid Redis range', async () => {
-    const { body } = await apiGet(`/api/v1/instances/${cfg.instanceId}/connection`);
-    const conn = body as Record<string, unknown>;
-    expect(Number(conn.port)).toBeGreaterThan(1023);
-    expect(Number(conn.port)).toBeLessThan(65536);
-  });
-});
-
-describe('API keys', () => {
-  // API returns { keys: APIKey[], count: number }
-  it('GET /api/v1/api-keys returns 200 with keys array', async () => {
-    const { status, body } = await apiGet('/api/v1/api-keys');
-    expect(status).toBe(200);
-    const b = body as { keys?: unknown[]; count?: number };
-    expect(Array.isArray(b.keys)).toBe(true);
-  });
-
-  it('api-keys have id and instance_id fields', async () => {
-    const { body } = await apiGet('/api/v1/api-keys');
-    const keys = ((body as { keys?: Record<string, unknown>[] }).keys) ?? [];
-    if (keys.length === 0) return;
-    for (const k of keys) {
-      expect(typeof k.id).toBe('string');
-      expect(typeof k.instance_id).toBe('string');
-    }
-  });
-});
-
-describe('Brain Stats endpoint', () => {
-  it('GET /api/v1/instances/:id/brain-stats returns 200', async () => {
-    const { status } = await apiGet(`/api/v1/instances/${cfg.instanceId}/brain-stats`);
-    expect(status).toBe(200);
-  });
-
-  it('brain-stats body has brain_level and brain_level_name', async () => {
-    const { body } = await apiGet(`/api/v1/instances/${cfg.instanceId}/brain-stats`);
-    const stats = body as Record<string, unknown>;
-    expect(typeof stats.brain_level).toBe('number');
-    expect(stats.brain_level).toBeGreaterThanOrEqual(1);
-    expect(typeof stats.brain_level_name).toBe('string');
-    expect(['Apprentice', 'Explorer', 'Expert', 'Architect', 'Oracle']).toContain(stats.brain_level_name);
-  });
-
-  it('brain-stats has hours_saved and brain_recall_count', async () => {
-    const { body } = await apiGet(`/api/v1/instances/${cfg.instanceId}/brain-stats`);
-    const stats = body as Record<string, unknown>;
-    expect(typeof stats.hours_saved).toBe('number');
-    expect(stats.hours_saved).toBeGreaterThanOrEqual(0);
-    expect(typeof stats.brain_recall_count).toBe('number');
-    expect(stats.brain_recall_count).toBeGreaterThanOrEqual(0);
-  });
-
-  it('brain-stats has standard search telemetry fields', async () => {
-    const { body } = await apiGet(`/api/v1/instances/${cfg.instanceId}/brain-stats`);
-    const stats = body as Record<string, unknown>;
-    expect(typeof stats.total_searches).toBe('number');
-    expect(typeof stats.avg_latency_ms).toBe('number');
-    expect(Array.isArray(stats.top_queries)).toBe(true);
-  });
-});
-
-describe('Provisioning status messages', () => {
-  it('non-existent instance connection returns 4xx, never 500', async () => {
-    const { status } = await apiGet('/api/v1/instances/00000000-0000-0000-0000-000000000001/connection');
-    expect([400, 403, 404, 422]).toContain(status);
-  });
-});
-
-describe('Auto-provision endpoint', () => {
-  it('POST /api/v1/instances/auto returns 200 or 201', async () => {
-    const { status } = await apiPost('/api/v1/instances/auto', {});
-    expect([200, 201]).toContain(status);
-  });
-
-  it('returns existing running instance without creating a new one', async () => {
-    const { body } = await apiPost('/api/v1/instances/auto', {});
-    const b = body as { instance?: { id: string; status: string }; created?: boolean };
-    if (b.instance) {
-      // Existing instance returned
-      expect(typeof b.instance.id).toBe('string');
-      expect(b.created).toBe(false);
-    }
-  });
-});

package/src/__tests__/e2e/api-health.test.ts

@@ -1,103 +0,0 @@
-/**
- * E2E: API health & public endpoints
- *
- * These tests require NO credentials — they hit publicly accessible endpoints.
- * Run: E2E_API_URL=https://api.dev.cachly.dev npx vitest run src/__tests__/e2e/api-health.test.ts
- */
-
-import { describe, it, expect } from 'vitest';
-import { cfg } from './config.js';
-
-describe('API health (no auth required)', () => {
-  it('GET /health returns 200', async () => {
-    const res = await fetch(`${cfg.apiUrl}/health`);
-    expect(res.status).toBe(200);
-  });
-
-  it('GET /health body contains status ok', async () => {
-    const res = await fetch(`${cfg.apiUrl}/health`);
-    const body = await res.json() as Record<string, unknown>;
-    expect(body.status ?? body.ok ?? body.alive).toBeTruthy();
-  });
-
-  it('unknown route returns 404, not 500', async () => {
-    const res = await fetch(`${cfg.apiUrl}/api/v1/does-not-exist-xyz`);
-    expect(res.status).toBe(404);
-  });
-});
-
-describe('Device flow init (no auth required)', () => {
-  it('GET /api/v1/auth/device/code returns device_code and user_code', async () => {
-    const res = await fetch(`${cfg.apiUrl}/api/v1/auth/device/code`);
-    expect(res.status).toBe(200);
-    const body = await res.json() as Record<string, unknown>;
-    expect(typeof body.device_code).toBe('string');
-    expect(typeof body.user_code).toBe('string');
-    expect(typeof body.verification_uri).toBe('string');
-    expect(body.verification_uri).toContain('cachly.dev');
-  });
-
-  it('device_code is at least 20 chars (not truncated)', async () => {
-    const res = await fetch(`${cfg.apiUrl}/api/v1/auth/device/code`);
-    const body = await res.json() as Record<string, unknown>;
-    expect((body.device_code as string).length).toBeGreaterThanOrEqual(20);
-  });
-
-  it('expires_in is a positive number', async () => {
-    const res = await fetch(`${cfg.apiUrl}/api/v1/auth/device/code`);
-    const body = await res.json() as Record<string, unknown>;
-    expect(Number(body.expires_in)).toBeGreaterThan(0);
-  });
-});
-
-describe('Badge endpoint (public, no auth)', () => {
-  it('returns 400 or 404 for an invalid instance id', async () => {
-    const res = await fetch(`${cfg.apiUrl}/api/v1/badge/not-a-real-uuid`);
-    expect([400, 404]).toContain(res.status);
-  });
-
-  it('returns badge JSON for a valid instance id', async () => {
-    if (!cfg.instanceId) return; // skip if not configured
-    const res = await fetch(`${cfg.apiUrl}/api/v1/badge/${cfg.instanceId}`);
-    expect(res.status).toBe(200);
-    const body = await res.json() as Record<string, unknown>;
-    expect(typeof body.schemaVersion).toBe('number');
-    expect(typeof body.label).toBe('string');
-    expect(typeof body.message).toBe('string');
-  });
-
-  it('badge message contains lesson count (numeric string)', async () => {
-    if (!cfg.instanceId) return;
-    const res = await fetch(`${cfg.apiUrl}/api/v1/badge/${cfg.instanceId}`);
-    const body = await res.json() as Record<string, unknown>;
-    expect((body.message as string)).toMatch(/\d+/);
-  });
-});
-
-describe('Telemetry endpoint (public)', () => {
-  it('POST /api/v1/telemetry/mcp accepts anonymous event', async () => {
-    const res = await fetch(`${cfg.apiUrl}/api/v1/telemetry/mcp`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ event: 'e2e_test_ping', version: '0.0.0', editor: 'test', source: 'e2e' }),
-    });
-    expect([200, 202, 204]).toContain(res.status);
-  });
-
-  it('POST /api/v1/telemetry/mcp accepts jwt-attributed event', async () => {
-    if (!cfg.jwt) return;
-    const res = await fetch(`${cfg.apiUrl}/api/v1/telemetry/mcp`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        event: 'e2e_test_ping_authed',
-        version: '0.0.0',
-        editor: 'test',
-        source: 'e2e',
-        jwt: cfg.jwt,
-        instance_id: cfg.instanceId,
-      }),
-    });
-    expect([200, 202, 204]).toContain(res.status);
-  });
-});