Arcrun/registry/components/kbdb_create_block/main.go

// kbdb_create_block — POST 一個單一 block 到 KBDB（支援 parent_id，給留言鏈用）
// 對應 KBDB endpoint: POST /blocks（不是 ingest）
//
//go:build tinygo

package main

import (
	"encoding/json"
	"io"
	"os"
	"unsafe"
)

//go:wasmimport u6u http_request
func hostHttpRequest(
	urlPtr uintptr, urlLen uint32,
	methodPtr uintptr, methodLen uint32,
	headersPtr uintptr, headersLen uint32,
	bodyPtr uintptr, bodyLen uint32,
	outPtr uintptr, outLenPtr uintptr,
) uint32

type Input struct {
	KBDBUrl  string `json:"kbdb_url"`
	APIKey   string `json:"api_key"`
	Content  string `json:"content"`
	Type     string `json:"type"`
	ParentID string `json:"parent_id"`
	UserID   string `json:"user_id"`
	Source   string `json:"source"`
	PageName string `json:"page_name"`
	TagsJSON string `json:"tags_json"`
}

var dummy [1]byte

func safePtr(b []byte) (uintptr, uint32) {
	if len(b) == 0 {
		return uintptr(unsafe.Pointer(&dummy[0])), 0
	}
	return uintptr(unsafe.Pointer(&b[0])), uint32(len(b))
}

func main() {
	raw, err := io.ReadAll(os.Stdin)
	if err != nil {
		writeError("failed to read stdin: " + err.Error())
		return
	}

	var input Input
	if err := json.Unmarshal(raw, &input); err != nil {
		writeError("invalid input JSON: " + err.Error())
		return
	}

	if input.APIKey == "" {
		writeError("api_key 必填")
		return
	}
	if input.Content == "" {
		writeError("content 必填")
		return
	}

	kbdbURL := input.KBDBUrl
	if kbdbURL == "" {
		kbdbURL = "https://kbdb.finally.click"
	}

	// 構造 KBDB POST /blocks body（只放有值的欄位）
	body := make(map[string]interface{})
	body["content"] = input.Content
	if input.Type != "" {
		body["type"] = input.Type
	}
	if input.ParentID != "" {
		body["parent_id"] = input.ParentID
	}
	if input.UserID != "" {
		body["user_id"] = input.UserID
	}
	if input.Source != "" {
		body["source"] = input.Source
	}
	if input.PageName != "" {
		body["page_name"] = input.PageName
	}
	if input.TagsJSON != "" {
		body["tags_json"] = input.TagsJSON
	}
	bodyBytes, _ := json.Marshal(body)

	headers := map[string]string{
		"Content-Type":  "application/json",
		"Authorization": "Bearer " + input.APIKey,
	}
	headersBytes, _ := json.Marshal(headers)

	url := kbdbURL + "/blocks"
	urlBytes := []byte(url)
	methodBytes := []byte("POST")

	outBuf := make([]byte, 65536)
	var outLen uint32

	urlPtr, urlLen := safePtr(urlBytes)
	methodPtr, methodLen := safePtr(methodBytes)
	headersPtr, headersLen := safePtr(headersBytes)
	bodyPtr, bodyLenU := safePtr(bodyBytes)

	result := hostHttpRequest(
		urlPtr, urlLen,
		methodPtr, methodLen,
		headersPtr, headersLen,
		bodyPtr, bodyLenU,
		uintptr(unsafe.Pointer(&outBuf[0])), uintptr(unsafe.Pointer(&outLen)),
	)

	if result != 0 {
		writeError("KBDB POST request failed (host_http_request returned non-zero)")
		return
	}

	respStr := string(outBuf[:outLen])
	var kbdbResp map[string]interface{}
	if err := json.Unmarshal([]byte(respStr), &kbdbResp); err != nil {
		writeError("KBDB returned non-JSON: " + respStr)
		return
	}

	if _, hasErr := kbdbResp["error"]; hasErr {
		out, _ := json.Marshal(map[string]interface{}{
			"success": false,
			"error":   kbdbResp["error"],
		})
		os.Stdout.Write(out)
		return
	}

	out, _ := json.Marshal(map[string]interface{}{
		"success": true,
		"data":    kbdbResp,
	})
	os.Stdout.Write(out)
}

func writeError(msg string) {
	out, _ := json.Marshal(map[string]interface{}{"success": false, "error": msg})
	os.Stdout.Write(out)
}