ugcinc 4.0.2 → 4.1.1

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+exports.default = (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',
+        imageInputs: [],
+        socialAudioIsVariable: false,
+        socialAudioSelectedIds: [],
+        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?.imageInputs ?? [{ id: 'image1' }, { id: 'image2' }, { id: 'image3' }];
+                for (const input of imageInputs) {
+                    inputs.push({ id: input.id, type: 'image', isArray: false, required: true });
+                }
+            }
+        }
+        inputs.push({ id: 'account', type: 'account', isArray: false, required: true }, { id: 'caption', type: 'text', isArray: false, required: false });
+        if (config?.socialAudioIsVariable) {
+            inputs.push({ id: 'social-audio', type: 'audio', isArray: false, required: false });
+        }
+        return { inputs, outputs: [] };
+    },
+});

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

@@ -0,0 +1,21 @@
+import { type InputType } from './types';
+export interface BranchDefinition {
+    key: string;
+}
+interface BranchValueConfig {
+    inputType?: InputType;
+}
+export interface PassthroughInput {
+    id: string;
+    type: string;
+    isArray?: boolean;
+    branchValues?: Record<string, BranchValueConfig>;
+}
+declare const _default: import("./types").NodeDefinition<"generator", {
+    branches: BranchDefinition[];
+    passthroughInputs: PassthroughInput[];
+    defaultBranchKey: string;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default _default;

package/dist/automations/nodes/branch.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+exports.default = (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 = [];
+        inputs.push({ id: 'key', type: 'text', isArray: false, required: 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,
+                    });
+                }
+            }
+            outputs.push({ id: passthrough.id, type: pType, isArray: pIsArray, required: true });
+        }
+        return { inputs, outputs };
+    },
+});

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

@@ -0,0 +1,7 @@
+declare const _default: import("./types").NodeDefinition<"generator", {
+    expectedCount: number | undefined;
+    forEachTemplateId: string | undefined;
+    outputMode: "single";
+    selectionMode: null;
+}, false>;
+export default _default;

package/dist/automations/nodes/collect.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+exports.default = (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: {
+        expectedCount: undefined,
+        forEachTemplateId: undefined,
+        outputMode: 'single',
+        selectionMode: null,
+    },
+    computePorts: ({ getConnectedOutput }) => {
+        const inputTypes = ['image', 'video', 'audio', 'text', 'object', 'boolean', 'number'];
+        const defaultOutputTypes = ['image', 'video', 'audio', 'text', 'object'];
+        let outputType = defaultOutputTypes;
+        let outputIsArray = true;
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('value');
+            if (connectedOutput?.type) {
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType) && !connectedOutput.isArray) {
+                    outputType = connType;
+                    outputIsArray = true;
+                }
+            }
+        }
+        const inputs = [
+            {
+                id: 'value',
+                type: inputTypes,
+                isArray: false,
+                required: true,
+            },
+        ];
+        const outputs = [
+            {
+                id: 'array',
+                type: outputType,
+                isArray: outputIsArray,
+                required: true,
+            },
+        ];
+        return { inputs, outputs };
+    },
+});

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

@@ -0,0 +1,8 @@
+import type { ResolvedPorts } from '../types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    workflowTemplateId: string | undefined;
+    resolvedPorts: ResolvedPorts | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

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

@@ -0,0 +1,61 @@
+"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,
+        resolvedPorts: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: async ({ config, client }) => {
+        // Use cached resolved ports if available
+        if (config?.resolvedPorts) {
+            return {
+                inputs: config.resolvedPorts.inputs ?? [],
+                outputs: config.resolvedPorts.outputs ?? [],
+            };
+        }
+        // If no templateId selected, return empty ports
+        const templateId = config?.workflowTemplateId;
+        if (!templateId || !client) {
+            return { inputs: [], outputs: [] };
+        }
+        // Fetch the sub-workflow template
+        const response = await client.getTemplate({ templateId });
+        if (!response.ok) {
+            return { inputs: [], outputs: [] };
+        }
+        const template = response.data;
+        // Find the manual-trigger node to get input definitions
+        const manualTrigger = template.nodes.find(n => n.type === 'manual-trigger');
+        const triggerOutputs = manualTrigger?.type === 'manual-trigger'
+            ? (manualTrigger.config?.outputs ?? [])
+            : [];
+        // Convert trigger outputs to compose-workflow inputs
+        const inputs = triggerOutputs.map(output => ({
+            id: output.id,
+            type: output.type,
+            isArray: output.isArray ?? false,
+            required: true,
+            ...(output.type === 'enum' && output.enumOptions ? { enumOptions: output.enumOptions } : {}),
+        }));
+        // Use template's output_schema for outputs
+        const outputSchema = template.output_schema ?? {};
+        const outputs = Object.entries(outputSchema).map(([id, schema]) => ({
+            id,
+            type: schema.type,
+            isArray: false,
+            required: true,
+        }));
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,35 @@
+import { type InputType } from './types';
+type DmPlatform = 'imessage' | 'instagram';
+export interface CreateDmMessage {
+    sender: 'user' | 'recipient';
+    text: string;
+    hasImage?: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    platform: DmPlatform;
+    platformInputType: InputType;
+    lightMode: boolean;
+    lightModeInputType: InputType;
+    username: string;
+    usernameInputType: InputType;
+    time: string;
+    timeInputType: InputType;
+    profilePicUrl: string;
+    profilePicInputType: InputType;
+    messages: CreateDmMessage[];
+    messagesInputType: InputType;
+    imageAttachmentUrl: string | undefined;
+    imageAttachmentInputType: InputType;
+    imessageSenderBubbleColor: string | undefined;
+    imessageShowReadReceipt: boolean;
+    imessageReadReceiptText: string;
+    imessageReadReceiptTimeInputType: InputType;
+    imessageUnreadBadgeText: string;
+    imessageUnreadBadgeInputType: InputType;
+    imessageMessageHeaderTimestampText: string;
+    imessageMessageHeaderTimeInputType: InputType;
+    instagramUserHasStory: boolean;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

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

@@ -0,0 +1,86 @@
+"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',
+        platformInputType: 'static',
+        lightMode: true,
+        lightModeInputType: 'static',
+        username: '',
+        usernameInputType: 'static',
+        time: '9:41',
+        timeInputType: 'static',
+        profilePicUrl: 'https://ugcinc.co/logo.png',
+        profilePicInputType: 'static',
+        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 😭😭😭' },
+        ],
+        messagesInputType: 'static',
+        imageAttachmentUrl: undefined,
+        imageAttachmentInputType: 'static',
+        // iMessage-specific
+        imessageSenderBubbleColor: undefined,
+        imessageShowReadReceipt: false,
+        imessageReadReceiptText: 'Read',
+        imessageReadReceiptTimeInputType: 'static',
+        imessageUnreadBadgeText: '67',
+        imessageUnreadBadgeInputType: 'static',
+        imessageMessageHeaderTimestampText: '',
+        imessageMessageHeaderTimeInputType: 'static',
+        // Instagram-specific
+        instagramUserHasStory: false,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const inputs = [];
+        if (config?.platformInputType === 'variable') {
+            inputs.push({ id: 'platform', type: 'text', isArray: false, required: true });
+        }
+        if (config?.lightModeInputType === 'variable') {
+            inputs.push({ id: 'light-mode', type: 'boolean', isArray: false, required: false });
+        }
+        if (config?.usernameInputType === 'variable') {
+            inputs.push({ id: 'username', type: 'text', isArray: false, required: true });
+        }
+        if (config?.timeInputType === 'variable') {
+            inputs.push({ id: 'time', type: 'text', isArray: false, required: false });
+        }
+        if (config?.profilePicInputType === 'variable') {
+            inputs.push({ id: 'profile-pic', type: 'image', isArray: false, required: false });
+        }
+        if (config?.messagesInputType === 'variable') {
+            inputs.push({ id: 'messages', type: 'object', isArray: true, required: true });
+        }
+        if (config?.imageAttachmentInputType === 'variable') {
+            inputs.push({ id: 'image-attachment', type: 'image', isArray: false, required: false });
+        }
+        // iMessage-specific
+        if (config?.platform === 'imessage') {
+            if (config.imessageShowReadReceipt && config.imessageReadReceiptTimeInputType === 'variable') {
+                inputs.push({ id: 'read-receipt-time', type: 'text', isArray: false, required: false });
+            }
+            if (config.imessageUnreadBadgeInputType === 'variable') {
+                inputs.push({ id: 'unread-badge', type: 'text', isArray: false, required: false });
+            }
+            if (config.imessageMessageHeaderTimeInputType === 'variable') {
+                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,18 @@
+export type CustomModelOutputType = 'image' | 'video' | 'audio';
+export 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;
+}, false>;
+export default definition;

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,7 @@
+import type { DeduplicationLevel } from '../../render/types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    deduplication: DeduplicationLevel;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/deduplicate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'deduplicate',
+    label: 'Mass Repost',
+    description: 'Make videos unique for safe reposting',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        deduplication: 'level3',
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'video',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

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

@@ -0,0 +1,25 @@
+import { type InputType } from './types';
+type IndexExpression = {
+    type: 'single';
+    index: number;
+} | {
+    type: 'range';
+    start: number;
+    end: number;
+} | {
+    type: 'list';
+    indexes: number[];
+};
+interface DestructureSelection {
+    portId: string;
+    indexExpr: IndexExpression;
+    inputType?: InputType;
+    propertyPath?: string;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    selections: DestructureSelection[];
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;
+export type { DestructureSelection, IndexExpression };

package/dist/automations/nodes/destructure.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'destructure',
+    label: 'Destructure',
+    description: 'Extract specific elements from an array by index or range',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        selections: [],
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config, getConnectedOutput }) => {
+        const selections = config?.selections ?? [];
+        // Input accepts any array type
+        const inputTypes = ['image', 'video', 'audio', 'text', 'object'];
+        const inputs = [
+            {
+                id: 'array',
+                type: inputTypes,
+                isArray: true,
+                required: true,
+            },
+        ];
+        const outputs = [];
+        // Determine base type from connected input
+        let baseType = 'object';
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('array');
+            if (connectedOutput?.type && connectedOutput.isArray) {
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType)) {
+                    baseType = connType;
+                }
+            }
+        }
+        for (const selection of selections) {
+            // If variable, add input port for index expression
+            if (selection.inputType === 'variable') {
+                inputs.push({
+                    id: `idx-${selection.portId}`,
+                    type: 'text',
+                    isArray: false,
+                    required: true,
+                });
+            }
+            // Output type depends on index expression:
+            // - 'single' -> single item (isArray: false)
+            // - 'range' or 'list' -> array of items (isArray: true)
+            const outputIsArray = selection.indexExpr.type !== 'single';
+            outputs.push({
+                id: selection.portId,
+                type: baseType,
+                isArray: outputIsArray,
+                required: true,
+            });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/for-each.d.ts

@@ -0,0 +1,22 @@
+import type { BasePortType } from '../types';
+interface ForEachOutputProperty {
+    portId: string;
+    propertyPath: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+interface ForEachInputPort {
+    id: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputProperties: ForEachOutputProperty[];
+    inputPorts: ForEachInputPort[];
+    exposeItem: boolean;
+    exposeIndex: boolean;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;
+export type { ForEachOutputProperty, ForEachInputPort };