@octaviaflow/flow-rules 0.1.0

package/dist/catalog/logic/for-each/pathOptions.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ForEach source-path helpers (pure, framework-free).
+ *
+ * Extracted from ForEachConfigPanel so the iterable-path collection logic can
+ * be unit-tested without dragging the Design System into the test runner.
+ * These mirror the legacy `loopableInSource` collector and emit dot-paths that
+ * the engine's `resolveArrayPath` resolves directly.
+ */
+/**
+ * The upstream-node shape a config panel passes in.
+ *
+ * Declared here rather than imported from the UI's panel registry: this
+ * package must not depend on React, and only this one field was ever used.
+ * The UI's `CustomConfigComponentProps['upstreamNodes']` is assignable to it.
+ */
+export interface UpstreamNodeRef {
+    id: string;
+    label?: string;
+    type?: string;
+    config?: Record<string, unknown>;
+    outputSchema?: unknown;
+    /** The last run's output, when the editor has one to offer. */
+    executionData?: {
+        output?: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface PathOption {
+    id: string;
+    text: string;
+    description?: string;
+}
+/** Recursively infer a DataSchema-like object from a runtime sample record. */
+export declare function inferSchemaFromSample(sample: Record<string, unknown>): {
+    type: string;
+    properties: Record<string, any>;
+};
+/**
+ * Recursively walk a JSONSchema-like shape, emitting one PathOption per
+ * array node encountered. Mirrors the legacy `loopableInSource` collector
+ * (cloudwf-ui editmap.jsp:241-265) so the dropdown surfaces every level
+ * the user could iterate, not just the top.
+ *
+ * Emitted dot-paths match the engine's `resolveArrayPath` resolver, which
+ * already walks dot-notation and falls back to looking inside `data[0]`
+ * for nested fields — so `data.departments` resolves correctly without
+ * any engine change.
+ */
+export declare function collectArrayPaths(schema: any, prefix: string, add: (id: string, text: string, description?: string) => void, depth?: number): void;
+/** Walk a runtime sample for the same path collection — used when the
+ *  static schema is missing/shallow but executionData has real shape. */
+export declare function collectArrayPathsFromSample(sample: unknown, prefix: string, add: (id: string, text: string, description?: string) => void, depth?: number): void;
+/**
+ * Build iterable field options from upstream nodes.
+ *
+ * Walks the upstream output schema (and execution data as a fallback) to
+ * surface every array path the user can iterate. The legacy mapper
+ * collected the same set as `loopableInSource` and exposed it via the
+ * "Loop Over" dropdown; we surface it here so ForEach has equivalent
+ * reach for nested arrays inside JSONB columns.
+ */
+export declare function buildPathOptions(upstreamNodes?: UpstreamNodeRef[]): PathOption[];

package/dist/catalog/logic/for-each/pathOptions.js

@@ -0,0 +1,151 @@
+/**
+ * ForEach source-path helpers (pure, framework-free).
+ *
+ * Extracted from ForEachConfigPanel so the iterable-path collection logic can
+ * be unit-tested without dragging the Design System into the test runner.
+ * These mirror the legacy `loopableInSource` collector and emit dot-paths that
+ * the engine's `resolveArrayPath` resolves directly.
+ */
+/** Recursively infer a DataSchema-like object from a runtime sample record. */
+export function inferSchemaFromSample(sample) {
+    const properties = {};
+    for (const [key, value] of Object.entries(sample)) {
+        if (value === null || value === undefined) {
+            properties[key] = { type: 'string' };
+        }
+        else if (Array.isArray(value)) {
+            if (value.length > 0 && typeof value[0] === 'object' && value[0] !== null) {
+                properties[key] = { type: 'array', items: inferSchemaFromSample(value[0]) };
+            }
+            else {
+                properties[key] = { type: 'array' };
+            }
+        }
+        else if (typeof value === 'object') {
+            properties[key] = inferSchemaFromSample(value);
+        }
+        else if (typeof value === 'number') {
+            properties[key] = { type: 'number' };
+        }
+        else if (typeof value === 'boolean') {
+            properties[key] = { type: 'boolean' };
+        }
+        else {
+            properties[key] = { type: 'string' };
+        }
+    }
+    return { type: 'object', properties };
+}
+/**
+ * Recursively walk a JSONSchema-like shape, emitting one PathOption per
+ * array node encountered. Mirrors the legacy `loopableInSource` collector
+ * (cloudwf-ui editmap.jsp:241-265) so the dropdown surfaces every level
+ * the user could iterate, not just the top.
+ *
+ * Emitted dot-paths match the engine's `resolveArrayPath` resolver, which
+ * already walks dot-notation and falls back to looking inside `data[0]`
+ * for nested fields — so `data.departments` resolves correctly without
+ * any engine change.
+ */
+export function collectArrayPaths(schema, prefix, add, depth = 0) {
+    if (!schema || typeof schema !== 'object' || depth > 8)
+        return;
+    if (schema.type === 'array') {
+        if (prefix) {
+            const itemsType = schema.items?.type;
+            const label = itemsType === 'object' ? 'array of objects' : 'array';
+            add(prefix, `${prefix}  (${label})`, `Iterate over "${prefix}"`);
+        }
+        // Descend into items so nested arrays inside this array are emitted too.
+        if (schema.items) {
+            collectArrayPaths(schema.items, prefix, add, depth + 1);
+        }
+        return;
+    }
+    if (schema.type === 'object' && schema.properties) {
+        for (const [key, child] of Object.entries(schema.properties)) {
+            const next = prefix ? `${prefix}.${key}` : key;
+            collectArrayPaths(child, next, add, depth + 1);
+        }
+    }
+}
+/** Walk a runtime sample for the same path collection — used when the
+ *  static schema is missing/shallow but executionData has real shape. */
+export function collectArrayPathsFromSample(sample, prefix, add, depth = 0) {
+    if (!sample || typeof sample !== 'object' || depth > 8)
+        return;
+    if (Array.isArray(sample)) {
+        if (prefix) {
+            const itemsObj = sample.length > 0 && typeof sample[0] === 'object' && sample[0] !== null;
+            const label = itemsObj ? 'array of objects' : 'array';
+            add(prefix, `${prefix}  (${label})`, `Iterate over "${prefix}"`);
+        }
+        if (sample.length > 0) {
+            collectArrayPathsFromSample(sample[0], prefix, add, depth + 1);
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(sample)) {
+        const next = prefix ? `${prefix}.${key}` : key;
+        collectArrayPathsFromSample(value, next, add, depth + 1);
+    }
+}
+/**
+ * Build iterable field options from upstream nodes.
+ *
+ * Walks the upstream output schema (and execution data as a fallback) to
+ * surface every array path the user can iterate. The legacy mapper
+ * collected the same set as `loopableInSource` and exposed it via the
+ * "Loop Over" dropdown; we surface it here so ForEach has equivalent
+ * reach for nested arrays inside JSONB columns.
+ */
+export function buildPathOptions(upstreamNodes) {
+    const paths = [];
+    const seen = new Set();
+    const add = (id, text, description) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        paths.push({ id, text, description });
+    };
+    if (upstreamNodes) {
+        for (const node of upstreamNodes) {
+            const label = node.label || node.type || 'Upstream';
+            const queryTable = node.config?.visualConfig?.tables?.[0];
+            // Always offer "data" — the standard array wrapper from queries. At
+            // RUNTIME a Query emits `{ data: rows }` regardless of object name, so
+            // the iterable path is `data`; we just LABEL it with the object name
+            // (e.g. "contacts") when known. Offering the bare object name AS the
+            // path resolved nowhere at runtime ("does not resolve to an array").
+            add('data', queryTable ? `${queryTable} (${label})` : `All records (${label})`, queryTable ? `Iterate over every ${queryTable} record` : 'Iterate over every record from upstream');
+            // Recursive walk of static schema. The engine's resolveArrayPath
+            // handles dot-paths like `data.departments` by walking obj.data[0]
+            // for the nested field, so deep paths Just Work without any engine
+            // change.
+            const schema = node.outputSchema || node.config?._outputSchema;
+            if (schema)
+                collectArrayPaths(schema, '', add);
+            // Fallback: when the static schema is missing or shallow, walk the
+            // last execution's actual output. Same path format.
+            const output = node.executionData?.output;
+            if (output) {
+                const records = Array.isArray(output.data)
+                    ? output.data
+                    : Array.isArray(output)
+                        ? output
+                        : null;
+                if (records && records.length > 0 && typeof records[0] === 'object') {
+                    collectArrayPathsFromSample(records[0], '', add);
+                }
+            }
+            // NOTE: we deliberately do NOT offer the bare object/table name as a
+            // path — at runtime the rows live under `data`, not under the object
+            // name (the object name only keys the DataStream schema tree). The
+            // `data` option above is labelled with the object name instead.
+        }
+    }
+    if (paths.length === 0) {
+        add('data', 'data (upstream output)');
+    }
+    return paths;
+}

package/dist/catalog/logic/group/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Group action
+ *
+ * A generic container — drop nodes inside and they become children
+ * (parentId points at the group). No runtime semantics: the engine
+ * just executes the children in their normal order. Used to fold a
+ * sub-flow into a single visual block on the canvas. Drag a child
+ * out of the group's bbox to detach.
+ *
+ * Mirrors ForEach structurally (container + top input / bottom output
+ * ports) but without the iteration config. The DS renders it via the
+ * built-in `group` node kind.
+ */
+import { type ActionDefinition } from '../../types';
+export declare const groupDefinition: ActionDefinition;

package/dist/catalog/logic/group/index.js

@@ -0,0 +1,46 @@
+/**
+ * Group action
+ *
+ * A generic container — drop nodes inside and they become children
+ * (parentId points at the group). No runtime semantics: the engine
+ * just executes the children in their normal order. Used to fold a
+ * sub-flow into a single visual block on the canvas. Drag a child
+ * out of the group's bbox to detach.
+ *
+ * Mirrors ForEach structurally (container + top input / bottom output
+ * ports) but without the iteration config. The DS renders it via the
+ * built-in `group` node kind.
+ */
+import { ActionCategory, ActionStatus, ActionType, } from '../../types';
+export const groupDefinition = {
+    id: 'group',
+    name: 'Group',
+    description: 'Visually group a set of steps — drop nodes inside to nest them.',
+    category: ActionCategory.Logic,
+    type: ActionType.Group,
+    tags: ['logic', 'container', 'subflow', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'GroupObjects',
+    color: '#6f6f6f',
+    // No fields — the group itself has no config.
+    inputSchema: { fields: [] },
+    // The engine surfaces whatever the last child step emitted; we
+    // declare a generic output bag so downstream nodes can still see
+    // "something" came out of the group.
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'result',
+                type: 'object',
+                description: 'Aggregated output of the contained steps.',
+            },
+        ],
+    },
+    version: '1.0.0',
+    createdAt: '2026-05-19T00:00:00Z',
+    updatedAt: '2026-05-19T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: false,
+};

package/dist/catalog/policies.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Workflow Policies
+ * Define rules and constraints for workflow behavior
+ */
+export interface WorkflowPolicies {
+    connection: ConnectionPolicies;
+    node: NodePolicies;
+    execution: ExecutionPolicies;
+    validation: ValidationPolicies;
+}
+export interface ConnectionPolicies {
+    allowSelfLoop: boolean;
+    allowMultipleOutputs: boolean;
+    allowMultipleInputs: boolean;
+    strictTypeChecking: boolean;
+    maxConnectionsPerNode?: number;
+    preventCircularDependencies: boolean;
+    allowConditionalConnections: boolean;
+    requireAllInputsConnected: boolean;
+}
+export interface NodePolicies {
+    minNodes: number;
+    maxNodes?: number;
+    allowDuplicateTypes: boolean;
+    requiredNodeTypes?: string[];
+    forbiddenNodeTypes?: string[];
+    allowOrphanNodes: boolean;
+    snapToGrid: boolean;
+    gridSize: number;
+}
+export interface ExecutionPolicies {
+    allowParallelExecution: boolean;
+    maxExecutionTime?: number;
+    retryFailedNodes: boolean;
+    maxRetries: number;
+    continueOnError: boolean;
+    requireApproval: boolean;
+}
+export interface ValidationPolicies {
+    validateOnChange: boolean;
+    validateBeforeExecution: boolean;
+    blockExecutionOnValidationError: boolean;
+    showValidationWarnings: boolean;
+    strictMode: boolean;
+}
+/**
+ * Policy violation types
+ */
+export declare enum PolicyViolationType {
+    SelfLoop = "self_loop",
+    MultipleOutputs = "multiple_outputs",
+    MultipleInputs = "multiple_inputs",
+    TypeMismatch = "type_mismatch",
+    MaxConnectionsExceeded = "max_connections_exceeded",
+    CircularDependency = "circular_dependency",
+    OrphanNode = "orphan_node",
+    MissingRequiredNode = "missing_required_node",
+    ForbiddenNodeType = "forbidden_node_type",
+    MaxNodesExceeded = "max_nodes_exceeded",
+    MinNodesNotMet = "min_nodes_not_met",
+    RequiredInputNotConnected = "required_input_not_connected"
+}
+export interface PolicyViolation {
+    type: PolicyViolationType;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+    portId?: string;
+    suggestion?: string;
+}
+/**
+ * Default workflow policies
+ */
+export declare const DEFAULT_WORKFLOW_POLICIES: WorkflowPolicies;

package/dist/catalog/policies.js

@@ -0,0 +1,62 @@
+/**
+ * Workflow Policies
+ * Define rules and constraints for workflow behavior
+ */
+/**
+ * Policy violation types
+ */
+export var PolicyViolationType;
+(function (PolicyViolationType) {
+    PolicyViolationType["SelfLoop"] = "self_loop";
+    PolicyViolationType["MultipleOutputs"] = "multiple_outputs";
+    PolicyViolationType["MultipleInputs"] = "multiple_inputs";
+    PolicyViolationType["TypeMismatch"] = "type_mismatch";
+    PolicyViolationType["MaxConnectionsExceeded"] = "max_connections_exceeded";
+    PolicyViolationType["CircularDependency"] = "circular_dependency";
+    PolicyViolationType["OrphanNode"] = "orphan_node";
+    PolicyViolationType["MissingRequiredNode"] = "missing_required_node";
+    PolicyViolationType["ForbiddenNodeType"] = "forbidden_node_type";
+    PolicyViolationType["MaxNodesExceeded"] = "max_nodes_exceeded";
+    PolicyViolationType["MinNodesNotMet"] = "min_nodes_not_met";
+    PolicyViolationType["RequiredInputNotConnected"] = "required_input_not_connected";
+})(PolicyViolationType || (PolicyViolationType = {}));
+/**
+ * Default workflow policies
+ */
+export const DEFAULT_WORKFLOW_POLICIES = {
+    connection: {
+        allowSelfLoop: false,
+        allowMultipleOutputs: true,
+        allowMultipleInputs: false,
+        strictTypeChecking: true,
+        maxConnectionsPerNode: undefined,
+        preventCircularDependencies: true,
+        allowConditionalConnections: true,
+        requireAllInputsConnected: false,
+    },
+    node: {
+        minNodes: 1,
+        maxNodes: undefined,
+        allowDuplicateTypes: true,
+        requiredNodeTypes: undefined,
+        forbiddenNodeTypes: undefined,
+        allowOrphanNodes: true,
+        snapToGrid: true,
+        gridSize: 20,
+    },
+    execution: {
+        allowParallelExecution: true,
+        maxExecutionTime: undefined,
+        retryFailedNodes: true,
+        maxRetries: 3,
+        continueOnError: false,
+        requireApproval: false,
+    },
+    validation: {
+        validateOnChange: true,
+        validateBeforeExecution: true,
+        blockExecutionOnValidationError: true,
+        showValidationWarnings: true,
+        strictMode: false,
+    },
+};

package/dist/catalog/storage/csv-action/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionDefinition } from '../../types';
+export declare const csvActionDefinition: ActionDefinition;

package/dist/catalog/storage/csv-action/index.js

@@ -0,0 +1,38 @@
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const csvActionDefinition = {
+    id: 'csv_action',
+    name: 'CSV',
+    description: 'Parse CSV files into structured records or generate CSV files from workflow data',
+    category: ActionCategory.Storage,
+    type: ActionType.CsvAction,
+    tags: ['csv', 'parse', 'generate', 'file', 'format', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Document',
+    color: '#198038',
+    inputSchema: {
+        fields: [
+            { key: 'operation', label: 'Operation', type: FieldType.Select, options: [{ label: 'Parse (CSV → Records)', value: 'parse' }, { label: 'Generate (Records → CSV)', value: 'generate' }], defaultValue: 'parse', validation: { required: true } },
+            { key: 'content', label: 'CSV Content', type: FieldType.String, description: 'Paste CSV content or use FX token from upstream step' },
+            { key: 'delimiter', label: 'Delimiter', type: FieldType.Select, options: [{ label: 'Comma (,)', value: ',' }, { label: 'Semicolon (;)', value: ';' }, { label: 'Tab', value: '\t' }, { label: 'Pipe (|)', value: '|' }], defaultValue: ',' },
+            { key: 'headerRow', label: 'Header Row', type: FieldType.Number, description: 'Row number containing column headers (default: 1)', defaultValue: 1 },
+            { key: 'encoding', label: 'Encoding', type: FieldType.Select, options: [{ label: 'UTF-8', value: 'utf-8' }, { label: 'Latin-1', value: 'latin1' }, { label: 'ASCII', value: 'ascii' }], defaultValue: 'utf-8' },
+            { key: 'includeHeader', label: 'Include Header Row', type: FieldType.Boolean, description: 'Include column headers in generated CSV', defaultValue: true },
+            { key: 'fileName', label: 'Output File Name', type: FieldType.String, description: 'Name for generated file (e.g. export.csv)', defaultValue: 'export.csv' },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'data', type: FieldType.Array, description: 'Parsed records (parse mode) — loop these with a ForEach. Generated CSV string in generate mode.' },
+            { key: 'columns', type: FieldType.JSON, description: 'Column names' },
+            { key: 'rowCount', type: FieldType.Number, description: 'Number of records' },
+        ],
+        sampleOutput: { data: [{ id: 1, name: 'Widget', price: 9.99 }], columns: ['id', 'name', 'price'], rowCount: 1 },
+    },
+    version: '1.0.0',
+    createdAt: '2026-03-28T00:00:00Z',
+    updatedAt: '2026-03-28T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: false,
+};

package/dist/catalog/storage/dropbox-action/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionDefinition } from '../../types';
+export declare const dropboxActionDefinition: ActionDefinition;

package/dist/catalog/storage/dropbox-action/index.js

@@ -0,0 +1,33 @@
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const dropboxActionDefinition = {
+    id: 'dropbox_action',
+    name: 'Dropbox',
+    description: 'Upload, download, list, delete, move, or copy files in Dropbox',
+    category: ActionCategory.Storage,
+    type: ActionType.DropboxAction,
+    tags: ['dropbox', 'cloud', 'storage', 'upload', 'download', 'built-in'],
+    status: ActionStatus.Beta,
+    icon: 'CloudUpload',
+    color: '#0061FF',
+    inputSchema: {
+        fields: [
+            { key: 'connector', label: 'Dropbox Account', type: FieldType.Connection, description: 'Select a connected Dropbox account', validation: { required: true } },
+            { key: 'operation', label: 'Operation', type: FieldType.Select, options: [{ label: 'Download File', value: 'download' }, { label: 'Upload File', value: 'upload' }, { label: 'List Files', value: 'list' }, { label: 'Delete', value: 'delete' }, { label: 'Move', value: 'move' }, { label: 'Copy', value: 'copy' }, { label: 'Create Folder', value: 'create_folder' }, { label: 'Get Shared Link', value: 'shared_link' }], defaultValue: 'download', validation: { required: true } },
+            { key: 'path', label: 'File / Folder Path', type: FieldType.String, description: 'Path on Dropbox (use file explorer to browse)' },
+            { key: 'content', label: 'File Content (Upload)', type: FieldType.String, description: 'Content to upload — use FX token from upstream' },
+            { key: 'fileName', label: 'File Name (Upload)', type: FieldType.String },
+            { key: 'destPath', label: 'Destination Path (Move/Copy)', type: FieldType.String },
+            { key: 'mode', label: 'Upload Mode', type: FieldType.Select, options: [{ label: 'Add (fail if exists)', value: 'add' }, { label: 'Overwrite', value: 'overwrite' }], defaultValue: 'overwrite' },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'data', type: FieldType.JSON, description: 'File content, list, or metadata' },
+            { key: 'path', type: FieldType.String, description: 'Dropbox file path' },
+            { key: 'sharedLink', type: FieldType.String, description: 'Shared link URL' },
+        ],
+        sampleOutput: { path: '/reports/monthly.csv', data: 'content...' },
+    },
+    version: '1.0.0', createdAt: '2026-03-28T00:00:00Z', updatedAt: '2026-03-28T00:00:00Z', createdBy: 'system', isOfficial: true, testable: false,
+};

package/dist/catalog/storage/excel-action/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionDefinition } from '../../types';
+export declare const excelActionDefinition: ActionDefinition;

package/dist/catalog/storage/excel-action/index.js

@@ -0,0 +1,32 @@
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const excelActionDefinition = {
+    id: 'excel_action',
+    name: 'Excel',
+    description: 'Parse Excel (.xlsx) files into structured records or generate Excel files from workflow data',
+    category: ActionCategory.Storage,
+    type: ActionType.ExcelAction,
+    tags: ['excel', 'xlsx', 'xls', 'spreadsheet', 'parse', 'generate', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Spreadsheet',
+    color: '#217346',
+    inputSchema: {
+        fields: [
+            { key: 'operation', label: 'Operation', type: FieldType.Select, options: [{ label: 'Parse (Excel → Records)', value: 'parse' }, { label: 'Generate (Records → Excel)', value: 'generate' }], defaultValue: 'parse', validation: { required: true } },
+            { key: 'content', label: 'Excel File', type: FieldType.String, description: 'S3 key of uploaded Excel file or FX token from upstream' },
+            { key: 'sheetName', label: 'Sheet Name', type: FieldType.String, description: 'Name of sheet to read (default: first sheet)' },
+            { key: 'headerRow', label: 'Header Row', type: FieldType.Number, description: 'Row number containing headers', defaultValue: 1 },
+            { key: 'fileName', label: 'Output File Name', type: FieldType.String, defaultValue: 'export.xlsx' },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'data', type: FieldType.Array, description: 'Parsed records (parse mode) — loop these with a ForEach. File metadata in generate mode.' },
+            { key: 'columns', type: FieldType.JSON, description: 'Column names' },
+            { key: 'rowCount', type: FieldType.Number, description: 'Number of records' },
+            { key: 's3Key', type: FieldType.String, description: 'S3 key of generated file' },
+        ],
+        sampleOutput: { data: [{ id: 1, name: 'Widget' }], columns: ['id', 'name'], rowCount: 1 },
+    },
+    version: '1.0.0', createdAt: '2026-03-28T00:00:00Z', updatedAt: '2026-03-28T00:00:00Z', createdBy: 'system', isOfficial: true, testable: false,
+};

package/dist/catalog/storage/file-action/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionDefinition } from '../../types';
+export declare const fileActionDefinition: ActionDefinition;

package/dist/catalog/storage/file-action/index.js

@@ -0,0 +1,119 @@
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const fileActionDefinition = {
+    id: 'file_action',
+    name: 'Files',
+    description: 'Parse, generate, or convert files (CSV, JSON, XML, Excel). Read from S3, SFTP, FTP, Google Drive, URL, or upload. Write generated files to any storage destination.',
+    category: ActionCategory.Storage,
+    type: ActionType.FileAction,
+    tags: ['file', 'csv', 'json', 'xml', 'excel', 'parse', 'generate', 'convert', 's3', 'sftp', 'ftp', 'built-in'],
+    status: ActionStatus.Beta,
+    icon: 'DocumentImport',
+    color: '#6929c4',
+    inputSchema: {
+        fields: [
+            {
+                key: 'mode',
+                label: 'Mode',
+                type: FieldType.Select,
+                options: [
+                    { label: 'Parse File (Read)', value: 'parse' },
+                    { label: 'Generate File (Write)', value: 'generate' },
+                    { label: 'Convert Format', value: 'convert' },
+                ],
+                defaultValue: 'parse',
+                validation: { required: true },
+            },
+            {
+                key: 'source',
+                label: 'Source',
+                type: FieldType.Select,
+                options: [
+                    // 'upload' removed: there is no runtime upload source — the Engine
+                    // always failed it with "No content to parse" (DEV-249).
+                    { label: 'AWS S3', value: 's3' },
+                    { label: 'URL', value: 'url' },
+                    { label: 'Inline Paste', value: 'inline' },
+                    { label: 'Previous Step Output', value: 'previous_step' },
+                ],
+                defaultValue: 'inline',
+                validation: { required: false },
+            },
+            {
+                key: 'format',
+                label: 'File Format',
+                type: FieldType.Select,
+                options: [
+                    { label: 'Auto-detect', value: 'auto' },
+                    { label: 'CSV', value: 'csv' },
+                    { label: 'TSV', value: 'tsv' },
+                    { label: 'JSON', value: 'json' },
+                    { label: 'JSONL', value: 'jsonl' },
+                    { label: 'XML', value: 'xml' },
+                    { label: 'Excel (.xlsx)', value: 'excel' },
+                ],
+                defaultValue: 'auto',
+            },
+            {
+                key: 'inlineContent',
+                label: 'File Content',
+                type: FieldType.String,
+                description: 'Paste CSV, JSON, or other file content here',
+                validation: { required: false },
+            },
+            {
+                key: 's3Key',
+                label: 'S3 Key',
+                type: FieldType.String,
+                description: 'S3 object key (path) to read from',
+                validation: { required: false },
+            },
+            {
+                key: 'url',
+                label: 'File URL',
+                type: FieldType.String,
+                description: 'Public URL to download file from',
+                validation: { required: false },
+            },
+            {
+                key: 'outputFormat',
+                label: 'Output Format (Generate/Convert)',
+                type: FieldType.Select,
+                options: [
+                    { label: 'CSV', value: 'csv' },
+                    { label: 'JSON', value: 'json' },
+                    { label: 'Excel (.xlsx)', value: 'excel' },
+                    { label: 'XML', value: 'xml' },
+                    { label: 'TSV', value: 'tsv' },
+                ],
+                defaultValue: 'csv',
+            },
+            {
+                key: 'outputFileName',
+                label: 'Output File Name',
+                type: FieldType.String,
+                description: 'Name for generated file (e.g. report.csv)',
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'data', type: FieldType.JSON, description: 'Parsed records (parse mode) or file metadata (generate mode)' },
+            { key: 'columns', type: FieldType.JSON, description: 'Column names from parsed file' },
+            { key: 'rowCount', type: FieldType.Number, description: 'Number of records' },
+            { key: 's3Key', type: FieldType.String, description: 'S3 key of generated file' },
+        ],
+        sampleOutput: {
+            data: [{ id: 1, name: 'Widget', price: 9.99 }],
+            columns: ['id', 'name', 'price'],
+            rowCount: 1,
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2026-03-27T00:00:00Z',
+    updatedAt: '2026-03-27T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: false,
+};