@elevasis/core 0.1.0

package/src/operations/triggers/webhook/definitions/instantly-auto-reply-received.ts

@@ -0,0 +1,51 @@
+/**
+ * Instantly Auto Reply Received Trigger Definition
+ *
+ * Webhook trigger for Instantly auto-reply email events.
+ * Uses Instantly's native snake_case format - no transformation needed.
+ */
+
+import type { TriggerDefinition, WebhookTriggerConfig } from '../../../../platform/registry/types'
+
+/**
+ * Instantly auto reply received webhook payload structure
+ *
+ * Uses snake_case matching Instantly's API. Workflows receive this directly.
+ */
+export interface InstantlyAutoReplyReceivedPayload {
+  timestamp: string
+  event_type: 'auto_reply_received'
+  workspace: string
+  campaign_id: string
+  campaign_name?: string
+  lead_email: string
+  email_account: string
+  reply_subject?: string
+  reply_text?: string
+  reply_text_snippet?: string
+  step?: number
+  variant?: number
+}
+
+/**
+ * Instantly Auto Reply Received Trigger Definition
+ *
+ * Trigger type: webhook
+ * Provider: instantly
+ * Event: auto_reply_received
+ */
+export const instantlyAutoReplyReceivedTrigger: TriggerDefinition = {
+  resourceId: 'trigger-instantly-auto-reply-received',
+  type: 'trigger',
+  triggerType: 'webhook',
+  name: 'Instantly Auto Reply Received',
+  description:
+    'Webhook fired when an automated reply (out-of-office, auto-responder) is received for an Instantly campaign email',
+  version: '1.0.0',
+  status: 'dev',
+  webhookPath: '/webhooks/instantly/auto-reply-received',
+  config: {
+    provider: 'instantly',
+    event: 'auto_reply_received'
+  } as WebhookTriggerConfig
+}

package/src/operations/triggers/webhook/definitions/instantly-campaign-completed.ts

@@ -0,0 +1,45 @@
+/**
+ * Instantly Campaign Completed Trigger Definition
+ *
+ * Webhook trigger for Instantly campaign completion events.
+ * Uses Instantly's native snake_case format - no transformation needed.
+ */
+
+import type { TriggerDefinition, WebhookTriggerConfig } from '../../../../platform/registry/types'
+
+/**
+ * Instantly campaign completed webhook payload structure
+ *
+ * Uses snake_case matching Instantly's API. Workflows receive this directly.
+ */
+export interface InstantlyCampaignCompletedPayload {
+  timestamp: string
+  event_type: 'campaign_completed'
+  workspace: string
+  campaign_id: string
+  campaign_name?: string
+  total_leads?: number
+  total_sent?: number
+}
+
+/**
+ * Instantly Campaign Completed Trigger Definition
+ *
+ * Trigger type: webhook
+ * Provider: instantly
+ * Event: campaign_completed
+ */
+export const instantlyCampaignCompletedTrigger: TriggerDefinition = {
+  resourceId: 'trigger-instantly-campaign-completed',
+  type: 'trigger',
+  triggerType: 'webhook',
+  name: 'Instantly Campaign Completed',
+  description: 'Webhook fired when an Instantly email campaign finishes sending to all leads',
+  version: '1.0.0',
+  status: 'dev',
+  webhookPath: '/webhooks/instantly/campaign-completed',
+  config: {
+    provider: 'instantly',
+    event: 'campaign_completed'
+  } as WebhookTriggerConfig
+}

package/src/operations/triggers/webhook/definitions/instantly-email-bounced.ts

@@ -0,0 +1,49 @@
+/**
+ * Instantly Email Bounced Trigger Definition
+ *
+ * Webhook trigger for Instantly email bounce events.
+ * Uses Instantly's native snake_case format - no transformation needed.
+ */
+
+import type { TriggerDefinition, WebhookTriggerConfig } from '../../../../platform/registry/types'
+
+/**
+ * Instantly email bounced webhook payload structure
+ *
+ * Uses snake_case matching Instantly's API. Workflows receive this directly.
+ */
+export interface InstantlyEmailBouncedPayload {
+  timestamp: string
+  event_type: 'email_bounced'
+  workspace: string
+  campaign_id: string
+  campaign_name?: string
+  lead_email: string
+  email_account: string
+  bounce_type?: string
+  bounce_reason?: string
+  step?: number
+  variant?: number
+}
+
+/**
+ * Instantly Email Bounced Trigger Definition
+ *
+ * Trigger type: webhook
+ * Provider: instantly
+ * Event: email_bounced
+ */
+export const instantlyEmailBouncedTrigger: TriggerDefinition = {
+  resourceId: 'trigger-instantly-email-bounced',
+  type: 'trigger',
+  triggerType: 'webhook',
+  name: 'Instantly Email Bounced',
+  description: 'Webhook fired when an email sent from an Instantly campaign bounces',
+  version: '1.0.0',
+  status: 'dev',
+  webhookPath: '/webhooks/instantly/email-bounced',
+  config: {
+    provider: 'instantly',
+    event: 'email_bounced'
+  } as WebhookTriggerConfig
+}

package/src/operations/triggers/webhook/definitions/instantly-lead-unsubscribed.ts

@@ -0,0 +1,45 @@
+/**
+ * Instantly Lead Unsubscribed Trigger Definition
+ *
+ * Webhook trigger for Instantly lead unsubscribe events.
+ * Uses Instantly's native snake_case format - no transformation needed.
+ */
+
+import type { TriggerDefinition, WebhookTriggerConfig } from '../../../../platform/registry/types'
+
+/**
+ * Instantly lead unsubscribed webhook payload structure
+ *
+ * Uses snake_case matching Instantly's API. Workflows receive this directly.
+ */
+export interface InstantlyLeadUnsubscribedPayload {
+  timestamp: string
+  event_type: 'lead_unsubscribed'
+  workspace: string
+  campaign_id: string
+  campaign_name?: string
+  lead_email: string
+  email_account: string
+}
+
+/**
+ * Instantly Lead Unsubscribed Trigger Definition
+ *
+ * Trigger type: webhook
+ * Provider: instantly
+ * Event: lead_unsubscribed
+ */
+export const instantlyLeadUnsubscribedTrigger: TriggerDefinition = {
+  resourceId: 'trigger-instantly-lead-unsubscribed',
+  type: 'trigger',
+  triggerType: 'webhook',
+  name: 'Instantly Lead Unsubscribed',
+  description: 'Webhook fired when a lead unsubscribes from an Instantly email campaign',
+  version: '1.0.0',
+  status: 'dev',
+  webhookPath: '/webhooks/instantly/lead-unsubscribed',
+  config: {
+    provider: 'instantly',
+    event: 'lead_unsubscribed'
+  } as WebhookTriggerConfig
+}

package/src/operations/triggers/webhook/definitions/instantly-reply-received.ts

@@ -0,0 +1,54 @@
+/**
+ * Instantly Reply Received Trigger Definition
+ *
+ * Webhook trigger for Instantly email reply events.
+ * Uses Instantly's native snake_case format - no transformation needed.
+ */
+
+import type { TriggerDefinition, WebhookTriggerConfig } from '../../../../platform/registry/types'
+
+/**
+ * Instantly webhook payload structure
+ *
+ * Uses snake_case matching Instantly's API. Workflows receive this directly.
+ */
+export interface InstantlyReplyWebhookPayload {
+  timestamp: string
+  event_type: 'reply_received'
+  workspace: string
+  campaign_id: string
+  campaign_name?: string
+  lead_email: string
+  email_account: string
+  unibox_url: string
+  reply_to_uuid: string
+  reply_subject: string
+  reply_text: string
+  reply_text_snippet: string
+  reply_html: string
+  step: number
+  variant: number
+  is_first: boolean
+}
+
+/**
+ * Instantly Reply Received Trigger Definition
+ *
+ * Trigger type: webhook
+ * Provider: instantly
+ * Event: reply_received
+ */
+export const instantlyReplyReceivedTrigger: TriggerDefinition = {
+  resourceId: 'trigger-instantly-reply-received',
+  type: 'trigger',
+  triggerType: 'webhook',
+  name: 'Instantly Reply Received',
+  description: 'Webhook fired when a lead replies to an Instantly email campaign',
+  version: '1.0.0',
+  status: 'dev',
+  webhookPath: '/webhooks/instantly/reply-received',
+  config: {
+    provider: 'instantly',
+    event: 'reply_received'
+  } as WebhookTriggerConfig
+}

package/src/operations/triggers/webhook/index.ts

@@ -0,0 +1,35 @@
+/**
+ * Webhook Triggers Module
+ *
+ * Webhooks are a type of trigger that start workflow executions
+ * when external services send HTTP requests to Elevasis.
+ *
+ * This module contains:
+ * - Provider interface for webhook signature validation (types only)
+ * - Trigger definitions for specific webhook events
+ *
+ * Note: Provider IMPLEMENTATIONS live in apps/api/src/webhooks/providers/
+ */
+
+// Provider interface and types (contract only - implementations in apps/api)
+export type { WebhookProvider, WebhookValidationResult } from './types'
+
+// Webhook trigger definitions
+export {
+  instantlyReplyReceivedTrigger,
+  type InstantlyReplyWebhookPayload
+} from './definitions/instantly-reply-received'
+export { instantlyEmailBouncedTrigger, type InstantlyEmailBouncedPayload } from './definitions/instantly-email-bounced'
+export {
+  instantlyLeadUnsubscribedTrigger,
+  type InstantlyLeadUnsubscribedPayload
+} from './definitions/instantly-lead-unsubscribed'
+export {
+  instantlyCampaignCompletedTrigger,
+  type InstantlyCampaignCompletedPayload
+} from './definitions/instantly-campaign-completed'
+export { instantlyAccountErrorTrigger, type InstantlyAccountErrorPayload } from './definitions/instantly-account-error'
+export {
+  instantlyAutoReplyReceivedTrigger,
+  type InstantlyAutoReplyReceivedPayload
+} from './definitions/instantly-auto-reply-received'

package/src/operations/triggers/webhook/types.ts

@@ -0,0 +1,74 @@
+/**
+ * Webhook Trigger type definitions
+ *
+ * These types define the contract for webhook providers that validate
+ * signatures from external services (Cal.com, Fillout, Stripe, Instantly, etc.)
+ *
+ * Webhooks are a type of trigger - they start workflow executions
+ * when external services send HTTP requests to Elevasis.
+ *
+ * Note: Provider IMPLEMENTATIONS live in apps/api/src/webhooks/providers/
+ * This file only contains the interface contract.
+ */
+
+import type { WebhookProviderType } from '../../../platform/registry/types'
+
+/**
+ * Result of webhook signature validation
+ */
+export interface WebhookValidationResult {
+  /** Whether the signature is valid */
+  isValid: boolean
+  /** Parsed payload if validation succeeded */
+  payload?: unknown
+  /** Error message if validation failed */
+  error?: string
+}
+
+/**
+ * Webhook provider interface
+ *
+ * Each provider implements signature validation specific to their
+ * webhook format (e.g., HMAC-SHA256 for Cal.com and Fillout).
+ *
+ * @example
+ * ```typescript
+ * class CalComProvider implements WebhookProvider {
+ *   readonly providerId = 'cal-com' as const
+ *
+ *   async validateSignature(rawBody, headers, secret) {
+ *     // HMAC-SHA256 validation
+ *   }
+ *
+ *   getEventType(payload) {
+ *     return payload.triggerEvent // e.g., 'BOOKING_CREATED'
+ *   }
+ * }
+ * ```
+ */
+export interface WebhookProvider {
+  /** Provider identifier (e.g., 'cal-com', 'fillout', 'stripe') */
+  readonly providerId: WebhookProviderType
+
+  /**
+   * Validate webhook signature and return parsed payload
+   *
+   * @param rawBody - Raw request body as string (before JSON parsing)
+   * @param headers - Request headers (lowercase keys)
+   * @param secret - Webhook signing secret from credentials
+   * @returns Validation result with parsed payload or error
+   */
+  validateSignature(
+    rawBody: string,
+    headers: Record<string, string>,
+    secret: string
+  ): Promise<WebhookValidationResult>
+
+  /**
+   * Extract event type from validated payload
+   *
+   * @param payload - Parsed webhook payload (from validateSignature)
+   * @returns Provider-specific event type (e.g., 'BOOKING_CREATED', 'invoice.paid')
+   */
+  getEventType(payload: unknown): string
+}

package/src/organization-model/README.md

@@ -0,0 +1,79 @@
+# Organization Model
+
+The organization model is the published semantic contract that maps a tenant's product shape to domain surfaces, features, and navigation.
+
+Use this module when you need to resolve or validate an organization's contract before wiring UI shells, routing, or domain-specific capability checks.
+
+## Published Exports
+
+The public entry point exposes:
+
+- `OrganizationModelSchema`
+- `DEFAULT_ORGANIZATION_MODEL`
+- `defineOrganizationModel`
+- `resolveOrganizationModel`
+- `OrganizationModel` and the supporting domain types
+
+Import it from the published subpath:
+
+```ts
+import {
+  DEFAULT_ORGANIZATION_MODEL,
+  defineOrganizationModel,
+  resolveOrganizationModel,
+  type OrganizationModel
+} from '@elevasis/core/organization-model'
+```
+
+## Contract Shape
+
+The model is versioned and currently validates against `version: 1`.
+
+Top-level fields:
+
+- `domains` - semantic domain entries that bind entity IDs, surface IDs, resource IDs, and capability IDs.
+- `branding` - organization branding defaults and overrides.
+- `features` - feature flags and labels for the shell.
+- `navigation` - navigation model for the product shell.
+- `crm` - CRM-specific contract data.
+- `leadGen` - lead generation contract data.
+- `delivery` - delivery and project contract data.
+- `resourceMappings` - cross-surface resource mappings.
+
+## Default Domain Set
+
+The default model includes four semantic domains:
+
+- `crm` - deal pipeline and relationship management.
+- `lead-gen` - lists, companies, and contacts.
+- `delivery` - projects, milestones, and tasks.
+- `operations` - organization graph and command-view surfaces.
+
+## Feature Keys
+
+The current feature keys are:
+
+- `acquisition`
+- `delivery`
+- `operations`
+- `monitoring`
+- `settings`
+- `seo`
+- `calibration`
+
+Each feature can carry an enabled flag and an optional label override.
+
+## Resolution Semantics
+
+- `defineOrganizationModel()` is a typed helper. It does not validate or merge anything by itself.
+- `resolveOrganizationModel()` deep-merges a partial override into the default model, then validates the result with `OrganizationModelSchema`.
+- Plain objects merge recursively.
+- Arrays replace the default value instead of merging element-by-element.
+- Missing fields fall back to `DEFAULT_ORGANIZATION_MODEL`.
+
+## Practical Guidance
+
+- Use `resolveOrganizationModel()` when you need a runtime-safe model for rendering or policy checks.
+- Use `defineOrganizationModel()` when authoring a static partial model in source.
+- Keep domain IDs, surface IDs, and capability IDs stable because downstream UI and policy code depend on them.
+

package/src/organization-model/__tests__/graph.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, it } from 'vitest'
+import { buildOrganizationGraph } from '../graph'
+import { defineOrganizationModel, resolveOrganizationModel } from '../resolve'
+
+describe('organization-graph', () => {
+  it('derives semantic graph nodes and edges from the organization model', () => {
+    const model = resolveOrganizationModel(
+      defineOrganizationModel({
+        branding: {
+          organizationName: 'Acme',
+          productName: 'Acme OS',
+          shortName: 'Acme'
+        }
+      })
+    )
+
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(graph.version).toBe(1)
+    expect(graph.organizationModelVersion).toBe(1)
+
+    const feature = graph.nodes.find((node) => node.id === 'feature:operations')
+    expect(feature).toMatchObject({
+      kind: 'feature',
+      sourceId: 'operations',
+      label: 'Operations',
+      enabled: true,
+      featureKey: 'operations'
+    })
+
+    const disabledFeature = graph.nodes.find((node) => node.id === 'feature:seo')
+    expect(disabledFeature).toMatchObject({
+      kind: 'feature',
+      sourceId: 'seo',
+      enabled: false
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'domain:crm')).toMatchObject({
+      kind: 'domain',
+      sourceId: 'crm',
+      label: 'CRM'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'surface:crm.pipeline')).toMatchObject({
+      kind: 'surface',
+      sourceId: 'crm.pipeline',
+      surfaceType: 'graph'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'entity:crm.deal')).toMatchObject({
+      kind: 'entity',
+      sourceId: 'crm.deal',
+      label: 'crm.deal'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'capability:crm.pipeline.manage')).toMatchObject({
+      kind: 'capability',
+      sourceId: 'crm.pipeline.manage',
+      label: 'crm.pipeline.manage'
+    })
+
+    expect(graph.edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: 'contains',
+          sourceId: 'organization-model',
+          targetId: 'domain:crm'
+        }),
+        expect.objectContaining({
+          kind: 'exposes',
+          sourceId: 'feature:acquisition',
+          targetId: 'surface:crm.pipeline'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'surface:crm.pipeline',
+          targetId: 'domain:crm'
+        })
+      ])
+    )
+  })
+
+  it('bridges command view topology into resource nodes and labeled relationship edges', () => {
+    const model = resolveOrganizationModel(
+      defineOrganizationModel({
+        resourceMappings: [
+          {
+            id: 'workflow-order-model',
+            label: 'Order Workflow Model',
+            resourceId: 'workflow-order',
+            resourceType: 'workflow',
+            domainIds: ['operations'],
+            entityIds: [],
+            surfaceIds: ['operations.command-view'],
+            capabilityIds: []
+          }
+        ]
+      })
+    )
+
+    const graph = buildOrganizationGraph({
+      organizationModel: model,
+      commandViewData: {
+        workflows: [
+          {
+            resourceId: 'workflow-order',
+            name: 'Order Workflow Runtime',
+            description: 'Runtime workflow surfaced by Command View',
+            version: '1.0.0',
+            type: 'workflow',
+            status: 'prod',
+            domains: ['operations'],
+            stepCount: 3,
+            entryPoint: 'start'
+          }
+        ],
+        agents: [
+          {
+            resourceId: 'agent-order',
+            name: 'Order Agent Runtime',
+            description: 'Runtime agent surfaced by Command View',
+            version: '1.0.0',
+            type: 'agent',
+            status: 'prod',
+            domains: ['operations'],
+            modelProvider: 'openai',
+            modelId: 'gpt-4.1',
+            toolCount: 2,
+            hasKnowledgeMap: true,
+            hasMemory: false,
+            sessionCapable: true
+          }
+        ],
+        triggers: [],
+        integrations: [
+          {
+            resourceId: 'integration-stripe',
+            name: 'Stripe Runtime',
+            description: 'Runtime integration surfaced by Command View',
+            version: '1.0.0',
+            type: 'integration',
+            status: 'prod',
+            domains: ['operations'],
+            provider: 'stripe',
+            credentialName: 'stripe-prod'
+          }
+        ],
+        externalResources: [],
+        humanCheckpoints: [
+          {
+            resourceId: 'approval-high-value',
+            name: 'High Value Approval',
+            description: 'Runtime human checkpoint surfaced by Command View',
+            version: '1.0.0',
+            type: 'human',
+            status: 'prod',
+            domains: ['operations']
+          }
+        ],
+        edges: [
+          {
+            id: 'edge-runtime-triggers',
+            source: 'agent-order',
+            target: 'workflow-order',
+            relationship: 'triggers'
+          },
+          {
+            id: 'edge-runtime-uses',
+            source: 'workflow-order',
+            target: 'integration-stripe',
+            relationship: 'uses'
+          },
+          {
+            id: 'edge-runtime-approval',
+            source: 'workflow-order',
+            target: 'approval-high-value',
+            relationship: 'approval'
+          }
+        ]
+      }
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:workflow-order')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'workflow-order',
+      resourceType: 'workflow',
+      label: 'Order Workflow Model'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:agent-order')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'agent-order',
+      resourceType: 'agent',
+      label: 'Order Agent Runtime'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:approval-high-value')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'approval-high-value',
+      resourceType: 'human_checkpoint',
+      label: 'High Value Approval'
+    })
+
+    expect(graph.edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: 'contains',
+          sourceId: 'organization-model',
+          targetId: 'resource:agent-order'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:agent-order',
+          targetId: 'domain:operations'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:agent-order',
+          targetId: 'resource:workflow-order',
+          label: 'triggers',
+          relationshipType: 'triggers'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:workflow-order',
+          targetId: 'resource:integration-stripe',
+          label: 'uses',
+          relationshipType: 'uses'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:workflow-order',
+          targetId: 'resource:approval-high-value',
+          label: 'approval',
+          relationshipType: 'approval'
+        }),
+        expect.objectContaining({
+          kind: 'maps_to',
+          sourceId: 'resource:workflow-order',
+          targetId: 'domain:operations'
+        }),
+        expect.objectContaining({
+          kind: 'maps_to',
+          sourceId: 'resource:workflow-order',
+          targetId: 'surface:operations.command-view'
+        })
+      ])
+    )
+  })
+})