@runchr/gstack-antigravity 0.1.0

package/gstack-origin/supabase/functions/telemetry-ingest/index.ts

@@ -0,0 +1,135 @@
+// gstack telemetry-ingest edge function
+// Validates and inserts a batch of telemetry events.
+// Called by bin/gstack-telemetry-sync.
+
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2";
+
+interface TelemetryEvent {
+  v: number;
+  ts: string;
+  event_type: string;
+  skill: string;
+  session_id?: string;
+  gstack_version: string;
+  os: string;
+  arch?: string;
+  duration_s?: number;
+  outcome: string;
+  error_class?: string;
+  used_browse?: boolean;
+  sessions?: number;
+  installation_id?: string;
+}
+
+const MAX_BATCH_SIZE = 100;
+const MAX_PAYLOAD_BYTES = 50_000; // 50KB
+
+Deno.serve(async (req) => {
+  if (req.method !== "POST") {
+    return new Response("POST required", { status: 405 });
+  }
+
+  // Check payload size
+  const contentLength = parseInt(req.headers.get("content-length") || "0");
+  if (contentLength > MAX_PAYLOAD_BYTES) {
+    return new Response("Payload too large", { status: 413 });
+  }
+
+  try {
+    const body = await req.json();
+    const events: TelemetryEvent[] = Array.isArray(body) ? body : [body];
+
+    if (events.length > MAX_BATCH_SIZE) {
+      return new Response(`Batch too large (max ${MAX_BATCH_SIZE})`, { status: 400 });
+    }
+
+    const supabase = createClient(
+      Deno.env.get("SUPABASE_URL") ?? "",
+      Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? ""
+    );
+
+    // Validate and transform events
+    const rows = [];
+    const installationUpserts: Map<string, { version: string; os: string }> = new Map();
+
+    for (const event of events) {
+      // Required fields
+      if (!event.ts || !event.gstack_version || !event.os || !event.outcome) {
+        continue; // skip malformed
+      }
+
+      // Validate schema version
+      if (event.v !== 1) continue;
+
+      // Validate event_type
+      const validTypes = ["skill_run", "upgrade_prompted", "upgrade_completed"];
+      if (!validTypes.includes(event.event_type)) continue;
+
+      rows.push({
+        schema_version: event.v,
+        event_type: event.event_type,
+        gstack_version: String(event.gstack_version).slice(0, 20),
+        os: String(event.os).slice(0, 20),
+        arch: event.arch ? String(event.arch).slice(0, 20) : null,
+        event_timestamp: event.ts,
+        skill: event.skill ? String(event.skill).slice(0, 50) : null,
+        session_id: event.session_id ? String(event.session_id).slice(0, 50) : null,
+        duration_s: typeof event.duration_s === "number" ? event.duration_s : null,
+        outcome: String(event.outcome).slice(0, 20),
+        error_class: event.error_class ? String(event.error_class).slice(0, 100) : null,
+        used_browse: event.used_browse === true,
+        concurrent_sessions: typeof event.sessions === "number" ? event.sessions : 1,
+        installation_id: event.installation_id ? String(event.installation_id).slice(0, 64) : null,
+      });
+
+      // Track installations for upsert
+      if (event.installation_id) {
+        installationUpserts.set(event.installation_id, {
+          version: event.gstack_version,
+          os: event.os,
+        });
+      }
+    }
+
+    if (rows.length === 0) {
+      return new Response(JSON.stringify({ inserted: 0 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Insert events
+    const { error: insertError } = await supabase
+      .from("telemetry_events")
+      .insert(rows);
+
+    if (insertError) {
+      return new Response(JSON.stringify({ error: insertError.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Upsert installations (update last_seen)
+    for (const [id, data] of installationUpserts) {
+      await supabase
+        .from("installations")
+        .upsert(
+          {
+            installation_id: id,
+            last_seen: new Date().toISOString(),
+            gstack_version: data.version,
+            os: data.os,
+          },
+          { onConflict: "installation_id" }
+        );
+    }
+
+    return new Response(JSON.stringify({ inserted: rows.length }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch {
+    return new Response("Invalid request", { status: 400 });
+  }
+});

package/gstack-origin/supabase/functions/update-check/index.ts

@@ -0,0 +1,37 @@
+// gstack update-check edge function
+// Logs an install ping and returns the current latest version.
+// Called by bin/gstack-update-check as a parallel background request.
+
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2";
+
+const CURRENT_VERSION = Deno.env.get("GSTACK_CURRENT_VERSION") || "0.6.4.1";
+
+Deno.serve(async (req) => {
+  if (req.method !== "POST") {
+    return new Response(CURRENT_VERSION, { status: 200 });
+  }
+
+  try {
+    const { version, os } = await req.json();
+
+    if (!version || !os) {
+      return new Response(CURRENT_VERSION, { status: 200 });
+    }
+
+    const supabase = createClient(
+      Deno.env.get("SUPABASE_URL") ?? "",
+      Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? ""
+    );
+
+    // Log the update check (fire-and-forget)
+    await supabase.from("update_checks").insert({
+      gstack_version: String(version).slice(0, 20),
+      os: String(os).slice(0, 20),
+    });
+
+    return new Response(CURRENT_VERSION, { status: 200 });
+  } catch {
+    // Always return the version, even if logging fails
+    return new Response(CURRENT_VERSION, { status: 200 });
+  }
+});

package/gstack-origin/supabase/migrations/001_telemetry.sql

@@ -0,0 +1,89 @@
+-- gstack telemetry schema
+-- Tables for tracking usage, installations, and update checks.
+
+-- Main telemetry events (skill runs, upgrades)
+CREATE TABLE telemetry_events (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  received_at TIMESTAMPTZ DEFAULT now(),
+  schema_version INTEGER NOT NULL DEFAULT 1,
+  event_type TEXT NOT NULL DEFAULT 'skill_run',
+  gstack_version TEXT NOT NULL,
+  os TEXT NOT NULL,
+  arch TEXT,
+  event_timestamp TIMESTAMPTZ NOT NULL,
+  skill TEXT,
+  session_id TEXT,
+  duration_s NUMERIC,
+  outcome TEXT NOT NULL,
+  error_class TEXT,
+  used_browse BOOLEAN DEFAULT false,
+  concurrent_sessions INTEGER DEFAULT 1,
+  installation_id TEXT  -- nullable, only for "community" tier
+);
+
+-- Index for skill_sequences view performance
+CREATE INDEX idx_telemetry_session_ts ON telemetry_events (session_id, event_timestamp);
+-- Index for crash clustering
+CREATE INDEX idx_telemetry_error ON telemetry_events (error_class, gstack_version) WHERE outcome = 'error';
+
+-- Retention tracking per installation
+CREATE TABLE installations (
+  installation_id TEXT PRIMARY KEY,
+  first_seen TIMESTAMPTZ DEFAULT now(),
+  last_seen TIMESTAMPTZ DEFAULT now(),
+  gstack_version TEXT,
+  os TEXT
+);
+
+-- Install pings from update checks
+CREATE TABLE update_checks (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  checked_at TIMESTAMPTZ DEFAULT now(),
+  gstack_version TEXT NOT NULL,
+  os TEXT NOT NULL
+);
+
+-- RLS: anon key can INSERT and SELECT (all telemetry data is anonymous)
+ALTER TABLE telemetry_events ENABLE ROW LEVEL SECURITY;
+CREATE POLICY "anon_insert_only" ON telemetry_events FOR INSERT WITH CHECK (true);
+CREATE POLICY "anon_select" ON telemetry_events FOR SELECT USING (true);
+
+ALTER TABLE installations ENABLE ROW LEVEL SECURITY;
+CREATE POLICY "anon_insert_only" ON installations FOR INSERT WITH CHECK (true);
+CREATE POLICY "anon_select" ON installations FOR SELECT USING (true);
+-- Allow upsert (update last_seen)
+CREATE POLICY "anon_update_last_seen" ON installations FOR UPDATE USING (true) WITH CHECK (true);
+
+ALTER TABLE update_checks ENABLE ROW LEVEL SECURITY;
+CREATE POLICY "anon_insert_only" ON update_checks FOR INSERT WITH CHECK (true);
+CREATE POLICY "anon_select" ON update_checks FOR SELECT USING (true);
+
+-- Crash clustering view
+CREATE VIEW crash_clusters AS
+SELECT
+  error_class,
+  gstack_version,
+  COUNT(*) as total_occurrences,
+  COUNT(DISTINCT installation_id) as identified_users,  -- community tier only
+  COUNT(*) - COUNT(installation_id) as anonymous_occurrences,  -- events without installation_id
+  MIN(event_timestamp) as first_seen,
+  MAX(event_timestamp) as last_seen
+FROM telemetry_events
+WHERE outcome = 'error' AND error_class IS NOT NULL
+GROUP BY error_class, gstack_version
+ORDER BY total_occurrences DESC;
+
+-- Skill sequence co-occurrence view
+CREATE VIEW skill_sequences AS
+SELECT
+  a.skill as skill_a,
+  b.skill as skill_b,
+  COUNT(DISTINCT a.session_id) as co_occurrences
+FROM telemetry_events a
+JOIN telemetry_events b ON a.session_id = b.session_id
+  AND a.skill != b.skill
+  AND a.event_timestamp < b.event_timestamp
+WHERE a.event_type = 'skill_run' AND b.event_type = 'skill_run'
+GROUP BY a.skill, b.skill
+HAVING COUNT(DISTINCT a.session_id) >= 10
+ORDER BY co_occurrences DESC;

package/gstack-origin/test/analytics.test.ts

@@ -0,0 +1,277 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { parseJSONL, filterByPeriod, formatReport } from '../scripts/analytics';
+import type { AnalyticsEvent } from '../scripts/analytics';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+const TMP_DIR = path.join(os.tmpdir(), 'analytics-test');
+const SCRIPT = path.resolve(import.meta.dir, '../scripts/analytics.ts');
+
+function writeTempJSONL(name: string, lines: string[]): string {
+  fs.mkdirSync(TMP_DIR, { recursive: true });
+  const p = path.join(TMP_DIR, name);
+  fs.writeFileSync(p, lines.join('\n') + '\n');
+  return p;
+}
+
+/**
+ * Run the analytics script with a custom JSONL file by overriding the path.
+ * We test the exported functions directly for unit tests, and use this
+ * helper for integration-style checks.
+ */
+function runScript(jsonlPath: string | null, extraArgs: string = ''): string {
+  // We test via the exported functions; for CLI integration we read the file
+  // and run the pipeline manually to avoid needing to override the hardcoded path.
+  if (jsonlPath === null) {
+    return 'No analytics data found.';
+  }
+  if (!fs.existsSync(jsonlPath)) {
+    return 'No analytics data found.';
+  }
+  const content = fs.readFileSync(jsonlPath, 'utf-8').trim();
+  if (!content) {
+    return 'No analytics data found.';
+  }
+  const events = parseJSONL(content);
+  if (events.length === 0) {
+    return 'No analytics data found.';
+  }
+  // Parse period from extraArgs
+  let period = 'all';
+  const match = extraArgs.match(/--period\s+(\S+)/);
+  if (match) period = match[1];
+  const filtered = filterByPeriod(events, period);
+  return formatReport(filtered, period);
+}
+
+beforeEach(() => {
+  fs.mkdirSync(TMP_DIR, { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+describe('parseJSONL', () => {
+  test('parses valid JSONL lines', () => {
+    const content = [
+      '{"skill":"ship","ts":"2026-03-18T15:30:00Z","repo":"my-app"}',
+      '{"skill":"qa","ts":"2026-03-18T16:00:00Z","repo":"my-api"}',
+    ].join('\n');
+    const events = parseJSONL(content);
+    expect(events).toHaveLength(2);
+    expect(events[0].skill).toBe('ship');
+    expect(events[1].skill).toBe('qa');
+  });
+
+  test('skips malformed lines', () => {
+    const content = [
+      '{"skill":"ship","ts":"2026-03-18T15:30:00Z","repo":"my-app"}',
+      'not valid json',
+      '{broken',
+      '',
+      '{"skill":"qa","ts":"2026-03-18T16:00:00Z","repo":"my-api"}',
+    ].join('\n');
+    const events = parseJSONL(content);
+    expect(events).toHaveLength(2);
+    expect(events[0].skill).toBe('ship');
+    expect(events[1].skill).toBe('qa');
+  });
+
+  test('returns empty array for empty string', () => {
+    expect(parseJSONL('')).toHaveLength(0);
+  });
+
+  test('skips objects missing ts field', () => {
+    const content = '{"skill":"ship","repo":"my-app"}\n';
+    const events = parseJSONL(content);
+    expect(events).toHaveLength(0);
+  });
+});
+
+describe('filterByPeriod', () => {
+  const now = new Date();
+  const daysAgo = (n: number) => new Date(now.getTime() - n * 24 * 60 * 60 * 1000).toISOString();
+
+  const events: AnalyticsEvent[] = [
+    { skill: 'ship', ts: daysAgo(1), repo: 'app' },
+    { skill: 'qa', ts: daysAgo(3), repo: 'app' },
+    { skill: 'review', ts: daysAgo(10), repo: 'app' },
+    { skill: 'retro', ts: daysAgo(40), repo: 'app' },
+  ];
+
+  test('period "all" returns all events', () => {
+    expect(filterByPeriod(events, 'all')).toHaveLength(4);
+  });
+
+  test('period "7d" returns only last 7 days', () => {
+    const filtered = filterByPeriod(events, '7d');
+    expect(filtered).toHaveLength(2);
+    expect(filtered[0].skill).toBe('ship');
+    expect(filtered[1].skill).toBe('qa');
+  });
+
+  test('period "30d" returns last 30 days', () => {
+    const filtered = filterByPeriod(events, '30d');
+    expect(filtered).toHaveLength(3);
+  });
+
+  test('invalid period string returns all events', () => {
+    expect(filterByPeriod(events, 'bogus')).toHaveLength(4);
+  });
+});
+
+describe('formatReport', () => {
+  test('includes header and period label', () => {
+    const report = formatReport([], 'all');
+    expect(report).toContain('gstack skill usage analytics');
+    expect(report).toContain('Period: all time');
+  });
+
+  test('shows "last 7 days" for 7d period', () => {
+    const report = formatReport([], '7d');
+    expect(report).toContain('Period: last 7 days');
+  });
+
+  test('shows "last 30 days" for 30d period', () => {
+    const report = formatReport([], '30d');
+    expect(report).toContain('Period: last 30 days');
+  });
+
+  test('counts skill invocations correctly', () => {
+    const events: AnalyticsEvent[] = [
+      { skill: 'ship', ts: '2026-03-18T15:30:00Z', repo: 'app' },
+      { skill: 'ship', ts: '2026-03-18T16:00:00Z', repo: 'app' },
+      { skill: 'qa', ts: '2026-03-18T16:30:00Z', repo: 'app' },
+    ];
+    const report = formatReport(events);
+    expect(report).toContain('/ship');
+    expect(report).toContain('2 invocations');
+    expect(report).toContain('/qa');
+    expect(report).toContain('1 invocation');
+  });
+
+  test('groups by repo', () => {
+    const events: AnalyticsEvent[] = [
+      { skill: 'ship', ts: '2026-03-18T15:30:00Z', repo: 'app-a' },
+      { skill: 'qa', ts: '2026-03-18T16:00:00Z', repo: 'app-a' },
+      { skill: 'ship', ts: '2026-03-18T16:30:00Z', repo: 'app-b' },
+    ];
+    const report = formatReport(events);
+    expect(report).toContain('app-a: ship(1) qa(1)');
+    expect(report).toContain('app-b: ship(1)');
+  });
+
+  test('counts hook fire events separately', () => {
+    const events: AnalyticsEvent[] = [
+      { skill: 'ship', ts: '2026-03-18T15:30:00Z', repo: 'app' },
+      { skill: 'careful', ts: '2026-03-18T16:00:00Z', repo: 'app', event: 'hook_fire', pattern: 'rm_recursive' },
+      { skill: 'careful', ts: '2026-03-18T16:30:00Z', repo: 'app', event: 'hook_fire', pattern: 'rm_recursive' },
+      { skill: 'careful', ts: '2026-03-18T17:00:00Z', repo: 'app', event: 'hook_fire', pattern: 'git_force_push' },
+    ];
+    const report = formatReport(events);
+    expect(report).toContain('Safety Hook Events');
+    expect(report).toContain('rm_recursive');
+    expect(report).toContain('2 fires');
+    expect(report).toContain('git_force_push');
+    expect(report).toContain('1 fire');
+    expect(report).toContain('Total: 1 skill invocation, 3 hook fires');
+  });
+
+  test('handles mixed events correctly', () => {
+    const events: AnalyticsEvent[] = [
+      { skill: 'ship', ts: '2026-03-18T15:30:00Z', repo: 'my-app' },
+      { skill: 'ship', ts: '2026-03-18T15:35:00Z', repo: 'my-app' },
+      { skill: 'qa', ts: '2026-03-18T16:00:00Z', repo: 'my-api' },
+      { skill: 'careful', ts: '2026-03-18T16:30:00Z', repo: 'my-app', event: 'hook_fire', pattern: 'rm_recursive' },
+    ];
+    const report = formatReport(events);
+    // Skills counted correctly (hook_fire events excluded from skill counts)
+    expect(report).toContain('Total: 3 skill invocations, 1 hook fire');
+    // Both sections present
+    expect(report).toContain('Top Skills');
+    expect(report).toContain('Safety Hook Events');
+    expect(report).toContain('By Repo');
+  });
+});
+
+describe('integration via runScript helper', () => {
+  test('missing file → "No analytics data found."', () => {
+    const output = runScript(path.join(TMP_DIR, 'nonexistent.jsonl'));
+    expect(output).toBe('No analytics data found.');
+  });
+
+  test('null path → "No analytics data found."', () => {
+    const output = runScript(null);
+    expect(output).toBe('No analytics data found.');
+  });
+
+  test('empty file → "No analytics data found."', () => {
+    const p = writeTempJSONL('empty.jsonl', ['']);
+    // Overwrite with truly empty content
+    fs.writeFileSync(p, '');
+    const output = runScript(p);
+    expect(output).toBe('No analytics data found.');
+  });
+
+  test('all malformed lines → "No analytics data found."', () => {
+    const p = writeTempJSONL('bad.jsonl', [
+      'not json',
+      '{broken',
+      '42',
+    ]);
+    const output = runScript(p);
+    expect(output).toBe('No analytics data found.');
+  });
+
+  test('normal aggregation produces correct output', () => {
+    const p = writeTempJSONL('normal.jsonl', [
+      '{"skill":"ship","ts":"2026-03-18T15:30:00Z","repo":"my-app"}',
+      '{"skill":"ship","ts":"2026-03-18T15:35:00Z","repo":"my-app"}',
+      '{"skill":"qa","ts":"2026-03-18T16:00:00Z","repo":"my-app"}',
+      '{"skill":"review","ts":"2026-03-18T16:30:00Z","repo":"my-api"}',
+    ]);
+    const output = runScript(p);
+    expect(output).toContain('/ship');
+    expect(output).toContain('2 invocations');
+    expect(output).toContain('/qa');
+    expect(output).toContain('1 invocation');
+    expect(output).toContain('/review');
+    expect(output).toContain('Total: 4 skill invocations, 0 hook fires');
+  });
+
+  test('period filtering (7d) only includes recent entries', () => {
+    const now = new Date();
+    const recent = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000).toISOString();
+    const old = new Date(now.getTime() - 20 * 24 * 60 * 60 * 1000).toISOString();
+
+    const p = writeTempJSONL('period.jsonl', [
+      `{"skill":"ship","ts":"${recent}","repo":"app"}`,
+      `{"skill":"qa","ts":"${old}","repo":"app"}`,
+    ]);
+    const output = runScript(p, '--period 7d');
+    expect(output).toContain('Period: last 7 days');
+    expect(output).toContain('/ship');
+    expect(output).toContain('Total: 1 skill invocation, 0 hook fires');
+    // qa should be filtered out
+    expect(output).not.toContain('/qa');
+  });
+
+  test('hook fire events counted in full pipeline', () => {
+    const p = writeTempJSONL('hooks.jsonl', [
+      '{"skill":"ship","ts":"2026-03-18T15:30:00Z","repo":"app"}',
+      '{"event":"hook_fire","skill":"careful","pattern":"rm_recursive","ts":"2026-03-18T16:00:00Z","repo":"app"}',
+      '{"event":"hook_fire","skill":"careful","pattern":"rm_recursive","ts":"2026-03-18T16:30:00Z","repo":"app"}',
+      '{"event":"hook_fire","skill":"careful","pattern":"git_force_push","ts":"2026-03-18T17:00:00Z","repo":"app"}',
+    ]);
+    const output = runScript(p);
+    expect(output).toContain('Safety Hook Events');
+    expect(output).toContain('rm_recursive');
+    expect(output).toContain('2 fires');
+    expect(output).toContain('git_force_push');
+    expect(output).toContain('1 fire');
+    expect(output).toContain('Total: 1 skill invocation, 3 hook fires');
+  });
+});