ugcinc 4.0.1 → 4.1.0

package/dist/automations/nodes/auto-post.d.ts

@@ -0,0 +1,81 @@
+import type { InputType } from './types';
+/**
+ * Scheduling mode for post nodes
+ * - 'scheduled': Post immediately when automation runs
+ * - 'queue': Automatically schedule based on queue constraints
+ */
+export type PostSchedulingMode = 'scheduled' | 'queue';
+/**
+ * Post scheduling configuration for post nodes
+ */
+export interface PostSchedulingConfig {
+    /** Main scheduling mode ('scheduled' = post now, 'queue' = auto-schedule) */
+    mode: PostSchedulingMode;
+    /** Minimum hours between posts for this account (min 1) */
+    minDistanceHours?: number;
+    /** Maximum posts per day for this account (min 1) */
+    maxPostsPerDay?: number;
+    /** Minimum time of day for posting (HH:mm format, e.g., '09:00') */
+    randomWindowStart?: string;
+    /** Maximum time of day for posting (HH:mm format, e.g., '21:00') */
+    randomWindowEnd?: string;
+    /** Timezone for time window (IANA timezone, e.g., 'America/New_York') */
+    timezone?: string;
+    /** If true, post will be created with 'require-approval' status instead of being posted */
+    requireApproval?: boolean;
+}
+/**
+ * Auto Post mode - video or slideshow
+ */
+export type AutoPostMode = 'video' | 'slideshow';
+/**
+ * Auto Post input type for slideshow mode
+ * - 'static': Individual image input ports (image1, image2, etc.)
+ * - 'variable': Single 'images' port accepting an array
+ */
+export type AutoPostInputType = 'static' | 'variable';
+/**
+ * Auto Post input definition (for slideshow static mode)
+ */
+export interface AutoPostInput {
+    id: string;
+}
+/**
+ * Auto Post node configuration - posts a video or slideshow to social media
+ */
+export interface AutoPostNodeConfig {
+    /** Post mode - video or slideshow */
+    mode: AutoPostMode;
+    /** Input type for slideshow mode (defaults to 'static') */
+    inputType?: AutoPostInputType;
+    /** Dynamic image inputs (only used in slideshow mode with inputType='static') */
+    inputs?: AutoPostInput[];
+    /** Scheduling configuration */
+    scheduling?: PostSchedulingConfig;
+    /** Social audio configuration */
+    socialAudio?: {
+        /** If true, read from input port; if false, use selectedIds */
+        isVariable: boolean;
+        /** Selected social audio IDs (when isVariable is false) - one is randomly chosen when posting */
+        selectedIds?: string[];
+    };
+}
+declare const definition: import("./types").NodeDefinition<"terminal", {
+    mode: AutoPostMode;
+    inputType: InputType;
+    inputs: Array<{
+        id: string;
+    }>;
+    socialAudioIsVariable: boolean;
+    schedulingMode: string;
+    minDistanceHours: number;
+    maxPostsPerDay: number;
+    randomWindowStart: string;
+    randomWindowEnd: string;
+    timezone: string;
+    requireApproval: boolean;
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type AutoPostConfig = typeof definition.defaults;

package/dist/automations/nodes/auto-post.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'auto-post',
+    label: 'Auto Post',
+    description: 'Publish a video or slideshow',
+    type: 'terminal',
+    category: 'Output',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        mode: 'video',
+        inputType: 'static',
+        inputs: [],
+        socialAudioIsVariable: false,
+        schedulingMode: 'scheduled',
+        minDistanceHours: 4,
+        maxPostsPerDay: 3,
+        randomWindowStart: '09:00',
+        randomWindowEnd: '21:00',
+        timezone: 'America/New_York',
+        requireApproval: false,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const mode = config?.mode ?? 'video';
+        const inputs = [];
+        if (mode === 'video') {
+            inputs.push({ id: 'video', type: 'video', isArray: false, required: true });
+        }
+        else {
+            const inputType = config?.inputType ?? 'static';
+            if (inputType === 'variable') {
+                inputs.push({ id: 'images', type: 'object', isArray: false, required: true });
+            }
+            else {
+                const imageInputs = config?.inputs ?? [{ id: 'image1' }, { id: 'image2' }, { id: 'image3' }];
+                for (const input of imageInputs) {
+                    inputs.push({ id: input.id, type: 'image', isArray: false, required: true });
+                }
+            }
+        }
+        // Static inputs for both modes
+        inputs.push({ id: 'account', type: 'account', isArray: false, required: true }, { id: 'caption', type: 'text', isArray: false, required: false });
+        // Social audio variable input
+        if (config?.socialAudioIsVariable) {
+            inputs.push({ id: 'social-audio', type: 'audio', isArray: false, required: false });
+        }
+        return { inputs, outputs: [] };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/branch.d.ts

@@ -0,0 +1,58 @@
+import type { OutputMode } from '../types';
+import type { PassthroughInput } from './types';
+import type { RandomRouteObjectField } from './random-route';
+/**
+ * Branch node branch definition
+ */
+export interface BranchDefinition {
+    /** The key to match against (e.g., "happy", "sad", "neutral") */
+    key: string;
+}
+/**
+ * Per-branch value configuration - each branch can independently be variable or static
+ */
+export type BranchValueConfig = {
+    isVariable: true;
+} | {
+    isVariable: false;
+    value: unknown;
+};
+/**
+ * Branch node passthrough input definition
+ */
+export interface BranchPassthroughInput {
+    /** The input port ID (lowercase, hyphens/underscores only) */
+    id: string;
+    /** The value type */
+    type: 'image' | 'video' | 'audio' | 'text' | 'number' | 'boolean' | 'account' | 'object';
+    /** Whether this is an array type */
+    isArray?: boolean;
+    /** Per-branch value configuration. Key is branch key. Each branch can be variable (input port) or static (value). */
+    branchValues?: Record<string, BranchValueConfig>;
+    /** Object schema for object type (when type is 'object') */
+    objectSchema?: RandomRouteObjectField[];
+}
+/**
+ * Branch node configuration - routes inputs to a branch based on key match
+ */
+export interface BranchNodeConfig {
+    /** Output branches with keys to match against */
+    branches: BranchDefinition[];
+    /** Passthrough inputs that get routed to the matched branch's outputs */
+    passthroughInputs: BranchPassthroughInput[];
+    /** Optional default branch key if no match is found */
+    defaultBranchKey?: string;
+    /** Output mode - 'single' broadcasts one output to all consumers, 'per-input' creates one per consumer */
+    outputMode?: OutputMode;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    branches: {
+        key: string;
+    }[];
+    passthroughInputs: PassthroughInput[];
+    defaultBranchKey: string;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type BranchConfig = typeof definition.defaults;

package/dist/automations/nodes/branch.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'branch',
+    label: 'Branch',
+    description: 'Route inputs based on a key match',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        branches: [
+            { key: 'option-a' },
+            { key: 'option-b' },
+        ],
+        passthroughInputs: [{ id: 'input', type: 'image', isArray: false }],
+        defaultBranchKey: 'option-a',
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const branches = config?.branches ?? [];
+        const passthroughInputs = config?.passthroughInputs ?? [];
+        const inputs = [];
+        const outputs = [];
+        // Always add key input for branch selection
+        inputs.push({ id: 'key', type: 'text', isArray: false, required: true });
+        // Add input ports for each branch × passthrough where isVariable is true
+        for (const passthrough of passthroughInputs) {
+            const pType = passthrough.type;
+            const pIsArray = passthrough.isArray ?? false;
+            for (const branch of branches) {
+                const branchValue = passthrough.branchValues?.[branch.key];
+                if (branchValue?.inputType === 'variable') {
+                    inputs.push({
+                        id: `${branch.key}-${passthrough.id}`,
+                        type: pType,
+                        isArray: pIsArray,
+                        required: true,
+                    });
+                }
+            }
+            // One output per passthrough
+            outputs.push({ id: passthrough.id, type: pType, isArray: pIsArray, required: true });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/collect.d.ts

@@ -0,0 +1,16 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputMode: "single";
+    selectionMode: null;
+}>;
+export default definition;
+export type CollectConfig = typeof definition.defaults;
+/**
+ * Collect node configuration - collects outputs from for-each loop into an array
+ * Note: Most config is set during expansion, not by user
+ */
+export interface CollectNodeConfig {
+    /** Expected number of items to collect (set during for-each expansion) */
+    expectedCount?: number;
+    /** Template ID of the for-each loop this collects from (for validation) */
+    forEachTemplateId?: string;
+}

package/dist/automations/nodes/collect.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'collect',
+    label: 'Collect',
+    description: 'Collect outputs from a for-each loop into an array',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputMode: 'single', // Collect produces a single output after all loop iterations complete
+        selectionMode: null,
+    },
+    computePorts: ({ getConnectedOutput }) => {
+        // Input: accepts any non-array type (union)
+        const inputTypes = ['image', 'video', 'audio', 'text', 'object', 'boolean', 'number'];
+        // Default output: union of all types (will be array)
+        const defaultOutputTypes = ['image', 'video', 'audio', 'text', 'object'];
+        // Determine output type from connected input (inverse of for-each pattern)
+        let outputType = defaultOutputTypes;
+        let outputIsArray = true;
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('value');
+            if (connectedOutput?.type) {
+                const connType = connectedOutput.type;
+                // Handle single type (not a union)
+                if (!Array.isArray(connType) && !connectedOutput.isArray) {
+                    // If connected to a non-array type, output is an array of that type
+                    outputType = connType;
+                    outputIsArray = true;
+                }
+                // If connected to a union type, can't narrow - keep default union
+            }
+        }
+        const inputs = [
+            {
+                id: 'value',
+                type: inputTypes,
+                isArray: false,
+                required: true,
+            },
+        ];
+        const outputs = [
+            {
+                id: 'array',
+                type: outputType,
+                isArray: outputIsArray,
+                required: true,
+            },
+        ];
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/compose-workflow.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedPorts, EnumOption } from '../types';
+import { type ObjectSchemaField } from './types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    workflowTemplateId: string | undefined;
+    workflowVariableNodes: Array<{
+        id: string;
+        name?: string;
+        variableType?: "image" | "video" | "audio" | "text" | "enum";
+        enumOptions?: EnumOption[];
+    }>;
+    workflowOutputSchema: Record<string, {
+        type: string;
+        isArray?: boolean;
+        objectSchema?: ObjectSchemaField[];
+    }>;
+    resolvedPorts: ResolvedPorts | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type ComposeWorkflowConfig = typeof definition.defaults;

package/dist/automations/nodes/compose-workflow.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'compose-workflow',
+    label: 'Compose Workflow',
+    description: 'Embed other workflows',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        workflowTemplateId: undefined,
+        workflowVariableNodes: [],
+        workflowOutputSchema: {},
+        resolvedPorts: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const variableNodes = config?.workflowVariableNodes ?? [];
+        const outputSchema = config?.workflowOutputSchema ?? {};
+        // Inputs from workflow variable nodes
+        const inputs = variableNodes.map(v => ({
+            id: v.id,
+            type: (v.variableType ?? 'text'),
+            isArray: false,
+            required: true,
+            ...(v.variableType === 'enum' && v.enumOptions ? { enumOptions: v.enumOptions } : {}),
+        }));
+        // Outputs from workflow output schema
+        const outputs = Object.entries(outputSchema).map(([id, schema]) => ({
+            id,
+            type: schema.type,
+            isArray: schema.isArray ?? false,
+            required: true,
+            ...(schema.objectSchema && { objectSchema: schema.objectSchema }),
+        }));
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/create-dm.d.ts

@@ -0,0 +1,96 @@
+type DmPlatform = 'imessage' | 'instagram';
+/**
+ * Message in a Create DM conversation
+ */
+export interface CreateDmMessage {
+    /** Who sent this message */
+    sender: 'user' | 'recipient';
+    /** Message text content */
+    text: string;
+    /** Whether this message has an associated image (story reply for IG, sender image for iMessage) */
+    hasImage?: boolean;
+}
+/**
+ * Create DM node configuration - renders fake DM conversations for iMessage or Instagram
+ */
+export interface CreateDmNodeConfig {
+    /** Platform to render */
+    platform: 'imessage' | 'instagram';
+    /** Whether platform comes from input port */
+    platformIsVariable?: boolean;
+    /** Light or dark mode */
+    lightMode: boolean;
+    /** Whether light mode comes from input port */
+    lightModeIsVariable?: boolean;
+    /** Username displayed in header */
+    username: string;
+    /** Whether username comes from input port */
+    usernameIsVariable?: boolean;
+    /** Status bar time */
+    time: string;
+    /** Whether status bar time comes from input port */
+    timeIsVariable?: boolean;
+    /** Profile picture URL (fallback if profilePic input not connected) */
+    profilePicUrl?: string;
+    /** Whether profile pic comes from input port */
+    profilePicIsVariable?: boolean;
+    /** Whether messages come from input port */
+    messagesIsVariable?: boolean;
+    /** Static messages (used when messagesIsVariable is false) */
+    messages?: CreateDmMessage[];
+    /** Image attachment URL (story reply for IG, sender image for iMessage) */
+    imageAttachmentUrl?: string;
+    /** Whether image attachment comes from input port */
+    imageAttachmentIsVariable?: boolean;
+    /** iMessage-specific settings */
+    imessage?: {
+        senderBubbleColor?: string;
+        showReadReceipt: boolean;
+        readReceiptText: string;
+        /** Whether read receipt time comes from input port */
+        readReceiptTimeIsVariable?: boolean;
+        unreadBadgeText: string;
+        /** Whether unread badge comes from input port */
+        unreadBadgeIsVariable?: boolean;
+        messageHeaderTimestampText: string;
+        /** Whether message header time comes from input port */
+        messageHeaderTimeIsVariable?: boolean;
+    };
+    /** Instagram-specific settings */
+    instagram?: {
+        userHasStory: boolean;
+    };
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    platform: DmPlatform;
+    platformIsVariable: boolean;
+    lightMode: boolean;
+    lightModeIsVariable: boolean;
+    username: string;
+    usernameIsVariable: boolean;
+    time: string;
+    timeIsVariable: boolean;
+    profilePicUrl: string;
+    profilePicIsVariable: boolean;
+    messagesIsVariable: boolean;
+    messages: CreateDmMessage[];
+    imageAttachmentUrl: string | undefined;
+    imageAttachmentIsVariable: boolean;
+    imessage: {
+        senderBubbleColor: string | undefined;
+        showReadReceipt: boolean;
+        readReceiptText: string;
+        readReceiptTimeIsVariable: boolean;
+        unreadBadgeText: string;
+        unreadBadgeIsVariable: boolean;
+        messageHeaderTimestampText: string;
+        messageHeaderTimeIsVariable: boolean;
+    };
+    instagram: {
+        userHasStory: boolean;
+    };
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type CreateDmConfig = typeof definition.defaults;

package/dist/automations/nodes/create-dm.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'create-dm',
+    label: 'Create DM',
+    description: 'Create fake DM screenshots for iMessage or Instagram',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        platform: 'instagram',
+        platformIsVariable: false,
+        lightMode: true,
+        lightModeIsVariable: false,
+        username: '',
+        usernameIsVariable: false,
+        time: '9:41',
+        timeIsVariable: false,
+        profilePicUrl: 'https://ugcinc.co/logo.png',
+        profilePicIsVariable: false,
+        messagesIsVariable: false,
+        messages: [
+            { sender: 'user', text: 'Wow, this dm automation is realistic right 🤯' },
+            { sender: 'recipient', text: "I know, it's like we're really in imessage" },
+            { sender: 'recipient', text: 'Just be thankful we\'re not on android 😭😭😭' },
+        ],
+        imageAttachmentUrl: undefined,
+        imageAttachmentIsVariable: false,
+        imessage: {
+            senderBubbleColor: undefined,
+            showReadReceipt: false,
+            readReceiptText: 'Read',
+            readReceiptTimeIsVariable: false,
+            unreadBadgeText: '67',
+            unreadBadgeIsVariable: false,
+            messageHeaderTimestampText: '',
+            messageHeaderTimeIsVariable: false,
+        },
+        instagram: {
+            userHasStory: false,
+        },
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const inputs = [];
+        if (config?.platformIsVariable) {
+            inputs.push({ id: 'platform', type: 'text', isArray: false, required: true });
+        }
+        if (config?.lightModeIsVariable) {
+            inputs.push({ id: 'light-mode', type: 'boolean', isArray: false, required: false });
+        }
+        if (config?.usernameIsVariable) {
+            inputs.push({ id: 'username', type: 'text', isArray: false, required: true });
+        }
+        if (config?.timeIsVariable) {
+            inputs.push({ id: 'time', type: 'text', isArray: false, required: false });
+        }
+        if (config?.profilePicIsVariable) {
+            inputs.push({ id: 'profile-pic', type: 'image', isArray: false, required: false });
+        }
+        if (config?.messagesIsVariable) {
+            inputs.push({ id: 'messages', type: 'object', isArray: true, required: true });
+        }
+        if (config?.imageAttachmentIsVariable) {
+            inputs.push({ id: 'image-attachment', type: 'image', isArray: false, required: false });
+        }
+        // iMessage-specific
+        if (config?.platform === 'imessage') {
+            if (config.imessage?.showReadReceipt && config.imessage?.readReceiptTimeIsVariable) {
+                inputs.push({ id: 'read-receipt-time', type: 'text', isArray: false, required: false });
+            }
+            if (config.imessage?.unreadBadgeIsVariable) {
+                inputs.push({ id: 'unread-badge', type: 'text', isArray: false, required: false });
+            }
+            if (config.imessage?.messageHeaderTimeIsVariable) {
+                inputs.push({ id: 'message-header-time', type: 'text', isArray: false, required: false });
+            }
+        }
+        return {
+            inputs,
+            outputs: [{ id: 'output', type: 'image', isArray: false, required: true }],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/custom-model.d.ts

@@ -0,0 +1,19 @@
+type CustomModelOutputType = 'image' | 'video' | 'audio';
+interface CustomModelInputParam {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+    default?: unknown;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    modelId: string;
+    modelName: string;
+    outputType: CustomModelOutputType;
+    inputParams: CustomModelInputParam[];
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type CustomModelConfig = typeof definition.defaults;

package/dist/automations/nodes/custom-model.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'custom-model',
+    label: 'Custom Model',
+    description: 'Call any fal.ai model',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        modelId: '',
+        modelName: '',
+        outputType: 'image',
+        inputParams: [],
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const inputParams = config?.inputParams ?? [];
+        const outputType = config?.outputType ?? 'image';
+        // Generate input ports from inputParams
+        // Only params with name 'prompt' or type image/video/audio become input ports
+        const inputs = inputParams
+            .filter(param => param.name === 'prompt' ||
+            param.type === 'image' ||
+            param.type === 'video' ||
+            param.type === 'audio')
+            .map(param => ({
+            id: param.name,
+            type: (param.type === 'image' || param.type === 'video' || param.type === 'audio')
+                ? param.type
+                : 'text',
+            isArray: false,
+            required: param.required,
+        }));
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: outputType,
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/deduplicate.d.ts

@@ -0,0 +1,8 @@
+import type { DeduplicationLevel } from '../../render/types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    deduplication: DeduplicationLevel;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type DeduplicateConfig = typeof definition.defaults;