@octaviaflow/flow-rules 0.1.0

package/dist/catalog/communication/slack-message/index.js

@@ -0,0 +1,37 @@
+/**
+ * Slack Message Action
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const slackMessageDefinition = {
+    id: 'slack_message',
+    name: 'Slack',
+    description: 'Send messages to Slack channels or users',
+    category: ActionCategory.Communication,
+    type: ActionType.SlackMessage,
+    tags: ['communication', 'slack', 'chat', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'brand:slack',
+    color: '#4A154B',
+    inputSchema: {
+        fields: [
+            { key: 'connection', label: 'Slack Workspace', type: FieldType.Connection, validation: { required: true } },
+            { key: 'channel', label: 'Channel/User', type: FieldType.String, validation: { required: true } },
+            { key: 'message', label: 'Message', type: FieldType.String, validation: { required: true } },
+            { key: 'blocks', label: 'Blocks (JSON)', type: FieldType.JSON, validation: { required: false } },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'success', type: FieldType.Boolean, description: 'Whether message was sent' },
+            { key: 'timestamp', type: FieldType.String, description: 'Message timestamp' },
+        ],
+        sampleOutput: { success: true, timestamp: '1234567890.123456' },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/communication/teams-message/config.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Teams Message Configuration
+ */
+export interface TeamsMessageConfigType {
+    /** Teams connector instance id (OAuth). */
+    connection: string;
+    /** Target team id + human-readable name (for logs/labels). */
+    teamId: string;
+    teamName?: string;
+    /** Target channel id + human-readable name. */
+    channelId: string;
+    channelName?: string;
+    /** Optional message subject. */
+    title?: string;
+    /** Message body. */
+    message: string;
+}
+export declare const TeamsMessageConfig: {
+    defaults: TeamsMessageConfigType;
+    schema: {
+        connection: {
+            type: string;
+            required: boolean;
+        };
+        teamId: {
+            type: string;
+            required: boolean;
+        };
+        channelId: {
+            type: string;
+            required: boolean;
+        };
+        title: {
+            type: string;
+            required: boolean;
+        };
+        message: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<TeamsMessageConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<TeamsMessageConfigType>) => TeamsMessageConfigType;
+    getLabel: (config: TeamsMessageConfigType) => string;
+};

package/dist/catalog/communication/teams-message/config.js

@@ -0,0 +1,29 @@
+/**
+ * Teams Message Configuration
+ */
+export const TeamsMessageConfig = {
+    defaults: { connection: '', teamId: '', teamName: '', channelId: '', channelName: '', title: '', message: '' },
+    schema: {
+        connection: { type: 'connection', required: true },
+        teamId: { type: 'string', required: true },
+        channelId: { type: 'string', required: true },
+        title: { type: 'string', required: false },
+        message: { type: 'string', required: true },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.connection)
+            errors.push('Connect a Microsoft Teams account');
+        if (!config.teamId)
+            errors.push('Pick a team');
+        if (!config.channelId)
+            errors.push('Pick a channel');
+        if (!config.message)
+            errors.push('Add a message');
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...TeamsMessageConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => (config.channelName ? `Teams: #${config.channelName}` : 'Teams'),
+};

package/dist/catalog/communication/teams-message/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Teams Message Action
+ */
+import { ActionDefinition } from '../../types';
+export declare const teamsMessageDefinition: ActionDefinition;

package/dist/catalog/communication/teams-message/index.js

@@ -0,0 +1,39 @@
+/**
+ * Teams Message Action
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const teamsMessageDefinition = {
+    id: 'teams_message',
+    name: 'Teams',
+    description: 'Post messages to Microsoft Teams channels via OAuth 2.0',
+    category: ActionCategory.Communication,
+    type: ActionType.TeamsMessage,
+    tags: ['communication', 'teams', 'microsoft', 'chat', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'brand:teams',
+    color: '#4B53BC',
+    inputSchema: {
+        fields: [
+            { key: 'connection', label: 'Teams Account', type: FieldType.Connection, validation: { required: true } },
+            { key: 'teamId', label: 'Team', type: FieldType.String, validation: { required: true } },
+            { key: 'channelId', label: 'Channel', type: FieldType.String, validation: { required: true } },
+            { key: 'title', label: 'Subject', type: FieldType.String, validation: { required: false } },
+            { key: 'message', label: 'Message', type: FieldType.String, validation: { required: true } },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'ok', type: FieldType.Boolean, description: 'Whether the message was sent' },
+            { key: 'id', type: FieldType.String, description: 'Sent message id' },
+            { key: 'webUrl', type: FieldType.String, description: 'Deep link to the message' },
+        ],
+        sampleOutput: { ok: true, id: '1700000000000', webUrl: 'https://teams.microsoft.com/l/message/...' },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/communication/webhook-call/config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Webhook Call Configuration
+ */
+export interface WebhookCallConfigType {
+    url: string;
+    method: 'POST' | 'PUT' | 'PATCH' | 'GET';
+    payload?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+export declare const WebhookCallConfig: {
+    defaults: WebhookCallConfigType;
+    schema: {
+        url: {
+            type: string;
+            required: boolean;
+        };
+        method: {
+            type: string;
+            required: boolean;
+        };
+        payload: {
+            type: string;
+            required: boolean;
+        };
+        headers: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<WebhookCallConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<WebhookCallConfigType>) => WebhookCallConfigType;
+    getLabel: (config: WebhookCallConfigType) => string;
+};

package/dist/catalog/communication/webhook-call/config.js

@@ -0,0 +1,31 @@
+/**
+ * Webhook Call Configuration
+ */
+export const WebhookCallConfig = {
+    defaults: {
+        url: '',
+        method: 'POST',
+        payload: {},
+        headers: {},
+    },
+    schema: {
+        url: { type: 'url', required: true },
+        method: { type: 'select', required: true },
+        payload: { type: 'json', required: false },
+        headers: { type: 'json', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.url)
+            errors.push('Webhook URL is required');
+        if (!config.method)
+            errors.push('HTTP method is required');
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...WebhookCallConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        return `${config.method}: ${config.url.substring(0, 40)}...`;
+    },
+};

package/dist/catalog/communication/webhook-call/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Webhook Call Action
+ */
+import { ActionDefinition } from '../../types';
+export declare const webhookCallDefinition: ActionDefinition;

package/dist/catalog/communication/webhook-call/index.js

@@ -0,0 +1,43 @@
+/**
+ * Webhook Call Action
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const webhookCallDefinition = {
+    id: 'webhook_call',
+    name: 'Webhook Call',
+    description: 'Call external webhooks with custom payloads',
+    category: ActionCategory.Communication,
+    type: ActionType.WebhookCall,
+    tags: ['communication', 'webhook', 'http', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Webhook',
+    color: '#0043ce',
+    inputSchema: {
+        fields: [
+            { key: 'url', label: 'Webhook URL', type: FieldType.URL, validation: { required: true } },
+            { key: 'method', label: 'Method', type: FieldType.Select, options: [
+                    { label: 'POST', value: 'POST' },
+                    { label: 'PUT', value: 'PUT' },
+                    { label: 'PATCH', value: 'PATCH' },
+                    { label: 'GET', value: 'GET' },
+                ], defaultValue: 'POST', validation: { required: true } },
+            { key: 'payload', label: 'Payload', type: FieldType.JSON, validation: { required: false } },
+            { key: 'headers', label: 'Headers', type: FieldType.JSON, validation: { required: false } },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'statusCode', type: FieldType.Number, description: 'HTTP status code' },
+            { key: 'response', type: FieldType.JSON, description: 'Response body' },
+            { key: 'success', type: FieldType.Boolean, description: 'Whether call succeeded' },
+        ],
+        sampleOutput: { statusCode: 200, response: {}, success: true },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/communication/whatsapp-send/config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * WhatsApp Send — config contract (DEV-285)
+ */
+export interface WhatsappSendConfigType {
+    connection: string;
+    to: string;
+    mode: 'template' | 'text';
+    templateName?: string;
+    templateLanguage?: string;
+    /** Positional body variables, in {{1}}, {{2}} order. */
+    templateVariables?: string[];
+    text?: string;
+    previewUrl?: boolean;
+}
+export declare const WhatsappSendConfig: {
+    defaults: WhatsappSendConfigType;
+    validate: (config: Partial<WhatsappSendConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<WhatsappSendConfigType>) => WhatsappSendConfigType;
+    getLabel: (config: WhatsappSendConfigType) => string;
+};

package/dist/catalog/communication/whatsapp-send/config.js

@@ -0,0 +1,36 @@
+/**
+ * WhatsApp Send — config contract (DEV-285)
+ */
+export const WhatsappSendConfig = {
+    // Template is the default because it is the mode that always delivers;
+    // freeform silently depends on a 24-hour window the author can't see.
+    defaults: {
+        connection: '',
+        to: '',
+        mode: 'template',
+        templateLanguage: 'en_US',
+        templateVariables: [],
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.connection)
+            errors.push('Select a WhatsApp connection');
+        if (!config.to?.trim())
+            errors.push('Recipient phone number is required');
+        if (config.mode === 'text') {
+            if (!config.text?.trim())
+                errors.push('Message text is required');
+        }
+        else {
+            if (!config.templateName?.trim())
+                errors.push('Choose an approved template');
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...WhatsappSendConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => config.mode === 'text'
+        ? `WhatsApp to ${config.to || '—'}`
+        : `WhatsApp template "${config.templateName || '—'}" to ${config.to || '—'}`,
+};

package/dist/catalog/communication/whatsapp-send/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WhatsApp Send Action (DEV-285)
+ *
+ * Two modes, because WhatsApp has two genuinely different sends:
+ *   template — the ONLY thing that delivers outside the 24-hour
+ *              customer-service window. Meta charges by the template's
+ *              CATEGORY (Marketing costs ~6× Utility), so the picker shows it.
+ *   text     — freeform; delivers only within 24 hours of the contact's last
+ *              inbound message.
+ *
+ * A single "message" box would look like it works in testing and then fail
+ * the next day — which is why mode is an explicit, required choice.
+ */
+import { ActionDefinition } from '../../types';
+export declare const whatsappSendDefinition: ActionDefinition;

package/dist/catalog/communication/whatsapp-send/index.js

@@ -0,0 +1,57 @@
+/**
+ * WhatsApp Send Action (DEV-285)
+ *
+ * Two modes, because WhatsApp has two genuinely different sends:
+ *   template — the ONLY thing that delivers outside the 24-hour
+ *              customer-service window. Meta charges by the template's
+ *              CATEGORY (Marketing costs ~6× Utility), so the picker shows it.
+ *   text     — freeform; delivers only within 24 hours of the contact's last
+ *              inbound message.
+ *
+ * A single "message" box would look like it works in testing and then fail
+ * the next day — which is why mode is an explicit, required choice.
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const whatsappSendDefinition = {
+    id: 'whatsapp_send',
+    name: 'WhatsApp',
+    description: 'Send a WhatsApp message — an approved template, or freeform text inside the 24-hour reply window',
+    category: ActionCategory.Communication,
+    type: ActionType.WhatsappSend,
+    tags: ['communication', 'whatsapp', 'messaging', 'template', 'built-in'],
+    status: ActionStatus.Beta,
+    icon: 'brand:whatsapp',
+    color: '#25D366',
+    inputSchema: {
+        fields: [
+            { key: 'connection', label: 'WhatsApp Connection', type: FieldType.Connection, validation: { required: true } },
+            { key: 'to', label: 'To (phone number)', type: FieldType.String, validation: { required: true } },
+            { key: 'mode', label: 'Message Type', type: FieldType.Select, validation: { required: true } },
+            { key: 'templateName', label: 'Template', type: FieldType.String, validation: { required: false } },
+            { key: 'templateLanguage', label: 'Template Language', type: FieldType.String, validation: { required: false } },
+            { key: 'templateVariables', label: 'Template Variables', type: FieldType.JSON, validation: { required: false } },
+            { key: 'text', label: 'Message', type: FieldType.String, validation: { required: false } },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'ok', type: FieldType.Boolean, description: 'Whether WhatsApp accepted the message' },
+            { key: 'messageId', type: FieldType.String, description: 'WhatsApp message ID (wamid…)' },
+            { key: 'waId', type: FieldType.String, description: "Recipient's resolved WhatsApp ID" },
+            { key: 'mode', type: FieldType.String, description: 'template | text' },
+        ],
+        sampleOutput: {
+            ok: true,
+            messageId: 'wamid.HBgMOTE4ODAyODg1MTQ1FQIAERgSN0YxN0E5RkQ5MEQ4RkE5QzFEAA==',
+            waId: '919876543210',
+            mode: 'template',
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2026-07-30T00:00:00Z',
+    updatedAt: '2026-07-30T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/general/query/config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Build Query Configuration
+ *
+ * Configuration utilities and validation for the Build Query action
+ * Supports dual modes: Visual Builder (no-code) and SQL Editor (advanced)
+ */
+import { BuildQueryConfig, QueryMode, QueryType, QueryValidationResult, VisualQueryConfig, SQLQueryConfig } from './types';
+export declare const BuildQueryConfigDefaults: {
+    mode: QueryMode;
+    queryType: QueryType;
+    timeout: number;
+    maxRows: number;
+    visualConfig: VisualQueryConfig;
+    sqlConfig: SQLQueryConfig;
+};
+/**
+ * Validate Build Query configuration
+ */
+export declare const validateBuildQueryConfig: (config: Partial<BuildQueryConfig>) => QueryValidationResult;
+/**
+ * Merge user config with defaults
+ */
+export declare const mergeBuildQueryConfig: (userConfig: Partial<BuildQueryConfig>) => BuildQueryConfig;
+/**
+ * Get display label for configuration
+ */
+export declare const getBuildQueryLabel: (config: BuildQueryConfig) => string;
+/**
+ * Check if a connector is queryable (excludes storage-type connectors)
+ * Uses the isQueryable flag from connector metadata if available
+ */
+export declare function isQueryableConnector(connector: {
+    type?: string;
+    category?: string;
+    isQueryable?: boolean;
+}): boolean;