Demo代码(Golang)

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type TaskResponse struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
	Data struct {
		TaskID string `json:"taskId"`
	} `json:"data"`
}

type TaskRequest struct {
	Remark string        `json:"remark"`
	AppID  string        `json:"appId"`
	Inputs []TaskInput   `json:"inputs"`
}

type TaskInput struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

func main() {
	url := "https://api.comfylink.com/v1/openapi/tasks"
	reqBody := TaskRequest{
		Remark: "",
		AppID:  "YOUR_APPID",
		Inputs: []TaskInput{
			{Name: "6:text", Value: "test ..."},
		},
	}
	bodyBytes, err := json.Marshal(reqBody)
	if err != nil {
		fmt.Println("请求体序列化失败:", err)
		return
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyBytes))
	if err != nil {
		fmt.Println("创建请求失败:", err)
		return
	}
	req.Header.Set("X-API-Key", "YOUR_API_KEY")
	req.Header.Set("X-Client-Id", "YOUR_UUID")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("请求失败:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Printf("HTTP请求失败，状态码: %d\n", resp.StatusCode)
		return
	}

	var res TaskResponse
	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
		fmt.Println("响应解析失败:", err)
		return
	}

	if res.Code == 0 {
		fmt.Println("任务创建成功，任务ID:", res.Data.TaskID)
	} else {
		fmt.Println("任务创建失败:", res.Msg)
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

func main() {
	taskID := "创建任务返回的任务ID" // 替换为实际任务ID
	url := fmt.Sprintf("https://api.comfylink.com/v1/openapi/tasks/%s", taskID)

	req, err := http.NewRequest("DELETE", url, nil)
	if err != nil {
		fmt.Println("创建请求失败:", err)
		return
	}
	req.Header.Set("X-API-Key", "YOUR_API_KEY")
	req.Header.Set("X-Client-Id", "YOUR_UUID")

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("请求失败:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Printf("HTTP请求失败，状态码: %d\n", resp.StatusCode)
		return
	}

	var res struct {
		Code int    `json:"code"`
		Msg  string `json:"msg"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
		fmt.Println("响应解析失败:", err)
		return
	}

	if res.Code == 0 {
		fmt.Println("任务已取消")
	} else {
		fmt.Println("取消任务失败:", res.Msg)
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

func main() {
	taskID := "创建任务返回的任务ID" // 替换为实际任务ID
	url := fmt.Sprintf("https://api.comfylink.com/v1/openapi/tasks/%s", taskID)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Println("创建请求失败:", err)
		return
	}
	req.Header.Set("X-API-Key", "YOUR_API_KEY")
	req.Header.Set("X-Client-Id", "YOUR_UUID")

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("请求失败:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Printf("HTTP请求失败，状态码: %d\n", resp.StatusCode)
		return
	}

	var res struct {
		Code int    `json:"code"`
		Msg  string `json:"msg"`
		Data struct {
			Status  string      `json:"status"`
			Message string      `json:"message"`
			Outputs interface{} `json:"outputs"`
		} `json:"data"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
		fmt.Println("响应解析失败:", err)
		return
	}

	if res.Code == 0 {
		switch res.Data.Status {
		case "finished":
			fmt.Println("任务完成，输出:", res.Data.Outputs)
		case "failed":
			fmt.Println("任务失败:", res.Data.Message)
		case "canceled":
			fmt.Println("任务已取消:", res.Data.Message)
		case "pending":
			fmt.Println("任务排队中:", res.Data.Message)
		default:
			fmt.Println("未知状态:", res.Data.Status)
		}
	} else {
		fmt.Println("查询失败:", res.Msg)
	}
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"time"
)

func main() {
	url := "https://api.comfylink.com/v1/openapi/files"

	file, err := os.Open("comfylink.jpg")
	if err != nil {
		fmt.Println("打开文件失败:", err)
		return
	}
	defer file.Close()

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, err := writer.CreateFormFile("file", "comfylink.jpg")
	if err != nil {
		fmt.Println("创建表单文件失败:", err)
		return
	}
	if _, err := io.Copy(part, file); err != nil {
		fmt.Println("写入文件内容失败:", err)
		return
	}
	if err := writer.Close(); err != nil {
		fmt.Println("关闭表单写入器失败:", err)
		return
	}

	req, err := http.NewRequest("POST", url, body)
	if err != nil {
		fmt.Println("创建请求失败:", err)
		return
	}
	req.Header.Set("X-API-Key", "YOUR_API_KEY")
	req.Header.Set("X-Client-Id", "YOUR_UUID")
	req.Header.Set("Content-Type", writer.FormDataContentType())

	client := &http.Client{Timeout: 20 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("请求失败:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Printf("HTTP请求失败，状态码: %d\n", resp.StatusCode)
		return
	}

	var res struct {
		Code int    `json:"code"`
		Msg  string `json:"msg"`
		Data struct {
			Path string `json:"path"`
		} `json:"data"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
		fmt.Println("响应解析失败:", err)
		return
	}

	if res.Code == 0 {
		fmt.Println("文件上传成功，访问地址:", res.Data.Path)
	} else {
		fmt.Println("文件上传失败:", res.Msg)
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"os"
	"os/signal"
	"syscall"

	"github.com/gorilla/websocket"
)

func handleWebSocket(conn *websocket.Conn) {
	for {
		_, message, err := conn.ReadMessage()
		if err != nil {
			if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
				log.Println("WebSocket 连接已关闭")
			} else {
				log.Println("读取消息失败:", err)
			}
			return
		}

		var resp struct {
			Code int    `json:"code"`
			Msg  string `json:"msg"`
			Data struct {
				Status  string      `json:"status"`
				Message string      `json:"message"`
				Outputs interface{} `json:"outputs"`
			} `json:"data"`
		}

		if err := json.Unmarshal(message, &resp); err != nil {
			log.Printf("JSON解析失败: %s\n原始数据: %s\n", err, string(message))
			continue
		}

		if resp.Code != 0 {
			log.Printf("接口返回异常: %s", resp.Msg)
			continue
		}

		switch resp.Data.Status {
		case "finished":
			fmt.Println("【任务完成】")
			fmt.Println("输出结果:", resp.Data.Outputs)
		case "failed":
			fmt.Println("【任务失败】错误信息:", resp.Data.Message)
		case "canceled":
			fmt.Println("【任务已取消】原因:", resp.Data.Message)
		case "pending":
			fmt.Println("【任务排队中】当前状态:", resp.Data.Message)
		default:
			fmt.Println("未知状态:", resp.Data.Status)
		}
	}
}

func main() {
	u := url.URL{Scheme: "wss", Host: "api.comfylink.com", Path: "/v1/openapi/ws"}
	headers := http.Header{}
	headers.Add("X-API-Key", "YOUR_API_KEY")
	headers.Add("X-Client-Id", "YOUR_UUID")

	conn, _, err := websocket.DefaultDialer.Dial(u.String(), headers)
	if err != nil {
		fmt.Fprintf(os.Stderr, "连接失败: %v\n", err)
		os.Exit(1)
	}
	defer conn.Close()

	// 支持 Ctrl+C 友好退出
	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)
	go func() {
		<-interrupt
		fmt.Println("\n收到中断信号，关闭连接。")
		conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
		conn.Close()
		os.Exit(0)
	}()

	handleWebSocket(conn)
}