@littlebearapps/platform-admin-sdk 2.1.0 → 2.2.0

package/templates/full/tests/integration/feedback-schema.test.ts

@@ -0,0 +1,361 @@
+/// <reference types="node" />
+import { describe, it, expect, beforeEach } from 'vitest';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { MockD1Database, MockKVNamespace } from '../helpers/mock-storage';
+
+const schema = readFileSync(
+  join(__dirname, '..', '..', 'storage', 'd1', 'schema-feedback.sql'),
+  'utf-8'
+);
+
+describe('Feedback Events D1 Schema', () => {
+  let db: MockD1Database;
+  let kv: MockKVNamespace;
+
+  beforeEach(() => {
+    db = new MockD1Database();
+    kv = new MockKVNamespace();
+  });
+
+  describe('Table Structure', () => {
+    it('should have correct schema structure', () => {
+      expect(schema).toContain('CREATE TABLE IF NOT EXISTS feedback_events');
+      expect(schema).toContain('feedback_id TEXT PRIMARY KEY');
+      expect(schema).toContain('repo TEXT NOT NULL');
+      expect(schema).toContain('issue_number INTEGER NOT NULL');
+      expect(schema).toContain('category TEXT');
+      expect(schema).toContain("sentiment TEXT DEFAULT 'neutral'");
+      expect(schema).toContain('related_error_correlation TEXT');
+      expect(schema).toContain('user_contact_encrypted TEXT');
+      expect(schema).toContain('correlation_confidence REAL');
+      expect(schema).toContain('correlation_method TEXT');
+      expect(schema).toContain('UNIQUE(repo, issue_number)');
+    });
+
+    it('should have performance indexes', () => {
+      expect(schema).toContain('CREATE INDEX IF NOT EXISTS idx_feedback_category');
+      expect(schema).toContain('CREATE INDEX IF NOT EXISTS idx_feedback_sentiment');
+      expect(schema).toContain('CREATE INDEX IF NOT EXISTS idx_feedback_correlation');
+      expect(schema).toContain('CREATE INDEX IF NOT EXISTS idx_feedback_received_at');
+    });
+
+    it('should have auto-update trigger', () => {
+      expect(schema).toContain('CREATE TRIGGER IF NOT EXISTS feedback_events_updated_at');
+      expect(schema).toContain('AFTER UPDATE ON feedback_events');
+      expect(schema).toContain("UPDATE feedback_events SET updated_at = datetime('now')");
+    });
+  });
+
+  describe('Insert Operations', () => {
+    it('should insert valid feedback event', async () => {
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category,
+          related_error_correlation, correlation_confidence, correlation_method,
+          user_contact_encrypted
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `
+        )
+        .bind(
+          'delivery-123',
+          'convert-my-file',
+          42,
+          'feature-request',
+          'corr-xyz',
+          0.85,
+          'rule-based',
+          'encrypted-email'
+        )
+        .run();
+
+      expect(result.success).toBe(true);
+      const insert = db.statements.find((stmt) => stmt.sql.includes('INSERT INTO feedback_events'));
+      expect(insert).toBeTruthy();
+      expect(insert?.params).toHaveLength(8);
+    });
+
+    it('should insert minimal feedback event (no correlation)', async () => {
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category
+        )
+        VALUES (?, ?, ?, ?)
+      `
+        )
+        .bind('delivery-456', 'notebridge', 10, 'bug-report')
+        .run();
+
+      expect(result.success).toBe(true);
+      const insert = db.statements.find((stmt) => stmt.sql.includes('INSERT INTO feedback_events'));
+      expect(insert).toBeTruthy();
+      expect(insert?.params).toEqual(['delivery-456', 'notebridge', 10, 'bug-report']);
+    });
+  });
+
+  describe('Upsert Operations', () => {
+    it('should perform upsert on conflict', async () => {
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category,
+          related_error_correlation, correlation_confidence, correlation_method
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(repo, issue_number) DO UPDATE SET
+          category = excluded.category,
+          related_error_correlation = excluded.related_error_correlation,
+          correlation_confidence = excluded.correlation_confidence,
+          correlation_method = excluded.correlation_method
+      `
+        )
+        .bind('delivery-789', 'palette-kit', 5, 'ux-improvement', 'corr-abc', 0.95, 'manual')
+        .run();
+
+      expect(result.success).toBe(true);
+      const upsert = db.statements.find((stmt) => stmt.sql.includes('ON CONFLICT'));
+      expect(upsert).toBeTruthy();
+      expect(upsert?.sql).toContain('DO UPDATE SET');
+    });
+  });
+
+  describe('Query Operations', () => {
+    beforeEach(() => {
+      // Queue mock results for queries
+      db.queueRunResult({
+        success: true,
+        results: [
+          {
+            feedbackId: 'delivery-123',
+            repo: 'convert-my-file',
+            issueNumber: 42,
+            category: 'feature-request',
+            relatedErrorCorrelation: 'corr-xyz',
+            correlationConfidence: 0.85,
+            correlationMethod: 'rule-based',
+          },
+        ],
+      });
+    });
+
+    it('should query by category', async () => {
+      const result = await db
+        .prepare(
+          `
+        SELECT
+          feedback_id as feedbackId,
+          repo,
+          issue_number as issueNumber,
+          category,
+          related_error_correlation as relatedErrorCorrelation,
+          correlation_confidence as correlationConfidence,
+          correlation_method as correlationMethod
+        FROM feedback_events
+        WHERE category = ?
+        ORDER BY received_at DESC
+        LIMIT ?
+      `
+        )
+        .bind('feature-request', 20)
+        .run();
+
+      expect(result.success).toBe(true);
+      const query = db.statements.find((stmt) => stmt.sql.includes('WHERE category = ?'));
+      expect(query).toBeTruthy();
+      expect(query?.params).toEqual(['feature-request', 20]);
+    });
+
+    it('should query correlated feedback', async () => {
+      const result = await db
+        .prepare(
+          `
+        SELECT *
+        FROM feedback_events
+        WHERE related_error_correlation IS NOT NULL
+        ORDER BY correlation_confidence DESC
+      `
+        )
+        .run();
+
+      expect(result.success).toBe(true);
+      const query = db.statements.find((stmt) =>
+        stmt.sql.includes('related_error_correlation IS NOT NULL')
+      );
+      expect(query).toBeTruthy();
+    });
+
+    it('should query by repo with time range', async () => {
+      const result = await db
+        .prepare(
+          `
+        SELECT *
+        FROM feedback_events
+        WHERE repo = ? AND received_at >= datetime('now', '-30 days')
+        ORDER BY received_at DESC
+      `
+        )
+        .bind('notebridge')
+        .run();
+
+      expect(result.success).toBe(true);
+      const query = db.statements.find((stmt) => stmt.sql.includes("datetime('now', '-30 days')"));
+      expect(query).toBeTruthy();
+    });
+  });
+
+  describe('Constraint Validation', () => {
+    it('should enforce NOT NULL on repo', () => {
+      // We're testing that the constraint is defined in the schema
+      expect(schema).toContain('repo TEXT NOT NULL');
+    });
+
+    it('should enforce NOT NULL on issue_number', () => {
+      expect(schema).toContain('issue_number INTEGER NOT NULL');
+    });
+
+    it('should enforce UNIQUE constraint on (repo, issue_number)', () => {
+      expect(schema).toContain('UNIQUE(repo, issue_number)');
+    });
+  });
+
+  describe('Default Values', () => {
+    it('should have default sentiment as neutral', () => {
+      expect(schema).toContain("sentiment TEXT DEFAULT 'neutral'");
+    });
+
+    it('should have default received_at timestamp', () => {
+      expect(schema).toContain("received_at TEXT DEFAULT (datetime('now'))");
+    });
+
+    it('should have default updated_at timestamp', () => {
+      expect(schema).toContain("updated_at TEXT DEFAULT (datetime('now'))");
+    });
+  });
+
+  describe('Correlation Data', () => {
+    it('should store correlation confidence as REAL', () => {
+      expect(schema).toContain('correlation_confidence REAL');
+    });
+
+    it('should accept null correlation', async () => {
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category,
+          related_error_correlation
+        )
+        VALUES (?, ?, ?, ?, ?)
+      `
+        )
+        .bind('delivery-999', 'palette-kit', 99, 'other', null)
+        .run();
+
+      expect(result.success).toBe(true);
+      const insert = db.statements.find((stmt) => stmt.sql.includes('INSERT INTO feedback_events'));
+      expect(insert?.params[4]).toBeNull();
+    });
+
+    it('should store correlation method', async () => {
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category, correlation_method
+        )
+        VALUES (?, ?, ?, ?, ?)
+      `
+        )
+        .bind('delivery-111', 'convert-my-file', 11, 'bug-report', 'ml')
+        .run();
+
+      expect(result.success).toBe(true);
+      const insert = db.statements.find((stmt) => stmt.sql.includes('correlation_method'));
+      expect(insert?.params).toContain('ml');
+    });
+  });
+
+  describe('GDPR Compliance', () => {
+    it('should allow null user_contact_encrypted', async () => {
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category, user_contact_encrypted
+        )
+        VALUES (?, ?, ?, ?, ?)
+      `
+        )
+        .bind('delivery-222', 'notebridge', 22, 'feature-request', null)
+        .run();
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should store encrypted user contact', async () => {
+      const encryptedEmail = 'v1.aes-gcm.base64encodeddata';
+      const result = await db
+        .prepare(
+          `
+        INSERT INTO feedback_events (
+          feedback_id, repo, issue_number, category, user_contact_encrypted
+        )
+        VALUES (?, ?, ?, ?, ?)
+      `
+        )
+        .bind('delivery-333', 'palette-kit', 33, 'bug-report', encryptedEmail)
+        .run();
+
+      expect(result.success).toBe(true);
+      const insert = db.statements.find((stmt) => stmt.sql.includes('user_contact_encrypted'));
+      expect(insert?.params).toContain(encryptedEmail);
+    });
+  });
+
+  describe('KV Cache Integration', () => {
+    it('should cache feedback event after insert', async () => {
+      const feedbackData = {
+        feedbackId: 'delivery-444',
+        repo: 'convert-my-file',
+        issueNumber: 44,
+        category: 'feature-request',
+        relatedErrorCorrelation: null,
+        correlationConfidence: 0,
+        correlationMethod: 'rule-based',
+        userContactEncrypted: null,
+        receivedAt: new Date().toISOString(),
+      };
+
+      const cacheKey = `feedback:${feedbackData.repo}:${feedbackData.issueNumber}`;
+      await kv.put(cacheKey, JSON.stringify(feedbackData), {
+        expirationTtl: 900,
+      } as any);
+
+      expect(kv.store.get(cacheKey)).toBeTruthy();
+      const cached = JSON.parse(kv.store.get(cacheKey)!);
+      expect(cached.feedbackId).toBe('delivery-444');
+      expect(cached.category).toBe('feature-request');
+    });
+
+    it('should invalidate recent list cache on new event', async () => {
+      const repo = 'notebridge';
+      const cacheKey = `feedback:recent:${repo}`;
+
+      // Set cache
+      await kv.put(cacheKey, JSON.stringify([]), {
+        expirationTtl: 900,
+      } as any);
+
+      // Invalidate on new event
+      await kv.delete(cacheKey);
+
+      expect(kv.store.has(cacheKey)).toBe(false);
+    });
+  });
+});

package/templates/full/tests/integration/r2-archive.test.ts

@@ -0,0 +1,108 @@
+/// <reference types="node" />
+import { Buffer } from 'node:buffer';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { gunzipSync, gzipSync } from 'node:zlib';
+import {
+  archiveEvent,
+  getArchiveStats,
+  listArchivedEvents,
+  retrieveEvent,
+  type PlatformEvent,
+} from '../../storage/r2/archive';
+
+describe('R2 archive helpers', () => {
+  let mockR2: {
+    put: ReturnType<typeof vi.fn>;
+    get: ReturnType<typeof vi.fn>;
+    list: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    mockR2 = {
+      put: vi.fn(),
+      get: vi.fn(),
+      list: vi.fn(),
+    };
+  });
+
+  it('archives events using gzip compression and metadata', async () => {
+    const event: PlatformEvent = {
+      id: 'evt-123',
+      source: 'cloakpipe',
+      type: 'error_report',
+      timestamp: '2025-10-25T10:00:00Z',
+      data: { foo: 'bar' },
+      metadata: { schema_version: '1.0.0' },
+    };
+
+    const key = await archiveEvent(event, mockR2 as any);
+
+    expect(key).toBe('2025/10/25/cloakpipe/evt-123.json.gz');
+    expect(mockR2.put).toHaveBeenCalledTimes(1);
+
+    const [, body, options] = mockR2.put.mock.calls[0];
+    expect(options).toMatchObject({
+      httpMetadata: { contentType: 'application/json', contentEncoding: 'gzip' },
+      customMetadata: {
+        source: 'cloakpipe',
+        type: 'error_report',
+        timestamp: '2025-10-25T10:00:00Z',
+      },
+    });
+
+    const buffer = Buffer.from(body as ArrayBuffer);
+    const decompressed = JSON.parse(gunzipSync(buffer).toString('utf-8'));
+    expect(decompressed).toMatchObject({
+      id: 'evt-123',
+      source: 'cloakpipe',
+      type: 'error_report',
+    });
+  });
+
+  it('retrieves archived events and decompresses payload', async () => {
+    const event: PlatformEvent = {
+      id: 'evt-999',
+      source: 'homeostat',
+      type: 'autofix_result',
+      timestamp: '2025-10-26T12:34:56Z',
+      data: { status: 'ok' },
+      metadata: { schema_version: '1.0.0' },
+    };
+
+    const compressed = gzipSync(Buffer.from(JSON.stringify(event), 'utf-8'));
+    mockR2.get.mockResolvedValue({
+      arrayBuffer: async () =>
+        compressed.buffer.slice(
+          compressed.byteOffset,
+          compressed.byteOffset + compressed.byteLength
+        ),
+    });
+
+    const retrieved = await retrieveEvent('2025/10/26/homeostat/evt-999.json.gz', mockR2 as any);
+
+    expect(retrieved).toEqual(event);
+  });
+
+  it('lists archived events across date range prefixes', async () => {
+    mockR2.list
+      .mockResolvedValueOnce({ objects: [{ key: '2025/10/24/cloakpipe/a.json.gz' }] })
+      .mockResolvedValueOnce({ objects: [{ key: '2025/10/25/cloakpipe/b.json.gz' }] });
+
+    const keys = await listArchivedEvents('cloakpipe', '2025-10-24', '2025-10-25', mockR2 as any);
+
+    expect(keys).toEqual(['2025/10/24/cloakpipe/a.json.gz', '2025/10/25/cloakpipe/b.json.gz']);
+    expect(mockR2.list).toHaveBeenCalledTimes(2);
+  });
+
+  it('summarises archive statistics', async () => {
+    mockR2.list.mockResolvedValue({
+      objects: [
+        { key: 'foo', size: 10 },
+        { key: 'bar', size: 20 },
+      ],
+    });
+
+    const stats = await getArchiveStats(mockR2 as any);
+    expect(stats).toEqual({ count: 2, totalSizeBytes: 30, compressionRatio: null });
+  });
+});

package/templates/shared/.github/workflows/dependabot-automerge.yml

@@ -0,0 +1,41 @@
+# Dependabot Auto-Merge
+# Automatically merges patch/minor dependency updates when CI passes
+#
+# Reference: GitHub Security Rollout - littlebearapps
+
+name: Dependabot Auto-Merge
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot-automerge:
+    name: Auto-merge Dependabot
+    runs-on: ubuntu-latest
+    if: github.actor == 'dependabot[bot]'
+
+    steps:
+      - name: Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v2.4.0
+        with:
+          github-token: "${{ secrets.GITHUB_TOKEN }}"
+
+      - name: Enable auto-merge for patch/minor updates
+        if: steps.metadata.outputs.update-type == 'version-update:semver-patch' || steps.metadata.outputs.update-type == 'version-update:semver-minor'
+        run: gh pr merge --auto --squash "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Log major updates (manual review required)
+        if: steps.metadata.outputs.update-type == 'version-update:semver-major'
+        run: |
+          echo "::notice::Major version update detected - manual review required"
+          echo "Package: ${{ steps.metadata.outputs.dependency-names }}"
+          echo "Update type: ${{ steps.metadata.outputs.update-type }}"

package/templates/shared/.github/workflows/validate-controls.yml

@@ -0,0 +1,27 @@
+name: Validate Controls
+
+on:
+  pull_request:
+    paths:
+      - 'monitoring/controls.json'
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Validate controls.json
+        run: npm run validate:controls
+
+      - name: Require platform approval note
+        if: success()
+        run: |
+          echo '⚠️ Circuit breaker changes require platform team approval'

package/templates/shared/dashboard/src/components/Breadcrumbs.astro

@@ -0,0 +1,101 @@
+---
+/**
+ * Breadcrumbs.astro
+ * Navigation breadcrumbs for deep pages
+ * Truncates middle segments on mobile (shows first and last)
+ */
+
+interface BreadcrumbItem {
+  label: string;
+  href?: string; // Optional - current page won't have href
+}
+
+interface Props {
+  items: BreadcrumbItem[];
+}
+
+const { items } = Astro.props;
+---
+
+<nav aria-label="Breadcrumb" class="mb-4">
+  <ol class="flex items-center text-sm">
+    {
+      items.map((item, index) => {
+        const isLast = index === items.length - 1;
+        const isFirst = index === 0;
+        const isMiddle = !isFirst && !isLast;
+
+        return (
+          <li class={`flex items-center ${isMiddle ? 'hidden sm:flex' : ''}`}>
+            {/* Separator (not for first item) */}
+            {index > 0 && (
+              <svg
+                class={`w-4 h-4 mx-2 text-gray-400 dark:text-gray-500 flex-shrink-0 ${isMiddle ? 'hidden sm:block' : ''}`}
+                fill="none"
+                stroke="currentColor"
+                viewBox="0 0 24 24"
+              >
+                <path
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  stroke-width="2"
+                  d="M9 5l7 7-7 7"
+                />
+              </svg>
+            )}
+
+            {/* Mobile ellipsis (shown between first and last on mobile when there are middle items) */}
+            {isLast && items.length > 2 && (
+              <span class="sm:hidden flex items-center">
+                <svg
+                  class="w-4 h-4 mx-2 text-gray-400 dark:text-gray-500"
+                  fill="none"
+                  stroke="currentColor"
+                  viewBox="0 0 24 24"
+                >
+                  <path
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="2"
+                    d="M9 5l7 7-7 7"
+                  />
+                </svg>
+                <span class="text-gray-400 dark:text-gray-500 mr-2">...</span>
+                <svg
+                  class="w-4 h-4 mr-2 text-gray-400 dark:text-gray-500"
+                  fill="none"
+                  stroke="currentColor"
+                  viewBox="0 0 24 24"
+                >
+                  <path
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="2"
+                    d="M9 5l7 7-7 7"
+                  />
+                </svg>
+              </span>
+            )}
+
+            {/* Breadcrumb item */}
+            {item.href && !isLast ? (
+              <a
+                href={item.href}
+                class="text-gray-500 dark:text-gray-400 hover:text-blue-600 dark:hover:text-blue-400 transition-colors"
+              >
+                {item.label}
+              </a>
+            ) : (
+              <span
+                class={`${isLast ? 'text-gray-900 dark:text-white font-medium' : 'text-gray-500 dark:text-gray-400'}`}
+                aria-current={isLast ? 'page' : undefined}
+              >
+                {item.label}
+              </span>
+            )}
+          </li>
+        );
+      })
+    }
+  </ol>
+</nav>

package/templates/shared/dashboard/src/components/EmptyState.astro

@@ -0,0 +1,46 @@
+---
+/**
+ * EmptyState.astro
+ * Empty state placeholder with icon, title, description, and optional CTA
+ * Use when there's no data to display
+ */
+
+interface Props {
+  icon?: string;
+  title: string;
+  description?: string;
+  compact?: boolean;
+}
+
+const { icon = '📭', title, description, compact = false } = Astro.props;
+---
+
+<div class={`flex flex-col items-center justify-center text-center ${compact ? 'py-8' : 'py-16'}`}>
+  {/* Icon */}
+  <div class={`${compact ? 'text-3xl mb-3' : 'text-5xl mb-4'}`} role="img" aria-hidden="true">
+    {icon}
+  </div>
+
+  {/* Title */}
+  <h3
+    class={`font-semibold text-gray-900 dark:text-white ${compact ? 'text-base mb-1' : 'text-lg mb-2'}`}
+  >
+    {title}
+  </h3>
+
+  {/* Description */}
+  {
+    description && (
+      <p
+        class={`text-gray-500 dark:text-gray-400 max-w-md ${compact ? 'text-sm mb-3' : 'text-base mb-6'}`}
+      >
+        {description}
+      </p>
+    )
+  }
+
+  {/* CTA Slot */}
+  <div class="flex flex-wrap items-center justify-center gap-3">
+    <slot name="cta" />
+  </div>
+</div>