@octaviaflow/flow-rules 0.1.0

package/dist/catalog/api/graphql-query/config.js

@@ -0,0 +1,31 @@
+/**
+ * GraphQL Query Configuration
+ */
+export const GraphQLQueryConfig = {
+    defaults: {
+        endpoint: '',
+        query: '',
+        variables: {},
+        headers: {},
+    },
+    schema: {
+        endpoint: { type: 'url', required: true },
+        query: { type: 'code', required: true },
+        variables: { type: 'json', required: false },
+        headers: { type: 'json', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.endpoint)
+            errors.push('Endpoint is required');
+        if (!config.query)
+            errors.push('Query is required');
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...GraphQLQueryConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        return `GraphQL: ${config.endpoint}`;
+    },
+};

package/dist/catalog/api/graphql-query/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GraphQL Query Action
+ *
+ * Execute GraphQL queries against GraphQL endpoints
+ */
+import { ActionDefinition } from '../../types';
+export declare const graphqlQueryDefinition: ActionDefinition;

package/dist/catalog/api/graphql-query/index.js

@@ -0,0 +1,75 @@
+/**
+ * GraphQL Query Action
+ *
+ * Execute GraphQL queries against GraphQL endpoints
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const graphqlQueryDefinition = {
+    id: 'graphql_query',
+    name: 'GraphQL Query',
+    description: 'Execute GraphQL queries against GraphQL endpoints',
+    category: ActionCategory.API,
+    type: ActionType.GraphQLQuery,
+    tags: ['api', 'graphql', 'query', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'GraphQL',
+    color: '#0043ce',
+    inputSchema: {
+        fields: [
+            {
+                key: 'endpoint',
+                label: 'GraphQL Endpoint',
+                type: FieldType.URL,
+                description: 'GraphQL endpoint URL',
+                validation: { required: true },
+            },
+            {
+                key: 'query',
+                label: 'Query',
+                type: FieldType.Code,
+                description: 'GraphQL query',
+                language: 'json',
+                validation: { required: true },
+            },
+            {
+                key: 'variables',
+                label: 'Variables',
+                type: FieldType.JSON,
+                description: 'Query variables',
+                validation: { required: false },
+            },
+            {
+                key: 'headers',
+                label: 'Headers',
+                type: FieldType.JSON,
+                description: 'HTTP headers',
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'data',
+                type: FieldType.JSON,
+                description: 'Query result data',
+            },
+            {
+                key: 'errors',
+                type: FieldType.Array,
+                description: 'GraphQL errors',
+            },
+        ],
+        sampleOutput: {
+            data: { user: { id: '1', name: 'John' } },
+            errors: [],
+        },
+    },
+    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/email-send/config.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Email Configuration
+ *
+ * Only `send` runs today. The other operation values stay in the type so a
+ * step saved before DEV-349 still parses — but `validate` rejects them, so the
+ * editor shows an error instead of the Engine skipping the step silently.
+ */
+export interface EmailConfigType {
+    connection: string;
+    operation: 'send' | 'read' | 'search' | 'delete' | 'move' | 'mark_read';
+    to?: string;
+    cc?: string;
+    bcc?: string;
+    subject?: string;
+    body?: string;
+    isHtml?: boolean;
+    attachments?: string[];
+    folder?: string;
+    query?: string;
+    limit?: number;
+}
+export declare const EmailConfig: {
+    defaults: EmailConfigType;
+    schema: {
+        connection: {
+            type: string;
+            required: boolean;
+        };
+        operation: {
+            type: string;
+            required: boolean;
+        };
+        to: {
+            type: string;
+            required: boolean;
+        };
+        cc: {
+            type: string;
+            required: boolean;
+        };
+        bcc: {
+            type: string;
+            required: boolean;
+        };
+        subject: {
+            type: string;
+            required: boolean;
+        };
+        body: {
+            type: string;
+            required: boolean;
+        };
+        isHtml: {
+            type: string;
+            required: boolean;
+        };
+        attachments: {
+            type: string;
+            required: boolean;
+        };
+        folder: {
+            type: string;
+            required: boolean;
+        };
+        query: {
+            type: string;
+            required: boolean;
+        };
+        limit: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<EmailConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<EmailConfigType>) => EmailConfigType;
+    getLabel: (config: EmailConfigType) => string;
+};

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

@@ -0,0 +1,80 @@
+/**
+ * Email Configuration
+ *
+ * Only `send` runs today. The other operation values stay in the type so a
+ * step saved before DEV-349 still parses — but `validate` rejects them, so the
+ * editor shows an error instead of the Engine skipping the step silently.
+ */
+export const EmailConfig = {
+    defaults: {
+        connection: '',
+        operation: 'send',
+        to: '',
+        cc: '',
+        bcc: '',
+        subject: '',
+        body: '',
+        isHtml: false,
+        attachments: [],
+        folder: 'Inbox',
+        query: '',
+        limit: 10,
+    },
+    schema: {
+        connection: { type: 'connection', required: true },
+        operation: { type: 'select', required: true },
+        to: { type: 'string', required: false },
+        cc: { type: 'string', required: false },
+        bcc: { type: 'string', required: false },
+        subject: { type: 'string', required: false },
+        body: { type: 'string', required: false },
+        isHtml: { type: 'boolean', required: false },
+        attachments: { type: 'array', required: false },
+        folder: { type: 'string', required: false },
+        query: { type: 'string', required: false },
+        limit: { type: 'number', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.connection)
+            errors.push('Email service connection is required');
+        if (!config.operation)
+            errors.push('Operation is required');
+        // Validate operation-specific requirements
+        if (config.operation === 'send') {
+            if (!config.to)
+                errors.push('Recipient email is required for send operation');
+            if (!config.subject)
+                errors.push('Subject is required for send operation');
+            if (!config.body)
+                errors.push('Body is required for send operation');
+        }
+        else if (config.operation) {
+            // Read / Search / Delete / Move / Mark-as-read are not implemented by
+            // the Engine (DEV-349). Fail here so the step cannot be saved as valid.
+            errors.push('Only Send is available for the Email action right now');
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...EmailConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        switch (config.operation) {
+            case 'send':
+                return `Email: Send to ${config.to}`;
+            case 'read':
+                return `Email: Read from ${config.folder}`;
+            case 'search':
+                return `Email: Search "${config.query}"`;
+            case 'delete':
+                return `Email: Delete from ${config.folder}`;
+            case 'move':
+                return `Email: Move to ${config.folder}`;
+            case 'mark_read':
+                return `Email: Mark as read`;
+            default:
+                return `Email: ${config.operation}`;
+        }
+    },
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Email Action
+ *
+ * Sends an email through a connected email service. Send is the only
+ * operation the Engine implements; the Read / Search / Delete / Move /
+ * Mark-as-read options were withdrawn from the catalogue until they run
+ * (DEV-349) — a step saved with one of them fails validation instead of
+ * silently succeeding.
+ */
+import { ActionDefinition } from '../../types';
+export declare const emailDefinition: ActionDefinition;

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

@@ -0,0 +1,152 @@
+/**
+ * Email Action
+ *
+ * Sends an email through a connected email service. Send is the only
+ * operation the Engine implements; the Read / Search / Delete / Move /
+ * Mark-as-read options were withdrawn from the catalogue until they run
+ * (DEV-349) — a step saved with one of them fails validation instead of
+ * silently succeeding.
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const emailDefinition = {
+    id: 'email',
+    name: 'Email',
+    description: 'Send an email through any connected email service provider',
+    category: ActionCategory.Communication,
+    type: ActionType.EmailSend,
+    tags: ['communication', 'email', 'smtp', 'sendgrid', 'ses', 'imap', 'pop3', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Email',
+    color: '#0043ce',
+    inputSchema: {
+        fields: [
+            {
+                key: 'connection',
+                label: 'Email Service',
+                type: FieldType.Connection,
+                description: 'Email service connection (SMTP, IMAP, SendGrid, AWS SES, etc.)',
+                validation: { required: true },
+            },
+            {
+                key: 'operation',
+                label: 'Operation',
+                type: FieldType.Select,
+                description: 'Email operation — Send is the only operation available today',
+                options: [
+                    { label: 'Send', value: 'send' },
+                ],
+                defaultValue: 'send',
+                validation: { required: true },
+            },
+            {
+                key: 'to',
+                label: 'To',
+                type: FieldType.String,
+                description: 'Recipient email address(es), comma-separated (for send operation)',
+                validation: { required: false },
+            },
+            {
+                key: 'cc',
+                label: 'CC',
+                type: FieldType.String,
+                description: 'CC email address(es), comma-separated (for send operation)',
+                validation: { required: false },
+            },
+            {
+                key: 'bcc',
+                label: 'BCC',
+                type: FieldType.String,
+                description: 'BCC email address(es), comma-separated (for send operation)',
+                validation: { required: false },
+            },
+            {
+                key: 'subject',
+                label: 'Subject',
+                type: FieldType.String,
+                description: 'Email subject (for send operation)',
+                validation: { required: false },
+            },
+            {
+                key: 'body',
+                label: 'Body',
+                type: FieldType.String,
+                description: 'Email body content (for send operation)',
+                validation: { required: false },
+            },
+            {
+                key: 'isHtml',
+                label: 'Is HTML',
+                type: FieldType.Boolean,
+                description: 'Whether body is HTML content',
+                defaultValue: false,
+                validation: { required: false },
+            },
+            {
+                key: 'attachments',
+                label: 'Attachments',
+                type: FieldType.Array,
+                description: 'File attachments (URLs or file paths)',
+                validation: { required: false },
+            },
+            {
+                key: 'folder',
+                label: 'Folder',
+                type: FieldType.String,
+                description: 'Email folder (Inbox, Sent, Drafts, etc.)',
+                validation: { required: false },
+            },
+            {
+                key: 'query',
+                label: 'Search Query',
+                type: FieldType.String,
+                description: 'Search criteria (for search/read operations)',
+                validation: { required: false },
+            },
+            {
+                key: 'limit',
+                label: 'Limit',
+                type: FieldType.Number,
+                description: 'Maximum number of emails to retrieve',
+                defaultValue: 10,
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'success',
+                type: FieldType.Boolean,
+                description: 'Whether operation was successful',
+            },
+            {
+                key: 'data',
+                type: FieldType.JSON,
+                description: 'Operation result data (emails, message ID, etc.)',
+            },
+            {
+                key: 'count',
+                type: FieldType.Number,
+                description: 'Number of emails affected/returned',
+            },
+            {
+                key: 'messageId',
+                type: FieldType.String,
+                description: 'Email message ID (for send operation)',
+            },
+        ],
+        sampleOutput: {
+            success: true,
+            data: [{ id: 'email_123', from: 'sender@example.com', subject: 'Test' }],
+            count: 1,
+            messageId: 'msg_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/google-chat/config.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Google Chat Configuration
+ */
+export interface GoogleChatConfigType {
+    connection: string;
+    /** Target space resource name, e.g. "spaces/AAAA". */
+    space?: string;
+    /** Human-readable space name (for logs/labels). */
+    spaceName?: string;
+    /** Canonical message body. */
+    text?: string;
+    /** Legacy alias for `text`. */
+    message?: string;
+    /** Reply into an existing thread by key (optional). */
+    threadKey?: string;
+    /** Google Chat Cards v2 array (advanced, optional). */
+    cardsV2?: unknown[];
+}
+export declare const GoogleChatConfig: {
+    defaults: GoogleChatConfigType;
+    schema: {
+        connection: {
+            type: string;
+            required: boolean;
+        };
+        space: {
+            type: string;
+            required: boolean;
+        };
+        text: {
+            type: string;
+            required: boolean;
+        };
+        threadKey: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<GoogleChatConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<GoogleChatConfigType>) => GoogleChatConfigType;
+    getLabel: () => string;
+};

package/dist/catalog/communication/google-chat/config.js

@@ -0,0 +1,28 @@
+/**
+ * Google Chat Configuration
+ */
+export const GoogleChatConfig = {
+    defaults: { connection: '', space: '', spaceName: '', text: '', threadKey: '' },
+    schema: {
+        connection: { type: 'connection', required: true },
+        space: { type: 'string', required: true },
+        text: { type: 'string', required: false },
+        threadKey: { type: 'string', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.connection)
+            errors.push('Connect a Google Chat account');
+        if (!config.space)
+            errors.push('Pick a space');
+        // Text-only over OAuth (cards require app auth — see GoogleChatConfigPanel note).
+        if (!config.text && !config.message)
+            errors.push('Add a message');
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => ({
+        ...GoogleChatConfig.defaults,
+        ...userConfig,
+    }),
+    getLabel: () => 'Google Chat',
+};

package/dist/catalog/communication/google-chat/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Google Chat Action
+ */
+import { ActionDefinition } from '../../types';
+export declare const googleChatDefinition: ActionDefinition;

package/dist/catalog/communication/google-chat/index.js

@@ -0,0 +1,36 @@
+/**
+ * Google Chat Action
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const googleChatDefinition = {
+    id: 'google_chat',
+    name: 'Google Chat',
+    description: 'Post a message to a Google Chat space (OAuth 2.0 — pick any space you belong to)',
+    category: ActionCategory.Communication,
+    type: ActionType.GoogleChat,
+    tags: ['communication', 'google', 'chat', 'webhook', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'brand:google_chat',
+    color: '#00AC47',
+    inputSchema: {
+        fields: [
+            { key: 'connection', label: 'Google Chat Space', type: FieldType.Connection, validation: { required: true } },
+            { key: 'text', label: 'Message', type: FieldType.String, validation: { required: true } },
+            { key: 'threadKey', label: 'Thread Key', type: FieldType.String, validation: { required: false } },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'ok', type: FieldType.Boolean, description: 'Whether the message was sent' },
+            { key: 'name', type: FieldType.String, description: 'Created message resource name' },
+        ],
+        sampleOutput: { ok: true, name: 'spaces/AAAA/messages/BBBB' },
+    },
+    version: '1.0.0',
+    createdAt: '2026-06-18T00:00:00Z',
+    updatedAt: '2026-06-18T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

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

@@ -0,0 +1,47 @@
+/**
+ * Slack Message Configuration
+ */
+export interface SlackMessageConfigType {
+    connection: string;
+    /** 'channel' = post to a channel, 'user' = open a DM with a user. */
+    messageType?: 'channel' | 'user';
+    channel: string;
+    channelName?: string;
+    /** Canonical message body (the config panel stores it here). */
+    text?: string;
+    /** Legacy alias for `text`. */
+    message?: string;
+    /** Slack Block Kit JSON array, built via the visual builder. */
+    blocks?: unknown[];
+}
+export declare const SlackMessageConfig: {
+    defaults: SlackMessageConfigType;
+    schema: {
+        connection: {
+            type: string;
+            required: boolean;
+        };
+        messageType: {
+            type: string;
+            required: boolean;
+        };
+        channel: {
+            type: string;
+            required: boolean;
+        };
+        text: {
+            type: string;
+            required: boolean;
+        };
+        blocks: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<SlackMessageConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<SlackMessageConfigType>) => SlackMessageConfigType;
+    getLabel: (config: SlackMessageConfigType) => string;
+};

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

@@ -0,0 +1,36 @@
+/**
+ * Slack Message Configuration
+ */
+export const SlackMessageConfig = {
+    defaults: { connection: '', messageType: 'channel', channel: '', channelName: '', text: '', blocks: undefined },
+    schema: {
+        connection: { type: 'connection', required: true },
+        messageType: { type: 'string', required: false },
+        channel: { type: 'string', required: true },
+        text: { type: 'string', required: false },
+        blocks: { type: 'json', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.connection)
+            errors.push('Slack workspace connection is required');
+        if (!config.channel)
+            errors.push(config.messageType === 'user' ? 'A user is required' : 'A channel is required');
+        const hasText = Boolean(config.text || config.message);
+        const hasBlocks = Array.isArray(config.blocks) && config.blocks.length > 0;
+        if (!hasText && !hasBlocks)
+            errors.push('Add a message or at least one block');
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...SlackMessageConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        const prefix = config.messageType === 'user' ? '@' : '#';
+        return config.channelName
+            ? `Slack: ${prefix}${config.channelName}`
+            : config.channel
+                ? `Slack: ${config.channel}`
+                : 'Slack';
+    },
+};

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

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