ugcinc 4.1.0 → 4.1.2

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

@@ -1,18 +1,7 @@
-/**
- * Account node configuration - source node for selecting accounts to post from
- */
-export interface AccountNodeConfig {
-    /** List of account IDs to choose from */
-    accountIds: string[];
-    /** Selection mode */
-    selectionConfig?: {
-        mode?: 'random' | 'sequential';
-    };
-}
 declare const definition: import("./types").NodeDefinition<"source", {
-    accountIds: never[];
+    accountIds: string[];
     outputMode: "per-input";
     selectionMode: "random";
-}>;
+}, false>;
 export default definition;
-export type AccountConfig = typeof definition.defaults;
+export type AccountNodeConfig = typeof definition.defaults;

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

@@ -1,64 +1,24 @@
-/**
- * Auto Caption preset styles
- */
 export type AutoCaptionPreset = 'hormozi' | 'minimal' | 'bold-pop' | 'clean' | 'neon';
-/**
- * Auto Caption font weight options
- */
 export type AutoCaptionFontWeight = 'normal' | 'bold' | 'black';
-/**
- * Auto Caption position options
- */
 export type AutoCaptionPosition = 'top' | 'center' | 'bottom';
-/**
- * Auto Caption node configuration - adds TikTok-style captions to videos
- */
-export interface AutoCaptionNodeConfig {
-    /** Preset style (if set, other values are derived from preset) */
-    preset?: AutoCaptionPreset;
-    /** Google Font name */
-    fontName?: string;
-    /** Font size in pixels (20-150) */
-    fontSize?: number;
-    /** Font weight */
-    fontWeight?: AutoCaptionFontWeight;
-    /** Main text color */
-    fontColor?: string;
-    /** Highlighted/active word color */
-    highlightColor?: string;
-    /** Text stroke/outline color */
-    strokeColor?: string;
-    /** Stroke width in pixels (0-10) */
-    strokeWidth?: number;
-    /** Background color behind text */
-    backgroundColor?: string;
-    /** Vertical position */
-    position?: AutoCaptionPosition;
-    /** Vertical offset in pixels from position anchor */
-    yOffset?: number;
-    /** Maximum width as percentage of video width (0-100) */
-    maxWidth?: number;
-    /** Words per subtitle segment (1-12) */
-    wordsPerSubtitle?: number;
-    /** Enable bounce animation effect */
-    enableAnimation?: boolean;
-    /** Language code for transcription */
-    language?: string;
-}
 declare const definition: import("./types").NodeDefinition<"generator", {
-    fontName: string;
-    fontSize: number;
-    fontWeight: string;
-    fontColor: string;
-    highlightColor: string;
-    strokeColor: string;
-    strokeWidth: number;
-    position: string;
-    wordsPerSubtitle: number;
-    enableAnimation: boolean;
-    language: string;
+    preset: AutoCaptionPreset;
+    fontName: string | undefined;
+    fontSize: number | undefined;
+    fontWeight: AutoCaptionFontWeight | undefined;
+    fontColor: string | undefined;
+    highlightColor: string | undefined;
+    strokeColor: string | undefined;
+    strokeWidth: number | undefined;
+    backgroundColor: string | undefined;
+    position: AutoCaptionPosition | undefined;
+    yOffset: number | undefined;
+    maxWidth: number | undefined;
+    wordsPerSubtitle: number | undefined;
+    enableAnimation: boolean | undefined;
+    language: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type AutoCaptionConfig = typeof definition.defaults;
+export type AutoCaptionNodeConfig = typeof definition.defaults;

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

@@ -10,17 +10,21 @@ const definition = (0, types_1.defineNode)({
     outputModes: ['per-input', 'single'],
     selectionModes: null,
     defaults: {
-        fontName: 'Montserrat',
-        fontSize: 80,
-        fontWeight: 'bold',
-        fontColor: 'white',
-        highlightColor: 'yellow',
-        strokeColor: 'black',
-        strokeWidth: 3,
-        position: 'bottom',
-        wordsPerSubtitle: 3,
-        enableAnimation: true,
-        language: 'en',
+        preset: 'hormozi',
+        fontName: undefined,
+        fontSize: undefined,
+        fontWeight: undefined,
+        fontColor: undefined,
+        highlightColor: undefined,
+        strokeColor: undefined,
+        strokeWidth: undefined,
+        backgroundColor: undefined,
+        position: undefined,
+        yOffset: undefined,
+        maxWidth: undefined,
+        wordsPerSubtitle: undefined,
+        enableAnimation: undefined,
+        language: undefined,
         outputMode: 'per-input',
         selectionMode: null,
     },

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

@@ -1,73 +1,15 @@
-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
- */
+import { type InputType } from './types';
 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[];
-    };
-}
+export type PostSchedulingMode = 'scheduled' | 'queue';
 declare const definition: import("./types").NodeDefinition<"terminal", {
     mode: AutoPostMode;
     inputType: InputType;
-    inputs: Array<{
+    imageInputs: Array<{
         id: string;
     }>;
     socialAudioIsVariable: boolean;
-    schedulingMode: string;
+    socialAudioSelectedIds: string[];
+    schedulingMode: PostSchedulingMode;
     minDistanceHours: number;
     maxPostsPerDay: number;
     randomWindowStart: string;
@@ -76,6 +18,6 @@ declare const definition: import("./types").NodeDefinition<"terminal", {
     requireApproval: boolean;
     outputMode: null;
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type AutoPostConfig = typeof definition.defaults;
+export type AutoPostNodeConfig = typeof definition.defaults;

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

@@ -12,8 +12,9 @@ const definition = (0, types_1.defineNode)({
     defaults: {
         mode: 'video',
         inputType: 'static',
-        inputs: [],
+        imageInputs: [],
         socialAudioIsVariable: false,
+        socialAudioSelectedIds: [],
         schedulingMode: 'scheduled',
         minDistanceHours: 4,
         maxPostsPerDay: 3,
@@ -36,15 +37,13 @@ const definition = (0, types_1.defineNode)({
                 inputs.push({ id: 'images', type: 'object', isArray: false, required: true });
             }
             else {
-                const imageInputs = config?.inputs ?? [{ id: 'image1' }, { id: 'image2' }, { id: 'image3' }];
+                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 });
                 }
             }
         }
-        // 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 });
         }

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

@@ -1,58 +1,22 @@
-import type { OutputMode } from '../types';
-import type { PassthroughInput } from './types';
-import type { RandomRouteObjectField } from './random-route';
-/**
- * Branch node branch definition
- */
+import { type InputType } from './types';
 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) */
+interface BranchValueConfig {
+    inputType?: InputType;
+}
+export interface PassthroughInput {
     id: string;
-    /** The value type */
-    type: 'image' | 'video' | 'audio' | 'text' | 'number' | 'boolean' | 'account' | 'object';
-    /** Whether this is an array type */
+    type: string;
     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;
-    }[];
+    branches: BranchDefinition[];
     passthroughInputs: PassthroughInput[];
     defaultBranchKey: string;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type BranchConfig = typeof definition.defaults;
+export type BranchNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/branch.js

@@ -24,9 +24,7 @@ const definition = (0, types_1.defineNode)({
         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;
@@ -41,7 +39,6 @@ const definition = (0, types_1.defineNode)({
                     });
                 }
             }
-            // One output per passthrough
             outputs.push({ id: passthrough.id, type: pType, isArray: pIsArray, required: true });
         }
         return { inputs, outputs };

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

@@ -1,16 +1,8 @@
 declare const definition: import("./types").NodeDefinition<"generator", {
+    expectedCount: number | undefined;
+    forEachTemplateId: string | undefined;
     outputMode: "single";
     selectionMode: null;
-}>;
+}, false>;
 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;
-}
+export type CollectNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/collect.js

@@ -10,28 +10,24 @@ const definition = (0, types_1.defineNode)({
     outputModes: ['per-input', 'single'],
     selectionModes: null,
     defaults: {
-        outputMode: 'single', // Collect produces a single output after all loop iterations complete
+        expectedCount: undefined,
+        forEachTemplateId: undefined,
+        outputMode: 'single',
         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 = [

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

@@ -1,21 +1,9 @@
-import type { ResolvedPorts, EnumOption } from '../types';
-import { type ObjectSchemaField } from './types';
+import type { ResolvedPorts } 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;
-}>;
+}, false>;
 export default definition;
-export type ComposeWorkflowConfig = typeof definition.defaults;
+export type ComposeWorkflowNodeConfig = typeof definition.defaults;

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

@@ -11,30 +11,49 @@ const definition = (0, types_1.defineNode)({
     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,
+    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,
-            ...(v.variableType === 'enum' && v.enumOptions ? { enumOptions: v.enumOptions } : {}),
+            ...(output.type === 'enum' && output.enumOptions ? { enumOptions: output.enumOptions } : {}),
         }));
-        // Outputs from workflow output schema
+        // 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: schema.isArray ?? false,
+            isArray: false,
             required: true,
-            ...(schema.objectSchema && { objectSchema: schema.objectSchema }),
         }));
         return { inputs, outputs };
     },

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

@@ -1,96 +1,36 @@
-type DmPlatform = 'imessage' | 'instagram';
-/**
- * Message in a Create DM conversation
- */
+import { type InputType } from './types';
+export type DmPlatform = 'imessage' | 'instagram';
 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;
+    platformInputType: InputType;
     lightMode: boolean;
-    lightModeIsVariable: boolean;
+    lightModeInputType: InputType;
     username: string;
-    usernameIsVariable: boolean;
+    usernameInputType: InputType;
     time: string;
-    timeIsVariable: boolean;
+    timeInputType: InputType;
     profilePicUrl: string;
-    profilePicIsVariable: boolean;
-    messagesIsVariable: boolean;
+    profilePicInputType: InputType;
     messages: CreateDmMessage[];
+    messagesInputType: InputType;
     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;
-    };
+    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;
-export type CreateDmConfig = typeof definition.defaults;
+export type CreateDmNodeConfig = typeof definition.defaults;