ugcinc 4.1.0 → 4.1.1

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

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

package/dist/automations/nodes/account.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
+exports.default = (0, types_1.defineNode)({
     nodeId: 'account',
     label: 'Account',
     description: 'Select accounts to post from',
@@ -26,4 +26,3 @@ const definition = (0, types_1.defineNode)({
         ],
     }),
 });
-exports.default = definition;

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

@@ -1,64 +1,23 @@
-/**
- * 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;
+type AutoCaptionPreset = 'hormozi' | 'minimal' | 'bold-pop' | 'clean' | 'neon';
+type AutoCaptionFontWeight = 'normal' | 'bold' | 'black';
+type AutoCaptionPosition = 'top' | 'center' | 'bottom';
+declare const _default: import("./types").NodeDefinition<"generator", {
+    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;
-}>;
-export default definition;
-export type AutoCaptionConfig = typeof definition.defaults;
+}, false>;
+export default _default;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
+exports.default = (0, types_1.defineNode)({
     nodeId: 'auto-caption',
     label: 'Auto Caption',
     description: 'Add TikTok-style captions to videos',
@@ -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,
     },
@@ -43,4 +47,3 @@ const definition = (0, types_1.defineNode)({
         ],
     }),
 });
-exports.default = definition;

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
- */
-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", {
+import { type InputType } from './types';
+type AutoPostMode = 'video' | 'slideshow';
+type PostSchedulingMode = 'scheduled' | 'queue';
+declare const _default: 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,5 @@ declare const definition: import("./types").NodeDefinition<"terminal", {
     requireApproval: boolean;
     outputMode: null;
     selectionMode: null;
-}>;
-export default definition;
-export type AutoPostConfig = typeof definition.defaults;
+}, false>;
+export default _default;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
+exports.default = (0, types_1.defineNode)({
     nodeId: 'auto-post',
     label: 'Auto Post',
     description: 'Publish a video or slideshow',
@@ -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,19 +37,16 @@ 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 });
         }
         return { inputs, outputs: [] };
     },
 });
-exports.default = definition;

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

@@ -1,58 +1,21 @@
-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 */
+declare const _default: import("./types").NodeDefinition<"generator", {
     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;
+}, false>;
+export default _default;

package/dist/automations/nodes/branch.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
+exports.default = (0, types_1.defineNode)({
     nodeId: 'branch',
     label: 'Branch',
     description: 'Route inputs based on a key match',
@@ -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,10 +39,8 @@ const definition = (0, types_1.defineNode)({
                     });
                 }
             }
-            // 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

@@ -1,16 +1,7 @@
-declare const definition: import("./types").NodeDefinition<"generator", {
+declare const _default: import("./types").NodeDefinition<"generator", {
+    expectedCount: number | undefined;
+    forEachTemplateId: string | undefined;
     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;
-}
+}, false>;
+export default _default;

package/dist/automations/nodes/collect.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
+exports.default = (0, types_1.defineNode)({
     nodeId: 'collect',
     label: 'Collect',
     description: 'Collect outputs from a for-each loop into an array',
@@ -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 = [
@@ -53,4 +49,3 @@ const definition = (0, types_1.defineNode)({
         return { inputs, outputs };
     },
 });
-exports.default = definition;

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

@@ -1,21 +1,8 @@
-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;

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 };
     },