@studio-foundation/api 0.3.0-beta.1 → 0.3.0-beta.5

package/src/user-store-pg.ts

@@ -1,138 +0,0 @@
-// api/src/user-store-pg.ts
-// PgUserStore — PostgreSQL async variant of UserStore
-// Follows same pattern as PgRunStore in @studio/engine
-// Table prefix studio_ to avoid conflicts with user app tables
-
-import { createRequire } from 'node:module';
-import type { User, DailyUsage } from './user-store.js';
-export type { User, DailyUsage } from './user-store.js';
-
-export class PgUserStore {
-  private pool: import('pg').Pool;
-  private schemaReady: Promise<void> | null = null;
-
-  constructor(connectionString: string) {
-    const _require = createRequire(import.meta.url);
-    const { Pool } = _require('pg') as typeof import('pg');
-    this.pool = new Pool({ connectionString });
-  }
-
-  private ensureSchema(): Promise<void> {
-    if (!this.schemaReady) {
-      this.schemaReady = this.initSchema();
-    }
-    return this.schemaReady;
-  }
-
-  private async initSchema(): Promise<void> {
-    await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS studio_users (
-        id         TEXT PRIMARY KEY,
-        email      TEXT UNIQUE NOT NULL,
-        plan       TEXT NOT NULL DEFAULT 'free',
-        api_key    TEXT UNIQUE NOT NULL,
-        created_at TEXT NOT NULL
-      )
-    `);
-    await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS studio_usage (
-        user_id     TEXT NOT NULL,
-        date        TEXT NOT NULL,
-        runs_count  INTEGER NOT NULL DEFAULT 0,
-        tokens_used INTEGER NOT NULL DEFAULT 0,
-        PRIMARY KEY (user_id, date)
-      )
-    `);
-  }
-
-  async getUserByApiKey(apiKey: string): Promise<User | null> {
-    await this.ensureSchema();
-    const res = await this.pool.query<User>(
-      'SELECT id, email, plan, api_key, created_at FROM studio_users WHERE api_key = $1',
-      [apiKey]
-    );
-    return res.rows[0] ?? null;
-  }
-
-  async getUserById(id: string): Promise<User | null> {
-    await this.ensureSchema();
-    const res = await this.pool.query<User>(
-      'SELECT id, email, plan, api_key, created_at FROM studio_users WHERE id = $1',
-      [id]
-    );
-    return res.rows[0] ?? null;
-  }
-
-  async getUserByEmail(email: string): Promise<User | null> {
-    await this.ensureSchema();
-    const res = await this.pool.query<User>(
-      'SELECT id, email, plan, api_key, created_at FROM studio_users WHERE email = $1',
-      [email]
-    );
-    return res.rows[0] ?? null;
-  }
-
-  async listUsers(): Promise<User[]> {
-    await this.ensureSchema();
-    const res = await this.pool.query<User>(
-      'SELECT id, email, plan, api_key, created_at FROM studio_users ORDER BY created_at ASC'
-    );
-    return res.rows;
-  }
-
-  async saveUser(user: User): Promise<void> {
-    await this.ensureSchema();
-    await this.pool.query(
-      `INSERT INTO studio_users (id, email, plan, api_key, created_at)
-       VALUES ($1, $2, $3, $4, $5)
-       ON CONFLICT (id) DO UPDATE SET
-         email      = EXCLUDED.email,
-         plan       = EXCLUDED.plan,
-         api_key    = EXCLUDED.api_key,
-         created_at = EXCLUDED.created_at`,
-      [user.id, user.email, user.plan, user.api_key, user.created_at]
-    );
-  }
-
-  async deleteUser(id: string): Promise<void> {
-    await this.ensureSchema();
-    await this.pool.query('DELETE FROM studio_users WHERE id = $1', [id]);
-  }
-
-  async getDailyUsage(userId: string, date: string): Promise<DailyUsage> {
-    await this.ensureSchema();
-    const res = await this.pool.query<DailyUsage>(
-      'SELECT user_id, date, runs_count, tokens_used FROM studio_usage WHERE user_id = $1 AND date = $2',
-      [userId, date]
-    );
-    return res.rows[0] ?? { user_id: userId, date, runs_count: 0, tokens_used: 0 };
-  }
-
-  async incrementRuns(userId: string, date: string): Promise<void> {
-    await this.ensureSchema();
-    await this.pool.query(
-      `INSERT INTO studio_usage (user_id, date, runs_count, tokens_used)
-       VALUES ($1, $2, 1, 0)
-       ON CONFLICT (user_id, date) DO UPDATE SET
-         runs_count = studio_usage.runs_count + 1`,
-      [userId, date]
-    );
-  }
-
-  async incrementTokens(userId: string, date: string, tokens: number): Promise<void> {
-    await this.ensureSchema();
-    await this.pool.query(
-      `INSERT INTO studio_usage (user_id, date, runs_count, tokens_used)
-       VALUES ($1, $2, 0, $3)
-       ON CONFLICT (user_id, date) DO UPDATE SET
-         tokens_used = studio_usage.tokens_used + EXCLUDED.tokens_used`,
-      [userId, date, tokens]
-    );
-  }
-
-  async close(): Promise<void> {
-    await this.pool.end();
-  }
-}
-
-export type AnyUserStore = import('./user-store.js').UserStore | PgUserStore;

package/src/user-store.ts

@@ -1,125 +0,0 @@
-// api/src/user-store.ts
-// UserStore — SQLite persistence for users and daily usage
-// Follows same pattern as WebhookStore and IntegrationStore
-// Uses the same DB file as the run store (.studio/runs/runs.db)
-
-import { createRequire } from 'node:module';
-
-export interface User {
-  id: string;
-  email: string;
-  plan: string;
-  api_key: string;
-  created_at: string;
-}
-
-export interface DailyUsage {
-  user_id: string;
-  date: string;      // YYYY-MM-DD
-  runs_count: number;
-  tokens_used: number;
-}
-
-export class UserStore {
-  private db: import('better-sqlite3').Database;
-
-  constructor(dbPath: string) {
-    const _require = createRequire(import.meta.url);
-    const Database = _require('better-sqlite3') as new (path: string) => import('better-sqlite3').Database;
-    this.db = new Database(dbPath);
-    this.db.pragma('journal_mode = WAL');
-    this.initSchema();
-  }
-
-  private initSchema(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS users (
-        id         TEXT PRIMARY KEY,
-        email      TEXT UNIQUE NOT NULL,
-        plan       TEXT NOT NULL DEFAULT 'free',
-        api_key    TEXT UNIQUE NOT NULL,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS usage (
-        user_id    TEXT NOT NULL,
-        date       TEXT NOT NULL,
-        runs_count INTEGER NOT NULL DEFAULT 0,
-        tokens_used INTEGER NOT NULL DEFAULT 0,
-        PRIMARY KEY (user_id, date)
-      );
-    `);
-  }
-
-  getUserByApiKey(apiKey: string): User | null {
-    const row = this.db
-      .prepare('SELECT id, email, plan, api_key, created_at FROM users WHERE api_key = ?')
-      .get(apiKey) as User | undefined;
-    return row ?? null;
-  }
-
-  getUserById(id: string): User | null {
-    const row = this.db
-      .prepare('SELECT id, email, plan, api_key, created_at FROM users WHERE id = ?')
-      .get(id) as User | undefined;
-    return row ?? null;
-  }
-
-  getUserByEmail(email: string): User | null {
-    const row = this.db
-      .prepare('SELECT id, email, plan, api_key, created_at FROM users WHERE email = ?')
-      .get(email) as User | undefined;
-    return row ?? null;
-  }
-
-  listUsers(): User[] {
-    return this.db
-      .prepare('SELECT id, email, plan, api_key, created_at FROM users ORDER BY created_at ASC')
-      .all() as User[];
-  }
-
-  saveUser(user: User): void {
-    this.db.prepare(`
-      INSERT INTO users (id, email, plan, api_key, created_at)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        email      = excluded.email,
-        plan       = excluded.plan,
-        api_key    = excluded.api_key,
-        created_at = excluded.created_at
-    `).run(user.id, user.email, user.plan, user.api_key, user.created_at);
-  }
-
-  deleteUser(id: string): void {
-    this.db.prepare('DELETE FROM users WHERE id = ?').run(id);
-  }
-
-  getDailyUsage(userId: string, date: string): DailyUsage {
-    const row = this.db
-      .prepare('SELECT user_id, date, runs_count, tokens_used FROM usage WHERE user_id = ? AND date = ?')
-      .get(userId, date) as DailyUsage | undefined;
-    return row ?? { user_id: userId, date, runs_count: 0, tokens_used: 0 };
-  }
-
-  incrementRuns(userId: string, date: string): void {
-    this.db.prepare(`
-      INSERT INTO usage (user_id, date, runs_count, tokens_used)
-      VALUES (?, ?, 1, 0)
-      ON CONFLICT (user_id, date) DO UPDATE SET
-        runs_count = runs_count + 1
-    `).run(userId, date);
-  }
-
-  incrementTokens(userId: string, date: string, tokens: number): void {
-    this.db.prepare(`
-      INSERT INTO usage (user_id, date, runs_count, tokens_used)
-      VALUES (?, ?, 0, ?)
-      ON CONFLICT (user_id, date) DO UPDATE SET
-        tokens_used = tokens_used + excluded.tokens_used
-    `).run(userId, date, tokens);
-  }
-
-  close(): void {
-    this.db.close();
-  }
-}

package/src/utils/repo-resolver.ts

@@ -1,3 +0,0 @@
-// Re-exported from @studio/engine — implementation lives there
-export { resolveRepoPath, cloneRepo } from '@studio-foundation/engine';
-export type { RepoResolveOptions } from '@studio-foundation/engine';

package/src/webhook-dispatcher.ts

@@ -1,142 +0,0 @@
-// WebhookDispatcher — listens to pipeline events and delivers them to registered webhooks
-// Handles HMAC-SHA256 signing, retry logic (30s / 5min / 15min), and failure tracking
-
-import { createHmac, randomUUID } from 'node:crypto';
-import type { SseEventType } from './event-bus.js';
-import type { WebhookStore } from './webhook-store.js';
-
-export type WebhookEventType =
-  | 'pipeline_start'
-  | 'pipeline_complete'
-  | 'stage_complete'
-  | 'stage_rejected'
-  | 'stage_failed'
-  | 'group_feedback';
-
-// Retry delays in ms: attempt 1 failed → 30s, attempt 2 failed → 5min, attempt 3 failed → 15min
-const RETRY_DELAYS = [30_000, 5 * 60_000, 15 * 60_000];
-
-function mapToWebhookEvent(sseType: SseEventType, data: unknown): WebhookEventType | null {
-  switch (sseType) {
-    case 'pipeline_start':
-      return 'pipeline_start';
-    case 'pipeline_complete':
-      return 'pipeline_complete';
-    case 'stage_complete': {
-      const status = (data as { status?: string }).status;
-      if (status === 'rejected') return 'stage_rejected';
-      if (status === 'failed') return 'stage_failed';
-      return 'stage_complete';
-    }
-    case 'group_feedback':
-      return 'group_feedback';
-    default:
-      return null;
-  }
-}
-
-function sign(body: string, secret: string): string {
-  const hmac = createHmac('sha256', secret);
-  hmac.update(body, 'utf-8');
-  return `sha256=${hmac.digest('hex')}`;
-}
-
-export class WebhookDispatcher {
-  constructor(
-    private readonly store: WebhookStore,
-    private readonly projectName: string,
-    private readonly fetcher: typeof fetch = fetch,
-  ) {}
-
-  async handleBusEvent(runId: string, sseType: SseEventType, data: unknown): Promise<void> {
-    const webhookEvent = mapToWebhookEvent(sseType, data);
-    if (!webhookEvent) return;
-
-    const webhooks = this.store.listWebhooks().filter(
-      w => w.status === 'active' && w.events.includes(webhookEvent),
-    );
-
-    await Promise.all(
-      webhooks.map(webhook => this.dispatch(webhook.id, webhookEvent, runId, data, 1)),
-    );
-  }
-
-  private async dispatch(
-    webhookId: string,
-    event: WebhookEventType,
-    runId: string,
-    sourceData: unknown,
-    attempt: number,
-  ): Promise<void> {
-    const webhook = this.store.getWebhook(webhookId);
-    if (!webhook || webhook.status === 'failed') return;
-
-    const payload = {
-      event,
-      run_id: runId,
-      project: this.projectName,
-      ts: new Date().toISOString(),
-      ...(sourceData as object),
-    };
-
-    const body = JSON.stringify(payload);
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'X-Studio-Event': event,
-    };
-    if (webhook.secret) {
-      headers['X-Studio-Signature'] = sign(body, webhook.secret);
-    }
-
-    const deliveryId = randomUUID();
-    this.store.saveDelivery({
-      id: deliveryId,
-      webhook_id: webhookId,
-      event,
-      run_id: runId,
-      status: 'pending',
-      attempt,
-      created_at: new Date().toISOString(),
-    });
-
-    try {
-      const response = await this.fetcher(webhook.url, {
-        method: 'POST',
-        headers,
-        body,
-        signal: AbortSignal.timeout(10_000),
-      });
-
-      if (response.ok) {
-        this.store.updateDelivery(deliveryId, 'success');
-      } else {
-        this.handleFailure(webhookId, event, runId, sourceData, attempt, deliveryId);
-      }
-    } catch {
-      this.handleFailure(webhookId, event, runId, sourceData, attempt, deliveryId);
-    }
-  }
-
-  private handleFailure(
-    webhookId: string,
-    event: WebhookEventType,
-    runId: string,
-    sourceData: unknown,
-    attempt: number,
-    deliveryId: string,
-  ): void {
-    const maxAttempts = RETRY_DELAYS.length + 1; // 4 total (1 original + 3 retries)
-
-    if (attempt >= maxAttempts) {
-      this.store.updateDelivery(deliveryId, 'failed');
-      this.store.markWebhookFailed(webhookId);
-      return;
-    }
-
-    this.store.updateDelivery(deliveryId, 'retrying');
-    const delay = RETRY_DELAYS[attempt - 1];
-    setTimeout(() => {
-      void this.dispatch(webhookId, event, runId, sourceData, attempt + 1);
-    }, delay);
-  }
-}

package/src/webhook-store.ts

@@ -1,141 +0,0 @@
-// WebhookStore — SQLite persistence for webhook registrations and deliveries
-// Uses the same DB file as the run store (.studio/runs/runs.db)
-
-import { createRequire } from 'node:module';
-
-export interface WebhookRegistration {
-  id: string;
-  url: string;
-  events: string[];
-  secret?: string;
-  status: 'active' | 'failed';
-  created_at: string;
-}
-
-export interface WebhookDelivery {
-  id: string;
-  webhook_id: string;
-  event: string;
-  run_id: string;
-  status: 'pending' | 'retrying' | 'success' | 'failed';
-  attempt: number;
-  created_at: string;
-}
-
-export class WebhookStore {
-  private db: import('better-sqlite3').Database;
-
-  constructor(dbPath: string) {
-    const _require = createRequire(import.meta.url);
-    const Database = _require('better-sqlite3') as new (path: string) => import('better-sqlite3').Database;
-    this.db = new Database(dbPath);
-    this.db.pragma('journal_mode = WAL');
-    this.initSchema();
-  }
-
-  private initSchema(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS webhooks (
-        id TEXT PRIMARY KEY,
-        url TEXT NOT NULL,
-        events TEXT NOT NULL,
-        secret TEXT,
-        status TEXT NOT NULL DEFAULT 'active',
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS webhook_deliveries (
-        id TEXT PRIMARY KEY,
-        webhook_id TEXT NOT NULL,
-        event TEXT NOT NULL,
-        run_id TEXT NOT NULL,
-        status TEXT NOT NULL,
-        attempt INTEGER NOT NULL,
-        created_at TEXT NOT NULL,
-        FOREIGN KEY (webhook_id) REFERENCES webhooks(id)
-      );
-    `);
-  }
-
-  saveWebhook(webhook: WebhookRegistration): void {
-    this.db.prepare(`
-      INSERT INTO webhooks (id, url, events, secret, status, created_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        url = excluded.url,
-        events = excluded.events,
-        secret = excluded.secret,
-        status = excluded.status
-    `).run(
-      webhook.id,
-      webhook.url,
-      JSON.stringify(webhook.events),
-      webhook.secret ?? null,
-      webhook.status,
-      webhook.created_at,
-    );
-  }
-
-  getWebhook(id: string): WebhookRegistration | null {
-    const row = this.db.prepare(
-      'SELECT id, url, events, secret, status, created_at FROM webhooks WHERE id = ?'
-    ).get(id) as { id: string; url: string; events: string; secret: string | null; status: string; created_at: string } | undefined;
-
-    if (!row) return null;
-    return {
-      id: row.id,
-      url: row.url,
-      events: JSON.parse(row.events) as string[],
-      ...(row.secret != null ? { secret: row.secret } : {}),
-      status: row.status as 'active' | 'failed',
-      created_at: row.created_at,
-    };
-  }
-
-  listWebhooks(): WebhookRegistration[] {
-    const rows = this.db.prepare(
-      'SELECT id, url, events, secret, status, created_at FROM webhooks ORDER BY created_at DESC'
-    ).all() as Array<{ id: string; url: string; events: string; secret: string | null; status: string; created_at: string }>;
-
-    return rows.map(row => ({
-      id: row.id,
-      url: row.url,
-      events: JSON.parse(row.events) as string[],
-      ...(row.secret != null ? { secret: row.secret } : {}),
-      status: row.status as 'active' | 'failed',
-      created_at: row.created_at,
-    }));
-  }
-
-  deleteWebhook(id: string): boolean {
-    const result = this.db.prepare('DELETE FROM webhooks WHERE id = ?').run(id);
-    return result.changes > 0;
-  }
-
-  markWebhookFailed(id: string): void {
-    this.db.prepare("UPDATE webhooks SET status = 'failed' WHERE id = ?").run(id);
-  }
-
-  saveDelivery(delivery: WebhookDelivery): void {
-    this.db.prepare(`
-      INSERT INTO webhook_deliveries (id, webhook_id, event, run_id, status, attempt, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      delivery.id,
-      delivery.webhook_id,
-      delivery.event,
-      delivery.run_id,
-      delivery.status,
-      delivery.attempt,
-      delivery.created_at,
-    );
-  }
-
-  updateDelivery(id: string, status: WebhookDelivery['status']): void {
-    this.db.prepare('UPDATE webhook_deliveries SET status = ? WHERE id = ?').run(status, id);
-  }
-
-  close(): void {
-    this.db.close();
-  }
-}