Quicker Skill

{
    "wrench_action_id": "3eebe8d9-7521-46fa-b2e1-502754bce14f"
}

{
  "ActionId": "4283635b-ea40-405c-aa82-2f45254eda6a",
  "SharedActionId": "00000000-0000-0000-0000-000000000000",
  "Title": "Kimi网页转API",
  "Description": "通过 WebView2 驱动 Kimi 网页并在本地暴露 OpenAI 兼容接口。",
  "Keywords": "kimi,webview2,openai compatible,relay,api",
  "ChangeLog": "v0.1.0 初始版本，基于 deepseekWebRelay 派生 Kimi 适配动作。",
  "ShareUrl": "",
  "Icon": "https://files.getquicker.net/_icons/F61D79E8F06DE37A4D3C8D76A6DE4835E15F0720.png",
  "Variables": [
    {
      "Type": 0,
      "Key": "input",
      "DefaultValue": "",
      "IsInput": true,
      "Desc": "启动参数：留空正常启动，silent 后台启动，stop/shutdown 停止服务。"
    },
    {
      "Type": 0,
      "Key": "rtn",
      "DefaultValue": "",
      "IsOutput": false,
      "Desc": "返回值(自动)"
    },
    {
      "Type": 0,
      "Key": "errMessage",
      "DefaultValue": "",
      "IsOutput": false,
      "Desc": "错误信息(自动)"
    },
    {
      "Type": 0,
      "Desc": "结果文本(自动)",
      "IsOutput": false,
      "Key": "text"
    },
    {
      "Type": 0,
      "Desc": "菜单参数(自动)",
      "IsOutput": false,
      "Key": "menuKey"
    },
    {
      "Type": 2,
      "Desc": "静默启动",
      "DefaultValue": "true",
      "IsInput": false,
      "Key": "silent"
    }
  ],
  "Menus": {
    "config": "[fa:Regular_Sun]设置"
  }
}

param(
    [string]$BaseUrl = "http://127.0.0.1:56000",
    [string]$Model = "kimi-k2.5-fast",
    [int]$TimeoutSec = 180
)

$ErrorActionPreference = "Stop"

$workDir = Join-Path $PSScriptRoot "temp_attachments"
New-Item -ItemType Directory -Path $workDir -Force | Out-Null

$fileToken = "FILE_TOKEN_52481"
$imageToken = "IMG_TOKEN_85294"
$textPath = Join-Path $workDir "relay_test_note.txt"
$imagePath = Join-Path $workDir "relay_test_image.png"

Set-Content -Path $textPath -Value "文本附件口令：$fileToken" -Encoding UTF8

Add-Type -AssemblyName System.Drawing
$bmp = New-Object System.Drawing.Bitmap 900,260
$g = [System.Drawing.Graphics]::FromImage($bmp)
$g.Clear([System.Drawing.Color]::White)
$font = New-Object System.Drawing.Font("Microsoft YaHei", 36, [System.Drawing.FontStyle]::Bold)
$brush = New-Object System.Drawing.SolidBrush([System.Drawing.Color]::Black)
$g.DrawString("图片口令：$imageToken", $font, $brush, 30, 90)
$bmp.Save($imagePath, [System.Drawing.Imaging.ImageFormat]::Png)
$g.Dispose()
$font.Dispose()
$brush.Dispose()
$bmp.Dispose()

$attachments = @(
    @{
        name = [System.IO.Path]::GetFileName($textPath)
        mime_type = "text/plain"
        data_base64 = [Convert]::ToBase64String([System.IO.File]::ReadAllBytes($textPath))
    },
    @{
        name = [System.IO.Path]::GetFileName($imagePath)
        mime_type = "image/png"
        data_base64 = [Convert]::ToBase64String([System.IO.File]::ReadAllBytes($imagePath))
    }
)

$prompt = "请读取我上传的文本文件和图片中的口令，只按如下格式回复：FILE=<文本口令>;IMG=<图片口令>。不要添加其他内容。"
$uri = "$BaseUrl/v1/chat/completions"
$body = @{
    model = $Model
    stream = $false
    messages = @(
        @{
            role = "user"
            content = $prompt
        }
    )
    attachments = $attachments
} | ConvertTo-Json -Depth 12

Write-Host "POST $uri" -ForegroundColor Cyan
Write-Host "Model: $Model"
Write-Host "Text file token: $fileToken"
Write-Host "Image token: $imageToken"
Write-Host ""

try {
    $response = Invoke-RestMethod `
        -Uri $uri `
        -Method Post `
        -ContentType "application/json; charset=utf-8" `
        -Headers @{ Authorization = "Bearer sk-any" } `
        -Body $body `
        -TimeoutSec $TimeoutSec

    $content = $response.choices[0].message.content
    Write-Host "Response received:" -ForegroundColor Green
    $response | ConvertTo-Json -Depth 20
    Write-Host ""
    Write-Host "Attachment validation:" -ForegroundColor Yellow
    Write-Host ("file_token_present={0}" -f ($content -like "*$fileToken*"))
    Write-Host ("image_token_present={0}" -f ($content -like "*$imageToken*"))
}
catch {
    Write-Host "Request failed:" -ForegroundColor Red
    Write-Host $_.Exception.Message -ForegroundColor Red

    if ($_.ErrorDetails.Message) {
        Write-Host ""
        Write-Host "Server details:" -ForegroundColor Yellow
        Write-Host $_.ErrorDetails.Message
    }

    exit 1
}

param(
    [string]$BaseUrl = "http://127.0.0.1:56000",
    [string]$Model = "kimi-k2.5-fast"
)

$ErrorActionPreference = "Stop"

$tests = @(
    @{
        name = "code"
        prompt = "请只输出一个 JavaScript 代码块，内容是 add(a,b) 函数并返回 a+b。不要解释。"
    },
    @{
        name = "html"
        prompt = "请只输出完整 HTML，包含 doctype、html、head、body，并在 body 里放一个标题 Hello Relay。不要解释。"
    },
    @{
        name = "svg"
        prompt = "请只输出一个完整 SVG，画一个蓝色圆和白色文字 OK。不要解释。"
    },
    @{
        name = "longtext"
        prompt = '请输出 1 到 20 的编号列表，每行格式为"序号. 测试内容"。不要解释。'
    }
)

function Invoke-Test {
    param([string]$Prompt)
    $uri = "$BaseUrl/v1/chat/completions"
    $body = @{
        model = $Model
        stream = $false
        messages = @(
            @{
                role = "user"
                content = $Prompt
            }
        )
    } | ConvertTo-Json -Depth 10

    Invoke-RestMethod `
        -Uri $uri `
        -Method Post `
        -ContentType "application/json; charset=utf-8" `
        -Headers @{ Authorization = "Bearer sk-any" } `
        -Body $body `
        -TimeoutSec 120
}

$results = @()
foreach ($test in $tests) {
    Write-Host "Running $($test.name)..." -ForegroundColor Cyan
    $resp = Invoke-Test -Prompt $test.prompt
    $content = $resp.choices[0].message.content
    $snippet = if ($content.Length -gt 160) { $content.Substring(0,160) + "..." } else { $content }
    $results += [pscustomobject]@{
        name = $test.name
        length = $content.Length
        snippet = $snippet
        content = $content
    }
}

$results | ConvertTo-Json -Depth 6

param(
    [string]$BaseUrl = "http://127.0.0.1:56000",
    [string]$Model = "kimi-k2.5-fast",
    [string]$Prompt = "请只回复：测试成功",
    [int]$TimeoutSec = 90
)

$ErrorActionPreference = "Stop"

$uri = "$BaseUrl/v1/chat/completions"
$body = @{
    model = $Model
    stream = $false
    messages = @(
        @{
            role = "user"
            content = $Prompt
        }
    )
} | ConvertTo-Json -Depth 10

Write-Host "POST $uri" -ForegroundColor Cyan
Write-Host "Model: $Model"
Write-Host "Prompt: $Prompt"
Write-Host ""

try {
    $response = Invoke-RestMethod `
        -Uri $uri `
        -Method Post `
        -ContentType "application/json; charset=utf-8" `
        -Headers @{ Authorization = "Bearer sk-any" } `
        -Body $body `
        -TimeoutSec $TimeoutSec

    Write-Host "Response received:" -ForegroundColor Green
    $response | ConvertTo-Json -Depth 20
}
catch {
    Write-Host "Request failed:" -ForegroundColor Red
    Write-Host $_.Exception.Message -ForegroundColor Red

    if ($_.ErrorDetails.Message) {
        Write-Host ""
        Write-Host "Server details:" -ForegroundColor Yellow
        Write-Host $_.ErrorDetails.Message
    }

    exit 1
}

param(
    [string]$JsonPath = "f:\Desktop\kaifa\deepseek-网页转api\KimiWebRelay.json",
    [string]$BaseUrl = "http://127.0.0.1:56000",
    [string]$Prompt1 = "请只回复：自动验证第一次",
    [string]$Prompt2 = "请只回复：自动验证第二次",
    [int]$StartupWaitSec = 45
)

$ErrorActionPreference = "Stop"
$serverLog = "f:\Desktop\kaifa\deepseek-网页转api\服务端.log"
$buildScript = "f:\Desktop\kaifa\deepseek-网页转api\.agent\skills\quicker-skill\scripts\build.ps1"

function Invoke-RelayTest {
    param([string]$Prompt)
    & "f:\Desktop\kaifa\deepseek-网页转api\test_kimi_relay.ps1" -BaseUrl $BaseUrl -Prompt $Prompt
}

function Wait-RelayUp {
    param([int]$TimeoutSec = 25)
    $deadline = (Get-Date).AddSeconds($TimeoutSec)
    while ((Get-Date) -lt $deadline) {
        try {
            $resp = Invoke-WebRequest -Uri "$BaseUrl/models" -UseBasicParsing -TimeoutSec 3
            if ($resp.StatusCode -eq 200) { return $true }
        } catch {}
        try {
            $listener = Get-NetTCPConnection -LocalPort 56000 -State Listen -ErrorAction Stop
            if ($listener) { return $true }
        } catch {}
        Start-Sleep -Seconds 1
    }
    return $false
}

Write-Host "Preflight: shutdown existing relay over HTTP..." -ForegroundColor Cyan
try {
    Invoke-WebRequest -Uri "$BaseUrl/shutdown" -UseBasicParsing -TimeoutSec 3 | Out-Null
} catch {}
Start-Sleep -Seconds 3

if (Test-Path $serverLog) {
    Clear-Content $serverLog
}

Write-Host "Building action (build auto-starts relay)..." -ForegroundColor Cyan
& $buildScript -JsonPath $JsonPath | Out-Host

if (-not (Wait-RelayUp -TimeoutSec $StartupWaitSec)) {
    throw "Relay did not start within $StartupWaitSec seconds."
}

Write-Host "First request: build template" -ForegroundColor Cyan
$first = Invoke-RelayTest -Prompt $Prompt1
Start-Sleep -Seconds 2

Write-Host "Second request: verify direct request path" -ForegroundColor Cyan
$second = Invoke-RelayTest -Prompt $Prompt2
Start-Sleep -Seconds 2

if (-not (Test-Path $serverLog)) {
    throw "Server log not found: $serverLog"
}

$logText = Get-Content $serverLog -Raw
$usedDirect = $logText -match 'Direct request \(C#\): https://www\.kimi\.com/apiv2/kimi\.gateway\.chat\.v1\.ChatService/Chat'
$fallback = $logText -match 'Direct request failed, fallback to UI'
$nativeReq = $logText -match '\[REQ-NATIVE\] 已捕获原始请求体'
$secondResponseOk = $second -match [regex]::Escape($Prompt2.Replace("请只回复：", ""))

Write-Host ""
Write-Host "Verification summary" -ForegroundColor Green
Write-Host "Native request captured: $nativeReq"
Write-Host "Direct request used: $usedDirect"
Write-Host "Fallback happened: $fallback"
Write-Host "Second response matches prompt: $secondResponseOk"
Write-Host ""
Write-Host "Last 80 log lines:" -ForegroundColor Yellow
Get-Content $serverLog -Tail 80

[pscustomobject]@{
    native_request_captured = $nativeReq
    direct_request_used = $usedDirect
    fallback_happened = $fallback
    second_response_matches_prompt = $secondResponseOk
    first_response = $first
    second_response = $second
    server_log = $serverLog
} | ConvertTo-Json -Depth 6

Category,Title,Namespace/Type,Method/Property,Call Type,Description
UI,悬浮 Toast 提示,ToastNotifications.Notifier,ShowSuccess/ShowError/etc,实例 + 扩展方法,在屏幕指定位置弹出美观的悬浮提示框
UI,Windows 系统通知,Quicker.Utilities.AppHelper,ShowWindowsToastMessage,静态方法,触发 Windows 10+ 操作中心的通知
UI,用户选择弹窗,Quicker.View.SelectOperationWindow,ctor/ShowDialog,构造实例化,弹出标准的单选/多选列表对话框
Data,选项数据模型,Quicker.View.SimpleOperationItem,Name/Key/Icon,数据项实例化,为 SelectOperationWindow 提供行数据支持
System,获取选中文本,Quicker.Utilities.AppHelper,GetSelectedText,静态方法,高可靠性抓取当前光标选中的文字
System,窗口定位枚举,Quicker.Domain.ShowWindowLocation,WithMouse1/CenterScreen/etc,枚举常量,控制弹窗出现的起始位置
UI,颜色选择器,Quicker.View.ColorSelectorWindow,ShowDialog,构造实例化,弹出标准的颜色选取调色盘
UI,图标选择器 (Fa),Quicker.View.FaIconSelectorWindow,ShowDialog,构造实例化,弹出 FontAwesome 图标搜索和选择窗口
UI,程序/文件选择器,Quicker.View.AppSelectorWindow,ShowDialog,构造实例化,选择已安装的 App 或本地文件
UI,屏幕坐标拾取,Quicker.View.ScreenPointSelectWindow,ShowDialog,构造实例化,让用户在全屏范围内点击拾取坐标点
UI,托盘气泡提示,Quicker.Utilities.UI.NotifyIconWrapper,ShowMessage,实例方法,在系统托盘图标上方弹出传统气泡消息
UI,快捷键输入器,Quicker.View.KeyInput.KeySelectorWindow,ShowDialog,构造实例化,捕获用户录入的快捷键组合
UI,进程/程序选取器,Quicker.Modules.TextTools.Tools.ProfileExeSelectWindow,ShowDialog,构造实例化,用于选择当前运行的进程或程序路径
UI,蓝牙设备选择器,Quicker.Modules.TextTools.Tools.BluetoothDeviceSelectorWindow,ShowDialog,构造实例化,扫描并选择附近的蓝牙设备
Logic,App 全局服务器,Quicker.Domain.AppServer,ShowSearchWindow/ShowConfigWindow,实例方法,控制 Quicker 主搜索框和设置页面的显示
Logic,动作编辑器管理,Quicker.Domain.Services.ActionEditMgr,ShowEditor,实例方法,通过反射直接唤起特定动作的编辑窗口

param(
    [Parameter(Mandatory=$true)]
    [string]$JsonPath,

    [string]$WrenchId = ""
)

# 统一控制台编码为 UTF-8，避免中文输出乱码
$Utf8NoBom = New-Object System.Text.UTF8Encoding($false)
[Console]::InputEncoding = $Utf8NoBom
[Console]::OutputEncoding = $Utf8NoBom
$OutputEncoding = $Utf8NoBom

if ([string]::IsNullOrWhiteSpace($WrenchId)) {
    # 尝试读取同级或上级目录的 config.json
    $ConfigPath = Join-Path -Path $PSScriptRoot -ChildPath "..\config.json"
    if (Test-Path $ConfigPath) {
        try {
            $WrenchId = (Get-Content $ConfigPath -ErrorAction Stop | ConvertFrom-Json).wrench_action_id
        } catch { }
    }
}

# 兜底默认扳手 ID
if ([string]::IsNullOrWhiteSpace($WrenchId)) {
    $WrenchId = "3eebe8d9-7521-46fa-b2e1-502754bce14f"
}

# 将目标 json 转为绝对路径，并进行 URL 编码
$ResolvedPath = Convert-Path $JsonPath
$EncodedPath = [System.Net.WebUtility]::UrlEncode($ResolvedPath)

# 构建动作参数（不回显完整命令，避免噪音）
$CmdArgs = "runaction:${WrenchId}?action=build&filePath=${EncodedPath}"
Write-Host "正在调用 QuickerWrench ..." -ForegroundColor Cyan

# 执行构建调用并捕获输出
$rawOutput = & "C:\Program Files\Quicker\QuickerStarter.exe" -c120 $CmdArgs 2>&1 | Out-String

# 统一输出风格：错误红色、成功绿色
if ($LASTEXITCODE -ne 0 -or $rawOutput -match "❌|错误|编译失败|error\s+[A-Z]+\d+") {
    Write-Host ""
    Write-Host "构建失败" -ForegroundColor Red
    Write-Host "--------------------------------" -ForegroundColor DarkRed

    $errorLines = $rawOutput -split "`r?`n" | Where-Object {
        $_ -match "❌|错误|编译失败|error\s+[A-Z]+\d+"
    }

    if ($errorLines.Count -gt 0) {
        $errorLines | ForEach-Object { Write-Host $_ -ForegroundColor Red }
    } else {
        Write-Host ($rawOutput.Trim()) -ForegroundColor Red
    }

    exit 1
} else {
    Write-Host "构建完成" -ForegroundColor Green
    $resultText = $rawOutput.Trim()
    if (-not [string]::IsNullOrWhiteSpace($resultText)) {
        Write-Host "动作执行结果:" -ForegroundColor Cyan
        Write-Host $resultText
    }
}

param(
    [string]$QuickerDir = "C:\Program Files\Quicker"
)

$dllPath = Join-Path $QuickerDir "FontAwesomeIconsWpf.dll"
if (-not (Test-Path $dllPath)) {
    Write-Error "未找到图标程序集: $dllPath"
    exit 1
}

$outPath = Join-Path $PSScriptRoot "..\references\quicker_fontawesome_icons.csv"

$asm = [Reflection.Assembly]::LoadFrom($dllPath)
$iconEnum = $asm.GetType("FontAwesome5.EFontAwesomeIcon")
if ($null -eq $iconEnum) {
    Write-Error "未找到枚举类型 FontAwesome5.EFontAwesomeIcon"
    exit 1
}

[Enum]::GetNames($iconEnum) |
    Where-Object { $_ -ne "None" } |
    ForEach-Object {
        $parts = $_ -split "_", 2
        $style = if ($parts.Length -ge 1) { $parts[0] } else { "" }
        $name = if ($parts.Length -ge 2) { $parts[1] } else { $_ }
        [pscustomobject]@{
            enum_name   = $_
            style       = $style
            prefix      = "fa:$style"
            icon_name   = $name
            token       = "[fa:$_]"
            action_icon = "fa:$($_):#2D8CFF"
            search_text = (($_ + " " + $style + " " + $name) -replace "_"," ")
        }
    } |
    Export-Csv -Path $outPath -NoTypeInformation -Encoding UTF8

Write-Host "已导出: $outPath"

param(
    [Parameter(Position=0)]
    [string]$Keyword = "",

    [string]$Style = "",

    [switch]$Exact,

    [int]$Top = 50
)

$csvPath = Join-Path $PSScriptRoot "..\references\quicker_fontawesome_icons.csv"
if (-not (Test-Path $csvPath)) {
    Write-Error "图标索引不存在: $csvPath"
    exit 1
}

$rows = Import-Csv $csvPath

if (-not [string]::IsNullOrWhiteSpace($Style)) {
    $rows = $rows | Where-Object { $_.style -ieq $Style }
}

if (-not [string]::IsNullOrWhiteSpace($Keyword)) {
    if ($Exact) {
        $rows = $rows | Where-Object {
            $_.enum_name -ieq $Keyword -or
            $_.icon_name -ieq $Keyword -or
            $_.token -ieq $Keyword
        }
    }
    else {
        $parts = $Keyword -split '[\s,_-]+' | Where-Object { -not [string]::IsNullOrWhiteSpace($_) }
        foreach ($part in $parts) {
            $p = [Regex]::Escape($part)
            $rows = $rows | Where-Object {
                $_.enum_name -match $p -or
                $_.icon_name -match $p -or
                $_.search_text -match $p
            }
        }
    }
}

$rows |
    Select-Object -First $Top enum_name, style, icon_name, token, action_icon |
    Format-Table -AutoSize

{
    "ActionId": "",
    "SharedActionId": "00000000-0000-0000-0000-000000000000",
    "Title": "空白动作模板",
    "Description": "基于 C# 脚本的高级动作模板",
    "Keywords": "template",
    "ChangeLog": "v1.0.0 初始化",
    "ShareUrl": "",
    "Icon": "fa:Solid_Wrench:#FF4000",
    "Variables": [
        {
            "Key": "quicker_in_param",
            "Type": 0,
            "DefaultValue": "",
            "IsInput": true,
            "Desc": "URL传入参数"
        },
        {
            "Key": "rtn",
            "Type": 0,
            "DefaultValue": "",
            "IsOutput": false,
            "Desc": "返回值(自动)"
        },
        {
            "Key": "errMessage",
            "Type": 0,
            "DefaultValue": "",
            "IsOutput": false,
            "Desc": "错误信息(自动)"
        }
    ]
}

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Threading;
using Quicker.Public;
using System.Threading.Tasks;

// 这是一个使用 WPF DispatcherFrame 同步等待子程序（不卡死 UI）的标准化模板
public static string Exec(IStepContext context)
{
    // 输入变量示例（可选项：将本地变量或者从动作外传入的变量传给子程序）
    // var imagePath = context.GetVarValue("imagePath") as string;
    
    try
    {
        // 1. 组装输入给子程序的变量映射 
        var inputs = new Dictionary<string, object> 
        {
            // 例如给子程序的 "imagePath" 变量赋值
            { "imagePath", @"C:\test.png" }, 
        };

        // 2. 发起对子程序的异步调用 (但不马上 Wait，避免死锁)
        var task = context.RunSpAsync("MyOcrSubProgram", inputs);
        
        // 【核心操作】利用 DispatcherFrame 启动局部消息处理泵，安全地在这个线程同步等待
        // 这个手段能确保虽然下方代码暂停了执行，但 WPF 的内部组件事件能继续流动，从而让子程序能够正常完毕
        var frame = new DispatcherFrame();
        task.ContinueWith(t => 
        {
            // 当子程序异步执行完毕后，结束局部消息泵，释放当前线程
            frame.Continue = false;
        });
        Dispatcher.PushFrame(frame);
        
        // 3. 此时获取结果，非常安全且 100% 已经是执行完毕的状态
        var result = task.GetAwaiter().GetResult();
        
        // 4. 解析输出
        if (result != null && result.ContainsKey("text"))
        {
            var ocrText = result["text"]?.ToString();
            
            // 可以把结果写回当前动作的同名输出变量 (要求该动作配置里包含 IsOutput: true 的 text 变量)
            context.SetVarValue("text", ocrText);
            
            return ocrText;
        }

        return "OK (未获取到预期结果文本)";
    }
    catch (Exception ex)
    {
        return "ERROR: " + ex.Message;
    }
}

using System;
using System.Linq;
using System.Reflection;
using System.Windows;
using Quicker.Public;

// Roslyn v2 动态悬浮通知模板
// 优势：自动扫描 MainWindow 字段，兼容不同版本的 Quicker 混淆名

public static string Exec(IStepContext context)
{
    // 默认通过变量 message 获取内容，如果没有定义则使用 text 变量
    string message = (context.GetVarValue("message") as string) 
                  ?? (context.GetVarValue("text") as string) 
                  ?? "通知内容为空";

    Application.Current.Dispatcher.Invoke(() =>
    {
        try
        {
            var mw = Application.Current.MainWindow;
            if (mw == null) return;

            // 1. 动态定位 Notifier 实例
            object notifier = mw.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
                .FirstOrDefault(f => f.FieldType.FullName?.Contains("ToastNotifications.Notifier") == true)
                ?.GetValue(mw);

            if (notifier == null) throw new Exception("无法在当前版本 Quicker 中定位 Notifier。");

            // 2. 定位扩展方法类 SuccessExtensions (此处也可以根据需要替换为 WarningExtensions/ErrorExtensions)
            var extType = AppDomain.CurrentDomain.GetAssemblies()
                .SelectMany(a => { try { return a.GetTypes(); } catch { return Type.EmptyTypes; } })
                .FirstOrDefault(t => t.FullName == "ToastNotifications.Messages.SuccessExtensions");

            if (extType == null) throw new Exception("未找到 Toast 消息扩展库。");

            // 3. 执行弹出
            var method = extType.GetMethod("ShowSuccess", new[] { notifier.GetType(), typeof(string) });
            method?.Invoke(null, new object[] { notifier, message });
        }
        catch (Exception ex)
        {
            // 降级方案：MessageBox
            MessageBox.Show(message, "Quicker 通知 (Toast 调用失败)", MessageBoxButton.OK, MessageBoxImage.Information);
        }
    });

    return "OK";
}

{
    "ActionId": "",
    "SharedActionId": "00000000-0000-0000-0000-000000000000",
    "Title": "悬浮通知助手",
    "Description": "演示如何在悬浮通知中显示一段自定义信息。",
    "Keywords": "通知,Toast",
    "Icon": "fa:Regular_Bell:#FFD700",
    "Variables": [
        {
            "Type": 0,
            "Key": "message",
            "DefaultValue": "任务处理已成功！",
            "IsInput": true,
            "Desc": "展示的通知内容"
        }
    ],
    "Menus": {
        "config": "[fa:Regular_Sun]设置"
    },
    "References": []
}

using System;
using System.Windows;
using System.Reflection;
using System.Linq;
using Quicker.Public;
using System.Collections.Generic;
using System.Text;
using System.Threading;

// C# 脚本入口方法，必须返回 string，接受 IStepContext 参数
public static string Exec(IStepContext context)
{
    try
    {
        // 核心 1：所有操作建议包裹在 Dispatcher.Invoke 中处理 UI 线程冲突
        Application.Current.Dispatcher.Invoke(() => 
        {
            // 在此处编写你的业务逻辑
            // ...
        });

        return "OK";
    }
    catch (Exception ex)
    {
        // 返回错误信息供 Quicker 获取
        return "ERROR: " + ex.Message;
    }
}

//css_ref System.Windows.Forms.dll
//css_ref System.Drawing.dll
//css_ref Microsoft.Web.WebView2.Core.dll
//css_ref System.Runtime.Serialization.dll
//css_ref System.Xml.dll

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Linq;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Drawing;
using Microsoft.Web.WebView2.Core;

public static string Exec(Quicker.Public.IStepContext context)
{
    if (System.Threading.Thread.CurrentThread.GetApartmentState() != System.Threading.ApartmentState.STA)
    {
        MessageBox.Show("配置错误：请将模块执行线程设置为 STA 独立线程。", "Web Relay");
        return "ERROR";
    }

    string inputParam = "";
    string menuKeyParam = "";
    try { inputParam = context.GetVarValue("input") as string; } catch { }
    try { menuKeyParam = context.GetVarValue("menuKey") as string; } catch { }

    if (string.IsNullOrWhiteSpace(inputParam))
    {
        try
        {
            string quickerInParam = context.GetVarValue("quicker_in_param") as string;
            if (!string.IsNullOrWhiteSpace(quickerInParam))
            {
                foreach (var part in quickerInParam.Split('&'))
                {
                    var pair = part.Split(new[] { '=' }, 2);
                    if (pair.Length != 2) continue;
                    if (string.Equals(pair[0], "input", StringComparison.OrdinalIgnoreCase))
                        inputParam = WebUtility.UrlDecode(pair[1]);
                    else if (string.Equals(pair[0], "menuKey", StringComparison.OrdinalIgnoreCase) && string.IsNullOrWhiteSpace(menuKeyParam))
                        menuKeyParam = WebUtility.UrlDecode(pair[1]);
                }
            }
        }
        catch { }
    }

    inputParam = inputParam?.Trim().ToLower() ?? "";
    menuKeyParam = menuKeyParam?.Trim().ToLower() ?? "";
    string startupMode = !string.IsNullOrWhiteSpace(inputParam) ? inputParam : menuKeyParam;

    if (startupMode == "shutdown" || startupMode == "stop")
    {
        WebRelayForm.ShutdownRemoteService();
        return "OK";
    }

    bool isSilent = startupMode == "silent";

    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new WebRelayForm(isSilent));
    return "OK";
}

public class WebRelayForm : Form
{
    private const string TargetUrl = "https://example.com/chat";
    private const int ServerPort = 57000;
    private const string RelayTitle = "Web Relay";

    private readonly bool _isDebugMode;
    private readonly string _userDataFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "WebRelay_Data");

    private CoreWebView2Environment _env;
    private CoreWebView2Controller _controller;
    private CoreWebView2 _coreWebView;
    private HttpListener _httpListener;
    private HttpListenerContext _currentContext;
    private NotifyIcon _notifyIcon;
    private TextBox _txtLog;
    private Panel _webPanel;
    private bool _isInitializing;
    private bool _isCurrentRequestStreaming;
    private StringBuilder _nonStreamResponseBuffer = new StringBuilder();

    public WebRelayForm(bool isSilent)
    {
        _isDebugMode = !isSilent;

        InitializeComponent();
        InitializeSystemTray();

        this.Load += async (s, e) => {
            await InitializeWebViewSequenceAsync();
        };

        StartHttpServer();
    }

    public static void ShutdownRemoteService()
    {
        try
        {
            var request = WebRequest.Create("http://127.0.0.1:" + ServerPort + "/shutdown");
            request.Timeout = 2000;
            using (var response = request.GetResponse()) { }
        }
        catch { }
    }

    private void InitializeComponent()
    {
        this.Text = RelayTitle + " (Port: " + ServerPort + ")";
        this.Size = new Size(1200, 800);
        this.StartPosition = FormStartPosition.CenterScreen;

        _webPanel = new Panel();
        _webPanel.Dock = DockStyle.Fill;
        this.Controls.Add(_webPanel);

        _txtLog = new TextBox();
        _txtLog.Multiline = true;
        _txtLog.Dock = DockStyle.Right;
        _txtLog.Width = 360;
        _txtLog.ScrollBars = ScrollBars.Vertical;
        _txtLog.ReadOnly = true;
        this.Controls.Add(_txtLog);
    }

    private void InitializeSystemTray()
    {
        _notifyIcon = new NotifyIcon();
        _notifyIcon.Text = RelayTitle;
        _notifyIcon.Icon = SystemIcons.Application;
        _notifyIcon.Visible = true;
    }

    private async Task InitializeWebViewSequenceAsync()
    {
        if (_isInitializing) return;
        _isInitializing = true;
        try
        {
            _env = await CoreWebView2Environment.CreateAsync(null, _userDataFolder);
            _controller = await _env.CreateCoreWebView2ControllerAsync(_webPanel.Handle);
            _coreWebView = _controller.CoreWebView2;
            _controller.Bounds = _webPanel.ClientRectangle;
            await _coreWebView.AddScriptToExecuteOnDocumentCreatedAsync(GetNetworkInterceptorScript());
            _coreWebView.WebMessageReceived += OnWebMessageReceived;
            _coreWebView.Navigate(TargetUrl);
        }
        finally
        {
            _isInitializing = false;
        }
    }

    private void StartHttpServer()
    {
        try
        {
            _httpListener = new HttpListener();
            _httpListener.Prefixes.Add("http://127.0.0.1:" + ServerPort + "/");
            _httpListener.Start();
            Task.Run(ListenLoop);
            Log("HTTP 服务监听中: " + ServerPort);
        }
        catch (Exception ex)
        {
            Log("HTTP 启动失败: " + ex.Message);
        }
    }

    private async Task ListenLoop()
    {
        var listener = _httpListener;
        if (listener == null) return;
        while (listener.IsListening)
        {
            try
            {
                var ctx = await listener.GetContextAsync();
                HandleRequest(ctx);
            }
            catch { break; }
        }
    }

    private async void HandleRequest(HttpListenerContext ctx)
    {
        string path = ctx.Request.Url.AbsolutePath.ToLower();
        string method = ctx.Request.HttpMethod.ToUpper();
        ctx.Response.AppendHeader("Access-Control-Allow-Origin", "*");
        ctx.Response.AppendHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
        if (method == "OPTIONS") { ctx.Response.StatusCode = 200; ctx.Response.Close(); return; }

        if (path == "/shutdown")
        {
            ResponseText(ctx, "Closing...", 200, "text/plain");
            this.Invoke(new Action(() => this.Close()));
            return;
        }

        if (path == "/v1/models" && method == "GET")
        {
            ResponseText(ctx, "{\"object\":\"list\",\"data\":[]}", 200, "application/json");
            return;
        }

        if (path == "/v1/chat/completions" && method == "POST")
        {
            using (var reader = new StreamReader(ctx.Request.InputStream, Encoding.UTF8))
            {
                string body = reader.ReadToEnd();
                string prompt = ExtractPromptFromJson(body);
                if (string.IsNullOrWhiteSpace(prompt))
                {
                    ResponseText(ctx, "{\"error\":\"Parse Error\"}", 400, "application/json");
                    return;
                }

                _currentContext = ctx;
                _isCurrentRequestStreaming = body.Contains("\"stream\":true") || body.Contains("\"stream\": true");
                _nonStreamResponseBuffer.Clear();
                this.Invoke(new Action(() => InjectPromptToWebView(prompt)));
            }
            return;
        }

        ResponseText(ctx, "Not Found", 404, "text/plain");
    }

    private string ExtractPromptFromJson(string json)
    {
        try
        {
            var contentRegex = new Regex("\"content\"\\s*:\\s*\"((?:[^\"\\\\]|\\\\.)*)\"");
            var lastMatch = contentRegex.Matches(json).Cast<Match>().LastOrDefault();
            return lastMatch != null ? UnescapeJson(lastMatch.Groups[1].Value) : null;
        }
        catch { return null; }
    }

    private void InjectPromptToWebView(string prompt)
    {
        string promptBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(prompt ?? ""));
        string script = "window.WebRelayBridge.sendPromptFromBase64(\"" + promptBase64 + "\")";
        try { _coreWebView.ExecuteScriptAsync(script); } catch { }
    }

    private void OnWebMessageReceived(object sender, CoreWebView2WebMessageReceivedEventArgs e)
    {
        try
        {
            string msg = e.TryGetWebMessageAsString();
            if (msg.StartsWith("[LOG]")) { Log(msg); return; }
            if (_currentContext == null) return;
            if (msg.StartsWith("[NETWORK_DONE]")) { FinishRequest(); return; }
            if (msg.StartsWith("[NETWORK_DATA]")) { SendDelta(msg.Substring(14)); }
        }
        catch (Exception ex) { Log("MsgError: " + ex.Message); }
    }

    private void SendDelta(string text)
    {
        if (!_isCurrentRequestStreaming)
            _nonStreamResponseBuffer.Append(text);

        if (_isCurrentRequestStreaming)
        {
            string jsonChunk = "{\"id\":\"chatcmpl-webrelay\",\"object\":\"chat.completion.chunk\",\"created\":" + DateTimeOffset.Now.ToUnixTimeSeconds() + ",\"model\":\"web-relay\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"" + EscapeJson(text) + "\"},\"finish_reason\":null}]}";
            WriteSseData("data: " + jsonChunk + "\n\n");
        }
    }

    private void FinishRequest()
    {
        if (_currentContext == null) return;
        if (_isCurrentRequestStreaming)
        {
            string stopChunk = "{\"id\":\"chatcmpl-webrelay\",\"object\":\"chat.completion.chunk\",\"created\":" + DateTimeOffset.Now.ToUnixTimeSeconds() + ",\"model\":\"web-relay\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}]}";
            WriteSseData("data: " + stopChunk + "\n\n");
            WriteSseData("data: [DONE]\n\n");
        }
        else
        {
            string content = _nonStreamResponseBuffer.ToString();
            string json = "{\"id\":\"chatcmpl-webrelay\",\"object\":\"chat.completion\",\"created\":" + DateTimeOffset.Now.ToUnixTimeSeconds() + ",\"model\":\"web-relay\",\"choices\":[{\"index\":0,\"message\":{\"role\":\"assistant\",\"content\":\"" + EscapeJson(content) + "\"},\"finish_reason\":\"stop\"}]}";
            ResponseText(_currentContext, json, 200, "application/json");
        }
        CleanupRequest();
    }

    private void WriteSseData(string data)
    {
        try
        {
            byte[] buffer = Encoding.UTF8.GetBytes(data);
            _currentContext.Response.OutputStream.Write(buffer, 0, buffer.Length);
            _currentContext.Response.OutputStream.Flush();
        }
        catch { CleanupRequest(); }
    }

    private void CleanupRequest()
    {
        try { _currentContext?.Response.Close(); } catch { }
        _currentContext = null;
        _nonStreamResponseBuffer.Clear();
    }

    private void ResponseText(HttpListenerContext ctx, string text, int code, string contentType)
    {
        try
        {
            ctx.Response.StatusCode = code;
            ctx.Response.ContentType = contentType;
            byte[] buffer = Encoding.UTF8.GetBytes(text);
            ctx.Response.ContentLength64 = buffer.Length;
            ctx.Response.OutputStream.Write(buffer, 0, buffer.Length);
            ctx.Response.Close();
        }
        catch { }
    }

    private string EscapeJson(string s)
    {
        if (s == null) return "";
        return s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r").Replace("\n", "\\n").Replace("\t", "\\t");
    }

    private string UnescapeJson(string str)
    {
        return (str ?? "").Replace("\\\"", "\"").Replace("\\\\", "\\").Replace("\\n", "\n").Replace("\\r", "\r").Replace("\\t", "\t");
    }

    private void Log(string msg)
    {
        if (!_isDebugMode) return;
        try
        {
            if (_txtLog != null && !_txtLog.IsDisposed)
            {
                if (_txtLog.InvokeRequired) _txtLog.Invoke(new Action(() => Log(msg)));
                else _txtLog.AppendText("[" + DateTime.Now.ToString("HH:mm:ss") + "] " + msg + "\r\n");
            }
        }
        catch { }
    }

    private string GetNetworkInterceptorScript()
    {
        return @"
        window.chrome.webview.postMessage('[LOG] Interceptor Ready');
        const originalFetch = window.fetch;

        window.WebRelayBridge = {
            sendPromptFromBase64: function(textBase64) {
                const binary = atob(textBase64 || '');
                const text = new TextDecoder().decode(Uint8Array.from(binary, ch => ch.charCodeAt(0)));
                return this.sendPrompt(text);
            },
            sendPrompt: function(text) {
                // TODO: 替换为目标站点的输入框定位、模型切换、联网开关和发送按钮逻辑。
                window.chrome.webview.postMessage('[LOG] TODO: implement DOM send flow');
            }
        };

        window.fetch = async (...args) => {
            const response = await originalFetch(...args);
            // TODO: 只拦截目标聊天接口，并把真实响应增量透传回宿主。
            return response;
        };
        ";
    }
}

{
    "ActionId": "",
    "SharedActionId": "00000000-0000-0000-0000-000000000000",
    "Title": "网页转API模板",
    "Description": "基于 WebView2 + 本地 HTTP 中继 的网页聊天转 API 动作模板",
    "Keywords": "web relay,api,webview2,openai compatible",
    "ChangeLog": "v1.0.0 初始化网页转 API 模板",
    "ShareUrl": "",
    "Icon": "fa:Solid_Globe:#2F80ED",
    "Variables": [
        {
            "Key": "quicker_in_param",
            "Type": 0,
            "DefaultValue": "",
            "IsInput": true,
            "Desc": "动作参数"
        },
        {
            "Key": "input",
            "Type": 0,
            "DefaultValue": "",
            "IsInput": false,
            "Desc": "兼容输入参数"
        },
        {
            "Key": "rtn",
            "Type": 0,
            "DefaultValue": "",
            "IsOutput": false,
            "Desc": "返回值(自动)"
        },
        {
            "Key": "errMessage",
            "Type": 0,
            "DefaultValue": "",
            "IsOutput": false,
            "Desc": "错误信息(自动)"
        }
    ],
    "References": [
        "System.Windows.Forms.dll",
        "System.Drawing.dll",
        "Microsoft.Web.WebView2.Core.dll",
        "System.Runtime.Serialization.dll",
        "System.Xml.dll"
    ]
}