295 lines
7.8 KiB
Go
295 lines
7.8 KiB
Go
package plugins
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"os/exec"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
var qwenEventNames = stringSet(
|
|
"PreToolUse",
|
|
"PostToolUse",
|
|
"PostToolUseFailure",
|
|
"PostToolBatch",
|
|
"Notification",
|
|
"UserPromptSubmit",
|
|
"UserPromptExpansion",
|
|
"SessionStart",
|
|
"Stop",
|
|
"MessageDisplay",
|
|
"SubagentStart",
|
|
"SubagentStop",
|
|
"PreCompact",
|
|
"PostCompact",
|
|
"SessionEnd",
|
|
"PermissionRequest",
|
|
"PermissionDenied",
|
|
"StopFailure",
|
|
"TodoCreated",
|
|
"TodoCompleted",
|
|
"InstructionsLoaded",
|
|
)
|
|
|
|
var qwenRegexMatcherEvents = [...]string{
|
|
"PreToolUse",
|
|
"PostToolUse",
|
|
"PostToolUseFailure",
|
|
"PermissionRequest",
|
|
"PermissionDenied",
|
|
"SubagentStart",
|
|
"SubagentStop",
|
|
"PreCompact",
|
|
"PostCompact",
|
|
"SessionStart",
|
|
"SessionEnd",
|
|
"StopFailure",
|
|
"Notification",
|
|
"InstructionsLoaded",
|
|
"UserPromptExpansion",
|
|
}
|
|
|
|
type qwenRegexEntry struct {
|
|
Label string `json:"label"`
|
|
Pattern string `json:"pattern"`
|
|
}
|
|
|
|
func readQwenHookSettings(value any, label string) (qwenHookSettings, error) {
|
|
object, ok := value.(map[string]any)
|
|
if !ok || object == nil {
|
|
return nil, fmt.Errorf("%s must contain a JSON object", label)
|
|
}
|
|
settings := make(qwenHookSettings, len(object))
|
|
for event, item := range object {
|
|
if _, known := qwenEventNames[event]; !known {
|
|
settings[event] = item
|
|
continue
|
|
}
|
|
groups, ok := item.([]any)
|
|
if !ok {
|
|
return nil, fmt.Errorf(`%s field %q must be an array`, label, event)
|
|
}
|
|
for groupIndex, group := range groups {
|
|
if err := validateQwenGroup(group, label, event, groupIndex); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
settings[event] = item
|
|
}
|
|
return settings, nil
|
|
}
|
|
|
|
func validateQwenGroup(value any, label, event string, groupIndex int) error {
|
|
location := fmt.Sprintf(`%s field %q[%d]`, label, event, groupIndex)
|
|
group, ok := value.(map[string]any)
|
|
if !ok || group == nil {
|
|
return fmt.Errorf("%s must be an object", location)
|
|
}
|
|
if matcher, exists := group["matcher"]; exists {
|
|
if _, ok := matcher.(string); !ok {
|
|
return fmt.Errorf("%s matcher must be a string", location)
|
|
}
|
|
}
|
|
if sequential, exists := group["sequential"]; exists {
|
|
if _, ok := sequential.(bool); !ok {
|
|
return fmt.Errorf("%s sequential must be a boolean", location)
|
|
}
|
|
}
|
|
handlers, ok := group["hooks"].([]any)
|
|
if !ok {
|
|
return fmt.Errorf("%s must contain a hooks array", location)
|
|
}
|
|
for handlerIndex, handler := range handlers {
|
|
if err := validateQwenHandler(handler, location, handlerIndex); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateQwenHandler(value any, groupLabel string, handlerIndex int) error {
|
|
location := fmt.Sprintf("%s.hooks[%d]", groupLabel, handlerIndex)
|
|
handler, ok := value.(map[string]any)
|
|
if !ok || handler == nil {
|
|
return fmt.Errorf("%s must be an object", location)
|
|
}
|
|
kind, _ := handler["type"].(string)
|
|
if kind != "command" && kind != "http" && kind != "prompt" {
|
|
return fmt.Errorf("%s has unsupported type %q", location, kind)
|
|
}
|
|
if timeout, exists := handler["timeout"]; exists {
|
|
number, ok := timeout.(float64)
|
|
if !ok || math.IsNaN(number) || math.IsInf(number, 0) || number < 0 {
|
|
return fmt.Errorf("%s timeout must be a non-negative finite number", location)
|
|
}
|
|
}
|
|
for _, key := range []string{"name", "description", "statusMessage", "source"} {
|
|
if err := optionalQwenString(handler, key, location); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
switch kind {
|
|
case "command":
|
|
command, ok := handler["command"].(string)
|
|
if !ok || command == "" {
|
|
return fmt.Errorf("%s requires a non-empty command", location)
|
|
}
|
|
if err := optionalQwenStringMap(handler, "env", location); err != nil {
|
|
return err
|
|
}
|
|
if err := optionalQwenBoolean(handler, "async", location); err != nil {
|
|
return err
|
|
}
|
|
if shell, exists := handler["shell"]; exists && shell != "bash" && shell != "powershell" {
|
|
return fmt.Errorf(`%s shell must be "bash" or "powershell"`, location)
|
|
}
|
|
case "http":
|
|
url, ok := handler["url"].(string)
|
|
if !ok || url == "" {
|
|
return fmt.Errorf("%s requires a non-empty url", location)
|
|
}
|
|
if err := optionalQwenStringMap(handler, "headers", location); err != nil {
|
|
return err
|
|
}
|
|
if err := optionalQwenBoolean(handler, "once", location); err != nil {
|
|
return err
|
|
}
|
|
if err := optionalQwenString(handler, "if", location); err != nil {
|
|
return err
|
|
}
|
|
if allowed, exists := handler["allowedEnvVars"]; exists {
|
|
values, ok := allowed.([]any)
|
|
if !ok || !allQwenStrings(values) {
|
|
return fmt.Errorf("%s allowedEnvVars must be an array of strings", location)
|
|
}
|
|
}
|
|
case "prompt":
|
|
prompt, ok := handler["prompt"].(string)
|
|
if !ok || prompt == "" {
|
|
return fmt.Errorf("%s requires a non-empty prompt", location)
|
|
}
|
|
if err := optionalQwenString(handler, "model", location); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func optionalQwenString(value map[string]any, key, label string) error {
|
|
if item, exists := value[key]; exists {
|
|
if _, ok := item.(string); !ok {
|
|
return fmt.Errorf(`%s field %q must be a string`, label, key)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func optionalQwenBoolean(value map[string]any, key, label string) error {
|
|
if item, exists := value[key]; exists {
|
|
if _, ok := item.(bool); !ok {
|
|
return fmt.Errorf(`%s field %q must be a boolean`, label, key)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func optionalQwenStringMap(value map[string]any, key, label string) error {
|
|
item, exists := value[key]
|
|
if !exists {
|
|
return nil
|
|
}
|
|
entries, ok := item.(map[string]any)
|
|
if !ok {
|
|
return fmt.Errorf(`%s field %q must map names to strings`, label, key)
|
|
}
|
|
for _, entry := range entries {
|
|
if _, ok := entry.(string); !ok {
|
|
return fmt.Errorf(`%s field %q must map names to strings`, label, key)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func allQwenStrings(values []any) bool {
|
|
for _, value := range values {
|
|
if _, ok := value.(string); !ok {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func collectQwenRegexes(sources []qwenHookSettings) []qwenRegexEntry {
|
|
entries := make([]qwenRegexEntry, 0)
|
|
for sourceIndex, settings := range sources {
|
|
for _, event := range qwenRegexMatcherEvents {
|
|
groups, _ := settings[event].([]any)
|
|
for groupIndex, groupValue := range groups {
|
|
group := groupValue.(map[string]any)
|
|
matcher, ok := group["matcher"].(string)
|
|
if !ok || strings.TrimSpace(matcher) == "" || strings.TrimSpace(matcher) == "*" {
|
|
continue
|
|
}
|
|
entries = append(entries, qwenRegexEntry{
|
|
Label: fmt.Sprintf(
|
|
`Qwen Code hook source %d field %q[%d] matcher`,
|
|
sourceIndex,
|
|
event,
|
|
groupIndex,
|
|
),
|
|
Pattern: matcher,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
return entries
|
|
}
|
|
|
|
func validateQwenJavaScriptMatchers(sources []qwenHookSettings) error {
|
|
entries := collectQwenRegexes(sources)
|
|
if len(entries) == 0 {
|
|
return nil
|
|
}
|
|
nodePath, err := resolveNodeRuntime()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
payload, err := json.Marshal(entries)
|
|
if err != nil {
|
|
return fmt.Errorf("encode Qwen Code regular expressions: %w", err)
|
|
}
|
|
validator := `import fs from 'node:fs';
|
|
const entries = JSON.parse(fs.readFileSync(0, 'utf8'));
|
|
for (const entry of entries) {
|
|
try { new RegExp(entry.pattern); }
|
|
catch (error) {
|
|
process.stderr.write(entry.label + ': ' + (error instanceof Error ? error.message : String(error)));
|
|
process.exit(1);
|
|
}
|
|
}`
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
// #nosec G204 -- nodePath is resolved by exec.LookPath and every argument is fixed.
|
|
command := exec.CommandContext(ctx, nodePath, "--input-type=module", "--eval", validator)
|
|
command.Stdin = bytes.NewReader(payload)
|
|
output, runErr := command.CombinedOutput()
|
|
if ctx.Err() != nil {
|
|
return fmt.Errorf("Qwen Code regular expression validation timed out: %w", ctx.Err())
|
|
}
|
|
if runErr != nil {
|
|
message := strings.TrimSpace(string(output))
|
|
if message == "" {
|
|
message = runErr.Error()
|
|
}
|
|
return fmt.Errorf(
|
|
"Qwen Code matcher must be a valid JavaScript regular expression: %s",
|
|
message,
|
|
)
|
|
}
|
|
return nil
|
|
}
|