### Install and Run TikMatrix Development Environment

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/README.md

Installs the necessary dependencies and starts the TikMatrix development server. Requires Node.js 18.x+ and Rust 1.67.x+.

```shell
npm install --global @tauri-apps/cli
npm install
npm run tauri dev
```

--------------------------------

### Run TikMatrix Agent on Android via ADB

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/README.md

Commands to list connected Android devices and start the TikMatrix agent on a specified device using ADB. The agent facilitates automation on the Android phone.

```shell
# You can find the device id by the following command.
adb devices
# Start the agent on the phone.
adb -s <device_id> shell am instrument -w -r -e debug false -e class com.github.tikmatrix.stub.Stub com.github.tikmatrix.test/androidx.test.runner.AndroidJUnitRunner
```

--------------------------------

### Unfollow User Task API Command

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/api-test.md

This example shows a `curl` command for executing an unfollow user task through the TikTok Matrix API. It sends a POST request to the task endpoint with a payload specifying the target user and the 'direct' access method.

```shell
curl -X POST http://localhost:50809/api/v1/task \
  -H "Content-Type: application/json" \
  -d '{
    "serials": ["16091FDD40050N"],
    "script_name": "unfollow",
    "script_config": {
      "target_users": ["@tikmatrix001"],
      "access_method": "direct"
    }
  }'
```

--------------------------------

### Activate License API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Activates a license key for the service. Requires a license key and a unique machine identifier. Returns license details upon successful activation.

```javascript
import { activate_license } from './src/service/index.js';

async function activateLicense() {
  try {
    const licenseData = {
      license_key: 'TIKMATRIX-XXXX-XXXX-XXXX-XXXX',
      machine_id: 'unique_machine_identifier'
    };

    const response = await activate_license(licenseData);
    if (response.code === 0) {
      console.log('License activated successfully');
      console.log('Plan:', response.data.plan);
      console.log('Expires:', response.data.expires_at);
      console.log('Max devices:', response.data.max_devices);
    }
  } catch (error) {
    console.error('Failed to activate license:', error);
  }
}
```

--------------------------------

### Create Order API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Creates a new order for a subscription plan. Specifies the desired plan, billing cycle, payment method, and currency. Returns an order ID and payment URL.

```javascript
import { create_order } from './src/service/index.js';

async function createNewOrder() {
  try {
    const orderData = {
      plan: 'pro',
      billing_cycle: 'monthly',
      payment_method: 'stripe',
      currency: 'USD'
    };

    const response = await create_order(orderData);
    console.log('Order created:', response.data.order_id);
    console.log('Payment URL:', response.data.payment_url);
    return response.data;
  } catch (error) {
    console.error('Failed to create order:', error);
    throw error;
  }
}
```

--------------------------------

### Create and Manage Support Tickets with Attachments using Javascript

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

This snippet details the process of creating, listing, and replying to support tickets. It includes functionality to attach files to new tickets and replies, manage ticket status, and retrieve ticket details. The functions interact with imported service modules for ticket operations.

```javascript
import { support_create_ticket, support_fetch_tickets, support_ticket_detail, support_append_message } from './src/service/index.js';

// Create a support ticket with attachments
async function createSupportTicket() {
  try {
    const ticketData = {
      payload: {
        title: 'Cannot connect to device',
        description: 'Device shows as offline after update',
        category: 'technical',
        priority: 'high',
        device_info: {
          serial: '16091FDD40050N',
          model: 'Samsung Galaxy S21',
          android_version: '12'
        }
      },
      attachments: [
        {
          path: 'C:/logs/device_error.log',
          fileName: 'device_error.log',
          mimeType: 'text/plain'
        },
        {
          path: 'C:/screenshots/error_screen.png',
          fileName: 'error_screen.png',
          mimeType: 'image/png'
        }
      ]
    };

    const response = await support_create_ticket(ticketData);
    console.log('Ticket created:', response.data.ticket_id);
    return response.data.ticket_id;
  } catch (error) {
    console.error('Failed to create ticket:', error);
    throw error;
  }
}

// Fetch all support tickets
async function listSupportTickets() {
  try {
    const response = await support_fetch_tickets({
      status: 'open',
      limit: 20,
      offset: 0
    });

    console.log(`Found ${response.data.length} open tickets`);
    response.data.forEach(ticket => {
      console.log(`Ticket #${ticket.id}: ${ticket.title} - ${ticket.status}`);
    });
    return response.data;
  } catch (error) {
    console.error('Failed to fetch tickets:', error);
    return [];
  }
}

// Add message to existing ticket
async function replyToTicket(ticketId) {
  try {
    const replyData = {
      payload: {
        ticket_id: ticketId,
        message: 'I tried the suggested solution but the issue persists. Attached new logs.',
        sender: 'user'
      },
      attachments: [
        {
          path: 'C:/logs/latest_error.log',
          fileName: 'latest_error.log',
          mimeType: 'text/plain'
        }
      ]
    };

    await support_append_message(replyData);
    console.log('Reply added to ticket');
  } catch (error) {
    console.error('Failed to add reply:', error);
  }
}
```

--------------------------------

### Perform Bulk Marketing Operations on TikTok

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

This snippet demonstrates how to perform bulk marketing operations on TikTok, including following users, sending direct messages, importing marketing datasets, and running super marketing campaigns. It utilizes functions like `follow_now`, `message_now`, `import_super_marketing_dataset`, and `super_marketing_run_now`. Ensure the necessary service modules are imported and that valid account and user data are provided.

```javascript
import { follow_now, message_now, comment_now, super_marketing_run_now, import_super_marketing_dataset } from './src/service/index.js';

// Bulk follow users
async function bulkFollowUsers() {
  try {
    const followData = {
      serial: '16091FDD40050N',
      account_id: 123,
      target_users: [
        '@influencer1',
        '@influencer2',
        '@targetuser3'
      ],
      access_method: 'direct',
      delay_min: 5,
      delay_max: 15
    };

    const response = await follow_now(followData);
    console.log('Bulk follow initiated:', response.data);
  } catch (error) {
    console.error('Failed to execute bulk follow:', error);
  }
}

// Send bulk direct messages
async function sendBulkMessages() {
  try {
    const messageData = {
      serial: '16091FDD40050N',
      account_id: 123,
      recipients: [
        '@user1',
        '@user2',
        '@user3'
      ],
      message: 'Hey! Check out my latest video 🔥',
      delay_min: 10,
      delay_max: 30
    };

    const response = await message_now(messageData);
    console.log('Bulk messaging started:', response.data);
  } catch (error) {
    console.error('Failed to send bulk messages:', error);
  }
}

// Import dataset for super marketing
async function importMarketingDataset() {
  try {
    const datasetData = {
      data_type: 'usernames',
      label: 'Tech Influencers Q1 2024',
      strategy: 'consume_once',
      entries: [
        '@techinfluencer1',
        '@techinfluencer2',
        '@techinfluencer3'
      ]
    };

    const response = await import_super_marketing_dataset(datasetData);
    console.log('Dataset imported:', response.data);
    return response.data.dataset_id;
  } catch (error) {
    console.error('Failed to import dataset:', error);
    throw error;
  }
}

// Execute super marketing campaign
async function executeSuperMarketing(datasetId) {
  try {
    const campaignData = {
      dataset_id: datasetId,
      serials: ['16091FDD40050N', '16091FDD40051N'],
      script_name: 'super_follow',
      script_config: {
        max_consumption_per_run: 50,
        action_delay_min: 5,
        action_delay_max: 15,
        actions: ['follow', 'like_recent_posts']
      }
    };

    const response = await super_marketing_run_now(campaignData);
    console.log('Super marketing campaign launched:', response.data);
  } catch (error) {
    console.error('Failed to launch super marketing:', error);
  }
}

```

--------------------------------

### List Connected Android Devices (JavaScript)

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Fetches and displays a list of all connected Android devices along with their current status and TikTok app information. This function utilizes the `get_devices` service and expects an array of device objects in its response. No external dependencies beyond the project's service layer are explicitly mentioned.

```javascript
import { get_devices } from './src/service/index.js';

// Fetch all connected devices
async function listDevices() {
  try {
    const response = await get_devices();
    console.log('Connected devices:', response.data);
    // Response contains array of device objects with serial, model, status, etc.
    response.data.forEach(device => {
      console.log(`Device: ${device.serial}, Status: ${device.status}`);
    });
  } catch (error) {
    console.error('Failed to fetch devices:', error);
  }
}

listDevices();
```

--------------------------------

### Fetch Analytics and Task Statistics using Javascript

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

This snippet demonstrates how to fetch comprehensive account analytics and monitor task execution statistics. It relies on imported service functions to retrieve data on total posts, follower gains, likes received, engagement rate, and task counts by status (pending, running, completed, failed).

```javascript
import { get_analytics, count_task_by_status, count_online_device, count_all_account, get_running_tasks } from './src/service/index.js';

// Get comprehensive analytics
async function fetchAnalytics() {
  try {
    const response = await get_analytics();
    console.log('Total posts:', response.data.total_posts);
    console.log('Total followers gained:', response.data.followers_gained);
    console.log('Total likes received:', response.data.likes_received);
    console.log('Engagement rate:', response.data.engagement_rate);
    return response.data;
  } catch (error) {
    console.error('Failed to fetch analytics:', error);
    return null;
  }
}

// Get task statistics
async function getTaskStatistics() {
  try {
    const response = await count_task_by_status();
    console.log('Pending tasks:', response.data.pending);
    console.log('Running tasks:', response.data.running);
    console.log('Completed tasks:', response.data.completed);
    console.log('Failed tasks:', response.data.failed);
    return response.data;
  } catch (error) {
    console.error('Failed to get task statistics:', error);
    return null;
  }
}

// Monitor system status
async function monitorSystemStatus() {
  try {
    const [devicesResponse, accountsResponse, runningTasksResponse] = await Promise.all([
      count_online_device(),
      count_all_account(),
      get_running_tasks()
    ]);

    const status = {
      online_devices: devicesResponse.data.count,
      total_accounts: accountsResponse.data.count,
      running_tasks: runningTasksResponse.data.length
    };

    console.log('System Status:', status);
    return status;
  } catch (error) {
    console.error('Failed to monitor system status:', error);
    return null;
  }
}
```

--------------------------------

### Task Creation API

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/api-test.md

This API endpoint is used to create various tasks by specifying the script name and its configuration. Supported scripts include 'post', 'follow', 'unfollow', and 'account_warmup'.

```APIDOC
## POST /api/v1/task

### Description
This endpoint allows the creation of automated tasks for TikTok manipulation, such as posting videos, managing follows, or warming up accounts.

### Method
POST

### Endpoint
/api/v1/task

### Parameters
#### Request Body
- **serials** (array of strings) - Required - A list of serial identifiers for the devices to perform the task on.
- **script_name** (string) - Required - The name of the script to execute (e.g., "post", "follow", "unfollow", "account_warmup").
- **script_config** (object) - Required - Configuration specific to the chosen script.
  - **post** script_config:
    - **content_type** (integer) - Required - Type of content to post.
    - **captions** (string) - Optional - Text to accompany the posted video.
    - **material_list** (array of strings) - Required - Paths to video files for posting.
    - **upload_wait_time** (integer) - Optional - Time in seconds to wait for upload completion.
  - **follow** and **unfollow** script_config:
    - **target_users** (array of strings) - Required - List of TikTok usernames to follow or unfollow.
    - **access_method** (string) - Required - Method of access (e.g., "direct").
  - **account_warmup** script_config:
    - **task_duration** (integer) - Required - Total duration of the warm-up task in seconds.
    - **min_duration** (integer) - Required - Minimum duration for individual warm-up actions.
    - **max_duration** (integer) - Required - Maximum duration for individual warm-up actions.

### Request Example (Post Video)
```json
{
  "serials": ["16091FDD40050N"],
  "script_name": "post",
  "script_config": {
    "content_type": 0,
    "captions": "看看我的新视频！#热门 #推荐",
    "material_list": [
      "C:/Videos/video1.mp4"
    ],
    "upload_wait_time": 60
  }
}
```

### Request Example (Follow User)
```json
{
  "serials": ["16091FDD40050N"],
  "script_name": "follow",
  "script_config": {
    "target_users": ["@tikmatrix001"],
    "access_method": "direct"
  }
}
```

### Request Example (Account Warmup)
```json
{
  "serials": ["16091FDD40050N"],
  "script_name": "account_warmup",
  "script_config": {
    "task_duration": 600,
    "min_duration": 10,
    "max_duration": 30
  }
}
```

### Response
#### Success Response (200)
(Response details not provided in the source material, but typically includes a status and task ID)

#### Response Example
```json
{
  "status": "success",
  "task_id": "task-12345"
}
```
```

--------------------------------

### Create TikTok Account Warmup Task via API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Initiates an account warmup task for TikTok, which involves simulating user actions like searching, watching, liking, following, and commenting. Task duration and action types are configurable. This is done via a POST request to the /api/v1/task endpoint.

```javascript
import { get_tasks, update_task, delete_task, run_now_by_account } from './src/service/index.js';
import request from './src/utils/request.js';

// Create account warmup task
async function createWarmupTask() {
  try {
    const warmupConfig = {
      serials: ['16091FDD40050N'],
      script_name: 'account_warmup',
      script_config: {
        task_duration: 600,
        min_duration: 10,
        max_duration: 30,
        actions: ['search', 'watch', 'like', 'follow', 'comment']
      }
    };

    const response = await request({
      method: 'post',
      url: 'http://localhost:50809/api/v1/task',
      data: warmupConfig
    });

    console.log('Warmup task created:', response.data);
  } catch (error) {
    console.error('Failed to create warmup task:', error);
  }
}
```

--------------------------------

### Check License Status API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Retrieves the current status of the license, including plan, devices used, and device limit. Useful for monitoring license usage.

```javascript
import { get_license } from './src/service/index.js';

async function checkLicenseStatus() {
  try {
    const response = await get_license();
    console.log('License status:', response.data.status);
    console.log('Plan:', response.data.plan);
    console.log('Devices used:', response.data.devices_used);
    console.log('Devices limit:', response.data.devices_limit);
    return response.data;
  } catch (error) {
    console.error('Failed to check license:', error);
    return null;
  }
}
```

--------------------------------

### Execute ADB Command API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Executes a custom ADB command on a specified Android device. Requires the device serial number and the command string. Returns the command's output.

```javascript
import { adb_command } from './src/service/index.js';

async function executeAdbCommand() {
  try {
    const commandData = {
      serial: '16091FDD40050N',
      command: 'shell am start -n com.zhiliaoapp.musically/com.ss.android.ugc.aweme.splash.SplashActivity'
    };

    const response = await adb_command(commandData);
    console.log('ADB command output:', response.data.output);
    return response.data;
  } catch (error) {
    console.error('Failed to execute ADB command:', error);
    throw error;
  }
}
```

--------------------------------

### Post Video Task API Command

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/api-test.md

This command demonstrates how to use the `curl` utility to send a POST request to the TikTok Matrix API to post a video. It includes the target API endpoint, necessary headers, and a JSON payload specifying the video content and configuration.

```shell
curl -X POST http://localhost:50809/api/v1/task \
  -H "Content-Type: application/json" \
  -d '{
    "serials": ["16091FDD40050N"],
    "script_name": "post",
    "script_config": {
      "content_type": 0,
      "captions": "看看我的新视频！#热门 #推荐",
      "material_list": [
        "C:/Videos/video1.mp4"
      ],
      "upload_wait_time": 60
    }
  }'
```

--------------------------------

### Account Warmup Task API Command

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/api-test.md

This `curl` command demonstrates how to initiate an account warmup task using the TikTok Matrix API. The request includes a JSON payload defining the duration of the warmup task and the minimum and maximum engagement durations.

```shell
curl -X POST http://localhost:50809/api/v1/task \
  -H "Content-Type: application/json" \
  -d '{
    "serials": ["16091FDD40050N"],
    "script_name": "account_warmup",
    "script_config": {
      "task_duration": 600,
      "min_duration": 10,
      "max_duration": 30
    }
  }'
```

--------------------------------

### Follow User Task API Command

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/api-test.md

This `curl` command illustrates how to initiate a follow user task via the TikTok Matrix API. The request targets the `/api/v1/task` endpoint with a JSON payload specifying the user to follow and the access method.

```shell
curl -X POST http://localhost:50809/api/v1/task \
  -H "Content-Type: application/json" \
  -d '{
    "serials": ["16091FDD40050N"],
    "script_name": "follow",
    "script_config": {
      "target_users": ["@tikmatrix001"],
      "access_method": "direct"
    }
  }'
```

--------------------------------

### Create TikTok Video Posting Task via API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Creates a task to post videos to TikTok. It requires specifying video material paths, captions, and privacy settings. The task is submitted via a POST request to the /api/v1/task endpoint.

```javascript
import { get_tasks, update_task, delete_task, run_now_by_account } from './src/service/index.js';
import request from './src/utils/request.js';

// Create a post video task via direct API call
async function createPostTask() {
  try {
    const taskData = {
      serials: ['16091FDD40050N'],
      script_name: 'post',
      script_config: {
        content_type: 0,
        captions: '看看我的新视频！#热门 #推荐',
        material_list: [
          'C:/Videos/video1.mp4',
          'C:/Videos/video2.mp4'
        ],
        upload_wait_time: 60,
        music: 'trending_song',
        privacy: 'public'
      }
    };

    const response = await request({
      method: 'post',
      url: 'http://localhost:50809/api/v1/task',
      data: taskData
    });

    console.log('Task created:', response.data);
    return response.data.task_id;
  } catch (error) {
    console.error('Failed to create task:', error);
    throw error;
  }
}
```

--------------------------------

### Check Concurrency Limit API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Checks the current concurrency limit for licenses, showing the maximum allowed concurrent tasks and the number currently running. Helps in managing resource utilization.

```javascript
import { get_license_concurrency_limit } from './src/service/index.js';

async function checkConcurrencyLimit() {
  try {
    const response = await get_license_concurrency_limit();
    console.log('Max concurrent tasks:', response.data.limit);
    console.log('Currently running:', response.data.current);
    return response.data;
  } catch (error) {
    console.error('Failed to check concurrency limit:', error);
    return null;
  }
}
```

--------------------------------

### Run Specific TikTok Task Immediately via Service Function

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Executes a specific TikTok task immediately for a given account. Requires the account ID and script name. Configuration for immediate execution is passed within `script_config`.

```javascript
import { get_tasks, update_task, delete_task, run_now_by_account } from './src/service/index.js';
import request from './src/utils/request.js';

// Run task immediately for specific account
async function runTaskNow(accountId, scriptName) {
  try {
    const response = await run_now_by_account({
      account_id: accountId,
      script_name: scriptName,
      script_config: {
        immediate: true
      }
    });

    console.log('Task started:', response.data);
  } catch (error) {
    console.error('Failed to start task:', error);
  }
}
```

--------------------------------

### Run Automation Script API

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Runs a predefined automation script on a specified Android device. Requires the device serial, script name, and optional parameters. Returns the script execution result.

```javascript
import { script } from './src/service/index.js';

async function runAutomationScript() {
  try {
    const scriptData = {
      serial: '16091FDD40050N',
      script_name: 'clear_cache',
      params: {
        app_package: 'com.zhiliaoapp.musically',
        clear_data: false
      }
    };

    const response = await script(scriptData);
    console.log('Script execution result:', response.data);
    return response.data;
  } catch (error) {
    console.error('Failed to run script:', error);
    throw error;
  }
}
```

--------------------------------

### Retrieve Unused TikTok Materials using Service Function

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Fetches materials from the TikTok library that have not yet been used. The `get_materials` service function is called with a `used: false` parameter to filter the results. Handles potential errors during fetching.

```javascript
import { upload_videos, get_materials, delete_material, update_material, add_tags_to_material } from './src/service/index.js';

// Get unused materials for posting
async function getUnusedMaterials() {
  try {
    const response = await get_materials({ used: false });
    console.log(`Found ${response.data.length} unused materials`);
    return response.data;
  } catch (error) {
    console.error('Failed to fetch materials:', error);
    return [];
  }
}
```

--------------------------------

### Upload Multiple Videos to TikTok Material Library

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Uploads multiple video files to the TikTok material library. Each file can have an associated thumbnail. This function also allows assigning group IDs and tags to the uploaded materials for organization.

```javascript
import { upload_videos, get_materials, delete_material, update_material, add_tags_to_material } from './src/service/index.js';

// Upload multiple videos to material library
async function uploadVideoMaterials() {
  try {
    const materialsData = {
      files: [
        {
          path: 'C:/Videos/video1.mp4',
          thumbnail: 'C:/Videos/video1_thumb.jpg'
        },
        {
          path: 'C:/Videos/video2.mp4',
          thumbnail: 'C:/Videos/video2_thumb.jpg'
        }
      ],
      group_id: 1,
      tags: ['trending', 'comedy']
    };

    const response = await upload_videos(materialsData);
    console.log(`Uploaded ${response.data.length} materials successfully`);
    return response.data;
  } catch (error) {
    console.error('Failed to upload materials:', error);
    throw error;
  }
}
```

--------------------------------

### Open TikTok App via ADB

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Opens the TikTok application on a specified Android device using an ADB command. Requires the device serial number.

```javascript
import { adb_command } from './src/service/index.js';

async function openTikTokApp(serial) {
  try {
    const commandData = {
      serial: serial,
      command: 'shell monkey -p com.zhiliaoapp.musically -c android.intent.category.LAUNCHER 1'
    };

    await adb_command(commandData);
    console.log('TikTok app opened successfully');
  } catch (error) {
    console.error('Failed to open TikTok:', error);
  }
}
```

--------------------------------

### Manage TikTok Accounts (JavaScript)

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Provides functions to add, update, retrieve, and delete TikTok account credentials. This API supports organized multi-account management by allowing group assignments. The functions interact with the project's service layer (`get_accounts`, `add_account`, `update_account`, `delete_account`) and handle responses based on a `code` property.

```javascript
import { get_accounts, add_account, update_account, delete_account } from './src/service/index.js';

// Add a new TikTok account
async function addNewAccount() {
  try {
    const accountData = {
      username: 'tikmatrix001',
      password: 'secure_password_123',
      email: 'user@example.com',
      device: '16091FDD40050N',
      group_id: 1,
      status: 'active'
    };

    const response = await add_account(accountData);
    if (response.code === 0) {
      console.log('Account added successfully:', response.data);
    }
  } catch (error) {
    console.error('Failed to add account:', error);
  }
}

// Update existing account
async function updateExistingAccount(accountId) {
  try {
    const updates = {
      id: accountId,
      password: 'new_password_456',
      status: 'active'
    };

    await update_account(updates);
    console.log('Account updated successfully');
  } catch (error) {
    console.error('Failed to update account:', error);
  }
}

// Get all accounts and filter by status
async function listActiveAccounts() {
  try {
    const response = await get_accounts();
    const activeAccounts = response.data.filter(acc => acc.status === 'active');
    console.log(`Found ${activeAccounts.length} active accounts`);
    return activeAccounts;
  } catch (error) {
    console.error('Failed to fetch accounts:', error);
    return [];
  }
}
```

--------------------------------

### List Pending TikTok Tasks using Service Function

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Retrieves all existing TikTok tasks using the `get_tasks` service function and filters them to return only those with a 'pending' status. Handles potential errors during task fetching.

```javascript
import { get_tasks, update_task, delete_task, run_now_by_account } from './src/service/index.js';
import request from './src/utils/request.js';

// Get all tasks and filter by status
async function listPendingTasks() {
  try {
    const response = await get_tasks();
    const pendingTasks = response.data.filter(task => task.status === 'pending');
    console.log(`Found ${pendingTasks.length} pending tasks`);
    return pendingTasks;
  } catch (error) {
    console.error('Failed to fetch tasks:', error);
    return [];
  }
}
```

--------------------------------

### Manage TikTok Account Groups

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

This snippet covers group management operations for TikTok accounts, including creating, updating, deleting, and moving accounts/devices between groups. It also shows how to retrieve the count of accounts within a specific group. Functions like `add_group`, `move_to_group`, and `count_account_by_group_id` are used. Proper group IDs and device serials are required for these operations.

```javascript
import { get_groups, add_group, update_group, delete_group, move_to_group, count_account_by_group_id } from './src/service/index.js';

// Create a new group
async function createGroup() {
  try {
    const groupData = {
      name: 'Tech Content Creators',
      description: 'Accounts focused on tech content',
      settings: {
        posting_schedule: 'daily',
        max_posts_per_day: 3,
        auto_warmup: true
      }
    };

    const response = await add_group(groupData);
    console.log('Group created:', response.data);
    return response.data.id;
  } catch (error) {
    console.error('Failed to create group:', error);
    throw error;
  }
}

// Move devices to a group
async function assignDevicesToGroup(groupId) {
  try {
    const moveData = {
      group_id: groupId,
      serials: [
        '16091FDD40050N',
        '16091FDD40051N',
        '16091FDD40052N'
      ]
    };

    await move_to_group(moveData);
    console.log(`Moved ${moveData.serials.length} devices to group ${groupId}`);
  } catch (error) {
    console.error('Failed to move devices:', error);
  }
}

// Get account count by group
async function getGroupAccountStats(groupId) {
  try {
    const response = await count_account_by_group_id({ group_id: groupId });
    console.log(`Group ${groupId} has ${response.data.count} accounts`);
    return response.data.count;
  } catch (error) {
    console.error('Failed to get account count:', error);
    return 0;
  }
}

```

--------------------------------

### Fix TikMatrix Application Launch Issue on Mac

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/README.md

Removes extended file attributes from the TikMatrix application bundle on macOS to resolve launch errors. This command helps bypass potential security restrictions.

```shell
xattr -cr /Applications/TikMatrix.app
```

--------------------------------

### Tag TikTok Materials with Specific IDs

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Assigns predefined tag IDs to a specific material in the TikTok library using the `add_tags_to_material` service function. This helps in organizing and categorizing video or image assets.

```javascript
import { upload_videos, get_materials, delete_material, update_material, add_tags_to_material } from './src/service/index.js';

// Tag materials for organization
async function organizeMaterialsWithTags(materialId) {
  try {
    const tagIds = [1, 3, 5]; // Example tag IDs for 'viral', 'dance', 'trending'
    await add_tags_to_material({
      material_id: materialId,
      tag_ids: tagIds
    });

    console.log(`Tagged material ${materialId} with ${tagIds.length} tags`);
  } catch (error) {
    console.error('Failed to tag material:', error);
  }
}
```

--------------------------------

### Customize TikMatrix Product Name in Tauri Config

Source: https://github.com/tikmatrix/tiktok-matrix/blob/main/README.md

Modifies the product name for the TikMatrix application within the Tauri configuration file. This setting is located in `src/src-tauri/tauri.conf.json`.

```json
"package": {
    "productName": "TikMatrix",
    "version": "1.8.1"
  }
```

--------------------------------

### Update TikTok Material Metadata via Service Function

Source: https://context7.com/tikmatrix/tiktok-matrix/llms.txt

Updates the metadata for a specific TikTok material, identified by its ID. This includes changing its caption, usage status, and other properties like duration and resolution.

```javascript
import { upload_videos, get_materials, delete_material, update_material, add_tags_to_material } from './src/service/index.js';

// Update material metadata
async function updateMaterialInfo(materialId) {
  try {
    await update_material({
      id: materialId,
      caption: 'Updated caption text',
      used: false,
      metadata: {
        duration: 30,
        resolution: '1080x1920'
      }
    });

    console.log('Material updated successfully');
  } catch (error) {
    console.error('Failed to update material:', error);
  }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.