ugcinc 4.0.2 → 4.1.0

package/dist/accounts.d.ts

@@ -1,5 +1,150 @@
 import { BaseClient } from './base';
-import type { Account, AccountTask, GetAccountsParams, GetAccountStatusParams, UpdateAccountInfoParams, UpdateAccountInfoResponse, UpdateAccountSocialParams, UpdateAccountSocialResponse, DeleteAccountPostsParams, DeleteAccountPostsResponse, ResetWarmupParams, ResetWarmupResponse, ApiResponse } from './types';
+import type { ApiResponse } from './types';
+export interface Account {
+    id: string;
+    org_id: string;
+    type: string;
+    tag: string | null;
+    org_group: string | null;
+    user_group: string | null;
+    username: string | null;
+    nick_name: string | null;
+    pfp_url: string | null;
+    bio: string | null;
+    warmup_enabled: boolean | null;
+    warmup_version: 'original' | 'v1_smart' | 'v2_smart' | null;
+    post_version: 'original' | 'v1_custom' | null;
+    description: string | null;
+    keywords: string | null;
+    profiles: string | null;
+    niches: string | null;
+    age_range: string | null;
+    sex: string | null;
+    status: 'uninitialized' | 'pending' | 'initialized' | 'setup' | 'warming' | 'warmed' | 'needs_replacement' | 'error' | 'failed' | 'deleted';
+    phone_type: 'physical_iphone' | 'physical_android' | 'emulated_android' | 'social_api' | null;
+    oneup_social_network_id?: string | null;
+    oneup_category_id?: string | null;
+    metadata?: {
+        pending_info_change?: {
+            nick_name?: string;
+            pfp_url?: string;
+            bio?: string;
+            requested_at?: string;
+        };
+        failure_reason?: string;
+        error_type?: 'needs_replacement' | 'change_account';
+        [key: string]: unknown;
+    } | null;
+}
+export interface AccountStat {
+    id: string;
+    account_id: string;
+    followers: number | null;
+    following: number | null;
+    views: number | null;
+    likes: number | null;
+    created_at: string;
+}
+export interface AccountTask {
+    id: string;
+    account_id: string;
+    type: string;
+    status: string;
+    scheduled_time: string | null;
+    edit_profile_info: EditProfileInfo | null;
+    created_at: string;
+}
+export interface EditProfileInfo {
+    avatarUrl?: string;
+    nickName?: string;
+    bio?: string;
+}
+export interface GetAccountsParams {
+    tag?: string;
+    org_group?: string;
+    user_group?: string;
+    status?: 'uninitialized' | 'pending' | 'initialized' | 'setup' | 'warming' | 'warmed' | 'needs_replacement' | 'error' | 'failed' | 'deleted';
+}
+export interface GetAccountStatsParams {
+    accountIds?: string[];
+    startDate?: string;
+    endDate?: string;
+    tag?: string;
+    org_group?: string;
+    user_group?: string;
+}
+export interface GetAccountStatusParams {
+    accountIds?: string[];
+    includeCompleted?: boolean;
+}
+export interface AccountInfoUpdate {
+    accountId: string;
+    tag?: string;
+    org_group?: string;
+    user_group?: string;
+    keywords?: string;
+    profiles?: string;
+    description?: string;
+    warmupVersion?: 'original' | 'v1_smart' | 'v2_smart';
+    postVersion?: 'original' | 'v1_custom';
+    phoneType?: 'physical_iphone' | 'physical_android' | 'emulated_android' | 'social_api';
+}
+export interface UpdateAccountInfoParams {
+    updates: AccountInfoUpdate[];
+}
+export interface AccountInfoUpdateResult {
+    accountId: string;
+    success: boolean;
+    account?: Account;
+    error?: string;
+}
+export interface UpdateAccountInfoResponse {
+    message: string;
+    successful: number;
+    failed: number;
+    results: AccountInfoUpdateResult[];
+}
+export interface AccountSocialUpdate {
+    accountId: string;
+    avatarUrl?: string;
+    nickName?: string;
+    bio?: string;
+}
+export interface UpdateAccountSocialParams {
+    updates: AccountSocialUpdate[];
+}
+export interface AccountSocialUpdateResult {
+    accountId: string;
+    success: boolean;
+    error?: string;
+}
+export interface UpdateAccountSocialResponse {
+    message: string;
+    successful: number;
+    failed: number;
+    results: AccountSocialUpdateResult[];
+}
+export interface DeleteAccountPostsParams {
+    accountIds: string[];
+}
+export interface DeleteAccountPostsResponse {
+    message: string;
+    successful: number;
+    failed: number;
+    errors?: Array<{
+        accountId: string;
+        error: string;
+    }>;
+}
+export interface ResetWarmupParams {
+    accountId: string;
+    delete_activity?: boolean;
+}
+export interface ResetWarmupResponse {
+    message: string;
+    tasks_affected: number;
+    action: 'deleted' | 'reset';
+}
 /**
  * Client for managing accounts
  */

package/dist/automations/index.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Automations API Client
+ *
+ * Provides methods to interact with the UGC Inc Automations API.
+ * For graph logic (validation, port computation, connections), use graph-controller.ts
+ */
+import type { WorkflowDefinition, AutomationTemplate, AutomationRun, ExecutorNode, ExecutionEdge, AutomationExport, AutomationRunExport } from './types';
+import type { ApiResponse } from '../types';
+import { BaseClient } from '../base';
+export declare class AutomationsClient extends BaseClient {
+    /**
+     * List all automation templates for an organization
+     */
+    listTemplates(params: {
+        orgId: string;
+    }): Promise<ApiResponse<AutomationTemplate[]>>;
+    /**
+     * Get a specific automation template
+     */
+    getTemplate(params: {
+        templateId: string;
+    }): Promise<ApiResponse<AutomationTemplate>>;
+    /**
+     * Create or update an automation template
+     * @param templateId - If provided, updates existing template instead of creating new one
+     * @param skipValidation - If true, skips workflow validation (for saving drafts)
+     */
+    createTemplate(params: {
+        orgId: string;
+        name: string;
+        description?: string;
+        workflowDefinition: WorkflowDefinition;
+        templateId?: string;
+        skipValidation?: boolean;
+    }): Promise<ApiResponse<string>>;
+    /**
+     * Delete an automation template
+     */
+    deleteTemplate(params: {
+        templateId: string;
+    }): Promise<ApiResponse<null>>;
+    /**
+     * Run an automation template
+     * @param variableInputs - Optional map of variable node IDs to their runtime values
+     * @param saveAsPreview - If true, saves the output as a preview for sub-workflows
+     * @param tag - Optional tag for organizing runs
+     */
+    run(params: {
+        templateId: string;
+        orgId: string;
+        variableInputs?: Record<string, string>;
+        saveAsPreview?: boolean;
+        tag?: string;
+    }): Promise<ApiResponse<{
+        runId: string;
+    }>>;
+    /**
+     * Get automation run status
+     * Returns executors (expanded nodes) and edges (data flow connections)
+     */
+    getStatus(params: {
+        runId: string;
+    }): Promise<ApiResponse<{
+        run: AutomationRun;
+        executors: ExecutorNode[];
+        edges: ExecutionEdge[];
+    }>>;
+    /**
+     * List automation runs for a template
+     */
+    listRuns(params: {
+        templateId: string;
+        limit?: number;
+    }): Promise<ApiResponse<Array<{
+        run: AutomationRun;
+        nodeCount: number;
+    }>>>;
+    /**
+     * List all automation runs for the organization (across all templates)
+     * @param templateId - Optional filter to show runs from a specific automation only
+     */
+    listAllRuns(params: {
+        limit?: number;
+        reviewStatus?: 'pending_review' | 'approved' | 'rejected' | 'all';
+        templateId?: string;
+    }): Promise<ApiResponse<Array<{
+        run: AutomationRun;
+        templateName: string;
+        nodeCount: number;
+        completedNodeCount: number;
+    }>>>;
+    /**
+     * Update review status for a run
+     */
+    updateReviewStatus(params: {
+        runId: string;
+        reviewStatus: 'approved' | 'rejected';
+    }): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    /**
+     * Validate a workflow definition without creating it
+     */
+    validateWorkflow(params: {
+        workflowDefinition: WorkflowDefinition;
+    }): Promise<ApiResponse<{
+        valid: boolean;
+        errors: string[];
+    }>>;
+    /**
+     * Delete an automation run
+     */
+    deleteRun(params: {
+        runId: string;
+    }): Promise<ApiResponse<null>>;
+    /**
+     * Export automation template for debugging
+     * Returns the complete template definition with nodes and connections
+     */
+    exportTemplate(params: {
+        templateId: string;
+    }): Promise<ApiResponse<AutomationExport>>;
+    /**
+     * Export automation run for debugging
+     * Returns the complete run data including execution state, executor outputs, and edge values
+     */
+    exportRun(params: {
+        runId: string;
+    }): Promise<ApiResponse<AutomationRunExport>>;
+    /**
+     * Stop a running automation
+     * Marks the run as failed and all pending executors as failed.
+     * In-flight executors will complete gracefully.
+     */
+    stop(params: {
+        runId: string;
+    }): Promise<ApiResponse<null>>;
+    /**
+     * Get the recurrence status for an automation template
+     * Returns whether the template has a recurrence node, if it's published, and schedule info
+     */
+    getRecurrenceStatus(params: {
+        templateId: string;
+    }): Promise<ApiResponse<{
+        hasRecurrence: boolean;
+        isPublished: boolean;
+        nextRunAt: string | null;
+        lastRunAt: string | null;
+    }>>;
+    /**
+     * Publish an automation - enables recurrence scheduling
+     * The automation will run automatically based on its recurrence configuration
+     */
+    publish(params: {
+        templateId: string;
+    }): Promise<ApiResponse<null>>;
+    /**
+     * Unpublish an automation - disables recurrence and stops the scheduler workflow
+     * No more scheduled runs will occur until the automation is published again
+     */
+    unpublish(params: {
+        templateId: string;
+    }): Promise<ApiResponse<null>>;
+    /**
+     * Run an automation once immediately
+     * If the automation is published, this also updates the schedule (restarts the scheduler)
+     * This is used for the "Run Once" button on recurrence automations
+     */
+    runOnce(params: {
+        templateId: string;
+    }): Promise<ApiResponse<{
+        runIds: string[];
+    }>>;
+}

package/dist/automations/index.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Automations API Client
+ *
+ * Provides methods to interact with the UGC Inc Automations API.
+ * For graph logic (validation, port computation, connections), use graph-controller.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationsClient = void 0;
+const base_1 = require("../base");
+class AutomationsClient extends base_1.BaseClient {
+    /**
+     * List all automation templates for an organization
+     */
+    async listTemplates(params) {
+        return this.request('/automations/list', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Get a specific automation template
+     */
+    async getTemplate(params) {
+        return this.request('/automations/get', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Create or update an automation template
+     * @param templateId - If provided, updates existing template instead of creating new one
+     * @param skipValidation - If true, skips workflow validation (for saving drafts)
+     */
+    async createTemplate(params) {
+        return this.request('/automations/create', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Delete an automation template
+     */
+    async deleteTemplate(params) {
+        return this.request('/automations/delete', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Run an automation template
+     * @param variableInputs - Optional map of variable node IDs to their runtime values
+     * @param saveAsPreview - If true, saves the output as a preview for sub-workflows
+     * @param tag - Optional tag for organizing runs
+     */
+    async run(params) {
+        return this.request('/automations/run', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Get automation run status
+     * Returns executors (expanded nodes) and edges (data flow connections)
+     */
+    async getStatus(params) {
+        return this.request('/automations/status', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List automation runs for a template
+     */
+    async listRuns(params) {
+        return this.request('/automations/list-runs', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List all automation runs for the organization (across all templates)
+     * @param templateId - Optional filter to show runs from a specific automation only
+     */
+    async listAllRuns(params) {
+        return this.request('/automations/list-all-runs', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Update review status for a run
+     */
+    async updateReviewStatus(params) {
+        return this.request('/automations/update-review-status', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Validate a workflow definition without creating it
+     */
+    async validateWorkflow(params) {
+        return this.request('/automations/validate', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Delete an automation run
+     */
+    async deleteRun(params) {
+        return this.request('/automations/delete-run', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Export automation template for debugging
+     * Returns the complete template definition with nodes and connections
+     */
+    async exportTemplate(params) {
+        return this.request('/automations/export', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Export automation run for debugging
+     * Returns the complete run data including execution state, executor outputs, and edge values
+     */
+    async exportRun(params) {
+        return this.request('/automations/export-run', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Stop a running automation
+     * Marks the run as failed and all pending executors as failed.
+     * In-flight executors will complete gracefully.
+     */
+    async stop(params) {
+        return this.request('/automations/stop', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    // ===========================================================================
+    // Recurrence Scheduling
+    // ===========================================================================
+    /**
+     * Get the recurrence status for an automation template
+     * Returns whether the template has a recurrence node, if it's published, and schedule info
+     */
+    async getRecurrenceStatus(params) {
+        return this.request('/automations/recurrence-status', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Publish an automation - enables recurrence scheduling
+     * The automation will run automatically based on its recurrence configuration
+     */
+    async publish(params) {
+        return this.request('/automations/publish', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Unpublish an automation - disables recurrence and stops the scheduler workflow
+     * No more scheduled runs will occur until the automation is published again
+     */
+    async unpublish(params) {
+        return this.request('/automations/unpublish', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Run an automation once immediately
+     * If the automation is published, this also updates the schedule (restarts the scheduler)
+     * This is used for the "Run Once" button on recurrence automations
+     */
+    async runOnce(params) {
+        return this.request('/automations/run-once', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+}
+exports.AutomationsClient = AutomationsClient;

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

@@ -0,0 +1,18 @@
+/**
+ * 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[];
+    outputMode: "per-input";
+    selectionMode: "random";
+}>;
+export default definition;
+export type AccountConfig = typeof definition.defaults;

package/dist/automations/nodes/account.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'account',
+    label: 'Account',
+    description: 'Select accounts to post from',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        accountIds: [],
+        outputMode: 'per-input',
+        selectionMode: 'random',
+    },
+    computePorts: () => ({
+        inputs: [],
+        outputs: [
+            {
+                id: 'account',
+                type: 'account',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

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

@@ -0,0 +1,64 @@
+/**
+ * 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;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type AutoCaptionConfig = typeof definition.defaults;

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

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