Files
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

284 lines
6.4 KiB
Go
Executable File

// Package proxy ports offline proxy route bags (Rust proxy.rs).
package proxy
import (
"fmt"
"strconv"
"strings"
"github.com/marqdo/marqdo/plugins/web/internal/app"
"github.com/marqdo/marqdo/plugins/web/internal/table"
)
// Options is one proxy mount (web_app_proxy args).
type Options struct {
Path string
Upstream string
Stream bool
StripPrefix string
Methods []string
HeadersFromEnv string
TimeoutMs uint64
}
// RoutesFromTable normalizes `|路径|上游|流式|去前缀|方法|环境头|超时|` into proxy_routes map keys.
func RoutesFromTable(tableV any) map[string]any {
rows, _ := table.AsRows(tableV).([]any)
out := map[string]any{}
for _, row := range rows {
m, ok := row.(map[string]any)
if !ok {
continue
}
path := normalizeTablePath(col(m, "路径", "path", "Path"))
if path == "" || path == "/" {
continue
}
upstream := col(m, "上游", "upstream", "Upstream")
if upstream == "" {
continue
}
stream := true
if s := col(m, "流式", "stream", "Stream"); s != "" {
stream = boolish(s)
}
stripPrefix := col(m, "去前缀", "strip_prefix", "Strip-Prefix")
methodsRaw := col(m, "方法", "methods", "Methods")
methods := parseMethods(methodsRaw)
headersFromEnv := col(m, "环境头", "headers_from_env", "Headers-From-Env")
timeoutMs := uint64(120_000)
if s := col(m, "超时", "timeout_ms", "Timeout"); s != "" {
if n, err := strconv.ParseUint(strings.TrimSpace(s), 10, 64); err == nil {
timeoutMs = n
}
}
key := strings.TrimPrefix(path, "/")
out[key] = routeEntry(upstream, stream, stripPrefix, methods, headersFromEnv, timeoutMs)
}
return out
}
// Register adds one proxy route to app.proxy_routes (Rust web_app_proxy).
func Register(appBag map[string]any, opts Options) (map[string]any, error) {
if strings.TrimSpace(opts.Upstream) == "" {
return nil, fmt.Errorf("proxy requires `upstream`")
}
path, err := app.NormalizeRoutePath(opts.Path, appBag)
if err != nil {
return nil, err
}
key := strings.TrimPrefix(path, "/")
out := clone(appBag)
routes := map[string]any{}
if r, ok := out["proxy_routes"].(map[string]any); ok {
routes = clone(r)
}
methods := opts.Methods
if len(methods) == 0 {
methods = []string{"POST"}
}
timeout := opts.TimeoutMs
if timeout == 0 {
timeout = 120_000
}
routes[key] = routeEntry(opts.Upstream, opts.Stream, opts.StripPrefix, methods, opts.HeadersFromEnv, timeout)
out["proxy_routes"] = routes
return out, nil
}
// OptionsFromArgs parses web_app_proxy ABI args.
func OptionsFromArgs(args map[string]any) (Options, error) {
path, err := argStrReq(args, "path", "路径")
if err != nil {
return Options{}, err
}
upstream, err := argStrReq(args, "upstream", "上游")
if err != nil {
return Options{}, err
}
stream := true
if v, ok := first(args, "stream", "流式"); ok {
stream = boolish(v)
}
stripPrefix, _ := argStr(args, "strip_prefix", "去前缀")
headersFromEnv, _ := argStr(args, "headers_from_env", "环境头")
timeoutMs := uint64(120_000)
if v, ok := first(args, "timeout_ms", "超时"); ok {
if n, ok := asUint64(v); ok {
timeoutMs = n
}
}
return Options{
Path: path,
Upstream: upstream,
Stream: stream,
StripPrefix: stripPrefix,
Methods: parseMethodsArg(args["methods"], args["方法"]),
HeadersFromEnv: headersFromEnv,
TimeoutMs: timeoutMs,
}, nil
}
func routeEntry(upstream string, stream bool, stripPrefix string, methods []string, headersFromEnv string, timeoutMs uint64) map[string]any {
methodAny := make([]any, len(methods))
for i, m := range methods {
methodAny[i] = m
}
return map[string]any{
"upstream": upstream,
"stream": stream,
"strip_prefix": stripPrefix,
"methods": methodAny,
"headers_from_env": headersFromEnv,
"timeout_ms": float64(timeoutMs),
}
}
func normalizeTablePath(raw string) string {
s := strings.TrimSpace(raw)
if s == "" {
return ""
}
if !strings.HasPrefix(s, "/") {
return "/" + s
}
return s
}
func parseMethods(raw string) []string {
if strings.TrimSpace(raw) == "" {
return []string{"POST"}
}
var out []string
for _, part := range strings.Split(raw, ",") {
part = strings.TrimSpace(part)
if part != "" {
out = append(out, strings.ToUpper(part))
}
}
if len(out) == 0 {
return []string{"POST"}
}
return out
}
func parseMethodsArg(v any, alt any) []string {
if v == nil {
v = alt
}
if v == nil {
return nil
}
switch t := v.(type) {
case []any:
var out []string
for _, x := range t {
if s, ok := x.(string); ok && strings.TrimSpace(s) != "" {
out = append(out, strings.ToUpper(strings.TrimSpace(s)))
}
}
return out
case string:
return parseMethods(t)
}
return nil
}
func col(m map[string]any, keys ...string) string {
for _, k := range keys {
if v, ok := m[k]; ok {
return cellText(v)
}
}
return ""
}
func cellText(v any) string {
switch t := v.(type) {
case nil:
return ""
case string:
return t
case bool:
return strconv.FormatBool(t)
case float64:
if t == float64(int64(t)) {
return strconv.FormatInt(int64(t), 10)
}
return strconv.FormatFloat(t, 'f', -1, 64)
default:
return fmt.Sprint(t)
}
}
func boolish(v any) bool {
switch t := v.(type) {
case bool:
return t
case string:
switch strings.TrimSpace(t) {
case "true", "True", "1", "yes", "on", "真":
return true
}
return false
case float64:
return t != 0
}
return false
}
func asUint64(v any) (uint64, bool) {
switch t := v.(type) {
case float64:
if t >= 0 {
return uint64(t), true
}
case int64:
if t >= 0 {
return uint64(t), true
}
case int:
if t >= 0 {
return uint64(t), true
}
case string:
n, err := strconv.ParseUint(strings.TrimSpace(t), 10, 64)
return n, err == nil
}
return 0, false
}
func first(args map[string]any, keys ...string) (any, bool) {
for _, k := range keys {
if v, ok := args[k]; ok && v != nil {
return v, true
}
}
return nil, false
}
func argStr(args map[string]any, keys ...string) (string, bool) {
v, ok := first(args, keys...)
if !ok {
return "", false
}
s, _ := v.(string)
return s, true
}
func argStrReq(args map[string]any, keys ...string) (string, error) {
s, ok := argStr(args, keys...)
if !ok || strings.TrimSpace(s) == "" {
return "", fmt.Errorf("missing `%s`", keys[0])
}
return s, nil
}
func clone(m map[string]any) map[string]any {
out := make(map[string]any, len(m))
for k, v := range m {
out[k] = v
}
return out
}