@elevasis/core 0.1.0

package/src/integrations/webhook-endpoints/types.ts

@@ -0,0 +1,51 @@
+/**
+ * Webhook Endpoint Domain Types
+ *
+ * Browser-safe domain types for generic inbound webhook endpoints.
+ * These are camelCase representations of the `webhook_endpoints` DB table.
+ *
+ * Transform from snake_case DB rows happens in the API service layer,
+ * not here (per core-package.md conventions).
+ */
+
+/**
+ * Lifecycle status of a webhook endpoint.
+ * - `active`: Endpoint accepts inbound requests and triggers the target workflow
+ * - `paused`: Endpoint exists but rejects inbound requests with 404
+ */
+export type WebhookEndpointStatus = 'active' | 'paused'
+
+/**
+ * Generic inbound webhook endpoint domain type.
+ *
+ * Each endpoint gets a unique opaque URL (`/api/webhooks/inbound/:key`)
+ * that maps to a target workflow resource within an organization.
+ */
+export interface WebhookEndpoint {
+  /** UUID primary key */
+  id: string
+  /** Organization this endpoint belongs to */
+  organizationId: string
+  /**
+   * Unique opaque key used in the inbound URL.
+   * Format: `wh_` + 32 crypto-random hex chars (128 bits of entropy).
+   * This key IS the credential — it must be kept secret.
+   */
+  key: string
+  /** User-facing label (e.g., "Zapier → Lead Intake") */
+  name: string
+  /** Optional description for the endpoint */
+  description: string | null
+  /** Target workflow resourceId to invoke on inbound request, or null if not yet assigned */
+  resourceId: string | null
+  /** Whether the endpoint is accepting requests */
+  status: WebhookEndpointStatus
+  /** Timestamp of the most recent successful inbound request, or null */
+  lastTriggeredAt: string | null
+  /** Running total of inbound requests received */
+  requestCount: number
+  /** ISO 8601 creation timestamp */
+  createdAt: string
+  /** ISO 8601 last-updated timestamp */
+  updatedAt: string
+}

package/src/operations/activities/api-schemas.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod'
+import { NonEmptyStringSchema } from '../../platform/utils/validation'
+
+/**
+ * Activity Log API Validation Schemas
+ *
+ * Zod schemas for Activity Log endpoints with security controls:
+ * - Mass assignment prevention (.strict() mode)
+ * - Size limits (title: 200 chars, description: 1000 chars)
+ * - Enum validation (activityType, status)
+ * - Metadata size limits (50KB)
+ */
+
+// Activity type enum
+export const ActivityTypeSchema = z.enum([
+  'workflow_execution',
+  'agent_run',
+  'hitl_action',
+  'webhook_received',
+  'webhook_executed',
+  'webhook_failed',
+  'credential_change',
+  'api_key_change',
+  'deployment_change',
+  'membership_change'
+])
+
+// Activity status enum
+export const ActivityStatusSchema = z.enum(['success', 'failure', 'pending', 'approved', 'rejected', 'completed'])
+
+// Metadata schema with size limit (50KB)
+const MetadataSchema = z
+  .record(z.string(), z.unknown())
+  .refine((val) => JSON.stringify(val).length <= 50_000, 'Metadata exceeds 50KB limit')
+  .optional()
+
+// POST /api/activities - Create activity
+export const CreateActivitySchema = z
+  .object({
+    activityType: ActivityTypeSchema,
+    status: ActivityStatusSchema,
+    title: NonEmptyStringSchema.max(200),
+    description: z.string().max(1000).optional(),
+    entityType: NonEmptyStringSchema.max(100),
+    entityId: NonEmptyStringSchema.max(255),
+    entityName: z.string().max(255).optional(),
+    metadata: MetadataSchema,
+    occurredAt: z.string().datetime().optional(),
+    actorId: z.string().uuid().optional(),
+    actorType: z.enum(['user', 'system', 'api_key']).optional()
+    // NO organizationId (always from JWT/API key context)
+  })
+  .strict()
+
+// GET /api/activities/trend - Activity trend timestamps query params
+export const ActivityTrendQuerySchema = z
+  .object({
+    activityType: ActivityTypeSchema.optional(),
+    entityType: z.string().max(100).optional(),
+    entityId: z.string().max(255).optional(),
+    startDate: z.string().datetime().optional(),
+    endDate: z.string().datetime().optional()
+  })
+  .strict()
+
+// GET /api/activities - List activities query params
+export const ListActivitiesQuerySchema = z
+  .object({
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    offset: z.coerce.number().int().min(0).default(0),
+    activityType: ActivityTypeSchema.optional(),
+    entityType: z.string().max(100).optional(),
+    entityId: z.string().max(255).optional(),
+    startDate: z.string().datetime().optional(),
+    endDate: z.string().datetime().optional(),
+    status: ActivityStatusSchema.optional(),
+    search: z.string().max(200).optional()
+  })
+  .strict()

package/src/operations/activities/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Activity Log types and utilities
+ *
+ * Exports types for activity logging and querying
+ */
+
+export * from './types'
+export * from './api-schemas'
+export * from './sse-events'

package/src/operations/activities/sse-events.ts

@@ -0,0 +1,30 @@
+/**
+ * Activity SSE Event Types
+ *
+ * Type-safe definitions for activity-related SSE events
+ */
+
+import type { Activity } from './types'
+
+/**
+ * Event sent when new activity is created
+ */
+export interface ActivityCreatedEvent {
+  type: 'activity'
+  timestamp: number
+  data: Activity
+}
+
+/**
+ * Connection confirmation event
+ */
+export interface ActivityConnectedEvent {
+  type: 'connected'
+  timestamp: number
+  data?: undefined
+}
+
+/**
+ * Union of all activity SSE events
+ */
+export type ActivitySSEEvent = ActivityCreatedEvent | ActivityConnectedEvent

package/src/operations/activities/types.ts

@@ -0,0 +1,63 @@
+import type { Database } from '../../supabase/database.types'
+
+export type ActivityRow = Database['public']['Tables']['activities']['Row']
+export type ActivityInsert = Database['public']['Tables']['activities']['Insert']
+
+export type ActivityType =
+  | 'workflow_execution'
+  | 'agent_run'
+  | 'hitl_action'
+  | 'webhook_received'
+  | 'webhook_executed'
+  | 'webhook_failed'
+  | 'credential_change'
+  | 'api_key_change'
+  | 'deployment_change'
+  | 'membership_change'
+
+export type ActivityStatus = 'success' | 'failure' | 'pending' | 'approved' | 'rejected' | 'completed'
+
+export interface Activity {
+  id: string
+  organizationId: string
+  activityType: ActivityType
+  status: ActivityStatus
+  title: string
+  description: string | null
+  entityType: string
+  entityId: string
+  entityName: string | null
+  metadata: Record<string, unknown> | null
+  actorId: string | null
+  actorType: string | null
+  occurredAt: Date
+  createdAt: Date
+}
+
+export interface CreateActivityParams {
+  organizationId: string
+  activityType: ActivityType
+  status: ActivityStatus
+  title: string
+  description?: string
+  entityType: string
+  entityId: string
+  entityName?: string
+  metadata?: Record<string, unknown>
+  actorId?: string
+  actorType?: string
+  occurredAt?: Date
+}
+
+export interface ListActivitiesParams {
+  organizationId: string
+  limit?: number
+  offset?: number
+  activityType?: ActivityType
+  entityType?: string
+  entityId?: string
+  startDate?: string
+  endDate?: string
+  status?: string
+  search?: string
+}

package/src/operations/debug-logs/client.ts

@@ -0,0 +1,60 @@
+import type { DebugLogEntry, DebugLogClientOptions, DebugLogLevel } from './types'
+
+/**
+ * Client for fetching debug logs from the API
+ * Used by CLI and other tools to retrieve logs
+ */
+export class DebugLogClient {
+  private apiUrl: string
+  private headers: Record<string, string>
+
+  constructor(options?: DebugLogClientOptions) {
+    this.apiUrl = options?.apiUrl || 'http://localhost:5170'
+    this.headers = options?.headers || {}
+  }
+
+  async getLogs(options?: {
+    limit?: number
+    level?: DebugLogLevel
+    since?: string
+    source?: string
+  }): Promise<DebugLogEntry[]> {
+    const params = new URLSearchParams()
+    params.append('limit', (options?.limit || 100).toString())
+
+    if (options?.level) params.append('level', options.level)
+    if (options?.since) params.append('since', options.since)
+    if (options?.source) params.append('source', options.source)
+
+    try {
+      const response = await global.fetch(`${this.apiUrl}/api/debug-logs?${params}`, {
+        headers: this.headers
+      })
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch logs: ${response.statusText}`)
+      }
+
+      const result = (await response.json()) as { logs?: DebugLogEntry[] }
+      return result.logs || []
+    } catch (error) {
+      console.error('Failed to fetch debug logs:', error)
+      return []
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      const response = await global.fetch(`${this.apiUrl}/api/debug-logs`, {
+        method: 'DELETE',
+        headers: this.headers
+      })
+
+      if (!response.ok) {
+        throw new Error(`Failed to clear logs: ${response.statusText}`)
+      }
+    } catch (error) {
+      console.error('Failed to clear debug logs:', error)
+    }
+  }
+}

package/src/operations/debug-logs/debug-logger.ts

@@ -0,0 +1,83 @@
+/* eslint-disable no-undef */
+import type { DebugLogLevel } from './types'
+
+/**
+ * Simple debug logger for development
+ * Sends logs to the debug-logs API endpoint
+ */
+export class DebugLogger {
+  private apiUrl: string
+  private source?: string
+  private authToken?: string
+
+  constructor(apiUrl = 'http://localhost:5170', source?: string) {
+    this.apiUrl = apiUrl
+    this.source = source
+  }
+
+  setAuthToken(token: string | undefined): void {
+    this.authToken = token
+  }
+
+  /**
+   * Internal log method
+   */
+  private log(level: DebugLogLevel, message: string, data?: Record<string, unknown>): void {
+    // Use globalThis.fetch for universal browser/Node.js compatibility
+    const fetchFn =
+      typeof globalThis !== 'undefined' && globalThis.fetch
+        ? globalThis.fetch
+        : typeof window !== 'undefined' && window.fetch
+          ? window.fetch
+          : typeof global !== 'undefined' && global.fetch
+            ? global.fetch
+            : null
+
+    if (!fetchFn) {
+      // No fetch available, skip logging
+      return
+    }
+
+    // Fire-and-forget HTTP request
+    fetchFn(`${this.apiUrl}/api/debug-logs`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.authToken && { Authorization: `Bearer ${this.authToken}` })
+      },
+      body: JSON.stringify({
+        level,
+        message,
+        source: this.source,
+        data,
+        timestamp: new Date().toISOString()
+      })
+    }).catch(() => {
+      // Silent fail - this is development-only logging
+      // We don't want logging failures to break the app
+    })
+  }
+
+  debug(message: string, data?: Record<string, unknown>): void {
+    this.log('DEBUG', message, data)
+  }
+
+  info(message: string, data?: Record<string, unknown>): void {
+    this.log('INFO', message, data)
+  }
+
+  warn(message: string, data?: Record<string, unknown>): void {
+    this.log('WARN', message, data)
+  }
+
+  error(message: string, data?: Record<string, unknown>): void {
+    this.log('ERROR', message, data)
+  }
+
+  child(childSource: string): DebugLogger {
+    const combinedSource = this.source ? `${this.source}:${childSource}` : childSource
+    const child = new DebugLogger(this.apiUrl, combinedSource)
+    child.authToken = this.authToken
+    return child
+  }
+}

package/src/operations/debug-logs/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Debug Logs Module - Browser-safe exports
+ * Server-only exports (debugLogger instance) available via @repo/core/server
+ */
+
+export * from './types'
+export * from './debug-logger'
+export * from './client'

package/src/operations/debug-logs/server.ts

@@ -0,0 +1,19 @@
+/**
+ * Debug Logs - Server-only exports
+ * Contains debugLogger instance that uses process.env.API_URL
+ */
+
+import { DebugLogger } from './debug-logger'
+
+function getApiUrl(): string {
+  if (typeof process !== 'undefined' && process.env?.API_URL) {
+    return process.env.API_URL
+  }
+  return 'http://localhost:5170'
+}
+
+/**
+ * Default debug logger instance for Node.js environments
+ * Automatically detects production vs development from API_URL env var
+ */
+export const debugLogger = new DebugLogger(getApiUrl(), 'core')

package/src/operations/debug-logs/types.ts

@@ -0,0 +1,33 @@
+/**
+ * Debug log entry structure
+ */
+export interface DebugLogEntry {
+  id?: string
+  timestamp: string
+  level: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'
+  message: string
+  source?: string
+  data?: Record<string, unknown>
+}
+
+/**
+ * Log level type
+ */
+export type DebugLogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'
+
+/**
+ * Query options for retrieving logs
+ */
+export interface DebugLogQueryOptions {
+  limit?: number
+  level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'
+  since?: string
+}
+
+/**
+ * Options for DebugLogClient
+ */
+export interface DebugLogClientOptions {
+  apiUrl?: string
+  headers?: Record<string, string>
+}

package/src/operations/index.ts

@@ -0,0 +1,50 @@
+/**
+ * Operations group barrel - browser-safe exports
+ *
+ * Sessions, notifications, observability, activities, triggers
+ */
+
+// Sessions (types and validation schemas - classes exported via /server)
+export type {
+  SessionTurnResult,
+  SessionTokenUsage,
+  CreateSessionParams,
+  ListSessionsFilters,
+  SessionRow,
+  SessionInsert,
+  SessionMessageRow,
+  SessionMessageInsert,
+  SessionDTO,
+  ChatMessage,
+  MessageType,
+  ExecuteTurnRequest
+} from './sessions/types'
+
+// Session validation schemas
+export {
+  CreateSessionSchema,
+  ExecuteTurnSchema,
+  ListSessionsQuerySchema,
+  SessionIdParamSchema,
+  ExecutionIdParamsSchema,
+  WebSocketSessionTurnSchema,
+  type CreateSessionInput,
+  type ExecuteTurnInput,
+  type ListSessionsQuery,
+  type WebSocketSessionTurnMessage
+} from './sessions'
+
+// Notification types and validation schemas
+export * from './notifications/index'
+
+// Observability types and schemas
+export * from './observability'
+
+// Activity Log types
+export * from './activities/index'
+
+// Triggers (includes webhook providers and trigger definitions)
+export * from './triggers/index'
+
+// Debug Logs
+export * from './debug-logs/index'